pi-bridge 0.3.2 → 0.3.4

package/package.json

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

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');
 
@@ -97,6 +98,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,11 +121,35 @@ 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),
-  };
-
-  // Resolve any path (relative or absolute) to absolute before checking fake root
+    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.
+  // 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) {
@@ -220,17 +249,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) {
@@ -246,6 +271,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);
@@ -298,7 +375,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() {} });
@@ -311,7 +388,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 = [];
@@ -341,7 +418,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)));
@@ -355,7 +432,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;
@@ -404,7 +481,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) {
@@ -456,7 +533,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');
@@ -501,9 +578,59 @@ 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;
+    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)));
@@ -535,7 +662,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 = {}; }
@@ -600,7 +727,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;
     }
@@ -630,7 +757,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;
     }
@@ -651,6 +778,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');