@worca/ui 0.8.1 → 0.9.0-rc.1

package/server/process-manager.js

@@ -4,8 +4,9 @@
  */
 
 import { spawn } from 'node:child_process';
-import { randomBytes } from 'node:crypto';
+import { randomBytes, randomUUID } from 'node:crypto';
 import {
+  appendFileSync,
   closeSync,
   existsSync,
   mkdirSync,
@@ -22,6 +23,19 @@ import { join } from 'node:path';
 /** Byte threshold — must match claude_cli.py _ARG_INLINE_LIMIT */
 const ARG_INLINE_LIMIT = 128 * 1024;
 
+const TERMINAL_EVENTS = [
+  'pipeline.run.interrupted',
+  'pipeline.run.failed',
+  'pipeline.run.completed',
+];
+
+function elapsedMsSince(startedAtIso) {
+  if (!startedAtIso) return 0;
+  const started = Date.parse(startedAtIso);
+  if (Number.isNaN(started)) return 0;
+  return Math.max(0, Date.now() - started);
+}
+
 /**
  * Write content to a temp file with restricted permissions (0o600) and return its path.
  * Used to avoid E2BIG when passing large prompts as CLI arguments.
@@ -163,10 +177,11 @@ export class ProcessManager {
 
       if (status.pipeline_status !== 'running') continue;
 
-      status.pipeline_status = 'failed';
       if (!status.stop_reason) {
         status.stop_reason = 'stale';
       }
+      status.pipeline_status =
+        status.stop_reason === 'stale' ? 'interrupted' : 'failed';
       try {
         writeFileSync(
           statusPath,
@@ -177,6 +192,50 @@ export class ProcessManager {
       } catch {
         /* ignore */
       }
+
+      // Append synthetic interrupted event if no terminal event exists yet
+      const eventsPath = join(this.worcaDir, 'runs', runId, 'events.jsonl');
+      let hasTerminalEvent = false;
+      if (existsSync(eventsPath)) {
+        try {
+          const lines = readFileSync(eventsPath, 'utf8')
+            .split('\n')
+            .filter(Boolean);
+          hasTerminalEvent = lines.some((line) => {
+            try {
+              const evt = JSON.parse(line);
+              return TERMINAL_EVENTS.includes(evt.event_type);
+            } catch {
+              return false;
+            }
+          });
+        } catch {
+          /* ignore */
+        }
+      }
+      if (!hasTerminalEvent) {
+        try {
+          const evt = {
+            schema_version: '1',
+            event_id: randomUUID(),
+            event_type: 'pipeline.run.interrupted',
+            timestamp: new Date().toISOString(),
+            run_id: status.run_id ?? runId,
+            pipeline: {
+              branch: status.branch ?? null,
+              work_request: status.work_request ?? null,
+            },
+            payload: {
+              interrupted_stage: status.current_stage ?? 'unknown',
+              elapsed_ms: elapsedMsSince(status.started_at),
+              source: 'reconcile',
+            },
+          };
+          appendFileSync(eventsPath, `${JSON.stringify(evt)}\n`, 'utf8');
+        } catch {
+          /* ignore */
+        }
+      }
     }
 
     return fixed;

package/server/project-registry.js

@@ -10,7 +10,9 @@ import {
   unlinkSync,
   writeFileSync,
 } from 'node:fs';
+import { readdir } from 'node:fs/promises';
 import { basename, isAbsolute, join } from 'node:path';
+import { checkWorcaInstalled, readProjectWorcaVersion } from './worca-setup.js';
 
 export const SLUG_RE = /^[a-z0-9_-]{1,64}$/i;
 const DEFAULT_MAX_PROJECTS = 20;
@@ -24,6 +26,7 @@ export function slugify(name) {
     .toLowerCase()
     .replace(/[^a-z0-9_-]/g, '-')
     .replace(/-{2,}/g, '-')
+    .replace(/^-+|-+$/g, '')
     .slice(0, 64);
 }
 
