@finalai/agent-provider 0.1.0

package/dist/modules/sandbox/server.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/sandbox/server.ts"],
+  "sourcesContent": ["import * as z from 'zod';\nimport type { JsonValue } from \"../json.mjs\";\nimport { narrowerSandboxAccess, SandboxAccess, sandboxAccessAtLeast } from \"../manifest.mjs\";\nimport { base64ToBytes, bytesToStream } from \"./bytes.mjs\";\nimport { confinedReadDir, confinedReadFile, confinedStat } from \"./confined-files.mjs\";\nimport { createRpcPeer, type RpcPeerIface, type RpcRequestContextIface } from \"./rpc-peer.mjs\";\nimport {\n  isMcpChannelEndpoint,\n  SandboxCapability,\n  type McpChannelEndpointIface,\n  type McpChannelIface,\n  type NetworkSandboxSessionIface,\n  type SandboxMcpEndpoint,\n  type SandboxProcessIface,\n  type SandboxProviderHandleIface,\n} from \"./types.mjs\";\nimport {\n  createFrameChannelPair,\n  frameChannelFromStream,\n  frameChannelFromWebSocket,\n  HANDLE_RPC_EXECUTE_METHODS,\n  HANDLE_RPC_FILE_WRITE_METHODS,\n  HANDLE_RPC_LIFECYCLE_METHODS,\n  HANDLE_RPC_VERSION,\n  HandleRpcCloseCode,\n  handleRpcError,\n  HandleRpcErrorCode,\n  HandleRpcMethod,\n  handleRpcMethodSchemas,\n  parseHandleRpcMethod,\n  type DescribeResultIface,\n  type FrameChannelIface,\n  type FrameStreamIface,\n  type HandleRpcResult,\n  type WebSocketLikeIface,\n  type WireFrame,\n} from \"./wire.mjs\";\n\n// Serves the handle RPC (wire.ts) for a NetworkSandboxSessionIface. The session\n// service runs it for every provider at its stable per-binding endpoint, which\n// may lazily start the sandbox (through the provider) on the first call.\n\nexport interface HandleAccessPolicyIface {\n  // Read bindings reject writes, removes, process execution and computer use;\n  // execute bindings allow processes and computer use but not file writes.\n  mode: SandboxAccess;\n  // Allows sandbox/stop, sandbox/destroy and sandbox/setNetworkPolicy.\n  lifecycle: boolean;\n}\n\nexport const DEFAULT_HANDLE_ACCESS: HandleAccessPolicyIface = {\n  mode: SandboxAccess.Write,\n  lifecycle: false,\n};\n\nexport interface HandleAuthorizationIface {\n  // When the credential expires; the server closes the connection then unless\n  // the client refreshed it.\n  expiresAt: string | null;\n  // Narrows the server's access policy for this connection.\n  access?: HandleAccessPolicyIface;\n}\n\n// Returns null to reject. `token` is null when the client sent none.\nexport type HandleAuthorizeFn = (args: {\n  token: string | null;\n}) => Promise<HandleAuthorizationIface | null>;\n\nexport type HandleLifecycle = Pick<\n  SandboxProviderHandleIface<NetworkSandboxSessionIface>,\n  'onSandboxStop' | 'onSandboxDelete' | 'onRuntimeShutdown'\n>;\n\nexport interface HandleResolutionIface {\n  sandbox: NetworkSandboxSessionIface;\n  handle?: HandleLifecycle;\n  access?: HandleAccessPolicyIface;\n}\n\nexport interface HandleRpcMessageHandlerOptionsIface {\n  send: (frame: WireFrame) => void;\n  close: (code: number, reason: string) => void;\n  authorize: HandleAuthorizeFn;\n  // Called once per connection, after `initialize` is authorized. The session\n  // service's stable endpoint starts the sandbox here through its provider.\n  resolve: (authorization: HandleAuthorizationIface) => Promise<HandleResolutionIface>;\n  access?: HandleAccessPolicyIface;\n  // Token presented in the connection request, used when `initialize` has none.\n  connectionToken?: string | null;\n  // Send stream chunks as binary frames (default true).\n  binary?: boolean;\n  // The outer host applies hosted-tool policy before exposing this transport.\n  mcpChannels?: boolean;\n  now?: () => number;\n  // Runs for each validated operation, after binding access checks.\n  authorizeOperation?: (context: RpcRequestContextIface) => Promise<void>;\n}\n\nexport interface HandleRpcMessageHandlerIface {\n  onFrame(frame: WireFrame): void;\n  onClose(code?: number, reason?: string): void;\n}\n\n// Computer use counts only when `sandbox/computerUse` can answer it: an MCP\n// channel endpoint does not cross this wire (its host re-addresses it, as the\n// session service does with withHostedMcpEndpoints).\nconst servesComputerUse = async (sandbox: NetworkSandboxSessionIface): Promise<boolean> => {\n  if (sandbox.computerUse == null) return false;\n  try {\n    return !isMcpChannelEndpoint(await sandbox.computerUse());\n  } catch {\n    return false;\n  }\n};\n\nconst capabilitiesOf = async (\n  sandbox: NetworkSandboxSessionIface,\n  mcpChannels = false,\n): Promise<SandboxCapability[]> => {\n  const capabilities = [SandboxCapability.Files, SandboxCapability.Process];\n  if (sandbox.ports.length > 0) capabilities.push(SandboxCapability.Ports);\n  if (sandbox.setNetworkPolicy != null) capabilities.push(SandboxCapability.NetworkPolicy);\n  if (mcpChannels ? sandbox.computerUse != null : await servesComputerUse(sandbox))\n    capabilities.push(SandboxCapability.ComputerUse);\n  if (sandbox.screen != null) capabilities.push(SandboxCapability.Screen);\n  if (sandbox.localMcp != null) capabilities.push(SandboxCapability.LocalMcp);\n  return capabilities;\n};\n\nexport const describeSandbox = async (\n  sandbox: NetworkSandboxSessionIface,\n  mcpChannels = false,\n): Promise<DescribeResultIface> => ({\n  handleRpcVersion: HANDLE_RPC_VERSION,\n  id: sandbox.id,\n  defaultWorkingDirectory: sandbox.defaultWorkingDirectory,\n  ports: [...sandbox.ports],\n  capabilities: await capabilitiesOf(sandbox, mcpChannels),\n  description: sandbox.description,\n});\n\nconst narrowAccess = (\n  base: HandleAccessPolicyIface,\n  narrower: HandleAccessPolicyIface | undefined,\n): HandleAccessPolicyIface =>\n  narrower == null\n    ? base\n    : {\n        mode: narrowerSandboxAccess(base.mode, narrower.mode),\n        lifecycle: base.lifecycle && narrower.lifecycle,\n      };\n\nconst parseParams = <S extends z.ZodType>(schema: S, params: JsonValue): z.output<S> => {\n  const parsed = schema.safeParse(params);\n  if (!parsed.success) {\n    throw handleRpcError({\n      code: HandleRpcErrorCode.InvalidParams,\n      message: z.prettifyError(parsed.error),\n    });\n  }\n  return parsed.data;\n};\n\n// The upload stream ids a request names, read before full validation.\nconst uploadStreamIdsSchema = z.object({\n  streamId: z.number().int().nonnegative().optional(),\n  stdinStreamId: z.number().int().nonnegative().nullable().optional(),\n});\n\nconst unsupported = (what: string) =>\n  handleRpcError({ code: HandleRpcErrorCode.Unsupported, message: `this sandbox has no ${what}` });\n\n// Byte-range slice of a stream.\nconst sliceStream = (\n  source: ReadableStream<Uint8Array>,\n  offset: number,\n  length: number | undefined,\n): ReadableStream<Uint8Array> => {\n  let position = 0;\n  const end = length == null ? Number.POSITIVE_INFINITY : offset + length;\n  const reader = source.getReader();\n  return new ReadableStream<Uint8Array>({\n    pull: async (controller) => {\n      for (;;) {\n        if (position >= end) {\n          controller.close();\n          await reader.cancel().catch(() => undefined);\n          return;\n        }\n        const { done, value } = await reader.read();\n        if (done) {\n          controller.close();\n          return;\n        }\n        const chunkStart = position;\n        position += value.byteLength;\n        const from = Math.max(0, offset - chunkStart);\n        const to = Math.min(value.byteLength, end - chunkStart);\n        if (to > from) {\n          controller.enqueue(value.subarray(from, to));\n          return;\n        }\n      }\n    },\n    cancel: (reason) => reader.cancel(reason),\n  });\n};\n\n// Low-level, transport-agnostic handler: feed it frames, it calls `send` and\n// `close`. Use it where the host owns the socket (Hono upgradeWebSocket, a\n// Durable Object's hibernation handlers, a relay).\nexport const createHandleRpcMessageHandler = (\n  options: HandleRpcMessageHandlerOptionsIface,\n): HandleRpcMessageHandlerIface => {\n  const now = options.now ?? Date.now;\n  const [local, remote] = createFrameChannelPair();\n  let ended = false;\n  // `remote` is our side; frames the peer writes to it go out through `send`.\n  remote.listen({\n    frame: (frame) => options.send(frame),\n    close: (info) => {\n      if (!ended) {\n        ended = true;\n        options.close(info.code, info.reason);\n      }\n    },\n  });\n  const peerChannel: FrameChannelIface = local;\n  const connection = createServerConnection({\n    channel: peerChannel,\n    authorize: options.authorize,\n    resolve: options.resolve,\n    access: options.access ?? DEFAULT_HANDLE_ACCESS,\n    connectionToken: options.connectionToken ?? null,\n    binary: options.binary ?? true,\n    mcpChannels: options.mcpChannels,\n    now,\n    authorizeOperation: options.authorizeOperation,\n  });\n  return {\n    onFrame: (frame) => remote.send(frame),\n    onClose: (code, reason) => {\n      ended = true;\n      connection.close(code ?? 1000, reason ?? '');\n    },\n  };\n};\n\ninterface ServerConnectionIface {\n  close(code: number, reason: string): void;\n}\n\ninterface ServerConnectionArgsIface {\n  channel: FrameChannelIface;\n  authorize: HandleAuthorizeFn;\n  resolve: (authorization: HandleAuthorizationIface) => Promise<HandleResolutionIface>;\n  access: HandleAccessPolicyIface;\n  connectionToken: string | null;\n  binary: boolean;\n  mcpChannels?: boolean;\n  now: () => number;\n  authorizeOperation?: (context: RpcRequestContextIface) => Promise<void>;\n}\n\nconst createServerConnection = (args: ServerConnectionArgsIface): ServerConnectionIface => {\n  let sandbox: NetworkSandboxSessionIface | null = null;\n  let access = args.access;\n  let initializing = false;\n  let handle: HandleLifecycle | null = null;\n  let expiryTimer: ReturnType<typeof setTimeout> | null = null;\n  const processes = new Map<string, SandboxProcessIface>();\n  const mcpEndpoints = new Map<string, McpChannelEndpointIface>();\n  const mcpConnections = new Map<string, McpChannelIface>();\n  let nextMcpChannelId = 0;\n  let shutdown: Promise<void> | null = null;\n  // Incoming streams registered in beforeRequest, keyed by request id.\n  const incomingByRequest = new Map<\n    string | number,\n    { streamId: number; stream: ReadableStream<Uint8Array> }\n  >();\n\n  const scheduleExpiry = (expiresAt: string | null) => {\n    if (expiryTimer != null) clearTimeout(expiryTimer);\n    expiryTimer = null;\n    if (expiresAt == null) return;\n    const delay = Date.parse(expiresAt) - args.now();\n    if (Number.isNaN(delay)) return;\n    expiryTimer = setTimeout(\n      () =>\n        delay > 2_147_483_647\n          ? scheduleExpiry(expiresAt)\n          : peer.close(HandleRpcCloseCode.Unauthorized, 'credential expired'),\n      Math.max(0, Math.min(2_147_483_647, delay)),\n    );\n  };\n\n  const requireSandbox = (): NetworkSandboxSessionIface => {\n    if (sandbox == null) {\n      throw handleRpcError({\n        code: HandleRpcErrorCode.NotInitialized,\n        message: 'initialize first',\n      });\n    }\n    return sandbox;\n  };\n\n  const checkAccess = (method: HandleRpcMethod, params: JsonValue) => {\n    if (\n      method === HandleRpcMethod.Screen &&\n      !parseParams(handleRpcMethodSchemas[method].params, params).viewOnly &&\n      !sandboxAccessAtLeast(access.mode, SandboxAccess.Execute)\n    )\n      throw handleRpcError({\n        code: HandleRpcErrorCode.Forbidden,\n        message: 'Screen input control requires execute access',\n      });\n    if (\n      !sandboxAccessAtLeast(access.mode, SandboxAccess.Execute) &&\n      HANDLE_RPC_EXECUTE_METHODS.includes(method)\n    ) {\n      throw handleRpcError({\n        code: HandleRpcErrorCode.Forbidden,\n        message: `${method} is not allowed on a read-only binding`,\n      });\n    }\n    if (\n      !sandboxAccessAtLeast(access.mode, SandboxAccess.Write) &&\n      HANDLE_RPC_FILE_WRITE_METHODS.includes(method)\n    ) {\n      throw handleRpcError({\n        code: HandleRpcErrorCode.Forbidden,\n        message: `${method} is not allowed without write access`,\n      });\n    }\n    if (!access.lifecycle && HANDLE_RPC_LIFECYCLE_METHODS.includes(method)) {\n      throw handleRpcError({\n        code: HandleRpcErrorCode.Forbidden,\n        message: `${method} is not allowed on this binding`,\n      });\n    }\n  };\n\n  const featureFlags = (): Pick<DescribeResultIface, 'providerHooks' | 'mcpChannels'> => {\n    const flags: Pick<DescribeResultIface, 'providerHooks' | 'mcpChannels'> = {};\n    if (handle != null) flags.providerHooks = true;\n    if (args.mcpChannels === true) flags.mcpChannels = true;\n    return flags;\n  };\n\n  const initialize = async (\n    params: JsonValue,\n  ): Promise<HandleRpcResult<HandleRpcMethod.Initialize>> => {\n    const parsed = parseParams(handleRpcMethodSchemas[HandleRpcMethod.Initialize].params, params);\n    if (sandbox != null || initializing) {\n      throw handleRpcError({\n        code: HandleRpcErrorCode.InvalidRequest,\n        message: 'already initialized',\n      });\n    }\n    initializing = true;\n    try {\n      const token = parsed.token ?? args.connectionToken;\n      const authorization = await args.authorize({ token });\n      if (authorization == null) {\n        setTimeout(() => peer.close(HandleRpcCloseCode.Unauthorized, 'unauthorized'), 0);\n        throw handleRpcError({ code: HandleRpcErrorCode.Unauthorized, message: 'unauthorized' });\n      }\n      const resolution = await args.resolve(authorization);\n      access = narrowAccess(narrowAccess(access, resolution.access), authorization.access);\n      sandbox = resolution.sandbox;\n      handle = resolution.handle ?? null;\n      scheduleExpiry(authorization.expiresAt);\n      return {\n        ...(await describeSandbox(sandbox, args.mcpChannels)),\n        confinedFiles: true,\n        ...featureFlags(),\n        expiresAt: authorization.expiresAt,\n      };\n    } finally {\n      initializing = false;\n    }\n  };\n\n  const pump = (streamId: number, source: ReadableStream<Uint8Array>) => {\n    peer.streams.openOutgoing(streamId, source).catch(() => undefined);\n  };\n\n  const mcpDescriptor = (endpoint: SandboxMcpEndpoint, key: string) => {\n    if (!isMcpChannelEndpoint(endpoint)) return endpoint;\n    if (args.mcpChannels !== true) throw unsupported('MCP channels over the handle RPC');\n    mcpEndpoints.set(key, endpoint);\n    return { name: endpoint.name, endpointKey: key };\n  };\n  const mcpConnection = (id: string): McpChannelIface => {\n    const channel = mcpConnections.get(id);\n    if (channel == null)\n      throw handleRpcError({\n        code: HandleRpcErrorCode.NotFound,\n        message: 'MCP channel not found on this connection',\n      });\n    return channel;\n  };\n\n  // Fails a request's upload stream when the request fails, so the client\n  // stops sending.\n  const dispatch = async (context: RpcRequestContextIface): Promise<object> => {\n    try {\n      return await dispatchMethod(context);\n    } catch (error) {\n      const entry = incomingByRequest.get(context.id);\n      incomingByRequest.delete(context.id);\n      if (entry != null) peer.streams.cancelIncoming(entry.streamId, 'request failed');\n      throw error;\n    }\n  };\n\n  const dispatchMethod = async (context: RpcRequestContextIface): Promise<object> => {\n    const method = parseHandleRpcMethod(context.method);\n    if (method == null) {\n      throw handleRpcError({\n        code: HandleRpcErrorCode.MethodNotFound,\n        message: `unknown method ${context.method}`,\n      });\n    }\n    if (method === HandleRpcMethod.Initialize) return initialize(context.params);\n    const target = requireSandbox();\n    if (shutdown != null && method !== HandleRpcMethod.OnRuntimeShutdown)\n      throw handleRpcError({\n        code: HandleRpcErrorCode.ConnectionClosed,\n        message: 'Provider handle is shutting down',\n      });\n    checkAccess(method, context.params);\n    parseParams(handleRpcMethodSchemas[method].params, context.params);\n    await args.authorizeOperation?.(context);\n    if (context.signal.aborted)\n      throw handleRpcError({ code: HandleRpcErrorCode.Cancelled, message: 'request cancelled' });\n    const abortSignal = context.signal;\n    switch (method) {\n      case HandleRpcMethod.Describe:\n        return {\n          ...(await describeSandbox(target, args.mcpChannels)),\n          confinedFiles: true,\n          ...featureFlags(),\n        };\n      case HandleRpcMethod.AuthRefresh: {\n        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);\n        const authorization = await args.authorize({ token: params.token });\n        if (authorization == null)\n          throw handleRpcError({ code: HandleRpcErrorCode.Unauthorized, message: 'unauthorized' });\n        access = narrowAccess(access, authorization.access);\n        scheduleExpiry(authorization.expiresAt);\n        return { expiresAt: authorization.expiresAt };\n      }\n      case HandleRpcMethod.ReadFile: {\n        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);\n        const stream =\n          params.root == null\n            ? await target.readFile({ path: params.path, abortSignal })\n            : await (\n                target.confinedFileReader?.readFile ??\n                ((options) => confinedReadFile(target, options))\n              )({ path: params.path, root: params.root, abortSignal });\n        if (stream == null) return { found: false };\n        const ranged =\n          params.offset != null || params.length != null\n            ? sliceStream(stream, params.offset ?? 0, params.length)\n            : stream;\n        // The client registered the stream before asking, so start right away.\n        pump(params.streamId, ranged);\n        return { found: true };\n      }\n      case HandleRpcMethod.ReadTextFile: {\n        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);\n        const text = await target.readTextFile({ ...params, abortSignal });\n        return { text };\n      }\n      case HandleRpcMethod.WriteFile: {\n        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);\n        const incoming = incomingByRequest.get(context.id)?.stream ?? null;\n        const content =\n          incoming ??\n          bytesToStream(\n            params.contentBase64 == null ? new Uint8Array() : base64ToBytes(params.contentBase64),\n          );\n        await target.writeFile({ path: params.path, content, abortSignal });\n        incomingByRequest.delete(context.id);\n        return {};\n      }\n      case HandleRpcMethod.Spawn: {\n        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);\n        const stdin = incomingByRequest.get(context.id)?.stream ?? null;\n        if (processes.has(params.processId)) {\n          throw handleRpcError({\n            code: HandleRpcErrorCode.InvalidParams,\n            message: 'processId already in use',\n          });\n        }\n        const child = await target.spawn({\n          command: params.command,\n          args: params.args,\n          cwd: params.cwd,\n          env: params.env,\n          shell: params.shell,\n          timeoutMs: params.timeoutMs,\n          // A closed stdin is an empty stream.\n          stdin: stdin ?? '',\n        });\n        incomingByRequest.delete(context.id);\n        processes.set(params.processId, child);\n        pump(params.stdoutStreamId, child.stdout);\n        pump(params.stderrStreamId, child.stderr);\n        return { pid: child.pid };\n      }\n      case HandleRpcMethod.ProcessWait: {\n        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);\n        const child = processes.get(params.processId);\n        if (child == null)\n          throw handleRpcError({ code: HandleRpcErrorCode.NotFound, message: 'no such process' });\n        const result = await new Promise<{ exitCode: number }>((resolve, reject) => {\n          const onAbort = () =>\n            reject(handleRpcError({ code: HandleRpcErrorCode.Cancelled, message: 'cancelled' }));\n          abortSignal.addEventListener('abort', onAbort, { once: true });\n          child.wait().then(\n            (value) => {\n              abortSignal.removeEventListener('abort', onAbort);\n              resolve(value);\n            },\n            (cause: unknown) => {\n              abortSignal.removeEventListener('abort', onAbort);\n              reject(cause);\n            },\n          );\n        });\n        processes.delete(params.processId);\n        return result;\n      }\n      case HandleRpcMethod.ProcessKill: {\n        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);\n        const child = processes.get(params.processId);\n        if (child == null)\n          throw handleRpcError({ code: HandleRpcErrorCode.NotFound, message: 'no such process' });\n        await child.kill(params.signal);\n        return {};\n      }\n      case HandleRpcMethod.Run: {\n        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);\n        return target.run({ ...params, abortSignal });\n      }\n      case HandleRpcMethod.Stat: {\n        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);\n        return {\n          stat:\n            params.root == null\n              ? await target.stat({ path: params.path, abortSignal })\n              : await (\n                  target.confinedFileReader?.stat ?? ((options) => confinedStat(target, options))\n                )({\n                  path: params.path,\n                  root: params.root,\n                  abortSignal,\n                }),\n        };\n      }\n      case HandleRpcMethod.ReadDir: {\n        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);\n        return {\n          entries:\n            params.root == null\n              ? await target.readDir({ path: params.path, abortSignal })\n              : await (\n                  target.confinedFileReader?.readDir ??\n                  ((options) => confinedReadDir(target, options))\n                )({\n                  path: params.path,\n                  root: params.root,\n                  abortSignal,\n                }),\n        };\n      }\n      case HandleRpcMethod.RemovePath: {\n        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);\n        await target.removePath({ ...params, abortSignal });\n        return {};\n      }\n      case HandleRpcMethod.GetPortEndpoint: {\n        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);\n        return target.getPortEndpoint(params);\n      }\n      case HandleRpcMethod.Stop:\n        await target.stop();\n        return {};\n      case HandleRpcMethod.Destroy:\n        await target.destroy();\n        return {};\n      case HandleRpcMethod.OnRuntimeShutdown: {\n        if (handle == null) throw unsupported('provider lifecycle hooks');\n        const shutdownHandle = handle;\n        shutdown ??= (async () => {\n          await Promise.allSettled([...processes.values()].map((child) => child.kill()));\n          await Promise.allSettled([...mcpConnections.values()].map((channel) => channel.close()));\n          processes.clear();\n          mcpConnections.clear();\n          mcpEndpoints.clear();\n          await shutdownHandle.onRuntimeShutdown();\n        })();\n        await shutdown;\n        return {};\n      }\n      case HandleRpcMethod.OnSandboxStop:\n        if (handle == null) throw unsupported('provider lifecycle hooks');\n        await handle.onSandboxStop();\n        return {};\n      case HandleRpcMethod.OnSandboxDelete: {\n        if (handle == null) throw unsupported('provider lifecycle hooks');\n        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);\n        await handle.onSandboxDelete(params);\n        return {};\n      }\n      case HandleRpcMethod.SetNetworkPolicy: {\n        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);\n        if (target.setNetworkPolicy == null) throw unsupported('network policy');\n        await target.setNetworkPolicy(params);\n        return {};\n      }\n      case HandleRpcMethod.ComputerUse: {\n        if (target.computerUse == null) throw unsupported('computer use');\n        const endpoint = await target.computerUse();\n        return mcpDescriptor(endpoint, 'computerUse');\n      }\n      case HandleRpcMethod.McpOpen: {\n        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);\n        const endpoint = mcpEndpoints.get(params.endpointKey);\n        if (args.mcpChannels !== true || endpoint == null)\n          throw unsupported('MCP channel endpoint');\n        const channel = await endpoint.connect({ abortSignal });\n        if (abortSignal.aborted) {\n          await channel.close();\n          abortSignal.throwIfAborted();\n        }\n        const channelId = String(++nextMcpChannelId);\n        mcpConnections.set(channelId, channel);\n        return { channelId };\n      }\n      case HandleRpcMethod.McpSend: {\n        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);\n        await mcpConnection(params.channelId).send(params.message, { abortSignal });\n        return {};\n      }\n      case HandleRpcMethod.McpReceive: {\n        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);\n        return { messages: await mcpConnection(params.channelId).receive({ abortSignal }) };\n      }\n      case HandleRpcMethod.McpClose: {\n        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);\n        const channel = mcpConnection(params.channelId);\n        await channel.close();\n        mcpConnections.delete(params.channelId);\n        return {};\n      }\n      case HandleRpcMethod.Screen: {\n        if (target.screen == null) throw unsupported('screen');\n        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);\n        return target.screen(params);\n      }\n      case HandleRpcMethod.LocalMcp:\n        if (target.localMcp == null) throw unsupported('local MCP servers');\n        return {\n          endpoints: (await target.localMcp()).flatMap((endpoint, index) =>\n            args.mcpChannels !== true && isMcpChannelEndpoint(endpoint)\n              ? []\n              : [mcpDescriptor(endpoint, `localMcp:${index}:${endpoint.name}`)],\n          ),\n        };\n    }\n  };\n\n  // Registers client-to-server streams synchronously, before their chunks.\n  const beforeRequest = (context: RpcRequestContextIface) => {\n    if (context.method !== HandleRpcMethod.WriteFile && context.method !== HandleRpcMethod.Spawn)\n      return;\n    const ids = uploadStreamIdsSchema.safeParse(context.params);\n    if (!ids.success) return;\n    const streamId =\n      context.method === HandleRpcMethod.WriteFile ? ids.data.streamId : ids.data.stdinStreamId;\n    if (streamId == null) return;\n    const stream = peer.streams.openIncoming(streamId);\n    // Reject unauthorized or disallowed uploads before buffering their data.\n    const floor =\n      context.method === HandleRpcMethod.WriteFile ? SandboxAccess.Write : SandboxAccess.Execute;\n    if (sandbox == null || !sandboxAccessAtLeast(access.mode, floor)) {\n      peer.streams.cancelIncoming(streamId, 'rejected');\n      return;\n    }\n    incomingByRequest.set(context.id, { streamId, stream });\n  };\n\n  const onClose = () => {\n    if (expiryTimer != null) clearTimeout(expiryTimer);\n    for (const child of processes.values()) child.kill().catch(() => undefined);\n    for (const channel of mcpConnections.values()) void channel.close().catch(() => undefined);\n    mcpConnections.clear();\n    mcpEndpoints.clear();\n    processes.clear();\n    incomingByRequest.clear();\n  };\n\n  const peer: RpcPeerIface = createRpcPeer({\n    channel: args.channel,\n    binary: args.binary,\n    onRequest: dispatch,\n    beforeRequest,\n    onClose,\n  });\n\n  return { close: (code, reason) => peer.close(code, reason) };\n};\n\nexport interface ServeSandboxHandleArgsIface {\n  sandbox: NetworkSandboxSessionIface;\n  handle?: HandleLifecycle;\n  authorize: HandleAuthorizeFn;\n  access?: HandleAccessPolicyIface;\n  binary?: boolean;\n  // The outer host applies hosted-tool policy before exposing this transport.\n  mcpChannels?: boolean;\n  now?: () => number;\n}\n\nexport interface SandboxHandleServerIface {\n  // Attaches a connection; returns a function that closes it.\n  attach(channel: FrameChannelIface, context?: { token?: string | null }): () => void;\n  attachWebSocket(socket: WebSocketLikeIface, context?: { token?: string | null }): () => void;\n  attachStream(stream: FrameStreamIface, context?: { token?: string | null }): () => void;\n  messageHandler(args: {\n    send: (frame: WireFrame) => void;\n    close: (code: number, reason: string) => void;\n    token?: string | null;\n  }): HandleRpcMessageHandlerIface;\n}\n\nexport const serveSandboxHandle = (args: ServeSandboxHandleArgsIface): SandboxHandleServerIface => {\n  const access = args.access ?? DEFAULT_HANDLE_ACCESS;\n  const resolve = async (): Promise<HandleResolutionIface> => ({\n    sandbox: args.sandbox,\n    handle: args.handle,\n  });\n  const attach = (channel: FrameChannelIface, context?: { token?: string | null }) => {\n    const connection = createServerConnection({\n      channel,\n      authorize: args.authorize,\n      resolve,\n      access,\n      connectionToken: context?.token ?? null,\n      binary: args.binary ?? true,\n      mcpChannels: args.mcpChannels,\n      now: args.now ?? Date.now,\n    });\n    return () => connection.close(HandleRpcCloseCode.Normal, 'closed');\n  };\n  return {\n    attach,\n    attachWebSocket: (socket, context) =>\n      attach(frameChannelFromWebSocket(socket).channel, context),\n    attachStream: (stream, context) => attach(frameChannelFromStream(stream), context),\n    messageHandler: (handlerArgs) =>\n      createHandleRpcMessageHandler({\n        send: handlerArgs.send,\n        close: handlerArgs.close,\n        authorize: args.authorize,\n        resolve,\n        access,\n        connectionToken: handlerArgs.token ?? null,\n        binary: args.binary,\n        mcpChannels: args.mcpChannels,\n        now: args.now,\n      }),\n  };\n};\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/modules/sandbox/snapshots.d.mts

@@ -0,0 +1,49 @@
+import * as z from 'zod';
+import { SandboxEntryType } from "./types.mjs";
+export declare enum SandboxSnapshotOperation {
+    Stat = "stat",
+    ReadDirectory = "read-directory",
+    Read = "read"
+}
+export declare const sandboxSnapshotRequestSchema: z.ZodObject<{
+    operation: z.ZodEnum<typeof SandboxSnapshotOperation>;
+    path: z.ZodOptional<z.ZodString>;
+    snapshotId: z.ZodOptional<z.ZodString>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    length: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const sandboxSnapshotResponseSchema: z.ZodObject<{
+    root: z.ZodString;
+    path: z.ZodString;
+    snapshot: z.ZodObject<{
+        id: z.ZodString;
+        capturedAt: z.ZodString;
+    }, z.core.$strip>;
+    result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        operation: z.ZodLiteral<SandboxSnapshotOperation.Stat>;
+        stat: z.ZodNullable<z.ZodObject<{
+            path: z.ZodString;
+            type: z.ZodEnum<typeof SandboxEntryType>;
+            size: z.ZodNumber;
+            modifiedAt: z.ZodNullable<z.ZodString>;
+            mode: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        operation: z.ZodLiteral<SandboxSnapshotOperation.ReadDirectory>;
+        entries: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            path: z.ZodString;
+            type: z.ZodEnum<typeof SandboxEntryType>;
+            size: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>;
+        truncated: z.ZodBoolean;
+    }, z.core.$strip>, z.ZodObject<{
+        operation: z.ZodLiteral<SandboxSnapshotOperation.Read>;
+        offset: z.ZodNumber;
+        size: z.ZodNumber;
+        contentBase64: z.ZodString;
+        truncated: z.ZodBoolean;
+    }, z.core.$strip>], "operation">;
+}, z.core.$strip>;
+export type SandboxSnapshotRequestIface = z.infer<typeof sandboxSnapshotRequestSchema>;
+export type SandboxSnapshotResponseIface = z.infer<typeof sandboxSnapshotResponseSchema>;

package/dist/modules/sandbox/snapshots.mjs

@@ -0,0 +1,55 @@
+import * as z from "zod";
+import { SandboxEntryType } from "./types.mjs";
+var SandboxSnapshotOperation = /* @__PURE__ */ ((SandboxSnapshotOperation2) => {
+  SandboxSnapshotOperation2["Stat"] = "stat";
+  SandboxSnapshotOperation2["ReadDirectory"] = "read-directory";
+  SandboxSnapshotOperation2["Read"] = "read";
+  return SandboxSnapshotOperation2;
+})(SandboxSnapshotOperation || {});
+const sandboxSnapshotRequestSchema = z.object({
+  operation: z.nativeEnum(SandboxSnapshotOperation),
+  // Omitted means the provider's workspace root.
+  path: z.string().max(4096).optional(),
+  snapshotId: z.string().optional(),
+  offset: z.number().int().nonnegative().optional(),
+  length: z.number().int().positive().max(1024 * 1024).optional()
+});
+const statSchema = z.object({
+  path: z.string(),
+  type: z.nativeEnum(SandboxEntryType),
+  size: z.number().int().nonnegative(),
+  modifiedAt: z.string().nullable(),
+  mode: z.number().nullable()
+});
+const entrySchema = z.object({
+  name: z.string(),
+  path: z.string(),
+  type: z.nativeEnum(SandboxEntryType),
+  size: z.number().nullable()
+});
+const sandboxSnapshotResponseSchema = z.object({
+  root: z.string(),
+  path: z.string(),
+  snapshot: z.object({ id: z.string(), capturedAt: z.string() }),
+  result: z.discriminatedUnion("operation", [
+    z.object({ operation: z.literal("stat" /* Stat */), stat: statSchema.nullable() }),
+    z.object({
+      operation: z.literal("read-directory" /* ReadDirectory */),
+      entries: z.array(entrySchema),
+      truncated: z.boolean()
+    }),
+    z.object({
+      operation: z.literal("read" /* Read */),
+      offset: z.number().int().nonnegative(),
+      size: z.number().int().nonnegative(),
+      contentBase64: z.string(),
+      truncated: z.boolean()
+    })
+  ])
+});
+export {
+  SandboxSnapshotOperation,
+  sandboxSnapshotRequestSchema,
+  sandboxSnapshotResponseSchema
+};
+//# sourceMappingURL=snapshots.mjs.map

package/dist/modules/sandbox/snapshots.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/sandbox/snapshots.ts"],
+  "sourcesContent": ["import * as z from 'zod';\nimport { SandboxEntryType } from \"./types.mjs\";\n\nexport enum SandboxSnapshotOperation {\n  Stat = 'stat',\n  ReadDirectory = 'read-directory',\n  Read = 'read',\n}\n\nexport const sandboxSnapshotRequestSchema = z.object({\n  operation: z.nativeEnum(SandboxSnapshotOperation),\n  // Omitted means the provider's workspace root.\n  path: z.string().max(4096).optional(),\n  snapshotId: z.string().optional(),\n  offset: z.number().int().nonnegative().optional(),\n  length: z\n    .number()\n    .int()\n    .positive()\n    .max(1024 * 1024)\n    .optional(),\n});\n\nconst statSchema = z.object({\n  path: z.string(),\n  type: z.nativeEnum(SandboxEntryType),\n  size: z.number().int().nonnegative(),\n  modifiedAt: z.string().nullable(),\n  mode: z.number().nullable(),\n});\nconst entrySchema = z.object({\n  name: z.string(),\n  path: z.string(),\n  type: z.nativeEnum(SandboxEntryType),\n  size: z.number().nullable(),\n});\n\nexport const sandboxSnapshotResponseSchema = z.object({\n  root: z.string(),\n  path: z.string(),\n  snapshot: z.object({ id: z.string(), capturedAt: z.string() }),\n  result: z.discriminatedUnion('operation', [\n    z.object({ operation: z.literal(SandboxSnapshotOperation.Stat), stat: statSchema.nullable() }),\n    z.object({\n      operation: z.literal(SandboxSnapshotOperation.ReadDirectory),\n      entries: z.array(entrySchema),\n      truncated: z.boolean(),\n    }),\n    z.object({\n      operation: z.literal(SandboxSnapshotOperation.Read),\n      offset: z.number().int().nonnegative(),\n      size: z.number().int().nonnegative(),\n      contentBase64: z.string(),\n      truncated: z.boolean(),\n    }),\n  ]),\n});\n\nexport type SandboxSnapshotRequestIface = z.infer<typeof sandboxSnapshotRequestSchema>;\nexport type SandboxSnapshotResponseIface = z.infer<typeof sandboxSnapshotResponseSchema>;\n"],
+  "mappings": "AAAA,YAAY,OAAO;AACnB,SAAS,wBAAwB;AAE1B,IAAK,2BAAL,kBAAKA,8BAAL;AACL,EAAAA,0BAAA,UAAO;AACP,EAAAA,0BAAA,mBAAgB;AAChB,EAAAA,0BAAA,UAAO;AAHG,SAAAA;AAAA,GAAA;AAML,MAAM,+BAA+B,EAAE,OAAO;AAAA,EACnD,WAAW,EAAE,WAAW,wBAAwB;AAAA;AAAA,EAEhD,MAAM,EAAE,OAAO,EAAE,IAAI,IAAI,EAAE,SAAS;AAAA,EACpC,YAAY,EAAE,OAAO,EAAE,SAAS;AAAA,EAChC,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,SAAS;AAAA,EAChD,QAAQ,EACL,OAAO,EACP,IAAI,EACJ,SAAS,EACT,IAAI,OAAO,IAAI,EACf,SAAS;AACd,CAAC;AAED,MAAM,aAAa,EAAE,OAAO;AAAA,EAC1B,MAAM,EAAE,OAAO;AAAA,EACf,MAAM,EAAE,WAAW,gBAAgB;AAAA,EACnC,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY;AAAA,EACnC,YAAY,EAAE,OAAO,EAAE,SAAS;AAAA,EAChC,MAAM,EAAE,OAAO,EAAE,SAAS;AAC5B,CAAC;AACD,MAAM,cAAc,EAAE,OAAO;AAAA,EAC3B,MAAM,EAAE,OAAO;AAAA,EACf,MAAM,EAAE,OAAO;AAAA,EACf,MAAM,EAAE,WAAW,gBAAgB;AAAA,EACnC,MAAM,EAAE,OAAO,EAAE,SAAS;AAC5B,CAAC;AAEM,MAAM,gCAAgC,EAAE,OAAO;AAAA,EACpD,MAAM,EAAE,OAAO;AAAA,EACf,MAAM,EAAE,OAAO;AAAA,EACf,UAAU,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,GAAG,YAAY,EAAE,OAAO,EAAE,CAAC;AAAA,EAC7D,QAAQ,EAAE,mBAAmB,aAAa;AAAA,IACxC,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,iBAA6B,GAAG,MAAM,WAAW,SAAS,EAAE,CAAC;AAAA,IAC7F,EAAE,OAAO;AAAA,MACP,WAAW,EAAE,QAAQ,oCAAsC;AAAA,MAC3D,SAAS,EAAE,MAAM,WAAW;AAAA,MAC5B,WAAW,EAAE,QAAQ;AAAA,IACvB,CAAC;AAAA,IACD,EAAE,OAAO;AAAA,MACP,WAAW,EAAE,QAAQ,iBAA6B;AAAA,MAClD,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY;AAAA,MACrC,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY;AAAA,MACnC,eAAe,EAAE,OAAO;AAAA,MACxB,WAAW,EAAE,QAAQ;AAAA,IACvB,CAAC;AAAA,EACH,CAAC;AACH,CAAC;",
+  "names": ["SandboxSnapshotOperation"]
+}

