@ai-sdk/harness-codex 1.0.27 → 1.0.29

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @ai-sdk/harness-codex
 
+## 1.0.29
+
+### Patch Changes
+
+- c93803d: fix(harness): improve CLI relay tool invocation logic
+
+## 1.0.28
+
+### Patch Changes
+
+- @ai-sdk/harness@1.0.27
+
 ## 1.0.27
 
 ### Patch Changes

package/dist/bridge/index.mjs

@@ -480,7 +480,6 @@ function serialiseError(err) {
 // src/bridge/index.ts
 import { randomUUID } from "crypto";
 import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
-import { createServer } from "http";
 
 // src/bridge/cli-relay.ts
 var CLI_SHIM_FILENAME = "harness-tool.mjs";
@@ -520,24 +519,39 @@ if (!response.ok || payload.error) {
 console.log(JSON.stringify(payload.result ?? payload, null, 2));
 `;
 }
-function parseToolRelayCommand({
+function parseToolRelayCommands({
   command,
   cliShimPath
 }) {
-  return parseToolRelayCommandInternal({ command, cliShimPath, depth: 0 });
+  return parseToolRelayCommandsInternal({ command, cliShimPath, depth: 0 });
 }
-function parseToolRelayCommandInternal({
+function parseToolRelayCommandsInternal({
   command,
   cliShimPath,
   depth
 }) {
+  const commands = splitShellAndCommands(command);
+  if (!commands) return void 0;
+  if (commands.length > 1) {
+    const relayCalls = [];
+    for (const nestedCommand of commands) {
+      const nestedCalls = parseToolRelayCommandsInternal({
+        command: nestedCommand,
+        cliShimPath,
+        depth
+      });
+      if (!nestedCalls) return void 0;
+      relayCalls.push(...nestedCalls);
+    }
+    return relayCalls;
+  }
   const argv2 = parseShellWords(command);
   if (!argv2) return void 0;
   const relayCall = parseDirectToolRelayArgv({ argv: argv2, cliShimPath });
-  if (relayCall) return relayCall;
+  if (relayCall) return [relayCall];
   const innerCommand = extractShellEvalCommand(argv2);
   if (!innerCommand || depth >= 2) return void 0;
-  return parseToolRelayCommandInternal({
+  return parseToolRelayCommandsInternal({
     command: innerCommand,
     cliShimPath,
     depth: depth + 1
@@ -566,6 +580,46 @@ function extractShellEvalCommand(argv2) {
   if (argv2[1] !== "-c" && argv2[1] !== "-lc") return void 0;
   return argv2[2];
 }
+function splitShellAndCommands(command) {
+  const commands = [];
+  let start = 0;
+  let quote;
+  for (let i = 0; i < command.length; i++) {
+    const char = command[i];
+    if (quote === "'") {
+      if (char === "'") quote = void 0;
+      continue;
+    }
+    if (quote === '"') {
+      if (char === '"') {
+        quote = void 0;
+      } else if (char === "\\") {
+        i++;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (char === "\\") {
+      i++;
+      continue;
+    }
+    if (char === "&" && command[i + 1] === "&") {
+      const nestedCommand2 = command.slice(start, i).trim();
+      if (!nestedCommand2) return void 0;
+      commands.push(nestedCommand2);
+      start = i + 2;
+      i++;
+    }
+  }
+  if (quote) return void 0;
+  const nestedCommand = command.slice(start).trim();
+  if (!nestedCommand) return void 0;
+  commands.push(nestedCommand);
+  return commands;
+}
 function parseShellWords(command) {
   const words = [];
   let current = "";
@@ -670,40 +724,71 @@ function defaultUsage() {
   };
 }
 
+// src/bridge/tool-relay.ts
+import { createServer } from "http";
+
 // src/bridge/tool-relay-auth.ts
-import { readdir, readFile, readlink } from "fs/promises";
 var ToolRelayAuthorizer = class {
   constructor({
     ttlMs = 1e4,
     now = Date.now
   } = {}) {
     this.authorizations = [];
+    this.pendingRequests = [];
     this.ttlMs = ttlMs;
     this.now = now;
   }
   authorizeToolCall(call) {
     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() {
+  waitForToolCallAuthorization(call) {
     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) {
-    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 === void 0);
+  close() {
+    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;
   }
   pruneExpired() {
     const now = this.now();
@@ -712,6 +797,14 @@ var ToolRelayAuthorizer = class {
         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);
+      }
+    }
   }
 };
 var ToolRelayPendingCalls = class {
@@ -753,62 +846,96 @@ function normalizeJsonValue(value) {
   }
   return value;
 }
-async function isToolRelayRequestFromAllowedProcess({
-  socket,
-  allowedScriptPaths
-}) {
-  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
+
+// src/bridge/tool-relay.ts
+async function startAuthorizedToolRelay({
+  tools,
+  emit,
+  requestToolResult,
+  authorizer = new ToolRelayAuthorizer()
 }) {
-  for (const tablePath of ["/proc/net/tcp", "/proc/net/tcp6"]) {
-    const table = await readFile(tablePath, "utf8").catch(() => void 0);
-    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];
+  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 = [];
+      for await (const chunk of req) {
+        chunks.push(chunk);
+      }
+      const body = Buffer.concat(chunks).toString("utf8");
+      const { requestId, toolName, input } = JSON.parse(body);
+      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(
+    (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 void 0;
-}
-function parseProcNetAddress(value) {
-  const [, portHex] = value.split(":");
-  if (!portHex) return void 0;
-  return { port: Number.parseInt(portHex, 16) };
+  return {
+    port: address.port,
+    close: () => {
+      authorizer.close();
+      closeServer(server);
+    },
+    authorizeToolCall: (call) => authorizer.authorizeToolCall(call)
+  };
 }
-async function findProcessCmdlineForSocketInode({
-  inode
-}) {
-  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(() => void 0);
-      if (target !== `socket:[${inode}]`) continue;
-      const cmdline = await readFile(`/proc/${entry.name}/cmdline`, "utf8").then((value) => value.split("\0").filter(Boolean)).catch(() => void 0);
-      if (cmdline) return cmdline;
-    }
+function closeServer(server) {
+  try {
+    server.close();
+  } catch {
   }
-  return void 0;
 }
 
 // src/bridge/index.ts
@@ -852,7 +979,6 @@ async function runTurn(start, turn) {
   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
@@ -946,18 +1072,16 @@ async function runTurn(start, turn) {
         emit({ type: "bridge-thread", threadId: event.thread_id });
       }
       if (cliShimPath && event.item?.type === "command_execution") {
-        const relayCall = typeof event.item.command === "string" ? parseToolRelayCommand({
+        const relayCalls = typeof event.item.command === "string" ? parseToolRelayCommands({
           command: event.item.command,
           cliShimPath
         }) : void 0;
-        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;
         }
@@ -1174,97 +1298,11 @@ function mapUsage(usage) {
   };
 }
 async function startToolRelay({
-  allowedScriptPaths,
   tools,
   emit,
   requestToolResult
 }) {
-  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 = [];
-      for await (const chunk of req) {
-        chunks.push(chunk);
-      }
-      const body = Buffer.concat(chunks).toString("utf8");
-      const { requestId, toolName, input } = JSON.parse(body);
-      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(
-    (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) {
-  try {
-    server.close();
-  } catch {
-  }
+  return startAuthorizedToolRelay({ tools, emit, requestToolResult });
 }
 function parseArgs(args2) {
   const out = {};