@ai-sdk/harness-pi 1.0.119 → 1.0.120

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/harness-pi",
-  "version": "1.0.119",
+  "version": "1.0.120",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -26,7 +26,7 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/harness": "1.0.117",
+    "@ai-sdk/harness": "1.0.118",
     "@ai-sdk/provider-utils": "5.0.45",
     "@earendil-works/pi-ai": "0.74.2",
     "@earendil-works/pi-coding-agent": "^0.84.3",
@@ -37,7 +37,7 @@
     "zod": "^3.25.76 || ^4.1.8"
   },
   "devDependencies": {
-    "@ai-sdk/sandbox-just-bash": "1.0.117",
+    "@ai-sdk/sandbox-just-bash": "1.0.118",
     "@types/node": "22.19.19",
     "@vercel/ai-tsconfig": "0.0.0",
     "tsup": "^8.5.1",

package/src/pi-remote-ops.ts

@@ -1,3 +1,4 @@
+import { randomUUID } from 'node:crypto';
 import path from 'node:path';
 import { shellQuote } from '@ai-sdk/harness/utils';
 import type { Experimental_SandboxSession } from '@ai-sdk/provider-utils';
@@ -63,10 +64,46 @@ interface RunShellInput {
 interface RunShellResult {
   exitCode: number | null;
   output: Buffer;
+  stdout: string;
+  stderr: string;
 }
 
-function lastOutputLine(output: Buffer): string | undefined {
-  return output.toString('utf8').trim().split('\n').filter(Boolean).at(-1);
+const MAX_GREP_DIAGNOSTIC_BYTES = 8_192;
+const REALPATH_FRAME = '__PI_REALPATH_FRAME__';
+const BASE64_PATH_PATTERN =
+  /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+
+function realpathShellLines(targetVariable: string): string[] {
+  return [
+    'set -o pipefail',
+    `realpath_marker=${shellQuote(REALPATH_FRAME)}`,
+    `realpath_framed=$(realpath "$${targetVariable}" 2>/dev/null; realpath_status=$?; printf '%s' "$realpath_marker"; exit "$realpath_status")`,
+    'realpath_status=$?',
+    'if [ "$realpath_status" -ne 0 ]; then echo "__PI_REALPATH_FAILED__"; exit 3; fi',
+    'resolved=${realpath_framed%$realpath_marker}',
+    "resolved=${resolved%$'\\n'}",
+  ];
+}
+
+function framePathShell(pathExpression: string): string {
+  return `if ! printf '%s' ${pathExpression} | base64 | tr -d '\\r\\n'; then exit 4; fi; printf '%s' "$realpath_marker"`;
+}
+
+function parseFramedPath(output: string): string | undefined {
+  if (!output.endsWith(REALPATH_FRAME)) return undefined;
+
+  const encodedPath = output.slice(0, -REALPATH_FRAME.length);
+  if (!encodedPath || !BASE64_PATH_PATTERN.test(encodedPath)) {
+    return undefined;
+  }
+
+  try {
+    return new TextDecoder('utf-8', { fatal: true }).decode(
+      Buffer.from(encodedPath, 'base64'),
+    );
+  } catch {
+    return undefined;
+  }
 }
 
 export function createPiRemoteOps(options: PiRemoteOpsOptions): PiRemoteOps {
@@ -86,8 +123,7 @@ export function createPiRemoteOps(options: PiRemoteOpsOptions): PiRemoteOps {
       ...(input.signal ? { abortSignal: input.signal } : {}),
     });
 
-    const combined = `${result.stdout}${result.stderr}`;
-    const output = Buffer.from(combined, 'utf8');
+    const output = Buffer.from(`${result.stdout}${result.stderr}`, 'utf8');
     if (output.length > 0) {
       input.onData?.(output);
     }
@@ -95,6 +131,8 @@ export function createPiRemoteOps(options: PiRemoteOpsOptions): PiRemoteOps {
     return {
       exitCode: result.exitCode,
       output,
+      stdout: result.stdout,
+      stderr: result.stderr,
     };
   };
 
@@ -105,9 +143,9 @@ export function createPiRemoteOps(options: PiRemoteOpsOptions): PiRemoteOps {
     const result = await runShell(
       [
         `target=${shellQuote(remotePath)}`,
-        `if [ ! -e "$target" ]; then echo "__PI_REALPATH_NOT_FOUND__"; exit 2; fi`,
-        `resolved=$(realpath "$target" 2>/dev/null) || { echo "__PI_REALPATH_FAILED__"; exit 3; }`,
-        `printf '%s\\n' "$resolved"`,
+        ...realpathShellLines('target'),
+        `if [ ! -e "$resolved" ]; then echo "__PI_REALPATH_NOT_FOUND__"; exit 2; fi`,
+        framePathShell('"$resolved"'),
       ].join('; '),
     );
 
@@ -119,7 +157,7 @@ export function createPiRemoteOps(options: PiRemoteOpsOptions): PiRemoteOps {
       throw new Error(`Unable to resolve path: ${inputPath}`);
     }
 
-    const resolvedPath = lastOutputLine(result.output);
+    const resolvedPath = parseFramedPath(result.stdout);
     if (!resolvedPath) {
       throw new Error(`Unable to resolve path: ${inputPath}`);
     }
@@ -141,13 +179,14 @@ export function createPiRemoteOps(options: PiRemoteOpsOptions): PiRemoteOps {
     const result = await runShell(
       [
         `target=${shellQuote(remotePath)}`,
-        `if [ -e "$target" ] || [ -L "$target" ]; then resolved=$(realpath "$target" 2>/dev/null) || { echo "__PI_REALPATH_FAILED__"; exit 3; }; printf '%s\\n' "$resolved"; exit 0; fi`,
-        `dir=$(dirname "$target")`,
-        `base=$(basename "$target")`,
+        `if [ -e "$target" ] || [ -L "$target" ]; then ${realpathShellLines('target').join('; ')}; ${framePathShell('"$resolved"')}; exit 0; fi`,
+        'dir=${target%/*}',
+        'base=${target##*/}',
+        '[ -n "$dir" ] || dir=/',
         `missing="$base"`,
-        `while [ ! -e "$dir" ] && [ ! -L "$dir" ]; do parent=$(dirname "$dir"); if [ "$parent" = "$dir" ]; then echo "__PI_REALPATH_NOT_FOUND__"; exit 2; fi; missing="$(basename "$dir")/$missing"; dir="$parent"; done`,
-        `resolved_dir=$(realpath "$dir" 2>/dev/null) || { echo "__PI_REALPATH_FAILED__"; exit 3; }`,
-        `printf '%s/%s\\n' "$resolved_dir" "$missing"`,
+        'while [ ! -e "$dir" ] && [ ! -L "$dir" ]; do parent=${dir%/*}; [ -n "$parent" ] || parent=/; if [ "$parent" = "$dir" ]; then echo "__PI_REALPATH_NOT_FOUND__"; exit 2; fi; missing=${dir##*/}/$missing; dir=$parent; done',
+        ...realpathShellLines('dir'),
+        framePathShell('"$resolved/$missing"'),
       ].join('; '),
     );
 
@@ -160,7 +199,7 @@ export function createPiRemoteOps(options: PiRemoteOpsOptions): PiRemoteOps {
       throw new Error(`Unable to resolve path: ${inputPath}`);
     }
 
-    const resolvedPath = lastOutputLine(result.output);
+    const resolvedPath = parseFramedPath(result.stdout);
     if (!resolvedPath) {
       throw new Error(`Unable to resolve path: ${inputPath}`);
     }
@@ -318,24 +357,106 @@ export function createPiRemoteOps(options: PiRemoteOpsOptions): PiRemoteOps {
     const targetPath =
       relativeTarget.startsWith('../') || path.posix.isAbsolute(relativeTarget)
         ? resolvedPath
-        : relativeTarget;
-    const flags = [
-      '-r',
+        : relativeTarget.startsWith('-')
+          ? `./${relativeTarget}`
+          : relativeTarget;
+    const limit = Math.max(1, input.limit ?? 100);
+    const commonFlags = [
       '-n',
-      '--binary-files=without-match',
       ...(input.ignoreCase ? ['-i'] : []),
       ...(input.literal ? ['-F'] : []),
       ...(typeof input.context === 'number' && input.context > 0
         ? ['-C', String(input.context)]
         : []),
-      ...(input.glob ? ['--include', input.glob] : []),
     ];
-    const limit = Math.max(1, input.limit ?? 100);
+    const recursiveFlags = [
+      '-r',
+      ...commonFlags,
+      '-m',
+      String(limit),
+      ...(input.glob ? [`--include=${input.glob}`] : []),
+    ];
+    const temporaryPathPrefix = `/tmp/.ai-sdk-harness-pi-grep-${randomUUID()}`;
+    const outputPath = `${temporaryPathPrefix}.stdout`;
+    const stderrPath = `${temporaryPathPrefix}.stderr`;
+    const statusPath = `${temporaryPathPrefix}.status`;
+    const fileOutputPath = `${temporaryPathPrefix}.file.stdout`;
+    const fileStderrPath = `${temporaryPathPrefix}.file.stderr`;
+    const findStderrPath = `${temporaryPathPrefix}.find.stderr`;
+    const boundedFileGrepScript = [
+      `grep_limit=${limit}`,
+      `grep_output=${shellQuote(outputPath)}`,
+      `grep_stderr=${shellQuote(stderrPath)}`,
+      `grep_status=${shellQuote(statusPath)}`,
+      `grep_file_output=${shellQuote(fileOutputPath)}`,
+      `grep_file_stderr=${shellQuote(fileStderrPath)}`,
+      'grep_output_lines=$(wc -l < "$grep_output")',
+      'grep_overall_status=$(cat "$grep_status")',
+      'for grep_file in "$@"; do',
+      'grep_remaining=$((grep_limit - grep_output_lines))',
+      'if [ "$grep_remaining" -le 0 ]; then break; fi',
+      `grep ${commonFlags.map(shellQuote).join(' ')} -m "$grep_remaining" -e ${shellQuote(pattern)} "$grep_file" > "$grep_file_output" 2> "$grep_file_stderr"`,
+      'grep_file_status=$?',
+      'if [ "$grep_file_status" -eq 0 ]; then',
+      'grep_display_file=${grep_file#./}',
+      'grep_file_lines=0',
+      'while IFS= read -r grep_line; do',
+      'if [ "$grep_file_lines" -ge "$grep_remaining" ]; then break; fi',
+      'case "$grep_line" in',
+      `'--') printf '%s\\n' "$grep_line" ;;`,
+      `[0-9]*:*) printf '%s:%s\\n' "$grep_display_file" "$grep_line" ;;`,
+      `[0-9]*-*) printf '%s-%s\\n' "$grep_display_file" "$grep_line" ;;`,
+      `*) printf '%s:%s\\n' "$grep_display_file" "$grep_line" ;;`,
+      'esac',
+      'grep_file_lines=$((grep_file_lines + 1))',
+      'done < "$grep_file_output" >> "$grep_output"',
+      'grep_output_lines=$((grep_output_lines + grep_file_lines))',
+      'grep_overall_status=0',
+      'elif [ "$grep_file_status" -gt 1 ]; then',
+      `grep_diagnostic_size=$(wc -c < "$grep_stderr")`,
+      `grep_diagnostic_remaining=$((${MAX_GREP_DIAGNOSTIC_BYTES} - grep_diagnostic_size))`,
+      'if [ "$grep_diagnostic_remaining" -gt 0 ]; then head -c "$grep_diagnostic_remaining" "$grep_file_stderr" >> "$grep_stderr"; fi',
+      'grep_overall_status=2',
+      'break',
+      'fi',
+      'done',
+      'printf \'%s\\n\' "$grep_overall_status" > "$grep_status"',
+    ].join('\n');
+    const findFlags = [
+      shellQuote(targetPath),
+      '-type',
+      'f',
+      ...(input.glob ? ['-name', shellQuote(input.glob)] : []),
+    ].join(' ');
     const result = await runShell(
       [
         `if [ ! -e ${shellQuote(resolvedPath)} ]; then echo "__PI_GREP_NOT_FOUND__"; exit 2; fi`,
         `cd ${shellQuote(options.paths.sandboxWorkDir)}`,
-        `grep ${flags.map(shellQuote).join(' ')} -- ${shellQuote(pattern)} ${shellQuote(targetPath)} 2>/dev/null | head -n ${limit}`,
+        // Preserve binary skipping where grep supports it without passing an
+        // unsupported option to just-bash.
+        `binary_option_error=$(grep --binary-files=without-match -e '' /dev/null 2>&1)`,
+        `if [ -z "$binary_option_error" ]; then binary_option='--binary-files=without-match'; else binary_option=''; fi`,
+        `grep_stderr=${shellQuote(stderrPath)}`,
+        `grep_output=${shellQuote(outputPath)}`,
+        `grep_status_file=${shellQuote(statusPath)}`,
+        `grep_find_stderr=${shellQuote(findStderrPath)}`,
+        ': > "$grep_stderr"',
+        // just-bash buffers every pipeline stage and applies grep -m per file.
+        // Search files individually there so the producer never emits more
+        // than the remaining global result limit.
+        `if [ -n "$binary_option" ] || [ ! -d ${shellQuote(targetPath)} ]; then set -o pipefail; grep $binary_option ${recursiveFlags.map(shellQuote).join(' ')} -e ${shellQuote(pattern)} ${shellQuote(targetPath)} 2>"$grep_stderr" | head -n ${limit}; grep_status=$?; else : > "$grep_output"; printf '1\\n' > "$grep_status_file"; find ${findFlags} -exec bash -c ${shellQuote(boundedFileGrepScript)} bash {} + 2>"$grep_find_stderr"; find_status=$?; grep_diagnostic_size=$(wc -c < "$grep_stderr"); grep_diagnostic_remaining=$((${MAX_GREP_DIAGNOSTIC_BYTES} - grep_diagnostic_size)); if [ "$grep_diagnostic_remaining" -gt 0 ]; then head -c "$grep_diagnostic_remaining" "$grep_find_stderr" >> "$grep_stderr"; fi; grep_status=$(cat "$grep_status_file"); if [ "$find_status" -ne 0 ]; then grep_status=2; fi; cat "$grep_output"; fi`,
+        `head -c ${MAX_GREP_DIAGNOSTIC_BYTES} "$grep_stderr" >&2`,
+        `rm -f ${[
+          outputPath,
+          stderrPath,
+          statusPath,
+          fileOutputPath,
+          fileStderrPath,
+          findStderrPath,
+        ]
+          .map(shellQuote)
+          .join(' ')}`,
+        'exit "$grep_status"',
       ].join('; '),
     );
 
@@ -343,8 +464,33 @@ export function createPiRemoteOps(options: PiRemoteOpsOptions): PiRemoteOps {
     if (output.includes('__PI_GREP_NOT_FOUND__')) {
       throw new Error(`Path not found: ${input.path ?? '.'}`);
     }
+    const stdout = result.stdout.trim();
+    const stderr = result.stderr.trim();
+
+    if (
+      result.exitCode === 0 ||
+      result.exitCode === 1 ||
+      // GNU grep can receive SIGPIPE after head reaches the requested limit.
+      result.exitCode === 141
+    ) {
+      if (stdout) {
+        return [stdout, stderr].filter(Boolean).join('\n');
+      }
+      if (stderr) {
+        throw new Error(stderr);
+      }
+      return 'No matches found';
+    }
 
-    return output || 'No matches found';
+    // GNU grep exits 2 when recursive traversal encounters unreadable entries,
+    // even if it also found useful matches in readable files.
+    if (result.exitCode === 2 && stdout && stderr) {
+      return `${stdout}\n${stderr}`;
+    }
+    if (stderr) {
+      throw new Error(stderr);
+    }
+    throw new Error(output || `grep failed with exit code ${result.exitCode}`);
   };
 
   return {