@genspark/sb-box 0.0.0-stage → 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1167 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AuthenticationError: () => AuthenticationError,
+  BackgroundCommand: () => BackgroundCommand,
+  ClientDisconnectedError: () => ClientDisconnectedError,
+  CommandTimeoutError: () => CommandTimeoutError,
+  Commands: () => Commands,
+  ConflictError: () => ConflictError,
+  DEFAULT_BASE_URL: () => DEFAULT_BASE_URL,
+  DiskLostError: () => DiskLostError,
+  Files: () => Files,
+  ForbiddenError: () => ForbiddenError,
+  InsufficientCreditsError: () => InsufficientCreditsError,
+  InterpreterStartFailedError: () => InterpreterStartFailedError,
+  InterpreterUnavailableError: () => InterpreterUnavailableError,
+  LimitError: () => LimitError,
+  MemoryExpiredError: () => MemoryExpiredError,
+  NotFoundError: () => NotFoundError,
+  PlanRequiredError: () => PlanRequiredError,
+  Pty: () => Pty,
+  PtySession: () => PtySession,
+  PtyWebSocket: () => PtyWebSocket,
+  RegionRetiredError: () => RegionRetiredError,
+  SDK_VERSION: () => SDK_VERSION,
+  Sandbox: () => Sandbox,
+  Sandboxes: () => Sandboxes,
+  SbBox: () => SbBox,
+  SbBoxConnectionError: () => SbBoxConnectionError,
+  SbBoxError: () => SbBoxError,
+  ServerError: () => ServerError,
+  TemplateBuildError: () => TemplateBuildError,
+  Templates: () => Templates,
+  ValidationError: () => ValidationError,
+  WaitTimeoutError: () => WaitTimeoutError,
+  describeBody: () => describeBody,
+  errorFromResponse: () => errorFromResponse,
+  parseSse: () => parseSse,
+  redact: () => redact
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var KEY_RE = /gsk-[A-Za-z0-9._-]+/g;
+function redact(text) {
+  return text.replace(KEY_RE, "gsk-REDACTED");
+}
+var SbBoxError = class extends Error {
+  status;
+  code;
+  /** Parsed response body (or the raw text when it was not JSON). */
+  detail;
+  /** Seconds from a `Retry-After` header, when the server sent one. */
+  retryAfter;
+  requestId;
+  constructor(init) {
+    super(redact(init.message));
+    this.name = new.target.name;
+    this.status = init.status;
+    this.code = init.code;
+    this.detail = init.detail;
+    this.retryAfter = init.retryAfter;
+    this.requestId = init.requestId;
+  }
+  /** A named field from the error body (`plan`, `limit`, `balance`, `recovery`, …). */
+  field(name) {
+    const d = this.detail;
+    if (d && typeof d === "object") {
+      const o = d;
+      if (name in o) return o[name];
+      const inner = o.detail;
+      if (inner && typeof inner === "object" && name in inner) {
+        return inner[name];
+      }
+    }
+    return void 0;
+  }
+};
+var ValidationError = class extends SbBoxError {
+};
+var AuthenticationError = class extends SbBoxError {
+};
+var InsufficientCreditsError = class extends SbBoxError {
+  get balance() {
+    return this.field("balance");
+  }
+};
+var ForbiddenError = class extends SbBoxError {
+};
+var PlanRequiredError = class extends ForbiddenError {
+  get plan() {
+    return this.field("plan");
+  }
+  get upgrade() {
+    return this.field("upgrade");
+  }
+};
+var NotFoundError = class extends SbBoxError {
+};
+var RegionRetiredError = class extends NotFoundError {
+  get region() {
+    return this.field("region");
+  }
+};
+var CommandTimeoutError = class extends SbBoxError {
+  get killed() {
+    return this.field("killed") === true;
+  }
+};
+var ConflictError = class extends SbBoxError {
+};
+var LimitError = class extends ConflictError {
+  get plan() {
+    return this.field("plan");
+  }
+  get limit() {
+    return this.field("limit");
+  }
+  get current() {
+    return this.field("current");
+  }
+  get requested() {
+    return this.field("requested");
+  }
+};
+var InterpreterUnavailableError = class extends ConflictError {
+};
+var DiskLostError = class extends SbBoxError {
+};
+var MemoryExpiredError = class extends SbBoxError {
+  get recovery() {
+    return this.field("recovery") ?? [];
+  }
+};
+var ClientDisconnectedError = class extends SbBoxError {
+};
+var ServerError = class extends SbBoxError {
+};
+var InterpreterStartFailedError = class extends ServerError {
+};
+var SbBoxConnectionError = class extends SbBoxError {
+  constructor(message, cause) {
+    super({ status: 0, message });
+    if (cause !== void 0) this.cause = cause;
+  }
+};
+var TemplateBuildError = class extends SbBoxError {
+  templateId;
+  buildError;
+  constructor(templateId, buildError, detail) {
+    super({ status: 0, message: `template ${templateId} build failed: ${buildError ?? "unknown error"}`, detail });
+    this.templateId = templateId;
+    this.buildError = buildError;
+  }
+};
+var WaitTimeoutError = class extends SbBoxError {
+  constructor(message) {
+    super({ status: 0, message });
+  }
+};
+function pick(obj, key) {
+  if (obj && typeof obj === "object" && key in obj) return obj[key];
+  return void 0;
+}
+function describeBody(body, fallback) {
+  if (typeof body === "string") return { message: body || fallback };
+  if (!body || typeof body !== "object") return { message: fallback };
+  const detail = pick(body, "detail");
+  if (typeof detail === "string") return { message: detail };
+  if (detail && typeof detail === "object") {
+    const code2 = pick(detail, "code");
+    const msg = pick(detail, "message") ?? pick(detail, "error");
+    return { code: typeof code2 === "string" ? code2 : void 0, message: typeof msg === "string" ? msg : JSON.stringify(detail) };
+  }
+  const err = pick(body, "error");
+  if (typeof err === "string") {
+    const code2 = pick(body, "code");
+    return { code: typeof code2 === "string" ? code2 : void 0, message: err };
+  }
+  const reason = pick(body, "reason");
+  if (typeof reason === "string") {
+    const rec = pick(body, "recovery");
+    return { code: reason, message: Array.isArray(rec) ? `${reason} (recovery: ${rec.join(", ")})` : reason };
+  }
+  const message = pick(body, "message");
+  if (typeof message === "string") {
+    const errors = pick(body, "errors");
+    return { message: Array.isArray(errors) && errors.length ? `${message}: ${JSON.stringify(errors)}` : message };
+  }
+  const code = pick(body, "code");
+  return { code: typeof code === "string" ? code : void 0, message: fallback };
+}
+function errorFromResponse(status, body, headers) {
+  const { code, message } = describeBody(body, `HTTP ${status}`);
+  const ra = headers.get("retry-after");
+  const retryAfter = ra != null && ra !== "" && !Number.isNaN(Number(ra)) ? Number(ra) : void 0;
+  const init = {
+    status,
+    code,
+    message,
+    detail: body,
+    retryAfter,
+    requestId: headers.get("x-request-id") ?? void 0
+  };
+  switch (status) {
+    case 400:
+    case 422:
+      return new ValidationError(init);
+    case 401:
+      return new AuthenticationError(init);
+    case 402:
+      return new InsufficientCreditsError(init);
+    case 403:
+      return code === "sb_box_plan_required" ? new PlanRequiredError(init) : new ForbiddenError(init);
+    case 404:
+      return code === "sb_box_region_retired" ? new RegionRetiredError(init) : new NotFoundError(init);
+    case 408:
+      return new CommandTimeoutError(init);
+    case 409:
+      if (code && code.endsWith("_limit")) return new LimitError(init);
+      if (code === "sb_box_interpreter_unavailable") return new InterpreterUnavailableError(init);
+      return new ConflictError(init);
+    case 410:
+      return new DiskLostError(init);
+    case 428:
+      return new MemoryExpiredError(init);
+    case 499:
+      return new ClientDisconnectedError(init);
+    case 502:
+      return code === "sb_box_interpreter_start_failed" ? new InterpreterStartFailedError(init) : new ServerError(init);
+    default:
+      return status >= 500 ? new ServerError(init) : new SbBoxError(init);
+  }
+}
+
+// src/http.ts
+var SDK_VERSION = "0.1.0";
+var DEFAULT_BASE_URL = "https://www.genspark.ai/api/sb-box/v1";
+var BACKOFF_MS = [500, 1e3, 2e3];
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    const t = setTimeout(resolve, ms);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(t);
+      reject(signal.reason);
+    }, { once: true });
+  });
+}
+var Http = class {
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  url(path, query) {
+    const u = new URL(this.opts.baseUrl.replace(/\/+$/, "") + path);
+    if (query) {
+      for (const [k, v] of Object.entries(query)) {
+        if (v !== void 0 && v !== null && v !== "") u.searchParams.set(k, String(v));
+      }
+    }
+    return u.toString();
+  }
+  async request(path, opts = {}) {
+    const res = await this.send(path, { ...opts, raw: false });
+    return res;
+  }
+  async raw(path, opts = {}) {
+    return await this.send(path, { ...opts, raw: true });
+  }
+  async send(path, opts) {
+    const method = opts.method ?? "GET";
+    const headers = {
+      "X-Api-Key": this.opts.apiKey,
+      "User-Agent": this.opts.userAgent,
+      Accept: opts.raw ? "*/*" : "application/json",
+      ...opts.headers
+    };
+    let body;
+    if (opts.json !== void 0) {
+      headers["Content-Type"] = "application/json";
+      body = JSON.stringify(opts.json);
+    } else if (opts.body !== void 0) {
+      headers["Content-Type"] = opts.contentType ?? "application/octet-stream";
+      body = opts.body;
+    }
+    const url = this.url(path, opts.query);
+    const timeoutMs = (opts.timeout ?? this.opts.timeout) * 1e3;
+    const maxAttempts = opts.retry ? 1 + Math.max(0, this.opts.retries) : 1;
+    let attempt = 0;
+    while (true) {
+      attempt++;
+      const ac = new AbortController();
+      const onAbort = () => ac.abort(opts.signal?.reason);
+      opts.signal?.addEventListener("abort", onAbort, { once: true });
+      const timer = setTimeout(() => ac.abort(new Error(`request timed out after ${timeoutMs / 1e3}s`)), timeoutMs);
+      let res;
+      try {
+        res = await this.opts.fetch(url, { method, headers, body, signal: ac.signal });
+      } catch (e) {
+        clearTimeout(timer);
+        opts.signal?.removeEventListener("abort", onAbort);
+        if (opts.signal?.aborted) throw e;
+        if (opts.retry && attempt < maxAttempts) {
+          await sleep(jitter(BACKOFF_MS[Math.min(attempt - 1, BACKOFF_MS.length - 1)]));
+          continue;
+        }
+        const msg = e instanceof Error ? e.message : String(e);
+        throw new SbBoxConnectionError(`${method} ${path}: ${redact(msg)}`, e);
+      }
+      if (opts.raw && res.ok) {
+        const release = () => {
+          clearTimeout(timer);
+          opts.signal?.removeEventListener("abort", onAbort);
+        };
+        if (opts.bodyDeadline === false || !res.body) {
+          release();
+          return res;
+        }
+        return withBodyDeadline(res, ac.signal, release, `${method} ${path}: stream timed out after ${timeoutMs / 1e3}s`);
+      }
+      if (res.ok) {
+        try {
+          return await this.parseBody(res);
+        } finally {
+          clearTimeout(timer);
+          opts.signal?.removeEventListener("abort", onAbort);
+        }
+      }
+      let parsed;
+      try {
+        parsed = await this.parseBody(res);
+      } catch {
+        parsed = void 0;
+      } finally {
+        clearTimeout(timer);
+        opts.signal?.removeEventListener("abort", onAbort);
+      }
+      const err = errorFromResponse(res.status, parsed, res.headers);
+      if (res.status === 503 && opts.retryOn503Until !== void 0) {
+        const waitMs = (err.retryAfter ?? 2) * 1e3;
+        if (Date.now() + waitMs <= opts.retryOn503Until) {
+          await sleep(waitMs, opts.signal);
+          continue;
+        }
+      }
+      if (opts.retry && attempt < maxAttempts && [502, 503, 504].includes(res.status)) {
+        await sleep(jitter(BACKOFF_MS[Math.min(attempt - 1, BACKOFF_MS.length - 1)]), opts.signal);
+        continue;
+      }
+      throw err;
+    }
+  }
+  async parseBody(res) {
+    const ct = res.headers.get("content-type") ?? "";
+    const text = await res.text();
+    if (!text) return void 0;
+    if (ct.includes("json")) {
+      try {
+        return JSON.parse(text);
+      } catch {
+        return text;
+      }
+    }
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  }
+};
+function withBodyDeadline(res, signal, release, timeoutMsg) {
+  const reader = res.body.getReader();
+  const body = new ReadableStream({
+    async pull(controller) {
+      let chunk;
+      try {
+        chunk = await reader.read();
+      } catch (e) {
+        release();
+        const err = signal.aborted ? new SbBoxConnectionError(redact(timeoutMsg), e) : new SbBoxConnectionError(redact(e instanceof Error ? e.message : String(e)), e);
+        controller.error(err);
+        return;
+      }
+      if (chunk.done) {
+        release();
+        controller.close();
+        return;
+      }
+      controller.enqueue(chunk.value);
+    },
+    async cancel(reason) {
+      release();
+      await reader.cancel(reason).catch(() => void 0);
+    }
+  });
+  return new Response(body, { status: res.status, statusText: res.statusText, headers: res.headers });
+}
+function jitter(ms) {
+  return ms * (0.75 + Math.random() * 0.5);
+}
+function ensureStringMap(name, m) {
+  if (m === void 0) return void 0;
+  for (const [k, v] of Object.entries(m)) {
+    if (typeof v !== "string") {
+      throw new SbBoxError({ status: 0, message: `${name}.${k} must be a string (got ${typeof v})` });
+    }
+  }
+  return m;
+}
+
+// src/sse.ts
+async function* parseSse(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+  let event = "";
+  let data = [];
+  let id;
+  const flush = () => {
+    if (!event && data.length === 0) return void 0;
+    const msg = { event: event || "message", data: data.join("\n"), id };
+    event = "";
+    data = [];
+    id = void 0;
+    return msg;
+  };
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buf += decoder.decode(value, { stream: true });
+      let nl;
+      while ((nl = buf.indexOf("\n")) >= 0) {
+        let line = buf.slice(0, nl);
+        buf = buf.slice(nl + 1);
+        if (line.endsWith("\r")) line = line.slice(0, -1);
+        if (line === "") {
+          const m2 = flush();
+          if (m2) yield m2;
+          continue;
+        }
+        if (line.startsWith(":")) continue;
+        const colon = line.indexOf(":");
+        const field = colon < 0 ? line : line.slice(0, colon);
+        let value2 = colon < 0 ? "" : line.slice(colon + 1);
+        if (value2.startsWith(" ")) value2 = value2.slice(1);
+        if (field === "event") event = value2;
+        else if (field === "data") data.push(value2);
+        else if (field === "id") id = value2;
+      }
+    }
+    buf += decoder.decode();
+    if (buf.trim()) {
+      const colon = buf.indexOf(":");
+      const field = colon < 0 ? buf : buf.slice(0, colon);
+      const value = colon < 0 ? "" : buf.slice(colon + 1).replace(/^ /, "");
+      if (field === "data") data.push(value);
+      else if (field === "event") event = value;
+    }
+    const m = flush();
+    if (m) yield m;
+  } finally {
+    reader.releaseLock();
+  }
+}
+function parseJsonData(msg) {
+  if (!msg.data) return void 0;
+  try {
+    return JSON.parse(msg.data);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/sandbox.ts
+var DEFAULT_SHELL = ["/bin/sh", "-c"];
+function argv(command) {
+  if (typeof command === "string") return [...DEFAULT_SHELL, command];
+  if (!Array.isArray(command) || command.length === 0) throw new TypeError("command must be a non-empty argv array or a shell string");
+  return command;
+}
+function execBody(command, opts, withTimeout, max) {
+  const body = { command: argv(command) };
+  if (opts.cwd) body.cwd = opts.cwd;
+  const env2 = ensureStringMap("envVars", opts.envVars);
+  if (env2) body.envVars = env2;
+  if (opts.user) body.user = opts.user;
+  if (withTimeout) {
+    const t = opts.timeout ?? 60;
+    if (max !== void 0 && t > max) throw new RangeError(`timeout must be <= ${max} seconds`);
+    body.timeout = t;
+  }
+  return body;
+}
+async function* execEvents(res) {
+  if (!res.body) return;
+  let execId;
+  for await (const m of parseSse(res.body)) {
+    const d = parseJsonData(m) ?? {};
+    switch (m.event) {
+      case "execId":
+        execId = typeof d.execId === "string" ? d.execId : void 0;
+        break;
+      case "stdout":
+      case "stderr":
+        yield { kind: m.event, data: String(d.data ?? ""), execId };
+        break;
+      case "exit":
+        yield { kind: "exit", exitCode: Number(d.exitCode ?? 0), execId };
+        return;
+      case "error":
+        yield { kind: "error", data: String(d.error ?? m.data), stage: typeof d.stage === "string" ? d.stage : void 0, execId };
+        return;
+      default:
+        break;
+    }
+  }
+}
+var BackgroundCommand = class {
+  constructor(http, sandboxId, execId, pid) {
+    this.http = http;
+    this.sandboxId = sandboxId;
+    this.execId = execId;
+    this.pid = pid;
+  }
+  http;
+  sandboxId;
+  execId;
+  pid;
+  p(suffix) {
+    return `/sandboxes/${encodeURIComponent(this.sandboxId)}/commands/${encodeURIComponent(this.execId)}${suffix}`;
+  }
+  async input(data) {
+    const r = await this.http.request(this.p("/input"), { method: "POST", json: { data } });
+    return r.written;
+  }
+  async close() {
+    await this.http.request(this.p("/close"), { method: "POST" });
+  }
+  /** Block until the command exits; returns its exit code. `timeout` is seconds (default 600). */
+  async wait(timeout = 600) {
+    const r = await this.http.request(this.p("/wait"), { method: "POST", timeout: timeout + 30 });
+    return r.exitCode;
+  }
+  async kill(signal = 9) {
+    await this.http.request(`/sandboxes/${encodeURIComponent(this.sandboxId)}/commands/kill`, {
+      method: "POST",
+      json: { pid: this.pid, signal }
+    });
+  }
+  /** Stream the command's output. Resolves to an empty stream if the server already reaped it. */
+  async *connect() {
+    let res;
+    try {
+      res = await this.http.raw(this.p("/connect"), { headers: { Accept: "text/event-stream" }, timeout: 3600, bodyDeadline: false });
+    } catch (e) {
+      if (e instanceof NotFoundError) return;
+      throw e;
+    }
+    yield* execEvents(res);
+  }
+};
+var Commands = class {
+  constructor(http, sandboxId) {
+    this.http = http;
+    this.sandboxId = sandboxId;
+  }
+  http;
+  sandboxId;
+  p(suffix) {
+    return `/sandboxes/${encodeURIComponent(this.sandboxId)}/commands${suffix}`;
+  }
+  async start(command, opts = {}) {
+    const r = await this.http.request(this.p("/start"), {
+      method: "POST",
+      json: execBody(command, opts, false),
+      timeout: 120
+    });
+    return new BackgroundCommand(this.http, this.sandboxId, r.execId, r.pid);
+  }
+  async list() {
+    return this.http.request(this.p(""), { retry: true });
+  }
+  async kill(pid, signal = 9) {
+    await this.http.request(this.p("/kill"), { method: "POST", json: { pid, signal } });
+  }
+  async sendStdin(pid, data) {
+    await this.http.request(this.p("/send-stdin"), { method: "POST", json: { pid, data } });
+  }
+};
+var Files = class {
+  constructor(http, sandboxId) {
+    this.http = http;
+    this.sandboxId = sandboxId;
+  }
+  http;
+  sandboxId;
+  p(suffix) {
+    return `/sandboxes/${encodeURIComponent(this.sandboxId)}/files${suffix}`;
+  }
+  /** Write bytes (or a UTF-8 string). Returns the byte count written. */
+  async write(path, data, opts = {}) {
+    const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    const r = await this.http.request(this.p("/stream"), {
+      method: "POST",
+      body: bytes,
+      query: { path, user: opts.user },
+      timeout: 600
+    });
+    return r.written;
+  }
+  async read(path, opts = {}) {
+    const res = await this.http.raw(this.p("/stream"), { query: { path, user: opts.user }, timeout: 600, retry: true });
+    return new Uint8Array(await res.arrayBuffer());
+  }
+  async readText(path, opts = {}) {
+    const bytes = await this.read(path, opts);
+    return new TextDecoder(opts.encoding ?? "utf-8").decode(bytes);
+  }
+  async list(path = "/", opts = {}) {
+    return this.http.request(this.p("/list"), { query: { path, user: opts.user }, retry: true });
+  }
+};
+var PtySession = class {
+  constructor(http, sandboxId, execId, pid) {
+    this.http = http;
+    this.sandboxId = sandboxId;
+    this.execId = execId;
+    this.pid = pid;
+  }
+  http;
+  sandboxId;
+  execId;
+  pid;
+  p(suffix) {
+    return `/sandboxes/${encodeURIComponent(this.sandboxId)}/pty/${encodeURIComponent(this.execId)}${suffix}`;
+  }
+  async input(data) {
+    const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    await this.http.request(this.p("/input"), { method: "POST", body: bytes });
+  }
+  async resize(rows, cols) {
+    await this.http.request(this.p("/resize"), { method: "POST", json: { rows, cols } });
+  }
+  async kill() {
+    await this.http.request(this.p("/kill"), { method: "POST" });
+  }
+  /** Stream terminal output (SSE). Ends with a `exit` event. */
+  async *connect() {
+    const res = await this.http.raw(this.p("/connect"), { headers: { Accept: "text/event-stream" }, timeout: 3600, bodyDeadline: false });
+    if (!res.body) return;
+    for await (const m of parseSse(res.body)) {
+      const d = parseJsonData(m) ?? {};
+      if (m.event === "data") yield { kind: "data", data: String(d.data ?? "") };
+      else if (m.event === "exit") {
+        yield { kind: "exit", exitCode: d.exitCode === void 0 ? void 0 : Number(d.exitCode), reason: typeof d.reason === "string" ? d.reason : void 0 };
+        return;
+      }
+    }
+  }
+};
+var PtyWebSocket = class {
+  constructor(ws) {
+    this.ws = ws;
+  }
+  ws;
+  input(data) {
+    this.ws.send(JSON.stringify({ type: "stdin", data }));
+  }
+  resize(rows, cols) {
+    this.ws.send(JSON.stringify({ type: "resize", rows, cols }));
+  }
+  kill() {
+    this.ws.send(JSON.stringify({ type: "kill" }));
+  }
+  close() {
+    this.ws.close();
+  }
+};
+var Pty = class {
+  constructor(http, sandboxId) {
+    this.http = http;
+    this.sandboxId = sandboxId;
+  }
+  http;
+  sandboxId;
+  async open(opts = {}) {
+    const json = {
+      command: opts.command ?? ["/bin/bash"],
+      rows: opts.rows ?? 24,
+      cols: opts.cols ?? 80
+    };
+    if (opts.cwd) json.cwd = opts.cwd;
+    const env2 = ensureStringMap("envVars", opts.envVars);
+    if (env2) json.envVars = env2;
+    const r = await this.http.request(
+      `/sandboxes/${encodeURIComponent(this.sandboxId)}/pty`,
+      { method: "POST", json, timeout: 120 }
+    );
+    return new PtySession(this.http, this.sandboxId, r.execId, r.pid);
+  }
+  /**
+   * Open a terminal over WebSocket. Uses the global `WebSocket` (Node 22+, browsers) or the
+   * optional `ws` package. Resolves once the socket is open and the start frame is sent.
+   */
+  async connectWs(opts = {}, handlers = {}) {
+    const url = new URL(this.http.url(`/sandboxes/${encodeURIComponent(this.sandboxId)}/ws/pty`));
+    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+    const headers = { "X-Api-Key": this.http.opts.apiKey, "User-Agent": this.http.opts.userAgent };
+    let ws;
+    const G = globalThis;
+    if (G.WebSocket) {
+      url.searchParams.set("api_key", this.http.opts.apiKey);
+      ws = new G.WebSocket(url.toString());
+    } else {
+      let mod;
+      try {
+        mod = await import("ws");
+      } catch {
+        throw new SbBoxError({ status: 0, message: "pty.connectWs needs a WebSocket implementation: upgrade to Node 22+ or `npm install ws`" });
+      }
+      const Ctor = mod.default ?? mod.WebSocket;
+      ws = new Ctor(url.toString(), { headers });
+    }
+    await new Promise((resolve, reject) => {
+      ws.addEventListener("open", () => resolve());
+      ws.addEventListener("error", (ev) => reject(new SbBoxError({ status: 0, message: `pty websocket error: ${ev.message ?? "connection failed"}` })));
+    });
+    const start = {};
+    if (opts.command) start.command = opts.command;
+    if (opts.cwd) start.cwd = opts.cwd;
+    if (opts.rows) start.rows = opts.rows;
+    if (opts.cols) start.cols = opts.cols;
+    if (opts.envVars) start.envVars = ensureStringMap("envVars", opts.envVars);
+    ws.send(JSON.stringify(start));
+    ws.addEventListener("message", (ev) => {
+      let frame;
+      try {
+        frame = JSON.parse(String(ev.data));
+      } catch {
+        return;
+      }
+      if (frame.type === "stdout") handlers.onData?.(String(frame.data ?? ""), typeof frame.seq === "number" ? frame.seq : void 0);
+      else if (frame.type === "exit") handlers.onExit?.(Number(frame.exitCode ?? 0));
+      else if (frame.type === "error") handlers.onError?.(String(frame.error ?? ""));
+    });
+    return new PtyWebSocket(ws);
+  }
+};
+var Sandbox = class _Sandbox {
+  constructor(http, info) {
+    this.http = http;
+    this._info = info;
+    this.commands = new Commands(http, info.id);
+    this.files = new Files(http, info.id);
+    this.pty = new Pty(http, info.id);
+  }
+  http;
+  commands;
+  files;
+  pty;
+  _info;
+  /** The last record seen for this sandbox (call `refresh()` to update). */
+  get info() {
+    return this._info;
+  }
+  get id() {
+    return this._info.id;
+  }
+  get state() {
+    return this._info.state;
+  }
+  get templateId() {
+    return this._info.templateId ?? this._info.template_id;
+  }
+  get region() {
+    return this._info.region;
+  }
+  get metadata() {
+    return this._info.metadata ?? {};
+  }
+  get versions() {
+    return this._info.versions ?? [];
+  }
+  get createdAt() {
+    return this._info.createdAt ?? this._info.created_at;
+  }
+  get frozenAt() {
+    return this._info.frozenAt;
+  }
+  get timeoutAt() {
+    return this._info.timeoutAt;
+  }
+  /** Token to reach a sandbox created with `allowPublicTraffic: false` (create response only). */
+  get trafficAccessToken() {
+    return this._info.trafficAccessToken;
+  }
+  /** Public URL of a port inside the sandbox. */
+  portUrl(port) {
+    const tpl = this._info.portUrl;
+    if (!tpl) throw new SbBoxError({ status: 0, message: `sandbox ${this.id} has no portUrl` });
+    return tpl.replace("{port}", String(port));
+  }
+  p(suffix = "") {
+    return `/sandboxes/${encodeURIComponent(this.id)}${suffix}`;
+  }
+  update(info) {
+    this._info = { ...this._info, ...info };
+    return this;
+  }
+  async refresh() {
+    return this.update(await this.http.request(this.p(), { retry: true }));
+  }
+  async kill() {
+    await this.http.request(this.p(), { method: "DELETE", retry: true });
+  }
+  /** Freeze. The server may answer 202 (still freezing); with `wait` (default) we poll until `frozen`. */
+  async freeze(opts = {}) {
+    const r = await this.http.request(this.p("/freeze"), { method: "POST", retry: true, timeout: 120 });
+    if (r.id) this.update(r);
+    else if (r.state) this._info = { ...this._info, state: r.state };
+    if (opts.wait === false || this.state === "frozen") return this;
+    return this.waitForState("frozen", { timeout: opts.timeout ?? 90, interval: opts.interval ?? 2 });
+  }
+  async waitForState(target, opts = {}) {
+    const targets = Array.isArray(target) ? target : [target];
+    const deadline = Date.now() + (opts.timeout ?? 90) * 1e3;
+    const interval = (opts.interval ?? 2) * 1e3;
+    while (true) {
+      await this.refresh();
+      if (targets.includes(this.state)) return this;
+      if (Date.now() + interval > deadline) {
+        throw new WaitTimeoutError(`sandbox ${this.id} is ${this.state}, not ${targets.join("/")}, after ${opts.timeout ?? 90}s`);
+      }
+      await new Promise((r) => setTimeout(r, interval));
+    }
+  }
+  async resume(opts = {}) {
+    const json = {};
+    if (opts.timeout !== void 0) json.timeout = opts.timeout;
+    return this.update(await this.http.request(this.p("/resume"), { method: "POST", json, retry: true, timeout: 120 }));
+  }
+  async rollback(opts = {}) {
+    const json = { version: opts.version ?? 0 };
+    if (opts.timeout !== void 0) json.timeout = opts.timeout;
+    return this.update(await this.http.request(this.p("/rollback"), { method: "POST", json, timeout: 120 }));
+  }
+  /** Clone into a new sandbox owned by the caller. Retries on 503 + Retry-After until `timeout` (s). */
+  async clone(opts = {}) {
+    const json = { version: opts.version ?? 0 };
+    const md = ensureStringMap("metadata", opts.metadata);
+    if (md) json.metadata = md;
+    const total = opts.timeout ?? 120;
+    const info = await this.http.request(this.p("/clone"), {
+      method: "POST",
+      json,
+      timeout: 120,
+      retryOn503Until: Date.now() + total * 1e3
+    });
+    return new _Sandbox(this.http, info);
+  }
+  /** Set the lifetime deadline in seconds from now; 0 clears it. */
+  async setTimeout(seconds) {
+    await this.http.request(this.p("/timeout"), { method: "POST", json: { timeout: seconds }, retry: true });
+  }
+  async reset(opts = {}) {
+    const total = opts.timeout ?? 120;
+    return this.update(await this.http.request(this.p("/reset"), {
+      method: "POST",
+      timeout: 120,
+      retryOn503Until: Date.now() + total * 1e3
+    }));
+  }
+  async metrics(opts = {}) {
+    return this.http.request(this.p("/metrics"), { query: { start: opts.start, end: opts.end }, retry: true });
+  }
+  async grant(userId, opts = {}) {
+    const json = { perm: opts.perm ?? "read" };
+    if (opts.expiresAt) json.expires_at = opts.expiresAt;
+    if (opts.reason) json.reason = opts.reason;
+    return this.http.request(this.p(`/grants/${encodeURIComponent(userId)}`), { method: "PUT", json });
+  }
+  async grants() {
+    return this.http.request(this.p("/grants"), { retry: true });
+  }
+  async revoke(userId) {
+    await this.http.request(this.p(`/grants/${encodeURIComponent(userId)}`), { method: "DELETE" });
+  }
+  /** Run a command and wait for it. A non-zero exit is returned, not thrown. */
+  async exec(command, opts = {}) {
+    const body = execBody(command, opts, true, 600);
+    return this.http.request(this.p("/exec"), {
+      method: "POST",
+      json: body,
+      timeout: body.timeout + 30
+    });
+  }
+  /** Run a command and stream its output as it is produced. */
+  async *execStream(command, opts = {}) {
+    const body = execBody(command, opts, true, 600);
+    const res = await this.http.raw(this.p("/sse/exec"), {
+      method: "POST",
+      json: body,
+      headers: { Accept: "text/event-stream" },
+      timeout: body.timeout + 30
+    });
+    yield* execEvents(res);
+  }
+  /** Execute code in the sandbox's stateful interpreter. */
+  async runCode(code, opts = {}) {
+    const timeout = opts.timeout ?? 60;
+    if (timeout > 540) throw new RangeError("runCode timeout must be <= 540 seconds");
+    const json = { code, language: opts.language ?? "python", timeout };
+    if (opts.contextId) json.contextId = opts.contextId;
+    const env2 = ensureStringMap("envVars", opts.envVars);
+    if (env2) json.envVars = env2;
+    if (opts.images) json.images = opts.images;
+    return this.http.request(this.p("/run-code"), { method: "POST", json, timeout: timeout + 30 });
+  }
+};
+
+// src/templates.ts
+var Templates = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /** Start a build. Async: poll `get()` or use `waitReady()`. */
+  async build(opts) {
+    if (!opts.image && !opts.dockerfile) throw new TypeError("templates.build: image or dockerfile is required");
+    const body = {};
+    for (const [k, v] of Object.entries(opts)) if (v !== void 0) body[k] = v;
+    return this.http.request("/templates/build", { method: "POST", json: body, timeout: 120 });
+  }
+  /** Poll until the template is `ready`; throws `TemplateBuildError` on `error`. */
+  async waitReady(templateId, opts = {}) {
+    const timeout = (opts.timeout ?? 600) * 1e3;
+    const interval = (opts.interval ?? 5) * 1e3;
+    const deadline = Date.now() + timeout;
+    while (true) {
+      const t = await this.get(templateId);
+      if (t.status === "ready") return t;
+      if (t.status === "error") throw new TemplateBuildError(templateId, t.buildError, t);
+      if (Date.now() + interval > deadline) {
+        throw new WaitTimeoutError(`template ${templateId} still ${t.status} after ${timeout / 1e3}s`);
+      }
+      await new Promise((r) => setTimeout(r, interval));
+    }
+  }
+  async list() {
+    const r = await this.http.request("/templates", { retry: true });
+    return r.templates ?? [];
+  }
+  async shared() {
+    return this.http.request("/templates/shared", { retry: true });
+  }
+  async get(templateId) {
+    return this.http.request(`/templates/${encodeURIComponent(templateId)}`, { retry: true });
+  }
+  async delete(templateId) {
+    await this.http.request(`/templates/${encodeURIComponent(templateId)}`, { method: "DELETE" });
+  }
+  async grant(templateId, userId, opts = {}) {
+    const json = { perm: opts.perm ?? "read" };
+    if (opts.expiresAt) json.expires_at = opts.expiresAt;
+    if (opts.reason) json.reason = opts.reason;
+    return this.http.request(
+      `/templates/${encodeURIComponent(templateId)}/grants/${encodeURIComponent(userId)}`,
+      { method: "PUT", json }
+    );
+  }
+  async grants(templateId) {
+    return this.http.request(`/templates/${encodeURIComponent(templateId)}/grants`, { retry: true });
+  }
+  async revoke(templateId, userId) {
+    await this.http.request(
+      `/templates/${encodeURIComponent(templateId)}/grants/${encodeURIComponent(userId)}`,
+      { method: "DELETE" }
+    );
+  }
+};
+
+// src/client.ts
+function env(name) {
+  const p = globalThis.process;
+  return p?.env?.[name];
+}
+var Sandboxes = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  async create(opts = {}) {
+    const json = {};
+    if (opts.templateId) json.templateId = opts.templateId;
+    else json.templateName = opts.template ?? "base";
+    if (opts.timeout !== void 0) json.timeout = opts.timeout;
+    if (opts.onTimeout) json.lifecycle = { onTimeout: opts.onTimeout };
+    const md = ensureStringMap("metadata", opts.metadata);
+    if (md) json.metadata = md;
+    const ev = ensureStringMap("envVars", opts.envVars);
+    if (ev) json.envVars = ev;
+    if (opts.network) json.network = opts.network;
+    const info = await this.http.request("/sandboxes", { method: "POST", json, timeout: 120 });
+    return new Sandbox(this.http, info);
+  }
+  /** Compact rows. `state` filters (one or many); omitted = every live state. */
+  async list(state) {
+    const s = state === void 0 ? void 0 : Array.isArray(state) ? state.join(",") : state;
+    const r = await this.http.request("/sandboxes", { query: { state: s }, retry: true });
+    return r.sandboxes ?? [];
+  }
+  async shared() {
+    const rows = await this.http.request("/sandboxes/shared", { retry: true });
+    return rows.map((r) => new Sandbox(this.http, r));
+  }
+  async get(sandboxId) {
+    const info = await this.http.request(`/sandboxes/${encodeURIComponent(sandboxId)}`, { retry: true });
+    return new Sandbox(this.http, info);
+  }
+  /** Alias of `get()`. */
+  connect(sandboxId) {
+    return this.get(sandboxId);
+  }
+  handle(id) {
+    return new Sandbox(this.http, { id, state: "unknown" });
+  }
+  async kill(sandboxId) {
+    return this.handle(sandboxId).kill();
+  }
+  async freeze(sandboxId, opts = {}) {
+    return this.handle(sandboxId).freeze(opts);
+  }
+  async resume(sandboxId, opts = {}) {
+    return this.handle(sandboxId).resume(opts);
+  }
+  async rollback(sandboxId, opts = {}) {
+    return this.handle(sandboxId).rollback(opts);
+  }
+  async clone(sandboxId, opts = {}) {
+    return this.handle(sandboxId).clone(opts);
+  }
+  async setTimeout(sandboxId, seconds) {
+    return this.handle(sandboxId).setTimeout(seconds);
+  }
+  async reset(sandboxId, opts = {}) {
+    return this.handle(sandboxId).reset(opts);
+  }
+  async metrics(sandboxId, opts = {}) {
+    return this.handle(sandboxId).metrics(opts);
+  }
+  async grant(sandboxId, userId, opts = {}) {
+    return this.handle(sandboxId).grant(userId, opts);
+  }
+  async grants(sandboxId) {
+    return this.handle(sandboxId).grants();
+  }
+  async revoke(sandboxId, userId) {
+    return this.handle(sandboxId).revoke(userId);
+  }
+};
+var SbBox = class {
+  templates;
+  sandboxes;
+  baseUrl;
+  http;
+  constructor(opts = {}) {
+    const apiKey = opts.apiKey ?? env("SBBOX_API_KEY") ?? env("GSK_API_KEY");
+    if (!apiKey) {
+      throw new SbBoxError({ status: 0, message: "SB-Box API key missing: pass { apiKey } or set SBBOX_API_KEY (or GSK_API_KEY)" });
+    }
+    const f = opts.fetch ?? globalThis.fetch;
+    if (typeof f !== "function") {
+      throw new SbBoxError({ status: 0, message: "global fetch is not available: use Node 18+ or pass { fetch }" });
+    }
+    this.baseUrl = (opts.baseUrl ?? env("SBBOX_BASE_URL") ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    const ua = `sbbox-typescript-sdk/${SDK_VERSION} (+https://www.genspark.ai/sb-box/docs)` + (opts.userAgentSuffix ? ` ${opts.userAgentSuffix}` : "");
+    this.http = new Http({
+      apiKey,
+      baseUrl: this.baseUrl,
+      timeout: opts.timeout ?? 60,
+      retries: opts.retries ?? 3,
+      userAgent: ua,
+      fetch: f
+    });
+    this.templates = new Templates(this.http);
+    this.sandboxes = new Sandboxes(this.http);
+  }
+  regions() {
+    return this.http.request("/regions", { retry: true });
+  }
+  limits() {
+    return this.http.request("/limits", { retry: true });
+  }
+  usage(days = 30) {
+    return this.http.request("/usage", { query: { days }, retry: true });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthenticationError,
+  BackgroundCommand,
+  ClientDisconnectedError,
+  CommandTimeoutError,
+  Commands,
+  ConflictError,
+  DEFAULT_BASE_URL,
+  DiskLostError,
+  Files,
+  ForbiddenError,
+  InsufficientCreditsError,
+  InterpreterStartFailedError,
+  InterpreterUnavailableError,
+  LimitError,
+  MemoryExpiredError,
+  NotFoundError,
+  PlanRequiredError,
+  Pty,
+  PtySession,
+  PtyWebSocket,
+  RegionRetiredError,
+  SDK_VERSION,
+  Sandbox,
+  Sandboxes,
+  SbBox,
+  SbBoxConnectionError,
+  SbBoxError,
+  ServerError,
+  TemplateBuildError,
+  Templates,
+  ValidationError,
+  WaitTimeoutError,
+  describeBody,
+  errorFromResponse,
+  parseSse,
+  redact
+});
+//# sourceMappingURL=index.cjs.map