@mycadet/cli 0.12.8 → 0.12.9

package/node_modules/@mycadet/assistant-api/events/show-cloud-login.ts

@@ -1,5 +1,5 @@
 /**
- * `show_platform_login` SSE event.
+ * `show_cloud_login` SSE event.
  *
  * Emitted by the cloud-connect route when no cloud credentials are
  * stored yet, signalling connected clients to surface the cloud login UI.
@@ -12,7 +12,7 @@
 import { z } from "zod";
 
 export const ShowCloudLoginEventSchema = z.object({
-  type: z.literal("show_platform_login"),
+  type: z.literal("show_cloud_login"),
 });
 
 export type ShowCloudLoginEvent = z.infer<typeof ShowCloudLoginEventSchema>;

package/node_modules/@mycadet/assistant-api/node_modules/@mycadet/service-contracts/package.json

@@ -40,6 +40,6 @@
   },
   "devDependencies": {
     "@types/bun": "1.2.4",
-    "typescript": "5.7.3"
+    "typescript": "5.9.3"
   }
 }

package/node_modules/@mycadet/local-mode/node_modules/@mycadet/service-contracts/package.json

@@ -40,6 +40,6 @@
   },
   "devDependencies": {
     "@types/bun": "1.2.4",
-    "typescript": "5.7.3"
+    "typescript": "5.9.3"
   }
 }

package/node_modules/@mycadet/service-contracts/package.json

@@ -40,6 +40,6 @@
   },
   "devDependencies": {
     "@types/bun": "1.2.4",
-    "typescript": "5.7.3"
+    "typescript": "5.9.3"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mycadet/cli",
-  "version": "0.12.8",
+  "version": "0.12.9",
   "description": "CLI tools for mycadet",
   "type": "module",
   "exports": {
@@ -20,7 +20,7 @@
   "scripts": {
     "format": "prettier --write .",
     "format:check": "prettier --check .",
-    "lint": "eslint --max-warnings 323",
+    "lint": "eslint --max-warnings 322",
     "lint:unused": "knip --include files,dependencies,unlisted",
     "compile:check": "bun build --compile src/index.ts --outfile /dev/null",
     "test": "bun run scripts/run-tests.ts",

package/src/__tests__/cloud-releases.test.ts

@@ -7,7 +7,11 @@ import {
   resolveOwnImageRefs,
 } from "../lib/cloud-releases.js";
 import { dockerhubImages } from "../lib/docker.js";
-import { isDevVersion, isLocalVersion, isStagingVersion } from "../lib/version-compat.js";
+import {
+  isDevVersion,
+  isLocalVersion,
+  isStagingVersion,
+} from "../lib/version-compat.js";
 
 const originalFetch = globalThis.fetch;
 
@@ -79,12 +83,12 @@ describe("fetchReleases", () => {
 });
 
 describe("resolveImageRefs", () => {
-  test("released CLI resolves un-suffixed repos tagged with the target version", () => {
+  test("released CLI resolves un-suffixed repos tagged with the bare version", () => {
     const tags = resolveImageRefs("v0.12.6", "0.12.6");
-    expect(tags.assistant).toBe("mycadet/mycadet-assistant:v0.12.6");
-    expect(tags.gateway).toBe("mycadet/mycadet-gateway:v0.12.6");
+    expect(tags.assistant).toBe("mycadet/mycadet-assistant:0.12.6");
+    expect(tags.gateway).toBe("mycadet/mycadet-gateway:0.12.6");
     expect(tags["credential-executor"]).toBe(
-      "mycadet/mycadet-credential-executor:v0.12.6",
+      "mycadet/mycadet-credential-executor:0.12.6",
     );
   });
 
@@ -94,31 +98,32 @@ describe("resolveImageRefs", () => {
       "0.12.6-dev.202610081023.3a27b77",
     );
     expect(tags.assistant).toBe(
-      "mycadet/mycadet-assistant-dev:v0.12.6-dev.202610081023.3a27b77",
+      "mycadet/mycadet-assistant-dev:0.12.6-dev.202610081023.3a27b77",
     );
     expect(tags.gateway).toBe(
-      "mycadet/mycadet-gateway-dev:v0.12.6-dev.202610081023.3a27b77",
+      "mycadet/mycadet-gateway-dev:0.12.6-dev.202610081023.3a27b77",
     );
     expect(tags["credential-executor"]).toBe(
-      "mycadet/mycadet-credential-executor-dev:v0.12.6-dev.202610081023.3a27b77",
+      "mycadet/mycadet-credential-executor-dev:0.12.6-dev.202610081023.3a27b77",
     );
   });
 
   test("repo suffix follows the CLI version, tag follows the target", () => {
     const tags = resolveImageRefs("v0.12.5", "0.12.6-dev.202610081023.3a27b77");
-    expect(tags.assistant).toBe("mycadet/mycadet-assistant-dev:v0.12.5");
+    expect(tags.assistant).toBe("mycadet/mycadet-assistant-dev:0.12.5");
   });
 
   test("does not consult the network", async () => {
     mockFetchError();
     const tags = resolveImageRefs("v0.12.6", "0.12.6");
-    expect(tags.assistant).toContain(":v0.12.6");
+    expect(tags.assistant).toContain(":0.12.6");
   });
 
-  test("normalizes the v-prefix on the tag", () => {
+  test("normalizes the v-prefix off the tag", () => {
     const withoutPrefix = resolveImageRefs("0.12.6", "0.12.6");
     const withPrefix = resolveImageRefs("v0.12.6", "0.12.6");
-    expect(withoutPrefix.assistant).toBe(withPrefix.assistant);
+    expect(withoutPrefix.assistant).toBe("mycadet/mycadet-assistant:0.12.6");
+    expect(withPrefix.assistant).toBe(withoutPrefix.assistant);
   });
 });
 
@@ -126,9 +131,14 @@ describe("resolveOwnImageRefs", () => {
   test("uses the CLI's own version for both tag and repo suffix", () => {
     const tags = resolveOwnImageRefs("0.12.6-dev.202610081023.3a27b77");
     expect(tags.assistant).toBe(
-      "mycadet/mycadet-assistant-dev:v0.12.6-dev.202610081023.3a27b77",
+      "mycadet/mycadet-assistant-dev:0.12.6-dev.202610081023.3a27b77",
     );
   });
+
+  test("falls back to the literal latest tag when the CLI version is unknown", () => {
+    const tags = resolveOwnImageRefs("");
+    expect(tags.assistant).toBe("mycadet/mycadet-assistant:latest");
+  });
 });
 
 describe("dockerhubImages", () => {

package/src/__tests__/ensure-binary.test.ts

@@ -0,0 +1,182 @@
+import { describe, expect, test } from "bun:test";
+import { Readable, Writable } from "node:stream";
+
+import { ensureBinaryInstalled, readLineText } from "../lib/ensure-binary.js";
+
+/** A real Writable capturing everything written, as a test output stream. */
+function makeOutput(): { writable: Writable; text(): string } {
+  const captured: string[] = [];
+  const writable = new Writable({
+    write(chunk, _encoding, callback) {
+      captured.push(chunk.toString());
+      callback();
+    },
+  });
+  return { writable, text: () => captured.join("") };
+}
+
+describe("ensureBinaryInstalled", () => {
+  test("returns the existing probe result without prompting", async () => {
+    const output = makeOutput();
+    const version = await ensureBinaryInstalled({
+      binary: "nginx",
+      purpose: "the tunnel edge",
+      packages: { brew: ["brew", "install", "nginx"] },
+      manualHint: "install nginx",
+      probe: () => "nginx version 1.2",
+      confirmInstall: () => {
+        throw new Error("must not prompt for a present binary");
+      },
+      streams: { output: output.writable },
+    });
+    expect(version).toBe("nginx version 1.2");
+    expect(output.text()).toBe("");
+  });
+
+  test("offers to install and runs the first available package manager", async () => {
+    const output = makeOutput();
+    const installed: string[][] = [];
+    let probeCalls = 0;
+    const version = await ensureBinaryInstalled({
+      binary: "nginx",
+      purpose: "the tunnel edge",
+      packages: {
+        brew: ["brew", "install", "nginx"],
+        "apt-get": ["sudo", "apt-get", "install", "-y", "nginx"],
+      },
+      manualHint: "install nginx yourself",
+      probe: () => (++probeCalls > 1 ? "nginx version 1.2" : null),
+      pmAvailable: (pm) => pm === "apt-get",
+      runInstall: (argv) => {
+        installed.push(argv);
+        return true;
+      },
+      confirmInstall: async () => true,
+      streams: { output: output.writable },
+    });
+    expect(version).toBe("nginx version 1.2");
+    expect(installed).toEqual([["sudo", "apt-get", "install", "-y", "nginx"]]);
+    expect(output.text()).toContain("isn't installed");
+    expect(output.text()).not.toContain("apt-get install");
+  });
+
+  test("the default confirm takes Enter as yes", async () => {
+    const output = makeOutput();
+    const input = Object.assign(new Readable({ read() {} }), {
+      isTTY: true,
+    });
+    const installed: string[][] = [];
+    let probeCalls = 0;
+    const pending = ensureBinaryInstalled({
+      binary: "nginx",
+      purpose: "the tunnel edge",
+      packages: { brew: ["brew", "install", "nginx"] },
+      manualHint: "install nginx yourself",
+      probe: () => (++probeCalls > 1 ? "nginx version 1.2" : null),
+      pmAvailable: () => true,
+      runInstall: (argv) => {
+        installed.push(argv);
+        return true;
+      },
+      streams: { input, output: output.writable },
+    });
+    input.emit("data", "\n");
+    expect(await pending).toBe("nginx version 1.2");
+    expect(installed).toEqual([["brew", "install", "nginx"]]);
+    expect(output.text()).toContain("Install nginx now?");
+  });
+
+  test("a declined offer prints the manual hint and installs nothing", async () => {
+    const output = makeOutput();
+    let ran = false;
+    const version = await ensureBinaryInstalled({
+      binary: "ngrok",
+      purpose: "the ngrok tunnel",
+      packages: { brew: ["brew", "install", "ngrok/ngrok/ngrok"] },
+      manualHint: "get ngrok from ngrok.com",
+      probe: () => null,
+      runInstall: () => {
+        ran = true;
+        return true;
+      },
+      confirmInstall: async () => false,
+      streams: { output: output.writable },
+    });
+    expect(version).toBe(null);
+    expect(ran).toBe(false);
+    expect(output.text()).toContain("get ngrok from ngrok.com");
+  });
+
+  test("a failed install falls back to the manual hint", async () => {
+    const output = makeOutput();
+    const version = await ensureBinaryInstalled({
+      binary: "nginx",
+      purpose: "the tunnel edge",
+      packages: { brew: ["brew", "install", "nginx"] },
+      manualHint: "install nginx yourself",
+      probe: () => null,
+      runInstall: () => false,
+      confirmInstall: async () => true,
+      streams: { output: output.writable },
+    });
+    expect(version).toBe(null);
+    expect(output.text()).toContain("install nginx yourself");
+  });
+
+  test("no matching package manager prints the hint", async () => {
+    const output = makeOutput();
+    let ran = false;
+    const version = await ensureBinaryInstalled({
+      binary: "cloudflared",
+      purpose: "the cloudflare tunnel",
+      packages: { brew: ["brew", "install", "cloudflared"] },
+      manualHint: "cloudflared install docs",
+      probe: () => null,
+      pmAvailable: () => false,
+      runInstall: () => {
+        ran = true;
+        return true;
+      },
+      confirmInstall: async () => true,
+      streams: { output: output.writable },
+    });
+    expect(version).toBe(null);
+    expect(ran).toBe(false);
+    expect(output.text()).toContain("cloudflared install docs");
+  });
+
+  test("a non-interactive terminal declines instead of hanging", async () => {
+    const version = await ensureBinaryInstalled({
+      binary: "nginx",
+      purpose: "the tunnel edge",
+      packages: { brew: ["brew", "install", "nginx"] },
+      manualHint: "install nginx yourself",
+      probe: () => null,
+      confirmInstall: async () => {
+        throw new Error("Install confirm requires an interactive terminal.");
+      },
+    });
+    expect(version).toBe(null);
+  });
+});
+
+describe("readLineText", () => {
+  test("resolves the first line and ignores the rest", async () => {
+    const output = makeOutput();
+    const input = new Readable({ read() {} });
+    const pending = readLineText("token: ", {
+      input,
+      output: output.writable,
+    });
+    input.emit("data", "abc123\nsecond line\n");
+    expect(await pending).toBe("abc123");
+    expect(output.text()).toBe("token: ");
+  });
+
+  test("resolves an empty line on an immediate newline", async () => {
+    const input = new Readable({ read() {} });
+    const pending = readLineText("[Y/n] ", { input });
+    input.emit("data", "\n");
+    expect(await pending).toBe("");
+  });
+});

