pi-bridge 0.3.3 → 0.3.5

package/bin/pii.js

@@ -1,77 +1,21 @@
 #!/usr/bin/env node
 'use strict';
 
-const { spawnSync, execFileSync } = require('child_process');
+const { spawnSync } = require('child_process');
 const path = require('path');
-const fs = require('fs');
-const os = require('os');
 
 const pkg = require('../package.json');
 const preload = path.join(__dirname, '..', 'src', 'local', 'preload.js');
+const { findPi } = require('../src/local/find-pi.js');
 
 if (process.argv.includes('--version') || process.argv.includes('-v') || process.argv.includes('--v')) {
   process.stdout.write('pi-bridge/' + pkg.version + '\n');
   process.exit(0);
 }
 
-// List every `pi` on the PATH that pii inherited from its launching shell.
-// We resolve against that PATH (not a fresh `-NoProfile` shell) so that bundled
-// installs added to PATH via the user's profile are actually visible.
-function locateOnPath(cmd) {
-  const finder = os.platform() === 'win32' ? 'where.exe' : 'which';
-  try {
-    const out = execFileSync(finder, [cmd], { encoding: 'utf8' });
-    return out.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
-  } catch (_) {
-    return [];
-  }
-}
-
-function findPi() {
-  // 1. Standard npm global: pii and pi share the same node_modules prefix.
-  //    Prefer the current @earendil-works scope; keep @mariozechner as a legacy
-  //    fallback for machines that installed pi before it moved off that scope.
-  const sharedCandidates = [
-    path.resolve(__dirname, '..', '..', '@earendil-works', 'pi-coding-agent', 'dist', 'cli.js'),
-    path.resolve(__dirname, '..', '..', '@mariozechner', 'pi-coding-agent', 'dist', 'cli.js'),
-  ];
-  for (const cli of sharedCandidates) {
-    if (fs.existsSync(cli)) return { cli, nodeExe: process.execPath };
-  }
-
-  // 2. Resolve `pi` from PATH and follow it to its real JS entrypoint. The
-  //    pi.dev installer (curl https://pi.dev/install.sh | sh) drops a bundled
-  //    Node plus a bare `bin/pi` symlink that points straight at the package's
-  //    cli.js — often outside any npm prefix — so we realpath the symlink rather
-  //    than guessing filenames. Also covers npm shims and dev clones (which
-  //    expose pi as a symlink to cli.js too), and a bundled node next to pi is
-  //    preferred for version-matched execution.
-  const exe = os.platform() === 'win32' ? '.exe' : '';
-  for (const cmd of locateOnPath('pi')) {
-    let real;
-    try { real = fs.realpathSync(cmd); } catch (_) { real = cmd; }
-
-    let cli = null;
-    if (/\.[cm]?js$/i.test(real) && fs.existsSync(real)) {
-      cli = real;                                   // symlink/shim -> cli.js
-    } else if (fs.existsSync(path.join(path.dirname(cmd), 'pi.js'))) {
-      cli = path.join(path.dirname(cmd), 'pi.js');  // bundled wrapper + sibling
-    } else if (!/\.(cmd|ps1|bat|exe)$/i.test(real)) {
-      cli = real;                                   // shebang JS with no extension
-    }
-    if (!cli) continue;
-
-    const localNode = path.join(path.dirname(cmd), 'node' + exe);
-    const nodeExe = fs.existsSync(localNode) ? localNode : process.execPath;
-    return { cli, nodeExe };
-  }
-
-  return null;
-}
-
 let pi;
 try {
-  pi = findPi();
+  pi = findPi({ bridgeBinDir: __dirname });
 } catch (_) {}
 
 if (!pi) {

package/package.json

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

package/src/local/find-pi.js

@@ -0,0 +1,127 @@
+'use strict';
+
+// Locates the pi CLI entrypoint (a JS file) and the node binary to run it with.
+// Used by bin/pii.js; kept separate so it can be unit-tested.
+
+const { execFileSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+// Prefer the current @earendil-works scope; keep @mariozechner as a legacy
+// fallback for machines that installed pi before it moved off that scope.
+const PI_PACKAGES = [
+  path.join('@earendil-works', 'pi-coding-agent'),
+  path.join('@mariozechner', 'pi-coding-agent'),
+];
+
+// List every `pi` on the PATH that pii inherited from its launching shell.
+// We resolve against that PATH (not a fresh `-NoProfile` shell) so that bundled
+// installs added to PATH via the user's profile are actually visible.
+function locateOnPath(cmd, platform = process.platform) {
+  const finder = platform === 'win32' ? 'where.exe' : 'which';
+  try {
+    const out = execFileSync(finder, [cmd], { encoding: 'utf8' });
+    return out.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+  } catch (_) {
+    return [];
+  }
+}
+
+// Resolve a pi package's CLI from its package.json `bin` field, so we follow
+// whatever entrypoint the installed version declares (dist/cli.js in older
+// releases, dist/bundle/cli.js since 1.5).
+function cliFromPackage(pkgDir) {
+  let rel = null;
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(pkgDir, 'package.json'), 'utf8'));
+    rel = typeof pkg.bin === 'string' ? pkg.bin : pkg.bin && pkg.bin.pi;
+  } catch (_) {
+    return null;
+  }
+  const candidates = [rel, 'dist/bundle/cli.js', 'dist/cli.js'].filter(Boolean);
+  for (const c of candidates) {
+    const cli = path.resolve(pkgDir, c);
+    if (fs.existsSync(cli)) return cli;
+  }
+  return null;
+}
+
+function cliFromNodeModules(nodeModulesDir) {
+  for (const name of PI_PACKAGES) {
+    const cli = cliFromPackage(path.join(nodeModulesDir, name));
+    if (cli) return cli;
+  }
+  return null;
+}
+
+// True if the file is something node can execute: either it has a node
+// shebang or no shebang at all. Rejects npm's extensionless `sh` shims
+// (`#!/bin/sh` + `basedir=$(dirname ...)`), which node would choke on.
+function looksLikeNodeScript(file) {
+  let head;
+  try {
+    const fd = fs.openSync(file, 'r');
+    try {
+      const buf = Buffer.alloc(256);
+      const n = fs.readSync(fd, buf, 0, buf.length, 0);
+      head = buf.toString('utf8', 0, n);
+    } finally {
+      fs.closeSync(fd);
+    }
+  } catch (_) {
+    return false;
+  }
+  if (!head.startsWith('#!')) return true;
+  return /\bnode\b/.test(head.split(/\r?\n/, 1)[0]);
+}
+
+function findPi({
+  bridgeBinDir,
+  locate = locateOnPath,
+  platform = process.platform,
+  execPath = process.execPath,
+} = {}) {
+  // 1. Standard npm global: pii and pi share the same node_modules dir
+  //    (<node_modules>/pi-bridge/bin -> <node_modules>).
+  if (bridgeBinDir) {
+    const cli = cliFromNodeModules(path.resolve(bridgeBinDir, '..', '..'));
+    if (cli) return { cli, nodeExe: execPath };
+  }
+
+  // 2. Resolve `pi` from PATH. Covers npm globals when pi-bridge itself is
+  //    linked from a local checkout, the pi.dev installer (bundled Node plus a
+  //    bare `bin/pi` symlink straight to cli.js, often outside any npm prefix)
+  //    and dev clones.
+  const exe = platform === 'win32' ? '.exe' : '';
+  for (const cmd of locate('pi', platform)) {
+    const dir = path.dirname(cmd);
+    const localNode = path.join(dir, 'node' + exe);
+    const nodeExe = fs.existsSync(localNode) ? localNode : execPath;
+
+    // 2a. npm prefix layouts next to the launcher:
+    //     Windows: <prefix>/pi(.cmd) + <prefix>/node_modules/...
+    //     POSIX:   <prefix>/bin/pi   + <prefix>/lib/node_modules/...
+    const npmCli =
+      cliFromNodeModules(path.join(dir, 'node_modules')) ||
+      cliFromNodeModules(path.join(dir, '..', 'lib', 'node_modules'));
+    if (npmCli) return { cli: npmCli, nodeExe };
+
+    // 2b. Follow the launcher to its real JS entrypoint.
+    let real;
+    try { real = fs.realpathSync(cmd); } catch (_) { real = cmd; }
+
+    let cli = null;
+    if (/\.[cm]?js$/i.test(real) && fs.existsSync(real)) {
+      cli = real;                                   // symlink/shim -> cli.js
+    } else if (fs.existsSync(path.join(dir, 'pi.js'))) {
+      cli = path.join(dir, 'pi.js');                // bundled wrapper + sibling
+    } else if (!/\.(cmd|ps1|bat|exe)$/i.test(real) && looksLikeNodeScript(real)) {
+      cli = real;                                   // shebang JS with no extension
+    }
+    if (cli) return { cli, nodeExe };
+  }
+
+  return null;
+}
+
+module.exports = { findPi, cliFromPackage, looksLikeNodeScript, locateOnPath };

