@miosa/sdk 3.0.0 → 3.0.2

package/dist/index.js

@@ -168,7 +168,7 @@ var TokenRefreshFailedError = class extends MiosaError {
 };
 
 // src/version.ts
-var SDK_VERSION = "3.0.0";
+var SDK_VERSION = "2.0.7";
 var SDK_USER_AGENT = `@miosa/sdk/${SDK_VERSION}`;
 
 // src/http.ts
@@ -198,7 +198,6 @@ async function ensureHttp2Agent() {
   }
 }
 ensureHttp2Agent();
-var SSE_ACCEPT = "text/event-stream, application/json;q=0.9";
 var DEFAULT_TIMEOUT = 3e4;
 var DEFAULT_MAX_RETRIES = 3;
 var RETRY_STATUS = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
@@ -365,13 +364,16 @@ var HttpClient = class {
     return this.request(path, { method: "POST", formData });
   }
   /**
-   * Open a Server-Sent Events stream. Returns an AsyncIterableIterator of
-   * parsed event data objects. The caller is responsible for breaking the loop.
+   * Open a Server-Sent Events stream and yield each frame's parsed `data:`
+   * payload together with its SSE `event:` name (when present). Most callers
+   * want {@link stream}; use this when the event name carries meaning — e.g. the
+   * sandbox exec stream tags frames as `stdout` / `stderr` / `exit`. The caller
+   * is responsible for breaking the loop.
    */