package/src/__tests__/nginx-ingress.test.ts

@@ -2095,8 +2095,9 @@ describe("ensureTunnelEdge", () => {
       gatewayPort: 7830,
     });
 
-    await expect(promise).rejects.toThrow("brew install nginx");
-    await expect(promise).rejects.toThrow("apt install nginx");
+    await expect(promise).rejects.toThrow(
+      "See https://nginx.org/en/docs/install.html for how to install",
+    );
     await expect(promise).rejects.toThrow("NGINX_BIN");
     expect(spawnMock).not.toHaveBeenCalled();
   });

package/src/__tests__/ngrok-spawn.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, test } from "bun:test";
+
+import { buildNgrokSpawnArgs, isNgrokAuthError } from "../lib/tunnels/ngrok.js";
+
+describe("buildNgrokSpawnArgs", () => {
+  test("spawns a plain http agent against the loopback edge", () => {
+    expect(buildNgrokSpawnArgs(7830)).toEqual([
+      "http",
+      "127.0.0.1:7830",
+      "--log=stdout",
+    ]);
+  });
+
+  test("never passes --config so the default (authtoken-bearing) config loads", () => {
+    const args = buildNgrokSpawnArgs(7830, "me.ngrok.app");
+    expect(args.some((arg) => arg.startsWith("--config"))).toBe(false);
+  });
+
+  test("binds a reserved domain when given", () => {
+    expect(buildNgrokSpawnArgs(7830, "my-assistant.ngrok.app")).toEqual([
+      "http",
+      "127.0.0.1:7830",
+      "--log=stdout",
+      "--domain=my-assistant.ngrok.app",
+    ]);
+  });
+});
+
+describe("isNgrokAuthError", () => {
+  test("recognizes the free-account authtoken requirement", () => {
+    expect(
+      isNgrokAuthError(
+        "FATAL: authentication failed: Usage of ngrok requires a free authtoken. ERR_NGROK_105",
+      ),
+    ).toBe(true);
+  });
+
+  test("recognizes an unauthorized token", () => {
+    expect(isNgrokAuthError("unauthorized authtoken ERR_NGROK_401")).toBe(true);
+  });
+
+  test("does not claim other startup failures are auth errors", () => {
+    expect(
+      isNgrokAuthError(
+        "creating tunnel session failed: dial tcp 3.219.x.x:443: connection refused",
+      ),
+    ).toBe(false);
+  });
+});

