modelstat 0.0.31 → 0.0.33

package/package.json

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

package/scripts/postinstall.mjs

@@ -47,23 +47,38 @@ function inThisMonorepo() {
 async function main() {
   if (process.env.MODELSTAT_SKIP_POSTINSTALL === "1") {
     console.log(
-      "[modelstat] postinstall skipped (MODELSTAT_SKIP_POSTINSTALL=1) — model downloads lazily on first scan",
-    );
-    return;
-  }
-  if (process.env.CI === "true" || process.env.CI === "1") {
-    console.log(
-      "[modelstat] postinstall skipped (CI=1) — model downloads lazily on first scan",
+      "[modelstat] postinstall skipped (MODELSTAT_SKIP_POSTINSTALL=1)",
     );
     return;
   }
   if (inThisMonorepo()) {
-    // Dev environment — don't pull 2.7 GB on every workspace install.
+    // Dev environment — don't pull 2.7 GB on every workspace install,
+    // and don't muck with the developer's running daemon.
     return;
   }
-  if (!process.stdout.isTTY) {
+
+  // ── Always-run path: refresh the existing service if there is one ─
+  // The bundle at ~/.modelstat/bin/modelstat.mjs and its sibling
+  // node_modules need to track every upgrade, otherwise the daemon
+  // launches against stale code (or, worse, code that imports a
+  // native module the local install doesn't have anymore). This MUST
+  // run regardless of TTY/CI — the previous behaviour gated it on
+  // an interactive shell, which left every npm-cache / npx-prewarm
+  // install with a half-installed bundle the daemon couldn't load.
+  await rebootServiceIfInstalled();
+
+  // ── TTY-only path: pre-download the heavy summariser model ───────
+  // The 2.7 GB GGUF is the only thing we want to skip in non-TTY
+  // installs (CI, npm cache, packagers). The agent always preflights
+  // the summariser before producing segments (see src/pipeline.ts),
+  // so users in skip-mode just see the download then, instead of now.
+  const skipModelDownload =
+    process.env.CI === "true" ||
+    process.env.CI === "1" ||
+    !process.stdout.isTTY;
+  if (skipModelDownload) {
     console.log(
-      "[modelstat] postinstall: non-TTY — model will download lazily on first `modelstat scan`",
+      "[modelstat] non-interactive install — summariser model will download lazily on first scan",
     );
     return;
   }
@@ -110,16 +125,6 @@ async function main() {
       "[modelstat]   the model will download lazily on first `modelstat scan` instead",
     );
   }
-
-  // ── Auto-replace + restart the existing service ───────────────
-  // If a previous version of the agent is already installed as a
-  // launchd / systemd service, its bundle copy at
-  // ~/.modelstat/bin/modelstat.mjs is now STALE — the new code we
-  // just installed lives in <global node_modules>/modelstat/dist.
-  // Stop the service, refresh the bundle copy, restart. Without
-  // this step the user has to manually `modelstat stop && modelstat
-  // connect` after every upgrade.
-  await rebootServiceIfInstalled();
   console.log(
     "[modelstat] all set — your dashboard already has the new agent running",
   );
@@ -196,6 +201,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 +224,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

package/vendor/tray-mac/Sources/ModelstatTray/main.swift

@@ -439,33 +439,33 @@ final class TrayController: NSObject {
 // anyone signed up for. We set it here as a belt — the plist is the
 // braces — so a malformed bundle still behaves.
 //
-// TrayController is @MainActor, so its init must run on the main
-// actor. We wrap the bootstrap in a main-actor function to satisfy
-// Swift 6's strict concurrency without bloating the controller.
-//
 // IMPORTANT: nothing in AppKit retains TrayController for us. The
 // NSStatusItem holds the menu, and NSMenuItem.target is a weak
 // reference, so the controller has no strong owners. Without a
 // global anchor, ARC deallocates the controller as soon as init
 // returns — which leaves the timer's `[weak self]` callback firing
-// against nil and the menu title frozen on "Starting…" forever.
+// against nil and the menu title frozen on "Loading…" forever.
 // The `controller` global below is the strong reference that keeps
 // the controller alive for the entire app lifetime.
+//
+// CRITICAL: NSApplication.run() must NOT be called from inside a
+// `DispatchQueue.main.async { ... }` closure. NSApplication.run()
+// blocks for the lifetime of the app, and from libdispatch's
+// perspective the wrapping closure is "still executing" the entire
+// time — which means every other main-queue async block (including
+// the stats-poll completion that updates the menu title) gets queued
+// behind it and never runs. Schedule the controller setup separately
+// and call app.run() directly from top-level code so libdispatch's
+// main queue stays free to drain.
 @MainActor
 private var controller: TrayController?
 
-@MainActor
-func bootstrap() {
-  let app = NSApplication.shared
-  app.setActivationPolicy(.accessory)
-  controller = TrayController()
-  app.run()
+DispatchQueue.main.async {
+  MainActor.assumeIsolated {
+    controller = TrayController()
+  }
 }
 
-// Swift's top-level code runs on the main thread implicitly, but the
-// compiler doesn't infer main-actor isolation there. `DispatchQueue.main.async`
-// schedules the bootstrap on the main queue where the @MainActor hop
-// becomes a no-op; we keep the current thread alive with RunLoop.main
-// until AppKit takes over.
-DispatchQueue.main.async { bootstrap() }
-RunLoop.main.run()
+let app = NSApplication.shared
+app.setActivationPolicy(.accessory)
+app.run()