quilltap 4.10.0-dev.5 → 4.10.0-dev.51

package/bin/quilltap.js

@@ -484,6 +484,51 @@ function verifyPidIsNode(pid, expectedArgv0) {
   }
 }
 
+const HEARTBEAT_FRESH_MS = 5 * 60 * 1000;
+
+/**
+ * The freshness window in words, derived from the constant the check actually
+ * uses — so the sentence `--lock-clean` prints cannot drift away from the
+ * behaviour it describes.
+ */
+function describeFreshWindow() {
+  const seconds = Math.round(HEARTBEAT_FRESH_MS / 1000);
+  if (seconds % 60 !== 0) return `${seconds} seconds`;
+  const minutes = seconds / 60;
+  return minutes === 1 ? '1 minute' : `${minutes} minutes`;
+}
+
+/**
+ * Decide whether a lock record belongs to a live process.
+ *
+ * A hostname that differs from ours does NOT mean a different machine: macOS
+ * derives gethostname() dynamically when `scutil --get HostName` is unset, so
+ * one Mac reports e.g. "MacBook-Pro.local" and "Mac" at different times. So
+ * check PID liveness regardless of the recorded name, and fall back to
+ * heartbeat freshness for any environment rather than only for containers.
+ * See bug 126.
+ */
+function assessLock(lock, hostname) {
+  const sameHost = lock.hostname === hostname;
+  const alive = isPidAlive(lock.pid);
+  const isNode = alive ? verifyPidIsNode(lock.pid, lock.processArgv0 || '') : false;
+  const heartbeatAgeMs = lock.lastHeartbeat
+    ? Date.now() - new Date(lock.lastHeartbeat).getTime()
+    : Infinity;
+  const heartbeatFresh = heartbeatAgeMs < HEARTBEAT_FRESH_MS;
+
+  return {
+    sameHost,
+    alive,
+    isNode,
+    heartbeatAgeMs,
+    heartbeatFresh,
+    // Held by something running: a confirmed local process, or any holder
+    // still refreshing its heartbeat.
+    live: (alive && isNode) || heartbeatFresh,
+  };
+}
+
 /**
  * Handle --lock-status, --lock-clean, --lock-override commands.
  */
@@ -518,32 +563,20 @@ function handleLockCommand(dataDir, opts) {
       return;
     }
 
-    const sameHost = lock.hostname === hostname;
-    const alive = sameHost && isPidAlive(lock.pid);
-    const isNode = alive ? verifyPidIsNode(lock.pid, lock.processArgv0 || '') : false;
+    const { sameHost, alive, isNode, heartbeatAgeMs, heartbeatFresh } =
+      assessLock(lock, hostname);
 
     // Status line
     let status;
     if (alive && isNode) {
       status = '\x1b[32mACTIVE\x1b[0m (process confirmed running)';
+    } else if (heartbeatFresh) {
+      const ageStr = Math.round(heartbeatAgeMs / 1000) + 's';
+      status = `\x1b[32mACTIVE\x1b[0m (${lock.environment || 'unknown'}, heartbeat ${ageStr} ago)`;
     } else if (alive && !isNode) {
       status = '\x1b[33mSUSPECT\x1b[0m (PID alive but does not look like Quilltap — possible PID reuse)';
     } else if (!sameHost) {
-      // Different hostname — could be a container on this machine
-      const isVMOrContainer = lock.environment === 'docker';
-      const heartbeatAgeMs = lock.lastHeartbeat
-        ? Date.now() - new Date(lock.lastHeartbeat).getTime()
-        : Infinity;
-      const heartbeatFreshMs = 5 * 60 * 1000;
-
-      if (isVMOrContainer && heartbeatAgeMs < heartbeatFreshMs) {
-        const ageStr = Math.round(heartbeatAgeMs / 1000) + 's';
-        status = `\x1b[32mACTIVE (${lock.environment}, heartbeat ${ageStr} ago)\x1b[0m`;
-      } else if (isVMOrContainer) {
-        status = `\x1b[33mSTALE (${lock.environment}, no recent heartbeat)\x1b[0m — will be auto-claimed on next startup`;
-      } else {
-        status = '\x1b[33mSTALE (different host)\x1b[0m — will be auto-claimed on next startup';
-      }
+      status = `\x1b[33mSTALE (${lock.environment || 'unknown'} on ${lock.hostname}, no recent heartbeat)\x1b[0m — will be auto-claimed on next startup`;
     } else {
       status = '\x1b[31mSTALE (process dead)\x1b[0m — will be auto-claimed on next startup';
     }
