@worca/ui 0.29.0 → 0.31.0

package/server/ws-beads-watcher.js

@@ -4,22 +4,36 @@
  * because fs.watch on macOS misses SQLite WAL writes done via mmap.
  */
 
-import { existsSync, unwatchFile, watch, watchFile } from 'node:fs';
+import { existsSync, statSync, unwatchFile, watch, watchFile } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { countIssuesByRunLabel, listIssues } from './beads-reader.js';
 
 const BEADS_DEBOUNCE_MS = 500;
 const BEADS_POLL_MS = 2000;
 
+/**
+ * Resolve the beads.db path for a project's worcaDir, independent of any
+ * watcher instance. Used by tier-independent count lookups (chat-only mode,
+ * where no beadsWatcher exists because the WatcherSet is in TIER_POLLING).
+ * @param {string} worcaDir
+ * @returns {string}
+ */
+export function beadsDbPathFor(worcaDir) {
+  return resolve(join(worcaDir, '..', '.beads', 'beads.db'));
+}
+
 /**
  * @param {{ worcaDir: string, broadcaster: { broadcast: Function }, projectId?: string }} deps
  */
 export function createBeadsWatcher({ worcaDir, broadcaster, projectId }) {
-  const beadsDbPath = resolve(join(worcaDir, '..', '.beads', 'beads.db'));
+  const beadsDbPath = beadsDbPathFor(worcaDir);
   const beadsDir = resolve(join(worcaDir, '..', '.beads'));
   const beadsWalPath = `${beadsDbPath}-wal`;
   let fsWatcher = null;
   let BEADS_REFRESH_TIMER = null;
+  let lastPayloadJson = null;
+  let lastSelfReadWalStat = null;
+  let latestCounts = {};
 
   function scheduleBeadsRefresh() {
     if (BEADS_REFRESH_TIMER) clearTimeout(BEADS_REFRESH_TIMER);
@@ -30,6 +44,10 @@ export function createBeadsWatcher({ worcaDir, broadcaster, projectId }) {
           listIssues(beadsDbPath),
           countIssuesByRunLabel(beadsDbPath).catch(() => ({})),
         ]);
+        latestCounts = counts;
+        const payloadJson = JSON.stringify({ issues, counts });
+        if (payloadJson === lastPayloadJson) return;
+        lastPayloadJson = payloadJson;
         broadcaster.broadcast(
           'beads-update',
           {
@@ -40,6 +58,12 @@ export function createBeadsWatcher({ worcaDir, broadcaster, projectId }) {
           },
           projectId,
         );
+        try {
+          const s = statSync(beadsWalPath);
+          lastSelfReadWalStat = { mtimeMs: s.mtimeMs, size: s.size };
+        } catch {
+          lastSelfReadWalStat = null;
+        }
       } catch {
         /* ignore */
       }
@@ -60,6 +84,13 @@ export function createBeadsWatcher({ worcaDir, broadcaster, projectId }) {
     // on macOS. watchFile tolerates a missing file; it starts firing once created.
     watchFile(beadsWalPath, { interval: BEADS_POLL_MS }, (curr, prev) => {
       if (curr.mtimeMs !== prev.mtimeMs || curr.size !== prev.size) {
+        if (
+          lastSelfReadWalStat &&
+          curr.mtimeMs === lastSelfReadWalStat.mtimeMs &&
+          curr.size === lastSelfReadWalStat.size
+        ) {
+          return;
+        }
         scheduleBeadsRefresh();
       }
     });
@@ -78,5 +109,57 @@ export function createBeadsWatcher({ worcaDir, broadcaster, projectId }) {
     }
   }
 
-  return { getBeadsDbPath, destroy };
+  function getLatestCounts() {
+    return latestCounts;
+  }
+
+  return { getBeadsDbPath, getLatestCounts, destroy };
+}
+
+const FALLBACK_TTL_MS = 5000;
+/** @type {Map<string, { ts: number, counts: object }>} */
+const fallbackCache = new Map();
+/** @type {Map<string, Promise<object>>} */
+const fallbackInflight = new Map();
+
+/**
+ * Resolve per-run bead counts for a WatcherSet, independent of its tier.
+ *
+ * Fast path: the live watcher cache, populated only while a UI client is
+ * subscribed (TIER_FULL). Fallback: an on-demand DB read for callers that
+ * have no active watcher — e.g. chat integrations hitting REST with no
+ * browser open, where the WatcherSet sits in TIER_POLLING and `beadsWatcher`
+ * is null. The fallback is TTL-cached and in-flight-deduplicated so repeated
+ * chat polling does not spawn a `bd` subprocess per request.
+ *
+ * @param {{ projectId?: string, worcaDir?: string, beadsWatcher?: { getLatestCounts: () => object } | null }} [wset]
+ * @returns {Promise<Record<string, { total: number, done: number }>>}
+ */
+export async function resolveBeadsCounts(wset) {
+  if (!wset || !wset.worcaDir) return {};
+
+  const live = wset.beadsWatcher?.getLatestCounts();
+  if (live && Object.keys(live).length > 0) return live;
+
+  const key = wset.projectId ?? wset.worcaDir;
+  const cached = fallbackCache.get(key);
+  if (cached && Date.now() - cached.ts < FALLBACK_TTL_MS) return cached.counts;
+  if (fallbackInflight.has(key)) return fallbackInflight.get(key);
+
+  const dbPath = beadsDbPathFor(wset.worcaDir);
+  if (!existsSync(dbPath)) return {};
+
+  const promise = (async () => {
+    try {
+      const counts = await countIssuesByRunLabel(dbPath);
+      fallbackCache.set(key, { ts: Date.now(), counts });
+      return counts;
+    } catch {
+      return {};
+    } finally {
+      fallbackInflight.delete(key);
+    }
+  })();
+  fallbackInflight.set(key, promise);
+  return promise;
 }

