@mycadet/cli 0.12.10 → 0.13.0

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

@@ -51,6 +51,10 @@ mock.module("node:fs", () => ({
   readFileSync: readFileSyncMock,
 }));
 
+const fetchCurrentVersionMock = mock<typeof httpClient.fetchCurrentVersion>(
+  async () => "1.2.3",
+);
+
 const waitForDaemonReadyMock = mock<typeof httpClient.waitForDaemonReady>(
   async () => true,
 );
@@ -58,6 +62,7 @@ const waitForDaemonReadyMock = mock<typeof httpClient.waitForDaemonReady>(
 mock.module("../lib/http-client.js", () => ({
   ...httpClient,
   waitForDaemonReady: waitForDaemonReadyMock,
+  fetchCurrentVersion: fetchCurrentVersionMock,
 }));
 
 // Restore the real modules once this file finishes so the mocks do not leak
@@ -72,10 +77,10 @@ import {
   buildIngressNginxConfig,
   hasIpv6Loopback,
   buildRemoteWebIndexHtml,
-  cloudWebHubUrl,
   MAX_PRESERVED_MODULE_PRELOADS,
   ensureTunnelEdge,
   EDGE_TEMPLATE_VERSION,
+  findWebDistDir,
   startRemoteWebIngress,
   stopContainerTunnelEdge,
   stopIngressNginx,
@@ -123,6 +128,8 @@ afterEach(() => {
   existsSyncMock.mockImplementation(realFs.existsSync);
   readFileSyncMock.mockReset();
   readFileSyncMock.mockImplementation(realFs.readFileSync);
+  fetchCurrentVersionMock.mockReset();
+  fetchCurrentVersionMock.mockImplementation(async () => "1.2.3");
   waitForDaemonReadyMock.mockReset();
   waitForDaemonReadyMock.mockImplementation(async () => true);
   for (const dir of workspaces.splice(0)) {
@@ -306,7 +313,7 @@ describe("buildIngressNginxConfig", () => {
     ).toEqual([]);
   });
 
-  test("revalidates the shell and forbids storing only the inline config", () => {
+  test("revalidates the shell and forbids storing inline config", () => {
     const blocks = locationBlocks(remoteConf);
     const cacheControlOf = (matcher: string) =>
       blocks
@@ -317,11 +324,8 @@ describe("buildIngressNginxConfig", () => {
     expect(cacheControlOf("^~ /assistant/assets/")).toBe(
       "public, max-age=31536000, immutable",
     );
-    // Only the inline __config return, which nginx gives no validator, still
-    // refuses storage. A second no-store means a revalidating location
-    // regressed to re-sending its whole body on every load.
+    // Inline config has no validator and must not be stored.
     expect(cacheControlOf("= /assistant/__config")).toBe("no-store");
-    expect(remoteConf.match(/no-store/g)).toHaveLength(1);
   });
 
   test("serves remote web config for the SPA", () => {
@@ -456,9 +460,7 @@ describe("buildRemoteWebIndexHtml", () => {
     expect(result).toContain(
       'window.__CADET_CONFIG__={"remote":"docker","apiBaseUrl":"/v1"}',
     );
-    expect(result.indexOf('"webUrl"')).toBeLessThan(
-      result.indexOf('"docker"'),
-    );
+    expect(result.indexOf('"webUrl"')).toBeLessThan(result.indexOf('"docker"'));
   });
 
   test("escapes config JSON before embedding it in a script tag", () => {
@@ -528,26 +530,6 @@ describe("buildRemoteWebIndexHtml", () => {
   });
 });
 
-describe("cloudWebHubUrl", () => {
-  test("maps build environments to their cloud SPA base", () => {
-    expect(cloudWebHubUrl("production")).toBe(
-      "https://mycadet.ai/assistant",
-    );
-    expect(cloudWebHubUrl("staging")).toBe(
-      "https://staging.mycadet.ai/assistant",
-    );
-    expect(cloudWebHubUrl("dev")).toBe(
-      "https://dev.mycadet.ai/assistant",
-    );
-    expect(cloudWebHubUrl("local")).toBe(
-      "https://dev.mycadet.ai/assistant",
-    );
-    expect(cloudWebHubUrl(undefined)).toBe(
-      "https://dev.mycadet.ai/assistant",
-    );
-  });
-});
-
 describe("nginx ingress process state", () => {
   function writeIngressState(workspaceDir: string, listenPort: number): void {
     writeFileSync(
@@ -755,17 +737,19 @@ function mockWebDistMissing(): void {
 }
 
 /** Force findWebDistDir() to resolve a dist dir, regardless of checkout state. */
-function mockWebDistPresent(): void {
+function mockWebDistPresent(version: string | null = "1.2.3"): void {
   existsSyncMock.mockImplementation((path) =>
     String(path).endsWith(WEB_INDEX_SUFFIX) ? true : realFs.existsSync(path),
   );
   readFileSyncMock.mockImplementation(((path, options) =>
     String(path).endsWith(WEB_INDEX_SUFFIX)
       ? FAKE_INDEX_HTML
-      : realFs.readFileSync(
-          path as never,
-          options as never,
-        )) as typeof readFileSync);
+      : String(path).endsWith("release.json")
+        ? JSON.stringify(version === null ? {} : { version })
+        : realFs.readFileSync(
+            path as never,
+            options as never,
+          )) as typeof readFileSync);
 }
 
 /** Record a running edge: ingress state, live pidfile, matching ps output. */
@@ -846,14 +830,19 @@ const PRODUCTION_HUB_URL = "https://mycadet.ai/assistant";
 
 /**
  * Mirror of the SPA config fingerprint the edge records in its ingress state
- * (sha256 over the edge template version and the injected config JSON). Pins
+ * (sha256 over the template, injected config, bundle directory and index). Pins
  * both the injected config shape and the hash format; assumes the
  * production-pinned environment. The version itself is imported rather than
  * mirrored: bumping it is the correct response to any template edit, so a
  * copy here would fail every such edit without naming a defect.
  */
 function spaConfigHash(
-  opts: { assistantName?: string; assistantId?: string } = {},
+  opts: {
+    assistantName?: string;
+    assistantId?: string;
+    indexHtml?: string;
+    webDistDir?: string;
+  } = {},
 ): string {
   return createHash("sha256")
     .update(
@@ -866,6 +855,9 @@ function spaConfigHash(
           ...(opts.assistantId ? { assistantId: opts.assistantId } : {}),
           hubUrl: PRODUCTION_HUB_URL,
         },
+        webDistDir: opts.webDistDir ?? findWebDistDir(),
+        version: "1.2.3",
+        indexHtml: opts.indexHtml ?? FAKE_INDEX_HTML,
       }),
     )
     .digest("hex");
@@ -890,6 +882,70 @@ function pinProductionEnvironment(): void {
 describe("startRemoteWebIngress", () => {
   pinProductionEnvironment();
 
+  for (const [webVersion, runtimeVersion, ready] of [
+    ["1.2.3", "1.2.3", true],
+    ["1.2.3", "v1.2.3", true],
+    ["1.2.2", "1.2.3", false],
+    ["1.2.3", undefined, false],
+    [null, "1.2.3", false],
+  ] as const) {
+    test(`release resolution: UI ${webVersion}, assistant ${runtimeVersion}`, async () => {
+      const ws = makeWorkspace();
+      mockNginxInstalled();
+      mockNginxSpawn();
+      mockWebDistPresent(webVersion);
+      fetchCurrentVersionMock.mockResolvedValue(runtimeVersion);
+      const result = await startRemoteWebIngress({
+        workspaceDir: ws,
+        gatewayPort: 7830,
+        listenPort: 7845,
+        assistantId: "assistant-1",
+      });
+      expect(result.status).toBe("started");
+      expect(fetchCurrentVersionMock).toHaveBeenCalledWith(
+        "http://127.0.0.1:7830",
+      );
+      const conf = realFs.readFileSync(ingressConfPath(ws), "utf8");
+      const detail = conf
+        .split('location = "/v1/assistants/assistant-1/" {')[1]
+        ?.split("\n    }")[0];
+      expect(detail).toContain(`return ${ready ? 200 : 409} `);
+      if (ready) {
+        expect(detail).toContain('\\"version\\":\\"1.2.3\\"');
+      } else {
+        expect(detail).not.toContain('\\"url\\"');
+      }
+    });
+  }
+
+  test("restarts an edge when its verified assistant/UI release changes", async () => {
+    const ws = makeWorkspace();
+    mockNginxInstalled();
+    mockNginxSpawn();
+    mockWebDistPresent("1.2.3");
+    fetchCurrentVersionMock.mockResolvedValue("1.2.4");
+    const pid = mockRunningEdge(ws, {
+      listenPort: 7845,
+      includeWebApp: true,
+      gatewayPort: 7830,
+      remoteWebConfigHash: spaConfigHash({ assistantId: "assistant-1" }),
+    });
+    const edge = mockKillableNginx(pid);
+    const result = await startRemoteWebIngress({
+      workspaceDir: ws,
+      gatewayPort: 7830,
+      listenPort: 7845,
+      assistantId: "assistant-1",
+    });
+    expect(result.status).toBe("started");
+    expect(edge.killed()).toBe(true);
+    const conf = realFs.readFileSync(ingressConfPath(ws), "utf8");
+    const detail = conf
+      .split('location = "/v1/assistants/assistant-1/" {')[1]
+      ?.split("\n    }")[0];
+    expect(detail).toContain("return 409 ");
+  });
+
   test("webhooks-only mode starts the denylist+proxy edge without a web dist", async () => {
     const ws = makeWorkspace();
     mockNginxInstalled();
@@ -1247,6 +1303,7 @@ describe("startRemoteWebIngress", () => {
     const ws = makeWorkspace();
     mockNginxInstalled();
     mockNginxSpawn();
+    mockWebDistPresent();
     const pid = mockRunningEdge(ws, {
       listenPort: 7845,
       gatewayPort: 7830,
@@ -1300,6 +1357,44 @@ describe("startRemoteWebIngress", () => {
     expect(spawnMock).not.toHaveBeenCalled();
   });
 
+  for (const drift of ["indexHtml", "webDistDir"] as const) {
+    test(`restarts a detached edge when the web bundle ${drift} changes`, async () => {
+      const ws = makeWorkspace();
+      mockNginxInstalled();
+      mockNginxSpawn();
+      mockWebDistPresent();
+      const pid = mockRunningEdge(ws, {
+        listenPort: 7845,
+        includeWebApp: true,
+        gatewayPort: 7830,
+        remoteWebConfigHash: spaConfigHash({
+          ...(drift === "indexHtml"
+            ? {
+                indexHtml:
+                  '<html><head><script src="/assistant/assets/old.js"></script></head></html>',
+              }
+            : { webDistDir: "/old-release/dist" }),
+        }),
+      });
+      const edge = mockKillableNginx(pid);
+      const result = await startRemoteWebIngress({
+        workspaceDir: ws,
+        gatewayPort: 7830,
+      });
+      expect(result).toMatchObject({ status: "started", listenPort: 7845 });
+      expect(edge.killed()).toBe(true);
+      expect(readConfig(ws).ingress?.nginx?.remoteWebConfigHash).toBe(
+        spaConfigHash(),
+      );
+      expect(
+        realFs.readFileSync(
+          join(ws, "data", "ingress", "assistant-index.html"),
+          "utf-8",
+        ),
+      ).not.toContain("old.js");
+    });
+  }
+
   test("restarts the edge when the injected SPA config drifts from the recorded one", async () => {
     const ws = makeWorkspace();
     mockNginxInstalled();
@@ -1801,6 +1896,7 @@ describe("ensureTunnelEdge", () => {
     const ws = makeWorkspace();
     mockNginxInstalled();
     mockNginxSpawn();
+    mockWebDistPresent();
     const pid = mockRunningEdge(ws, {
       listenPort: 7845,
       includeWebApp: true,
@@ -2223,3 +2319,104 @@ describe("stopContainerTunnelEdge", () => {
     expect(await stopContainerTunnelEdge(containerEntry(7930))).toBe(false);
   });
 });
+
+describe("assistant metadata API", () => {
+  function config(id = "assistant-1") {
+    return buildIngressNginxConfig({
+      gatewayPort: 7830,
+      listenPort: 7840,
+      remoteWebIngress: {
+        webDistDir: "/tmp/web",
+        version: "1.2.3",
+        assistantId: id,
+        assistantName: "My assistant",
+        config: { appAllowedOrigins: ["https://parent.example"] },
+      },
+    });
+  }
+  function body(conf: string, path: string, status = 200): unknown {
+    const location = conf
+      .split(`location = "${path}" {`)[1]
+      ?.split("\n    }")[0];
+    const value = location?.match(/return (200|409) ("(?:\\.|[^"\\])*");/);
+    expect(Number(value?.[1])).toBe(status);
+    if (!value) {
+      throw new Error(`Missing metadata for ${path}`);
+    }
+    return JSON.parse(JSON.parse(value[2]));
+  }
+  test("lists only this host's assistant and returns its actual UI version and URL", () => {
+    const conf = config();
+    expect(body(conf, "/v1/assistants/")).toEqual({
+      results: [{ id: "assistant-1", name: "My assistant" }],
+      next: null,
+    });
+    expect(body(conf, "/v1/assistants/assistant-1/")).toEqual({
+      id: "assistant-1",
+      name: "My assistant",
+      status: "active",
+      version: "1.2.3",
+      url: "assistant/",
+    });
+    expect(conf).not.toContain('location = "/v1/assistants/other/"');
+  });
+  test("metadata supports both slash forms and only read methods", () => {
+    const conf = config();
+    for (const path of [
+      "/v1/assistants",
+      "/v1/assistants/",
+      "/v1/assistants/assistant-1",
+      "/v1/assistants/assistant-1/",
+    ]) {
+      expect(body(conf, path)).toBeDefined();
+    }
+    expect(conf).toContain(
+      "if ($request_method !~ ^(GET|HEAD)$) { return 405; }",
+    );
+    expect(conf).toContain(
+      '"https://parent.example" "https://parent.example";',
+    );
+    expect(conf).toContain(
+      "add_header Access-Control-Allow-Origin $cadet_app_origin always;",
+    );
+  });
+  test("unknown identity yields an empty list without inventing an assistant ID", () => {
+    const conf = buildIngressNginxConfig({
+      gatewayPort: 7830,
+      listenPort: 7840,
+      remoteWebIngress: { webDistDir: "/tmp/web" },
+    });
+    expect(body(conf, "/v1/assistants/")).toEqual({ results: [], next: null });
+  });
+  test("a known assistant without a UI bundle returns 409 on both detail paths", () => {
+    const conf = buildIngressNginxConfig({
+      gatewayPort: 7830,
+      listenPort: 7840,
+      remoteWebIngress: { webDistDir: "/tmp/web", assistantId: "assistant-1" },
+    });
+    expect(body(conf, "/v1/assistants/")).toEqual({
+      results: [{ id: "assistant-1" }],
+      next: null,
+    });
+    for (const path of [
+      "/v1/assistants/assistant-1",
+      "/v1/assistants/assistant-1/",
+    ]) {
+      expect(body(conf, path, 409)).toEqual({
+        detail: "assistant is not ready",
+      });
+    }
+  });
+  test("invalid browser origins fail before nginx starts", () => {
+    expect(() =>
+      buildIngressNginxConfig({
+        gatewayPort: 7830,
+        listenPort: 7840,
+        remoteWebIngress: {
+          webDistDir: "/tmp/web",
+          config: { appAllowedOrigins: ["https://parent.example/path"] },
+        },
+      }),
+    ).toThrow("App origins");
+  });
+});

package/src/__tests__/orphan-detection.test.ts

@@ -107,7 +107,7 @@ describe("getKnownPidsFromAssistants", () => {
     const entry: AssistantEntry = {
       assistantId: "managed-1",
       runtimeUrl: "https://cloud.mycadet.ai/foo",
-      cloud: "cadet",
+      cloud: "cloud",
     };
     const pids = getKnownPidsFromAssistants([entry]);
     expect(pids.size).toBe(0);

package/src/__tests__/paired-lifecycle.test.ts

@@ -102,13 +102,13 @@ describe("paired lifecycle guards", () => {
     expect(errors).not.toContain("only works with local and docker");
   });
 
-  test("retire refuses a paired entry and points to unpair", async () => {
+  test("retire refuses a paired entry and points to the host", async () => {
     process.argv = ["bun", "cadet", "retire", "px", "--yes"];
     const { exited, errors } = await runGuarded(retire);
 
     expect(exited).toBe(true);
     expect(errors).toContain("paired from another machine");
-    expect(errors).toContain("cadet unpair");
+    expect(errors).toContain("cadet devices");
     // It must NOT fall through to the generic "Unknown cloud type" path.
     expect(errors).not.toContain("Unknown cloud type");
   });

package/src/__tests__/ps-cloud-status.test.ts

@@ -230,13 +230,13 @@ describe("cadet ps — platform status line", () => {
         assistantId: "assistant-123",
         name: "Alice",
         runtimeUrl: "https://platform.example",
-        cloud: "cadet",
+        cloud: "cloud",
       },
       {
         assistantId: "assistant-456",
         name: "Bob",
         runtimeUrl: "https://platform.example/b",
-        cloud: "cadet",
+        cloud: "cloud",
       },
     ]);
     getActiveAssistantMock.mockReturnValue(null);
@@ -262,7 +262,8 @@ describe("cadet ps — platform status line", () => {
     // children of an assistant row…
     expect(output).toContain("ngrok");
     expect(output).not.toContain("└ ngrok");
-    expect(output).toContain("nginx edge");
+    expect(output).toContain("nginx");
+    expect(output).toContain("port ");
     // …the type column distinguishes the three process kinds…
     expect(output).toContain("🧑‍🚀 Assistant");
     expect(output).toContain("🚇 Tunnel");
@@ -277,7 +278,7 @@ describe("cadet ps — platform status line", () => {
         assistantId: "assistant-123",
         name: "Alice",
         runtimeUrl: "https://platform.example",
-        cloud: "cadet",
+        cloud: "cloud",
       },
     ]);
     getActiveAssistantMock.mockReturnValue("assistant-123");
@@ -286,7 +287,7 @@ describe("cadet ps — platform status line", () => {
 
     const output = stdout.join("\n");
     expect(output).toContain("* Alice");
-    expect(output).toContain("remote: cadet");
+    expect(output).toContain("remote: cloud");
     expect(output).toContain("https://platform.example");
     expect(output).not.toContain("* assistant-123");
   });
@@ -297,13 +298,13 @@ describe("cadet ps — platform status line", () => {
         assistantId: "assistant-123",
         name: "Alice",
         runtimeUrl: "https://platform.example/a",
-        cloud: "cadet",
+        cloud: "cloud",
       },
       {
         assistantId: "assistant-456",
         name: "Bob",
         runtimeUrl: "https://platform.example/b",
-        cloud: "cadet",
+        cloud: "cloud",
       },
     ]);
     getActiveAssistantMock.mockReturnValue("assistant-123");