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

package/dist/esm/common/settings.js

@@ -24,8 +24,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.343";
-const BUILD_COMMIT = "e66e8bf5e0039bfc9727326f22348a237c42d737";
+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/esm/sandbox/action.js

@@ -61,8 +61,8 @@ export 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/esm/sandbox/process/process.js

@@ -1,6 +1,11 @@
 import { ResponseError, SandboxAction } from "../action.js";
 import { isRetryableGatewayError, isTransientResetError, retryOnTransientReset } from "../../common/transient-retry.js";
 import { deleteProcessByIdentifier, deleteProcessByIdentifierKill, deleteProcessByIdentifierStdin, getProcess, getProcessByIdentifier, getProcessByIdentifierLogs, getProcessByIdentifierLogsStream, postProcess, postProcessByIdentifierStdin } from "../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)));
 export class SandboxProcess extends SandboxAction {
     constructor(sandbox) {
         super(sandbox);
@@ -276,13 +281,19 @@ export class SandboxProcess extends 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();
@@ -314,6 +325,42 @@ export class SandboxProcess extends 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 getProcessByIdentifier(this.withClient({

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

@@ -9,6 +9,8 @@ describe("SandboxProcess.wait", () => {
         const process = Object.create(SandboxProcess.prototype);
         const completed = { status: "completed" };
         const get = 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 expect(process.wait("process-id", { interval: 5000 })).resolves.toBe(completed);
         expect(get).toHaveBeenCalledTimes(1);
         expect(vi.getTimerCount()).toBe(0);

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

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