@miosa/sdk 3.2.1 → 3.2.3

package/dist/index.js

@@ -9,18 +9,23 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/errors.ts
+function defaultRetryable(status) {
+  return status === 408 || status === 429 || status >= 500;
+}
 var MiosaError = class _MiosaError extends Error {
   status;
   code;
   details;
   requestId;
-  constructor(message, status, code, details, requestId) {
+  retryable;
+  constructor(message, status, code, details, requestId, retryable = defaultRetryable(status)) {
     super(message);
     this.name = "MiosaError";
     this.status = status;
     this.code = code;
     this.details = details;
     this.requestId = requestId;
+    this.retryable = retryable;
   }
   static fromResponse(status, body5, requestId) {
     const nested = typeof body5.error === "object" ? body5.error : void 0;
@@ -30,145 +35,146 @@ var MiosaError = class _MiosaError extends Error {
     const code = nested?.code ?? body5.code ?? (flatErrorIsCode ? flatError : "UNKNOWN_ERROR");
     const details = nested?.details ?? body5.details ?? (body5.detail || body5.reason ? { detail: body5.detail, reason: body5.reason } : void 0);
     requestId ??= body5.request_id;
-    const connectError = connectErrorFromCode(code, message, status, details, requestId);
+    const retryable = nested?.retryable ?? body5.retryable ?? defaultRetryable(status);
+    const connectError = connectErrorFromCode(code, message, status, details, requestId, retryable);
     if (connectError) return connectError;
     if (status === 401 || status === 403) {
-      return new AuthError(message, status, code, details, requestId);
+      return new AuthError(message, status, code, details, requestId, retryable);
     }
     if (status === 404) {
-      return new NotFoundError(message, code, details, requestId);
+      return new NotFoundError(message, code, details, requestId, retryable);
     }
     if (status === 429) {
-      return new RateLimitError(message, details, requestId);
+      return new RateLimitError(message, details, requestId, void 0, retryable);
     }
     if (status === 402) {
-      return new InsufficientCreditsError(message, details, requestId);
+      return new InsufficientCreditsError(message, details, requestId, retryable);
     }
     if (status >= 400 && status < 500) {
-      return new ValidationError(message, status, code, details, requestId);
+      return new ValidationError(message, status, code, details, requestId, retryable);
     }
-    return new _MiosaError(message, status, code, details, requestId);
+    return new _MiosaError(message, status, code, details, requestId, retryable);
   }
 };
-function connectErrorFromCode(code, message, status, details, requestId) {
+function connectErrorFromCode(code, message, status, details, requestId, retryable) {
   switch (code) {
     case "PROJECT_NOT_LINKED":
-      return new ProjectNotLinkedError(message, status, details, requestId);
+      return new ProjectNotLinkedError(message, status, details, requestId, retryable);
     case "SUBJECT_NOT_ALLOWED":
-      return new SubjectNotAllowedError(message, status, details, requestId);
+      return new SubjectNotAllowedError(message, status, details, requestId, retryable);
     case "SCOPE_NOT_ALLOWED":
-      return new ScopeNotAllowedError(message, status, details, requestId);
+      return new ScopeNotAllowedError(message, status, details, requestId, retryable);
     case "MANAGED_PROVIDER_BINDING_ONLY":
-      return new ManagedProviderBindingOnlyError(message, status, details, requestId);
+      return new ManagedProviderBindingOnlyError(message, status, details, requestId, retryable);
     case "INSTALLATION_REQUIRED":
-      return new InstallationRequiredError(message, status, details, requestId);
+      return new InstallationRequiredError(message, status, details, requestId, retryable);
     case "USER_AUTHORIZATION_REQUIRED":
-      return new UserAuthorizationRequiredError(message, status, details, requestId);
+      return new UserAuthorizationRequiredError(message, status, details, requestId, retryable);
     case "EGRESS_HOST_NOT_ALLOWED":
-      return new EgressHostNotAllowedError(message, status, details, requestId);
+      return new EgressHostNotAllowedError(message, status, details, requestId, retryable);
     case "TOKEN_REFRESH_FAILED":
-      return new TokenRefreshFailedError(message, status, details, requestId);
+      return new TokenRefreshFailedError(message, status, details, requestId, retryable);
     default:
       return void 0;
   }
 }
 var AuthError = class extends MiosaError {
-  constructor(message, status = 401, code = "UNAUTHORIZED", details, requestId) {
-    super(message, status, code, details, requestId);
+  constructor(message, status = 401, code = "UNAUTHORIZED", details, requestId, retryable) {
+    super(message, status, code, details, requestId, retryable);
     this.name = "AuthError";
   }
 };
 var NotFoundError = class extends MiosaError {
-  constructor(message, code = "NOT_FOUND", details, requestId) {
-    super(message, 404, code, details, requestId);
+  constructor(message, code = "NOT_FOUND", details, requestId, retryable) {
+    super(message, 404, code, details, requestId, retryable);
     this.name = "NotFoundError";
   }
 };
 var RateLimitError = class extends MiosaError {
   retryAfter;
-  constructor(message, details, requestId, retryAfter) {
-    super(message, 429, "RATE_LIMITED", details, requestId);
+  constructor(message, details, requestId, retryAfter, retryable) {
+    super(message, 429, "RATE_LIMITED", details, requestId, retryable);
     this.name = "RateLimitError";
     this.retryAfter = retryAfter;
   }
 };
 var InsufficientCreditsError = class extends MiosaError {
-  constructor(message, details, requestId) {
-    super(message, 402, "INSUFFICIENT_CREDITS", details, requestId);
+  constructor(message, details, requestId, retryable) {
+    super(message, 402, "INSUFFICIENT_CREDITS", details, requestId, retryable);
     this.name = "InsufficientCreditsError";
   }
 };
 var ValidationError = class extends MiosaError {
-  constructor(message, status, code = "VALIDATION_ERROR", details, requestId) {
-    super(message, status, code, details, requestId);
+  constructor(message, status, code = "VALIDATION_ERROR", details, requestId, retryable) {
+    super(message, status, code, details, requestId, retryable);
     this.name = "ValidationError";
   }
 };
 var TimeoutError = class extends MiosaError {
   constructor(message = "Request timed out") {
-    super(message, 408, "TIMEOUT");
+    super(message, 408, "TIMEOUT", void 0, void 0, true);
     this.name = "TimeoutError";
   }
 };
 var NetworkError = class extends MiosaError {
   cause;
   constructor(message, cause) {
-    super(message, 0, "NETWORK_ERROR");
+    super(message, 0, "NETWORK_ERROR", void 0, void 0, true);
     this.name = "NetworkError";
     this.cause = cause;
   }
 };
 var ProjectNotLinkedError = class extends MiosaError {
-  constructor(message, status = 403, details, requestId) {
-    super(message, status, "PROJECT_NOT_LINKED", details, requestId);
+  constructor(message, status = 403, details, requestId, retryable) {
+    super(message, status, "PROJECT_NOT_LINKED", details, requestId, retryable);
     this.name = "ProjectNotLinkedError";
   }
 };
 var SubjectNotAllowedError = class extends MiosaError {
-  constructor(message, status = 403, details, requestId) {
-    super(message, status, "SUBJECT_NOT_ALLOWED", details, requestId);
+  constructor(message, status = 403, details, requestId, retryable) {
+    super(message, status, "SUBJECT_NOT_ALLOWED", details, requestId, retryable);
     this.name = "SubjectNotAllowedError";
   }
 };
 var ScopeNotAllowedError = class extends MiosaError {
-  constructor(message, status = 403, details, requestId) {
-    super(message, status, "SCOPE_NOT_ALLOWED", details, requestId);
+  constructor(message, status = 403, details, requestId, retryable) {
+    super(message, status, "SCOPE_NOT_ALLOWED", details, requestId, retryable);
     this.name = "ScopeNotAllowedError";
   }
 };
 var ManagedProviderBindingOnlyError = class extends MiosaError {
-  constructor(message, status = 403, details, requestId) {
-    super(message, status, "MANAGED_PROVIDER_BINDING_ONLY", details, requestId);
+  constructor(message, status = 403, details, requestId, retryable) {
+    super(message, status, "MANAGED_PROVIDER_BINDING_ONLY", details, requestId, retryable);
     this.name = "ManagedProviderBindingOnlyError";
   }
 };
 var InstallationRequiredError = class extends MiosaError {
-  constructor(message, status = 409, details, requestId) {
-    super(message, status, "INSTALLATION_REQUIRED", details, requestId);
+  constructor(message, status = 409, details, requestId, retryable) {
+    super(message, status, "INSTALLATION_REQUIRED", details, requestId, retryable);
     this.name = "InstallationRequiredError";
   }
 };
 var UserAuthorizationRequiredError = class extends MiosaError {
-  constructor(message, status = 403, details, requestId) {
-    super(message, status, "USER_AUTHORIZATION_REQUIRED", details, requestId);
+  constructor(message, status = 403, details, requestId, retryable) {
+    super(message, status, "USER_AUTHORIZATION_REQUIRED", details, requestId, retryable);
     this.name = "UserAuthorizationRequiredError";
   }
 };
 var EgressHostNotAllowedError = class extends MiosaError {
-  constructor(message, status = 403, details, requestId) {
-    super(message, status, "EGRESS_HOST_NOT_ALLOWED", details, requestId);
+  constructor(message, status = 403, details, requestId, retryable) {
+    super(message, status, "EGRESS_HOST_NOT_ALLOWED", details, requestId, retryable);
     this.name = "EgressHostNotAllowedError";
   }
 };
 var TokenRefreshFailedError = class extends MiosaError {
-  constructor(message, status = 502, details, requestId) {
-    super(message, status, "TOKEN_REFRESH_FAILED", details, requestId);
+  constructor(message, status = 502, details, requestId, retryable) {
+    super(message, status, "TOKEN_REFRESH_FAILED", details, requestId, retryable);
     this.name = "TokenRefreshFailedError";
   }
 };
 
 // src/version.ts
-var SDK_VERSION = "3.2.1";
+var SDK_VERSION = "3.2.3";
 var SDK_USER_AGENT = `@miosa/sdk/${SDK_VERSION}`;
 
 // src/http.ts
@@ -265,8 +271,12 @@ var HttpClient = class {
       fetchBody = JSON.stringify(body5);
     }
     let lastError;
-    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+    const maxRetries = options.maxRetries ?? this.maxRetries;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      options.signal?.throwIfAborted();
       const controller = new AbortController();
+      const cancel = () => controller.abort(options.signal?.reason);
+      options.signal?.addEventListener("abort", cancel, { once: true });
       const timer = setTimeout(() => controller.abort(), timeout);
       try {
         const response = await fetch(this.buildUrl(path), {
@@ -290,7 +300,7 @@ var HttpClient = class {
             errorBody,
             requestId
           );
-          if (RETRY_STATUS.has(response.status) && attempt < this.maxRetries) {
+          if (RETRY_STATUS.has(response.status) && attempt < maxRetries) {
             lastError = error;
             await sleep(retryDelay(attempt, retryAfter));
             continue;
@@ -307,7 +317,7 @@ var HttpClient = class {
         if (options.rawResponse) return response;
         return await response.json();
       } catch (err) {
-        clearTimeout(timer);
+        options.signal?.throwIfAborted();
         if (err instanceof MiosaError) {
           throw err;
         }
@@ -321,7 +331,7 @@ var HttpClient = class {
             `Network error reaching ${path}: ${err.message}`,
             err
           );
-          if (attempt < this.maxRetries) {
+          if (attempt < maxRetries) {
             lastError = networkErr;
             await sleep(retryDelay(attempt, null));
             continue;
@@ -329,9 +339,19 @@ var HttpClient = class {
           throw networkErr;
         }
         throw err;
+      } finally {
+        clearTimeout(timer);
+        options.signal?.removeEventListener("abort", cancel);
       }
     }
-    throw lastError ?? new MiosaError("Max retries exceeded", 0, "MAX_RETRIES_EXCEEDED");
+    throw lastError ?? new MiosaError(
+      "Max retries exceeded",
+      0,
+      "MAX_RETRIES_EXCEEDED",
+      void 0,
+      void 0,
+      true
+    );
   }
   async get(path, query3) {
     let fullPath = path;
@@ -381,44 +401,52 @@ var HttpClient = class {
       headers = { ...headers, "Content-Type": "application/json" };
       body5 = JSON.stringify(options.body);
     }
+    options.signal?.throwIfAborted();
     const controller = new AbortController();
-    let response;
+    const cancel = () => controller.abort(options.signal?.reason);
+    options.signal?.addEventListener("abort", cancel, { once: true });
+    const deadline = options.timeout === void 0 ? void 0 : new TimeoutError(
+      `Stream ${path} timed out after ${options.timeout}ms`
+    );
+    const timer = deadline === void 0 ? void 0 : setTimeout(() => controller.abort(deadline), options.timeout);
+    let reader;
     try {
-      response = await fetch(`${this.baseUrl}${path}`, {
-        method,
-        headers,
-        body: body5,
-        signal: controller.signal
-      });
-    } catch (err) {
-      if (err instanceof TypeError) {
-        throw new NetworkError(
-          `Network error opening SSE stream: ${err.message}`,
-          err
+      let response;
+      try {
+        response = await fetch(this.buildUrl(path), {
+          method,
+          headers,
+          body: body5,
+          signal: controller.signal
+        });
+      } catch (err) {
+        if (err instanceof TypeError) {
+          throw new NetworkError(
+            `Network error opening SSE stream: ${err.message}`,
+            err
+          );
+        }
+        throw err;
+      }
+      if (!response.ok) {
+        let errorBody = {};
+        try {
+          errorBody = await response.json();
+        } catch {
+        }
+        throw MiosaError.fromResponse(
+          response.status,
+          errorBody,
+          response.headers.get("x-request-id") ?? void 0
         );
       }
-      throw err;
-    }
-    if (!response.ok) {
-      let errorBody = {};
-      try {
-        errorBody = await response.json();
-      } catch {
+      if (!response.body) {
+        throw new MiosaError("SSE stream has no body", 0, "NO_STREAM_BODY");
       }
-      throw MiosaError.fromResponse(
-        response.status,
-        errorBody,
-        response.headers.get("x-request-id") ?? void 0
-      );
-    }
-    if (!response.body) {
-      throw new MiosaError("SSE stream has no body", 0, "NO_STREAM_BODY");
-    }
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    let event = null;
-    try {
+      reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let event = null;
       while (true) {
         const { done, value } = await reader.read();
         if (done) break;
@@ -446,9 +474,17 @@ var HttpClient = class {
           }
         }
       }
+    } catch (err) {
+      options.signal?.throwIfAborted();
+      if (deadline !== void 0 && controller.signal.reason === deadline) {
+        throw deadline;
+      }
+      throw err;
     } finally {
+      clearTimeout(timer);
+      options.signal?.removeEventListener("abort", cancel);
       controller.abort();
-      reader.releaseLock();
+      reader?.releaseLock();
     }
   }
   /**
@@ -8615,6 +8651,16 @@ function raiseUnresolvableShape(cpuCount, memoryMb, tier) {
     `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 execDeadline(options) {
+  const seconds = options?.timeout ?? options?.timeoutSec ?? options?.timeout_sec;
+  if (seconds === void 0) return {};
+  if (!Number.isFinite(seconds) || seconds <= 0 || seconds > 86400) {
+    throw new RangeError(
+      "Exec timeout must be greater than zero and at most 86400 seconds"
+    );
+  }
+  return { timeout: seconds * 1e3 + 5e3 };
+}
 function execBody(command, options = {}) {
   return stripUndefined26({
     command,
@@ -8784,7 +8830,7 @@ var SandboxTerminal = class {
     const response = unwrap48(
       await this.sandbox.http.post(`/sandboxes/${this.sandbox.id}/terminal`, body5)
     );
-    return response;
+    return normalizeTerminalSession(response);
   }
   async delete(sessionId) {
     await this.sandbox.http.delete(
@@ -8792,6 +8838,35 @@ var SandboxTerminal = class {
     );
   }
 };
+function normalizeTerminalSession(payload) {
+  const sessionId = payload.session_id;
+  const wsUrl = payload.ws_url;
+  const streamAuth = payload.stream_auth;
+  const streamAuthExpiresAt = payload.stream_auth_expires_at;
+  const expiresAt = payload.expires_at;
+  if (typeof sessionId !== "string" || typeof wsUrl !== "string" || typeof streamAuth !== "string" || typeof streamAuthExpiresAt !== "number" || typeof expiresAt !== "number") {
+    throw new MiosaError(
+      "Terminal create response did not contain a valid miosa-terminal-v1 session",
+      502,
+      "INVALID_TERMINAL_SESSION",
+      { received: Object.keys(payload) },
+      void 0,
+      false
+    );
+  }
+  return {
+    sessionId,
+    wsUrl,
+    streamAuth,
+    streamAuthExpiresAt,
+    expiresAt,
+    session_id: sessionId,
+    ws_url: wsUrl,
+    stream_auth: streamAuth,
+    stream_auth_expires_at: streamAuthExpiresAt,
+    expires_at: expiresAt
+  };
+}
 var SandboxEvents = class {
   constructor(sandbox) {
     this.sandbox = sandbox;
@@ -9045,10 +9120,17 @@ var Sandbox = class _Sandbox {
   }
   async runExec(command, options) {
     this.assertRunning("exec");
+    if (options?.signal) return this.runCancellableExec(command, options);
     const response = unwrap48(
-      await this.http.post(
+      await this.http.request(
         `/sandboxes/${this.id}/exec`,
-        execBody(command, options)
+        {
+          method: "POST",
+          body: execBody(command, options),
+          signal: options?.signal,
+          maxRetries: 0,
+          ...execDeadline(options)
+        }
       )
     );
     const exitCode = Number(response.exit_code ?? response.exitCode ?? 0);
@@ -9064,13 +9146,42 @@ var Sandbox = class _Sandbox {
     }
     return result;
   }
+  async runCancellableExec(command, options) {
+    let stdout = "";
+    let stderr = "";
+    let exitCode;
+    for await (const event of this.execStream(command, options)) {
+      if (event.type === "stdout" && typeof event.line === "string")
+        stdout += event.line;
+      if (event.type === "stderr" && typeof event.line === "string")
+        stderr += event.line;
+      if (event.type === "exit" && typeof event.exit_code === "number") {
+        exitCode = event.exit_code;
+        break;
+      }
+    }
+    options.signal?.throwIfAborted();
+    if (exitCode === void 0) {
+      throw new MiosaError(
+        "Execution stream ended without a terminal result",
+        502,
+        "EXEC_STREAM_INCOMPLETE",
+        void 0,
+        void 0,
+        false
+      );
+    }
+    return { stdout, stderr, exitCode, exit_code: exitCode };
+  }
   execStream(command, options) {
     this.assertRunning("exec.stream");
     const frames = this.http.streamFrames(
       `/sandboxes/${this.id}/exec/stream`,
       {
         method: "POST",
-        body: execBody(command, options)
+        body: execBody(command, options),
+        signal: options?.signal,
+        ...execDeadline(options)
       }
     );
     return (async function* () {
@@ -9520,7 +9631,9 @@ var Sandbox = class _Sandbox {
       `Sandbox ${this.id} entered terminal state '${state}' while waiting for readiness`,
       502,
       "SANDBOX_BOOT_FAILED",
-      { sandbox_id: this.id, state }
+      { sandbox_id: this.id, state },
+      void 0,
+      false
     );
   }
   /** Best-effort final check so an SSE `event: timeout` does not mask a boot failure that just landed. */
@@ -9612,12 +9725,21 @@ var Sandbox = class _Sandbox {
     }
   }
   async destroy() {
-    if (this.data.state === "destroyed") return;
-    await this.http.delete(`/sandboxes/${this.id}`);
+    if (this.data.state === "destroyed" || this.data.state === "destroying") {
+      return;
+    }
+    const receipt = unwrap48(
+      await this.http.delete(
+        `/sandboxes/${this.id}`
+      )
+    ) ?? {};
+    const settled = receipt.state === "destroyed" || receipt.state === void 0 && receipt.operation_id == null;
     this.data = {
       ...this.data,
-      state: "destroyed",
-      destroyed_at: (/* @__PURE__ */ new Date()).toISOString()
+      state: settled ? "destroyed" : "destroying",
+      ready: false,
+      operation_id: receipt.operation_id ?? this.data.operation_id ?? null,
+      destroyed_at: receipt.destroyed_at ?? this.data.destroyed_at ?? null
     };
   }
   delete() {
@@ -9754,7 +9876,25 @@ var Sandboxes = class {
       await sandbox.resume();
     }
     if (params.waitUntilReady === true) {
-      await sandbox.waitUntilReady({ timeout: params.waitTimeoutSec ?? 60 });
+      const ready = await sandbox.waitUntilReady({
+        timeout: params.waitTimeoutSec ?? 60
+      });
+      if (!ready) {
+        throw new MiosaError(
+          `Sandbox ${sandbox.id} did not become ready before the timeout`,
+          504,
+          "SANDBOX_READY_TIMEOUT"
+        );
+      }
+      await sandbox.refresh();
+      const executable = sandbox.state === "running" && (sandbox.ready || isCommandReady(await sandbox.readiness()));
+      if (!executable) {
+        throw new MiosaError(
+          `Sandbox ${sandbox.id} reported readiness but is not executable`,
+          409,
+          "SANDBOX_NOT_READY"
+        );
+      }
     }
     return sandbox;
   }