-  async *stream(path, options = {}) {
+  async *streamFrames(path, options = {}) {
     const method = options.method ?? "GET";
     let headers = this.baseHeaders({
-      Accept: SSE_ACCEPT,
+      Accept: "text/event-stream",
       ...options.headers
     });
     let body5 = null;
@@ -409,14 +411,13 @@ var HttpClient = class {
         response.headers.get("x-request-id") ?? void 0
       );
     }
-    if (response.status === 204) return;
     if (!response.body) {
       throw new MiosaError("SSE stream has no body", 0, "NO_STREAM_BODY");
     }
     const reader = response.body.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
-    let eventName;
+    let event = null;
     try {
       while (true) {
         const { done, value } = await reader.read();
@@ -424,23 +425,22 @@ var HttpClient = class {
         buffer += decoder.decode(value, { stream: true });
         const lines = buffer.split("\n");
         buffer = lines.pop() ?? "";
-        for (const line of lines) {
-          if (line.startsWith("event:")) {
-            eventName = line.slice(6).trim();
+        for (const rawLine of lines) {
+          const line = rawLine.replace(/\r$/, "");
+          if (line === "") {
+            event = null;
             continue;
           }
-          if (line === "") {
-            eventName = void 0;
+          if (line.startsWith(":")) continue;
+          if (line.startsWith("event:")) {
+            event = line.slice(6).trim();
             continue;
           }
           if (line.startsWith("data:")) {
             const raw = line.slice(5).trim();
-            const name = eventName;
-            eventName = void 0;
             if (raw === "[DONE]" || raw === "") continue;
             try {
-              const parsed = JSON.parse(raw);
-              yield name !== void 0 && parsed !== null && typeof parsed === "object" && !("type" in parsed) ? { type: name, ...parsed } : parsed;
+              yield { event, data: JSON.parse(raw) };
             } catch {
             }
           }
@@ -451,6 +451,15 @@ var HttpClient = class {
       reader.releaseLock();
     }
   }
+  /**
+   * Open a Server-Sent Events stream. Returns an AsyncIterableIterator of
+   * parsed event data objects. The caller is responsible for breaking the loop.
+   */
+  async *stream(path, options = {}) {
+    for await (const frame of this.streamFrames(path, options)) {
+      yield frame.data;
+    }
+  }
 };
 
 // src/resources/admin.ts
@@ -7788,130 +7797,41 @@ var Jobs = class {
     return `/opencomputers/hosts/${hostId}`;
   }
   /**
-   * Run a command on the host and wait for the buffered result.
-   *
-   * Sends `stream: false` so the server buffers output and answers with JSON.
-   * `stream` defaults to *true* server-side, which answers with a chunked SSE
-   * body instead - use {@link runStream} for that.
-   *
-   * Note this holds the connection open for the life of the command
-   * (`timeout_ms`, 30 s default), because the server does not answer until
-   * the command finishes.
+   * Dispatch a command to run on the remote host.
    */
   async run(hostId, params) {
-    return this.http.post(`${this.base(hostId)}/exec`, {
-      ...params,
-      stream: false
-    });
+    return this.http.post(`${this.base(hostId)}/exec`, params);
   }
   /**
-   * Run a command on the host and stream its output as it happens.
-   *
-   * Same endpoint as {@link run} with `stream: true`, which is the server's
-   * default mode. Terminates with one `exec_result` or one `exec_error`.
+   * List all jobs for a host.
    */
-  runStream(hostId, params) {
-    return translateExecStream(
-      this.http.stream(`${this.base(hostId)}/exec`, {
-        method: "POST",
-        body: { ...params, stream: true }
-      })
-    );
-  }
-  /**
-   * List recent job activity for a host.
-   *
-   * Hits `/jobs`, not `/exec`: there is no `GET /opencomputers/hosts/{id}/exec`
-   * route on the server, so the old path 404'd. The rows are audit-log events
-   * about jobs (`job.dispatched` / `job.done` / `job.failed`), newest first,
-   * not job records - see {@link JobAuditEvent}.
-   *
-   * @param limit Server caps this at 100 and defaults to 20.
-   */
-  async list(hostId, limit) {
-    return this.http.get(
-      `${this.base(hostId)}/jobs`,
-      limit === void 0 ? void 0 : { limit }
-    );
+  async list(hostId) {
+    return this.http.get(`${this.base(hostId)}/exec`);
   }
   /**
    * Fetch the current state of a job.
-   *
-   * The server wraps the record in a `job` envelope; this unwraps it.
    */
   async get(hostId, jobId) {
-    const response = await this.http.get(
-      `${this.base(hostId)}/exec/${jobId}`
-    );
-    if (response && typeof response === "object" && "job" in response) {
-      return response.job;
-    }
-    return response;
+    return this.http.get(`${this.base(hostId)}/exec/${jobId}`);
   }
   /**
-   * Re-attach to a job that is already running and stream what is left.
+   * Stream live output from a running job.
    *
-   * This is the reconnect endpoint. If the job has already reached a terminal
-   * state the server answers `204 No Content` and this yields nothing, rather
-   * than replaying output - the server never stored it.
+   * Yields `JobEvent` objects with `type` of `stdout`, `stderr`, `exit`, or
+   * `done`. Break the loop when you receive `done` or `exit`.
    */
   stream(hostId, jobId) {
-    return translateExecStream(
-      this.http.stream(`${this.base(hostId)}/exec/${jobId}/stream`)
+    return this.http.stream(
+      `${this.base(hostId)}/exec/${jobId}/stream`
     );
   }
   /**
    * Cancel a running or queued job.
-   *
-   * Answers `204` on success and `409` when the job is already terminal.
    */
   async cancel(hostId, jobId) {
     return this.http.delete(`${this.base(hostId)}/exec/${jobId}`);
   }
 };
-var EXEC_EVENT_NAMES = /* @__PURE__ */ new Set(["exec_chunk", "exec_result", "exec_error"]);
-function asString(value) {
-  return typeof value === "string" ? value : null;
-}
-function asNumber(value) {
-  return typeof value === "number" ? value : null;
-}
-function toJobEvent(raw) {
-  if (raw === null || typeof raw !== "object") return null;
-  const record = raw;
-  const name = asString(record["type"]);
-  if (name === null || !EXEC_EVENT_NAMES.has(name)) return null;
-  if (name === "exec_chunk") {
-    return {
-      type: "exec_chunk",
-      // The server defaults this to :stdout when the host omits it; anything
-      // other than "stderr" is stdout by the same rule.
-      stream: record["stream"] === "stderr" ? "stderr" : "stdout",
-      data: asString(record["data"])
-    };
-  }
-  if (name === "exec_result") {
-    return {
-      type: "exec_result",
-      exit_code: asNumber(record["exit_code"]),
-      elapsed_ms: asNumber(record["elapsed_ms"])
-    };
-  }
-  const jobId = asString(record["job_id"]);
-  return {
-    type: "exec_error",
-    reason: asString(record["reason"]),
-    // Only the timeout path carries job_id. exactOptionalPropertyTypes means
-    // the key has to be omitted rather than set to undefined.
-    ...jobId === null ? {} : { job_id: jobId }
-  };
-}
-async function* translateExecStream(source) {
-  for await (const raw of source) {
-    const event = toJobEvent(raw);
-    if (event !== null) yield event;
-  }
-}
 
 // src/resources/open-computers/secrets.ts
 var Secrets = class {
@@ -8522,32 +8442,6 @@ var RuntimeCapabilitiesResource = class {
   }
 };
 
-// src/resources/sandbox-host-routes.ts
-var SANDBOXES_HOST_BASE_URL = "https://sandboxes.miosa.ai/api/v1";
-var SANDBOXES_HOST = "sandboxes.miosa.ai";
-function isSandboxesHost(baseUrl) {
-  try {
-    return new URL(baseUrl).host === SANDBOXES_HOST;
-  } catch {
-    return false;
-  }
-}
-async function* streamSandboxesHostRoute(http, path, alternative) {
-  try {
-    yield* http.stream(path);
-  } catch (err) {
-    if (err instanceof MiosaError && err.status === 404 && !isSandboxesHost(http.baseUrl)) {
-      throw new NotFoundError(
-        `HTTP 404 for GET ${path}. This route is mounted only on the sandboxes host router (${SANDBOXES_HOST}); it is not part of the platform router that serves this client's baseUrl (${http.baseUrl}). Either construct the client with baseUrl: "${SANDBOXES_HOST_BASE_URL}", or ${alternative}. A wrong sandbox id also produces a 404.`,
-        err.code,
-        err.details,
-        err.requestId
-      );
-    }
-    throw err;
-  }
-}
-
 // src/resources/sandboxes.ts
 function encodeContent(content) {
   const bytes = typeof content === "string" ? new TextEncoder().encode(content) : content;
@@ -8558,12 +8452,12 @@ function encodeContent(content) {
   return btoa(bin);
 }
 var SANDBOX_TEMPLATE = "miosa-sandbox";
-var SANDBOX_SHAPE_CONTRACTS = {
-  xs: { cpuCount: 1, memoryMb: 2048, diskSizeMb: 10240 },
-  small: { cpuCount: 2, memoryMb: 4096, diskSizeMb: 10240 },
-  medium: { cpuCount: 4, memoryMb: 8192, diskSizeMb: 20480 },
-  large: { cpuCount: 8, memoryMb: 16384, diskSizeMb: 40960 },
-  xl: { cpuCount: 16, memoryMb: 32768, diskSizeMb: 81920 }
+var SANDBOX_TIER_BY_CPU = {
+  1: { size: "xs", memoryMb: 2048 },
+  2: { size: "small", memoryMb: 4096 },
+  4: { size: "medium", memoryMb: 8192 },
+  8: { size: "large", memoryMb: 16384 },
+  16: { size: "xl", memoryMb: 32768 }
 };
 var AGENT_WORKSPACE_TIMEOUT_SEC = 86400;
 var AGENT_WORKSPACE_IDLE_TIMEOUT_SEC = 1800;
@@ -8572,12 +8466,6 @@ var AGENT_WORKSPACE_KEEP_LAST_SNAPSHOTS = 1;
 function isLegacyForkParams(opts) {
   return "name" in opts || "metadata" in opts;
 }
-async function* dropWatchHandshake(source) {
-  for await (const event of source) {
-    if (event.type === "connected") continue;
-    yield event;
-  }
-}
 function unwrap48(payload) {
   if (payload !== null && typeof payload === "object" && "data" in payload && payload.data !== void 0) {
     return payload.data;
@@ -8622,31 +8510,9 @@ function createBody(params = {}) {
   if (legacyPersistencePolicy) metadata.miosa_persistent = persistent;
   const cpuCount = params.cpuCount ?? params.cpu_count;
   const memoryMb = params.memoryMb ?? params.memory_mb;
-  const diskMb = params.diskMb ?? params.disk_mb ?? params.diskSizeMb ?? params.disk_size_mb;
-  const suppliedResources = [cpuCount, memoryMb, diskMb].filter(
-    (value) => value !== void 0
-  ).length;
-  if (suppliedResources !== 0 && suppliedResources !== 3) {
-    throw new TypeError(
-      "Raw sandbox resources require cpuCount, memoryMb, and diskSizeMb together. Prefer size."
-    );
-  }
-  let resolvedSize = params.size;
-  if (suppliedResources === 3) {
-    const matchingSize = Object.entries(SANDBOX_SHAPE_CONTRACTS).find(
-      ([, contract]) => contract.cpuCount === cpuCount && contract.memoryMb === memoryMb && contract.diskSizeMb === diskMb
-    )?.[0];
-    if (!matchingSize) {
-      throw new TypeError(
-        "Raw sandbox resources must exactly match a named size contract."
-      );
-    }
-    if (resolvedSize && resolvedSize !== matchingSize) {
-      throw new TypeError(
-        `Raw sandbox resources match ${matchingSize}, not requested size ${resolvedSize}.`
-      );
-    }
-    resolvedSize = matchingSize;
+  const resolvedSize = params.size;
+  if (cpuCount !== void 0 || memoryMb !== void 0) {
+    assertPublishedShape(cpuCount, memoryMb);
   }
   if (snapshotExpirationSec !== void 0) {
     metadata.snapshot_expiration_sec = snapshotExpirationSec;
@@ -8692,6 +8558,19 @@ function createBody(params = {}) {
     external_project_id: params.externalProjectId ?? params.external_project_id
   });
 }
+function assertPublishedShape(cpuCount, memoryMb) {
+  const tier = cpuCount === void 0 ? void 0 : SANDBOX_TIER_BY_CPU[cpuCount];
+  if (tier && tier.memoryMb === memoryMb) return;
+  const supplied = `${cpuCount ?? "?"} vCPU / ${memoryMb ?? "?"} MiB`;
+  if (tier) {
+    throw new TypeError(
+      `Unsupported cpu/memory combination (${supplied}); nearest supported is ${tier.size} (${cpuCount} vCPU / ${tier.memoryMb} MiB). Pass size: "${tier.size}" or memoryMb: ${tier.memoryMb}. Custom disk sizes are allowed on top of any tier.`
+    );
+  }
+  throw new TypeError(
+    `Unsupported cpu/memory combination (${supplied}). Supported tiers: xs (1/2048), small (2/4096), medium (4/8192), large (8/16384), xl (16/32768). Pass a matching cpuCount + memoryMb (any diskSizeMb is allowed) or use size.`
+  );
+}
 function execBody(command, options = {}) {
   return stripUndefined26({
     command,
@@ -8700,6 +8579,19 @@ function execBody(command, options = {}) {
     timeout: options.timeout ?? options.timeoutSec ?? options.timeout_sec
   });
 }
+function normalizeExecEvent(event, payload) {
+  const record = payload !== null && typeof payload === "object" ? payload : {};
+  const isExit = event === "exit" || record.exit_code !== void 0 || record.exitCode !== void 0 || event === null && typeof payload === "number";
+  if (isExit) {
+    const code = Number(
+      record.exit_code ?? record.exitCode ?? (typeof payload === "number" ? payload : 0)
+    );
+    return { type: "exit", exit_code: code, exitCode: code };
+  }
+  const type = event === "stderr" ? "stderr" : "stdout";
+  const data = typeof payload === "string" ? payload : String(record.line ?? record.data ?? "");
+  return { type, data, line: data };
+}
 function stripUndefined26(input) {
   return Object.fromEntries(
     Object.entries(input).filter(([, value]) => value !== void 0)
@@ -8777,30 +8669,11 @@ var SandboxFiles = class {
     }
     return response;
   }
-  /**
-   * GET /api/v1/sandboxes/{id}/files/watch (SSE) — live file change events.
-   *
-   * SANDBOXES-HOST ONLY. This route is declared in `Web.Router.Sandboxes`
-   * and not in `Web.Router.Platform`, so it 404s against the SDK's default
-   * `https://api.miosa.ai/api/v1` base URL. Construct the client with
-   * `baseUrl: "https://sandboxes.miosa.ai/api/v1"` to reach it, or poll
-   * {@link list}/{@link stat} instead. See `./sandbox-host-routes.ts`.
-   *
-   * The server opens with a handshake record (`event: connected` /
-   * `data: {"sandbox_id":...}`) before any change events. That record is
-   * not a file change, so it is dropped here rather than yielded as a
-   * `SandboxFileChange` with `type: "connected"` and no `path`. Real change
-   * records carry their own `type` (`created` | `modified` | `deleted`) in
-   * the JSON body, so the SSE `event: file_change` name never overwrites it.
-   */
+  /** GET /api/v1/sandboxes/{id}/files/watch (SSE) — live file change events. */
   watch() {
     const http = this.sandbox.http;
-    return dropWatchHandshake(
-      streamSandboxesHostRoute(
-        http,
-        `/sandboxes/${this.sandbox.id}/files/watch`,
-        "poll list()/stat() instead"
-      )
+    return http.stream(
+      `/sandboxes/${this.sandbox.id}/files/watch`
     );
   }
 };
@@ -9149,13 +9022,18 @@ var Sandbox = class _Sandbox {
   }
   execStream(command, options) {
     this.assertRunning("exec.stream");
-    return this.http.stream(
+    const frames = this.http.streamFrames(
       `/sandboxes/${this.id}/exec/stream`,
       {
         method: "POST",
         body: execBody(command, options)
       }
     );
+    return (async function* () {
+      for await (const frame of frames) {
+        yield normalizeExecEvent(frame.event, frame.data);
+      }
+    })();
   }
   async writeFile(path, content) {
     this.assertRunning("writeFile");