@worca/ui 0.12.0 → 0.13.0

package/server/ws-status-watcher.js

@@ -1,32 +1,64 @@
 /**
- * Status file watcher — monitors status.json and active_run for changes.
- * Owns refresh scheduling, lastPipelineStatus tracking, and the status/activeRun FSWatchers.
+ * Status file watcher — monitors status.json and runs/ directory for changes.
+ * Owns refresh scheduling, lastPipelineStatus tracking, and the status/runsDirWatcher FSWatchers.
  */
 
-import { existsSync, readFileSync, watch } from 'node:fs';
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  watch,
+} from 'node:fs';
 import { join } from 'node:path';
 import { readSettings } from './settings-reader.js';
 import { discoverRunsAsync } from './watcher.js';
 
 const REFRESH_DEBOUNCE_MS = 75;
+const WORKTREE_WATCHER_THRESHOLD = 50;
+const WORKTREE_POLL_MS = 30_000;
+// Display-layer: broadest set — any status that means "stop watching this run".
+// Differs from runner/resume (which exclude 'failed' to keep it resumable) and
+// cleanup ({completed, failed}). Here we add 'error' so the UI also stops polling
+// pipelines that crashed before reaching a clean terminal state.
+const TERMINAL_STATUSES = new Set([
+  'completed',
+  'failed',
+  'error',
+  'interrupted',
+]);
 
 /**
- * Resolve the active run directory for a given worca base dir.
- * Returns `<worcaDir>/runs/<runId>` as long as runId is non-empty,
- * without gating on the existence of status.json.
+ * Resolve the latest active run directory for a given worca base dir.
+ * Scans runs/<runId>/pipeline.pid for live processes via process.kill(pid, 0).
+ * Returns the run dir of the latest live run (by run ID), or worcaDir as fallback.
  *
  * @param {string} worcaDir
  * @returns {string}
  */
