@cloudflare/sandbox 0.6.3 → 0.6.4

package/dist/openai/index.d.ts

@@ -1,4 +1,4 @@
-import { t as Sandbox } from "../sandbox-bAj-cB2H.js";
+import { t as Sandbox } from "../sandbox-C9WRqWBO.js";
 import { ApplyPatchOperation, ApplyPatchResult, Editor as Editor$1, Shell as Shell$1, ShellAction, ShellResult } from "@openai/agents";
 
 //#region src/openai/index.d.ts

package/dist/openai/index.js

@@ -1,4 +1,4 @@
-import { o as createLogger } from "../dist-D0sZt0AD.js";
+import { o as createLogger } from "../dist-2SF6oOaz.js";
 import { applyDiff } from "@openai/agents";
 
 //#region src/openai/index.ts

package/dist/opencode/index.d.ts

@@ -0,0 +1,149 @@
+import { t as Sandbox } from "../sandbox-C9WRqWBO.js";
+import { t as OpencodeStartupContext } from "../contexts-DeQQjsXq.js";
+import { Config } from "@opencode-ai/sdk";
+
+//#region src/opencode/types.d.ts
+/**
+ * Configuration options for starting OpenCode server
+ */
+interface OpencodeOptions {
+  /** Port for OpenCode server (default: 4096) */
+  port?: number;
+  /** Working directory for OpenCode (default: container's cwd) */
+  directory?: string;
+  /** OpenCode configuration */
+  config?: Config;
+}
+/**
+ * Server lifecycle management
+ */
+interface OpencodeServer {
+  /** Port the server is running on */
+  port: number;
+  /** Base URL for SDK client (http://localhost:{port}) */
+  url: string;
+  /** Close the server gracefully */
+  close(): Promise<void>;
+}
+/**
+ * Result from createOpencode()
+ * Client type comes from @opencode-ai/sdk (user's version)
+ */
+interface OpencodeResult<TClient = unknown> {
+  /** OpenCode SDK client with Sandbox transport */
+  client: TClient;
+  /** Server lifecycle management */
+  server: OpencodeServer;
+}
+/**
+ * Error thrown when OpenCode server fails to start
+ */
+declare class OpencodeStartupError extends Error {
+  readonly code: "OPENCODE_STARTUP_FAILED";
+  readonly context: OpencodeStartupContext;
+  constructor(message: string, context: OpencodeStartupContext, options?: ErrorOptions);
+}
+//#endregion
+//#region src/opencode/opencode.d.ts
+/**
+ * Starts an OpenCode server inside a Sandbox container.
+ *
+ * This function manages the server lifecycle only - use `createOpencode()` if you
+ * also need a typed SDK client for programmatic access.
+ *
+ * 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 server handle { port, url, close() }
+ *
+ * @example
+ * ```typescript
+ * import { getSandbox } from '@cloudflare/sandbox'
+ * import { createOpencodeServer } from '@cloudflare/sandbox/opencode'
+ *
+ * const sandbox = getSandbox(env.Sandbox, 'my-agent')
+ * const server = await createOpencodeServer(sandbox, {
+ *   directory: '/home/user/my-project',
+ *   config: { provider: { anthropic: { options: { apiKey: env.ANTHROPIC_KEY } } } }
+ * })
+ *
+ * // Proxy requests to the web UI
+ * return sandbox.containerFetch(request, server.port)
+ *
+ * // When done
+ * await server.close()
+ * ```
+ */
+declare function createOpencodeServer(sandbox: Sandbox<unknown>, options?: OpencodeOptions): Promise<OpencodeServer>;
+/**
+ * Creates an OpenCode server inside a Sandbox container and returns a typed SDK client.
+ *
+ * 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.
+ *
+ * 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 } } } }
+ * })
+ *
+ * // Use the SDK client for programmatic access
+ * const session = await client.session.create()
+ *
+ * // When done
+ * await server.close()
+ * ```
+ */
+declare function createOpencode<TClient = unknown>(sandbox: Sandbox<unknown>, options?: OpencodeOptions): Promise<OpencodeResult<TClient>>;
+/**
+ * Proxy a request to the OpenCode web UI.
+ *
+ * This function handles the redirect and proxying only - you must start the
+ * server separately using `createOpencodeServer()`.
+ *
+ * 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
+ *
+ * @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
+ *
+ * @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 } } } }
+ *     })
+ *     return proxyToOpencode(request, sandbox, server)
+ *   }
+ * }
+ * ```
+ */
+declare function proxyToOpencode(request: Request, sandbox: Sandbox<unknown>, server: OpencodeServer): Response | Promise<Response>;
+//#endregion
+export { type OpencodeOptions, type OpencodeResult, type OpencodeServer, OpencodeStartupError, createOpencode, createOpencodeServer, proxyToOpencode };
+//# sourceMappingURL=index.d.ts.map

