@ai-sdk/harness-opencode 1.0.118 → 1.0.120

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/harness-opencode",
-  "version": "1.0.118",
+  "version": "1.0.120",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -26,8 +26,8 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/harness": "1.0.116",
-    "@ai-sdk/provider-utils": "5.0.44",
+    "@ai-sdk/harness": "1.0.118",
+    "@ai-sdk/provider-utils": "5.0.45",
     "ws": "8.21.0"
   },
   "peerDependencies": {

package/src/bridge/index.ts

@@ -4,6 +4,7 @@ import {
   type BridgeTurn,
 } from '@ai-sdk/harness/bridge';
 import { randomUUID } from 'node:crypto';
+import { realpathSync } from 'node:fs';
 import path from 'node:path';
 import { argv, env as procEnv } from 'node:process';
 import { isDeepStrictEqual } from 'node:util';
@@ -1304,9 +1305,6 @@ async function selectPermissionReply({
   emit: Emit;
 }): Promise<{ reply: 'once' | 'always' | 'reject'; message?: string }> {
   const toolName = toPermissionToolName(action);
-  if (resources.some(resource => isExternalPath(resource))) {
-    return { reply: 'reject', message: 'External directory access rejected.' };
-  }
   if (
     isBuiltinToolInactive({ toolName, toolFiltering: builtinToolFiltering })
   ) {
@@ -1326,6 +1324,9 @@ async function selectPermissionReply({
   if (!permissionMode || permissionMode === 'allow-all') {
     return { reply: 'always' };
   }
+  if (resources.some(resource => isExternalPath(resource))) {
+    return { reply: 'reject', message: 'External directory access rejected.' };
+  }
   const kind = TOOL_KIND[toolName] ?? 'bash';
   const allowed =
     permissionMode === 'allow-edits'
@@ -1387,16 +1388,38 @@ function isBuiltinToolInactive(input: {
 
 function isExternalPath(resource: string): boolean {
   if (!path.isAbsolute(resource)) return false;
-  const normalized = path.resolve(resource);
   return (
-    !isPathInsideOrEqual(normalized, workdir) &&
-    (!skillsDir || !isPathInsideOrEqual(normalized, skillsDir))
+    !isPathInsideOrEqual(resource, workdir) &&
+    (!skillsDir || !isPathInsideOrEqual(resource, skillsDir))
   );
 }
 
 function isPathInsideOrEqual(file: string, root: string): boolean {
-  const normalizedRoot = path.resolve(root);
-  return file === normalizedRoot || file.startsWith(`${normalizedRoot}/`);
+  const relative = path.relative(
+    canonicalizeForContainment(root),
+    canonicalizeForContainment(file),
+  );
+  return (
+    relative === '' ||
+    (relative !== '..' &&
+      !relative.startsWith(`..${path.sep}`) &&
+      !path.isAbsolute(relative))
+  );
+}
+
+function canonicalizeForContainment(inputPath: string): string {
+  const normalized = path.resolve(inputPath);
+  try {
+    return realpathSync.native(normalized);
+  } catch {
+    const parent = path.dirname(normalized);
+    return parent === normalized
+      ? normalized
+      : path.join(
+          canonicalizeForContainment(parent),
+          path.basename(normalized),
+        );
+  }
 }
 
 function toWireToolName(nativeName: string): string {

package/src/opencode-harness.ts

@@ -43,6 +43,7 @@ import {
   waitForBridgeReady,
   withBridgeToken,
   writeSkills,
+  type SandboxChannelReconnectOptions,
   type WriteSkillsResult,
 } from '@ai-sdk/harness/utils';
 import {
@@ -120,6 +121,13 @@ export type OpenCodeHarnessSettings = {
    */
   readonly portEndpoint?: HarnessV1PortEndpoint;
   readonly startupTimeoutMs?: number;
+  /**
+   * Configures reconnection attempts after an established bridge connection
+   * drops. The reconnect window includes connection establishment and
+   * backoff delays. Defaults to 30 seconds with exponential backoff from 50
+   * milliseconds up to 2 seconds.
+   */
+  readonly reconnect?: SandboxChannelReconnectOptions;
   /**
    * Creates the authentication token used by the sandbox bridge. Defaults to
    * a random 32-byte hexadecimal token.
@@ -437,10 +445,11 @@ export function createOpenCode(
           });
           let supportsUserMessageResponses = false;
           const attachChannel: OpenCodeChannel = new SandboxChannel({
-            connect: () =>
+            connect: ({ abortSignal }) =>
               openWebSocket({
                 endpoint: attachEndpoint,
                 helloTimeoutMs: Math.min(timeoutMs, 5_000),
+                abortSignal,
                 onHello: supported => {
                   supportsUserMessageResponses = supported;
                 },
@@ -449,6 +458,7 @@ export function createOpenCode(
             initialLastSeenEventId: coords.lastSeenEventId,
             onDiagnostic,
             onBridgeError,
+            reconnect: settings.reconnect,
           });
           await attachChannel.open(isContinue ? { resume: true } : undefined);
           return createSession({
@@ -610,10 +620,11 @@ export function createOpenCode(
       let supportsUserMessageResponses = false;
 
       const channel: OpenCodeChannel = new SandboxChannel({
-        connect: () =>
+        connect: ({ abortSignal }) =>
           openWebSocket({
             endpoint: bridgeEndpoint,
             helloTimeoutMs: Math.min(timeoutMs, 5_000),
+            abortSignal,
             onHello: supported => {
               supportsUserMessageResponses = supported;
             },
@@ -621,6 +632,7 @@ export function createOpenCode(
         outboundSchema: outboundMessageSchema,
         onDiagnostic,
         onBridgeError,
+        reconnect: settings.reconnect,
         ...(respawnStrategy === 'replay'
           ? { initialLastSeenEventId: coords?.lastSeenEventId ?? 0 }
           : {}),
@@ -726,25 +738,39 @@ async function resolveBridgeEndpoint({
 function openWebSocket({
   endpoint,
   helloTimeoutMs,
+  abortSignal,
   onHello,
 }: {
   endpoint: HarnessV1PortEndpoint;
   helloTimeoutMs: number;
+  abortSignal: AbortSignal;
   onHello(supportsUserMessageResponses: boolean): void;
 }): Promise<WebSocket> {
   return new Promise((resolve, reject) => {
+    const abortReason = () =>
+      abortSignal.reason ?? new Error('WebSocket connection aborted');
+    if (abortSignal.aborted) {
+      reject(abortReason());
+      return;
+    }
+
     const ws = new WebSocket(endpoint.url, {
       headers: endpoint.headers == null ? undefined : { ...endpoint.headers },
     });
     let opened = false;
     let receivedHello = false;
     let settled = false;
+    let helloTimer: ReturnType<typeof setTimeout> | undefined;
+    let onAbort: (() => void) | undefined;
     const cleanup = () => {
       clearTimeout(helloTimer);
       ws.off('open', onOpen);
       ws.off('message', onMessage);
       ws.off('close', onClose);
       ws.off('error', onError);
+      if (onAbort != null) {
+        abortSignal.removeEventListener('abort', onAbort);
+      }
     };
     const settle = (error?: unknown) => {
       if (settled) return;
@@ -753,6 +779,20 @@ function openWebSocket({
       if (error == null) {
         resolve(ws);
       } else {
+        const suppressError = () => {};
+        const socketWithOnce = ws as WebSocket & {
+          once?: (event: string, listener: () => void) => void;
+        };
+        socketWithOnce.once?.('error', suppressError);
+        try {
+          ws.terminate();
+        } catch {
+          try {
+            ws.close();
+          } catch {
+            // best-effort
+          }
+        }
         reject(error);
       }
     };
@@ -793,11 +833,17 @@ function openWebSocket({
     const onError = (err: Error) => {
       settle(err);
     };
+    onAbort = () => settle(abortReason());
     ws.on('open', onOpen);
     ws.on('message', onMessage);
     ws.on('close', onClose);
     ws.on('error', onError);
-    const helloTimer = setTimeout(
+    abortSignal.addEventListener('abort', onAbort, { once: true });
+    if (abortSignal.aborted) {
+      onAbort();
+      return;
+    }
+    helloTimer = setTimeout(
       () =>
         settle(
           new Error(