@worca/ui 0.12.0 → 0.14.0

package/server/worktrees-routes.js

@@ -0,0 +1,272 @@
+/**
+ * REST routes for worktree management.
+ *
+ * GET  /worktrees          — list worktree entries enriched with disk/age/group data
+ * DELETE /worktrees/:run_id — remove a worktree (409 if running, 412 if resumable/grouped without ?force=1)
+ *
+ * Expects req.project.worcaDir to be set by projectResolver middleware.
+ */
+
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { Router } from 'express';
+import { removeWorktree } from './worktree-ops.js';
+
+const RESUMABLE_STATUSES = new Set(['failed', 'paused', 'cancelled']);
+
+// Disk usage cache — keyed by worktree path, expires after 30 s
+const _diskCache = new Map();
+const DISK_CACHE_TTL_MS = 30_000;
+
+/**
+ * Sum file sizes under a directory tree. Cross-platform: prior `du -sb`
+ * relied on GNU coreutils and silently returned 0 on macOS / BSD du,
+ * which is why the Worktrees view always showed "0 B".
+ *
+ * Skips symlinks (don't follow into other trees) and is bounded by
+ * MAX_WALK_FILES so a runaway directory can't hang the request.
+ * Errors on individual entries are swallowed so a transiently-locked
+ * file doesn't poison the whole sum.
+ */
+const MAX_WALK_FILES = 100_000;
+function _walkDirSize(rootPath) {
+  let total = 0;
+  let count = 0;
+  const stack = [rootPath];
+  while (stack.length > 0 && count < MAX_WALK_FILES) {
+    const cur = stack.pop();
+    let entries;
+    try {
+      entries = readdirSync(cur, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      count++;
+      if (count >= MAX_WALK_FILES) break;
+      const child = join(cur, e.name);
+      if (e.isSymbolicLink()) continue;
+      if (e.isDirectory()) {
+        stack.push(child);
+      } else if (e.isFile()) {
+        try {
+          total += statSync(child).size;
+        } catch {
+          /* ignore — file vanished mid-walk */
+        }
+      }
+    }
+  }
+  return total;
+}
+
+function _getDiskBytes(worktreePath) {
+  const now = Date.now();
+  const hit = _diskCache.get(worktreePath);
+  if (hit && hit.expiry > now) return hit.bytes;
+
+  let bytes = 0;
+  try {
+    bytes = _walkDirSize(worktreePath);
+  } catch {
+    bytes = 0;
+  }
+  _diskCache.set(worktreePath, { bytes, expiry: now + DISK_CACHE_TTL_MS });
+  return bytes;
+}
+
+/**
+ * Read pipeline_status from a worktree's status.json files.
+ * Checks .worca/runs/ (W-048 layout) then flat .worca/status.json (legacy).
+ * Returns null if no status file is found.
+ */
+function _readWorktreeStatus(worktreePath) {
+  const runsDir = join(worktreePath, '.worca', 'runs');
+  if (existsSync(runsDir)) {
+    for (const entry of readdirSync(runsDir)) {
+      const sp = join(runsDir, entry, 'status.json');
+      if (!existsSync(sp)) continue;
+      try {
+        const data = JSON.parse(readFileSync(sp, 'utf8'));
+        if (data.pipeline_status) return data.pipeline_status;
+      } catch {
+        /* ignore malformed */
+      }
+    }
+  }
+
+  const flat = join(worktreePath, '.worca', 'status.json');
+  if (existsSync(flat)) {
+    try {
+      const data = JSON.parse(readFileSync(flat, 'utf8'));
+      if (data.pipeline_status) return data.pipeline_status;
+    } catch {
+      /* ignore malformed */
+    }
+  }
+
+  return null;
+}
+
+function _listWorktrees(worcaDir) {
+  const pipelinesDir = join(worcaDir, 'multi', 'pipelines.d');
+  if (!existsSync(pipelinesDir)) return [];
+
+  const entries = [];
+  for (const file of readdirSync(pipelinesDir)) {
+    if (!file.endsWith('.json')) continue;
+
+    let reg;
+    try {
+      reg = JSON.parse(readFileSync(join(pipelinesDir, file), 'utf8'));
+    } catch {
+      continue;
+    }
+    if (!reg.worktree_path) continue;
+
+    const worktreePath = reg.worktree_path;
+    const worktreeExists = existsSync(worktreePath);
+
+    // Prefer actual status.json; fall back to registry field
+    let status = reg.status || 'unknown';
+    if (worktreeExists) {
+      const actual = _readWorktreeStatus(worktreePath);
+      if (actual) status = actual;
+    }
+
+    let ageSeconds = 0;
+    if (reg.started_at) {
+      const started = new Date(reg.started_at).getTime();
+      if (!Number.isNaN(started)) {
+        ageSeconds = Math.max(0, Math.floor((Date.now() - started) / 1_000));
+      }
+    }
+
+    entries.push({
+      run_id: reg.run_id || '',
+      title: reg.title || '',
+      branch: reg.branch || '',
+      worktree_path: worktreePath,
+      disk_bytes: worktreeExists ? _getDiskBytes(worktreePath) : 0,
+      age_seconds: ageSeconds,
+      // started_at lets the client sort with the same sortByStartDesc helper
+      // used by run-list, keeping ordering consistent across views.
+      started_at: reg.started_at || null,
+      status,
+      removable: status !== 'running',
+      fleet_id: reg.fleet_id || null,
+      workspace_id: reg.workspace_id || null,
+      group_type: reg.group_type || null,
+      group_status: null, // populated by W-040 / W-047
+      resumable: RESUMABLE_STATUSES.has(status),
+    });
+  }
+  return entries;
+}
+
+const RUN_ID_RE = /^[a-zA-Z0-9_-]+$/;
+function _validateRunId(runId) {
+  return (
+    typeof runId === 'string' &&
+    runId.length > 0 &&
+    runId.length <= 128 &&
+    RUN_ID_RE.test(runId)
+  );
+}
+
+/**
+ * Create the worktrees REST router.
+ * Mount with: router.use('/worktrees', requireWorcaDir, createWorktreesRouter())
+ */
+export function createWorktreesRouter() {
+  const router = Router({ mergeParams: true });
+
+  // GET /worktrees
+  router.get('/', (req, res) => {
+    const worcaDir = req.project?.worcaDir;
+    if (!worcaDir) {
+      return res
+        .status(501)
+        .json({ ok: false, error: 'worcaDir not configured' });
+    }
+    try {
+      const worktrees = _listWorktrees(worcaDir);
+      res.json({ ok: true, worktrees });
+    } catch (err) {
+      res.status(500).json({ ok: false, error: err.message });
+    }
+  });
+
+  // DELETE /worktrees/:run_id
+  router.delete('/:run_id', (req, res) => {
+    const worcaDir = req.project?.worcaDir;
+    if (!worcaDir) {
+      return res
+        .status(501)
+        .json({ ok: false, error: 'worcaDir not configured' });
+    }
+
+    const { run_id } = req.params;
+    if (!_validateRunId(run_id)) {
+      return res.status(400).json({ ok: false, error: 'Invalid run ID' });
+    }
+
+    const force = req.query.force === '1';
+
+    try {
+      const regFile = join(worcaDir, 'multi', 'pipelines.d', `${run_id}.json`);
+      if (!existsSync(regFile)) {
+        return res
+          .status(404)
+          .json({ ok: false, error: `Worktree "${run_id}" not found` });
+      }
+
+      let reg;
+      try {
+        reg = JSON.parse(readFileSync(regFile, 'utf8'));
+      } catch {
+        return res
+          .status(500)
+          .json({ ok: false, error: 'Failed to read registry entry' });
+      }
+
+      // Derive actual pipeline status
+      let status = reg.status || 'unknown';
+      if (reg.worktree_path && existsSync(reg.worktree_path)) {
+        const actual = _readWorktreeStatus(reg.worktree_path);
+        if (actual) status = actual;
+      }
+
+      // 409 — cannot remove a running worktree
+      if (status === 'running') {
+        return res.status(409).json({
+          ok: false,
+          error: 'Cannot remove a running worktree',
+          code: 'running',
+        });
+      }
+
+      // 412 — resumable or grouped run requires ?force=1 confirmation
+      const isResumable = RESUMABLE_STATUSES.has(status);
+      const isGrouped = !!(reg.fleet_id || reg.workspace_id);
+      if (!force && (isResumable || isGrouped)) {
+        return res.status(412).json({
+          ok: false,
+          error:
+            'Removing this worktree prevents resuming the run. Use ?force=1 to confirm.',
+          code: 'resumable_or_grouped',
+          resumable: isResumable,
+          fleet_id: reg.fleet_id || null,
+          workspace_id: reg.workspace_id || null,
+        });
+      }
+
+      removeWorktree(worcaDir, run_id);
+      res.json({ ok: true, run_id });
+    } catch (err) {
+      res.status(500).json({ ok: false, error: err.message });
+    }
+  });
+
+  return router;
+}

package/server/ws-log-watcher.js

@@ -17,14 +17,14 @@ import {
 /**
  * @param {{
  *   broadcaster: { broadcastToLogSubscribers: Function },
- *   resolveActiveRunDir: Function,
+ *   resolveLatestRunDir: Function,
  *   worcaDir: string,
  *   currentActiveRunId: Function
  * }} deps
  */
 export function createLogWatcher({
   broadcaster,
-  resolveActiveRunDir,
+  resolveLatestRunDir,
   worcaDir,
   currentActiveRunId,
 }) {
@@ -35,7 +35,7 @@ export function createLogWatcher({
   const logByteOffsets = new Map();
 
   function resolveLogsBaseDir() {
-    const runDir = resolveActiveRunDir();
+    const runDir = resolveLatestRunDir();
     return runDir === worcaDir ? worcaDir : runDir;
   }
 
@@ -54,16 +54,21 @@ export function createLogWatcher({
     logByteOffsets.clear();
   }
 
-  function watchSingleLogFile(stage, filePath, iteration) {
-    const key =
-      iteration != null
-        ? `${stage}__iter${iteration}`
-        : stage || '__orchestrator__';
+  function _watcherKey(runId, stage, iteration, suffix = '') {
+    const stagePart = stage || '__orchestrator__';
+    const iterPart = iteration != null ? `__iter${iteration}` : '';
+    const runPart = runId ? `${runId}__` : '';
+    return `${runPart}${stagePart}${iterPart}${suffix}`;
+  }
+
+  function watchSingleLogFile(stage, filePath, iteration, options = {}) {
+    const explicitRunId = options.runId || null;
+    const key = _watcherKey(explicitRunId, stage, iteration);
     if (logWatchers.has(key)) return;
     try {
       if (!existsSync(filePath)) return;
       logByteOffsets.set(key, fileByteLength(filePath));
-      const watcherRunId = currentActiveRunId();
+      const watcherRunId = explicitRunId || currentActiveRunId();
       const watcher = watch(filePath, (eventType) => {
         if (eventType === 'change') {
           try {
@@ -99,62 +104,66 @@ export function createLogWatcher({
     }
   }
 
-  function watchStageDir(stage, stageDir) {
-    const dirKey = `${stage}__dir`;
+  function watchStageDir(stage, stageDir, options = {}) {
+    const explicitRunId = options.runId || null;
+    const dirKey = _watcherKey(explicitRunId, stage, null, '__dir');
     if (logWatchers.has(dirKey)) return;
     try {
       const dirWatcher = watch(stageDir, (_eventType, filename) => {
         if (filename && /^iter-\d+\.log$/.test(filename)) {
           const iterNum = parseInt(filename.match(/\d+/)[0], 10);
           const iterPath = join(stageDir, filename);
-          watchSingleLogFile(stage, iterPath, iterNum);
+          watchSingleLogFile(stage, iterPath, iterNum, options);
         }
       });
       logWatchers.set(dirKey, dirWatcher);
-      const logsBase = resolveLogsBaseDir();
+      const logsBase = options.runDir || resolveLogsBaseDir();
       const backfill = listIterationFiles(logsBase, stage);
       for (const { iteration, path } of backfill) {
-        watchSingleLogFile(stage, path, iteration);
+        watchSingleLogFile(stage, path, iteration, options);
       }
     } catch {
       /* ignore */
     }
   }
 
-  function watchLogFile(stage) {
-    const logsBase = resolveLogsBaseDir();
+  function watchLogFile(stage, options = {}) {
+    const logsBase = options.runDir || resolveLogsBaseDir();
     if (!stage) {
       const logPath = resolveLogPath(logsBase, null);
-      watchSingleLogFile(null, logPath, null);
+      watchSingleLogFile(null, logPath, null, options);
       return;
     }
     const stageDir = resolveLogPath(logsBase, stage);
     if (existsSync(stageDir) && statSync(stageDir).isDirectory()) {
       const iters = listIterationFiles(logsBase, stage);
       for (const { iteration, path } of iters) {
-        watchSingleLogFile(stage, path, iteration);
+        watchSingleLogFile(stage, path, iteration, options);
       }
-      watchStageDir(stage, stageDir);
+      watchStageDir(stage, stageDir, options);
     } else {
       const logPath = join(logsBase, 'logs', `${stage}.log`);
       if (existsSync(logPath)) {
-        watchSingleLogFile(stage, logPath, null);
+        watchSingleLogFile(stage, logPath, null, options);
       }
     }
   }
 
-  function watchAllLogFiles() {
-    const logsBase = resolveLogsBaseDir();
+  function watchAllLogFiles(options = {}) {
+    const logsBase = options.runDir || resolveLogsBaseDir();
     const logFiles = listLogFiles(logsBase);
     const watchedStages = new Set();
     for (const { stage } of logFiles) {
       if (watchedStages.has(stage)) continue;
       watchedStages.add(stage);
       const actualStage = stage === 'orchestrator' ? null : stage;
-      watchLogFile(actualStage);
+      watchLogFile(actualStage, options);
     }
     const logsDir = join(logsBase, 'logs');
-    const dirKey = '__logs_dir__';
+    const explicitRunId = options.runId || null;
+    const dirKey = explicitRunId
+      ? `${explicitRunId}__logs_dir__`
+      : '__logs_dir__';
     if (logWatchers.has(dirKey)) return;
     if (!existsSync(logsDir)) return;
     try {
@@ -163,16 +172,16 @@ export function createLogWatcher({
         if (filename.endsWith('.log')) {
           const stage = filename.replace('.log', '');
           const actualStage = stage === 'orchestrator' ? null : stage;
-          watchLogFile(actualStage);
+          watchLogFile(actualStage, options);
         } else {
           const stagePath = join(logsDir, filename);
           try {
             if (existsSync(stagePath) && statSync(stagePath).isDirectory()) {
               const iters = listIterationFiles(logsBase, filename);
               for (const { iteration, path } of iters) {
-                watchSingleLogFile(filename, path, iteration);
+                watchSingleLogFile(filename, path, iteration, options);
               }
-              watchStageDir(filename, stagePath);
+              watchStageDir(filename, stagePath, options);
             }
           } catch {
             /* ignore */

package/server/ws-message-router.js

@@ -32,6 +32,7 @@ import {
   stopPipeline as pmStopPipeline,
   reconcileStatus,
 } from './process-manager.js';
+import { resolveRunDir } from './run-dir-resolver.js';
 import { readSettings } from './settings-reader.js';
 import { discoverRuns } from './watcher.js';
 
@@ -342,90 +343,100 @@ export function createMessageRouter({
 
       if (!proj.wset.logWatcher) return;
 
-      const archivedRunDir = runId
-        ? join(proj.worcaDir, 'results', runId)
-        : null;
-      const archivedLogDir = archivedRunDir
-        ? join(archivedRunDir, 'logs')
-        : null;
-      const isArchived = archivedLogDir && existsSync(archivedLogDir);
-
-      if (isArchived) {
-        proj.wset.logWatcher.sendArchivedLogs(
-          ws,
-          archivedLogDir,
-          stage,
-          iteration,
-        );
+      // Resolve runId → on-disk run dir. Handles local active (runs/<id>),
+      // archived (results/<id>), and worktree overlay (pipelines.d/<id>.json
+      // → worktree_path/.worca/runs/<id>). Falls back to the project's
+      // latest-active-run base when no runId is given.
+      let logsBase;
+      let watchOptions;
+      if (runId) {
+        const runDir = resolveRunDir(proj.worcaDir, runId);
+        if (runDir) {
+          logsBase = runDir;
+          // Tail only when the run is still alive (pipeline.pid present);
+          // archived dirs get backfill but no live watcher.
+          watchOptions = existsSync(join(runDir, 'pipeline.pid'))
+            ? { runDir, runId }
+            : null;
+        } else {
+          // Run not found anywhere; nothing to send or watch.
+          return;
+        }
       } else {
-        const logsBase = proj.wset.logWatcher.resolveLogsBaseDir();
-        if (stage) {
-          if (iteration != null) {
-            const logPath = resolveIterationLogPath(logsBase, stage, iteration);
-            const lines = readLastLines(logPath, 200);
-            if (lines.length > 0) {
-              ws.send(
-                JSON.stringify({
-                  id: `evt-${Date.now()}`,
-                  ok: true,
-                  type: 'log-bulk',
-                  payload: { stage, iteration, lines },
-                }),
-              );
-            }
-          } else {
-            const stageDir = resolveLogPath(logsBase, stage);
-            if (existsSync(stageDir) && statSync(stageDir).isDirectory()) {
-              const iters = listIterationFiles(logsBase, stage);
-              for (const { iteration: iterNum, path } of iters) {
-                const lines = readLastLines(path, 200);
-                if (lines.length > 0) {
-                  ws.send(
-                    JSON.stringify({
-                      id: `evt-${Date.now()}-iter${iterNum}`,
-                      ok: true,
-                      type: 'log-bulk',
-                      payload: { stage, iteration: iterNum, lines },
-                    }),
-                  );
-                }
-              }
-            } else {
-              const logPath = join(logsBase, 'logs', `${stage}.log`);
-              const lines = readLastLines(logPath, 200);
+        logsBase = proj.wset.logWatcher.resolveLogsBaseDir();
+        watchOptions = {};
+      }
+
+      if (stage) {
+        if (iteration != null) {
+          const logPath = resolveIterationLogPath(logsBase, stage, iteration);
+          const lines = readLastLines(logPath, 200);
+          if (lines.length > 0) {
+            ws.send(
+              JSON.stringify({
+                id: `evt-${Date.now()}`,
+                ok: true,
+                type: 'log-bulk',
+                payload: { stage, iteration, lines },
+              }),
+            );
+          }
+        } else {
+          const stageDir = resolveLogPath(logsBase, stage);
+          if (existsSync(stageDir) && statSync(stageDir).isDirectory()) {
+            const iters = listIterationFiles(logsBase, stage);
+            for (const { iteration: iterNum, path } of iters) {
+              const lines = readLastLines(path, 200);
               if (lines.length > 0) {
                 ws.send(
                   JSON.stringify({
-                    id: `evt-${Date.now()}`,
+                    id: `evt-${Date.now()}-iter${iterNum}`,
                     ok: true,
                     type: 'log-bulk',
-                    payload: { stage, lines },
+                    payload: { stage, iteration: iterNum, lines },
                   }),
                 );
               }
             }
-          }
-          proj.wset.logWatcher.watchLogFile(stage);
-        } else {
-          const logFiles = listLogFiles(logsBase);
-          for (const { stage: s2, iteration: iterNum, path } of logFiles) {
-            const lines = readLastLines(path, 200);
+          } else {
+            const logPath = join(logsBase, 'logs', `${stage}.log`);
+            const lines = readLastLines(logPath, 200);
             if (lines.length > 0) {
               ws.send(
                 JSON.stringify({
-                  id: `evt-${Date.now()}-${s2}-${iterNum || 0}`,
+                  id: `evt-${Date.now()}`,
                   ok: true,
                   type: 'log-bulk',
-                  payload: {
-                    stage: s2,
-                    iteration: iterNum ?? undefined,
-                    lines,
-                  },
+                  payload: { stage, lines },
                 }),
               );
             }
           }
-          proj.wset.logWatcher.watchAllLogFiles();
+        }
+        if (watchOptions) {
+          proj.wset.logWatcher.watchLogFile(stage, watchOptions);
+        }
+      } else {
+        const logFiles = listLogFiles(logsBase);
+        for (const { stage: s2, iteration: iterNum, path } of logFiles) {
+          const lines = readLastLines(path, 200);
+          if (lines.length > 0) {
+            ws.send(
+              JSON.stringify({
+                id: `evt-${Date.now()}-${s2}-${iterNum || 0}`,
+                ok: true,
+                type: 'log-bulk',
+                payload: {
+                  stage: s2,
+                  iteration: iterNum ?? undefined,
+                  lines,
+                },
+              }),
+            );
+          }
+        }
+        if (watchOptions) {
+          proj.wset.logWatcher.watchAllLogFiles(watchOptions);
         }
       }
       return;
@@ -852,56 +863,6 @@ export function createMessageRouter({
       return;
     }
 
-    // list-pipelines — return parallel pipeline entries for a project
-    if (req.type === 'list-pipelines') {
-      const proj = resolveProject(ws, req.payload);
-      const multiWatcher = proj.wset.getMultiWatcher?.();
-      const pipelines = multiWatcher ? multiWatcher.listPipelines() : [];
-      ws.send(JSON.stringify(makeOk(req, { pipelines })));
-      return;
-    }
-
-    // subscribe-pipeline — subscribe to a specific parallel pipeline's events
-    if (req.type === 'subscribe-pipeline') {
-      const { runId } = req.payload || {};
-      if (typeof runId !== 'string') {
-        ws.send(
-          JSON.stringify(
-            makeError(req, 'bad_request', 'payload.runId required'),
-          ),
-        );
-        return;
-      }
-      const proj = resolveProject(ws, req.payload);
-      const multiWatcher = proj.wset.getMultiWatcher?.();
-      if (multiWatcher) {
-        multiWatcher.promotePipeline(runId);
-      }
-      const s = clientManager.ensureSubs(ws);
-      s.pipelineRunId = runId;
-      s.pipelineProjectId = proj.wset.projectId;
-      ws.send(JSON.stringify(makeOk(req, { subscribed: true })));
-      return;
-    }
-
-    // unsubscribe-pipeline — clear pipeline subscription and demote watcher
-    if (req.type === 'unsubscribe-pipeline') {
-      const s = clientManager.ensureSubs(ws);
-      const prevRunId = s.pipelineRunId;
-      const prevProjectId = s.pipelineProjectId;
-      s.pipelineRunId = null;
-      s.pipelineProjectId = null;
-      if (prevRunId && prevProjectId) {
-        const wset = watcherSets.get(prevProjectId) || getDefaultWs();
-        const multiWatcher = wset?.getMultiWatcher?.();
-        if (multiWatcher) {
-          multiWatcher.demotePipeline(prevRunId);
-        }
-      }
-      ws.send(JSON.stringify(makeOk(req, { unsubscribed: true })));
-      return;
-    }
-
     // Unknown type
     ws.send(
       JSON.stringify(

package/server/ws-modular.js

@@ -15,9 +15,9 @@ import { readProjectWorcaVersion } from './worca-setup.js';
 import { createBroadcaster } from './ws-broadcaster.js';
 import { createClientManager } from './ws-client-manager.js';
 import { createMessageRouter } from './ws-message-router.js';
-import { resolveActiveRunDir } from './ws-status-watcher.js';
+import { resolveLatestRunDir } from './ws-status-watcher.js';
 
-export { resolveActiveRunDir };
+export { resolveLatestRunDir };
 
 /**
  * Attach a WebSocket server to an existing HTTP server.
@@ -300,6 +300,15 @@ export function attachWsServer(httpServer, config) {
       if (existsSync(runsPath) || existsSync(resultsPath)) {
         return projectId;
       }
+      const registryPath = join(
+        wset.worcaDir,
+        'multi',
+        'pipelines.d',
+        `${runId}.json`,
+      );
+      if (existsSync(registryPath)) {
+        return projectId;
+      }
     }
     return null;
   }