pi-bridge 0.3.1 → 0.3.3

package/bin/pii.js

@@ -14,37 +14,56 @@ if (process.argv.includes('--version') || process.argv.includes('-v') || process
   process.exit(0);
 }
 
-function findPi() {
-  // 1. Standard npm global: both packages share the same node_modules prefix
-  const shared = path.resolve(__dirname, '..', '..', '@mariozechner', 'pi-coding-agent', 'dist', 'cli.js');
-  if (fs.existsSync(shared)) {
-    return { cli: shared, nodeExe: process.execPath };
+// 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 [];
   }
+}
 
-  // 2. Unix GitHub clone: which pi returns the JS file directly
-  if (os.platform() !== 'win32') {
-    try {
-      const wrapper = execFileSync('which', ['pi'], { encoding: 'utf8' }).trim();
-      if (fs.existsSync(wrapper)) return { cli: wrapper, nodeExe: process.execPath };
-    } catch (_) {}
+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 };
   }
 
-  // 3. Fallback: PowerShell Get-Command — handles custom/bundled Windows installs
-  //    where pi lives outside the standard npm prefix. Also picks up the bundled
-  //    node.exe that shipped alongside pi (required for version-matched execution).
-  if (os.platform() === 'win32') {
-    try {
-      const wrapper = execFileSync(
-        'powershell',
-        ['-NoProfile', '-Command', '(Get-Command pi -ErrorAction Stop).Source'],
-        { encoding: 'utf8' }
-      ).trim();
-      const basedir = path.dirname(wrapper);
-      const cli = wrapper.replace(/\.(ps1|cmd)$/i, '.js');
-      const localNode = path.join(basedir, 'node.exe');
-      const nodeExe = fs.existsSync(localNode) ? localNode : process.execPath;
-      if (fs.existsSync(cli)) return { cli, nodeExe };
-    } catch (_) {}
+  // 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;
@@ -57,8 +76,9 @@ try {
 
 if (!pi) {
   process.stderr.write(
-    'pii: Could not find pi.\n' +
-    'Install it with: npm install -g @mariozechner/pi-coding-agent\n'
+    'pii: Could not find pi on your PATH.\n' +
+    'If pi is already installed, re-open your shell so the install is on PATH, then retry.\n' +
+    'Otherwise install pi: curl -fsSL https://pi.dev/install.sh | sh\n'
   );
   process.exit(1);
 }

package/package.json

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

package/src/local/fs-patch.js

@@ -97,6 +97,10 @@ function patchFs(fakeRoot, port, token) {
     renameSync:     fs.renameSync.bind(fs),
     copyFileSync:   fs.copyFileSync.bind(fs),
     realpathSync:   fs.realpathSync.bind(fs),
+    mkdtempSync:    fs.mkdtempSync.bind(fs),
+    rmdirSync:      fs.rmdirSync.bind(fs),
+    chmodSync:      fs.chmodSync.bind(fs),
+    cpSync:         fs.cpSync ? fs.cpSync.bind(fs) : undefined,
     createWriteStream: fs.createWriteStream.bind(fs),
     createReadStream:  fs.createReadStream.bind(fs),
   };
@@ -116,6 +120,11 @@ function patchFs(fakeRoot, port, token) {
     rename:     fs.promises.rename.bind(fs.promises),
     copyFile:   fs.promises.copyFile.bind(fs.promises),
     open:       fs.promises.open.bind(fs.promises),
+    mkdtemp:    fs.promises.mkdtemp.bind(fs.promises),
+    realpath:   fs.promises.realpath.bind(fs.promises),
+    rmdir:      fs.promises.rmdir.bind(fs.promises),
+    chmod:      fs.promises.chmod.bind(fs.promises),
+    cp:         fs.promises.cp ? fs.promises.cp.bind(fs.promises) : undefined,
   };
 
   // Resolve any path (relative or absolute) to absolute before checking fake root
@@ -246,6 +255,58 @@ function patchFs(fakeRoot, port, token) {
     httpPost(port, token, '/mkdir?path=' + encodeURIComponent(rpath(s)), '');
   };
 
+  /**
+   * The remote runs the real mkdtempSync and returns only the generated
+   * directory name, so uniqueness keeps Node's semantics and no remote path has
+   * to be mapped back to a local one.
+   */
+  fs.mkdtempSync = function patchedMkdtempSync(prefix, opts) {
+    const s = abs(prefix);
+    if (!s || !isFakePath(s, fakeRoot)) return orig.mkdtempSync(prefix, opts);
+    const name = httpPost(port, token, '/mkdtemp?path=' + encodeURIComponent(rpath(s)), '');
+    return path.join(path.dirname(s), String(name).trim());
+  };
+
+  fs.rmdirSync = function patchedRmdirSync(p, opts) {
+    const s = abs(p);
+    if (!s || !isFakePath(s, fakeRoot)) return orig.rmdirSync(p, opts);
+    const recursive = (opts && opts.recursive) ? '1' : '0';
+    httpPost(port, token, '/rm?path=' + encodeURIComponent(rpath(s)) + '&recursive=' + recursive, '');
+  };
+
+  fs.chmodSync = function patchedChmodSync(p, mode) {
+    const s = abs(p);
+    if (!s || !isFakePath(s, fakeRoot)) return orig.chmodSync(p, mode);
+    // Octal on the wire: String(0o755) is "493", which the server would have to
+    // guess at. toString(8) keeps the intent explicit for numbers and strings.
+    const octal = typeof mode === 'number' ? mode.toString(8) : String(mode).replace(/^0o?/i, '');
+    httpPost(port, token, '/chmod?path=' + encodeURIComponent(rpath(s)) + '&mode=' + octal, '');
+  };
+
+  // Recursive copy: the remote /copy route handles one file, so directories are
+  // walked here through the already-patched calls.
+  fs.cpSync = function patchedCpSync(src, dest, opts) {
+    const srcS = abs(src);
+    const destS = abs(dest);
+    const involved = (srcS && isFakePath(srcS, fakeRoot)) || (destS && isFakePath(destS, fakeRoot));
+    if (!involved) {
+      if (!orig.cpSync) throw new Error('fs.cpSync is not available in this Node version');
+      return orig.cpSync(src, dest, opts);
+    }
+    const stats = fs.statSync(srcS);
+    if (!stats.isDirectory()) {
+      fs.copyFileSync(srcS, destS);
+      return;
+    }
+    if (!(opts && opts.recursive)) {
+      throw Object.assign(new Error('EISDIR: illegal operation on a directory, cp ' + srcS), { code: 'EISDIR' });
+    }
+    fs.mkdirSync(destS, { recursive: true });
+    for (const entry of fs.readdirSync(srcS)) {
+      fs.cpSync(path.join(srcS, entry), path.join(destS, entry), opts);
+    }
+  };
+
   fs.unlinkSync = function patchedUnlinkSync(p) {
     const s = abs(p);
     if (!s || !isFakePath(s, fakeRoot)) return orig.unlinkSync(p);
@@ -501,6 +562,56 @@ function patchFs(fakeRoot, port, token) {
     });
   };
 
+  fs.promises.rename = async function patchedRename(from, to) {
+    const fromS = abs(from);
+    const toS   = abs(to);
+    if (!fromS || !isFakePath(fromS, fakeRoot)) return origP.rename(from, to);
+    await new Promise(function(resolve, reject) {
+      const req = http.request(
+        { method: 'POST', hostname: '127.0.0.1', port: port,
+          path: '/rename?from=' + encodeURIComponent(rpath(fromS)) + '&to=' + encodeURIComponent(toS ? rpath(toS) : String(to)),
+          headers: { 'x-token': token, 'Content-Length': 0 } },
+        function(res) { res.resume(); res.on('end', function() { res.statusCode < 300 ? resolve() : reject(new Error('HTTP ' + res.statusCode)); }); }
+      );
+      req.on('error', reject); req.end();
+    });
+  };
+
+  fs.promises.mkdtemp = async function patchedMkdtemp(prefix, opts) {
+    const s = abs(prefix);
+    if (!s || !isFakePath(s, fakeRoot)) return origP.mkdtemp(prefix, opts);
+    return fs.mkdtempSync(prefix, opts);
+  };
+
+  fs.promises.realpath = async function patchedRealpath(p, opts) {
+    const s = abs(p);
+    if (!s || !isFakePath(s, fakeRoot)) return origP.realpath(p, opts);
+    return s;
+  };
+
+  fs.promises.rmdir = async function patchedRmdir(p, opts) {
+    const s = abs(p);
+    if (!s || !isFakePath(s, fakeRoot)) return origP.rmdir(p, opts);
+    return fs.promises.rm(p, Object.assign({}, opts));
+  };
+
+  fs.promises.chmod = async function patchedChmod(p, mode) {
+    const s = abs(p);
+    if (!s || !isFakePath(s, fakeRoot)) return origP.chmod(p, mode);
+    fs.chmodSync(p, mode);
+  };
+
+  fs.promises.cp = async function patchedCp(src, dest, opts) {
+    const srcS = abs(src);
+    const destS = abs(dest);
+    const involved = (srcS && isFakePath(srcS, fakeRoot)) || (destS && isFakePath(destS, fakeRoot));
+    if (!involved) {
+      if (!origP.cp) throw new Error('fs.promises.cp is not available in this Node version');
+      return origP.cp(src, dest, opts);
+    }
+    fs.cpSync(src, dest, opts);
+  };
+
   // 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;
@@ -651,6 +762,12 @@ function patchFs(fakeRoot, port, token) {
   fsp.mkdir      = fs.promises.mkdir;
   fsp.rm         = fs.promises.rm;
   fsp.unlink     = fs.promises.unlink;
+  fsp.rename     = fs.promises.rename;
+  fsp.mkdtemp    = fs.promises.mkdtemp;
+  fsp.realpath   = fs.promises.realpath;
+  fsp.rmdir      = fs.promises.rmdir;
+  fsp.chmod      = fs.promises.chmod;
+  fsp.cp         = fs.promises.cp;
   fsp.copyFile   = fs.promises.copyFile;
   fsp.open       = fs.promises.open;
 }

package/src/remote/handlers.js

@@ -123,6 +123,32 @@ function createHandlers() {
         return;
       }
 
+      if (req.method === 'POST' && pathname === '/mkdtemp') {
+        const prefix = url.searchParams.get('path');
+        if (!prefix) return sendError(res, 400, 'Missing path parameter');
+        // Real mkdtemp, so uniqueness is the kernel's problem rather than a
+        // check-then-create race. Only the generated name is returned; the
+        // caller already knows the directory.
+        const created = fs.mkdtempSync(prefix);
+        res.writeHead(200, { 'Content-Type': 'text/plain' });
+        res.end(require('path').basename(created));
+        return;
+      }
+
+      if (req.method === 'POST' && pathname === '/chmod') {
+        const p = url.searchParams.get('path');
+        const mode = url.searchParams.get('mode');
+        if (!p) return sendError(res, 400, 'Missing path parameter');
+        if (!mode) return sendError(res, 400, 'Missing mode parameter');
+        // The client always sends octal digits, so the wire value cannot be
+        // mistaken for a decimal bitmask.
+        if (!/^[0-7]{3,4}$/.test(mode)) return sendError(res, 400, 'Invalid mode parameter');
+        fs.chmodSync(p, parseInt(mode, 8));
+        res.writeHead(200, { 'Content-Type': 'text/plain' });
+        res.end('ok');
+        return;
+      }
+
       if (req.method === 'POST' && pathname === '/delete') {
         const p = url.searchParams.get('path');
         if (!p) return sendError(res, 400, 'Missing path parameter');