@finalai/agent-provider 0.1.0

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

@@ -0,0 +1,66 @@
+import { SandboxAccess } from "../manifest.mjs";
+import { type RpcRequestContextIface } from "./rpc-peer.mjs";
+import { type NetworkSandboxSessionIface, type SandboxProviderHandleIface } from "./types.mjs";
+import { type DescribeResultIface, type FrameChannelIface, type FrameStreamIface, type WebSocketLikeIface, type WireFrame } from "./wire.mjs";
+export interface HandleAccessPolicyIface {
+    mode: SandboxAccess;
+    lifecycle: boolean;
+}
+export declare const DEFAULT_HANDLE_ACCESS: HandleAccessPolicyIface;
+export interface HandleAuthorizationIface {
+    expiresAt: string | null;
+    access?: HandleAccessPolicyIface;
+}
+export type HandleAuthorizeFn = (args: {
+    token: string | null;
+}) => Promise<HandleAuthorizationIface | null>;
+export type HandleLifecycle = Pick<SandboxProviderHandleIface<NetworkSandboxSessionIface>, 'onSandboxStop' | 'onSandboxDelete' | 'onRuntimeShutdown'>;
+export interface HandleResolutionIface {
+    sandbox: NetworkSandboxSessionIface;
+    handle?: HandleLifecycle;
+    access?: HandleAccessPolicyIface;
+}
+export interface HandleRpcMessageHandlerOptionsIface {
+    send: (frame: WireFrame) => void;
+    close: (code: number, reason: string) => void;
+    authorize: HandleAuthorizeFn;
+    resolve: (authorization: HandleAuthorizationIface) => Promise<HandleResolutionIface>;
+    access?: HandleAccessPolicyIface;
+    connectionToken?: string | null;
+    binary?: boolean;
+    mcpChannels?: boolean;
+    now?: () => number;
+    authorizeOperation?: (context: RpcRequestContextIface) => Promise<void>;
+}
+export interface HandleRpcMessageHandlerIface {
+    onFrame(frame: WireFrame): void;
+    onClose(code?: number, reason?: string): void;
+}
+export declare const describeSandbox: (sandbox: NetworkSandboxSessionIface, mcpChannels?: boolean) => Promise<DescribeResultIface>;
+export declare const createHandleRpcMessageHandler: (options: HandleRpcMessageHandlerOptionsIface) => HandleRpcMessageHandlerIface;
+export interface ServeSandboxHandleArgsIface {
+    sandbox: NetworkSandboxSessionIface;
+    handle?: HandleLifecycle;
+    authorize: HandleAuthorizeFn;
+    access?: HandleAccessPolicyIface;
+    binary?: boolean;
+    mcpChannels?: boolean;
+    now?: () => number;
+}
+export interface SandboxHandleServerIface {
+    attach(channel: FrameChannelIface, context?: {
+        token?: string | null;
+    }): () => void;
+    attachWebSocket(socket: WebSocketLikeIface, context?: {
+        token?: string | null;
+    }): () => void;
+    attachStream(stream: FrameStreamIface, context?: {
+        token?: string | null;
+    }): () => void;
+    messageHandler(args: {
+        send: (frame: WireFrame) => void;
+        close: (code: number, reason: string) => void;
+        token?: string | null;
+    }): HandleRpcMessageHandlerIface;
+}
+export declare const serveSandboxHandle: (args: ServeSandboxHandleArgsIface) => SandboxHandleServerIface;

package/dist/modules/sandbox/server.mjs

