@blaxel/core 0.3.35-preview.342 → 0.3.35-preview.344

package/dist/cjs/common/settings.js

@@ -30,8 +30,8 @@ function missingCredentialsMessage() {
     return "No Blaxel credentials found. Set the BL_API_KEY and BL_WORKSPACE environment variables, or run `bl login`.";
 }
 // Build info - these placeholders are replaced at build time by build:replace-imports
-const BUILD_VERSION = "0.3.35-preview.342";
-const BUILD_COMMIT = "a85b1b2bd40aafb7ab4d2a9cedb22713f44fc94c";
+const BUILD_VERSION = "0.3.35-preview.344";
+const BUILD_COMMIT = "5f8cd5a9c6ba61ebc883d5c583b198b67da4167d";
 const BUILD_SENTRY_DSN = "https://fd5e60e1c9820e1eef5ccebb84a07127@o4508714045276160.ingest.us.sentry.io/4510465864564736";
 const BLAXEL_API_VERSION = "2026-09-22";
 // Bun < 1.3.11 never sends connection-level WINDOW_UPDATE: the pooled h2

package/dist/cjs/sandbox/action.js

@@ -67,8 +67,8 @@ exports.ResponseError = ResponseError;
 /**
  * Thrown when the edge/CDN in front of the sandbox returns a gateway status
  * (502/503/504) — the request never got a usable answer from the sandbox
- * itself (it is waking from standby, the command outran the edge's ~60s
- * origin-read timeout, or the edge could not reach origin). Safe to retry on an
+ * itself (it is waking from standby, the request outran the edge, which cuts
+ * held requests at 120s, or the edge could not reach origin). Safe to retry on an
  * idempotent operation. Catch it with `err instanceof SandboxGatewayError` or
  * `isGatewayTimeout(err)`.
  */

package/dist/cjs/sandbox/process/process.js

@@ -4,6 +4,11 @@ exports.SandboxProcess = void 0;
 const action_js_1 = require("../action.js");
 const transient_retry_js_1 = require("../../common/transient-retry.js");
 const index_js_1 = require("../client/index.js");