package/dist/modules/sandbox/stream-mux.d.mts

@@ -0,0 +1,18 @@
+import type { JsonValue } from "../json.mjs";
+import { type WireFrame } from "./wire.mjs";
+export interface StreamMuxIface {
+    openIncoming(streamId: number): ReadableStream<Uint8Array>;
+    discardIncoming(streamId: number): void;
+    cancelIncoming(streamId: number, reason: string): void;
+    openOutgoing(streamId: number, source: ReadableStream<Uint8Array>): Promise<void>;
+    abortOutgoing(streamId: number, reason: string): void;
+    handleNotification(method: string, params: JsonValue): boolean;
+    handleBinary(frame: Uint8Array): void;
+    failAll(error: Error): void;
+}
+export declare const createStreamMux: (args: {
+    send: (frame: WireFrame) => void;
+    binary: boolean;
+    windowBytes?: number;
+    chunkBytes?: number;
+}) => StreamMuxIface;

package/dist/modules/sandbox/stream-mux.mjs

@@ -0,0 +1,285 @@
+import { base64ToBytes, bytesToBase64 } from "./bytes.mjs";
+import {
+  decodeBinaryFrame,
+  encodeChunkFrame,
+  errnoOf,
+  handleRpcError,
+  HandleRpcErrorCode,
+  HandleRpcNotification,
+  INITIAL_STREAM_WINDOW_BYTES,
+  isHandleRpcError,
+  MAX_CHUNK_BYTES,
+  streamCancelParamsSchema,
+  streamChunkParamsSchema,
+  streamCreditParamsSchema,
+  streamEndParamsSchema,
+  streamErrorParamsSchema
+} from "./wire.mjs";
+const createStreamMux = (args) => {
+  const windowBytes = args.windowBytes ?? INITIAL_STREAM_WINDOW_BYTES;
+  const chunkBytes = Math.min(args.chunkBytes ?? MAX_CHUNK_BYTES, windowBytes);
+  const grantThreshold = Math.max(1, Math.floor(windowBytes / 4));
+  const incoming = /* @__PURE__ */ new Map();
+  const outgoing = /* @__PURE__ */ new Map();
+  let failed = null;
+  const notify = (method, params) => {
+    args.send(JSON.stringify({ jsonrpc: "2.0", method, params }));
+  };
+  const wakeIncoming = (state) => {
+    const wake = state.wake;
+    state.wake = null;
+    wake?.();
+  };
+  const wakeOutgoing = (state) => {
+    const wake = state.wake;
+    state.wake = null;
+    wake?.();
+  };
+  const stopOutgoing = (state, error, silent) => {
+    if (state.cancelled != null) return;
+    state.cancelled = error;
+    state.silent = silent;
+    wakeOutgoing(state);
+    state.reader?.cancel(error).catch(() => void 0);
+  };
+  const grant = (streamId, state, bytes) => {
+    state.ungranted += bytes;
+    if (state.ended || state.error != null) return;
+    if (state.ungranted >= grantThreshold) {
+      const amount = state.ungranted;
+      state.ungranted = 0;
+      state.credit += amount;
+      notify(HandleRpcNotification.StreamCredit, { streamId, bytes: amount });
+    }
+  };
+  const openIncoming = (streamId) => {
+    const state = {
+      queue: [],
+      ended: false,
+      error: failed,
+      wake: null,
+      ungranted: 0,
+      credit: windowBytes
+    };
+    incoming.set(streamId, state);
+    return new ReadableStream(
+      {
+        pull: async (controller) => {
+          while (state.queue.length === 0 && !state.ended && state.error == null) {
+            await new Promise((resolve) => {
+              state.wake = resolve;
+            });
+          }
+          const chunk = state.queue.shift();
+          if (chunk != null) {
+            controller.enqueue(chunk);
+            grant(streamId, state, chunk.byteLength);
+            return;
+          }
+          incoming.delete(streamId);
+          if (state.error != null) controller.error(state.error);
+          else controller.close();
+        },
+        cancel: (reason) => {
+          if (incoming.get(streamId) !== state) return;
+          incoming.delete(streamId);
+          state.error = handleRpcError({
+            code: HandleRpcErrorCode.Cancelled,
+            message: "stream cancelled"
+          });
+          notify(HandleRpcNotification.StreamCancel, {
+            streamId,
+            reason: reason instanceof Error ? reason.message : "cancelled"
+          });
+        }
+      },
+      { highWaterMark: 0 }
+    );
+  };
+  const discardIncoming = (streamId) => {
+    const state = incoming.get(streamId);
+    if (state == null) return;
+    incoming.delete(streamId);
+    state.ended = true;
+    wakeIncoming(state);
+  };
+  const cancelIncoming = (streamId, reason) => {
+    const state = incoming.get(streamId);
+    if (state == null) return;
+    incoming.delete(streamId);
+    state.error = handleRpcError({ code: HandleRpcErrorCode.Cancelled, message: reason });
+    wakeIncoming(state);
+    notify(HandleRpcNotification.StreamCancel, { streamId, reason });
+  };
+  const sendChunk = (streamId, payload) => {
+    if (args.binary) args.send(encodeChunkFrame(streamId, payload));
+    else notify(HandleRpcNotification.StreamChunk, { streamId, data: bytesToBase64(payload) });
+  };
+  const openOutgoing = async (streamId, source) => {
+    const reader = source.getReader();
+    const state = {
+      credit: windowBytes,
+      cancelled: failed,
+      silent: failed != null,
+      wake: null,
+      reader
+    };
+    outgoing.set(streamId, state);
+    try {
+      for (; ; ) {
+        if (state.cancelled != null) throw state.cancelled;
+        const { done, value } = await reader.read();
+        if (state.cancelled != null) throw state.cancelled;
+        if (done) break;
+        let offset = 0;
+        while (offset < value.byteLength) {
+          while (state.credit <= 0 && state.cancelled == null) {
+            await new Promise((resolve) => {
+              state.wake = resolve;
+            });
+          }
+          if (state.cancelled != null) throw state.cancelled;
+          const size = Math.min(value.byteLength - offset, state.credit, chunkBytes);
+          sendChunk(streamId, value.subarray(offset, offset + size));
+          state.credit -= size;
+          offset += size;
+        }
+      }
+      outgoing.delete(streamId);
+      notify(HandleRpcNotification.StreamEnd, { streamId });
+    } catch (error) {
+      outgoing.delete(streamId);
+      reader.cancel(error).catch(() => void 0);
+      if (!state.silent && failed == null) {
+        const message = error instanceof Error ? error.message : "stream source failed";
+        notify(HandleRpcNotification.StreamError, {
+          streamId,
+          message,
+          code: isHandleRpcError(error) ? error.code : HandleRpcErrorCode.Internal,
+          errno: errnoOf(error)
+        });
+      }
+      throw error;
+    }
+  };
+  const abortOutgoing = (streamId, reason) => {
+    const state = outgoing.get(streamId);
+    if (state == null) return;
+    stopOutgoing(
+      state,
+      handleRpcError({ code: HandleRpcErrorCode.Cancelled, message: reason }),
+      false
+    );
+  };
+  const deliverChunk = (streamId, payload) => {
+    const state = incoming.get(streamId);
+    if (state == null || state.ended || state.error != null) return;
+    if (payload.byteLength > state.credit || payload.byteLength > MAX_CHUNK_BYTES) {
+      state.queue.length = 0;
+      state.error = handleRpcError({
+        code: HandleRpcErrorCode.InvalidRequest,
+        message: "stream exceeded its credit window"
+      });
+      notify(HandleRpcNotification.StreamCancel, {
+        streamId,
+        reason: "stream exceeded its credit window"
+      });
+      wakeIncoming(state);
+      return;
+    }
+    state.credit -= payload.byteLength;
+    state.queue.push(payload);
+    wakeIncoming(state);
+  };
+  const handleNotification = (method, params) => {
+    switch (method) {
+      case HandleRpcNotification.StreamChunk: {
+        const parsed = streamChunkParamsSchema.safeParse(params);
+        if (parsed.success) {
+          try {
+            deliverChunk(parsed.data.streamId, base64ToBytes(parsed.data.data));
+          } catch {
+            cancelIncoming(parsed.data.streamId, "invalid base64 stream chunk");
+          }
+        }
+        return true;
+      }
+      case HandleRpcNotification.StreamEnd: {
+        const parsed = streamEndParamsSchema.safeParse(params);
+        const state = parsed.success ? incoming.get(parsed.data.streamId) : void 0;
+        if (state != null) {
+          state.ended = true;
+          wakeIncoming(state);
+        }
+        return true;
+      }
+      case HandleRpcNotification.StreamError: {
+        const parsed = streamErrorParamsSchema.safeParse(params);
+        const state = parsed.success ? incoming.get(parsed.data.streamId) : void 0;
+        if (parsed.success && state != null) {
+          state.error = handleRpcError({
+            code: parsed.data.code ?? HandleRpcErrorCode.Internal,
+            message: parsed.data.message,
+            errno: parsed.data.errno ?? null
+          });
+          wakeIncoming(state);
+        }
+        return true;
+      }
+      case HandleRpcNotification.StreamCredit: {
+        const parsed = streamCreditParamsSchema.safeParse(params);
+        const state = parsed.success ? outgoing.get(parsed.data.streamId) : void 0;
+        if (parsed.success && state != null) {
+          state.credit += parsed.data.bytes;
+          wakeOutgoing(state);
+        }
+        return true;
+      }
+      case HandleRpcNotification.StreamCancel: {
+        const parsed = streamCancelParamsSchema.safeParse(params);
+        const state = parsed.success ? outgoing.get(parsed.data.streamId) : void 0;
+        if (parsed.success && state != null) {
+          stopOutgoing(
+            state,
+            handleRpcError({
+              code: HandleRpcErrorCode.Cancelled,
+              message: parsed.data.reason ?? "stream cancelled by peer"
+            }),
+            true
+          );
+        }
+        return true;
+      }
+      default:
+        return false;
+    }
+  };
+  const handleBinary = (frame) => {
+    const decoded = decodeBinaryFrame(frame);
+    if (decoded != null) deliverChunk(decoded.streamId, decoded.payload);
+  };
+  const failAll = (error) => {
+    failed = error;
+    for (const state of incoming.values()) {
+      state.error = error;
+      wakeIncoming(state);
+    }
+    incoming.clear();
+    for (const state of outgoing.values()) stopOutgoing(state, error, true);
+    outgoing.clear();
+  };
+  return {
+    openIncoming,
+    discardIncoming,
+    cancelIncoming,
+    openOutgoing,
+    abortOutgoing,
+    handleNotification,
+    handleBinary,
+    failAll
+  };
+};
+export {
+  createStreamMux
+};
+//# sourceMappingURL=stream-mux.mjs.map

