@fudrouter/fsrouter 0.6.93 → 0.6.95

package/dist/routes/db/route.js

@@ -72,13 +72,51 @@ export async function POST_handler(req, res) {
             if (db && typeof db.close === "function")
                 db.close();
         }
-        // 2. Remove active -wal and -shm files to prevent corruption/mismatch
+        // 2. Remove active -wal and -shm files to prevent corruption/mismatch.
+        // On Windows these files can be locked by the OS/AV/SQLite even after
+        // db.close() (EBUSY). Use a retry + rename fallback so restore never
+        // hard-fails on a transient lock.
         const walFile = path.join(DATA_DIR, "db", "data.sqlite-wal");
         const shmFile = path.join(DATA_DIR, "db", "data.sqlite-shm");
-        if (fs.existsSync(walFile))
-            fs.unlinkSync(walFile);
-        if (fs.existsSync(shmFile))
-            fs.unlinkSync(shmFile);
+        const safeUnlink = (file) => {
+            if (!fs.existsSync(file))
+                return;
+            // Give the DB a moment to fully release the file handle.
+            const attempts = process.platform === "win32" ? 12 : 3;
+            for (let i = 0; i < attempts; i++) {
+                try {
+                    fs.unlinkSync(file);
+                    return;
+                }
+                catch (e) {
+                    if (e.code === "EBUSY" || e.code === "EPERM" || e.code === "ETXTBSY") {
+                        // Fallback: rename out of the way (atomic on NTFS) then retry unlink.
+                        try {
+                            const tmp = `${file}.old-${Date.now()}`;
+                            fs.renameSync(file, tmp);
+                            try {
+                                fs.unlinkSync(tmp);
+                            }
+                            catch { /* ignore */ }
+                            return;
+                        }
+                        catch {
+                            // Wait and retry — the lock may be released shortly.
+                            try {
+                                Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 250);
+                            }
+                            catch { /* noop */ }
+                            continue;
+                        }
+                    }
+                    throw e;
+                }
+            }
+            // Last resort: leave the file; SQLite rebuilds -wal/-shm on next open.
+            console.warn(`[Restore] Could not remove ${file} (locked) — continuing.`);
+        };
+        safeUnlink(walFile);
+        safeUnlink(shmFile);
         // 3. Restore secrets/raw DB only for legacy backups. Do not overwrite the
         // logical import with a stale/incompatible SQLite file.
         const filesToRestore = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fudrouter/fsrouter",
-  "version": "0.6.93",
+  "version": "0.6.95",
   "private": false,
   "type": "module",
   "description": "9Router v2 — Express Backend (API, SSE, DB, Auth, MITM)",

package/scripts/postinstall.cjs

@@ -1,15 +1,16 @@
 #!/usr/bin/env node
 /**
- * Post-install: wire automation symlinks so pm2 (cwd=/root) can find the
- * Python venv, source tree and browser profiles used by the signup scripts.
+ * Post-install: wire automation symlinks so the signup scripts can find the
+ * Python venv, source tree and browser profiles regardless of the process cwd.
  *
- * pm2 runs the server with cwd=/root, and the automation routes resolve paths
- * relative to process.cwd() (e.g. .venv/bin/python, src/automation/*.py,
- * profiles/<provider>). On this VPS the real files live under /root/AMRouter,
- * so we symlink /root/{.venv,src,profiles} -> /root/AMRouter/{...}.
+ * The automation routes resolve paths relative to process.cwd()
+ * (e.g. .venv/bin/python, src/automation/*.py, profiles/<provider>). When the
+ * server runs under pm2 the cwd is the installed package directory
+ * (/usr/local/lib/node_modules/@fudrouter/fsrouter), NOT /root — so we create
+ * the symlinks in BOTH locations to be cwd-independent.
  *
- * Idempotent and non-fatal: never throws (npm install must succeed even if
- * the symlinks can't be created).
+ * Idempotent and non-fatal: never throws (npm install must succeed even if a
+ * symlink can't be created).
  */
 const fs = require("fs");
 const path = require("path");
@@ -19,26 +20,30 @@ function log(msg) {
   console.log(`[fsrouter:postinstall] ${msg}`);
 }
 
+function isSymlink(p) {
+  try {
+    return fs.lstatSync(p).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+
 function symlinkIfMissing(linkPath, targetPath) {
   try {
     if (!fs.existsSync(targetPath)) {
-      // target missing — only create the symlink if the link itself is absent
-      if (fs.existsSync(linkPath) || isSymlink(linkPath)) {
-        // leave existing link alone; just warn if it points nowhere
-        if (!fs.existsSync(linkPath)) fs.unlinkSync(linkPath);
-      }
+      // target missing — remove a dangling link if present, then skip
+      if (isSymlink(linkPath)) fs.unlinkSync(linkPath);
       log(`skip ${linkPath} (target ${targetPath} not found)`);
       return;
     }
     if (isSymlink(linkPath)) {
-      const cur = fs.readlinkSync(linkPath);
-      if (cur === targetPath) {
+      if (fs.readlinkSync(linkPath) === targetPath) {
         log(`ok ${linkPath} -> ${targetPath}`);
         return;
       }
       fs.unlinkSync(linkPath);
     } else if (fs.existsSync(linkPath)) {
-      log(`skip ${linkPath} (exists and is not a symlink)`);
+      log(`skip ${linkPath} (exists and is not a symlink — leaving untouched)`);
       return;
     }
     fs.symlinkSync(targetPath, linkPath, "dir");
@@ -48,20 +53,9 @@ function symlinkIfMissing(linkPath, targetPath) {
   }
 }
 
-function isSymlink(p) {
-  try {
-    return fs.lstatSync(p).isSymbolicLink();
-  } catch {
-    return false;
-  }
-}
-
 function main() {
-  // Prefer the canonical AMRouter checkout; fall back to the installed package.
-  const candidates = [
-    "/root/AMRouter",
-    path.resolve(__dirname, ".."), // package root when installed
-  ];
+  // Real AMRouter checkout (where the venv + browser profiles live)
+  const candidates = ["/root/AMRouter", path.resolve(__dirname, "..", "..")];
   let base = null;
   for (const c of candidates) {
     if (fs.existsSync(c)) {
@@ -75,12 +69,20 @@ function main() {
   }
   log(`base=${base}`);
 
-  // Virtualenv (venv python)
-  symlinkIfMissing("/root/.venv", path.join(base, ".venv"));
-  // Source tree (src/automation/*.py)
-  symlinkIfMissing("/root/src", path.join(base, "backend", "src"));
-  // Browser profiles used by automation signup scripts
-  symlinkIfMissing("/root/profiles", path.join(base, "backend", "profiles"));
+  const venvTarget = path.join(base, ".venv");
+  const srcTarget = path.join(base, "backend", "src");
+  const profilesTarget = path.join(base, "backend", "profiles");
+
+  // Locations to symlink from (cwd-independent coverage)
+  const linkBases = ["/root", process.cwd()]; // /root + the dir npm ran install in (global package dir under pm2)
+
+  for (const lb of linkBases) {
+    symlinkIfMissing(path.join(lb, ".venv"), venvTarget);
+    // src only if it doesn't already exist as a real dir (package ships src/)
+    const srcLink = path.join(lb, "src");
+    if (!fs.existsSync(srcLink)) symlinkIfMissing(srcLink, srcTarget);
+    symlinkIfMissing(path.join(lb, "profiles"), profilesTarget);
+  }
 }
 
 try {