@@ -130,6 +133,40 @@ export function synthesizeDefaultProject(projectRoot) {
   };
 }
 
+const SCAN_MAX_RESULTS = 200;
+
+/**
+ * Scan a directory for immediate child folders that contain a .git subdirectory.
+ * Skips dotfiles (names starting with ".") and "node_modules".
+ * Returns entries sorted alphabetically by name, capped at SCAN_MAX_RESULTS.
+ *
+ * @param {string} dirPath - Absolute path to the parent directory
+ * @returns {Promise<{ name: string, path: string }[]>}
+ */
+export async function scanDirectory(dirPath) {
+  const entries = await readdir(dirPath, { withFileTypes: true });
+  const results = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+    const childPath = join(dirPath, entry.name);
+    if (existsSync(join(childPath, '.git'))) {
+      const installed = checkWorcaInstalled(childPath);
+      const worcaVersion = installed
+        ? readProjectWorcaVersion(childPath)
+        : null;
+      results.push({
+        name: entry.name,
+        path: childPath,
+        installed,
+        worcaVersion,
+      });
+      if (results.length >= SCAN_MAX_RESULTS) break;
+    }
+  }
+  return results.sort((a, b) => a.name.localeCompare(b.name));
+}
+
 /**
  * Read max projects from {prefsDir}/config.json. Defaults to 20.
  */

package/server/project-routes.js

@@ -20,9 +20,11 @@ import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { Router } from 'express';
 import { dbExists, getIssue, listIssues } from './beads-reader.js';