package/dist/modules/sandbox/stream-mux.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/sandbox/stream-mux.ts"],
+  "sourcesContent": ["import type { JsonObject, JsonValue } from \"../json.mjs\";\nimport { base64ToBytes, bytesToBase64 } from \"./bytes.mjs\";\nimport {\n  decodeBinaryFrame,\n  encodeChunkFrame,\n  errnoOf,\n  handleRpcError,\n  HandleRpcErrorCode,\n  HandleRpcNotification,\n  INITIAL_STREAM_WINDOW_BYTES,\n  isHandleRpcError,\n  MAX_CHUNK_BYTES,\n  streamCancelParamsSchema,\n  streamChunkParamsSchema,\n  streamCreditParamsSchema,\n  streamEndParamsSchema,\n  streamErrorParamsSchema,\n  type WireFrame,\n} from \"./wire.mjs\";\n\n// Credit-based byte streams multiplexed on one handle RPC connection (see the\n// framing notes in wire.ts). Used identically by client and server.\n\nexport interface StreamMuxIface {\n  // Data flowing from the peer to us. The stream must be opened before the\n  // peer can send its first chunk.\n  openIncoming(streamId: number): ReadableStream<Uint8Array>;\n  // Drops an incoming stream the peer will never send (a file not found).\n  discardIncoming(streamId: number): void;\n  // Tells the peer to stop sending, and fails the local reader.\n  cancelIncoming(streamId: number, reason: string): void;\n  // Data flowing from us to the peer; resolves when `stream/end` was sent and\n  // rejects if the peer cancels or the connection fails.\n  openOutgoing(streamId: number, source: ReadableStream<Uint8Array>): Promise<void>;\n  // Stops an outgoing stream locally and fails it on the peer.\n  abortOutgoing(streamId: number, reason: string): void;\n  // Returns true when the notification was a stream notification.\n  handleNotification(method: string, params: JsonValue): boolean;\n  handleBinary(frame: Uint8Array): void;\n  failAll(error: Error): void;\n}\n\ninterface IncomingStateIface {\n  queue: Uint8Array[];\n  ended: boolean;\n  error: Error | null;\n  wake: (() => void) | null;\n  ungranted: number;\n  credit: number;\n}\n\ninterface OutgoingStateIface {\n  credit: number;\n  cancelled: Error | null;\n  // True when the peer or the connection stopped the stream, so the peer must\n  // not be told about it.\n  silent: boolean;\n  wake: (() => void) | null;\n  reader: ReadableStreamDefaultReader<Uint8Array> | null;\n}\n\nexport const createStreamMux = (args: {\n  send: (frame: WireFrame) => void;\n  binary: boolean;\n  windowBytes?: number;\n  chunkBytes?: number;\n}): StreamMuxIface => {\n  const windowBytes = args.windowBytes ?? INITIAL_STREAM_WINDOW_BYTES;\n  const chunkBytes = Math.min(args.chunkBytes ?? MAX_CHUNK_BYTES, windowBytes);\n  // Credit is returned in batches to keep the reverse channel quiet.\n  const grantThreshold = Math.max(1, Math.floor(windowBytes / 4));\n  const incoming = new Map<number, IncomingStateIface>();\n  const outgoing = new Map<number, OutgoingStateIface>();\n  let failed: Error | null = null;\n\n  const notify = (method: HandleRpcNotification, params: JsonObject) => {\n    args.send(JSON.stringify({ jsonrpc: '2.0', method, params }));\n  };\n\n  const wakeIncoming = (state: IncomingStateIface) => {\n    const wake = state.wake;\n    state.wake = null;\n    wake?.();\n  };\n\n  const wakeOutgoing = (state: OutgoingStateIface) => {\n    const wake = state.wake;\n    state.wake = null;\n    wake?.();\n  };\n\n  const stopOutgoing = (state: OutgoingStateIface, error: Error, silent: boolean) => {\n    if (state.cancelled != null) return;\n    state.cancelled = error;\n    state.silent = silent;\n    wakeOutgoing(state);\n    state.reader?.cancel(error).catch(() => undefined);\n  };\n\n  const grant = (streamId: number, state: IncomingStateIface, bytes: number) => {\n    state.ungranted += bytes;\n    if (state.ended || state.error != null) return;\n    if (state.ungranted >= grantThreshold) {\n      const amount = state.ungranted;\n      state.ungranted = 0;\n      state.credit += amount;\n      notify(HandleRpcNotification.StreamCredit, { streamId, bytes: amount });\n    }\n  };\n\n  const openIncoming = (streamId: number): ReadableStream<Uint8Array> => {\n    const state: IncomingStateIface = {\n      queue: [],\n      ended: false,\n      error: failed,\n      wake: null,\n      ungranted: 0,\n      credit: windowBytes,\n    };\n    incoming.set(streamId, state);\n    return new ReadableStream<Uint8Array>(\n      {\n        pull: async (controller) => {\n          while (state.queue.length === 0 && !state.ended && state.error == null) {\n            await new Promise<void>((resolve) => {\n              state.wake = resolve;\n            });\n          }\n          const chunk = state.queue.shift();\n          if (chunk != null) {\n            controller.enqueue(chunk);\n            grant(streamId, state, chunk.byteLength);\n            return;\n          }\n          incoming.delete(streamId);\n          if (state.error != null) controller.error(state.error);\n          else controller.close();\n        },\n        cancel: (reason) => {\n          if (incoming.get(streamId) !== state) return;\n          incoming.delete(streamId);\n          state.error = handleRpcError({\n            code: HandleRpcErrorCode.Cancelled,\n            message: 'stream cancelled',\n          });\n          notify(HandleRpcNotification.StreamCancel, {\n            streamId,\n            reason: reason instanceof Error ? reason.message : 'cancelled',\n          });\n        },\n      },\n      { highWaterMark: 0 },\n    );\n  };\n\n  const discardIncoming = (streamId: number) => {\n    const state = incoming.get(streamId);\n    if (state == null) return;\n    incoming.delete(streamId);\n    state.ended = true;\n    wakeIncoming(state);\n  };\n\n  const cancelIncoming = (streamId: number, reason: string) => {\n    const state = incoming.get(streamId);\n    if (state == null) return;\n    incoming.delete(streamId);\n    state.error = handleRpcError({ code: HandleRpcErrorCode.Cancelled, message: reason });\n    wakeIncoming(state);\n    notify(HandleRpcNotification.StreamCancel, { streamId, reason });\n  };\n\n  const sendChunk = (streamId: number, payload: Uint8Array) => {\n    if (args.binary) args.send(encodeChunkFrame(streamId, payload));\n    else notify(HandleRpcNotification.StreamChunk, { streamId, data: bytesToBase64(payload) });\n  };\n\n  const openOutgoing = async (\n    streamId: number,\n    source: ReadableStream<Uint8Array>,\n  ): Promise<void> => {\n    const reader = source.getReader();\n    const state: OutgoingStateIface = {\n      credit: windowBytes,\n      cancelled: failed,\n      silent: failed != null,\n      wake: null,\n      reader,\n    };\n    outgoing.set(streamId, state);\n    try {\n      for (;;) {\n        if (state.cancelled != null) throw state.cancelled;\n        const { done, value } = await reader.read();\n        // Stopping cancels the reader, which ends a pending read.\n        if (state.cancelled != null) throw state.cancelled;\n        if (done) break;\n        let offset = 0;\n        while (offset < value.byteLength) {\n          while (state.credit <= 0 && state.cancelled == null) {\n            await new Promise<void>((resolve) => {\n              state.wake = resolve;\n            });\n          }\n          if (state.cancelled != null) throw state.cancelled;\n          const size = Math.min(value.byteLength - offset, state.credit, chunkBytes);\n          sendChunk(streamId, value.subarray(offset, offset + size));\n          state.credit -= size;\n          offset += size;\n        }\n      }\n      outgoing.delete(streamId);\n      notify(HandleRpcNotification.StreamEnd, { streamId });\n    } catch (error) {\n      outgoing.delete(streamId);\n      reader.cancel(error).catch(() => undefined);\n      if (!state.silent && failed == null) {\n        const message = error instanceof Error ? error.message : 'stream source failed';\n        notify(HandleRpcNotification.StreamError, {\n          streamId,\n          message,\n          code: isHandleRpcError(error) ? error.code : HandleRpcErrorCode.Internal,\n          errno: errnoOf(error),\n        });\n      }\n      throw error;\n    }\n  };\n\n  const abortOutgoing = (streamId: number, reason: string) => {\n    const state = outgoing.get(streamId);\n    if (state == null) return;\n    stopOutgoing(\n      state,\n      handleRpcError({ code: HandleRpcErrorCode.Cancelled, message: reason }),\n      false,\n    );\n  };\n\n  const deliverChunk = (streamId: number, payload: Uint8Array) => {\n    const state = incoming.get(streamId);\n    if (state == null || state.ended || state.error != null) return;\n    if (payload.byteLength > state.credit || payload.byteLength > MAX_CHUNK_BYTES) {\n      state.queue.length = 0;\n      state.error = handleRpcError({\n        code: HandleRpcErrorCode.InvalidRequest,\n        message: 'stream exceeded its credit window',\n      });\n      notify(HandleRpcNotification.StreamCancel, {\n        streamId,\n        reason: 'stream exceeded its credit window',\n      });\n      wakeIncoming(state);\n      return;\n    }\n    state.credit -= payload.byteLength;\n    state.queue.push(payload);\n    wakeIncoming(state);\n  };\n\n  const handleNotification = (method: string, params: JsonValue): boolean => {\n    switch (method) {\n      case HandleRpcNotification.StreamChunk: {\n        const parsed = streamChunkParamsSchema.safeParse(params);\n        if (parsed.success) {\n          try {\n            deliverChunk(parsed.data.streamId, base64ToBytes(parsed.data.data));\n          } catch {\n            cancelIncoming(parsed.data.streamId, 'invalid base64 stream chunk');\n          }\n        }\n        return true;\n      }\n      case HandleRpcNotification.StreamEnd: {\n        const parsed = streamEndParamsSchema.safeParse(params);\n        const state = parsed.success ? incoming.get(parsed.data.streamId) : undefined;\n        if (state != null) {\n          state.ended = true;\n          wakeIncoming(state);\n        }\n        return true;\n      }\n      case HandleRpcNotification.StreamError: {\n        const parsed = streamErrorParamsSchema.safeParse(params);\n        const state = parsed.success ? incoming.get(parsed.data.streamId) : undefined;\n        if (parsed.success && state != null) {\n          state.error = handleRpcError({\n            code: parsed.data.code ?? HandleRpcErrorCode.Internal,\n            message: parsed.data.message,\n            errno: parsed.data.errno ?? null,\n          });\n          wakeIncoming(state);\n        }\n        return true;\n      }\n      case HandleRpcNotification.StreamCredit: {\n        const parsed = streamCreditParamsSchema.safeParse(params);\n        const state = parsed.success ? outgoing.get(parsed.data.streamId) : undefined;\n        if (parsed.success && state != null) {\n          state.credit += parsed.data.bytes;\n          wakeOutgoing(state);\n        }\n        return true;\n      }\n      case HandleRpcNotification.StreamCancel: {\n        const parsed = streamCancelParamsSchema.safeParse(params);\n        const state = parsed.success ? outgoing.get(parsed.data.streamId) : undefined;\n        if (parsed.success && state != null) {\n          stopOutgoing(\n            state,\n            handleRpcError({\n              code: HandleRpcErrorCode.Cancelled,\n              message: parsed.data.reason ?? 'stream cancelled by peer',\n            }),\n            true,\n          );\n        }\n        return true;\n      }\n      default:\n        return false;\n    }\n  };\n\n  const handleBinary = (frame: Uint8Array) => {\n    const decoded = decodeBinaryFrame(frame);\n    if (decoded != null) deliverChunk(decoded.streamId, decoded.payload);\n  };\n\n  const failAll = (error: Error) => {\n    failed = error;\n    for (const state of incoming.values()) {\n      state.error = error;\n      wakeIncoming(state);\n    }\n    incoming.clear();\n    for (const state of outgoing.values()) stopOutgoing(state, error, true);\n    outgoing.clear();\n  };\n\n  return {\n    openIncoming,\n    discardIncoming,\n    cancelIncoming,\n    openOutgoing,\n    abortOutgoing,\n    handleNotification,\n    handleBinary,\n    failAll,\n  };\n};\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/modules/sandbox/testing.d.mts

@@ -0,0 +1,25 @@
+import { type ConnectSandboxClientArgsIface, type SandboxClientIface } from "./client.mjs";
+import { type HandleAccessPolicyIface, type HandleAuthorizeFn, type HandleLifecycle, type HandleRpcMessageHandlerOptionsIface } from "./server.mjs";
+import type { NetworkSandboxSessionIface } from "./types.mjs";
+import { type FrameChannelIface } from "./wire.mjs";
+export interface InMemoryHandleNetworkIface {
+    serve(args: {
+        url: string;
+        sandbox: NetworkSandboxSessionIface;
+        handle?: HandleLifecycle;
+        authorize?: HandleAuthorizeFn;
+        access?: HandleAccessPolicyIface;
+        binary?: boolean;
+        mcpChannels?: boolean;
+    }): void;
+    mount(url: string, options: Omit<HandleRpcMessageHandlerOptionsIface, 'send' | 'close' | 'connectionToken'>): void;
+    openChannel(target: {
+        url: string;
+        token: string;
+    }): Promise<FrameChannelIface>;
+    connect(args: Omit<ConnectSandboxClientArgsIface, 'openChannel'>): Promise<SandboxClientIface>;
+    dropAll(): void;
+    dials(): string[];
+}
+export declare const allowAllTokens: HandleAuthorizeFn;
+export declare const createInMemoryHandleNetwork: () => InMemoryHandleNetworkIface;