package/src/__tests__/ps-table.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, test } from "bun:test";
+
+import { displayWidth, formatRow } from "../commands/ps.js";
+
+describe("displayWidth", () => {
+  test("ascii strings count one cell per character", () => {
+    expect(displayWidth("healthy")).toBe(7);
+    expect(displayWidth("")).toBe(0);
+  });
+
+  test("emoji count two cells", () => {
+    expect(displayWidth("🟢")).toBe(2);
+    expect(displayWidth("🚀")).toBe(2);
+  });
+
+  test("the ZWJ astronaut sequence counts two cells, not its UTF-16 length", () => {
+    // "🧑‍🚀" is 5 UTF-16 units but renders 2 cells wide.
+    expect(displayWidth("🧑‍🚀 Assistant")).toBe(12);
+  });
+
+  test("a variation selector widens a narrow symbol to two cells", () => {
+    expect(displayWidth("⚠️ warn")).toBe(7);
+  });
+});
+
+describe("ps table alignment", () => {
+  const colWidths = { name: 15, type: 14, status: 10, info: 0 };
+
+  /** The terminal column where `marker` starts (string indices shift under
+   * emoji, which render 2 cells but span 2 UTF-16 units or more). */
+  const columnOf = (s: string, marker: string): number =>
+    displayWidth(s.slice(0, s.indexOf(marker)));
+
+  test("emoji cells keep every later column aligned", () => {
+    const emojiRow = formatRow(
+      {
+        name: "slim-yak",
+        type: "🧑‍🚀 Assistant",
+        status: "🟢 healthy",
+        info: "http://x",
+      },
+      colWidths,
+    );
+    const asciiRow = formatRow(
+      {
+        name: "plain",
+        type: "Assistant",
+        status: "healthy",
+        info: "http://y",
+      },
+      colWidths,
+    );
+    expect(columnOf(emojiRow, "http://x")).toBe(columnOf(asciiRow, "http://y"));
+  });
+
+  test("the header separator matches the emoji row's column starts", () => {
+    const widths = {
+      name: displayWidth("slim-yak-yhpdq6"),
+      type: displayWidth("🧑‍🚀 Assistant"),
+      status: displayWidth("🟢 healthy"),
+      info: 0,
+    };
+    const header = formatRow(
+      { name: "NAME", type: "TYPE", status: "STATUS", info: "INFO" },
+      widths,
+    );
+    const row = formatRow(
+      {
+        name: "slim-yak-yhpdq6",
+        type: "🧑‍🚀 Assistant",
+        status: "🟢 healthy",
+        info: "http://127.0.0.1:7830",
+      },
+      widths,
+    );
+    expect(columnOf(header, "TYPE")).toBe(columnOf(row, "🧑‍🚀"));
+    expect(columnOf(header, "STATUS")).toBe(columnOf(row, "🟢"));
+  });
+});

