@miosa/sdk 3.0.2 → 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 = "2.0.7";
+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;
@@ -8510,9 +8513,10 @@ function createBody(params = {}) {
   if (legacyPersistencePolicy) metadata.miosa_persistent = persistent;
   const cpuCount = params.cpuCount ?? params.cpu_count;
   const memoryMb = params.memoryMb ?? params.memory_mb;
+  const diskSizeMb = params.diskSizeMb ?? params.disk_size_mb;
   const resolvedSize = params.size;
   if (cpuCount !== void 0 || memoryMb !== void 0) {
-    assertPublishedShape(cpuCount, memoryMb);
+    resolveRawShape(cpuCount, memoryMb, diskSizeMb, resolvedSize);
   }
   if (snapshotExpirationSec !== void 0) {
     metadata.snapshot_expiration_sec = snapshotExpirationSec;
@@ -8527,7 +8531,7 @@ function createBody(params = {}) {
     cpu_count: cpuCount,
     memory_mb: memoryMb,
     disk_mb: params.diskMb ?? params.disk_mb,
-    disk_size_mb: params.diskSizeMb ?? params.disk_size_mb,
+    disk_size_mb: diskSizeMb,
     timeout_sec: params.timeoutSec ?? params.timeout_sec ?? (legacyPersistencePolicy && persistent === true ? 86400 : void 0),
     idle_timeout_sec: params.idleTimeoutSec ?? params.idle_timeout_sec ?? (legacyPersistencePolicy && persistent === true ? 1800 : void 0),
     always_on: params.alwaysOn ?? params.always_on,
@@ -8558,17 +8562,27 @@ function createBody(params = {}) {
     external_project_id: params.externalProjectId ?? params.external_project_id
   });
 }
-function assertPublishedShape(cpuCount, memoryMb) {
+function resolveRawShape(cpuCount, memoryMb, diskSizeMb, requestedSize) {
   const tier = cpuCount === void 0 ? void 0 : SANDBOX_TIER_BY_CPU[cpuCount];
-  if (tier && tier.memoryMb === memoryMb) return;
+  const matchedSize = tier && tier.memoryMb === memoryMb ? tier.size : void 0;
+  if (matchedSize === void 0 && (cpuCount === void 0 || memoryMb === void 0 || diskSizeMb === void 0)) {
+    raiseUnresolvableShape(cpuCount, memoryMb, tier);
+  }
+  if (requestedSize !== void 0 && requestedSize !== matchedSize) {
+    throw new TypeError(
+      `Raw sandbox resources (${cpuCount} vCPU / ${memoryMb} MiB) do not match requested size "${requestedSize}".`
+    );
+  }
+}
+function raiseUnresolvableShape(cpuCount, memoryMb, tier) {
   const supplied = `${cpuCount ?? "?"} vCPU / ${memoryMb ?? "?"} MiB`;
   if (tier) {
     throw new TypeError(
-      `Unsupported cpu/memory combination (${supplied}); nearest supported is ${tier.size} (${cpuCount} vCPU / ${tier.memoryMb} MiB). Pass size: "${tier.size}" or memoryMb: ${tier.memoryMb}. Custom disk sizes are allowed on top of any tier.`
+      `Unsupported cpu/memory combination (${supplied}); nearest published tier is ${tier.size} (${cpuCount} vCPU / ${tier.memoryMb} MiB). Pass size: "${tier.size}" or memoryMb: ${tier.memoryMb}, or supply cpuCount, memoryMb, and diskSizeMb together for a custom shape.`
     );
   }
   throw new TypeError(
-    `Unsupported cpu/memory combination (${supplied}). Supported tiers: xs (1/2048), small (2/4096), medium (4/8192), large (8/16384), xl (16/32768). Pass a matching cpuCount + memoryMb (any diskSizeMb is allowed) or use size.`
+    `Unsupported cpu/memory combination (${supplied}). Supported tiers: xs (1/2048), small (2/4096), medium (4/8192), large (8/16384), xl (16/32768). Pass a matching cpuCount + memoryMb (any diskSizeMb is allowed), use size, or supply cpuCount, memoryMb, and diskSizeMb together for a custom shape.`
   );
 }
 function execBody(command, options = {}) {
@@ -9421,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;
@@ -9443,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
@@ -9475,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(