withruntime 0.17.2 → 0.21.0

package/dist/cloudflare/worker.d.ts

@@ -1,10 +1,22 @@
-/** Workers conditional entry. The Durable Object coordinates requests and stores
- * configuration; Runtime owns compute. Existing Container/Wrangler declarations
- * still need removal during infrastructure migration. */
-import { DurableObject } from "cloudflare:workers";
+/** Workers conditional entry: what a Worker imports as `withruntime/cloudflare`.
+ * `Sandbox` is the Durable Object class the Worker exports and binds, as with
+ * @cloudflare/sandbox; it keeps the sandbox's name and preview tokens, and
+ * Runtime runs the sandbox. The Wrangler config drops its `containers` block. */
+import { DurableObject, WorkerEntrypoint } from "cloudflare:workers";
 import type { DurableObjectState, DurableObjectNamespace, Request as WorkerRequest, Response as WorkerResponse } from "@cloudflare/workers-types/index.ts";
-import { Sandbox as RuntimeSandbox, type SandboxOptions, type SessionOptions, type ExecOptions, type ProcessOptions, type ReadFileResult, type ReadFileStreamResult } from "./index.js";
+import { type RefusedAsync } from "../compat/core.js";
+import { Sandbox as RuntimeSandbox, type CheckChangesOptions, type GitCheckoutOptions, type MountBucketOptions, type SandboxOptions, type SessionOptions, type ExecOptions, type ProcessOptions, type ReadFileResult, type ReadFileStreamResult, type StreamOptions, type WaitForPortOptions, type WatchOptions } from "./index.js";
+import type { CreateContextOptions, RunCodeOptions } from "./interpreter.js";
 export * from "./index.js";
+/** The bindings a Worker passes to proxyToSandbox, as Cloudflare names them. */
+export interface SandboxEnv<T extends Sandbox = Sandbox> {
+    Sandbox: DurableObjectNamespace<T>;
+}
+/** Cloudflare's egress entrypoint for outbound interception, which Runtime
+ * does with network rules and secrets instead. */
+export declare class ContainerProxy extends WorkerEntrypoint {
+    fetch(): Promise<WorkerResponse>;
+}
 export interface RuntimeWorkerEnv {
     RUNTIME_API_KEY: string;
     RUNTIME_API_URL?: string;
@@ -19,6 +31,14 @@ type Configuration = {
     keepAlive?: boolean;
 };
 export declare class Sandbox<Env extends RuntimeWorkerEnv = RuntimeWorkerEnv> extends DurableObject<Env> {
+    readonly callTunnels: RefusedAsync;
+    readonly setContainerTimeouts: RefusedAsync;
+    readonly setTransport: RefusedAsync;
+    readonly containerFetch: RefusedAsync;
+    readonly getContainerPlacementId: RefusedAsync;
+    readonly createBackup: RefusedAsync;
+    readonly restoreBackup: RefusedAsync;
+    readonly terminal: RefusedAsync;
     private configuration;
     private configurationIntent?;
     private facade?;
@@ -37,6 +57,7 @@ export declare class Sandbox<Env extends RuntimeWorkerEnv = RuntimeWorkerEnv> ex
     execStream(command: string, options?: ExecOptions): Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
     startProcess(command: string, options?: ProcessOptions): Promise<{
         id: string;
+        pid: undefined;
         command: string;
         status: string;
         startTime: Date;
@@ -54,12 +75,17 @@ export declare class Sandbox<Env extends RuntimeWorkerEnv = RuntimeWorkerEnv> ex
             exitCode: number;
         }>;
         waitForLog: (pattern: string | RegExp, timeout?: number) => Promise<{
-            match?: true | RegExpMatchArray | undefined;
             line: string;
+            match?: undefined;
+        } | {
+            line: string;
+            match: RegExpMatchArray;
         }>;
+        waitForPort: (port: number, options?: WaitForPortOptions) => Promise<void>;
     }>;
     listProcesses(): Promise<{
         id: string;
+        pid: undefined;
         command: string;
         status: string;
         startTime: Date;
@@ -77,12 +103,17 @@ export declare class Sandbox<Env extends RuntimeWorkerEnv = RuntimeWorkerEnv> ex
             exitCode: number;
         }>;
         waitForLog: (pattern: string | RegExp, timeout?: number) => Promise<{
-            match?: true | RegExpMatchArray | undefined;
             line: string;
+            match?: undefined;
+        } | {
+            line: string;
+            match: RegExpMatchArray;
         }>;
+        waitForPort: (port: number, options?: WaitForPortOptions) => Promise<void>;
     }[]>;
     getProcess(id: string): Promise<{
         id: string;
+        pid: undefined;
         command: string;
         status: string;
         startTime: Date;
@@ -100,9 +131,13 @@ export declare class Sandbox<Env extends RuntimeWorkerEnv = RuntimeWorkerEnv> ex
             exitCode: number;
         }>;
         waitForLog: (pattern: string | RegExp, timeout?: number) => Promise<{
-            match?: true | RegExpMatchArray | undefined;
             line: string;
+            match?: undefined;
+        } | {
+            line: string;
+            match: RegExpMatchArray;
         }>;
