@ai-sdk/harness-codex 1.0.28 → 1.0.29

package/src/bridge/index.ts

@@ -19,24 +19,19 @@ import type { HarnessV1BuiltinToolName } from '@ai-sdk/harness';
 import type { StartMessage } from '../codex-bridge-protocol';
 import { randomUUID } from 'node:crypto';
 import { mkdir, writeFile } from 'node:fs/promises';
-import { createServer, type Server } from 'node:http';
 // Temporary workaround for upstream codex MCP-tool bug — see ./cli-relay.ts
 import {
   CLI_SHIM_FILENAME,
   buildCliShimScript,
-  parseToolRelayCommand,
+  parseToolRelayCommands,
 } from './cli-relay';
 import {
   createCodexStepTracker,
   defaultUsage,
   type CodexStepTracker,
 } from './codex-step-tracker';
-import {
-  ToolRelayAuthorizer,
-  ToolRelayPendingCalls,
-  isToolRelayRequestFromAllowedProcess,
-  type ToolRelayCall,
-} from './tool-relay-auth';
+import { startAuthorizedToolRelay, type ToolRelay } from './tool-relay';
+import type { ToolRelayCall } from './tool-relay-auth';
 import { argv, env as procEnv, stdout } from 'node:process';
 
 /*
@@ -100,12 +95,6 @@ await runBridge<StartMessage>({
 });
 
 type Emit = (msg: Record<string, unknown>) => void;
-type ToolRelay = {
-  port: number;
-  close(): void;
-  authorizeToolCall(call: ToolRelayCall): void;
-  authorizeAnyToolCall(): void;
-};
 
 async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
   const emit: Emit = msg => turn.emit(msg as BridgeEvent);
@@ -142,7 +131,6 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
   if (start.tools && start.tools.length > 0) {
     cliShimPath = `${cliShimDir}/${CLI_SHIM_FILENAME}`;
     relay = await startToolRelay({
-      allowedScriptPaths: [cliShimPath, `${bootstrapDir}/host-tool-mcp.mjs`],
       tools: start.tools,
       emit,
       requestToolResult: turn.requestToolResult,
@@ -258,21 +246,19 @@ async function runTurn(start: StartMessage, turn: BridgeTurn): Promise<void> {
       }
       // Temporary workaround for upstream codex MCP-tool bug — see ./cli-relay.ts
       if (cliShimPath && event.item?.type === 'command_execution') {
-        const relayCall =
+        const relayCalls =
           typeof event.item.command === 'string'
-            ? parseToolRelayCommand({
+            ? parseToolRelayCommands({
                 command: event.item.command,
                 cliShimPath,
               })
             : undefined;
-        if (event.type === 'item.started' && relay) {
-          if (relayCall) {
+        if (event.type === 'item.started' && relay && relayCalls) {
+          for (const relayCall of relayCalls) {
             relay.authorizeToolCall(relayCall);
-          } else if (typeof event.item.command !== 'string') {
-            relay.authorizeAnyToolCall();
           }
         }
-        if (relayCall) {
+        if (relayCalls) {
           stepTracker.observeEvent({ event, itemId: event.item.id });
           continue;
         }
@@ -589,116 +575,17 @@ function mapUsage(usage: Record<string, number>): Record<string, unknown> {
  * (via `requestToolResult`), and responds with `{ result }`.
  */
 async function startToolRelay({
-  allowedScriptPaths,
   tools,
   emit,
   requestToolResult,
 }: {
-  allowedScriptPaths: ReadonlyArray<string>;
   tools: ReadonlyArray<{ name: string }>;
   emit: Emit;
   requestToolResult: (
     toolCallId: string,
   ) => Promise<{ output: unknown; isError?: boolean }>;
 }): Promise<ToolRelay> {
-  const toolNames = new Set(tools.map(t => t.name));
-  const allowedScriptPathSet = new Set(allowedScriptPaths);
-  const authorizer = new ToolRelayAuthorizer();
-  const pendingCalls = new ToolRelayPendingCalls();
-
-  const server = createServer(async (req, res) => {
-    try {
-      if (req.method !== 'POST' || req.url !== '/') {
-        res.writeHead(401, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'unauthorized tool relay request' }));
-        return;
-      }
-      const chunks: Buffer[] = [];
-      for await (const chunk of req) {
-        chunks.push(chunk as Buffer);
-      }
-      const body = Buffer.concat(chunks).toString('utf8');
-      const { requestId, toolName, input } = JSON.parse(body) as {
-        requestId: string;
-        toolName: string;
-        input: unknown;
-      };
-
-      if (!toolNames.has(toolName)) {
-        res.writeHead(403, { 'Content-Type': 'application/json' });
-        res.end(
-          JSON.stringify({ error: `Tool "${toolName}" is not available` }),
-        );
-        return;
-      }
-      const relayCall = { toolName, input };
-      const authorized =
-        authorizer.consumeToolCall(relayCall) ||
-        (await isToolRelayRequestFromAllowedProcess({
-          socket: req.socket,
-          allowedScriptPaths: allowedScriptPathSet,
-        }));
-      if (!authorized) {
-        res.writeHead(401, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'unauthorized tool relay request' }));
-        return;
-      }
-
-      const { result } = pendingCalls.begin({
-        call: relayCall,
-        run: async () => {
-          emit({
-            type: 'tool-call',
-            toolCallId: requestId,
-            toolName,
-            input: JSON.stringify(input ?? {}),
-            providerExecuted: false,
-          });
-
-          const toolResult = await requestToolResult(requestId);
-          emit({
-            type: 'tool-result',
-            toolCallId: requestId,
-            toolName,
-            result: toolResult.output ?? null,
-            isError: !!toolResult.isError,
-          });
-          return toolResult;
-        },
-      });
-      const { output } = await result;
-
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ result: output }));
-    } catch (error) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(
-        JSON.stringify({
-          error: error instanceof Error ? error.message : String(error),
-        }),
-      );
-    }
-  });
-
-  await new Promise<void>(resolve =>
-    server.listen(0, '127.0.0.1', () => resolve()),
-  );
-  const address = server.address();
-  if (!address || typeof address === 'string') {
-    throw new Error('tool relay did not expose a numeric port');
-  }
-  return {
-    port: address.port,
-    close: () => closeServer(server),
-    authorizeToolCall: call => authorizer.authorizeToolCall(call),
-    authorizeAnyToolCall: () => authorizer.authorizeAnyToolCall(),
-  };
-}
-
-function closeServer(server: Server): void {
-  try {
-    server.close();
-  } catch {}
+  return startAuthorizedToolRelay({ tools, emit, requestToolResult });
 }
 
 function parseArgs(args: string[]): {

package/src/bridge/tool-relay-auth.ts

@@ -1,6 +1,3 @@
-import { readdir, readFile, readlink } from 'node:fs/promises';
-import type { Socket } from 'node:net';
-
 export type ToolRelayCall = {
   toolName: string;
   input: unknown;
@@ -14,9 +11,13 @@ export type ToolRelayResult = {
 export class ToolRelayAuthorizer {
   private readonly ttlMs: number;
   private readonly now: () => number;
-  private readonly authorizations: Array<{
-    key?: string;
+  private readonly authorizations: Array<{ key: string; expiresAt: number }> =
+    [];
+  private readonly pendingRequests: Array<{
+    key: string;
     expiresAt: number;
+    timeout: ReturnType<typeof setTimeout>;
+    resolve: (authorized: boolean) => void;
   }> = [];
 
   constructor({
@@ -32,29 +33,58 @@ export class ToolRelayAuthorizer {
 
   authorizeToolCall(call: ToolRelayCall): void {
     this.pruneExpired();
+    const key = toolRelayCallKey(call);
+    const pendingRequestIndex = this.pendingRequests.findIndex(
+      request => request.key === key,
+    );
+    if (pendingRequestIndex !== -1) {
+      const [pendingRequest] = this.pendingRequests.splice(
+        pendingRequestIndex,
+        1,
+      );
+      clearTimeout(pendingRequest.timeout);
+      pendingRequest.resolve(true);
+      return;
+    }
     this.authorizations.push({
-      key: toolRelayCallKey(call),
+      key,
       expiresAt: this.now() + this.ttlMs,
     });
   }
 
-  authorizeAnyToolCall(): void {
+  waitForToolCallAuthorization(call: ToolRelayCall): Promise<boolean> {
     this.pruneExpired();
-    this.authorizations.push({
-      expiresAt: this.now() + this.ttlMs,
+    const key = toolRelayCallKey(call);
+    const authorizationIndex = this.authorizations.findIndex(
+      authorization => authorization.key === key,
+    );
+    if (authorizationIndex !== -1) {
+      this.authorizations.splice(authorizationIndex, 1);
+      return Promise.resolve(true);
+    }
+
+    const expiresAt = this.now() + this.ttlMs;
+    return new Promise(resolve => {
+      const pendingRequest = {
+        key,
+        expiresAt,
+        timeout: setTimeout(() => {
+          const index = this.pendingRequests.indexOf(pendingRequest);
+          if (index !== -1) this.pendingRequests.splice(index, 1);
+          resolve(false);
+        }, this.ttlMs),
+        resolve,
+      };
+      this.pendingRequests.push(pendingRequest);
     });
   }
 
-  consumeToolCall(call: ToolRelayCall): boolean {
-    this.pruneExpired();
-    const key = toolRelayCallKey(call);
-    let index = this.authorizations.findIndex(auth => auth.key === key);
-    if (index === -1) {
-      index = this.authorizations.findIndex(auth => auth.key === undefined);
+  close(): void {
+    this.authorizations.length = 0;
+    for (const pendingRequest of this.pendingRequests.splice(0)) {
+      clearTimeout(pendingRequest.timeout);
+      pendingRequest.resolve(false);
     }
-    if (index === -1) return false;
-    this.authorizations.splice(index, 1);
-    return true;
   }
 
   private pruneExpired(): void {
@@ -64,6 +94,14 @@ export class ToolRelayAuthorizer {
         this.authorizations.splice(i, 1);
       }
     }
+    for (let i = this.pendingRequests.length - 1; i >= 0; i--) {
+      const pendingRequest = this.pendingRequests[i];
+      if (pendingRequest.expiresAt <= now) {
+        this.pendingRequests.splice(i, 1);
+        clearTimeout(pendingRequest.timeout);
+        pendingRequest.resolve(false);
+      }
+    }
   }
 }
 
@@ -116,80 +154,3 @@ function normalizeJsonValue(value: unknown): unknown {
   }
   return value;
 }
-
-export async function isToolRelayRequestFromAllowedProcess({
-  socket,
-  allowedScriptPaths,
-}: {
-  socket: Socket;
-  allowedScriptPaths: ReadonlySet<string>;
-}): Promise<boolean> {
-  if (process.platform !== 'linux') return false;
-  if (!socket.remotePort || !socket.localPort) return false;
-
-  const inode = await findTcpSocketInode({
-    clientPort: socket.remotePort,
-    serverPort: socket.localPort,
-  });
-  if (!inode) return false;
-
-  const cmdline = await findProcessCmdlineForSocketInode({ inode });
-  return cmdline?.some(arg => allowedScriptPaths.has(arg)) ?? false;
-}
-
-async function findTcpSocketInode({
-  clientPort,
-  serverPort,
-}: {
-  clientPort: number;
-  serverPort: number;
-}): Promise<string | undefined> {
-  for (const tablePath of ['/proc/net/tcp', '/proc/net/tcp6']) {
-    const table = await readFile(tablePath, 'utf8').catch(() => undefined);
-    if (!table) continue;
-    for (const line of table.split('\n').slice(1)) {
-      const columns = line.trim().split(/\s+/);
-      if (columns.length < 10) continue;
-      const local = parseProcNetAddress(columns[1]);
-      const remote = parseProcNetAddress(columns[2]);
-      if (
-        local?.port === clientPort &&
-        remote?.port === serverPort &&
-        columns[9] !== '0'
-      ) {
-        return columns[9];
-      }
-    }
-  }
-  return undefined;
-}
-
-function parseProcNetAddress(value: string): { port: number } | undefined {
-  const [, portHex] = value.split(':');
-  if (!portHex) return undefined;
-  return { port: Number.parseInt(portHex, 16) };
-}
-
-async function findProcessCmdlineForSocketInode({
-  inode,
-}: {
-  inode: string;
-}): Promise<string[] | undefined> {
-  const procEntries = await readdir('/proc', { withFileTypes: true }).catch(
-    () => [],
-  );
-  for (const entry of procEntries) {
-    if (!entry.isDirectory() || !/^\d+$/.test(entry.name)) continue;
-    const fdDir = `/proc/${entry.name}/fd`;
-    const fds = await readdir(fdDir).catch(() => []);
-    for (const fd of fds) {
-      const target = await readlink(`${fdDir}/${fd}`).catch(() => undefined);
-      if (target !== `socket:[${inode}]`) continue;
-      const cmdline = await readFile(`/proc/${entry.name}/cmdline`, 'utf8')
-        .then(value => value.split('\0').filter(Boolean))
-        .catch(() => undefined);
-      if (cmdline) return cmdline;
-    }
-  }
-  return undefined;
-}

package/src/bridge/tool-relay.ts

@@ -0,0 +1,119 @@
+import { createServer, type Server } from 'node:http';
+import {
+  ToolRelayAuthorizer,
+  ToolRelayPendingCalls,
+  type ToolRelayCall,
+} from './tool-relay-auth';
+
+export type ToolRelay = {
+  port: number;
+  close(): void;
+  authorizeToolCall(call: ToolRelayCall): void;
+};
+
+export async function startAuthorizedToolRelay({
+  tools,
+  emit,
+  requestToolResult,
+  authorizer = new ToolRelayAuthorizer(),
+}: {
+  tools: ReadonlyArray<{ name: string }>;
+  emit: (message: Record<string, unknown>) => void;
+  requestToolResult: (
+    toolCallId: string,
+  ) => Promise<{ output: unknown; isError?: boolean }>;
+  authorizer?: ToolRelayAuthorizer;
+}): Promise<ToolRelay> {
+  const toolNames = new Set(tools.map(tool => tool.name));
+  const pendingCalls = new ToolRelayPendingCalls();
+
+  const server = createServer(async (req, res) => {
+    try {
+      if (req.method !== 'POST' || req.url !== '/') {
+        res.writeHead(401, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'unauthorized tool relay request' }));
+        return;
+      }
+      const chunks: Buffer[] = [];
+      for await (const chunk of req) {
+        chunks.push(chunk as Buffer);
+      }
+      const body = Buffer.concat(chunks).toString('utf8');
+      const { requestId, toolName, input } = JSON.parse(body) as {
+        requestId: string;
+        toolName: string;
+        input: unknown;
+      };
+
+      if (!toolNames.has(toolName)) {
+        res.writeHead(403, { 'Content-Type': 'application/json' });
+        res.end(
+          JSON.stringify({ error: `Tool "${toolName}" is not available` }),
+        );
+        return;
+      }
+      const relayCall = { toolName, input };
+      if (!(await authorizer.waitForToolCallAuthorization(relayCall))) {
+        res.writeHead(401, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'unauthorized tool relay request' }));
+        return;
+      }
+
+      const { result } = pendingCalls.begin({
+        call: relayCall,
+        run: async () => {
+          emit({
+            type: 'tool-call',
+            toolCallId: requestId,
+            toolName,
+            input: JSON.stringify(input ?? {}),
+            providerExecuted: false,
+          });
+
+          const toolResult = await requestToolResult(requestId);
+          emit({
+            type: 'tool-result',
+            toolCallId: requestId,
+            toolName,
+            result: toolResult.output ?? null,
+            isError: !!toolResult.isError,
+          });
+          return toolResult;
+        },
+      });
+      const { output } = await result;
+
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ result: output }));
+    } catch (error) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(
+        JSON.stringify({
+          error: error instanceof Error ? error.message : String(error),
+        }),
+      );
+    }
+  });
+
+  await new Promise<void>(resolve =>
+    server.listen(0, '127.0.0.1', () => resolve()),
+  );
+  const address = server.address();
+  if (!address || typeof address === 'string') {
+    throw new Error('tool relay did not expose a numeric port');
+  }
+  return {
+    port: address.port,
+    close: () => {
+      authorizer.close();
+      closeServer(server);
+    },
+    authorizeToolCall: call => authorizer.authorizeToolCall(call),
+  };
+}
+
+function closeServer(server: Server): void {
+  try {
+    server.close();
+  } catch {}
+}