@mycadet/cli 0.12.7 → 0.12.8

package/src/__tests__/pair.test.ts

@@ -20,14 +20,7 @@ const originalEnvironment = process.env.CADET_ENVIRONMENT;
 process.env.CADET_ENVIRONMENT = "production";
 
 import { buildAppConnectUrl, pair } from "../commands/pair.js";
-
-// bun-types' global fetch carries a `preconnect` member; these mocks only need
-// the call shape, so hand the assignment a member-complete callable.
-function withPreconnect(
-  impl: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>,
-): typeof fetch {
-  return Object.assign(impl, { preconnect: () => {} });
-}
+import { withPreconnect } from "./helpers/http.js";
 
 // Distinct loopback (mint) vs reachable (advertised) URLs to verify the split.
 const LOCAL_URL = "http://127.0.0.1:7830";

package/src/__tests__/{ps-platform-status.test.ts → ps-cloud-status.test.ts}

@@ -26,12 +26,16 @@ process.env.CADET_LOCKFILE_DIR = testDir;
 import * as assistantConfig from "../lib/assistant-config.js";
 import * as healthCheck from "../lib/health-check.js";
 import * as orphanDetection from "../lib/orphan-detection.js";
-import * as platformClient from "../lib/platform-client.js";
+import * as cloudClient from "../lib/cloud-client.js";
 
 const loadAllAssistantsMock = spyOn(
   assistantConfig,
   "loadAllAssistants",
 ).mockReturnValue([]);