package/dist/opencode/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/opencode/types.ts","../../src/opencode/opencode.ts"],"sourcesContent":[],"mappings":";;;;;;;;AAMiB,UAAA,eAAA,CAMN;EAMM;EAaA,IAAA,CAAA,EAAA,MAAA;EAUJ;EAEc,SAAA,CAAA,EAAA,MAAA;EAId;EACC,MAAA,CAAA,EApCH,MAoCG;;;;;UA9BG,cAAA;EC8OK;EACX,IAAA,EAAA,MAAA;EACC;EACD,GAAA,EAAA,MAAA;EAAR;EAAO,KAAA,EAAA,ED3OC,OC2OD,CAAA,IAAA,CAAA;AAgDV;;;;;AAGG,UDvRc,cCuRd,CAAA,UAAA,OAAA,CAAA,CAAA;EAAO;EAqDM,MAAA,ED1UN,OC0UM;EACL;EACA,MAAA,ED1UD,cC0UC;;;;;AAEU,cDtUR,oBAAA,SAA6B,KAAA,CCsUrB;;oBDpUM;wCAId,kCACC;;;;;;;AA1Cd;AAYA;AAaA;AAUA;;;;;;;;;ACuNA;;;;;;AAmDA;;;;;;;AAwDA;;;AAGU,iBA9GY,oBAAA,CA8GZ,OAAA,EA7GC,OA6GD,CAAA,OAAA,CAAA,EAAA,OAAA,CAAA,EA5GE,eA4GF,CAAA,EA3GP,OA2GO,CA3GC,cA2GD,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA3DY,2CACX,4BACC,kBACT,QAAQ,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqDV,eAAA,UACL,kBACA,0BACD,iBACP,WAAW,QAAQ"}

package/dist/opencode/index.js

