@alibaba-group/opensandbox 0.1.3 → 0.1.5

package/dist/cjs/internal.cjs

@@ -90,25 +90,26 @@ var SandboxException = class extends Error {
   name = "SandboxException";
   error;
   cause;
+  requestId;
   constructor(opts = {}) {
     super(opts.message);
     this.cause = opts.cause;
     this.error = opts.error ?? new SandboxError(SandboxError.INTERNAL_UNKNOWN_ERROR);
+    this.requestId = opts.requestId;
   }
 };
 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)
+      error: opts.error ?? new SandboxError(SandboxError.UNEXPECTED_RESPONSE, opts.message),
+      requestId: opts.requestId
     });
     this.statusCode = opts.statusCode;
-    this.requestId = opts.requestId;
     this.rawBody = opts.rawBody;
   }
 };
@@ -153,11 +154,15 @@ var SandboxesAdapter = class {
     }
     return d;
   }
+  parseOptionalIsoDate(field, v) {
+    if (v == null) return null;
+    return this.parseIsoDate(field, v);
+  }
   mapSandboxInfo(raw) {
     return {
       ...raw ?? {},
       createdAt: this.parseIsoDate("createdAt", raw?.createdAt),
-      expiresAt: this.parseIsoDate("expiresAt", raw?.expiresAt)
+      expiresAt: this.parseOptionalIsoDate("expiresAt", raw?.expiresAt)
     };
   }
   async createSandbox(req) {
@@ -173,7 +178,7 @@ var SandboxesAdapter = class {
     return {
       ...raw ?? {},
       createdAt: this.parseIsoDate("createdAt", raw?.createdAt),
-      expiresAt: this.parseIsoDate("expiresAt", raw?.expiresAt)
+      expiresAt: this.parseOptionalIsoDate("expiresAt", raw?.expiresAt)
     };
   }
   async getSandbox(sandboxId) {
@@ -244,9 +249,9 @@ var SandboxesAdapter = class {
       expiresAt: raw?.expiresAt ? this.parseIsoDate("expiresAt", raw.expiresAt) : void 0
     };
   }
-  async getSandboxEndpoint(sandboxId, port) {
+  async getSandboxEndpoint(sandboxId, port, useServerProxy = false) {
     const { data, error, response } = await this.client.GET("/sandboxes/{sandboxId}/endpoints/{port}", {
-      params: { path: { sandboxId, port } }
+      params: { path: { sandboxId, port }, query: { use_server_proxy: useServerProxy } }
     });
     throwOnOpenApiFetchError({ error, response }, "Get sandbox endpoint failed");
     const ok = data;
@@ -858,11 +863,61 @@ function joinUrl2(baseUrl, pathname) {
   return `${base}${path}`;
 }
 function toRunCommandRequest(command, opts) {
-  return {
+  if (opts?.gid != null && opts.uid == null) {
+    throw new Error("uid is required when gid is provided");
+  }
+  const body = {
     command,
     cwd: opts?.workingDirectory,
     background: !!opts?.background
   };
+  if (opts?.timeoutSeconds != null) {
+    body.timeout = Math.round(opts.timeoutSeconds * 1e3);
+  }
+  if (opts?.uid != null) {
+    body.uid = opts.uid;
+  }
+  if (opts?.gid != null) {
+    body.gid = opts.gid;
+  }
+  if (opts?.envs != null) {
+    body.envs = opts.envs;
+  }
+  return body;
+}
+function toRunInSessionRequest(command, opts) {
+  const body = {
+    command
+  };
+  if (opts?.workingDirectory != null) {
+    body.cwd = opts.workingDirectory;
+  }
+  if (opts?.timeout != null) {
+    body.timeout = opts.timeout;
+  }
+  return body;
+}
+function inferForegroundExitCode(execution) {
+  const errorValue = execution.error?.value?.trim();
+  const parsedExitCode = errorValue && /^-?\d+$/.test(errorValue) ? Number(errorValue) : Number.NaN;
+  return execution.error != null ? Number.isFinite(parsedExitCode) ? parsedExitCode : null : execution.complete ? 0 : null;
+}
+function assertNonBlank(value, field) {
+  if (!value.trim()) {
+    throw new Error(`${field} cannot be empty`);
+  }
+}
+function parseOptionalDate(value, field) {
+  if (value == null) return void 0;
+  if (value instanceof Date) return value;
+  if (typeof value !== "string") {
+    throw new Error(`Invalid ${field}: expected ISO string, got ${typeof value}`);
+  }
+  const parsed = new Date(value);
+  if (Number.isNaN(parsed.getTime())) {
+    throw new Error(`Invalid ${field}: ${value}`);
+  }
+  return parsed;
 }
 var CommandsAdapter = class {
   constructor(client, opts) {
@@ -871,43 +926,149 @@ var CommandsAdapter = class {
     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");
+  buildRunStreamSpec(command, opts) {
+    assertNonBlank(command, "command");
+    return {
+      pathname: "/command",
+      body: toRunCommandRequest(command, opts),
+      fallbackErrorMessage: "Run command failed"
+    };
   }
-  async *runStream(command, opts, signal) {
-    const url = joinUrl2(this.opts.baseUrl, "/command");
-    const body = JSON.stringify(toRunCommandRequest(command, opts));
+  buildRunInSessionStreamSpec(sessionId, command, opts) {
+    assertNonBlank(sessionId, "sessionId");
+    assertNonBlank(command, "command");
+    return {
+      pathname: `/session/${encodeURIComponent(sessionId)}/run`,
+      body: toRunInSessionRequest(command, opts),
+      fallbackErrorMessage: "Run in session failed"
+    };
+  }
+  async *streamExecution(spec, signal) {
+    const url = joinUrl2(this.opts.baseUrl, spec.pathname);
     const res = await this.fetch(url, {
       method: "POST",
       headers: {
-        "accept": "text/event-stream",
+        accept: "text/event-stream",
         "content-type": "application/json",
         ...this.opts.headers ?? {}
       },
-      body,
+      body: JSON.stringify(spec.body),
       signal
     });
-    for await (const ev of parseJsonEventStream(res, { fallbackErrorMessage: "Run command failed" })) {
+    for await (const ev of parseJsonEventStream(res, {
+      fallbackErrorMessage: spec.fallbackErrorMessage
+    })) {
       yield ev;
     }
   }
-  async run(command, opts, handlers, signal) {
+  async consumeExecutionStream(stream, handlers, inferExitCode = false) {
     const execution = {
       logs: { stdout: [], stderr: [] },
       result: []
     };
     const dispatcher = new ExecutionEventDispatcher(execution, handlers);
-    for await (const ev of this.runStream(command, opts, signal)) {
+    for await (const ev of stream) {
       if (ev.type === "init" && (ev.text ?? "") === "" && execution.id) {
         ev.text = execution.id;
       }
       await dispatcher.dispatch(ev);
     }
+    if (inferExitCode) {
+      execution.exitCode = inferForegroundExitCode(execution);
+    }
     return execution;
   }
+  async interrupt(sessionId) {
+    const { error, response } = await this.client.DELETE("/command", {
+      params: { query: { id: sessionId } }
+    });
+    throwOnOpenApiFetchError({ error, response }, "Interrupt command failed");
+  }
+  async getCommandStatus(commandId) {
+    const { data, error, response } = await this.client.GET("/command/status/{id}", {
+      params: { path: { id: commandId } }
+    });
+    throwOnOpenApiFetchError({ error, response }, "Get command status failed");
+    const ok = data;
+    if (!ok || typeof ok !== "object") {
+      throw new Error("Get command status failed: unexpected response shape");
+    }
+    return {
+      id: ok.id,
+      content: ok.content,
+      running: ok.running,
+      exitCode: ok.exit_code ?? null,
+      error: ok.error,
+      startedAt: parseOptionalDate(ok.started_at, "startedAt"),
+      finishedAt: parseOptionalDate(ok.finished_at, "finishedAt") ?? null
+    };
+  }
+  async getBackgroundCommandLogs(commandId, cursor) {
+    const { data, error, response } = await this.client.GET("/command/{id}/logs", {
+      params: { path: { id: commandId }, query: cursor == null ? {} : { cursor } },
+      parseAs: "text"
+    });
+    throwOnOpenApiFetchError({ error, response }, "Get command logs failed");
+    const ok = data;
+    if (typeof ok !== "string") {
+      throw new Error("Get command logs failed: unexpected response shape");
+    }
+    const cursorHeader = response.headers.get("EXECD-COMMANDS-TAIL-CURSOR");
+    const parsedCursor = cursorHeader != null && cursorHeader !== "" ? Number(cursorHeader) : void 0;
+    return {
+      content: ok,
+      cursor: Number.isFinite(parsedCursor ?? NaN) ? parsedCursor : void 0
+    };
+  }
+  async *runStream(command, opts, signal) {
+    for await (const ev of this.streamExecution(
+      this.buildRunStreamSpec(command, opts),
+      signal
+    )) {
+      yield ev;
+    }
+  }
+  async run(command, opts, handlers, signal) {
+    return this.consumeExecutionStream(
+      this.runStream(command, opts, signal),
+      handlers,
+      !opts?.background
+    );
+  }
+  async createSession(options) {
+    const body = options?.workingDirectory != null ? { cwd: options.workingDirectory } : {};
+    const { data, error, response } = await this.client.POST("/session", {
+      body
+    });
+    throwOnOpenApiFetchError({ error, response }, "Create session failed");
+    const ok = data;
+    if (!ok || typeof ok.session_id !== "string") {
+      throw new Error("Create session failed: unexpected response shape");
+    }
+    return ok.session_id;
+  }
+  async *runInSessionStream(sessionId, command, opts, signal) {
+    for await (const ev of this.streamExecution(
+      this.buildRunInSessionStreamSpec(sessionId, command, opts),
+      signal
+    )) {
+      yield ev;
+    }
+  }
+  async runInSession(sessionId, command, options, handlers, signal) {
+    return this.consumeExecutionStream(
+      this.runInSessionStream(sessionId, command, options, signal),
+      handlers,
+      true
+    );
+  }
+  async deleteSession(sessionId) {
+    const { error, response } = await this.client.DELETE(
+      "/session/{sessionId}",
+      { params: { path: { sessionId } } }
+    );
+    throwOnOpenApiFetchError({ error, response }, "Delete session failed");
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {