sbox-sdk 0.0.2

package/dist/e2b/index.js

@@ -0,0 +1,411 @@
+/**
+ * `sbox-sdk/e2b` — adapter for E2B (@e2b/code-interpreter). The canonical
+ * reference adapter: richest capability set (code interpreter, snapshots,
+ * ports, pause/resume). The heavy SDK is lazy-imported inside create()/connect()
+ * so importing this subpath stays cheap. Requires the optional peer
+ * dependency `@e2b/code-interpreter`.
+ */
+import { AsyncQueue, defineProvider, numExit, SandboxError, } from "../adapter/index.js";
+export const E2B_CAPS = {
+    background: "native",
+    codeInterpreter: "native",
+    egressControl: "unsupported",
+    exposePort: "native",
+    filesUpload: "native",
+    filesWatch: "native",
+    fork: "unsupported",
+    gpu: "unsupported",
+    killProcess: "native",
+    list: "native",
+    metrics: "native",
+    pause: "native",
+    privatePreview: "unsupported",
+    proxiedFetch: "unsupported",
+    pty: "unsupported",
+    region: "unsupported",
+    secretsVault: "unsupported",
+    setTimeout: "native",
+    snapshot: "native",
+    ssh: "unsupported",
+    statefulKernel: "native",
+    stdin: "unsupported",
+    stop: "unsupported",
+    streaming: "native",
+    volumes: "unsupported",
+};
+const E2B_FLAGS = {
+    exitCodeNative: true,
+    perCommandEnvCwd: true,
+    preservesDiskOnStop: false,
+    preservesMemoryOnPause: true,
+    previewModel: "subdomain",
+};
+let cached = null;
+async function loadE2B() {
+    if (!cached) {
+        cached = (await import("@e2b/code-interpreter"));
+    }
+    return cached;
+}
+// --------------------------------------------------------------------------
+// helpers
+// --------------------------------------------------------------------------
+function toArrayBuffer(b) {
+    return b.buffer.slice(b.byteOffset, b.byteOffset + b.byteLength);
+}
+function mapFsEvent(type) {
+    const t = String(type).toLowerCase();
+    if (t.includes("create")) {
+        return "create";
+    }
+    if (t.includes("remove") || t.includes("delete")) {
+        return "delete";
+    }
+    return "modify";
+}
+function mapResult(r) {
+    const rr = r;
+    const mime = {};
+    const put = (key, mimeType) => {
+        const v = rr[key];
+        if (typeof v === "string") {
+            mime[mimeType] = v;
+        }
+    };
+    put("text", "text/plain");
+    put("html", "text/html");
+    put("markdown", "text/markdown");
+    put("svg", "image/svg+xml");
+    put("png", "image/png");
+    put("jpeg", "image/jpeg");
+    put("pdf", "application/pdf");
+    put("latex", "text/latex");
+    if (rr.json !== undefined) {
+        mime["application/json"] =
+            typeof rr.json === "string" ? rr.json : JSON.stringify(rr.json);
+    }
+    return { mime, text: typeof rr.text === "string" ? rr.text : undefined };
+}
+function mapExecution(exec) {
+    return {
+        error: exec.error
+            ? {
+                name: exec.error.name,
+                traceback: exec.error.traceback,
+                value: exec.error.value,
+            }
+            : undefined,
+        logs: { stderr: exec.logs.stderr, stdout: exec.logs.stdout },
+        results: exec.results.map(mapResult),
+    };
+}
+function mapE2BError(e) {
+    const name = e && typeof e === "object" && "name" in e
+        ? String(e.name)
+        : "";
+    const msg = e instanceof Error ? e.message : String(e);
+    const hay = `${name} ${msg}`;
+    if (/notfound|not found/i.test(hay)) {
+        return new SandboxError("NotFound", msg, { cause: e, provider: "e2b" });
+    }
+    if (/auth|unauthorized|api ?key|forbidden/i.test(hay)) {
+        return new SandboxError("Unauthorized", msg, { cause: e, provider: "e2b" });
+    }
+    if (/ratelimit|rate limit|quota|too many/i.test(hay)) {
+        return new SandboxError("QuotaExceeded", msg, {
+            cause: e,
+            provider: "e2b",
+            retryable: true,
+        });
+    }
+    if (/timeout|timed out/i.test(hay)) {
+        return new SandboxError("Timeout", msg, { cause: e, provider: "e2b" });
+    }
+    return undefined;
+}
+// --------------------------------------------------------------------------
+// provider
+// --------------------------------------------------------------------------
+export const e2b = defineProvider((opts) => {
+    const makeHandle = (initial) => {
+        let current = initial;
+        const contexts = new Map();
+        const runStreaming = (cmd, options) => {
+            const queue = new AsyncQueue();
+            let killer = null;
+            const handleP = current.commands
+                .run(cmd, {
+                background: true,
+                cwd: options.cwd,
+                envs: options.env,
+                onStderr: (data) => queue.push({ data, type: "stderr" }),
+                onStdout: (data) => queue.push({ data, type: "stdout" }),
+                timeoutMs: options.timeoutMs,
+            })
+                .then((handle) => {
+                killer = () => handle.kill();
+                void (async () => {
+                    try {
+                        const res = await handle.wait();
+                        queue.push({ exitCode: res.exitCode, type: "exit" });
+                    }
+                    catch (error) {
+                        queue.push({ exitCode: numExit(error), type: "exit" });
+                    }
+                    queue.close();
+                })();
+                return handle;
+            })
+                .catch((error) => {
+                queue.fail(mapE2BError(error) ?? SandboxError.wrap(error, "e2b"));
+                return null;
+            });
+            return {
+                pid: handleP.then((h) => (h ? String(h.pid) : "")),
+                kill: async () => {
+                    await handleP;
+                    if (killer) {
+                        await killer();
+                    }
+                },
+                [Symbol.asyncIterator]: () => queue.iterator(),
+            };
+        };
+        const handle = {
+            async createContext(options) {
+                const c = await current.createCodeContext({
+                    cwd: options.cwd,
+                    language: options.language,
+                });
+                const { id } = c;
+                contexts.set(id, c);
+                return { id, language: options.language ?? "python" };
+            },
+            async deleteSnapshot(ref) {
+                const { Sandbox } = await loadE2B();
+                await Sandbox.deleteSnapshot(ref, { apiKey: opts.apiKey });
+            },
+            async destroy() {
+                await current.kill();
+            },
+            exec(cmd, options) {
+                return runStreaming(cmd, options);
+            },
+            exposePort(port) {
+                const host = current.getHost(port);
+                return { port, url: `https://${host}` };
+            },
+            async getInfo() {
+                const i = await current.getInfo();
+                return {
+                    createdAt: i.startedAt,
+                    id: current.sandboxId,
+                    metadata: i.metadata,
+                    name: i.name,
+                    provider: "e2b",
+                    raw: i,
+                    state: "running",
+                };
+            },
+            get id() {
+                return current.sandboxId;
+            },
+            async killProcess(processId) {
+                await current.commands.kill(Number(processId));
+            },
+            async listDir(path) {
+                const entries = await current.files.list(path);
+                return entries.map((e) => ({
+                    name: e.name,
+                    path: e.path ?? `${path}/${e.name}`,
+                    type: e.type === "dir" ? "dir" : "file",
+                }));
+            },
+            async listProcesses() {
+                const ps = await current.commands.list();
+                return ps.map((p) => ({
+                    cmd: p.cmd ?? p.args?.join(" ") ?? "",
+                    id: String(p.pid),
+                }));
+            },
+            async mkdir(path) {
+                await current.files.makeDir(path);
+            },
+            async pause(_ctx) {
+                const { Sandbox } = await loadE2B();
+                await Sandbox.pause(current.sandboxId, { apiKey: opts.apiKey });
+            },
+            get raw() {
+                return current;
+            },
+            readFile(path) {
+                return current.files.read(path, { format: "bytes" });
+            },
+            async remove(path) {
+                await current.files.remove(path);
+            },
+            async rename(from, to) {
+                await current.files.rename(from, to);
+            },
+            async resume() {
+                const { Sandbox } = await loadE2B();
+                current = (await Sandbox.connect(current.sandboxId, {
+                    apiKey: opts.apiKey,
+                }));
+            },
+            async runCode(code, options) {
+                const realContext = options.context
+                    ? contexts.get(options.context.id)
+                    : undefined;
+                const common = {
+                    onStderr: options.onStderr
+                        ? (m) => options.onStderr(m.line)
+                        : undefined,
+                    onStdout: options.onStdout
+                        ? (m) => options.onStdout(m.line)
+                        : undefined,
+                };
+                const exec = realContext
+                    ? await current.runCode(code, {
+                        ...common,
+                        context: realContext,
+                    })
+                    : await current.runCode(code, {
+                        ...common,
+                        language: options.language,
+                    });
+                return mapExecution(exec);
+            },
+            async setTimeout(ttlMs) {
+                await current.setTimeout(ttlMs);
+            },
+            async snapshot(options) {
+                const snap = await current.createSnapshot({ name: options.name });
+                return {
+                    id: snap.snapshotId,
+                    name: options.name,
+                    provider: "e2b",
+                    raw: snap,
+                };
+            },
+            async spawn(cmd, options) {
+                const queue = new AsyncQueue();
+                const handle2 = await current.commands.run(cmd, {
+                    background: true,
+                    cwd: options.cwd,
+                    envs: options.env,
+                    onStderr: (data) => queue.push({ type: "stderr", data }),
+                    onStdout: (data) => queue.push({ type: "stdout", data }),
+                    timeoutMs: options.timeoutMs,
+                });
+                void (async () => {
+                    try {
+                        const res = await handle2.wait();
+                        queue.push({ exitCode: res.exitCode, type: "exit" });
+                    }
+                    catch (error) {
+                        queue.push({ type: "exit", exitCode: numExit(error) });
+                    }
+                    queue.close();
+                })();
+                const pid = String(handle2.pid);
+                return {
+                    id: pid,
+                    pid: Promise.resolve(pid),
+                    kill: async () => {
+                        await handle2.kill();
+                    },
+                    [Symbol.asyncIterator]: () => queue.iterator(),
+                };
+            },
+            async stat(path) {
+                const e = await current.files.getInfo(path);
+                return {
+                    mtime: e.modifiedTime,
+                    path: e.path ?? path,
+                    size: e.size,
+                    type: e.type === "dir" ? "dir" : "file",
+                };
+            },
+            async upload(path, data) {
+                if (typeof data === "string") {
+                    await current.files.write(path, data);
+                }
+                else if (data instanceof Uint8Array) {
+                    await current.files.write(path, toArrayBuffer(data));
+                }
+                else {
+                    await current.files.write(path, data);
+                }
+            },
+            async watch(path, cb, recursive) {
+                const wh = await current.files.watchDir(path, (ev) => {
+                    const { name } = ev;
+                    cb({
+                        path: name ? `${path}/${name}` : path,
+                        type: mapFsEvent(ev.type),
+                    });
+                }, { recursive });
+                return async () => {
+                    await wh.stop();
+                };
+            },
+            async writeFile(path, data) {
+                await current.files.write(path, toArrayBuffer(data));
+            },
+        };
+        return handle;
+    };
+    const provider = {
+        capabilities: E2B_CAPS,
+        async connect(id) {
+            const { Sandbox } = await loadE2B();
+            const native = await Sandbox.connect(id, { apiKey: opts.apiKey });
+            return makeHandle(native);
+        },
+        async create(spec, ctx) {
+            const { Sandbox } = await loadE2B();
+            const createOpts = {
+                apiKey: opts.apiKey,
+                domain: opts.domain,
+                envs: spec.env,
+                metadata: {
+                    ...spec.metadata,
+                    ...(ctx.idempotencyKey ? { _sboxIdem: ctx.idempotencyKey } : {}),
+                },
+                timeoutMs: spec.ttlMs,
+            };
+            const native = spec.template
+                ? await Sandbox.create(spec.template, createOpts)
+                : await Sandbox.create(createOpts);
+            return makeHandle(native);
+        },
+        flags: E2B_FLAGS,
+        async *list(filter, _ctx) {
+            const { Sandbox } = await loadE2B();
+            const pg = Sandbox.list({ apiKey: opts.apiKey });
+            let count = 0;
+            while (pg.hasNext) {
+                const items = await pg.nextItems();
+                for (const it of items) {
+                    yield {
+                        createdAt: it.startedAt,
+                        id: it.sandboxId,
+                        metadata: it.metadata,
+                        name: it.name,
+                        provider: "e2b",
+                        raw: it,
+                        state: "running",
+                    };
+                    count++;
+                    if (filter?.limit !== undefined && count >= filter.limit) {
+                        return;
+                    }
+                }
+            }
+        },
+        mapError: mapE2BError,
+        name: "e2b",
+    };
+    return provider;
+});