+        waitForPort: (port: number, options?: WaitForPortOptions) => Promise<void>;
     } | null>;
     getProcessLogs(id: string): Promise<{
         stdout: string;
@@ -117,6 +152,35 @@ export declare class Sandbox<Env extends RuntimeWorkerEnv = RuntimeWorkerEnv> ex
         execStream: (command: string, options?: ExecOptions) => Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
         startProcess: (command: string, options?: ProcessOptions) => Promise<{
             id: string;
+            pid: undefined;
+            command: string;
+            status: string;
+            startTime: Date;
+            endTime: Date | undefined;
+            exitCode: number | undefined;
+            sessionId: string | undefined;
+            kill: (signal?: string) => Promise<void>;
+            getStatus: () => Promise<"running" | "killed" | "unknown" | "failed" | "completed">;
+            getLogs: () => Promise<{
+                stdout: string;
+                stderr: string;
+                processId: string;
+            }>;
+            waitForExit: (timeout?: number) => Promise<{
+                exitCode: number;
+            }>;
+            waitForLog: (pattern: string | RegExp, timeout?: number) => Promise<{
+                line: string;
+                match?: undefined;
+            } | {
+                line: string;
+                match: RegExpMatchArray;
+            }>;
+            waitForPort: (port: number, options?: WaitForPortOptions) => Promise<void>;
+        }>;
+        listProcesses: () => Promise<{
+            id: string;
+            pid: undefined;
             command: string;
             status: string;
             startTime: Date;
@@ -134,10 +198,51 @@ export declare class Sandbox<Env extends RuntimeWorkerEnv = RuntimeWorkerEnv> ex
                 exitCode: number;
             }>;
             waitForLog: (pattern: string | RegExp, timeout?: number) => Promise<{
-                match?: true | RegExpMatchArray | undefined;
                 line: string;
+                match?: undefined;
+            } | {
+                line: string;
+                match: RegExpMatchArray;
             }>;
+            waitForPort: (port: number, options?: WaitForPortOptions) => Promise<void>;
+        }[]>;
+        getProcess: (id: string) => Promise<{
+            id: string;
+            pid: undefined;
+            command: string;
+            status: string;
+            startTime: Date;
+            endTime: Date | undefined;
+            exitCode: number | undefined;
+            sessionId: string | undefined;
+            kill: (signal?: string) => Promise<void>;
+            getStatus: () => Promise<"running" | "killed" | "unknown" | "failed" | "completed">;
+            getLogs: () => Promise<{
+                stdout: string;
+                stderr: string;
+                processId: string;
+            }>;
+            waitForExit: (timeout?: number) => Promise<{
+                exitCode: number;
+            }>;
+            waitForLog: (pattern: string | RegExp, timeout?: number) => Promise<{
+                line: string;
+                match?: undefined;
+            } | {
+                line: string;
+                match: RegExpMatchArray;
+            }>;
+            waitForPort: (port: number, options?: WaitForPortOptions) => Promise<void>;
+        } | null>;
+        killProcess: (id: string, signal?: string) => Promise<void>;
+        killAllProcesses: () => Promise<number>;
+        cleanupCompletedProcesses: () => Promise<number>;
+        getProcessLogs: (id: string) => Promise<{
+            stdout: string;
+            stderr: string;
+            processId: string;
         }>;
