@worca/ui 0.13.0 → 0.15.1

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;
+}