@worca/ui 0.23.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/ws-fleet-manifest-watcher.js

@@ -4,12 +4,11 @@
  */
 
 import { existsSync, readFileSync, watch } from 'node:fs';
-import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { effectiveFleetStatus } from './fleet-routes.js';
+import { fleetRunsDir as resolveFleetRunsDir } from './paths.js';
 
 const FLEET_DEBOUNCE_MS = 200;
-const DEFAULT_FLEET_RUNS_DIR = join(homedir(), '.worca', 'fleet-runs');
 
 const FAILURE_STATES = new Set(['failed', 'setup_failed', 'unrecoverable']);
 
@@ -40,8 +39,10 @@ function resolveChildStatus(child) {
  */
 export function createFleetManifestWatcher({
   broadcaster,
-  fleetRunsDir = DEFAULT_FLEET_RUNS_DIR,
+  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();

package/server/ws-modular.js

@@ -7,9 +7,9 @@
  */
 
 import { existsSync, watch } from 'node:fs';
-import { homedir } from 'node:os';
 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';
@@ -18,6 +18,7 @@ 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 };
 
@@ -50,7 +51,13 @@ export function attachWsServer(httpServer, config) {
   // 3a. Fleet manifest watcher — global, not per-project (§13.5)
   const fleetManifestWatcher = createFleetManifestWatcher({
     broadcaster,
-    fleetRunsDir: join(homedir(), '.worca', 'fleet-runs'),
+    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
@@ -278,6 +285,7 @@ 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,
+  };
+}