+        streamProcessLogs: (id: string) => Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
         writeFile: (path: string, content: string | ReadableStream<Uint8Array<ArrayBufferLike>>, options?: {
             encoding?: string;
         } | undefined) => Promise<{
@@ -154,6 +259,7 @@ export declare class Sandbox<Env extends RuntimeWorkerEnv = RuntimeWorkerEnv> ex
                 encoding?: "utf8" | "utf-8" | "base64";
             }): Promise<ReadFileResult>;
         };
+        readFileStream: (path: string) => Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
         mkdir: (path: string, options?: {
             recursive?: boolean;
         } | undefined) => Promise<{
@@ -213,7 +319,39 @@ export declare class Sandbox<Env extends RuntimeWorkerEnv = RuntimeWorkerEnv> ex
             count: number;
             timestamp: string;
         }>;
+        gitCheckout: (repoUrl: string, options?: Omit<GitCheckoutOptions, "sessionId">) => Promise<import("./index.js").GitCheckoutResult>;
+        watch: (path: string, options?: Omit<WatchOptions, "sessionId">) => Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
+        checkChanges: (path: string, options?: Omit<CheckChangesOptions, "sessionId">) => Promise<import("./index.js").CheckChangesResult>;
         setEnvVars: (env: Record<string, string | undefined>) => Promise<void>;
