@worca/ui 0.9.0-rc.1 → 0.9.0

package/server/process-manager.js

@@ -4,9 +4,8 @@
  */
 
 import { spawn } from 'node:child_process';
-import { randomBytes, randomUUID } from 'node:crypto';
+import { randomBytes } from 'node:crypto';
 import {
-  appendFileSync,
   closeSync,
   existsSync,
   mkdirSync,
@@ -23,19 +22,6 @@ 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.
@@ -177,11 +163,10 @@ 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,
@@ -192,50 +177,6 @@ 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,7 +20,6 @@ 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 {
@@ -139,12 +138,7 @@ export function projectResolver({ prefsDir, projectRoot }) {
 /**
  * Router for project CRUD: GET/POST/DELETE /api/projects[/:id]
  */
-export function createProjectRoutes({
-  prefsDir,
-  projectRoot,
-  serverHost,
-  serverPort,
-}) {
+export function createProjectRoutes({ prefsDir, projectRoot }) {
   const router = Router();
 
   // GET /api/projects — list all projects (or synthesized default)
@@ -175,17 +169,6 @@ export function createProjectRoutes({
     }
     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 });
@@ -284,16 +267,6 @@ export function createProjectRoutes({
       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) {
@@ -317,11 +290,7 @@ export function createProjectRoutes({
  * @param {{ prefsDir?: string|null }} [options] — prefsDir enables active
  *   worca-cc version lookup for /worca-status' `outdated` flag.
  */
-export function createProjectScopedRoutes({
-  prefsDir = null,
-  serverHost,
-  serverPort,
-} = {}) {
+export function createProjectScopedRoutes({ prefsDir = null } = {}) {
   const router = Router({ mergeParams: true });
   const prefsPath = prefsDir ? join(prefsDir, 'preferences.json') : null;
 
@@ -1396,17 +1365,6 @@ 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

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

package/server/ensure-webhook.js

@@ -1,66 +0,0 @@
-// ensure-webhook.js — auto-configure a webhook pointing to this worca-ui instance
-// in a project's settings.local.json so the pipeline sends events to the UI.
-
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { localPathFor } from './settings-merge.js';
-
-/**
- * Ensure a webhook entry exists in the project's settings.local.json
- * pointing to the worca-ui inbox at the given host:port.
- *
- * Skips if a webhook for this host:port already exists.
- * Creates settings.local.json if it doesn't exist.
- *
- * @param {string} projectPath — absolute path to the project root
- * @param {{ host: string, port: number }} server — worca-ui server address
- */
-export function ensureWebhookForUi(projectPath, { host, port }) {
-  const settingsPath = join(projectPath, '.claude', 'settings.json');
-  const localPath = localPathFor(settingsPath);
-  // Use localhost instead of 127.0.0.1 — the pipeline validator only allows
-  // https:// or http://localhost for security.
-  const displayHost =
-    host === '127.0.0.1' || host === '::1' ? 'localhost' : host;
-  const inboxUrl = `http://${displayHost}:${port}/api/webhooks/inbox`;
-
-  // Read existing local settings (or start fresh)
-  let local = {};
-  if (existsSync(localPath)) {
-    try {
-      local = JSON.parse(readFileSync(localPath, 'utf8'));
-    } catch {
-      local = {};
-    }
-  }
-
-  if (!local.worca) local.worca = {};
-  if (!Array.isArray(local.worca.webhooks)) local.worca.webhooks = [];
-
-  // Check if a webhook for this URL already exists
-  const exists = local.worca.webhooks.some((wh) => wh.url === inboxUrl);
-  if (exists) return false;
-
-  // Also check base settings.json (in case it was manually configured there)
-  try {
-    const base = JSON.parse(readFileSync(settingsPath, 'utf8'));
-    const baseWebhooks = base?.worca?.webhooks || [];
-    if (baseWebhooks.some((wh) => wh.url === inboxUrl)) return false;
-  } catch {
-    // no base settings — proceed
-  }
-
-  local.worca.webhooks.push({
-    url: inboxUrl,
-    events: ['pipeline.*'],
-  });
-
-  // Ensure events are enabled
-  if (!local.worca.events) local.worca.events = {};
-  if (local.worca.events.enabled === undefined) {
-    local.worca.events.enabled = true;
-  }
-
-  writeFileSync(localPath, `${JSON.stringify(local, null, 2)}\n`, 'utf8');
-  return true;
-}