@mycadet/cli 0.12.7-dev.202610111049.d2b52a8 → 0.12.8

package/src/commands/ps.ts

@@ -11,6 +11,7 @@ import {
   getDaemonPidPath,
   loadAllAssistants,
   lookupAssistantByIdentifier,
+  readRootProcesses,
   type AssistantEntry,
 } from "../lib/assistant-config";
 import { parseAssistantTargetArg } from "../lib/assistant-target-args.js";
@@ -44,14 +45,21 @@ import {
 
 // ── Table formatting helpers ────────────────────────────────────
 
+/** What each row's `type` column says: the KIND of process the row describes. */
+const ASSISTANT_TYPE = "🧑‍🚀 Assistant";
+const TUNNEL_TYPE = "🚇 Tunnel";
+const APP_TYPE = "🌐 App";
+
 interface TableRow {
   name: string;
+  type: string;
   status: string;
   info: string;
 }
 
 interface ColWidths {
   name: number;
+  type: number;
   status: number;
   info: number;
 }
@@ -62,27 +70,38 @@ function pad(s: string, w: number): string {
 
 function computeColWidths(
   rows: TableRow[],
-  headers: TableRow = { name: "NAME", status: "STATUS", info: "INFO" },
+  headers: TableRow = {
+    name: "NAME",
+    type: "TYPE",
+    status: "STATUS",
+    info: "INFO",
+  },
 ): ColWidths {
   const all = [headers, ...rows];
   return {
     name: Math.max(...all.map((r) => r.name.length)),
+    type: Math.max(...all.map((r) => r.type.length)),
     status: Math.max(...all.map((r) => r.status.length), "checking...".length),
     info: Math.max(...all.map((r) => r.info.length)),
   };
 }
 
 function formatRow(r: TableRow, colWidths: ColWidths): string {
-  return `  ${pad(r.name, colWidths.name)}  ${pad(r.status, colWidths.status)}  ${r.info}`;
+  return `  ${pad(r.name, colWidths.name)}  ${pad(r.type, colWidths.type)}  ${pad(r.status, colWidths.status)}  ${r.info}`;
 }
 
 function printTable(
   rows: TableRow[],
-  headers: TableRow = { name: "PROCESS", status: "STATUS", info: "INFO" },
+  headers: TableRow = {
+    name: "PROCESS",
+    type: "TYPE",
+    status: "STATUS",
+    info: "INFO",
+  },
 ): void {
   const colWidths = computeColWidths(rows, headers);
   console.log(formatRow(headers, colWidths));
-  const sep = `  ${"-".repeat(colWidths.name)}  ${"-".repeat(colWidths.status)}  ${"-".repeat(colWidths.info)}`;
+  const sep = `  ${"-".repeat(colWidths.name)}  ${"-".repeat(colWidths.type)}  ${"-".repeat(colWidths.status)}  ${"-".repeat(colWidths.info)}`;
   console.log(sep);
   for (const row of rows) {
     console.log(formatRow(row, colWidths));
@@ -108,6 +127,7 @@ function flattenProcessTree(
     rows.push({
       name:
         depth === 0 ? entry.name : `${"  ".repeat(depth - 1)}├─ ${entry.name}`,
+      type: ASSISTANT_TYPE,
       status: withStatusEmoji(STATUS_LABELS[entry.status]),
       info: entry.info ?? "",
     });
@@ -118,6 +138,7 @@ function flattenProcessTree(
       const prefix = `${"  ".repeat(depth)}${isLast ? "└─" : "├─"} ${child.name}`;
       rows.push({
         name: prefix,
+        type: ASSISTANT_TYPE,
         status: withStatusEmoji(STATUS_LABELS[child.status]),
         info: child.info ?? "",
       });
@@ -284,9 +305,7 @@ async function getLocalProcesses(entry: AssistantEntry): Promise<TableRow[]> {
   // tree (assistant + every child it owns, built from the OS process table)
   // with the gateway's own entry appended — no hard-coded subsystem list to
   // drift out of sync with what the assistant actually spawns.
-  const tree = gatewayUrl
-    ? await fetchGatewayPs(gatewayUrl, token)
-    : null;
+  const tree = gatewayUrl ? await fetchGatewayPs(gatewayUrl, token) : null;
 
   const rows: TableRow[] =
     tree && tree.length > 0
@@ -303,6 +322,7 @@ async function getLocalProcesses(entry: AssistantEntry): Promise<TableRow[]> {
   });
   rows.push({
     name: "credential-executor",
+    type: ASSISTANT_TYPE,
     status: withStatusEmoji(ces.running ? "running" : "not running"),
     info: ces.running ? formatDetectionInfo(ces) : "not detected",
   });
@@ -349,6 +369,7 @@ async function detectLocalProcessesFallback(
 
   return results.map((proc, i) => ({
     name: allSpecs[i].name,
+    type: ASSISTANT_TYPE,
     status: withStatusEmoji(proc.running ? "running" : "not running"),
     info: proc.running ? formatDetectionInfo(proc) : "not detected",
   }));
@@ -393,12 +414,14 @@ async function getDockerProcesses(entry: AssistantEntry): Promise<TableRow[]> {
       if (!state) {
         return {
           name,
+          type: ASSISTANT_TYPE,
           status: withStatusEmoji("not found"),
           info: `container ${containerName}`,
         };
       }
       return {
         name,
+        type: ASSISTANT_TYPE,
         status: withStatusEmoji(state === "running" ? "running" : state),
         info: `container ${containerName}`,
       };
@@ -412,6 +435,7 @@ async function getDockerProcesses(entry: AssistantEntry): Promise<TableRow[]> {
     const alive = isLocalProcessAlive(watcherPid);
     results.push({
       name: "file-watcher",
+      type: ASSISTANT_TYPE,
       status: withStatusEmoji(alive ? "running" : "not running"),
       info: alive ? `PID ${watcherPid}` : "not detected",
     });
@@ -430,22 +454,20 @@ function locationFor(entry: AssistantEntry): string {
   return entry.runtimeUrl ?? "unknown — no runtime URL recorded";
 }
 
-async function showAssistantProcesses(entry: AssistantEntry): Promise<void> {
+async function getAssistantProcessRows(
+  entry: AssistantEntry,
+): Promise<TableRow[]> {
   const cloud = entry.cloud;
 
   console.log(`Processes for ${formatAssistantReference(entry)} (${cloud}):`);
   console.log(`Location: ${locationFor(entry)}\n`);
 
   if (cloud === "local") {
-    const rows = await getLocalProcesses(entry);
-    printTable(rows);
-    return;
+    return getLocalProcesses(entry);
   }
 
   if (cloud === "docker") {
-    const rows = await getDockerProcesses(entry);
-    printTable(rows);
-    return;
+    return getDockerProcesses(entry);
   }
 
   if (isCloudHome(cloud)) {
@@ -454,20 +476,17 @@ async function showAssistantProcesses(entry: AssistantEntry): Promise<void> {
     const psData = await fetchManagedPs(entry.runtimeUrl, entry.assistantId);
 
     if (!psData) {
-      const rows: TableRow[] = [
+      return [
         {
           name: "assistant",
+          type: ASSISTANT_TYPE,
           status: withStatusEmoji("unreachable"),
           info: "could not reach Cadet Cloud API — run `cadet login`",
         },
       ];
-      printTable(rows);
-      return;
     }
 
-    const rows = flattenProcessTree(psData.processes);
-    printTable(rows);
-    return;
+    return flattenProcessTree(psData.processes);
   }
 
   if (cloud === "apple-container") {
@@ -476,6 +495,7 @@ async function showAssistantProcesses(entry: AssistantEntry): Promise<void> {
     const rows: TableRow[] = [
       {
         name: "container",
+        type: ASSISTANT_TYPE,
         status: withStatusEmoji(socketAlive ? "running" : "not running"),
         info: socketAlive
           ? `mgmt ${mgmtSocket}`
@@ -487,12 +507,12 @@ async function showAssistantProcesses(entry: AssistantEntry): Promise<void> {
       const health = await checkHealth(entry.runtimeUrl, token);
       rows.push({
         name: "gateway",
+        type: ASSISTANT_TYPE,
         status: withStatusEmoji(health.status),
         info: entry.runtimeUrl + (health.detail ? ` | ${health.detail}` : ""),
       });
     }
-    printTable(rows);
-    return;
+    return rows;
   }
 
   if (cloud === "paired") {
@@ -500,15 +520,14 @@ async function showAssistantProcesses(entry: AssistantEntry): Promise<void> {
     // list — probe the remote gateway's health over the bearer token instead.
     const token = loadGuardianToken(entry.assistantId)?.accessToken;
     const health = await checkHealth(entry.runtimeUrl, token);
-    const rows: TableRow[] = [
+    return [
       {
         name: "gateway",
+        type: ASSISTANT_TYPE,
         status: withStatusEmoji(health.status),
         info: entry.runtimeUrl + (health.detail ? ` | ${health.detail}` : ""),
       },
     ];
-    printTable(rows);
-    return;
   }
 
   let output: string;
@@ -525,7 +544,7 @@ async function showAssistantProcesses(entry: AssistantEntry): Promise<void> {
     const msg = error instanceof Error ? error.message : String(error);
     if (msg.includes("timed out")) {
       console.warn(`Warning: remote process listing timed out — ${msg}`);
-      return;
+      return [];
     }
     console.error(`Failed to list processes: ${msg}`);
     process.exit(1);
@@ -535,16 +554,93 @@ async function showAssistantProcesses(entry: AssistantEntry): Promise<void> {
 
   if (procs.length === 0) {
     console.log("No cadet processes found on the remote instance.");
-    return;
+    return [];
   }
 
-  const rows: TableRow[] = procs.map((p) => ({
+  return procs.map((p) => ({
     name: classifyProcess(p.command),
+    type: ASSISTANT_TYPE,
     status: withStatusEmoji("running"),
     info: `PID ${p.pid} | ${p.command.slice(0, 80)}`,
   }));
+}
+
+// ── Root-managed process rows (tunnel agent, app edge) ──────────
+
+/** A CLI-managed process row, plus the assistant it fronts (when recorded). */
+interface RootManagedRow {
+  row: TableRow;
+  assistantId?: string;
+}
+
+/**
+ * Rows for the CLI-managed processes recorded at the lockfile root: the
+ * `tunnel` agent and the `app` nginx edge. Pids are liveness-checked so a
+ * stale entry reads as not running rather than as a lie. Each row carries the
+ * assistant it fronts so the listing can nest it under that assistant.
+ */
+async function getRootManagedRows(): Promise<RootManagedRow[]> {
+  const { tunnel, app } = readRootProcesses();
+  const rows: RootManagedRow[] = [];
+
+  if (tunnel) {
+    const alive = isLocalProcessAlive(tunnel.pid);
+    rows.push({
+      assistantId: tunnel.assistantId,
+      row: {
+        name: tunnel.provider ?? "unknown provider",
+        type: TUNNEL_TYPE,
+        status: withStatusEmoji(alive ? "running" : "not running"),
+        info: alive ? `PID ${tunnel.pid}` : `PID ${tunnel.pid} (exited)`,
+      },
+    });
+  }
+  if (app) {
+    const alive = isLocalProcessAlive(app.pid);
+    rows.push({
+      assistantId: app.assistantId,
+      row: {
+        name: "nginx edge",
+        type: APP_TYPE,
+        status: withStatusEmoji(alive ? "running" : "not running"),
+        info: alive ? `PID ${app.pid}` : `PID ${app.pid} (exited)`,
+      },
+    });
+  }
+  return rows;
+}
+
+/**
+ * Fold the CLI-managed process rows into ONE table with the assistant rows:
+ * a process fronts an assistant when it recorded that assistant's id, and
+ * those rows nest under it; anything unattributed (or fronting an assistant
+ * this environment no longer lists) renders at the bottom, machine-level.
+ */
+async function assistantRowsWithRootProcesses(
+  assistants: AssistantEntry[],
+  healths: AssistantHealth[],
+  activeAssistantId: string | null,
+): Promise<TableRow[]> {
+  const nestedByAssistant = new Map<string, TableRow[]>();
+  const unattributed: TableRow[] = [];
+  const knownIds = new Set(assistants.map((entry) => entry.assistantId));
+  for (const managed of await getRootManagedRows()) {
+    if (managed.assistantId && knownIds.has(managed.assistantId)) {
+      const nested = nestedByAssistant.get(managed.assistantId) ?? [];
+      nested.push({ ...managed.row, name: `  └ ${managed.row.name}` });
+      nestedByAssistant.set(managed.assistantId, nested);
+    } else {
+      unattributed.push(managed.row);
+    }
+  }
 
-  printTable(rows);
+  const rows: TableRow[] = [];
+  assistants.forEach((entry, i) => {
+    rows.push(formatAssistantListRow(entry, activeAssistantId, healths[i]!));
+    rows.push(...(nestedByAssistant.get(entry.assistantId) ?? []));
+  });
+  rows.push(...unattributed);
+  return rows;
 }
 
 // ── List all assistants (no arg) ────────────────────────────────
@@ -611,6 +707,7 @@ function formatAssistantListRow(
   const prefix = entry.assistantId === activeAssistantId ? "* " : "  ";
   return {
     name: prefix + getAssistantDisplayName(entry),
+    type: ASSISTANT_TYPE,
     status: withStatusEmoji(health.status),
     info: infoParts.join(" | "),
   };
@@ -654,6 +751,7 @@ export async function listAllAssistants(verbose: boolean): Promise<void> {
       console.log("\nOrphaned processes detected:\n");
       const rows: TableRow[] = orphans.map((o) => ({
         name: o.name,
+        type: ASSISTANT_TYPE,
         status: withStatusEmoji("running"),
         info: `PID ${o.pid} (from ${o.source})`,
       }));
@@ -666,60 +764,71 @@ export async function listAllAssistants(verbose: boolean): Promise<void> {
     return;
   }
 
-  const rows = await Promise.all(
-    assistants.map(async (entry) =>
-      formatAssistantListRow(
-        entry,
-        activeAssistantId,
-        await getAssistantListHealth(entry),
-      ),
-    ),
+  const healths = await Promise.all(
+    assistants.map((entry) => getAssistantListHealth(entry)),
   );
 
-  printTable(rows, { name: "NAME", status: "STATUS", info: "INFO" });
-  console.log("");
+  printTable(
+    await assistantRowsWithRootProcesses(
+      assistants,
+      healths,
+      activeAssistantId,
+    ),
+    { name: "NAME", type: "TYPE", status: "STATUS", info: "INFO" },
+  );
 }
 
 // ── Entry point ─────────────────────────────────────────────────
 
 export const ps = Object.assign(
   async function ps(): Promise<void> {
-  const args = process.argv.slice(3);
-  if (args.includes("--help") || args.includes("-h")) {
-    console.log("Usage: cadet ps [<name-or-id>] [--verbose]");
-    console.log("");
-    console.log(
-      "List all assistants, or show processes for a specific assistant.",
-    );
-    console.log("");
-    console.log("Arguments:");
-    console.log(
-      "  <name-or-id> Show processes for the assistant display name or ID",
-    );
-    console.log("");
-    console.log("Options:");
-    console.log(
-      "  --verbose    Show diagnostic logs (platform sync, auth issues)",
-    );
-    process.exit(0);
-  }
+    const args = process.argv.slice(3);
+    if (args.includes("--help") || args.includes("-h")) {
+      console.log("Usage: cadet ps [<name-or-id>] [--verbose]");
+      console.log("");
+      console.log(
+        "List all assistants, or show processes for a specific assistant.",
+      );
+      console.log("");
+      console.log("Arguments:");
+      console.log(
+        "  <name-or-id> Show processes for the assistant display name or ID",
+      );
+      console.log("");
+      console.log("Options:");
+      console.log(
+        "  --verbose    Show diagnostic logs (platform sync, auth issues)",
+      );
+      process.exit(0);
+    }
 
-  const verbose = args.includes("--verbose");
-  const assistantIdentifier = parseAssistantTargetArg(args);
+    const verbose = args.includes("--verbose");
+    const assistantIdentifier = parseAssistantTargetArg(args);
 
-  if (!assistantIdentifier) {
-    await listAllAssistants(verbose);
-    return;
-  }
+    if (!assistantIdentifier) {
+      await listAllAssistants(verbose);
+      return;
+    }
 
-  const result = lookupAssistantByIdentifier(assistantIdentifier);
-  if (result.status !== "found") {
-    console.error(formatAssistantLookupError(assistantIdentifier, result));
-    process.exit(1);
-  }
+    const result = lookupAssistantByIdentifier(assistantIdentifier);
+    if (result.status !== "found") {
+      console.error(formatAssistantLookupError(assistantIdentifier, result));
+      process.exit(1);
+    }
 
-  await showAssistantProcesses(result.entry);
-},
+    const rows = await getAssistantProcessRows(result.entry);
+    // The CLI-managed processes (root lockfile) that front THIS assistant ride
+    // the same table; ones fronting another assistant stay in the list view.
+    for (const managed of await getRootManagedRows()) {
+      if (
+        managed.assistantId &&
+        managed.assistantId !== result.entry.assistantId
+      ) {
+        continue;
+      }
+      rows.push(managed.row);
+    }
+    printTable(rows);
+  },
   { description: "List assistants (or processes for a specific assistant)" },
 );
-

package/src/commands/retire.ts

@@ -25,7 +25,6 @@ import {
   authHeaders,
   authHeadersForKnownOrganization,
   getCloudUrl,
-  readGatewayCredential,
   readCloudToken,
 } from "../lib/cloud-client.js";
 import { retireDocker, dockerResourceNames } from "../lib/docker.js";
@@ -51,12 +50,6 @@ interface RetireArgs {
   yes: boolean;
 }
 
-interface SelfHostedPlatformRegistration {
-  cloudAssistantId: string;
-  cloudBaseUrl: string | null;
-  organizationId: string | null;
-}
-
 const CLOUD_TOKEN_ENV = "CADET_CLOUD_TOKEN";
 const LEGACY_CLOUD_TOKEN_ENV = "CADET_PLATFORM_TOKEN";
 
@@ -68,54 +61,11 @@ function readPlatformRetireToken(): string | null {
   return readCloudToken();
 }
 
-function platformOrigin(cloudUrl: string): string | null {
-  try {
-    return new URL(cloudUrl).origin;
-  } catch {
-    return null;
-  }
-}
-
-function resolveTrustedSelfHostedCloudUrl(
-  storedCloudUrl: string | null,
-): string | null {
-  const configuredCloudUrl = getCloudUrl();
-  if (!storedCloudUrl) return configuredCloudUrl;
-
-  const storedOrigin = platformOrigin(storedCloudUrl);
-  const configuredOrigin = platformOrigin(configuredCloudUrl);
-  if (storedOrigin && configuredOrigin && storedOrigin === configuredOrigin) {
-    return configuredCloudUrl;
-  }
-
-  console.warn(
-    "⚠️  Stored platform URL does not match the configured platform URL; skipping platform unregister.",
-  );
-  return null;
-}
-
 function nonEmptyString(value: string | null | undefined): string | null {
   const trimmed = value?.trim();
   return trimmed ? trimmed : null;
 }
 
-function lockfileSelfHostedPlatformRegistration(
-  entry: AssistantEntry,
-): SelfHostedPlatformRegistration | null {
-  const cloudAssistantId = nonEmptyString(
-    entry.cloudAssistantId ?? entry.cloudAssistantId,
-  );
-  if (!cloudAssistantId) return null;
-
-  return {
-    cloudAssistantId,
-    cloudBaseUrl: nonEmptyString(entry.cloudBaseUrl ?? entry.platformBaseUrl),
-    organizationId: nonEmptyString(
-      entry.cloudOrganizationId ?? entry.platformOrganizationId,
-    ),
-  };
-}
-
 async function deleteCloudAssistant(
   assistantId: string,
   options: {
@@ -150,85 +100,23 @@ async function deleteCloudAssistant(
   }
 }
 
-async function readSelfHostedPlatformRegistration(
-  entry: AssistantEntry,
-): Promise<SelfHostedPlatformRegistration | null> {
-  const fallback = lockfileSelfHostedPlatformRegistration(entry);
-  const gatewayUrl = entry.localUrl ?? entry.runtimeUrl;
-  const cloudRegistration = await readGatewayCredential(
-    gatewayUrl,
-    "cadet:platform_assistant_id",
-    entry.bearerToken,
-  );
-  if (cloudRegistration.unreachable) {
-    if (fallback) {
-      console.warn(
-        "\u26a0\ufe0f  Could not read platform registration from the local assistant; using saved platform registration.",
-      );
-      return fallback;
-    }
-    console.warn(
-      "\u26a0\ufe0f  Could not read cloud registration from the local assistant and no saved cloud registration is available; skipping cloud unregister.",
-    );
-    return null;
-  }
-
-  const cloudAssistantId =
-    nonEmptyString(cloudRegistration.value) ?? fallback?.cloudAssistantId;
-  if (!cloudAssistantId) return null;
-
-  const [cloudBaseUrl, organizationId] = await Promise.all([
-    readGatewayCredential(
-      gatewayUrl,
-      "cadet:platform_base_url",
-      entry.bearerToken,
-    ),
-    readGatewayCredential(
-      gatewayUrl,
-      "cadet:platform_organization_id",
-      entry.bearerToken,
-    ),
-  ]);
-
-  return {
-    cloudAssistantId,
-    cloudBaseUrl:
-      nonEmptyString(cloudBaseUrl.value) ??
-      fallback?.cloudBaseUrl ??
-      null,
-    organizationId:
-      nonEmptyString(organizationId.value) ?? fallback?.organizationId ?? null,
-  };
-}
-
 async function unregisterSelfHostedLocalPlatformRecord(
   entry: AssistantEntry,
 ): Promise<void> {
   const token = readPlatformRetireToken();
   if (!token) return;
 
-  const registration = await readSelfHostedPlatformRegistration(entry);
-  if (!registration) return;
-
-  const cloudUrl = resolveTrustedSelfHostedCloudUrl(
-    registration.cloudBaseUrl,
-  );
-  if (!cloudUrl) return;
-  if (!registration.organizationId) {
-    console.warn(
-      "⚠️  Could not read platform organization ID from the local assistant; skipping platform unregister.",
-    );
-    return;
-  }
+  const cloudAssistantId = nonEmptyString(entry.cloudAssistantId);
+  if (!cloudAssistantId) return;
 
-  await deleteCloudAssistant(registration.cloudAssistantId, {
+  await deleteCloudAssistant(cloudAssistantId, {
     token,
-    cloudUrl,
-    organizationId: registration.organizationId,
+    cloudUrl: getCloudUrl(),
+    organizationId: nonEmptyString(entry.cloudOrganizationId) ?? undefined,
     label: "Platform self-hosted unregister",
-    successMessage: "\u2705 Platform self-hosted registration unregistered.",
+    successMessage: "✅ Platform self-hosted registration unregistered.",
     alreadyGoneMessage:
-      "\u2705 Platform self-hosted registration already unregistered (404).",
+      "✅ Platform self-hosted registration already unregistered (404).",
   });
 }
 
@@ -331,8 +219,8 @@ function printRetireTarget(entry: AssistantEntry, cloud: string): void {
         : {}),
       ...(entry.cloud === "docker"
         ? {
-            container:
-              dockerResourceNames(entry.assistantId).assistantContainer,
+            container: dockerResourceNames(entry.assistantId)
+              .assistantContainer,
           }
         : {}),
     },
@@ -373,28 +261,29 @@ function teeConsoleToLogFile(fd: number | "ignore"): void {
 
 export const retire = Object.assign(
   async function retire(): Promise<void> {
-  if (process.env.CADET_DESKTOP_APP) {
-    resetLogFile("retire.log");
-  }
-  const logFd = process.env.CADET_DESKTOP_APP
-    ? openLogFile("retire.log")
-    : "ignore";
-  teeConsoleToLogFile(logFd);
+    if (process.env.CADET_DESKTOP_APP) {
+      resetLogFile("retire.log");
+    }
+    const logFd = process.env.CADET_DESKTOP_APP
+      ? openLogFile("retire.log")
+      : "ignore";
+    teeConsoleToLogFile(logFd);
 
-  try {
-    await retireInner();
-  } finally {
-    closeLogFile(logFd);
-  }
-},
+    try {
+      await retireInner();
+    } finally {
+      closeLogFile(logFd);
+    }
+  },
   { description: "Delete an assistant instance" },
 );
 
-
 async function retireInner(): Promise<void> {
   const args = process.argv.slice(3);
   if (args.includes("--help") || args.includes("-h")) {
-    console.log("Usage: cadet retire [<name-or-id>] [--source <source>] [--yes]");
+    console.log(
+      "Usage: cadet retire [<name-or-id>] [--source <source>] [--yes]",
+    );
     console.log("");
     console.log("Delete an assistant instance and archive its data.");
     console.log(
@@ -422,7 +311,9 @@ async function retireInner(): Promise<void> {
     console.error(
       "Error: No assistant specified and no active assistant. Pass a name or ID, or pick one with `cadet use <name>`.",
     );
-    console.error("Usage: cadet retire <name-or-id> [--source <source>] [--yes]");
+    console.error(
+      "Usage: cadet retire <name-or-id> [--source <source>] [--yes]",
+    );
     process.exit(1);
   }