modelstat 0.0.29 → 0.0.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "modelstat",
-  "version": "0.0.29",
+  "version": "0.0.31",
   "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
@@ -201,6 +209,48 @@ async function rebootServiceIfInstalled() {
   console.log("[modelstat] ✓ background service restarted with new build");
 }
 
+/**
+ * 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}`,

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

@@ -54,6 +54,12 @@ struct AgentStats: Decodable {
   let agent_url: String?
   let device: DeviceInfo?
   let analyzed: AnalyzedInfo?
+  /// Daemon heartbeat snapshot mirrored to ~/.modelstat/last-status.json.
+  /// Present on both unclaimed and claimed responses post-0.0.30 so the
+  /// tray can show real numbers even when the public device-view 404s
+  /// (claimed devices). Older daemons that don't write the file leave
+  /// this nil.
+  let local: LocalStatus?
 }
 
 struct DeviceInfo: Decodable {
@@ -65,10 +71,32 @@ struct DeviceInfo: Decodable {
 
 struct AnalyzedInfo: Decodable {
   let count: Int?
+  /// `processing` = sessions with at least one un-classified segment;
+  /// `finished` = every segment classified. From device-view endpoint.
+  let processing: Int?
+  let finished: Int?
   let totalTokens: String?
   let totalCostUsd: Double?
 }
 
+struct LocalStatus: Decodable {
+  let status: String?
+  let message: String?
+  let queue_size: Int?
+  let last_event_at: String?
+  let agent_version: String?
+  let stats: LocalStatsCounters?
+}
+
+struct LocalStatsCounters: Decodable {
+  let installations_detected: Int?
+  let identities_detected: Int?
+  let files_scanned: Int?
+  let files_unchanged: Int?
+  let events_uploaded: Int?
+  let batches_uploaded: Int?
+}
+
 @MainActor
 final class TrayController: NSObject {
   private let statusItem: NSStatusItem
@@ -80,9 +108,13 @@ final class TrayController: NSObject {
   private var pollTimer: Timer?
 
   // Menu items we update on every poll
-  private let statusMI = NSMenuItem(title: "Starting…", action: nil, keyEquivalent: "")
+  private let statusMI = NSMenuItem(title: "Loading…", action: nil, keyEquivalent: "")
   private let deviceMI = NSMenuItem(title: "", action: nil, keyEquivalent: "")
   private let analyzedMI = NSMenuItem(title: "", action: nil, keyEquivalent: "")
+  /// Pipeline activity — sessions processing/finished + events uploaded.
+  private let pipelineMI = NSMenuItem(title: "", action: nil, keyEquivalent: "")
+  /// What the agent has discovered on this machine — installations + identities.
+  private let detectedMI = NSMenuItem(title: "", action: nil, keyEquivalent: "")
   private let claimMI = NSMenuItem(title: "Open device page", action: #selector(openDashboard), keyEquivalent: "o")
   private let copyClaimMI = NSMenuItem(title: "Copy claim URL", action: #selector(copyClaimUrl), keyEquivalent: "c")
   private let jobsMI = NSMenuItem(title: "View pipeline…", action: #selector(openJobs), keyEquivalent: "j")
@@ -120,7 +152,11 @@ final class TrayController: NSObject {
     statusMI.isEnabled = false
     deviceMI.isEnabled = false
     analyzedMI.isEnabled = false
-    for mi in [statusMI, deviceMI, analyzedMI] { menu.addItem(mi) }
+    pipelineMI.isEnabled = false
+    detectedMI.isEnabled = false
+    for mi in [statusMI, deviceMI, analyzedMI, pipelineMI, detectedMI] {
+      menu.addItem(mi)
+    }
     menu.addItem(NSMenuItem.separator())
     claimMI.target = self
     copyClaimMI.target = self
@@ -233,41 +269,102 @@ final class TrayController: NSObject {
 
   private func renderStats() {
     guard let s = latest else {
-      statusMI.title = "pairing…"
+      statusMI.title = "Loading…"
       return
     }
     if s.paired == false {
-      statusMI.title = "not paired — run `modelstat connect`"
+      statusMI.title = "Not paired — run `npx modelstat@latest`"
       deviceMI.title = ""
       analyzedMI.title = ""
+      pipelineMI.title = ""
+      detectedMI.title = ""
       claimMI.title = "Open modelstat.ai"
       copyClaimMI.isHidden = true
       return
     }
+
+    // Live agent phase comes from the local heartbeat mirror.
+    // 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
+    if let m = phaseMsg, !m.isEmpty {
+      statusMI.title = "● \(phase) — \(m)"
+    } else {
+      statusMI.title = "● \(phase)"
+    }
+
     if s.claimed == true {
-      statusMI.title = "Claimed ✓"
-      deviceMI.title = "Synced to your account"
-      analyzedMI.title = ""
+      // 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"
       claimMI.title = "Open dashboard"
       copyClaimMI.isHidden = true
-      return
+    } 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)"
+      claimMI.title = "Open device page"
+      copyClaimMI.isHidden = (s.claim_url == nil || s.claim_url?.isEmpty == true)
     }
-    // Unclaimed: show the rich summary from the stats payload.
-    let status = s.device?.agent_status ?? "ready"
-    statusMI.title = "Agent: \(status)"
-    let host = s.device?.hostname ?? "unknown"
-    let os = s.device?.os_family ?? ""
-    deviceMI.title = "\(host) · \(os)"
+
+    // Sessions / tokens / cost (only available for unclaimed since
+    // the device-view exposes them). Claimed devices show pipeline
+    // + detected counts instead — see below.
     if let a = s.analyzed {
       let tok = a.totalTokens ?? "0"
       let cnt = a.count ?? 0
       let usd = String(format: "%.2f", a.totalCostUsd ?? 0.0)
-      analyzedMI.title = "\(cnt) sessions · \(fmtTokens(tok)) tokens · $\(usd)"
+      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)"
+    } else {
+      analyzedMI.title = ""
+    }
+
+    // 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 {
+      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
+      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 queue > 0 { bits.append("\(queue) in queue") }
+      pipelineMI.title = bits.isEmpty ? "" : bits.joined(separator: " · ")
     } else {
-      analyzedMI.title = "no activity yet"
+      pipelineMI.title = ""
     }
-    claimMI.title = "Open device page"
-    copyClaimMI.isHidden = (s.claim_url == nil || s.claim_url?.isEmpty == true)
+
+    // 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 {
+      let installs = c.installations_detected ?? 0
+      let ids = c.identities_detected ?? 0
+      if installs > 0 || ids > 0 {
+        detectedMI.title = "\(installs) tools · \(ids) accounts detected"
+      } else {
+        detectedMI.title = ""
+      }
+    } else {
+      detectedMI.title = ""
+    }
+  }
+
+  private func fmtCount(_ n: Int) -> String {
+    if n >= 1_000_000 { return String(format: "%.1fM", Double(n) / 1_000_000) }
+    if n >= 1_000 { return String(format: "%.1fK", Double(n) / 1_000) }
+    return String(n)
   }
 
   private func fmtTokens(_ raw: String) -> String {