sbox-sdk 0.0.2

package/dist/daytona/index.js

@@ -0,0 +1,258 @@
+/**
+ * `sbox-sdk/daytona` — adapter for `@daytonaio/sdk`. A full-featured sandbox:
+ * exec + code interpreter (with matplotlib charts), filesystem, snapshots,
+ * stop/pause/resume, preview links, regions. Node-only (uses Buffer for fs).
+ * Notable normalization: Daytona timeouts are in SECONDS — the adapter converts
+ * from the SDK's milliseconds. Requires the optional peer dependency
+ * `@daytonaio/sdk`.
+ */
+import { AsyncQueue, defineProvider, SandboxError } from "../adapter/index.js";
+export const DAYTONA_CAPS = {
+    background: "unsupported",
+    codeInterpreter: "native",
+    egressControl: "unsupported",
+    exposePort: "native",
+    filesUpload: "native",
+    filesWatch: "unsupported",
+    fork: "unsupported",
+    gpu: "unsupported",
+    killProcess: "unsupported",
+    list: "native",
+    metrics: "unsupported",
+    pause: "native",
+    privatePreview: "native",
+    proxiedFetch: "unsupported",
+    pty: "unsupported",
+    region: "native",
+    secretsVault: "unsupported",
+    setTimeout: "native",
+    snapshot: "unsupported",
+    ssh: "unsupported",
+    statefulKernel: "unsupported",
+    stdin: "unsupported",
+    stop: "native",
+    streaming: "emulated",
+    volumes: "unsupported",
+};
+const DAYTONA_FLAGS = {
+    exitCodeNative: true,
+    perCommandEnvCwd: true,
+    preservesDiskOnStop: true,
+    preservesMemoryOnPause: true,
+    previewModel: "subdomain",
+};
+let cached = null;
+async function loadDaytona() {
+    if (!cached) {
+        cached = (await import("@daytonaio/sdk"));
+    }
+    return cached;
+}
+function mapState(state) {
+    switch (state) {
+        case "started":
+        case "running": {
+            return "running";
+        }
+        case "stopped":
+        case "archived": {
+            return "stopped";
+        }
+        case "paused": {
+            return "paused";
+        }
+        case "starting":
+        case "creating": {
+            return "creating";
+        }
+        case "error": {
+            return "error";
+        }
+        default: {
+            return "unknown";
+        }
+    }
+}
+function secs(ms) {
+    return ms === undefined ? undefined : Math.ceil(ms / 1000);
+}
+function mapDaytonaError(e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (/not ?found/i.test(msg)) {
+        return new SandboxError("NotFound", msg, { cause: e, provider: "daytona" });
+    }
+    if (/unauthor|forbidden|api key/i.test(msg)) {
+        return new SandboxError("Unauthorized", msg, {
+            cause: e,
+            provider: "daytona",
+        });
+    }
+    if (/timeout|timed out/i.test(msg)) {
+        return new SandboxError("Timeout", msg, { cause: e, provider: "daytona" });
+    }
+    return undefined;
+}
+export const daytona = defineProvider((opts) => {
+    let client = null;
+    const getClient = async () => {
+        if (!client) {
+            const mod = await loadDaytona();
+            client = new mod.Daytona({
+                apiKey: opts.apiKey,
+                apiUrl: opts.apiUrl,
+                target: opts.target,
+            });
+        }
+        return client;
+    };
+    const makeHandle = (sb) => {
+        const proc = sb.process;
+        const { fs } = sb;
+        const lifecycle = sb;
+        return {
+            id: lifecycle.id,
+            raw: sb,
+            getInfo() {
+                return {
+                    id: lifecycle.id,
+                    state: mapState(lifecycle.state),
+                    provider: "daytona",
+                    metadata: {},
+                    raw: sb,
+                };
+            },
+            async destroy() {
+                await lifecycle.delete();
+            },
+            async stop() {
+                await lifecycle.stop();
+            },
+            async pause() {
+                await lifecycle.pause();
+            },
+            async resume() {
+                await lifecycle.start();
+            },
+            async setTimeout(ttlMs) {
+                await lifecycle.setAutostopInterval(Math.max(0, Math.ceil(ttlMs / 60_000)));
+            },
+            exec(cmd, options) {
+                const queue = new AsyncQueue();
+                void proc
+                    .executeCommand(cmd, options.cwd, options.env, secs(options.timeoutMs))
+                    .then((res) => {
+                    const out = res.result ?? res.artifacts?.stdout ?? "";
+                    if (out) {
+                        queue.push({ type: "stdout", data: out });
+                    }
+                    queue.push({ type: "exit", exitCode: res.exitCode ?? 0 });
+                    queue.close();
+                })
+                    .catch((error) => queue.fail(mapDaytonaError(error) ?? SandboxError.wrap(error, "daytona")));
+                return {
+                    pid: Promise.resolve(""),
+                    async kill() {
+                        /* executeCommand is buffered; no kill handle */
+                    },
+                    [Symbol.asyncIterator]: () => queue.iterator(),
+                };
+            },
+            async readFile(path) {
+                return new Uint8Array(await fs.downloadFile(path));
+            },
+            async writeFile(path, data) {
+                await fs.uploadFile(data, path);
+            },
+            async listDir(path) {
+                const files = await fs.listFiles(path);
+                return files.map((f) => ({
+                    name: f.name,
+                    path: `${path.replace(/\/$/, "")}/${f.name}`,
+                    type: f.isDir ? "dir" : "file",
+                }));
+            },
+            async mkdir(path) {
+                await fs.createFolder(path, "755");
+            },
+            async remove(path, recursive) {
+                await fs.deleteFile(path, recursive);
+            },
+            async rename(from, to) {
+                await fs.moveFiles(from, to);
+            },
+            async stat(path) {
+                const d = await fs.getFileDetails(path);
+                return {
+                    path,
+                    type: d.isDir ? "dir" : "file",
+                    size: d.size ?? 0,
+                    mtime: d.modTime ? new Date(d.modTime) : undefined,
+                };
+            },
+            async exposePort(port) {
+                const link = await lifecycle.getPreviewLink(port);
+                return { url: link.url, port, token: link.token };
+            },
+            async runCode(code, options) {
+                const res = await proc.codeRun(code, { language: options.language });
+                const charts = res.artifacts?.charts ?? [];
+                return {
+                    results: charts.map((c) => {
+                        const cc = c;
+                        const mime = {};
+                        if (cc.png) {
+                            mime["image/png"] = cc.png;
+                        }
+                        return { mime };
+                    }),
+                    logs: { stdout: res.result ? [res.result] : [], stderr: [] },
+                    error: res.exitCode && res.exitCode !== 0
+                        ? { name: "Error", value: res.result ?? "" }
+                        : undefined,
+                };
+            },
+            async createContext(options) {
+                // Daytona codeRun is stateless; return a nominal context (statefulKernel = unsupported).
+                return { id: "default", language: options.language ?? "python" };
+            },
+        };
+    };
+    const provider = {
+        name: "daytona",
+        capabilities: DAYTONA_CAPS,
+        flags: DAYTONA_FLAGS,
+        mapError: mapDaytonaError,
+        async create(spec) {
+            const c = await getClient();
+            const tpl = spec.template;
+            const base = tpl && /[:/]/.test(tpl) ? { image: tpl } : tpl ? { snapshot: tpl } : {};
+            const sb = await c.create({
+                ...base,
+                envVars: spec.env,
+                labels: spec.metadata,
+                ...(spec.resources?.vcpus
+                    ? { resources: { cpu: spec.resources.vcpus } }
+                    : {}),
+            }, spec.ttlMs ? { timeout: secs(spec.ttlMs) } : undefined);
+            return makeHandle(sb);
+        },
+        async connect(id) {
+            const c = await getClient();
+            return makeHandle((await c.get(id)));
+        },
+        async *list() {
+            const c = await getClient();
+            for await (const s of c.list()) {
+                const sb = s;
+                yield {
+                    id: sb.id,
+                    state: mapState(sb.state),
+                    provider: "daytona",
+                    metadata: {},
+                    raw: s,
+                };
+            }
+        },
+    };
+    return provider;
+});