-export function resolveActiveRunDir(worcaDir) {
-  const activeRunPath = join(worcaDir, 'active_run');
-  if (existsSync(activeRunPath)) {
+export function resolveLatestRunDir(worcaDir) {
+  const runsDir = join(worcaDir, 'runs');
+  if (existsSync(runsDir)) {
+    let latest = null;
     try {
-      const runId = readFileSync(activeRunPath, 'utf8').trim();
-      if (runId) return join(worcaDir, 'runs', runId);
+      for (const entry of readdirSync(runsDir, { withFileTypes: true })) {
+        if (!entry.isDirectory()) continue;
+        const pidPath = join(runsDir, entry.name, 'pipeline.pid');
+        if (!existsSync(pidPath)) continue;
+        try {
+          const pid = parseInt(readFileSync(pidPath, 'utf8').trim(), 10);
+          if (!Number.isNaN(pid) && pid > 0) {
+            process.kill(pid, 0); // throws if dead
+            if (!latest || entry.name > latest) latest = entry.name;
+          }
+        } catch {
+          /* dead process or invalid PID */
+        }
+      }
     } catch {
       /* ignore */
     }
+    if (latest) return join(runsDir, latest);
   }
   return worcaDir; // legacy fallback
 }
@@ -57,14 +89,118 @@ export function createStatusWatcher({
   let watchedRunDir = null;
   let activeRunWatcher = null;
   let runsDirWatcher = null;
+  let pipelinesDirWatcher = null;
+  const worktreeRunWatchers = new Map(); // Map<run_id, FSWatcher>
+  let worktreePollingInterval = null;
 
   function currentActiveRunId() {
     if (!watchedRunDir) return null;
     return watchedRunDir.split('/').pop() || null;
   }
 
-  function _resolveActiveRunDir() {
-    return resolveActiveRunDir(worcaDir);
+  function _resolveLatestRunDir() {
+    return resolveLatestRunDir(worcaDir);
+  }
+
+  function reconcileWorktreeWatchers() {
+    const pipelinesDirPath = join(worcaDir, 'multi', 'pipelines.d');
+    if (!existsSync(pipelinesDirPath)) {
+      for (const w of worktreeRunWatchers.values()) {
+        try {
+          w.close();
+        } catch {
+          /* ignore */
+        }
+      }
+      worktreeRunWatchers.clear();
+      if (worktreePollingInterval) {
+        clearInterval(worktreePollingInterval);
+        worktreePollingInterval = null;
+      }
+      return;
+    }
+
+    // Read all non-terminal entries from pipelines.d/
+    const activeEntries = new Map(); // run_id -> reg
+    try {
+      for (const entry of readdirSync(pipelinesDirPath)) {
+        if (!entry.endsWith('.json')) continue;
+        try {
+          const reg = JSON.parse(
+            readFileSync(join(pipelinesDirPath, entry), 'utf8'),
+          );
+          if (
+            reg.run_id &&
+            reg.worktree_path &&
+            !TERMINAL_STATUSES.has(reg.status)
+          ) {
+            activeEntries.set(reg.run_id, reg);
+          }
+        } catch {
+          /* ignore malformed */
+        }
+      }
+    } catch {
+      /* ignore */
+    }
+
+    // >50 concurrent worktrees: fall back to periodic polling
+    if (activeEntries.size > WORKTREE_WATCHER_THRESHOLD) {
+      for (const w of worktreeRunWatchers.values()) {
+        try {
+          w.close();
+        } catch {
+          /* ignore */
+        }
+      }
+      worktreeRunWatchers.clear();
+      if (!worktreePollingInterval) {
+        worktreePollingInterval = setInterval(
+          () => scheduleRefresh(),
+          WORKTREE_POLL_MS,
+        );
+      }
+      return;
+    }
+
+    // Below threshold: stop polling if it was running
+    if (worktreePollingInterval) {
+      clearInterval(worktreePollingInterval);
+      worktreePollingInterval = null;
+    }
+
+    // Remove watchers for entries no longer active
+    for (const [runId, w] of worktreeRunWatchers) {
+      if (!activeEntries.has(runId)) {
+        try {
+          w.close();
+        } catch {
+          /* ignore */
+        }
+        worktreeRunWatchers.delete(runId);
+      }
+    }
+
+    // Add watchers for new active entries
+    for (const [runId, reg] of activeEntries) {
+      if (worktreeRunWatchers.has(runId)) continue;
+      const wtRunsDir = join(reg.worktree_path, '.worca', 'runs');
+      if (!existsSync(wtRunsDir)) continue;
+      try {
+        const w = watch(
+          wtRunsDir,
+          { recursive: true },
+          (_eventType, filename) => {
+            if (!filename || filename.endsWith('status.json')) {
+              scheduleRefresh();
+            }
+          },
+        );
+        worktreeRunWatchers.set(runId, w);
+      } catch {
+        /* ignore */
+      }
+    }
   }
 
   function scheduleRefresh() {
@@ -79,6 +215,7 @@ export function createStatusWatcher({
       }
       try {
         const runs = await discoverRunsAsync(worcaDir);
+        reconcileWorktreeWatchers();
         const subscribedIds = new Set();
         for (const ws of wss.clients) {
           const s = getSubs(ws);
@@ -128,7 +265,7 @@ export function createStatusWatcher({
       statusWatcher.close();
       statusWatcher = null;
     }
-    const runDir = _resolveActiveRunDir();
+    const runDir = _resolveLatestRunDir();
     if (watchedRunDir !== null && runDir !== watchedRunDir) {
       if (onActiveRunChange) onActiveRunChange();
     }
@@ -181,7 +318,7 @@ export function createStatusWatcher({
           );
         } else {
           setTimeout(() => {
-            if (_resolveActiveRunDir() === runDir) tryWatch();
+            if (_resolveLatestRunDir() === runDir) tryWatch();
           }, 500);
         }
       } catch {
@@ -195,19 +332,15 @@ export function createStatusWatcher({
   // Initialize status watcher
   setupStatusWatcher();
 
-  // Watch worcaDir for active_run pointer changes
+  // Watch worcaDir for legacy status.json changes
   try {
     if (existsSync(worcaDir)) {
       activeRunWatcher = watch(
         worcaDir,
         { recursive: false },
         (_eventType, filename) => {
-          if (
-            !filename ||
-            filename === 'active_run' ||
-            filename === 'status.json'
-          ) {
-            const newRunDir = _resolveActiveRunDir();
+          if (!filename || filename === 'status.json') {
+            const newRunDir = _resolveLatestRunDir();
             if (newRunDir !== watchedRunDir) {
               setupStatusWatcher();
             }
@@ -238,6 +371,24 @@ export function createStatusWatcher({
     /* ignore */
   }
 
+  // Watch .worca/multi/pipelines.d/ for pipeline additions/removals.
+  // Create the directory eagerly so the watcher fires even on first worktree run.
+  const pipelinesDirPath = join(worcaDir, 'multi', 'pipelines.d');
+  try {
+    mkdirSync(pipelinesDirPath, { recursive: true });
+    pipelinesDirWatcher = watch(
+      pipelinesDirPath,
+      { recursive: false },
+      (_eventType, filename) => {
+        if (!filename || filename.endsWith('.json')) {
+          scheduleRefresh();
+        }
+      },
+    );
+  } catch {
+    /* ignore */
+  }
+
   function getWatchedRunDir() {
     return watchedRunDir;
   }
@@ -246,12 +397,25 @@ export function createStatusWatcher({
     if (statusWatcher) statusWatcher.close();
     if (activeRunWatcher) activeRunWatcher.close();
     if (runsDirWatcher) runsDirWatcher.close();
+    if (pipelinesDirWatcher) pipelinesDirWatcher.close();
+    for (const w of worktreeRunWatchers.values()) {
+      try {
+        w.close();
+      } catch {
+        /* ignore */
+      }
+    }
+    worktreeRunWatchers.clear();
+    if (worktreePollingInterval) {
+      clearInterval(worktreePollingInterval);
+      worktreePollingInterval = null;
+    }
   }
 
   return {
     scheduleRefresh,
     currentActiveRunId,
-    resolveActiveRunDir: _resolveActiveRunDir,
+    resolveLatestRunDir: _resolveLatestRunDir,
     getWatchedRunDir,
     lastPipelineStatus,
     destroy,

package/server/ws.js

@@ -2,4 +2,4 @@
  * WebSocket server entry point.
  */
 
-export { attachWsServer, resolveActiveRunDir } from './ws-modular.js';
+export { attachWsServer, resolveLatestRunDir } from './ws-modular.js';

package/server/multi-watcher.js

@@ -1,237 +0,0 @@
-/**
- * MultiWatcher — watches .worca/multi/pipelines.d/ for a project,
- * tracking parallel pipeline instances and their status changes.
- *
- * Each pipeline in pipelines.d/{run_id}.json is monitored. On status
- * changes, broadcasts 'pipeline-status-changed' events. Optionally
- * creates per-worktree WatcherSets for log/status streaming.
- */
-
-import { existsSync, watch } from 'node:fs';
-import { readdir, readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { TIER_FULL, TIER_POLLING, WatcherSet } from './watcher-set.js';
-
-export class MultiWatcher {
-  /**
-   * @param {string} projectId — parent project name
-   * @param {string} worcaDir — parent project's .worca/ directory
-   * @param {{ broadcaster, getSubs, wss, settingsPath, projectRoot, webhookInbox }} deps
-   */
-  constructor(projectId, worcaDir, deps) {
-    this.projectId = projectId;
-    this.worcaDir = worcaDir;
-    this._deps = deps;
-    this._dirWatcher = null;
-    this._debounceTimer = null;
-    this._closed = false;
-
-    /** @type {Map<string, { entry: object, watcherSet: WatcherSet|null }>} */
-    this.pipelines = new Map();
-  }
-
-  /** Start watching pipelines.d/ directory. */
-  start() {
-    this._syncPipelines(); // Initial scan
-
-    const pipelinesDir = join(this.worcaDir, 'multi', 'pipelines.d');
-    if (existsSync(pipelinesDir)) {
-      try {
-        this._dirWatcher = watch(pipelinesDir, { persistent: false }, () => {
-          if (this._closed) return;
-          if (this._debounceTimer) clearTimeout(this._debounceTimer);
-          this._debounceTimer = setTimeout(() => {
-            this._debounceTimer = null;
-            if (!this._closed) this._syncPipelines();
-          }, 300);
-        });
-      } catch {
-        // fs.watch not supported or dir doesn't exist — skip
-      }
-    }
-  }
-
-  /** Scan pipelines.d/, diff against current map, broadcast changes. */
-  async _syncPipelines() {
-    const pipelinesDir = join(this.worcaDir, 'multi', 'pipelines.d');
-    const freshEntries = new Map();
-
-    try {
-      const files = await readdir(pipelinesDir);
-      const readPromises = files
-        .filter((f) => f.endsWith('.json'))
-        .map(async (fname) => {
-          try {
-            const entry = JSON.parse(
-              await readFile(join(pipelinesDir, fname), 'utf8'),
-            );
-            return entry.run_id ? [entry.run_id, entry] : null;
-          } catch {
-            return null;
-          }
-        });
-      for (const result of await Promise.all(readPromises)) {
-        if (result) freshEntries.set(result[0], result[1]);
-      }
-    } catch {
-      // directory doesn't exist or unreadable — freshEntries stays empty
-    }
-
-    // Add new pipelines or update changed ones
-    for (const [runId, entry] of freshEntries) {
-      const existing = this.pipelines.get(runId);
-      if (!existing) {
-        this._addPipeline(runId, entry);
-      } else if (
-        existing.entry.status !== entry.status ||
-        existing.entry.stage !== entry.stage
-      ) {
-        // Destroy WatcherSet when pipeline transitions out of running
-        if (
-          existing.entry.status === 'running' &&
-          entry.status !== 'running' &&
-          existing.watcherSet
-        ) {
-          try {
-            existing.watcherSet.destroy();
-          } catch {
-            /* ignore */
-          }
-          existing.watcherSet = null;
-        }
-        existing.entry = entry;
-        this._broadcastPipelineStatus(runId, entry);
-      }
-    }
-
-    // Remove deleted pipelines
-    for (const runId of [...this.pipelines.keys()]) {
-      if (!freshEntries.has(runId)) {
-        this._removePipeline(runId);
-      }
-    }
-  }
-
-  /** Register a new pipeline and broadcast its status. */
-  _addPipeline(runId, entry) {
-    let watcherSet = null;
-
-    // Create a WatcherSet for running worktree pipelines
-    if (entry.worktree_path && entry.status === 'running') {
-      const worktreeWorcaDir = join(entry.worktree_path, '.worca');
-      if (existsSync(worktreeWorcaDir)) {
-        try {
-          const pipelineProjectId = `${this.projectId}::${runId}`;
-          watcherSet = new WatcherSet(
-            pipelineProjectId,
-            worktreeWorcaDir,
-            {
-              ...this._deps,
-              settingsPath: join(
-                entry.worktree_path,
-                '.claude',
-                'settings.json',
-              ),
-              projectRoot: entry.worktree_path,
-            },
-            // Skip creating a nested MultiWatcher in pipeline WatcherSets
-            { _skipMultiWatcher: true },
-          );
-          watcherSet.create();
-          // Start in POLLING tier — promoted when user subscribes
-        } catch (err) {
-          console.error(
-            `[MultiWatcher:${this.projectId}] Failed to create WatcherSet for pipeline ${runId}:`,
-            err.message,
-          );
-          watcherSet = null;
-        }
-      }
-    }
-
-    this.pipelines.set(runId, { entry, watcherSet });
-    this._broadcastPipelineStatus(runId, entry);
-  }
-
-  /** Destroy a pipeline's WatcherSet and broadcast removal. */
-  _removePipeline(runId) {
-    const pipeline = this.pipelines.get(runId);
-    if (pipeline?.watcherSet) {
-      try {
-        pipeline.watcherSet.destroy();
-      } catch {
-        // ignore cleanup errors
-      }
-    }
-    this.pipelines.delete(runId);
-    this._deps.broadcaster.broadcast('pipeline-status-changed', {
-      project: this.projectId,
-      runId,
-      status: 'removed',
-    });
-  }
-
-  /** Broadcast a pipeline status change event. */
-  _broadcastPipelineStatus(runId, entry) {
-    this._deps.broadcaster.broadcast('pipeline-status-changed', {
-      project: this.projectId,
-      runId,
-      status: entry.status,
-      stage: entry.stage || null,
-      title: entry.title || null,
-      worktree_path: entry.worktree_path || null,
-      started_at: entry.started_at || null,
-      pid: entry.pid || null,
-    });
-  }
-
-  /** List current pipeline entries (for list-pipelines WS request). */
-  listPipelines() {
-    return Array.from(this.pipelines.values()).map((p) => p.entry);
-  }
-
-  /** Get WatcherSet for a specific pipeline (for log/status streaming). */
-  getPipelineWatcherSet(runId) {
-    return this.pipelines.get(runId)?.watcherSet || null;
-  }
-
-  /** Promote a pipeline's watcher to FULL tier (on user subscribe). */
-  promotePipeline(runId) {
-    const ws = this.pipelines.get(runId)?.watcherSet;
-    if (ws && ws.getTier() === TIER_POLLING) ws.setTier(TIER_FULL);
-  }
-
-  /** Demote a pipeline's watcher back to POLLING tier (on user unsubscribe). */
-  demotePipeline(runId) {
-    const ws = this.pipelines.get(runId)?.watcherSet;
-    if (ws && ws.getTier() === TIER_FULL) ws.setTier(TIER_POLLING);
-  }
-
-  /** Destroy all pipeline watchers and close directory watcher. Idempotent. */
-  destroy() {
-    if (this._closed) return;
-    this._closed = true;
-    if (this._dirWatcher) {
-      try {
-        this._dirWatcher.close();
-      } catch {
-        // ignore
-      }
-      this._dirWatcher = null;
-    }
-    if (this._debounceTimer) {
-      clearTimeout(this._debounceTimer);
-      this._debounceTimer = null;
-    }
-    for (const { watcherSet } of this.pipelines.values()) {
-      if (watcherSet) {
-        try {
-          watcherSet.destroy();
-        } catch {
-          // ignore cleanup errors
-        }
-      }
-    }
-    this.pipelines.clear();
-  }
-}