@computesdk/cocoonstack 0.0.0-stage → 1.0.1

package/dist/index.mjs

@@ -0,0 +1,594 @@
+// src/index.ts
+import http from "http";
+import http2 from "http2";
+import https from "https";
+import { performance } from "perf_hooks";
+import { StringDecoder } from "string_decoder";
+import tls from "tls";
+import { defineProvider, escapeShellArg } from "@computesdk/provider";
+var PROVIDER = "cocoonstack";
+var DEFAULT_TEMPLATE = "node-rt:24.04";
+var DEFAULT_TTL_SECONDS = 300;
+var MAX_TTL_SECONDS = 86400;
+var DEFAULT_REQUEST_TIMEOUT_MS = 12e4;
+var COMMAND_HTTP_TIMEOUT_BUFFER_MS = 5e3;
+var MAX_RESPONSE_BYTES = 16 << 20;
+var SIZES = [
+  { size: "small", cpu: 1, memoryMb: 512 },
+  { size: "medium", cpu: 2, memoryMb: 1024 },
+  { size: "large", cpu: 4, memoryMb: 4096 },
+  { size: "xlarge", cpu: 4, memoryMb: 8192 },
+  { size: "2xlarge", cpu: 8, memoryMb: 16384 }
+];
+var CocoonstackApiError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "CocoonstackApiError";
+  }
+};
+var claimTokens = /* @__PURE__ */ new Map();
+var sessions = /* @__PURE__ */ new Map();
+var sessionStreams = /* @__PURE__ */ new WeakMap();
+var secureContext = tls.createSecureContext();
+var httpAgent = new http.Agent({ keepAlive: true });
+var httpsAgent = new https.Agent({ keepAlive: true });
+function env(name) {
+  return typeof process === "undefined" ? void 0 : process.env[name];
+}
+function resolve(config) {
+  const baseUrl = config.baseUrl || env("COCOONSTACK_API_URL") || "";
+  if (!baseUrl) {
+    throw new Error(
+      "Missing Cocoon Stack endpoint. Pass baseUrl or set COCOONSTACK_API_URL to your sandboxd address."
+    );
+  }
+  return {
+    baseUrl: baseUrl.replace(/\/$/, ""),
+    apiKey: config.apiKey || env("COCOONSTACK_API_KEY") || "",
+    template: config.template ?? DEFAULT_TEMPLATE,
+    net: config.net ?? "none",
+    size: config.size ?? "small",
+    ttlSeconds: config.ttlSeconds ?? DEFAULT_TTL_SECONDS,
+    requestTimeoutMs: config.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS
+  };
+}
+function claimKey(resolved, id) {
+  return `${resolved.baseUrl} ${id}`;
+}
+function rememberClaim(resolved, id, token, deadline) {
+  const now = Date.now();
+  for (const [key, claim] of claimTokens) {
+    if (claim.deadline < now) claimTokens.delete(key);
+  }
+  claimTokens.set(claimKey(resolved, id), { token, deadline: deadline.getTime() });
+}
+function retainedToken(resolved, id) {
+  const key = claimKey(resolved, id);
+  const claim = claimTokens.get(key);
+  if (!claim) return void 0;
+  if (claim.deadline < Date.now()) {
+    claimTokens.delete(key);
+    return void 0;
+  }
+  return claim.token;
+}
+function detail(body) {
+  const match = /"error"\s*:\s*"([^"]*)"/.exec(body);
+  return match?.[1] ?? body;
+}
+function session(origin, lane) {
+  const key = `${lane} ${origin}`;
+  const live = sessions.get(key);
+  if (live && !live.closed && !live.destroyed) return live;
+  const created = http2.connect(origin, { secureContext });
+  applyHold(created);
+  const drop = () => {
+    if (sessions.get(key) === created) sessions.delete(key);
+  };
+  created.on("connect", () => applyHold(created));
+  created.on("close", drop);
+  created.on("goaway", drop);
+  created.on("error", drop);
+  sessions.set(key, created);
+  return created;
+}
+function holdSession(live) {
+  sessionStreams.set(live, (sessionStreams.get(live) ?? 0) + 1);
+  applyHold(live);
+  return () => {
+    sessionStreams.set(live, Math.max(0, (sessionStreams.get(live) ?? 1) - 1));
+    applyHold(live);
+  };
+}
+function applyHold(live) {
+  const socket = live.socket;
+  if (!socket) return;
+  if ((sessionStreams.get(live) ?? 0) > 0) socket.ref?.();
+  else socket.unref?.();
+}
+function h2Request(origin, lane, method, path, headers, payload, timeoutMs, signal) {
+  return new Promise((fulfill, reject) => {
+    const live = session(origin, lane);
+    const release = holdSession(live);
+    const stream = live.request({ ":method": method, ":path": path, ...headers });
+    let status = 0;
+    let bytes = 0;
+    const chunks = [];
+    const abort = () => stream.close(http2.constants.NGHTTP2_CANCEL);
+    signal?.addEventListener("abort", abort, { once: true });
+    let released = false;
+    const done = () => {
+      if (released) return;
+      released = true;
+      signal?.removeEventListener("abort", abort);
+      release();
+    };
+    stream.setTimeout(timeoutMs, () => {
+      stream.close(http2.constants.NGHTTP2_CANCEL);
+      reject(new Error("sandboxd request timed out"));
+    });
+    stream.on("response", (responseHeaders) => {
+      status = Number(responseHeaders[":status"] ?? 0);
+    });
+    stream.on("data", (chunk) => {
+      bytes += chunk.length;
+      if (bytes > MAX_RESPONSE_BYTES) {
+        stream.close(http2.constants.NGHTTP2_CANCEL);
+        reject(new Error(`sandboxd response exceeds ${MAX_RESPONSE_BYTES >> 20} MiB`));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    stream.on("end", () => {
+      done();
+      fulfill({ status, text: Buffer.concat(chunks).toString("utf8") });
+    });
+    stream.on("error", (error) => {
+      done();
+      reject(signal?.aborted ? signal.reason instanceof Error ? signal.reason : new Error("aborted") : error);
+    });
+    stream.on("close", done);
+    stream.end(payload);
+  });
+}
+function h1Request(url, method, headers, payload, timeoutMs, signal) {
+  return new Promise((fulfill, reject) => {
+    const secure = url.protocol === "https:";
+    const client = (secure ? https : http).request(
+      url,
+      {
+        method,
+        agent: secure ? httpsAgent : httpAgent,
+        timeout: timeoutMs,
+        signal,
+        headers: {
+          ...headers,
+          ...payload === void 0 ? {} : { "content-length": Buffer.byteLength(payload) }
+        }
+      },
+      (response) => {
+        let bytes = 0;
+        const chunks = [];
+        response.on("data", (chunk) => {
+          bytes += chunk.length;
+          if (bytes > MAX_RESPONSE_BYTES) {
+            client.destroy(new Error(`sandboxd response exceeds ${MAX_RESPONSE_BYTES >> 20} MiB`));
+            return;
+          }
+          chunks.push(chunk);
+        });
+        response.on("error", reject);
+        response.on("end", () => fulfill({ status: response.statusCode ?? 0, text: Buffer.concat(chunks).toString("utf8") }));
+      }
+    );
+    client.on("timeout", () => client.destroy(new Error("sandboxd request timed out")));
+    client.on("error", reject);
+    client.end(payload);
+  });
+}
+async function request(resolved, token, method, path, body, signal, timeoutMs = resolved.requestTimeoutMs, lane = "main") {
+  const url = new URL(`${resolved.baseUrl}${path}`);
+  const payload = body === void 0 ? void 0 : JSON.stringify(body);
+  const headers = {
+    "content-type": "application/json",
+    ...token ? { authorization: `Bearer ${token}` } : {}
+  };
+  const { status, text } = url.protocol === "https:" ? await h2Request(url.origin, lane, method, `${url.pathname}${url.search}`, headers, payload, timeoutMs, signal) : await h1Request(url, method, headers, payload, timeoutMs, signal);
+  if (status < 200 || status >= 300) {
+    throw new CocoonstackApiError(status, `sandboxd ${method} ${path} failed (${status}): ${detail(text)}`);
+  }
+  return text ? JSON.parse(text) : void 0;
+}
+function isSize(value) {
+  return SIZES.some((tier) => tier.size === value);
+}
+function sizeFor(resolved, options) {
+  if (options?.size !== void 0) {
+    if (!isSize(options.size)) {
+      throw new Error(
+        `Unknown Cocoon Stack size ${JSON.stringify(options.size)}; one of ${SIZES.map((tier2) => tier2.size).join(", ")}.`
+      );
+    }
+    return options.size;
+  }
+  const cpu = options?.vcpus ?? options?.cpus ?? options?.cpu;
+  const memoryMb = options?.memoryMb ?? options?.memoryMiB ?? options?.memMiB ?? options?.memory;
+  if (cpu === void 0 && memoryMb === void 0) return resolved.size;
+  const tier = SIZES.find((candidate) => candidate.cpu >= (cpu ?? 0) && candidate.memoryMb >= (memoryMb ?? 0));
+  if (!tier) {
+    throw new Error(
+      `No Cocoon Stack size tier offers ${cpu ?? "-"} CPU / ${memoryMb ?? "-"} MB; the largest is 2xlarge (8 CPU / 16384 MB).`
+    );
+  }
+  return tier.size;
+}
+function ttlFor(resolved, options) {
+  if (!options?.timeout) return resolved.ttlSeconds;
+  return Math.min(MAX_TTL_SECONDS, Math.ceil(options.timeout / 1e3));
+}
+function fromRow(config, row, token) {
+  return {
+    id: row.id,
+    token,
+    template: row.key.template,
+    net: row.key.net,
+    size: row.key.size,
+    createdAt: /* @__PURE__ */ new Date(),
+    deadline: new Date(row.deadline),
+    config
+  };
+}
+async function index(resolved) {
+  const listing = await request(resolved, resolved.apiKey, "GET", "/v1/sandboxes");
+  return listing.sandboxes;
+}
+function relay(sandbox, resolved, rpc, options) {
+  return new Promise((fulfill, reject) => {
+    const url = new URL(`${resolved.baseUrl}/v1/sandboxes/${encodeURIComponent(sandbox.id)}/agent`);
+    const secure = url.protocol === "https:";
+    const client = (secure ? https : http).request(url, {
+      method: "GET",
+      agent: secure ? httpsAgent : httpAgent,
+      headers: { upgrade: "silkd", connection: "Upgrade", authorization: `Bearer ${sandbox.token}` }
+    });
+    let settled = false;
+    let timer;
+    const finish = (outcome) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      outcome();
+    };
+    if (options.timeoutMs) {
+      timer = setTimeout(() => {
+        finish(() => reject(new Error(`Command timed out after ${options.timeoutMs} ms`)));
+        client.destroy();
+      }, options.timeoutMs);
+    }
+    client.on("response", (response) => {
+      let body = "";
+      response.setEncoding("utf8");
+      response.on("data", (chunk) => {
+        body += chunk;
+      });
+      response.on(
+        "end",
+        () => finish(
+          () => reject(
+            new CocoonstackApiError(
+              response.statusCode ?? 0,
+              `sandboxd agent relay refused (${response.statusCode}): ${detail(body)}`
+            )
+          )
+        )
+      );
+    });
+    client.on("upgrade", (_response, socket, head) => {
+      const out = new StringDecoder("utf8");
+      const err = new StringDecoder("utf8");
+      let stdout = "";
+      let stderr = "";
+      let frames = 0;
+      let lastOut = 0;
+      let lastErr = 0;
+      let pending = head.toString("utf8");
+      const handle = (frame) => {
+        switch (frame.type) {
+          case "started":
+            if (options.detach) {
+              finish(() => fulfill({ exitCode: 0, stdout: String(frame.pid ?? ""), stderr: "" }));
+              socket.destroy();
+            }
+            break;
+          case "stdout": {
+            lastOut = ++frames;
+            const text = out.write(Buffer.from(frame.data ?? "", "base64"));
+            stdout += text;
+            if (text) options.onStdout?.(text);
+            break;
+          }
+          case "stderr": {
+            lastErr = ++frames;
+            const text = err.write(Buffer.from(frame.data ?? "", "base64"));
+            stderr += text;
+            if (text) options.onStderr?.(text);
+            break;
+          }
+          case "exit": {
+            const tailOut = out.end();
+            const tailErr = err.end();
+            stdout += tailOut;
+            stderr += tailErr;
+            const tails = [
+              [lastOut, tailOut, options.onStdout],
+              [lastErr, tailErr, options.onStderr]
+            ];
+            for (const [, text, notify] of tails.sort((a, b) => a[0] - b[0])) {
+              if (text) notify?.(text);
+            }
+            finish(() => fulfill({ exitCode: frame.code ?? 0, stdout, stderr }));
+            socket.destroy();
+            break;
+          }
+          case "error":
+            finish(() => reject(new Error(`silkd ${frame.kind ?? "error"}: ${frame.message ?? ""}`)));
+            socket.destroy();
+            break;
+          default:
+            break;
+        }
+      };
+      socket.setEncoding("utf8");
+      socket.on("data", (chunk) => {
+        pending += chunk;
+        let newline = pending.indexOf("\n");
+        while (newline >= 0) {
+          const line = pending.slice(0, newline);
+          pending = pending.slice(newline + 1);
+          if (line.trim()) {
+            try {
+              handle(JSON.parse(line));
+            } catch (error) {
+              finish(() => reject(error instanceof Error ? error : new Error(String(error))));
+              socket.destroy();
+              return;
+            }
+          }
+          newline = pending.indexOf("\n");
+        }
+      });
+      socket.on("error", (error) => finish(() => reject(error)));
+      socket.on("close", () => finish(() => reject(new Error("Agent relay closed before the command exited"))));
+      socket.write(`${JSON.stringify({ v: 1, ...rpc })}
+`);
+    });
+    client.on("error", (error) => finish(() => reject(error)));
+    client.end();
+  });
+}
+async function exec(sandbox, command, options) {
+  const started = performance.now();
+  const resolved = resolve(sandbox.config);
+  const argv = ["bash", "-c", command];
+  if (options?.background || options?.onStdout || options?.onStderr) {
+    const result = await relay(
+      sandbox,
+      resolved,
+      {
+        op: "exec",
+        argv,
+        ...options.cwd ? { cwd: options.cwd } : {},
+        ...options.env ? { env: options.env } : {},
+        ...options.background ? { detach: true } : {}
+      },
+      {
+        timeoutMs: options.timeout ?? resolved.requestTimeoutMs,
+        detach: options.background,
+        onStdout: options.onStdout,
+        onStderr: options.onStderr
+      }
+    );
+    return { ...result, durationMs: performance.now() - started };
+  }
+  try {
+    const result = await request(
+      resolved,
+      sandbox.token,
+      "POST",
+      `/v1/sandboxes/${encodeURIComponent(sandbox.id)}/exec`,
+      {
+        argv,
+        ...options?.cwd ? { cwd: options.cwd } : {},
+        ...options?.env ? { env: options.env } : {},
+        ...options?.timeout ? { timeout_seconds: Math.ceil(options.timeout / 1e3) } : {}
+      },
+      void 0,
+      options?.timeout ? options.timeout + COMMAND_HTTP_TIMEOUT_BUFFER_MS : resolved.requestTimeoutMs
+    );
+    return {
+      exitCode: result.exit_code,
+      stdout: result.stdout,
+      stderr: result.stderr,
+      durationMs: performance.now() - started
+    };
+  } catch (error) {
+    if (error instanceof CocoonstackApiError && error.status === 504) {
+      throw new Error(`Command timed out after ${options?.timeout} ms`);
+    }
+    throw error;
+  }
+}
+async function shell(runCommand, sandbox, command, failure) {
+  const result = await runCommand(sandbox, command);
+  if (result.exitCode !== 0) {
+    throw new Error(`${failure}: ${result.stderr.trim() || `exit ${result.exitCode}`}`);
+  }
+  return result.stdout;
+}
+var provider = defineProvider({
+  name: PROVIDER,
+  methods: {
+    sandbox: {
+      create: async (config, options) => {
+        const resolved = resolve(config);
+        const template = options?.templateId ?? options?.image ?? resolved.template;
+        const size = sizeFor(resolved, options);
+        const claimed = await request(
+          resolved,
+          resolved.apiKey,
+          "POST",
+          "/v1/claim",
+          { template, net: resolved.net, size, ttl_seconds: ttlFor(resolved, options) },
+          options?.signal
+        );
+        if (claimed.redirect) {
+          throw new Error(
+            `sandboxd redirected the claim to ${claimed.redirect.join(", ")}; point baseUrl at a node that serves the pool.`
+          );
+        }
+        const deadline = new Date(claimed.deadline);
+        rememberClaim(resolved, claimed.id, claimed.token, deadline);
+        const sandbox = {
+          id: claimed.id,
+          token: claimed.token,
+          template,
+          net: resolved.net,
+          size,
+          createdAt: /* @__PURE__ */ new Date(),
+          deadline,
+          config
+        };
+        return { sandbox, sandboxId: sandbox.id };
+      },
+      getById: async (config, sandboxId) => {
+        const resolved = resolve(config);
+        const token = retainedToken(resolved, sandboxId);
+        if (token === void 0) return null;
+        const row = (await index(resolved)).find((candidate) => candidate.id === sandboxId);
+        return row ? { sandbox: fromRow(config, row, token), sandboxId } : null;
+      },
+      list: async (config) => {
+        const resolved = resolve(config);
+        return (await index(resolved)).flatMap((row) => {
+          const token = retainedToken(resolved, row.id);
+          return token === void 0 ? [] : [{ sandbox: fromRow(config, row, token), sandboxId: row.id }];
+        });
+      },
+      destroy: async (config, sandboxId) => {
+        const resolved = resolve(config);
+        try {
+          await request(
+            resolved,
+            retainedToken(resolved, sandboxId) ?? resolved.apiKey,
+            "POST",
+            `/v1/sandboxes/${encodeURIComponent(sandboxId)}/release`,
+            void 0,
+            void 0,
+            resolved.requestTimeoutMs,
+            "release"
+          );
+        } catch (error) {
+          if (!(error instanceof CocoonstackApiError && error.status === 404)) throw error;
+        }
+        claimTokens.delete(claimKey(resolved, sandboxId));
+      },
+      runCommand: exec,
+      streamCommand: exec,
+      getInfo: async (sandbox) => ({
+        id: sandbox.id,
+        provider: PROVIDER,
+        status: "running",
+        createdAt: sandbox.createdAt,
+        timeout: Math.max(0, sandbox.deadline.getTime() - Date.now()),
+        metadata: {
+          template: sandbox.template,
+          net: sandbox.net,
+          size: sandbox.size,
+          deadline: sandbox.deadline.toISOString()
+        }
+      }),
+      getUrl: async (sandbox, options) => {
+        const resolved = resolve(sandbox.config);
+        const preview = await request(
+          resolved,
+          resolved.apiKey,
+          "POST",
+          `/v1/sandboxes/${encodeURIComponent(sandbox.id)}/preview`,
+          { token: sandbox.token, port: options.port, ttl_seconds: 0 }
+        );
+        return preview.url;
+      },
+      filesystem: {
+        readFile: async (sandbox, path, runCommand) => shell(runCommand, sandbox, `cat "${shellPath(path)}"`, `Failed to read ${path}`),
+        writeFile: async (sandbox, path, content, runCommand) => {
+          const encoded = Buffer.from(content, "utf8").toString("base64");
+          const cut = path.lastIndexOf("/");
+          const directory = cut < 0 ? "." : path.slice(0, cut) || "/";
+          await shell(
+            runCommand,
+            sandbox,
+            `mkdir -p "${shellPath(directory)}" && printf %s "${escapeShellArg(encoded)}" | base64 -d > "${shellPath(path)}"`,
+            `Failed to write ${path}`
+          );
+        },
+        mkdir: async (sandbox, path, runCommand) => {
+          await shell(runCommand, sandbox, `mkdir -p "${shellPath(path)}"`, `Failed to create ${path}`);
+        },
+        readdir: async (sandbox, path, runCommand) => {
+          const listing = await shell(
+            runCommand,
+            sandbox,
+            `find "${shellPath(path)}" -mindepth 1 -maxdepth 1 -printf '%y\\t%s\\t%T@\\t%f\\0'`,
+            `Failed to list ${path}`
+          );
+          return listing.split("\0").flatMap((record) => {
+            if (!record) return [];
+            const [kind, size, modified, ...rest] = record.split("	");
+            const name = rest.join("	");
+            if (!name) return [];
+            return [
+              {
+                name,
+                type: kind === "d" ? "directory" : "file",
+                size: Number.parseInt(size, 10) || 0,
+                modified: new Date(Number.parseFloat(modified) * 1e3)
+              }
+            ];
+          });
+        },
+        exists: async (sandbox, path, runCommand) => {
+          const result = await runCommand(sandbox, `test -e "${shellPath(path)}"`);
+          return result.exitCode === 0;
+        },
+        remove: async (sandbox, path, runCommand) => {
+          await shell(runCommand, sandbox, `rm -rf "${shellPath(path)}"`, `Failed to remove ${path}`);
+        }
+      },
+      getInstance: (sandbox) => sandbox
+    }
+  }
+});
+var cocoonstack = (config) => {
+  if (config.preconnect) preconnect(config.baseUrl || env("COCOONSTACK_API_URL") || "");
+  return provider(config);
+};
+var index_default = cocoonstack;
+function shellPath(path) {
+  return escapeShellArg(path.startsWith("/") ? path : `./${path}`);
+}
+function preconnect(baseUrl) {
+  let url;
+  try {
+    url = new URL(baseUrl);
+  } catch {
+    return;
+  }
+  if (url.protocol === "https:") session(url.origin, "main");
+}
+export {
+  CocoonstackApiError,
+  cocoonstack,
+  index_default as default
+};
+//# sourceMappingURL=index.mjs.map