package/dist/e2b/index.d.ts

@@ -0,0 +1,63 @@
+import type { Sandbox as E2BSandbox } from "@e2b/code-interpreter";
+import type { SandboxProvider } from "../adapter/index.js";
+export interface E2BOptions {
+    apiKey: string;
+    /** Self-hosted E2B domain, if not the default cloud. */
+    domain?: string;
+}
+export declare const E2B_CAPS: {
+    readonly background: "native";
+    readonly codeInterpreter: "native";
+    readonly egressControl: "unsupported";
+    readonly exposePort: "native";
+    readonly filesUpload: "native";
+    readonly filesWatch: "native";
+    readonly fork: "unsupported";
+    readonly gpu: "unsupported";
+    readonly killProcess: "native";
+    readonly list: "native";
+    readonly metrics: "native";
+    readonly pause: "native";
+    readonly privatePreview: "unsupported";
+    readonly proxiedFetch: "unsupported";
+    readonly pty: "unsupported";
+    readonly region: "unsupported";
+    readonly secretsVault: "unsupported";
+    readonly setTimeout: "native";
+    readonly snapshot: "native";
+    readonly ssh: "unsupported";
+    readonly statefulKernel: "native";
+    readonly stdin: "unsupported";
+    readonly stop: "unsupported";
+    readonly streaming: "native";
+    readonly volumes: "unsupported";
+};
+export type E2BCaps = typeof E2B_CAPS;
+export declare const e2b: (opts: E2BOptions) => SandboxProvider<{
+    readonly background: "native";
+    readonly codeInterpreter: "native";
+    readonly egressControl: "unsupported";
+    readonly exposePort: "native";
+    readonly filesUpload: "native";
+    readonly filesWatch: "native";
+    readonly fork: "unsupported";
+    readonly gpu: "unsupported";
+    readonly killProcess: "native";
+    readonly list: "native";
+    readonly metrics: "native";
+    readonly pause: "native";
+    readonly privatePreview: "unsupported";
+    readonly proxiedFetch: "unsupported";
+    readonly pty: "unsupported";
+    readonly region: "unsupported";
+    readonly secretsVault: "unsupported";
+    readonly setTimeout: "native";
+    readonly snapshot: "native";
+    readonly ssh: "unsupported";
+    readonly statefulKernel: "native";
+    readonly stdin: "unsupported";
+    readonly stop: "unsupported";
+    readonly streaming: "native";
+    readonly volumes: "unsupported";
+}, E2BSandbox>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/e2b/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAenE,OAAO,KAAK,EAkBV,eAAe,EAIhB,MAAM,qBAAqB,CAAC;AAE7B,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,wDAAwD;IACxD,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Ba,CAAC;AAEnC,MAAM,MAAM,OAAO,GAAG,OAAO,QAAQ,CAAC;AAwHtC,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;cAiTd,CAAC"}