@alibaba-group/opensandbox 0.1.1-dev0 → 0.1.2-dev0

package/dist/chunk-NFNOESEY.js

@@ -0,0 +1,926 @@
+// src/core/exceptions.ts
+var SandboxError = class {
+  constructor(code, message) {
+    this.code = code;
+    this.message = message;
+  }
+  static INTERNAL_UNKNOWN_ERROR = "INTERNAL_UNKNOWN_ERROR";
+  static READY_TIMEOUT = "READY_TIMEOUT";
+  static UNHEALTHY = "UNHEALTHY";
+  static INVALID_ARGUMENT = "INVALID_ARGUMENT";
+  static UNEXPECTED_RESPONSE = "UNEXPECTED_RESPONSE";
+};
+var SandboxException = class extends Error {
+  name = "SandboxException";
+  error;
+  cause;
+  constructor(opts = {}) {
+    super(opts.message);
+    this.cause = opts.cause;
+    this.error = opts.error ?? new SandboxError(SandboxError.INTERNAL_UNKNOWN_ERROR);
+  }
+};
+var SandboxApiException = class extends SandboxException {
+  name = "SandboxApiException";
+  statusCode;
+  requestId;
+  rawBody;
+  constructor(opts) {
+    super({
+      message: opts.message,
+      cause: opts.cause,
+      error: opts.error ?? new SandboxError(SandboxError.UNEXPECTED_RESPONSE, opts.message)
+    });
+    this.statusCode = opts.statusCode;
+    this.requestId = opts.requestId;
+    this.rawBody = opts.rawBody;
+  }
+};
+var SandboxInternalException = class extends SandboxException {
+  name = "SandboxInternalException";
+  constructor(opts) {
+    super({
+      message: opts.message,
+      cause: opts.cause,
+      error: new SandboxError(SandboxError.INTERNAL_UNKNOWN_ERROR, opts.message)
+    });
+  }
+};
+var SandboxUnhealthyException = class extends SandboxException {
+  name = "SandboxUnhealthyException";
+  constructor(opts) {
+    super({
+      message: opts.message,
+      cause: opts.cause,
+      error: new SandboxError(SandboxError.UNHEALTHY, opts.message)
+    });
+  }
+};
+var SandboxReadyTimeoutException = class extends SandboxException {
+  name = "SandboxReadyTimeoutException";
+  constructor(opts) {
+    super({
+      message: opts.message,
+      cause: opts.cause,
+      error: new SandboxError(SandboxError.READY_TIMEOUT, opts.message)
+    });
+  }
+};
+var InvalidArgumentException = class extends SandboxException {
+  name = "InvalidArgumentException";
+  constructor(opts) {
+    super({
+      message: opts.message,
+      cause: opts.cause,
+      error: new SandboxError(SandboxError.INVALID_ARGUMENT, opts.message)
+    });
+  }
+};
+
+// src/openapi/execdClient.ts
+import createClient from "openapi-fetch";
+function createExecdClient(opts) {
+  return createClient({
+    baseUrl: opts.baseUrl,
+    headers: opts.headers,
+    fetch: opts.fetch
+  });
+}
+
+// src/openapi/lifecycleClient.ts
+import createClient2 from "openapi-fetch";
+function readEnvApiKey() {
+  const env = globalThis?.process?.env;
+  const v = env?.OPEN_SANDBOX_API_KEY;
+  return typeof v === "string" && v.length ? v : void 0;
+}
+function createLifecycleClient(opts = {}) {
+  const apiKey = opts.apiKey ?? readEnvApiKey();
+  const headers = {
+    ...opts.headers ?? {}
+  };
+  if (apiKey && !headers["OPEN-SANDBOX-API-KEY"]) {
+    headers["OPEN-SANDBOX-API-KEY"] = apiKey;
+  }
+  return createClient2({
+    baseUrl: opts.baseUrl ?? "http://localhost:8080/v1",
+    headers,
+    fetch: opts.fetch
+  });
+}
+
+// src/models/executionEventDispatcher.ts
+function extractText(results) {
+  if (!results || typeof results !== "object") return void 0;
+  const r = results;
+  const v = r["text/plain"] ?? r.text ?? r.textPlain;
+  return v == null ? void 0 : String(v);
+}
+var ExecutionEventDispatcher = class {
+  constructor(execution, handlers) {
+    this.execution = execution;
+    this.handlers = handlers;
+  }
+  async dispatch(ev) {
+    await this.handlers?.onEvent?.(ev);
+    const ts = ev.timestamp ?? Date.now();
+    switch (ev.type) {
+      case "init": {
+        const id = ev.text ?? "";
+        if (id) this.execution.id = id;
+        const init = { id, timestamp: ts };
+        await this.handlers?.onInit?.(init);
+        return;
+      }
+      case "stdout": {
+        const msg = { text: ev.text ?? "", timestamp: ts, isError: false };
+        this.execution.logs.stdout.push(msg);
+        await this.handlers?.onStdout?.(msg);
+        return;
+      }
+      case "stderr": {
+        const msg = { text: ev.text ?? "", timestamp: ts, isError: true };
+        this.execution.logs.stderr.push(msg);
+        await this.handlers?.onStderr?.(msg);
+        return;
+      }
+      case "result": {
+        const r = { text: extractText(ev.results), timestamp: ts, raw: ev.results };
+        this.execution.result.push(r);
+        await this.handlers?.onResult?.(r);
+        return;
+      }
+      case "execution_count": {
+        const c = ev.execution_count;
+        if (typeof c === "number") this.execution.executionCount = c;
+        return;
+      }
+      case "execution_complete": {
+        const ms = ev.execution_time;
+        const complete = { timestamp: ts, executionTimeMs: typeof ms === "number" ? ms : 0 };
+        this.execution.complete = complete;
+        await this.handlers?.onExecutionComplete?.(complete);
+        return;
+      }
+      case "error": {
+        const e = ev.error;
+        if (e) {
+          const err = {
+            name: String(e.ename ?? e.name ?? ""),
+            value: String(e.evalue ?? e.value ?? ""),
+            timestamp: ts,
+            traceback: Array.isArray(e.traceback) ? e.traceback.map(String) : []
+          };
+          this.execution.error = err;
+          await this.handlers?.onError?.(err);
+        }
+        return;
+      }
+      default:
+        return;
+    }
+  }
+};
+
+// src/adapters/openapiError.ts
+function throwOnOpenApiFetchError(result, fallbackMessage) {
+  if (!result.error) return;
+  const requestId = result.response.headers.get("x-request-id") ?? void 0;
+  const status = result.response.status ?? 0;
+  const err = result.error;
+  const message = err?.message ?? err?.error?.message ?? fallbackMessage;
+  const code = err?.code ?? err?.error?.code;
+  const msg = err?.message ?? err?.error?.message ?? message;
+  throw new SandboxApiException({
+    message: msg,
+    statusCode: status,
+    requestId,
+    error: code ? new SandboxError(String(code), String(msg ?? "")) : new SandboxError(SandboxError.UNEXPECTED_RESPONSE, String(msg ?? "")),
+    rawBody: result.error
+  });
+}
+
+// src/adapters/sse.ts
+function tryParseJson(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return void 0;
+  }
+}
+async function* parseJsonEventStream(res, opts) {
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    const parsed = tryParseJson(text);
+    const err = parsed && typeof parsed === "object" ? parsed : void 0;
+    const requestId = res.headers.get("x-request-id") ?? void 0;
+    const message = err?.message ?? opts?.fallbackErrorMessage ?? `Stream request failed (status=${res.status})`;
+    const code = err?.code ? String(err.code) : SandboxError.UNEXPECTED_RESPONSE;
+    throw new SandboxApiException({
+      message,
+      statusCode: res.status,
+      requestId,
+      error: new SandboxError(code, err?.message ? String(err.message) : message),
+      rawBody: parsed ?? text
+    });
+  }
+  if (!res.body) {
+    return;
+  }
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder("utf-8");
+  let buf = "";
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buf += decoder.decode(value, { stream: true });
+    let idx;
+    while ((idx = buf.indexOf("\n")) >= 0) {
+      const rawLine = buf.slice(0, idx);
+      buf = buf.slice(idx + 1);
+      const line = rawLine.trim();
+      if (!line) continue;
+      if (line.startsWith(":")) continue;
+      if (line.startsWith("event:") || line.startsWith("id:") || line.startsWith("retry:")) continue;
+      const jsonLine = line.startsWith("data:") ? line.slice("data:".length).trim() : line;
+      if (!jsonLine) continue;
+      const parsed = tryParseJson(jsonLine);
+      if (!parsed) continue;
+      yield parsed;
+    }
+  }
+  buf += decoder.decode();
+  const last = buf.trim();
+  if (last) {
+    const jsonLine = last.startsWith("data:") ? last.slice("data:".length).trim() : last;
+    const parsed = tryParseJson(jsonLine);
+    if (parsed) yield parsed;
+  }
+}
+
+// src/adapters/commandsAdapter.ts
+function joinUrl(baseUrl, pathname) {
+  const base = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  const path = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  return `${base}${path}`;
+}
+function toRunCommandRequest(command, opts) {
+  return {
+    command,
+    cwd: opts?.workingDirectory,
+    background: !!opts?.background
+  };
+}
+var CommandsAdapter = class {
+  constructor(client, opts) {
+    this.client = client;
+    this.opts = opts;
+    this.fetch = opts.fetch ?? fetch;
+  }
+  fetch;
+  async interrupt(sessionId) {
+    const { error, response } = await this.client.DELETE("/command", {
+      params: { query: { id: sessionId } }
+    });
+    throwOnOpenApiFetchError({ error, response }, "Interrupt command failed");
+  }
+  async *runStream(command, opts, signal) {
+    const url = joinUrl(this.opts.baseUrl, "/command");
+    const body = JSON.stringify(toRunCommandRequest(command, opts));
+    const res = await this.fetch(url, {
+      method: "POST",
+      headers: {
+        "accept": "text/event-stream",
+        "content-type": "application/json",
+        ...this.opts.headers ?? {}
+      },
+      body,
+      signal
+    });
+    for await (const ev of parseJsonEventStream(res, { fallbackErrorMessage: "Run command failed" })) {
+      yield ev;
+    }
+  }
+  async run(command, opts, handlers, signal) {
+    const execution = {
+      logs: { stdout: [], stderr: [] },
+      result: []
+    };
+    const dispatcher = new ExecutionEventDispatcher(execution, handlers);
+    for await (const ev of this.runStream(command, opts, signal)) {
+      if (ev.type === "init" && (ev.text ?? "") === "" && execution.id) {
+        ev.text = execution.id;
+      }
+      await dispatcher.dispatch(ev);
+    }
+    return execution;
+  }
+};
+
+// src/adapters/filesystemAdapter.ts
+function joinUrl2(baseUrl, pathname) {
+  const base = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  const path = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  return `${base}${path}`;
+}
+function toUploadBlob(data) {
+  if (typeof data === "string") return new Blob([data]);
+  if (data instanceof Blob) return data;
+  if (data instanceof ArrayBuffer) return new Blob([data]);
+  const copied = Uint8Array.from(data);
+  return new Blob([copied.buffer]);
+}
+function isReadableStream(v) {
+  return !!v && typeof v.getReader === "function";
+}
+function isAsyncIterable(v) {
+  return !!v && typeof v[Symbol.asyncIterator] === "function";
+}
+function isNodeRuntime() {
+  const p = globalThis?.process;
+  return !!p?.versions?.node;
+}
+async function collectBytes(source) {
+  const chunks = [];
+  let total = 0;
+  if (isReadableStream(source)) {
+    const reader = source.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (value) {
+          chunks.push(value);
+          total += value.length;
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  } else {
+    for await (const chunk of source) {
+      chunks.push(chunk);
+      total += chunk.length;
+    }
+  }
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return out;
+}
+function toReadableStream(it) {
+  const RS = ReadableStream;
+  if (typeof RS?.from === "function") return RS.from(it);
+  const iterator = it[Symbol.asyncIterator]();
+  return new ReadableStream({
+    async pull(controller) {
+      const r = await iterator.next();
+      if (r.done) {
+        controller.close();
+        return;
+      }
+      controller.enqueue(r.value);
+    },
+    async cancel() {
+      await iterator.return?.();
+    }
+  });
+}
+function basename(p) {
+  const parts = p.split("/").filter(Boolean);
+  return parts.length ? parts[parts.length - 1] : "file";
+}
+function encodeUtf8(s) {
+  return new TextEncoder().encode(s);
+}
+async function* multipartUploadBody(opts) {
+  const b = opts.boundary;
+  yield encodeUtf8(`--${b}\r
+`);
+  yield encodeUtf8(
+    `Content-Disposition: form-data; name="metadata"; filename="metadata"\r
+`
+  );
+  yield encodeUtf8(`Content-Type: application/json\r
+\r
+`);
+  yield encodeUtf8(opts.metadataJson);
+  yield encodeUtf8(`\r
+`);
+  yield encodeUtf8(`--${b}\r
+`);
+  yield encodeUtf8(
+    `Content-Disposition: form-data; name="file"; filename="${opts.fileName}"\r
+`
+  );
+  yield encodeUtf8(`Content-Type: ${opts.fileContentType}\r
+\r
+`);
+  if (isReadableStream(opts.file)) {
+    const reader = opts.file.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (value) yield value;
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  } else {
+    for await (const chunk of opts.file) {
+      yield chunk;
+    }
+  }
+  yield encodeUtf8(`\r
+--${b}--\r
+`);
+}
+function toPermission(e) {
+  return {
+    mode: e.mode ?? 755,
+    owner: e.owner,
+    group: e.group
+  };
+}
+var FilesystemAdapter = class {
+  constructor(client, opts) {
+    this.client = client;
+    this.opts = opts;
+    this.fetch = opts.fetch ?? fetch;
+  }
+  fetch;
+  static Api = {
+    // This is intentionally derived from OpenAPI schema types so API changes surface quickly.
+    SearchFilesOk: null,
+    FilesInfoOk: null,
+    MakeDirsRequest: null,
+    SetPermissionsRequest: null,
+    MoveFilesRequest: null,
+    ReplaceContentsRequest: null
+  };
+  parseIsoDate(field, v) {
+    if (typeof v !== "string" || !v) {
+      throw new Error(`Invalid ${field}: expected ISO string, got ${typeof v}`);
+    }
+    const d = new Date(v);
+    if (Number.isNaN(d.getTime())) {
+      throw new Error(`Invalid ${field}: ${v}`);
+    }
+    return d;
+  }
+  static _ApiFileInfo = null;
+  mapApiFileInfo(raw) {
+    const { path, size, created_at, modified_at, mode, owner, group, ...rest } = raw;
+    return {
+      ...rest,
+      path,
+      size,
+      mode,
+      owner,
+      group,
+      createdAt: created_at ? this.parseIsoDate("createdAt", created_at) : void 0,
+      modifiedAt: modified_at ? this.parseIsoDate("modifiedAt", modified_at) : void 0
+    };
+  }
+  async getFileInfo(paths) {
+    const { data, error, response } = await this.client.GET("/files/info", {
+      params: { query: { path: paths } }
+    });
+    throwOnOpenApiFetchError({ error, response }, "Get file info failed");
+    const raw = data;
+    if (!raw) return {};
+    if (typeof raw !== "object") {
+      throw new Error(
+        `Get file info failed: unexpected response shape (got ${typeof raw})`
+      );
+    }
+    const out = {};
+    for (const [k, v] of Object.entries(raw)) {
+      if (!v || typeof v !== "object") {
+        throw new Error(
+          `Get file info failed: invalid file info for path=${k}`
+        );
+      }
+      out[k] = this.mapApiFileInfo(v);
+    }
+    return out;
+  }
+  async deleteFiles(paths) {
+    const { error, response } = await this.client.DELETE("/files", {
+      params: { query: { path: paths } }
+    });
+    throwOnOpenApiFetchError({ error, response }, "Delete files failed");
+  }
+  async createDirectories(entries) {
+    const map = {};
+    for (const e of entries) {
+      map[e.path] = toPermission(e);
+    }
+    const body = map;
+    const { error, response } = await this.client.POST("/directories", {
+      body
+    });
+    throwOnOpenApiFetchError({ error, response }, "Create directories failed");
+  }
+  async deleteDirectories(paths) {
+    const { error, response } = await this.client.DELETE("/directories", {
+      params: { query: { path: paths } }
+    });
+    throwOnOpenApiFetchError({ error, response }, "Delete directories failed");
+  }
+  async setPermissions(entries) {
+    const req = {};
+    for (const e of entries) {
+      req[e.path] = toPermission(e);
+    }
+    const body = req;
+    const { error, response } = await this.client.POST("/files/permissions", {
+      body
+    });
+    throwOnOpenApiFetchError({ error, response }, "Set permissions failed");
+  }
+  async moveFiles(entries) {
+    const req = entries.map((e) => ({
+      src: e.src,
+      dest: e.dest
+    }));
+    const body = req;
+    const { error, response } = await this.client.POST("/files/mv", {
+      body
+    });
+    throwOnOpenApiFetchError({ error, response }, "Move files failed");
+  }
+  async replaceContents(entries) {
+    const req = {};
+    for (const e of entries) {
+      req[e.path] = { old: e.oldContent, new: e.newContent };
+    }
+    const body = req;
+    const { error, response } = await this.client.POST("/files/replace", {
+      body
+    });
+    throwOnOpenApiFetchError({ error, response }, "Replace contents failed");
+  }
+  async search(entry) {
+    const { data, error, response } = await this.client.GET("/files/search", {
+      params: { query: { path: entry.path, pattern: entry.pattern } }
+    });
+    throwOnOpenApiFetchError({ error, response }, "Search files failed");
+    const ok = data;
+    if (!ok) return [];
+    if (!Array.isArray(ok)) {
+      throw new Error(
+        `Search files failed: unexpected response shape (expected array, got ${typeof ok})`
+      );
+    }
+    return ok.map((x) => this.mapApiFileInfo(x));
+  }
+  async uploadFile(meta, data) {
+    const url = joinUrl2(this.opts.baseUrl, "/files/upload");
+    const fileName = basename(meta.path);
+    const metadataJson = JSON.stringify(meta);
+    if (isReadableStream(data) || isAsyncIterable(data)) {
+      if (!isNodeRuntime()) {
+        const bytes = await collectBytes(data);
+        return await this.uploadFile(meta, bytes);
+      }
+      const boundary = `opensandbox_${Math.random().toString(16).slice(2)}_${Date.now()}`;
+      const bodyIt = multipartUploadBody({
+        boundary,
+        metadataJson,
+        fileName,
+        fileContentType: "application/octet-stream",
+        file: data
+      });
+      const stream = toReadableStream(bodyIt);
+      const res2 = await this.fetch(url, {
+        method: "POST",
+        headers: {
+          "content-type": `multipart/form-data; boundary=${boundary}`,
+          ...this.opts.headers ?? {}
+        },
+        body: stream,
+        // Node fetch (undici) requires duplex for streaming request bodies.
+        duplex: "half"
+      });
+      if (!res2.ok) {
+        const requestId = res2.headers.get("x-request-id") ?? void 0;
+        const rawBody = await res2.text().catch(() => void 0);
+        throw new SandboxApiException({
+          message: `Upload failed (status=${res2.status})`,
+          statusCode: res2.status,
+          requestId,
+          error: new SandboxError(
+            SandboxError.UNEXPECTED_RESPONSE,
+            "Upload failed"
+          ),
+          rawBody
+        });
+      }
+      return;
+    }
+    const form = new FormData();
+    form.append(
+      "metadata",
+      new Blob([metadataJson], { type: "application/json" }),
+      "metadata"
+    );
+    if (typeof data === "string") {
+      const textBlob = new Blob([data], { type: "text/plain; charset=utf-8" });
+      form.append("file", textBlob, fileName);
+    } else {
+      const blob = toUploadBlob(data);
+      const fileBlob = blob.type ? blob : new Blob([blob], { type: "application/octet-stream" });
+      form.append("file", fileBlob, fileName);
+    }
+    const res = await this.fetch(url, {
+      method: "POST",
+      headers: {
+        ...this.opts.headers ?? {}
+      },
+      body: form
+    });
+    if (!res.ok) {
+      const requestId = res.headers.get("x-request-id") ?? void 0;
+      const rawBody = await res.text().catch(() => void 0);
+      throw new SandboxApiException({
+        message: `Upload failed (status=${res.status})`,
+        statusCode: res.status,
+        requestId,
+        error: new SandboxError(
+          SandboxError.UNEXPECTED_RESPONSE,
+          "Upload failed"
+        ),
+        rawBody
+      });
+    }
+  }
+  async readBytes(path, opts) {
+    const url = joinUrl2(this.opts.baseUrl, "/files/download") + `?path=${encodeURIComponent(path)}`;
+    const res = await this.fetch(url, {
+      method: "GET",
+      headers: {
+        ...this.opts.headers ?? {},
+        ...opts?.range ? { Range: opts.range } : {}
+      }
+    });
+    if (!res.ok) {
+      const requestId = res.headers.get("x-request-id") ?? void 0;
+      const rawBody = await res.text().catch(() => void 0);
+      throw new SandboxApiException({
+        message: "Download failed",
+        statusCode: res.status,
+        requestId,
+        error: new SandboxError(
+          SandboxError.UNEXPECTED_RESPONSE,
+          "Download failed"
+        ),
+        rawBody
+      });
+    }
+    const ab = await res.arrayBuffer();
+    return new Uint8Array(ab);
+  }
+  readBytesStream(path, opts) {
+    return this.downloadStream(path, opts);
+  }
+  async *downloadStream(path, opts) {
+    const url = joinUrl2(this.opts.baseUrl, "/files/download") + `?path=${encodeURIComponent(path)}`;
+    const res = await this.fetch(url, {
+      method: "GET",
+      headers: {
+        ...this.opts.headers ?? {},
+        ...opts?.range ? { Range: opts.range } : {}
+      }
+    });
+    if (!res.ok) {
+      const requestId = res.headers.get("x-request-id") ?? void 0;
+      const rawBody = await res.text().catch(() => void 0);
+      throw new SandboxApiException({
+        message: "Download stream failed",
+        statusCode: res.status,
+        requestId,
+        error: new SandboxError(
+          SandboxError.UNEXPECTED_RESPONSE,
+          "Download stream failed"
+        ),
+        rawBody
+      });
+    }
+    const body = res.body;
+    if (!body) return;
+    const reader = body.getReader();
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) return;
+      if (value) yield value;
+    }
+  }
+  async readFile(path, opts) {
+    const bytes = await this.readBytes(path, { range: opts?.range });
+    const encoding = opts?.encoding ?? "utf-8";
+    return new TextDecoder(encoding).decode(bytes);
+  }
+  async writeFiles(entries) {
+    for (const e of entries) {
+      const meta = {
+        path: e.path,
+        owner: e.owner,
+        group: e.group,
+        mode: e.mode
+      };
+      await this.uploadFile(meta, e.data ?? "");
+    }
+  }
+};
+
+// src/adapters/healthAdapter.ts
+var HealthAdapter = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async ping() {
+    const { error, response } = await this.client.GET("/ping");
+    throwOnOpenApiFetchError({ error, response }, "Execd ping failed");
+    return true;
+  }
+};
+
+// src/adapters/metricsAdapter.ts
+function normalizeMetrics(m) {
+  const cpuCount = m.cpu_count ?? 0;
+  const cpuUsedPercentage = m.cpu_used_pct ?? 0;
+  const memoryTotalMiB = m.mem_total_mib ?? 0;
+  const memoryUsedMiB = m.mem_used_mib ?? 0;
+  const timestamp = m.timestamp ?? 0;
+  return {
+    cpuCount: Number(cpuCount),
+    cpuUsedPercentage: Number(cpuUsedPercentage),
+    memoryTotalMiB: Number(memoryTotalMiB),
+    memoryUsedMiB: Number(memoryUsedMiB),
+    timestamp: Number(timestamp)
+  };
+}
+var MetricsAdapter = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getMetrics() {
+    const { data, error, response } = await this.client.GET("/metrics");
+    throwOnOpenApiFetchError({ error, response }, "Get execd metrics failed");
+    const ok = data;
+    if (!ok || typeof ok !== "object") {
+      throw new Error("Get execd metrics failed: unexpected response shape");
+    }
+    return normalizeMetrics(ok);
+  }
+};
+
+// src/adapters/sandboxesAdapter.ts
+function encodeMetadataFilter(metadata) {
+  const parts = [];
+  for (const [k, v] of Object.entries(metadata)) {
+    parts.push(`${k}=${v}`);
+  }
+  return parts.join("&");
+}
+var SandboxesAdapter = class {
+  constructor(client) {
+    this.client = client;
+  }
+  parseIsoDate(field, v) {
+    if (typeof v !== "string" || !v) {
+      throw new Error(`Invalid ${field}: expected ISO string, got ${typeof v}`);
+    }
+    const d = new Date(v);
+    if (Number.isNaN(d.getTime())) {
+      throw new Error(`Invalid ${field}: ${v}`);
+    }
+    return d;
+  }
+  mapSandboxInfo(raw) {
+    return {
+      ...raw ?? {},
+      createdAt: this.parseIsoDate("createdAt", raw?.createdAt),
+      expiresAt: this.parseIsoDate("expiresAt", raw?.expiresAt)
+    };
+  }
+  async createSandbox(req) {
+    const body = req;
+    const { data, error, response } = await this.client.POST("/sandboxes", {
+      body
+    });
+    throwOnOpenApiFetchError({ error, response }, "Create sandbox failed");
+    const raw = data;
+    if (!raw || typeof raw !== "object") {
+      throw new Error("Create sandbox failed: unexpected response shape");
+    }
+    return {
+      ...raw ?? {},
+      createdAt: this.parseIsoDate("createdAt", raw?.createdAt),
+      expiresAt: this.parseIsoDate("expiresAt", raw?.expiresAt)
+    };
+  }
+  async getSandbox(sandboxId) {
+    const { data, error, response } = await this.client.GET("/sandboxes/{sandboxId}", {
+      params: { path: { sandboxId } }
+    });
+    throwOnOpenApiFetchError({ error, response }, "Get sandbox failed");
+    const ok = data;
+    if (!ok || typeof ok !== "object") {
+      throw new Error("Get sandbox failed: unexpected response shape");
+    }
+    return this.mapSandboxInfo(ok);
+  }
+  async listSandboxes(params = {}) {
+    const query = {};
+    if (params.states?.length) query.state = params.states;
+    if (params.metadata && Object.keys(params.metadata).length) {
+      query.metadata = encodeMetadataFilter(params.metadata);
+    }
+    if (params.page != null) query.page = params.page;
+    if (params.pageSize != null) query.pageSize = params.pageSize;
+    const { data, error, response } = await this.client.GET("/sandboxes", {
+      params: { query }
+    });
+    throwOnOpenApiFetchError({ error, response }, "List sandboxes failed");
+    const raw = data;
+    if (!raw || typeof raw !== "object") {
+      throw new Error("List sandboxes failed: unexpected response shape");
+    }
+    const itemsRaw = raw.items;
+    if (!Array.isArray(itemsRaw)) throw new Error("List sandboxes failed: unexpected items shape");
+    return {
+      ...raw ?? {},
+      items: itemsRaw.map((x) => this.mapSandboxInfo(x))
+    };
+  }
+  async deleteSandbox(sandboxId) {
+    const { error, response } = await this.client.DELETE("/sandboxes/{sandboxId}", {
+      params: { path: { sandboxId } }
+    });
+    throwOnOpenApiFetchError({ error, response }, "Delete sandbox failed");
+  }
+  async pauseSandbox(sandboxId) {
+    const { error, response } = await this.client.POST("/sandboxes/{sandboxId}/pause", {
+      params: { path: { sandboxId } }
+    });
+    throwOnOpenApiFetchError({ error, response }, "Pause sandbox failed");
+  }
+  async resumeSandbox(sandboxId) {
+    const { error, response } = await this.client.POST("/sandboxes/{sandboxId}/resume", {
+      params: { path: { sandboxId } }
+    });
+    throwOnOpenApiFetchError({ error, response }, "Resume sandbox failed");
+  }
+  async renewSandboxExpiration(sandboxId, req) {
+    const body = req;
+    const { data, error, response } = await this.client.POST("/sandboxes/{sandboxId}/renew-expiration", {
+      params: { path: { sandboxId } },
+      body
+    });
+    throwOnOpenApiFetchError({ error, response }, "Renew sandbox expiration failed");
+    const raw = data;
+    if (!raw || typeof raw !== "object") {
+      throw new Error("Renew sandbox expiration failed: unexpected response shape");
+    }
+    return {
+      ...raw ?? {},
+      expiresAt: raw?.expiresAt ? this.parseIsoDate("expiresAt", raw.expiresAt) : void 0
+    };
+  }
+  async getSandboxEndpoint(sandboxId, port) {
+    const { data, error, response } = await this.client.GET("/sandboxes/{sandboxId}/endpoints/{port}", {
+      params: { path: { sandboxId, port } }
+    });
+    throwOnOpenApiFetchError({ error, response }, "Get sandbox endpoint failed");
+    const ok = data;
+    if (!ok || typeof ok !== "object") {
+      throw new Error("Get sandbox endpoint failed: unexpected response shape");
+    }
+    return ok;
+  }
+};
+
+export {
+  SandboxError,
+  SandboxException,
+  SandboxApiException,
+  SandboxInternalException,
+  SandboxUnhealthyException,
+  SandboxReadyTimeoutException,
+  InvalidArgumentException,
+  createExecdClient,
+  createLifecycleClient,
+  ExecutionEventDispatcher,
+  CommandsAdapter,
+  FilesystemAdapter,
+  HealthAdapter,
+  MetricsAdapter,
+  SandboxesAdapter
+};
+//# sourceMappingURL=chunk-NFNOESEY.js.map