@mycadet/cli 0.12.6-dev.202610082233.54244ee → 0.12.7

package/src/commands/setup.ts

@@ -9,9 +9,10 @@ import {
   ensureProviderApiKey,
   formatProviderName,
 } from "../lib/provider-secrets.js";
+import { yellow } from "../lib/color.js";
 
-function parseSetupArgs(args: string[]): { provider: string } {
-  let provider = "anthropic";
+function parseSetupArgs(args: string[]): { provider?: string } {
+  let provider: string | undefined;
 
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -32,6 +33,58 @@ function parseSetupArgs(args: string[]): { provider: string } {
   return { provider };
 }
 
+interface DefaultProviderResponse {
+  provider?: string;
+}
+
+/** Parse the default-provider payload without a type assertion. */
+function parseDefaultProviderResponse(value: unknown): DefaultProviderResponse {
+  if (typeof value !== "object" || value === null) return {};
+  const provider = "provider" in value ? value.provider : undefined;
+  return typeof provider === "string" ? { provider } : {};
+}
+
+/**
+ * Ask the active assistant which provider it routes by default
+ * (`GET /v1/config/llm/default-provider`), so `cadet setup` without
+ * `--provider` configures the connection the assistant actually uses —
+ * e.g. the keyless Cadet Cloud managed connection picked at hatch —
+ * instead of blindly prompting for an API key. Falls back to cadet
+ * when the runtime is unreachable or predates the endpoint; the
+ * returned warning says why, for the caller to render.
+ */
+async function resolveDefaultProvider(
+  gatewayUrl: string,
+  bearerToken?: string,
+): Promise<{ provider: string; warning?: string }> {
+  try {
+    const response = await fetch(
+      `${gatewayUrl}/v1/config/llm/default-provider`,
+      {
+        headers: {
+          "Content-Type": "application/json",
+          ...(bearerToken ? { Authorization: `Bearer ${bearerToken}` } : {}),
+        },
+        signal: AbortSignal.timeout(5000),
+      },
+    );
+    if (!response.ok) {
+      return {
+        provider: "cadet",
+        warning: `Default provider lookup failed (gateway responded ${response.status}); falling back to Cadet Cloud.`,
+      };
+    }
+    const data = parseDefaultProviderResponse(await response.json());
+    const provider = data.provider?.trim().toLowerCase();
+    return { provider: provider || "cadet" };
+  } catch (error) {
+    return {
+      provider: "cadet",
+      warning: `Default provider lookup failed (${error instanceof Error ? error.message : String(error)}); falling back to Cadet Cloud.`,
+    };
+  }
+}
+
 function isGuardianAccessTokenUsable(
   tokenData: GuardianTokenData | null,
 ): tokenData is GuardianTokenData {
@@ -86,7 +139,8 @@ async function resolveSetupBearerToken(
   return entry.bearerToken;
 }
 
-export async function setup(): Promise<void> {
+export const setup = Object.assign(
+  async function setup(): Promise<void> {
   const args = process.argv.slice(3);
 
   if (args.includes("--help") || args.includes("-h")) {
@@ -95,9 +149,7 @@ export async function setup(): Promise<void> {
     console.log("Configure a provider API key on the active assistant.");
     console.log("");
     console.log("Options:");
-    console.log(
-      "  --provider <provider>  Provider to configure. Defaults to anthropic.",
-    );
+    console.log("  --provider <provider>  Provider to configure. Defaults to Cadet Cloud");
     console.log("");
     console.log("Behavior:");
     console.log(
@@ -113,7 +165,7 @@ export async function setup(): Promise<void> {
     process.exit(0);
   }
 
-  let parsed: { provider: string };
+  let parsed: { provider?: string };
   try {
     parsed = parseSetupArgs(args);
   } catch (error) {
@@ -130,13 +182,25 @@ export async function setup(): Promise<void> {
   const gatewayUrl = entry.localUrl ?? entry.runtimeUrl;
   const bearerToken = await resolveSetupBearerToken(entry, gatewayUrl);
 
+  // Respect the assistant's configured default provider (e.g. Cadet Cloud
+  // chosen at hatch) unless the caller named one explicitly — the runtime's
+  // keyless managed connection should not be greeted by an API-key prompt.
+  let provider = parsed.provider;
+  if (!provider) {
+    const resolved = await resolveDefaultProvider(gatewayUrl, bearerToken);
+    provider = resolved.provider;
+    if (resolved.warning) {
+      console.error(yellow(resolved.warning));
+    }
+  }
+
   console.log("Cadet Setup");
   console.log("============\n");
 
   try {
     const result = await ensureProviderApiKey({
       gatewayUrl,
-      provider: parsed.provider,
+      provider,
       bearerToken,
       env: process.env,
     });
@@ -171,4 +235,7 @@ export async function setup(): Promise<void> {
     );
     process.exit(1);
   }
-}
+},
+  { description: "Configure API keys interactively" },
+);
+

package/src/commands/sleep.ts

@@ -3,6 +3,7 @@ import { join } from "path";
 
 import {
   getDaemonPidPath,
+  loadAllAssistants,
   resolveTargetAssistant,
 } from "../lib/assistant-config.js";
 import type { AssistantEntry } from "../lib/assistant-config.js";
@@ -60,10 +61,11 @@ function readActiveCallLeases(cadetDir: string): ActiveCallLease[] {
   );
 }
 
-export async function sleep(): Promise<void> {
+export const sleep = Object.assign(
+  async function sleep(): Promise<void> {
   const args = process.argv.slice(3);
   if (args.includes("--help") || args.includes("-h")) {
-    console.log("Usage: cadet sleep [<name>] [--force] [--wait [<duration>]]");
+    console.log("Usage: cadet sleep [<name> | --all] [--force] [--wait [<duration>]]");
     console.log("");
     console.log("Stop the assistant and gateway processes.");
     console.log("");
@@ -73,6 +75,9 @@ export async function sleep(): Promise<void> {
     );
     console.log("");
     console.log("Options:");
+    console.log(
+      "  --all     Stop every assistant across all remotes instead of one",
+    );
     console.log(
       "  --force   Stop the assistant even if a phone call keepalive lease is active",
     );
@@ -128,7 +133,110 @@ export async function sleep(): Promise<void> {
   const nameArg = args.find(
     (a) => !a.startsWith("-") && a !== waitDurationToken,
   );
+  const all = args.includes("--all");
+
+  if (all && nameArg) {
+    console.error("Error: --all cannot be combined with an assistant name.");
+    process.exit(1);
+  }
+
+  if (all) {
+    await sleepAll({ force, wait, waitMs });
+    return;
+  }
+
   const entry = resolveTargetAssistant(nameArg);
+  try {
+    await sleepAssistant(entry, { force, wait, waitMs });
+  } catch (err) {
+    if (err instanceof SleepExit) {
+      console.log(err.message);
+      process.exit(err.exitCode);
+    }
+    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+},
+  { description: "Stop the assistant process" },
+);
+
+
+type SleepOptions = {
+  force: boolean;
+  wait: boolean;
+  waitMs: number | null;
+};
+
+/**
+ * Carries a deliberate exit outcome (a cancelled drain) across the
+ * per-assistant boundary so the callers can exit with the right code
+ * instead of treating it as a stop failure.
+ */
+class SleepExit extends Error {
+  constructor(
+    readonly exitCode: number,
+    message: string,
+  ) {
+    super(message);
+  }
+}
+
+/**
+ * Stop every assistant this CLI's environment knows about — `--all`. The
+ * CLI only ever reaches one environment, so this is the current env's
+ * lockfile. Same per-assistant stop as the single path, but one
+ * assistant's failure (or an unmanageable runtime) never blocks the
+ * others; a failure only decides the exit code.
+ */
+async function sleepAll(opts: SleepOptions): Promise<void> {
+  const entries = loadAllAssistants();
+  if (entries.length === 0) {
+    console.error("Error: no assistants found. Run 'cadet hatch' first.");
+    process.exit(1);
+  }
+
+  let failures = 0;
+  const seen = new Set<string>();
+  for (const entry of entries) {
+    if (seen.has(entry.assistantId)) continue;
+    seen.add(entry.assistantId);
+    if (entry.cloud === "apple-container" || entry.cloud === "paired") {
+      console.log(
+        `Skipping '${entry.assistantId}' (${entry.cloud}) — its lifecycle is managed elsewhere.`,
+      );
+      continue;
+    }
+    try {
+      await sleepAssistant(entry, opts);
+    } catch (err) {
+      if (err instanceof SleepExit) {
+        // A cancelled drain is the user asking to stop — honor it immediately.
+        console.log(err.message);
+        process.exit(err.exitCode);
+      }
+      failures++;
+      console.error(
+        `Error: failed to stop '${entry.assistantId}': ${
+          err instanceof Error ? err.message : String(err)
+        }`,
+      );
+    }
+  }
+  if (failures > 0) {
+    process.exit(1);
+  }
+}
+
+/**
+ * Stop one assistant. Throws on hard errors (active call leases, missing
+ * resources, unmanageable runtimes) so the caller decides between exiting
+ * (single-assistant path) and continuing to the next entry (`--all`).
+ */
+async function sleepAssistant(
+  entry: AssistantEntry,
+  opts: SleepOptions,
+): Promise<void> {
+  const { force, wait, waitMs } = opts;
 
   if (entry.cloud === "docker") {
     if (wait) {
@@ -146,31 +254,27 @@ export async function sleep(): Promise<void> {
   }
 
   if (entry.cloud === "apple-container") {
-    console.error(
-      `Error: '${entry.assistantId}' uses the Apple Containers runtime. Its lifecycle is managed by the macOS app — use the app to stop it.`,
+    throw new Error(
+      `'${entry.assistantId}' uses the Apple Containers runtime. Its lifecycle is managed by the macOS app — use the app to stop it.`,
     );
-    process.exit(1);
   }
 
   if (entry.cloud === "paired") {
-    console.error(
-      `Error: '${entry.assistantId}' is a remote assistant paired from another machine — its lifecycle is managed on its host machine, not here. Use \`cadet client ${entry.assistantId}\` to chat with it.`,
+    throw new Error(
+      `'${entry.assistantId}' is a remote assistant paired from another machine — its lifecycle is managed on its host machine, not here. Use \`cadet client ${entry.assistantId}\` to chat with it.`,
     );
-    process.exit(1);
   }
 
   if (entry.cloud && entry.cloud !== "local") {
-    console.error(
-      `Error: 'cadet sleep' only works with local and docker assistants. '${entry.assistantId}' is a ${entry.cloud} instance.`,
+    throw new Error(
+      `'cadet sleep' only works with local and docker assistants. '${entry.assistantId}' is a ${entry.cloud} instance.`,
     );
-    process.exit(1);
   }
 
   if (!entry.resources) {
-    console.error(
-      `Error: Local assistant '${entry.assistantId}' is missing resource configuration. Re-hatch to fix.`,
+    throw new Error(
+      `Local assistant '${entry.assistantId}' is missing resource configuration. Re-hatch to fix.`,
     );
-    process.exit(1);
   }
   const resources = entry.resources;
   const assistantPidFile = getDaemonPidPath(resources);
@@ -180,26 +284,23 @@ export async function sleep(): Promise<void> {
   if (!force) {
     const assistantAlive = isProcessAlive(assistantPidFile).alive;
     if (assistantAlive) {
+      let leases: ActiveCallLease[];
       try {
-        const activeCallLeases = readActiveCallLeases(cadetDir);
-        if (activeCallLeases.length > 0) {
-          const activeIds = activeCallLeases.map(
-            (lease) => lease.callSessionId,
-          );
-          console.error(
-            `Error: assistant is staying awake for active phone calls (${activeIds.join(
-              ", ",
-            )}). Use 'cadet sleep --force' to stop it anyway.`,
-          );
-          process.exit(1);
-        }
+        leases = readActiveCallLeases(cadetDir);
       } catch (err) {
-        console.error(
-          `Error: ${
+        throw new Error(
+          `${
             err instanceof Error ? err.message : String(err)
           }. Use 'cadet sleep --force' to override if you want to stop the assistant anyway.`,
         );
-        process.exit(1);
+      }
+      if (leases.length > 0) {
+        const activeIds = leases.map((lease) => lease.callSessionId);
+        throw new Error(
+          `assistant is staying awake for active phone calls (${activeIds.join(
+            ", ",
+          )}). Use 'cadet sleep --force' to stop it anyway.`,
+        );
       }
     }
   }
@@ -207,8 +308,7 @@ export async function sleep(): Promise<void> {
   if (wait) {
     const outcome = await runDrainPhase(entry, assistantPidFile, waitMs);
     if (outcome === "cancelled") {
-      console.log("Sleep cancelled — the assistant is still running.");
-      process.exit(130);
+      throw new SleepExit(130, "Sleep cancelled — the assistant is still running.");
     }
   }
 

package/src/commands/ssh.ts

@@ -18,7 +18,8 @@ const SSH_OPTS = [
   "LogLevel=ERROR",
 ];
 
-export async function ssh(): Promise<void> {
+export const ssh = Object.assign(
+  async function ssh(): Promise<void> {
   const args = process.argv.slice(3);
   if (args.includes("--help") || args.includes("-h")) {
     console.log("Usage: cadet ssh [<name>]");
@@ -137,4 +138,7 @@ export async function ssh(): Promise<void> {
     });
     child.on("error", reject);
   });
-}
+},
+  { description: "SSH into a remote assistant instance" },
+);
+

package/src/commands/teleport.ts

@@ -1274,7 +1274,8 @@ async function tryInjectPlatformCredentials(
 // Main entry point
 // ---------------------------------------------------------------------------
 
-export async function teleport(): Promise<void> {
+export const teleport = Object.assign(
+  async function teleport(): Promise<void> {
   const args = process.argv.slice(3);
   const { from, to, targetEnv, targetName, keepSource, dryRun, help } =
     parseArgs(args);
@@ -1664,4 +1665,7 @@ export async function teleport(): Promise<void> {
   }
 
   console.log(`Teleport complete: ${from} → ${toEntry.assistantId}`);
-}
+},
+  { description: "Transfer assistant data between environments" },
+);
+

package/src/commands/terminal.ts

@@ -159,7 +159,8 @@ async function listTmuxSessions(
 // Main entry point
 // ---------------------------------------------------------------------------
 
-export async function terminal(): Promise<void> {
+export const terminal = Object.assign(
+  async function terminal(): Promise<void> {
   const args = process.argv.slice(3);
 
   if (args.includes("--help") || args.includes("-h")) {
@@ -222,4 +223,7 @@ export async function terminal(): Promise<void> {
 
   // Default: interactive shell
   await interactiveSession(assistant);
-}
+},
+  { description: "Open a terminal into a managed assistant container" },
+);
+

package/src/commands/tunnel.ts

@@ -440,7 +440,8 @@ async function spawnDetachedTunnel(): Promise<void> {
   }
 }
 
-export async function tunnel(): Promise<void> {
+export const tunnel = Object.assign(
+  async function tunnel(): Promise<void> {
   const { assistantName, provider, domain, clearDomain, detach } = parseArgs();
 
   if (detach) {
@@ -506,4 +507,7 @@ export async function tunnel(): Promise<void> {
     ...baseTunnelOpts,
     ...(preserveIngressUrl ? { preserveIngressUrl } : {}),
   });
-}
+},
+  { description: "Create a tunnel for a locally hosted assistant" },
+);
+

package/src/commands/uninstall.ts

@@ -0,0 +1,228 @@
+import { existsSync, readFileSync, renameSync, rmSync, unlinkSync } from "fs";
+import { basename, dirname, join } from "path";
+import { fileURLToPath } from "url";
+
+import { loadAllAssistants } from "../lib/assistant-config.js";
+import {
+  canPromptForConfirmation,
+  confirmAction,
+} from "../lib/confirm-action.js";
+import {
+  getConfigDirs,
+  getInputHistoryPath,
+  getLogDir,
+  getStateDir,
+} from "../lib/environments/paths.js";
+import { getCurrentEnvironment } from "../lib/environments/resolve.js";
+
+/** A directory (or file) scheduled for deletion, with what it holds. */
+interface DeleteTarget {
+  path: string;
+  description: string;
+}
+
+/**
+ * Owning packages a global install of the CLI can live under, in priority
+ * order — @mycadet/cli always wins over its meta wrapper.
+ */
+const OWNED_PACKAGE_NAMES: ReadonlyArray<string> = [
+  "@mycadet/cli",
+  "@mycadet/meta",
+];
+
+/**
+ * Find the package root the CLI is running from (…/node_modules/mycadet),
+ * or null when running from a source tree. A `.git` ANYWHERE up the tree
+ * (repo root or monorepo parent — a checkout's cli/ subpackage has no .git
+ * of its own) means this is source, never an install.
+ */
+function findInstalledPackageRoot(startDir: string): string | null {
+  // Pass 1: any .git ancestor = a checkout, never an install.
+  for (let dir = startDir; ; dir = dirname(dir)) {
+    if (existsSync(join(dir, ".git"))) return null;
+    const parent = dirname(dir);
+    if (parent === dir) break; // Reached the filesystem root.
+  }
+  // Pass 2: walk up looking for the owned package root, priority order —
+  // the whole chain is checked for each name in turn, so @mycadet/cli wins
+  // over @mycadet/meta wherever both appear.
+  for (const owned of OWNED_PACKAGE_NAMES) {
+    for (let dir = startDir; ; dir = dirname(dir)) {
+      const pkgPath = join(dir, "package.json");
+      if (existsSync(pkgPath)) {
+        try {
+          const parsed: unknown = JSON.parse(readFileSync(pkgPath, "utf8"));
+          if (
+            typeof parsed === "object" &&
+            parsed !== null &&
+            "name" in parsed &&
+            parsed.name === owned
+          ) {
+            return dir;
+          }
+        } catch {
+          // Unreadable package.json — keep walking up.
+        }
+      }
+      const parent = dirname(dir);
+      if (parent === dir) break;
+    }
+  }
+  return null;
+}
+
+/**
+ * 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.
+ */
+function selfDelete(): void {
+  const execPath = process.execPath;
+  const execBase = basename(execPath);
+  if (execBase === "cadet" || execBase === "cadet.exe") {
+    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);
+        rmSync(stale, { force: true, recursive: true });
+      } else {
+        unlinkSync(execPath);
+      }
+      console.log(`Removed ${execPath}.`);
+      return;
+    } catch (err) {
+      console.warn(
+        `⚠️  Could not remove ${execPath}: ${
+          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}.`);
+    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}: ${
+        err instanceof Error ? err.message : String(err)
+      } — remove it with \`bun remove -g mycadet\` (or \`npm uninstall -g mycadet\`).`,
+    );
+  }
+}
+
+function collectDeleteTargets(env = getCurrentEnvironment()): DeleteTarget[] {
+  const targets: DeleteTarget[] = [
+    {
+      path: getStateDir(env),
+      description: "assistant state, retired archives, and the assistants it holds",
+    },
+    ...getConfigDirs(env).map((dir) => ({
+      path: dir,
+      description: "config and lockfile",
+    })),
+    { 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" },
+  ];
+  // Only targets that exist — the prompt lists what will actually go.
+  return targets.filter((t) => existsSync(t.path));
+}
+
+function rmrf(target: string): void {
+  rmSync(target, { recursive: true, force: true });
+}
+
+export const uninstall = Object.assign(
+  async function uninstall(): Promise<void> {
+    const args = process.argv.slice(3);
+    if (args.includes("--help") || args.includes("-h")) {
+      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.",
+      );
+      process.exit(0);
+    }
+    const yes = args.includes("--yes");
+
+    // Retire tears down an assistant AND archives its data. Uninstall assumes
+    // an empty rack: retiring first is the way to keep an archive.
+    if (loadAllAssistants().length > 0) {
+      console.error(
+        "Error: You still have assistants. Retire them first (`cadet retire <name>`) — retiring archives their data before removing it.",
+      );
+      process.exit(1);
+    }
+
+    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) {
+      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})`);
+      }
+    }
+    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()) {
+        console.error(
+          "Error: Refusing to uninstall without confirmation in a non-interactive terminal.",
+        );
+        console.error("Re-run with --yes to confirm from automation.");
+        process.exit(1);
+      }
+      const confirmed = await confirmAction(
+        "Press Enter to uninstall Cadet, or Esc/q to cancel: ",
+      );
+      if (!confirmed) {
+        console.log("Uninstall cancelled.");
+        process.exit(1);
+      }
+    }
+
+    for (const t of targets) {
+      rmrf(t.path);
+      console.log(`Deleted ${t.path}.`);
+    }
+
+    selfDelete();
+  },
+  { description: "Remove Cadet entirely" },
+);

package/src/commands/unpair.ts

@@ -46,7 +46,8 @@ EXAMPLES:
 `);
 }
 
-export async function unpair(): Promise<void> {
+export const unpair = Object.assign(
+  async function unpair(): Promise<void> {
   const args = process.argv.slice(3);
 
   if (args.includes("--help") || args.includes("-h")) {
@@ -115,4 +116,7 @@ export async function unpair(): Promise<void> {
   console.log(
     "Note: this only forgets the connection on this machine. The assistant's host can fully revoke this device from its side.",
   );
-}
+},
+  { description: "Forget a paired assistant imported from another machine [beta]" },
+);
+