@mycadet/cli 0.12.9 → 0.12.11

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,12 @@ describe("cadet uninstall", () => {
     warnSpy.mockRestore();
   });
 
-  test("warns and retires remaining assistants, then proceeds to the confirm gate", 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 is retired — with its data deleted — as part
-      // of the uninstall (v0.0.10 run feedback: the old hard refusal just
+      // 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"),
@@ -105,7 +137,7 @@ describe("cadet uninstall", () => {
           expect.stringContaining("1 assistant still exists"),
         );
         expect(warnSpy).toHaveBeenCalledWith(
-          expect.stringContaining("will be retired now"),
+          expect.stringContaining("will be retired as part of this uninstall"),
         );
         expect(errorSpy).not.toHaveBeenCalledWith(
           expect.stringContaining("Retire them first"),
@@ -138,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();
@@ -166,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/commands/client.ts

@@ -1304,10 +1304,9 @@ async function spawnBackgroundWebInterface(
 export function buildWebInterfaceConfig(opts: {
   webUrl: string;
   cloudUrl: string;
-  disableCloud: boolean;
 }): Record<string, unknown> {
-  const { webUrl, cloudUrl, disableCloud } = opts;
-  return { webUrl, cloudUrl, disableCloud };
+  const { webUrl, cloudUrl } = opts;
+  return { webUrl, cloudUrl };
 }
 
 async function runWebInterface(
@@ -1349,9 +1348,7 @@ async function runWebInterface(
   const webUrl = getWebUrl();
   const safeJson = (v: unknown) =>
     JSON.stringify(v).replace(/</g, "\\u003c").replace(/>/g, "\\u003e");
-  const configJson = safeJson(
-    buildWebInterfaceConfig({ webUrl, cloudUrl, disableCloud }),
-  );
+  const configJson = safeJson(buildWebInterfaceConfig({ webUrl, cloudUrl }));
   const hasOverrides = Object.keys(parsedFlagOverrides).length > 0;
   const flagOverridesSnippet = hasOverrides
     ? `;window.__CADET_FLAG_OVERRIDES__=${safeJson(parsedFlagOverrides)}`
@@ -1557,6 +1554,7 @@ async function runViteDevServer(
       ...viteFlagVars,
       ...(disableCloud ? { VITE_CADET_DISABLE_CLOUD: "true" } : {}),
       VITE_CLOUD_MODE: "false",
+      VITE_WEB_MODE: "full",
       API_PROXY_TARGET: cloudUrl,
       CADET_WEB_URL: getWebUrl(),
       CADET_CLOUD_URL: cloudUrl,

package/src/commands/devices.ts

@@ -13,6 +13,7 @@
  * that runs the assistant (server side).
  */
 
+import { z } from "zod";
 import { createHash } from "node:crypto";
 
 import type { DeviceRecord } from "@mycadet/local-mode";
@@ -33,8 +34,16 @@ import {
   canPromptForConfirmation,
   confirmAction,
 } from "../lib/confirm-action.js";
+import { GATEWAY_INTERNAL_PORT } from "../lib/environments/paths.js";
+import { execOutput } from "../lib/step-runner.js";
+import { dockerResourceNames } from "../lib/docker.js";
 import { loopbackSafeFetch } from "../lib/loopback-fetch.js";
 
+const dockerGatewayResponseSchema = z.object({
+  status: z.number().int().min(200).max(599),
+  body: z.string(),
+});
+
 function printUsage(): void {
   console.log(`cadet devices [beta] - List and revoke devices paired to a local assistant
 
@@ -81,6 +90,9 @@ function resolveLoopbackBase(entry: AssistantEntry): string {
     process.exit(1);
   }
 
+  if (entry.cloud === "docker")
+    return `http://127.0.0.1:${GATEWAY_INTERNAL_PORT}`;
+
   const base =
     entry.localUrl ||
     (entry.resources?.gatewayPort
@@ -96,6 +108,31 @@ function resolveLoopbackBase(entry: AssistantEntry): string {
   return base.replace(/\/+$/, "");
 }
 
+/** Docker host management enters the gateway network namespace before calling loopback-only routes. */
+async function deviceRequest(
+  entry: AssistantEntry,
+  url: string,
+  init: RequestInit,
+): Promise<Response> {
+  if (entry.cloud !== "docker") return loopbackSafeFetch(url, init);
+  const script = `const r = await fetch(process.argv[1], {...JSON.parse(process.argv[2]), signal: AbortSignal.timeout(10000)}); console.log(JSON.stringify({status:r.status, body:await r.text()}));`;
+  const output = await execOutput(
+    "docker",
+    [
+      "exec",
+      dockerResourceNames(entry.assistantId).gatewayContainer,
+      "bun",
+      "-e",
+      script,
+      url,
+      JSON.stringify(init),
+    ],
+    { timeoutMs: 15000 },
+  );
+  const result = dockerGatewayResponseSchema.parse(JSON.parse(output));
+  return new Response(result.body, { status: result.status });
+}
+
 /**
  * The hashed device id the gateway stores for THIS machine's own guardian
  * credential (`leaseGuardianToken` registers it device-bound as
@@ -122,7 +159,7 @@ async function listDevices(
 
   let response: Response;
   try {
-    response = await loopbackSafeFetch(`${base}/v1/devices`, {
+    response = await deviceRequest(entry, `${base}/v1/devices`, {
       method: "GET",
       headers: getClientRegistrationHeaders(CLI_INTERFACE_ID),
     });
@@ -239,7 +276,7 @@ async function revokeDevice(
 
   let response: Response;
   try {
-    response = await loopbackSafeFetch(`${base}/v1/devices/revoke`, {
+    response = await deviceRequest(entry, `${base}/v1/devices/revoke`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -281,38 +318,37 @@ async function revokeDevice(
 
 export const devices = Object.assign(
   async function devices(): Promise<void> {
-  const rawArgs = process.argv.slice(3);
-
-  if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
-    printUsage();
-    return;
-  }
+    const rawArgs = process.argv.slice(3);
 
-  const jsonOutput = rawArgs.includes("--json");
-  const args = rawArgs.filter((a) => a !== "--json");
-
-  if (args[0] === "revoke") {
-    const rest = args.slice(1);
-    const yes = rest.includes("--yes");
-    const positionals = rest.filter((a) => !a.startsWith("-"));
-    const hashedDeviceId = positionals[0];
-    if (!hashedDeviceId) {
-      console.error("Error: a hashedDeviceId is required to revoke.");
+    if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
       printUsage();
-      process.exit(1);
+      return;
     }
-    const nameArg = positionals.slice(1).join(" ") || undefined;
+
+    const jsonOutput = rawArgs.includes("--json");
+    const args = rawArgs.filter((a) => a !== "--json");
+
+    if (args[0] === "revoke") {
+      const rest = args.slice(1);
+      const yes = rest.includes("--yes");
+      const positionals = rest.filter((a) => !a.startsWith("-"));
+      const hashedDeviceId = positionals[0];
+      if (!hashedDeviceId) {
+        console.error("Error: a hashedDeviceId is required to revoke.");
+        printUsage();
+        process.exit(1);
+      }
+      const nameArg = positionals.slice(1).join(" ") || undefined;
+      const entry = resolveTargetAssistant(nameArg);
+      const base = resolveLoopbackBase(entry);
+      await revokeDevice(entry, base, hashedDeviceId, yes, jsonOutput);
+      return;
+    }
+
+    const nameArg = parseAssistantTargetArg(args, []);
     const entry = resolveTargetAssistant(nameArg);
     const base = resolveLoopbackBase(entry);
-    await revokeDevice(entry, base, hashedDeviceId, yes, jsonOutput);
-    return;
-  }
-
-  const nameArg = parseAssistantTargetArg(args, []);
-  const entry = resolveTargetAssistant(nameArg);
-  const base = resolveLoopbackBase(entry);
-  await listDevices(entry, base, jsonOutput);
-},
+    await listDevices(entry, base, jsonOutput);
+  },
   { description: "List or revoke devices paired to a local assistant [beta]" },
 );
-

package/src/commands/hatch.ts

@@ -6,10 +6,11 @@ import {
   saveAssistantEntry,
   setActiveAssistant,
 } from "../lib/assistant-config";
+import { green } from "../lib/color";
 import { HATCH_ART, HATCHED_EMOJI, VALID_REMOTE_HOSTS } from "../lib/constants";
 import type { RemoteHost } from "../lib/constants";
 import { hatchDocker } from "../lib/docker";
-import { parseFeatureFlagArgs, readAmbientFlagEnvVars } from "../lib/flag-args";
+import { readAmbientFlagEnvVars } from "../lib/flag-args";
 import { hatchLocal } from "../lib/hatch-local";
 import {
   getCloudUrl,
@@ -22,37 +23,26 @@ const DEFAULT_REMOTE: RemoteHost = "local";
 
 interface HatchArgs {
   verbose: boolean;
-  keepAlive: boolean;
   name: string | null;
   remote: RemoteHost;
   watch: boolean;
   sourcePath: string | null;
   configValues: Record<string, string>;
   flagEnvVars: Record<string, string>;
-  analyze: boolean;
-  disableCloud: boolean;
   netnsContainer: string | null;
   gatewayPort: number | null;
   assistantCaCert: string | null;
 }
 
 function parseArgs(): HatchArgs {
-  const { envVars: cliFlagVars, remaining: args } = parseFeatureFlagArgs(
-    process.argv.slice(3),
-  );
-  const flagEnvVars = { ...readAmbientFlagEnvVars(), ...cliFlagVars };
-  const disableCloudAmbient =
-    process.env.CADET_DISABLE_CLOUD?.trim().toLowerCase();
-  let disableCloud =
-    disableCloudAmbient === "true" || disableCloudAmbient === "1";
+  const args = process.argv.slice(3);
+  const flagEnvVars = readAmbientFlagEnvVars();
   let verbose = false;
-  let keepAlive = false;
   let name: string | null = null;
   let remote: RemoteHost = DEFAULT_REMOTE;
   let watch = false;
   let sourcePath: string | null = null;
   const configValues: Record<string, string> = {};
-  let analyze = false;
   let netnsContainer: string | null = null;
   let gatewayPort: number | null = null;
   let assistantCaCert: string | null = null;
@@ -68,47 +58,33 @@ function parseArgs(): HatchArgs {
       console.log(
         "  -v, --verbose             Show service startup logs and extended next steps",
       );
-      console.log("  --name <name>             Custom instance name");
+      console.log("  --name <name>             Custom name for this assistant");
       console.log(
         "  --remote <host>           Remote host (local, docker, custom, cloud)",
       );
       console.log(
-        "  --watch                   Run assistant and gateway in watch mode (hot reload on source changes)",
-      );
-      console.log(
-        "  --source <path>           Build images from a local source tree at <path>. Useful for callers that want each run to pick up local CLI changes.",
+        "  --watch                   Run Cadet in watch mode with hot reload on source changes",
       );
       console.log(
-        "  --keep-alive              Stay alive after hatch, exit when gateway stops",
+        "  --source <path>           Build images from a local source tree at <path>",
       );
       console.log(
         "  --config <key=value>      Set a workspace config value (repeatable)",
       );
       console.log(
-        "  --flag <key=value>        Set a feature flag override as CADET_FLAG_<KEY> env var (repeatable)",
-      );
-      console.log(
-        "  --analyze                 Emit a structured hatch-timing log line on stdout",
-      );
-      console.log(
-        "  --disable-cloud        Suppress all outbound platform API calls",
-      );
-      console.log(
-        "  --netns-container <name>  Join an existing container's network namespace (docker target only) instead of creating a per-instance network. The namespace owner publishes host ports, so --gateway-port is required.",
+        "  --netns-container <name>  Join an existing container's network namespace instead of creating a per-instance network.",
       );
       console.log(
-        "  --gateway-port <port>     Use an explicit host port for the gateway runtime URL instead of auto-allocating. Required with --netns-container.",
+        "  --gateway-port <port>     Use an explicit host port for accessing the assistant.",
       );
       console.log(
-        "  --assistant-ca-cert <path>  Trust an extra PEM CA bundle in the assistant container (NODE_EXTRA_CA_CERTS) from process start. Useful behind a TLS-terminating egress proxy.",
+        "  --assistant-ca-cert <path>  Trust an extra PEM CA bundle in the assistant container from process start.",
       );
       process.exit(0);
     } else if (arg === "-v" || arg == "--verbose") {
       verbose = true;
     } else if (arg === "--watch") {
       watch = true;
-    } else if (arg === "--analyze") {
-      analyze = true;
     } else if (arg === "--source") {
       const next = args[i + 1];
       if (!next || next.startsWith("-")) {
@@ -117,8 +93,6 @@ function parseArgs(): HatchArgs {
       }
       sourcePath = next;
       i++;
-    } else if (arg === "--keep-alive") {
-      keepAlive = true;
     } else if (arg === "--name") {
       const next = args[i + 1];
       if (!next || next.startsWith("-")) {
@@ -162,8 +136,6 @@ function parseArgs(): HatchArgs {
       const value = next.slice(eqIndex + 1);
       configValues[key] = value;
       i++;
-    } else if (arg === "--disable-cloud") {
-      disableCloud = true;
     } else if (arg === "--netns-container") {
       const next = args[i + 1];
       if (!next || next.startsWith("-")) {
@@ -193,7 +165,7 @@ function parseArgs(): HatchArgs {
       i++;
     } else {
       console.error(
-        `Error: Unknown argument '${arg}'. Valid options: -v, --verbose, --watch, --source <path>, --keep-alive, --name <name>, --remote <${VALID_REMOTE_HOSTS.join("|")}>, --config <key=value>, --flag <key=value>, --analyze, --disable-cloud, --netns-container <name>, --gateway-port <port>, --assistant-ca-cert <path>`,
+        `Error: Unknown argument '${arg}'. Valid options: -v, --verbose, --watch, --source <path>, --name <name>, --remote <${VALID_REMOTE_HOSTS.join("|")}>, --config <key=value>, --netns-container <name>, --gateway-port <port>, --assistant-ca-cert <path>`,
       );
       process.exit(1);
     }
@@ -201,15 +173,12 @@ function parseArgs(): HatchArgs {
 
   return {
     verbose,
-    keepAlive,
     name,
     remote,
     watch,
     sourcePath,
     configValues,
     flagEnvVars,
-    analyze,
-    disableCloud,
     netnsContainer,
     gatewayPort,
     assistantCaCert,
@@ -229,25 +198,17 @@ export const hatch = Object.assign(
 
   const {
     verbose,
-    keepAlive,
     name,
     remote,
     watch,
     sourcePath,
     configValues,
     flagEnvVars,
-    analyze,
-    disableCloud,
     netnsContainer,
     gatewayPort,
     assistantCaCert,
   } = parseArgs();
 
-  if (disableCloud) {
-    process.env.CADET_DISABLE_CLOUD = "true";
-    flagEnvVars.CADET_DISABLE_CLOUD = "true";
-  }
-
   if (watch && remote !== "local" && remote !== "docker") {
     console.error(
       "Error: --watch is only supported for local and docker hatch targets.",
@@ -285,7 +246,6 @@ export const hatch = Object.assign(
     await hatchLocal({
       name,
       watch,
-      keepAlive,
       configValues,
       flagEnvVars,
       verbose,
@@ -300,7 +260,6 @@ export const hatch = Object.assign(
       configValues,
       flagEnvVars,
       sourcePath,
-      analyze,
       netnsContainer: netnsContainer ?? undefined,
       gatewayPort: gatewayPort ?? undefined,
       assistantCaCertPath: assistantCaCert ?? undefined,
@@ -347,7 +306,9 @@ async function hatchCadetPlatform(): Promise<void> {
   });
   setActiveAssistant(result.id);
 
-  console.log(`   ${HATCHED_EMOJI}  Your assistant has hatched!`);
+  console.log(
+    "   " + green(`${HATCHED_EMOJI}  Your assistant has hatched!`, process.stdout),
+  );
   console.log("");
   console.log(`   ID:     ${result.id}`);
   console.log(`   Name:   ${result.name}`);