@arker-ai/sdk 0.5.1 → 0.6.2

package/dist/e2b.d.cts

@@ -0,0 +1,29 @@
+import { C as CreateOptions } from './common-C5zJ-LkS.cjs';
+import 'computesdk';
+
+interface CommandExitResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+declare class Sandbox {
+    #private;
+    readonly sandboxId: string;
+    readonly commands: {
+        run: (command: string) => Promise<CommandExitResult>;
+    };
+    readonly files: {
+        read: (path: string) => Promise<string>;
+        write: (path: string, content: string) => Promise<void>;
+        makeDir: (path: string) => Promise<void>;
+        list: (path: string) => Promise<unknown[]>;
+        exists: (path: string) => Promise<boolean>;
+        remove: (path: string) => Promise<void>;
+    };
+    private constructor();
+    static create(templateId?: string, opts?: CreateOptions): Promise<Sandbox>;
+    static connect(sandboxId: string): Promise<Sandbox>;
+    kill(): Promise<void>;
+}
+
+export { type CommandExitResult, Sandbox };

package/dist/e2b.d.ts

@@ -0,0 +1,29 @@
+import { C as CreateOptions } from './common-C5zJ-LkS.js';
+import 'computesdk';
+
+interface CommandExitResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+declare class Sandbox {
+    #private;
+    readonly sandboxId: string;
+    readonly commands: {
+        run: (command: string) => Promise<CommandExitResult>;
+    };
+    readonly files: {
+        read: (path: string) => Promise<string>;
+        write: (path: string, content: string) => Promise<void>;
+        makeDir: (path: string) => Promise<void>;
+        list: (path: string) => Promise<unknown[]>;
+        exists: (path: string) => Promise<boolean>;
+        remove: (path: string) => Promise<void>;
+    };
+    private constructor();
+    static create(templateId?: string, opts?: CreateOptions): Promise<Sandbox>;
+    static connect(sandboxId: string): Promise<Sandbox>;
+    kill(): Promise<void>;
+}
+
+export { type CommandExitResult, Sandbox };

package/dist/e2b.js

@@ -0,0 +1,75 @@
+import {
+  assertSupportedObjectKeys,
+  createCompatSdk,
+  guardUnsupported,
+  resolveTimeout
+} from "./chunk-35IEV6BU.js";
+import "./chunk-7BHPVQNG.js";
+
+// src/e2b.ts
+import { e2b as createE2BProvider } from "@computesdk/e2b";
+var E2B_CREATE_OPTION_KEYS = ["timeout", "timeoutMs"];
+function sdk() {
+  return createCompatSdk({
+    fallbackProvider: createE2BProvider({})
+  });
+}
+var Sandbox = class _Sandbox {
+  sandboxId;
+  #box;
+  commands;
+  files;
+  constructor(box) {
+    this.#box = box;
+    this.sandboxId = box.sandboxId;
+    this.commands = {
+      run: async (command) => {
+        const result = await this.#box.runCommand(command);
+        return {
+          stdout: result.stdout,
+          stderr: result.stderr,
+          exitCode: result.exitCode
+        };
+      }
+    };
+    this.files = {
+      read: (path) => this.#box.filesystem.readFile(path),
+      write: async (path, content) => {
+        await this.#box.filesystem.writeFile(path, content);
+      },
+      makeDir: async (path) => {
+        await this.#box.filesystem.mkdir(path);
+      },
+      list: (path) => this.#box.filesystem.readdir(path),
+      exists: (path) => this.#box.filesystem.exists(path),
+      remove: async (path) => {
+        await this.#box.filesystem.remove(path);
+      }
+    };
+  }
+  static async create(templateId, opts) {
+    if (templateId !== void 0 && typeof templateId !== "string") {
+      throw new Error(
+        `Sandbox.create only supports create() or create(templateId, { timeoutMs }) in the Arker compatibility layer for e2b. Use the native e2b SDK for unsupported create signatures.`
+      );
+    }
+    assertSupportedObjectKeys(opts, E2B_CREATE_OPTION_KEYS, "e2b", "Sandbox.create");
+    const timeout = resolveTimeout(opts);
+    const box = await sdk().sandbox.create({
+      ...templateId ? { templateId } : {},
+      ...timeout !== void 0 ? { timeout } : {}
+    });
+    return guardUnsupported(new _Sandbox(box), "e2b");
+  }
+  static async connect(sandboxId) {
+    const box = await sdk().sandbox.getById(sandboxId);
+    if (!box) throw new Error(`Sandbox ${sandboxId} not found`);
+    return guardUnsupported(new _Sandbox(box), "e2b");
+  }
+  async kill() {
+    await this.#box.destroy();
+  }
+};
+export {
+  Sandbox
+};

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "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)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   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
@@ -149,6 +159,12 @@ var Arker = class {
       );
     }
     const sourceOrgId = src.sourceOrgId ?? (src.sourceVmName !== void 0 && GOLDEN_NAMES.has(src.sourceVmName) ? ARKER_ORG_ID : void 0);
