@worca/ui 0.13.0 → 0.14.0

package/app/styles.css

@@ -1039,9 +1039,17 @@ sl-details.log-history-panel::part(content) {
   min-width: 140px;
 }
 
-.log-controls sl-input [slot="prefix"] {
+/* Prefix-slot icon centering. Inline SVGs default to baseline alignment,
+   which sits them at the top of an sl-input. Flex-center the slot wrapper
+   so any iconSvg(...) we drop into a prefix lines up with the placeholder
+   / value text. Generic rule covers every sl-input; .log-controls keeps
+   the extra left padding it always had. */
+sl-input [slot="prefix"] {
   display: flex;
   align-items: center;
+}
+
+.log-controls sl-input [slot="prefix"] {
   padding-left: 4px;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@worca/ui",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "Pipeline monitoring UI for worca-cc",
   "license": "MIT",
   "author": "Sinisha Djukic",
@@ -63,6 +63,7 @@
     "lit-html": "^3.3.1",
     "lucide": "^0.577.0",
     "marked": "^17.0.1",
+    "proper-lockfile": "^4.1.2",
     "ws": "^8.18.3"
   },
   "devDependencies": {

package/server/app.js

@@ -11,6 +11,8 @@ import express from 'express';
 import { dbExists, getIssue, listIssues } from './beads-reader.js';
 import { RAW_BODY } from './integrations/index.js';
 import { verify } from './integrations/verify.js';
+import { LaunchLock } from './launch-lock.js';
+import { createPreferencesRouter } from './preferences-routes.js';
 import { ProcessManager } from './process-manager.js';
 import { scanDirectory } from './project-registry.js';
 import {
@@ -19,6 +21,7 @@ import {
   projectResolver,
 } from './project-routes.js';
 import { validateIntegrationsConfig } from './settings-validator.js';
+import { createStatusRouter } from './status-routes.js';
 import { discoverSubagents } from './subagents-discovery.js';
 import { checkWorcaVersion } from './version-check.js';
 import { getVersionInfo } from './versions.js';
@@ -89,6 +92,13 @@ export function createApp(options = {}) {
   const webhookInbox = options.webhookInbox || createInbox();
   app.locals.webhookInbox = webhookInbox;
 
+  // Single LaunchLock instance shared across BOTH legacy /api and
+  // /api/projects/:id mounts so the global max_concurrent_pipelines cap is
+  // enforced atomically across all entry points. Without this, two routers
+  // each held their own mutex and concurrent launches via /api/runs +
+  // /api/projects/:id/runs could both pass the cap check and start.
+  const launchLock = new LaunchLock();
+
   // ─── Legacy single-project API ─────────────────────────────────────────
   // Mounts the shared project-scoped routes at /api with a middleware that
   // injects req.project from the closure options, so /api/runs, /api/settings,
@@ -112,7 +122,12 @@ export function createApp(options = {}) {
       };
       next();
     },
-    createProjectScopedRoutes({ serverHost, serverPort }),
+    createProjectScopedRoutes({
+      prefsDir,
+      serverHost,
+      serverPort,
+      launchLock,
+    }),
   );
 
   // ─── Unique routes (not in project-scoped router) ──────────────────────
@@ -519,6 +534,8 @@ export function createApp(options = {}) {
 
   // ─── Multi-project routes ──────────────────────────────────────────────
   if (prefsDir) {
+    app.use('/api/preferences', createPreferencesRouter({ prefsDir }));
+    app.use('/api/status', createStatusRouter({ prefsDir }));
     app.use(
       '/api/projects',
       createProjectRoutes({ prefsDir, projectRoot, serverHost, serverPort }),
@@ -526,7 +543,12 @@ export function createApp(options = {}) {
     app.use(
       '/api/projects/:projectId',
       projectResolver({ prefsDir, projectRoot }),
-      createProjectScopedRoutes({ prefsDir, serverHost, serverPort }),
+      createProjectScopedRoutes({
+        prefsDir,
+        serverHost,
+        serverPort,
+        launchLock,
+      }),
     );
   }
 

package/server/atomic-write.js

@@ -0,0 +1,18 @@
+/**
+ * Atomic file write: write to a temp file then rename into place.
+ * Prevents partial reads when a reader opens the file mid-write.
+ */
+
+import { mkdirSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+export function atomicWriteSync(filePath, data, options = {}) {
+  const dir = dirname(filePath);
+  mkdirSync(dir, { recursive: true });
+  const tmp = join(
+    dir,
+    `.${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`,
+  );
+  writeFileSync(tmp, data, options);
+  renameSync(tmp, filePath);
+}

package/server/beads-reader.js

@@ -89,15 +89,40 @@ export async function listUnlinkedIssues(beadsDb) {
   }
 }
 
+/**
+ * Returns { runId: { total, done } } for every run:<id> label in the beads db.
+ *
+ * `total` comes from the cheap `bd label list-all` count. `done` requires
+ * looking at issue status, so we query `bd list --label-any run:<id>` per
+ * run and count statuses === "closed". N+1 queries, but N is bounded by
+ * the number of pipeline runs and this endpoint is called on app load /
+ * project switch only, not on every render.
+ */
 export async function countIssuesByRunLabel(beadsDb) {
   try {
     const rows = await runBd(['label', 'list-all'], beadsDb);
     const counts = {};
-    for (const row of rows) {
-      if (row.label.startsWith('run:')) {
-        counts[row.label.replace('run:', '')] = row.count;
-      }
+    const runLabels = rows.filter((r) => r.label.startsWith('run:'));
+    for (const row of runLabels) {
+      counts[row.label.replace('run:', '')] = { total: row.count, done: 0 };
     }
+    // Count closed issues per label in parallel.
+    await Promise.all(
+      runLabels.map(async (row) => {
+        const runId = row.label.replace('run:', '');
+        try {
+          const issues = await runBd(
+            ['list', '--label-any', row.label, '--all', '--limit', '0'],
+            beadsDb,
+          );
+          counts[runId].done = issues.filter(
+            (i) => i.status === 'closed',
+          ).length;
+        } catch {
+          /* leave done at 0 on per-run failure */
+        }
+      }),
+    );
     return counts;
   } catch {
     return {};

package/server/global-keys.js

@@ -0,0 +1,49 @@
+import { GLOBAL_ONLY_KEYS } from './keys-schema.js';
+
+const INERT_MILESTONE_KEYS = ['pr_approval', 'deploy_approval'];
+
+/**
+ * Mutates `blob` in place: extracts misplaced global-only keys and strips
+ * inert milestone keys (pr_approval/deploy_approval when set to `true`).
+ *
+ * Returns { globalExtracted, removedMilestones } for the caller to merge
+ * into ~/.worca/settings.json and to surface in the response.
+ */
+export function extractAndStripGlobalKeys(blob) {
+  const globalExtracted = {};
+  const removedMilestones = [];
+
+  const worca = blob.worca;
+  if (!worca || typeof worca !== 'object') {
+    return { globalExtracted, removedMilestones };
+  }
+
+  for (const [section, key] of GLOBAL_ONLY_KEYS) {
+    const sectionObj = worca[section];
+    if (!sectionObj || typeof sectionObj !== 'object') continue;
+    if (!(key in sectionObj)) continue;
+
+    if (!globalExtracted[section]) globalExtracted[section] = {};
+    globalExtracted[section][key] = sectionObj[key];
+    delete sectionObj[key];
+
+    if (Object.keys(sectionObj).length === 0) {
+      delete worca[section];
+    }
+  }
+
+  const milestones = worca.milestones;
+  if (milestones && typeof milestones === 'object') {
+    for (const key of INERT_MILESTONE_KEYS) {
+      if (milestones[key] === true) {
+        delete milestones[key];
+        removedMilestones.push(key);
+      }
+    }
+    if (Object.keys(milestones).length === 0) {
+      delete worca.milestones;
+    }
+  }
+
+  return { globalExtracted, removedMilestones };
+}

package/server/keys-schema.js

@@ -0,0 +1,16 @@
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const schema = JSON.parse(
+  readFileSync(
+    resolve(__dirname, '../../src/worca/schemas/keys.json'),
+    'utf-8',
+  ),
+);
+
+export const GLOBAL_ONLY_KEYS = schema.global_only_keys;
+export const NORMALIZE_SKIP_KEYS = schema.normalize_skip_keys;
+export const GLOBAL_DEFAULTS = schema.defaults.global;
+export const PROJECT_DEFAULTS = schema.defaults.project;

package/server/launch-lock.js

@@ -0,0 +1,25 @@
+/**
+ * In-process async mutex using a promise chain.
+ * Used to serialize pipeline launches so max_concurrent_pipelines is enforced atomically.
+ */
+export class LaunchLock {
+  #tail = Promise.resolve();
+
+  acquire() {
+    let release;
+    const prev = this.#tail;
+    this.#tail = new Promise((resolve) => {
+      release = resolve;
+    });
+    return prev.then(() => release);
+  }
+
+  async withLock(fn) {
+    const release = await this.acquire();
+    try {
+      return await fn();
+    } finally {
+      release();
+    }
+  }
+}

package/server/preferences-routes.js

@@ -0,0 +1,143 @@
+import { join } from 'node:path';
+import { Router } from 'express';
+import { readGlobalSettings, writeGlobalSettings } from './settings-reader.js';
+
+const VALID_CLEANUP_POLICIES = ['never', 'on-success', 'manual-only'];
+const VALID_MODELS = ['opus', 'sonnet', 'haiku'];
+const MIN_DISK_BYTES = 500_000_000;
+const MAX_DISK_BYTES = 50_000_000_000;
+
+export function validateGlobalSettingsPayload(body) {
+  const details = [];
+
+  if (body.worca !== undefined) {
+    if (
+      typeof body.worca !== 'object' ||
+      body.worca === null ||
+      Array.isArray(body.worca)
+    ) {
+      details.push('worca must be an object');
+      return { valid: false, details };
+    }
+    const w = body.worca;
+
+    if (w.parallel !== undefined) {
+      if (
+        typeof w.parallel !== 'object' ||
+        w.parallel === null ||
+        Array.isArray(w.parallel)
+      ) {
+        details.push('worca.parallel must be an object');
+      } else {
+        if (w.parallel.max_concurrent_pipelines !== undefined) {
+          const v = w.parallel.max_concurrent_pipelines;
+          if (!Number.isInteger(v) || v < 1 || v > 100) {
+            details.push(
+              'max_concurrent_pipelines must be an integer between 1 and 100',
+            );
+          }
+        }
+        if (w.parallel.cleanup_policy !== undefined) {
+          if (!VALID_CLEANUP_POLICIES.includes(w.parallel.cleanup_policy)) {
+            details.push(
+              `cleanup_policy must be one of: ${VALID_CLEANUP_POLICIES.join(', ')}`,
+            );
+          }
+        }
+      }
+    }
+
+    if (w.ui !== undefined) {
+      if (typeof w.ui !== 'object' || w.ui === null || Array.isArray(w.ui)) {
+        details.push('worca.ui must be an object');
+      } else if (w.ui.worktree_disk_warning_bytes !== undefined) {
+        const v = w.ui.worktree_disk_warning_bytes;
+        if (
+          typeof v !== 'number' ||
+          !Number.isFinite(v) ||
+          v < MIN_DISK_BYTES ||
+          v > MAX_DISK_BYTES
+        ) {
+          details.push(
+            `worktree_disk_warning_bytes must be a number between ${MIN_DISK_BYTES} and ${MAX_DISK_BYTES}`,
+          );
+        }
+      }
+    }
+
+    if (w.circuit_breaker !== undefined) {
+      if (
+        typeof w.circuit_breaker !== 'object' ||
+        w.circuit_breaker === null ||
+        Array.isArray(w.circuit_breaker)
+      ) {
+        details.push('worca.circuit_breaker must be an object');
+      } else if (w.circuit_breaker.classifier_model !== undefined) {
+        if (!VALID_MODELS.includes(w.circuit_breaker.classifier_model)) {
+          details.push(
+            `classifier_model must be one of: ${VALID_MODELS.join(', ')}`,
+          );
+        }
+      }
+    }
+  }
+
+  return details.length ? { valid: false, details } : { valid: true };
+}
+
+export function createPreferencesRouter({ prefsDir }) {
+  const router = Router();
+  const globalSettingsPath = join(prefsDir, 'settings.json');
+
+  router.get('/', (_req, res) => {
+    try {
+      const prefs = readGlobalSettings(globalSettingsPath);
+      res.json({ ok: true, preferences: prefs });
+    } catch (err) {
+      res.status(500).json({
+        ok: false,
+        error: 'Failed to read global preferences',
+        detail: err.message,
+      });
+    }
+  });
+
+  router.put('/', (req, res) => {
+    const body = req.body;
+    if (!body || typeof body !== 'object' || Array.isArray(body)) {
+      return res.status(400).json({
+        ok: false,
+        error: {
+          code: 'validation_error',
+          message: 'Request body must be a JSON object',
+          details: [],
+        },
+      });
+    }
+
+    const validation = validateGlobalSettingsPayload(body);
+    if (!validation.valid) {
+      return res.status(400).json({
+        ok: false,
+        error: {
+          code: 'validation_error',
+          message: 'Invalid preferences payload',
+          details: validation.details,
+        },
+      });
+    }
+
+    try {
+      const merged = writeGlobalSettings(globalSettingsPath, body);
+      res.json({ ok: true, preferences: merged });
+    } catch (err) {
+      res.status(500).json({
+        ok: false,
+        error: 'Failed to write global preferences',
+        detail: err.message,
+      });
+    }
+  });
+
+  return router;
+}

package/server/process-manager.js

@@ -22,6 +22,8 @@ import { tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
 
 import { dispatchExternal } from './dispatch-external.js';
+import { readGlobalSettings } from './settings-reader.js';
+import { removeWorktree } from './worktree-ops.js';
 
 /** Byte threshold — must match claude_cli.py _ARG_INLINE_LIMIT */
 const ARG_INLINE_LIMIT = 128 * 1024;
@@ -78,10 +80,11 @@ export class ProcessManager {
   /**
    * @param {{ worcaDir: string, projectRoot?: string, settingsPath?: string }} options
    */
-  constructor({ worcaDir, projectRoot, settingsPath }) {
+  constructor({ worcaDir, projectRoot, settingsPath, prefsDir }) {
     this.worcaDir = worcaDir;
     this.projectRoot = projectRoot || process.cwd();
     this.settingsPath = settingsPath ?? null;
+    this.prefsDir = prefsDir ?? null;
   }
 
   /**
@@ -127,10 +130,17 @@ export class ProcessManager {
    * @returns {{ pid: number } | null}
    */
   getRunningPid(runId) {
-    // Build candidate PID paths: per-run first, then project-level fallback
+    // Build candidate PID paths: per-run first (with worktree overlay),
+    // then project-level fallback. Worktree runs live under
+    // <worktree_path>/.worca/runs/<id>/ and are routed via pipelines.d/.
     const candidates = [];
     if (runId) {
-      candidates.push(join(this.worcaDir, 'runs', runId, 'pipeline.pid'));
+      const ctx = this.resolveRunContext(runId);
+      if (ctx) {
+        candidates.push(join(ctx.runDir, 'pipeline.pid'));
+      } else {
+        candidates.push(join(this.worcaDir, 'runs', runId, 'pipeline.pid'));
+      }
     }
     candidates.push(join(this.worcaDir, 'pipeline.pid'));
 
@@ -285,12 +295,76 @@ export class ProcessManager {
           }
         }
       }
+
+      this.maybeAutoCleanup(runId);
     }
 
     await Promise.all(dispatches);
     return fixed;
   }
 
+  /**
+   * Post-completion cleanup hook (§5b).
+   * When cleanup_policy is 'on-success' and the run completed cleanly,
+   * removes the worktree via worktree-ops and emits a worktree.auto_cleanup
+   * event. 'never' (default) and 'manual-only' are both no-ops.
+   * @param {string} runId
+   * @returns {{ cleaned: boolean, runId?: string, path?: string, reason?: string }}
+   */
+  maybeAutoCleanup(runId) {
+    const ctx = this.resolveRunContext(runId);
+    const runDir = ctx ? ctx.runDir : join(this.worcaDir, 'runs', runId);
+    const statusPath = join(runDir, 'status.json');
+
+    if (!existsSync(statusPath)) return { cleaned: false };
+
+    let status;
+    try {
+      status = JSON.parse(readFileSync(statusPath, 'utf8'));
+    } catch {
+      return { cleaned: false };
+    }
+
+    const worktreePath = status.worktree_path;
+    if (!worktreePath) return { cleaned: false };
+
+    const exitOk = status.pipeline_status === 'completed';
+    if (!exitOk) return { cleaned: false };
+
+    let policy = 'never';
+    if (this.prefsDir) {
+      try {
+        const globalPrefs = readGlobalSettings(
+          join(this.prefsDir, 'settings.json'),
+        );
+        policy = globalPrefs?.worca?.parallel?.cleanup_policy ?? 'never';
+      } catch {
+        // Fall back to default 'never'
+      }
+    }
+
+    if (policy !== 'on-success') return { cleaned: false };
+
+    removeWorktree(this.worcaDir, runId);
+
+    try {
+      const eventsPath = join(runDir, 'events.jsonl');
+      const evt = {
+        schema_version: '1',
+        event_id: randomUUID(),
+        event_type: 'worktree.auto_cleanup',
+        timestamp: new Date().toISOString(),
+        run_id: status.run_id ?? runId,
+        payload: { runId, path: worktreePath, reason: 'on-success' },
+      };
+      appendFileSync(eventsPath, `${JSON.stringify(evt)}\n`, 'utf8');
+    } catch {
+      /* non-fatal */
+    }
+
+    return { cleaned: true, runId, path: worktreePath, reason: 'on-success' };
+  }
+
   /**
    * Start a new pipeline run.
    * @param {{ inputType?: string, inputValue?: string, msize?: number, mloops?: number, planFile?: string, resume?: boolean, projectRoot?: string }} opts
@@ -527,14 +601,17 @@ export class ProcessManager {
     // Fire-and-forget: reconcileStatus is async but we intentionally don't
     // await it — this is a background cleanup path after the response is sent.
     const worcaDir = this.worcaDir;
-    const { settingsPath } = this;
+    const { settingsPath, prefsDir } = this;
     const watchdog = setTimeout(() => {
       try {
         process.kill(pid, 0); // check alive
         process.kill(pid, 'SIGKILL');
-        setTimeout(() => reconcileStatus(worcaDir, settingsPath), 500);
+        setTimeout(
+          () => reconcileStatus(worcaDir, settingsPath, prefsDir),
+          500,
+        );
       } catch {
-        reconcileStatus(worcaDir, settingsPath);
+        reconcileStatus(worcaDir, settingsPath, prefsDir);
       }
     }, 10000);
     watchdog.unref();
@@ -823,9 +900,13 @@ export function getRunningPid(worcaDir, runId) {
   return new ProcessManager({ worcaDir }).getRunningPid(runId);
 }
 
-/** @param {string} worcaDir @param {string} [settingsPath] */
-export function reconcileStatus(worcaDir, settingsPath) {
-  return new ProcessManager({ worcaDir, settingsPath }).reconcileStatus();
+/** @param {string} worcaDir @param {string} [settingsPath] @param {string} [prefsDir] */
+export function reconcileStatus(worcaDir, settingsPath, prefsDir) {
+  return new ProcessManager({
+    worcaDir,
+    settingsPath,
+    prefsDir,
+  }).reconcileStatus();
 }
 
 /** @param {string} worcaDir @param {object} opts */

package/server/process-registry.js

@@ -0,0 +1,92 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { atomicWriteSync } from './atomic-write.js';
+
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    if (err.code === 'EPERM') return true;
+    return false;
+  }
+}
+
+function clearStalePid(statusPath, status) {
+  try {
+    const patched = {
+      ...status,
+      pipeline_status: 'error',
+      error: 'Stale PID: process no longer running',
+    };
+    atomicWriteSync(statusPath, `${JSON.stringify(patched, null, 2)}\n`);
+  } catch {
+    // best-effort
+  }
+}
+
+/**
+ * Count running pipelines across all registered projects.
+ * Walks ~/.worca/projects.d/, checks each project's .worca/runs/ for
+ * status.json entries with pipeline_status=running, and verifies PID liveness.
+ * Prunes stale PIDs (dead processes still marked as running).
+ */
+export function countRunningPipelinesAcrossProjects(prefsDir) {
+  const projectsDir = join(prefsDir, 'projects.d');
+  if (!existsSync(projectsDir)) return 0;
+
+  let entries;
+  try {
+    entries = readdirSync(projectsDir);
+  } catch {
+    return 0;
+  }
+
+  let count = 0;
+
+  for (const file of entries) {
+    if (!file.endsWith('.json')) continue;
+
+    let project;
+    try {
+      project = JSON.parse(readFileSync(join(projectsDir, file), 'utf-8'));
+    } catch {
+      continue;
+    }
+
+    if (!project || typeof project.path !== 'string') continue;
+
+    const runsDir = join(project.path, '.worca', 'runs');
+    if (!existsSync(runsDir)) continue;
+
+    let runEntries;
+    try {
+      runEntries = readdirSync(runsDir);
+    } catch {
+      continue;
+    }
+
+    for (const runEntry of runEntries) {
+      const statusPath = join(runsDir, runEntry, 'status.json');
+      if (!existsSync(statusPath)) continue;
+
+      let status;
+      try {
+        status = JSON.parse(readFileSync(statusPath, 'utf-8'));
+      } catch {
+        continue;
+      }
+
+      if (status.pipeline_status !== 'running') continue;
+      if (!status.pid) continue;
+
+      if (isPidAlive(status.pid)) {
+        count++;
+      } else {
+        clearStalePid(statusPath, status);
+      }
+    }
+  }
+
+  return count;
+}