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

package/src/commands/tunnel.ts

@@ -22,9 +22,10 @@ import {
 } from "../lib/ingress-config.js";
 import {
   ensureTunnelEdge,
-  formatEdgeMode,
+  getNginxVersion,
   type TunnelEdge,
 } from "../lib/nginx-ingress.js";
+import { ensureBinaryInstalled } from "../lib/ensure-binary.js";
 import { STALE_CLI_UPDATE_HINT } from "../lib/stale-cli-hint.js";
 import {
   ADOPTED_TUNNEL_RE,
@@ -46,7 +47,7 @@ interface TunnelArgs {
   provider: TunnelProviderName;
   domain: string | null;
   clearDomain: boolean;
-  detach: boolean;
+  foreground: boolean;
 }
 
 const FLAGS_WITH_VALUES = ["--provider", "--domain"] as const;
@@ -56,7 +57,7 @@ function parseArgs(): TunnelArgs {
   let provider: TunnelProviderName | null = null;
   let domain: string | null = null;
   let clearDomain = false;
-  let detach = false;
+  let foreground = false;
 
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -73,29 +74,30 @@ function parseArgs(): TunnelArgs {
       console.log(
         "How far that URL reaches depends on the provider; omit --provider for",
       );
-      console.log("the default. A tailscale tunnel is reachable only from your");
       console.log(
-        "own tailnet; webhook integrations need a public tunnel (see Providers",
+        "the default. A tailscale tunnel is reachable only from your",
       );
-      console.log("below).");
+      console.log(
+        "own tailnet; webhook integrations need a public tunnel. See Providers",
+      );
+      console.log("below.");
       console.log("");
       console.log(
         "The tunnel always fronts the local nginx edge, which is started automatically.",
       );
       console.log(
-        "nginx must be installed (macOS: brew install nginx, Linux: sudo apt install nginx).",
+        "nginx must be installed; if it is missing, cadet offers to install it.",
       );
       console.log("");
       console.log("Arguments:");
       console.log(
-        "  <name>                        Name of the assistant (defaults to active or only local)",
+        "  <name>                        Name of the assistant, defaults to active or only local",
       );
       console.log("");
       console.log("Options:");
       console.log(
-        `  --provider <provider>         Tunnel provider: ${TUNNEL_PROVIDERS.join(", ")}`,
+        `  --provider <provider>         Tunnel provider: ${TUNNEL_PROVIDERS.join(", ")} — default ${DEFAULT_TUNNEL_PROVIDER}`,
       );
-      console.log(`                                (default: ${DEFAULT_TUNNEL_PROVIDER})`);
       console.log(
         "  --domain <domain>             Reserved domain to bind, for providers that support",
       );
@@ -110,19 +112,22 @@ function parseArgs(): TunnelArgs {
         "                                tunnel without one. Cannot be combined with --domain.",
       );
       console.log(
-        `  -d, --detach                  Run the tunnel in the background. Waits up to ${TUNNEL_BACKGROUND_START_TIMEOUT_MS / 1000}s for the`,
+        `  --foreground                  Stream the tunnel's logs to this terminal. By default the tunnel`,
       );
       console.log(
-        "                                initial established/failed status before returning; logs go to",
+        "                                runs in the background: the command returns after printing the public",
       );
       console.log(
-        "                                the CLI log directory. Stop it with `kill <pid>`, except when it",
+        `                                URL, and logs stream to tunnel.log in the CLI log directory. A background`,
       );
       console.log(
-        "                                adopted an already-running tunnel (started outside this",
+        "                                tunnel stops with `kill <pid>`, except when it adopted an already-running",
       );
       console.log(
-        "                                command): killing the supervisor then leaves that tunnel running.",
+        "                                tunnel (started outside this command): killing the supervisor then",
+      );
+      console.log(
+        "                                leaves that tunnel running.",
       );
       console.log("");
       console.log("Providers:");
@@ -137,7 +142,8 @@ function parseArgs(): TunnelArgs {
       console.log("");
       console.log("Examples:");
       console.log(`  $ cadet tunnel --provider ${DEFAULT_TUNNEL_PROVIDER}`);
-      const domainExample = PROVIDER_META[DEFAULT_TUNNEL_PROVIDER].domainExample;
+      const domainExample =
+        PROVIDER_META[DEFAULT_TUNNEL_PROVIDER].domainExample;
       if (domainExample) {
         console.log(
           `  $ cadet tunnel --provider ${DEFAULT_TUNNEL_PROVIDER} --domain ${domainExample}`,
@@ -148,9 +154,6 @@ function parseArgs(): TunnelArgs {
       }
       console.log("  $ cadet tunnel --provider cloudflare");
       console.log("  $ cadet tunnel my-assistant --provider tailscale");
-      console.log(
-        `  $ cadet tunnel --provider ${DEFAULT_TUNNEL_PROVIDER} --detach`,
-      );
       process.exit(0);
     } else if (arg === "--provider") {
       const next = args[i + 1];
@@ -174,7 +177,8 @@ function parseArgs(): TunnelArgs {
     } else if (arg === "--domain") {
       const next = args[i + 1];
       if (!next || next.startsWith("-")) {
-        const domainExample = PROVIDER_META[DEFAULT_TUNNEL_PROVIDER].domainExample;
+        const domainExample =
+          PROVIDER_META[DEFAULT_TUNNEL_PROVIDER].domainExample;
         console.error(
           `Error: --domain requires a value${domainExample ? `, e.g. --domain ${domainExample}` : ""}`,
         );
@@ -184,8 +188,8 @@ function parseArgs(): TunnelArgs {
       i++;
     } else if (arg === "--clear-domain") {
       clearDomain = true;
-    } else if (arg === "-d" || arg === "--detach") {
-      detach = true;
+    } else if (arg === "--foreground") {
+      foreground = true;
     } else if (arg.startsWith("-")) {
       console.error(`Error: Unknown option '${arg}'.`);
       process.exit(1);
@@ -199,9 +203,7 @@ function parseArgs(): TunnelArgs {
 
   if (provider === null) {
     provider = DEFAULT_TUNNEL_PROVIDER;
-    console.log(
-      `Using the default provider: ${provider} (pass --provider to choose another).`,
-    );
+    console.log(`Using the default provider: ${provider}.`);
   }
 
   if (domain && !providerSupportsReservedDomain(provider)) {
@@ -225,7 +227,7 @@ function parseArgs(): TunnelArgs {
     process.exit(1);
   }
 
-  return { assistantName, provider, domain, clearDomain, detach };
+  return { assistantName, provider, domain, clearDomain, foreground };
 }
 
 /** A tunnelable assistant plus the gateway port and workspace the edge fronts. */
@@ -343,31 +345,31 @@ const TUNNEL_BACKGROUND_START_TIMEOUT_MS = 35_000;
 const TUNNEL_ESTABLISHED_RE = /Tunnel established: (\S+)/;
 
 /**
- * Re-invoke `cadet tunnel` (without `-d`/`--detach`) as a detached background
- * process via `relaunchDetached`, waiting for the child to either print its
- * "Tunnel established" or adopted-tunnel line (readiness) or
- * exit early (failure), so a misconfigured provider still fails loudly in
- * the terminal that ran `-d`.
+ * Re-invoke `cadet tunnel --foreground` as a detached background process via
+ * `relaunchDetached`, waiting for the child to either print its
+ * "Tunnel established" or adopted-tunnel line (readiness) or exit early
+ * (failure), so a misconfigured provider still fails loudly in the terminal
+ * that ran `cadet tunnel`.
  *
- * The log filename is scoped to this (parent) process's pid so concurrent
- * `-d` runs (e.g. tunneling two different local assistants at once) don't
- * truncate and read each other's readiness output.
+ * The log file is the fixed `tunnel.log` so there is one stable path to tail;
+ * concurrent tunnel runs share (and truncate) it.
  */
 async function spawnDetachedTunnel(): Promise<void> {
   const childArgs: string[] = ["tunnel"];
   for (const arg of process.argv.slice(3)) {
-    if (arg === "-d" || arg === "--detach") {
+    if (arg === "--foreground") {
       continue;
     }
     childArgs.push(arg);
   }
+  childArgs.push("--foreground");
 
   let publicUrl: string | undefined;
   let adopted = false;
 
   const { child, logPath, ready, exitCode } = await relaunchDetached({
     args: childArgs,
-    logFile: `tunnel-${process.pid}.log`,
+    logFile: "tunnel.log",
     timeoutMs: TUNNEL_BACKGROUND_START_TIMEOUT_MS,
     isReady: (logPath) => {
       let logText = "";
@@ -415,57 +417,78 @@ async function spawnDetachedTunnel(): Promise<void> {
 
 export const tunnel = Object.assign(
   async function tunnel(): Promise<void> {
-  const { assistantName, provider, domain, clearDomain, detach } = parseArgs();
+    const { assistantName, provider, domain, clearDomain, foreground } =
+      parseArgs();
 
-  if (detach) {
-    await spawnDetachedTunnel();
-    return;
-  }
+    if (!foreground) {
+      await spawnDetachedTunnel();
+      return;
+    }
 
-  if (PROVIDER_META[provider].comingSoon) {
-    throw cadetTunnelComingSoonError(provider);
-  }
+    if (PROVIDER_META[provider].comingSoon) {
+      throw cadetTunnelComingSoonError(provider);
+    }
 
-  const { entry, gatewayPort, workspaceDir } =
-    resolveLocalTunnelTarget(assistantName);
+    const { entry, gatewayPort, workspaceDir } =
+      resolveLocalTunnelTarget(assistantName);
 
-  const preserveIngressUrl =
-    provider === "tailscale" && guardTailnetOnlyWebhookIngress(workspaceDir);
+    const preserveIngressUrl =
+      provider === "tailscale" && guardTailnetOnlyWebhookIngress(workspaceDir);
 
-  if (clearDomain) {
-    clearReservedDomain();
-    console.log("Cleared the saved reserved domain.");
-  }
+    if (clearDomain) {
+      clearReservedDomain();
+      console.log("Cleared the saved reserved domain.");
+    }
 
-  let edge: TunnelEdge;
-  try {
-    edge = await ensureTunnelEdge({
-      assistantId: entry.assistantId,
-      workspaceDir,
-      gatewayPort,
+    const nginxVersion = await ensureBinaryInstalled({
+      binary: "nginx",
+      purpose: "the tunnel edge",
+      packages: {
+        brew: ["brew", "install", "nginx"],
+        "apt-get": ["sudo", "apt-get", "install", "-y", "nginx"],
+        dnf: ["sudo", "dnf", "install", "-y", "nginx"],
+        pacman: ["sudo", "pacman", "-S", "--noconfirm", "nginx"],
+        zypper: ["sudo", "zypper", "install", "-y", "nginx"],
+        choco: ["choco", "install", "-y", "nginx"],
+      },
+      manualHint:
+        "See https://nginx.org/en/docs/install.html for how to install, or point NGINX_BIN at an existing binary.",
+      probe: getNginxVersion,
     });
-  } catch (err) {
-    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
-    process.exit(1);
-  }
+    if (!nginxVersion) {
+      console.error("Error: nginx is required to run the tunnel edge.");
+      process.exit(1);
+    }
 
-  console.log(
-    `${edge.started ? "Started" : "Reusing"} the nginx edge on 127.0.0.1:${edge.port} ` +
-      `(serves ${formatEdgeMode(edge.includesWebApp)}).`,
-  );
+    let edge: TunnelEdge;
+    try {
+      edge = await ensureTunnelEdge({
+        assistantId: entry.assistantId,
+        workspaceDir,
+        gatewayPort,
+      });
+    } catch (err) {
+      console.error(
+        `Error: ${err instanceof Error ? err.message : String(err)}`,
+      );
+      process.exit(1);
+    }
+
+    console.log(
+      `${edge.started ? "Started" : "Reusing"} the nginx edge on 127.0.0.1:${edge.port}.`,
+    );
 
-  const baseTunnelOpts = {
-    port: edge.port,
-    assistantId: entry.assistantId,
-    workspaceDir,
-  };
+    const baseTunnelOpts = {
+      port: edge.port,
+      assistantId: entry.assistantId,
+      workspaceDir,
+    };
 
-  await runProviderTunnel(provider, {
-    ...baseTunnelOpts,
-    ...(domain ? { domain } : {}),
-    ...(preserveIngressUrl ? { preserveIngressUrl } : {}),
-  });
-},
+    await runProviderTunnel(provider, {
+      ...baseTunnelOpts,
+      ...(domain ? { domain } : {}),
+      ...(preserveIngressUrl ? { preserveIngressUrl } : {}),
+    });
+  },
   { description: "Create a tunnel for a locally hosted assistant" },
 );
-

package/src/commands/uninstall.ts

@@ -1,5 +1,5 @@
 import { existsSync, readFileSync, renameSync, rmSync, unlinkSync } from "fs";
-import { basename, dirname, join } from "path";
+import { basename, dirname, join, sep } from "path";
 import { fileURLToPath } from "url";
 
 import {
@@ -14,8 +14,8 @@ import {
 import { retireDocker } from "../lib/docker.js";
 import {
   getConfigDirs,
-  getInputHistoryPath,
   getLogDir,
+  getSharedStateDir,
   getStateDir,
 } from "../lib/environments/paths.js";
 import { getCurrentEnvironment } from "../lib/environments/resolve.js";
@@ -98,62 +98,84 @@ function findInstalledPackageRoot(startDir: string): string | null {
   return null;
 }
 
+/** The CLI's own install location, when it can be deleted. */
+interface SelfDeleteTarget {
+  path: string;
+  description: string;
+}
+
 /**
- * Remove the running CLI. Handles the two real install shapes:
- *   - the compiled `cadet` binary (process.execPath IS the install)
- *   - a global package install (bun install -g mycadet / npm install -g)
- * Under a source checkout or a bare runtime (bun/node), nothing is deleted —
- * the runtime binary must never be a deletion target.
+ * Where this CLI is running from, when that is an INSTALL we can remove:
+ * the compiled `cadet` binary (process.execPath IS the install) or a global
+ * package install (bun install -g mycadet / npm install -g mycadet). Under
+ * a source checkout or a bare runtime (bun/node), null — the runtime binary
+ * must never be a deletion target. The uninstall prompt lists the same
+ * target it later deletes, so both share this resolver.
  */
-function selfDelete(): void {
+function resolveSelfDeleteTarget(): SelfDeleteTarget | null {
   const execPath = process.execPath;
   const execBase = basename(execPath);
   if (execBase === "cadet" || execBase === "cadet.exe") {
+    return { path: execPath, description: "the Cadet executable" };
+  }
+  const runningFile = fileURLToPath(import.meta.url);
+  const pkgRoot = findInstalledPackageRoot(dirname(runningFile));
+  if (pkgRoot) {
+    return { path: pkgRoot, description: "the installed Cadet CLI package" };
+  }
+  return null;
+}
+
+/**
+ * Delete the install {@link resolveSelfDeleteTarget} found. The two shapes
+ * delete differently — the running binary needs the win32 rename dance, a
+ * package dir is a plain recursive delete — and the bin symlinks the
+ * package manager planted (e.g. ~/.bun/bin/cadet, the npm global bin) are
+ * left dangling — say so.
+ */
+function selfDelete(): void {
+  const target = resolveSelfDeleteTarget();
+  if (!target) {
+    console.log(
+      "Cadet is running from a source checkout — skipping self-removal.",
+    );
+    console.log(
+      "Remove the installed copy with `bun remove -g mycadet` or `npm uninstall -g mycadet`.",
+    );
+    return;
+  }
+  const execBase = basename(target.path);
+  const isCompiledBinary = execBase === "cadet" || execBase === "cadet.exe";
+  if (isCompiledBinary) {
     try {
       if (process.platform === "win32") {
         // Windows refuses to unlink a running executable — stage it under a
         // junk name and delete that.
-        const stale = `${execPath}.uninstalled`;
-        renameSync(execPath, stale);
+        const stale = `${target.path}.uninstalled`;
+        renameSync(target.path, stale);
         rmSync(stale, { force: true, recursive: true });
       } else {
-        unlinkSync(execPath);
+        unlinkSync(target.path);
       }
-      console.log(`Removed ${execPath}.`);
-      return;
+      console.log(`Removed ${target.path}.`);
     } catch (err) {
       console.warn(
-        `⚠️  Could not remove ${execPath}: ${
+        `⚠️  Could not remove ${target.path}: ${
           err instanceof Error ? err.message : String(err)
         } — remove it by hand.`,
       );
-      return;
     }
-  }
-
-  // Package-manager install: remove the package directory we are running
-  // from, best-effort. Bin symlinks the package manager planted (e.g.
-  // ~/.bun/bin/cadet, the npm global bin) are left dangling — say so.
-  const runningFile = fileURLToPath(import.meta.url);
-  const pkgRoot = findInstalledPackageRoot(dirname(runningFile));
-  if (!pkgRoot) {
-    console.log(
-      "Cadet is running from a source checkout — skipping self-removal.",
-    );
-    console.log(
-      "Remove the installed copy with `bun remove -g mycadet` (or `npm uninstall -g mycadet`).",
-    );
     return;
   }
   try {
-    rmSync(pkgRoot, { recursive: true, force: true });
-    console.log(`Removed ${pkgRoot}.`);
+    rmSync(target.path, { recursive: true, force: true });
+    console.log(`Removed ${target.path}.`);
     console.log(
       "The `cadet` command on your PATH is now stale — remove it if your package manager didn't (`bun remove -g mycadet` or `npm uninstall -g mycadet`).",
     );
   } catch (err) {
     console.warn(
-      `⚠️  Could not remove ${pkgRoot}: ${
+      `⚠️  Could not remove ${target.path}: ${
         err instanceof Error ? err.message : String(err)
       } — remove it with \`bun remove -g mycadet\` (or \`npm uninstall -g mycadet\`).`,
     );
@@ -173,10 +195,24 @@ function collectDeleteTargets(env = getCurrentEnvironment()): DeleteTarget[] {
     { path: getLogDir(env), description: "logs" },
     // Not environment-scoped: deleting it affects every cadet CLI on the
     // machine — called out in the prompt, not hidden.
-    { path: getInputHistoryPath(), description: "shared terminal input history" },
+    {
+      path: getSharedStateDir(),
+      description: "shared state, including the terminal input history",
+    },
   ];
   // Only targets that exist — the prompt lists what will actually go.
-  return targets.filter((t) => existsSync(t.path));
+  const existing = targets.filter((t) => existsSync(t.path));
+  // The log dir lives INSIDE a listed target (the config dir on
+  // macOS/Linux, the state dir on Windows) and goes with its parent's
+  // recursive delete — never list a path twice.
+  const deduped: DeleteTarget[] = [];
+  for (const t of existing) {
+    const covered = deduped.some(
+      (k) => t.path === k.path || t.path.startsWith(k.path + sep),
+    );
+    if (!covered) deduped.push(t);
+  }
+  return deduped;
 }
 
 function rmrf(target: string): void {
@@ -190,63 +226,48 @@ export const uninstall = Object.assign(
       console.log("Usage: cadet uninstall [--yes]");
       console.log("");
       console.log(
-        "Remove Cadet entirely: delete every location it uses for this environment (assistant state, retired archives, config, logs) and then delete the executable itself.",
+        "Remove Cadet entirely: retire any remaining assistants, delete every location it uses for this environment (assistant state, retired archives, config, logs), and remove the Cadet installation itself.",
       );
       process.exit(0);
     }
     const yes = args.includes("--yes");
 
-    // Assistants still on the rack are retired — with their data deleted —
-    // as part of the uninstall. Uninstall deletes every location cadet uses
-    // INCLUDING the retired archives, so retiring first (which archives)
-    // only matters for the teardown it performs: docker assistants keep
-    // containers, volumes, and a network in docker that the filesystem
-    // sweep below never reaches. A warning, not a refusal (v0.0.10 run
-    // feedback: the hard error just blocked the uninstall).
+    const env = getCurrentEnvironment();
+    const envLabel = env.name ?? "production";
     const existing = loadAllAssistants();
+    const targets = collectDeleteTargets(env);
+    const selfTarget = resolveSelfDeleteTarget();
+
+    console.log(
+      `This removes Cadet entirely for the '${envLabel}' environment and cannot be undone.`,
+    );
+
+    // Assistants still on the rack are retired — with their data deleted —
+    // as part of the uninstall, and retiring happens only AFTER the
+    // confirmation below: it is part of what the prompt describes, never a
+    // side effect of running the command. Uninstall deletes every location
+    // cadet uses INCLUDING the retired archives, so retiring first (which
+    // archives) only matters for the teardown it performs: docker
+    // assistants keep containers, volumes, and a network in docker that
+    // the filesystem sweep below never reaches. A warning, not a refusal
+    // (v0.0.10 run feedback: the hard error just blocked the uninstall).
     if (existing.length > 0) {
       console.warn(
-        `\n⚠️  ${existing.length} assistant(s) still exist: ${existing.map((a) => a.assistantId).join(", ")}`,
+        `\n⚠️  ${existing.length} ${existing.length === 1 ? "assistant still exists" : "assistants still exist"}: ${existing.map((a) => a.assistantId).join(", ")}`,
       );
       console.warn(
-        "   They will be retired now — their data (and any retired archives) will be permanently deleted by this uninstall.",
+        "   They will be retired as part of this uninstall — their data (and any retired archives) will be permanently deleted.",
       );
-      for (const entry of existing) {
-        if (entry.cloud === "apple-container" || entry.cloud === "paired") {
-          console.log(`   Skipping '${entry.assistantId}' (${entry.cloud}) — its lifecycle is managed elsewhere.`);
-          continue;
-        }
-        try {
-          await retireAssistantData(entry);
-        } catch (err) {
-          console.error(
-            `   Warning: could not fully retire '${entry.assistantId}': ${err instanceof Error ? err.message : String(err)}`,
-          );
-        }
-      }
     }
 
-    const env = getCurrentEnvironment();
-    const envLabel = env.name ?? "production";
-    const targets = collectDeleteTargets(env);
-    const execPath = process.execPath;
-
-    console.log(
-      `This removes Cadet entirely for the '${envLabel}' environment and cannot be undone.`,
-    );
-    if (targets.length === 0) {
+    if (targets.length === 0 && selfTarget === null) {
       console.log("No Cadet data directories found to delete.");
     } else {
       console.log("It will permanently delete:");
-      for (const t of targets) {
-        console.log(`  - ${t.path}  (${t.description})`);
+      for (const t of selfTarget ? [...targets, selfTarget] : targets) {
+        console.log(`  - ${t.path}  — ${t.description}`);
       }
     }
-    const execBase = basename(execPath);
-    const isCompiledBinary = execBase === "cadet" || execBase === "cadet.exe";
-    if (isCompiledBinary) {
-      console.log(`It will then remove the Cadet executable at ${execPath}.`);
-    }
 
     if (!yes) {
       if (!canPromptForConfirmation()) {
@@ -265,6 +286,20 @@ export const uninstall = Object.assign(
       }
     }
 
+    for (const entry of existing) {
+      if (entry.cloud === "apple-container" || entry.cloud === "paired") {
+        console.log(`   Skipping '${entry.assistantId}' on ${entry.cloud} — its lifecycle is managed elsewhere.`);
+        continue;
+      }
+      try {
+        await retireAssistantData(entry);
+      } catch (err) {
+        console.error(
+          `   Warning: could not fully retire '${entry.assistantId}': ${err instanceof Error ? err.message : String(err)}`,
+        );
+      }
+    }
+
     for (const t of targets) {
       rmrf(t.path);
       console.log(`Deleted ${t.path}.`);

package/src/commands/upgrade.ts

@@ -19,6 +19,7 @@ import {
   GATEWAY_INTERNAL_PORT,
   ASSISTANT_INTERNAL_PORT,
   dockerResourceNames,
+  pullImage,
   startContainers,
   stopContainers,
 } from "../lib/docker";
@@ -46,7 +47,6 @@ import {
 } from "../lib/backup-ops.js";
 import { emitCliError, categorizeUpgradeError } from "../lib/cli-error.js";
 import { parseAssistantTargetArg } from "../lib/assistant-target-args.js";
-import { exec } from "../lib/step-runner.js";
 import {
   broadcastUpgradeEvent,
   attemptFailedStateRestore,
@@ -118,12 +118,12 @@ function parseArgs(): UpgradeArgs {
       console.log("");
       console.log("Arguments:");
       console.log(
-        "  <name>               Name of the assistant to upgrade (default: active or only assistant)",
+        "  <name>               Name of the assistant to upgrade, defaults to active or only assistant",
       );
       console.log("");
       console.log("Options:");
       console.log(
-        "  --version <version>  Target version to upgrade to (default: CLI version)",
+        "  --version <version>  Target version to upgrade to, defaults to the CLI version",
       );
       console.log(
         "  --latest             Upgrade to the latest stable release, updating the CLI first if needed",
@@ -316,7 +316,7 @@ async function upgradeDocker(
       );
       return;
     }
-    console.log(`🔁 Reinstalling ${versionTag} (--force)...\n`);
+    console.log(`🔁 Reinstalling ${versionTag} with --force...\n`);
   }
 
   console.log("🔍 Resolving image references...");
@@ -406,7 +406,7 @@ async function upgradeDocker(
   try {
     for (const [service, image] of pullImages) {
       console.log(`   Pulling ${service}: ${image}`);
-      await exec("docker", ["pull", image]);
+      await pullImage(image);
     }
   } catch (pullErr) {
     const detail = pullErr instanceof Error ? pullErr.message : String(pullErr);
@@ -453,7 +453,7 @@ async function upgradeDocker(
     // Clean up old pre-upgrade backups, keep last 3
     pruneOldBackups(entry.assistantId, 3);
   } else {
-    console.warn("⚠️  Pre-upgrade backup failed (continuing with upgrade)\n");
+    console.warn("⚠️  Pre-upgrade backup failed, continuing with upgrade\n");
   }
 
   // Persist the backup path so `cadet rollback` can restore the exact backup
@@ -891,7 +891,7 @@ async function upgradeLocal(
       );
       return;
     }
-    console.log(`🔁 Reinstalling ${targetVersion} (--force)...\n`);
+    console.log(`🔁 Reinstalling ${targetVersion} with --force...\n`);
   }
 
   console.log(
@@ -933,7 +933,7 @@ async function upgradeLocal(
     console.log(`   Backup saved: ${backupPath}\n`);
     pruneOldBackups(entry.assistantId, 3);
   } else {
-    console.warn("⚠️  Pre-upgrade backup failed (continuing with upgrade)\n");
+    console.warn("⚠️  Pre-upgrade backup failed, continuing with upgrade\n");
   }
 
   let bootstrapSecret = entry.guardianBootstrapSecret;

package/src/commands/use.ts

@@ -38,7 +38,7 @@ export const use = Object.assign(
           `Active assistant: ${formatAssistantReference(result.entry)}`,
         );
       } else {
-        console.log(`Active assistant: ${active} (not found in lockfile)`);
+        console.log(`Active assistant: ${active} — not found in lockfile`);
       }
     } else {
       console.log("No active assistant set.");