+        createCodeContext: (options?: CreateContextOptions) => Promise<import("./interpreter.js").CodeContext>;
+        runCode: (code: string, options?: RunCodeOptions) => Promise<{
+            code: string;
+            logs: {
+                stdout: string[];
+                stderr: string[];
+            };
+            error: import("./interpreter.js").ExecutionError | undefined;
+            executionCount: number | undefined;
+            results: {
+                text: string | undefined;
+                html: string | undefined;
+                png: string | undefined;
+                jpeg: string | undefined;
+                svg: string | undefined;
+                latex: string | undefined;
+                markdown: string | undefined;
+                javascript: string | undefined;
+                json: unknown;
+                chart: undefined;
+                data: Record<string, unknown> | undefined;
+            }[];
+        }>;
+        runCodeStream: (code: string, options?: RunCodeOptions) => Promise<ReadableStream<any>>;
+        listCodeContexts: () => Promise<import("./interpreter.js").CodeContext[]>;
+        deleteCodeContext: (id: string) => Promise<void>;
+        mountBucket: (bucket: string, path: string, options: MountBucketOptions) => Promise<void>;
+        unmountBucket: (path: string) => Promise<void>;
+        terminal: () => Promise<never>;
     }>;
     getSession(id: string): Promise<{
         id: string;
@@ -221,6 +359,63 @@ export declare class Sandbox<Env extends RuntimeWorkerEnv = RuntimeWorkerEnv> ex
         execStream: (command: string, options?: ExecOptions) => Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
         startProcess: (command: string, options?: ProcessOptions) => Promise<{
             id: string;
+            pid: undefined;
+            command: string;
+            status: string;
+            startTime: Date;
+            endTime: Date | undefined;
+            exitCode: number | undefined;
+            sessionId: string | undefined;
+            kill: (signal?: string) => Promise<void>;
+            getStatus: () => Promise<"running" | "killed" | "unknown" | "failed" | "completed">;
+            getLogs: () => Promise<{
+                stdout: string;
+                stderr: string;
+                processId: string;
+            }>;
+            waitForExit: (timeout?: number) => Promise<{
+                exitCode: number;
+            }>;
+            waitForLog: (pattern: string | RegExp, timeout?: number) => Promise<{
+                line: string;
+                match?: undefined;
+            } | {
+                line: string;
+                match: RegExpMatchArray;
+            }>;
+            waitForPort: (port: number, options?: WaitForPortOptions) => Promise<void>;
+        }>;
+        listProcesses: () => Promise<{
+            id: string;
+            pid: undefined;
+            command: string;
+            status: string;
+            startTime: Date;
+            endTime: Date | undefined;
+            exitCode: number | undefined;
+            sessionId: string | undefined;
+            kill: (signal?: string) => Promise<void>;
+            getStatus: () => Promise<"running" | "killed" | "unknown" | "failed" | "completed">;
+            getLogs: () => Promise<{
+                stdout: string;
+                stderr: string;
+                processId: string;
+            }>;
+            waitForExit: (timeout?: number) => Promise<{
+                exitCode: number;
+            }>;
+            waitForLog: (pattern: string | RegExp, timeout?: number) => Promise<{
+                line: string;
+                match?: undefined;
+            } | {
+                line: string;
+                match: RegExpMatchArray;
+            }>;
+            waitForPort: (port: number, options?: WaitForPortOptions) => Promise<void>;
+        }[]>;
+        getProcess: (id: string) => Promise<{
+            id: string;
+            pid: undefined;
             command: string;
             status: string;
             startTime: Date;
@@ -238,10 +433,23 @@ export declare class Sandbox<Env extends RuntimeWorkerEnv = RuntimeWorkerEnv> ex
                 exitCode: number;
             }>;
             waitForLog: (pattern: string | RegExp, timeout?: number) => Promise<{
-                match?: true | RegExpMatchArray | undefined;
                 line: string;
+                match?: undefined;
+            } | {
+                line: string;
+                match: RegExpMatchArray;
             }>;
+            waitForPort: (port: number, options?: WaitForPortOptions) => Promise<void>;
+        } | null>;
+        killProcess: (id: string, signal?: string) => Promise<void>;
+        killAllProcesses: () => Promise<number>;
+        cleanupCompletedProcesses: () => Promise<number>;
+        getProcessLogs: (id: string) => Promise<{
+            stdout: string;
+            stderr: string;
+            processId: string;
         }>;
+        streamProcessLogs: (id: string) => Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
         writeFile: (path: string, content: string | ReadableStream<Uint8Array<ArrayBufferLike>>, options?: {
             encoding?: string;
         } | undefined) => Promise<{
@@ -258,6 +466,7 @@ export declare class Sandbox<Env extends RuntimeWorkerEnv = RuntimeWorkerEnv> ex
                 encoding?: "utf8" | "utf-8" | "base64";
             }): Promise<ReadFileResult>;
         };
+        readFileStream: (path: string) => Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
         mkdir: (path: string, options?: {
             recursive?: boolean;
         } | undefined) => Promise<{
@@ -317,7 +526,39 @@ export declare class Sandbox<Env extends RuntimeWorkerEnv = RuntimeWorkerEnv> ex
             count: number;
             timestamp: string;
         }>;
+        gitCheckout: (repoUrl: string, options?: Omit<GitCheckoutOptions, "sessionId">) => Promise<import("./index.js").GitCheckoutResult>;
+        watch: (path: string, options?: Omit<WatchOptions, "sessionId">) => Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
+        checkChanges: (path: string, options?: Omit<CheckChangesOptions, "sessionId">) => Promise<import("./index.js").CheckChangesResult>;
         setEnvVars: (env: Record<string, string | undefined>) => Promise<void>;
