@vellumai/cli 0.11.3-dev.202608172108.14b9345 → 0.11.3-dev.202608172253.65bf2a2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/cli",
-  "version": "0.11.3-dev.202608172108.14b9345",
+  "version": "0.11.3-dev.202608172253.65bf2a2",
   "description": "CLI tools for vellum-assistant",
   "type": "module",
   "exports": {

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

@@ -120,11 +120,11 @@ describe("up", () => {
     logSpy.mockRestore();
   });
 
-  test("starts the webhooks-only edge when the flag is off and states the mode", async () => {
+  test("starts the edge and states the remote web mode", async () => {
     ensureTunnelEdgeMock.mockResolvedValue({
-      port: 7845,
+      port: 7840,
       started: true,
-      includesWebApp: false,
+      includesWebApp: true,
     });
 
     await up({
@@ -139,28 +139,9 @@ describe("up", () => {
       workspaceDir,
       gatewayPort: 7830,
     });
-    const output = logs.join("\n");
-    expect(output).toContain("http://127.0.0.1:7845 (webhooks only)");
-    expect(output).toContain("web-remote-ingress");
-    expect(output).toContain("vellum tunnel --provider ngrok");
-  });
-
-  test("states the remote web mode when the flag is on", async () => {
-    ensureTunnelEdgeMock.mockResolvedValue({
-      port: 7840,
-      started: true,
-      includesWebApp: true,
-    });
-
-    await up({
-      assistantId: "assistant-1",
-      workspaceDir,
-      gatewayPort: 7830,
-    });
-
     const output = logs.join("\n");
     expect(output).toContain("http://127.0.0.1:7840 (remote web + webhooks)");
-    expect(output).not.toContain("Enable the web-remote-ingress feature flag");
+    expect(output).toContain("vellum tunnel --provider ngrok");
   });
 });
 

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

@@ -23,12 +23,10 @@ import {
   test,
 } from "bun:test";
 
-import * as featureFlags from "../lib/feature-flags.js";
 import * as httpClient from "../lib/http-client.js";
 
 const realChildProcess = { ...childProcess };
 const realFs = { ...fsModule };
-const realFeatureFlags = { ...featureFlags };
 const realHttpClient = { ...httpClient };
 
 const execFileSyncMock = mock(childProcess.execFileSync);
@@ -60,21 +58,11 @@ mock.module("../lib/http-client.js", () => ({
   waitForDaemonReady: waitForDaemonReadyMock,
 }));
 
-const isFeatureFlagEnabledMock = mock<
-  typeof featureFlags.isAssistantFeatureFlagEnabled
->(async () => true);
-
-mock.module("../lib/feature-flags.js", () => ({
-  ...featureFlags,
-  isAssistantFeatureFlagEnabled: isFeatureFlagEnabledMock,
-}));
-
 // Restore the real modules once this file finishes so the mocks do not leak
 // into sibling test files in the same `bun test` run.
 afterAll(() => {
   mock.module("node:child_process", () => realChildProcess);
   mock.module("node:fs", () => realFs);
-  mock.module("../lib/feature-flags.js", () => realFeatureFlags);
   mock.module("../lib/http-client.js", () => realHttpClient);
 });
 
@@ -132,8 +120,6 @@ afterEach(() => {
   readFileSyncMock.mockImplementation(realFs.readFileSync);
   waitForDaemonReadyMock.mockReset();
   waitForDaemonReadyMock.mockImplementation(async () => true);
-  isFeatureFlagEnabledMock.mockReset();
-  isFeatureFlagEnabledMock.mockImplementation(async () => true);
   for (const dir of workspaces.splice(0)) {
     rmSync(dir, { recursive: true, force: true });
   }
@@ -1617,7 +1603,7 @@ describe("ensureTunnelEdge", () => {
     expect(indexHtml).toContain(`"hubUrl":"${PRODUCTION_HUB_URL}"`);
   });
 
-  test("reuses a running edge that matches the flag-resolved mode", async () => {
+  test("reuses a running edge that already serves the SPA mode", async () => {
     const ws = makeWorkspace();
     mockNginxInstalled();
     mockNginxSpawn();
@@ -1644,34 +1630,6 @@ describe("ensureTunnelEdge", () => {
     expect(spawnMock).not.toHaveBeenCalled();
   });
 
-  test("reuses a running webhooks-only edge and reports the recorded mode", async () => {
-    const ws = makeWorkspace();
-    mockNginxInstalled();
-    mockNginxSpawn();
-    mockWebDistMissing();
-    isFeatureFlagEnabledMock.mockImplementation(async () => false);
-    const pid = mockRunningEdge(ws, {
-      listenPort: 7845,
-      includeWebApp: false,
-      gatewayPort: 7830,
-    });
-    const edge = mockKillableNginx(pid);
-
-    const result = await ensureTunnelEdge({
-      assistantId: ASSISTANT_ID,
-      workspaceDir: ws,
-      gatewayPort: 7830,
-    });
-
-    expect(result).toEqual({
-      port: 7845,
-      started: false,
-      includesWebApp: false,
-    });
-    expect(edge.killed()).toBe(false);
-    expect(spawnMock).not.toHaveBeenCalled();
-  });
-
   test("restarts the edge when the lockfile display name changes", async () => {
     const ws = makeWorkspace();
     mockNginxInstalled();
@@ -1751,9 +1709,8 @@ describe("ensureTunnelEdge", () => {
     const ws = makeWorkspace();
     mockNginxInstalled();
     mockNginxSpawn();
-    mockWebDistMissing();
-    isFeatureFlagEnabledMock.mockImplementation(async () => false);
-    const pid = mockRunningEdge(ws, { listenPort: 7845, includeWebApp: true });
+    mockWebDistPresent();
+    const pid = mockRunningEdge(ws, { listenPort: 7845, includeWebApp: false });
     mockUnkillableNginx(pid);
 
     const promise = ensureTunnelEdge({
@@ -1763,7 +1720,7 @@ describe("ensureTunnelEdge", () => {
     });
 
     await expect(promise).rejects.toThrow(
-      "still running in web app mode and could not be restarted in webhooks-only mode",
+      "still running in webhooks-only mode and could not be restarted in web app mode",
     );
     await expect(promise).rejects.toThrow("vellum nginx-ingress down");
     expect(spawnMock).not.toHaveBeenCalled();
@@ -1773,12 +1730,12 @@ describe("ensureTunnelEdge", () => {
     const ws = makeWorkspace();
     mockNginxInstalled();
     mockNginxSpawn();
-    mockWebDistMissing();
-    isFeatureFlagEnabledMock.mockImplementation(async () => false);
+    mockWebDistPresent();
     const pid = mockRunningEdge(ws, {
       listenPort: 7845,
-      includeWebApp: false,
+      includeWebApp: true,
       gatewayPort: 7900,
+      remoteWebConfigHash: spaConfigHash(),
     });
     mockUnkillableNginx(pid);
 
@@ -1799,12 +1756,12 @@ describe("ensureTunnelEdge", () => {
     const ws = makeWorkspace();
     mockNginxInstalled();
     mockNginxSpawn();
-    mockWebDistMissing();
-    isFeatureFlagEnabledMock.mockImplementation(async () => false);
+    mockWebDistPresent();
     const pid = mockRunningEdge(ws, {
       listenPort: 7845,
-      includeWebApp: false,
+      includeWebApp: true,
       gatewayPort: 7900,
+      remoteWebConfigHash: spaConfigHash(),
     });
     const edge = mockKillableNginx(pid);
 
@@ -1817,26 +1774,19 @@ describe("ensureTunnelEdge", () => {
     expect(result).toEqual({
       port: REQUESTED_PORT,
       started: true,
-      includesWebApp: false,
+      includesWebApp: true,
     });
     expect(edge.killed()).toBe(true);
     const conf = realFs.readFileSync(ingressConfPath(ws), "utf-8");
-    expect(conf).toBe(
-      buildIngressNginxConfig({
-        gatewayPort: 7830,
-        listenPort: REQUESTED_PORT,
-        ipv6Loopback: hasIpv6Loopback(),
-      }),
-    );
+    expect(conf).toContain("location ^~ /assistant/ {");
   });
 
-  test("restarts a mode-drifted edge into the flag-resolved mode", async () => {
+  test("restarts a webhooks-only edge into the SPA mode", async () => {
     const ws = makeWorkspace();
     mockNginxInstalled();
     mockNginxSpawn();
-    mockWebDistMissing();
-    isFeatureFlagEnabledMock.mockImplementation(async () => false);
-    const pid = mockRunningEdge(ws, { listenPort: 7845, includeWebApp: true });
+    mockWebDistPresent();
+    const pid = mockRunningEdge(ws, { listenPort: 7845, includeWebApp: false });
     const edge = mockKillableNginx(pid);
 
     const result = await ensureTunnelEdge({
@@ -1848,20 +1798,14 @@ describe("ensureTunnelEdge", () => {
     expect(result).toEqual({
       port: REQUESTED_PORT,
       started: true,
-      includesWebApp: false,
+      includesWebApp: true,
     });
     expect(edge.killed()).toBe(true);
     const conf = realFs.readFileSync(ingressConfPath(ws), "utf-8");
-    expect(conf).toBe(
-      buildIngressNginxConfig({
-        gatewayPort: 7830,
-        listenPort: REQUESTED_PORT,
-        ipv6Loopback: hasIpv6Loopback(),
-      }),
-    );
+    expect(conf).toContain("location ^~ /assistant/ {");
   });
 
-  test("flag enabled starts the SPA edge", async () => {
+  test("starts the SPA edge", async () => {
     const ws = makeWorkspace();
     mockNginxInstalled();
     mockNginxSpawn();
@@ -1878,11 +1822,6 @@ describe("ensureTunnelEdge", () => {
       started: true,
       includesWebApp: true,
     });
-    expect(isFeatureFlagEnabledMock).toHaveBeenCalledWith(
-      ASSISTANT_ID,
-      featureFlags.WEB_REMOTE_INGRESS_FLAG,
-      { runtimeUrl: "http://127.0.0.1:7830" },
-    );
     const conf = realFs.readFileSync(ingressConfPath(ws), "utf-8");
     expect(conf).toContain("location ^~ /assistant/ {");
     expect(conf).toContain("location ^~ /webhooks/ {");
@@ -1894,40 +1833,11 @@ describe("ensureTunnelEdge", () => {
     });
   });
 
-  test("flag disabled starts the webhooks-only edge", async () => {
-    const ws = makeWorkspace();
-    mockNginxInstalled();
-    mockNginxSpawn();
-    mockWebDistMissing();
-    isFeatureFlagEnabledMock.mockImplementation(async () => false);
-
-    const result = await ensureTunnelEdge({
-      assistantId: ASSISTANT_ID,
-      workspaceDir: ws,
-      gatewayPort: 7830,
-    });
-
-    expect(result).toEqual({
-      port: REQUESTED_PORT,
-      started: true,
-      includesWebApp: false,
-    });
-    const conf = realFs.readFileSync(ingressConfPath(ws), "utf-8");
-    expect(conf).toContain("location = /v1/pair { return 404; }");
-    expect(conf).not.toContain("location ^~ /assistant/ {");
-    expect((readConfig(ws).ingress as Record<string, unknown>).nginx).toEqual({
-      listenPort: REQUESTED_PORT,
-      includeWebApp: false,
-      gatewayPort: 7830,
-    });
-  });
-
   test("forwards onStarting so callers can print progress", async () => {
     const ws = makeWorkspace();
     mockNginxInstalled();
     mockNginxSpawn();
-    mockWebDistMissing();
-    isFeatureFlagEnabledMock.mockImplementation(async () => false);
+    mockWebDistPresent();
     const onStarting = mock(
       (_info: {
         version: string;
@@ -1943,18 +1853,18 @@ describe("ensureTunnelEdge", () => {
       onStarting,
     });
 
-    expect(onStarting).toHaveBeenCalledWith({
-      version: NGINX_VERSION,
-      webDistDir: null,
-      listenPort: REQUESTED_PORT,
-    });
+    expect(onStarting).toHaveBeenCalledTimes(1);
+    const info = onStarting.mock.calls[0][0];
+    expect(info.version).toBe(NGINX_VERSION);
+    expect(info.listenPort).toBe(REQUESTED_PORT);
+    expect(typeof info.webDistDir).toBe("string");
   });
 
-  test("an entry without an assistant id gets the webhooks-only edge", async () => {
+  test("an entry without an assistant id still gets the SPA edge", async () => {
     const ws = makeWorkspace();
     mockNginxInstalled();
     mockNginxSpawn();
-    mockWebDistMissing();
+    mockWebDistPresent();
 
     const result = await ensureTunnelEdge({
       assistantId: undefined,
@@ -1965,11 +1875,10 @@ describe("ensureTunnelEdge", () => {
     expect(result).toEqual({
       port: REQUESTED_PORT,
       started: true,
-      includesWebApp: false,
+      includesWebApp: true,
     });
-    expect(isFeatureFlagEnabledMock).not.toHaveBeenCalled();
     const conf = realFs.readFileSync(ingressConfPath(ws), "utf-8");
-    expect(conf).not.toContain("location ^~ /assistant/ {");
+    expect(conf).toContain("location ^~ /assistant/ {");
   });
 
   test("missing nginx throws with install instructions", async () => {
@@ -1988,97 +1897,7 @@ describe("ensureTunnelEdge", () => {
     expect(spawnMock).not.toHaveBeenCalled();
   });
 
-  test("flag lookup failure throws the wake hint", async () => {
-    const ws = makeWorkspace();
-    mockNginxInstalled();
-    isFeatureFlagEnabledMock.mockImplementation(async () => {
-      throw new Error("connect ECONNREFUSED");
-    });
-
-    const promise = ensureTunnelEdge({
-      assistantId: ASSISTANT_ID,
-      workspaceDir: ws,
-      gatewayPort: 7830,
-    });
-
-    await expect(promise).rejects.toThrow(
-      "Could not verify the `web-remote-ingress` feature flag",
-    );
-    await expect(promise).rejects.toThrow("Try `vellum wake` and retry");
-    await expect(promise).rejects.toThrow("connect ECONNREFUSED");
-    expect(spawnMock).not.toHaveBeenCalled();
-  });
-
-  test("flagRetry retries a thrown flag lookup and then starts the edge", async () => {
-    const ws = makeWorkspace();
-    mockNginxInstalled();
-    mockNginxSpawn();
-    mockWebDistMissing();
-    isFeatureFlagEnabledMock
-      .mockImplementationOnce(async () => {
-        throw new Error('HTTP 503 {"status":"starting"}');
-      })
-      .mockImplementationOnce(async () => {
-        throw new Error('HTTP 503 {"status":"starting"}');
-      })
-      .mockImplementationOnce(async () => false);
-
-    const result = await ensureTunnelEdge({
-      assistantId: ASSISTANT_ID,
-      workspaceDir: ws,
-      gatewayPort: 7830,
-      flagRetry: { attempts: 3, intervalMs: 1 },
-    });
-
-    expect(isFeatureFlagEnabledMock).toHaveBeenCalledTimes(3);
-    expect(result).toEqual({
-      port: REQUESTED_PORT,
-      started: true,
-      includesWebApp: false,
-    });
-  });
-
-  test("flagRetry does not retry a resolved false: it is a real answer", async () => {
-    const ws = makeWorkspace();
-    mockNginxInstalled();
-    mockNginxSpawn();
-    mockWebDistMissing();
-    isFeatureFlagEnabledMock.mockImplementation(async () => false);
-
-    const result = await ensureTunnelEdge({
-      assistantId: ASSISTANT_ID,
-      workspaceDir: ws,
-      gatewayPort: 7830,
-      flagRetry: { attempts: 3, intervalMs: 1 },
-    });
-
-    expect(isFeatureFlagEnabledMock).toHaveBeenCalledTimes(1);
-    expect(result.includesWebApp).toBe(false);
-  });
-
-  test("an exhausted flagRetry throws the wake hint with the last error", async () => {
-    const ws = makeWorkspace();
-    mockNginxInstalled();
-    isFeatureFlagEnabledMock.mockImplementation(async () => {
-      throw new Error("connect ECONNREFUSED");
-    });
-
-    const promise = ensureTunnelEdge({
-      assistantId: ASSISTANT_ID,
-      workspaceDir: ws,
-      gatewayPort: 7830,
-      flagRetry: { attempts: 3, intervalMs: 1 },
-    });
-
-    await expect(promise).rejects.toThrow(
-      "Could not verify the `web-remote-ingress` feature flag",
-    );
-    await expect(promise).rejects.toThrow("connect ECONNREFUSED");
-    expect(isFeatureFlagEnabledMock).toHaveBeenCalledTimes(3);
-    expect(spawnMock).not.toHaveBeenCalled();
-  });
-
-  test("missing web dist with the flag enabled throws build guidance", async () => {
+  test("missing web dist throws build guidance", async () => {
     const ws = makeWorkspace();
     mockNginxInstalled();
     mockWebDistMissing();
@@ -2096,8 +1915,7 @@ describe("ensureTunnelEdge", () => {
     const ws = makeWorkspace();
     mockNginxInstalled();
     mockNginxSpawn();
-    mockWebDistMissing();
-    isFeatureFlagEnabledMock.mockImplementation(async () => false);
+    mockWebDistPresent();
     waitForDaemonReadyMock.mockImplementation(async () => false);
 
     await expect(
@@ -2113,8 +1931,7 @@ describe("ensureTunnelEdge", () => {
     const ws = makeWorkspace();
     mockNginxInstalled();
     mockNginxSpawnExitsOnStartup();
-    mockWebDistMissing();
-    isFeatureFlagEnabledMock.mockImplementation(async () => false);
+    mockWebDistPresent();
     waitForDaemonReadyMock.mockImplementation(async () => true);
 
     const promise = ensureTunnelEdge({