package/server/ws-message-router.js

@@ -11,7 +11,6 @@ import { join } from 'node:path';
 import { isRequest, makeError, makeOk } from '../app/protocol.js';
 import {
   dbExists as beadsDbExists,
-  countIssuesByRunLabel,
   getIssue,
   listDistinctRunLabels,
   listIssues,
@@ -35,6 +34,7 @@ import {
 import { resolveRunDir } from './run-dir-resolver.js';
 import { readSettings } from './settings-reader.js';
 import { discoverRuns } from './watcher.js';
+import { resolveBeadsCounts } from './ws-beads-watcher.js';
 
 /**
  * @param {{
@@ -643,19 +643,12 @@ export function createMessageRouter({
       return;
     }
 
-    // list-beads-counts
+    // list-beads-counts — tier-independent: resolveBeadsCounts falls back to
+    // an on-demand DB read when no beadsWatcher exists (TIER_POLLING), so
+    // chat/REST callers with no browser open still get counts.
     if (req.type === 'list-beads-counts') {
       const proj = resolveProject(ws, req.payload);
-      if (!proj.wset.beadsWatcher) {
-        ws.send(JSON.stringify(makeOk(req, { counts: {} })));
-        return;
-      }
-      const beadsDbPath = proj.wset.beadsWatcher.getBeadsDbPath();
-      if (!beadsDbExists(beadsDbPath)) {
-        ws.send(JSON.stringify(makeOk(req, { counts: {} })));
-        return;
-      }
-      const counts = await countIssuesByRunLabel(beadsDbPath);
+      const counts = await resolveBeadsCounts(proj.wset);
       ws.send(JSON.stringify(makeOk(req, { counts })));
       return;
     }

package/server/ws-modular.js

@@ -13,6 +13,7 @@ import { fleetRunsDir, workspaceRunsDir } from './paths.js';
 import { readProjects, synthesizeDefaultProject } from './project-registry.js';
 import { TIER_FULL, TIER_POLLING, WatcherSet } from './watcher-set.js';
 import { readProjectWorcaVersion } from './worca-setup.js';
+import { resolveBeadsCounts } from './ws-beads-watcher.js';
 import { createBroadcaster } from './ws-broadcaster.js';
 import { createClientManager } from './ws-client-manager.js';
 import { createFleetManifestWatcher } from './ws-fleet-manifest-watcher.js';
@@ -330,10 +331,15 @@ export function attachWsServer(httpServer, config) {
     return null;
   }
 
+  function getBeadsCounts(projectId) {
+    return resolveBeadsCounts(watcherSets.get(projectId));
+  }
+
   return {
     wss,
     broadcast: broadcaster.broadcast,
     scheduleRefresh,
     resolveRunProject,
+    getBeadsCounts,
   };
 }