@@ -0,0 +1,297 @@
+import { o as createLogger } from "../dist-2SF6oOaz.js";
+import { t as ErrorCode } from "../errors-BHN41iBd.js";
+
+//#region src/opencode/types.ts
+/**
+* Error thrown when OpenCode server fails to start
+*/
+var OpencodeStartupError = class extends Error {
+	code = ErrorCode.OPENCODE_STARTUP_FAILED;
+	context;
+	constructor(message, context, options) {
+		super(message, options);
+		this.name = "OpencodeStartupError";
+		this.context = context;
+	}
+};
+
+//#endregion
+//#region src/opencode/opencode.ts
+function getLogger() {
+	return createLogger({
+		component: "sandbox-do",
+		operation: "opencode"
+	});
+}
+const DEFAULT_PORT = 4096;
+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;
+}
+let createOpencodeClient;
+async function ensureSdkLoaded() {
+	if (createOpencodeClient) return;
+	try {
+		createOpencodeClient = (await import("@opencode-ai/sdk")).createOpencodeClient;
+	} catch {
+		throw new Error("@opencode-ai/sdk is required for OpenCode integration. Install it with: npm install @opencode-ai/sdk");
+	}
+}
+/**
+* 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;
+	}
+	return null;
+}
+/**
+* Ensures OpenCode server is running in the container.
+* Reuses existing process if one is already running on the specified port.
+* Handles concurrent startup attempts gracefully by retrying on failure.
+* Returns the process handle.
+*/
+async function ensureOpencodeServer(sandbox, port, directory, config) {
+	const existingProcess = await findExistingOpencodeProcess(sandbox, port);
+	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: "/",
+					timeout: 6e4
+				});
+			} 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
+		});
+		return existingProcess;
+	}
+	try {
+		return await startOpencodeServer(sandbox, port, directory, config);
+	} catch (startupError) {
+		const retryProcess = await findExistingOpencodeProcess(sandbox, port);
+		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: "/",
+					timeout: 6e4
+				});
+			} 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;
+	}
+}
+/**
+* Internal function to start a new OpenCode server process.
+*/
+async function startOpencodeServer(sandbox, port, directory, config) {
+	getLogger().info("Starting OpenCode server", {
+		port,
+		directory
+	});
+	const env = {};
+	if (config) {
+		env.OPENCODE_CONFIG_CONTENT = JSON.stringify(config);
+		if (config.provider && typeof config.provider === "object" && !Array.isArray(config.provider)) for (const [providerId, providerConfig] of Object.entries(config.provider)) {
+			let apiKey = providerConfig?.options?.apiKey;
+			if (!apiKey) apiKey = providerConfig?.apiKey;
+			if (typeof apiKey === "string") {
+				const envVar = `${providerId.toUpperCase()}_API_KEY`;
+				env[envVar] = apiKey;
+			}
+		}
+	}
+	const command = buildOpencodeCommand(port, directory);
+	const process = await sandbox.startProcess(command, { env: Object.keys(env).length > 0 ? env : void 0 });
+	try {
+		await process.waitForPort(port, {
+			mode: "http",
+			path: "/",
+			timeout: 6e4
+		});
+		getLogger().info("OpenCode server started successfully", {
+			port,
+			processId: process.id
+		});
+	} catch (e) {
+		const logs = await process.getLogs();
+		const error = e instanceof Error ? e : void 0;
+		getLogger().error("OpenCode server failed to start", error, {
+			port,
+			stderr: logs.stderr
+		});
+		throw new OpencodeStartupError(`OpenCode server failed to start. Stderr: ${logs.stderr || "(empty)"}`, {
+			port,
+			stderr: logs.stderr,
+			command
+		}, { cause: e });
+	}
+	return process;
+}
+/**
+* Starts an OpenCode server inside a Sandbox container.
+*
+* This function manages the server lifecycle only - use `createOpencode()` if you
+* also need a typed SDK client for programmatic access.
+*
+* 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 server handle { port, url, close() }
+*
+* @example
+* ```typescript
+* import { getSandbox } from '@cloudflare/sandbox'
+* import { createOpencodeServer } from '@cloudflare/sandbox/opencode'
+*
+* const sandbox = getSandbox(env.Sandbox, 'my-agent')
+* const server = await createOpencodeServer(sandbox, {
+*   directory: '/home/user/my-project',
+*   config: { provider: { anthropic: { options: { apiKey: env.ANTHROPIC_KEY } } } }
+* })
+*
+* // Proxy requests to the web UI
+* return sandbox.containerFetch(request, server.port)
+*
+* // When done
+* await server.close()
+* ```
+*/
+async function createOpencodeServer(sandbox, options) {
+	const port = options?.port ?? DEFAULT_PORT;
+	const process = await ensureOpencodeServer(sandbox, port, options?.directory, options?.config);
+	return {
+		port,
+		url: `http://localhost:${port}`,
+		close: () => process.kill("SIGTERM")
+	};
+}
+/**
+* Creates an OpenCode server inside a Sandbox container and returns a typed SDK client.
+*
+* 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.
+*
+* 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 } } } }
+* })
+*
+* // Use the SDK client for programmatic access
+* const session = await client.session.create()
+*
+* // When done
+* await server.close()
+* ```
+*/
+async function createOpencode(sandbox, options) {
+	await ensureSdkLoaded();
+	const server = await createOpencodeServer(sandbox, options);
+	return {
+		client: createOpencodeClient({
+			baseUrl: server.url,
+			fetch: (request) => sandbox.containerFetch(request, server.port)
+		}),
+		server
+	};
+}
+/**
+* Proxy a request to the OpenCode web UI.
+*
+* This function handles the redirect and proxying only - you must start the
+* server separately using `createOpencodeServer()`.
+*
+* 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
+*
+* @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
+*
+* @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 } } } }
+*     })
+*     return proxyToOpencode(request, sandbox, server)
+*   }
+* }
+* ```
+*/
+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);
+		}
+	}
+	return sandbox.containerFetch(request, server.port);
+}
+
+//#endregion
+export { OpencodeStartupError, createOpencode, createOpencodeServer, proxyToOpencode };
+//# sourceMappingURL=index.js.map

