withruntime 0.17.2 → 0.21.0

package/dist/cloudflare/index.js

@@ -3,14 +3,16 @@ import { Runtime } from "../client.js";
 import { NotFoundError } from "../errors.js";
 import { timeoutSignal } from "../transport.js";
 import { quote, client, closeShell, CompatibilityError, refuse, destroy, environment, execOptions, only, pathAt, saveEnvironment, shellCommand, shellRoot, } from "../compat/core.js";
-import { BucketUnmountError, InvalidMountConfigError, ProcessExitedBeforeReadyError, ProcessReadyTimeoutError, S3FSMountError, response, } from "./errors.js";
+import { BucketUnmountError, InvalidMountConfigError, ProcessExitedBeforeReadyError, ProcessReadyTimeoutError, S3FSMountError, ValidationFailedError, response, } from "./errors.js";
 import { CodeInterpreter, hasEnv, RUN_ENV, } from "./interpreter.js";
 import { sseStream } from "./streams.js";
+import { mimeType } from "./mime.js";
 import { CHANGES, watchFilters } from "./watch.js";
 export { CompatibilityError };
 export * from "./errors.js";
 export { CodeInterpreter } from "./interpreter.js";
-export { collectFile, isExecResult, isProcess, isProcessStatus, parseSSEStream, streamFile, } from "./streams.js";
+export { collectFile, isExecResult, isProcess, isProcessStatus, parseSSEStream, streamFile, asyncIterableToSSEStream, responseToAsyncIterable, } from "./streams.js";
+export * from "./types.js";
 export class SandboxSecurityError extends Error {
     code;
     constructor(message, code) {
@@ -262,7 +264,7 @@ export class Sandbox {
         return sseStream(async (send) => {
             send({
                 type: "metadata",
-                mimeType: isBinary ? "application/octet-stream" : "text/plain",
+                mimeType: read.mimeType,
                 size: bytes.length,
                 isBinary,
                 encoding: isBinary ? "base64" : "utf-8",
@@ -800,11 +802,18 @@ export class ExecutionSession {
         if (options.encoding && !["utf8", "utf-8", "base64"].includes(options.encoding))
             throw new CompatibilityError("Cloudflare", `file encoding ${options.encoding}`);
         let bytes;
-        if (typeof content === "string")
-            bytes =
-                options.encoding === "base64"
-                    ? Uint8Array.from(atob(content), (c) => c.charCodeAt(0))
-                    : new TextEncoder().encode(content);
+        if (typeof content === "string" && options.encoding === "base64") {
+            // Cloudflare's container refuses anything but base64's alphabet.
+            if (!/^[A-Za-z0-9+/=]*$/.test(content))
+                throw new ValidationFailedError(response("VALIDATION_FAILED", `Invalid base64 content for '${path}': must contain only A-Z, a-z, 0-9, +, /, =`, {
+                    validationErrors: [
+                        { field: "content", message: "Invalid base64 characters", code: "INVALID_BASE64" },
+                    ],
+                }, { httpStatus: 400 }));
+            bytes = Uint8Array.from(atob(content), (c) => c.charCodeAt(0));
+        }
+        else if (typeof content === "string")
+            bytes = new TextEncoder().encode(content);
         else {
             const buffer = await new Response(content).arrayBuffer();
             bytes = new Uint8Array(buffer);
@@ -813,7 +822,7 @@ export class ExecutionSession {
         return { success: true, path, bytesWritten: bytes.length, timestamp: new Date().toISOString() };
     }
     async readFile(path, options = {}) {
-        const s = await this.sandbox.native(), bytes = await s.files.read(await this.path(path));
+        const s = await this.sandbox.native(), resolved = await this.path(path), bytes = await s.files.read(resolved), type = mimeType(resolved, bytes);
         if (options.encoding === "none")
             return {
                 success: true,
@@ -825,7 +834,7 @@ export class ExecutionSession {
                     },
                 }),
                 size: bytes.length,
-                mimeType: "application/octet-stream",
+                mimeType: type,
                 timestamp: new Date().toISOString(),
             };
         const text = new TextDecoder().decode(bytes), binary = text.includes("\0") || text.includes("\ufffd"), encoded = options.encoding === "base64" || (options.encoding === undefined && binary);
@@ -839,6 +848,7 @@ export class ExecutionSession {
             content: encoded ? btoa(raw) : text,
             encoding: encoded ? "base64" : "utf-8",
             isBinary: binary,
+            mimeType: type,
             size: bytes.length,
             timestamp: new Date().toISOString(),
         };
@@ -888,7 +898,68 @@ export class ExecutionSession {
         this.options = { ...this.options, env: { ...this.options.env, ...cleanEnv(env) } };
         await (await this.sandbox.native()).files.write(`/workspace/.runtime-compat/cloudflare/${encodeURIComponent(this.id)}.json`, JSON.stringify(this.options), { mode: 0o600 });
     }
+    // The rest of Cloudflare's ExecutionSession: the sandbox's calls, in this session.
+    moveFile(path, newPath) {
+        return this.renameFile(path, newPath);
+    }
+    readFileStream(path) {
+        return this.sandbox.readFileStream(path, { sessionId: this.id });
+    }
+    gitCheckout(repoUrl, options = {}) {
+        return this.sandbox.gitCheckout(repoUrl, { ...options, sessionId: this.id });
+    }
+    watch(path, options = {}) {
+        return this.sandbox.watch(path, { ...options, sessionId: this.id });
+    }
+    checkChanges(path, options = {}) {
+        return this.sandbox.checkChanges(path, { ...options, sessionId: this.id });
+    }
+    listProcesses() {
+        return this.sandbox.listProcesses();
+    }
+    getProcess(id) {
+        return this.sandbox.getProcess(id);
+    }
+    killProcess(id, signal) {
+        return this.sandbox.killProcess(id, signal);
+    }
+    killAllProcesses() {
+        return this.sandbox.killAllProcesses();
+    }
+    cleanupCompletedProcesses() {
+        return this.sandbox.cleanupCompletedProcesses();
+    }
+    getProcessLogs(id) {
+        return this.sandbox.getProcessLogs(id);
+    }
+    streamProcessLogs(id, options) {
+        return this.sandbox.streamProcessLogs(id, options);
+    }
+    createCodeContext(options) {
+        return this.sandbox.createCodeContext(options);
+    }
+    runCode(code, options) {
+        return this.sandbox.runCode(code, options);
+    }
+    runCodeStream(code, options) {
+        return this.sandbox.runCodeStream(code, options);
+    }
+    listCodeContexts() {
+        return this.sandbox.listCodeContexts();
+    }
+    deleteCodeContext(contextId) {
+        return this.sandbox.deleteCodeContext(contextId);
+    }
+    mountBucket(bucket, mountPath, options) {
+        return this.sandbox.mountBucket(bucket, mountPath, options);
+    }
+    unmountBucket(mountPath) {
+        return this.sandbox.unmountBucket(mountPath);
+    }
 }
+refuse("Cloudflare", "ExecutionSession", ExecutionSession, {
+    terminal: "open a terminal with the native Runtime sandbox's terminal()",
+});
 export class Process {
     sandbox;
     native;
@@ -940,43 +1011,96 @@ export class Process {
         });
         return { exitCode: r.exitCode ?? -1 };
     }
-    async waitForLog(pattern, timeout = 30000) {
-        const condition = `log pattern ${String(pattern)}`;
-        const context = { processId: this.id, command: this.command, condition };
+    /** Cloudflare's errors for a wait, with its messages: a timeout, or the
+     * process ending first. */
+    #timedOut(condition, timeout) {
+        return new ProcessReadyTimeoutError(response("PROCESS_READY_TIMEOUT", `Process did not become ready within ${timeout}ms. Waiting for: ${condition}`, { processId: this.id, command: this.command, condition, timeout }, {
+            httpStatus: 408,
+            suggestion: `Check if your process outputs ${condition}. You can increase the timeout parameter.`,
+        }));
+    }
+    #exited(condition, exitCode) {
+        return new ProcessExitedBeforeReadyError(response("PROCESS_EXITED_BEFORE_READY", `Process exited with code ${exitCode} before becoming ready. Waiting for: ${condition}`, { processId: this.id, command: this.command, condition, exitCode }, { httpStatus: 500, suggestion: "Check process logs with getLogs() for error messages" }));
+    }
+    /** Waits as Cloudflare does: with no limit unless `timeout` is given. */
+    async #within(condition, timeout, wait) {
+        if (timeout === undefined)
+            return wait();
         const signal = timeoutSignal(timeout);
         try {
-            return await this.#waitForLog(pattern, signal);
+            return await wait(signal);
         }
         catch (error) {
             if (!signal.aborted)
                 throw error;
-            throw new ProcessReadyTimeoutError(response("PROCESS_READY_TIMEOUT", `Process did not become ready within ${timeout}ms`, { ...context, timeout }, { httpStatus: 408, operation: "process.start" }));
+            throw this.#timedOut(condition, timeout);
         }
     }
-    async #waitForLog(pattern, signal) {
-        let output = "";
+    async waitForLog(pattern, timeout) {
+        const condition = typeof pattern === "string" ? `"${pattern}"` : pattern.toString();
+        return this.#within(condition, timeout, (signal) => this.#waitForLog(pattern, condition, signal));
+    }
+    async #waitForLog(pattern, condition, signal) {
+        let stdout = "", stderr = "";
         for await (const e of this.native.output({ signal })) {
-            if (e.type === "stdout" || e.type === "stderr") {
-                output += e.data;
-                const match = typeof pattern === "string" ? output.includes(pattern) : output.match(pattern);
-                if (match)
-                    return {
-                        line: output
-                            .split("\n")
-                            .find((line) => typeof pattern === "string"
-                            ? line.includes(pattern)
-                            : new RegExp(pattern.source, pattern.flags.replace("g", "")).test(line)) ?? output,
-                        ...(typeof pattern === "string" ? {} : { match }),
-                    };
-            }
-            else if (e.type === "exit")
-                throw new ProcessExitedBeforeReadyError(response("PROCESS_EXITED_BEFORE_READY", "Process exited before expected output", {
-                    processId: this.id,
-                    command: this.command,
-                    condition: `log pattern ${String(pattern)}`,
-                    exitCode: e.exitCode ?? -1,
-                }, { httpStatus: 409, operation: "process.start" }));
+            if (e.type === "stdout")
+                stdout += e.data;
+            else if (e.type === "stderr")
+                stderr += e.data;
+            const found = matchLine(stdout, pattern) ?? matchLine(stderr, pattern);
+            if (found)
+                return found;
+            if (e.type === "exit")
+                throw this.#exited(condition, e.exitCode ?? 1);
         }
-        throw new Error("Process output ended before expected output");
+        throw this.#exited(condition, 0);
+    }
+    /** Resolves once the port answers: an HTTP status in range (200-399 by
+     * default) at `path`, or a TCP connection in `tcp` mode. Throws if the
+     * process ends first, or after `timeout` milliseconds when one is given. */
+    async waitForPort(port, options = {}) {
+        only("Cloudflare waitForPort", options, ["mode", "path", "status", "timeout", "interval"]);
+        const { mode = "http", path = "/", status = { min: 200, max: 399 }, interval = 500 } = options;
+        if (!Number.isInteger(port) || port < 1 || port > 65535)
+            throw new TypeError(`Invalid port number: ${port}`);
+        if (mode !== "http" && mode !== "tcp")
+            throw new TypeError("mode is http or tcp");
+        const condition = mode === "http" ? `port ${port} (HTTP ${path})` : `port ${port} (TCP)`;
+        const min = typeof status === "number" ? status : status.min;
+        const max = typeof status === "number" ? status : status.max;
+        const url = `http://127.0.0.1:${port}${path.startsWith("/") ? path : `/${path}`}`;
+        const probe = mode === "http"
+            ? `code=$(curl -s -o /dev/null -w '%{http_code}' --max-time 2 ${quote(url)}) && [ "$code" -ge ${min} ] && [ "$code" -le ${max} ]`
+            : `exec 3<>/dev/tcp/127.0.0.1/${port}`;
+        const s = await this.sandbox.native();
+        await this.#within(condition, options.timeout, async (signal) => {
+            for (;;) {
+                await this.native.refresh();
+                if (this.native.info.state !== "running")
+                    throw this.#exited(condition, this.native.info.exitCode ?? 1);
+                if ((await s.exec(["bash", "-c", probe], { signal })).exitCode === 0)
+                    return;
+                await new Promise((done) => setTimeout(done, interval));
+                signal?.throwIfAborted();
+            }
+        });
     }
 }
