@ai-sdk/harness-opencode 1.0.26 → 1.0.28

package/CHANGELOG.md

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

package/dist/bridge/index.mjs

@@ -480,7 +480,6 @@ function serialiseError(err) {
 // src/bridge/index.ts
 import { randomUUID } from "crypto";
 import { mkdirSync } from "fs";
-import { createServer } from "http";
 import path2 from "path";
 import { argv, env as procEnv2 } from "process";
 import {
@@ -703,31 +702,71 @@ function prependOpenCodeBinToPath({
   ].join(path.delimiter);
 }
 
+// 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
     });
   }
-  consumeToolCall(call) {
+  waitForToolCallAuthorization(call) {
     this.pruneExpired();
     const key = toolRelayCallKey(call);
-    const index = this.authorizations.findIndex((auth) => auth.key === key);
-    if (index === -1) return false;
-    this.authorizations.splice(index, 1);
-    return true;
+    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);
+    });
+  }
+  close() {
+    this.authorizations.length = 0;
+    for (const pendingRequest of this.pendingRequests.splice(0)) {
+      clearTimeout(pendingRequest.timeout);
+      pendingRequest.resolve(false);
+    }
   }
   pruneExpired() {
     const now = this.now();
@@ -736,6 +775,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);
+      }
+    }
   }
 };
 function toolRelayCallKey({ toolName, input }) {
@@ -755,62 +802,87 @@ 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 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;
+      }
+      if (!await authorizer.waitForToolCallAuthorization({ toolName, input })) {
+        res.writeHead(401, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "unauthorized tool relay request" }));
+        return;
       }
+      emit({
+        type: "tool-call",
+        toolCallId: requestId,
+        toolName,
+        input: JSON.stringify(input ?? {}),
+        providerExecuted: false
+      });
+      const { output, isError } = await requestToolResult(requestId);
+      emit({
+        type: "tool-result",
+        toolCallId: requestId,
+        toolName,
+        result: output ?? null,
+        isError: !!isError
+      });
+      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
@@ -903,7 +975,6 @@ async function ensureRuntime({
   if (start.tools && start.tools.length > 0) {
     runtime.toolNames = new Set(start.tools.map((tool) => tool.name));
     runtime.relay = await startToolRelay({
-      allowedScriptPaths: [`${bootstrapDir}/host-tool-mcp.mjs`],
       tools: start.tools,
       emit,
       requestToolResult: turn.requestToolResult
@@ -2153,87 +2224,11 @@ function emitAssistantContentPart(part, emit) {
   emit({ type: "reasoning-end", id });
 }
 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 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 authorized = authorizer.consumeToolCall({ toolName, input }) || 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;
-      }
-      emit({
-        type: "tool-call",
-        toolCallId: requestId,
-        toolName,
-        input: JSON.stringify(input ?? {}),
-        providerExecuted: false
-      });
-      const { output, isError } = await requestToolResult(requestId);
-      emit({
-        type: "tool-result",
-        toolCallId: requestId,
-        toolName,
-        result: output ?? null,
-        isError: !!isError
-      });
-      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)
-  };
-}
-function closeServer(server) {
-  try {
-    server.close();
-  } catch {
-  }
+  return startAuthorizedToolRelay({ tools, emit, requestToolResult });
 }
 function createDeferred() {
   let resolve;