withruntime 0.17.2 → 0.21.0

package/dist/cloudflare/worker.js

@@ -1,12 +1,47 @@
-/** 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";
-import { only, CompatibilityError } from "../compat/core.js";
+/** 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 { only, refusal, CompatibilityError } from "../compat/core.js";
 import { Runtime } from "../client.js";
 import { workerSandboxIdentity } from "./identity.js";
-import { Sandbox as RuntimeSandbox, sanitizeSandboxId, validateSandboxConfiguration, } from "./index.js";
+import { Sandbox as RuntimeSandbox, SandboxSecurityError, sanitizeSandboxId, validateSandboxConfiguration, } from "./index.js";
 export * from "./index.js";
+/** Cloudflare's egress entrypoint for outbound interception, which Runtime
+ * does with network rules and secrets instead. */
+export class ContainerProxy extends WorkerEntrypoint {
+    fetch() {
+        return Promise.reject(refusal("Cloudflare", "ContainerProxy", OUTBOUND));
+    }
+}
+const OUTBOUND = "set the sandbox's network rules with Runtime's network API, and store keys as Runtime secrets, which Runtime's proxy adds to the requests you name";
+const TERMINAL = "open a terminal with the native Runtime sandbox's terminal()";
+/** Members of Cloudflare's Durable Object a Runtime sandbox has no counterpart
+ * for, refused with what to use instead. */
+const REFUSED = {
+    callTunnels: "use exposePort for a public URL",
+    setContainerTimeouts: "a Runtime sandbox has no container start to tune",
+    setTransport: "Runtime's API is the only transport",
+    containerFetch: "fetch the URL exposePort returns",
+    getContainerPlacementId: "a Runtime sandbox's id is its place",
+    createBackup: "snapshot the sandbox with Runtime's snapshots, or keep the folder on a volume",
+    restoreBackup: "create a sandbox from a Runtime snapshot",
+    terminal: TERMINAL,
+};
+/** Hooks and outbound settings a subclass of Cloudflare's class may set,
+ * which would otherwise be silently ignored. */
+const SUBCLASS = {
+    onStart: "a Runtime sandbox has no Durable Object lifecycle hooks",
+    onStop: "a Runtime sandbox has no Durable Object lifecycle hooks",
+    onError: "a Runtime sandbox has no Durable Object lifecycle hooks",
+    onActivityExpired: "set sleepAfter or keepAlive instead",
+    interceptHttps: OUTBOUND,
+    enableInternet: OUTBOUND,
+    allowedHosts: OUTBOUND,
+    deniedHosts: OUTBOUND,
+};
+const STATIC_OUTBOUND = ["outboundByHost", "outbound", "outboundHandlers"];
 const CONFIGURATION_KEY = "runtime.configuration";
 const CONFIGURATION_INTENT_KEY = "runtime.configuration.pending";
 /** Preserve the original failure even when durable recovery also fails. */
@@ -58,20 +93,46 @@ function sessionTarget(session) {
         exec: (command, options) => session.exec(command, options),
         execStream: (command, options) => session.execStream(command, options),
         startProcess: async (command, options) => processTarget(await session.startProcess(command, options)),
+        listProcesses: async () => (await session.listProcesses()).map((p) => processTarget(p)),
+        getProcess: async (id) => {
+            const p = await session.getProcess(id);
+            return p ? processTarget(p) : null;
+        },
+        killProcess: (id, signal) => session.killProcess(id, signal),
+        killAllProcesses: () => session.killAllProcesses(),
+        cleanupCompletedProcesses: () => session.cleanupCompletedProcesses(),
+        getProcessLogs: (id) => session.getProcessLogs(id),
+        streamProcessLogs: (id) => session.streamProcessLogs(id),
         writeFile: (...args) => session.writeFile(...args),
         readFile,
+        readFileStream: (path) => session.readFileStream(path),
         mkdir: (...args) => session.mkdir(...args),
         deleteFile: (path) => session.deleteFile(path),
         renameFile: (path, to) => session.renameFile(path, to),
         moveFile: (path, to) => session.renameFile(path, to),
         exists: (path) => session.exists(path),
         listFiles: (...args) => session.listFiles(...args),
+        gitCheckout: (repoUrl, options) => session.gitCheckout(repoUrl, options),
+        watch: (path, options) => session.watch(path, options),
+        checkChanges: (path, options) => session.checkChanges(path, options),
         setEnvVars: (...args) => session.setEnvVars(...args),
+        createCodeContext: (options) => session.createCodeContext(options),
+        runCode: (code, options) => session.runCode(code, options),
+        runCodeStream: (code, options) => session.runCodeStream(code, options),
+        listCodeContexts: () => session.listCodeContexts(),
+        deleteCodeContext: (id) => session.deleteCodeContext(id),
+        mountBucket: (bucket, path, options) => session.mountBucket(bucket, path, options),
+        unmountBucket: (path) => session.unmountBucket(path),
+        terminal: () => Promise.reject(refusal("Cloudflare", "ExecutionSession.terminal", TERMINAL)),
     };
 }
