@ai-sdk/harness-opencode 1.0.27 → 1.0.28

package/dist/index.js

@@ -168,7 +168,7 @@ var inboundMessageSchema = z.discriminatedUnion("type", [
 ]);
 
 // src/version.ts
-var VERSION = true ? "1.0.27" : "0.0.0-test";
+var VERSION = true ? "1.0.28" : "0.0.0-test";
 
 // src/opencode-harness.ts
 var OPENCODE_CLIENT_APP = `ai-sdk/harness-opencode/${VERSION}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/harness-opencode",
-  "version": "1.0.27",
+  "version": "1.0.28",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,

package/src/bridge/index.ts

@@ -5,7 +5,6 @@ import {
 } from '@ai-sdk/harness/bridge';
 import { randomUUID } from 'node:crypto';
 import { mkdirSync } from 'node:fs';
-import { createServer, type Server } from 'node:http';
 import path from 'node:path';
 import { argv, env as procEnv } from 'node:process';
 import type { StartMessage } from '../opencode-bridge-protocol';
@@ -35,21 +34,12 @@ import {
   type HarnessUsage,
   type OpenCodeTokenUsage,
 } from './opencode-usage';
-import {
-  ToolRelayAuthorizer,
-  isToolRelayRequestFromAllowedProcess,
-  type ToolRelayCall,
-} from './tool-relay-auth';
+import { startAuthorizedToolRelay, type ToolRelay } from './tool-relay';
 
 type Emit = (msg: Record<string, unknown>) => void;
 
 type OpenCodeClient = ReturnType<typeof createOpencodeClient>;
 type OpenCodeServer = Awaited<ReturnType<typeof createOpencodeServer>>;
-type ToolRelay = {
-  port: number;
-  close(): void;
-  authorizeToolCall(call: ToolRelayCall): void;
-};
 
 type RuntimeState = {
   server?: OpenCodeServer;
@@ -172,7 +162,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,
@@ -1814,105 +1803,17 @@ function emitAssistantContentPart(part: unknown, emit: Emit): void {
 }
 
 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 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 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<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),
-  };
-}
-
-function closeServer(server: Server): void {
-  try {
-    server.close();
-  } catch {}
+  return startAuthorizedToolRelay({ tools, emit, requestToolResult });
 }
 
 function createDeferred<T>(): {

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;
@@ -11,6 +8,12 @@ export class ToolRelayAuthorizer {
   private readonly now: () => number;
   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({
     ttlMs = 10_000,
@@ -25,19 +28,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,
     });
   }
 
-  consumeToolCall(call: ToolRelayCall): boolean {
+  waitForToolCallAuthorization(call: ToolRelayCall): Promise<boolean> {
     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(): void {
+    this.authorizations.length = 0;
+    for (const pendingRequest of this.pendingRequests.splice(0)) {
+      clearTimeout(pendingRequest.timeout);
+      pendingRequest.resolve(false);
+    }
   }
 
   private pruneExpired(): void {
@@ -47,6 +89,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);
+      }
+    }
   }
 }
 
@@ -72,80 +122,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,107 @@
+import { createServer, type Server } from 'node:http';
+import { ToolRelayAuthorizer, 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 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;
+      }
+      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<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 {}
+}