modelstat 0.0.30 → 0.0.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "modelstat",
-  "version": "0.0.30",
+  "version": "0.0.32",
   "description": "modelstat companion — reads local AI-tool usage and ships tokenised events to modelstat.",
   "license": "Apache-2.0",
   "type": "module",

package/scripts/postinstall.mjs

@@ -167,12 +167,20 @@ async function rebootServiceIfInstalled() {
   const { spawnSync } = await import("node:child_process");
   console.log("[modelstat] refreshing background service…");
 
-  // Stop first — best effort, ignore failures.
+  // Stop the SERVICE (launchctl bootout / systemctl --user disable)
+  // via the fresh bundle's own knowledge of each platform.
   spawnSync(process.execPath, [freshBundle, "stop"], {
     stdio: "ignore",
     timeout: 30_000,
   });
 
+  // Belt-and-braces: kill any stray daemon process that the service
+  // supervisor didn't reap (stale lock, killed parent, KeepAlive
+  // race during the bundle swap below). Lock file at
+  // ~/.modelstat/daemon.lock has the live PID; SIGTERM it gently
+  // first, escalate to SIGKILL if it's still around 2 s later.
+  await killStaleDaemon(stateDir);
+
   // Copy the new bundle over the old `~/.modelstat/bin/modelstat.mjs`
   // so the service supervisor (launchd/systemd) loads the new code on
   // next launch. The fresh bundle's `connect` / `start` does this on
@@ -188,6 +196,16 @@ async function rebootServiceIfInstalled() {
     );
   }
 
+  // The bundle is portable EXCEPT for `node-llama-cpp` and its
+  // platform-specific native sub-packages — they're marked external
+  // in tsup so they're resolved at runtime via Node's `node_modules`
+  // walk-up. From `~/.modelstat/bin/modelstat.mjs` there's no parent
+  // `node_modules` to find them in, so the bundled summariser dies
+  // at preflight with "Cannot find package 'node-llama-cpp'". Set up
+  // a sibling `node_modules` directory containing the runtime
+  // dependencies, sourced from this package's own install location.
+  await setupNativeNodeModules(installedBundle);
+
   // Start back up. `modelstat start` re-runs preflight (incl. the
   // processing-version reconcile that wipes cursors when we ship a
   // new pipeline), so the upgrade picks up the new behaviour
@@ -201,6 +219,140 @@ async function rebootServiceIfInstalled() {
   console.log("[modelstat] ✓ background service restarted with new build");
 }
 
+/**
+ * Make `node-llama-cpp` and its platform-specific native sibling
+ * packages reachable from `~/.modelstat/bin/modelstat.mjs` so the
+ * bundle's runtime `import("node-llama-cpp")` resolves.
+ *
+ * Strategy:
+ *   - Find the source `node_modules` directory in this package's
+ *     install (npm flat layout puts it at <pkg>/.. for global
+ *     installs; pnpm/bun layouts vary but the same walk-up works
+ *     since postinstall always runs from the package root).
+ *   - For each runtime dep we care about (`node-llama-cpp` plus
+ *     every `@node-llama-cpp/*` and `@reflink/*` sub-package),
+ *     symlink it into `~/.modelstat/bin/node_modules/<name>`.
+ *     Symlinks are free + fast; if symlinking fails (filesystem
+ *     boundary, permissions) fall back to a recursive copy with
+ *     `dereference:true` so the resulting tree has no dangling
+ *     refs into the source location.
+ *
+ * Idempotent: each upgrade clears the destination first.
+ */
+async function setupNativeNodeModules(installedBundle) {
+  const here = dirname(fileURLToPath(import.meta.url));
+  // Find a parent `node_modules` containing `node-llama-cpp`. The
+  // walk handles npm flat (<prefix>/lib/node_modules), pnpm flat
+  // (<prefix>/lib/node_modules with peer hoisting), and the npx
+  // cache layout (~/.npm/_npx/<hash>/node_modules).
+  let srcNodeModules = null;
+  for (let dir = here, i = 0; i < 8; i++) {
+    const probe = join(dir, "node_modules", "node-llama-cpp", "package.json");
+    if (existsSync(probe)) {
+      srcNodeModules = join(dir, "node_modules");
+      break;
+    }
+    const up = resolve(dir, "..");
+    if (up === dir) break;
+    dir = up;
+  }
+  if (!srcNodeModules) {
+    console.warn(
+      "[modelstat] couldn't locate node-llama-cpp in this install — bundled summariser will fail at preflight. Re-install with `npm i -g modelstat` or report a bug.",
+    );
+    return;
+  }
+
+  const fs = await import("node:fs/promises");
+  const destDir = join(dirname(installedBundle), "node_modules");
+  await fs.mkdir(destDir, { recursive: true });
+
+  // Discover every native package we need: the main one + every
+  // platform-specific sibling (the binary blob is in one of the
+  // `@node-llama-cpp/*` packages chosen by node-llama-cpp's
+  // optional-dependencies resolution at install time).
+  const wanted = new Set(["node-llama-cpp"]);
+  const all = await fs
+    .readdir(srcNodeModules, { withFileTypes: true })
+    .catch(() => []);
+  for (const e of all) {
+    if (!e.isDirectory()) continue;
+    if (!e.name.startsWith("@")) continue;
+    if (
+      e.name === "@node-llama-cpp" ||
+      e.name === "@reflink"
+    ) {
+      // Scoped dirs contain multiple packages — copy/symlink the
+      // whole scope dir so all platform variants are reachable.
+      wanted.add(e.name);
+    }
+  }
+
+  for (const pkg of wanted) {
+    const src = join(srcNodeModules, pkg);
+    const dest = join(destDir, pkg);
+    if (!existsSync(src)) continue;
+    try {
+      await fs.rm(dest, { recursive: true, force: true });
+    } catch {
+      /* ignore */
+    }
+    try {
+      await fs.symlink(src, dest, "dir");
+    } catch {
+      try {
+        await fs.cp(src, dest, { recursive: true, dereference: true });
+      } catch (err2) {
+        console.warn(
+          `[modelstat] couldn't link ${pkg}: ${err2 && err2.message ? err2.message : err2}`,
+        );
+      }
+    }
+  }
+}
+
+/**
+ * Kill any daemon process the service supervisor didn't reap.
+ * Reads ~/.modelstat/daemon.lock for the PID, sends SIGTERM, then
+ * SIGKILL after a short grace period. Tolerates a missing/stale
+ * lock file — we just want to make sure the new bundle is the only
+ * thing holding the lock when we restart.
+ */
+async function killStaleDaemon(stateDir) {
+  const { readFileSync } = await import("node:fs");
+  const lockPath = join(stateDir, "daemon.lock");
+  let payload;
+  try {
+    payload = JSON.parse(readFileSync(lockPath, "utf8"));
+  } catch {
+    return; // no lock file — nothing to do
+  }
+  const pid = Number(payload?.pid);
+  if (!Number.isInteger(pid) || pid <= 0) return;
+  if (pid === process.pid) return; // shouldn't happen, but defensive
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch (err) {
+    if (err && err.code === "ESRCH") return; // already gone
+    // EPERM: not our process — leave it alone.
+    return;
+  }
+  // Wait up to 2 s for graceful exit.
+  for (let i = 0; i < 20; i++) {
+    try {
+      process.kill(pid, 0); // signal 0 = existence check
+    } catch {
+      return; // exited
+    }
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+    /* gone or denied */
+  }
+}
+
 main().catch((err) => {
   console.warn(
     `[modelstat] postinstall failed: ${err && err.message ? err.message : err}`,