+        createCodeContext: (options?: CreateContextOptions) => Promise<import("./interpreter.js").CodeContext>;
+        runCode: (code: string, options?: RunCodeOptions) => Promise<{
+            code: string;
+            logs: {
+                stdout: string[];
+                stderr: string[];
+            };
+            error: import("./interpreter.js").ExecutionError | undefined;
+            executionCount: number | undefined;
+            results: {
+                text: string | undefined;
+                html: string | undefined;
+                png: string | undefined;
+                jpeg: string | undefined;
+                svg: string | undefined;
+                latex: string | undefined;
+                markdown: string | undefined;
+                javascript: string | undefined;
+                json: unknown;
+                chart: undefined;
+                data: Record<string, unknown> | undefined;
+            }[];
+        }>;
+        runCodeStream: (code: string, options?: RunCodeOptions) => Promise<ReadableStream<any>>;
+        listCodeContexts: () => Promise<import("./interpreter.js").CodeContext[]>;
+        deleteCodeContext: (id: string) => Promise<void>;
+        mountBucket: (bucket: string, path: string, options: MountBucketOptions) => Promise<void>;
+        unmountBucket: (path: string) => Promise<void>;
+        terminal: () => Promise<never>;
     }>;
     deleteSession(id: string): Promise<{
         success: boolean;
@@ -391,6 +632,52 @@ export declare class Sandbox<Env extends RuntimeWorkerEnv = RuntimeWorkerEnv> ex
         timestamp: string;
     }>;
     setEnvVars(...args: Parameters<RuntimeSandbox["setEnvVars"]>): Promise<void>;
+    setLabels(labels: Record<string, string>): Promise<void>;
+    execWithSessionToken(command: string, sessionId: string, options?: ExecOptions): Promise<import("./index.js").ExecResult>;
+    execStreamWithSessionToken(command: string, sessionId: string, options?: StreamOptions): Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
+    streamProcessLogs(processId: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
+    cleanupCompletedProcesses(sessionId?: string): Promise<number>;
+    readFileStream(path: string, options?: {
+        sessionId?: string;
+    }): Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
+    gitCheckout(repoUrl: string, options?: GitCheckoutOptions): Promise<import("./index.js").GitCheckoutResult>;
+    watch(path: string, options?: WatchOptions): Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
+    checkChanges(path: string, options?: CheckChangesOptions): Promise<import("./index.js").CheckChangesResult>;
+    mountBucket(bucket: string, mountPath: string, options: MountBucketOptions): Promise<void>;
+    unmountBucket(mountPath: string): Promise<void>;
+    createCodeContext(options?: CreateContextOptions): Promise<import("./interpreter.js").CodeContext>;
+    runCode(code: string, options?: RunCodeOptions): Promise<{
+        code: string;
+        logs: {
+            stdout: string[];
+            stderr: string[];
+        };
+        error: import("./interpreter.js").ExecutionError | undefined;
+        executionCount: number | undefined;
+        results: {
+            text: string | undefined;
+            html: string | undefined;
+            png: string | undefined;
+            jpeg: string | undefined;
+            svg: string | undefined;
+            latex: string | undefined;
+            markdown: string | undefined;
+            javascript: string | undefined;
+            json: unknown;
+            chart: undefined;
+            data: Record<string, unknown> | undefined;
+        }[];
+    }>;
+    runCodeStream(code: string, options?: RunCodeOptions): Promise<ReadableStream<any>>;
+    listCodeContexts(): Promise<import("./interpreter.js").CodeContext[]>;
+    deleteCodeContext(contextId: string): Promise<void>;
+    /** Stops the sandbox; its files stay, and the next call starts it again. */
+    stop(signal?: unknown): Promise<void>;
+    /** A subclass's Cloudflare-only hooks and outbound settings would do
+     * nothing here, so the first call refuses them by name. */
+    private refuseSubclassSettings;
     exposePort(port: number, options: {
         name?: string;
         hostname: string;