@worca/ui 0.22.0 → 0.24.0

package/server/worktree-ops.js

@@ -59,7 +59,18 @@ export async function removeWorktree(
         /* ignore */
       }
       if (isRealDir) {
-        await rm(worktreePath, { recursive: true, force: true });
+        // maxRetries handles transient ENOTEMPTY/EBUSY/EPERM on macOS when a
+        // background process (Spotlight, language servers, npm install
+        // finishing) touches a deep node_modules subtree between the
+        // recursive walk's readdir and the final rmdir. Without retries,
+        // a single race surfaces "ENOTEMPTY: directory not empty, rmdir
+        // .../node_modules/lucide/dist" to the user.
+        await rm(worktreePath, {
+          recursive: true,
+          force: true,
+          maxRetries: 5,
+          retryDelay: 200,
+        });
       }
     }
   }

package/server/worktrees-routes.js

@@ -262,6 +262,17 @@ function _patchRegistry(worcaDir, runId, patch) {
   }
 }
 
+function _isPidAlive(pid) {
+  if (!pid || typeof pid !== 'number') return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    if (err.code === 'EPERM') return true;
+    return false;
+  }
+}
+
 async function _listWorktrees(worcaDir) {
   const pipelinesDir = join(worcaDir, 'multi', 'pipelines.d');
   if (!existsSync(pipelinesDir)) return [];
@@ -290,6 +301,29 @@ async function _listWorktrees(worcaDir) {
       if (actual) status = actual;
     }
 
+    // Stale-registry reconciliation: a child can die before ever writing
+    // status.json (e.g. fleet halt right after dispatch, preflight crash,
+    // SIGKILL). In that case the worktree exists but .worca/runs/ doesn't,
+    // _readWorktreeStatus returns null, and we'd fall back to reg.status
+    // which may still say "running" with a dead pid. Treat that as
+    // "interrupted" and patch the registry so this only happens once.
+    //
+    // Only reconcile when reg.pid is present — a missing pid means the
+    // entry is either from a non-standard registration path (e.g. test
+    // fixtures) or pre-dates the pid-on-registration contract, so we
+    // can't make liveness claims about it.
+    if (
+      status === 'running' &&
+      typeof reg.pid === 'number' &&
+      !_isPidAlive(reg.pid)
+    ) {
+      status = 'interrupted';
+      _patchRegistry(worcaDir, reg.run_id, {
+        status: 'interrupted',
+        interrupted_reason: 'stale_pid',
+      });
+    }
+
     let ageSeconds = 0;
     if (reg.started_at) {
       const started = new Date(reg.started_at).getTime();

package/server/ws-fleet-manifest-watcher.js

@@ -0,0 +1,131 @@
+/**
+ * Fleet manifest watcher — monitors ~/.worca/fleet-runs/<fleet_id>.json for changes.
+ * Emits fleet-update WS events when a fleet manifest is written (§13.5).
+ */
+
+import { existsSync, readFileSync, watch } from 'node:fs';
+import { join } from 'node:path';
+import { effectiveFleetStatus } from './fleet-routes.js';
+import { fleetRunsDir as resolveFleetRunsDir } from './paths.js';
+
+const FLEET_DEBOUNCE_MS = 200;
+
+const FAILURE_STATES = new Set(['failed', 'setup_failed', 'unrecoverable']);
+
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function resolveChildStatus(child) {
+  const { project_path, run_id } = child;
+  if (!project_path || !run_id) return 'running';
+  const registryPath = join(
+    project_path,
+    '.worca',
+    'multi',
+    'pipelines.d',
+    `${run_id}.json`,
+  );
+  const entry = readJson(registryPath);
+  return entry?.status ?? 'running';
+}
+
+/**
+ * @param {{ broadcaster: { broadcast: Function }, fleetRunsDir?: string }} deps
+ */
+export function createFleetManifestWatcher({
+  broadcaster,
+  fleetRunsDir: fleetRunsDirArg,
+}) {
+  // Lazy resolution honors $WORCA_HOME (issue #162).
+  const fleetRunsDir = resolveFleetRunsDir(fleetRunsDirArg);
+  let fsWatcher = null;
+  /** @type {Map<string, ReturnType<typeof setTimeout>>} */
+  const debounceTimers = new Map();
+
+  function broadcastFleetUpdate(fleetId, manifestPath) {
+    const manifest = readJson(manifestPath);
+    if (!manifest) return;
+
+    const rawChildren = Array.isArray(manifest.children)
+      ? manifest.children
+      : [];
+    const children = rawChildren.map((child) => ({
+      run_id: child.run_id,
+      project_path: child.project_path,
+      status: resolveChildStatus(child),
+    }));
+
+    const completed_children = children.filter(
+      (c) => c.status === 'completed',
+    ).length;
+    const failed_children = children.filter((c) =>
+      FAILURE_STATES.has(c.status),
+    ).length;
+
+    // Derive the effective status (same rules as REST) instead of broadcasting
+    // raw manifest.status — otherwise cards stay "running" forever, because
+    // run_fleet.py never writes a terminal status after it exits. Pure
+    // function: persists nothing, so we don't trigger a watch→write→watch loop.
+    const { status, halt_reason } = effectiveFleetStatus(
+      manifest,
+      children.map((c) => c.status),
+    );
+
+    broadcaster.broadcast('fleet-update', {
+      fleet_id: fleetId,
+      status,
+      halt_reason,
+      completed_children,
+      failed_children,
+      children,
+    });
+  }
+
+  function scheduleUpdate(fleetId, manifestPath) {
+    const existing = debounceTimers.get(fleetId);
+    if (existing) clearTimeout(existing);
+    debounceTimers.set(
+      fleetId,
+      setTimeout(() => {
+        debounceTimers.delete(fleetId);
+        broadcastFleetUpdate(fleetId, manifestPath);
+      }, FLEET_DEBOUNCE_MS),
+    );
+  }
+
+  try {
+    if (existsSync(fleetRunsDir)) {
+      fsWatcher = watch(
+        fleetRunsDir,
+        { persistent: false },
+        (_event, filename) => {
+          if (!filename?.endsWith('.json')) return;
+          const fleetId = filename.slice(0, -5);
+          scheduleUpdate(fleetId, join(fleetRunsDir, filename));
+        },
+      );
+    }
+  } catch {
+    // fs.watch unsupported or dir unavailable — skip silently
+  }
+
+  function destroy() {
+    if (fsWatcher) {
+      try {
+        fsWatcher.close();
+      } catch {
+        /* ignore */
+      }
+      fsWatcher = null;
+    }
+    for (const timer of debounceTimers.values()) clearTimeout(timer);
+    debounceTimers.clear();
+  }
+
+  return { destroy };
+}

package/server/ws-message-router.js

@@ -80,6 +80,22 @@ export function createMessageRouter({
     };
   }
 
+  // When a run-scoped subscribe arrives with a `payload.projectId` that
+  // differs from the client's currently-bound subs.projectId, re-bind the
+  // WS to that project. Without this, the targeted project's WatcherSet
+  // stays in POLLING tier (no logWatcher / no live updates), and the
+  // backfill / live stream silently never arrive — symptoms reported by
+  // the user as "no logs / no agent prompts" on the run-detail page in
+  // global mode. We keep the previous projectId reference so demotion
+  // still happens via the normal client-count mechanism.
+  function _adoptProjectFromPayload(ws, payload) {
+    const requested = payload?.projectId;
+    if (!requested || !watcherSets.has(requested)) return;
+    const subs = clientManager.getSubs(ws);
+    if (subs?.projectId === requested) return;
+    clientManager.setProtocol(ws, subs?.protocolVersion ?? 1, requested);
+  }
+
   async function handleMessage(ws, data) {
     let json;
     try {
@@ -147,6 +163,7 @@ export function createMessageRouter({
         );
         return;
       }
+      _adoptProjectFromPayload(ws, req.payload);
       const proj = resolveProject(ws, req.payload);
       const runs = discoverRuns(proj.worcaDir);
       const run = runs.find((r) => r.id === runId);
@@ -294,6 +311,7 @@ export function createMessageRouter({
         );
         return;
       }
+      _adoptProjectFromPayload(ws, req.payload);
       const proj = resolveProject(ws, req.payload);
       if (!proj) {
         ws.send(
@@ -336,6 +354,7 @@ export function createMessageRouter({
     // subscribe-log
     if (req.type === 'subscribe-log') {
       const { stage, runId, iteration } = req.payload || {};
+      _adoptProjectFromPayload(ws, req.payload);
       const proj = resolveProject(ws, req.payload);
       const s = clientManager.ensureSubs(ws);
       s.logStage = stage || '*';
@@ -652,6 +671,7 @@ export function createMessageRouter({
         );
         return;
       }
+      _adoptProjectFromPayload(ws, req.payload);
       const proj = resolveProject(ws, req.payload);
       if (!proj.wset.beadsWatcher) {
         ws.send(JSON.stringify(makeOk(req, { issues: [], runId })));

package/server/ws-modular.js

@@ -9,13 +9,16 @@
 import { existsSync, watch } from 'node:fs';
 import { join } from 'node:path';
 import { WebSocketServer } from 'ws';
+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 { createBroadcaster } from './ws-broadcaster.js';
 import { createClientManager } from './ws-client-manager.js';
+import { createFleetManifestWatcher } from './ws-fleet-manifest-watcher.js';
 import { createMessageRouter } from './ws-message-router.js';
 import { resolveLatestRunDir } from './ws-status-watcher.js';
+import { createWorkspaceManifestWatcher } from './ws-workspace-manifest-watcher.js';
 
 export { resolveLatestRunDir };
 
@@ -45,7 +48,19 @@ export function attachWsServer(httpServer, config) {
     getSubs: clientManager.getSubs,
   });
 
-  // 3. Create WatcherSet(s) — one per project
+  // 3a. Fleet manifest watcher — global, not per-project (§13.5)
+  const fleetManifestWatcher = createFleetManifestWatcher({
+    broadcaster,
+    fleetRunsDir: fleetRunsDir(),
+  });
+
+  // 3a-ws. Workspace manifest watcher — global, separate from fleet (W-047 §13.5)
+  const workspaceManifestWatcher = createWorkspaceManifestWatcher({
+    broadcaster,
+    workspaceRunsDir: workspaceRunsDir(),
+  });
+
+  // 3b. Create WatcherSet(s) — one per project
   /** @type {Map<string, WatcherSet>} */
   const watcherSets = new Map();
 
@@ -269,6 +284,8 @@ export function attachWsServer(httpServer, config) {
 
   wss.on('close', () => {
     clientManager.destroy();
+    fleetManifestWatcher.destroy();
+    workspaceManifestWatcher.destroy();
     if (dirWatcher) {
       try {
         dirWatcher.close();

package/server/ws-workspace-manifest-watcher.js

@@ -0,0 +1,136 @@
+/**
+ * Workspace manifest watcher — monitors ~/.worca/workspace-runs/ for pointer
+ * file changes, reads the actual manifest, and broadcasts workspace-update,
+ * workspace-tier-update, and guide-conflict WS events.
+ *
+ * Separate from fleet-update per W-040 §13.5 — never multiplexed.
+ */
+
+import { existsSync, readFileSync, watch } from 'node:fs';
+import { join } from 'node:path';
+import { workspaceRunsDir as resolveWorkspaceRunsDir } from './paths.js';
+
+const WS_DEBOUNCE_MS = 200;
+
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function readManifestFromPointer(wsRunsDir, wsId) {
+  const pointer = readJson(join(wsRunsDir, `${wsId}.json`));
+  if (!pointer?.workspace_root) return null;
+  const manifestPath = join(
+    pointer.workspace_root,
+    '.worca',
+    'workspace-runs',
+    wsId,
+    'workspace-manifest.json',
+  );
+  return readJson(manifestPath);
+}
+
+/**
+ * @param {{ broadcaster: { broadcast: Function }, workspaceRunsDir?: string }} deps
+ */
+export function createWorkspaceManifestWatcher({
+  broadcaster,
+  workspaceRunsDir: workspaceRunsDirArg,
+}) {
+  // Lazy resolution honors $WORCA_HOME (issue #162).
+  const workspaceRunsDir = resolveWorkspaceRunsDir(workspaceRunsDirArg);
+
+  let fsWatcher = null;
+  /** @type {Map<string, ReturnType<typeof setTimeout>>} */
+  const debounceTimers = new Map();
+
+  function broadcastWorkspaceUpdate(wsId) {
+    const manifest = readManifestFromPointer(workspaceRunsDir, wsId);
+    if (!manifest) return;
+
+    const children = Array.isArray(manifest.children) ? manifest.children : [];
+    const dag = manifest.dag ?? { tiers: [] };
+
+    broadcaster.broadcast('workspace-update', {
+      workspace_id: wsId,
+      workspace_name: manifest.workspace_name ?? null,
+      status: manifest.status ?? 'running',
+      halt_reason: manifest.halt_reason ?? null,
+      dag,
+      children: children.map((c) => ({
+        repo: c.repo,
+        run_id: c.run_id,
+        status: c.status,
+        tier: c.tier,
+      })),
+      integration_test: manifest.integration_test ?? null,
+    });
+
+    const tiers = dag.tiers ?? [];
+    for (const tier of tiers) {
+      broadcaster.broadcast('workspace-tier-update', {
+        workspace_id: wsId,
+        tier: tier.tier,
+        repos: tier.repos,
+        status: tier.status,
+      });
+    }
+
+    const conflicts = manifest.guide_conflicts;
+    if (Array.isArray(conflicts) && conflicts.length > 0) {
+      broadcaster.broadcast('guide-conflict', {
+        workspace_id: wsId,
+        conflicts,
+      });
+    }
+  }
+
+  function scheduleUpdate(wsId) {
+    const existing = debounceTimers.get(wsId);
+    if (existing) clearTimeout(existing);
+    debounceTimers.set(
+      wsId,
+      setTimeout(() => {
+        debounceTimers.delete(wsId);
+        broadcastWorkspaceUpdate(wsId);
+      }, WS_DEBOUNCE_MS),
+    );
+  }
+
+  try {
+    if (existsSync(workspaceRunsDir)) {
+      fsWatcher = watch(
+        workspaceRunsDir,
+        { persistent: false },
+        (_event, filename) => {
+          if (!filename?.endsWith('.json')) return;
+          const wsId = filename.slice(0, -5);
+          scheduleUpdate(wsId);
+        },
+      );
+    }
+  } catch {
+    // fs.watch unsupported or dir unavailable — skip silently
+  }
+
+  function destroy() {
+    if (fsWatcher) {
+      try {
+        fsWatcher.close();
+      } catch {
+        /* ignore */
+      }
+      fsWatcher = null;
+    }
+    for (const timer of debounceTimers.values()) clearTimeout(timer);
+    debounceTimers.clear();
+  }
+
+  return {
+    destroy,
+    _broadcastForTest: broadcastWorkspaceUpdate,
+  };
+}