+/** A Process as plain data and callable members, as Cloudflare's RPC returns
+ * one. `pid` is absent: Runtime does not report it (Cloudflare's type has it
+ * optional). */
 function processTarget(process) {
     return {
         id: process.id,
+        pid: undefined,
         command: process.command,
         status: process.status,
         startTime: process.startTime,
@@ -83,6 +144,7 @@ function processTarget(process) {
         getLogs: () => process.getLogs(),
         waitForExit: (timeout) => process.waitForExit(timeout),
         waitForLog: (pattern, timeout) => process.waitForLog(pattern, timeout),
+        waitForPort: (port, options) => process.waitForPort(port, options),
     };
 }
 export class Sandbox extends DurableObject {
@@ -126,6 +188,7 @@ export class Sandbox extends DurableObject {
             throw new Error("Call getSandbox(namespace, id) before using the Durable Object");
         if (!this.env.RUNTIME_API_KEY?.startsWith("rtcloud_"))
             throw new Error("Set the RUNTIME_API_KEY Worker secret to a Runtime API key");
+        this.refuseSubclassSettings();
         this.facade ??= new RuntimeSandbox(new Runtime({ apiKey: this.env.RUNTIME_API_KEY, baseUrl: this.env.RUNTIME_API_URL }), workerSandboxIdentity(this.ctx.id.toString(), this.configuration), { ...this.configuration });
         return this.facade;
     }
@@ -308,34 +371,99 @@ export class Sandbox extends DurableObject {
     async setEnvVars(...args) {
         return (await this.sandbox()).setEnvVars(...args);
     }
+    // The rest of Cloudflare's 0.x Sandbox, each a call on the Runtime sandbox.
+    async setLabels(labels) {
+        return (await this.sandbox()).setLabels(labels);
+    }
+    async execWithSessionToken(command, sessionId, options) {
+        return (await this.sandbox(options?.signal)).execWithSessionToken(command, sessionId, options);
+    }
+    async execStreamWithSessionToken(command, sessionId, options) {
+        return (await this.sandbox(options?.signal)).execStreamWithSessionToken(command, sessionId, options);
+    }
+    async streamProcessLogs(processId, options) {
+        return (await this.sandbox(options?.signal)).streamProcessLogs(processId, options);
+    }
+    async cleanupCompletedProcesses(sessionId) {
+        return (await this.sandbox()).cleanupCompletedProcesses(sessionId);
+    }
+    async readFileStream(path, options) {
+        return (await this.sandbox()).readFileStream(path, options);
+    }
+    async gitCheckout(repoUrl, options) {
+        return (await this.sandbox()).gitCheckout(repoUrl, options);
+    }
+    async watch(path, options) {
+        return (await this.sandbox()).watch(path, options);
+    }
+    async checkChanges(path, options) {
+        return (await this.sandbox()).checkChanges(path, options);
+    }
+    async mountBucket(bucket, mountPath, options) {
+        return (await this.sandbox()).mountBucket(bucket, mountPath, options);
+    }
+    async unmountBucket(mountPath) {
+        return (await this.sandbox()).unmountBucket(mountPath);
+    }
+    async createCodeContext(options) {
+        return (await this.sandbox()).createCodeContext(options);
+    }
+    async runCode(code, options) {
+        return (await this.sandbox(options?.signal)).runCode(code, options);
+    }
+    async runCodeStream(code, options) {
+        return (await this.sandbox(options?.signal)).runCodeStream(code, options);
+    }
+    async listCodeContexts() {
+        return (await this.sandbox()).listCodeContexts();
+    }
+    async deleteCodeContext(contextId) {
+        return (await this.sandbox()).deleteCodeContext(contextId);
+    }
+    /** Stops the sandbox; its files stay, and the next call starts it again. */
+    async stop(signal) {
+        return (await this.sandbox()).stop(signal);
+    }
+    /** A subclass's Cloudflare-only hooks and outbound settings would do
+     * nothing here, so the first call refuses them by name. */
+    refuseSubclassSettings() {
+        for (const [member, alternative] of Object.entries(SUBCLASS))
+            if (this[member] !== undefined)
+                throw refusal("Cloudflare", `Sandbox.${member}`, alternative);
+        const statics = this.constructor;
+        for (const member of STATIC_OUTBOUND)
+            if (statics[member] !== undefined)
+                throw refusal("Cloudflare", `Sandbox.${member}`, OUTBOUND);
+    }
     exposePort(port, options) {
         return this.previewOperation(() => this.expose(port, options));
     }
     async expose(port, options) {
         only("Cloudflare Worker exposePort", options, ["name", "hostname", "token"]);
         if (!Number.isInteger(port) || port < 1024 || port > 65535 || port === 3000)
-            throw new TypeError("Preview port must be 1024-65535, excluding 3000");
-        if (!/^[a-z0-9.-]+$/i.test(options.hostname) ||
+            throw new SandboxSecurityError(`Invalid port number: ${port}. Must be 1024-65535, excluding 3000 (sandbox control plane).`, "INVALID_PORT");
+        if (!/^[a-z0-9.-]+(:\d{1,5})?$/i.test(options.hostname) ||
             options.hostname.startsWith(".") ||
-            options.hostname.endsWith("."))
+            /\.(:|$)/.test(options.hostname))
             throw new TypeError("Preview hostname must be a DNS hostname");
         if (options.hostname.endsWith(".workers.dev"))
-            throw new Error("Port exposure requires a custom domain; .workers.dev does not support wildcard preview subdomains");
+            throw new Error("Port exposure requires a custom domain. .workers.dev domains do not support wildcard subdomains required for port proxying.");
+        if (options.token !== undefined)
+            validateToken(options.token);
         const existing = await this.ctx.storage.get(`runtime.preview.${port}`);
-        const token = options.token ?? existing?.token ?? crypto.randomUUID().replaceAll("-", "");
+        const token = options.token ?? existing?.token ?? newToken();
         const ports = await this.ctx.storage.list({
             prefix: "runtime.preview.",
         });
-        if ([...ports.values()].some((p) => p.port !== port && p.token === token))
-            throw new Error(`Token '${token}' is already in use by another port`);
-        if (!/^[a-z0-9_]{1,63}$/.test(token))
-            throw new TypeError("Preview token must contain 1-63 lowercase letters, digits or underscores");
+        const taken = [...ports.values()].find((p) => p.port !== port && p.token === token);
+        if (taken)
+            throw new SandboxSecurityError(`Token '${token}' is already in use by port ${taken.port}. Please use a different token.`, "TOKEN_IN_USE");
         const sandbox = await this.sandbox();
         const name = this.configuration.sandboxName.name;
         if (name !== name.toLowerCase())
             throw new CompatibilityError("Cloudflare", "uppercase sandbox IDs in preview hostnames; use normalizeId:true");
         const native = await (await sandbox.native()).previews.create(port, { visibility: "private" });
-        const url = `https://${port}-${name}-${token}.${options.hostname}`;
+        const url = previewUrl(port, name, options.hostname, token);
         await this.ctx.storage.put(`runtime.preview.${port}`, {
             token,
             url,
@@ -366,7 +494,7 @@ export class Sandbox extends DurableObject {
                 prefix: "runtime.preview.",
             })).values(),
         ].map((p) => ({
-            url: `https://${p.port}-${this.configuration.sandboxName.name}-${p.token}.${hostname}`,
+            url: previewUrl(p.port, this.configuration.sandboxName.name, hostname, p.token),
             port: p.port,
             status: "active",
         }));
@@ -410,6 +538,9 @@ export class Sandbox extends DurableObject {
     }
 }
 export function getSandbox(namespace, id, options = {}) {
+    for (const [option, alternative] of Object.entries(OPTIONS))
+        if (options[option] !== undefined)
+            throw refusal("Cloudflare", `getSandbox ${option}`, alternative);
     only("Cloudflare Worker getSandbox", options, ["normalizeId", "sleepAfter", "keepAlive"]);
     sanitizeSandboxId(id);
     const name = options.normalizeId ? id.toLowerCase() : id;
@@ -422,6 +553,16 @@ export function getSandbox(namespace, id, options = {}) {
     // Await configuration for every operation so no request can race name setup.
     return new Proxy(stub, {
         get(target, key) {
+            // Cloudflare's getSandbox adds these on the Worker side; an RPC stub
+            // would answer every name, so refuse them here, by name.
+            if (key === "tunnels")
+                return tunnels;
+            if (key === "wsConnect")
+                return () => Promise.reject(refusal("Cloudflare", "Sandbox.wsConnect", "connect to the URL exposePort returns"));
+            if (key === "terminal")
+                return () => Promise.reject(refusal("Cloudflare", "Sandbox.terminal", TERMINAL));
+            if (key === "client")
+                throw refusal("Cloudflare", "Sandbox.client", "Runtime's API is the client");
             const value = Reflect.get(target, key);
             if (typeof value !== "function" || key === "then")
                 return value;
@@ -429,6 +570,51 @@ export function getSandbox(namespace, id, options = {}) {
         },
     });
 }
+for (const [member, alternative] of Object.entries(REFUSED))
+    Object.defineProperty(Sandbox.prototype, member, {
+        configurable: true,
+        writable: true,
+        value: () => Promise.reject(refusal("Cloudflare", `Sandbox.${member}`, alternative)),
+    });
+/** getSandbox options Cloudflare's class reads that a Runtime sandbox has no
+ * counterpart for. */
+const OPTIONS = {
+    containerTimeouts: "a Runtime sandbox has no container start to tune",
+    transport: "Runtime's API is the only transport",
+    enableDefaultSession: "commands share the default session; use createSession() for a separate shell",
+    labels: "call sandbox.setLabels(labels)",
+};
+const TUNNELS = "use exposePort for a URL to a port; Runtime serves it itself";
+const tunnels = Object.fromEntries(["get", "list", "destroy"].map((method) => [
+    method,
+    () => Promise.reject(refusal("Cloudflare", `Sandbox.tunnels.${method}`, TUNNELS)),
+]));
+/** Cloudflare's preview URL for a port: `http` and the given port on a local
+ * hostname, `https` otherwise, built as its SDK builds it. */
+function previewUrl(port, sandboxId, hostname, token) {
+    const id = sanitizeSandboxId(sandboxId).toLowerCase();
+    const [host = "", mainPort] = hostname.split(":");
+    const local = ["localhost", "127.0.0.1", "0.0.0.0"].includes(host);
+    const base = new URL(local ? `http://${host}:${mainPort || "80"}` : `https://${hostname}`);
+    base.hostname = `${port}-${id}-${token}.${host}`;
+    return base.toString();
+}
+function validateToken(token) {
+    if (token.length === 0)
+        throw new SandboxSecurityError("Custom token cannot be empty.", "INVALID_TOKEN");
+    if (token.length > 16)
+        throw new SandboxSecurityError(`Custom token too long. Maximum 16 characters allowed. Received: ${token.length} characters.`, "INVALID_TOKEN");
+    if (!/^[a-z0-9_]+$/.test(token))
+        throw new SandboxSecurityError("Custom token must contain only lowercase letters (a-z), numbers (0-9), and underscores (_). Invalid token provided.", "INVALID_TOKEN");
+}
+/** 16 characters of a-z, 0-9 and _, as Cloudflare's tokens are. */
+function newToken() {
+    const bytes = crypto.getRandomValues(new Uint8Array(12));
+    return btoa(String.fromCharCode(...bytes))
+        .replace(/[+/]/g, "_")
+        .replace(/=/g, "")
+        .toLowerCase();
+}
 function previewRoute(url) {
     const label = url.hostname.split(".")[0] ?? "";
     const match = /^(\d{4,5})-([a-z0-9_-]+)-([a-z0-9_]{1,63})$/.exec(label);

package/dist/containers/index.d.ts

@@ -0,0 +1,10 @@
+/** `withruntime/containers`: Containers alone. One OCI image's process on its
+ * own microVM, at the sandbox rates. In a private beta.
+ *
+ *   import { containers } from "withruntime/containers";
+ *   const client = containers(); // RUNTIME_API_KEY, or this machine's saved connection
+ */
+import { Runtime, type RuntimeOptions } from "../client.js";
+export type * from "../products/containers.js";
+/** `runtime.containers` of a client made with `options`. */
+export declare function containers(options?: RuntimeOptions): Runtime["containers"];

package/dist/containers/index.js

@@ -0,0 +1,11 @@
+/** `withruntime/containers`: Containers alone. One OCI image's process on its
+ * own microVM, at the sandbox rates. In a private beta.
+ *
+ *   import { containers } from "withruntime/containers";
+ *   const client = containers(); // RUNTIME_API_KEY, or this machine's saved connection
+ */
+import { Runtime } from "../client.js";
+/** `runtime.containers` of a client made with `options`. */
+export function containers(options) {
+    return new Runtime(options).containers;
+}

package/dist/daytona/sandbox.d.ts

@@ -126,7 +126,8 @@ export declare class Sandbox {
     /** Pauses the sandbox with its memory. */
     pause(_timeout?: number): Promise<void>;
     /** Runtime has no archive tier: a stopped sandbox stays paused, kept for
-     * its retention (30 days paid, 7 without credit, or autoDeleteInterval). */
+     * its retention (while the account has credit, 7 days without, or
+     * autoDeleteInterval rounded up to whole days). */
     archive(): Promise<void>;
     /** Ends the sandbox for good. */
     delete(_timeout?: number): Promise<void>;

package/dist/daytona/sandbox.js

@@ -270,7 +270,8 @@ export class Sandbox {
         this.#pausedByPause = true;
     }
     /** Runtime has no archive tier: a stopped sandbox stays paused, kept for
-     * its retention (30 days paid, 7 without credit, or autoDeleteInterval). */
+     * its retention (while the account has credit, 7 days without, or
+     * autoDeleteInterval rounded up to whole days). */
     async archive() {
         await this.stop();
     }

package/dist/identity.js

@@ -5,8 +5,24 @@ async function requestCredentials() {
     const token = process.env.RUNTIME_ID_TOKEN_REQUEST_TOKEN;
     if (url && token)
         return { url, token };
-    // A process started before the guest wrote its environment still finds it.
-    return fileCredentials();
+    // A process started without them (a server started before the guest wrote
+    // its environment, a sandbox whose guest software predates the variables)
+    // asks the host, which answers every running sandbox whatever its image or
+    // age, then the guest's file. Only inside a sandbox: elsewhere nothing is
+    // asked over the network.
+    if (!(await exists(sandboxMarker.path)))
+        return null;
+    return currentCredentials();
+}
+async function exists(path) {
+    try {
+        const { access } = await import("node:fs/promises");
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
 async function fileCredentials() {
     try {

package/dist/index.d.ts

@@ -76,3 +76,6 @@ export { openWalletAccount, claimWalletAccount, rekeyWalletAccount, type OpenedW
 export type { Topup } from "./products/billing.js";
 export type { NewKey, LimitedKey, LimitedKeyAction, MadeKey, ListedKey, KeyUsage, } from "./products/api-keys.js";
 export type { SsoConnection, SsoStatus } from "./products/sso.js";
+export type { Agent, AgentDefinition, AgentEvent, AgentSession, AgentSessionHandle, AgentSessionState, AgentTemplate, AgentTemplateKey, AgentTrigger, AgentTriggerKind, AgentUse, CreateAgent, CreateAgentTrigger, StartAgentSession, } from "./products/agents.js";
+export { AGENT_TEMPLATES, AGENT_USES } from "./products/agents.js";
+export type { Container, ContainerState, CreateContainer, UpdateContainer, } from "./products/containers.js";

package/dist/index.js

@@ -48,3 +48,4 @@ export class Sandbox extends SandboxClass {
 }
 export { identityToken } from "./identity.js";
 export { openWalletAccount, claimWalletAccount, rekeyWalletAccount, } from "./wallet.js";
+export { AGENT_TEMPLATES, AGENT_USES } from "./products/agents.js";

package/dist/product-names.js

@@ -34,6 +34,8 @@ export const PRODUCT_NAMES = [
     { name: "jobs", title: "Jobs", engine: "machine", singular: "job", old: was("job") },
     { name: "workflows", title: "Workflows", engine: "machine", singular: "workflow", old: [] },
     { name: "builds", title: "Builds", engine: "machine", singular: "build", old: [] },
+    { name: "agents", title: "Agents", engine: "machine", singular: "agent", old: [] },
+    { name: "ci", title: "CI/CD", engine: "machine", old: [] },
     // Disk
     { name: "volumes", title: "Volumes", engine: "disk", singular: "volume", old: was("volume") },
     {
@@ -91,6 +93,7 @@ export const PRODUCT_NAMES = [
     { name: "usage", title: "Usage", engine: "meter", old: [] },
     { name: "billing", title: "Billing", engine: "meter", old: [] },
     { name: "metrics", title: "Metrics", engine: "meter", old: [] },
+    { name: "plans", title: "Plans", engine: "meter", singular: "plan", old: [] },
     // Database (not now: CLOUD.md section 2)
     { name: "postgres", title: "Postgres", engine: "database", old: [] },
     { name: "mysql", title: "MySQL", engine: "database", old: [] },