400 lines
10 KiB
TypeScript
400 lines
10 KiB
TypeScript
import { describe, expect, it, vi } from "vitest";
|
|
|
|
const readConfigFileSnapshot = vi.fn();
|
|
const confirm = vi.fn().mockResolvedValue(true);
|
|
const writeConfigFile = vi.fn().mockResolvedValue(undefined);
|
|
const migrateLegacyConfig = vi.fn((raw: unknown) => ({
|
|
config: raw as Record<string, unknown>,
|
|
changes: ["Moved routing.allowFrom → whatsapp.allowFrom."],
|
|
}));
|
|
|
|
const runExec = vi.fn().mockResolvedValue({ stdout: "", stderr: "" });
|
|
const runCommandWithTimeout = vi.fn().mockResolvedValue({
|
|
stdout: "",
|
|
stderr: "",
|
|
code: 0,
|
|
signal: null,
|
|
killed: false,
|
|
});
|
|
|
|
const legacyReadConfigFileSnapshot = vi.fn().mockResolvedValue({
|
|
path: "/tmp/clawdis.json",
|
|
exists: false,
|
|
raw: null,
|
|
parsed: {},
|
|
valid: true,
|
|
config: {},
|
|
issues: [],
|
|
legacyIssues: [],
|
|
});
|
|
const createConfigIO = vi.fn(() => ({
|
|
readConfigFileSnapshot: legacyReadConfigFileSnapshot,
|
|
}));
|
|
|
|
const findLegacyGatewayServices = vi.fn().mockResolvedValue([]);
|
|
const uninstallLegacyGatewayServices = vi.fn().mockResolvedValue([]);
|
|
const resolveGatewayProgramArguments = vi.fn().mockResolvedValue({
|
|
programArguments: ["node", "cli", "gateway-daemon", "--port", "18789"],
|
|
});
|
|
const serviceInstall = vi.fn().mockResolvedValue(undefined);
|
|
const serviceIsLoaded = vi.fn().mockResolvedValue(false);
|
|
const serviceRestart = vi.fn().mockResolvedValue(undefined);
|
|
const serviceUninstall = vi.fn().mockResolvedValue(undefined);
|
|
|
|
vi.mock("@clack/prompts", () => ({
|
|
confirm,
|
|
intro: vi.fn(),
|
|
note: vi.fn(),
|
|
outro: vi.fn(),
|
|
}));
|
|
|
|
vi.mock("../agents/skills-status.js", () => ({
|
|
buildWorkspaceSkillStatus: () => ({ skills: [] }),
|
|
}));
|
|
|
|
vi.mock("../config/config.js", async (importOriginal) => {
|
|
const actual = await importOriginal();
|
|
return {
|
|
...actual,
|
|
CONFIG_PATH_CLAWDBOT: "/tmp/clawdbot.json",
|
|
createConfigIO,
|
|
readConfigFileSnapshot,
|
|
writeConfigFile,
|
|
migrateLegacyConfig,
|
|
};
|
|
});
|
|
|
|
vi.mock("../daemon/legacy.js", () => ({
|
|
findLegacyGatewayServices,
|
|
uninstallLegacyGatewayServices,
|
|
}));
|
|
|
|
vi.mock("../daemon/program-args.js", () => ({
|
|
resolveGatewayProgramArguments,
|
|
}));
|
|
|
|
vi.mock("../process/exec.js", () => ({
|
|
runExec,
|
|
runCommandWithTimeout,
|
|
}));
|
|
|
|
vi.mock("../daemon/service.js", () => ({
|
|
resolveGatewayService: () => ({
|
|
label: "LaunchAgent",
|
|
loadedText: "loaded",
|
|
notLoadedText: "not loaded",
|
|
install: serviceInstall,
|
|
uninstall: serviceUninstall,
|
|
restart: serviceRestart,
|
|
isLoaded: serviceIsLoaded,
|
|
readCommand: vi.fn(),
|
|
}),
|
|
}));
|
|
|
|
vi.mock("../runtime.js", () => ({
|
|
defaultRuntime: {
|
|
log: () => {},
|
|
error: () => {},
|
|
exit: () => {
|
|
throw new Error("exit");
|
|
},
|
|
},
|
|
}));
|
|
|
|
vi.mock("../utils.js", async (importOriginal) => {
|
|
const actual = await importOriginal();
|
|
return {
|
|
...actual,
|
|
resolveUserPath: (value: string) => value,
|
|
sleep: vi.fn(),
|
|
};
|
|
});
|
|
|
|
vi.mock("./health.js", () => ({
|
|
healthCommand: vi.fn().mockResolvedValue(undefined),
|
|
}));
|
|
|
|
vi.mock("./onboard-helpers.js", () => ({
|
|
applyWizardMetadata: (cfg: Record<string, unknown>) => cfg,
|
|
DEFAULT_WORKSPACE: "/tmp",
|
|
guardCancel: (value: unknown) => value,
|
|
printWizardHeader: vi.fn(),
|
|
}));
|
|
|
|
describe("doctor", () => {
|
|
it("migrates routing.allowFrom to whatsapp.allowFrom", async () => {
|
|
readConfigFileSnapshot.mockResolvedValue({
|
|
path: "/tmp/clawdbot.json",
|
|
exists: true,
|
|
raw: "{}",
|
|
parsed: { routing: { allowFrom: ["+15555550123"] } },
|
|
valid: false,
|
|
config: {},
|
|
issues: [
|
|
{
|
|
path: "routing.allowFrom",
|
|
message: "legacy",
|
|
},
|
|
],
|
|
legacyIssues: [
|
|
{
|
|
path: "routing.allowFrom",
|
|
message: "legacy",
|
|
},
|
|
],
|
|
});
|
|
|
|
const { doctorCommand } = await import("./doctor.js");
|
|
const runtime = {
|
|
log: vi.fn(),
|
|
error: vi.fn(),
|
|
exit: vi.fn(),
|
|
};
|
|
|
|
migrateLegacyConfig.mockReturnValue({
|
|
config: { whatsapp: { allowFrom: ["+15555550123"] } },
|
|
changes: ["Moved routing.allowFrom → whatsapp.allowFrom."],
|
|
});
|
|
|
|
await doctorCommand(runtime);
|
|
|
|
expect(writeConfigFile).toHaveBeenCalledTimes(1);
|
|
const written = writeConfigFile.mock.calls[0]?.[0] as Record<
|
|
string,
|
|
unknown
|
|
>;
|
|
expect((written.whatsapp as Record<string, unknown>)?.allowFrom).toEqual([
|
|
"+15555550123",
|
|
]);
|
|
expect(written.routing).toBeUndefined();
|
|
});
|
|
|
|
it("migrates legacy Clawdis services", async () => {
|
|
readConfigFileSnapshot.mockResolvedValue({
|
|
path: "/tmp/clawdbot.json",
|
|
exists: true,
|
|
raw: "{}",
|
|
parsed: {},
|
|
valid: true,
|
|
config: {},
|
|
issues: [],
|
|
legacyIssues: [],
|
|
});
|
|
|
|
findLegacyGatewayServices.mockResolvedValueOnce([
|
|
{
|
|
platform: "darwin",
|
|
label: "com.clawdis.gateway",
|
|
detail: "loaded",
|
|
},
|
|
]);
|
|
serviceIsLoaded.mockResolvedValueOnce(false);
|
|
serviceInstall.mockClear();
|
|
|
|
const { doctorCommand } = await import("./doctor.js");
|
|
const runtime = {
|
|
log: vi.fn(),
|
|
error: vi.fn(),
|
|
exit: vi.fn(),
|
|
};
|
|
|
|
await doctorCommand(runtime);
|
|
|
|
expect(uninstallLegacyGatewayServices).toHaveBeenCalledTimes(1);
|
|
expect(serviceInstall).toHaveBeenCalledTimes(1);
|
|
});
|
|
|
|
it("migrates legacy config file", async () => {
|
|
readConfigFileSnapshot
|
|
.mockResolvedValueOnce({
|
|
path: "/tmp/clawdbot.json",
|
|
exists: false,
|
|
raw: null,
|
|
parsed: {},
|
|
valid: true,
|
|
config: {},
|
|
issues: [],
|
|
legacyIssues: [],
|
|
})
|
|
.mockResolvedValueOnce({
|
|
path: "/tmp/clawdbot.json",
|
|
exists: true,
|
|
raw: "{}",
|
|
parsed: {
|
|
gateway: { mode: "local", bind: "loopback" },
|
|
agent: {
|
|
workspace: "/Users/steipete/clawdbot",
|
|
sandbox: {
|
|
workspaceRoot: "/Users/steipete/clawdbot/sandboxes",
|
|
docker: {
|
|
image: "clawdbot-sandbox",
|
|
containerPrefix: "clawdbot-sbx",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
valid: true,
|
|
config: {
|
|
gateway: { mode: "local", bind: "loopback" },
|
|
agent: {
|
|
workspace: "/Users/steipete/clawdbot",
|
|
sandbox: {
|
|
workspaceRoot: "/Users/steipete/clawdbot/sandboxes",
|
|
docker: {
|
|
image: "clawdbot-sandbox",
|
|
containerPrefix: "clawdbot-sbx",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
issues: [],
|
|
legacyIssues: [],
|
|
});
|
|
|
|
legacyReadConfigFileSnapshot.mockResolvedValueOnce({
|
|
path: "/Users/steipete/.clawdis/clawdis.json",
|
|
exists: true,
|
|
raw: "{}",
|
|
parsed: {
|
|
gateway: { mode: "local", bind: "loopback" },
|
|
agent: {
|
|
workspace: "/Users/steipete/clawd",
|
|
sandbox: {
|
|
workspaceRoot: "/Users/steipete/clawd/sandboxes",
|
|
docker: {
|
|
image: "clawdis-sandbox",
|
|
containerPrefix: "clawdis-sbx",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
valid: true,
|
|
config: {
|
|
gateway: { mode: "local", bind: "loopback" },
|
|
agent: {
|
|
workspace: "/Users/steipete/clawd",
|
|
sandbox: {
|
|
workspaceRoot: "/Users/steipete/clawd/sandboxes",
|
|
docker: {
|
|
image: "clawdis-sandbox",
|
|
containerPrefix: "clawdis-sbx",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
issues: [],
|
|
legacyIssues: [],
|
|
});
|
|
|
|
migrateLegacyConfig.mockReturnValueOnce({
|
|
config: {
|
|
gateway: { mode: "local", bind: "loopback" },
|
|
agent: {
|
|
workspace: "/Users/steipete/clawd",
|
|
sandbox: {
|
|
workspaceRoot: "/Users/steipete/clawd/sandboxes",
|
|
docker: {
|
|
image: "clawdis-sandbox",
|
|
containerPrefix: "clawdis-sbx",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
changes: [],
|
|
});
|
|
|
|
const { doctorCommand } = await import("./doctor.js");
|
|
const runtime = {
|
|
log: vi.fn(),
|
|
error: vi.fn(),
|
|
exit: vi.fn(),
|
|
};
|
|
|
|
await doctorCommand(runtime);
|
|
|
|
const written = writeConfigFile.mock.calls.at(-1)?.[0] as Record<
|
|
string,
|
|
unknown
|
|
>;
|
|
const agent = written.agent as Record<string, unknown>;
|
|
const sandbox = agent.sandbox as Record<string, unknown>;
|
|
const docker = sandbox.docker as Record<string, unknown>;
|
|
|
|
expect(agent.workspace).toBe("/Users/steipete/clawdbot");
|
|
expect(sandbox.workspaceRoot).toBe("/Users/steipete/clawdbot/sandboxes");
|
|
expect(docker.image).toBe("clawdbot-sandbox");
|
|
expect(docker.containerPrefix).toBe("clawdbot-sbx");
|
|
});
|
|
it("falls back to legacy sandbox image when missing", async () => {
|
|
readConfigFileSnapshot.mockResolvedValue({
|
|
path: "/tmp/clawdbot.json",
|
|
exists: true,
|
|
raw: "{}",
|
|
parsed: {
|
|
agent: {
|
|
sandbox: {
|
|
mode: "non-main",
|
|
docker: {
|
|
image: "clawdbot-sandbox-common:bookworm-slim",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
valid: true,
|
|
config: {
|
|
agent: {
|
|
sandbox: {
|
|
mode: "non-main",
|
|
docker: {
|
|
image: "clawdbot-sandbox-common:bookworm-slim",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
issues: [],
|
|
legacyIssues: [],
|
|
});
|
|
|
|
runExec.mockImplementation((command: string, args: string[]) => {
|
|
if (command !== "docker") {
|
|
return Promise.resolve({ stdout: "", stderr: "" });
|
|
}
|
|
if (args[0] === "version") {
|
|
return Promise.resolve({ stdout: "1", stderr: "" });
|
|
}
|
|
if (args[0] === "image" && args[1] === "inspect") {
|
|
const image = args[2];
|
|
if (image === "clawdbot-sandbox-common:bookworm-slim") {
|
|
return Promise.reject(new Error("missing"));
|
|
}
|
|
if (image === "clawdis-sandbox-common:bookworm-slim") {
|
|
return Promise.resolve({ stdout: "ok", stderr: "" });
|
|
}
|
|
}
|
|
return Promise.resolve({ stdout: "", stderr: "" });
|
|
});
|
|
|
|
confirm.mockResolvedValueOnce(false).mockResolvedValueOnce(true);
|
|
|
|
const { doctorCommand } = await import("./doctor.js");
|
|
const runtime = {
|
|
log: vi.fn(),
|
|
error: vi.fn(),
|
|
exit: vi.fn(),
|
|
};
|
|
|
|
await doctorCommand(runtime);
|
|
|
|
const written = writeConfigFile.mock.calls.at(-1)?.[0] as Record<
|
|
string,
|
|
unknown
|
|
>;
|
|
const agent = written.agent as Record<string, unknown>;
|
|
const sandbox = agent.sandbox as Record<string, unknown>;
|
|
const docker = sandbox.docker as Record<string, unknown>;
|
|
|
|
expect(docker.image).toBe("clawdis-sandbox-common:bookworm-slim");
|
|
expect(runCommandWithTimeout).not.toHaveBeenCalled();
|
|
});
|
|
});
|