package/src/local/fs-patch.js

@@ -4,6 +4,7 @@ const fs = require('fs');
 const fsp = require('fs/promises');
 const http = require('http');
 const path = require('path');
+const { fileURLToPath } = require('url');
 const { isFakePath, toRemotePath } = require('./path-mapper');
 const { httpGet, httpPost } = require('./http-client');
 
@@ -127,9 +128,28 @@ function patchFs(fakeRoot, port, token) {
     cp:         fs.promises.cp ? fs.promises.cp.bind(fs.promises) : undefined,
   };
 
-  // Resolve any path (relative or absolute) to absolute before checking fake root
+  // Resolve any path (relative or absolute) to absolute before checking fake root.
+  // file: URLs are accepted too: jiti's bundled ESM resolver probes package
+  // mains with fs.statSync(new URL(...)), which must reach the remote.
+  // Buffer paths deliberately pass through: Node 20's JS rmSync walks children
+  // as Buffers via the public fs.*, and routing those would make removeFakeDir
+  // list and delete files on the remote.
   function abs(p) {
-    return typeof p === 'string' ? path.resolve(p) : null;
+    if (typeof p === 'string') return path.resolve(p);
+    if (p instanceof URL) return p.protocol === 'file:' ? path.resolve(fileURLToPath(p)) : null;
+    return null;
+  }
+
+  // Shared by statSync/lstatSync. Honours { throwIfNoEntry: false }, which the
+  // ESM resolver relies on to probe candidate files without try/catch.
+  function statRemoteSync(s, opts) {
+    try {
+      return makeStats(JSON.parse(httpGet(port, token, '/stat?path=' + encodeURIComponent(rpath(s)))));
+    } catch (e) {
+      const missing = e && e.message && (e.message.includes('ENOENT') || e.message.includes('403'));
+      if (missing && opts && opts.throwIfNoEntry === false) return undefined;
+      rethrowRemote(e, s);
+    }
   }
 
   function rpath(fakePath) {
@@ -215,6 +235,9 @@ function patchFs(fakeRoot, port, token) {
 
   fs.accessSync = function patchedAccessSync(p, mode) {
     const s = abs(p);
+    // Same Windows bash fake as existsSync: newer pi probes the shell with
+    // accessSync, which would otherwise hit the local disk and fail.
+    if (process.platform === 'win32' && isBashPath(s)) return;
     if (!s || !isFakePath(s, fakeRoot)) return orig.accessSync(p, mode);
     try {
       const exists = httpGet(port, token, '/exists?path=' + encodeURIComponent(rpath(s))).trim() === '1';
@@ -229,17 +252,13 @@ function patchFs(fakeRoot, port, token) {
   fs.statSync = function patchedStatSync(p, opts) {
     const s = abs(p);
     if (!s || !isFakePath(s, fakeRoot)) return orig.statSync(p, opts);
-    try {
-      return makeStats(JSON.parse(httpGet(port, token, '/stat?path=' + encodeURIComponent(rpath(s)))));
-    } catch (e) { rethrowRemote(e, s); }
+    return statRemoteSync(s, opts);
   };
 
   fs.lstatSync = function patchedLstatSync(p, opts) {
     const s = abs(p);
     if (!s || !isFakePath(s, fakeRoot)) return orig.lstatSync(p, opts);
-    try {
-      return makeStats(JSON.parse(httpGet(port, token, '/stat?path=' + encodeURIComponent(rpath(s)))));
-    } catch (e) { rethrowRemote(e, s); }
+    return statRemoteSync(s, opts);
   };
 
   fs.writeFileSync = function patchedWriteFileSync(p, data, opts) {
@@ -359,7 +378,7 @@ function patchFs(fakeRoot, port, token) {
 
   // createReadStream: read entire file from remote, pipe as stream
   fs.createReadStream = function patchedCreateReadStream(p, opts) {
-    const s = typeof p === 'string' ? abs(p) : null;
+    const s = abs(p);
     if (!s || !isFakePath(s, fakeRoot)) return orig.createReadStream(p, opts);
     const { Readable } = require('stream');
     const stream = new Readable({ read() {} });
@@ -372,7 +391,7 @@ function patchFs(fakeRoot, port, token) {
 
   // createWriteStream: buffer writes, POST on finish
   fs.createWriteStream = function patchedCreateWriteStream(p, opts) {
-    const s = typeof p === 'string' ? abs(p) : null;
+    const s = abs(p);
     if (!s || !isFakePath(s, fakeRoot)) return orig.createWriteStream(p, opts);
     const { Writable } = require('stream');
     const chunks = [];
@@ -390,6 +409,7 @@ function patchFs(fakeRoot, port, token) {
 
   fs.promises.access = async function patchedAccess(p, mode) {
     const s = abs(p);
+    if (process.platform === 'win32' && isBashPath(s)) return;
     if (!s || !isFakePath(s, fakeRoot)) return origP.access(p, mode);
     try {
       const exists = (await httpGetAsync(port, token, '/exists?path=' + encodeURIComponent(rpath(s)))).trim() === '1';
@@ -402,7 +422,7 @@ function patchFs(fakeRoot, port, token) {
   };
 
   fs.promises.readFile = async function patchedReadFile(p, opts) {
-    const s = typeof p === 'string' ? abs(p) : null;
+    const s = abs(p);
     if (!s || !isFakePath(s, fakeRoot)) return origP.readFile(p, opts);
     try {
       const body = await httpGetAsync(port, token, '/read?path=' + encodeURIComponent(rpath(s)));
@@ -416,7 +436,7 @@ function patchFs(fakeRoot, port, token) {
   };
 
   fs.promises.readdir = async function patchedReaddir(p, opts) {
-    const s = typeof p === 'string' ? abs(p) : p.toString();
+    const s = abs(p) || p.toString();
     if (!isFakePath(s, fakeRoot)) return origP.readdir(p, opts);
     try {
       const withFileTypes = opts && opts.withFileTypes;
@@ -465,7 +485,7 @@ function patchFs(fakeRoot, port, token) {
   };
 
   fs.promises.writeFile = async function patchedWriteFile(p, data, opts) {
-    const s = typeof p === 'string' ? abs(p) : null;
+    const s = abs(p);
     if (!s || !isFakePath(s, fakeRoot)) return origP.writeFile(p, data, opts);
     const content = Buffer.isBuffer(data) ? data.toString('utf8') : String(data);
     await new Promise(function(resolve, reject) {
@@ -517,7 +537,7 @@ function patchFs(fakeRoot, port, token) {
   };
 
   fs.promises.appendFile = async function patchedAppendFile(p, data, opts) {
-    const s = typeof p === 'string' ? abs(p) : null;
+    const s = abs(p);
     if (!s || !isFakePath(s, fakeRoot)) return origP.appendFile(p, data, opts);
     const content = Buffer.isBuffer(data) ? data.toString('utf8') : String(data);
     const buf = Buffer.from(content, 'utf8');
@@ -614,7 +634,7 @@ function patchFs(fakeRoot, port, token) {
 
   // fs.promises.open: return a minimal FileHandle for reading
   fs.promises.open = async function patchedOpen(p, flags, mode) {
-    const s = typeof p === 'string' ? abs(p) : null;
+    const s = abs(p);
     if (!s || !isFakePath(s, fakeRoot)) return origP.open(p, flags, mode);
     // Fetch the file content eagerly; return a minimal FileHandle-like object
     const content = await httpGetAsync(port, token, '/read?path=' + encodeURIComponent(rpath(s)));
@@ -646,7 +666,7 @@ function patchFs(fakeRoot, port, token) {
   const watchFilePollers = new Map();
 
   fs.watch = function patchedWatch(filename, opts, listener) {
-    const s = abs(typeof filename === 'string' ? filename : null);
+    const s = abs(filename);
     if (!s || !isFakePath(s, fakeRoot)) return origWatch(filename, opts, listener);
 
     if (typeof opts === 'function') { listener = opts; opts = {}; }
@@ -711,7 +731,7 @@ function patchFs(fakeRoot, port, token) {
   };
 
   fs.watchFile = function patchedWatchFile(filename, opts, listener) {
-    const s = abs(typeof filename === 'string' ? filename : null);
+    const s = abs(filename);
     if (!s || !isFakePath(s, fakeRoot)) {
       return origWatchFile ? origWatchFile(filename, opts, listener) : undefined;
     }
@@ -741,7 +761,7 @@ function patchFs(fakeRoot, port, token) {
   };
 
   fs.unwatchFile = function patchedUnwatchFile(filename, listener) {
-    const s = abs(typeof filename === 'string' ? filename : null);
+    const s = abs(filename);
     if (!s || !isFakePath(s, fakeRoot)) {
       return origUnwatchFile ? origUnwatchFile(filename, listener) : undefined;
     }