package/dist/opencode/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["createOpencodeClient: unknown","env: Record<string, string>"],"sources":["../../src/opencode/types.ts","../../src/opencode/opencode.ts"],"sourcesContent":["import type { Config } from '@opencode-ai/sdk';\nimport { ErrorCode, type OpencodeStartupContext } from '@repo/shared/errors';\n\n/**\n * Configuration options for starting OpenCode server\n */\nexport interface OpencodeOptions {\n  /** Port for OpenCode server (default: 4096) */\n  port?: number;\n  /** Working directory for OpenCode (default: container's cwd) */\n  directory?: string;\n  /** OpenCode configuration */\n  config?: Config;\n}\n\n/**\n * Server lifecycle management\n */\nexport interface OpencodeServer {\n  /** Port the server is running on */\n  port: number;\n  /** Base URL for SDK client (http://localhost:{port}) */\n  url: string;\n  /** Close the server gracefully */\n  close(): Promise<void>;\n}\n\n/**\n * Result from createOpencode()\n * Client type comes from @opencode-ai/sdk (user's version)\n */\nexport interface OpencodeResult<TClient = unknown> {\n  /** OpenCode SDK client with Sandbox transport */\n  client: TClient;\n  /** Server lifecycle management */\n  server: OpencodeServer;\n}\n\n/**\n * Error thrown when OpenCode server fails to start\n */\nexport class OpencodeStartupError extends Error {\n  public readonly code = ErrorCode.OPENCODE_STARTUP_FAILED;\n  public readonly context: OpencodeStartupContext;\n\n  constructor(\n    message: string,\n    context: OpencodeStartupContext,\n    options?: ErrorOptions\n  ) {\n    super(message, options);\n    this.name = 'OpencodeStartupError';\n    this.context = context;\n  }\n}\n","import type { Config } from '@opencode-ai/sdk';\nimport { createLogger, type Logger, type Process } from '@repo/shared';\nimport type { Sandbox } from '../sandbox';\nimport type { OpencodeOptions, OpencodeResult, OpencodeServer } from './types';\nimport { OpencodeStartupError } from './types';\n\n// Lazy logger creation to avoid global scope restrictions in Workers\nfunction getLogger(): Logger {\n  return createLogger({ component: 'sandbox-do', operation: 'opencode' });\n}\n\nconst DEFAULT_PORT = 4096;\nconst OPENCODE_SERVE = (port: number) =>\n  `opencode serve --port ${port} --hostname 0.0.0.0`;\n\n/**\n * Build the full command, optionally with a directory prefix.\n * If directory is provided, we cd to it first so OpenCode uses it as cwd.\n */\nfunction buildOpencodeCommand(port: number, directory?: string): string {\n  const serve = OPENCODE_SERVE(port);\n  return directory ? `cd ${directory} && ${serve}` : serve;\n}\n\n// Dynamic import to handle peer dependency\n// Using unknown since SDK is optional peer dep - cast at usage site\nlet createOpencodeClient: unknown;\n\nasync function ensureSdkLoaded(): Promise<void> {\n  if (createOpencodeClient) return;\n\n  try {\n    const sdk = await import('@opencode-ai/sdk');\n    createOpencodeClient = sdk.createOpencodeClient;\n  } catch {\n    throw new Error(\n      '@opencode-ai/sdk is required for OpenCode integration. ' +\n        'Install it with: npm install @opencode-ai/sdk'\n    );\n  }\n}\n\n/**\n * Find an existing OpenCode server process running on the specified port.\n * Returns the process if found and still active, null otherwise.\n * Matches by the serve command pattern since directory prefix may vary.\n */\nasync function findExistingOpencodeProcess(\n  sandbox: Sandbox<unknown>,\n  port: number\n): Promise<Process | null> {\n  const processes = await sandbox.listProcesses();\n  const serveCommand = OPENCODE_SERVE(port);\n\n  for (const proc of processes) {\n    // Match commands that contain the serve command (with or without cd prefix)\n    if (proc.command.includes(serveCommand)) {\n      if (proc.status === 'starting' || proc.status === 'running') {\n        return proc;\n      }\n    }\n  }\n\n  return null;\n}\n\n/**\n * Ensures OpenCode server is running in the container.\n * Reuses existing process if one is already running on the specified port.\n * Handles concurrent startup attempts gracefully by retrying on failure.\n * Returns the process handle.\n */\nasync function ensureOpencodeServer(\n  sandbox: Sandbox<unknown>,\n  port: number,\n  directory?: string,\n  config?: Config\n): Promise<Process> {\n  // Check if OpenCode is already running on this port\n  const existingProcess = await findExistingOpencodeProcess(sandbox, port);\n  if (existingProcess) {\n    // Reuse existing process - wait for it to be ready if still starting\n    if (existingProcess.status === 'starting') {\n      getLogger().debug('Found starting OpenCode process, waiting for ready', {\n        port,\n        processId: existingProcess.id\n      });\n      try {\n        await existingProcess.waitForPort(port, {\n          mode: 'http',\n          path: '/',\n          timeout: 60_000\n        });\n      } catch (e) {\n        const logs = await existingProcess.getLogs();\n        throw new OpencodeStartupError(\n          `OpenCode server failed to start. Stderr: ${logs.stderr || '(empty)'}`,\n          { port, stderr: logs.stderr, command: existingProcess.command },\n          { cause: e }\n        );\n      }\n    }\n    getLogger().debug('Reusing existing OpenCode process', {\n      port,\n      processId: existingProcess.id\n    });\n    return existingProcess;\n  }\n\n  // Try to start a new OpenCode server\n  try {\n    return await startOpencodeServer(sandbox, port, directory, config);\n  } catch (startupError) {\n    // Startup failed - check if another concurrent request started the server\n    // This handles the race condition where multiple requests try to start simultaneously\n    const retryProcess = await findExistingOpencodeProcess(sandbox, port);\n    if (retryProcess) {\n      getLogger().debug(\n        'Startup failed but found concurrent process, reusing',\n        {\n          port,\n          processId: retryProcess.id\n        }\n      );\n      // Wait for the concurrent server to be ready\n      if (retryProcess.status === 'starting') {\n        try {\n          await retryProcess.waitForPort(port, {\n            mode: 'http',\n            path: '/',\n            timeout: 60_000\n          });\n        } catch (e) {\n          const logs = await retryProcess.getLogs();\n          throw new OpencodeStartupError(\n            `OpenCode server failed to start. Stderr: ${logs.stderr || '(empty)'}`,\n            { port, stderr: logs.stderr, command: retryProcess.command },\n            { cause: e }\n          );\n        }\n      }\n      return retryProcess;\n    }\n\n    // No concurrent server found - the failure was genuine\n    throw startupError;\n  }\n}\n\n/**\n * Internal function to start a new OpenCode server process.\n */\nasync function startOpencodeServer(\n  sandbox: Sandbox<unknown>,\n  port: number,\n  directory?: string,\n  config?: Config\n): Promise<Process> {\n  getLogger().info('Starting OpenCode server', { port, directory });\n\n  // Pass config via OPENCODE_CONFIG_CONTENT and also extract API keys to env vars\n  // because OpenCode's provider auth looks for env vars like ANTHROPIC_API_KEY\n  const env: Record<string, string> = {};\n\n  if (config) {\n    env.OPENCODE_CONFIG_CONTENT = JSON.stringify(config);\n\n    // Extract API keys from provider config\n    // Support both options.apiKey (official type) and legacy top-level apiKey\n    if (\n      config.provider &&\n      typeof config.provider === 'object' &&\n      !Array.isArray(config.provider)\n    ) {\n      for (const [providerId, providerConfig] of Object.entries(\n        config.provider\n      )) {\n        // Try options.apiKey first (official Config type)\n        let apiKey = providerConfig?.options?.apiKey;\n        // Fall back to top-level apiKey for convenience\n        if (!apiKey) {\n          apiKey = (providerConfig as Record<string, unknown> | undefined)\n            ?.apiKey as string | undefined;\n        }\n        if (typeof apiKey === 'string') {\n          const envVar = `${providerId.toUpperCase()}_API_KEY`;\n          env[envVar] = apiKey;\n        }\n      }\n    }\n  }\n\n  const command = buildOpencodeCommand(port, directory);\n  const process = await sandbox.startProcess(command, {\n    env: Object.keys(env).length > 0 ? env : undefined\n  });\n\n  // Wait for server to be ready\n  try {\n    await process.waitForPort(port, {\n      mode: 'http',\n      path: '/',\n      timeout: 60_000\n    });\n    getLogger().info('OpenCode server started successfully', {\n      port,\n      processId: process.id\n    });\n  } catch (e) {\n    const logs = await process.getLogs();\n    const error = e instanceof Error ? e : undefined;\n    getLogger().error('OpenCode server failed to start', error, {\n      port,\n      stderr: logs.stderr\n    });\n    throw new OpencodeStartupError(\n      `OpenCode server failed to start. Stderr: ${logs.stderr || '(empty)'}`,\n      { port, stderr: logs.stderr, command },\n      { cause: e }\n    );\n  }\n\n  return process;\n}\n\n/**\n * Starts an OpenCode server inside a Sandbox container.\n *\n * This function manages the server lifecycle only - use `createOpencode()` if you\n * also need a typed SDK client for programmatic access.\n *\n * If an OpenCode server is already running on the specified port, this function\n * will reuse it instead of starting a new one.\n *\n * @param sandbox - The Sandbox instance to run OpenCode in\n * @param options - Configuration options\n * @returns Promise resolving to server handle { port, url, close() }\n *\n * @example\n * ```typescript\n * import { getSandbox } from '@cloudflare/sandbox'\n * import { createOpencodeServer } from '@cloudflare/sandbox/opencode'\n *\n * const sandbox = getSandbox(env.Sandbox, 'my-agent')\n * const server = await createOpencodeServer(sandbox, {\n *   directory: '/home/user/my-project',\n *   config: { provider: { anthropic: { options: { apiKey: env.ANTHROPIC_KEY } } } }\n * })\n *\n * // Proxy requests to the web UI\n * return sandbox.containerFetch(request, server.port)\n *\n * // When done\n * await server.close()\n * ```\n */\nexport async function createOpencodeServer(\n  sandbox: Sandbox<unknown>,\n  options?: OpencodeOptions\n): Promise<OpencodeServer> {\n  const port = options?.port ?? DEFAULT_PORT;\n  const process = await ensureOpencodeServer(\n    sandbox,\n    port,\n    options?.directory,\n    options?.config\n  );\n\n  return {\n    port,\n    url: `http://localhost:${port}`,\n    close: () => process.kill('SIGTERM')\n  };\n}\n\n/**\n * Creates an OpenCode server inside a Sandbox container and returns a typed SDK client.\n *\n * This function is API-compatible with OpenCode's own createOpencode(), but uses\n * Sandbox process management instead of Node.js spawn. The returned client uses\n * a custom fetch adapter to route requests through the Sandbox container.\n *\n * If an OpenCode server is already running on the specified port, this function\n * will reuse it instead of starting a new one.\n *\n * @param sandbox - The Sandbox instance to run OpenCode in\n * @param options - Configuration options\n * @returns Promise resolving to { client, server }\n *\n * @example\n * ```typescript\n * import { getSandbox } from '@cloudflare/sandbox'\n * import { createOpencode } from '@cloudflare/sandbox/opencode'\n *\n * const sandbox = getSandbox(env.Sandbox, 'my-agent')\n * const { client, server } = await createOpencode(sandbox, {\n *   directory: '/home/user/my-project',\n *   config: { provider: { anthropic: { options: { apiKey: env.ANTHROPIC_KEY } } } }\n * })\n *\n * // Use the SDK client for programmatic access\n * const session = await client.session.create()\n *\n * // When done\n * await server.close()\n * ```\n */\nexport async function createOpencode<TClient = unknown>(\n  sandbox: Sandbox<unknown>,\n  options?: OpencodeOptions\n): Promise<OpencodeResult<TClient>> {\n  await ensureSdkLoaded();\n\n  const server = await createOpencodeServer(sandbox, options);\n\n  // Create SDK client with Sandbox transport\n  // Cast from unknown - SDK is optional peer dependency loaded dynamically\n  const clientFactory = createOpencodeClient as (options: {\n    baseUrl: string;\n    fetch: (request: Request) => Promise<Response>;\n  }) => TClient;\n\n  const client = clientFactory({\n    baseUrl: server.url,\n    fetch: (request: Request) => sandbox.containerFetch(request, server.port)\n  });\n\n  return { client, server };\n}\n\n/**\n * Proxy a request to the OpenCode web UI.\n *\n * This function handles the redirect and proxying only - you must start the\n * server separately using `createOpencodeServer()`.\n *\n * Specifically handles:\n * 1. Ensuring the `?url=` parameter is set (required for OpenCode's frontend to\n *    make API calls through the proxy instead of directly to localhost:4096)\n * 2. Proxying the request to the container\n *\n * @param request - The incoming HTTP request\n * @param sandbox - The Sandbox instance running OpenCode\n * @param server - The OpenCode server handle from createOpencodeServer()\n * @returns Response from OpenCode or a redirect response\n *\n * @example\n * ```typescript\n * import { getSandbox } from '@cloudflare/sandbox'\n * import { createOpencodeServer, proxyToOpencode } from '@cloudflare/sandbox/opencode'\n *\n * export default {\n *   async fetch(request: Request, env: Env) {\n *     const sandbox = getSandbox(env.Sandbox, 'opencode')\n *     const server = await createOpencodeServer(sandbox, {\n *       directory: '/home/user/project',\n *       config: { provider: { anthropic: { options: { apiKey: env.ANTHROPIC_KEY } } } }\n *     })\n *     return proxyToOpencode(request, sandbox, server)\n *   }\n * }\n * ```\n */\nexport function proxyToOpencode(\n  request: Request,\n  sandbox: Sandbox<unknown>,\n  server: OpencodeServer\n): Response | Promise<Response> {\n  const url = new URL(request.url);\n\n  // OpenCode's frontend defaults to http://127.0.0.1:4096 when hostname includes\n  // \"localhost\" or \"opencode.ai\". The ?url= parameter overrides this behavior.\n  // We only redirect GET requests for HTML pages (initial page load).\n  // API calls (POST, PATCH, etc.) and asset requests are proxied directly\n  // since redirecting POST loses the request body.\n  if (!url.searchParams.has('url') && request.method === 'GET') {\n    const accept = request.headers.get('accept') || '';\n    const isHtmlRequest = accept.includes('text/html') || url.pathname === '/';\n    if (isHtmlRequest) {\n      url.searchParams.set('url', url.origin);\n      return Response.redirect(url.toString(), 302);\n    }\n  }\n\n  return sandbox.containerFetch(request, server.port);\n}\n"],"mappings":"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"}

