@mycadet/cli 0.12.9 → 0.12.10

package/src/__tests__/uninstall.test.ts

@@ -1,4 +1,12 @@
-import { afterAll, afterEach, describe, expect, spyOn, test } from "bun:test";
+import {
+  afterAll,
+  afterEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from "bun:test";
 import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "fs";
 import { tmpdir } from "os";
 import { dirname, join } from "path";
@@ -8,6 +16,7 @@ import {
   getConfigDirs,
   getInputHistoryPath,
   getLogDir,
+  getSharedStateDir,
   getStateDir,
 } from "../lib/environments/paths.js";
 import { getCurrentEnvironment } from "../lib/environments/resolve.js";
@@ -16,6 +25,20 @@ import type { AssistantEntry } from "../lib/assistant-config.js";
 // The command reads its argv at call time.
 const ORIGINAL_ARGV = process.argv;
 
+// retireDocker is the one retirement path with observable side effects
+// (docker teardown), and uninstall is the only importer in its graph.
+// Mocked module-wide so tests pin WHEN it runs — never before the
+// confirmation gate — as much as whether it runs.
+const retireDockerCalls: string[] = [];
+let onRetireDocker: ((name: string) => void) | undefined;
+
+mock.module("../lib/docker.js", () => ({
+  retireDocker: (name: string) => {
+    retireDockerCalls.push(name);
+    onRetireDocker?.(name);
+  },
+}));
+
 // Every XDG location the command touches MUST be redirected: the homedir
 // fallback would otherwise point at the real user's data dirs.
 function redirectXdg(): string {
@@ -70,7 +93,15 @@ describe("cadet uninstall", () => {
   const errorSpy = spyOn(console, "error").mockImplementation(() => {});
   const warnSpy = spyOn(console, "warn").mockImplementation(() => {});
 
+  function printedOutput(): string {
+    return logSpy.mock.calls
+      .map((args) => args.map(String).join(" "))
+      .join("\n");
+  }
+
   afterEach(() => {
+    retireDockerCalls.length = 0;
+    onRetireDocker = undefined;
     logSpy.mockClear();
     errorSpy.mockClear();
     warnSpy.mockClear();
@@ -82,11 +113,12 @@ describe("cadet uninstall", () => {
     warnSpy.mockRestore();
   });
 
-  test("warns and retires remaining assistants, then proceeds to the confirm gate", async () => {
+  test("warns that remaining assistants will be retired, then proceeds to the confirm gate", async () => {
     await withRestoredEnv(async () => {
       const root = redirectXdg();
       // A remaining assistant is retired — with its data deleted — as part
-      // of the uninstall (v0.0.10 run feedback: the old hard refusal just
+      // of the uninstall AFTER the user confirms; the pre-confirm summary
+      // says so up front (v0.0.10 run feedback: the hard refusal just
       // blocked the uninstall; the fs sweep deletes the archives anyway).
       writeFileSync(
         join(process.env.CADET_LOCKFILE_DIR!, "lockfile.json"),
@@ -105,7 +137,7 @@ describe("cadet uninstall", () => {
           expect.stringContaining("1 assistant still exists"),
         );
         expect(warnSpy).toHaveBeenCalledWith(
-          expect.stringContaining("will be retired now"),
+          expect.stringContaining("will be retired as part of this uninstall"),
         );
         expect(errorSpy).not.toHaveBeenCalledWith(
           expect.stringContaining("Retire them first"),
@@ -138,6 +170,67 @@ describe("cadet uninstall", () => {
     });
   });
 
+  test("does not retire assistants when the confirm gate refuses", async () => {
+    await withRestoredEnv(async () => {
+      const root = redirectXdg();
+      writeFileSync(
+        join(process.env.CADET_LOCKFILE_DIR!, "lockfile.json"),
+        JSON.stringify({
+          assistants: [{ ...makeEntry("docker-assistant"), cloud: "docker" }],
+        }) + "\n",
+      );
+
+      const exitMock = spyOn(process, "exit");
+      exitMock.mockImplementation((code?: number | string | undefined): never => {
+        throw new Error(`process.exit:${code}`);
+      });
+      try {
+        process.argv = ["bun", "cadet", "uninstall"];
+        await expect(uninstall()).rejects.toThrow("process.exit:1");
+      } finally {
+        exitMock.mockRestore();
+      }
+      // Retirement is part of the confirmed flow — a refusal must leave the
+      // assistant's docker resources untouched.
+      expect(retireDockerCalls).toEqual([]);
+
+      rmSync(root, { recursive: true, force: true });
+    });
+  });
+
+  test("--yes retires remaining assistants after the deletion list is shown", async () => {
+    await withRestoredEnv(async () => {
+      const root = redirectXdg();
+      writeFileSync(
+        join(process.env.CADET_LOCKFILE_DIR!, "lockfile.json"),
+        JSON.stringify({
+          assistants: [{ ...makeEntry("docker-assistant"), cloud: "docker" }],
+        }) + "\n",
+      );
+      mkdirSync(getConfigDirs(getCurrentEnvironment())[0]!, {
+        recursive: true,
+      });
+
+      // Capture what had been printed by the time retirement ran — the list
+      // the user confirms against must already be on screen.
+      let outputAtRetire = "";
+      onRetireDocker = () => {
+        outputAtRetire = printedOutput();
+      };
+
+      process.argv = ["bun", "cadet", "uninstall", "--yes"];
+      await uninstall();
+
+      expect(retireDockerCalls).toEqual(["docker-assistant"]);
+      expect(outputAtRetire).toContain("It will permanently delete:");
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("will be retired as part of this uninstall"),
+      );
+
+      rmSync(root, { recursive: true, force: true });
+    });
+  });
+
   test("--yes deletes the environment's XDG locations and leaves the source checkout alone", async () => {
     await withRestoredEnv(async () => {
       const root = redirectXdg();
@@ -166,15 +259,54 @@ describe("cadet uninstall", () => {
       expect(existsSync(logDir)).toBe(false);
       expect(existsSync(historyPath)).toBe(false);
 
+      // The list shows the shared state DIR (never the input-history FILE
+      // alone) and never names a nested path twice — the log dir goes with
+      // its parent's recursive delete.
+      const out = printedOutput();
+      expect(out).toContain(
+        `  - ${getSharedStateDir()}  — shared state, including the terminal input history`,
+      );
+      expect(out).not.toContain(logDir);
+      expect(out).not.toContain(historyPath);
+      expect(out).not.toContain("It will then remove the Cadet executable");
+
       // Running under bun from a git checkout: self-removal must print the
       // note and delete NOTHING outside the XDG targets.
-      const note = logSpy.mock.calls
-        .map((args) => args.map(String).join(" "))
-        .join("\n");
-      expect(note).toContain("source checkout");
+      expect(printedOutput()).toContain("source checkout");
       expect(existsSync(process.execPath)).toBe(true);
 
       rmSync(root, { recursive: true, force: true });
     });
   });
+
+  test("--yes lists and removes the Cadet executable itself", async () => {
+    await withRestoredEnv(async () => {
+      const root = redirectXdg();
+      const configDir = getConfigDirs(getCurrentEnvironment())[0]!;
+      mkdirSync(configDir, { recursive: true });
+
+      // A compiled-binary install: process.execPath IS the install, so the
+      // uninstall list must name it alongside the data dirs.
+      const fakeBinDir = join(root, "bin");
+      mkdirSync(fakeBinDir, { recursive: true });
+      const fakeBin = join(fakeBinDir, "cadet");
+      writeFileSync(fakeBin, "#!/bin/sh\n");
+
+      const realExecPath = process.execPath;
+      process.execPath = fakeBin;
+      try {
+        process.argv = ["bun", "cadet", "uninstall", "--yes"];
+        await uninstall();
+      } finally {
+        process.execPath = realExecPath;
+      }
+
+      expect(printedOutput()).toContain(
+        `  - ${fakeBin}  — the Cadet executable`,
+      );
+      expect(existsSync(fakeBin)).toBe(false);
+
+      rmSync(root, { recursive: true, force: true });
+    });
+  });
 });

package/src/commands/client.ts

@@ -1304,10 +1304,9 @@ async function spawnBackgroundWebInterface(
 export function buildWebInterfaceConfig(opts: {
   webUrl: string;
   cloudUrl: string;
-  disableCloud: boolean;
 }): Record<string, unknown> {
-  const { webUrl, cloudUrl, disableCloud } = opts;
-  return { webUrl, cloudUrl, disableCloud };
+  const { webUrl, cloudUrl } = opts;
+  return { webUrl, cloudUrl };
 }
 
 async function runWebInterface(
@@ -1349,9 +1348,7 @@ async function runWebInterface(
   const webUrl = getWebUrl();
   const safeJson = (v: unknown) =>
     JSON.stringify(v).replace(/</g, "\\u003c").replace(/>/g, "\\u003e");
-  const configJson = safeJson(
-    buildWebInterfaceConfig({ webUrl, cloudUrl, disableCloud }),
-  );
+  const configJson = safeJson(buildWebInterfaceConfig({ webUrl, cloudUrl }));
   const hasOverrides = Object.keys(parsedFlagOverrides).length > 0;
   const flagOverridesSnippet = hasOverrides
     ? `;window.__CADET_FLAG_OVERRIDES__=${safeJson(parsedFlagOverrides)}`
@@ -1557,6 +1554,7 @@ async function runViteDevServer(
       ...viteFlagVars,
       ...(disableCloud ? { VITE_CADET_DISABLE_CLOUD: "true" } : {}),
       VITE_CLOUD_MODE: "false",
+      VITE_WEB_MODE: "full",
       API_PROXY_TARGET: cloudUrl,
       CADET_WEB_URL: getWebUrl(),
       CADET_CLOUD_URL: cloudUrl,

package/src/commands/hatch.ts

@@ -6,6 +6,7 @@ import {
   saveAssistantEntry,
   setActiveAssistant,
 } from "../lib/assistant-config";
+import { green } from "../lib/color";
 import { HATCH_ART, HATCHED_EMOJI, VALID_REMOTE_HOSTS } from "../lib/constants";
 import type { RemoteHost } from "../lib/constants";
 import { hatchDocker } from "../lib/docker";
@@ -347,7 +348,9 @@ async function hatchCadetPlatform(): Promise<void> {
   });
   setActiveAssistant(result.id);
 
-  console.log(`   ${HATCHED_EMOJI}  Your assistant has hatched!`);
+  console.log(
+    "   " + green(`${HATCHED_EMOJI}  Your assistant has hatched!`, process.stdout),
+  );
   console.log("");
   console.log(`   ID:     ${result.id}`);
   console.log(`   Name:   ${result.name}`);

package/src/commands/pair.ts

@@ -3,9 +3,12 @@
  *
  * Print the pairing link for another device, and the same link rendered as a
  * QR code. Runs on the machine hosting the assistant: it mints a remote-web
- * pairing challenge over the loopback gateway and approves it immediately, so
- * running this command IS the local-presence proof and one scan (or one paste
- * into `cadet connect import`) completes the pairing.
+ * pairing challenge through the gateway CLI (`gateway pairing mint <url>` —
+ * locally, or docker-exec'd into the gateway container) which approves it
+ * immediately, so running this command IS the local-presence proof and one
+ * scan (or one paste into `cadet connect import`) completes the pairing.
+ * local and docker assistants mint without any HTTP; other topologies keep
+ * the loopback HTTP mint.
  *
  * `--web-approve` is the reverse direction: approve a code a device already
  * shows, for pairings that device started on its own.
@@ -38,8 +41,11 @@ import {
 import { GATEWAY_PORT } from "../lib/constants.js";
 import { getCurrentEnvironment } from "../lib/environments/resolve.js";
 import { isLoopbackUrl, loopbackSafeFetch } from "../lib/loopback-fetch.js";
+import { dockerResourceNames } from "../lib/docker.js";
+import { gatewayCliInvocation } from "../lib/local.js";
 import { formatWebApproveFailure, parseGatewayErrorCode } from "../lib/pair.js";
 import { STALE_CLI_UPDATE_HINT } from "../lib/stale-cli-hint.js";
+import { execOutput } from "../lib/step-runner.js";
 
 function assistantDisplayName(entry: AssistantEntry): string {
   return entry.name || entry.assistantName || entry.assistantId;
@@ -89,9 +95,10 @@ function printUsage(): void {
 USAGE:
     cadet pair [assistant] [options]
 
-Mints a pairing challenge on the assistant's gateway over loopback and
-approves it on the spot (running this command on the host machine is the
-approval), then prints the pairing link and the same link as a QR code.
+Mints a pairing challenge on the assistant's gateway (via the gateway CLI
+for local and docker assistants, over loopback HTTP otherwise) and approves
+it on the spot (running this command on the host machine is the approval),
+then prints the pairing link and the same link as a QR code.
 Scanning the QR, opening the link, or passing it to 'cadet connect import'
 on the other device completes the pairing in one step.
 
@@ -214,26 +221,122 @@ async function exitOnHttpError(response: Response): Promise<Response> {
   return response;
 }
 
-/** Create a remote-web pairing challenge (RFC 8628 device-code flow). */
-async function createRemoteWebPairingChallenge(
-  gatewayUrl: string,
+/**
+ * Mint (and approve) a remote-web pairing challenge. `local` and `docker`
+ * remotes mint through the gateway CLI — `gateway pairing mint <url>` run on
+ * the assistant's host (locally, or docker-exec'd into the gateway container)
+ * — replacing the old loopback HTTP mint whose loopback-peer gate
+ * containerized gateways could never satisfy (published-port NAT rewrites
+ * host-originated peers to the docker bridge address). The mint executes the
+ * pairing logic directly against the file-backed challenge store, so the
+ * running gateway's verification routes see it with no IPC round-trip.
+ * Process execution is the local-presence proof; the mint command approves
+ * on the spot, so the returned challenge is already paired-ready. Other
+ * topologies keep the loopback HTTP mint they used before.
+ */
+async function mintPairingChallengeOrExit(
+  entry: AssistantEntry,
+  publicBaseUrl: string,
+): Promise<RemoteWebPairingChallengeResponse> {
+  if (entry.cloud !== "local" && entry.cloud !== "docker") {
+    return mintPairingChallengeOverLoopbackOrExit(entry, publicBaseUrl);
+  }
+
+  let stdout: string;
+  try {
+    if (entry.cloud === "docker") {
+      stdout = await execOutput(
+        "docker",
+        [
+          "exec",
+          dockerResourceNames(entry.assistantId).gatewayContainer,
+          "bun",
+          "run",
+          "src/cli/index.ts",
+          "pairing",
+          "mint",
+          publicBaseUrl,
+        ],
+        { timeoutMs: 30_000 },
+      );
+    } else {
+      const invocation = gatewayCliInvocation(entry.resources);
+      stdout = await execOutput(
+        invocation.command,
+        [...invocation.args, "pairing", "mint", publicBaseUrl],
+        {
+          cwd: invocation.cwd,
+          env: invocation.env,
+          timeoutMs: 30_000,
+        },
+      );
+    }
+  } catch (err) {
+    console.error(
+      `Error: could not mint a pairing challenge on the gateway ` +
+        `(${err instanceof Error ? err.message : String(err)}).`,
+    );
+    console.error("Is the assistant running? Try `cadet wake`.");
+    process.exit(1);
+  }
+
+  const lastLine = stdout.split("\n").filter(Boolean).pop() ?? "";
+  let challenge: RemoteWebPairingChallengeResponse;
+  try {
+    challenge = JSON.parse(lastLine) as RemoteWebPairingChallengeResponse;
+  } catch {
+    console.error(
+      "Error: could not parse the gateway's pairing mint output.",
+    );
+    process.exit(1);
+  }
+  if (!challenge.deviceCode || !challenge.userCode) {
+    console.error(
+      "Error: the gateway's pairing mint output is missing the challenge codes.",
+    );
+    process.exit(1);
+  }
+  return challenge;
+}
+
+/**
+ * Mint a challenge over the gateway's loopback HTTP route — the path every
+ * topology took before the gateway-CLI mint existed. Kept for remotes that
+ * are neither `local` nor `docker` (apple containers, SSH-managed hosts,
+ * cloud-managed), where no gateway-CLI execution surface is defined.
+ */
+async function mintPairingChallengeOverLoopbackOrExit(
+  entry: AssistantEntry,
   publicBaseUrl: string,
 ): Promise<RemoteWebPairingChallengeResponse> {
+  // Mint over loopback (localUrl avoids mDNS for same-machine calls), then
+  // approve immediately: running this CLI on the host IS the local-presence
+  // proof, so the other device completes pairing in one step from the link.
+  const mintUrl = (
+    entry.localUrl ||
+    entry.runtimeUrl ||
+    `http://127.0.0.1:${GATEWAY_PORT}`
+  ).replace(/\/+$/, "");
   const response = await gatewayPostOrExit(
-    gatewayUrl,
+    mintUrl,
     "/v1/remote-web/pairing-challenge",
     { publicBaseUrl } satisfies RemoteWebPairingChallengeRequest,
   );
-  return (await response.json()) as RemoteWebPairingChallengeResponse;
+  const challenge: RemoteWebPairingChallengeResponse =
+    await response.json();
+  await gatewayPostOrExit(mintUrl, "/v1/remote-web/pairing-verification", {
+    userCode: challenge.userCode,
+  } satisfies RemoteWebPairingVerificationRequest);
+  return challenge;
 }
 
 /**
  * Approve a pending pairing challenge by its user code, the local-presence
  * proof for the device-code flow. Single owner of the pairing-verification
- * route and request body: the link flow approves via
- * {@link approveRemoteWebPairing} (generic exit on non-2xx), while
- * `--web-approve` calls this directly to inspect rejections and print mismatch
- * diagnostics (see {@link formatWebApproveFailure}).
+ * route and request body: `--web-approve` calls this directly to inspect
+ * rejections and print mismatch diagnostics (see
+ * {@link formatWebApproveFailure}); the link flow needs no separate
+ * verification call — the gateway-CLI mint approves on the spot.
  */
 async function postPairingVerification(
   gatewayUrl: string,
@@ -244,20 +347,6 @@ async function postPairingVerification(
   } satisfies RemoteWebPairingVerificationRequest);
 }
 
-/**
- * Approve the challenge this command just minted so one scan completes
- * pairing, exiting with a generic message on non-2xx.
- */
-async function approveRemoteWebPairing(
-  gatewayUrl: string,
-  userCode: string,
-): Promise<RemoteWebPairingVerificationResponse> {
-  const response = await exitOnHttpError(
-    await postPairingVerification(gatewayUrl, userCode),
-  );
-  return (await response.json()) as RemoteWebPairingVerificationResponse;
-}
-
 export const pair = Object.assign(
   async function pair(): Promise<void> {
   const rawArgs = process.argv.slice(3);
@@ -355,6 +444,24 @@ export const pair = Object.assign(
     }
   }
 
+  // Minting requires host presence on this machine. Native and docker
+  // topologies qualify (the latter via docker exec); an assistant this
+  // machine only knows through `connect import` has no host presence here
+  // at all, and `cadet pair` never worked against it (its loopback gate
+  // denied remote mints). Refuse clearly instead of a confusing mint
+  // failure.
+  if (entry.cloud === "paired") {
+    console.error(
+      `Error: ${formatAssistantReference(entry)} was paired as a remote ` +
+        "assistant (cadet connect import), so this machine does not host it.",
+    );
+    console.error(
+      "Run `cadet pair` on the machine hosting the assistant, or approve " +
+        "a code it shows with `cadet pair --web-approve <code>`.",
+    );
+    process.exit(1);
+  }
+
   // Mint over loopback (localUrl avoids mDNS for same-machine calls), but
   // advertise a REACHABLE url in the link, since the loopback url would point
   // the other device at its own localhost. Prefer an explicit --url, then the
@@ -437,14 +544,10 @@ export const pair = Object.assign(
   }
   const publicBaseUrl = resolved.url;
 
-  // Mint a challenge and immediately approve it: running this CLI on the host
-  // IS the local-presence proof, so the other device completes pairing in one
-  // step from the link alone.
-  const challenge = await createRemoteWebPairingChallenge(
-    mintUrl,
-    publicBaseUrl,
-  );
-  await approveRemoteWebPairing(mintUrl, challenge.userCode);
+  // Mint a challenge (approved on the spot by the gateway-CLI invocation):
+  // running this CLI on the host IS the local-presence proof, so the other
+  // device completes pairing in one step from the link alone.
+  const challenge = await mintPairingChallengeOrExit(entry, publicBaseUrl);
   const pairUrl = buildRemoteWebPairingUrl(challenge);
   const displayName = assistantDisplayName(entry);
   const appUrl = appVariant

package/src/commands/ps.ts

@@ -660,35 +660,23 @@ async function getRootManagedRows(): Promise<RootManagedRow[]> {
 }
 
 /**
- * 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.
+ * Fold the CLI-managed process rows into ONE table with the assistant rows.
+ * Tunnel agents and the nginx edge are root resources of the machine, not
+ * children of whichever assistant they front — especially as the web bundle
+ * splits into /app and /ui — so every CLI-managed row renders 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);
-    }
-  }
+  const rootRows = (await getRootManagedRows()).map((managed) => managed.row);
 
   const rows: TableRow[] = [];
   assistants.forEach((entry, i) => {
     rows.push(formatAssistantListRow(entry, activeAssistantId, healths[i]!));
-    rows.push(...(nestedByAssistant.get(entry.assistantId) ?? []));
   });
-  rows.push(...unattributed);
+  rows.push(...rootRows);
   return rows;
 }
 

package/src/commands/teleport.ts

@@ -185,7 +185,6 @@ function printHelp(): void {
 
 export function parseArgs(argv: string[]): {
   from: string | undefined;
-  to: string | undefined;
   targetEnv: "local" | "docker" | "platform" | undefined;
   targetName: string | undefined;
   keepSource: boolean;
@@ -193,7 +192,6 @@ export function parseArgs(argv: string[]): {
   help: boolean;
 } {
   let from: string | undefined;
-  let to: string | undefined;
   let targetEnv: "local" | "docker" | "platform" | undefined;
   let targetName: string | undefined;
   let keepSource = false;
@@ -209,11 +207,6 @@ export function parseArgs(argv: string[]): {
         continue;
       }
       from = argv[++i];
-    } else if (arg === "--to" && i + 1 < argv.length) {
-      if (argv[i + 1].startsWith("--")) {
-        continue;
-      }
-      to = argv[++i];
     } else if (
       arg === "--local" ||
       arg === "--docker" ||
@@ -242,7 +235,7 @@ export function parseArgs(argv: string[]): {
     process.exit(1);
   }
 
-  return { from, to, targetEnv, targetName, keepSource, dryRun, help };
+  return { from, targetEnv, targetName, keepSource, dryRun, help };
 }
 
 // ---------------------------------------------------------------------------
@@ -1253,7 +1246,6 @@ async function tryInjectCloudCredentials(
       bearerToken: entry.bearerToken,
       assistantApiKey,
       cloudAssistantId: registration.assistant.id,
-      cloudBaseUrl: cloudUrl,
       organizationId: orgId,
       userId: user.id,
       webhookSecret: registration.webhook_secret,
@@ -1277,7 +1269,7 @@ async function tryInjectCloudCredentials(
 export const teleport = Object.assign(
   async function teleport(): Promise<void> {
   const args = process.argv.slice(3);
-  const { from, to, targetEnv, targetName, keepSource, dryRun, help } =
+  const { from, targetEnv, targetName, keepSource, dryRun, help } =
     parseArgs(args);
 
   if (help) {
@@ -1285,17 +1277,6 @@ export const teleport = Object.assign(
     process.exit(0);
   }
 
-  // Legacy --to flag deprecation
-  if (to) {
-    console.error("Error: --to is deprecated. Use environment flags instead:");
-    console.error(
-      "  cadet teleport --from <source> --local|--docker|--platform [name]",
-    );
-    console.error("");
-    console.error("Run 'cadet teleport --help' for details.");
-    process.exit(1);
-  }
-
   if (!from) {
     printHelp();
     process.exit(1);