+// Server-side hold per long-poll: just under the gateway's 120s cut on held requests.
+const PROCESS_WAIT_MAX_SECONDS = 119;
+// Client-side slack on top of the hold before a wait request counts as stalled.
+const PROCESS_WAIT_GRACE_SECONDS = 10;
+const waitSeconds = (remainingMs) => Math.max(1, Math.ceil(Math.min(PROCESS_WAIT_MAX_SECONDS, remainingMs / 1000)));
 class SandboxProcess extends action_js_1.SandboxAction {
     constructor(sandbox) {
         super(sandbox);
@@ -279,13 +284,19 @@ class SandboxProcess extends action_js_1.SandboxAction {
             // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
             controller.signal.addEventListener("abort", () => reject(controller.signal.reason), { once: true });
         });
+        let longPoll = true;
         const poll = async () => {
             while (true) {
                 if (performance.now() >= deadline)
                     controller.abort(timeoutError());
                 controller.signal.throwIfAborted();
                 try {
-                    const result = await this.get(identifier, { signal: controller.signal, retry: false });
+                    let result = longPoll ? await this.waitOnce(identifier, waitSeconds(deadline - performance.now()), controller.signal) : undefined;
+                    if (!result) {
+                        // Sandbox older than the /wait route: poll for the rest of this call.
+                        longPoll = false;
+                        result = await this.get(identifier, { signal: controller.signal, retry: false });
+                    }
                     if (performance.now() >= deadline)
                         controller.abort(timeoutError());
                     controller.signal.throwIfAborted();
@@ -317,6 +328,42 @@ class SandboxProcess extends action_js_1.SandboxAction {
             signal?.removeEventListener("abort", cancel);
         }
     }
+    /** One long-poll on GET /process/{identifier}/wait; undefined when the sandbox predates the route. */
+    async waitOnce(identifier, timeout, signal) {
+        // A request stalled past hold + 10s is dropped and retried by wait() like a lost connection.
+        // ponytail: AbortController + setTimeout, AbortSignal.any needs Node 20.3+ and engines allows 18.
+        const request = new AbortController();
+        let stalled = false;
+        const timer = setTimeout(() => { stalled = true; request.abort(); }, (timeout + PROCESS_WAIT_GRACE_SECONDS) * 1000);
+        // Clear here too: a transport that ignores abort never reaches the finally below.
+        const forward = () => { clearTimeout(timer); request.abort(signal.reason); };
+        signal.addEventListener("abort", forward, { once: true });
+        try {
+            // Not in the generated client yet (ENG-6233): same call shape as getProcessByIdentifier.
+            const { response, data, error } = await this.client.get({
+                security: [{ scheme: "bearer", type: "http" }],
+                url: "/process/{identifier}/wait",
+                path: { identifier },
+                query: { timeout },
+                baseUrl: this.url,
+                signal: request.signal,
+            });
+            // gin answers an unknown route with a plain-text 404; the endpoint's own 404 is JSON.
+            if (response.status === 404 && typeof error === "string")
+                return undefined;
+            this.handleResponseError(response, data, error);
+            return data;
+        }
+        catch (error) {
+            if (stalled && !signal.aborted)
+                throw new TypeError("fetch failed", { cause: error });
+            throw error;
+        }
+        finally {
+            clearTimeout(timer);
+            signal.removeEventListener("abort", forward);
+        }
+    }
     async get(identifier, { signal, retry = true } = {}) {
         const read = async () => {
             const { response, data, error } = await (0, index_js_1.getProcessByIdentifier)(this.withClient({

package/dist/cjs/sandbox/process/process.test.js

@@ -11,6 +11,8 @@ const process_js_1 = require("./process.js");
         const process = Object.create(process_js_1.SandboxProcess.prototype);
         const completed = { status: "completed" };
         const get = vitest_1.vi.spyOn(process, "get").mockResolvedValue(completed);
+        // Sandbox without the /wait route: the read goes through the polling fallback.
+        Object.assign(process, { waitOnce: () => Promise.resolve(undefined) });
         await (0, vitest_1.expect)(process.wait("process-id", { interval: 5000 })).resolves.toBe(completed);
         (0, vitest_1.expect)(get).toHaveBeenCalledTimes(1);
         (0, vitest_1.expect)(vitest_1.vi.getTimerCount()).toBe(0);

package/dist/cjs/sandbox/process/process.wait.test.js

@@ -84,8 +84,8 @@ const response = (status) => new Response(JSON.stringify({ status, exitCode: sta
         const controller = new AbortController();
         const reason = new Error("caller cancelled");
         const assertion = (0, vitest_1.expect)(api().wait("original", { maxWait: -1, signal: controller.signal })).rejects.toBe(reason);
-        await vitest_1.vi.advanceTimersByTimeAsync(86_400_000);
-        (0, vitest_1.expect)(vitest_1.vi.getTimerCount()).toBe(0);
+        await vitest_1.vi.advanceTimersByTimeAsync(60_000);
+        (0, vitest_1.expect)(vitest_1.vi.getTimerCount()).toBe(1); // Only the per-request stall timer.
         controller.abort(reason);
         await assertion;
         (0, vitest_1.expect)(fetch.mock.calls[0][0].signal.aborted).toBe(true);
@@ -119,3 +119,94 @@ const response = (status) => new Response(JSON.stringify({ status, exitCode: sta
         await (0, vitest_1.expect)(api().wait("original", { maxWait: 25 })).rejects.toThrow("Process did not finish in time");
     });
 });
+(0, vitest_1.describe)("process wait long-poll (GET /process/{id}/wait)", () => {
+    const requested = (fetch) => fetch.mock.calls.map(call => new URL(call[0].url));
+    const missingRoute = () => new Response("404 page not found", { status: 404, headers: { "content-type": "text/plain" } });
+    (0, vitest_1.it)("finishes on the first wait call", async () => {
+        const fetch = vitest_1.vi.fn().mockResolvedValue(response("completed"));
+        vitest_1.vi.stubGlobal("fetch", fetch);
+        (0, vitest_1.expect)((await api().wait("original")).status).toBe("completed");
+        const [url] = requested(fetch);
+        (0, vitest_1.expect)(fetch).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(url.pathname).toBe("/process/original/wait");
+        (0, vitest_1.expect)(url.searchParams.get("timeout")).toBe("60"); // default maxWait 60000 ms
+    });
+    (0, vitest_1.it)("calls /wait again while the process is running", async () => {
+        const fetch = vitest_1.vi.fn()
+            .mockResolvedValueOnce(response("running"))
+            .mockResolvedValueOnce(response("running"))
+            .mockResolvedValue(response("failed"));
+        vitest_1.vi.stubGlobal("fetch", fetch);
+        (0, vitest_1.expect)((await api().wait("original", { maxWait: -1, interval: 1 })).exitCode).toBe(7);
+        const urls = requested(fetch);
+        (0, vitest_1.expect)(urls.map(u => u.pathname)).toEqual(Array(3).fill("/process/original/wait"));
+        (0, vitest_1.expect)(urls.every(u => u.searchParams.get("timeout") === "119")).toBe(true);
+    });
+    (0, vitest_1.it)("falls back to polling for the rest of the call on gin's plain-text 404", async () => {
+        const fetch = vitest_1.vi.fn()
+            .mockResolvedValueOnce(missingRoute())
+            .mockResolvedValueOnce(response("running"))
+            .mockResolvedValue(response("completed"));
+        vitest_1.vi.stubGlobal("fetch", fetch);
+        (0, vitest_1.expect)((await api().wait("original", { interval: 1 })).status).toBe("completed");
+        (0, vitest_1.expect)(requested(fetch).map(u => u.pathname)).toEqual(["/process/original/wait", "/process/original", "/process/original"]);
+    });
+    (0, vitest_1.it)("treats a JSON 404 from /wait as process not found", async () => {
+        const fetch = vitest_1.vi.fn().mockResolvedValue(new Response(JSON.stringify({ error: "process not found" }), { status: 404, headers: { "content-type": "application/json" } }));
+        vitest_1.vi.stubGlobal("fetch", fetch);
+        await (0, vitest_1.expect)(api().wait("original")).rejects.toMatchObject({ status: 404 });
+        (0, vitest_1.expect)(fetch).toHaveBeenCalledTimes(1);
+    });
+    (0, vitest_1.it)("caps the server hold at what is left of maxWait and still times out", async () => {
+        vitest_1.vi.useFakeTimers();
+        const fetch = vitest_1.vi.fn().mockImplementation(() => Promise.resolve(response("running")));
+        vitest_1.vi.stubGlobal("fetch", fetch);
+        const assertion = (0, vitest_1.expect)(api().wait("original", { maxWait: 1500, interval: 100 })).rejects.toThrow("did not finish in time");
+        await vitest_1.vi.advanceTimersByTimeAsync(1500);
+        await assertion;
+        const holds = requested(fetch).map(u => Number(u.searchParams.get("timeout")));
+        (0, vitest_1.expect)(holds[0]).toBe(2);
+        (0, vitest_1.expect)(holds.every(h => h >= 1 && h <= 2)).toBe(true);
+        (0, vitest_1.expect)(vitest_1.vi.getTimerCount()).toBe(0);
+    });
+    (0, vitest_1.it)("does not abort a held request before the server answers", async () => {
+        // The per-request timeout is hold + 10s, so a request held for the full 119s is not aborted.
+        vitest_1.vi.useFakeTimers();
+        let answer;
+        const fetch = vitest_1.vi.fn(() => new Promise(resolve => { answer = resolve; }));
+        vitest_1.vi.stubGlobal("fetch", fetch);
+        const waiting = api().wait("original", { maxWait: -1 });
+        await vitest_1.vi.advanceTimersByTimeAsync(119_000);
+        (0, vitest_1.expect)(fetch.mock.calls[0][0].signal.aborted).toBe(false);
+        answer(response("completed"));
+        (0, vitest_1.expect)((await waiting).status).toBe("completed");
+    });
+    (0, vitest_1.it)("drops a /wait request stalled past hold + 10s and retries it", async () => {
+        vitest_1.vi.useFakeTimers();
+        const hang = (request) => new Promise((_, reject) => {
+            request.signal.addEventListener("abort", () => reject(request.signal.reason), { once: true });
+        });
+        const fetch = vitest_1.vi.fn().mockImplementationOnce(hang).mockResolvedValue(response("completed"));
+        vitest_1.vi.stubGlobal("fetch", fetch);
+        const waiting = api().wait("original", { maxWait: -1, interval: 1 });
+        await vitest_1.vi.advanceTimersByTimeAsync(128_999);
+        (0, vitest_1.expect)(fetch).toHaveBeenCalledTimes(1);
+        await vitest_1.vi.advanceTimersByTimeAsync(10);
+        (0, vitest_1.expect)((await waiting).status).toBe("completed");
+        (0, vitest_1.expect)(fetch).toHaveBeenCalledTimes(2);
+        (0, vitest_1.expect)(fetch.mock.calls[0][0].signal.aborted).toBe(true);
+        (0, vitest_1.expect)(vitest_1.vi.getTimerCount()).toBe(0);
+    });
+    (0, vitest_1.it)("a short maxWait times out before the per-request stall timer, leaving no timers", async () => {
+        vitest_1.vi.useFakeTimers();
+        const hang = (request) => new Promise((_, reject) => {
+            request.signal.addEventListener("abort", () => reject(request.signal.reason), { once: true });
+        });
+        vitest_1.vi.stubGlobal("fetch", vitest_1.vi.fn(hang));
+        // maxWait 5s: hold 5s, stall timer 15s, so the overall deadline fires first.
+        const assertion = (0, vitest_1.expect)(api().wait("original", { maxWait: 5_000 })).rejects.toThrow("did not finish in time");
+        await vitest_1.vi.advanceTimersByTimeAsync(5_000);
+        await assertion;
+        (0, vitest_1.expect)(vitest_1.vi.getTimerCount()).toBe(0);
+    });
+});

package/dist/cjs/types/sandbox/action.d.ts

@@ -13,8 +13,8 @@ export declare class ResponseError extends Error {
 /**
  * Thrown when the edge/CDN in front of the sandbox returns a gateway status
  * (502/503/504) — the request never got a usable answer from the sandbox
- * itself (it is waking from standby, the command outran the edge's ~60s
- * origin-read timeout, or the edge could not reach origin). Safe to retry on an
+ * itself (it is waking from standby, the request outran the edge, which cuts
+ * held requests at 120s, or the edge could not reach origin). Safe to retry on an
  * idempotent operation. Catch it with `err instanceof SandboxGatewayError` or
  * `isGatewayTimeout(err)`.
  */

package/dist/cjs/types/sandbox/process/process.d.ts

@@ -21,6 +21,8 @@ export declare class SandboxProcess extends SandboxAction {
         interval?: number;
         signal?: AbortSignal;
     }): Promise<GetProcessByIdentifierResponse>;
+    /** One long-poll on GET /process/{identifier}/wait; undefined when the sandbox predates the route. */
+    private waitOnce;
     get(identifier: string, { signal, retry }?: {
         signal?: AbortSignal;
         retry?: boolean;