@vellumai/cli 0.10.12-dev.202607250140.9979030 → 0.10.12-dev.202607250508.d09ff97

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/cli",
-  "version": "0.10.12-dev.202607250140.9979030",
+  "version": "0.10.12-dev.202607250508.d09ff97",
   "description": "CLI tools for vellum-assistant",
   "type": "module",
   "exports": {

package/src/__tests__/wake.test.ts

@@ -179,7 +179,7 @@ mock.module("../lib/nginx-ingress.js", () => ({
   startRemoteWebIngress: startRemoteWebIngressMock,
 }));
 
-const { wake } = await import("../commands/wake.js");
+const { wake, WEB_INGRESS_FLAG_RETRY } = await import("../commands/wake.js");
 
 let tempDir: string;
 let originalArgv: string[];
@@ -408,8 +408,18 @@ describe("vellum wake — web ingress restore", () => {
     ingress: { enabled: true, publicBaseUrl: "https://assistant.example.com" },
   };
 
+  const originalRetry = { ...WEB_INGRESS_FLAG_RETRY };
+
   beforeEach(() => {
     process.argv = ["bun", "vellum", "wake", "local-assistant"];
+    // Shrink the startup-window retry so failure-path tests stay fast.
+    WEB_INGRESS_FLAG_RETRY.attempts = 3;
+    WEB_INGRESS_FLAG_RETRY.intervalMs = 5;
+  });
+
+  afterEach(() => {
+    WEB_INGRESS_FLAG_RETRY.attempts = originalRetry.attempts;
+    WEB_INGRESS_FLAG_RETRY.intervalMs = originalRetry.intervalMs;
   });
 
   test("restores the edge when ingress is enabled, the flag is on, and it is not already running", async () => {
@@ -515,8 +525,35 @@ describe("vellum wake — web ingress restore", () => {
 
     await wake();
 
+    // The probe retries through the startup window before giving up.
+    expect(isAssistantFeatureFlagEnabledMock.mock.calls.length).toBe(3);
     expect(startRemoteWebIngressMock).not.toHaveBeenCalled();
     expect(warnSpy).toHaveBeenCalled();
     expect(logSpy).toHaveBeenCalledWith("Wake complete.");
   });
+
+  test("a flag probe that fails while the gateway is starting retries and then restores", async () => {
+    loadRawConfigMock.mockReturnValue(enabledConfig);
+    isAssistantFeatureFlagEnabledMock
+      .mockRejectedValueOnce(
+        new Error(
+          'Failed to fetch feature flags: HTTP 503 {"status":"starting"}',
+        ),
+      )
+      .mockRejectedValueOnce(
+        new Error(
+          'Failed to fetch feature flags: HTTP 503 {"status":"starting"}',
+        ),
+      )
+      .mockResolvedValueOnce(true);
+
+    await wake();
+
+    expect(isAssistantFeatureFlagEnabledMock.mock.calls.length).toBe(3);
+    expect(logSpy).toHaveBeenCalledWith(
+      "   Waiting for the gateway before restoring the web ingress edge...",
+    );
+    expect(startRemoteWebIngressMock).toHaveBeenCalled();
+    expect(logSpy).toHaveBeenCalledWith("Wake complete.");
+  });
 });

package/src/commands/pair.ts

@@ -390,7 +390,7 @@ export async function pair(): Promise<void> {
       `Re-run with a reachable URL, e.g.:\n  vellum pair --url ${suggestion}`,
     );
     console.error(
-      "Pairing a phone by QR instead? Use: vellum pair --qr " +
+      "Pairing another device by QR instead? Use: vellum pair --qr " +
         "(needs an https URL — run `vellum tunnel --provider tailscale` first).",
     );
     process.exit(1);
@@ -478,7 +478,7 @@ export async function pair(): Promise<void> {
         }'s website, not your assistant's address`,
       };
       console.error(
-        "Error: --qr needs a public https URL the phone can open — " +
+        "Error: --qr needs a public https URL the scanning device can open — " +
           `${detailByReason[qrResult.reason]}.`,
       );
       console.error(

package/src/commands/wake.ts

@@ -425,6 +425,52 @@ export async function wake(): Promise<void> {
   }
 }
 
+/**
+ * Retry policy for the flag probe that gates the web-ingress restore. The
+ * gateway has typically been up for milliseconds at this point and answers
+ * `503 {"status":"starting"}` (or refuses connections) until its startup
+ * completes, so a single probe races it. Mutable so tests can shrink the
+ * window.
+ */
+export const WEB_INGRESS_FLAG_RETRY = {
+  attempts: 15,
+  intervalMs: 2_000,
+};
+
+/**
+ * Probe the `web-remote-ingress` flag, riding out the gateway's startup
+ * window: transient failures retry on an interval until the attempt budget is
+ * spent, then the last error propagates to the caller's warn path.
+ */
+async function verifyWebIngressFlagWithRetry(
+  assistantId: string,
+  gatewayPort: number,
+): Promise<boolean> {
+  let lastError: unknown;
+  for (let attempt = 1; attempt <= WEB_INGRESS_FLAG_RETRY.attempts; attempt++) {
+    try {
+      return await isAssistantFeatureFlagEnabled(
+        assistantId,
+        WEB_REMOTE_INGRESS_FLAG,
+        { runtimeUrl: `http://127.0.0.1:${gatewayPort}` },
+      );
+    } catch (err) {
+      lastError = err;
+      if (attempt === 1) {
+        console.log(
+          "   Waiting for the gateway before restoring the web ingress edge...",
+        );
+      }
+      if (attempt < WEB_INGRESS_FLAG_RETRY.attempts) {
+        await new Promise((resolve) =>
+          setTimeout(resolve, WEB_INGRESS_FLAG_RETRY.intervalMs),
+        );
+      }
+    }
+  }
+  throw lastError;
+}
+
 /**
  * Bring the nginx web ingress edge back up after a wake when the workspace
  * config still wants it. Only restores when ingress is explicitly enabled with
@@ -460,11 +506,7 @@ async function restoreWebIngressIfEnabled(
 
   let flagEnabled: boolean;
   try {
-    flagEnabled = await isAssistantFeatureFlagEnabled(
-      assistantId,
-      WEB_REMOTE_INGRESS_FLAG,
-      { runtimeUrl: `http://127.0.0.1:${gatewayPort}` },
-    );
+    flagEnabled = await verifyWebIngressFlagWithRetry(assistantId, gatewayPort);
   } catch (err) {
     console.warn(
       `   Could not verify the \`${WEB_REMOTE_INGRESS_FLAG}\` flag to restore the web ingress edge; leaving it down. Bring it up manually with \`vellum nginx-ingress up\`. ${