@worca/ui 0.11.0 → 0.13.0

package/server/watcher.js

@@ -49,28 +49,7 @@ export function discoverRuns(worcaDir) {
   const runs = [];
   const seenIds = new Set();
 
-  // 1. Check active_run pointer for the current run
-  const activeRunPath = join(worcaDir, 'active_run');
-  if (existsSync(activeRunPath)) {
-    try {
-      const activeId = readFileSync(activeRunPath, 'utf8').trim();
-      const runDir = join(worcaDir, 'runs', activeId);
-      const candidate = join(runDir, 'status.json');
-      if (existsSync(candidate)) {
-        let status = JSON.parse(readFileSync(candidate, 'utf8'));
-        status = enrichWithDispatchEvents(status, runDir);
-        const active =
-          !isTerminal(status) && status.pipeline_status === 'running';
-        const id = createRunId(status);
-        runs.push({ id, active, ...status });
-        seenIds.add(id);
-      }
-    } catch {
-      /* ignore */
-    }
-  }
-
-  // 2. Scan .worca/runs/ for other runs
+  // 1. Scan .worca/runs/ for runs
   const runsDir = join(worcaDir, 'runs');
   if (existsSync(runsDir)) {
     for (const entry of readdirSync(runsDir)) {
@@ -92,7 +71,7 @@ export function discoverRuns(worcaDir) {
     }
   }
 
-  // 3. Legacy: flat .worca/status.json
+  // 2. Legacy: flat .worca/status.json
   const statusPath = join(worcaDir, 'status.json');
   if (existsSync(statusPath)) {
     try {
@@ -109,7 +88,7 @@ export function discoverRuns(worcaDir) {
     }
   }
 
-  // 4. Results: handle both dir format (results/{id}/status.json) and file format (results/{id}.json)
+  // 3. Results: handle both dir format (results/{id}/status.json) and file format (results/{id}.json)
   const resultsDir = join(worcaDir, 'results');
   if (existsSync(resultsDir)) {
     for (const entry of readdirSync(resultsDir, { withFileTypes: true })) {
@@ -148,6 +127,51 @@ export function discoverRuns(worcaDir) {
     }
   }
 
+  // 4. Fan out across pipelines.d/ registry entries (worktree runs)
+  const pipelinesDir = join(worcaDir, 'multi', 'pipelines.d');
+  if (existsSync(pipelinesDir)) {
+    for (const entry of readdirSync(pipelinesDir)) {
+      if (!entry.endsWith('.json')) continue;
+      try {
+        const reg = JSON.parse(readFileSync(join(pipelinesDir, entry), 'utf8'));
+        if (!reg.worktree_path) continue;
+        const wtRunsDir = join(reg.worktree_path, '.worca', 'runs');
+        if (!existsSync(wtRunsDir)) continue;
+        for (const runEntry of readdirSync(wtRunsDir)) {
+          const sp = join(wtRunsDir, runEntry, 'status.json');
+          if (!existsSync(sp)) continue;
+          try {
+            let status = JSON.parse(readFileSync(sp, 'utf8'));
+            status = enrichWithDispatchEvents(
+              status,
+              join(wtRunsDir, runEntry),
+            );
+            const id = createRunId(status);
+            if (seenIds.has(id)) continue;
+            seenIds.add(id);
+            const active =
+              !isTerminal(status) && status.pipeline_status === 'running';
+            runs.push({
+              id,
+              active,
+              ...status,
+              worktree_worca_dir: join(reg.worktree_path, '.worca'),
+              is_worktree_run: true,
+              fleet_id: reg.fleet_id || null,
+              workspace_id: reg.workspace_id || null,
+              group_type: reg.group_type || null,
+              target_branch: reg.target_branch || null,
+            });
+          } catch {
+            /* ignore malformed status */
+          }
+        }
+      } catch {
+        /* ignore malformed registry entry */
+      }
+    }
+  }
+
   return runs;
 }
 
@@ -159,23 +183,7 @@ export async function discoverRunsAsync(worcaDir) {
   const runs = [];
   const seenIds = new Set();
 
-  // 1. Active run
-  const activeRunPath = join(worcaDir, 'active_run');
-  try {
-    const activeId = (await readFile(activeRunPath, 'utf8')).trim();
-    const runDir = join(worcaDir, 'runs', activeId);
-    const candidate = join(runDir, 'status.json');
-    let status = JSON.parse(await readFile(candidate, 'utf8'));
-    status = enrichWithDispatchEvents(status, runDir);
-    const active = !isTerminal(status) && status.pipeline_status === 'running';
-    const id = createRunId(status);
-    runs.push({ id, active, ...status });
-    seenIds.add(id);
-  } catch {
-    /* ignore */
-  }
-
-  // 2. Scan .worca/runs/
+  // 1. Scan .worca/runs/
   const runsDir = join(worcaDir, 'runs');
   try {
     const entries = await readdir(runsDir);
@@ -203,7 +211,7 @@ export async function discoverRunsAsync(worcaDir) {
     /* ignore */
   }
 
-  // 3. Legacy flat status.json
+  // 2. Legacy flat status.json
   try {
     const status = JSON.parse(
       await readFile(join(worcaDir, 'status.json'), 'utf8'),
@@ -219,7 +227,7 @@ export async function discoverRunsAsync(worcaDir) {
     /* ignore */
   }
 
-  // 4. Results
+  // 3. Results
   const resultsDir = join(worcaDir, 'results');
   try {
     const entries = await readdir(resultsDir, { withFileTypes: true });
@@ -252,6 +260,67 @@ export async function discoverRunsAsync(worcaDir) {
     /* ignore */
   }
 
+  // 4. Fan out across pipelines.d/ registry entries (worktree runs)
+  const pipelinesDirAsync = join(worcaDir, 'multi', 'pipelines.d');
+  try {
+    const regEntries = await readdir(pipelinesDirAsync);
+    const wtReadPromises = regEntries
+      .filter((e) => e.endsWith('.json'))
+      .map(async (e) => {
+        try {
+          const reg = JSON.parse(
+            await readFile(join(pipelinesDirAsync, e), 'utf8'),
+          );
+          if (!reg.worktree_path) return [];
+          const wtRunsDir = join(reg.worktree_path, '.worca', 'runs');
+          let runEntries;
+          try {
+            runEntries = await readdir(wtRunsDir);
+          } catch {
+            return [];
+          }
+          const results = [];
+          for (const runEntry of runEntries) {
+            try {
+              const sp = join(wtRunsDir, runEntry, 'status.json');
+              let status = JSON.parse(await readFile(sp, 'utf8'));
+              status = enrichWithDispatchEvents(
+                status,
+                join(wtRunsDir, runEntry),
+              );
+              results.push({ status, reg });
+            } catch {
+              /* ignore */
+            }
+          }
+          return results;
+        } catch {
+          return [];
+        }
+      });
+    const wtResults = (await Promise.all(wtReadPromises)).flat();
+    for (const { status, reg } of wtResults) {
+      const id = createRunId(status);
+      if (seenIds.has(id)) continue;
+      seenIds.add(id);
+      const active =
+        !isTerminal(status) && status.pipeline_status === 'running';
+      runs.push({
+        id,
+        active,
+        ...status,
+        worktree_worca_dir: join(reg.worktree_path, '.worca'),
+        is_worktree_run: true,
+        fleet_id: reg.fleet_id || null,
+        workspace_id: reg.workspace_id || null,
+        group_type: reg.group_type || null,
+        target_branch: reg.target_branch || null,
+      });
+    }
+  } catch {
+    /* ignore */
+  }
+
   return runs;
 }
 

package/server/worktrees-routes.js

@@ -0,0 +1,349 @@
+/**
+ * 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 { execFileSync } from 'node:child_process';
+import {
+  existsSync,
+  lstatSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  unlinkSync,
+} from 'node:fs';
+import { join } from 'node:path';
+import { Router } from 'express';
+
+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;
+}
+
+/**
+ * Remove a worktree and its registry entry.
+ * Mirrors WorktreeSource.remove from src/worca/cli/cleanup.py:
+ *   1. Attempt `git worktree remove --force <path>` from the project root
+ *   2. On failure (e.g. non-worktree temp dir in tests), fall back to rmSync
+ *   3. Run `git worktree prune` so git's metadata (`.git/worktrees/<id>/`)
+ *      drops the entry even when the directory was removed manually
+ *   4. Delete the registry file
+ */
+function _removeWorktree(worcaDir, runId) {
+  const regFile = join(worcaDir, 'multi', 'pipelines.d', `${runId}.json`);
+  // worcaDir is `<projectRoot>/.worca` — git commands must run inside the
+  // project repo, not the server's cwd, or `git worktree remove` errors out
+  // and the .git/worktrees/<id>/ metadata is left as `prunable`.
+  const projectRoot = join(worcaDir, '..');
+  let worktreePath = null;
+
+  if (existsSync(regFile)) {
+    try {
+      const reg = JSON.parse(readFileSync(regFile, 'utf8'));
+      worktreePath = reg.worktree_path || null;
+    } catch {
+      /* ignore */
+    }
+  }
+
+  if (worktreePath && existsSync(worktreePath)) {
+    try {
+      execFileSync('git', ['worktree', 'remove', '--force', worktreePath], {
+        cwd: projectRoot,
+        stdio: 'pipe',
+        timeout: 30_000,
+      });
+    } catch {
+      // Path is not a registered git worktree — brute-force remove.
+      // Refuse to follow symlinks: rmSync on a symlink to a real directory
+      // would delete the link itself (good), but we don't want to risk a
+      // user-symlinked path here being mistaken for a worktree we own.
+      let isRealDir = false;
+      try {
+        const st = lstatSync(worktreePath);
+        isRealDir = st.isDirectory() && !st.isSymbolicLink();
+      } catch {
+        /* ignore */
+      }
+      if (isRealDir) {
+        rmSync(worktreePath, { recursive: true, force: true });
+      }
+    }
+  }
+
+  // Always prune — covers (a) successful remove leaving residual metadata,
+  // (b) brute-force rmSync path, and (c) entries already left prunable by
+  // earlier failures. Errors are non-fatal (e.g. project not a git repo).
+  try {
+    execFileSync('git', ['worktree', 'prune'], {
+      cwd: projectRoot,
+      stdio: 'pipe',
+      timeout: 30_000,
+    });
+  } catch {
+    /* non-fatal */
+  }
+
+  if (existsSync(regFile)) {
+    unlinkSync(regFile);
+  }
+}
+
+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;
   }
 

package/server/ws-message-router.js

@@ -852,56 +852,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;
   }