package/dist/{sandbox-bAj-cB2H.d.ts → sandbox-C9WRqWBO.d.ts}

@@ -1772,7 +1772,7 @@ declare class Sandbox<Env = unknown> extends Container<Env> implements ISandbox
   streamProcessLogs(processId: string, options?: {
     signal?: AbortSignal;
   }): Promise<ReadableStream<Uint8Array>>;
-  gitCheckout(repoUrl: string, options: {
+  gitCheckout(repoUrl: string, options?: {
     branch?: string;
     targetDir?: string;
     sessionId?: string;
@@ -1865,4 +1865,4 @@ declare class Sandbox<Env = unknown> extends Container<Env> implements ISandbox
 }
 //#endregion
 export { ProcessInfoResult as $, RequestConfig as A, FileChunk as B, WriteFileRequest as C, ContainerStub as D, BaseApiResponse as E, BucketProvider as F, ListFilesOptions as G, FileStreamEvent as H, ExecEvent as I, PortCloseResult as J, LogEvent as K, ExecOptions as L, SessionRequest as M, BaseExecOptions as N, ErrorResponse as O, BucketCredentials as P, ProcessCleanupResult as Q, ExecResult as R, ReadFileRequest as S, ExecuteResponse as T, GitCheckoutResult as U, FileMetadata as V, ISandbox as W, PortListResult as X, PortExposeResult as Y, Process as Z, GitCheckoutRequest as _, ExecutionResult as _t, CreateSessionRequest as a, ProcessStatus as at, FileOperationRequest as b, DeleteSessionResponse as c, StreamOptions as ct, ProcessClient as d, isExecResult as dt, ProcessKillResult as et, ExposePortRequest as f, isProcess as ft, InterpreterClient as g, Execution as gt, ExecutionCallbacks as h, CreateContextOptions as ht, CommandsResponse as i, ProcessStartResult as it, ResponseHandler as j, HttpClientOptions as k, PingResponse as l, WaitForLogResult as lt, UnexposePortRequest as m, CodeContext as mt, getSandbox as n, ProcessLogsResult as nt, CreateSessionResponse as o, SandboxOptions as ot, PortClient as p, isProcessStatus as pt, MountBucketOptions as q, SandboxClient as r, ProcessOptions as rt, DeleteSessionRequest as s, SessionOptions as st, Sandbox as t, ProcessListResult as tt, UtilityClient as u, WaitForPortOptions as ut, GitClient as v, RunCodeOptions as vt, CommandClient as w, MkdirRequest as x, FileClient as y, ExecutionSession as z };
-//# sourceMappingURL=sandbox-bAj-cB2H.d.ts.map
+//# sourceMappingURL=sandbox-C9WRqWBO.d.ts.map