@worca/ui 0.8.1-rc.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-routes.js

@@ -20,6 +20,7 @@ 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 {
@@ -138,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)
@@ -169,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 });
@@ -267,6 +284,16 @@ export function createProjectRoutes({ prefsDir, projectRoot }) {
       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) {
@@ -290,7 +317,11 @@ export function createProjectRoutes({ prefsDir, projectRoot }) {
  * @param {{ prefsDir?: string|null }} [options] — prefsDir enables active
  *   worca-cc version lookup for /worca-status' `outdated` flag.
  */
-export function createProjectScopedRoutes({ prefsDir = null } = {}) {
+export function createProjectScopedRoutes({
+  prefsDir = null,
+  serverHost,
+  serverPort,
+} = {}) {
   const router = Router({ mergeParams: true });
   const prefsPath = prefsDir ? join(prefsDir, 'preferences.json') : null;
 
@@ -1365,6 +1396,17 @@ export function createProjectScopedRoutes({ prefsDir = null } = {}) {
 
     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

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