+import { ensureWebhookForUi } from './ensure-webhook.js';
 import { readPreferences } from './preferences.js';
 import { ProcessManager } from './process-manager.js';
 import {
+  getMaxProjects,
   readProjects,
   removeProject,
   SLUG_RE,
@@ -36,6 +38,8 @@ import {
   readMergedSettings,
 } from './settings-merge.js';
 import { validateSettingsPayload } from './settings-validator.js';
+import { isVersionBehind } from './version-check.js';
+import { getVersionInfo } from './versions.js';
 import { discoverRuns } from './watcher.js';
 import {
   checkWorcaInstalled,
@@ -135,7 +139,12 @@ export function projectResolver({ prefsDir, projectRoot }) {
 /**
  * Router for project CRUD: GET/POST/DELETE /api/projects[/:id]
  */
-export function createProjectRoutes({ prefsDir, projectRoot }) {
+export function createProjectRoutes({
+  prefsDir,
+  projectRoot,
+  serverHost,
+  serverPort,
+}) {
   const router = Router();
 
   // GET /api/projects — list all projects (or synthesized default)
@@ -166,6 +175,17 @@ export function createProjectRoutes({ prefsDir, projectRoot }) {
     }
     try {
       writeProject(prefsDir, entry);
+      // Auto-configure webhook so pipeline events reach this UI server
+      if (serverHost && serverPort) {
+        try {
+          ensureWebhookForUi(entry.path, {
+            host: serverHost,
+            port: serverPort,
+          });
+        } catch {
+          /* best-effort — don't fail project creation */
+        }
+      }
       res.status(201).json({ ok: true, project: entry });
     } catch (err) {
       res.status(400).json({ ok: false, error: err.message });
@@ -182,15 +202,128 @@ export function createProjectRoutes({ prefsDir, projectRoot }) {
     res.json({ ok: true, removed: id });
   });
 
+  // POST /api/projects/batch — register multiple projects atomically
+  router.post('/batch', (req, res) => {
+    const { projects: batch } = req.body || {};
+    if (!Array.isArray(batch) || batch.length === 0) {
+      return res
+        .status(400)
+        .json({ ok: false, error: 'projects must be a non-empty array' });
+    }
+
+    // Validate all entries first (all-or-nothing)
+    const failed = [];
+    for (const entry of batch) {
+      const validation = validateProjectEntry(entry);
+      if (!validation.valid) {
+        failed.push({ name: entry?.name ?? '', error: validation.error });
+        continue;
+      }
+      if (!existsSync(entry.path)) {
+        failed.push({
+          name: entry.name,
+          error: `directory does not exist: ${entry.path}`,
+        });
+      }
+    }
+    if (failed.length > 0) {
+      return res.status(400).json({
+        ok: false,
+        error: `${failed.length} project${failed.length > 1 ? 's' : ''} failed validation`,
+        failed,
+      });
+    }
+
+    // Check for intra-batch duplicate names
+    const batchNames = batch.map((e) => e?.name).filter(Boolean);
+    if (new Set(batchNames).size < batchNames.length) {
+      return res
+        .status(400)
+        .json({ ok: false, error: 'Duplicate names within batch' });
+    }
+
+    // Check for intra-batch duplicate paths
+    const batchPaths = batch.map((e) => e?.path).filter(Boolean);
+    if (new Set(batchPaths).size < batchPaths.length) {
+      return res
+        .status(400)
+        .json({ ok: false, error: 'Duplicate paths within batch' });
+    }
+
+    // Check for duplicate paths against existing projects
+    const existing = readProjects(prefsDir);
+    const existingPaths = new Set(
+      existing.map((p) => p.path.replace(/\/+$/, '')),
+    );
+    const duplicates = batch.filter((entry) =>
+      existingPaths.has(entry.path.replace(/\/+$/, '')),
+    );
+    if (duplicates.length > 0) {
+      return res.status(400).json({
+        ok: false,
+        error: `${duplicates.length} project${duplicates.length > 1 ? 's' : ''} already registered`,
+        failed: duplicates.map((entry) => ({
+          name: entry.name,
+          error: `path already registered: ${entry.path}`,
+        })),
+      });
+    }
+
+    // Check max projects limit
+    const max = getMaxProjects(prefsDir);
+    if (existing.length + batch.length > max) {
+      return res.status(400).json({
+        ok: false,
+        error: `adding ${batch.length} project${batch.length > 1 ? 's' : ''} would exceed the limit of ${max}`,
+      });
+    }
+
+    // Write all projects — roll back on partial failure
+    const written = [];
+    try {
+      for (const entry of batch) {
+        writeProject(prefsDir, entry);
+        written.push(entry.name);
+        if (serverHost && serverPort) {
+          try {
+            ensureWebhookForUi(entry.path, {
+              host: serverHost,
+              port: serverPort,
+            });
+          } catch {
+            /* best-effort */
+          }
+        }
+      }
+      res.status(201).json({ ok: true, projects: batch });
+    } catch (err) {
+      for (const name of written) {
+        try {
+          removeProject(prefsDir, name);
+        } catch {
+          // ignore rollback errors
+        }
+      }
+      res.status(400).json({ ok: false, error: err.message });
+    }
+  });
+
   return router;
 }
 
 /**
  * Router for project-scoped sub-routes.
  * The projectResolver middleware must run before this to set req.project.
+ * @param {{ prefsDir?: string|null }} [options] — prefsDir enables active
+ *   worca-cc version lookup for /worca-status' `outdated` flag.
  */
-export function createProjectScopedRoutes() {
+export function createProjectScopedRoutes({
+  prefsDir = null,
+  serverHost,
+  serverPort,
+} = {}) {
   const router = Router({ mergeParams: true });
+  const prefsPath = prefsDir ? join(prefsDir, 'preferences.json') : null;
 
   // Guard: run-related, cost, and pipeline routes require worcaDir
   function requireWorcaDir(req, res, next) {
@@ -1213,10 +1346,35 @@ export function createProjectScopedRoutes() {
     res.json({ ok: true, templates });
   });
 
-  // GET /api/projects/:projectId/worca-status — check worca installation state
-  router.get('/worca-status', (req, res) => {
-    const installed = checkWorcaInstalled(req.project.projectRoot);
-    res.json({ ok: true, installed });
+  // GET /api/projects/:projectId/worca-status — check worca installation state.
+  // `outdated` is true when the project's installed worca-cc version is
+  // strictly behind the active (dev-path or globally-installed) worca-cc.
+  router.get('/worca-status', async (req, res) => {
+    const { projectRoot } = req.project;
+    const installed = checkWorcaInstalled(projectRoot);
+    if (!installed) {
+      return res.json({
+        ok: true,
+        installed: false,
+        version: null,
+        outdated: false,
+      });
+    }
+    const version = readProjectWorcaVersion(projectRoot);
+    let outdated = false;
+    if (version != null) {
+      try {
+        const versionInfo = await getVersionInfo({
+          prefsPath,
+          worcaVersion: req.app.locals.worcaVersion || null,
+        });
+        outdated = isVersionBehind(version, versionInfo.activeWorcaCc);
+      } catch {
+        // Best-effort — if version lookup fails, treat as not outdated
+        outdated = false;
+      }
+    }
+    res.json({ ok: true, installed: true, version, outdated });
   });
 
   // POST /api/projects/:projectId/worca-setup — install or update worca
@@ -1238,6 +1396,17 @@ export function createProjectScopedRoutes() {
 
     try {
       const { pid } = runWorcaSetup(projectRoot, { source });
+      // Auto-configure webhook so pipeline events reach this UI server
+      if (serverHost && serverPort) {
+        try {
+          ensureWebhookForUi(projectRoot, {
+            host: serverHost,
+            port: serverPort,
+          });
+        } catch {
+          /* best-effort */
+        }
+      }
       res.json({ ok: true, pid });
     } catch (err) {
       res.status(500).json({ ok: false, error: err.message });

package/server/settings-validator.js

@@ -323,8 +323,35 @@ export function validateSettingsPayload(body) {
                 continue;
               }
               for (const v of val) {
-                if (!VALID_AGENTS.includes(v)) {
-                  details.push(`Unknown agent "${v}" in dispatch for "${key}"`);
+                if (typeof v !== 'string') {
+                  details.push(`Dispatch entry for "${key}" must be a string`);
+                }
+              }
+            }
+          }
+        }
+        if (g.subagent_dispatch !== undefined) {
+          if (
+            typeof g.subagent_dispatch !== 'object' ||
+            g.subagent_dispatch === null ||
+            Array.isArray(g.subagent_dispatch)
+          ) {
+            details.push('governance.subagent_dispatch must be an object');
+          } else {
+            for (const [key, val] of Object.entries(g.subagent_dispatch)) {
+              if (!VALID_AGENTS.includes(key)) {
+                details.push(`Unknown subagent_dispatch agent: "${key}"`);
+                continue;
+              }
+              if (!Array.isArray(val)) {
+                details.push(`subagent_dispatch for "${key}" must be an array`);
+                continue;
+              }
+              for (const v of val) {
+                if (typeof v !== 'string') {
+                  details.push(
+                    `subagent_dispatch entry for "${key}" must be a string`,
+                  );
                 }
               }
             }
@@ -505,3 +532,253 @@ export function validateSettingsPayload(body) {
 
   return details.length ? { valid: false, details } : { valid: true };
 }
+
+const VALID_WEBHOOK_OUT_FORMATS = [
+  'generic-json',
+  'slack-compatible',
+  'discord-compatible',
+  'teams-card',
+  'ntfy',
+  'plain-text',
+];
+
+export function validateIntegrationsConfig(cfg) {
+  const details = [];
+
+  if (cfg.schema_version === undefined || cfg.schema_version !== 1) {
+    details.push('schema_version must be present and equal to 1');
+  }
+
+  if (cfg.enabled !== undefined && typeof cfg.enabled !== 'boolean') {
+    details.push('enabled must be a boolean');
+  }
+
+  if (cfg.webhook_secret_env !== undefined) {
+    if (
+      typeof cfg.webhook_secret_env !== 'string' ||
+      cfg.webhook_secret_env.length === 0
+    ) {
+      details.push('webhook_secret_env must be a non-empty string');
+    }
+  }
+
+  if (cfg.webhook_secrets_env !== undefined) {
+    if (
+      typeof cfg.webhook_secrets_env !== 'string' ||
+      cfg.webhook_secrets_env.length === 0
+    ) {
+      details.push('webhook_secrets_env must be a non-empty string');
+    }
+  }
+
+  if (
+    cfg.strict_inbox_verification !== undefined &&
+    typeof cfg.strict_inbox_verification !== 'boolean'
+  ) {
+    details.push('strict_inbox_verification must be a boolean');
+  }
+
+  // telegram
+  if (cfg.telegram !== undefined) {
+    if (
+      typeof cfg.telegram !== 'object' ||
+      cfg.telegram === null ||
+      Array.isArray(cfg.telegram)
+    ) {
+      details.push('telegram must be an object');
+    } else {
+      const tg = cfg.telegram;
+      if (tg.enabled !== undefined && typeof tg.enabled !== 'boolean') {
+        details.push('telegram.enabled must be a boolean');
+      }
+      const hasTgToken =
+        (typeof tg.bot_token === 'string' && tg.bot_token.length > 0) ||
+        (typeof tg.bot_token_env === 'string' && tg.bot_token_env.length > 0);
+      if (!hasTgToken) {
+        details.push(
+          'telegram requires bot_token or bot_token_env (non-empty string)',
+        );
+      }
+      if (
+        tg.chat_id === undefined ||
+        (typeof tg.chat_id !== 'string' && typeof tg.chat_id !== 'number')
+      ) {
+        details.push('telegram.chat_id must be a string or number');
+      }
+      if (tg.events === undefined || !Array.isArray(tg.events)) {
+        details.push('telegram.events must be an array');
+      } else {
+        for (let i = 0; i < tg.events.length; i++) {
+          if (typeof tg.events[i] !== 'string' || tg.events[i].length === 0) {
+            details.push(`telegram.events[${i}] must be a non-empty string`);
+          }
+        }
+      }
+      if (tg.rate_limit_per_min !== undefined) {
+        if (
+          !Number.isInteger(tg.rate_limit_per_min) ||
+          tg.rate_limit_per_min < 1
+        ) {
+          details.push(
+            'telegram.rate_limit_per_min must be a positive integer',
+          );
+        }
+      }
+    }
+  }
+
+  // discord
+  if (cfg.discord !== undefined) {
+    if (
+      typeof cfg.discord !== 'object' ||
+      cfg.discord === null ||
+      Array.isArray(cfg.discord)
+    ) {
+      details.push('discord must be an object');
+    } else {
+      const dc = cfg.discord;
+      if (dc.enabled !== undefined && typeof dc.enabled !== 'boolean') {
+        details.push('discord.enabled must be a boolean');
+      }
+      const hasDcToken =
+        (typeof dc.bot_token === 'string' && dc.bot_token.length > 0) ||
+        (typeof dc.bot_token_env === 'string' && dc.bot_token_env.length > 0);
+      if (!hasDcToken) {
+        details.push(
+          'discord requires bot_token or bot_token_env (non-empty string)',
+        );
+      }
+      if (
+        dc.channel_id === undefined ||
+        typeof dc.channel_id !== 'string' ||
+        dc.channel_id.length === 0
+      ) {
+        details.push('discord.channel_id must be a non-empty string');
+      }
+      if (dc.events !== undefined && !Array.isArray(dc.events)) {
+        details.push('discord.events must be an array');
+      } else if (Array.isArray(dc.events)) {
+        for (let i = 0; i < dc.events.length; i++) {
+          if (typeof dc.events[i] !== 'string' || dc.events[i].length === 0) {
+            details.push(`discord.events[${i}] must be a non-empty string`);
+          }
+        }
+      }
+    }
+  }
+
+  // slack
+  if (cfg.slack !== undefined) {
+    if (
+      typeof cfg.slack !== 'object' ||
+      cfg.slack === null ||
+      Array.isArray(cfg.slack)
+    ) {
+      details.push('slack must be an object');
+    } else {
+      const sl = cfg.slack;
+      if (sl.enabled !== undefined && typeof sl.enabled !== 'boolean') {
+        details.push('slack.enabled must be a boolean');
+      }
+      const hasSlUrl =
+        (typeof sl.webhook_url === 'string' && sl.webhook_url.length > 0) ||
+        (typeof sl.webhook_url_env === 'string' &&
+          sl.webhook_url_env.length > 0);
+      if (!hasSlUrl) {
+        details.push(
+          'slack requires webhook_url or webhook_url_env (non-empty string)',
+        );
+      }
+      if (sl.events !== undefined && !Array.isArray(sl.events)) {
+        details.push('slack.events must be an array');
+      } else if (Array.isArray(sl.events)) {
+        for (let i = 0; i < sl.events.length; i++) {
+          if (typeof sl.events[i] !== 'string' || sl.events[i].length === 0) {
+            details.push(`slack.events[${i}] must be a non-empty string`);
+          }
+        }
+      }
+    }
+  }
+
+  // webhook_out
+  if (cfg.webhook_out !== undefined) {
+    if (
+      typeof cfg.webhook_out !== 'object' ||
+      cfg.webhook_out === null ||
+      Array.isArray(cfg.webhook_out)
+    ) {
+      details.push('webhook_out must be an object');
+    } else {
+      const wo = cfg.webhook_out;
+      if (wo.enabled !== undefined && typeof wo.enabled !== 'boolean') {
+        details.push('webhook_out.enabled must be a boolean');
+      }
+      if (wo.endpoints !== undefined) {
+        if (!Array.isArray(wo.endpoints)) {
+          details.push('webhook_out.endpoints must be an array');
+        } else {
+          for (let i = 0; i < wo.endpoints.length; i++) {
+            const ep = wo.endpoints[i];
+            const pfx = `webhook_out.endpoints[${i}]`;
+            if (typeof ep !== 'object' || ep === null || Array.isArray(ep)) {
+              details.push(`${pfx} must be an object`);
+              continue;
+            }
+            if (
+              ep.url === undefined ||
+              typeof ep.url !== 'string' ||
+              ep.url.trim().length === 0
+            ) {
+              details.push(`${pfx}.url must be a non-empty string`);
+            } else {
+              try {
+                const parsed = new URL(ep.url);
+                if (
+                  parsed.protocol !== 'http:' &&
+                  parsed.protocol !== 'https:'
+                ) {
+                  details.push(`${pfx}.url must use http or https protocol`);
+                }
+              } catch {
+                details.push(`${pfx}.url is not a valid URL`);
+              }
+            }
+            if (ep.format !== undefined) {
+              if (!VALID_WEBHOOK_OUT_FORMATS.includes(ep.format)) {
+                details.push(
+                  `${pfx}.format must be one of: ${VALID_WEBHOOK_OUT_FORMATS.join(', ')}`,
+                );
+              }
+            }
+            if (ep.headers !== undefined) {
+              if (
+                typeof ep.headers !== 'object' ||
+                ep.headers === null ||
+                Array.isArray(ep.headers)
+              ) {
+                details.push(`${pfx}.headers must be an object`);
+              }
+            }
+            if (ep.events !== undefined && !Array.isArray(ep.events)) {
+              details.push(`${pfx}.events must be an array`);
+            } else if (Array.isArray(ep.events)) {
+              for (let j = 0; j < ep.events.length; j++) {
+                if (
+                  typeof ep.events[j] !== 'string' ||
+                  ep.events[j].length === 0
+                ) {
+                  details.push(
+                    `${pfx}.events[${j}] must be a non-empty string`,
+                  );
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return details.length ? { valid: false, details } : { valid: true };
+}