@worca/ui 0.1.0-rc.1

package/server/index.js

@@ -0,0 +1,131 @@
+// server/index.js
+import { readFileSync } from 'node:fs';
+import { createServer } from 'node:http';
+import { homedir, platform } from 'node:os';
+import { join } from 'node:path';
+import { createApp } from './app.js';
+import { attachWsServer } from './ws.js';
+
+// Parse argv
+let port = parseInt(process.env.PORT, 10) || 3400;
+let host = process.env.HOST || '127.0.0.1';
+let isGlobal = false;
+for (let i = 0; i < process.argv.length; i++) {
+  if (process.argv[i] === '--port' && process.argv[i + 1])
+    port = parseInt(process.argv[++i], 10);
+  if (process.argv[i] === '--host' && process.argv[i + 1])
+    host = process.argv[++i];
+  if (process.argv[i] === '--global') isGlobal = true;
+}
+
+// Resolve project root: walk up from cwd until we find .claude/settings.json
+import { existsSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+function findProjectRoot(startDir) {
+  let dir = startDir;
+  while (dir !== dirname(dir)) {
+    if (existsSync(join(dir, '.claude', 'settings.json'))) return dir;
+    dir = dirname(dir);
+  }
+  return startDir; // fallback
+}
+
+import { createInbox } from './webhook-inbox.js';
+
+let projectRoot, worcaDir, settingsPath;
+
+if (isGlobal) {
+  // Global mode: no project root needed
+  projectRoot = null;
+  worcaDir = null;
+  settingsPath = null;
+} else {
+  // Per-project mode: resolve from cwd
+  projectRoot = findProjectRoot(process.cwd());
+  worcaDir = join(projectRoot, '.worca');
+  settingsPath = join(projectRoot, '.claude', 'settings.json');
+}
+
+const prefsDir = join(homedir(), '.worca');
+const webhookInbox = createInbox();
+const app = createApp({
+  settingsPath,
+  worcaDir,
+  projectRoot,
+  webhookInbox,
+  prefsDir,
+});
+const server = createServer(app);
+
+// Register error handler BEFORE attachWsServer — the WSS constructor adds its
+// own error forwarder on the HTTP server, so our handler must be first in line.
+server.on('error', (err) => {
+  if (err.code === 'EADDRINUSE') {
+    console.error(
+      `\n  Error: Port ${port} is already in use (${host}:${port})\n`,
+    );
+    console.error('  To fix this, either:\n');
+    console.error(
+      `    1. Start on a different port:  worca-ui start --port ${port + 1}`,
+    );
+    console.error(
+      `       Or directly:                PORT=${port + 1} npm start\n`,
+    );
+    console.error('    2. Stop the existing server:   worca-ui stop');
+    if (!isGlobal) {
+      console.error(
+        '       Or the global server:       worca-ui stop --global',
+      );
+    }
+    console.error(`\n    3. Find what's using the port: lsof -i :${port}\n`);
+  } else {
+    console.error(`\n  Error: Failed to start server — ${err.message}\n`);
+  }
+  process.exit(1);
+});
+
+const { broadcast, scheduleRefresh, resolveRunProject } = attachWsServer(
+  server,
+  {
+    worcaDir,
+    settingsPath,
+    prefsPath: join(homedir(), '.worca', 'preferences.json'),
+    prefsDir,
+    webhookInbox,
+    projectRoot,
+  },
+);
+
+// Expose broadcast, scheduleRefresh, and resolveRunProject to REST route handlers
+app.locals.broadcast = broadcast;
+app.locals.scheduleRefresh = scheduleRefresh;
+app.locals.resolveRunProject = resolveRunProject;
+
+// ─── inotify budget check (Linux only) ─────────────────────────────────
+if (platform() === 'linux') {
+  try {
+    const max = parseInt(
+      readFileSync('/proc/sys/fs/inotify/max_user_watches', 'utf8').trim(),
+      10,
+    );
+    if (Number.isFinite(max)) {
+      if (max < 8192) {
+        console.warn(
+          `[inotify] max_user_watches=${max} is very low. ` +
+            `Run: sudo sysctl fs.inotify.max_user_watches=524288`,
+        );
+      } else {
+        console.log(`[inotify] max_user_watches=${max}`);
+      }
+    }
+  } catch {
+    // /proc not available or not readable — skip
+  }
+}
+
+server.listen(port, host, () => {
+  console.log(
+    `worca-ui${isGlobal ? ' (global)' : ''} running at http://${host}:${port}`,
+  );
+});

package/server/log-tailer.js

@@ -0,0 +1,156 @@
+import {
+  closeSync,
+  existsSync,
+  openSync,
+  readdirSync,
+  readFileSync,
+  readSync,
+  statSync,
+} from 'node:fs';
+import { join } from 'node:path';
+import { STAGE_ORDER_WITH_ORCHESTRATOR } from '../app/utils/stage-order.js';
+
+/** Re-export for consumers (includes orchestrator). */
+export const STAGE_ORDER = STAGE_ORDER_WITH_ORCHESTRATOR;
+
+export function resolveLogPath(worcaDir, stage, iteration = null) {
+  if (!stage) return join(worcaDir, 'logs', 'orchestrator.log');
+  if (iteration !== null) {
+    return join(worcaDir, 'logs', stage, `iter-${iteration}.log`);
+  }
+  return join(worcaDir, 'logs', stage);
+}
+
+export function resolveIterationLogPath(worcaDir, stage, iteration) {
+  return join(worcaDir, 'logs', stage, `iter-${iteration}.log`);
+}
+
+export function listIterationFiles(worcaDir, stage) {
+  const stageDir = join(worcaDir, 'logs', stage);
+  if (!existsSync(stageDir)) return [];
+  try {
+    return readdirSync(stageDir)
+      .filter((f) => /^iter-\d+\.log$/.test(f))
+      .sort((a, b) => {
+        const an = parseInt(a.match(/\d+/)[0], 10);
+        const bn = parseInt(b.match(/\d+/)[0], 10);
+        return an - bn;
+      })
+      .map((f) => ({
+        iteration: parseInt(f.match(/\d+/)[0], 10),
+        path: join(stageDir, f),
+      }));
+  } catch {
+    return [];
+  }
+}
+
+export function readLastLines(filePath, n) {
+  if (!existsSync(filePath)) return [];
+  try {
+    const content = readFileSync(filePath, 'utf8');
+    const lines = content.split('\n').filter((l) => l.length > 0);
+    return lines.slice(-n);
+  } catch {
+    return [];
+  }
+}
+
+export function countLines(filePath) {
+  if (!existsSync(filePath)) return 0;
+  try {
+    const content = readFileSync(filePath, 'utf8');
+    return content.split('\n').filter((l) => l.length > 0).length;
+  } catch {
+    return 0;
+  }
+}
+
+export function readLinesFrom(filePath, startLine) {
+  if (!existsSync(filePath)) return [];
+  try {
+    const content = readFileSync(filePath, 'utf8');
+    const lines = content.split('\n').filter((l) => l.length > 0);
+    return lines.slice(startLine);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Return the byte length of a file (0 if missing/unreadable).
+ * Used as the initial offset when starting to tail a log file.
+ */
+export function fileByteLength(filePath) {
+  try {
+    return statSync(filePath).size;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Read new lines from a file starting at `byteOffset`.
+ * Returns `{ lines: string[], newOffset: number }`.
+ * Only the bytes after the offset are read, making this O(delta) instead of O(n).
+ */
+export function readNewLines(filePath, byteOffset) {
+  try {
+    const size = statSync(filePath).size;
+    if (size <= byteOffset) return { lines: [], newOffset: byteOffset };
+    const fd = openSync(filePath, 'r');
+    try {
+      const len = size - byteOffset;
+      const buf = Buffer.alloc(len);
+      readSync(fd, buf, 0, len, byteOffset);
+      const text = buf.toString('utf8');
+      const lines = text.split('\n').filter((l) => l.length > 0);
+      return { lines, newOffset: size };
+    } finally {
+      closeSync(fd);
+    }
+  } catch {
+    return { lines: [], newOffset: byteOffset };
+  }
+}
+
+export function listLogFiles(worcaDir) {
+  const logsDir = join(worcaDir, 'logs');
+  if (!existsSync(logsDir)) return [];
+  try {
+    const entries = readdirSync(logsDir, { withFileTypes: true });
+    const files = [];
+
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.endsWith('.log')) {
+        // Legacy flat file (e.g., orchestrator.log)
+        files.push({
+          stage: entry.name.replace('.log', ''),
+          path: join(logsDir, entry.name),
+        });
+      } else if (entry.isDirectory()) {
+        // Nested stage directory — list iteration files
+        const iters = listIterationFiles(worcaDir, entry.name);
+        for (const iter of iters) {
+          files.push({
+            stage: entry.name,
+            iteration: iter.iteration,
+            path: iter.path,
+          });
+        }
+      }
+    }
+
+    // Sort by pipeline stage order, then by iteration
+    files.sort((a, b) => {
+      const ai = STAGE_ORDER.indexOf(a.stage);
+      const bi = STAGE_ORDER.indexOf(b.stage);
+      const orderDiff = (ai === -1 ? 999 : ai) - (bi === -1 ? 999 : bi);
+      if (orderDiff !== 0) return orderDiff;
+      return (a.iteration || 0) - (b.iteration || 0);
+    });
+    return files;
+  } catch {
+    return [];
+  }
+}

package/server/multi-watcher.js

@@ -0,0 +1,237 @@
+/**
+ * MultiWatcher — watches .worca/multi/pipelines.d/ for a project,
+ * tracking parallel pipeline instances and their status changes.
+ *
+ * Each pipeline in pipelines.d/{run_id}.json is monitored. On status
+ * changes, broadcasts 'pipeline-status-changed' events. Optionally
+ * creates per-worktree WatcherSets for log/status streaming.
+ */
+
+import { existsSync, watch } from 'node:fs';
+import { readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { TIER_FULL, TIER_POLLING, WatcherSet } from './watcher-set.js';
+
+export class MultiWatcher {
+  /**
+   * @param {string} projectId — parent project name
+   * @param {string} worcaDir — parent project's .worca/ directory
+   * @param {{ broadcaster, getSubs, wss, settingsPath, projectRoot, webhookInbox }} deps
+   */
+  constructor(projectId, worcaDir, deps) {
+    this.projectId = projectId;
+    this.worcaDir = worcaDir;
+    this._deps = deps;
+    this._dirWatcher = null;
+    this._debounceTimer = null;
+    this._closed = false;
+
+    /** @type {Map<string, { entry: object, watcherSet: WatcherSet|null }>} */
+    this.pipelines = new Map();
+  }
+
+  /** Start watching pipelines.d/ directory. */
+  start() {
+    this._syncPipelines(); // Initial scan
+
+    const pipelinesDir = join(this.worcaDir, 'multi', 'pipelines.d');
+    if (existsSync(pipelinesDir)) {
+      try {
+        this._dirWatcher = watch(pipelinesDir, { persistent: false }, () => {
+          if (this._closed) return;
+          if (this._debounceTimer) clearTimeout(this._debounceTimer);
+          this._debounceTimer = setTimeout(() => {
+            this._debounceTimer = null;
+            if (!this._closed) this._syncPipelines();
+          }, 300);
+        });
+      } catch {
+        // fs.watch not supported or dir doesn't exist — skip
+      }
+    }
+  }
+
+  /** Scan pipelines.d/, diff against current map, broadcast changes. */
+  async _syncPipelines() {
+    const pipelinesDir = join(this.worcaDir, 'multi', 'pipelines.d');
+    const freshEntries = new Map();
+
+    try {
+      const files = await readdir(pipelinesDir);
+      const readPromises = files
+        .filter((f) => f.endsWith('.json'))
+        .map(async (fname) => {
+          try {
+            const entry = JSON.parse(
+              await readFile(join(pipelinesDir, fname), 'utf8'),
+            );
+            return entry.run_id ? [entry.run_id, entry] : null;
+          } catch {
+            return null;
+          }
+        });
+      for (const result of await Promise.all(readPromises)) {
+        if (result) freshEntries.set(result[0], result[1]);
+      }
+    } catch {
+      // directory doesn't exist or unreadable — freshEntries stays empty
+    }
+
+    // Add new pipelines or update changed ones
+    for (const [runId, entry] of freshEntries) {
+      const existing = this.pipelines.get(runId);
+      if (!existing) {
+        this._addPipeline(runId, entry);
+      } else if (
+        existing.entry.status !== entry.status ||
+        existing.entry.stage !== entry.stage
+      ) {
+        // Destroy WatcherSet when pipeline transitions out of running
+        if (
+          existing.entry.status === 'running' &&
+          entry.status !== 'running' &&
+          existing.watcherSet
+        ) {
+          try {
+            existing.watcherSet.destroy();
+          } catch {
+            /* ignore */
+          }
+          existing.watcherSet = null;
+        }
+        existing.entry = entry;
+        this._broadcastPipelineStatus(runId, entry);
+      }
+    }
+
+    // Remove deleted pipelines
+    for (const runId of [...this.pipelines.keys()]) {
+      if (!freshEntries.has(runId)) {
+        this._removePipeline(runId);
+      }
+    }
+  }
+
+  /** Register a new pipeline and broadcast its status. */
+  _addPipeline(runId, entry) {
+    let watcherSet = null;
+
+    // Create a WatcherSet for running worktree pipelines
+    if (entry.worktree_path && entry.status === 'running') {
+      const worktreeWorcaDir = join(entry.worktree_path, '.worca');
+      if (existsSync(worktreeWorcaDir)) {
+        try {
+          const pipelineProjectId = `${this.projectId}::${runId}`;
+          watcherSet = new WatcherSet(
+            pipelineProjectId,
+            worktreeWorcaDir,
+            {
+              ...this._deps,
+              settingsPath: join(
+                entry.worktree_path,
+                '.claude',
+                'settings.json',
+              ),
+              projectRoot: entry.worktree_path,
+            },
+            // Skip creating a nested MultiWatcher in pipeline WatcherSets
+            { _skipMultiWatcher: true },
+          );
+          watcherSet.create();
+          // Start in POLLING tier — promoted when user subscribes
+        } catch (err) {
+          console.error(
+            `[MultiWatcher:${this.projectId}] Failed to create WatcherSet for pipeline ${runId}:`,
+            err.message,
+          );
+          watcherSet = null;
+        }
+      }
+    }
+
+    this.pipelines.set(runId, { entry, watcherSet });
+    this._broadcastPipelineStatus(runId, entry);
+  }
+
+  /** Destroy a pipeline's WatcherSet and broadcast removal. */
+  _removePipeline(runId) {
+    const pipeline = this.pipelines.get(runId);
+    if (pipeline?.watcherSet) {
+      try {
+        pipeline.watcherSet.destroy();
+      } catch {
+        // ignore cleanup errors
+      }
+    }
+    this.pipelines.delete(runId);
+    this._deps.broadcaster.broadcast('pipeline-status-changed', {
+      project: this.projectId,
+      runId,
+      status: 'removed',
+    });
+  }
+
+  /** Broadcast a pipeline status change event. */
+  _broadcastPipelineStatus(runId, entry) {
+    this._deps.broadcaster.broadcast('pipeline-status-changed', {
+      project: this.projectId,
+      runId,
+      status: entry.status,
+      stage: entry.stage || null,
+      title: entry.title || null,
+      worktree_path: entry.worktree_path || null,
+      started_at: entry.started_at || null,
+      pid: entry.pid || null,
+    });
+  }
+
+  /** List current pipeline entries (for list-pipelines WS request). */
+  listPipelines() {
+    return Array.from(this.pipelines.values()).map((p) => p.entry);
+  }
+
+  /** Get WatcherSet for a specific pipeline (for log/status streaming). */
+  getPipelineWatcherSet(runId) {
+    return this.pipelines.get(runId)?.watcherSet || null;
+  }
+
+  /** Promote a pipeline's watcher to FULL tier (on user subscribe). */
+  promotePipeline(runId) {
+    const ws = this.pipelines.get(runId)?.watcherSet;
+    if (ws && ws.getTier() === TIER_POLLING) ws.setTier(TIER_FULL);
+  }
+
+  /** Demote a pipeline's watcher back to POLLING tier (on user unsubscribe). */
+  demotePipeline(runId) {
+    const ws = this.pipelines.get(runId)?.watcherSet;
+    if (ws && ws.getTier() === TIER_FULL) ws.setTier(TIER_POLLING);
+  }
+
+  /** Destroy all pipeline watchers and close directory watcher. Idempotent. */
+  destroy() {
+    if (this._closed) return;
+    this._closed = true;
+    if (this._dirWatcher) {
+      try {
+        this._dirWatcher.close();
+      } catch {
+        // ignore
+      }
+      this._dirWatcher = null;
+    }
+    if (this._debounceTimer) {
+      clearTimeout(this._debounceTimer);
+      this._debounceTimer = null;
+    }
+    for (const { watcherSet } of this.pipelines.values()) {
+      if (watcherSet) {
+        try {
+          watcherSet.destroy();
+        } catch {
+          // ignore cleanup errors
+        }
+      }
+    }
+    this.pipelines.clear();
+  }
+}

package/server/preferences.js

@@ -0,0 +1,17 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+const DEFAULTS = { theme: 'light' };
+
+export function readPreferences(path) {
+  try {
+    return { ...DEFAULTS, ...JSON.parse(readFileSync(path, 'utf8')) };
+  } catch {
+    return { ...DEFAULTS };
+  }
+}
+
+export function writePreferences(prefs, path) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(prefs, null, 2)}\n`);
+}