@finalai/agent-provider 0.1.0

package/dist/modules/sandbox/wire.mjs

@@ -0,0 +1,537 @@
+import * as z from "zod";
+import { jsonValueSchema } from "../json.mjs";
+import { NetworkPolicy, PortProtocol, SandboxCapability, SandboxEntryType } from "./types.mjs";
+const HANDLE_RPC_VERSION = 1;
+const HANDLE_RPC_SUBPROTOCOL = "final.handle-rpc.v1";
+const HANDLE_RPC_BEARER_PROTOCOL_PREFIX = "bearer.";
+const MAX_CHUNK_BYTES = 256 * 1024;
+const INITIAL_STREAM_WINDOW_BYTES = 1024 * 1024;
+const MAX_INLINE_WRITE_BYTES = 64 * 1024;
+const BINARY_FRAME_MAGIC = 241;
+const BINARY_FRAME_HEADER_BYTES = 6;
+const MAX_STREAM_ID = 4294967295;
+var BinaryFrameKind = /* @__PURE__ */ ((BinaryFrameKind2) => {
+  BinaryFrameKind2[BinaryFrameKind2["Chunk"] = 1] = "Chunk";
+  return BinaryFrameKind2;
+})(BinaryFrameKind || {});
+var HandleRpcCloseCode = /* @__PURE__ */ ((HandleRpcCloseCode2) => {
+  HandleRpcCloseCode2[HandleRpcCloseCode2["Normal"] = 1e3] = "Normal";
+  HandleRpcCloseCode2[HandleRpcCloseCode2["ProtocolError"] = 4400] = "ProtocolError";
+  HandleRpcCloseCode2[HandleRpcCloseCode2["Unauthorized"] = 4401] = "Unauthorized";
+  return HandleRpcCloseCode2;
+})(HandleRpcCloseCode || {});
+var HandleRpcErrorCode = /* @__PURE__ */ ((HandleRpcErrorCode2) => {
+  HandleRpcErrorCode2[HandleRpcErrorCode2["ParseError"] = -32700] = "ParseError";
+  HandleRpcErrorCode2[HandleRpcErrorCode2["InvalidRequest"] = -32600] = "InvalidRequest";
+  HandleRpcErrorCode2[HandleRpcErrorCode2["MethodNotFound"] = -32601] = "MethodNotFound";
+  HandleRpcErrorCode2[HandleRpcErrorCode2["InvalidParams"] = -32602] = "InvalidParams";
+  HandleRpcErrorCode2[HandleRpcErrorCode2["Internal"] = -32603] = "Internal";
+  HandleRpcErrorCode2[HandleRpcErrorCode2["Unauthorized"] = -32001] = "Unauthorized";
+  HandleRpcErrorCode2[HandleRpcErrorCode2["NotInitialized"] = -32002] = "NotInitialized";
+  HandleRpcErrorCode2[HandleRpcErrorCode2["Forbidden"] = -32010] = "Forbidden";
+  HandleRpcErrorCode2[HandleRpcErrorCode2["NotFound"] = -32011] = "NotFound";
+  HandleRpcErrorCode2[HandleRpcErrorCode2["Unsupported"] = -32012] = "Unsupported";
+  HandleRpcErrorCode2[HandleRpcErrorCode2["ConnectionClosed"] = -32013] = "ConnectionClosed";
+  HandleRpcErrorCode2[HandleRpcErrorCode2["Timeout"] = -32014] = "Timeout";
+  HandleRpcErrorCode2[HandleRpcErrorCode2["Cancelled"] = -32800] = "Cancelled";
+  return HandleRpcErrorCode2;
+})(HandleRpcErrorCode || {});
+var HandleRpcMethod = /* @__PURE__ */ ((HandleRpcMethod2) => {
+  HandleRpcMethod2["Initialize"] = "initialize";
+  HandleRpcMethod2["Describe"] = "sandbox/describe";
+  HandleRpcMethod2["ReadFile"] = "sandbox/readFile";
+  HandleRpcMethod2["ReadTextFile"] = "sandbox/readTextFile";
+  HandleRpcMethod2["WriteFile"] = "sandbox/writeFile";
+  HandleRpcMethod2["Spawn"] = "sandbox/spawn";
+  HandleRpcMethod2["Run"] = "sandbox/run";
+  HandleRpcMethod2["Stat"] = "sandbox/stat";
+  HandleRpcMethod2["ReadDir"] = "sandbox/readDir";
+  HandleRpcMethod2["RemovePath"] = "sandbox/removePath";
+  HandleRpcMethod2["GetPortEndpoint"] = "sandbox/getPortEndpoint";
+  HandleRpcMethod2["Stop"] = "sandbox/stop";
+  HandleRpcMethod2["Destroy"] = "sandbox/destroy";
+  HandleRpcMethod2["SetNetworkPolicy"] = "sandbox/setNetworkPolicy";
+  HandleRpcMethod2["OnSandboxStop"] = "handle/onSandboxStop";
+  HandleRpcMethod2["OnSandboxDelete"] = "handle/onSandboxDelete";
+  HandleRpcMethod2["OnRuntimeShutdown"] = "handle/onRuntimeShutdown";
+  HandleRpcMethod2["ComputerUse"] = "sandbox/computerUse";
+  HandleRpcMethod2["Screen"] = "sandbox/screen";
+  HandleRpcMethod2["LocalMcp"] = "sandbox/localMcp";
+  HandleRpcMethod2["McpOpen"] = "mcp/open";
+  HandleRpcMethod2["McpSend"] = "mcp/send";
+  HandleRpcMethod2["McpReceive"] = "mcp/receive";
+  HandleRpcMethod2["McpClose"] = "mcp/close";
+  HandleRpcMethod2["ProcessWait"] = "process/wait";
+  HandleRpcMethod2["ProcessKill"] = "process/kill";
+  HandleRpcMethod2["AuthRefresh"] = "auth/refresh";
+  return HandleRpcMethod2;
+})(HandleRpcMethod || {});
+var HandleRpcNotification = /* @__PURE__ */ ((HandleRpcNotification2) => {
+  HandleRpcNotification2["CancelRequest"] = "$/cancel_request";
+  HandleRpcNotification2["StreamChunk"] = "stream/chunk";
+  HandleRpcNotification2["StreamEnd"] = "stream/end";
+  HandleRpcNotification2["StreamError"] = "stream/error";
+  HandleRpcNotification2["StreamCredit"] = "stream/credit";
+  HandleRpcNotification2["StreamCancel"] = "stream/cancel";
+  return HandleRpcNotification2;
+})(HandleRpcNotification || {});
+const handleRpcError = (args) => Object.assign(new Error(args.message), {
+  name: "HandleRpcError",
+  code: args.code,
+  retryable: args.retryable ?? false,
+  errno: args.errno ?? null,
+  data: args.data ?? null
+});
+const handleRpcErrorFieldsSchema = z.object({ code: z.number(), retryable: z.boolean() });
+const errnoFieldsSchema = z.object({ code: z.string() });
+const isHandleRpcError = (cause) => cause instanceof Error && handleRpcErrorFieldsSchema.safeParse(cause).success;
+const errnoOf = (cause) => {
+  if (isHandleRpcError(cause)) return cause.errno;
+  if (!(cause instanceof Error)) return null;
+  const parsed = errnoFieldsSchema.safeParse(cause);
+  return parsed.success ? parsed.data.code : null;
+};
+const jsonRpcIdSchema = z.union([z.string(), z.number().int()]);
+const jsonRpcRequestSchema = z.object({
+  jsonrpc: z.literal("2.0"),
+  id: jsonRpcIdSchema,
+  method: z.string().min(1),
+  params: jsonValueSchema.optional()
+});
+const jsonRpcNotificationSchema = z.object({
+  jsonrpc: z.literal("2.0"),
+  method: z.string().min(1),
+  params: jsonValueSchema.optional()
+});
+const jsonRpcErrorObjectSchema = z.object({
+  code: z.number().int(),
+  message: z.string(),
+  data: jsonValueSchema.optional()
+});
+const jsonRpcSuccessSchema = z.object({
+  jsonrpc: z.literal("2.0"),
+  id: jsonRpcIdSchema,
+  result: jsonValueSchema
+});
+const jsonRpcErrorResponseSchema = z.object({
+  jsonrpc: z.literal("2.0"),
+  id: jsonRpcIdSchema.nullable(),
+  error: jsonRpcErrorObjectSchema
+});
+const handleRpcErrorDataSchema = z.object({
+  errno: z.string().nullable().optional(),
+  retryable: z.boolean().optional()
+});
+const streamIdSchema = z.number().int().min(0).max(MAX_STREAM_ID);
+const pathSchema = z.string().min(1);
+const isSandboxCapability = (value) => Object.values(SandboxCapability).some((capability) => capability === value);
+const sandboxCapabilitiesSchema = z.array(z.string()).transform((values) => values.filter(isSandboxCapability));
+const isSandboxEntryType = (value) => Object.values(SandboxEntryType).some((entryType) => entryType === value);
+const entryTypeSchema = z.string().transform((value) => isSandboxEntryType(value) ? value : SandboxEntryType.Other);
+const statSchema = z.object({
+  path: z.string(),
+  type: entryTypeSchema,
+  size: z.number().nonnegative(),
+  modifiedAt: z.string().nullable(),
+  mode: z.number().int().nullable()
+});
+const dirEntrySchema = z.object({
+  name: z.string(),
+  path: z.string(),
+  type: entryTypeSchema,
+  size: z.number().nonnegative().nullable()
+});
+const mcpEndpointSchema = z.object({
+  name: z.string(),
+  url: z.string(),
+  headers: z.record(z.string(), z.string())
+});
+const mcpChannelEndpointSchema = z.object({
+  name: z.string(),
+  endpointKey: z.string().min(1)
+});
+const sandboxMcpEndpointSchema = z.union([mcpEndpointSchema, mcpChannelEndpointSchema]);
+const screenOptionsSchema = z.strictObject({ viewOnly: z.boolean().default(true) });
+const screenSessionSchema = z.object({
+  url: z.string(),
+  token: z.string(),
+  expiresAt: z.string()
+});
+const describeResultSchema = z.object({
+  handleRpcVersion: z.literal(HANDLE_RPC_VERSION),
+  id: z.string(),
+  defaultWorkingDirectory: z.string(),
+  ports: z.array(z.number().int()),
+  capabilities: sandboxCapabilitiesSchema,
+  description: z.string(),
+  confinedFiles: z.boolean().optional(),
+  providerHooks: z.boolean().optional(),
+  mcpChannels: z.boolean().optional()
+});
+const initializeParamsSchema = z.object({
+  handleRpcVersion: z.literal(HANDLE_RPC_VERSION),
+  token: z.string().nullable().optional(),
+  client: z.object({ name: z.string(), version: z.string() }).optional()
+});
+const initializeResultSchema = describeResultSchema.extend({
+  // When the connection's credential expires (null: never).
+  expiresAt: z.string().nullable()
+});
+const emptySchema = z.object({}).passthrough();
+const emptyResultSchema = z.object({}).passthrough();
+const processOptionFields = {
+  command: z.string().min(1),
+  args: z.array(z.string()).optional(),
+  cwd: z.string().optional(),
+  env: z.record(z.string(), z.string()).optional(),
+  shell: z.boolean().optional(),
+  timeoutMs: z.number().int().positive().optional()
+};
+const readFileParamsSchema = z.object({
+  root: pathSchema.optional(),
+  path: pathSchema,
+  streamId: streamIdSchema,
+  // Byte range; omitted reads the whole file.
+  offset: z.number().int().nonnegative().optional(),
+  length: z.number().int().nonnegative().optional()
+});
+const readFileResultSchema = z.object({
+  found: z.boolean()
+});
+const readTextFileParamsSchema = z.object({
+  path: pathSchema,
+  encoding: z.string().optional(),
+  startLine: z.number().int().positive().optional(),
+  endLine: z.number().int().positive().optional()
+});
+const readTextFileResultSchema = z.object({ text: z.string().nullable() });
+const writeFileParamsSchema = z.object({
+  path: pathSchema,
+  streamId: streamIdSchema.optional(),
+  contentBase64: z.string().optional()
+}).refine((params) => params.streamId == null !== (params.contentBase64 == null), {
+  message: "exactly one of streamId and contentBase64 is required"
+});
+const spawnParamsSchema = z.object({
+  ...processOptionFields,
+  // Client-chosen handle for process/wait and process/kill.
+  processId: z.string().min(1),
+  // Null means stdin is closed from the start.
+  stdinStreamId: streamIdSchema.nullable(),
+  stdoutStreamId: streamIdSchema,
+  stderrStreamId: streamIdSchema
+});
+const spawnResultSchema = z.object({ pid: z.string().nullable() });
+const runParamsSchema = z.object({
+  ...processOptionFields,
+  stdin: z.string().optional()
+});
+const runResultSchema = z.object({
+  exitCode: z.number().int(),
+  stdout: z.string(),
+  stderr: z.string()
+});
+const pathParamsSchema = z.object({ path: pathSchema, root: pathSchema.optional() });
+const statResultSchema = z.object({ stat: statSchema.nullable() });
+const readDirResultSchema = z.object({ entries: z.array(dirEntrySchema) });
+const removePathParamsSchema = z.object({
+  path: pathSchema,
+  recursive: z.boolean().optional(),
+  force: z.boolean().optional()
+});
+const getPortEndpointParamsSchema = z.object({
+  port: z.number().int().min(1).max(65535),
+  protocol: z.nativeEnum(PortProtocol).optional()
+});
+const getPortEndpointResultSchema = z.object({
+  url: z.string(),
+  headers: z.record(z.string(), z.string()).optional()
+});
+const setNetworkPolicyParamsSchema = z.object({
+  mode: z.nativeEnum(NetworkPolicy),
+  allow: z.array(z.string()).optional()
+});
+const sandboxDeleteHookParamsSchema = z.object({ reason: z.string().optional() });
+const localMcpResultSchema = z.object({ endpoints: z.array(sandboxMcpEndpointSchema) });
+const mcpOpenParamsSchema = z.object({ endpointKey: z.string().min(1) });
+const mcpChannelParamsSchema = z.object({ channelId: z.string().min(1) });
+const mcpSendParamsSchema = mcpChannelParamsSchema.extend({ message: jsonValueSchema });
+const mcpOpenResultSchema = mcpChannelParamsSchema;
+const mcpReceiveResultSchema = z.object({ messages: z.array(jsonValueSchema) });
+const processIdParamsSchema = z.object({ processId: z.string().min(1) });
+const processWaitResultSchema = z.object({ exitCode: z.number().int() });
+const processKillParamsSchema = z.object({
+  processId: z.string().min(1),
+  signal: z.string().optional()
+});
+const authRefreshParamsSchema = z.object({ token: z.string().min(1) });
+const authRefreshResultSchema = z.object({ expiresAt: z.string().nullable() });
+const cancelRequestParamsSchema = z.object({ requestId: jsonRpcIdSchema });
+const streamChunkParamsSchema = z.object({ streamId: streamIdSchema, data: z.string() });
+const streamEndParamsSchema = z.object({ streamId: streamIdSchema });
+const streamErrorParamsSchema = z.object({
+  streamId: streamIdSchema,
+  message: z.string(),
+  code: z.number().int().optional(),
+  errno: z.string().nullable().optional()
+});
+const streamCreditParamsSchema = z.object({
+  streamId: streamIdSchema,
+  bytes: z.number().int().positive()
+});
+const streamCancelParamsSchema = z.object({
+  streamId: streamIdSchema,
+  reason: z.string().optional()
+});
+const handleRpcMethodSchemas = {
+  ["initialize" /* Initialize */]: { params: initializeParamsSchema, result: initializeResultSchema },
+  ["sandbox/describe" /* Describe */]: { params: emptySchema, result: describeResultSchema },
+  ["sandbox/readFile" /* ReadFile */]: { params: readFileParamsSchema, result: readFileResultSchema },
+  ["sandbox/readTextFile" /* ReadTextFile */]: {
+    params: readTextFileParamsSchema,
+    result: readTextFileResultSchema
+  },
+  ["sandbox/writeFile" /* WriteFile */]: { params: writeFileParamsSchema, result: emptyResultSchema },
+  ["sandbox/spawn" /* Spawn */]: { params: spawnParamsSchema, result: spawnResultSchema },
+  ["sandbox/run" /* Run */]: { params: runParamsSchema, result: runResultSchema },
+  ["sandbox/stat" /* Stat */]: { params: pathParamsSchema, result: statResultSchema },
+  ["sandbox/readDir" /* ReadDir */]: { params: pathParamsSchema, result: readDirResultSchema },
+  ["sandbox/removePath" /* RemovePath */]: { params: removePathParamsSchema, result: emptyResultSchema },
+  ["sandbox/getPortEndpoint" /* GetPortEndpoint */]: {
+    params: getPortEndpointParamsSchema,
+    result: getPortEndpointResultSchema
+  },
+  ["sandbox/stop" /* Stop */]: { params: emptySchema, result: emptyResultSchema },
+  ["sandbox/destroy" /* Destroy */]: { params: emptySchema, result: emptyResultSchema },
+  ["handle/onSandboxStop" /* OnSandboxStop */]: { params: emptySchema, result: emptyResultSchema },
+  ["handle/onSandboxDelete" /* OnSandboxDelete */]: {
+    params: sandboxDeleteHookParamsSchema,
+    result: emptyResultSchema
+  },
+  ["handle/onRuntimeShutdown" /* OnRuntimeShutdown */]: { params: emptySchema, result: emptyResultSchema },
+  ["sandbox/setNetworkPolicy" /* SetNetworkPolicy */]: {
+    params: setNetworkPolicyParamsSchema,
+    result: emptyResultSchema
+  },
+  ["sandbox/computerUse" /* ComputerUse */]: { params: emptySchema, result: sandboxMcpEndpointSchema },
+  ["sandbox/screen" /* Screen */]: { params: screenOptionsSchema, result: screenSessionSchema },
+  ["sandbox/localMcp" /* LocalMcp */]: { params: emptySchema, result: localMcpResultSchema },
+  ["mcp/open" /* McpOpen */]: { params: mcpOpenParamsSchema, result: mcpOpenResultSchema },
+  ["mcp/send" /* McpSend */]: { params: mcpSendParamsSchema, result: emptyResultSchema },
+  ["mcp/receive" /* McpReceive */]: { params: mcpChannelParamsSchema, result: mcpReceiveResultSchema },
+  ["mcp/close" /* McpClose */]: { params: mcpChannelParamsSchema, result: emptyResultSchema },
+  ["process/wait" /* ProcessWait */]: { params: processIdParamsSchema, result: processWaitResultSchema },
+  ["process/kill" /* ProcessKill */]: { params: processKillParamsSchema, result: emptyResultSchema },
+  ["auth/refresh" /* AuthRefresh */]: {
+    params: authRefreshParamsSchema,
+    result: authRefreshResultSchema
+  }
+};
+const handleRpcNotificationSchemas = {
+  ["$/cancel_request" /* CancelRequest */]: cancelRequestParamsSchema,
+  ["stream/chunk" /* StreamChunk */]: streamChunkParamsSchema,
+  ["stream/end" /* StreamEnd */]: streamEndParamsSchema,
+  ["stream/error" /* StreamError */]: streamErrorParamsSchema,
+  ["stream/credit" /* StreamCredit */]: streamCreditParamsSchema,
+  ["stream/cancel" /* StreamCancel */]: streamCancelParamsSchema
+};
+const handleRpcResultParsers = {
+  ["initialize" /* Initialize */]: (raw) => handleRpcMethodSchemas["initialize" /* Initialize */].result.parse(raw),
+  ["sandbox/describe" /* Describe */]: (raw) => handleRpcMethodSchemas["sandbox/describe" /* Describe */].result.parse(raw),
+  ["sandbox/readFile" /* ReadFile */]: (raw) => handleRpcMethodSchemas["sandbox/readFile" /* ReadFile */].result.parse(raw),
+  ["sandbox/readTextFile" /* ReadTextFile */]: (raw) => handleRpcMethodSchemas["sandbox/readTextFile" /* ReadTextFile */].result.parse(raw),
+  ["sandbox/writeFile" /* WriteFile */]: (raw) => handleRpcMethodSchemas["sandbox/writeFile" /* WriteFile */].result.parse(raw),
+  ["sandbox/spawn" /* Spawn */]: (raw) => handleRpcMethodSchemas["sandbox/spawn" /* Spawn */].result.parse(raw),
+  ["sandbox/run" /* Run */]: (raw) => handleRpcMethodSchemas["sandbox/run" /* Run */].result.parse(raw),
+  ["sandbox/stat" /* Stat */]: (raw) => handleRpcMethodSchemas["sandbox/stat" /* Stat */].result.parse(raw),
+  ["sandbox/readDir" /* ReadDir */]: (raw) => handleRpcMethodSchemas["sandbox/readDir" /* ReadDir */].result.parse(raw),
+  ["sandbox/removePath" /* RemovePath */]: (raw) => handleRpcMethodSchemas["sandbox/removePath" /* RemovePath */].result.parse(raw),
+  ["sandbox/getPortEndpoint" /* GetPortEndpoint */]: (raw) => handleRpcMethodSchemas["sandbox/getPortEndpoint" /* GetPortEndpoint */].result.parse(raw),
+  ["sandbox/stop" /* Stop */]: (raw) => handleRpcMethodSchemas["sandbox/stop" /* Stop */].result.parse(raw),
+  ["sandbox/destroy" /* Destroy */]: (raw) => handleRpcMethodSchemas["sandbox/destroy" /* Destroy */].result.parse(raw),
+  ["handle/onRuntimeShutdown" /* OnRuntimeShutdown */]: (raw) => handleRpcMethodSchemas["handle/onRuntimeShutdown" /* OnRuntimeShutdown */].result.parse(raw),
+  ["handle/onSandboxStop" /* OnSandboxStop */]: (raw) => handleRpcMethodSchemas["handle/onSandboxStop" /* OnSandboxStop */].result.parse(raw),
+  ["handle/onSandboxDelete" /* OnSandboxDelete */]: (raw) => handleRpcMethodSchemas["handle/onSandboxDelete" /* OnSandboxDelete */].result.parse(raw),
+  ["sandbox/setNetworkPolicy" /* SetNetworkPolicy */]: (raw) => handleRpcMethodSchemas["sandbox/setNetworkPolicy" /* SetNetworkPolicy */].result.parse(raw),
+  ["sandbox/computerUse" /* ComputerUse */]: (raw) => handleRpcMethodSchemas["sandbox/computerUse" /* ComputerUse */].result.parse(raw),
+  ["sandbox/screen" /* Screen */]: (raw) => handleRpcMethodSchemas["sandbox/screen" /* Screen */].result.parse(raw),
+  ["sandbox/localMcp" /* LocalMcp */]: (raw) => handleRpcMethodSchemas["sandbox/localMcp" /* LocalMcp */].result.parse(raw),
+  ["mcp/open" /* McpOpen */]: (raw) => handleRpcMethodSchemas["mcp/open" /* McpOpen */].result.parse(raw),
+  ["mcp/send" /* McpSend */]: (raw) => handleRpcMethodSchemas["mcp/send" /* McpSend */].result.parse(raw),
+  ["mcp/receive" /* McpReceive */]: (raw) => handleRpcMethodSchemas["mcp/receive" /* McpReceive */].result.parse(raw),
+  ["mcp/close" /* McpClose */]: (raw) => handleRpcMethodSchemas["mcp/close" /* McpClose */].result.parse(raw),
+  ["process/wait" /* ProcessWait */]: (raw) => handleRpcMethodSchemas["process/wait" /* ProcessWait */].result.parse(raw),
+  ["process/kill" /* ProcessKill */]: (raw) => handleRpcMethodSchemas["process/kill" /* ProcessKill */].result.parse(raw),
+  ["auth/refresh" /* AuthRefresh */]: (raw) => handleRpcMethodSchemas["auth/refresh" /* AuthRefresh */].result.parse(raw)
+};
+const parseHandleRpcResult = (method, raw) => handleRpcResultParsers[method](raw);
+const isHandleRpcMethod = (value) => Object.values(HandleRpcMethod).some((method) => method === value);
+const parseHandleRpcMethod = (method) => isHandleRpcMethod(method) ? method : null;
+const HANDLE_RPC_FILE_WRITE_METHODS = [
+  "sandbox/writeFile" /* WriteFile */,
+  "sandbox/removePath" /* RemovePath */
+];
+const HANDLE_RPC_EXECUTE_METHODS = [
+  "sandbox/spawn" /* Spawn */,
+  "sandbox/run" /* Run */,
+  "process/wait" /* ProcessWait */,
+  "process/kill" /* ProcessKill */,
+  "sandbox/computerUse" /* ComputerUse */,
+  "sandbox/localMcp" /* LocalMcp */,
+  "mcp/open" /* McpOpen */,
+  "mcp/send" /* McpSend */,
+  "mcp/receive" /* McpReceive */,
+  "mcp/close" /* McpClose */
+];
+const HANDLE_RPC_WRITE_METHODS = [
+  ...HANDLE_RPC_FILE_WRITE_METHODS,
+  ...HANDLE_RPC_EXECUTE_METHODS
+];
+const HANDLE_RPC_LIFECYCLE_METHODS = [
+  "handle/onSandboxStop" /* OnSandboxStop */,
+  "handle/onSandboxDelete" /* OnSandboxDelete */,
+  "handle/onRuntimeShutdown" /* OnRuntimeShutdown */,
+  "sandbox/stop" /* Stop */,
+  "sandbox/destroy" /* Destroy */,
+  "sandbox/setNetworkPolicy" /* SetNetworkPolicy */
+];
+const HANDLE_RPC_IDEMPOTENT_METHODS = [
+  "sandbox/describe" /* Describe */,
+  "sandbox/readTextFile" /* ReadTextFile */,
+  "sandbox/stat" /* Stat */,
+  "sandbox/readDir" /* ReadDir */,
+  "sandbox/getPortEndpoint" /* GetPortEndpoint */,
+  "sandbox/screen" /* Screen */,
+  "sandbox/computerUse" /* ComputerUse */,
+  "sandbox/localMcp" /* LocalMcp */
+];
+const encodeChunkFrame = (streamId, payload) => {
+  const frame = new Uint8Array(BINARY_FRAME_HEADER_BYTES + payload.byteLength);
+  frame[0] = BINARY_FRAME_MAGIC;
+  frame[1] = 1 /* Chunk */;
+  new DataView(frame.buffer, frame.byteOffset, frame.byteLength).setUint32(2, streamId, false);
+  frame.set(payload, BINARY_FRAME_HEADER_BYTES);
+  return frame;
+};
+const decodeBinaryFrame = (frame) => {
+  if (frame.byteLength < BINARY_FRAME_HEADER_BYTES || frame[0] !== BINARY_FRAME_MAGIC) return null;
+  if (frame[1] !== 1 /* Chunk */) return null;
+  const streamId = new DataView(frame.buffer, frame.byteOffset, frame.byteLength).getUint32(
+    2,
+    false
+  );
+  return {
+    kind: 1 /* Chunk */,
+    streamId,
+    payload: frame.subarray(BINARY_FRAME_HEADER_BYTES)
+  };
+};
+const encodeJsonRpc = (message) => JSON.stringify(message);
+const handleRpcTokenFromRequest = (request) => {
+  const authorization = request.headers.get("authorization");
+  if (authorization != null) {
+    const match = /^Bearer\s+(.+)$/i.exec(authorization.trim());
+    if (match?.[1] != null) return match[1];
+  }
+  const protocols = request.headers.get("sec-websocket-protocol");
+  if (protocols != null) {
+    for (const entry of protocols.split(",")) {
+      const value = entry.trim();
+      if (value.startsWith(HANDLE_RPC_BEARER_PROTOCOL_PREFIX)) {
+        const token = value.slice(HANDLE_RPC_BEARER_PROTOCOL_PREFIX.length);
+        if (token.length > 0) return token;
+      }
+    }
+  }
+  return null;
+};
+const handleRpcClientProtocols = (token) => [
+  HANDLE_RPC_SUBPROTOCOL,
+  `${HANDLE_RPC_BEARER_PROTOCOL_PREFIX}${token}`
+];
+export * from "./frame-channel.mjs";
+export {
+  BINARY_FRAME_HEADER_BYTES,
+  BINARY_FRAME_MAGIC,
+  BinaryFrameKind,
+  HANDLE_RPC_BEARER_PROTOCOL_PREFIX,
+  HANDLE_RPC_EXECUTE_METHODS,
+  HANDLE_RPC_FILE_WRITE_METHODS,
+  HANDLE_RPC_IDEMPOTENT_METHODS,
+  HANDLE_RPC_LIFECYCLE_METHODS,
+  HANDLE_RPC_SUBPROTOCOL,
+  HANDLE_RPC_VERSION,
+  HANDLE_RPC_WRITE_METHODS,
+  HandleRpcCloseCode,
+  HandleRpcErrorCode,
+  HandleRpcMethod,
+  HandleRpcNotification,
+  INITIAL_STREAM_WINDOW_BYTES,
+  MAX_CHUNK_BYTES,
+  MAX_INLINE_WRITE_BYTES,
+  authRefreshParamsSchema,
+  authRefreshResultSchema,
+  cancelRequestParamsSchema,
+  decodeBinaryFrame,
+  describeResultSchema,
+  dirEntrySchema,
+  encodeChunkFrame,
+  encodeJsonRpc,
+  errnoOf,
+  getPortEndpointParamsSchema,
+  getPortEndpointResultSchema,
+  handleRpcClientProtocols,
+  handleRpcError,
+  handleRpcErrorDataSchema,
+  handleRpcMethodSchemas,
+  handleRpcNotificationSchemas,
+  handleRpcResultParsers,
+  handleRpcTokenFromRequest,
+  initializeParamsSchema,
+  initializeResultSchema,
+  isHandleRpcError,
+  jsonRpcErrorObjectSchema,
+  jsonRpcErrorResponseSchema,
+  jsonRpcNotificationSchema,
+  jsonRpcRequestSchema,
+  jsonRpcSuccessSchema,
+  localMcpResultSchema,
+  mcpChannelEndpointSchema,
+  mcpChannelParamsSchema,
+  mcpEndpointSchema,
+  mcpOpenParamsSchema,
+  mcpOpenResultSchema,
+  mcpReceiveResultSchema,
+  mcpSendParamsSchema,
+  parseHandleRpcMethod,
+  parseHandleRpcResult,
+  pathParamsSchema,
+  processIdParamsSchema,
+  processKillParamsSchema,
+  processWaitResultSchema,
+  readDirResultSchema,
+  readFileParamsSchema,
+  readFileResultSchema,
+  readTextFileParamsSchema,
+  readTextFileResultSchema,
+  removePathParamsSchema,
+  runParamsSchema,
+  runResultSchema,
+  sandboxCapabilitiesSchema,
+  sandboxDeleteHookParamsSchema,
+  sandboxMcpEndpointSchema,
+  screenOptionsSchema,
+  screenSessionSchema,
+  setNetworkPolicyParamsSchema,
+  spawnParamsSchema,
+  spawnResultSchema,
+  statResultSchema,
+  statSchema,
+  streamCancelParamsSchema,
+  streamChunkParamsSchema,
+  streamCreditParamsSchema,
+  streamEndParamsSchema,
+  streamErrorParamsSchema,
+  writeFileParamsSchema
+};
+//# sourceMappingURL=wire.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/sandbox/wire.ts"],
+  "sourcesContent": ["import * as z from 'zod';\nimport { jsonValueSchema, type JsonValue } from \"../json.mjs\";\nimport { NetworkPolicy, PortProtocol, SandboxCapability, SandboxEntryType } from \"./types.mjs\";\n\n// The sandbox handle RPC: an SDK-defined,\n// provider-neutral wire with one method per NetworkSandboxSessionIface method,\n// carried over one persistent WebSocket (or any ordered message stream).\n//\n// Framing\n// - Text frames are JSON-RPC 2.0 messages (single messages, no batches).\n// - Binary frames carry stream data: a 6-byte header followed by the payload.\n//     byte 0     magic 0xF1\n//     byte 1     BinaryFrameKind (1 = chunk)\n//     bytes 2-5  stream id, uint32 big-endian\n//   A peer that cannot send binary frames sends `stream/chunk` notifications\n//   with base64 data instead; every peer accepts both forms.\n//\n// Connection\n// - The client authenticates in the connection request (WebSocket\n//   subprotocol `bearer.<token>` next to HANDLE_RPC_SUBPROTOCOL, or an\n//   `Authorization: Bearer` header where the runtime allows headers) and again\n//   in the first message, `initialize { handleRpcVersion: 1, token }`, which is\n//   the only authentication on transports without a connection request.\n// - Nothing but `initialize` is accepted before initialization.\n// - `initialize` returns what `sandbox/describe` returns.\n// - Lazy attach: the session service's stable per-binding address may start\n//   the sandbox (through its provider) while handling the first call, and\n//   serves every call on that connection itself; there is no redirect.\n// - `auth/refresh { token }` replaces the connection's credential before it\n//   expires; a server closes a connection whose credential expired with\n//   HandleRpcCloseCode.Unauthorized, and the client reconnects with a fresh one.\n// - `$/cancel_request { requestId }` cancels an in-flight request.\n//\n// Streams\n// - Every stream id is allocated by the client (uint32, unique per connection)\n//   and named in the request that uses it: `sandbox/readFile.streamId` and\n//   `sandbox/spawn.stdoutStreamId/stderrStreamId` flow server to client,\n//   `sandbox/writeFile.streamId` and `sandbox/spawn.stdinStreamId` flow client\n//   to server. The receiver registers a stream before the first chunk can\n//   arrive (the client before sending the request, the server when it receives\n//   it), so chunks are never orphaned.\n// - Flow control is credit based: a sender may have at most\n//   INITIAL_STREAM_WINDOW_BYTES unacknowledged bytes per stream; the receiver\n//   returns credit with `stream/credit { streamId, bytes }` as its consumer\n//   reads. Chunks are at most MAX_CHUNK_BYTES.\n// - `stream/end` closes a stream, `stream/error` fails it, and\n//   `stream/cancel` (receiver to sender) stops it.\n// - Streams and process handles are scoped to one connection: if the\n//   connection closes, the server kills that connection's processes and both\n//   sides fail its open streams.\n\nexport const HANDLE_RPC_VERSION = 1;\nexport const HANDLE_RPC_SUBPROTOCOL = 'final.handle-rpc.v1';\nexport const HANDLE_RPC_BEARER_PROTOCOL_PREFIX = 'bearer.';\nexport const MAX_CHUNK_BYTES = 256 * 1024;\nexport const INITIAL_STREAM_WINDOW_BYTES = 1024 * 1024;\n// Inline (base64) file writes up to this size skip the stream round trip.\nexport const MAX_INLINE_WRITE_BYTES = 64 * 1024;\nexport const BINARY_FRAME_MAGIC = 0xf1;\nexport const BINARY_FRAME_HEADER_BYTES = 6;\nconst MAX_STREAM_ID = 0xffffffff;\n\nexport enum BinaryFrameKind {\n  Chunk = 1,\n}\n\nexport enum HandleRpcCloseCode {\n  Normal = 1000,\n  ProtocolError = 4400,\n  Unauthorized = 4401,\n}\n\nexport enum HandleRpcErrorCode {\n  ParseError = -32700,\n  InvalidRequest = -32600,\n  MethodNotFound = -32601,\n  InvalidParams = -32602,\n  Internal = -32603,\n  Unauthorized = -32001,\n  NotInitialized = -32002,\n  // Rejected by the binding's access policy (a read-only binding writing).\n  Forbidden = -32010,\n  NotFound = -32011,\n  // The sandbox does not have the capability.\n  Unsupported = -32012,\n  // Client side: the connection closed before the request was answered.\n  ConnectionClosed = -32013,\n  Timeout = -32014,\n  Cancelled = -32800,\n}\n\nexport enum HandleRpcMethod {\n  Initialize = 'initialize',\n  Describe = 'sandbox/describe',\n  ReadFile = 'sandbox/readFile',\n  ReadTextFile = 'sandbox/readTextFile',\n  WriteFile = 'sandbox/writeFile',\n  Spawn = 'sandbox/spawn',\n  Run = 'sandbox/run',\n  Stat = 'sandbox/stat',\n  ReadDir = 'sandbox/readDir',\n  RemovePath = 'sandbox/removePath',\n  GetPortEndpoint = 'sandbox/getPortEndpoint',\n  Stop = 'sandbox/stop',\n  Destroy = 'sandbox/destroy',\n  SetNetworkPolicy = 'sandbox/setNetworkPolicy',\n  OnSandboxStop = 'handle/onSandboxStop',\n  OnSandboxDelete = 'handle/onSandboxDelete',\n  OnRuntimeShutdown = 'handle/onRuntimeShutdown',\n  ComputerUse = 'sandbox/computerUse',\n  Screen = 'sandbox/screen',\n  LocalMcp = 'sandbox/localMcp',\n  McpOpen = 'mcp/open',\n  McpSend = 'mcp/send',\n  McpReceive = 'mcp/receive',\n  McpClose = 'mcp/close',\n  ProcessWait = 'process/wait',\n  ProcessKill = 'process/kill',\n  AuthRefresh = 'auth/refresh',\n}\n\nexport enum HandleRpcNotification {\n  CancelRequest = '$/cancel_request',\n  StreamChunk = 'stream/chunk',\n  StreamEnd = 'stream/end',\n  StreamError = 'stream/error',\n  StreamCredit = 'stream/credit',\n  StreamCancel = 'stream/cancel',\n}\n\n// Errors carry a numeric HandleRpcErrorCode plus the sandbox's errno-style code\n// (ENOENT, ENOTDIR, ...) when it had one.\nexport interface HandleRpcErrorIface extends Error {\n  readonly code: HandleRpcErrorCode;\n  readonly retryable: boolean;\n  readonly errno: string | null;\n  readonly data: JsonValue | null;\n}\n\nexport const handleRpcError = (args: {\n  code: HandleRpcErrorCode;\n  message: string;\n  retryable?: boolean;\n  errno?: string | null;\n  data?: JsonValue | null;\n}): HandleRpcErrorIface =>\n  Object.assign(new Error(args.message), {\n    name: 'HandleRpcError',\n    code: args.code,\n    retryable: args.retryable ?? false,\n    errno: args.errno ?? null,\n    data: args.data ?? null,\n  });\n\nconst handleRpcErrorFieldsSchema = z.object({ code: z.number(), retryable: z.boolean() });\nconst errnoFieldsSchema = z.object({ code: z.string() });\n\nexport const isHandleRpcError = (cause: unknown): cause is HandleRpcErrorIface =>\n  cause instanceof Error && handleRpcErrorFieldsSchema.safeParse(cause).success;\n\n// The errno-style string code of a sandbox error (`ENOENT`), if any.\nexport const errnoOf = (cause: unknown): string | null => {\n  if (isHandleRpcError(cause)) return cause.errno;\n  if (!(cause instanceof Error)) return null;\n  const parsed = errnoFieldsSchema.safeParse(cause);\n  return parsed.success ? parsed.data.code : null;\n};\n\nconst jsonRpcIdSchema = z.union([z.string(), z.number().int()]);\nexport type JsonRpcId = z.infer<typeof jsonRpcIdSchema>;\n\nexport const jsonRpcRequestSchema = z.object({\n  jsonrpc: z.literal('2.0'),\n  id: jsonRpcIdSchema,\n  method: z.string().min(1),\n  params: jsonValueSchema.optional(),\n});\n\nexport const jsonRpcNotificationSchema = z.object({\n  jsonrpc: z.literal('2.0'),\n  method: z.string().min(1),\n  params: jsonValueSchema.optional(),\n});\n\nexport const jsonRpcErrorObjectSchema = z.object({\n  code: z.number().int(),\n  message: z.string(),\n  data: jsonValueSchema.optional(),\n});\n\nexport const jsonRpcSuccessSchema = z.object({\n  jsonrpc: z.literal('2.0'),\n  id: jsonRpcIdSchema,\n  result: jsonValueSchema,\n});\n\nexport const jsonRpcErrorResponseSchema = z.object({\n  jsonrpc: z.literal('2.0'),\n  id: jsonRpcIdSchema.nullable(),\n  error: jsonRpcErrorObjectSchema,\n});\n\nexport type JsonRpcRequestIface = z.infer<typeof jsonRpcRequestSchema>;\nexport type JsonRpcNotificationIface = z.infer<typeof jsonRpcNotificationSchema>;\nexport type JsonRpcErrorObjectIface = z.infer<typeof jsonRpcErrorObjectSchema>;\n\n// Data in error responses: { errno, retryable } when known.\nexport const handleRpcErrorDataSchema = z.object({\n  errno: z.string().nullable().optional(),\n  retryable: z.boolean().optional(),\n});\n\nconst streamIdSchema = z.number().int().min(0).max(MAX_STREAM_ID);\nconst pathSchema = z.string().min(1);\n\n// Tolerant on read: capabilities this build does not know are dropped.\nconst isSandboxCapability = (value: string): value is SandboxCapability =>\n  Object.values(SandboxCapability).some((capability) => capability === value);\nexport const sandboxCapabilitiesSchema = z\n  .array(z.string())\n  .transform((values) => values.filter(isSandboxCapability));\n\nconst isSandboxEntryType = (value: string): value is SandboxEntryType =>\n  Object.values(SandboxEntryType).some((entryType) => entryType === value);\nconst entryTypeSchema = z\n  .string()\n  .transform((value) => (isSandboxEntryType(value) ? value : SandboxEntryType.Other));\n\nexport const statSchema = z.object({\n  path: z.string(),\n  type: entryTypeSchema,\n  size: z.number().nonnegative(),\n  modifiedAt: z.string().nullable(),\n  mode: z.number().int().nullable(),\n});\n\nexport const dirEntrySchema = z.object({\n  name: z.string(),\n  path: z.string(),\n  type: entryTypeSchema,\n  size: z.number().nonnegative().nullable(),\n});\n\nexport const mcpEndpointSchema = z.object({\n  name: z.string(),\n  url: z.string(),\n  headers: z.record(z.string(), z.string()),\n});\n\n// In-process channels are advertised only by hosts enabling the channel bridge.\nexport const mcpChannelEndpointSchema = z.object({\n  name: z.string(),\n  endpointKey: z.string().min(1),\n});\nexport const sandboxMcpEndpointSchema = z.union([mcpEndpointSchema, mcpChannelEndpointSchema]);\n\nexport const screenOptionsSchema = z.strictObject({ viewOnly: z.boolean().default(true) });\n\nexport const screenSessionSchema = z.object({\n  url: z.string(),\n  token: z.string(),\n  expiresAt: z.string(),\n});\n\nexport const describeResultSchema = z.object({\n  handleRpcVersion: z.literal(HANDLE_RPC_VERSION),\n  id: z.string(),\n  defaultWorkingDirectory: z.string(),\n  ports: z.array(z.number().int()),\n  capabilities: sandboxCapabilitiesSchema,\n  description: z.string(),\n  confinedFiles: z.boolean().optional(),\n  providerHooks: z.boolean().optional(),\n  mcpChannels: z.boolean().optional(),\n});\n\nexport const initializeParamsSchema = z.object({\n  handleRpcVersion: z.literal(HANDLE_RPC_VERSION),\n  token: z.string().nullable().optional(),\n  client: z.object({ name: z.string(), version: z.string() }).optional(),\n});\n\nexport const initializeResultSchema = describeResultSchema.extend({\n  // When the connection's credential expires (null: never).\n  expiresAt: z.string().nullable(),\n});\n\nconst emptySchema = z.object({}).passthrough();\nconst emptyResultSchema = z.object({}).passthrough();\n\nconst processOptionFields = {\n  command: z.string().min(1),\n  args: z.array(z.string()).optional(),\n  cwd: z.string().optional(),\n  env: z.record(z.string(), z.string()).optional(),\n  shell: z.boolean().optional(),\n  timeoutMs: z.number().int().positive().optional(),\n};\n\nexport const readFileParamsSchema = z.object({\n  root: pathSchema.optional(),\n  path: pathSchema,\n  streamId: streamIdSchema,\n  // Byte range; omitted reads the whole file.\n  offset: z.number().int().nonnegative().optional(),\n  length: z.number().int().nonnegative().optional(),\n});\n\nexport const readFileResultSchema = z.object({\n  found: z.boolean(),\n});\n\nexport const readTextFileParamsSchema = z.object({\n  path: pathSchema,\n  encoding: z.string().optional(),\n  startLine: z.number().int().positive().optional(),\n  endLine: z.number().int().positive().optional(),\n});\n\nexport const readTextFileResultSchema = z.object({ text: z.string().nullable() });\n\nexport const writeFileParamsSchema = z\n  .object({\n    path: pathSchema,\n    streamId: streamIdSchema.optional(),\n    contentBase64: z.string().optional(),\n  })\n  .refine((params) => (params.streamId == null) !== (params.contentBase64 == null), {\n    message: 'exactly one of streamId and contentBase64 is required',\n  });\n\nexport const spawnParamsSchema = z.object({\n  ...processOptionFields,\n  // Client-chosen handle for process/wait and process/kill.\n  processId: z.string().min(1),\n  // Null means stdin is closed from the start.\n  stdinStreamId: streamIdSchema.nullable(),\n  stdoutStreamId: streamIdSchema,\n  stderrStreamId: streamIdSchema,\n});\n\nexport const spawnResultSchema = z.object({ pid: z.string().nullable() });\n\nexport const runParamsSchema = z.object({\n  ...processOptionFields,\n  stdin: z.string().optional(),\n});\n\nexport const runResultSchema = z.object({\n  exitCode: z.number().int(),\n  stdout: z.string(),\n  stderr: z.string(),\n});\n\nexport const pathParamsSchema = z.object({ path: pathSchema, root: pathSchema.optional() });\nexport const statResultSchema = z.object({ stat: statSchema.nullable() });\nexport const readDirResultSchema = z.object({ entries: z.array(dirEntrySchema) });\n\nexport const removePathParamsSchema = z.object({\n  path: pathSchema,\n  recursive: z.boolean().optional(),\n  force: z.boolean().optional(),\n});\n\nexport const getPortEndpointParamsSchema = z.object({\n  port: z.number().int().min(1).max(65535),\n  protocol: z.nativeEnum(PortProtocol).optional(),\n});\n\nexport const getPortEndpointResultSchema = z.object({\n  url: z.string(),\n  headers: z.record(z.string(), z.string()).optional(),\n});\n\nexport const setNetworkPolicyParamsSchema = z.object({\n  mode: z.nativeEnum(NetworkPolicy),\n  allow: z.array(z.string()).optional(),\n});\n\nexport const sandboxDeleteHookParamsSchema = z.object({ reason: z.string().optional() });\n\nexport const localMcpResultSchema = z.object({ endpoints: z.array(sandboxMcpEndpointSchema) });\nexport const mcpOpenParamsSchema = z.object({ endpointKey: z.string().min(1) });\nexport const mcpChannelParamsSchema = z.object({ channelId: z.string().min(1) });\nexport const mcpSendParamsSchema = mcpChannelParamsSchema.extend({ message: jsonValueSchema });\nexport const mcpOpenResultSchema = mcpChannelParamsSchema;\nexport const mcpReceiveResultSchema = z.object({ messages: z.array(jsonValueSchema) });\n\nexport const processIdParamsSchema = z.object({ processId: z.string().min(1) });\nexport const processWaitResultSchema = z.object({ exitCode: z.number().int() });\nexport const processKillParamsSchema = z.object({\n  processId: z.string().min(1),\n  signal: z.string().optional(),\n});\n\nexport const authRefreshParamsSchema = z.object({ token: z.string().min(1) });\nexport const authRefreshResultSchema = z.object({ expiresAt: z.string().nullable() });\n\nexport const cancelRequestParamsSchema = z.object({ requestId: jsonRpcIdSchema });\nexport const streamChunkParamsSchema = z.object({ streamId: streamIdSchema, data: z.string() });\nexport const streamEndParamsSchema = z.object({ streamId: streamIdSchema });\nexport const streamErrorParamsSchema = z.object({\n  streamId: streamIdSchema,\n  message: z.string(),\n  code: z.number().int().optional(),\n  errno: z.string().nullable().optional(),\n});\nexport const streamCreditParamsSchema = z.object({\n  streamId: streamIdSchema,\n  bytes: z.number().int().positive(),\n});\nexport const streamCancelParamsSchema = z.object({\n  streamId: streamIdSchema,\n  reason: z.string().optional(),\n});\n\nexport type DescribeResultIface = z.infer<typeof describeResultSchema>;\nexport type InitializeResultIface = z.infer<typeof initializeResultSchema>;\n\n// Params and result schema for every request method: the single source of\n// truth for both ends.\nexport const handleRpcMethodSchemas = {\n  [HandleRpcMethod.Initialize]: { params: initializeParamsSchema, result: initializeResultSchema },\n  [HandleRpcMethod.Describe]: { params: emptySchema, result: describeResultSchema },\n  [HandleRpcMethod.ReadFile]: { params: readFileParamsSchema, result: readFileResultSchema },\n  [HandleRpcMethod.ReadTextFile]: {\n    params: readTextFileParamsSchema,\n    result: readTextFileResultSchema,\n  },\n  [HandleRpcMethod.WriteFile]: { params: writeFileParamsSchema, result: emptyResultSchema },\n  [HandleRpcMethod.Spawn]: { params: spawnParamsSchema, result: spawnResultSchema },\n  [HandleRpcMethod.Run]: { params: runParamsSchema, result: runResultSchema },\n  [HandleRpcMethod.Stat]: { params: pathParamsSchema, result: statResultSchema },\n  [HandleRpcMethod.ReadDir]: { params: pathParamsSchema, result: readDirResultSchema },\n  [HandleRpcMethod.RemovePath]: { params: removePathParamsSchema, result: emptyResultSchema },\n  [HandleRpcMethod.GetPortEndpoint]: {\n    params: getPortEndpointParamsSchema,\n    result: getPortEndpointResultSchema,\n  },\n  [HandleRpcMethod.Stop]: { params: emptySchema, result: emptyResultSchema },\n  [HandleRpcMethod.Destroy]: { params: emptySchema, result: emptyResultSchema },\n  [HandleRpcMethod.OnSandboxStop]: { params: emptySchema, result: emptyResultSchema },\n  [HandleRpcMethod.OnSandboxDelete]: {\n    params: sandboxDeleteHookParamsSchema,\n    result: emptyResultSchema,\n  },\n  [HandleRpcMethod.OnRuntimeShutdown]: { params: emptySchema, result: emptyResultSchema },\n  [HandleRpcMethod.SetNetworkPolicy]: {\n    params: setNetworkPolicyParamsSchema,\n    result: emptyResultSchema,\n  },\n  [HandleRpcMethod.ComputerUse]: { params: emptySchema, result: sandboxMcpEndpointSchema },\n  [HandleRpcMethod.Screen]: { params: screenOptionsSchema, result: screenSessionSchema },\n  [HandleRpcMethod.LocalMcp]: { params: emptySchema, result: localMcpResultSchema },\n  [HandleRpcMethod.McpOpen]: { params: mcpOpenParamsSchema, result: mcpOpenResultSchema },\n  [HandleRpcMethod.McpSend]: { params: mcpSendParamsSchema, result: emptyResultSchema },\n  [HandleRpcMethod.McpReceive]: { params: mcpChannelParamsSchema, result: mcpReceiveResultSchema },\n  [HandleRpcMethod.McpClose]: { params: mcpChannelParamsSchema, result: emptyResultSchema },\n  [HandleRpcMethod.ProcessWait]: { params: processIdParamsSchema, result: processWaitResultSchema },\n  [HandleRpcMethod.ProcessKill]: { params: processKillParamsSchema, result: emptyResultSchema },\n  [HandleRpcMethod.AuthRefresh]: {\n    params: authRefreshParamsSchema,\n    result: authRefreshResultSchema,\n  },\n} as const satisfies Record<HandleRpcMethod, { params: z.ZodType; result: z.ZodType }>;\n\nexport const handleRpcNotificationSchemas = {\n  [HandleRpcNotification.CancelRequest]: cancelRequestParamsSchema,\n  [HandleRpcNotification.StreamChunk]: streamChunkParamsSchema,\n  [HandleRpcNotification.StreamEnd]: streamEndParamsSchema,\n  [HandleRpcNotification.StreamError]: streamErrorParamsSchema,\n  [HandleRpcNotification.StreamCredit]: streamCreditParamsSchema,\n  [HandleRpcNotification.StreamCancel]: streamCancelParamsSchema,\n} as const satisfies Record<HandleRpcNotification, z.ZodType>;\n\nexport type HandleRpcParams<M extends HandleRpcMethod> = z.input<\n  (typeof handleRpcMethodSchemas)[M]['params']\n>;\nexport type HandleRpcResult<M extends HandleRpcMethod> = z.output<\n  (typeof handleRpcMethodSchemas)[M]['result']\n>;\nexport type HandleRpcNotificationParams<N extends HandleRpcNotification> = z.input<\n  (typeof handleRpcNotificationSchemas)[N]\n>;\n\n// Typed result parsers, so generic callers get HandleRpcResult<M>.\nexport type HandleRpcResultParsers = {\n  [M in HandleRpcMethod]: (raw: JsonValue) => HandleRpcResult<M>;\n};\n\nexport const handleRpcResultParsers: HandleRpcResultParsers = {\n  [HandleRpcMethod.Initialize]: (raw) =>\n    handleRpcMethodSchemas[HandleRpcMethod.Initialize].result.parse(raw),\n  [HandleRpcMethod.Describe]: (raw) =>\n    handleRpcMethodSchemas[HandleRpcMethod.Describe].result.parse(raw),\n  [HandleRpcMethod.ReadFile]: (raw) =>\n    handleRpcMethodSchemas[HandleRpcMethod.ReadFile].result.parse(raw),\n  [HandleRpcMethod.ReadTextFile]: (raw) =>\n    handleRpcMethodSchemas[HandleRpcMethod.ReadTextFile].result.parse(raw),\n  [HandleRpcMethod.WriteFile]: (raw) =>\n    handleRpcMethodSchemas[HandleRpcMethod.WriteFile].result.parse(raw),\n  [HandleRpcMethod.Spawn]: (raw) => handleRpcMethodSchemas[HandleRpcMethod.Spawn].result.parse(raw),\n  [HandleRpcMethod.Run]: (raw) => handleRpcMethodSchemas[HandleRpcMethod.Run].result.parse(raw),\n  [HandleRpcMethod.Stat]: (raw) => handleRpcMethodSchemas[HandleRpcMethod.Stat].result.parse(raw),\n  [HandleRpcMethod.ReadDir]: (raw) =>\n    handleRpcMethodSchemas[HandleRpcMethod.ReadDir].result.parse(raw),\n  [HandleRpcMethod.RemovePath]: (raw) =>\n    handleRpcMethodSchemas[HandleRpcMethod.RemovePath].result.parse(raw),\n  [HandleRpcMethod.GetPortEndpoint]: (raw) =>\n    handleRpcMethodSchemas[HandleRpcMethod.GetPortEndpoint].result.parse(raw),\n  [HandleRpcMethod.Stop]: (raw) => handleRpcMethodSchemas[HandleRpcMethod.Stop].result.parse(raw),\n  [HandleRpcMethod.Destroy]: (raw) =>\n    handleRpcMethodSchemas[HandleRpcMethod.Destroy].result.parse(raw),\n  [HandleRpcMethod.OnRuntimeShutdown]: (raw) =>\n    handleRpcMethodSchemas[HandleRpcMethod.OnRuntimeShutdown].result.parse(raw),\n  [HandleRpcMethod.OnSandboxStop]: (raw) =>\n    handleRpcMethodSchemas[HandleRpcMethod.OnSandboxStop].result.parse(raw),\n  [HandleRpcMethod.OnSandboxDelete]: (raw) =>\n    handleRpcMethodSchemas[HandleRpcMethod.OnSandboxDelete].result.parse(raw),\n  [HandleRpcMethod.SetNetworkPolicy]: (raw) =>\n    handleRpcMethodSchemas[HandleRpcMethod.SetNetworkPolicy].result.parse(raw),\n  [HandleRpcMethod.ComputerUse]: (raw) =>\n    handleRpcMethodSchemas[HandleRpcMethod.ComputerUse].result.parse(raw),\n  [HandleRpcMethod.Screen]: (raw) =>\n    handleRpcMethodSchemas[HandleRpcMethod.Screen].result.parse(raw),\n  [HandleRpcMethod.LocalMcp]: (raw) =>\n    handleRpcMethodSchemas[HandleRpcMethod.LocalMcp].result.parse(raw),\n  [HandleRpcMethod.McpOpen]: (raw) =>\n    handleRpcMethodSchemas[HandleRpcMethod.McpOpen].result.parse(raw),\n  [HandleRpcMethod.McpSend]: (raw) =>\n    handleRpcMethodSchemas[HandleRpcMethod.McpSend].result.parse(raw),\n  [HandleRpcMethod.McpReceive]: (raw) =>\n    handleRpcMethodSchemas[HandleRpcMethod.McpReceive].result.parse(raw),\n  [HandleRpcMethod.McpClose]: (raw) =>\n    handleRpcMethodSchemas[HandleRpcMethod.McpClose].result.parse(raw),\n  [HandleRpcMethod.ProcessWait]: (raw) =>\n    handleRpcMethodSchemas[HandleRpcMethod.ProcessWait].result.parse(raw),\n  [HandleRpcMethod.ProcessKill]: (raw) =>\n    handleRpcMethodSchemas[HandleRpcMethod.ProcessKill].result.parse(raw),\n  [HandleRpcMethod.AuthRefresh]: (raw) =>\n    handleRpcMethodSchemas[HandleRpcMethod.AuthRefresh].result.parse(raw),\n};\n\nexport const parseHandleRpcResult = <M extends HandleRpcMethod>(\n  method: M,\n  raw: JsonValue,\n): HandleRpcResult<M> => handleRpcResultParsers[method](raw);\n\nconst isHandleRpcMethod = (value: string): value is HandleRpcMethod =>\n  Object.values(HandleRpcMethod).some((method) => method === value);\n\nexport const parseHandleRpcMethod = (method: string): HandleRpcMethod | null =>\n  isHandleRpcMethod(method) ? method : null;\n\n// Methods that write files; rejected below write access.\nexport const HANDLE_RPC_FILE_WRITE_METHODS: readonly HandleRpcMethod[] = [\n  HandleRpcMethod.WriteFile,\n  HandleRpcMethod.RemovePath,\n];\n\n// Methods that run processes or act on the machine; rejected below execute access.\nexport const HANDLE_RPC_EXECUTE_METHODS: readonly HandleRpcMethod[] = [\n  HandleRpcMethod.Spawn,\n  HandleRpcMethod.Run,\n  HandleRpcMethod.ProcessWait,\n  HandleRpcMethod.ProcessKill,\n  HandleRpcMethod.ComputerUse,\n  HandleRpcMethod.LocalMcp,\n  HandleRpcMethod.McpOpen,\n  HandleRpcMethod.McpSend,\n  HandleRpcMethod.McpReceive,\n  HandleRpcMethod.McpClose,\n];\n\n// Methods that change the sandbox; rejected on read-only bindings.\nexport const HANDLE_RPC_WRITE_METHODS: readonly HandleRpcMethod[] = [\n  ...HANDLE_RPC_FILE_WRITE_METHODS,\n  ...HANDLE_RPC_EXECUTE_METHODS,\n];\n\n// Lifecycle and policy methods; rejected unless the binding allows lifecycle.\nexport const HANDLE_RPC_LIFECYCLE_METHODS: readonly HandleRpcMethod[] = [\n  HandleRpcMethod.OnSandboxStop,\n  HandleRpcMethod.OnSandboxDelete,\n  HandleRpcMethod.OnRuntimeShutdown,\n  HandleRpcMethod.Stop,\n  HandleRpcMethod.Destroy,\n  HandleRpcMethod.SetNetworkPolicy,\n];\n\n// Safe to re-issue after a connection loss.\nexport const HANDLE_RPC_IDEMPOTENT_METHODS: readonly HandleRpcMethod[] = [\n  HandleRpcMethod.Describe,\n  HandleRpcMethod.ReadTextFile,\n  HandleRpcMethod.Stat,\n  HandleRpcMethod.ReadDir,\n  HandleRpcMethod.GetPortEndpoint,\n  HandleRpcMethod.Screen,\n  HandleRpcMethod.ComputerUse,\n  HandleRpcMethod.LocalMcp,\n];\n\nexport const encodeChunkFrame = (streamId: number, payload: Uint8Array): Uint8Array => {\n  const frame = new Uint8Array(BINARY_FRAME_HEADER_BYTES + payload.byteLength);\n  frame[0] = BINARY_FRAME_MAGIC;\n  frame[1] = BinaryFrameKind.Chunk;\n  new DataView(frame.buffer, frame.byteOffset, frame.byteLength).setUint32(2, streamId, false);\n  frame.set(payload, BINARY_FRAME_HEADER_BYTES);\n  return frame;\n};\n\nexport const decodeBinaryFrame = (\n  frame: Uint8Array,\n): { kind: BinaryFrameKind; streamId: number; payload: Uint8Array } | null => {\n  if (frame.byteLength < BINARY_FRAME_HEADER_BYTES || frame[0] !== BINARY_FRAME_MAGIC) return null;\n  if (frame[1] !== BinaryFrameKind.Chunk) return null;\n  const streamId = new DataView(frame.buffer, frame.byteOffset, frame.byteLength).getUint32(\n    2,\n    false,\n  );\n  return {\n    kind: BinaryFrameKind.Chunk,\n    streamId,\n    payload: frame.subarray(BINARY_FRAME_HEADER_BYTES),\n  };\n};\n\nexport const encodeJsonRpc = (message: JsonValue): string => JSON.stringify(message);\n\n// Extracts the bearer token from an upgrade request: `Authorization: Bearer`\n// first, then a `bearer.<token>` entry in Sec-WebSocket-Protocol.\nexport const handleRpcTokenFromRequest = (request: Request): string | null => {\n  const authorization = request.headers.get('authorization');\n  if (authorization != null) {\n    const match = /^Bearer\\s+(.+)$/i.exec(authorization.trim());\n    if (match?.[1] != null) return match[1];\n  }\n  const protocols = request.headers.get('sec-websocket-protocol');\n  if (protocols != null) {\n    for (const entry of protocols.split(',')) {\n      const value = entry.trim();\n      if (value.startsWith(HANDLE_RPC_BEARER_PROTOCOL_PREFIX)) {\n        const token = value.slice(HANDLE_RPC_BEARER_PROTOCOL_PREFIX.length);\n        if (token.length > 0) return token;\n      }\n    }\n  }\n  return null;\n};\n\n// Subprotocols a client offers; the server answers HANDLE_RPC_SUBPROTOCOL.\nexport const handleRpcClientProtocols = (token: string): string[] => [\n  HANDLE_RPC_SUBPROTOCOL,\n  `${HANDLE_RPC_BEARER_PROTOCOL_PREFIX}${token}`,\n];\n\nexport * from \"./frame-channel.mjs\";\n"],
+  "mappings": "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",
+  "names": ["BinaryFrameKind", "HandleRpcCloseCode", "HandleRpcErrorCode", "HandleRpcMethod", "HandleRpcNotification"]
+}

package/dist/modules/sandbox/workspace-root.d.mts

@@ -0,0 +1,8 @@
+import type { NetworkSandboxSessionIface } from "./types.mjs";
+export interface MapSessionPathArgsIface {
+    sessionRoot: string;
+    workspaceRoot: string;
+    path: string;
+}
+export declare const mapSessionPath: (args: MapSessionPathArgsIface) => string;
+export declare const withSessionWorkspaceRoot: <S extends NetworkSandboxSessionIface>(sandbox: S, sessionRoot: string) => S;