@mycadet/cli 0.12.6-dev.202610082233.54244ee → 0.12.7

package/src/__tests__/uninstall.test.ts

@@ -0,0 +1,171 @@
+import { afterAll, afterEach, describe, expect, spyOn, test } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { dirname, join } from "path";
+
+import { uninstall } from "../commands/uninstall.js";
+import {
+  getConfigDirs,
+  getInputHistoryPath,
+  getLogDir,
+  getStateDir,
+} from "../lib/environments/paths.js";
+import { getCurrentEnvironment } from "../lib/environments/resolve.js";
+import type { AssistantEntry } from "../lib/assistant-config.js";
+
+// The command reads its argv at call time.
+const ORIGINAL_ARGV = process.argv;
+
+// Every XDG location the command touches MUST be redirected: the homedir
+// fallback would otherwise point at the real user's data dirs.
+function redirectXdg(): string {
+  const root = mkdtempSync(join(tmpdir(), "cadet-uninstall-"));
+  process.env.XDG_DATA_HOME = join(root, "data");
+  process.env.XDG_CONFIG_HOME = join(root, "config");
+  process.env.XDG_STATE_HOME = join(root, "state");
+  process.env.CADET_ENVIRONMENT = "production";
+  process.env.CADET_LOCKFILE_DIR = join(root, "lockdir");
+  mkdirSync(process.env.CADET_LOCKFILE_DIR, { recursive: true });
+  return root;
+}
+
+const RESTORED_ENV_KEYS = [
+  "XDG_DATA_HOME",
+  "XDG_CONFIG_HOME",
+  "XDG_STATE_HOME",
+  "CADET_ENVIRONMENT",
+  "CADET_LOCKFILE_DIR",
+] as const;
+
+function withRestoredEnv(run: () => Promise<void>): Promise<void> {
+  const before = Object.fromEntries(
+    RESTORED_ENV_KEYS.map((k) => [k, process.env[k]]),
+  );
+  return run().finally(() => {
+    for (const k of RESTORED_ENV_KEYS) {
+      if (before[k] === undefined) delete process.env[k];
+      else process.env[k] = before[k]!;
+    }
+    process.argv = ORIGINAL_ARGV;
+  });
+}
+
+function makeEntry(assistantId: string): AssistantEntry {
+  return {
+    assistantId,
+    runtimeUrl: "http://127.0.0.1:7801",
+    cloud: "local",
+    resources: {
+      instanceDir: join(tmpdir(), "cadet-uninstall-instance"),
+      daemonPort: 7801,
+      gatewayPort: 7831,
+      qdrantPort: 6334,
+      cesPort: 7790,
+    },
+  };
+}
+
+describe("cadet uninstall", () => {
+  const logSpy = spyOn(console, "log").mockImplementation(() => {});
+  const errorSpy = spyOn(console, "error").mockImplementation(() => {});
+  const warnSpy = spyOn(console, "warn").mockImplementation(() => {});
+
+  afterEach(() => {
+    logSpy.mockClear();
+    errorSpy.mockClear();
+    warnSpy.mockClear();
+  });
+
+  afterAll(() => {
+    logSpy.mockRestore();
+    errorSpy.mockRestore();
+    warnSpy.mockRestore();
+  });
+
+  test("refuses while assistants remain — retire them first", async () => {
+    await withRestoredEnv(async () => {
+      const root = redirectXdg();
+      // A remaining assistant in the lockfile means there is data that
+      // should be retired (and archived) first.
+      writeFileSync(
+        join(process.env.CADET_LOCKFILE_DIR!, "lockfile.json"),
+        JSON.stringify({ assistants: [makeEntry("test-assistant")] }) + "\n",
+      );
+
+      const exitMock = spyOn(process, "exit");
+      exitMock.mockImplementation((code?: number | string | undefined): never => {
+        throw new Error(`process.exit:${code}`);
+      });
+      try {
+        await expect(uninstall()).rejects.toThrow("process.exit:1");
+        expect(errorSpy).toHaveBeenCalledWith(
+          expect.stringContaining("Retire them first"),
+        );
+      } finally {
+        exitMock.mockRestore();
+      }
+      rmSync(root, { recursive: true, force: true });
+    });
+  });
+
+  test("refuses non-interactively without --yes", async () => {
+    await withRestoredEnv(async () => {
+      const root = redirectXdg();
+
+      const exitMock = spyOn(process, "exit");
+      exitMock.mockImplementation((code?: number | string | undefined): never => {
+        throw new Error(`process.exit:${code}`);
+      });
+      try {
+        process.argv = ["bun", "cadet", "uninstall"];
+        await expect(uninstall()).rejects.toThrow("process.exit:1");
+        expect(errorSpy).toHaveBeenCalledWith(
+          expect.stringContaining("non-interactive"),
+        );
+      } finally {
+        exitMock.mockRestore();
+      }
+      rmSync(root, { recursive: true, force: true });
+    });
+  });
+
+  test("--yes deletes the environment's XDG locations and leaves the source checkout alone", async () => {
+    await withRestoredEnv(async () => {
+      const root = redirectXdg();
+      const env = getCurrentEnvironment();
+
+      // Pre-create every target the command should delete, using the SAME
+      // path helpers so the test stays honest about what they resolve to.
+      const stateDir = getStateDir(env);
+      mkdirSync(join(stateDir, "assistants", "some-assistant"), {
+        recursive: true,
+      });
+      mkdirSync(join(stateDir, "retired"), { recursive: true });
+      const configDir = getConfigDirs(env)[0]!;
+      mkdirSync(configDir, { recursive: true });
+      const logDir = getLogDir(env);
+      mkdirSync(logDir, { recursive: true });
+      const historyPath = getInputHistoryPath();
+      mkdirSync(dirname(historyPath), { recursive: true });
+      writeFileSync(historyPath, "history");
+
+      process.argv = ["bun", "cadet", "uninstall", "--yes"];
+      await uninstall();
+
+      expect(existsSync(stateDir)).toBe(false);
+      expect(existsSync(configDir)).toBe(false);
+      expect(existsSync(logDir)).toBe(false);
+      expect(existsSync(historyPath)).toBe(false);
+
+      // Running under bun from a git checkout: self-removal must print the
+      // note and delete NOTHING outside the XDG targets.
+      const note = logSpy.mock.calls
+        .map((args) => args.map(String).join(" "))
+        .join("\n");
+      expect(note).toContain("source checkout");
+      expect(existsSync(process.execPath)).toBe(true);
+
+      rmSync(root, { recursive: true, force: true });
+    });
+  });
+});

