@miosa/sdk 3.1.0 → 3.2.0

package/dist/index.d.ts

@@ -7432,14 +7432,27 @@ declare class Sandbox {
      * Returns `true` once the sandbox is ready, `false` on `event: timeout`
      * or when the local timeout elapses before ready.
      *
+     * Throws {@link MiosaError} with code `SANDBOX_BOOT_FAILED` as soon as the
+     * sandbox is observed in a terminal failure state (`error` or `destroyed`)
+     * while waiting, instead of silently exhausting the timeout and returning
+     * `false` — a permanent boot failure and "still booting, keep waiting" must
+     * never look the same to the caller. The readiness SSE stream itself has no
+     * dedicated failure event today (the server only ever emits
+     * `ready`/`status`/`timeout`), so on `event: timeout` this makes one
+     * authoritative {@link readiness} check before giving up, to catch a
+     * failure that landed right at the boundary.
+     *
      * If the SSE endpoint returns 404 (server pre-dates the streaming
-     * endpoint) this transparently falls back to polling
-     * {@link readiness} every 10 ms until ready or timeout.
+     * endpoint) this transparently falls back to polling {@link readiness}
+     * every 10 ms until ready, timeout, or terminal failure.
      */
     waitUntilReady(options?: {
         timeout?: number;
         stream?: boolean;
     }): Promise<boolean>;
+    private bootFailedError;
+    /** Best-effort final check so an SSE `event: timeout` does not mask a boot failure that just landed. */
+    private throwIfTerminallyFailed;
     /**
      * Readiness answers from the server; `assertRunning` reads the local
      * snapshot. Leaving that snapshot behind meant a caller could await

package/dist/index.js

@@ -168,7 +168,7 @@ var TokenRefreshFailedError = class extends MiosaError {
 };
 
 // src/version.ts
-var SDK_VERSION = "3.1.0";
+var SDK_VERSION = "3.2.0";
 var SDK_USER_AGENT = `@miosa/sdk/${SDK_VERSION}`;
 
 // src/http.ts
@@ -373,7 +373,7 @@ var HttpClient = class {
   async *streamFrames(path, options = {}) {
     const method = options.method ?? "GET";
     let headers = this.baseHeaders({
-      Accept: "text/event-stream",
+      Accept: "text/event-stream, application/json, */*",
       ...options.headers
     });
     let body5 = null;
@@ -8459,6 +8459,9 @@ var SANDBOX_TIER_BY_CPU = {
   8: { size: "large", memoryMb: 16384 },
   16: { size: "xl", memoryMb: 32768 }
 };
+function isTerminalSandboxFailure(state) {
+  return state === "error" || state === "destroyed";
+}
 var AGENT_WORKSPACE_TIMEOUT_SEC = 86400;
 var AGENT_WORKSPACE_IDLE_TIMEOUT_SEC = 1800;
 var AGENT_WORKSPACE_SNAPSHOT_EXPIRATION_DAYS = 30;
@@ -9432,18 +9435,32 @@ var Sandbox = class _Sandbox {
    * Returns `true` once the sandbox is ready, `false` on `event: timeout`
    * or when the local timeout elapses before ready.
    *
+   * Throws {@link MiosaError} with code `SANDBOX_BOOT_FAILED` as soon as the
+   * sandbox is observed in a terminal failure state (`error` or `destroyed`)
+   * while waiting, instead of silently exhausting the timeout and returning
+   * `false` — a permanent boot failure and "still booting, keep waiting" must
+   * never look the same to the caller. The readiness SSE stream itself has no
+   * dedicated failure event today (the server only ever emits
+   * `ready`/`status`/`timeout`), so on `event: timeout` this makes one
+   * authoritative {@link readiness} check before giving up, to catch a
+   * failure that landed right at the boundary.
+   *
    * If the SSE endpoint returns 404 (server pre-dates the streaming
-   * endpoint) this transparently falls back to polling
-   * {@link readiness} every 10 ms until ready or timeout.
+   * endpoint) this transparently falls back to polling {@link readiness}
+   * every 10 ms until ready, timeout, or terminal failure.
    */
   async waitUntilReady(options = {}) {
     const timeout = options.timeout ?? 30;
     const stream = options.stream ?? true;
     if (stream) {
       const sseResult = await this.tryReadinessStream(timeout);
-      if (sseResult !== null) {
-        if (sseResult) await this.adoptReadyState();
-        return sseResult;
+      if (sseResult === true) {
+        await this.adoptReadyState();
+        return true;
+      }
+      if (sseResult === false) {
+        await this.throwIfTerminallyFailed();
+        return false;
       }
     }
     const deadlineMs = Date.now() + timeout * 1e3;
@@ -9454,12 +9471,39 @@ var Sandbox = class _Sandbox {
           await this.adoptReadyState();
           return true;
         }
-      } catch {
+        if (isTerminalSandboxFailure(data.state)) {
+          throw this.bootFailedError(data.state);
+        }
+      } catch (err) {
+        if (err instanceof MiosaError && err.code === "SANDBOX_BOOT_FAILED") {
+          throw err;
+        }
       }
       await new Promise((resolve) => setTimeout(resolve, 10));
     }
     return false;
   }
+  bootFailedError(state) {
+    return new MiosaError(
+      `Sandbox ${this.id} entered terminal state '${state}' while waiting for readiness`,
+      502,
+      "SANDBOX_BOOT_FAILED",
+      { sandbox_id: this.id, state }
+    );
+  }
+  /** Best-effort final check so an SSE `event: timeout` does not mask a boot failure that just landed. */
+  async throwIfTerminallyFailed() {
+    try {
+      const data = await this.readiness();
+      if (isTerminalSandboxFailure(data?.state)) {
+        throw this.bootFailedError(data.state);
+      }
+    } catch (err) {
+      if (err instanceof MiosaError && err.code === "SANDBOX_BOOT_FAILED") {
+        throw err;
+      }
+    }
+  }
   /**
    * Readiness answers from the server; `assertRunning` reads the local
    * snapshot. Leaving that snapshot behind meant a caller could await
@@ -9486,7 +9530,11 @@ var Sandbox = class _Sandbox {
     try {
       const headers = {
         Authorization: `Bearer ${this.http.apiKey}`,
-        Accept: "text/event-stream",
+        // Combined defensively: a bare `text/event-stream` Accept header 406s
+        // on some `:accepts`-guarded routes (seen on the databases stream
+        // route). Offering json/`*/*` as fallbacks is free when SSE is
+        // actually returned.
+        Accept: "text/event-stream, application/json, */*",
         "User-Agent": SDK_USER_AGENT
       };
       const response = await fetch(