modelstat 0.0.19 → 0.0.21

package/dist/cli.mjs

@@ -44049,7 +44049,15 @@ async function buildForOneSession(sessionId, events, adapters2) {
   const turnSurfaces = sorted.map((e) => turnSurface(e));
   const turnEmbeddings = [];
   for (const s of turnSurfaces) {
-    turnEmbeddings.push(s.length > 0 ? await adapters2.embed(s) : []);
+    if (s.length === 0) {
+      turnEmbeddings.push([]);
+      continue;
+    }
+    try {
+      turnEmbeddings.push(await adapters2.embed(s));
+    } catch {
+      turnEmbeddings.push([]);
+    }
   }
   const boundaries = [];
   let runStart = 0;
@@ -44320,27 +44328,62 @@ var init_node2 = __esm({
 });
 
 // src/pipeline.ts
-function getAdapters() {
-  if (!adapters) {
-    const cfg = defaultOllamaConfig();
+async function probeOllama(baseUrl) {
+  try {
+    const ctrl = new AbortController();
+    const t = setTimeout(() => ctrl.abort(), 500);
+    const res = await fetch(`${baseUrl.replace(/\/+$/, "")}/api/tags`, {
+      method: "GET",
+      signal: ctrl.signal
+    });
+    clearTimeout(t);
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+function fallbackAdapters() {
+  return {
+    embed: async () => [],
+    // Throw → companion-core/summariseSlice's try/catch falls back to
+    // the `promptFacts` string which is what we want here.
+    summarize: async () => {
+      throw new Error("ollama_unavailable");
+    },
+    tokenize: (text) => Math.max(1, Math.ceil(text.length / 4))
+  };
+}
+async function getAdapters() {
+  if (adapters && probed) return adapters;
+  const cfg = defaultOllamaConfig();
+  const up = await probeOllama(cfg.baseUrl);
+  probed = true;
+  if (up) {
+    console.log(`[modelstat] ollama up at ${cfg.baseUrl} \u2014 using LLM pipeline`);
     adapters = {
       embed: ollamaEmbed(cfg),
       summarize: ollamaSummarize(cfg),
       tokenize: ollamaTokenize()
     };
+  } else {
+    console.log(
+      `[modelstat] ollama not reachable at ${cfg.baseUrl} \u2014 using fallback pipeline (server does classification)`
+    );
+    adapters = fallbackAdapters();
   }
   return adapters;
 }
 async function buildSegments(events) {
-  return buildSegmentsForSession(events, getAdapters());
+  return buildSegmentsForSession(events, await getAdapters());
 }
-var adapters;
+var adapters, probed;
 var init_pipeline2 = __esm({
   "src/pipeline.ts"() {
     "use strict";
     init_pipeline();
     init_node2();
     adapters = null;
+    probed = false;
   }
 });
 
@@ -44406,6 +44449,7 @@ async function scanAll(cb = {}) {
   let batchesUploaded = 0;
   let eventsUploaded = 0;
   let buffer = [];
+  let pendingCursors = [];
   async function flushBatch() {
     if (!buffer.length) return;
     cb.onUpload?.(buffer.length);
@@ -44420,6 +44464,8 @@ async function scanAll(cb = {}) {
     const res = await uploadBatch(batch);
     batchesUploaded += 1;
     eventsUploaded += res.accepted;
+    for (const pc of pendingCursors) state.setCursor(pc.path, pc.cs);
+    pendingCursors = [];
     buffer = [];
   }
   for (let i = 0; i < jobs.length; i++) {
@@ -44440,7 +44486,7 @@ async function scanAll(cb = {}) {
           if (buffer.length >= BATCH_MAX_EVENTS) await flushBatch();
         }
       }
-      if (cs) state.setCursor(job.path, cs);
+      if (cs) pendingCursors.push({ path: job.path, cs });
     } catch (e) {
       console.warn(`  ! parse failed for ${job.path}:`, e.message);
     }
@@ -44457,11 +44503,130 @@ var init_scan = __esm({
     init_pipeline2();
     init_config2();
     init_api();
-    AGENT_VERSION = "agent-dev-0.0.1";
+    AGENT_VERSION = "agent-dev-0.0.21";
     BATCH_MAX_EVENTS = 2e3;
   }
 });
 
+// src/lock.ts
+import {
+  closeSync,
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync2,
+  openSync,
+  readFileSync as readFileSync2,
+  renameSync,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync3,
+  writeSync
+} from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join4 } from "path";
+function isProcessAlive(pid) {
+  if (!pid || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    const code = e.code;
+    if (code === "EPERM") return true;
+    return false;
+  }
+}
+function readLock() {
+  try {
+    const raw = readFileSync2(LOCK_FILE, "utf8");
+    const obj = JSON.parse(raw);
+    if (typeof obj.pid !== "number") return null;
+    return {
+      pid: obj.pid,
+      startedAt: obj.startedAt ?? "unknown",
+      agentVersion: obj.agentVersion ?? "unknown",
+      apiUrl: obj.apiUrl ?? "unknown"
+    };
+  } catch {
+    return null;
+  }
+}
+function writeLockAtomic(meta) {
+  mkdirSync2(LOCK_DIR, { recursive: true });
+  const tmp = `${LOCK_FILE}.${meta.pid}.${Date.now()}.tmp`;
+  const fd = openSync(tmp, "wx");
+  try {
+    writeSync(fd, JSON.stringify(meta, null, 2));
+  } finally {
+    closeSync(fd);
+  }
+  renameSync(tmp, LOCK_FILE);
+}
+function removeLockIfOwned(ownerPid) {
+  const lock = readLock();
+  if (!lock) return;
+  if (lock.pid !== ownerPid) return;
+  try {
+    unlinkSync2(LOCK_FILE);
+  } catch {
+  }
+}
+function acquireDaemonLock(opts) {
+  const existing = readLock();
+  if (existing && isProcessAlive(existing.pid)) {
+    if (!opts.force) {
+      const ageSec = ageInSeconds(existing.startedAt);
+      return { kind: "already_running", owner: existing, ageSec };
+    }
+    try {
+      process.kill(existing.pid, "SIGTERM");
+    } catch {
+    }
+  }
+  const meta = {
+    pid: process.pid,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    agentVersion: opts.agentVersion,
+    apiUrl: opts.apiUrl
+  };
+  writeLockAtomic(meta);
+  const cleanup = () => removeLockIfOwned(process.pid);
+  process.once("beforeExit", cleanup);
+  process.once("SIGINT", () => {
+    cleanup();
+    process.exit(130);
+  });
+  process.once("SIGTERM", () => {
+    cleanup();
+    process.exit(143);
+  });
+  process.once("uncaughtException", (err) => {
+    cleanup();
+    console.error("modelstat daemon crashed:", err);
+    process.exit(1);
+  });
+  return { kind: "acquired" };
+}
+function ageInSeconds(iso) {
+  const t = Date.parse(iso);
+  if (Number.isNaN(t)) return -1;
+  return Math.max(0, Math.floor((Date.now() - t) / 1e3));
+}
+function formatAge(seconds) {
+  if (seconds < 0) return "?";
+  if (seconds < 60) return `${seconds}s`;
+  const m = Math.floor(seconds / 60);
+  const s = seconds % 60;
+  if (m < 60) return `${m}m ${s}s`;
+  const h = Math.floor(m / 60);
+  return `${h}h ${m % 60}m`;
+}
+var LOCK_DIR, LOCK_FILE;
+var init_lock = __esm({
+  "src/lock.ts"() {
+    "use strict";
+    LOCK_DIR = join4(homedir5(), ".modelstat");
+    LOCK_FILE = join4(LOCK_DIR, "daemon.lock");
+  }
+});
+
 // ../../node_modules/.pnpm/readdirp@4.1.2/node_modules/readdirp/esm/index.js
 import { stat as stat3, lstat, readdir as readdir2, realpath } from "fs/promises";
 import { Readable as Readable2 } from "stream";
@@ -46188,7 +46353,7 @@ __export(daemon_exports, {
   setProgress: () => setProgress,
   setQueue: () => setQueue
 });
-import { existsSync as existsSync5, statSync as statSync2 } from "fs";
+import { existsSync as existsSync6, statSync as statSync2 } from "fs";
 function setPhase(phase, message) {
   status.phase = phase;
   status.message = message ?? null;
@@ -46280,10 +46445,29 @@ async function runScanCycle(reason) {
 function basename3(p) {
   return p.split("/").pop() ?? p;
 }
-async function runDaemon() {
+async function runDaemon(opts = {}) {
   if (!state.bearer || !state.deviceId) {
     throw new Error("not enrolled \u2014 run `modelstat connect` first");
   }
+  const lock = acquireDaemonLock({
+    agentVersion: AGENT_VERSION2,
+    apiUrl: state.apiUrl,
+    force: opts.force === true
+  });
+  if (lock.kind === "already_running") {
+    console.log(
+      `modelstat daemon is already running \u2014 PID ${lock.owner.pid}, started ${formatAge(
+        lock.ageSec
+      )} ago, agent ${lock.owner.agentVersion}.`
+    );
+    console.log(
+      "  \u2192 to stop it:          kill " + lock.owner.pid
+    );
+    console.log(
+      "  \u2192 to force-replace it: modelstat start --force"
+    );
+    return;
+  }
   setPhase("starting", "Booting");
   const hb = setInterval(() => void sendHeartbeat(), HEARTBEAT_INTERVAL_MS);
   hb.unref();
@@ -46291,21 +46475,21 @@ async function runDaemon() {
   await runDiscovery();
   await runScanCycle("startup");
   const chokidar = (await Promise.resolve().then(() => (init_esm2(), esm_exports))).default;
-  const { homedir: homedir6, platform: platform5 } = await import("os");
-  const { join: join7 } = await import("path");
-  const home2 = homedir6();
+  const { homedir: homedir7, platform: platform5 } = await import("os");
+  const { join: join8 } = await import("path");
+  const home2 = homedir7();
   const dirs = [
-    join7(home2, ".claude/projects"),
-    join7(home2, ".codex/sessions"),
-    join7(home2, ".cursor/ai-tracking"),
-    join7(home2, ".gemini"),
+    join8(home2, ".claude/projects"),
+    join8(home2, ".codex/sessions"),
+    join8(home2, ".cursor/ai-tracking"),
+    join8(home2, ".gemini"),
     ...platform5() === "darwin" ? [
-      join7(home2, "Library/Application Support/Cursor/User/workspaceStorage"),
-      join7(home2, "Library/Application Support/Claude")
+      join8(home2, "Library/Application Support/Cursor/User/workspaceStorage"),
+      join8(home2, "Library/Application Support/Claude")
     ] : [
-      join7(home2, ".config/Cursor/User/workspaceStorage")
+      join8(home2, ".config/Cursor/User/workspaceStorage")
     ]
-  ].filter((p) => existsSync5(p) && statSync2(p).isDirectory());
+  ].filter((p) => existsSync6(p) && statSync2(p).isDirectory());
   setPhase("watching", `Watching ${dirs.length} directories`);
   const watcher = chokidar.watch(dirs, {
     persistent: true,
@@ -46350,8 +46534,9 @@ var init_daemon = __esm({
     init_src2();
     init_api();
     init_config2();
+    init_lock();
     init_scan();
-    AGENT_VERSION2 = "agent-dev-0.0.19";
+    AGENT_VERSION2 = "agent-dev-0.0.21";
     HEARTBEAT_INTERVAL_MS = 1e4;
     SCAN_INTERVAL_MS = 5 * 60 * 1e3;
     status = {
@@ -46371,37 +46556,37 @@ var watch_exports = {};
 __export(watch_exports, {
   watchForever: () => watchForever
 });
-import { existsSync as existsSync6 } from "fs";
-import { homedir as homedir5, platform as platform3 } from "os";
-import { join as join6 } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { homedir as homedir6, platform as platform3 } from "os";
+import { join as join7 } from "path";
 function resolveWatchDirs() {
-  const home2 = homedir5();
-  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join6(home2, ".config");
-  const xdgData = process.env.XDG_DATA_HOME ?? join6(home2, ".local/share");
+  const home2 = homedir6();
+  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join7(home2, ".config");
+  const xdgData = process.env.XDG_DATA_HOME ?? join7(home2, ".local/share");
   const candidates = [
     // universal (default HOME-rooted CLI data dirs)
-    join6(home2, ".claude/projects"),
-    join6(home2, ".codex/sessions"),
-    join6(home2, ".cursor/ai-tracking"),
-    join6(home2, ".gemini"),
-    join6(home2, ".aider"),
+    join7(home2, ".claude/projects"),
+    join7(home2, ".codex/sessions"),
+    join7(home2, ".cursor/ai-tracking"),
+    join7(home2, ".gemini"),
+    join7(home2, ".aider"),
     // XDG / Linux
-    join6(xdgConfig, "claude/projects"),
-    join6(xdgConfig, "codex/sessions"),
-    join6(xdgConfig, "Cursor/User/workspaceStorage"),
-    join6(xdgConfig, "Code/User/workspaceStorage"),
-    join6(xdgConfig, "Code - Insiders/User/workspaceStorage"),
-    join6(xdgData, "claude/projects"),
+    join7(xdgConfig, "claude/projects"),
+    join7(xdgConfig, "codex/sessions"),
+    join7(xdgConfig, "Cursor/User/workspaceStorage"),
+    join7(xdgConfig, "Code/User/workspaceStorage"),
+    join7(xdgConfig, "Code - Insiders/User/workspaceStorage"),
+    join7(xdgData, "claude/projects"),
     // macOS
     ...platform3() === "darwin" ? [
-      join6(home2, "Library/Application Support/Cursor/User/workspaceStorage"),
-      join6(home2, "Library/Application Support/Claude"),
-      join6(home2, "Library/Application Support/Code/User/workspaceStorage"),
-      join6(home2, "Library/Application Support/Windsurf/User/workspaceStorage"),
-      join6(home2, "Library/Application Support/Zed")
+      join7(home2, "Library/Application Support/Cursor/User/workspaceStorage"),
+      join7(home2, "Library/Application Support/Claude"),
+      join7(home2, "Library/Application Support/Code/User/workspaceStorage"),
+      join7(home2, "Library/Application Support/Windsurf/User/workspaceStorage"),
+      join7(home2, "Library/Application Support/Zed")
     ] : []
   ];
-  return Array.from(new Set(candidates)).filter((p) => existsSync6(p));
+  return Array.from(new Set(candidates)).filter((p) => existsSync7(p));
 }
 async function safeScan(reason) {
   if (scanning) {
@@ -47017,13 +47202,14 @@ async function cmdWatch() {
   const { watchForever: watchForever2 } = await Promise.resolve().then(() => (init_watch(), watch_exports));
   await watchForever2();
 }
-async function cmdStart() {
+async function cmdStart(rest) {
   if (!state.bearer || !state.deviceId) {
     console.error("not paired yet. Run `modelstat connect` first.");
     process.exit(1);
   }
+  const force = rest.includes("--force") || rest.includes("-f");
   const { runDaemon: runDaemon2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
-  await runDaemon2();
+  await runDaemon2({ force });
 }
 async function cmdStop() {
   try {
@@ -47187,7 +47373,7 @@ async function main() {
     case "start":
       if (!state.bearer || !state.deviceId)
         return cmdConnect(parseConnectOpts(rest));
-      return cmdStart();
+      return cmdStart(rest);
     case "connect":
       return cmdConnect(parseConnectOpts(rest));
     case "self-register":