@cloudflare/sandbox 0.13.0-next.651.1 → 0.13.0-next.709.1

package/dist/opencode/index.js

@@ -1,60 +1,103 @@
-import { s as createLogger } from "../dist-DF8sudAg.js";
-import { r as ErrorCode } from "../errors-BG6NZiPD.js";
+import { i as ErrorCode } from "../errors-CXR0xBpw.js";
+import "../errors-QYlSkVGz.js";
+import { r as createLogger } from "../dist-Duor5GbS.js";
+import { n as createExtensionProcessSandbox, t as SandboxExtension } from "../extensions-CFB2xHqY.js";
 
-//#region src/opencode/types.ts
+//#region ../../extensions/opencode/src/client.ts
+let createSDKClient;
+async function loadSDK() {
+	if (createSDKClient) return createSDKClient;
+	try {
+		createSDKClient = (await import("@opencode-ai/sdk/v2/client")).createOpencodeClient;
+		return createSDKClient;
+	} catch {
+		throw new Error("@opencode-ai/sdk is required for OpenCode integration. Install it with: npm install @opencode-ai/sdk");
+	}
+}
+/**
+* Build a typed OpenCode SDK client from a lifecycle handle.
+*
+* Works against either the Worker stub (`sandbox.opencode`) or the in-DO object
+* (`this.opencode`): it ensures the server through the handle, reads the stored
+* config, and routes every request through `handle.fetch`. Because the handle
+* owns `containerFetch`, this helper never touches sandbox transport directly.
+*
+* The SDK is imported lazily so the peer dependency is only required when an
+* OpenCode client is actually built.
+*/
+async function createOpenCodeClient(handle, options) {
+	const server = await handle.start(options);
+	const config = await handle.config();
+	const directory = options?.directory ?? config.directory;
+	return (await loadSDK())({
+		baseUrl: server.url,
+		fetch: (input, init) => handle.fetch(new Request(input, init)),
+		directory
+	});
+}
+
+//#endregion
+//#region ../../extensions/opencode/src/types.ts
 /**
 * Error thrown when OpenCode server fails to start
 */
