@arker-ai/sdk 0.5.2 → 0.6.3

package/dist/{chunk-YGZOUXII.js → chunk-7BHPVQNG.js}

@@ -121,6 +121,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,
@@ -128,13 +134,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,
-      tunnel: src.tunnel ?? null
+      resources
     };
     const useBurst = sourceOrgId === ARKER_ORG_ID && src.sourceVmName !== void 0 && isBurstRef(src.sourceVmName);
     const baseUrl = useBurst && this.burstBaseUrl ? this.burstBaseUrl : this.baseUrl;
@@ -281,6 +284,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;
@@ -315,7 +322,6 @@ var VM = class _VM {
   root_source_vm_name;
   worker_id;
   sessions;
-  tunnels;
   constructor(client, vmId, baseUrl = client._baseUrlFor(vmId), data) {
     this._client = client;
     this.id = vmId;
@@ -438,8 +444,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);
@@ -495,22 +518,30 @@ var VM = class _VM {
   async deleteSession(sessionId) {
     return this._client._request("DELETE", `${vmPath(this.id)}/sessions/${pathSegment(sessionId)}`, void 0, this.baseUrl);
   }
-  // ── Tunnels: VM-scoped, addressed by recoverable tunnel key ───────
-  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 createTunnel(request = {}) {
-    return this._client._request("POST", `${vmPath(this.id)}/tunnels`, request, this.baseUrl);
-  }
-  async getTunnel(key) {
-    return this._client._request("GET", `${vmPath(this.id)}/tunnels/${pathSegment(key)}`, void 0, this.baseUrl);
-  }
-  async deleteTunnel(key) {
-    return this._client._request("DELETE", `${vmPath(this.id)}/tunnels/${pathSegment(key)}`, 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) {
@@ -522,6 +553,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");
@@ -604,7 +805,10 @@ 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") {
@@ -675,6 +879,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);