package/dist/fly/index.d.ts

@@ -0,0 +1,75 @@
+import type { SandboxProvider } from "../adapter/index.js";
+export interface FlyOptions {
+    apiToken: string;
+    appName: string;
+    image?: string;
+    region?: string;
+    /** Public app domain for preview URLs; defaults to `<appName>.fly.dev`. */
+    appDomain?: string;
+    /** Override the Machines API base (default https://api.machines.dev/v1). */
+    apiBaseUrl?: string;
+    /** Injectable fetch (testing); defaults to globalThis.fetch. */
+    fetch?: typeof fetch;
+}
+interface FlyMachine {
+    id: string;
+    state?: string;
+    config?: unknown;
+}
+export declare const FLY_CAPS: {
+    readonly background: "unsupported";
+    readonly codeInterpreter: "unsupported";
+    readonly egressControl: "unsupported";
+    readonly exposePort: "native";
+    readonly filesUpload: "native";
+    readonly filesWatch: "unsupported";
+    readonly fork: "unsupported";
+    readonly gpu: "unsupported";
+    readonly killProcess: "unsupported";
+    readonly list: "native";
+    readonly metrics: "unsupported";
+    readonly pause: "native";
+    readonly privatePreview: "unsupported";
+    readonly proxiedFetch: "unsupported";
+    readonly pty: "unsupported";
+    readonly region: "native";
+    readonly secretsVault: "unsupported";
+    readonly setTimeout: "unsupported";
+    readonly snapshot: "unsupported";
+    readonly ssh: "unsupported";
+    readonly statefulKernel: "unsupported";
+    readonly stdin: "unsupported";
+    readonly stop: "native";
+    readonly streaming: "emulated";
+    readonly volumes: "unsupported";
+};
+export type FlyCaps = typeof FLY_CAPS;
+export declare const fly: (opts: FlyOptions) => SandboxProvider<{
+    readonly background: "unsupported";
+    readonly codeInterpreter: "unsupported";
+    readonly egressControl: "unsupported";
+    readonly exposePort: "native";
+    readonly filesUpload: "native";
+    readonly filesWatch: "unsupported";
+    readonly fork: "unsupported";
+    readonly gpu: "unsupported";
+    readonly killProcess: "unsupported";
+    readonly list: "native";
+    readonly metrics: "unsupported";
+    readonly pause: "native";
+    readonly privatePreview: "unsupported";
+    readonly proxiedFetch: "unsupported";
+    readonly pty: "unsupported";
+    readonly region: "native";
+    readonly secretsVault: "unsupported";
+    readonly setTimeout: "unsupported";
+    readonly snapshot: "unsupported";
+    readonly ssh: "unsupported";
+    readonly statefulKernel: "unsupported";
+    readonly stdin: "unsupported";
+    readonly stop: "native";
+    readonly streaming: "emulated";
+    readonly volumes: "unsupported";
+}, FlyMachine>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/fly/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/fly/index.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EASV,eAAe,EAGhB,MAAM,qBAAqB,CAAC;AAE7B,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,2EAA2E;IAC3E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,4EAA4E;IAC5E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gEAAgE;IAChE,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;CACtB;AAED,UAAU,UAAU;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Ba,CAAC;AAEnC,MAAM,MAAM,OAAO,GAAG,OAAO,QAAQ,CAAC;AA0BtC,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;cA+Kd,CAAC"}