modelstat 0.0.7 → 0.0.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "modelstat",
-  "version": "0.0.7",
+  "version": "0.0.12",
   "description": "modelstat companion — reads local AI-tool usage and ships tokenised events to modelstat.",
   "license": "Apache-2.0",
   "type": "module",
@@ -10,6 +10,7 @@
   },
   "files": [
     "dist",
+    "vendor/tray-mac",
     "README.md",
     "LICENSE"
   ],
@@ -17,16 +18,15 @@
     "dev:connect": "tsx ./src/cli.ts connect",
     "dev:scan": "tsx ./src/cli.ts scan",
     "dev:watch": "tsx ./src/cli.ts watch",
-    "dev:register": "tsx ./src/cli.ts register",
     "dev:discover": "tsx ./src/cli.ts discover",
     "build": "tsup",
-    "prepack": "pnpm run build",
+    "build:tray": "bash ./scripts/build-tray.sh",
+    "prepack": "pnpm run build && pnpm run build:tray",
     "pack:tarball": "pnpm run build && npm pack --pack-destination ../..",
     "install:local": "bash ./scripts/install-local.sh",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "better-sqlite3": "^11.7.0",
     "chokidar": "^4.0.3",
     "conf": "^13.1.0",
     "dotenv": "^16.4.7",
