modelstat 0.0.31 → 0.0.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "modelstat",
-  "version": "0.0.31",
+  "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

@@ -196,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
@@ -209,6 +219,98 @@ 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