-var OpencodeStartupError = class extends Error {
+var OpenCodeStartupError = class extends Error {
 	code = ErrorCode.OPENCODE_STARTUP_FAILED;
 	context;
 	constructor(message, context, options) {
 		super(message, options);
-		this.name = "OpencodeStartupError";
+		this.name = "OpenCodeStartupError";
 		this.context = context;
 	}
 };
 
 //#endregion
-//#region src/opencode/opencode.ts
+//#region ../../extensions/opencode/src/opencode.ts
 function getLogger() {
 	return createLogger({
 		component: "sandbox-do",
 		operation: "opencode"
 	});
 }
-const DEFAULT_PORT = 4096;
+const DEFAULT_PORT$1 = 4096;
 const OPENCODE_STARTUP_TIMEOUT_MS = 18e4;
-const OPENCODE_SERVE = (port) => `opencode serve --port ${port} --hostname 0.0.0.0`;
-/**
-* Build the full command, optionally with a directory prefix.
-* If directory is provided, we cd to it first so OpenCode uses it as cwd.
-*/
-function buildOpencodeCommand(port, directory) {
-	const serve = OPENCODE_SERVE(port);
-	return directory ? `cd ${directory} && ${serve}` : serve;
+function openCodeCommand(port) {
+	return [
+		"opencode",
+		"serve",
+		"--port",
+		String(port),
+		"--hostname",
+		"0.0.0.0"
+	];
 }
-let createOpencodeClient;
-async function ensureSdkLoaded() {
-	if (createOpencodeClient) return;
-	try {
-		createOpencodeClient = (await import("@opencode-ai/sdk/v2/client")).createOpencodeClient;
-	} catch {
-		throw new Error("@opencode-ai/sdk is required for OpenCode integration. Install it with: npm install @opencode-ai/sdk");
-	}
+function commandsEqual(a, b) {
+	return a.length === b.length && a.every((value, index) => value === b[index]);
 }
-/**
-* Find an existing OpenCode server process running on the specified port.
-* Returns the process if found and still active, null otherwise.
-* Matches by the serve command pattern since directory prefix may vary.
-*/
-async function findExistingOpencodeProcess(sandbox, port) {
-	const processes = await sandbox.listProcesses();
-	const serveCommand = OPENCODE_SERVE(port);
-	for (const proc of processes) if (proc.command.includes(serveCommand)) {
-		if (proc.status === "starting" || proc.status === "running") return proc;
+/** Recover a running OpenCode process from runtime-local process status. */
+async function findExistingOpenCodeProcess(sandbox, port, directory) {
+	const command = openCodeCommand(port);
+	const processes = createExtensionProcessSandbox(sandbox);
+	const status = (await processes.listProcesses()).find((candidate) => candidate.state === "running" && candidate.cwd === directory && commandsEqual(candidate.command, command));
+	return status ? processes.getProcess(status.id) : null;
+}
+async function collectStderr(process) {
+	const reader = (await process.logs({
+		replay: true,
+		follow: false
+	})).getReader();
+	const decoder = new TextDecoder();
+	let stderr = "";
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			if (value.type === "stderr") stderr += decoder.decode(value.data, { stream: true });
+		}
+		return stderr + decoder.decode();
+	} finally {
+		reader.releaseLock();
 	}
-	return null;
 }
 /**
 * Ensures OpenCode server is running in the container.
@@ -62,30 +105,9 @@ async function findExistingOpencodeProcess(sandbox, port) {
 * Handles concurrent startup attempts gracefully by retrying on failure.
 * Returns the process handle.
 */
-async function ensureOpencodeServer(sandbox, port, directory, config, customEnv) {
-	const existingProcess = await findExistingOpencodeProcess(sandbox, port);
+async function ensureOpenCodeServer(sandbox, port, directory, config, customEnv) {
+	const existingProcess = await findExistingOpenCodeProcess(sandbox, port, directory);
 	if (existingProcess) {
-		if (existingProcess.status === "starting") {
-			getLogger().debug("Found starting OpenCode process, waiting for ready", {
-				port,
-				processId: existingProcess.id
-			});
-			try {
-				await existingProcess.waitForPort(port, {
-					mode: "http",
-					path: "/path",
-					status: 200,
-					timeout: OPENCODE_STARTUP_TIMEOUT_MS
-				});
-			} catch (e) {
-				const logs = await existingProcess.getLogs();
-				throw new OpencodeStartupError(`OpenCode server failed to start. Stderr: ${logs.stderr || "(empty)"}`, {
-					port,
-					stderr: logs.stderr,
-					command: existingProcess.command
-				}, { cause: e });
-			}
-		}
 		getLogger().debug("Reusing existing OpenCode process", {
 			port,
 			processId: existingProcess.id
@@ -93,29 +115,14 @@ async function ensureOpencodeServer(sandbox, port, directory, config, customEnv)
 		return existingProcess;
 	}
 	try {
-		return await startOpencodeServer(sandbox, port, directory, config, customEnv);
+		return await startOpenCodeServer(sandbox, port, directory, config, customEnv);
 	} catch (startupError) {
-		const retryProcess = await findExistingOpencodeProcess(sandbox, port);
+		const retryProcess = await findExistingOpenCodeProcess(sandbox, port, directory);
 		if (retryProcess) {
 			getLogger().debug("Startup failed but found concurrent process, reusing", {
 				port,
 				processId: retryProcess.id
 			});
-			if (retryProcess.status === "starting") try {
-				await retryProcess.waitForPort(port, {
-					mode: "http",
-					path: "/path",
-					status: 200,
-					timeout: OPENCODE_STARTUP_TIMEOUT_MS
-				});
-			} catch (e) {
-				const logs = await retryProcess.getLogs();
-				throw new OpencodeStartupError(`OpenCode server failed to start. Stderr: ${logs.stderr || "(empty)"}`, {
-					port,
-					stderr: logs.stderr,
-					command: retryProcess.command
-				}, { cause: e });
-			}
 			return retryProcess;
 		}
 		throw startupError;
@@ -124,7 +131,7 @@ async function ensureOpencodeServer(sandbox, port, directory, config, customEnv)
 /**
 * Internal function to start a new OpenCode server process.
 */
-async function startOpencodeServer(sandbox, port, directory, config, customEnv) {
+async function startOpenCodeServer(sandbox, port, directory, config, customEnv) {
 	getLogger().info("Starting OpenCode server", {
 		port,
 		directory
@@ -152,8 +159,11 @@ async function startOpencodeServer(sandbox, port, directory, config, customEnv)
 		}
 	}
 	if (customEnv) Object.assign(env, customEnv);
-	const command = buildOpencodeCommand(port, directory);
-	const process = await sandbox.startProcess(command, { env: Object.keys(env).length > 0 ? env : void 0 });
+	const command = openCodeCommand(port);
+	const process = await createExtensionProcessSandbox(sandbox).exec(command, {
+		cwd: directory,
+		env: Object.keys(env).length > 0 ? env : void 0
+	});
 	try {
 		await process.waitForPort(port, {
 			mode: "http",
@@ -166,16 +176,16 @@ async function startOpencodeServer(sandbox, port, directory, config, customEnv)
 			processId: process.id
 		});
 	} catch (e) {
-		const logs = await process.getLogs();
+		const stderr = await collectStderr(process);
 		const error = e instanceof Error ? e : void 0;
 		getLogger().error("OpenCode server failed to start", error, {
 			port,
-			stderr: logs.stderr
+			stderr
 		});
-		throw new OpencodeStartupError(`OpenCode server failed to start. Stderr: ${logs.stderr || "(empty)"}`, {
+		throw new OpenCodeStartupError(`OpenCode server failed to start. Stderr: ${stderr || "(empty)"}`, {
 			port,
-			stderr: logs.stderr,
-			command
+			stderr,
+			command: command.join(" ")
 		}, { cause: e });
 	}
 	return process;
@@ -183,7 +193,7 @@ async function startOpencodeServer(sandbox, port, directory, config, customEnv)
 /**
 * Starts an OpenCode server inside a Sandbox container.
 *
-* This function manages the server lifecycle only - use `createOpencode()` if you
+* This function manages the server lifecycle only - use `createOpenCodeClient()` if you
 * also need a typed SDK client for programmatic access.
 *
 * If an OpenCode server is already running on the specified port, this function
@@ -196,10 +206,10 @@ async function startOpencodeServer(sandbox, port, directory, config, customEnv)
 * @example
 * ```typescript
 * import { getSandbox } from '@cloudflare/sandbox'
-* import { createOpencodeServer } from '@cloudflare/sandbox/opencode'
+* import { createOpenCodeServer } from '@cloudflare/sandbox/opencode'
 *
 * const sandbox = getSandbox(env.Sandbox, 'my-agent')
-* const server = await createOpencodeServer(sandbox, {
+* const server = await createOpenCodeServer(sandbox, {
 *   directory: '/home/user/my-project',
 *   config: {
 *     provider: {
@@ -226,148 +236,219 @@ async function startOpencodeServer(sandbox, port, directory, config, customEnv)
 * await server.close()
 * ```
 */
-async function createOpencodeServer(sandbox, options) {
-	const port = options?.port ?? DEFAULT_PORT;
-	const process = await ensureOpencodeServer(sandbox, port, options?.directory, options?.config, options?.env);
+async function createOpenCodeServer(sandbox, options) {
+	const port = options?.port ?? DEFAULT_PORT$1;
+	const process = await ensureOpenCodeServer(sandbox, port, options?.directory, options?.config, options?.env);
 	return {
 		port,
 		url: `http://localhost:${port}`,
-		close: () => process.kill("SIGTERM")
+		close: async () => {
+			await process.kill(15);
+			await process.waitForExit().catch(() => {});
+		}
 	};
 }
+
+//#endregion
+//#region ../../extensions/opencode/src/lifecycle.ts
+const DEFAULT_PORT = 4096;
+const STATE_KEY_PREFIX = "opencode:desired-state:";
+/** Recognise the retryable container-unavailable error across RPC. */
+function isContainerUnavailable(error) {
+	if (typeof error !== "object" || error === null) return false;
+	return error.name === "ContainerUnavailableError";
+}
 /**
-* Creates an OpenCode server inside a Sandbox container and returns a typed SDK client.
+* DO-resident lifecycle handle for an OpenCode server. Owns the durable
+* `opencode serve` process: start/reuse, stop, status, and request proxying.
 *
-* This function is API-compatible with OpenCode's own createOpencode(), but uses
-* Sandbox process management instead of Node.js spawn. The returned client uses
-* a custom fetch adapter to route requests through the Sandbox container.
+* It extends {@link SandboxExtension}, so the DO stub exposes it as
+* `sandbox.opencode` and method calls dispatch through `callExtension` — the
+* same path the interpreter extension uses. `createOpenCodeClient` consumes the
+* same handle from either the Worker stub or the in-DO object.
 *
-* If an OpenCode server is already running on the specified port, this function
-* will reuse it instead of starting a new one.
-*
-* @param sandbox - The Sandbox instance to run OpenCode in
-* @param options - Configuration options
-* @returns Promise resolving to { client, server }
-*
-* @example
-* ```typescript
-* import { getSandbox } from '@cloudflare/sandbox'
-* import { createOpencode } from '@cloudflare/sandbox/opencode'
-*
-* const sandbox = getSandbox(env.Sandbox, 'my-agent')
-* const { client, server } = await createOpencode(sandbox, {
-*   directory: '/home/user/my-project',
-*   config: {
-*     provider: {
-*       anthropic: {
-*         options: { apiKey: env.ANTHROPIC_KEY }
-*       },
-*       // Or use Cloudflare AI Gateway (with unified billing, no provider keys needed).
-*       // 'cloudflare-ai-gateway': {
-*       //   options: {
-*       //     accountId: env.CF_ACCOUNT_ID,
-*       //     gatewayId: env.CF_GATEWAY_ID,
-*       //     apiToken: env.CF_API_TOKEN
-*       //   },
-*       //   models: { 'anthropic/claude-sonnet-4-5-20250929': {} }
-*       // }
-*     }
-*   },
-*   // Optional: Pass additional environment variables (e.g., for OTEL telemetry)
-*   env: {
-*     OTEL_EXPORTER_OTLP_ENDPOINT: 'http://127.0.0.1:4318',
-*     TRACEPARENT: '00-abc123-def456-01'
-*   }
-* })
-*
-* // Use the SDK client for programmatic access
-* const session = await client.session.create()
+* The server starts lazily: nothing runs until `start()` (or `fetch()`, which
+* calls it) is invoked. To start optimistically, call `opencode.start()` from
+* your Sandbox subclass's `onStart`.
+*/
+var OpenCodeHandle = class extends SandboxExtension {
+	#sandbox;
+	#defaults;
+	#storage;
+	#stateKey;
+	#server;
+	#lastOptions;
+	constructor(sandbox, defaults = {}, storage, stateIndex = 0) {
+		super(sandbox);
+		this.#sandbox = sandbox;
+		this.#defaults = defaults;
+		this.#storage = storage;
+		this.#stateKey = `${STATE_KEY_PREFIX}${stateIndex}`;
+	}
+	/**
+	* Start or reuse the OpenCode server, returning RPC-safe metadata. With no
+	* options it reuses the last-used config, recovering persisted desired-state
+	* after a cold start. Retries once on a transient `CONTAINER_UNAVAILABLE`
+	* (e.g. a rollout in flight).
+	*/
+	async start(options) {
+		const recovered = options ?? this.#lastOptions ?? await this.#loadPersisted();
+		const resolved = {
+			...this.#defaults,
+			...recovered
+		};
+		this.#lastOptions = resolved;
+		await this.#persist(resolved);
+		let server;
+		try {
+			server = await createOpenCodeServer(this.#sandbox, resolved);
+		} catch (error) {
+			if (!isContainerUnavailable(error)) throw error;
+			server = await createOpenCodeServer(this.#sandbox, resolved);
+		}
+		this.#server = server;
+		return {
+			port: server.port,
+			url: server.url
+		};
+	}
+	/** Stop the running server, if one was started through this handle. */
+	async stop() {
+		if (!this.#server) return;
+		await this.#server.close();
+		this.#server = void 0;
+	}
+	/** Report whether the named OpenCode server is currently running. */
+	async status() {
+		const resolved = {
+			...this.#defaults,
+			...this.#lastOptions
+		};
+		const port = resolved.port ?? DEFAULT_PORT;
+		return {
+			running: await findExistingOpenCodeProcess(this.#sandbox, port, resolved.directory) !== null,
+			port,
+			url: `http://localhost:${port}`
+		};
+	}
+	/** Snapshot of the resolved configuration the client builder reads. */
+	async config() {
+		const resolved = {
+			...this.#defaults,
+			...this.#lastOptions
+		};
+		return {
+			port: resolved.port ?? DEFAULT_PORT,
+			directory: resolved.directory
+		};
+	}
+	/**
+	* Start the server then route a request into the container. This is the
+	* transport the SDK client's `fetch` adapter and the Worker proxy use, so it
+	* works identically from the Worker stub (one RPC hop) or in-DO (local).
+	*/
+	async fetch(request) {
+		const server = await this.start();
+		return this.#sandbox.containerFetch(request, server.port);
+	}
+	/**
+	* Persist resolved desired-state so a cold DO can recover it. Best-effort.
+	*
+	* Secret-bearing fields (`config`, `env`) are never written to storage. They
+	* are sourced fresh from the handle's defaults — which the Sandbox rebuilds
+	* from the environment on every construction — so a cold start always uses
+	* current credentials rather than a durable copy.
+	*/
+	async #persist(options) {
+		if (!this.#storage) return;
+		const { config: _config, env: _env, ...safe } = options;
+		await this.#storage.put(this.#stateKey, safe);
+	}
+	/** Read persisted desired-state, if any, after a DO eviction. */
+	async #loadPersisted() {
+		if (!this.#storage) return void 0;
+		return this.#storage.get(this.#stateKey);
+	}
+};
+/**
+* Assigns each handle a stable per-sandbox index so its persisted state key is
+* deterministic across DO reconstruction (field initializers run in the same
+* order each time). Keyed weakly so it is collected with the sandbox.
+*/
+const stateIndexCounter = /* @__PURE__ */ new WeakMap();
+/**
+* Factory — attach as a field on a Sandbox subclass:
+* `opencode = withOpenCode(this, { directory, config, storage: this.ctx.storage })`.
 *
-* // When done
-* await server.close()
-* ```
+* Pass `storage` to persist desired-state so the server is recovered after a DO
+* eviction (cold start). The server starts lazily on first use.
 */
-async function createOpencode(sandbox, options) {
-	await ensureSdkLoaded();
-	const server = await createOpencodeServer(sandbox, options);
-	const clientFactory = createOpencodeClient;
-	if (!clientFactory) throw new Error("OpenCode SDK client unavailable.");
-	return {
-		client: clientFactory({
-			baseUrl: server.url,
-			fetch: (input, init) => sandbox.containerFetch(new Request(input, init), server.port)
-		}),
-		server
-	};
+function withOpenCode(sandbox, options = {}) {
+	const { storage, ...defaults } = options;
+	const index = stateIndexCounter.get(sandbox) ?? 0;
+	stateIndexCounter.set(sandbox, index + 1);
+	return new OpenCodeHandle(sandbox, defaults, storage, index);
 }
+
+//#endregion
+//#region ../../extensions/opencode/src/proxy.ts
 /**
-* Proxy a request directly to the OpenCode server.
+* Proxy a request to the OpenCode web UI through a lifecycle handle.
 *
-* Unlike `proxyToOpencode()`, this helper does not apply any web UI redirects
-* or query parameter rewrites. Use it for API/CLI traffic where raw request
-* forwarding is preferred.
+* For an initial HTML page load that still lacks the `?url=` parameter, returns
+* a redirect that adds it (so the OpenCode frontend calls back through the
+* proxy instead of `127.0.0.1:4096`). Every other request is routed through
+* `handle.fetch`, which ensures the server is running before forwarding into the
+* container.
 */
-function proxyToOpencodeServer(request, sandbox, server) {
-	return sandbox.containerFetch(request, server.port);
+function proxyToOpenCodeUI(request, handle, options) {
+	const url = new URL(request.url);
+	if (!url.searchParams.has("url") && request.method === "GET") {
+		if ((request.headers.get("accept") || "").includes("text/html") || url.pathname === "/") {
+			url.searchParams.set("url", options?.callbackOrigin ?? url.origin);
+			return Response.redirect(url.toString(), 302);
+		}
+	}
+	return handle.fetch(request);
 }
 /**
-* Proxy a request to the OpenCode web UI.
-*
-* This function handles the redirect and proxying only - you must start the
-* server separately using `createOpencodeServer()`.
+* Curried Worker fetch wrapper for OpenCode.
 *
-* Specifically handles:
-* 1. Ensuring the `?url=` parameter is set (required for OpenCode's frontend to
-*    make API calls through the proxy instead of directly to localhost:4096)
-* 2. Proxying the request to the container
+* `createOpenCodeProxy(resolve, options?)` captures a lazy per-request resolver
+* for the OpenCode lifecycle handle (`sandbox.opencode`) and returns a function
+* that wraps the user's worker entrypoint.
 *
-* @param request - The incoming HTTP request
-* @param sandbox - The Sandbox instance running OpenCode
-* @param server - The OpenCode server handle from createOpencodeServer()
-* @returns Response from OpenCode or a redirect response
+* The wrapped handler runs first. If it returns a 404 (or has no `fetch`), the
+* request falls through to the OpenCode web-UI proxy — the redirect handshake
+* for HTML loads and an ensure-then-forward into the container for everything
+* else. A 404 from the user handler is the "not mine, proxy it" signal, so the
+* handler only needs to own its own routes and `return new Response('Not
+* found', { status: 404 })` for the rest.
 *
-* @example
-* ```typescript
-* import { getSandbox } from '@cloudflare/sandbox'
-* import { createOpencodeServer, proxyToOpencode } from '@cloudflare/sandbox/opencode'
-*
-* export default {
-*   async fetch(request: Request, env: Env) {
-*     const sandbox = getSandbox(env.Sandbox, 'opencode')
-*     const server = await createOpencodeServer(sandbox, {
-*       directory: '/home/user/project',
-*       config: {
-*         provider: {
-*           anthropic: {
-*             options: { apiKey: env.ANTHROPIC_KEY }
-*           },
-*           // Optional: Route all providers through Cloudflare AI Gateway
-*           'cloudflare-ai-gateway': {
-*             options: {
-*               accountId: env.CF_ACCOUNT_ID,
-*               gatewayId: env.CF_GATEWAY_ID,
-*               apiToken: env.CF_API_TOKEN
-*             }
-*           }
-*         }
-*       }
-*     })
-*     return proxyToOpencode(request, sandbox, server)
+* ```ts
+* export default createOpenCodeProxy(
+*   (env) => getSandbox(env.Sandbox, 'my-sandbox').opencode
+* )({
+*   async fetch(request, env) {
+*     // handle your own routes, else:
+*     return new Response('Not found', { status: 404 });
 *   }
-* }
+* });
 * ```
 */
-function proxyToOpencode(request, sandbox, server) {
-	const url = new URL(request.url);
-	if (!url.searchParams.has("url") && request.method === "GET") {
-		if ((request.headers.get("accept") || "").includes("text/html") || url.pathname === "/") {
-			url.searchParams.set("url", url.origin);
-			return Response.redirect(url.toString(), 302);
+function createOpenCodeProxy(resolve, options) {
+	return (handler) => ({
+		...handler,
+		async fetch(request, env, ctx) {
+			if (handler.fetch) {
+				const response = await handler.fetch(request, env, ctx);
+				if (response.status !== 404) return response;
+			}
+			return proxyToOpenCodeUI(request, resolve(env), options);
 		}
-	}
-	return proxyToOpencodeServer(request, sandbox, server);
+	});
 }
 
 //#endregion
-export { OpencodeStartupError, createOpencode, createOpencodeServer, proxyToOpencode, proxyToOpencodeServer };
+export { OpenCodeHandle, OpenCodeStartupError, createOpenCodeClient, createOpenCodeProxy, proxyToOpenCodeUI, withOpenCode };
 //# sourceMappingURL=index.js.map