@worca/ui 0.12.0 → 0.14.0

package/app/protocol.js

@@ -2,7 +2,7 @@
  * Protocol definitions for worca-ui WebSocket communication.
  */
 
-/** @typedef {'subscribe-run'|'unsubscribe-run'|'subscribe-log'|'unsubscribe-log'|'list-runs'|'get-agent-prompt'|'get-preferences'|'set-preferences'|'stop-run'|'resume-run'|'list-beads-issues'|'start-beads-issue'|'list-beads-counts'|'list-beads-refs'|'list-beads-unlinked'|'run-snapshot'|'run-update'|'runs-list'|'log-line'|'log-bulk'|'preferences'|'run-started'|'run-stopped'|'stage-restarted'|'beads-update'} MessageType */
+/** @typedef {'subscribe-run'|'unsubscribe-run'|'subscribe-log'|'unsubscribe-log'|'list-runs'|'get-agent-prompt'|'get-preferences'|'set-preferences'|'stop-run'|'resume-run'|'list-beads-issues'|'start-beads-issue'|'list-beads-counts'|'list-beads-refs'|'list-beads-unlinked'|'run-snapshot'|'run-update'|'runs-list'|'log-line'|'log-bulk'|'preferences'|'run-started'|'run-stopped'|'stage-restarted'|'beads-update'|'hello'|'hello-ack'} MessageType */
 
 /** @type {MessageType[]} */
 export const MESSAGE_TYPES = [
@@ -29,12 +29,6 @@ export const MESSAGE_TYPES = [
   // Protocol handshake
   'hello',
   'hello-ack',
-  // Parallel pipelines
-  'list-pipelines',
-  'subscribe-pipeline',
-  'unsubscribe-pipeline',
-  'pipeline-status-changed',
-  'pipelines-list',
   // Server → Client events
   'run-snapshot',
   'run-update',

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;
 }
 
@@ -4525,3 +4533,61 @@ sl-tooltip.bead-tooltip::part(body) {
   padding: 2rem;
 }
 
+
+/* --- Worktrees view --- */
+.worktrees-view {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+}
+.worktrees-summary {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px 6px;
+  align-items: baseline;
+  padding: 6px 0 2px;
+  font-size: 12px;
+  color: var(--muted);
+  font-variant-numeric: tabular-nums;
+}
+.worktrees-summary .meta-sep {
+  color: var(--border-subtle);
+  margin: 0 2px;
+}
+.worktrees-disk-alert {
+  margin-bottom: 4px;
+}
+.worktrees-toolbar {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  flex-wrap: wrap;
+}
+.worktrees-toolbar .worktrees-filter {
+  flex: 1;
+  min-width: 240px;
+}
+.worktree-card-path {
+  align-items: baseline;
+}
+.worktree-path-mono {
+  font-family: var(--font-mono, ui-monospace, SFMono-Regular, Menlo, monospace);
+  font-size: 11px;
+  color: var(--muted);
+  word-break: break-all;
+}
+.worktrees-bulk-groups {
+  margin: 8px 0 0;
+  padding-left: 18px;
+  font-size: 13px;
+  color: var(--muted);
+}
+.worktrees-bulk-groups li {
+  margin-bottom: 2px;
+}
+.dialog-actions {
+  display: flex;
+  gap: 8px;
+  justify-content: flex-end;
+  width: 100%;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@worca/ui",
-  "version": "0.12.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;
+}