@@ -34,9 +34,9 @@
     "undici": "^7.1.0"
   },
   "devDependencies": {
+    "@modelstat/companion-core": "workspace:*",
     "@modelstat/core": "workspace:*",
     "@modelstat/parsers": "workspace:*",
-    "@types/better-sqlite3": "^7.6.12",
     "@types/node": "^22.10.5",
     "tsup": "^8.3.5",
     "tsx": "^4.19.2",

package/vendor/tray-mac/Package.swift

@@ -0,0 +1,32 @@
+// swift-tools-version:5.9
+//
+// ModelstatTray — a tiny menu-bar app for macOS.
+//
+// No third-party deps. AppKit provides NSStatusItem for the menu-bar
+// icon; Foundation is enough for subprocess + JSON. The whole thing
+// is a single main.swift so release builds are fast and the bundle
+// we ship in the DMG is small (~1 MB).
+//
+// Build:
+//   swift build -c release             (executable at .build/release/modelstat-tray)
+//   ./build-app.sh                     (wraps the binary in ModelstatTray.app)
+//
+// Wired into the macOS install path in apps/agent-dev/src/service.ts —
+// the launchd plist launches THIS instead of the headless daemon; the
+// tray then spawns `modelstat start` as a child so there's still only
+// one process managing the pipeline.
+import PackageDescription
+
+let package = Package(
+  name: "ModelstatTray",
+  platforms: [.macOS(.v12)],
+  products: [
+    .executable(name: "modelstat-tray", targets: ["ModelstatTray"])
+  ],
+  targets: [
+    .executableTarget(
+      name: "ModelstatTray",
+      path: "Sources/ModelstatTray"
+    )
+  ]
+)

package/vendor/tray-mac/Resources/Info.plist

@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleDevelopmentRegion</key>
+  <string>en</string>
+  <key>CFBundleDisplayName</key>
+  <string>Modelstat</string>
+  <key>CFBundleExecutable</key>
+  <string>modelstat-tray</string>
+  <key>CFBundleIdentifier</key>
+  <string>ai.modelstat.tray</string>
+  <key>CFBundleInfoDictionaryVersion</key>
+  <string>6.0</string>
+  <key>CFBundleName</key>
+  <string>Modelstat</string>
+  <key>CFBundlePackageType</key>
+  <string>APPL</string>
+  <key>CFBundleShortVersionString</key>
+  <string>0.1.0</string>
+  <key>CFBundleVersion</key>
+  <string>1</string>
+  <key>LSMinimumSystemVersion</key>
+  <string>12.0</string>
+  <!-- Agent-style app: no Dock icon, no window at launch, just the
+       menu-bar item. -->
+  <key>LSUIElement</key>
+  <true/>
+  <!-- Launch at login when the installer drops us into
+       ~/Library/LaunchAgents (actually driven by the launchd plist). -->
+  <key>LSBackgroundOnly</key>
+  <false/>
+  <key>NSHighResolutionCapable</key>
+  <true/>
+  <key>NSSupportsAutomaticTermination</key>
+  <false/>
+  <key>NSSupportsSuddenTermination</key>
+  <true/>
+  <key>NSHumanReadableCopyright</key>
+  <string>© 2026 modelstat</string>
+</dict>
+</plist>

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

@@ -0,0 +1,353 @@
+// ModelstatTray — macOS menu-bar companion for the modelstat agent.
+//
+// What it does:
+//   · puts a "◉" status item in the menu bar
+//   · runs `modelstat start` as a child process so the pipeline is live
+//   · polls `modelstat stats --json` every 5 s to refresh the dropdown
+//   · offers: Open dashboard, Copy claim URL, View pipeline, Pause/Resume,
+//     Quit
+//
+// Spawning the CLI is deliberate: the CLI already owns discover/scan/
+// watch + IngestClient retry semantics, and the tray never needs to
+// touch ingestion or auth. Keeps this binary a thin shell — one file,
+// ~300 LOC, no dependencies beyond AppKit/Foundation.
+
+import AppKit
+import Foundation
+
+// ── Resolve the `modelstat` CLI on $PATH, then at the install-path
+//    the agent-dev installer writes into (~/.modelstat/bin/modelstat.mjs)
+//    so we don't rely on shell profiles loading in launchd's env.
+func locateCli() -> URL? {
+  let fm = FileManager.default
+  let home = NSHomeDirectory()
+  let candidates = [
+    "\(home)/.modelstat/bin/modelstat.mjs",
+    "/opt/homebrew/bin/modelstat",
+    "/usr/local/bin/modelstat",
+    "/usr/bin/modelstat",
+  ]
+  for p in candidates {
+    if fm.isExecutableFile(atPath: p) { return URL(fileURLWithPath: p) }
+  }
+  // Last-ditch: `which modelstat` via a login shell so PATH lookups
+  // honour the user's zsh/bash config.
+  let task = Process()
+  task.launchPath = "/bin/zsh"
+  task.arguments = ["-l", "-c", "which modelstat"]
+  let pipe = Pipe()
+  task.standardOutput = pipe
+  task.standardError = Pipe()
+  do { try task.run(); task.waitUntilExit() } catch { return nil }
+  let out = String(data: pipe.fileHandleForReading.readDataToEndOfFile(), encoding: .utf8) ?? ""
+  let path = out.trimmingCharacters(in: .whitespacesAndNewlines)
+  return path.isEmpty ? nil : URL(fileURLWithPath: path)
+}
+
+struct AgentStats: Decodable {
+  let paired: Bool?
+  let claimed: Bool?
+  let dashboard: String?
+  let claim_code: String?
+  let status: String?
+  let claim_url: String?
+  let agent_url: String?
+  let device: DeviceInfo?
+  let analyzed: AnalyzedInfo?
+}
+
+struct DeviceInfo: Decodable {
+  let hostname: String?
+  let os_family: String?
+  let agent_status: String?
+  let last_seen_at: String?
+}
+
+struct AnalyzedInfo: Decodable {
+  let count: Int?
+  let totalTokens: String?
+  let totalCostUsd: Double?
+}
+
+@MainActor
+final class TrayController: NSObject {
+  private let statusItem: NSStatusItem
+  private let menu = NSMenu()
+  private let cli: URL?
+  private var daemon: Process?
+  private var paused = false
+  private var latest: AgentStats?
+  private var pollTimer: Timer?
+
+  // Menu items we update on every poll
+  private let statusMI = NSMenuItem(title: "Starting…", action: nil, keyEquivalent: "")
+  private let deviceMI = NSMenuItem(title: "", action: nil, keyEquivalent: "")
+  private let analyzedMI = 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")
+  private let pauseMI = NSMenuItem(title: "Pause", action: #selector(togglePaused), keyEquivalent: "p")
+
+  override init() {
+    self.cli = locateCli()
+    self.statusItem = NSStatusBar.system.statusItem(withLength: NSStatusItem.variableLength)
+    super.init()
+    configureStatusItem()
+    buildMenu()
+    startDaemon()
+    refreshStats()
+    pollTimer = Timer.scheduledTimer(withTimeInterval: 5.0, repeats: true) { [weak self] _ in
+      Task { @MainActor in self?.refreshStats() }
+    }
+  }
+
+  private func configureStatusItem() {
+    // SF Symbol falls back to a bullet on older macOS versions; the
+    // title always works so we stack title + symbol for robustness.
+    if #available(macOS 11.0, *),
+       let btn = statusItem.button,
+       let img = NSImage(systemSymbolName: "circle.hexagongrid.fill", accessibilityDescription: "modelstat")
+    {
+      img.isTemplate = true
+      btn.image = img
+    } else {
+      statusItem.button?.title = "◉"
+    }
+    statusItem.button?.toolTip = "modelstat"
+  }
+
+  private func buildMenu() {
+    statusMI.isEnabled = false
+    deviceMI.isEnabled = false
+    analyzedMI.isEnabled = false
+    for mi in [statusMI, deviceMI, analyzedMI] { menu.addItem(mi) }
+    menu.addItem(NSMenuItem.separator())
+    claimMI.target = self
+    copyClaimMI.target = self
+    jobsMI.target = self
+    pauseMI.target = self
+    menu.addItem(claimMI)
+    menu.addItem(copyClaimMI)
+    menu.addItem(jobsMI)
+    menu.addItem(pauseMI)
+    menu.addItem(NSMenuItem.separator())
+    let logsMI = NSMenuItem(title: "Open logs folder", action: #selector(openLogs), keyEquivalent: "l")
+    logsMI.target = self
+    menu.addItem(logsMI)
+    menu.addItem(NSMenuItem.separator())
+    let quitMI = NSMenuItem(title: "Quit modelstat", action: #selector(quit), keyEquivalent: "q")
+    quitMI.target = self
+    menu.addItem(quitMI)
+    statusItem.menu = menu
+  }
+
+  // ── Daemon lifecycle ─────────────────────────────────────────────
+
+  private func startDaemon() {
+    guard let cli else {
+      statusMI.title = "modelstat CLI not found"
+      return
+    }
+    let p = Process()
+    if cli.pathExtension == "mjs" {
+      p.launchPath = "/usr/bin/env"
+      p.arguments = ["node", cli.path, "start"]
+    } else {
+      p.launchPath = cli.path
+      p.arguments = ["start"]
+    }
+    // Bolt stdout/stderr onto the same log the launchd plist uses so
+    // `modelstat status` still sees the same tail.
+    let logsDir = ("~/.modelstat/logs" as NSString).expandingTildeInPath
+    try? FileManager.default.createDirectory(atPath: logsDir, withIntermediateDirectories: true)
+    let out = FileHandle(forWritingAtPath: "\(logsDir)/out.log") ?? FileHandle.standardOutput
+    let err = FileHandle(forWritingAtPath: "\(logsDir)/err.log") ?? FileHandle.standardError
+    p.standardOutput = out
+    p.standardError = err
+    p.terminationHandler = { [weak self] proc in
+      // Daemon exited — if we didn't pause it intentionally, restart
+      // after 2s so a crash is self-healing without user clicks.
+      Task { @MainActor in
+        guard let self else { return }
+        guard !self.paused else { return }
+        self.daemon = nil
+        DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) { [weak self] in
+          self?.startDaemon()
+        }
+        _ = proc
+      }
+    }
+    do {
+      try p.run()
+      daemon = p
+    } catch {
+      statusMI.title = "modelstat start failed: \(error.localizedDescription)"
+    }
+  }
+
+  private func stopDaemon() {
+    daemon?.terminate()
+    daemon = nil
+  }
+
+  // ── Polling `modelstat stats --json` ────────────────────────────
+
+  private func refreshStats() {
+    guard let cli else { return }
+    let p = Process()
+    if cli.pathExtension == "mjs" {
+      p.launchPath = "/usr/bin/env"
+      p.arguments = ["node", cli.path, "stats", "--json"]
+    } else {
+      p.launchPath = cli.path
+      p.arguments = ["stats", "--json"]
+    }
+    let pipe = Pipe()
+    p.standardOutput = pipe
+    p.standardError = Pipe()
+    do {
+      try p.run()
+    } catch {
+      return
+    }
+    // Run on a background queue so we don't block the main loop.
+    DispatchQueue.global(qos: .utility).async { [weak self] in
+      p.waitUntilExit()
+      let data = pipe.fileHandleForReading.readDataToEndOfFile()
+      let stats = try? JSONDecoder().decode(AgentStats.self, from: data)
+      DispatchQueue.main.async {
+        self?.latest = stats
+        self?.renderStats()
+      }
+    }
+  }
+
+  private func renderStats() {
+    guard let s = latest else {
+      statusMI.title = "pairing…"
+      return
+    }
+    if s.paired == false {
+      statusMI.title = "not paired — run `modelstat connect`"
+      deviceMI.title = ""
+      analyzedMI.title = ""
+      claimMI.title = "Open modelstat.ai"
+      copyClaimMI.isHidden = true
+      return
+    }
+    if s.claimed == true {
+      statusMI.title = "Claimed ✓"
+      deviceMI.title = "Synced to your account"
+      analyzedMI.title = ""
+      claimMI.title = "Open dashboard"
+      copyClaimMI.isHidden = true
+      return
+    }
+    // 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)"
+    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)"
+    } else {
+      analyzedMI.title = "no activity yet"
+    }
+    claimMI.title = "Open device page"
+    copyClaimMI.isHidden = (s.claim_url == nil || s.claim_url?.isEmpty == true)
+  }
+
+  private func fmtTokens(_ raw: String) -> String {
+    guard let n = Double(raw) else { return raw }
+    if n >= 1e9 { return String(format: "%.1fB", n / 1e9) }
+    if n >= 1e6 { return String(format: "%.1fM", n / 1e6) }
+    if n >= 1e3 { return String(format: "%.0fK", n / 1e3) }
+    return String(format: "%.0f", n)
+  }
+
+  // ── Menu actions ────────────────────────────────────────────────
+
+  @objc private func openDashboard() {
+    let url: String
+    if latest?.claimed == true {
+      url = "https://modelstat.ai/dashboard"
+    } else if let claim = latest?.claim_url, !claim.isEmpty {
+      url = claim
+    } else {
+      url = "https://modelstat.ai"
+    }
+    if let u = URL(string: url) { NSWorkspace.shared.open(u) }
+  }
+
+  @objc private func openJobs() {
+    let url: String
+    if latest?.claimed == true {
+      url = "https://modelstat.ai/dashboard/jobs"
+    } else if let claim = latest?.claim_url, !claim.isEmpty {
+      url = claim + "/jobs"
+    } else {
+      url = "https://modelstat.ai/dashboard/jobs"
+    }
+    if let u = URL(string: url) { NSWorkspace.shared.open(u) }
+  }
+
+  @objc private func copyClaimUrl() {
+    guard let claim = latest?.claim_url, !claim.isEmpty else { return }
+    let pb = NSPasteboard.general
+    pb.clearContents()
+    pb.setString(claim, forType: .string)
+  }
+
+  @objc private func togglePaused() {
+    paused.toggle()
+    if paused {
+      stopDaemon()
+      pauseMI.title = "Resume"
+      statusMI.title = "Paused"
+    } else {
+      pauseMI.title = "Pause"
+      startDaemon()
+    }
+  }
+
+  @objc private func openLogs() {
+    let path = ("~/.modelstat/logs" as NSString).expandingTildeInPath
+    NSWorkspace.shared.open(URL(fileURLWithPath: path))
+  }
+
+  @objc private func quit() {
+    stopDaemon()
+    pollTimer?.invalidate()
+    NSApp.terminate(nil)
+  }
+}
+
+// ── App bootstrap ──────────────────────────────────────────────────
+//
+// LSUIElement=true in Info.plist hides the Dock icon. Without it the
+// agent would bounce in the Dock on every boot, which is not what
+// 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.
+@MainActor
+func bootstrap() {
+  let app = NSApplication.shared
+  app.setActivationPolicy(.accessory)
+  _ = TrayController()
+  app.run()
+}
+
+// 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()

package/vendor/tray-mac/build-app.sh

@@ -0,0 +1,43 @@
+#!/usr/bin/env bash
+# Build ModelstatTray.app from the Swift package.
+#
+# Output:
+#   .build/release/modelstat-tray     (raw executable)
+#   build/ModelstatTray.app           (bundle ready to drop into /Applications)
+#
+# Usage:
+#   ./build-app.sh                    (release build, universal when running on arm64)
+#   SWIFT_ARCH=x86_64 ./build-app.sh  (cross-build for Intel)
+#
+# We deliberately DO NOT codesign here — the installer pipeline takes
+# care of that with the team's Developer ID. This script just has to
+# produce a runnable bundle; `codesign` + `create-dmg` happen in CI.
+
+set -euo pipefail
+
+HERE="$(cd "$(dirname "$0")" && pwd)"
+cd "$HERE"
+
+APP_NAME="ModelstatTray"
+BUNDLE="build/${APP_NAME}.app"
+
+# Clean prior bundle; leave the .build/ cache so incremental swift
+# compiles stay fast.
+rm -rf "$BUNDLE"
+mkdir -p "$BUNDLE/Contents/MacOS" "$BUNDLE/Contents/Resources"
+
+echo "▶ swift build -c release"
+swift build -c release
+
+cp ".build/release/modelstat-tray" "$BUNDLE/Contents/MacOS/modelstat-tray"
+chmod +x "$BUNDLE/Contents/MacOS/modelstat-tray"
+cp "Resources/Info.plist" "$BUNDLE/Contents/Info.plist"
+
+# Embedded PkgInfo file — AppKit used to be picky about this. Costs
+# four bytes to include and silences a startup warning on older macOS.
+printf "APPL????" > "$BUNDLE/Contents/PkgInfo"
+
+echo
+echo "✓ Built $BUNDLE"
+echo "  run:  open '$BUNDLE'"
+echo "  install: cp -R '$BUNDLE' /Applications/"