@finalai/agent-provider 0.1.0

package/dist/modules/sandbox/client.mjs

@@ -0,0 +1,500 @@
+import { bytesToBase64, bytesToStream, encodeSandboxText, readAllBytes, utf8Encode } from "./bytes.mjs";
+import { readTextFileStream, runCollect } from "./convenience.mjs";
+import { resolvePosixPath } from "./paths.mjs";
+import { createRpcPeer } from "./rpc-peer.mjs";
+import {
+  SandboxCapability
+} from "./types.mjs";
+import {
+  frameChannelFromWebSocket,
+  HANDLE_RPC_IDEMPOTENT_METHODS,
+  HANDLE_RPC_VERSION,
+  handleRpcClientProtocols,
+  HandleRpcCloseCode,
+  handleRpcError,
+  HandleRpcErrorCode,
+  HandleRpcMethod,
+  handleRpcMethodSchemas,
+  isHandleRpcError,
+  MAX_INLINE_WRITE_BYTES,
+  parseHandleRpcResult
+} from "./wire.mjs";
+const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const defaultOpenChannel = (WebSocketImpl) => async (target) => {
+  const Impl = WebSocketImpl ?? globalThis.WebSocket;
+  if (Impl == null)
+    throw new Error("no WebSocket implementation available; pass WebSocket or openChannel");
+  const { channel, opened } = frameChannelFromWebSocket(
+    new Impl(target.url, handleRpcClientProtocols(target.token))
+  );
+  await opened;
+  return channel;
+};
+const isRetryable = (cause) => isHandleRpcError(cause) && cause.retryable;
+const connectSandboxClient = async (args) => {
+  const now = args.now ?? Date.now;
+  const sleep = args.sleep ?? defaultSleep;
+  const randomId = args.randomId ?? (() => crypto.randomUUID());
+  const openChannel = args.openChannel ?? defaultOpenChannel(args.WebSocket);
+  const attempts = args.reconnect?.attempts ?? 5;
+  const baseDelayMs = args.reconnect?.baseDelayMs ?? 100;
+  const maxDelayMs = args.reconnect?.maxDelayMs ?? 5e3;
+  const refreshMarginMs = args.refreshMarginMs ?? 6e4;
+  const binary = args.binary ?? true;
+  let origin = {
+    url: args.url,
+    token: args.token,
+    expiresAt: args.expiresAt ?? null
+  };
+  let current = null;
+  let connecting = null;
+  let closedByUser = false;
+  let refreshTimer = null;
+  const live = /* @__PURE__ */ new Set();
+  let lastInfo = null;
+  const refreshOrigin = async () => {
+    if (args.refreshToken == null) return false;
+    const fresh = await args.refreshToken();
+    origin = {
+      url: fresh.url ?? origin.url,
+      token: fresh.token,
+      expiresAt: fresh.expiresAt
+    };
+    return true;
+  };
+  const scheduleRefresh = (connection) => {
+    if (refreshTimer != null) clearTimeout(refreshTimer);
+    refreshTimer = null;
+    const expiresAt = connection.info.expiresAt ?? connection.target.expiresAt;
+    if (expiresAt == null || args.refreshToken == null || closedByUser) return;
+    const remaining = Date.parse(expiresAt) - now();
+    if (Number.isNaN(remaining)) return;
+    const delay = Math.max(0, Math.min(remaining - refreshMarginMs, remaining / 2));
+    refreshTimer = setTimeout(
+      () => {
+        void refreshConnection(connection).catch(() => void 0);
+      },
+      Math.min(2147483647, delay)
+    );
+  };
+  const refreshConnection = async (connection) => {
+    if (closedByUser || connection.peer.isClosed()) return;
+    await refreshOrigin();
+    if (origin.url === connection.target.url) {
+      const result = await requestOn(connection, HandleRpcMethod.AuthRefresh, {
+        token: origin.token
+      });
+      connection.target = {
+        ...connection.target,
+        token: origin.token,
+        expiresAt: result.expiresAt
+      };
+      connection.info = { ...connection.info, expiresAt: result.expiresAt };
+      scheduleRefresh(connection);
+      return;
+    }
+    if (current === connection) current = null;
+    await getConnection();
+  };
+  const initialize = async (target) => {
+    const channel = await openChannel({ url: target.url, token: target.token });
+    let connection = null;
+    const peer = createRpcPeer({
+      channel,
+      binary,
+      onClose: () => {
+        if (connection == null) return;
+        live.delete(connection);
+        if (current === connection) current = null;
+      }
+    });
+    try {
+      const raw = await peer.request(HandleRpcMethod.Initialize, {
+        handleRpcVersion: HANDLE_RPC_VERSION,
+        token: target.token,
+        client: args.clientInfo
+      });
+      const info = handleRpcMethodSchemas[HandleRpcMethod.Initialize].result.parse(raw);
+      connection = { peer, target, info, nextStreamId: 1 };
+      live.add(connection);
+      return connection;
+    } catch (error) {
+      peer.close(HandleRpcCloseCode.Normal, "initialize failed");
+      throw error;
+    }
+  };
+  const establish = async () => {
+    let failures = 0;
+    let refreshed = false;
+    for (; ; ) {
+      if (closedByUser)
+        throw handleRpcError({
+          code: HandleRpcErrorCode.ConnectionClosed,
+          message: "client closed"
+        });
+      try {
+        const connection = await initialize(origin);
+        current = connection;
+        lastInfo = connection.info;
+        scheduleRefresh(connection);
+        return connection;
+      } catch (error) {
+        if (closedByUser) throw error;
+        const unauthorized = isHandleRpcError(error) && error.code === HandleRpcErrorCode.Unauthorized;
+        if (unauthorized && !refreshed && await refreshOrigin().catch(() => false)) {
+          refreshed = true;
+          continue;
+        }
+        if (unauthorized) throw error;
+        failures += 1;
+        if (failures >= attempts) {
+          throw handleRpcError({
+            code: HandleRpcErrorCode.ConnectionClosed,
+            message: `could not connect to the sandbox: ${error instanceof Error ? error.message : String(error)}`,
+            retryable: true
+          });
+        }
+        await sleep(Math.min(maxDelayMs, baseDelayMs * 2 ** (failures - 1)));
+      }
+    }
+  };
+  const getConnection = () => {
+    if (current != null && !current.peer.isClosed()) return Promise.resolve(current);
+    connecting ??= establish().finally(() => {
+      connecting = null;
+    });
+    return connecting;
+  };
+  const requestOn = async (connection, method, params, options) => {
+    const raw = await connection.peer.request(method, params, { signal: options?.signal });
+    return parseHandleRpcResult(method, raw);
+  };
+  const callOnConnection = async (method, params, options) => {
+    const idempotent = HANDLE_RPC_IDEMPOTENT_METHODS.includes(method);
+    for (let attempt = 0; ; attempt += 1) {
+      const connection = await getConnection();
+      try {
+        return { connection, result: await requestOn(connection, method, params, options) };
+      } catch (error) {
+        if (attempt === 0 && idempotent && isRetryable(error)) continue;
+        throw error;
+      }
+    }
+  };
+  const call = async (method, params, options) => (await callOnConnection(method, params, options)).result;
+  const allocateStreamId = (connection) => {
+    const id = connection.nextStreamId;
+    connection.nextStreamId += 1;
+    return id;
+  };
+  const first = await getConnection();
+  const describe = () => current?.info ?? lastInfo ?? first.info;
+  const readFile = async (options) => {
+    const connection = await getConnection();
+    const streamId = allocateStreamId(connection);
+    const stream = connection.peer.streams.openIncoming(streamId);
+    try {
+      const result = await requestOn(
+        connection,
+        HandleRpcMethod.ReadFile,
+        {
+          path: options.path,
+          root: options.root,
+          streamId,
+          offset: options.offset,
+          length: options.length
+        },
+        { signal: options.abortSignal }
+      );
+      if (!result.found) {
+        connection.peer.streams.discardIncoming(streamId);
+        return null;
+      }
+    } catch (error) {
+      connection.peer.streams.discardIncoming(streamId);
+      throw error;
+    }
+    options.abortSignal?.addEventListener(
+      "abort",
+      () => connection.peer.streams.cancelIncoming(streamId, "aborted"),
+      {
+        once: true
+      }
+    );
+    return stream;
+  };
+  const writeFile = async (options) => {
+    const connection = await getConnection();
+    const streamId = allocateStreamId(connection);
+    const sending = connection.peer.streams.openOutgoing(streamId, options.content);
+    sending.catch(() => void 0);
+    try {
+      await requestOn(
+        connection,
+        HandleRpcMethod.WriteFile,
+        { path: options.path, streamId },
+        { signal: options.abortSignal }
+      );
+    } catch (error) {
+      connection.peer.streams.abortOutgoing(streamId, "request failed");
+      throw error;
+    }
+  };
+  const writeBinaryFile = async (options) => {
+    if (options.content.byteLength > MAX_INLINE_WRITE_BYTES) {
+      await writeFile({
+        path: options.path,
+        content: bytesToStream(options.content),
+        abortSignal: options.abortSignal
+      });
+      return;
+    }
+    await call(
+      HandleRpcMethod.WriteFile,
+      { path: options.path, contentBase64: bytesToBase64(options.content) },
+      { signal: options.abortSignal }
+    );
+  };
+  const spawn = async (options) => {
+    const connection = await getConnection();
+    const processId = randomId();
+    const stdoutStreamId = allocateStreamId(connection);
+    const stderrStreamId = allocateStreamId(connection);
+    const stdinStreamId = allocateStreamId(connection);
+    const stdout = connection.peer.streams.openIncoming(stdoutStreamId);
+    const stderr = connection.peer.streams.openIncoming(stderrStreamId);
+    let stdinWriter = null;
+    let stdinSource;
+    if (options.stdin == null) {
+      const pipe = new TransformStream();
+      stdinWriter = pipe.writable.getWriter();
+      stdinSource = pipe.readable;
+    } else if (options.stdin instanceof ReadableStream) {
+      stdinSource = options.stdin;
+    } else {
+      stdinSource = bytesToStream(utf8Encode(options.stdin));
+    }
+    connection.peer.streams.openOutgoing(stdinStreamId, stdinSource).catch(() => void 0);
+    let pid;
+    try {
+      const result = await requestOn(connection, HandleRpcMethod.Spawn, {
+        processId,
+        command: options.command,
+        args: options.args,
+        cwd: options.cwd,
+        env: options.env,
+        shell: options.shell,
+        timeoutMs: options.timeoutMs,
+        stdinStreamId,
+        stdoutStreamId,
+        stderrStreamId
+      });
+      pid = result.pid;
+    } catch (error) {
+      connection.peer.streams.discardIncoming(stdoutStreamId);
+      connection.peer.streams.discardIncoming(stderrStreamId);
+      connection.peer.streams.abortOutgoing(stdinStreamId, "spawn failed");
+      throw error;
+    }
+    let waiting = null;
+    const kill = async (signal) => {
+      try {
+        await requestOn(connection, HandleRpcMethod.ProcessKill, { processId, signal });
+      } catch (error) {
+        if (isHandleRpcError(error) && (error.code === HandleRpcErrorCode.NotFound || error.retryable))
+          return;
+        throw error;
+      }
+    };
+    options.abortSignal?.addEventListener("abort", () => void kill().catch(() => void 0), {
+      once: true
+    });
+    return {
+      pid,
+      stdout,
+      stderr,
+      write: async (data, writeOptions) => {
+        if (stdinWriter == null) throw new Error("stdin was provided at spawn");
+        const bytes = data instanceof Uint8Array ? data : utf8Encode(data);
+        if (bytes.byteLength > 0) await stdinWriter.write(bytes);
+        if (writeOptions?.end === true) await stdinWriter.close();
+      },
+      wait: () => {
+        waiting ??= requestOn(
+          connection,
+          HandleRpcMethod.ProcessWait,
+          { processId },
+          { signal: options.abortSignal }
+        );
+        return waiting;
+      },
+      kill
+    };
+  };
+  const client = {
+    get id() {
+      return describe().id;
+    },
+    get defaultWorkingDirectory() {
+      return describe().defaultWorkingDirectory;
+    },
+    get ports() {
+      return describe().ports;
+    },
+    get description() {
+      return describe().description;
+    },
+    get capabilities() {
+      return describe().capabilities;
+    },
+    confinedFiles: describe().confinedFiles === true,
+    providerHooks: describe().providerHooks === true,
+    onRuntimeShutdown: async () => {
+      await call(HandleRpcMethod.OnRuntimeShutdown, {});
+    },
+    onSandboxStop: async () => {
+      await call(HandleRpcMethod.OnSandboxStop, {});
+    },
+    onSandboxDelete: async (options) => {
+      await call(HandleRpcMethod.OnSandboxDelete, options ?? {});
+    },
+    readFile: (options) => readFile(options),
+    readFileRange: readFile,
+    readBinaryFile: async (options) => {
+      const stream = await readFile(options);
+      return stream == null ? null : readAllBytes(stream);
+    },
+    readTextFile: async (options) => {
+      const { abortSignal: _abortSignal, ...params } = options;
+      const parsed = handleRpcMethodSchemas[HandleRpcMethod.ReadTextFile].params.safeParse(params);
+      if (!parsed.success)
+        throw handleRpcError({
+          code: HandleRpcErrorCode.InvalidParams,
+          message: parsed.error.message
+        });
+      const stream = await readFile({ path: options.path, abortSignal: options.abortSignal });
+      return stream == null ? null : readTextFileStream(stream, options);
+    },
+    writeFile,
+    writeBinaryFile,
+    writeTextFile: async (options) => writeBinaryFile({
+      path: options.path,
+      content: encodeSandboxText(options.content, options.encoding),
+      abortSignal: options.abortSignal
+    }),
+    spawn,
+    run: (options) => runCollect({ spawn }, options),
+    stat: async (options) => (await call(
+      HandleRpcMethod.Stat,
+      { path: options.path, root: options.root },
+      { signal: options.abortSignal }
+    )).stat,
+    readDir: async (options) => (await call(
+      HandleRpcMethod.ReadDir,
+      { path: options.path, root: options.root },
+      { signal: options.abortSignal }
+    )).entries,
+    resolvePath: (path) => resolvePosixPath(describe().defaultWorkingDirectory, path),
+    removePath: async (options) => {
+      const { abortSignal, ...params } = options;
+      await call(HandleRpcMethod.RemovePath, params, { signal: abortSignal });
+    },
+    getPortEndpoint: (options) => call(HandleRpcMethod.GetPortEndpoint, options),
+    getPortUrl: async (options) => (await call(HandleRpcMethod.GetPortEndpoint, options)).url,
+    stop: async () => {
+      await call(HandleRpcMethod.Stop, {});
+    },
+    destroy: async () => {
+      await call(HandleRpcMethod.Destroy, {});
+    },
+    close: () => {
+      closedByUser = true;
+      if (refreshTimer != null) clearTimeout(refreshTimer);
+      for (const connection of live)
+        connection.peer.close(HandleRpcCloseCode.Normal, "client closed");
+      live.clear();
+      current = null;
+    }
+  };
+  const mcpEndpoint = (connection, endpoint) => {
+    if ("url" in endpoint) return endpoint;
+    return {
+      name: endpoint.name,
+      connect: async (options) => {
+        const opened = await requestOn(
+          connection,
+          HandleRpcMethod.McpOpen,
+          { endpointKey: endpoint.endpointKey },
+          { signal: options?.abortSignal }
+        );
+        let closed = false;
+        const requireOpen = () => {
+          if (closed)
+            throw handleRpcError({
+              code: HandleRpcErrorCode.ConnectionClosed,
+              message: "MCP channel closed"
+            });
+        };
+        const channel = {
+          send: async (message, sendOptions) => {
+            requireOpen();
+            await requestOn(
+              connection,
+              HandleRpcMethod.McpSend,
+              { channelId: opened.channelId, message },
+              { signal: sendOptions?.abortSignal }
+            );
+          },
+          receive: async (receiveOptions) => {
+            requireOpen();
+            return (await requestOn(
+              connection,
+              HandleRpcMethod.McpReceive,
+              { channelId: opened.channelId },
+              { signal: receiveOptions?.abortSignal }
+            )).messages;
+          },
+          close: async () => {
+            if (closed) return;
+            closed = true;
+            if (!connection.peer.isClosed())
+              await requestOn(connection, HandleRpcMethod.McpClose, {
+                channelId: opened.channelId
+              });
+          }
+        };
+        if (options?.abortSignal?.aborted === true) {
+          await channel.close().catch(() => void 0);
+          options.abortSignal.throwIfAborted();
+        }
+        return channel;
+      }
+    };
+  };
+  const capabilities = first.info.capabilities;
+  if (capabilities.includes(SandboxCapability.NetworkPolicy)) {
+    client.setNetworkPolicy = async (policy) => {
+      await call(HandleRpcMethod.SetNetworkPolicy, policy);
+    };
+  }
+  if (capabilities.includes(SandboxCapability.ComputerUse)) {
+    client.computerUse = async () => {
+      const { connection, result } = await callOnConnection(HandleRpcMethod.ComputerUse, {});
+      return mcpEndpoint(connection, result);
+    };
+  }
+  if (capabilities.includes(SandboxCapability.Screen)) {
+    client.screen = (options) => call(HandleRpcMethod.Screen, options ?? {});
+  }
+  if (capabilities.includes(SandboxCapability.LocalMcp)) {
+    client.localMcp = async () => {
+      const { connection, result } = await callOnConnection(HandleRpcMethod.LocalMcp, {});
+      return result.endpoints.map((endpoint) => mcpEndpoint(connection, endpoint));
+    };
+  }
+  return client;
+};
+export {
+  connectSandboxClient
+};
+//# sourceMappingURL=client.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/sandbox/client.ts"],
+  "sourcesContent": ["import { bytesToBase64, bytesToStream, encodeSandboxText, readAllBytes, utf8Encode } from \"./bytes.mjs\";\nimport { readTextFileStream, runCollect } from \"./convenience.mjs\";\nimport { resolvePosixPath } from \"./paths.mjs\";\nimport { createRpcPeer, type RpcPeerIface } from \"./rpc-peer.mjs\";\nimport {\n  SandboxCapability,\n  type AbortableIface,\n  type DirEntryIface,\n  type McpChannelIface,\n  type NetworkPolicyIface,\n  type NetworkSandboxSessionIface,\n  type SandboxMcpEndpoint,\n  type SandboxProcessIface,\n  type SandboxProcessOptionsIface,\n  type ScreenSessionIface,\n  type StatIface,\n} from \"./types.mjs\";\nimport {\n  frameChannelFromWebSocket,\n  HANDLE_RPC_IDEMPOTENT_METHODS,\n  HANDLE_RPC_VERSION,\n  handleRpcClientProtocols,\n  HandleRpcCloseCode,\n  handleRpcError,\n  HandleRpcErrorCode,\n  HandleRpcMethod,\n  handleRpcMethodSchemas,\n  isHandleRpcError,\n  MAX_INLINE_WRITE_BYTES,\n  parseHandleRpcResult,\n  type FrameChannelIface,\n  type HandleRpcParams,\n  type HandleRpcResult,\n  type InitializeResultIface,\n  type WebSocketConstructorIface,\n} from \"./wire.mjs\";\n\n// NetworkSandboxSessionIface implemented purely over the handle RPC: no\n// provider code, only the wire. Works wherever a WebSocket exists (Workers,\n// browsers, Node 22+) or over any frame channel through `openChannel`.\n\nexport interface SandboxClientIface extends NetworkSandboxSessionIface {\n  readonly confinedFiles: boolean;\n  readonly providerHooks: boolean;\n  onSandboxStop(): Promise<void>;\n  onSandboxDelete(options?: { reason?: string }): Promise<void>;\n  onRuntimeShutdown(): Promise<void>;\n  readonly capabilities: readonly SandboxCapability[];\n  // A byte range of a file, streamed; null when the file does not exist.\n  readFileRange(options: {\n    path: string;\n    root?: string;\n    offset: number;\n    length?: number;\n    abortSignal?: AbortSignal;\n  }): Promise<ReadableStream<Uint8Array> | null>;\n  // Closes every connection and fails in-flight calls.\n  close(): void;\n}\n\nexport interface SandboxClientCredentialIface {\n  token: string;\n  expiresAt: string | null;\n  // A new stable endpoint URL, when the issuer moved it.\n  url?: string;\n}\n\nexport interface ConnectSandboxClientArgsIface {\n  // The session service's stable per-binding address; the first call to reach\n  // it attaches the sandbox, and every call is served there.\n  url: string;\n  token: string;\n  expiresAt?: string | null;\n  // Defaults to the global WebSocket.\n  WebSocket?: WebSocketConstructorIface;\n  // Replaces WebSocket dialing entirely (relays, tests).\n  openChannel?: (target: { url: string; token: string }) => Promise<FrameChannelIface>;\n  // Returns a fresh credential for the stable endpoint (`url`), e.g. from the\n  // broker's `sandbox` route.\n  refreshToken?: () => Promise<SandboxClientCredentialIface>;\n  // Send stream chunks as binary frames (default true).\n  binary?: boolean;\n  reconnect?: { attempts?: number; baseDelayMs?: number; maxDelayMs?: number };\n  // How long before expiry to refresh the credential (default 60 s).\n  refreshMarginMs?: number;\n  clientInfo?: { name: string; version: string };\n  now?: () => number;\n  sleep?: (ms: number) => Promise<void>;\n  randomId?: () => string;\n}\n\ninterface TargetIface {\n  url: string;\n  token: string;\n  expiresAt: string | null;\n}\n\ninterface ConnectionIface {\n  peer: RpcPeerIface;\n  target: TargetIface;\n  info: InitializeResultIface;\n  nextStreamId: number;\n}\n\nconst defaultSleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));\n\nconst defaultOpenChannel =\n  (WebSocketImpl: WebSocketConstructorIface | undefined) =>\n  async (target: { url: string; token: string }): Promise<FrameChannelIface> => {\n    const Impl = WebSocketImpl ?? globalThis.WebSocket;\n    if (Impl == null)\n      throw new Error('no WebSocket implementation available; pass WebSocket or openChannel');\n    const { channel, opened } = frameChannelFromWebSocket(\n      new Impl(target.url, handleRpcClientProtocols(target.token)),\n    );\n    await opened;\n    return channel;\n  };\n\nconst isRetryable = (cause: unknown): boolean => isHandleRpcError(cause) && cause.retryable;\n\nexport const connectSandboxClient = async (\n  args: ConnectSandboxClientArgsIface,\n): Promise<SandboxClientIface> => {\n  const now = args.now ?? Date.now;\n  const sleep = args.sleep ?? defaultSleep;\n  const randomId = args.randomId ?? (() => crypto.randomUUID());\n  const openChannel = args.openChannel ?? defaultOpenChannel(args.WebSocket);\n  const attempts = args.reconnect?.attempts ?? 5;\n  const baseDelayMs = args.reconnect?.baseDelayMs ?? 100;\n  const maxDelayMs = args.reconnect?.maxDelayMs ?? 5_000;\n  const refreshMarginMs = args.refreshMarginMs ?? 60_000;\n  const binary = args.binary ?? true;\n\n  let origin: TargetIface = {\n    url: args.url,\n    token: args.token,\n    expiresAt: args.expiresAt ?? null,\n  };\n  let current: ConnectionIface | null = null;\n  let connecting: Promise<ConnectionIface> | null = null;\n  let closedByUser = false;\n  let refreshTimer: ReturnType<typeof setTimeout> | null = null;\n  const live = new Set<ConnectionIface>();\n  let lastInfo: InitializeResultIface | null = null;\n\n  const refreshOrigin = async (): Promise<boolean> => {\n    if (args.refreshToken == null) return false;\n    const fresh = await args.refreshToken();\n    origin = {\n      url: fresh.url ?? origin.url,\n      token: fresh.token,\n      expiresAt: fresh.expiresAt,\n    };\n    return true;\n  };\n\n  const scheduleRefresh = (connection: ConnectionIface) => {\n    if (refreshTimer != null) clearTimeout(refreshTimer);\n    refreshTimer = null;\n    const expiresAt = connection.info.expiresAt ?? connection.target.expiresAt;\n    if (expiresAt == null || args.refreshToken == null || closedByUser) return;\n    const remaining = Date.parse(expiresAt) - now();\n    if (Number.isNaN(remaining)) return;\n    const delay = Math.max(0, Math.min(remaining - refreshMarginMs, remaining / 2));\n    refreshTimer = setTimeout(\n      () => {\n        void refreshConnection(connection).catch(() => undefined);\n      },\n      Math.min(2_147_483_647, delay),\n    );\n  };\n\n  // The connection takes the new token in place; in-flight calls continue.\n  // A moved endpoint (a new `url`) is dialed fresh instead, and in-flight\n  // calls finish on the old connection.\n  const refreshConnection = async (connection: ConnectionIface) => {\n    if (closedByUser || connection.peer.isClosed()) return;\n    await refreshOrigin();\n    if (origin.url === connection.target.url) {\n      const result = await requestOn(connection, HandleRpcMethod.AuthRefresh, {\n        token: origin.token,\n      });\n      connection.target = {\n        ...connection.target,\n        token: origin.token,\n        expiresAt: result.expiresAt,\n      };\n      connection.info = { ...connection.info, expiresAt: result.expiresAt };\n      scheduleRefresh(connection);\n      return;\n    }\n    if (current === connection) current = null;\n    await getConnection();\n  };\n\n  const initialize = async (target: TargetIface): Promise<ConnectionIface> => {\n    const channel = await openChannel({ url: target.url, token: target.token });\n    let connection: ConnectionIface | null = null;\n    const peer = createRpcPeer({\n      channel,\n      binary,\n      onClose: () => {\n        if (connection == null) return;\n        live.delete(connection);\n        if (current === connection) current = null;\n      },\n    });\n    try {\n      const raw = await peer.request(HandleRpcMethod.Initialize, {\n        handleRpcVersion: HANDLE_RPC_VERSION,\n        token: target.token,\n        client: args.clientInfo,\n      });\n      const info = handleRpcMethodSchemas[HandleRpcMethod.Initialize].result.parse(raw);\n      connection = { peer, target, info, nextStreamId: 1 };\n      live.add(connection);\n      return connection;\n    } catch (error) {\n      peer.close(HandleRpcCloseCode.Normal, 'initialize failed');\n      throw error;\n    }\n  };\n\n  const establish = async (): Promise<ConnectionIface> => {\n    let failures = 0;\n    let refreshed = false;\n    for (;;) {\n      if (closedByUser)\n        throw handleRpcError({\n          code: HandleRpcErrorCode.ConnectionClosed,\n          message: 'client closed',\n        });\n      try {\n        const connection = await initialize(origin);\n        current = connection;\n        lastInfo = connection.info;\n        scheduleRefresh(connection);\n        return connection;\n      } catch (error) {\n        if (closedByUser) throw error;\n        const unauthorized =\n          isHandleRpcError(error) && error.code === HandleRpcErrorCode.Unauthorized;\n        if (unauthorized && !refreshed && (await refreshOrigin().catch(() => false))) {\n          refreshed = true;\n          continue;\n        }\n        if (unauthorized) throw error;\n        failures += 1;\n        if (failures >= attempts) {\n          throw handleRpcError({\n            code: HandleRpcErrorCode.ConnectionClosed,\n            message: `could not connect to the sandbox: ${error instanceof Error ? error.message : String(error)}`,\n            retryable: true,\n          });\n        }\n        await sleep(Math.min(maxDelayMs, baseDelayMs * 2 ** (failures - 1)));\n      }\n    }\n  };\n\n  const getConnection = (): Promise<ConnectionIface> => {\n    if (current != null && !current.peer.isClosed()) return Promise.resolve(current);\n    connecting ??= establish().finally(() => {\n      connecting = null;\n    });\n    return connecting;\n  };\n\n  const requestOn = async <M extends HandleRpcMethod>(\n    connection: ConnectionIface,\n    method: M,\n    params: HandleRpcParams<M>,\n    options?: { signal?: AbortSignal },\n  ): Promise<HandleRpcResult<M>> => {\n    const raw = await connection.peer.request(method, params, { signal: options?.signal });\n    return parseHandleRpcResult(method, raw);\n  };\n\n  const callOnConnection = async <M extends HandleRpcMethod>(\n    method: M,\n    params: HandleRpcParams<M>,\n    options?: { signal?: AbortSignal },\n  ): Promise<{ connection: ConnectionIface; result: HandleRpcResult<M> }> => {\n    const idempotent = HANDLE_RPC_IDEMPOTENT_METHODS.includes(method);\n    for (let attempt = 0; ; attempt += 1) {\n      const connection = await getConnection();\n      try {\n        return { connection, result: await requestOn(connection, method, params, options) };\n      } catch (error) {\n        if (attempt === 0 && idempotent && isRetryable(error)) continue;\n        throw error;\n      }\n    }\n  };\n\n  const call = async <M extends HandleRpcMethod>(\n    method: M,\n    params: HandleRpcParams<M>,\n    options?: { signal?: AbortSignal },\n  ): Promise<HandleRpcResult<M>> => (await callOnConnection(method, params, options)).result;\n\n  const allocateStreamId = (connection: ConnectionIface): number => {\n    const id = connection.nextStreamId;\n    connection.nextStreamId += 1;\n    return id;\n  };\n\n  const first = await getConnection();\n  const describe = (): InitializeResultIface => current?.info ?? lastInfo ?? first.info;\n\n  const readFile = async (options: {\n    path: string;\n    root?: string;\n    offset?: number;\n    length?: number;\n    abortSignal?: AbortSignal;\n  }) => {\n    const connection = await getConnection();\n    const streamId = allocateStreamId(connection);\n    const stream = connection.peer.streams.openIncoming(streamId);\n    try {\n      const result = await requestOn(\n        connection,\n        HandleRpcMethod.ReadFile,\n        {\n          path: options.path,\n          root: options.root,\n          streamId,\n          offset: options.offset,\n          length: options.length,\n        },\n        { signal: options.abortSignal },\n      );\n      if (!result.found) {\n        connection.peer.streams.discardIncoming(streamId);\n        return null;\n      }\n    } catch (error) {\n      connection.peer.streams.discardIncoming(streamId);\n      throw error;\n    }\n    options.abortSignal?.addEventListener(\n      'abort',\n      () => connection.peer.streams.cancelIncoming(streamId, 'aborted'),\n      {\n        once: true,\n      },\n    );\n    return stream;\n  };\n\n  const writeFile = async (options: {\n    path: string;\n    content: ReadableStream<Uint8Array>;\n    abortSignal?: AbortSignal;\n  }) => {\n    const connection = await getConnection();\n    const streamId = allocateStreamId(connection);\n    const sending = connection.peer.streams.openOutgoing(streamId, options.content);\n    sending.catch(() => undefined);\n    try {\n      await requestOn(\n        connection,\n        HandleRpcMethod.WriteFile,\n        { path: options.path, streamId },\n        { signal: options.abortSignal },\n      );\n    } catch (error) {\n      connection.peer.streams.abortOutgoing(streamId, 'request failed');\n      throw error;\n    }\n  };\n\n  const writeBinaryFile = async (options: {\n    path: string;\n    content: Uint8Array;\n    abortSignal?: AbortSignal;\n  }) => {\n    if (options.content.byteLength > MAX_INLINE_WRITE_BYTES) {\n      await writeFile({\n        path: options.path,\n        content: bytesToStream(options.content),\n        abortSignal: options.abortSignal,\n      });\n      return;\n    }\n    await call(\n      HandleRpcMethod.WriteFile,\n      { path: options.path, contentBase64: bytesToBase64(options.content) },\n      { signal: options.abortSignal },\n    );\n  };\n\n  const spawn = async (options: SandboxProcessOptionsIface): Promise<SandboxProcessIface> => {\n    const connection = await getConnection();\n    const processId = randomId();\n    const stdoutStreamId = allocateStreamId(connection);\n    const stderrStreamId = allocateStreamId(connection);\n    const stdinStreamId = allocateStreamId(connection);\n    const stdout = connection.peer.streams.openIncoming(stdoutStreamId);\n    const stderr = connection.peer.streams.openIncoming(stderrStreamId);\n    let stdinWriter: WritableStreamDefaultWriter<Uint8Array> | null = null;\n    let stdinSource: ReadableStream<Uint8Array>;\n    if (options.stdin == null) {\n      const pipe = new TransformStream<Uint8Array, Uint8Array>();\n      stdinWriter = pipe.writable.getWriter();\n      stdinSource = pipe.readable;\n    } else if (options.stdin instanceof ReadableStream) {\n      stdinSource = options.stdin;\n    } else {\n      stdinSource = bytesToStream(utf8Encode(options.stdin));\n    }\n    connection.peer.streams.openOutgoing(stdinStreamId, stdinSource).catch(() => undefined);\n    let pid: string | null;\n    try {\n      const result = await requestOn(connection, HandleRpcMethod.Spawn, {\n        processId,\n        command: options.command,\n        args: options.args,\n        cwd: options.cwd,\n        env: options.env,\n        shell: options.shell,\n        timeoutMs: options.timeoutMs,\n        stdinStreamId,\n        stdoutStreamId,\n        stderrStreamId,\n      });\n      pid = result.pid;\n    } catch (error) {\n      connection.peer.streams.discardIncoming(stdoutStreamId);\n      connection.peer.streams.discardIncoming(stderrStreamId);\n      connection.peer.streams.abortOutgoing(stdinStreamId, 'spawn failed');\n      throw error;\n    }\n    let waiting: Promise<{ exitCode: number }> | null = null;\n    const kill = async (signal?: string) => {\n      try {\n        await requestOn(connection, HandleRpcMethod.ProcessKill, { processId, signal });\n      } catch (error) {\n        // Already exited and reaped, or the connection (and so the process) is gone.\n        if (\n          isHandleRpcError(error) &&\n          (error.code === HandleRpcErrorCode.NotFound || error.retryable)\n        )\n          return;\n        throw error;\n      }\n    };\n    options.abortSignal?.addEventListener('abort', () => void kill().catch(() => undefined), {\n      once: true,\n    });\n    return {\n      pid,\n      stdout,\n      stderr,\n      write: async (data, writeOptions) => {\n        if (stdinWriter == null) throw new Error('stdin was provided at spawn');\n        const bytes = data instanceof Uint8Array ? data : utf8Encode(data);\n        if (bytes.byteLength > 0) await stdinWriter.write(bytes);\n        if (writeOptions?.end === true) await stdinWriter.close();\n      },\n      wait: () => {\n        waiting ??= requestOn(\n          connection,\n          HandleRpcMethod.ProcessWait,\n          { processId },\n          { signal: options.abortSignal },\n        );\n        return waiting;\n      },\n      kill,\n    };\n  };\n\n  const client: SandboxClientIface = {\n    get id() {\n      return describe().id;\n    },\n    get defaultWorkingDirectory() {\n      return describe().defaultWorkingDirectory;\n    },\n    get ports() {\n      return describe().ports;\n    },\n    get description() {\n      return describe().description;\n    },\n    get capabilities() {\n      return describe().capabilities;\n    },\n    confinedFiles: describe().confinedFiles === true,\n    providerHooks: describe().providerHooks === true,\n    onRuntimeShutdown: async () => {\n      await call(HandleRpcMethod.OnRuntimeShutdown, {});\n    },\n    onSandboxStop: async () => {\n      await call(HandleRpcMethod.OnSandboxStop, {});\n    },\n    onSandboxDelete: async (options) => {\n      await call(HandleRpcMethod.OnSandboxDelete, options ?? {});\n    },\n    readFile: (options) => readFile(options),\n    readFileRange: readFile,\n    readBinaryFile: async (options) => {\n      const stream = await readFile(options);\n      return stream == null ? null : readAllBytes(stream);\n    },\n    readTextFile: async (options) => {\n      const { abortSignal: _abortSignal, ...params } = options;\n      const parsed = handleRpcMethodSchemas[HandleRpcMethod.ReadTextFile].params.safeParse(params);\n      if (!parsed.success)\n        throw handleRpcError({\n          code: HandleRpcErrorCode.InvalidParams,\n          message: parsed.error.message,\n        });\n      const stream = await readFile({ path: options.path, abortSignal: options.abortSignal });\n      return stream == null ? null : readTextFileStream(stream, options);\n    },\n    writeFile,\n    writeBinaryFile,\n    writeTextFile: async (options) =>\n      writeBinaryFile({\n        path: options.path,\n        content: encodeSandboxText(options.content, options.encoding),\n        abortSignal: options.abortSignal,\n      }),\n    spawn,\n    run: (options) => runCollect({ spawn }, options),\n    stat: async (options): Promise<StatIface | null> =>\n      (\n        await call(\n          HandleRpcMethod.Stat,\n          { path: options.path, root: options.root },\n          { signal: options.abortSignal },\n        )\n      ).stat,\n    readDir: async (options): Promise<DirEntryIface[]> =>\n      (\n        await call(\n          HandleRpcMethod.ReadDir,\n          { path: options.path, root: options.root },\n          { signal: options.abortSignal },\n        )\n      ).entries,\n    resolvePath: (path) => resolvePosixPath(describe().defaultWorkingDirectory, path),\n    removePath: async (options) => {\n      const { abortSignal, ...params } = options;\n      await call(HandleRpcMethod.RemovePath, params, { signal: abortSignal });\n    },\n    getPortEndpoint: (options) => call(HandleRpcMethod.GetPortEndpoint, options),\n    getPortUrl: async (options) => (await call(HandleRpcMethod.GetPortEndpoint, options)).url,\n    stop: async () => {\n      await call(HandleRpcMethod.Stop, {});\n    },\n    destroy: async () => {\n      await call(HandleRpcMethod.Destroy, {});\n    },\n    close: () => {\n      closedByUser = true;\n      if (refreshTimer != null) clearTimeout(refreshTimer);\n      for (const connection of live)\n        connection.peer.close(HandleRpcCloseCode.Normal, 'client closed');\n      live.clear();\n      current = null;\n    },\n  };\n\n  const mcpEndpoint = (\n    connection: ConnectionIface,\n    endpoint: HandleRpcResult<HandleRpcMethod.ComputerUse>,\n  ): SandboxMcpEndpoint => {\n    if ('url' in endpoint) return endpoint;\n    return {\n      name: endpoint.name,\n      connect: async (options?: AbortableIface): Promise<McpChannelIface> => {\n        const opened = await requestOn(\n          connection,\n          HandleRpcMethod.McpOpen,\n          { endpointKey: endpoint.endpointKey },\n          { signal: options?.abortSignal },\n        );\n        let closed = false;\n        const requireOpen = (): void => {\n          if (closed)\n            throw handleRpcError({\n              code: HandleRpcErrorCode.ConnectionClosed,\n              message: 'MCP channel closed',\n            });\n        };\n        const channel: McpChannelIface = {\n          send: async (message, sendOptions) => {\n            requireOpen();\n            await requestOn(\n              connection,\n              HandleRpcMethod.McpSend,\n              { channelId: opened.channelId, message },\n              { signal: sendOptions?.abortSignal },\n            );\n          },\n          receive: async (receiveOptions) => {\n            requireOpen();\n            return (\n              await requestOn(\n                connection,\n                HandleRpcMethod.McpReceive,\n                { channelId: opened.channelId },\n                { signal: receiveOptions?.abortSignal },\n              )\n            ).messages;\n          },\n          close: async () => {\n            if (closed) return;\n            closed = true;\n            if (!connection.peer.isClosed())\n              await requestOn(connection, HandleRpcMethod.McpClose, {\n                channelId: opened.channelId,\n              });\n          },\n        };\n        if (options?.abortSignal?.aborted === true) {\n          await channel.close().catch(() => undefined);\n          options.abortSignal.throwIfAborted();\n        }\n        return channel;\n      },\n    };\n  };\n\n  const capabilities = first.info.capabilities;\n  if (capabilities.includes(SandboxCapability.NetworkPolicy)) {\n    client.setNetworkPolicy = async (policy: NetworkPolicyIface) => {\n      await call(HandleRpcMethod.SetNetworkPolicy, policy);\n    };\n  }\n  if (capabilities.includes(SandboxCapability.ComputerUse)) {\n    client.computerUse = async (): Promise<SandboxMcpEndpoint> => {\n      const { connection, result } = await callOnConnection(HandleRpcMethod.ComputerUse, {});\n      return mcpEndpoint(connection, result);\n    };\n  }\n  if (capabilities.includes(SandboxCapability.Screen)) {\n    client.screen = (options): Promise<ScreenSessionIface> =>\n      call(HandleRpcMethod.Screen, options ?? {});\n  }\n  if (capabilities.includes(SandboxCapability.LocalMcp)) {\n    client.localMcp = async (): Promise<SandboxMcpEndpoint[]> => {\n      const { connection, result } = await callOnConnection(HandleRpcMethod.LocalMcp, {});\n      return result.endpoints.map((endpoint) => mcpEndpoint(connection, endpoint));\n    };\n  }\n  return client;\n};\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/modules/sandbox/confined-files.d.mts

@@ -0,0 +1,22 @@
+import type { AbortableIface, ConfinedSandboxFilesIface, SandboxSessionIface } from "./types.mjs";
+export declare const CONFINED_FILES_SCRIPT = "import json, os, stat, sys, datetime\np = json.loads(sys.argv[1])\nroot = os.path.normpath(p['root'])\npath = os.path.normpath(p['path'])\nif not root.startswith('/') or not path.startswith('/') or os.path.commonpath([root, path]) != root:\n    raise ValueError('path outside workspace')\nfd = os.open('/', os.O_RDONLY | os.O_DIRECTORY)\ntry:\n    parts = [x for x in path.split('/') if x]\n    for i, part in enumerate(parts):\n        flags = os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK\n        if i < len(parts) - 1 or p['operation'] == 'directory':\n            flags |= os.O_DIRECTORY\n        next_fd = os.open(part, flags, dir_fd=fd)\n        os.close(fd)\n        fd = next_fd\n    info = os.fstat(fd)\n    def kind(s):\n        return 'directory' if stat.S_ISDIR(s.st_mode) else 'file' if stat.S_ISREG(s.st_mode) else 'symlink' if stat.S_ISLNK(s.st_mode) else 'other'\n    if p['operation'] == 'stat':\n        print(json.dumps({'path': path, 'type': kind(info), 'size': info.st_size, 'modifiedAt': datetime.datetime.fromtimestamp(info.st_mtime, datetime.timezone.utc).isoformat(), 'mode': stat.S_IMODE(info.st_mode)}))\n    elif p['operation'] == 'directory':\n        entries = []\n        for name in os.listdir(fd):\n            try:\n                s = os.stat(name, dir_fd=fd, follow_symlinks=False)\n            except FileNotFoundError:\n                continue\n            entries.append({'name': name, 'path': os.path.join(path, name), 'type': kind(s), 'size': s.st_size})\n        print(json.dumps(entries))\n    else:\n        if not stat.S_ISREG(info.st_mode):\n            raise ValueError('not a regular file')\n        sys.stdout.buffer.write(b'OK\\n')\n        sys.stdout.buffer.flush()\n        while True:\n            chunk = os.read(fd, 65536)\n            if not chunk:\n                break\n            sys.stdout.buffer.write(chunk)\nexcept FileNotFoundError:\n    if p['operation'] == 'read':\n        sys.stdout.buffer.write(b'MISSING\\n')\n    else:\n        print('null')\nfinally:\n    os.close(fd)\n";
+interface ConfinedPathIface extends AbortableIface {
+    path: string;
+    root: string;
+}
+export declare const confinedStat: (sandbox: Pick<SandboxSessionIface, "run" | "spawn">, options: ConfinedPathIface) => Promise<{
+    path: string;
+    type: import("./types.mjs").SandboxEntryType;
+    size: number;
+    modifiedAt: string | null;
+    mode: number | null;
+} | null>;
+export declare const confinedReadDir: (sandbox: Pick<SandboxSessionIface, "run" | "spawn">, options: ConfinedPathIface) => Promise<{
+    name: string;
+    path: string;
+    type: import("./types.mjs").SandboxEntryType;
+    size: number | null;
+}[]>;
+export declare const confinedReadFile: (sandbox: Pick<SandboxSessionIface, "run" | "spawn">, options: ConfinedPathIface) => Promise<ReadableStream<Uint8Array<ArrayBufferLike>> | null>;
+export declare const createConfinedFileReader: (sandbox: Pick<SandboxSessionIface, "run" | "spawn">) => ConfinedSandboxFilesIface;
+export {};