@mycadet/cli 0.12.9 → 0.12.11

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} ${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}' 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)}`,
-          );
-        }
-      }
     }
 
-    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) {
+      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

@@ -76,7 +76,10 @@ import {
   startLocalDaemon,
   stopLocalProcesses,
 } from "../lib/local.js";
-import { restoreTunnelEdgeAndAutoTunnel } from "../lib/tunnel.js";
+import {
+  restoreContainerTunnelEdge,
+  restoreTunnelEdgeAndAutoTunnel,
+} from "../lib/tunnel.js";
 import {
   leaseGuardianToken,
   resetGuardianBootstrap,
@@ -516,6 +519,8 @@ async function upgradeDocker(
       preUpgradeBackupPath: backupPath ?? undefined,
     };
     saveAssistantEntry(updatedEntry);
+    // Refresh the host-served web bundle before clients reload on completion.
+    await restoreContainerTunnelEdge(updatedEntry);
 
     // Notify clients on the new service group that the upgrade succeeded.
     await broadcastUpgradeEvent(

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/assistant-config.ts

@@ -170,6 +170,10 @@ export interface RootProcessRecord {
   /** The assistant the process fronts, so `cadet ps` can nest the row. */
   assistantId?: string;
   startedAt: string;
+  /** Listening port for the nginx edge. */
+  port?: number;
+  /** Managed process temporarily displaced by a pairing-only tunnel. */
+  previous?: RootProcessRecord;
 }
 
 export type RootProcessKind = "tunnel" | "app";
@@ -247,12 +251,21 @@ export function stampRootProcess(
   });
 }
 
-/** Drop the recorded root process entry, e.g. once the process is stopped. */
-export function clearRootProcess(kind: RootProcessKind): void {
+/** Release a recorded process, preserving a replacement or restoring a displaced record. */
+export function clearRootProcess(
+  kind: RootProcessKind,
+  expectedPid?: number,
+): void {
   withCliLockfileLock(() => {
     const data = readLockfile();
-    if (data[kind] === undefined) return;
-    delete data[kind];
+    const record = data[kind];
+    if (
+      record === undefined ||
+      (expectedPid !== undefined && record.pid !== expectedPid)
+    )
+      return;
+    if (record.previous) data[kind] = record.previous;
+    else delete data[kind];
     writeLockfileUnlocked(data);
   });
 }
@@ -442,7 +455,9 @@ export function loadLatestAssistant(): AssistantEntry | null {
 }
 
 export function findAssistantByName(name: string): AssistantEntry | null {
-  return loadAllAssistants().find((entry) => entry.assistantId === name) ?? null;
+  return (
+    loadAllAssistants().find((entry) => entry.assistantId === name) ?? null
+  );
 }
 
 export function getAssistantDisplayName(entry: AssistantEntry): string {

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-poll.ts

@@ -0,0 +1,75 @@
+import { z } from "zod";
+import { loopbackSafeFetch } from "./loopback-fetch.js";
+
+const requestSchema = z.object({
+  request_id: z.string().regex(/^[a-f0-9]{64}$/),
+  poll_secret: z.string().regex(/^[a-f0-9]{64}$/),
+  verification_uri: z.string().url(),
+  user_code: z.string().min(1),
+  interval: z.number().min(1).max(10),
+});
+const resultSchema = z.object({ session_token: z.string().min(1) });
+
+/** Browser approval and polling work when the terminal and browser are on different hosts. */
+export async function pollingCloudLogin(
+  cloudUrl: string,
+  options: {
+    timeoutMs?: number;
+    fetch?: (
+      input: string | URL | Request,
+      init?: RequestInit,
+    ) => Promise<Response>;
+    log?: (message: string) => void;
+  } = {},
+): Promise<string> {
+  const request = options.fetch ?? loopbackSafeFetch;
+  const log = options.log ?? console.log;
+  const signal = AbortSignal.timeout(options.timeoutMs ?? 300_000);
+  const origin = new URL(cloudUrl).origin;
+  try {
+    const started = await request(`${origin}/v1/auth/cli/start`, {
+      method: "POST",
+      signal,
+    });
+    if (!started.ok)
+      throw new Error(`Could not start terminal login (${started.status}).`);
+    const login = requestSchema.parse(await started.json());
+    log(`Open this URL to log in: ${login.verification_uri}`);
+    log(
+      `Confirm code ${login.user_code} in your browser. Waiting up to 5 minutes...`,
+    );
+    while (!signal.aborted) {
+      const response = await request(`${origin}/v1/auth/cli/poll`, {
+        method: "POST",
+        signal,
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          request_id: login.request_id,
+          poll_secret: login.poll_secret,
+        }),
+      });
+      if (response.status === 200)
+        return resultSchema.parse(await response.json()).session_token;
+      if (response.status === 410)
+        throw new Error("Login request expired. Run cadet login again.");
+      if (response.status !== 202)
+        throw new Error(`Login polling failed (${response.status}).`);
+      await new Promise<void>((resolve, reject) => {
+        const abort = () => {
+          clearTimeout(timer);
+          reject(new Error("Login timed out after 5 minutes."));
+        };
+        const timer = setTimeout(() => {
+          signal.removeEventListener("abort", abort);
+          resolve();
+        }, login.interval * 1000);
+        signal.addEventListener("abort", abort, { once: true });
+        if (signal.aborted) abort();
+      });
+    }
+    throw new Error("Login timed out after 5 minutes.");
+  } catch (error) {
+    if (signal.aborted) throw new Error("Login timed out after 5 minutes.");
+    throw error;
+  }
+}

package/src/lib/cloud-login.ts

@@ -6,6 +6,7 @@
  * login when the user picks that provider).
  */
 
+import { pollingCloudLogin } from "./cloud-login-poll.js";
 import { randomBytes } from "crypto";
 import { createServer } from "http";
 import type { AddressInfo } from "net";
@@ -37,7 +38,7 @@ import {
   generatePkcePair,
 } from "./workos-pkce.js";
 
-const LOGIN_TIMEOUT_MS = 120_000; // 2 minutes
+const LOGIN_TIMEOUT_MS = 300_000;
 
 function escapeHtml(s: string): string {
   return s
@@ -258,6 +259,7 @@ export function startLoopbackListener(
 
 /** App-held WorkOS PKCE login */
 export async function workosPkceLogin(cloudUrl: string): Promise<string> {
+  if (!process.stdin.isTTY) return pollingCloudLogin(cloudUrl);
   const clientId = await fetchWorkosClientId(cloudUrl);
   const { verifier, challenge } = generatePkcePair();
   const state = randomBytes(32).toString("hex");
@@ -409,7 +411,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/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);
+}