@mycadet/cli 0.12.8 → 0.12.9-dev.202610131620.d833e01

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"),
@@ -102,10 +134,10 @@ describe("cadet uninstall", () => {
         // not an assistant guard.
         await expect(uninstall()).rejects.toThrow("process.exit:1");
         expect(warnSpy).toHaveBeenCalledWith(
-          expect.stringContaining("1 assistant(s) still exist"),
+          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/__tests__/wake.test.ts

@@ -1503,14 +1503,14 @@ describe("cadet wake — tunnel edge restore", () => {
     loadRawConfigMock.mockReturnValue(webhookConfig);
     ensureTunnelEdgeMock.mockRejectedValue(
       new Error(
-        "nginx is not installed, so the tunnel edge cannot start. Install it (macOS: `brew install nginx`, Linux: `sudo apt install nginx`) or point NGINX_BIN at an existing binary.",
+        "nginx is not installed, so the tunnel edge cannot start. See https://nginx.org/en/docs/install.html for how to install, or point NGINX_BIN at an existing binary.",
       ),
     );
 
     await wake();
 
     expect(warnSpy).toHaveBeenCalledWith(
-      expect.stringContaining("brew install nginx"),
+      expect.stringContaining("https://nginx.org/en/docs/install.html"),
     );
     // No tunnel is recorded here, so no provider can be named and the advice
     // points at the help that lists them.

package/src/commands/backup.ts

@@ -42,10 +42,10 @@ export const backup = Object.assign(
     console.log("Options:");
     console.log("  --output <path>          Path to save the .vbundle file");
     console.log(
-      "                           (default: ~/.local/share/cadet/backups/<name>-<timestamp>.vbundle)",
+      "                           defaults to ~/.local/share/cadet/backups/<name>-<timestamp>.vbundle",
     );
     console.log(
-      `  --export-timeout <secs>  Export request timeout in seconds (default: ${DEFAULT_EXPORT_TIMEOUT_MS / 1000})`,
+      `  --export-timeout <secs>  Export request timeout in seconds, defaults to ${DEFAULT_EXPORT_TIMEOUT_MS / 1000}`,
     );
     console.log("");
     console.log("Examples:");
@@ -254,7 +254,7 @@ async function backupPlatform(
   const cloudToken = readCloudToken();
   if (!cloudToken) {
     console.error(
-      "Not logged in. Run 'cadet login' first (required for cloud-managed backup).",
+      "Not logged in. Run 'cadet login' first.",
     );
     process.exit(1);
   }

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/completions.test.ts

@@ -0,0 +1,104 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+
+import { saveAssistantEntry } from "../lib/assistant-config.js";
+import { completeCadet } from "./completions.js";
+
+const COMMAND_NAMES = [
+  "backup",
+  "clean",
+  "client",
+  "completions",
+  "confirm",
+  "connect",
+  "hatch",
+  "ps",
+  "retire",
+  "sleep",
+  "use",
+  "wake",
+];
+
+describe("completeCadet", () => {
+  let lockfileDir: string;
+  let prevLockfileDir: string | undefined;
+
+  beforeEach(() => {
+    lockfileDir = mkdtempSync(join(tmpdir(), "cadet-completions-"));
+    prevLockfileDir = process.env.CADET_LOCKFILE_DIR;
+    process.env.CADET_LOCKFILE_DIR = lockfileDir;
+  });
+
+  afterEach(() => {
+    if (prevLockfileDir === undefined) delete process.env.CADET_LOCKFILE_DIR;
+    else process.env.CADET_LOCKFILE_DIR = prevLockfileDir;
+    rmSync(lockfileDir, { recursive: true, force: true });
+  });
+
+  function seed(id: string): void {
+    saveAssistantEntry({
+      assistantId: id,
+      cloud: "docker",
+      runtimeUrl: "http://localhost:7830",
+      hatchedAt: new Date().toISOString(),
+    });
+  }
+
+  test("no words yet offers every command name, sorted", () => {
+    const input: string[] = [];
+    expect(completeCadet(input, COMMAND_NAMES)).toEqual(
+      [...COMMAND_NAMES].sort(),
+    );
+    // The word under the cursor is popped from a COPY — the caller's array
+    // (bash's COMP_WORDS) must come back untouched.
+    expect(input).toEqual([]);
+  });
+
+  test("first positional of an assistant-name command offers known assistant names", () => {
+    seed("quill-owl-d4e5f6");
+    seed("fable-fox-a1b2c3");
+    // `cadet retire <TAB>` — the empty trailing word is the word being completed.
+    expect(completeCadet(["retire", ""], COMMAND_NAMES)).toEqual([
+      "fable-fox-a1b2c3",
+      "quill-owl-d4e5f6",
+    ]);
+  });
+
+  test("partial words are returned unfiltered — the shell does prefix filtering", () => {
+    seed("quill-owl-d4e5f6");
+    seed("fable-fox-a1b2c3");
+    expect(completeCadet(["retire", "fable"], COMMAND_NAMES)).toEqual([
+      "fable-fox-a1b2c3",
+      "quill-owl-d4e5f6",
+    ]);
+  });
+
+  test("flag prefixes fall through to the shell default (no candidates)", () => {
+    seed("fable-fox-a1b2c3");
+    expect(completeCadet(["retire", "--"], COMMAND_NAMES)).toEqual([]);
+    expect(completeCadet(["retire", "--name"], COMMAND_NAMES)).toEqual([]);
+  });
+
+  test("deeper positionals of an assistant-name command offer nothing", () => {
+    seed("fable-fox-a1b2c3");
+    expect(
+      completeCadet(["exec", "fable-fox-a1b2c3", ""], COMMAND_NAMES),
+    ).toEqual([]);
+    expect(
+      completeCadet(["logs", "fable-fox-a1b2c3", "tail", ""], COMMAND_NAMES),
+    ).toEqual([]);
+  });
+
+  test("commands that take no assistant name offer nothing after the command word", () => {
+    seed("fable-fox-a1b2c3");
+    expect(completeCadet(["hatch", ""], COMMAND_NAMES)).toEqual([]);
+    expect(completeCadet(["ps", ""], COMMAND_NAMES)).toEqual([]);
+  });
+
+  test("an unreadable/empty lockfile completes quietly with no names", () => {
+    // No entries seeded — the lockfile dir exists but has no lockfile.json.
+    expect(completeCadet(["retire", ""], COMMAND_NAMES)).toEqual([]);
+  });
+});

package/src/commands/completions.ts

@@ -0,0 +1,87 @@
+import { loadAllAssistants } from "../lib/assistant-config.js";
+
+/**
+ * Commands whose first positional argument is an assistant name — completing
+ * their first word offers the names of known assistants (from the lockfile)
+ * instead of falling through to shell file completion.
+ */
+const ASSISTANT_NAME_COMMANDS = new Set([
+  "exec",
+  "logs",
+  "message",
+  "restart",
+  "restore",
+  "retire",
+  "rollback",
+  "sleep",
+  "teleport",
+  "terminal",
+  "tunnel",
+  "unpair",
+  "upgrade",
+  "use",
+  "wake",
+]);
+
+/** Assistant names known to this CLI's lockfile; [] when the lockfile is unreadable. */
+function assistantNames(): string[] {
+  try {
+    return loadAllAssistants()
+      .map((entry) => entry.assistantId)
+      .sort();
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Resolve completion candidates for the word the cursor is on.
+ *
+ * `words` carries every command-line word after `cadet` up to the cursor,
+ * INCLUDING the (possibly empty) word being completed — the same shape bash
+ * passes via `COMP_WORDS[@]:1`. The returned list is UNFILTERED: the shell
+ * (`compgen -W`) does the prefix filtering, so the CLI only decides WHAT
+ * KIND of thing completes here.
+ */
+export function completeCadet(
+  input: string[],
+  commandNames: readonly string[],
+): string[] {
+  const words = [...input];
+  const toComplete = words.pop() ?? "";
+  const preceding = words;
+
+  // Completing the command word itself (or nothing typed yet).
+  if (preceding.length === 0) {
+    return [...commandNames].sort();
+  }
+
+  // First positional of an assistant-name command: offer instance names.
+  // Flag prefixes fall through to shell default (no flag completion yet).
+  if (
+    preceding.length === 1 &&
+    ASSISTANT_NAME_COMMANDS.has(preceding[0]) &&
+    !toComplete.startsWith("-")
+  ) {
+    return assistantNames();
+  }
+
+  return [];
+}
+
+const BASH_COMPLETION_SCRIPT = `# bash completion for the cadet CLI — load with:  eval "$(cadet completions)"
+_cadet_completions() {
+  local candidates
+  candidates=$(cadet __complete "\${COMP_WORDS[@]:1}" 2>/dev/null)
+  COMPREPLY=($(compgen -W "$candidates" -- "\${COMP_WORDS[COMP_CWORD]}"))
+}
+complete -F _cadet_completions cadet`;
+
+// ── Entry point ─────────────────────────────────────────────────
+
+export const completions = Object.assign(
+  async function completions(): Promise<void> {
+    console.log(BASH_COMPLETION_SCRIPT);
+  },
+  { description: `Print bash completion setup (eval "$(cadet completions)")` },
+);

package/src/commands/exec.ts

@@ -75,28 +75,28 @@ export const exec = Object.assign(
     console.log("");
     console.log("Arguments:");
     console.log(
-      "  <name>              Name of the assistant (defaults to active)",
+      "  <name>              Name of the assistant, defaults to active",
     );
     console.log(
       "  <command...>        Command and arguments to run (after --)",
     );
     console.log("");
     console.log("Options:");
-    console.log("  --service <svc>     Target service (default: assistant)");
+    console.log("  --service <svc>     Target service, defaults to assistant");
     console.log(
       "  -it                 Interactive mode with TTY (like docker exec -it)",
     );
     console.log(
-      "  --timeout <secs>    Timeout in seconds (default: 30, 0 = no timeout)",
+      "  --timeout <secs>    Timeout in seconds — default 30, 0 = no timeout",
     );
     console.log(
-      "  --verbose           Show debug output (SSE events, sentinel parsing)",
+      "  --verbose           Show debug output",
     );
     console.log("");
     console.log("Services:");
-    console.log("  assistant (or mycadet)");
-    console.log("  gateway (or cadet-gateway)");
-    console.log("  credential-executor (or cadet-credential-executor)");
+    console.log("  assistant");
+    console.log("  gateway");
+    console.log("  credential-executor");
     console.log("");
     console.log("Examples:");
     console.log("  cadet exec -- ls -la /workspace");

package/src/commands/flags.ts

@@ -59,7 +59,7 @@ function printFlagTable(flags: FeatureFlagEntry[]): void {
     console.log(formatRow(row));
   }
   console.log("");
-  console.log("* = overridden (differs from default)");
+  console.log("* = overridden");
 }
 
 function printHelp(): void {
@@ -67,7 +67,7 @@ function printHelp(): void {
   console.log("");
   console.log("Show and toggle feature flags for the active assistant.");
   console.log(
-    "Reads from the gateway's merged flag state (persisted overrides > remote > defaults).",
+    "Reads from the gateway's merged flag state.",
   );
   console.log("");
   console.log("Subcommands:");

package/src/commands/hatch.ts

@@ -6,6 +6,7 @@ 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";
@@ -76,7 +77,7 @@ function parseArgs(): HatchArgs {
         "  --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> (no watcher). Useful for callers (e.g. evals) that want each run to pick up local CLI changes.",
+        "  --source <path>           Build images from a local source tree at <path>. Useful for callers that want each run to pick up local CLI changes.",
       );
       console.log(
         "  --keep-alive              Stay alive after hatch, exit when gateway stops",
@@ -347,7 +348,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}`);

package/src/commands/logs.ts

@@ -32,19 +32,19 @@ function printHelp(): void {
   console.log("");
   console.log("Arguments:");
   console.log(
-    "  <name>                Name of the assistant (defaults to latest)",
+    "  <name>                Name of the assistant, defaults to latest",
   );
   console.log("");
   console.log("Options:");
-  console.log("  -f, --follow          Follow log output (stream new lines)");
-  console.log("  -n, --tail <N>        Show last N lines (default: all)");
+  console.log("  -f, --follow          Follow log output");
+  console.log("  -n, --tail <N>        Show last N lines");
   console.log("  -t, --timestamps      Show timestamps on each line");
   console.log(
-    "  --since <time>        Show logs since timestamp or relative (e.g. 10m, 2h)",
+    "  --since <time>        Show logs since timestamp or relative, e.g. 10m or 2h",
   );
   console.log("  --until <time>        Show logs until timestamp or relative");
   console.log(
-    "  -s, --service <name>  Filter to a specific service (e.g. assistant, gateway)",
+    "  -s, --service <name>  Filter to a specific service",
   );
   console.log("  -h, --help            Show this help");
 }
@@ -186,13 +186,13 @@ async function showLocalLogs(
 
   if (opts.since && !sinceDate) {
     console.error(
-      `Error: Could not parse --since value '${opts.since}'. Use relative (e.g. 10m, 2h) or ISO format.`,
+      `Error: Could not parse --since value '${opts.since}'. Use a relative value such as 10m or 2h, or ISO format.`,
     );
     process.exit(1);
   }
   if (opts.until && !untilDate) {
     console.error(
-      `Error: Could not parse --until value '${opts.until}'. Use relative (e.g. 10m, 2h) or ISO format.`,
+      `Error: Could not parse --until value '${opts.until}'. Use a relative value such as 10m or 2h, or ISO format.`,
     );
     process.exit(1);
   }