+const readRootProcessesMock = spyOn(
+  assistantConfig,
+  "readRootProcesses",
+).mockReturnValue({});
 const getActiveAssistantMock = spyOn(
   assistantConfig,
   "getActiveAssistant",
@@ -40,31 +44,31 @@ const detectOrphanedProcessesMock = spyOn(
   orphanDetection,
   "detectOrphanedProcesses",
 ).mockResolvedValue([]);
-const getPlatformUrlMock = spyOn(
-  platformClient,
-  "getPlatformUrl",
+const getCloudUrlMock = spyOn(
+  cloudClient,
+  "getCloudUrl",
 ).mockReturnValue("http://platform.test");
 
-// Per-test toggle for `readPlatformToken`.
-const readPlatformTokenMock = spyOn(
-  platformClient,
-  "readPlatformToken",
+// Per-test toggle for `readCloudToken`.
+const readCloudTokenMock = spyOn(
+  cloudClient,
+  "readCloudToken",
 ).mockReturnValue(null);
 
-// `fetchCurrentUser` + `fetchPlatformAssistants` are spied so we can assert
+// `fetchCurrentUser` + `fetchCloudAssistants` are spied so we can assert
 // they're never invoked on the no-token path, and re-shaped per-test for the
 // token-but-unreachable path.
 const fetchCurrentUserMock = spyOn(
-  platformClient,
+  cloudClient,
   "fetchCurrentUser",
 ).mockResolvedValue({
   id: "u1",
   email: "test@example.com",
   display: "Test",
 });
-const fetchPlatformAssistantsMock = spyOn(
-  platformClient,
-  "fetchPlatformAssistants",
+const fetchCloudAssistantsMock = spyOn(
+  cloudClient,
+  "fetchCloudAssistants",
 ).mockResolvedValue([]);
 const checkManagedHealthMock = spyOn(
   healthCheck,
@@ -99,33 +103,36 @@ beforeEach(() => {
   }) as typeof process.stdout.write;
 });
 
+const NL = String.fromCharCode(10);
+
 afterEach(() => {
   console.log = originalLog;
   console.error = originalError;
   process.stdout.write = originalStdoutWrite;
   loadAllAssistantsMock.mockReturnValue([]);
   getActiveAssistantMock.mockReturnValue(null);
-  readPlatformTokenMock.mockReturnValue(null);
+  readCloudTokenMock.mockReturnValue(null);
   fetchCurrentUserMock.mockReset();
   fetchCurrentUserMock.mockResolvedValue({
     id: "u1",
     email: "test@example.com",
     display: "Test",
   });
-  fetchPlatformAssistantsMock.mockReset();
-  fetchPlatformAssistantsMock.mockResolvedValue([]);
+  fetchCloudAssistantsMock.mockReset();
+  fetchCloudAssistantsMock.mockResolvedValue([]);
   checkManagedHealthMock.mockReset();
   checkManagedHealthMock.mockResolvedValue({ status: "healthy", detail: null });
+  readRootProcessesMock.mockReturnValue({});
 });
 
 afterAll(() => {
   loadAllAssistantsMock.mockRestore();
   getActiveAssistantMock.mockRestore();
   detectOrphanedProcessesMock.mockRestore();
-  getPlatformUrlMock.mockRestore();
-  readPlatformTokenMock.mockRestore();
+  getCloudUrlMock.mockRestore();
+  readCloudTokenMock.mockRestore();
   fetchCurrentUserMock.mockRestore();
-  fetchPlatformAssistantsMock.mockRestore();
+  fetchCloudAssistantsMock.mockRestore();
   checkManagedHealthMock.mockRestore();
   rmSync(testDir, { recursive: true, force: true });
 });
@@ -142,7 +149,7 @@ import { listAllAssistants } from "../commands/ps.js";
 
 describe("cadet ps — platform status line", () => {
   test("no local token: no login-status line, skips ALL network fetches", async () => {
-    readPlatformTokenMock.mockReturnValue(null);
+    readCloudTokenMock.mockReturnValue(null);
 
     await listAllAssistants(false);
 
@@ -155,20 +162,20 @@ describe("cadet ps — platform status line", () => {
       false,
     );
 
-    // Structural guarantee: we never even tried to talk to the platform.
+    // Structural guarantee: we never even tried to talk to the cloud.
     expect(fetchCurrentUserMock).not.toHaveBeenCalled();
-    expect(fetchPlatformAssistantsMock).not.toHaveBeenCalled();
+    expect(fetchCloudAssistantsMock).not.toHaveBeenCalled();
   });
 
   test("local token present but platform is unreachable: no status line, no leaked org-fetch error", async () => {
-    readPlatformTokenMock.mockReturnValue("session_abc123");
+    readCloudTokenMock.mockReturnValue("session_abc123");
     // Simulate the exact Bun connect failure the user reported:
     //   "Unable to connect. Is the computer able to access the url?"
     const connectError = new Error(
       "Unable to connect. Is the computer able to access the url?",
     );
     fetchCurrentUserMock.mockRejectedValue(connectError);
-    fetchPlatformAssistantsMock.mockRejectedValue(connectError);
+    fetchCloudAssistantsMock.mockRejectedValue(connectError);
 
     await listAllAssistants(false);
 
@@ -183,13 +190,13 @@ describe("cadet ps — platform status line", () => {
   });
 
   test("local token present and platform reachable: no login-status line", async () => {
-    readPlatformTokenMock.mockReturnValue("session_abc123");
+    readCloudTokenMock.mockReturnValue("session_abc123");
     fetchCurrentUserMock.mockResolvedValue({
       id: "u1",
       email: "user@example.com",
       display: "Example User",
     });
-    fetchPlatformAssistantsMock.mockResolvedValue([]);
+    fetchCloudAssistantsMock.mockResolvedValue([]);
 
     await listAllAssistants(false);
 
@@ -217,6 +224,52 @@ describe("cadet ps — platform status line", () => {
     }
   });
 
+  test("CLI-managed root processes nest under the assistant they front", async () => {
+    loadAllAssistantsMock.mockReturnValue([
+      {
+        assistantId: "assistant-123",
+        name: "Alice",
+        runtimeUrl: "https://platform.example",
+        cloud: "cadet",
+      },
+      {
+        assistantId: "assistant-456",
+        name: "Bob",
+        runtimeUrl: "https://platform.example/b",
+        cloud: "cadet",
+      },
+    ]);
+    getActiveAssistantMock.mockReturnValue(null);
+    checkManagedHealthMock.mockImplementation(async () => ({
+      status: "healthy",
+      detail: null,
+    }));
+    // The tunnel fronts Alice (recorded id); the edge records no assistant.
+    readRootProcessesMock.mockReturnValue({
+      tunnel: {
+        pid: 4242,
+        provider: "ngrok",
+        startedAt: "2026-10-11T00:00:00.000Z",
+        assistantId: "assistant-123",
+      },
+      app: { pid: 77, startedAt: "2026-10-11T00:00:00.000Z" },
+    });
+
+    await listAllAssistants(false);
+
+    const output = stdout.join(NL);
+    // The tunnel nests under Alice — its name is just the provider now…
+    expect(output).toContain("└ ngrok");
+    // …the unattributed edge renders machine-level…
+    expect(output).toContain("nginx edge");
+    // …the type column distinguishes the three process kinds…
+    expect(output).toContain("🧑‍🚀 Assistant");
+    expect(output).toContain("🚇 Tunnel");
+    expect(output).toContain("🌐 App");
+    // …and the second table is gone: one header row only.
+    expect(output.match(/NAME/g)?.length).toBe(1);
+  });
+
   test("assistant rows use display name as primary label and keep id visible", async () => {
     loadAllAssistantsMock.mockReturnValue([
       {

package/src/__tests__/{recover.test.ts → restore.test.ts}

@@ -61,7 +61,7 @@ afterAll(() => {
   mock.module("../lib/step-runner.js", () => ({ exec: realExec }));
 });
 
-import { recover } from "../commands/recover.js";
+import { restore } from "../commands/restore.js";
 
 // ── Test fixtures ─────────────────────────────────────────────────────────────
 
@@ -175,18 +175,19 @@ afterAll(() => {
 
 // ── Tests ─────────────────────────────────────────────────────────────────────
 
-describe("recover --help", () => {
+describe("restore --help", () => {
   test("prints usage, description, and examples then exits 0", async () => {
-    process.argv = ["bun", "cadet", "recover", "--help"];
-    await expect(recover()).rejects.toThrow("process.exit(0)");
+    process.argv = ["bun", "cadet", "restore", "--help"];
+    await expect(restore()).rejects.toThrow("process.exit(0)");
     const output = consoleLogSpy.mock.calls.flat().join("\n");
-    expect(output).toContain("Usage: cadet recover <name>");
+    expect(output).toContain("Usage: cadet restore <name>");
+    expect(output).toContain("recovers a retired assistant");
     expect(output).toContain("Examples:");
-    expect(output).toContain("cadet recover");
+    expect(output).toContain("cadet restore");
   });
 });
 
-describe("recover error cases", () => {
+describe("restore error cases", () => {
   for (const failure of ["missing", "conflict"] as const) {
     test(`recovery ${failure} leaves destination and registry untouched and permits retry`, async () => {
       const name = `retry-${failure}`;
@@ -211,8 +212,8 @@ describe("recover error cases", () => {
       }
       const registry = resolveLockfilePaths(process.env)[0]!;
       const before = readFileSync(registry, "utf8");
-      process.argv = ["bun", "cadet", "recover", name];
-      await expect(recover()).rejects.toThrow(`signing key ${failure}`);
+      process.argv = ["bun", "cadet", "restore", name];
+      await expect(restore()).rejects.toThrow(`signing key ${failure}`);
       expect(existsSync(instanceDir)).toBe(false);
       expect(readFileSync(registry, "utf8")).toBe(before);
       expect(existsSync(archivePath)).toBe(true);
@@ -222,7 +223,7 @@ describe("recover error cases", () => {
       // Restore the authoritative identity in the archive metadata and retry.
       entry.resources!.signingKey = "ab".repeat(32);
       writeFileSync(metadataPath, JSON.stringify(entry));
-      await recover();
+      await restore();
       expect(existsSync(instanceDir)).toBe(true);
       expect(existsSync(archivePath)).toBe(false);
       expect(startGatewayMock).toHaveBeenCalledTimes(1);
@@ -241,8 +242,8 @@ describe("recover error cases", () => {
       join(dir, "actor-token-signing-key"),
       Buffer.from("cd".repeat(32), "hex"),
     );
-    process.argv = ["bun", "cadet", "recover", name];
-    await recover();
+    process.argv = ["bun", "cadet", "restore", name];
+    await restore();
     expect(startGatewayMock).toHaveBeenCalledWith(
       false,
       expect.objectContaining({ signingKey: "cd".repeat(32) }),
@@ -256,8 +257,8 @@ describe("recover error cases", () => {
     const entry = makeEntry(name, join(testDir, "cadet", "assistants", name));
     delete entry.resources!.signingKey;
     const { archivePath, metadataPath } = writeArchiveFixtures(name, entry);
-    process.argv = ["bun", "cadet", "recover", name];
-    await expect(recover()).rejects.toThrow("signing key missing");
+    process.argv = ["bun", "cadet", "restore", name];
+    await expect(restore()).rejects.toThrow("signing key missing");
     expect(existsSync(archivePath)).toBe(true);
     expect(existsSync(metadataPath)).toBe(true);
     expect(startLocalDaemonMock).not.toHaveBeenCalled();
@@ -265,14 +266,14 @@ describe("recover error cases", () => {
   });
 
   test("exits 1 when no name is given", async () => {
-    process.argv = ["bun", "cadet", "recover"];
-    await expect(recover()).rejects.toThrow("process.exit(1)");
-    expect(consoleErrorSpy.mock.calls[0][0]).toContain("Usage:");
+    process.argv = ["bun", "cadet", "restore"];
+    await expect(restore()).rejects.toThrow("process.exit(1)");
+    expect(consoleErrorSpy.mock.calls[0][0]).toContain("<name> is required");
   });
 
   test("exits 1 when archive is missing", async () => {
-    process.argv = ["bun", "cadet", "recover", "ghost-assistant"];
-    await expect(recover()).rejects.toThrow("process.exit(1)");
+    process.argv = ["bun", "cadet", "restore", "ghost-assistant"];
+    await expect(restore()).rejects.toThrow("process.exit(1)");
     expect(consoleErrorSpy.mock.calls[0][0]).toContain(
       "No retired archive found for 'ghost-assistant'",
     );
@@ -292,8 +293,8 @@ describe("recover error cases", () => {
       join(retiredDir, `${name}.json`),
       JSON.stringify(entry, null, 2) + "\n",
     );
-    process.argv = ["bun", "cadet", "recover", name];
-    await expect(recover()).rejects.toThrow("missing resource configuration");
+    process.argv = ["bun", "cadet", "restore", name];
+    await expect(restore()).rejects.toThrow("missing resource configuration");
   });
 
   test("exits 1 when target .cadet/ already exists", async () => {
@@ -303,13 +304,13 @@ describe("recover error cases", () => {
     writeArchiveFixtures(name, entry);
     // Pre-create the collision path that recover checks
     mkdirSync(join(instanceDir, ".cadet"), { recursive: true });
-    process.argv = ["bun", "cadet", "recover", name];
-    await expect(recover()).rejects.toThrow("process.exit(1)");
+    process.argv = ["bun", "cadet", "restore", name];
+    await expect(restore()).rejects.toThrow("process.exit(1)");
     expect(consoleErrorSpy.mock.calls[0][0]).toContain("already exists");
   });
 });
 
-describe("recover extraction path — named instance (instanceDir !== homedir())", () => {
+describe("archive-recovery extraction path — named instance (instanceDir !== homedir())", () => {
   test("extracts to retiredDir and renames staging dir to instanceDir directly", async () => {
     const name = "named-instance";
     const instanceDir = join(testDir, "custom-location", name);
@@ -321,8 +322,8 @@ describe("recover extraction path — named instance (instanceDir !== homedir())
     // Parent dir must exist for renameSync
     mkdirSync(join(testDir, "custom-location"), { recursive: true });
 
-    process.argv = ["bun", "cadet", "recover", name];
-    await recover();
+    process.argv = ["bun", "cadet", "restore", name];
+    await restore();
 
     // exec must have been called with -C retiredDir
     expect(execMock).toHaveBeenCalledTimes(1);
@@ -355,8 +356,8 @@ describe("recover extraction path — named instance (instanceDir !== homedir())
     const entry = makeEntry(name, instanceDir);
     const { archivePath, extractedPath } = writeArchiveFixtures(name, entry);
 
-    process.argv = ["bun", "cadet", "recover", name];
-    await recover();
+    process.argv = ["bun", "cadet", "restore", name];
+    await restore();
 
     expect(existsSync(extractedPath)).toBe(false);
     expect(existsSync(instanceDir)).toBe(true);