package/src/__tests__/tailscale.test.ts

@@ -79,7 +79,7 @@ function makeDeps(opts: {
   const calls: string[][] = [];
   const binary = opts.binary === undefined ? "tailscale" : opts.binary;
   const deps: TailscaleDeps = {
-    findBinary: () => binary,
+    findBinary: async () => binary,
     run: (_bin, args) => {
       calls.push(args);
       return opts.responses?.[args.join(" ")] ?? ok();

package/src/__tests__/teleport.test.ts

@@ -2821,7 +2821,7 @@ describe("auth + transient-error resilience", () => {
       await teleport();
       expect(pollCalls).toBeGreaterThanOrEqual(2);
       expect(warnSpy).toHaveBeenCalledWith(
-        expect.stringContaining("polling failed, retrying"),
+        expect.stringContaining("polling failed:"),
       );
     } finally {
       restoreFetch();

package/src/__tests__/tunnel.test.ts

@@ -84,9 +84,13 @@ const EDGE_PORT = 18080;
 const ensureTunnelEdgeMock = mock<typeof nginxIngress.ensureTunnelEdge>(
   async () => ({ port: EDGE_PORT, started: true, includesWebApp: true }),
 );
+const getNginxVersionMock = mock<typeof nginxIngress.getNginxVersion>(
+  () => "nginx version (test)",
+);
 mock.module("../lib/nginx-ingress.js", () => ({
   ...realNginxIngress,
   ensureTunnelEdge: ensureTunnelEdgeMock,
+  getNginxVersion: getNginxVersionMock,
 }));
 
 const { tunnel } = await import("../commands/tunnel.js");
@@ -324,7 +328,6 @@ describe("tunnel edge targeting", () => {
     });
     expect(runCloudflareTunnelMock).not.toHaveBeenCalled();
     expect(logs).toContain(`Started the nginx edge on 127.0.0.1:${EDGE_PORT}`);
-    expect(logs).toContain("serves remote web + webhooks");
   });
 
   test("the tunnel level notifies the gateway of the provider's public URL", async () => {
@@ -673,7 +676,6 @@ describe("tunnel edge targeting", () => {
       workspaceDir: join(entry.resources!.instanceDir, "workspace"),
     });
     expect(logs).toContain(`Reusing the nginx edge on 127.0.0.1:${EDGE_PORT}`);
-    expect(logs).toContain("serves webhooks only");
   });
 
   test("a bare invocation tunnels the default provider", async () => {
@@ -782,7 +784,7 @@ describe("tunnel edge targeting", () => {
     ensureTunnelEdgeMock.mockRejectedValue(
       new Error(
         "nginx is not installed, so the tunnel edge cannot start. " +
-          "Install it (macOS: `brew install nginx`, Linux: `sudo apt install nginx`) " +
+          "See https://nginx.org/en/docs/install.html for how to install, " +
           "or point NGINX_BIN at an existing binary.",
       ),
     );
@@ -790,7 +792,9 @@ describe("tunnel edge targeting", () => {
     const { exited, errors } = await runTunnelExpectingExit1();
 
     expect(exited).toBe(true);
-    expect(errors).toContain("brew install nginx");
+    expect(errors).toContain(
+      "See https://nginx.org/en/docs/install.html for how to install",
+    );
     expect(runNgrokTunnelMock).not.toHaveBeenCalled();
     expect(runCloudflareTunnelMock).not.toHaveBeenCalled();
     expect(runTailscaleTunnelMock).not.toHaveBeenCalled();
@@ -1139,13 +1143,14 @@ describe("ngrok --domain spawn args", () => {
     expect(spawnMock).toHaveBeenCalledTimes(1);
     const [cmd, args] = spawnMock.mock.calls[0];
     expect(cmd).toBe("ngrok");
+    // Plain `ngrok http` so the user's default config — where their
+    // authtoken lives — is what the agent loads.
     expect(args).toEqual([
-      "start",
-      "cadet",
-      `--config=${realNgrok.ngrokConfigPath()}`,
+      "http",
+      "127.0.0.1:7831",
       "--log=stdout",
+      "--domain=foo.ngrok.app",
     ]);
-    // The reserved domain rides the XDG config the agent loads, not a flag.
     expect(realNgrok.loadNgrokDomain()).toBe("foo.ngrok.app");
 
     const config = IngressTestConfigSchema.parse(
@@ -1430,11 +1435,13 @@ describe("ngrok --domain spawn args", () => {
     expect(spawnMock).toHaveBeenCalledTimes(1);
     const [cmd, args] = spawnMock.mock.calls[0];
     expect(cmd).toBe("ngrok");
+    // Plain `ngrok http` so the user's default config — where their
+    // authtoken lives — is what the agent loads.
     expect(args).toEqual([
-      "start",
-      "cadet",
-      `--config=${realNgrok.ngrokConfigPath()}`,
+      "http",
+      "127.0.0.1:7830",
       "--log=stdout",
+      "--domain=foo.ngrok.app",
     ]);
 
     const config = IngressTestConfigSchema.parse(
@@ -1469,10 +1476,10 @@ describe("ngrok --domain spawn args", () => {
     expect(spawnMock).toHaveBeenCalledTimes(1);
     const [, args] = spawnMock.mock.calls[0];
     expect(args).toEqual([
-      "start",
-      "cadet",
-      `--config=${realNgrok.ngrokConfigPath()}`,
+      "http",
+      "127.0.0.1:7831",
       "--log=stdout",
+      "--domain=foo.ngrok.app",
     ]);
 
     const config = IngressTestConfigSchema.parse(

package/src/__tests__/uninstall.test.ts

@@ -102,7 +102,7 @@ describe("cadet uninstall", () => {
         // not an assistant guard.
         await expect(uninstall()).rejects.toThrow("process.exit:1");
         expect(warnSpy).toHaveBeenCalledWith(
-          expect.stringContaining("1 assistant(s) still exist"),
+          expect.stringContaining("1 assistant still exists"),
         );
         expect(warnSpy).toHaveBeenCalledWith(
           expect.stringContaining("will be retired now"),

package/src/__tests__/wake.test.ts

@@ -1503,14 +1503,14 @@ describe("cadet wake — tunnel edge restore", () => {
     loadRawConfigMock.mockReturnValue(webhookConfig);
     ensureTunnelEdgeMock.mockRejectedValue(
       new Error(
-        "nginx is not installed, so the tunnel edge cannot start. Install it (macOS: `brew install nginx`, Linux: `sudo apt install nginx`) or point NGINX_BIN at an existing binary.",
+        "nginx is not installed, so the tunnel edge cannot start. See https://nginx.org/en/docs/install.html for how to install, or point NGINX_BIN at an existing binary.",
       ),
     );
 
     await wake();
 
     expect(warnSpy).toHaveBeenCalledWith(
-      expect.stringContaining("brew install nginx"),
+      expect.stringContaining("https://nginx.org/en/docs/install.html"),
     );
     // No tunnel is recorded here, so no provider can be named and the advice
     // points at the help that lists them.

package/src/commands/backup.ts

@@ -42,10 +42,10 @@ export const backup = Object.assign(
     console.log("Options:");
     console.log("  --output <path>          Path to save the .vbundle file");
     console.log(
-      "                           (default: ~/.local/share/cadet/backups/<name>-<timestamp>.vbundle)",
+      "                           defaults to ~/.local/share/cadet/backups/<name>-<timestamp>.vbundle",
     );
     console.log(
-      `  --export-timeout <secs>  Export request timeout in seconds (default: ${DEFAULT_EXPORT_TIMEOUT_MS / 1000})`,
+      `  --export-timeout <secs>  Export request timeout in seconds, defaults to ${DEFAULT_EXPORT_TIMEOUT_MS / 1000}`,
     );
     console.log("");
     console.log("Examples:");
@@ -254,7 +254,7 @@ async function backupPlatform(
   const cloudToken = readCloudToken();
   if (!cloudToken) {
     console.error(
-      "Not logged in. Run 'cadet login' first (required for cloud-managed backup).",
+      "Not logged in. Run 'cadet login' first.",
     );
     process.exit(1);
   }