pi-bridge 0.2.9 → 0.3.1

package/bin/pii.js

@@ -63,6 +63,11 @@ if (!pi) {
   process.exit(1);
 }
 
+// Expose resolved pi paths so child-process-patch can re-spawn pi correctly
+// when the review skill (or any internal tool) calls `pi` as a subprocess.
+process.env.PI_BRIDGE_CLI  = pi.cli;
+process.env.PI_BRIDGE_NODE = pi.nodeExe;
+
 const result = spawnSync(
   pi.nodeExe,
   ['--require', preload, pi.cli, ...process.argv.slice(2)],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-bridge",
-  "version": "0.2.9",
+  "version": "0.3.1",
   "description": "Transparent filesystem bridge that makes pi run natively on a remote machine over SSH",
   "type": "commonjs",
   "bin": {

package/src/local/child-process-patch.js

@@ -5,19 +5,18 @@ const path = require('path');
 const { isFakePath, toRemotePath } = require('./path-mapper');
 
 /**
- * Patch child_process.spawn and child_process.spawnSync so that commands
+ * Patch child_process spawn/spawnSync/execSync/execFileSync so that commands
  * whose cwd lands inside fakeRoot are transparently redirected to run on
  * the remote machine via SSH.
  *
- * Pi's bash tool uses spawn/spawnSync exclusively, so this covers all shell
- * command execution (ls, cat, grep, npm run, etc.).
- *
  * @param {string} fakeRoot - Local fake root directory (real path, no symlinks)
  * @param {string} remote   - SSH target, e.g. 'user@host'
  */
 function patchChildProcess(fakeRoot, remote) {
-  const origSpawn     = cp.spawn.bind(cp);
-  const origSpawnSync = cp.spawnSync.bind(cp);
+  const origSpawn       = cp.spawn.bind(cp);
+  const origSpawnSync   = cp.spawnSync.bind(cp);
+  const origExecSync    = cp.execSync.bind(cp);
+  const origExecFileSync = cp.execFileSync.bind(cp);
 
   /**
    * Resolve the effective cwd from spawn options.
@@ -44,6 +43,7 @@ function patchChildProcess(fakeRoot, remote) {
    * - node / node.exe: pi's internal tooling (session export, compaction, …)
    *   spawns Node with large payloads as args; redirecting those over SSH would
    *   produce an ENAMETOOLONG error on Windows and is never correct anyway.
+   * - pi / pii: need local internet access for the Claude API and auth.
    */
   function isLocalOnly(file) {
     const name = normalizeCmd(file).toLowerCase();
@@ -51,15 +51,30 @@ function patchChildProcess(fakeRoot, remote) {
   }
 
   /**
-   * Build the SSH-redirected command: cd to remote cwd, then run the
-   * original command with its arguments, all shell-quoted.
+   * When pi spawns 'pi' or 'pii' as a subprocess (e.g. the /review skill),
+   * the bare command name won't be found in PATH on Windows because pi is a
+   * JS file located by pii's findPi(). pii.js sets PI_BRIDGE_CLI / PI_BRIDGE_NODE
+   * in the environment so we can resolve the correct executable here.
+   *
+   * Returns { nodeExe, cli } when applicable, null otherwise.
+   */
+  function resolvePiExe(file) {
+    const name = normalizeCmd(file).toLowerCase();
+    if (name !== 'pi' && name !== 'pii') return null;
+    const cli = process.env.PI_BRIDGE_CLI;
+    if (!cli) return null;
+    return { nodeExe: process.env.PI_BRIDGE_NODE || process.execPath, cli };
+  }
+
+  /**
+   * Build SSH args for a file + args invocation:
+   * cd to remote cwd, then run the command with shell-quoted arguments.
    */
   function buildSshArgs(file, args, opts) {
     file = normalizeCmd(file);
-    const fakeCwd    = effectiveCwd(opts);
-    const remoteCwd  = toRemotePath(fakeCwd, fakeRoot);
+    const fakeCwd   = effectiveCwd(opts);
+    const remoteCwd = toRemotePath(fakeCwd, fakeRoot);
 
-    // Reconstruct the command string with shell-safe quoting
     const argStr = (args || [])
       .map(function(a) { return "'" + String(a).replace(/'/g, "'\\''") + "'"; })
       .join(' ');
@@ -68,15 +83,28 @@ function patchChildProcess(fakeRoot, remote) {
     return ['-o', 'BatchMode=yes', remote, remoteCmd];
   }
 
+  /**
+   * Build SSH args for a raw shell command string (used by execSync).
+   */
+  function buildSshArgsForShell(command, opts) {
+    const fakeCwd   = effectiveCwd(opts);
+    const remoteCwd = toRemotePath(fakeCwd, fakeRoot);
+    const remoteCmd = 'cd ' + JSON.stringify(remoteCwd) + ' && ' + command;
+    return ['-o', 'BatchMode=yes', remote, remoteCmd];
+  }
+
   // ── spawn ────────────────────────────────────────────────────────────────────
 
   cp.spawn = function patchedSpawn(file, args, opts) {
-    // Normalise overloaded signature: spawn(file) / spawn(file, opts) / spawn(file, args, opts)
     if (!Array.isArray(args)) { opts = args; args = []; }
     opts = opts || {};
 
     const cwd = effectiveCwd(opts);
-    if (!isFakePath(cwd, fakeRoot) || isLocalOnly(file)) return origSpawn(file, args, opts);
+    if (!isFakePath(cwd, fakeRoot) || isLocalOnly(file)) {
+      const piExe = resolvePiExe(file);
+      if (piExe) return origSpawn(piExe.nodeExe, [piExe.cli, ...args], opts);
+      return origSpawn(file, args, opts);
+    }
 
     return origSpawn('ssh', buildSshArgs(file, args, opts), Object.assign({}, opts, { cwd: undefined }));
   };
@@ -88,10 +116,41 @@ function patchChildProcess(fakeRoot, remote) {
     opts = opts || {};
 
     const cwd = effectiveCwd(opts);
-    if (!isFakePath(cwd, fakeRoot) || isLocalOnly(file)) return origSpawnSync(file, args, opts);
+    if (!isFakePath(cwd, fakeRoot) || isLocalOnly(file)) {
+      const piExe = resolvePiExe(file);
+      if (piExe) return origSpawnSync(piExe.nodeExe, [piExe.cli, ...args], opts);
+      return origSpawnSync(file, args, opts);
+    }
 
     return origSpawnSync('ssh', buildSshArgs(file, args, opts), Object.assign({}, opts, { cwd: undefined }));
   };
+
+  // ── execSync ─────────────────────────────────────────────────────────────────
+
+  cp.execSync = function patchedExecSync(command, opts) {
+    opts = opts || {};
+
+    const cwd = effectiveCwd(opts);
+    if (!isFakePath(cwd, fakeRoot)) return origExecSync(command, opts);
+
+    return origExecFileSync('ssh', buildSshArgsForShell(command, opts), Object.assign({}, opts, { cwd: undefined }));
+  };
+
+  // ── execFileSync ─────────────────────────────────────────────────────────────
+
+  cp.execFileSync = function patchedExecFileSync(file, args, opts) {
+    if (!Array.isArray(args)) { opts = args; args = []; }
+    opts = opts || {};
+
+    const cwd = effectiveCwd(opts);
+    if (!isFakePath(cwd, fakeRoot) || isLocalOnly(file)) {
+      const piExe = resolvePiExe(file);
+      if (piExe) return origExecFileSync(piExe.nodeExe, [piExe.cli, ...args], opts);
+      return origExecFileSync(file, args, opts);
+    }
+
+    return origExecFileSync('ssh', buildSshArgs(file, args, opts), Object.assign({}, opts, { cwd: undefined }));
+  };
 }
 
 module.exports = { patchChildProcess };

package/src/local/http-client.js

@@ -93,31 +93,37 @@ req.on('error', (e) => {
  * @throws                 - On HTTP errors or non-2xx status codes
  */
 function httpPost(port, token, urlPath, body) {
+  // Body is passed via stdin (not embedded in the script) to avoid ENAMETOOLONG
+  // on Windows when writing large files such as session exports.
   const script = `
 const http = require('http');
-const body = ${JSON.stringify(body)};
-const bodyBuf = Buffer.from(body, 'utf8');
-let resBody = '';
-let statusCode = 0;
-const req = http.request(
-  { method:'POST', hostname:'127.0.0.1', port:${JSON.stringify(port)}, path:${JSON.stringify(urlPath)},
-    headers:{'x-token':${JSON.stringify(token)},'Content-Type':'text/plain; charset=utf-8','Content-Length':bodyBuf.length} },
-  (res) => {
-    statusCode = res.statusCode;
-    res.setEncoding('utf8');
-    res.on('data', (d) => { resBody += d; });
-    res.on('end', () => {
-      process.stdout.write(JSON.stringify({ ok: statusCode >= 200 && statusCode < 300, status: statusCode, body: resBody }));
-    });
-  }
-);
-req.on('error', (e) => {
-  process.stdout.write(JSON.stringify({ ok: false, status: 0, body: e.message }));
+let raw = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (d) => { raw += d; });
+process.stdin.on('end', () => {
+  const bodyBuf = Buffer.from(raw, 'utf8');
+  let resBody = '';
+  let statusCode = 0;
+  const req = http.request(
+    { method:'POST', hostname:'127.0.0.1', port:${JSON.stringify(port)}, path:${JSON.stringify(urlPath)},
+      headers:{'x-token':${JSON.stringify(token)},'Content-Type':'text/plain; charset=utf-8','Content-Length':bodyBuf.length} },
+    (res) => {
+      statusCode = res.statusCode;
+      res.setEncoding('utf8');
+      res.on('data', (d) => { resBody += d; });
+      res.on('end', () => {
+        process.stdout.write(JSON.stringify({ ok: statusCode >= 200 && statusCode < 300, status: statusCode, body: resBody }));
+      });
+    }
+  );
+  req.on('error', (e) => {
+    process.stdout.write(JSON.stringify({ ok: false, status: 0, body: e.message }));
+  });
+  req.write(bodyBuf);
+  req.end();
 });
-req.write(bodyBuf);
-req.end();
 `;
-  const raw = withRetry(() => execFileSync(process.execPath, ['-e', script], { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }));
+  const raw = withRetry(() => execFileSync(process.execPath, ['-e', script], { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], input: body }));
   const result = JSON.parse(raw);
   if (!result.ok) {
     const err = new Error('HTTP ' + result.status + ': ' + result.body);