modelstat 0.0.32 → 0.0.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "modelstat",
-  "version": "0.0.32",
+  "version": "0.0.34",
   "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",
   );
@@ -312,13 +317,71 @@ async function setupNativeNodeModules(installedBundle) {
 }
 
 /**
- * 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.
+ * Kill any modelstat-related process the service supervisor didn't
+ * reap. Two passes:
+ *   (1) PID from ~/.modelstat/daemon.lock — the most reliable hit
+ *       when the lock is fresh and our own daemon wrote it.
+ *   (2) Process scan via `pgrep -f` on macOS/Linux — catches stray
+ *       daemons launched by an OLDER bundle (different command
+ *       line, different lock format), zombies that survived a
+ *       launchd KeepAlive bounce, and the case where the user has
+ *       BOTH the launchd-managed daemon AND a hand-spawned one
+ *       running. The pattern is intentionally narrow
+ *       (`modelstat\\.mjs`) so we don't kill `modelstatd` or any
+ *       other process that happens to share a substring.
+ *
+ * SIGTERM first, escalate to SIGKILL after 2 s. All failures
+ * tolerated — we just want the new bundle to be the only modelstat
+ * process holding the lock when we restart.
  */
 async function killStaleDaemon(stateDir) {
+  await killByLockfile(stateDir);
+  await killByProcessScan();
+}
+
+async function killByProcessScan() {
+  const { spawnSync } = await import("node:child_process");
+  // pgrep is on macOS by default, Linux via procps.
+  const r = spawnSync("pgrep", ["-f", "modelstat\\.mjs"], {
+    encoding: "utf8",
+  });
+  if (r.status !== 0 || !r.stdout) return;
+  const pids = r.stdout
+    .split(/\s+/)
+    .map((s) => Number(s))
+    .filter((n) => Number.isInteger(n) && n > 0 && n !== process.pid);
+  if (pids.length === 0) return;
+  for (const pid of pids) {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+      /* gone or not ours */
+    }
+  }
+  // Wait up to 2 s for graceful exits.
+  for (let i = 0; i < 20; i++) {
+    let alive = 0;
+    for (const pid of pids) {
+      try {
+        process.kill(pid, 0);
+        alive += 1;
+      } catch {
+        /* exited */
+      }
+    }
+    if (alive === 0) return;
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  for (const pid of pids) {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+      /* gone or denied */
+    }
+  }
+}
+
+async function killByLockfile(stateDir) {
   const { readFileSync } = await import("node:fs");
   const lockPath = join(stateDir, "daemon.lock");
   let payload;

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()