modelstat 0.0.39 → 0.0.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "modelstat",
-  "version": "0.0.39",
+  "version": "0.0.41",
   "description": "modelstat companion — reads local AI-tool usage and ships tokenised events to modelstat.",
   "license": "Apache-2.0",
   "type": "module",
@@ -69,6 +69,7 @@
     "pack:tarball": "pnpm run build && npm pack --pack-destination ../..",
     "install:local": "bash ./scripts/install-local.sh",
     "postinstall": "node ./scripts/postinstall.mjs",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "test": "node --import tsx --test src/**/*.test.ts"
   }
 }

package/scripts/postinstall.mjs

@@ -132,7 +132,6 @@ async function main() {
 
 async function rebootServiceIfInstalled() {
   const stateDir = join(homedir(), ".modelstat");
-  const installedBundle = join(stateDir, "bin", "modelstat.mjs");
   const launchdPlist = join(
     homedir(),
     "Library",
@@ -186,31 +185,29 @@ async function rebootServiceIfInstalled() {
   // 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
-  // its own first run, but we want the service to come back alive
-  // immediately — not wait for a manual `modelstat connect`.
-  const { copyFileSync, mkdirSync } = await import("node:fs");
-  try {
-    mkdirSync(dirname(installedBundle), { recursive: true });
-    copyFileSync(freshBundle, installedBundle);
-  } catch (err) {
+  // Re-stage the installed bundle AND its native summariser runtime in
+  // ONE canonical step by spawning the freshly-unpacked bundle's own
+  // `_setup-runtime` command. That runs the SAME service.ts staging the
+  // `modelstat connect` path uses: it copies dist/cli.mjs over
+  // ~/.modelstat/bin/modelstat.mjs and `npm install`s the complete
+  // node-llama-cpp closure (incl. this platform's prebuilt binary) into
+  // ~/.modelstat/bin/node_modules. freshBundle runs from the just-
+  // unpacked npm tree, so its installNativeRuntime() pins the version.
+  //
+  // This replaces the old hand-copy + symlink-the-npm-cache approach,
+  // whose symlinks dangled the moment the cache/global was pruned — the
+  // opposite of self-contained. One mechanism, every platform.
+  console.log("[modelstat] staging new bundle + native runtime…");
+  const setup = spawnSync(process.execPath, [freshBundle, "_setup-runtime"], {
+    stdio: "inherit",
+    timeout: 300_000,
+  });
+  if (setup.status !== 0) {
     console.warn(
-      `[modelstat] couldn't refresh installed bundle: ${err && err.message ? err.message : err}`,
+      `[modelstat] couldn't stage the new bundle/runtime (exit ${setup.status ?? "?"}); the service may still be on the previous build`,
     );
   }
 
-  // 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
@@ -224,98 +221,6 @@ 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 modelstat-related process the service supervisor didn't
  * reap. Two passes:

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

@@ -95,6 +95,12 @@ struct LocalStatsCounters: Decodable {
   let files_unchanged: Int?
   let events_uploaded: Int?
   let batches_uploaded: Int?
+  /// Lifetime count of cognition segments uploaded from this machine
+  /// (persisted by the daemon, so it survives restarts).
+  let segments_sent: Int?
+  /// Segments in the batch being uploaded right now — a gauge that
+  /// drops back to 0 between bursts. Usually 0 when idle.
+  let segments_sending: Int?
 }
 
 @MainActor
@@ -105,7 +111,15 @@ final class TrayController: NSObject {
   private var daemon: Process?
   private var paused = false
   private var latest: AgentStats?
-  private var pollTimer: Timer?
+  /// Live local heartbeat, read straight from ~/.modelstat/last-status.json
+  /// on the fast timer. Decoupled from `latest` (the slower, network-backed
+  /// `stats --json` shell-out) so the menu's numbers move every second.
+  private var localLatest: LocalStatus?
+  /// Advances once per fast tick to drive the "alive" pulse on the status
+  /// line — a cheap, honest signal that the agent is doing work right now.
+  private var spinnerTick = 0
+  private var fastTimer: Timer?
+  private var slowTimer: Timer?
 
   // Menu items we update on every poll
   private let statusMI = NSMenuItem(title: "Loading…", action: nil, keyEquivalent: "")
@@ -128,9 +142,28 @@ final class TrayController: NSObject {
     buildMenu()
     startDaemon()
     refreshStats()
-    pollTimer = Timer.scheduledTimer(withTimeInterval: 5.0, repeats: true) { [weak self] _ in
-      Task { @MainActor in self?.refreshStats() }
+    tickLocal()
+
+    // Two cadences, both registered in `.common` mode so they keep firing
+    // while the menu is open and being tracked — a plain
+    // `Timer.scheduledTimer` only runs in `.default` mode, so the dropdown
+    // froze the moment you opened it. That alone made a working agent look
+    // stuck.
+    //   · fast (1s): read last-status.json directly — cheap, no subprocess
+    //     — and re-render so phase/segment numbers tick live.
+    //   · slow (15s): shell out to `modelstat stats --json` for the
+    //     network-backed paired/claimed/device/analyzed data that barely
+    //     changes (and, for claimed devices, costs a 404 round-trip).
+    let fast = Timer(timeInterval: 1.0, repeats: true) { [weak self] _ in
+      MainActor.assumeIsolated { self?.tickLocal() }
     }
+    RunLoop.main.add(fast, forMode: .common)
+    fastTimer = fast
+    let slow = Timer(timeInterval: 15.0, repeats: true) { [weak self] _ in
+      MainActor.assumeIsolated { self?.refreshStats() }
+    }
+    RunLoop.main.add(slow, forMode: .common)
+    slowTimer = slow
   }
 
   private func configureStatusItem() {
@@ -148,13 +181,23 @@ final class TrayController: NSObject {
     statusItem.button?.toolTip = "modelstat"
   }
 
+  /// The five non-clickable info rows at the top of the menu, in order.
+  private var infoItems: [NSMenuItem] {
+    [statusMI, deviceMI, analyzedMI, pipelineMI, detectedMI]
+  }
+
+  /// Set an info row's title, hiding the row when the title is empty.
+  /// A disabled `NSMenuItem` with an empty title still takes a full
+  /// row of height — that was the stray blank space under "Claimed ✓".
+  private func setInfo(_ item: NSMenuItem, _ title: String) {
+    item.title = title
+    item.isHidden = title.isEmpty
+  }
+
   private func buildMenu() {
-    statusMI.isEnabled = false
-    deviceMI.isEnabled = false
-    analyzedMI.isEnabled = false
-    pipelineMI.isEnabled = false
-    detectedMI.isEnabled = false
-    for mi in [statusMI, deviceMI, analyzedMI, pipelineMI, detectedMI] {
+    for mi in infoItems {
+      mi.isEnabled = false
+      mi.isHidden = mi.title.isEmpty
       menu.addItem(mi)
     }
     menu.addItem(NSMenuItem.separator())
@@ -231,6 +274,26 @@ final class TrayController: NSObject {
     daemon = nil
   }
 
+  // ── Live local heartbeat (fast path) ────────────────────────────
+
+  /// Read ~/.modelstat/last-status.json directly and re-render. Runs every
+  /// second from a `.common`-mode timer, so it updates the dropdown even
+  /// while it's open. No subprocess, no network — just a few-KB JSON read.
+  /// The file's top-level shape is the daemon's heartbeat body, which
+  /// matches `LocalStatus`, so we decode it straight.
+  private func tickLocal() {
+    guard !paused else { return }
+    spinnerTick &+= 1
+    let path = ("~/.modelstat/last-status.json" as NSString).expandingTildeInPath
+    if let data = FileManager.default.contents(atPath: path),
+       let ls = try? JSONDecoder().decode(LocalStatus.self, from: data)
+    {
+      localLatest = ls
+    }
+    // Re-render even if the read failed so the pulse keeps moving.
+    renderStats()
+  }
+
   // ── Polling `modelstat stats --json` ────────────────────────────
 
   private func refreshStats() {
@@ -268,16 +331,19 @@ final class TrayController: NSObject {
   }
 
   private func renderStats() {
+    // Paused: togglePaused() owns the status line ("Paused"); don't let the
+    // fast tick clobber it with a stale phase from the file.
+    guard !paused else { return }
     guard let s = latest else {
-      statusMI.title = "Loading…"
+      setInfo(statusMI, "Loading…")
       return
     }
+    // Prefer the live file read (fast timer) over the network shell-out's
+    // embedded copy, which can be up to 15s stale.
+    let local = localLatest ?? s.local
     if s.paired == false {
-      statusMI.title = "Not paired — run `npx modelstat@latest`"
-      deviceMI.title = ""
-      analyzedMI.title = ""
-      pipelineMI.title = ""
-      detectedMI.title = ""
+      setInfo(statusMI, "Not paired — run `npx modelstat@latest`")
+      for mi in [deviceMI, analyzedMI, pipelineMI, detectedMI] { setInfo(mi, "") }
       claimMI.title = "Open modelstat.ai"
       copyClaimMI.isHidden = true
       return
@@ -287,26 +353,36 @@ final class TrayController: NSObject {
     // Falls back to the device-view's reported agent_status. If
     // both are missing we say "running" rather than "starting" so
     // the menu doesn't lie about the daemon's state.
-    let phase = s.local?.status ?? s.device?.agent_status ?? "running"
-    let phaseMsg = s.local?.message
+    let phase = local?.status ?? s.device?.agent_status ?? "running"
+    let phaseMsg = local?.message
+    // Pulse the leading dot while the agent is actively working so the
+    // menu reads as alive even on the rare beat where the numbers don't
+    // change. Steady dot when idle/watching/offline.
+    let dot = isActivePhase(phase) ? (spinnerTick % 2 == 0 ? "●" : "○") : "●"
     if let m = phaseMsg, !m.isEmpty {
-      statusMI.title = "● \(phase) — \(m)"
+      setInfo(statusMI, "\(dot) \(phase) — \(m)")
     } else {
-      statusMI.title = "● \(phase)"
+      setInfo(statusMI, "\(dot) \(phase)")
     }
 
     if s.claimed == true {
       // Claimed device: device-view 404s for the tray (no auth) so
       // we lean entirely on the local heartbeat snapshot for live
-      // numbers, plus point the menu items at the dashboard.
-      deviceMI.title = s.local?.agent_version ?? "Claimed ✓ — synced to your account"
+      // numbers, plus point the menu items at the dashboard. Keep the
+      // reassuring "Claimed ✓" and append the agent version when the
+      // local snapshot carries it.
+      if let v = local?.agent_version, !v.isEmpty {
+        setInfo(deviceMI, "Claimed ✓ · \(v)")
+      } else {
+        setInfo(deviceMI, "Claimed ✓ — synced to your account")
+      }
       claimMI.title = "Open dashboard"
       copyClaimMI.isHidden = true
     } else {
       // Unclaimed: device-view fills in the rich numbers.
       let host = s.device?.hostname ?? "unknown"
       let os = s.device?.os_family ?? ""
-      deviceMI.title = "\(host) · \(os)"
+      setInfo(deviceMI, "\(host) · \(os)")
       claimMI.title = "Open device page"
       copyClaimMI.isHidden = (s.claim_url == nil || s.claim_url?.isEmpty == true)
     }
@@ -321,43 +397,58 @@ final class TrayController: NSObject {
       let proc = a.processing ?? 0
       let done = a.finished ?? cnt
       let breakdown = proc > 0 ? " (\(done) finished · \(proc) processing)" : ""
-      analyzedMI.title = "\(cnt) sessions\(breakdown) · \(fmtTokens(tok)) tokens · $\(usd)"
+      setInfo(analyzedMI, "\(cnt) sessions\(breakdown) · \(fmtTokens(tok)) tokens · $\(usd)")
     } else {
-      analyzedMI.title = ""
+      setInfo(analyzedMI, "")
     }
 
-    // Pipeline activity — events + batches uploaded since daemon
-    // started. Sourced from the local heartbeat mirror so it works
-    // for both claimed and unclaimed devices.
-    if let c = s.local?.stats {
+    // Pipeline activity — segments are the headline (what the user
+    // asked to see): how many are uploading right now, and how many
+    // have been sent in total. Events / files trail as context. All
+    // sourced from the local heartbeat mirror so it works for both
+    // claimed and unclaimed devices.
+    if let c = local?.stats {
+      let sending = c.segments_sending ?? 0
+      let sent = c.segments_sent ?? 0
       let events = c.events_uploaded ?? 0
-      let batches = c.batches_uploaded ?? 0
       let scanned = c.files_scanned ?? 0
-      let queue = s.local?.queue_size ?? 0
+      let queue = local?.queue_size ?? 0
       var bits: [String] = []
-      if events > 0 || batches > 0 {
-        bits.append("\(fmtCount(events)) events · \(batches) batches uploaded")
-      }
-      if scanned > 0 { bits.append("\(scanned) files scanned") }
+      if sending > 0 { bits.append("↑ \(sending) sending") }
+      if sent > 0 { bits.append("\(fmtCount(sent)) segments sent") }
+      if events > 0 { bits.append("\(fmtCount(events)) events") }
+      if scanned > 0 { bits.append("\(scanned) files") }
       if queue > 0 { bits.append("\(queue) in queue") }
-      pipelineMI.title = bits.isEmpty ? "" : bits.joined(separator: " · ")
+      setInfo(pipelineMI, bits.joined(separator: " · "))
     } else {
-      pipelineMI.title = ""
+      setInfo(pipelineMI, "")
     }
 
     // What the agent found on this machine — installations +
     // identities (Claude Keychain, Codex JWT, …). Mirror of the
     // discover() output the daemon ran at startup.
-    if let c = s.local?.stats {
+    if let c = local?.stats {
       let installs = c.installations_detected ?? 0
       let ids = c.identities_detected ?? 0
       if installs > 0 || ids > 0 {
-        detectedMI.title = "\(installs) tools · \(ids) accounts detected"
+        setInfo(detectedMI, "\(installs) tools · \(ids) accounts detected")
       } else {
-        detectedMI.title = ""
+        setInfo(detectedMI, "")
       }
     } else {
-      detectedMI.title = ""
+      setInfo(detectedMI, "")
+    }
+  }
+
+  /// Phases where the agent is doing visible work right now — drives the
+  /// pulsing status dot. "watching"/"idle" are healthy-but-quiet (steady
+  /// dot); "offline"/"error" are problems (steady dot, not a busy pulse).
+  private func isActivePhase(_ phase: String) -> Bool {
+    switch phase {
+    case "starting", "discovering", "scanning", "processing", "uploading":
+      return true
+    default:
+      return false
     }
   }
 
@@ -427,7 +518,8 @@ final class TrayController: NSObject {
 
   @objc private func quit() {
     stopDaemon()
-    pollTimer?.invalidate()
+    fastTimer?.invalidate()
+    slowTimer?.invalidate()
     NSApp.terminate(nil)
   }
 }