+    const legacy = src;
+    const resources = src.resources ?? (legacy.vcpu_count != null || legacy.memory_mib != null || legacy.disk_mib != null ? {
+      vcpu: legacy.vcpu_count ?? null,
+      memory_mib: legacy.memory_mib ?? null,
+      disk_mib: legacy.disk_mib ?? null
+    } : null);
     const body = {
       source_vm_id: src.sourceVmId ?? null,
       source_vm_name: src.sourceVmName ?? null,
@@ -156,12 +172,10 @@ var Arker = class {
       name: src.name ?? null,
       public: src.public ?? null,
       network: src.network ?? null,
+      egress: src.egress ?? null,
       disk: src.disk ?? true,
-      vcpu_count: src.vcpu_count ?? null,
-      memory_mib: src.memory_mib ?? null,
-      max_memory_mib: src.max_memory_mib ?? null,
-      disk_mib: src.disk_mib ?? null,
-      durable: src.durable ?? null
+      durable: src.durable ?? null,
+      resources
     };
     const useBurst = sourceOrgId === ARKER_ORG_ID && src.sourceVmName !== void 0 && isBurstRef(src.sourceVmName);
     const baseUrl = useBurst && this.burstBaseUrl ? this.burstBaseUrl : this.baseUrl;
@@ -192,6 +206,33 @@ var Arker = class {
     });
     return { vms, nextCursor: resp.next_cursor ?? null };
   }
