@cloudflare/sandbox 0.13.0-next.769.1 → 1.0.0-rc.0

package/dist/opencode/index.js

@@ -1,454 +0,0 @@
-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 ../../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 {
-	code = ErrorCode.OPENCODE_STARTUP_FAILED;
-	context;
-	constructor(message, context, options) {
-		super(message, options);
-		this.name = "OpenCodeStartupError";
-		this.context = context;
-	}
-};
-
-//#endregion
-//#region ../../extensions/opencode/src/opencode.ts
-function getLogger() {
-	return createLogger({
-		component: "sandbox-do",
-		operation: "opencode"
-	});
-}
-const DEFAULT_PORT$1 = 4096;
-const OPENCODE_STARTUP_TIMEOUT_MS = 18e4;
-function openCodeCommand(port) {
-	return [
-		"opencode",
-		"serve",
-		"--port",
-		String(port),
-		"--hostname",
-		"0.0.0.0"
-	];
-}
-function commandsEqual(a, b) {
-	return a.length === b.length && a.every((value, index) => value === b[index]);
-}
-/** 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();
-	}
-}
-/**
-* 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, customEnv) {
-	const existingProcess = await findExistingOpenCodeProcess(sandbox, port, directory);
-	if (existingProcess) {
-		getLogger().debug("Reusing existing OpenCode process", {
-			port,
-			processId: existingProcess.id
-		});
-		return existingProcess;
-	}
-	try {
-		return await startOpenCodeServer(sandbox, port, directory, config, customEnv);
-	} catch (startupError) {
-		const retryProcess = await findExistingOpenCodeProcess(sandbox, port, directory);
-		if (retryProcess) {
-			getLogger().debug("Startup failed but found concurrent process, reusing", {
-				port,
-				processId: retryProcess.id
-			});
-			return retryProcess;
-		}
-		throw startupError;
-	}
-}
-/**
-* Internal function to start a new OpenCode server process.
-*/
-async function startOpenCodeServer(sandbox, port, directory, config, customEnv) {
-	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)) {
-				if (providerId === "cloudflare-ai-gateway") continue;
-				let apiKey = providerConfig?.options?.apiKey;
-				if (!apiKey) apiKey = providerConfig?.apiKey;
-				if (typeof apiKey === "string") {
-					const envVar = `${providerId.toUpperCase()}_API_KEY`;
-					env[envVar] = apiKey;
-				}
-			}
-			const aiGatewayConfig = config.provider["cloudflare-ai-gateway"];
-			if (aiGatewayConfig?.options) {
-				const options = aiGatewayConfig.options;
-				if (typeof options.accountId === "string") env.CLOUDFLARE_ACCOUNT_ID = options.accountId;
-				if (typeof options.gatewayId === "string") env.CLOUDFLARE_GATEWAY_ID = options.gatewayId;
-				if (typeof options.apiToken === "string") env.CLOUDFLARE_API_TOKEN = options.apiToken;
-			}
-		}
-	}
-	if (customEnv) Object.assign(env, customEnv);
-	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",
-			path: "/path",
-			status: 200,
-			timeout: OPENCODE_STARTUP_TIMEOUT_MS
-		});
-		getLogger().info("OpenCode server started successfully", {
-			port,
-			processId: process.id
-		});
-	} catch (e) {
-		const stderr = await collectStderr(process);
-		const error = e instanceof Error ? e : void 0;
-		getLogger().error("OpenCode server failed to start", error, {
-			port,
-			stderr
-		});
-		throw new OpenCodeStartupError(`OpenCode server failed to start. Stderr: ${stderr || "(empty)"}`, {
-			port,
-			stderr,
-			command: command.join(" ")
-		}, { cause: e });
-	}
-	return process;
-}
-/**
-* Starts an OpenCode server inside a Sandbox container.
-*
-* 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
-* 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 }
-*       },
-*       // 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': {} }
-*       // }
-*     }
-*   }
-* })
-*
-* // 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$1;
-	const process = await ensureOpenCodeServer(sandbox, port, options?.directory, options?.config, options?.env);
-	return {
-		port,
-		url: `http://localhost:${port}`,
-		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";
-}
-/**
-* DO-resident lifecycle handle for an OpenCode server. Owns the durable
-* `opencode serve` process: start/reuse, stop, status, and request proxying.
-*
-* 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.
-*
-* 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 })`.
-*
-* Pass `storage` to persist desired-state so the server is recovered after a DO
-* eviction (cold start). The server starts lazily on first use.
-*/
-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 to the OpenCode web UI through a lifecycle handle.
-*
-* 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 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);
-}
-/**
-* Curried Worker fetch wrapper for OpenCode.
-*
-* `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.
-*
-* 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.
-*
-* ```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 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);
-		}
-	});
-}
-
-//#endregion
-export { OpenCodeHandle, OpenCodeStartupError, createOpenCodeClient, createOpenCodeProxy, proxyToOpenCodeUI, withOpenCode };
-//# sourceMappingURL=index.js.map

package/dist/opencode/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["createSDKClient: OpenCodeClientFactory | undefined","DEFAULT_PORT","env: Record<string, string>","#sandbox","#defaults","#storage","#stateKey","#lastOptions","#loadPersisted","#persist","server: OpenCodeServer","#server"],"sources":["../../../../extensions/opencode/src/client.ts","../../../../extensions/opencode/src/types.ts","../../../../extensions/opencode/src/opencode.ts","../../../../extensions/opencode/src/lifecycle.ts","../../../../extensions/opencode/src/proxy.ts"],"sourcesContent":["import type { OpencodeClient } from '@opencode-ai/sdk/v2/client';\nimport type { OpenCodeHandle } from './lifecycle';\nimport type { OpenCodeOptions } from './types';\n\ntype OpenCodeClientFactory = (options: {\n  baseUrl: string;\n  fetch: typeof fetch;\n  directory?: string;\n}) => OpencodeClient;\n\nlet createSDKClient: OpenCodeClientFactory | undefined;\n\nasync function loadSDK(): Promise<OpenCodeClientFactory> {\n  if (createSDKClient) return createSDKClient;\n  try {\n    const sdk = await import('@opencode-ai/sdk/v2/client');\n    createSDKClient = sdk.createOpencodeClient as OpenCodeClientFactory;\n    return createSDKClient;\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 * Build a typed OpenCode SDK client from a lifecycle handle.\n *\n * Works against either the Worker stub (`sandbox.opencode`) or the in-DO object\n * (`this.opencode`): it ensures the server through the handle, reads the stored\n * config, and routes every request through `handle.fetch`. Because the handle\n * owns `containerFetch`, this helper never touches sandbox transport directly.\n *\n * The SDK is imported lazily so the peer dependency is only required when an\n * OpenCode client is actually built.\n */\nexport async function createOpenCodeClient<TClient = OpencodeClient>(\n  handle: OpenCodeHandle,\n  options?: OpenCodeOptions\n): Promise<TClient> {\n  const server = await handle.start(options);\n  const config = await handle.config();\n  const directory = options?.directory ?? config.directory;\n\n  const factory = await loadSDK();\n  const client = factory({\n    baseUrl: server.url,\n    fetch: (input, init) => handle.fetch(new Request(input, init)),\n    directory\n  });\n\n  return client as TClient;\n}\n","import type { Config } from '@opencode-ai/sdk/v2';\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  /** Additional environment variables to pass to the OpenCode process */\n  env?: Record<string, string>;\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 * 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 {\n  createExtensionProcessSandbox,\n  type SandboxLike\n} from '@cloudflare/sandbox/extensions';\nimport type { Config } from '@opencode-ai/sdk/v2';\nimport {\n  createLogger,\n  type Logger,\n  type SandboxCommand,\n  type SandboxProcess\n} from '@repo/shared';\nimport type { OpenCodeOptions, 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\nexport interface OpenCodeSandboxLike extends SandboxLike {\n  exec: NonNullable<SandboxLike['exec']>;\n  getProcess: NonNullable<SandboxLike['getProcess']>;\n  listProcesses: NonNullable<SandboxLike['listProcesses']>;\n  containerFetch(request: Request, port: number): Promise<Response>;\n}\n\nconst DEFAULT_PORT = 4096;\nconst OPENCODE_STARTUP_TIMEOUT_MS = 180_000;\nfunction openCodeCommand(port: number): SandboxCommand {\n  return ['opencode', 'serve', '--port', String(port), '--hostname', '0.0.0.0'];\n}\n\nfunction commandsEqual(a: SandboxCommand, b: SandboxCommand): boolean {\n  return a.length === b.length && a.every((value, index) => value === b[index]);\n}\n\n/** Recover a running OpenCode process from runtime-local process status. */\nexport async function findExistingOpenCodeProcess(\n  sandbox: OpenCodeSandboxLike,\n  port: number,\n  directory?: string\n): Promise<SandboxProcess | null> {\n  const command = openCodeCommand(port);\n  const processes = createExtensionProcessSandbox(sandbox);\n  const status = (await processes.listProcesses()).find(\n    (candidate) =>\n      candidate.state === 'running' &&\n      candidate.cwd === directory &&\n      commandsEqual(candidate.command, command)\n  );\n  return status ? processes.getProcess(status.id) : null;\n}\n\nasync function collectStderr(process: SandboxProcess): Promise<string> {\n  const stream = await process.logs({ replay: true, follow: false });\n  const reader = stream.getReader();\n  const decoder = new TextDecoder();\n  let stderr = '';\n  try {\n    while (true) {\n      const { done, value } = await reader.read();\n      if (done) break;\n      if (value.type === 'stderr') {\n        stderr += decoder.decode(value.data, { stream: true });\n      }\n    }\n    return stderr + decoder.decode();\n  } finally {\n    reader.releaseLock();\n  }\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: OpenCodeSandboxLike,\n  port: number,\n  directory?: string,\n  config?: Config,\n  customEnv?: Record<string, string>\n): Promise<SandboxProcess> {\n  const existingProcess = await findExistingOpenCodeProcess(\n    sandbox,\n    port,\n    directory\n  );\n  if (existingProcess) {\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(\n      sandbox,\n      port,\n      directory,\n      config,\n      customEnv\n    );\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(\n      sandbox,\n      port,\n      directory\n    );\n    if (retryProcess) {\n      getLogger().debug(\n        'Startup failed but found concurrent process, reusing',\n        { port, processId: retryProcess.id }\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: OpenCodeSandboxLike,\n  port: number,\n  directory?: string,\n  config?: Config,\n  customEnv?: Record<string, string>\n): Promise<SandboxProcess> {\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        if (providerId === 'cloudflare-ai-gateway') {\n          continue;\n        }\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      const aiGatewayConfig = config.provider['cloudflare-ai-gateway'];\n      if (aiGatewayConfig?.options) {\n        const options = aiGatewayConfig.options as Record<string, unknown>;\n\n        if (typeof options.accountId === 'string') {\n          env.CLOUDFLARE_ACCOUNT_ID = options.accountId;\n        }\n\n        if (typeof options.gatewayId === 'string') {\n          env.CLOUDFLARE_GATEWAY_ID = options.gatewayId;\n        }\n\n        if (typeof options.apiToken === 'string') {\n          env.CLOUDFLARE_API_TOKEN = options.apiToken;\n        }\n      }\n    }\n  }\n\n  // Custom env vars override config-extracted ones\n  if (customEnv) {\n    Object.assign(env, customEnv);\n  }\n\n  const command = openCodeCommand(port);\n  const process = await createExtensionProcessSandbox(sandbox).exec(command, {\n    cwd: directory,\n    env: Object.keys(env).length > 0 ? env : undefined\n  });\n\n  // Wait for server to be ready - check the actual health endpoint\n  try {\n    await process.waitForPort(port, {\n      mode: 'http',\n      path: '/path',\n      status: 200,\n      timeout: OPENCODE_STARTUP_TIMEOUT_MS\n    });\n    getLogger().info('OpenCode server started successfully', {\n      port,\n      processId: process.id\n    });\n  } catch (e) {\n    const stderr = await collectStderr(process);\n    const error = e instanceof Error ? e : undefined;\n    getLogger().error('OpenCode server failed to start', error, {\n      port,\n      stderr\n    });\n    throw new OpenCodeStartupError(\n      `OpenCode server failed to start. Stderr: ${stderr || '(empty)'}`,\n      { port, stderr, command: command.join(' ') },\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 `createOpenCodeClient()` 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: {\n *     provider: {\n *       anthropic: {\n *         options: { apiKey: env.ANTHROPIC_KEY }\n *       },\n *       // Or use Cloudflare AI Gateway (with unified billing, no provider keys needed).\n *       // 'cloudflare-ai-gateway': {\n *       //   options: {\n *       //     accountId: env.CF_ACCOUNT_ID,\n *       //     gatewayId: env.CF_GATEWAY_ID,\n *       //     apiToken: env.CF_API_TOKEN\n *       //   },\n *       //   models: { 'anthropic/claude-sonnet-4-5-20250929': {} }\n *       // }\n *     }\n *   }\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: OpenCodeSandboxLike,\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    options?.env\n  );\n\n  return {\n    port,\n    url: `http://localhost:${port}`,\n    close: async () => {\n      await process.kill(15);\n      await process.waitForExit().catch(() => {\n        /* exit observed */\n      });\n    }\n  };\n}\n\n/**\n * Proxy a request directly to the OpenCode server.\n *\n * Unlike `proxyToOpenCode()`, this helper does not apply any web UI redirects\n * or query parameter rewrites. Use it for API/CLI traffic where raw request\n * forwarding is preferred.\n */\nexport function proxyToOpenCodeServer(\n  request: Request,\n  sandbox: OpenCodeSandboxLike,\n  server: OpenCodeServer\n): Promise<Response> {\n  return sandbox.containerFetch(request, server.port);\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: {\n *         provider: {\n *           anthropic: {\n *             options: { apiKey: env.ANTHROPIC_KEY }\n *           },\n *           // Optional: Route all providers through Cloudflare AI Gateway\n *           'cloudflare-ai-gateway': {\n *             options: {\n *               accountId: env.CF_ACCOUNT_ID,\n *               gatewayId: env.CF_GATEWAY_ID,\n *               apiToken: env.CF_API_TOKEN\n *             }\n *           }\n *         }\n *       }\n *     })\n *     return proxyToOpenCode(request, sandbox, server)\n *   }\n * }\n * ```\n */\nexport function proxyToOpenCode(\n  request: Request,\n  sandbox: OpenCodeSandboxLike,\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 proxyToOpenCodeServer(request, sandbox, server);\n}\n","import {\n  SandboxExtension,\n  type SandboxLike\n} from '@cloudflare/sandbox/extensions';\nimport {\n  createOpenCodeServer,\n  findExistingOpenCodeProcess,\n  type OpenCodeSandboxLike\n} from './opencode';\nimport type { OpenCodeOptions, OpenCodeServer } from './types';\n\nconst DEFAULT_PORT = 4096;\n\n/** Resolved server metadata that is safe to return across the RPC boundary. */\nexport interface OpenCodeServerInfo {\n  port: number;\n  url: string;\n}\n\n/** Snapshot of the resolved lifecycle configuration. */\nexport interface OpenCodeConfig {\n  port: number;\n  directory?: string;\n}\n\n/** Current server status as observed in the container. */\nexport interface OpenCodeStatus extends OpenCodeServerInfo {\n  running: boolean;\n}\n\n/**\n * The slice of `DurableObjectStorage` the handle uses to persist desired-state.\n * Pass `this.ctx.storage` so the server config survives a Durable Object\n * eviction (cold start) and is recovered lazily on the next `start()`.\n */\nexport interface OpenCodeStateStorage {\n  get<T>(key: string): Promise<T | undefined>;\n  put<T>(key: string, value: T): Promise<void>;\n}\n\n/** Options for {@link withOpenCode}: server defaults plus optional storage. */\nexport interface WithOpenCodeOptions extends OpenCodeOptions {\n  /** Persist desired-state here so it survives DO eviction. */\n  storage?: OpenCodeStateStorage;\n}\n\nconst STATE_KEY_PREFIX = 'opencode:desired-state:';\n\n/** Recognise the retryable container-unavailable error across RPC. */\nfunction isContainerUnavailable(error: unknown): boolean {\n  if (typeof error !== 'object' || error === null) return false;\n  return (error as { name?: unknown }).name === 'ContainerUnavailableError';\n}\n\n/**\n * DO-resident lifecycle handle for an OpenCode server. Owns the durable\n * `opencode serve` process: start/reuse, stop, status, and request proxying.\n *\n * It extends {@link SandboxExtension}, so the DO stub exposes it as\n * `sandbox.opencode` and method calls dispatch through `callExtension` — the\n * same path the interpreter extension uses. `createOpenCodeClient` consumes the\n * same handle from either the Worker stub or the in-DO object.\n *\n * The server starts lazily: nothing runs until `start()` (or `fetch()`, which\n * calls it) is invoked. To start optimistically, call `opencode.start()` from\n * your Sandbox subclass's `onStart`.\n */\nexport class OpenCodeHandle extends SandboxExtension {\n  readonly #sandbox: OpenCodeSandboxLike;\n  readonly #defaults: OpenCodeOptions;\n  readonly #storage: OpenCodeStateStorage | undefined;\n  readonly #stateKey: string;\n  #server: OpenCodeServer | undefined;\n  #lastOptions: OpenCodeOptions | undefined;\n\n  constructor(\n    sandbox: OpenCodeSandboxLike,\n    defaults: OpenCodeOptions = {},\n    storage?: OpenCodeStateStorage,\n    stateIndex = 0\n  ) {\n    super(sandbox as SandboxLike);\n    this.#sandbox = sandbox;\n    this.#defaults = defaults;\n    this.#storage = storage;\n    this.#stateKey = `${STATE_KEY_PREFIX}${stateIndex}`;\n  }\n\n  /**\n   * Start or reuse the OpenCode server, returning RPC-safe metadata. With no\n   * options it reuses the last-used config, recovering persisted desired-state\n   * after a cold start. Retries once on a transient `CONTAINER_UNAVAILABLE`\n   * (e.g. a rollout in flight).\n   */\n  async start(options?: OpenCodeOptions): Promise<OpenCodeServerInfo> {\n    const recovered =\n      options ?? this.#lastOptions ?? (await this.#loadPersisted());\n    const resolved = { ...this.#defaults, ...recovered };\n    this.#lastOptions = resolved;\n    await this.#persist(resolved);\n\n    let server: OpenCodeServer;\n    try {\n      server = await createOpenCodeServer(this.#sandbox, resolved);\n    } catch (error) {\n      if (!isContainerUnavailable(error)) throw error;\n      server = await createOpenCodeServer(this.#sandbox, resolved);\n    }\n\n    this.#server = server;\n    return { port: server.port, url: server.url };\n  }\n\n  /** Stop the running server, if one was started through this handle. */\n  async stop(): Promise<void> {\n    if (!this.#server) return;\n    await this.#server.close();\n    this.#server = undefined;\n  }\n\n  /** Report whether the named OpenCode server is currently running. */\n  async status(): Promise<OpenCodeStatus> {\n    const resolved = { ...this.#defaults, ...this.#lastOptions };\n    const port = resolved.port ?? DEFAULT_PORT;\n    const process = await findExistingOpenCodeProcess(\n      this.#sandbox,\n      port,\n      resolved.directory\n    );\n    return {\n      running: process !== null,\n      port,\n      url: `http://localhost:${port}`\n    };\n  }\n\n  /** Snapshot of the resolved configuration the client builder reads. */\n  async config(): Promise<OpenCodeConfig> {\n    const resolved = { ...this.#defaults, ...this.#lastOptions };\n    return {\n      port: resolved.port ?? DEFAULT_PORT,\n      directory: resolved.directory\n    };\n  }\n\n  /**\n   * Start the server then route a request into the container. This is the\n   * transport the SDK client's `fetch` adapter and the Worker proxy use, so it\n   * works identically from the Worker stub (one RPC hop) or in-DO (local).\n   */\n  async fetch(request: Request): Promise<Response> {\n    const server = await this.start();\n    return this.#sandbox.containerFetch(request, server.port);\n  }\n\n  /**\n   * Persist resolved desired-state so a cold DO can recover it. Best-effort.\n   *\n   * Secret-bearing fields (`config`, `env`) are never written to storage. They\n   * are sourced fresh from the handle's defaults — which the Sandbox rebuilds\n   * from the environment on every construction — so a cold start always uses\n   * current credentials rather than a durable copy.\n   */\n  async #persist(options: OpenCodeOptions): Promise<void> {\n    if (!this.#storage) return;\n    const { config: _config, env: _env, ...safe } = options;\n    await this.#storage.put(this.#stateKey, safe);\n  }\n\n  /** Read persisted desired-state, if any, after a DO eviction. */\n  async #loadPersisted(): Promise<OpenCodeOptions | undefined> {\n    if (!this.#storage) return undefined;\n    return this.#storage.get<OpenCodeOptions>(this.#stateKey);\n  }\n}\n\n/**\n * Assigns each handle a stable per-sandbox index so its persisted state key is\n * deterministic across DO reconstruction (field initializers run in the same\n * order each time). Keyed weakly so it is collected with the sandbox.\n */\nconst stateIndexCounter = new WeakMap<OpenCodeSandboxLike, number>();\n\n/**\n * Factory — attach as a field on a Sandbox subclass:\n * `opencode = withOpenCode(this, { directory, config, storage: this.ctx.storage })`.\n *\n * Pass `storage` to persist desired-state so the server is recovered after a DO\n * eviction (cold start). The server starts lazily on first use.\n */\nexport function withOpenCode(\n  sandbox: OpenCodeSandboxLike,\n  options: WithOpenCodeOptions = {}\n): OpenCodeHandle {\n  const { storage, ...defaults } = options;\n  const index = stateIndexCounter.get(sandbox) ?? 0;\n  stateIndexCounter.set(sandbox, index + 1);\n  return new OpenCodeHandle(sandbox, defaults, storage, index);\n}\n","import type { OpenCodeHandle } from './lifecycle';\n\n/** Configuration for {@link createOpenCodeProxy}. */\nexport interface OpenCodeProxyOptions {\n  /** Origin the OpenCode web UI should call back through. Defaults to the request origin. */\n  callbackOrigin?: string;\n}\n\n/**\n * Proxy a request to the OpenCode web UI through a lifecycle handle.\n *\n * For an initial HTML page load that still lacks the `?url=` parameter, returns\n * a redirect that adds it (so the OpenCode frontend calls back through the\n * proxy instead of `127.0.0.1:4096`). Every other request is routed through\n * `handle.fetch`, which ensures the server is running before forwarding into the\n * container.\n */\nexport function proxyToOpenCodeUI(\n  request: Request,\n  handle: OpenCodeHandle,\n  options?: OpenCodeProxyOptions\n): Response | Promise<Response> {\n  const url = new URL(request.url);\n\n  // OpenCode's frontend defaults its API base to 127.0.0.1:4096; the ?url=\n  // parameter overrides that. Only redirect initial HTML GET loads — redirecting\n  // a POST would drop the 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', options?.callbackOrigin ?? url.origin);\n      return Response.redirect(url.toString(), 302);\n    }\n  }\n\n  // Ensure-then-forward: the handle starts the server on demand before proxying.\n  return handle.fetch(request);\n}\n\n/**\n * Curried Worker fetch wrapper for OpenCode.\n *\n * `createOpenCodeProxy(resolve, options?)` captures a lazy per-request resolver\n * for the OpenCode lifecycle handle (`sandbox.opencode`) and returns a function\n * that wraps the user's worker entrypoint.\n *\n * The wrapped handler runs first. If it returns a 404 (or has no `fetch`), the\n * request falls through to the OpenCode web-UI proxy — the redirect handshake\n * for HTML loads and an ensure-then-forward into the container for everything\n * else. A 404 from the user handler is the \"not mine, proxy it\" signal, so the\n * handler only needs to own its own routes and `return new Response('Not\n * found', { status: 404 })` for the rest.\n *\n * ```ts\n * export default createOpenCodeProxy(\n *   (env) => getSandbox(env.Sandbox, 'my-sandbox').opencode\n * )({\n *   async fetch(request, env) {\n *     // handle your own routes, else:\n *     return new Response('Not found', { status: 404 });\n *   }\n * });\n * ```\n */\nexport function createOpenCodeProxy<Env>(\n  resolve: (env: Env) => OpenCodeHandle,\n  options?: OpenCodeProxyOptions\n): (handler: ExportedHandler<Env>) => ExportedHandler<Env> {\n  return (handler) => ({\n    ...handler,\n    async fetch(request, env, ctx) {\n      if (handler.fetch) {\n        const response = await handler.fetch(request, env, ctx);\n        if (response.status !== 404) return response;\n      }\n      return proxyToOpenCodeUI(request, resolve(env), options);\n    }\n  });\n}\n"],"mappings":"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"}

package/dist/process-types-GStiZ8f8.d.ts

@@ -1,73 +0,0 @@
-//#region ../shared/dist/process-types.d.ts
-type SandboxCommand = readonly [executable: string, ...args: string[]];
-/**
- * Terminal outcome observed for the root subprocess.
- *
- * The process resource remains running until its supervised process group has
- * settled. Signals delivered only to descendants do not rewrite this outcome.
- */
-interface ProcessExit {
-  code: number;
-  signal?: number;
-  timedOut: boolean;
-}
-interface ProcessFailure {
-  code: string;
-  message: string;
-}
-interface ProcessStatusBase {
-  id: string;
-  pid: number;
-  command: SandboxCommand;
-  cwd?: string;
-  startedAt: string;
-}
-/** Lifecycle state for the complete supervised process group. */
-type ProcessStatus = (ProcessStatusBase & {
-  state: 'running';
-}) | (ProcessStatusBase & {
-  state: 'exited';
-  exit: ProcessExit;
-  endedAt: string;
-}) | (ProcessStatusBase & {
-  state: 'error';
-  error: ProcessFailure;
-  endedAt: string;
-});
-type ProcessLogCursor = string;
-type ProcessLogEvent = {
-  type: 'stdout' | 'stderr';
-  cursor: ProcessLogCursor;
-  timestamp: string;
-  data: Uint8Array;
-} | {
-  type: 'terminal';
-  state: 'exited';
-  cursor: ProcessLogCursor;
-  timestamp: string;
-  exit: ProcessExit;
-} | {
-  type: 'terminal';
-  state: 'error';
-  cursor: ProcessLogCursor;
-  timestamp: string;
-  error: ProcessFailure;
-} | {
-  type: 'truncated';
-  cursor?: ProcessLogCursor;
-  timestamp: string;
-};
-interface WaitForLogResult {
-  stream: 'stdout' | 'stderr';
-  text: string;
-  match: string;
-  cursor?: ProcessLogCursor;
-}
-interface ProcessLogsRPCOptions {
-  since?: ProcessLogCursor;
-  replay?: boolean;
-  follow?: boolean;
-}
-//#endregion
-export { ProcessLogsRPCOptions as a, WaitForLogResult as c, ProcessLogEvent as i, ProcessFailure as n, ProcessStatus as o, ProcessLogCursor as r, SandboxCommand as s, ProcessExit as t };
-//# sourceMappingURL=process-types-GStiZ8f8.d.ts.map

package/dist/process-types-GStiZ8f8.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"process-types-GStiZ8f8.d.ts","names":["SandboxCommand","ProcessExit","ProcessFailure","ProcessStatusBase","ProcessStatus","ProcessLogCursor","ProcessLogEvent","Uint8Array","WaitForLogResult","ProcessStartOptions","Record","ProcessLogsRPCOptions","ProcessLogSubscriptionAPI","ReadableStream","Promise","SandboxProcessesAPI"],"sources":["../../shared/dist/process-types.d.ts"],"sourcesContent":["export type SandboxCommand = readonly [executable: string, ...args: string[]];\n/**\n * Terminal outcome observed for the root subprocess.\n *\n * The process resource remains running until its supervised process group has\n * settled. Signals delivered only to descendants do not rewrite this outcome.\n */\nexport interface ProcessExit {\n    code: number;\n    signal?: number;\n    timedOut: boolean;\n}\nexport interface ProcessFailure {\n    code: string;\n    message: string;\n}\ninterface ProcessStatusBase {\n    id: string;\n    pid: number;\n    command: SandboxCommand;\n    cwd?: string;\n    startedAt: string;\n}\n/** Lifecycle state for the complete supervised process group. */\nexport type ProcessStatus = (ProcessStatusBase & {\n    state: 'running';\n}) | (ProcessStatusBase & {\n    state: 'exited';\n    exit: ProcessExit;\n    endedAt: string;\n}) | (ProcessStatusBase & {\n    state: 'error';\n    error: ProcessFailure;\n    endedAt: string;\n});\nexport type ProcessLogCursor = string;\nexport type ProcessLogEvent = {\n    type: 'stdout' | 'stderr';\n    cursor: ProcessLogCursor;\n    timestamp: string;\n    data: Uint8Array;\n} | {\n    type: 'terminal';\n    state: 'exited';\n    cursor: ProcessLogCursor;\n    timestamp: string;\n    exit: ProcessExit;\n} | {\n    type: 'terminal';\n    state: 'error';\n    cursor: ProcessLogCursor;\n    timestamp: string;\n    error: ProcessFailure;\n} | {\n    type: 'truncated';\n    cursor?: ProcessLogCursor;\n    timestamp: string;\n};\nexport interface WaitForLogResult {\n    stream: 'stdout' | 'stderr';\n    text: string;\n    match: string;\n    cursor?: ProcessLogCursor;\n}\nexport interface ProcessStartOptions {\n    cwd?: string;\n    env?: Record<string, string>;\n    timeout?: number;\n}\nexport interface ProcessLogsRPCOptions {\n    since?: ProcessLogCursor;\n    replay?: boolean;\n    follow?: boolean;\n}\nexport interface ProcessLogSubscriptionAPI {\n    stream(): Promise<ReadableStream<ProcessLogEvent>>;\n    cancel(): Promise<void>;\n    [Symbol.dispose](): void;\n}\nexport interface SandboxProcessesAPI {\n    start(command: SandboxCommand, options?: ProcessStartOptions): Promise<ProcessStatus>;\n    get(id: string): Promise<ProcessStatus | null>;\n    list(): Promise<ProcessStatus[]>;\n    openLogs(id: string, options?: ProcessLogsRPCOptions): Promise<ProcessLogSubscriptionAPI>;\n    kill(id: string, signal?: number): Promise<void>;\n    hasActive(): Promise<boolean>;\n}\nexport {};\n//# sourceMappingURL=process-types.d.ts.map"],"mappings":";KAAYA,cAAAA;AAAZ;AAOA;AAKA;AAGC;AASD;;AAEMG,UAnBWF,WAAAA,CAmBXE;EAEIF,IAAAA,EAAAA,MAAAA;EAEJE,MAAAA,CAAAA,EAAAA,MAAAA;EAEKD,QAAAA,EAAAA,OAAAA;;AAGCG,UAvBKH,cAAAA,CAuBW;EAChBI,IAAAA,EAAAA,MAAAA;EAEAD,OAAAA,EAAAA,MAAAA;;UAtBFF,iBAAAA,CA4BEE;EAEFJ,EAAAA,EAAAA,MAAAA;EAIEI,GAAAA,EAAAA,MAAAA;EAEDH,OAAAA,EAjCEF,cAiCFE;EAGEG,GAAAA,CAAAA,EAAAA,MAAAA;EAAgB,SAAA,EAAA,MAAA;AAG7B;AAWA;KA7CYD,aAAAA,IAAiBD;;MAEvBA;;QAEIF;;MAEJE;;SAEKD;;;KAGCG,gBAAAA;KACAC,eAAAA;;UAEAD;;QAEFE;;;;UAIEF;;QAEFJ;;;;UAIEI;;SAEDH;;;WAGEG;;;UAGIG,gBAAAA;;;;WAIJH;;UAOIM,qBAAAA;UACLN"}

package/dist/sandbox-BbAabq93.d.ts

@@ -1,42 +0,0 @@
-import { o as ProcessStatus, s as SandboxCommand } from "./process-types-GStiZ8f8.js";
-import { A as CreateTerminalOptions, D as MountBucketOptions, M as Terminal, R as ExecOptions, S as BackupOptions, T as DirectoryBackup, _ as RenameFileResult, b as WriteFileResult, d as ListFilesOptions, f as ListFilesResult, g as ReadFileStreamResult, h as ReadFileResult, i as DeleteFileResult, k as RestoreBackupResult, m as MoveFileResult, o as FileEncoding, p as MkdirResult, q as SandboxProcess, r as CheckChangesResult, s as FileExistsResult, t as CheckChangesOptions, v as WatchOptions } from "./filesystem-BWAZCZER.js";
-
-//#region ../shared/dist/types/sandbox.d.ts
-
-interface ISandbox {
-  exec(command: SandboxCommand, options?: ExecOptions): Promise<SandboxProcess>;
-  getProcess(id: string): Promise<SandboxProcess | null>;
-  listProcesses(): Promise<ProcessStatus[]>;
-  writeFile(path: string, content: string | ReadableStream<Uint8Array>, options?: {
-    encoding?: string;
-  }): Promise<WriteFileResult>;
-  readFile(path: string, options: {
-    encoding: 'none';
-  }): Promise<ReadFileStreamResult>;
-  readFile(path: string, options?: {
-    encoding?: Exclude<FileEncoding, 'none'>;
-  }): Promise<ReadFileResult>;
-  readFileStream(path: string): Promise<ReadableStream<Uint8Array>>;
-  watch(path: string, options?: WatchOptions): Promise<ReadableStream<Uint8Array>>;
-  checkChanges(path: string, options?: CheckChangesOptions): Promise<CheckChangesResult>;
-  mkdir(path: string, options?: {
-    recursive?: boolean;
-  }): Promise<MkdirResult>;
-  deleteFile(path: string): Promise<DeleteFileResult>;
-  renameFile(oldPath: string, newPath: string, options?: Record<string, never>): Promise<RenameFileResult>;
-  moveFile(sourcePath: string, destinationPath: string, options?: Record<string, never>): Promise<MoveFileResult>;
-  listFiles(path: string, options?: ListFilesOptions): Promise<ListFilesResult>;
-  exists(path: string): Promise<FileExistsResult>;
-  setEnvVars(envVars: Record<string, string | undefined>): Promise<void>;
-  mountBucket(bucket: string, mountPath: string, options: MountBucketOptions): Promise<void>;
-  unmountBucket(mountPath: string): Promise<void>;
-  createBackup(options: BackupOptions): Promise<DirectoryBackup>;
-  restoreBackup(backup: DirectoryBackup): Promise<RestoreBackupResult>;
-  wsConnect(request: Request, port: number): Promise<Response>;
-  createTerminal(options: CreateTerminalOptions): Promise<Terminal>;
-  getTerminal(id: string): Promise<Terminal | null>;
-  listTerminals(): Promise<Terminal[]>;
-}
-//#endregion
-export { ISandbox as t };
-//# sourceMappingURL=sandbox-BbAabq93.d.ts.map

package/dist/sandbox-BbAabq93.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sandbox-BbAabq93.d.ts","names":["ProcessStatus","SandboxCommand","CreateTerminalOptions","Terminal","BackupOptions","DirectoryBackup","MountBucketOptions","RestoreBackupResult","ExecOptions","SandboxProcess","CheckChangesOptions","CheckChangesResult","DeleteFileResult","FileEncoding","FileExistsResult","ListFilesOptions","ListFilesResult","MkdirResult","MoveFileResult","ReadFileResult","ReadFileStreamResult","RenameFileResult","WatchOptions","WriteFileResult","ISandbox","Promise","Uint8Array","ReadableStream","Exclude","Record","Request","Response"],"sources":["../../shared/dist/types/sandbox.d.ts"],"sourcesContent":["import type { ProcessStatus, SandboxCommand } from '../process-types.js';\nimport type { CreateTerminalOptions, Terminal } from '../pty-types.js';\nimport type { BackupOptions, DirectoryBackup, MountBucketOptions, RestoreBackupResult } from './backup-mounts.js';\nimport type { ExecOptions, SandboxProcess } from './core.js';\nimport type { CheckChangesOptions, CheckChangesResult, DeleteFileResult, FileEncoding, FileExistsResult, ListFilesOptions, ListFilesResult, MkdirResult, MoveFileResult, ReadFileResult, ReadFileStreamResult, RenameFileResult, WatchOptions, WriteFileResult } from './filesystem.js';\nexport interface ISandbox {\n    exec(command: SandboxCommand, options?: ExecOptions): Promise<SandboxProcess>;\n    getProcess(id: string): Promise<SandboxProcess | null>;\n    listProcesses(): Promise<ProcessStatus[]>;\n    writeFile(path: string, content: string | ReadableStream<Uint8Array>, options?: {\n        encoding?: string;\n    }): Promise<WriteFileResult>;\n    readFile(path: string, options: {\n        encoding: 'none';\n    }): Promise<ReadFileStreamResult>;\n    readFile(path: string, options?: {\n        encoding?: Exclude<FileEncoding, 'none'>;\n    }): Promise<ReadFileResult>;\n    readFileStream(path: string): Promise<ReadableStream<Uint8Array>>;\n    watch(path: string, options?: WatchOptions): Promise<ReadableStream<Uint8Array>>;\n    checkChanges(path: string, options?: CheckChangesOptions): Promise<CheckChangesResult>;\n    mkdir(path: string, options?: {\n        recursive?: boolean;\n    }): Promise<MkdirResult>;\n    deleteFile(path: string): Promise<DeleteFileResult>;\n    renameFile(oldPath: string, newPath: string, options?: Record<string, never>): Promise<RenameFileResult>;\n    moveFile(sourcePath: string, destinationPath: string, options?: Record<string, never>): Promise<MoveFileResult>;\n    listFiles(path: string, options?: ListFilesOptions): Promise<ListFilesResult>;\n    exists(path: string): Promise<FileExistsResult>;\n    setEnvVars(envVars: Record<string, string | undefined>): Promise<void>;\n    mountBucket(bucket: string, mountPath: string, options: MountBucketOptions): Promise<void>;\n    unmountBucket(mountPath: string): Promise<void>;\n    createBackup(options: BackupOptions): Promise<DirectoryBackup>;\n    restoreBackup(backup: DirectoryBackup): Promise<RestoreBackupResult>;\n    wsConnect(request: Request, port: number): Promise<Response>;\n    createTerminal(options: CreateTerminalOptions): Promise<Terminal>;\n    getTerminal(id: string): Promise<Terminal | null>;\n    listTerminals(): Promise<Terminal[]>;\n}\n//# sourceMappingURL=sandbox.d.ts.map"],"mappings":"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"}