+/** The first line holding a match, as Cloudflare's waitForLog answers. */
+function matchLine(text, pattern) {
+    if (typeof pattern === "string") {
+        if (!text.includes(pattern))
+            return null;
+        return { line: text.split("\n").find((line) => line.includes(pattern)) ?? pattern };
+    }
+    const safe = new RegExp(pattern.source, pattern.flags.replace("g", ""));
+    const match = text.match(safe);
+    if (!match)
+        return null;
+    for (const line of text.split("\n")) {
+        const lineMatch = line.match(safe);
+        if (lineMatch)
+            return { line, match: lineMatch };
+    }
+    return { line: match[0], match };
+}

package/dist/cloudflare/interpreter.js

@@ -106,11 +106,20 @@ export class CodeInterpreter {
         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 } : {}));
+        try {
+            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 } : {}));
+        }
+        catch (error) {
+            // Cloudflare's container has no fixed count; Runtime's does. Say so,
+            // and what frees one, in the message: only it survives Worker RPC.
+            if (error.code !== "context_limit")
+                throw error;
+            throw new Error(`${error.message} Cloudflare's container has no fixed limit; delete a context you no longer need with deleteCodeContext(), and list them with listCodeContexts(). runCode without a context uses one per language.`, { cause: error });
+        }
     }
     async runCode(code, options = {}) {
         if (hasEnv(options.envVars))

package/dist/cloudflare/mime.d.ts

@@ -0,0 +1 @@
+export declare function mimeType(path: string, bytes: Uint8Array): string;

package/dist/cloudflare/mime.js

@@ -0,0 +1,66 @@
+/** A file's MIME type as Cloudflare's container reports it: from the
+ * extension first, then from the content (`file --mime-type` there; the
+ * common signatures and text here), else application/octet-stream. */
+const BY_EXTENSION = {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp",
+    svg: "image/svg+xml",
+    ico: "image/x-icon",
+    bmp: "image/bmp",
+    avif: "image/avif",
+    pdf: "application/pdf",
+    zip: "application/zip",
+    gz: "application/gzip",
+    tgz: "application/gzip",
+    tar: "application/x-tar",
+    wasm: "application/wasm",
+    json: "application/json",
+    xml: "application/xml",
+    js: "text/javascript",
+    mjs: "text/javascript",
+    cjs: "text/javascript",
+    css: "text/css",
+    html: "text/html",
+    htm: "text/html",
+    md: "text/markdown",
+    txt: "text/plain",
+    csv: "text/csv",
+    yaml: "text/yaml",
+    yml: "text/yaml",
+    py: "text/x-python",
+    sh: "application/x-sh",
+    mp3: "audio/mpeg",
+    wav: "audio/wav",
+    mp4: "video/mp4",
+    webm: "video/webm",
+    woff: "font/woff",
+    woff2: "font/woff2",
+    ttf: "font/ttf",
+};
+const SIGNATURES = [
+    [[0x89, 0x50, 0x4e, 0x47], "image/png"],
+    [[0xff, 0xd8, 0xff], "image/jpeg"],
+    [[0x47, 0x49, 0x46, 0x38], "image/gif"],
+    [[0x25, 0x50, 0x44, 0x46], "application/pdf"],
+    [[0x50, 0x4b, 0x03, 0x04], "application/zip"],
+    [[0x1f, 0x8b], "application/gzip"],
+    [[0x00, 0x61, 0x73, 0x6d], "application/wasm"],
+    [[0x7f, 0x45, 0x4c, 0x46], "application/x-executable"],
+];
+export function mimeType(path, bytes) {
+    const name = path.split("/").pop() ?? "";
+    const dot = name.lastIndexOf(".");
+    const known = dot > 0 ? BY_EXTENSION[name.slice(dot + 1).toLowerCase()] : undefined;
+    if (known)
+        return known;
+    for (const [signature, type] of SIGNATURES)
+        if (signature.every((byte, i) => bytes[i] === byte))
+            return type;
+    if (bytes.length === 0)
+        return "inode/x-empty";
+    const text = new TextDecoder().decode(bytes.subarray(0, 8192));
+    return text.includes("\0") || text.includes("�") ? "application/octet-stream" : "text/plain";
+}

package/dist/cloudflare/streams.d.ts

@@ -25,6 +25,14 @@ export declare function sseStream<T>(events: (send: (event: T) => void, signal:
 /** 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>;
+/** The events of a server-sent-events Response, as parseSSEStream reads them. */
+export declare function responseToAsyncIterable<T>(response: Response, signal?: AbortSignal): AsyncIterable<T>;
+/** Events as a server-sent-events stream, one `data:` line each, then
+ * `data: [DONE]`, as Cloudflare's helper writes them. */
+export declare function asyncIterableToSSEStream<T>(events: AsyncIterable<T>, options?: {
+    signal?: AbortSignal;
+    serialize?: (event: T) => string;
+}): ReadableStream<Uint8Array>;
 /** 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>;

package/dist/cloudflare/streams.js

@@ -77,6 +77,36 @@ export async function* parseSSEStream(stream, signal) {
         reader.releaseLock();
     }
 }
+/** The events of a server-sent-events Response, as parseSSEStream reads them. */
+export async function* responseToAsyncIterable(response, signal) {
+    if (!response.ok)
+        throw new Error(`Response not ok: ${response.status} ${response.statusText}`);
+    if (!response.body)
+        throw new Error("No response body");
+    yield* parseSSEStream(response.body, signal);
+}
+/** Events as a server-sent-events stream, one `data:` line each, then
+ * `data: [DONE]`, as Cloudflare's helper writes them. */
+export function asyncIterableToSSEStream(events, options = {}) {
+    const encoder = new TextEncoder();
+    const serialize = options.serialize ?? ((event) => JSON.stringify(event));
+    return new ReadableStream({
+        async start(controller) {
+            try {
+                for await (const event of events) {
+                    if (options.signal?.aborted)
+                        throw new Error("Operation was aborted");
+                    controller.enqueue(encoder.encode(`data: ${serialize(event)}\n\n`));
+                }
+                controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+                controller.close();
+            }
+            catch (error) {
+                controller.error(error);
+            }
+        },
+    });
+}
 /** A `readFileStream()` stream's chunks: strings for text, bytes for binary.
  * Returns the file's metadata. */
 export async function* streamFile(stream) {