+  /**
+   * List run activity visible to the authenticated caller across VMs,
+   * providers, and regions. Admin call — routed through the control plane.
+   */
+  async listRuns(opts = {}) {
+    return this._request("GET", buildQuery("/v1/runs", {
+      since: opts.since,
+      until: opts.until,
+      vm: opts.vm,
+      vms: opts.vmIds && opts.vmIds.length > 0 ? opts.vmIds.join(",") : void 0,
+      region: opts.region,
+      provider: opts.provider,
+      source: opts.source,
+      search: opts.search,
+      limit: opts.limit,
+      offset: opts.offset,
+      lite: opts.lite === void 0 ? void 0 : opts.lite,
+      runtime: opts.runtime,
+      endpoint: opts.endpoint,
+      actions: opts.actions && opts.actions.length > 0 ? opts.actions.join(",") : void 0,
+      status: opts.status && opts.status.length > 0 ? opts.status.join(",") : void 0,
+      status_min: opts.statusMin,
+      status_max: opts.statusMax,
+      sort: opts.sort,
+      dir: opts.dir
+    }), void 0, this.controlBaseUrl);
+  }
   /** Compute call — goes direct to the backend hosting this VM (no
    * control-plane hop). Returns a fully-populated VM handle. */
   async getVm(vmId) {
@@ -281,6 +322,10 @@ var Arker = class {
     return retryDelay(this.retry, attempt);
   }
   /** @internal */
+  _authHeaders() {
+    return { authorization: `Bearer ${this.apiKey}` };
+  }
+  /** @internal */
   _baseUrlFor(ref) {
     if (isBurstRef(ref) && this.burstBaseUrl) return this.burstBaseUrl;
     return this.baseUrl;
@@ -306,12 +351,15 @@ var VM = class _VM {
   vcpu_count;
   memory_mib;
   disk_mib;
+  network;
+  max_vcpus;
+  max_memory_mib;
+  min_memory_mib;
   started_at;
   root_source_vm_id;
   root_source_vm_name;
   worker_id;
   sessions;
-  tunnels;
   constructor(client, vmId, baseUrl = client._baseUrlFor(vmId), data) {
     this._client = client;
     this.id = vmId;
@@ -434,8 +482,25 @@ var VM = class _VM {
     }
     throw new ArkerError(lastError?.code ?? "internal", lastError?.message ?? "write failed", 200);
   }
+  /**
+   * Update this VM's resource allocation and/or network settings via
+   * `PATCH /v1/vms/{id}`. Returns the updated `Vm`.
+   *
+   * Accepts either a `PatchVmRequest` (`{ resources, network }`) or, for
+   * convenience, flat resource fields (`{ vcpu, memory_mib, disk_mib }`)
+   * which are folded into `resources`.
+   */
   async resize(request) {
-    return this._client._request("POST", `${vmPath(this.id)}/resize`, request, this.baseUrl);
+    const r = request;
+    const body = r.resources !== void 0 || r.vcpu === void 0 && r.memory_mib === void 0 && r.disk_mib === void 0 ? { resources: r.resources ?? null, network: r.network ?? null } : {
+      resources: {
+        vcpu: r.vcpu ?? null,
+        memory_mib: r.memory_mib ?? null,
+        disk_mib: r.disk_mib ?? null
+      },
+      network: r.network ?? null
+    };
+    return this._client._request("PATCH", vmPath(this.id), body, this.baseUrl);
   }
   async delete() {
     return this._client._request("DELETE", vmPath(this.id), void 0, this.baseUrl);
@@ -491,19 +556,30 @@ var VM = class _VM {
   async deleteSession(sessionId) {
     return this._client._request("DELETE", `${vmPath(this.id)}/sessions/${pathSegment(sessionId)}`, void 0, this.baseUrl);
   }
-  // ── Tunnels: opened as a side effect of fork/run, addressed by port ─
-  async listTunnels(opts = {}) {
-    return this._client._request("GET", buildQuery(`${vmPath(this.id)}/tunnels`, {
-      cursor: opts.cursor,
-      limit: opts.limit,
-      state: opts.state
-    }), void 0, this.baseUrl);
-  }
-  async getTunnel(port) {
-    return this._client._request("GET", `${vmPath(this.id)}/tunnels/${port}`, void 0, this.baseUrl);
-  }
-  async deleteTunnel(port) {
-    return this._client._request("DELETE", `${vmPath(this.id)}/tunnels/${port}`, void 0, this.baseUrl);
+  async connectPty(options = {}) {
+    const sessionId = options.sessionId ?? sessionIdFrom(await this.createSession());
+    const useTicket = options.useTicket ?? !isNodeRuntime();
+    const params = {
+      cols: options.cols,
+      rows: options.rows,
+      command: options.command,
+      persist: options.persist,
+      cancel_ttl_secs: options.cancelTtlSecs && options.cancelTtlSecs > 0 ? Math.floor(options.cancelTtlSecs) : void 0
+    };
+    let ticket;
+    if (useTicket) {
+      const response = await this._client._request(
+        "POST",
+        `${vmPath(this.id)}/sessions/${pathSegment(sessionId)}/pty-ticket`,
+        {},
+        this.baseUrl
+      );
+      ticket = response.ticket;
+    }
+    const url = buildPtyWebSocketUrl(this.baseUrl, this.id, sessionId, { ...params, ticket });
+    const factory = options.webSocketFactory ?? (useTicket ? browserPtyWebSocketFactory : nodePtyWebSocketFactory);
+    const socket = await factory(url, useTicket ? {} : { headers: this._client._authHeaders() });
+    return new PtyConnectionImpl(sessionId, socket);
   }
 };
 function buildQuery(path, params) {
@@ -515,6 +591,176 @@ function buildQuery(path, params) {
   const qs = usp.toString();
   return qs ? `${path}?${qs}` : path;
 }
+function buildPtyWebSocketUrl(baseUrl, vmId, sessionId, params) {
+  const url = new URL(`${normalizeBaseUrl(baseUrl)}${vmPath(vmId)}/sessions/${pathSegment(sessionId)}/pty`);
+  if (url.protocol === "https:") url.protocol = "wss:";
+  else if (url.protocol === "http:") url.protocol = "ws:";
+  else throw new Error(`unsupported PTY WebSocket protocol: ${url.protocol}`);
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0 || value === null) continue;
+    url.searchParams.set(key, String(value));
+  }
+  return url.toString();
+}
+function sessionIdFrom(session) {
+  const id = session.session_id ?? session.id;
+  if (!id) throw new ArkerError("internal", "createSession response missing session_id", 200);
+  return id;
+}
+function isNodeRuntime() {
+  return typeof process !== "undefined" && Boolean(process.versions?.node);
+}
+async function nodePtyWebSocketFactory(url, init) {
+  const ws = await import("ws");
+  return new ws.default(url, { headers: init.headers });
+}
+function browserPtyWebSocketFactory(url) {
+  if (typeof globalThis.WebSocket !== "function") {
+    throw new Error("WebSocket is not available in this runtime");
+  }
+  return new globalThis.WebSocket(url);
+}
+var PtyConnectionImpl = class {
+  constructor(sessionId, socket) {
+    this.sessionId = sessionId;
+    this.socket = socket;
+    try {
+      socket.binaryType = "arraybuffer";
+    } catch {
+    }
+    this.ready = waitForSocketOpen(socket);
+    addSocketListener(socket, "message", (event) => {
+      const data = messageData(event);
+      if (data !== void 0) this.emitData(bytesFromMessageData(data));
+    });
+    addSocketListener(socket, "close", (event) => this.emitClose(closeEvent(event)));
+    addSocketListener(socket, "error", (event) => this.emitError(event));
+  }
+  sessionId;
+  socket;
+  ready;
+  dataListeners = /* @__PURE__ */ new Set();
+  closeListeners = /* @__PURE__ */ new Set();
+  errorListeners = /* @__PURE__ */ new Set();
+  onData(listener) {
+    this.dataListeners.add(listener);
+    return () => this.dataListeners.delete(listener);
+  }
+  onClose(listener) {
+    this.closeListeners.add(listener);
+    return () => this.closeListeners.delete(listener);
+  }
+  onError(listener) {
+    this.errorListeners.add(listener);
+    return () => this.errorListeners.delete(listener);
+  }
+  send(data) {
+    this.socket.send(ptyInputBytes(data));
+  }
+  resize(cols, rows) {
+    this.socket.send(JSON.stringify({ type: "resize", cols: clampPtyDimension(cols), rows: clampPtyDimension(rows) }));
+  }
+  kill() {
+    this.socket.send(JSON.stringify({ type: "kill" }));
+  }
+  close(code, reason) {
+    this.socket.close(code, reason);
+  }
+  emitData(data) {
+    for (const listener of this.dataListeners) listener(data);
+  }
+  emitClose(event) {
+    for (const listener of this.closeListeners) listener(event);
+  }
+  emitError(error) {
+    for (const listener of this.errorListeners) listener(error);
+  }
+};
+function waitForSocketOpen(socket) {
+  if (socket.readyState === 1) return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    let removeOpen;
+    let removeError;
+    let removeClose;
+    const cleanup = () => {
+      removeOpen?.();
+      removeError?.();
+      removeClose?.();
+    };
+    removeOpen = addSocketListener(socket, "open", () => {
+      cleanup();
+      resolve();
+    });
+    removeError = addSocketListener(socket, "error", (event) => {
+      cleanup();
+      reject(event instanceof Error ? event : new Error("PTY WebSocket failed to open"));
+    });
+    removeClose = addSocketListener(socket, "close", (event) => {
+      cleanup();
+      const ev = closeEvent(event);
+      reject(new Error(`PTY WebSocket closed before opening${ev.code ? ` (${ev.code})` : ""}`));
+    });
+  });
+}
+function addSocketListener(socket, type, listener) {
+  if (socket.addEventListener) {
+    socket.addEventListener(type, listener);
+    return () => socket.removeEventListener?.(type, listener);
+  }
+  if (socket.on) {
+    const nodeListener = (...args) => {
+      if (type === "message") listener({ data: args[0] });
+      else if (type === "close") listener({ code: args[0], reason: args[1] });
+      else listener(args[0]);
+    };
+    socket.on(type, nodeListener);
+    return () => socket.off?.(type, nodeListener);
+  }
+  return () => {
+  };
+}
+function messageData(event) {
+  if (event && typeof event === "object" && "data" in event) {
+    return event.data;
+  }
+  return void 0;
+}
+function closeEvent(event) {
+  if (!event || typeof event !== "object") return {};
+  const raw = event;
+  return {
+    code: typeof raw.code === "number" ? raw.code : void 0,
+    reason: typeof raw.reason === "string" ? raw.reason : void 0
+  };
+}
+function bytesFromMessageData(data) {
+  if (typeof data === "string") return new TextEncoder().encode(data);
+  if (data instanceof Uint8Array) return data;
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  if (ArrayBuffer.isView(data)) {
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  }
+  if (Array.isArray(data)) {
+    const chunks = data.map(bytesFromMessageData);
+    const total = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+      out.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return out;
+  }
+  return new Uint8Array();
+}
+function ptyInputBytes(data) {
+  if (typeof data === "string") return new TextEncoder().encode(data);
+  return data;
+}
+function clampPtyDimension(value) {
+  if (!Number.isFinite(value)) return 1;
+  return Math.max(1, Math.min(1e3, Math.trunc(value)));
+}
 function normalizeBaseUrl(baseUrl) {
   const trimmed = baseUrl.trim().replace(/\/+$/, "");
   if (!trimmed) throw new Error("baseUrl must not be empty");
@@ -597,15 +843,17 @@ function parseRunResponse(payload) {
       stderr: decodeBytes(stderr, stderrEncoding),
       stderrEncoding,
       exitCode: numberField(body.exit_code, "run response.exit_code"),
-      failReason: typeof body.fail_reason === "string" ? body.fail_reason : null
+      failReason: typeof body.fail_reason === "string" ? body.fail_reason : null,
+      memoryRequestedMib: optionalNumberOrNull(body.memory_requested_mib),
+      memoryAchievedMib: optionalNumberOrNull(body.memory_achieved_mib),
+      memoryPartial: typeof body.memory_partial === "boolean" ? body.memory_partial : void 0
     };
   }
   if (typeof body.run_id === "string") {
     return {
       type: "background",
       runId: body.run_id,
-      state: typeof body.state === "string" ? body.state : "running",
-      tunnels: Array.isArray(body.tunnels) ? body.tunnels : []
+      state: typeof body.state === "string" ? body.state : "running"
     };
   }
   throw new ArkerError("internal", "unrecognized run response shape", 200);
@@ -669,6 +917,10 @@ function numberField(value, context) {
   if (typeof value !== "number") throw new ArkerError("internal", `${context} must be a number`, 200);
   return value;
 }
+function optionalNumberOrNull(value) {
+  if (value === null || typeof value === "number") return value;
+  return void 0;
+}
 function assertWriteComplete(result, context) {
   if (result.complete && result.written) return;
   throw new ArkerError("internal", `${context} did not complete`, 200);