withruntime 0.11.2 → 0.14.0

package/dist/cloudflare/interpreter.js

@@ -0,0 +1,223 @@
+import { CompatibilityError, only } from "../compat/core.js";
+import { sseStream } from "./streams.js";
+const FORMATS = {
+    text: "text/plain",
+    html: "text/html",
+    png: "image/png",
+    jpeg: "image/jpeg",
+    svg: "image/svg+xml",
+    latex: "text/latex",
+    markdown: "text/markdown",
+    javascript: "application/javascript",
+    json: "application/json",
+};
+/** One rich result, as Cloudflare's: each format by name, the MIME bundle in
+ * `data`. `chart` is never set on Runtime. */
+export class Result {
+    text;
+    html;
+    png;
+    jpeg;
+    svg;
+    latex;
+    markdown;
+    javascript;
+    json;
+    chart;
+    data;
+    constructor(data) {
+        for (const [field, mime] of Object.entries(FORMATS))
+            if (data[mime] !== undefined)
+                this[field] = data[mime];
+        this.data = data;
+    }
+    formats() {
+        return Object.keys(FORMATS).filter((field) => this[field]);
+    }
+}
+export class Execution {
+    code;
+    context;
+    results = [];
+    logs = { stdout: [], stderr: [] };
+    error;
+    executionCount;
+    constructor(code, context) {
+        this.code = code;
+        this.context = context;
+    }
+    toJSON() {
+        return {
+            code: this.code,
+            logs: this.logs,
+            error: this.error,
+            executionCount: this.executionCount,
+            results: this.results.map((r) => ({
+                text: r.text,
+                html: r.html,
+                png: r.png,
+                jpeg: r.jpeg,
+                svg: r.svg,
+                latex: r.latex,
+                markdown: r.markdown,
+                javascript: r.javascript,
+                json: r.json,
+                chart: r.chart,
+                data: r.data,
+            })),
+        };
+    }
+}
+const context = (c) => ({
+    id: c.id,
+    language: c.language,
+    cwd: c.cwd,
+    createdAt: new Date(c.startedAt),
+    lastUsed: new Date(c.startedAt),
+});
+const failure = (e) => ({
+    name: e.name,
+    message: e.value,
+    traceback: e.traceback ? e.traceback.split("\n") : [],
+});
+/** A run that ended without the code's own error still tells the caller why. */
+const ended = (run) => run.status === "timeout"
+    ? { name: "TimeoutError", message: "Execution timed out", traceback: [] }
+    : run.status === "interrupted" || run.status === "lost"
+        ? { name: "InterruptedError", message: `Execution ${run.status}`, traceback: [] }
+        : undefined;
+const TEXT_MIME = /^text\/|json|javascript|svg|latex/;
+export const RUN_ENV = "envVars on a run; set them when making the context with createCodeContext({ envVars })";
+export const hasEnv = (env) => Object.values(env ?? {}).some((v) => v !== undefined);
+function base64(bytes) {
+    let raw = "";
+    for (let i = 0; i < bytes.length; i += 32768)
+        raw += String.fromCharCode(...bytes.subarray(i, i + 32768));
+    return btoa(raw);
+}
+/** Cloudflare's code interpreter on Runtime's: Python, JavaScript and
+ * TypeScript contexts whose variables persist between runs. */
+export class CodeInterpreter {
+    #native;
+    constructor(sandbox) {
+        this.#native = typeof sandbox === "function" ? sandbox : () => sandbox.native();
+    }
+    async createCodeContext(options = {}) {
+        only("Cloudflare createCodeContext", options, ["language", "cwd", "envVars", "timeout"]);
+        const language = this.#language(options.language);
+        const s = await this.#native();
+        return context(await s.interpreter.contexts.create({
+            language,
+            cwd: options.cwd ?? "/workspace",
+            env: Object.fromEntries(Object.entries(options.envVars ?? {}).filter((e) => e[1] !== undefined)),
+        }, options.timeout !== undefined ? { timeoutMs: options.timeout } : {}));
+    }
+    async runCode(code, options = {}) {
+        if (hasEnv(options.envVars))
+            throw new CompatibilityError("Cloudflare", RUN_ENV);
+        const { s, target } = await this.#prepare(options);
+        const execution = new Execution(code, target);
+        const run = await s.interpreter.run(code, {
+            context: target.id,
+            ...(options.timeout !== undefined ? { timeoutMs: options.timeout } : {}),
+            ...(options.signal ? { signal: options.signal } : {}),
+            onStdout: (text) => {
+                execution.logs.stdout.push(text);
+                return options.onStdout?.({ text, timestamp: Date.now() });
+            },
+            onStderr: (text) => {
+                execution.logs.stderr.push(text);
+                return options.onStderr?.({ text, timestamp: Date.now() });
+            },
+            onResult: async (raw) => {
+                const result = new Result(await this.#inline(s, raw));
+                execution.results.push(result);
+                return options.onResult?.(result);
+            },
+            onError: (raw) => {
+                execution.error = failure(raw);
+                return options.onError?.(execution.error);
+            },
+        });
+        execution.executionCount = run.executionCount ?? undefined;
+        if (!execution.error && ended(run)) {
+            execution.error = ended(run);
+            await options.onError?.(execution.error);
+        }
+        return execution;
+    }
+    /** The run as Cloudflare's container streams it: `data:` lines of stdout,
+     * stderr, result, error and execution_complete events. */
+    async runCodeStream(code, options = {}) {
+        if (hasEnv(options.envVars))
+            throw new CompatibilityError("Cloudflare", RUN_ENV);
+        const { s, target } = await this.#prepare(options);
+        return sseStream(async (send, cancelled) => {
+            const signal = options.signal ? AbortSignal.any([options.signal, cancelled]) : cancelled;
+            const run = await s.interpreter.run(code, {
+                context: target.id,
+                signal,
+                ...(options.timeout !== undefined ? { timeoutMs: options.timeout } : {}),
+                onStdout: (text) => send({ type: "stdout", text, timestamp: Date.now() }),
+                onStderr: (text) => send({ type: "stderr", text, timestamp: Date.now() }),
+                onResult: async (raw) => {
+                    const { data: _data, ...fields } = new Result(await this.#inline(s, raw));
+                    send({ type: "result", ...fields, data: raw.data, timestamp: Date.now() });
+                },
+                onError: (e) => send({ type: "error", ename: e.name, evalue: e.value, traceback: failure(e).traceback }),
+            });
+            const stop = ended(run);
+            if (run.error === null && stop)
+                send({ type: "error", ename: stop.name, evalue: stop.message, traceback: [] });
+            send({ type: "execution_complete", execution_count: run.executionCount });
+        });
+    }
+    async listCodeContexts() {
+        return (await (await this.#native()).interpreter.contexts.list()).map(context);
+    }
+    async deleteCodeContext(contextId) {
+        await (await this.#native()).interpreter.contexts.remove(contextId);
+    }
+    #language(language) {
+        if (language === undefined)
+            return "python";
+        if (!["python", "javascript", "typescript"].includes(language))
+            throw new Error(`Unsupported language: ${language}. Supported languages: python, javascript, typescript`);
+        return language;
+    }
+    async #prepare(options) {
+        only("Cloudflare runCode", options, [
+            "context",
+            "language",
+            "envVars",
+            "timeout",
+            "signal",
+            "onStdout",
+            "onStderr",
+            "onResult",
+            "onError",
+        ]);
+        const s = await this.#native();
+        // Each language's own name is Runtime's default context for it, started on first use.
+        const language = this.#language(options.context?.language ?? options.language);
+        const target = options.context ?? {
+            id: language,
+            language,
+            cwd: "/workspace",
+            createdAt: new Date(),
+            lastUsed: new Date(),
+        };
+        return { s, target };
+    }
+    /** Large results travel by reference; Cloudflare's arrive inline. */
+    async #inline(s, raw) {
+        const data = { ...raw.data };
+        for (const [mime, ref] of Object.entries(raw.refs ?? {})) {
+            if (data[mime] !== undefined)
+                continue;
+            const bytes = await s.interpreter.result(ref);
+            data[mime] = TEXT_MIME.test(mime) ? new TextDecoder().decode(bytes) : base64(bytes);
+        }
+        return data;
+    }
+}

package/dist/cloudflare/streams.d.ts

@@ -0,0 +1,38 @@
+/** Cloudflare's stream helpers and type guards: the adapter's streams are
+ * server-sent events in Cloudflare's own shapes, so these read them as
+ * Cloudflare's do. */
+export type FileMetadata = {
+    mimeType: string;
+    size: number;
+    isBinary: boolean;
+    encoding: "utf-8" | "base64";
+};
+export type FileChunk = string | Uint8Array;
+export type FileStreamEvent = ({
+    type: "metadata";
+} & FileMetadata) | {
+    type: "chunk";
+    data: string;
+} | {
+    type: "complete";
+    bytesRead: number;
+} | {
+    type: "error";
+    error: string;
+};
+/** One `data:` line per event, as Cloudflare's container sends them. */
+export declare function sseStream<T>(events: (send: (event: T) => void, signal: AbortSignal) => Promise<void>): ReadableStream<Uint8Array>;
+/** The events of a server-sent-events stream, each `data:` parsed as JSON;
+ * `[DONE]`, blank and unparsable data are skipped, as Cloudflare's do. */
+export declare function parseSSEStream<T>(stream: ReadableStream<Uint8Array>, signal?: AbortSignal): AsyncIterable<T>;
+/** A `readFileStream()` stream's chunks: strings for text, bytes for binary.
+ * Returns the file's metadata. */
+export declare function streamFile(stream: ReadableStream<Uint8Array>): AsyncGenerator<FileChunk, FileMetadata>;
+/** A whole `readFileStream()` file in memory, with its metadata. */
+export declare function collectFile(stream: ReadableStream<Uint8Array>): Promise<{
+    content: string | Uint8Array;
+    metadata: FileMetadata;
+}>;
+export declare function isExecResult(value: unknown): boolean;
+export declare function isProcess(value: unknown): boolean;
+export declare function isProcessStatus(value: string): boolean;

package/dist/cloudflare/streams.js

@@ -0,0 +1,145 @@
+/** Cloudflare's stream helpers and type guards: the adapter's streams are
+ * server-sent events in Cloudflare's own shapes, so these read them as
+ * Cloudflare's do. */
+/** One `data:` line per event, as Cloudflare's container sends them. */
+export function sseStream(events) {
+    const encode = new TextEncoder();
+    const cancelled = new AbortController();
+    return new ReadableStream({
+        async start(controller) {
+            try {
+                await events((event) => {
+                    if (!cancelled.signal.aborted)
+                        controller.enqueue(encode.encode(`data: ${JSON.stringify(event)}\n\n`));
+                }, cancelled.signal);
+                if (!cancelled.signal.aborted)
+                    controller.close();
+            }
+            catch (error) {
+                if (!cancelled.signal.aborted)
+                    controller.error(error);
+            }
+        },
+        cancel(reason) {
+            cancelled.abort(reason);
+        },
+    });
+}
+/** The events of a server-sent-events stream, each `data:` parsed as JSON;
+ * `[DONE]`, blank and unparsable data are skipped, as Cloudflare's do. */
+export async function* parseSSEStream(stream, signal) {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let data = [];
+    const aborted = () => {
+        if (signal?.aborted)
+            throw new Error("Operation was aborted");
+    };
+    const onAbort = () => void reader.cancel().catch(() => undefined);
+    signal?.addEventListener("abort", onAbort);
+    const parse = function* (final) {
+        const lines = buffer.split(/\r?\n/);
+        buffer = final ? "" : lines.pop();
+        for (const line of lines) {
+            if (line === "") {
+                const text = data.join("\n");
+                data = [];
+                if (text.trim() === "" || text === "[DONE]")
+                    continue;
+                try {
+                    yield JSON.parse(text);
+                }
+                catch {
+                    // Cloudflare skips data that is not JSON.
+                }
+            }
+            else if (line.startsWith("data:"))
+                data.push(line.slice(line[5] === " " ? 6 : 5));
+        }
+    };
+    try {
+        for (;;) {
+            aborted();
+            const { done, value } = await reader.read();
+            aborted();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            yield* parse(false);
+        }
+        buffer += "\n\n";
+        yield* parse(true);
+    }
+    finally {
+        signal?.removeEventListener("abort", onAbort);
+        await reader.cancel().catch(() => undefined);
+        reader.releaseLock();
+    }
+}
+/** A `readFileStream()` stream's chunks: strings for text, bytes for binary.
+ * Returns the file's metadata. */
+export async function* streamFile(stream) {
+    let metadata = null;
+    for await (const event of parseSSEStream(stream))
+        switch (event.type) {
+            case "metadata":
+                metadata = {
+                    mimeType: event.mimeType,
+                    size: event.size,
+                    isBinary: event.isBinary,
+                    encoding: event.encoding,
+                };
+                break;
+            case "chunk":
+                if (!metadata)
+                    throw new Error("Received chunk before metadata");
+                yield metadata.isBinary && metadata.encoding === "base64"
+                    ? Uint8Array.from(atob(event.data), (c) => c.charCodeAt(0))
+                    : event.data;
+                break;
+            case "complete":
+                if (!metadata)
+                    throw new Error("Stream completed without metadata");
+                return metadata;
+            case "error":
+                throw new Error(`File streaming error: ${event.error}`);
+        }
+    throw new Error("Stream ended unexpectedly");
+}
+/** A whole `readFileStream()` file in memory, with its metadata. */
+export async function collectFile(stream) {
+    const chunks = [];
+    const reading = streamFile(stream);
+    let next = await reading.next();
+    while (!next.done) {
+        chunks.push(next.value);
+        next = await reading.next();
+    }
+    const metadata = next.value;
+    if (!metadata.isBinary)
+        return { content: chunks.filter((c) => typeof c === "string").join(""), metadata };
+    const bytes = chunks.filter((c) => c instanceof Uint8Array);
+    const content = new Uint8Array(bytes.reduce((sum, c) => sum + c.length, 0));
+    let offset = 0;
+    for (const chunk of bytes) {
+        content.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return { content, metadata };
+}
+export function isExecResult(value) {
+    const v = value;
+    return (!!v &&
+        typeof v.success === "boolean" &&
+        typeof v.exitCode === "number" &&
+        typeof v.stdout === "string" &&
+        typeof v.stderr === "string");
+}
+export function isProcess(value) {
+    const v = value;
+    return (!!v && typeof v.id === "string" && typeof v.command === "string" && typeof v.status === "string");
+}
+export function isProcessStatus(value) {
+    return ["starting", "running", "completed", "failed", "killed", "error"].includes(value);
+}

package/dist/cloudflare/watch.d.ts

@@ -0,0 +1,9 @@
+import type { WatchOptions } from "./index.js";
+/** Cloudflare's watch filters: include or exclude, never both; by default
+ * .git, node_modules and .DS_Store are left out. */
+export declare function watchFilters(options: WatchOptions): {
+    include?: string[];
+    exclude?: string[];
+};
+/** argv: path, recursive, include JSON, exclude JSON. Prints boot.digest. */
+export declare const CHANGES = "import fnmatch,hashlib,json,os,sys\nroot,recursive,inc,exc=sys.argv[1],sys.argv[2]==\"1\",json.loads(sys.argv[3]),json.loads(sys.argv[4])\ndef hit(rel,pats): return any(fnmatch.fnmatch(rel,p) or fnmatch.fnmatch(os.path.basename(rel),p) or any(fnmatch.fnmatch(x,p) for x in rel.split(\"/\")) for p in pats)\nh=hashlib.sha256()\nfor d,dirs,files in os.walk(root):\n  rel=os.path.relpath(d,root)\n  dirs[:]=sorted(x for x in dirs if recursive and not hit(os.path.normpath(os.path.join(rel,x)),exc))\n  for n in sorted(dirs+files):\n    r=os.path.normpath(os.path.join(rel,n))\n    if hit(r,exc) or (inc and n in files and not hit(r,inc)): continue\n    try: st=os.lstat(os.path.join(d,n))\n    except FileNotFoundError: continue\n    h.update(f\"{r}\\0{st.st_size}\\0{st.st_mtime_ns}\\0{st.st_mode}\\n\".encode())\nprint(open(\"/proc/sys/kernel/random/boot_id\").read().strip().replace(\"-\",\"\")+\".\"+h.hexdigest())";

package/dist/cloudflare/watch.js

@@ -0,0 +1,24 @@
+/** Cloudflare's watch filters: include or exclude, never both; by default
+ * .git, node_modules and .DS_Store are left out. */
+export function watchFilters(options) {
+    if (options.include?.length && options.exclude?.length)
+        throw new Error("include and exclude cannot be used together");
+    if (options.include?.length)
+        return { include: options.include };
+    return { exclude: options.exclude ?? [".git", "node_modules", ".DS_Store"] };
+}
+/** argv: path, recursive, include JSON, exclude JSON. Prints boot.digest. */
+export const CHANGES = `import fnmatch,hashlib,json,os,sys
+root,recursive,inc,exc=sys.argv[1],sys.argv[2]=="1",json.loads(sys.argv[3]),json.loads(sys.argv[4])
+def hit(rel,pats): return any(fnmatch.fnmatch(rel,p) or fnmatch.fnmatch(os.path.basename(rel),p) or any(fnmatch.fnmatch(x,p) for x in rel.split("/")) for p in pats)
+h=hashlib.sha256()
+for d,dirs,files in os.walk(root):
+  rel=os.path.relpath(d,root)
+  dirs[:]=sorted(x for x in dirs if recursive and not hit(os.path.normpath(os.path.join(rel,x)),exc))
+  for n in sorted(dirs+files):
+    r=os.path.normpath(os.path.join(rel,n))
+    if hit(r,exc) or (inc and n in files and not hit(r,inc)): continue
+    try: st=os.lstat(os.path.join(d,n))
+    except FileNotFoundError: continue
+    h.update(f"{r}\\0{st.st_size}\\0{st.st_mtime_ns}\\0{st.st_mode}\\n".encode())
+print(open("/proc/sys/kernel/random/boot_id").read().strip().replace("-","")+"."+h.hexdigest())`;