@@ -551,7 +584,7 @@ function handleLockCommand(dataDir, opts) {
     console.log(`Instance Lock Status: ${status}`);
     console.log();
     console.log(`  PID:          ${lock.pid}`);
-    console.log(`  Hostname:     ${lock.hostname}${sameHost ? ' (this host)' : ' (different host)'}`);
+    console.log(`  Hostname:     ${lock.hostname}${sameHost ? ' (this host)' : ` (recorded name differs from ours: ${hostname})`}`);
     console.log(`  Environment:  ${lock.environment || 'unknown'}`);
     console.log(`  Process:      ${lock.processTitle || 'unknown'}`);
     console.log(`  Started:      ${lock.startedAt || 'unknown'}`);
@@ -599,37 +632,31 @@ function handleLockCommand(dataDir, opts) {
       return;
     }
 
-    const sameHost = lock.hostname === hostname;
-    const alive = sameHost && isPidAlive(lock.pid);
+    const { sameHost, alive, isNode, heartbeatAgeMs, heartbeatFresh } =
+      assessLock(lock, hostname);
 
-    if (alive) {
-      const isNode = verifyPidIsNode(lock.pid, lock.processArgv0 || '');
-      if (isNode) {
-        console.log(`Lock is held by a live Quilltap process (PID ${lock.pid}). Cannot clean.`);
-        console.log('Stop the running instance first, or use --lock-override to force.');
-        process.exit(1);
-      } else {
-        console.log(`Lock references PID ${lock.pid} which is alive but does NOT look like a Quilltap process.`);
-        console.log('This is likely a stale lock with a reused PID. Removing.');
-      }
+    if (alive && isNode) {
+      console.log(`Lock is held by a live Quilltap process (PID ${lock.pid}). Cannot clean.`);
+      console.log('Stop the running instance first, or use --lock-override to force.');
+      process.exit(1);
+    } else if (heartbeatFresh) {
+      // Reached only when `alive` is false — the arm above has already claimed
+      // every confirmed-live case — so this must not assert that anything is
+      // running. Freshness alone is the deliberate fallback (bug 126) for
+      // environments where PID checks are unreliable; the refusal is right,
+      // and what it says is simply what was tested.
+      const ageStr = Math.round(heartbeatAgeMs / 1000) + 's';
+      console.log(`Lock heartbeat is still fresh (${ageStr} ago). Cannot clean.`);
+      console.log(
+        `A lock counts as held until its heartbeat is ${describeFreshWindow()} stale, even if its process has gone. ` +
+          'Wait it out, or use --lock-override to force.'
+      );
+      process.exit(1);
+    } else if (alive && !isNode) {
+      console.log(`Lock references PID ${lock.pid} which is alive but does NOT look like a Quilltap process.`);
+      console.log('This is likely a stale lock with a reused PID. Removing.');
     } else if (!sameHost) {
-      // Different hostname — check if it's a container with a recent heartbeat
-      const isVMOrContainer = lock.environment === 'docker';
-      const heartbeatAgeMs = lock.lastHeartbeat
-        ? Date.now() - new Date(lock.lastHeartbeat).getTime()
-        : Infinity;
-      const heartbeatFreshMs = 5 * 60 * 1000;
-
-      if (isVMOrContainer && heartbeatAgeMs < heartbeatFreshMs) {
-        const ageStr = Math.round(heartbeatAgeMs / 1000) + 's';
-        console.log(`Lock is held by a live ${lock.environment} instance (heartbeat ${ageStr} ago). Cannot clean.`);
-        console.log('Stop the other instance first, or use --lock-override to force.');
-        process.exit(1);
-      } else if (isVMOrContainer) {
-        console.log(`Lock was held by ${lock.environment} (${lock.hostname}) with no recent heartbeat. Removing stale lock.`);
-      } else {
-        console.log(`Lock was held by a different host (${lock.hostname}). Removing stale lock.`);
-      }
+      console.log(`Lock was held by ${lock.environment || 'unknown'} on ${lock.hostname} with no recent heartbeat. Removing stale lock.`);
     } else {
       console.log(`Lock was held by PID ${lock.pid} which is no longer running. Removing stale lock.`);
     }

package/lib/native-modules.js

@@ -62,6 +62,84 @@ function betterSqlite3NeedsRebuild() {
   }
 }
 
+// Locate an executable installed by a dependency, given the package directory
+// that needs it. Checks the package's own `.bin` first, then the `.bin` beside
+// it (the hoisted case, which is the usual one). Returns null when absent.
+function findBinFor(pkgDir, tool) {
+  const fs = require('fs');
+  const names = process.platform === 'win32' ? [`${tool}.cmd`, `${tool}.exe`, tool] : [tool];
+  const dirs = [
+    path.join(pkgDir, 'node_modules', '.bin'),  // nested install
+    path.join(pkgDir, '..', '.bin'),            // hoisted alongside the package
+  ];
+  for (const dir of dirs) {
+    for (const name of names) {
+      const candidate = path.join(dir, name);
+      if (fs.existsSync(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+
+// Rebuild ONE native package in place, addressed by its directory.
+//
+// Deliberately does NOT go through `npm rebuild <name>`, which fails this job
+// two different ways:
+//
+//   1. npm refuses install scripts for any package not listed in the root
+//      package.json `allowScripts` map (keyed `name@version`). The root
+//      SQLCipher copy is installed under the ALIAS `better-sqlite3`, which is
+//      not a key there, so the rebuild dies with EALLOWSCRIPTS.
+//   2. Asking for the real name (`better-sqlite3-multiple-ciphers`) at the root
+//      instead resolves a phantom directory: npm reports "rebuilt dependencies
+//      successfully" and the binding on disk is untouched. A success message is
+//      worse than an error.
+//
+// Running the package's own build chain (`prebuild-install || node-gyp rebuild`,
+// exactly what its `install` script does) in its own directory sidesteps both:
+// no name resolution, no npm script policy. `prebuild-install` downloads the
+// prebuilt binary for the running ABI and needs network; node-gyp compiles and
+// needs a toolchain.
+//
+// Returns { ok, reason }. Never throws. Verifies the result rather than trusting
+// the exit code — see (2): the whole failure mode here is a rebuild that claims
+// to have worked.
+function rebuildNativePackage(pkgDir, bindingPath) {
+  const fs = require('fs');
+  if (!fs.existsSync(pkgDir)) return { ok: false, reason: `no package at ${pkgDir}` };
+
+  const before = fs.existsSync(bindingPath) ? readCompiledAbi(bindingPath) : null;
+  const attempts = [];
+
+  const prebuild = findBinFor(pkgDir, 'prebuild-install');
+  if (prebuild) attempts.push({ label: 'prebuild-install', cmd: `"${prebuild}"` });
+
+  const nodeGyp = findBinFor(pkgDir, 'node-gyp');
+  if (nodeGyp) attempts.push({ label: 'node-gyp rebuild', cmd: `"${nodeGyp}" rebuild --release` });
+
+  if (attempts.length === 0) {
+    return { ok: false, reason: 'neither prebuild-install nor node-gyp is installed' };
+  }
+
+  const failures = [];
+  for (const attempt of attempts) {
+    try {
+      execSync(attempt.cmd, { cwd: pkgDir, stdio: 'inherit' });
+    } catch (err) {
+      failures.push(`${attempt.label}: ${err.message.split('\n')[0]}`);
+      continue;
+    }
+    // Trust nothing but the binary. A tool can exit 0 having done nothing.
+    const after = fs.existsSync(bindingPath) ? readCompiledAbi(bindingPath) : null;
+    if (after === process.versions.modules) return { ok: true, reason: attempt.label };
+    failures.push(
+      `${attempt.label}: exited 0 but the binding is still ${after ?? 'missing'} ` +
+      `(wanted ${process.versions.modules}${before ? `, was ${before}` : ''})`,
+    );
+  }
+  return { ok: false, reason: failures.join('; ') };
+}
+
 // Rebuild the named native modules against the current Node ABI. Prints a
 // friendly notice rather than throwing; returns true on success, false on
 // failure. Backfills node-pty's spawn-helper afterward.
@@ -96,7 +174,27 @@ function ensureDatabaseNativeModule() {
   } catch {
     return true; // detection hiccup — let the real load be the source of truth
   }
-  return rebuildModules(['better-sqlite3-multiple-ciphers']);
+
+  const bindingPath = betterSqlite3BindingPath();
+  if (!bindingPath) {
+    console.error('  Warning: could not locate the SQLCipher binding to rebuild.');
+    return false;
+  }
+  // build/Release/better_sqlite3.node → the package directory above it.
+  const pkgDir = path.resolve(path.dirname(bindingPath), '..', '..');
+
+  console.log(`  Rebuilding the SQLCipher binding for Node.js ${process.version}...`);
+  const result = rebuildNativePackage(pkgDir, bindingPath);
+  if (result.ok) {
+    console.log(`  Done (${result.reason}).`);
+    console.log('');
+    return true;
+  }
+  console.error('');
+  console.error(`  Warning: failed to rebuild the SQLCipher binding — ${result.reason}`);
+  console.error(`  Try running: (cd ${pkgDir} && ./node_modules/.bin/prebuild-install)`);
+  console.error('');
+  return false;
 }
 
 // node-pty needs a `spawn-helper` executable beside the pty.node it loads, or
@@ -194,7 +292,10 @@ function ensureNativeModules() {
 module.exports = {
   resolveModuleDir,
   readCompiledAbi,
+  betterSqlite3BindingPath,
   betterSqlite3NeedsRebuild,
+  findBinFor,
+  rebuildNativePackage,
   ensureDatabaseNativeModule,
   ensureNativeModules,
   reconcileNodePtySpawnHelper,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quilltap",
-  "version": "4.10.0-dev.5",
+  "version": "4.10.0-dev.51",
   "description": "Self-hosted AI workspace for writers, worldbuilders, and roleplayers. Run with npx quilltap.",
   "author": {
     "name": "Charles Sebold",