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

package/src/commands/wake.ts

@@ -58,7 +58,7 @@ export const wake = Object.assign(
     console.log("");
     console.log("Arguments:");
     console.log(
-      "  <name>    Name of the assistant to start (default: active or only local)",
+      "  <name>    Name of the assistant to start, defaults to active or only local",
     );
     console.log("");
     console.log("Options:");
@@ -122,7 +122,7 @@ export const wake = Object.assign(
   // Foreground blocking is a single-assistant concern (--all refuses the
   // flag), and the docker path already warned that foreground is ignored.
   if (foreground && entry.cloud !== "docker") {
-    console.log("Running in foreground (Ctrl+C to stop)...\n");
+    console.log("Running in the foreground, Ctrl+C to stop...\n");
     // Block forever — the daemon is running with inherited stdio so its
     // output streams to this terminal. When the user hits Ctrl+C, SIGINT
     // propagates to the daemon child and both exit.
@@ -213,7 +213,7 @@ async function wakeAssistant(
         .filter(Boolean)
         .join(" and ");
       console.warn(
-        `Warning: ${ignored} ignored for Docker instances (not supported).`,
+        `Warning: ${ignored} ignored for Docker instances.`,
       );
     }
     const res = dockerResourceNames(entry.assistantId);
@@ -364,7 +364,7 @@ async function wakeAssistant(
       daemonMigrationsFailed = daemonState.status === "migration_failed";
       if (watch) {
         console.log(
-          `Assistant running (pid ${daemonState.pid}) — watch mode not available (no source files). Keeping existing process.`,
+          `Assistant running (pid ${daemonState.pid}) — watch mode not available, no source files. Keeping existing process.`,
         );
       } else if (daemonMigrationsFailed) {
         console.log(
@@ -488,7 +488,7 @@ async function wakeAssistant(
       } else {
         if (watch) {
           console.log(
-            `Gateway running (pid ${gatewayState.pid}) — watch mode not available (no source files). Keeping existing process.`,
+            `Gateway running (pid ${gatewayState.pid}) — watch mode not available, no source files. Keeping existing process.`,
           );
         } else {
           console.log(`Gateway already running (pid ${gatewayState.pid}).`);
@@ -569,7 +569,7 @@ async function wakeAssistant(
           await new Promise((r) => setTimeout(r, 2000 * 2 ** (attempt - 1)));
         } else {
           console.warn(
-            `   Guardian token re-provision failed${err instanceof GuardianLeasePermanentError ? " (not retrying — a malformed 200 will not fix itself)" : ` after ${maxAttempts} attempts`}: ${err}`,
+            `   Guardian token re-provision failed${err instanceof GuardianLeasePermanentError ?", not retrying — a malformed 200 will not fix itself" : ` after ${maxAttempts} attempts`}: ${err}`,
           );
           // The user explicitly confirmed this destructive repair — a
           // success exit here would make callers (the web recovery flow)

package/src/index.ts

@@ -14,6 +14,7 @@ import cliPkg from "../package.json";
 import { backup } from "./commands/backup";
 import { clean } from "./commands/clean";
 import { client } from "./commands/client";
+import { completeCadet, completions } from "./commands/completions";
 import { confirm } from "./commands/confirm";
 import { connect } from "./commands/connect";
 import { devices } from "./commands/devices";
@@ -53,6 +54,7 @@ const commands = {
   backup,
   clean,
   client,
+  completions,
   confirm,
   connect,
   debug,
@@ -231,6 +233,19 @@ async function main() {
     process.exit(0);
   }
 
+  // Hidden completion hook: the bash completion script calls
+  // `cadet __complete <words-up-to-cursor>` and filters the printed
+  // candidates against the word under the cursor. Deliberately unlisted in
+  // the command map so it never shows up in help.
+  if (commandName === "__complete") {
+    const candidates = completeCadet(
+      process.argv.slice(3),
+      Object.keys(commands),
+    );
+    console.log(candidates.join("\n"));
+    process.exit(0);
+  }
+
   const command = commands[commandName as CommandName];
 
   if (!command) {

package/src/lib/__tests__/docker.test.ts

@@ -8,6 +8,7 @@ import {
   collectWatchTargets,
   dockerResourceNames,
   ensureDockerDaemonRunning,
+  pullImage,
   resolveAvatarDevicePath,
   resolveDockerHatchMode,
   resolveDockerProviderCredentialSetupAction,
@@ -158,6 +159,38 @@ describe("resolveDockerProviderCredentialSetupAction", () => {
       }),
     ).toBe("skip");
   });
+
+  test("detached hatch with a pre-collected key configures instead of deferring", () => {
+    expect(
+      resolveDockerProviderCredentialSetupAction({
+        provider: "fireworks",
+        guardianAccessToken: "guardian-token",
+        detached: true,
+        precollectedKey: "fw-key-123",
+      }),
+    ).toBe("configure");
+  });
+
+  test("pre-collected key without a guardian token reports missing-token (no silent defer)", () => {
+    expect(
+      resolveDockerProviderCredentialSetupAction({
+        provider: "fireworks",
+        detached: true,
+        precollectedKey: "fw-key-123",
+      }),
+    ).toBe("missing-token");
+  });
+
+  test("an explicitly skipped key still counts as answered — configure runs and reports the gap", () => {
+    expect(
+      resolveDockerProviderCredentialSetupAction({
+        provider: "fireworks",
+        guardianAccessToken: "guardian-token",
+        detached: true,
+        precollectedKey: "",
+      }),
+    ).toBe("configure");
+  });
 });
 
 describe("buildServiceRunArgs — gateway", () => {
@@ -384,25 +417,48 @@ describe("collectWatchTargets", () => {
 });
 
 /**
- * Build a fake `exec` that records calls and fails the probes named in `fail`.
- * Injected into `ensureDockerDaemonRunning` so these cases need no `mock.module`
- * (which is process-global and would leak across the CLI's single-process test
- * run) and no real Docker/Colima subprocesses.
+ * Build a STATEFUL fake `exec` modeling the Docker daemon + Colima interplay:
+ * `docker info` succeeds only while `daemonUp`; a `colima start` heals the
+ * daemon (unless the fake is told to model the zombie state, where Colima's
+ * state file says "already running, ignoring" but the daemon stays dead —
+ * only the stop → start cycle recovers). Injected into
+ * `ensureDockerDaemonRunning` so these cases need no `mock.module` (which is
+ * process-global and would leak across the CLI's single-process test run) and
+ * no real Docker/Colima subprocesses.
  */
-function fakeExec(fail: { dockerInfo?: boolean; colimaStatus?: boolean }) {
+function fakeExec(
+  opts: {
+    /** Daemon already reachable when the test starts. */
+    daemonUpAtStart?: boolean;
+    /** `colima start` exits nonzero instead of healing. */
+    startFails?: boolean;
+    /** First `colima start` is a zombie no-op that does NOT heal the daemon. */
+    zombieFirstStart?: boolean;
+  } = {},
+) {
   const calls: Array<{ cmd: string; args: string[] }> = [];
+  let daemonUp = opts.daemonUpAtStart ?? false;
+  let starts = 0;
   const exec = async (cmd: string, args: string[] = []): Promise<void> => {
     calls.push({ cmd, args });
-    if (cmd === "docker" && args[0] === "info" && fail.dockerInfo) {
-      throw new Error("Cannot connect to the Docker daemon");
+    if (cmd === "docker" && args[0] === "info") {
+      if (!daemonUp) throw new Error("Cannot connect to the Docker daemon");
+      return;
+    }
+    if (cmd === "colima" && args[0] === "start") {
+      starts++;
+      if (opts.startFails) throw new Error("colima start exited 1");
+      if (!opts.zombieFirstStart || starts > 1) daemonUp = true;
+      return;
     }
-    if (cmd === "colima" && args[0] === "status" && fail.colimaStatus) {
-      throw new Error("colima is not running");
+    if (cmd === "colima" && args[0] === "stop") {
+      daemonUp = false;
+      return;
     }
   };
   const ran = (cmd: string, sub: string): boolean =>
     calls.some((c) => c.cmd === cmd && c.args[0] === sub);
-  return { exec: exec as typeof import("../step-runner.js").exec, ran };
+  return { exec, ran };
 }
 
 describe("ensureDockerDaemonRunning", () => {
@@ -410,30 +466,122 @@ describe("ensureDockerDaemonRunning", () => {
   // Colima, because that switches the active `docker context` and points
   // `docker start` at a VM that never held the instance's containers.
   test("reuses an already-reachable daemon (e.g. Docker Desktop) and never touches Colima", async () => {
-    const { exec, ran } = fakeExec({ dockerInfo: false });
+    const { exec, ran } = fakeExec({ daemonUpAtStart: true });
 
     await ensureDockerDaemonRunning(exec);
 
     expect(ran("docker", "info")).toBe(true);
-    expect(ran("colima", "status")).toBe(false);
     expect(ran("colima", "start")).toBe(false);
+    expect(ran("colima", "stop")).toBe(false);
   });
 
-  test("starts Colima only when no daemon is reachable", async () => {
-    const { exec, ran } = fakeExec({ dockerInfo: true, colimaStatus: true });
+  test("starts Colima when no daemon is reachable and confirms the daemon answered", async () => {
+    const { exec, ran } = fakeExec();
 
-    await ensureDockerDaemonRunning(exec);
+    await ensureDockerDaemonRunning(exec, { settleTimeoutMs: 0 });
 
     expect(ran("docker", "info")).toBe(true);
     expect(ran("colima", "start")).toBe(true);
+    expect(ran("colima", "stop")).toBe(false);
   });
 
-  test("does not restart Colima when it is already running", async () => {
-    const { exec, ran } = fakeExec({ dockerInfo: true, colimaStatus: false });
+  // Regression (v0.12.8 release feedback): a zombie Colima — stale state file
+  // saying "already running" while the daemon inside is dead — used to sail
+  // through wake (no `colima status` oracle anymore) and leave every later
+  // docker command dying on the unreachable socket.
+  test("recovers a zombie Colima: start no-ops, daemon stays dead → stop --force → start → daemon up", async () => {
+    const { exec, ran } = fakeExec({ zombieFirstStart: true });
 
-    await ensureDockerDaemonRunning(exec);
+    await ensureDockerDaemonRunning(exec, { settleTimeoutMs: 0 });
 
-    expect(ran("colima", "status")).toBe(true);
-    expect(ran("colima", "start")).toBe(false);
+    expect(ran("colima", "start")).toBe(true);
+    expect(ran("colima", "stop")).toBe(true);
+  });
+
+  test("never deletes the Colima VM — the VM disk holds every image and volume", async () => {
+    const { exec, ran } = fakeExec({ zombieFirstStart: true });
+
+    await ensureDockerDaemonRunning(exec, { settleTimeoutMs: 0 });
+
+    expect(ran("colima", "delete")).toBe(false);
+  });
+
+  test("throws an actionable error when even the restart cannot bring the daemon up", () => {
+    // A start that always exits nonzero: the first failure surfaces its
+    // output, the recovery stop+start runs, and the final wait still finds
+    // no daemon → the helper throws instead of letting hatch proceed.
+    const { exec } = fakeExec({ startFails: true });
+    expect(
+      ensureDockerDaemonRunning(exec, { settleTimeoutMs: 0 }),
+    ).rejects.toThrow(/Failed to restart Colima/);
+  });
+});
+
+describe("pullImage", () => {
+  function fakePull(
+    opts: {
+      failFirstPullWith?: string;
+      failAllPullsWith?: string;
+    } = {},
+  ) {
+    const calls: Array<{ cmd: string; args: string[] }> = [];
+    let pulls = 0;
+    const exec = async (cmd: string, args: string[] = []): Promise<void> => {
+      calls.push({ cmd, args });
+      if (cmd === "docker" && args[0] === "pull") {
+        pulls++;
+        if (opts.failAllPullsWith) throw new Error(opts.failAllPullsWith);
+        if (opts.failFirstPullWith && pulls === 1) {
+          throw new Error(opts.failFirstPullWith);
+        }
+      }
+      // `docker logout` (and anything else) succeeds silently.
+    };
+    const ran = (sub: string): boolean =>
+      calls.some((c) => c.cmd === "docker" && c.args[0] === sub);
+    return { exec, ran };
+  }
+
+  test("pulls without touching stored credentials on success", async () => {
+    const { exec, ran } = fakePull();
+
+    await pullImage("mycadet/mycadet-assistant:v1", () => {}, exec);
+
+    expect(ran("pull")).toBe(true);
+    expect(ran("logout")).toBe(false);
+  });
+
+  test("clears stale Docker Hub credentials and retries once on an expired-token error", async () => {
+    const { exec, ran } = fakePull({
+      failFirstPullWith:
+        "Error response from daemon: authentication required - personal access token is expired",
+    });
+
+    await pullImage("mycadet/mycadet-assistant:v1", () => {}, exec);
+
+    expect(ran("logout")).toBe(true);
+  });
+
+  test("wraps the failure with actionable copy when the auth retry also fails", () => {
+    const { exec } = fakePull({
+      failAllPullsWith:
+        "Error response from daemon: authentication required - personal access token is expired",
+    });
+
+    expect(
+      pullImage("mycadet/mycadet-assistant:v1", () => {}, exec),
+    ).rejects.toThrow("Failed to pull mycadet/mycadet-assistant:v1");
+  });
+
+  test("rethrows non-auth pull errors raw and never logs out", () => {
+    const { exec, ran } = fakePull({
+      failAllPullsWith:
+        "Cannot connect to the Docker daemon at unix:///var/run/docker.sock",
+    });
+
+    expect(
+      pullImage("mycadet/mycadet-assistant:v1", () => {}, exec),
+    ).rejects.toThrow("Cannot connect to the Docker daemon");
+    expect(ran("logout")).toBe(false);
   });
 });

package/src/lib/__tests__/job-polling.test.ts

@@ -203,7 +203,7 @@ describe("pollJobUntilDone", () => {
       expect(refreshes).toBe(1);
       expect(calls).toBe(2);
       // The 401 branch logs its own distinct warning (not the generic
-      // "polling failed, retrying" one) so operators can distinguish an
+      // "polling failed:" one) so operators can distinguish an
       // auth refresh from a transient-error retry in the output.
       expect(warnSpy).toHaveBeenCalledWith(
         expect.stringContaining("refreshing auth"),

package/src/lib/__tests__/local-gateway-cli.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, test } from "bun:test";
+
+import type { LocalInstanceResources } from "../assistant-config.js";
+import { gatewayCliInvocation } from "../local.js";
+
+function fakeResources(instanceDir: string): LocalInstanceResources {
+  // gatewayCliInvocation only reads instanceDir; the rest of the resources
+  // shape is irrelevant here.
+  return { instanceDir } as unknown as LocalInstanceResources;
+}
+
+describe("gatewayCliInvocation", () => {
+  test("runs the gateway package's CLI entry through bun", () => {
+    const invocation = gatewayCliInvocation();
+    expect(invocation.args[0]).toBe("run");
+    expect(invocation.args[1]).toMatch(/gateway\/src\/cli\/index\.ts$/);
+  });
+
+  test("pins CADET_WORKSPACE_DIR to the instance dir for named instances", () => {
+    const invocation = gatewayCliInvocation(
+      fakeResources("/data/assistants/testy"),
+    );
+    expect(invocation.env.CADET_WORKSPACE_DIR).toBe(
+      "/data/assistants/testy/workspace",
+    );
+  });
+
+  test("pins GATEWAY_SECURITY_DIR to the instance dir for named instances", () => {
+    const invocation = gatewayCliInvocation(
+      fakeResources("/data/assistants/testy"),
+    );
+    expect(invocation.env.GATEWAY_SECURITY_DIR).toBe(
+      "/data/assistants/testy/gateway-security",
+    );
+  });
+
+  test("leaves the workspace resolution untouched for the default instance", () => {
+    delete process.env.CADET_WORKSPACE_DIR;
+    const invocation = gatewayCliInvocation();
+    expect(invocation.env.CADET_WORKSPACE_DIR).toBeUndefined();
+  });
+});

package/src/lib/cloud-client.ts

@@ -604,7 +604,6 @@ export interface CredentialInjectionParams {
   bearerToken?: string;
   assistantApiKey?: string | null;
   cloudAssistantId: string;
-  cloudBaseUrl: string;
   organizationId: string;
   userId?: string;
   webhookSecret?: string | null;
@@ -631,8 +630,6 @@ export async function injectCredentialsIntoAssistant(
     promises.push(inject("cadet:assistant_api_key", params.assistantApiKey));
   }
 
-  promises.push(inject("cadet:platform_base_url", params.cloudBaseUrl));
-
   if (params.webhookSecret) {
     promises.push(inject("cadet:webhook_secret", params.webhookSecret));
   }

package/src/lib/cloud-login.ts

@@ -409,7 +409,6 @@ export async function registerLocalAssistantWithPlatform(
     bearerToken: options.bearerToken ?? entry.bearerToken,
     assistantApiKey,
     cloudAssistantId: registration.assistant.id,
-    cloudBaseUrl: cloudUrl,
     organizationId: orgId,
     userId: user.id,
     webhookSecret: registration.webhook_secret,

package/src/lib/cloud-releases.ts

@@ -85,7 +85,9 @@ export async function fetchLatestStableVersion(): Promise<string | null> {
 }
 
 /**
- * Image refs for a target version: the tag is the target version, the repo
+ * Image refs for a target version: the tag is the target version exactly as
+ * the release workflows push it — bare ("0.12.8", "0.12.8-dev…"); a
+ * git-tag-style "v" prefix on the input is tolerated and stripped. The repo
  * follows the CLI's own version shape (dev CLI → `-dev` repos).
  */
 export function resolveImageRefs(
@@ -93,8 +95,8 @@ export function resolveImageRefs(
   cliVersion: string,
 ): Record<ServiceName, string> {
   const versionTag = targetVersion.startsWith("v")
-    ? targetVersion
-    : `v${targetVersion}`;
+    ? targetVersion.slice(1)
+    : targetVersion;
   const images = dockerhubImages(cliVersion);
   return {
     assistant: `${images.assistant}:${versionTag}`,
@@ -107,5 +109,5 @@ export function resolveImageRefs(
 export function resolveOwnImageRefs(
   cliVersion: string,
 ): Record<ServiceName, string> {
-  return resolveImageRefs(cliVersion ? `v${cliVersion}` : "latest", cliVersion);
+  return resolveImageRefs(cliVersion || "latest", cliVersion);
 }

package/src/lib/color.ts

@@ -14,3 +14,7 @@ export function red(text: string, stream?: NodeJS.WriteStream): string {
 export function yellow(text: string, stream?: NodeJS.WriteStream): string {
   return colorize("\x1b[33m", text, stream);
 }
+
+export function green(text: string, stream?: NodeJS.WriteStream): string {
+  return colorize("\x1b[32m", text, stream);
+}