@@ -0,0 +1,567 @@
+import * as z from "zod";
+import { narrowerSandboxAccess, SandboxAccess, sandboxAccessAtLeast } from "../manifest.mjs";
+import { base64ToBytes, bytesToStream } from "./bytes.mjs";
+import { confinedReadDir, confinedReadFile, confinedStat } from "./confined-files.mjs";
+import { createRpcPeer } from "./rpc-peer.mjs";
+import {
+  isMcpChannelEndpoint,
+  SandboxCapability
+} from "./types.mjs";
+import {
+  createFrameChannelPair,
+  frameChannelFromStream,
+  frameChannelFromWebSocket,
+  HANDLE_RPC_EXECUTE_METHODS,
+  HANDLE_RPC_FILE_WRITE_METHODS,
+  HANDLE_RPC_LIFECYCLE_METHODS,
+  HANDLE_RPC_VERSION,
+  HandleRpcCloseCode,
+  handleRpcError,
+  HandleRpcErrorCode,
+  HandleRpcMethod,
+  handleRpcMethodSchemas,
+  parseHandleRpcMethod
+} from "./wire.mjs";
+const DEFAULT_HANDLE_ACCESS = {
+  mode: SandboxAccess.Write,
+  lifecycle: false
+};
+const servesComputerUse = async (sandbox) => {
+  if (sandbox.computerUse == null) return false;
+  try {
+    return !isMcpChannelEndpoint(await sandbox.computerUse());
+  } catch {
+    return false;
+  }
+};
+const capabilitiesOf = async (sandbox, mcpChannels = false) => {
+  const capabilities = [SandboxCapability.Files, SandboxCapability.Process];
+  if (sandbox.ports.length > 0) capabilities.push(SandboxCapability.Ports);
+  if (sandbox.setNetworkPolicy != null) capabilities.push(SandboxCapability.NetworkPolicy);
+  if (mcpChannels ? sandbox.computerUse != null : await servesComputerUse(sandbox))
+    capabilities.push(SandboxCapability.ComputerUse);
+  if (sandbox.screen != null) capabilities.push(SandboxCapability.Screen);
+  if (sandbox.localMcp != null) capabilities.push(SandboxCapability.LocalMcp);
+  return capabilities;
+};
+const describeSandbox = async (sandbox, mcpChannels = false) => ({
+  handleRpcVersion: HANDLE_RPC_VERSION,
+  id: sandbox.id,
+  defaultWorkingDirectory: sandbox.defaultWorkingDirectory,
+  ports: [...sandbox.ports],
+  capabilities: await capabilitiesOf(sandbox, mcpChannels),
+  description: sandbox.description
+});
+const narrowAccess = (base, narrower) => narrower == null ? base : {
+  mode: narrowerSandboxAccess(base.mode, narrower.mode),
+  lifecycle: base.lifecycle && narrower.lifecycle
+};
+const parseParams = (schema, params) => {
+  const parsed = schema.safeParse(params);
+  if (!parsed.success) {
+    throw handleRpcError({
+      code: HandleRpcErrorCode.InvalidParams,
+      message: z.prettifyError(parsed.error)
+    });
+  }
+  return parsed.data;
+};
+const uploadStreamIdsSchema = z.object({
+  streamId: z.number().int().nonnegative().optional(),
+  stdinStreamId: z.number().int().nonnegative().nullable().optional()
+});
+const unsupported = (what) => handleRpcError({ code: HandleRpcErrorCode.Unsupported, message: `this sandbox has no ${what}` });
+const sliceStream = (source, offset, length) => {
+  let position = 0;
+  const end = length == null ? Number.POSITIVE_INFINITY : offset + length;
+  const reader = source.getReader();
+  return new ReadableStream({
+    pull: async (controller) => {
+      for (; ; ) {
+        if (position >= end) {
+          controller.close();
+          await reader.cancel().catch(() => void 0);
+          return;
+        }
+        const { done, value } = await reader.read();
+        if (done) {
+          controller.close();
+          return;
+        }
+        const chunkStart = position;
+        position += value.byteLength;
+        const from = Math.max(0, offset - chunkStart);
+        const to = Math.min(value.byteLength, end - chunkStart);
+        if (to > from) {
+          controller.enqueue(value.subarray(from, to));
+          return;
+        }
+      }
+    },
+    cancel: (reason) => reader.cancel(reason)
+  });
+};
+const createHandleRpcMessageHandler = (options) => {
+  const now = options.now ?? Date.now;
+  const [local, remote] = createFrameChannelPair();
+  let ended = false;
+  remote.listen({
+    frame: (frame) => options.send(frame),
+    close: (info) => {
+      if (!ended) {
+        ended = true;
+        options.close(info.code, info.reason);
+      }
+    }
+  });
+  const peerChannel = local;
+  const connection = createServerConnection({
+    channel: peerChannel,
+    authorize: options.authorize,
+    resolve: options.resolve,
+    access: options.access ?? DEFAULT_HANDLE_ACCESS,
+    connectionToken: options.connectionToken ?? null,
+    binary: options.binary ?? true,
+    mcpChannels: options.mcpChannels,
+    now,
+    authorizeOperation: options.authorizeOperation
+  });
+  return {
+    onFrame: (frame) => remote.send(frame),
+    onClose: (code, reason) => {
+      ended = true;
+      connection.close(code ?? 1e3, reason ?? "");
+    }
+  };
+};
+const createServerConnection = (args) => {
+  let sandbox = null;
+  let access = args.access;
+  let initializing = false;
+  let handle = null;
+  let expiryTimer = null;
+  const processes = /* @__PURE__ */ new Map();
+  const mcpEndpoints = /* @__PURE__ */ new Map();
+  const mcpConnections = /* @__PURE__ */ new Map();
+  let nextMcpChannelId = 0;
+  let shutdown = null;
+  const incomingByRequest = /* @__PURE__ */ new Map();
+  const scheduleExpiry = (expiresAt) => {
+    if (expiryTimer != null) clearTimeout(expiryTimer);
+    expiryTimer = null;
+    if (expiresAt == null) return;
+    const delay = Date.parse(expiresAt) - args.now();
+    if (Number.isNaN(delay)) return;
+    expiryTimer = setTimeout(
+      () => delay > 2147483647 ? scheduleExpiry(expiresAt) : peer.close(HandleRpcCloseCode.Unauthorized, "credential expired"),
+      Math.max(0, Math.min(2147483647, delay))
+    );
+  };
+  const requireSandbox = () => {
+    if (sandbox == null) {
+      throw handleRpcError({
+        code: HandleRpcErrorCode.NotInitialized,
+        message: "initialize first"
+      });
+    }
+    return sandbox;
+  };
+  const checkAccess = (method, params) => {
+    if (method === HandleRpcMethod.Screen && !parseParams(handleRpcMethodSchemas[method].params, params).viewOnly && !sandboxAccessAtLeast(access.mode, SandboxAccess.Execute))
+      throw handleRpcError({
+        code: HandleRpcErrorCode.Forbidden,
+        message: "Screen input control requires execute access"
+      });
+    if (!sandboxAccessAtLeast(access.mode, SandboxAccess.Execute) && HANDLE_RPC_EXECUTE_METHODS.includes(method)) {
+      throw handleRpcError({
+        code: HandleRpcErrorCode.Forbidden,
+        message: `${method} is not allowed on a read-only binding`
+      });
+    }
+    if (!sandboxAccessAtLeast(access.mode, SandboxAccess.Write) && HANDLE_RPC_FILE_WRITE_METHODS.includes(method)) {
+      throw handleRpcError({
+        code: HandleRpcErrorCode.Forbidden,
+        message: `${method} is not allowed without write access`
+      });
+    }
+    if (!access.lifecycle && HANDLE_RPC_LIFECYCLE_METHODS.includes(method)) {
+      throw handleRpcError({
+        code: HandleRpcErrorCode.Forbidden,
+        message: `${method} is not allowed on this binding`
+      });
+    }
+  };
+  const featureFlags = () => {
+    const flags = {};
+    if (handle != null) flags.providerHooks = true;
+    if (args.mcpChannels === true) flags.mcpChannels = true;
+    return flags;
+  };
+  const initialize = async (params) => {
+    const parsed = parseParams(handleRpcMethodSchemas[HandleRpcMethod.Initialize].params, params);
+    if (sandbox != null || initializing) {
+      throw handleRpcError({
+        code: HandleRpcErrorCode.InvalidRequest,
+        message: "already initialized"
+      });
+    }
+    initializing = true;
+    try {
+      const token = parsed.token ?? args.connectionToken;
+      const authorization = await args.authorize({ token });
+      if (authorization == null) {
+        setTimeout(() => peer.close(HandleRpcCloseCode.Unauthorized, "unauthorized"), 0);
+        throw handleRpcError({ code: HandleRpcErrorCode.Unauthorized, message: "unauthorized" });
+      }
+      const resolution = await args.resolve(authorization);
+      access = narrowAccess(narrowAccess(access, resolution.access), authorization.access);
+      sandbox = resolution.sandbox;
+      handle = resolution.handle ?? null;
+      scheduleExpiry(authorization.expiresAt);
+      return {
+        ...await describeSandbox(sandbox, args.mcpChannels),
+        confinedFiles: true,
+        ...featureFlags(),
+        expiresAt: authorization.expiresAt
+      };
+    } finally {
+      initializing = false;
+    }
+  };
+  const pump = (streamId, source) => {
+    peer.streams.openOutgoing(streamId, source).catch(() => void 0);
+  };
+  const mcpDescriptor = (endpoint, key) => {
+    if (!isMcpChannelEndpoint(endpoint)) return endpoint;
+    if (args.mcpChannels !== true) throw unsupported("MCP channels over the handle RPC");
+    mcpEndpoints.set(key, endpoint);
+    return { name: endpoint.name, endpointKey: key };
+  };
+  const mcpConnection = (id) => {
+    const channel = mcpConnections.get(id);
+    if (channel == null)
+      throw handleRpcError({
+        code: HandleRpcErrorCode.NotFound,
+        message: "MCP channel not found on this connection"
+      });
+    return channel;
+  };
+  const dispatch = async (context) => {
+    try {
+      return await dispatchMethod(context);
+    } catch (error) {
+      const entry = incomingByRequest.get(context.id);
+      incomingByRequest.delete(context.id);
+      if (entry != null) peer.streams.cancelIncoming(entry.streamId, "request failed");
+      throw error;
+    }
+  };
+  const dispatchMethod = async (context) => {
+    const method = parseHandleRpcMethod(context.method);
+    if (method == null) {
+      throw handleRpcError({
+        code: HandleRpcErrorCode.MethodNotFound,
+        message: `unknown method ${context.method}`
+      });
+    }
+    if (method === HandleRpcMethod.Initialize) return initialize(context.params);
+    const target = requireSandbox();
+    if (shutdown != null && method !== HandleRpcMethod.OnRuntimeShutdown)
+      throw handleRpcError({
+        code: HandleRpcErrorCode.ConnectionClosed,
+        message: "Provider handle is shutting down"
+      });
+    checkAccess(method, context.params);
+    parseParams(handleRpcMethodSchemas[method].params, context.params);
+    await args.authorizeOperation?.(context);
+    if (context.signal.aborted)
+      throw handleRpcError({ code: HandleRpcErrorCode.Cancelled, message: "request cancelled" });
+    const abortSignal = context.signal;
+    switch (method) {
+      case HandleRpcMethod.Describe:
+        return {
+          ...await describeSandbox(target, args.mcpChannels),
+          confinedFiles: true,
+          ...featureFlags()
+        };
+      case HandleRpcMethod.AuthRefresh: {
+        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);
+        const authorization = await args.authorize({ token: params.token });
+        if (authorization == null)
+          throw handleRpcError({ code: HandleRpcErrorCode.Unauthorized, message: "unauthorized" });
+        access = narrowAccess(access, authorization.access);
+        scheduleExpiry(authorization.expiresAt);
+        return { expiresAt: authorization.expiresAt };
+      }
+      case HandleRpcMethod.ReadFile: {
+        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);
+        const stream = params.root == null ? await target.readFile({ path: params.path, abortSignal }) : await (target.confinedFileReader?.readFile ?? ((options) => confinedReadFile(target, options)))({ path: params.path, root: params.root, abortSignal });
+        if (stream == null) return { found: false };
+        const ranged = params.offset != null || params.length != null ? sliceStream(stream, params.offset ?? 0, params.length) : stream;
+        pump(params.streamId, ranged);
+        return { found: true };
+      }
+      case HandleRpcMethod.ReadTextFile: {
+        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);
+        const text = await target.readTextFile({ ...params, abortSignal });
+        return { text };
+      }
+      case HandleRpcMethod.WriteFile: {
+        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);
+        const incoming = incomingByRequest.get(context.id)?.stream ?? null;
+        const content = incoming ?? bytesToStream(
+          params.contentBase64 == null ? new Uint8Array() : base64ToBytes(params.contentBase64)
+        );
+        await target.writeFile({ path: params.path, content, abortSignal });
+        incomingByRequest.delete(context.id);
+        return {};
+      }
+      case HandleRpcMethod.Spawn: {
+        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);
+        const stdin = incomingByRequest.get(context.id)?.stream ?? null;
+        if (processes.has(params.processId)) {
+          throw handleRpcError({
+            code: HandleRpcErrorCode.InvalidParams,
+            message: "processId already in use"
+          });
+        }
+        const child = await target.spawn({
+          command: params.command,
+          args: params.args,
+          cwd: params.cwd,
+          env: params.env,
+          shell: params.shell,
+          timeoutMs: params.timeoutMs,
+          // A closed stdin is an empty stream.
+          stdin: stdin ?? ""
+        });
+        incomingByRequest.delete(context.id);
+        processes.set(params.processId, child);
+        pump(params.stdoutStreamId, child.stdout);
+        pump(params.stderrStreamId, child.stderr);
+        return { pid: child.pid };
+      }
+      case HandleRpcMethod.ProcessWait: {
+        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);
+        const child = processes.get(params.processId);
+        if (child == null)
+          throw handleRpcError({ code: HandleRpcErrorCode.NotFound, message: "no such process" });
+        const result = await new Promise((resolve, reject) => {
+          const onAbort = () => reject(handleRpcError({ code: HandleRpcErrorCode.Cancelled, message: "cancelled" }));
+          abortSignal.addEventListener("abort", onAbort, { once: true });
+          child.wait().then(
+            (value) => {
+              abortSignal.removeEventListener("abort", onAbort);
+              resolve(value);
+            },
+            (cause) => {
+              abortSignal.removeEventListener("abort", onAbort);
+              reject(cause);
+            }
+          );
+        });
+        processes.delete(params.processId);
+        return result;
+      }
+      case HandleRpcMethod.ProcessKill: {
+        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);
+        const child = processes.get(params.processId);
+        if (child == null)
+          throw handleRpcError({ code: HandleRpcErrorCode.NotFound, message: "no such process" });
+        await child.kill(params.signal);
+        return {};
+      }
+      case HandleRpcMethod.Run: {
+        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);
+        return target.run({ ...params, abortSignal });
+      }
+      case HandleRpcMethod.Stat: {
+        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);
+        return {
+          stat: params.root == null ? await target.stat({ path: params.path, abortSignal }) : await (target.confinedFileReader?.stat ?? ((options) => confinedStat(target, options)))({
+            path: params.path,
+            root: params.root,
+            abortSignal
+          })
+        };
+      }
+      case HandleRpcMethod.ReadDir: {
+        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);
+        return {
+          entries: params.root == null ? await target.readDir({ path: params.path, abortSignal }) : await (target.confinedFileReader?.readDir ?? ((options) => confinedReadDir(target, options)))({
+            path: params.path,
+            root: params.root,
+            abortSignal
+          })
+        };
+      }
+      case HandleRpcMethod.RemovePath: {
+        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);
+        await target.removePath({ ...params, abortSignal });
+        return {};
+      }
+      case HandleRpcMethod.GetPortEndpoint: {
+        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);
+        return target.getPortEndpoint(params);
+      }
+      case HandleRpcMethod.Stop:
+        await target.stop();
+        return {};
+      case HandleRpcMethod.Destroy:
+        await target.destroy();
+        return {};
+      case HandleRpcMethod.OnRuntimeShutdown: {
+        if (handle == null) throw unsupported("provider lifecycle hooks");
+        const shutdownHandle = handle;
+        shutdown ??= (async () => {
+          await Promise.allSettled([...processes.values()].map((child) => child.kill()));
+          await Promise.allSettled([...mcpConnections.values()].map((channel) => channel.close()));
+          processes.clear();
+          mcpConnections.clear();
+          mcpEndpoints.clear();
+          await shutdownHandle.onRuntimeShutdown();
+        })();
+        await shutdown;
+        return {};
+      }
+      case HandleRpcMethod.OnSandboxStop:
+        if (handle == null) throw unsupported("provider lifecycle hooks");
+        await handle.onSandboxStop();
+        return {};
+      case HandleRpcMethod.OnSandboxDelete: {
+        if (handle == null) throw unsupported("provider lifecycle hooks");
+        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);
+        await handle.onSandboxDelete(params);
+        return {};
+      }
+      case HandleRpcMethod.SetNetworkPolicy: {
+        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);
+        if (target.setNetworkPolicy == null) throw unsupported("network policy");
+        await target.setNetworkPolicy(params);
+        return {};
+      }
+      case HandleRpcMethod.ComputerUse: {
+        if (target.computerUse == null) throw unsupported("computer use");
+        const endpoint = await target.computerUse();
+        return mcpDescriptor(endpoint, "computerUse");
+      }
+      case HandleRpcMethod.McpOpen: {
+        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);
+        const endpoint = mcpEndpoints.get(params.endpointKey);
+        if (args.mcpChannels !== true || endpoint == null)
+          throw unsupported("MCP channel endpoint");
+        const channel = await endpoint.connect({ abortSignal });
+        if (abortSignal.aborted) {
+          await channel.close();
+          abortSignal.throwIfAborted();
+        }
+        const channelId = String(++nextMcpChannelId);
+        mcpConnections.set(channelId, channel);
+        return { channelId };
+      }
+      case HandleRpcMethod.McpSend: {
+        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);
+        await mcpConnection(params.channelId).send(params.message, { abortSignal });
+        return {};
+      }
+      case HandleRpcMethod.McpReceive: {
+        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);
+        return { messages: await mcpConnection(params.channelId).receive({ abortSignal }) };
+      }
+      case HandleRpcMethod.McpClose: {
+        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);
+        const channel = mcpConnection(params.channelId);
+        await channel.close();
+        mcpConnections.delete(params.channelId);
+        return {};
+      }
+      case HandleRpcMethod.Screen: {
+        if (target.screen == null) throw unsupported("screen");
+        const params = parseParams(handleRpcMethodSchemas[method].params, context.params);
+        return target.screen(params);
+      }
+      case HandleRpcMethod.LocalMcp:
+        if (target.localMcp == null) throw unsupported("local MCP servers");
+        return {
+          endpoints: (await target.localMcp()).flatMap(
+            (endpoint, index) => args.mcpChannels !== true && isMcpChannelEndpoint(endpoint) ? [] : [mcpDescriptor(endpoint, `localMcp:${index}:${endpoint.name}`)]
+          )
+        };
+    }
+  };
+  const beforeRequest = (context) => {
+    if (context.method !== HandleRpcMethod.WriteFile && context.method !== HandleRpcMethod.Spawn)
+      return;
+    const ids = uploadStreamIdsSchema.safeParse(context.params);
+    if (!ids.success) return;
+    const streamId = context.method === HandleRpcMethod.WriteFile ? ids.data.streamId : ids.data.stdinStreamId;
+    if (streamId == null) return;
+    const stream = peer.streams.openIncoming(streamId);
+    const floor = context.method === HandleRpcMethod.WriteFile ? SandboxAccess.Write : SandboxAccess.Execute;
+    if (sandbox == null || !sandboxAccessAtLeast(access.mode, floor)) {
+      peer.streams.cancelIncoming(streamId, "rejected");
+      return;
+    }
+    incomingByRequest.set(context.id, { streamId, stream });
+  };
+  const onClose = () => {
+    if (expiryTimer != null) clearTimeout(expiryTimer);
+    for (const child of processes.values()) child.kill().catch(() => void 0);
+    for (const channel of mcpConnections.values()) void channel.close().catch(() => void 0);
+    mcpConnections.clear();
+    mcpEndpoints.clear();
+    processes.clear();
+    incomingByRequest.clear();
+  };
+  const peer = createRpcPeer({
+    channel: args.channel,
+    binary: args.binary,
+    onRequest: dispatch,
+    beforeRequest,
+    onClose
+  });
+  return { close: (code, reason) => peer.close(code, reason) };
+};
+const serveSandboxHandle = (args) => {
+  const access = args.access ?? DEFAULT_HANDLE_ACCESS;
+  const resolve = async () => ({
+    sandbox: args.sandbox,
+    handle: args.handle
+  });
+  const attach = (channel, context) => {
+    const connection = createServerConnection({
+      channel,
+      authorize: args.authorize,
+      resolve,
+      access,
+      connectionToken: context?.token ?? null,
+      binary: args.binary ?? true,
+      mcpChannels: args.mcpChannels,
+      now: args.now ?? Date.now
+    });
+    return () => connection.close(HandleRpcCloseCode.Normal, "closed");
+  };
+  return {
+    attach,
+    attachWebSocket: (socket, context) => attach(frameChannelFromWebSocket(socket).channel, context),
+    attachStream: (stream, context) => attach(frameChannelFromStream(stream), context),
+    messageHandler: (handlerArgs) => createHandleRpcMessageHandler({
+      send: handlerArgs.send,
+      close: handlerArgs.close,
+      authorize: args.authorize,
+      resolve,
+      access,
+      connectionToken: handlerArgs.token ?? null,
+      binary: args.binary,
+      mcpChannels: args.mcpChannels,
+      now: args.now
+    })
+  };
+};
+export {
+  DEFAULT_HANDLE_ACCESS,
+  createHandleRpcMessageHandler,
+  describeSandbox,
+  serveSandboxHandle
+};
+//# sourceMappingURL=server.mjs.map