@mycadet/cli 0.12.7 → 0.12.9-dev.202610131452.9acab64

package/src/__tests__/uninstall.test.ts

@@ -1,4 +1,12 @@
-import { afterAll, afterEach, describe, expect, spyOn, test } from "bun:test";
+import {
+  afterAll,
+  afterEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from "bun:test";
 import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "fs";
 import { tmpdir } from "os";
 import { dirname, join } from "path";
@@ -8,6 +16,7 @@ import {
   getConfigDirs,
   getInputHistoryPath,
   getLogDir,
+  getSharedStateDir,
   getStateDir,
 } from "../lib/environments/paths.js";
 import { getCurrentEnvironment } from "../lib/environments/resolve.js";
@@ -16,6 +25,20 @@ import type { AssistantEntry } from "../lib/assistant-config.js";
 // The command reads its argv at call time.
 const ORIGINAL_ARGV = process.argv;
 
+// retireDocker is the one retirement path with observable side effects
+// (docker teardown), and uninstall is the only importer in its graph.
+// Mocked module-wide so tests pin WHEN it runs — never before the
+// confirmation gate — as much as whether it runs.
+const retireDockerCalls: string[] = [];
+let onRetireDocker: ((name: string) => void) | undefined;
+
+mock.module("../lib/docker.js", () => ({
+  retireDocker: (name: string) => {
+    retireDockerCalls.push(name);
+    onRetireDocker?.(name);
+  },
+}));
+
 // 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 {
@@ -70,7 +93,15 @@ describe("cadet uninstall", () => {
   const errorSpy = spyOn(console, "error").mockImplementation(() => {});
   const warnSpy = spyOn(console, "warn").mockImplementation(() => {});
 
+  function printedOutput(): string {
+    return logSpy.mock.calls
+      .map((args) => args.map(String).join(" "))
+      .join("\n");
+  }
+
   afterEach(() => {
+    retireDockerCalls.length = 0;
+    onRetireDocker = undefined;
     logSpy.mockClear();
     errorSpy.mockClear();
     warnSpy.mockClear();
@@ -82,11 +113,13 @@ describe("cadet uninstall", () => {
     warnSpy.mockRestore();
   });
 
-  test("refuses while assistants remain — retire them first", async () => {
+  test("warns that remaining assistants will be retired, then proceeds to the confirm gate", async () => {
     await withRestoredEnv(async () => {
       const root = redirectXdg();
-      // A remaining assistant in the lockfile means there is data that
-      // should be retired (and archived) first.
+      // A remaining assistant is retired — with its data deleted — as part
+      // of the uninstall AFTER the user confirms; the pre-confirm summary
+      // says so up front (v0.0.10 run feedback: the hard refusal just
+      // blocked the uninstall; the fs sweep deletes the archives anyway).
       writeFileSync(
         join(process.env.CADET_LOCKFILE_DIR!, "lockfile.json"),
         JSON.stringify({ assistants: [makeEntry("test-assistant")] }) + "\n",
@@ -97,8 +130,16 @@ describe("cadet uninstall", () => {
         throw new Error(`process.exit:${code}`);
       });
       try {
+        // Non-interactive without --yes, the CONFIRM gate is what refuses —
+        // not an assistant guard.
         await expect(uninstall()).rejects.toThrow("process.exit:1");
-        expect(errorSpy).toHaveBeenCalledWith(
+        expect(warnSpy).toHaveBeenCalledWith(
+          expect.stringContaining("1 assistant still exists"),
+        );
+        expect(warnSpy).toHaveBeenCalledWith(
+          expect.stringContaining("will be retired as part of this uninstall"),
+        );
+        expect(errorSpy).not.toHaveBeenCalledWith(
           expect.stringContaining("Retire them first"),
         );
       } finally {
@@ -129,6 +170,67 @@ describe("cadet uninstall", () => {
     });
   });
 
+  test("does not retire assistants when the confirm gate refuses", async () => {
+    await withRestoredEnv(async () => {
+      const root = redirectXdg();
+      writeFileSync(
+        join(process.env.CADET_LOCKFILE_DIR!, "lockfile.json"),
+        JSON.stringify({
+          assistants: [{ ...makeEntry("docker-assistant"), cloud: "docker" }],
+        }) + "\n",
+      );
+
+      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");
+      } finally {
+        exitMock.mockRestore();
+      }
+      // Retirement is part of the confirmed flow — a refusal must leave the
+      // assistant's docker resources untouched.
+      expect(retireDockerCalls).toEqual([]);
+
+      rmSync(root, { recursive: true, force: true });
+    });
+  });
+
+  test("--yes retires remaining assistants after the deletion list is shown", async () => {
+    await withRestoredEnv(async () => {
+      const root = redirectXdg();
+      writeFileSync(
+        join(process.env.CADET_LOCKFILE_DIR!, "lockfile.json"),
+        JSON.stringify({
+          assistants: [{ ...makeEntry("docker-assistant"), cloud: "docker" }],
+        }) + "\n",
+      );
+      mkdirSync(getConfigDirs(getCurrentEnvironment())[0]!, {
+        recursive: true,
+      });
+
+      // Capture what had been printed by the time retirement ran — the list
+      // the user confirms against must already be on screen.
+      let outputAtRetire = "";
+      onRetireDocker = () => {
+        outputAtRetire = printedOutput();
+      };
+
+      process.argv = ["bun", "cadet", "uninstall", "--yes"];
+      await uninstall();
+
+      expect(retireDockerCalls).toEqual(["docker-assistant"]);
+      expect(outputAtRetire).toContain("It will permanently delete:");
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("will be retired as part of this uninstall"),
+      );
+
+      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();
@@ -157,15 +259,54 @@ describe("cadet uninstall", () => {
       expect(existsSync(logDir)).toBe(false);
       expect(existsSync(historyPath)).toBe(false);
 
+      // The list shows the shared state DIR (never the input-history FILE
+      // alone) and never names a nested path twice — the log dir goes with
+      // its parent's recursive delete.
+      const out = printedOutput();
+      expect(out).toContain(
+        `  - ${getSharedStateDir()}  — shared state, including the terminal input history`,
+      );
+      expect(out).not.toContain(logDir);
+      expect(out).not.toContain(historyPath);
+      expect(out).not.toContain("It will then remove the Cadet executable");
+
       // 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(printedOutput()).toContain("source checkout");
       expect(existsSync(process.execPath)).toBe(true);
 
       rmSync(root, { recursive: true, force: true });
     });
   });
+
+  test("--yes lists and removes the Cadet executable itself", async () => {
+    await withRestoredEnv(async () => {
+      const root = redirectXdg();
+      const configDir = getConfigDirs(getCurrentEnvironment())[0]!;
+      mkdirSync(configDir, { recursive: true });
+
+      // A compiled-binary install: process.execPath IS the install, so the
+      // uninstall list must name it alongside the data dirs.
+      const fakeBinDir = join(root, "bin");
+      mkdirSync(fakeBinDir, { recursive: true });
+      const fakeBin = join(fakeBinDir, "cadet");
+      writeFileSync(fakeBin, "#!/bin/sh\n");
+
+      const realExecPath = process.execPath;
+      process.execPath = fakeBin;
+      try {
+        process.argv = ["bun", "cadet", "uninstall", "--yes"];
+        await uninstall();
+      } finally {
+        process.execPath = realExecPath;
+      }
+
+      expect(printedOutput()).toContain(
+        `  - ${fakeBin}  — the Cadet executable`,
+      );
+      expect(existsSync(fakeBin)).toBe(false);
+
+      rmSync(root, { recursive: true, force: true });
+    });
+  });
 });

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

@@ -20,7 +20,7 @@ import type { GuardianTokenData } from "../lib/guardian-token.js";
 import * as guardianToken from "../lib/guardian-token.js";
 import * as local from "../lib/local.js";
 import * as loopbackFetch from "../lib/loopback-fetch.js";
-import * as ngrok from "../lib/ngrok.js";
+import * as ngrok from "../lib/tunnels/ngrok.js";
 import * as upgradeLifecycle from "../lib/upgrade-lifecycle.js";
 
 const realAssistantConfig = { ...assistantConfig };
@@ -157,7 +157,7 @@ const maybeStartNgrokTunnelMock = mock<typeof ngrok.maybeStartNgrokTunnel>(
   async () => null,
 );
 
-mock.module("../lib/ngrok.js", () => ({
+mock.module("../lib/tunnels/ngrok.js", () => ({
   ...realNgrok,
   maybeStartNgrokTunnel: maybeStartNgrokTunnelMock,
 }));
@@ -302,7 +302,7 @@ afterAll(() => {
   mock.module("../lib/guardian-token.js", () => realGuardianToken);
   mock.module("../lib/local.js", () => realLocal);
   mock.module("../lib/loopback-fetch.js", () => realLoopbackFetch);
-  mock.module("../lib/ngrok.js", () => realNgrok);
+  mock.module("../lib/tunnels/ngrok.js", () => realNgrok);
   mock.module("../lib/upgrade-lifecycle.js", () => realUpgradeLifecycle);
 });
 

package/src/__tests__/upgrade-replay-env.test.ts

@@ -6,7 +6,7 @@ import { buildReplayEnv, buildReplayState } from "../lib/upgrade-lifecycle.js";
 import { snapshotEnv } from "./helpers/env.js";
 
 const restoreEnv = snapshotEnv([
-  "CADET_PLATFORM_URL",
+  "CADET_CLOUD_URL",
   "ANTHROPIC_API_KEY",
   "CADET_DEVICE_ID",
 ]);
@@ -24,33 +24,33 @@ describe("buildReplayEnv", () => {
       ACTOR_TOKEN_SIGNING_KEY: "s3",
       PATH: "/usr/bin",
       GATEWAY_PORT: "18080",
-      CADET_DISABLE_PLATFORM: "1",
+      CADET_DISABLE_CLOUD: "1",
       CADET_DEVICE_ID: "abc",
     };
 
     expect(buildReplayEnv(captured, "gateway")).toEqual({
-      CADET_DISABLE_PLATFORM: "1",
+      CADET_DISABLE_CLOUD: "1",
       CADET_DEVICE_ID: "abc",
     });
   });
 
-  test("gateway: captured CADET_PLATFORM_URL dropped when set on host", () => {
-    process.env.CADET_PLATFORM_URL = "https://host.example.com";
+  test("gateway: captured CADET_CLOUD_URL dropped when set on host", () => {
+    process.env.CADET_CLOUD_URL = "https://host.example.com";
     const replay = buildReplayEnv(
-      { CADET_PLATFORM_URL: "https://stale.example.com" },
+      { CADET_CLOUD_URL: "https://stale.example.com" },
       "gateway",
     );
     expect(replay).toEqual({});
   });
 
-  test("gateway: captured CADET_PLATFORM_URL kept when unset on host", () => {
-    delete process.env.CADET_PLATFORM_URL;
+  test("gateway: captured CADET_CLOUD_URL kept when unset on host", () => {
+    delete process.env.CADET_CLOUD_URL;
     const replay = buildReplayEnv(
-      { CADET_PLATFORM_URL: "https://stale.example.com" },
+      { CADET_CLOUD_URL: "https://stale.example.com" },
       "gateway",
     );
     expect(replay).toEqual({
-      CADET_PLATFORM_URL: "https://stale.example.com",
+      CADET_CLOUD_URL: "https://stale.example.com",
     });
   });
 
@@ -118,9 +118,9 @@ describe("buildReplayState", () => {
   });
 
   test("backfills CADET_DEVICE_ID on gateway replay env when absent", () => {
-    const state = buildReplayState({}, { CADET_DISABLE_PLATFORM: "1" });
+    const state = buildReplayState({}, { CADET_DISABLE_CLOUD: "1" });
     expect(state.extraGatewayEnv).toEqual({
-      CADET_DISABLE_PLATFORM: "1",
+      CADET_DISABLE_CLOUD: "1",
       CADET_DEVICE_ID: "host-device-id",
     });
   });