modelstat 0.0.26 → 0.0.28

package/package.json

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

package/scripts/postinstall.mjs

@@ -26,6 +26,7 @@
  */
 
 import { existsSync } from "node:fs";
+import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -97,7 +98,7 @@ async function main() {
   try {
     await ensureLlamaModel(defaultLlamaConfig());
     console.log("");
-    console.log("[modelstat] ✓ summariser ready — run `modelstat connect` next");
+    console.log("[modelstat] ✓ summariser ready");
   } catch (err) {
     // Don't fail the npm install. The model will retry-download on
     // first scan; better to leave the user with a working binary
@@ -109,6 +110,95 @@ 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",
+  );
+}
+
+async function rebootServiceIfInstalled() {
+  const stateDir = join(homedir(), ".modelstat");
+  const installedBundle = join(stateDir, "bin", "modelstat.mjs");
+  const launchdPlist = join(
+    homedir(),
+    "Library",
+    "LaunchAgents",
+    "ai.modelstat.agent.plist",
+  );
+  const systemdUnit = join(
+    process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"),
+    "systemd",
+    "user",
+    "modelstat.service",
+  );
+  const hasService = existsSync(launchdPlist) || existsSync(systemdUnit);
+  if (!hasService) {
+    console.log(
+      "[modelstat] no background service installed — run `modelstat connect` to set one up",
+    );
+    return;
+  }
+
+  // Locate the freshly-installed bundle in this package. From
+  // scripts/postinstall.mjs → ../dist/cli.mjs.
+  const here = dirname(fileURLToPath(import.meta.url));
+  const freshBundle = join(here, "..", "dist", "cli.mjs");
+  if (!existsSync(freshBundle)) {
+    console.warn(
+      "[modelstat] couldn't find new bundle — service refresh skipped",
+    );
+    return;
+  }
+
+  // Spawn the FRESH bundle to do the actual restart through its own
+  // service.ts — that's the same code that knows how to talk to
+  // launchd / systemd on each platform. We can't import service.ts
+  // directly here (postinstall is a plain .mjs without TS resolution),
+  // but spawning the new bundle gives us the new behaviour.
+  const { spawnSync } = await import("node:child_process");
+  console.log("[modelstat] refreshing background service…");
+
+  // Stop first — best effort, ignore failures.
+  spawnSync(process.execPath, [freshBundle, "stop"], {
+    stdio: "ignore",
+    timeout: 30_000,
+  });
+
+  // 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) {
+    console.warn(
+      `[modelstat] couldn't refresh installed bundle: ${err && err.message ? err.message : err}`,
+    );
+  }
+
+  // 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
+  // immediately. Detached so the daemon survives this script.
+  const { spawn } = await import("node:child_process");
+  const child = spawn(process.execPath, [freshBundle, "start"], {
+    detached: true,
+    stdio: "ignore",
+  });
+  child.unref();
+  console.log("[modelstat] ✓ background service restarted with new build");
 }
 
 main().catch((err) => {