package/src/__tests__/upgrade-local.test.ts

@@ -202,7 +202,7 @@ function makeLocalEntry(): AssistantEntry {
       gatewayPort: 7830,
       qdrantPort: 6333,
       cesPort: 7822,
-      signingKey: "existing-signing-key",
+      signingKey: "ab".repeat(32),
     },
     guardianBootstrapSecret: "existing-bootstrap-secret",
   };
@@ -307,6 +307,19 @@ afterAll(() => {
 });
 
 describe("cadet upgrade local", () => {
+  test("missing identity refuses without backup, installation, restart or repair", async () => {
+    const entry = findAssistantByNameMock("local-assistant")!;
+    delete entry.resources!.signingKey;
+    await expect(upgrade()).rejects.toThrow("process.exit(1)");
+    expect(createBackupMock).not.toHaveBeenCalled();
+    expect(ensureLocalRuntimeMock).not.toHaveBeenCalled();
+    expect(startLocalDaemonMock).not.toHaveBeenCalled();
+    expect(startGatewayMock).not.toHaveBeenCalled();
+    expect(generateLocalSigningKeyMock).not.toHaveBeenCalled();
+    expect(resetGuardianBootstrapMock).not.toHaveBeenCalled();
+    expect(saveAssistantEntryMock).not.toHaveBeenCalled();
+  });
+
   test("uses explicit target versions as-is", async () => {
     const resolveLatest = mock(async () => "v0.9.9");
 
@@ -394,7 +407,7 @@ describe("cadet upgrade local", () => {
         instanceDir: tempDir,
         runtimeVersion: cliPkg.version ? `v${cliPkg.version}` : "v0.8.12",
       }),
-      { signingKey: "existing-signing-key" },
+      { signingKey: "ab".repeat(32) },
     );
     expect(startGatewayMock).toHaveBeenCalledWith(
       false,
@@ -403,7 +416,7 @@ describe("cadet upgrade local", () => {
         runtimeVersion: cliPkg.version ? `v${cliPkg.version}` : "v0.8.12",
       }),
       {
-        signingKey: "existing-signing-key",
+        signingKey: "ab".repeat(32),
         bootstrapSecret: "existing-bootstrap-secret",
       },
     );

package/src/__tests__/use.test.ts

@@ -43,7 +43,7 @@ function writeLockfile(
 ): void {
   mkdirSync(testDir, { recursive: true });
   writeFileSync(
-    join(testDir, ".cadet.lock.json"),
+    join(testDir, "lockfile.json"),
     JSON.stringify(
       {
         assistants: entries,
@@ -58,7 +58,7 @@ function writeLockfile(
 describe("cadet use", () => {
   beforeEach(() => {
     process.env.CADET_LOCKFILE_DIR = testDir;
-    rmSync(join(testDir, ".cadet.lock.json"), { force: true });
+    rmSync(join(testDir, "lockfile.json"), { force: true });
     process.argv = ["bun", "cadet", "use"];
     process.exit = ((code?: number) => {
       throw new Error(`process.exit:${code}`);

package/src/__tests__/wake-error.test.ts

@@ -0,0 +1,76 @@
+import { expect, test } from "bun:test";
+import { resolveLockfilePaths } from "@mycadet/local-mode";
+import {
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+
+test("CLI wake emits actionable structured identity error and exits 1 without mutating state", async () => {
+  const root = mkdtempSync(join(tmpdir(), "wake-error-"));
+  try {
+    const env = {
+      ...process.env,
+      HOME: root,
+      USERPROFILE: root,
+      CADET_ENVIRONMENT: "local",
+      CADET_LOCKFILE_DIR: root,
+      XDG_CONFIG_HOME: join(root, "config"),
+      XDG_DATA_HOME: join(root, "data"),
+    };
+    const registry = resolveLockfilePaths(env)[0]!;
+    mkdirSync(dirname(registry), { recursive: true });
+    const original = JSON.stringify({
+      assistants: [
+        {
+          assistantId: "example",
+          cloud: "local",
+          runtimeUrl: "http://127.0.0.1:27830",
+          resources: {
+            instanceDir: join(root, "instance"),
+            daemonPort: 27821,
+            gatewayPort: 27830,
+            cesPort: 27822,
+            qdrantPort: 26333,
+          },
+        },
+      ],
+    });
+    writeFileSync(registry, original);
+    const child = Bun.spawn(
+      [
+        process.execPath,
+        join(import.meta.dir, "../index.ts"),
+        "wake",
+        "example",
+      ],
+      {
+        env,
+        stdout: "pipe",
+        stderr: "pipe",
+        windowsHide: true,
+      },
+    );
+    const [exit, stderr] = await Promise.all([
+      child.exited,
+      new Response(child.stderr).text(),
+    ]);
+    expect(exit).toBe(1);
+    const line = stderr
+      .split("\n")
+      .find((value) => value.startsWith("CLI_ERROR:"));
+    expect(line).toBeDefined();
+    const payload = JSON.parse(line!.slice("CLI_ERROR:".length));
+    expect(payload.error).toBe("AUTH_IDENTITY_UNAVAILABLE");
+    expect(payload.detail).toBe("missing");
+    expect(payload.message).toContain('cadet wake "example" --repair-guardian');
+    expect(payload.message).toContain("all clients to authenticate again");
+    expect(readFileSync(registry, "utf8")).toBe(original);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});