@amsterdamdatalabs/enact-factory 0.1.1

package/dist/support/web.js

@@ -0,0 +1,1097 @@
+// ============================================
+// EnactFactory - Web Interface
+// ============================================
+import { createServer } from 'node:http';
+import { writeFileSync, readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { addSSEClient, getActiveSSECount, broadcastEvent, getLogBuffer, getStageBuffer, getChatBuffer } from '../core/eventHub.js';
+import { formatCost } from '../support/costTracker.js';
+import { getRateLimiterMetrics } from '../support/rateLimiter.js';
+import { scanLocalProjects, invalidateProjectCache } from '../support/projectMapper.js';
+import { createDashboardHtml } from '../support/dashboardHtml.js';
+import { getProjectGitInfo, startGitStatusPoller } from '../support/gitStatus.js';
+import { getActiveMonitors, registerMonitor, unregisterMonitor } from '../automation/longRunningMonitor.js';
+import { getAllProcesses, killProcess, startHealthChecker } from '../adapters/processRegistry.js';
+import { setDefaultAdapter } from '../adapters/index.js';
+import { fetchQuota } from '../support/quotaTracker.js';
+import { PairPipeline } from '../agents/pairPipeline.js';
+import { initLocale } from '../locale/index.js';
+import { runChatCompletion, getDefaultChatModel } from '../support/chatBackend.js';
+import { handleTerminalWebSocketUpgrade, shutdownTerminalBridge } from '../support/terminalBridge.js';
+import { createWorkItemBoardHtml } from '../workItems/workItemBoardHtml.js';
+import { getWorkItemStore, syncFromAzdo, isAzdoBridgeReady } from '../workItems/index.js';
+import { getDaemonStatus, startDaemon, stopDaemon } from '../cli/daemon.js';
+import { getWorkItemState } from '../workItemState/store.js';
+import { handleFactoryApiRequest } from '../factory/http.js';
+import { getLaneStatusSnapshot } from '../core/laneStatus.js';
+import { buildDashboardSurfaceConfig } from '../core/dashboardContract.js';
+import { requireWorkspaceUiPort } from '../core/workspaceConfig.js';
+import { ensureAzdoSyncStarted, stopAzdoSync } from '../workItems/azdoSyncRuntime.js';
+let server = null;
+let runnerRef;
+// In-process DB health state — updated by the sync heartbeat and /api/health checks.
+// Exported so azdoSyncRuntime can mark it degraded on store errors.
+let _dbHealthy = true;
+export function setDbHealthy(ok) { _dbHealthy = ok; }
+export function getDbHealthy() { return _dbHealthy; }
+// The single UI port. Both `dash` and the daemon serve the dashboard here.
+function defaultUiPort() {
+    return requireWorkspaceUiPort();
+}
+// CORS origin allowlist — hostname-strict match (no substring/prefix pitfalls)
+function isAllowedOrigin(origin) {
+    let url;
+    try {
+        url = new URL(origin);
+    }
+    catch {
+        return false;
+    }
+    const { protocol, hostname } = url;
+    if (protocol !== 'http:' && protocol !== 'https:')
+        return false;
+    // Exact hostname matches
+    if (hostname === 'localhost' || hostname === '127.0.0.1')
+        return true;
+    if (hostname === 'tauri.localhost')
+        return true;
+    // Tailscale CGNAT range: 100.64.0.0/10 → first octet 100, second 64–127
+    const tailscaleMatch = hostname.match(/^100\.(\d{1,3})\.\d{1,3}\.\d{1,3}$/);
+    if (tailscaleMatch) {
+        const second = Number(tailscaleMatch[1]);
+        if (second >= 64 && second <= 127)
+            return true;
+    }
+    return false;
+}
+// Never leak raw Error objects (which include stack traces in many runtimes)
+// or arbitrary thrown values to HTTP responses.
+function safeErrorMessage(err) {
+    if (err instanceof Error && typeof err.message === 'string' && err.message) {
+        return err.message;
+    }
+    return 'Internal error';
+}
+const execWorkItems = new Map();
+const CHAT_PROVIDERS = new Set(['claude', 'codex', 'responses', 'cursor', 'hermes', 'opencode']);
+function cleanupExecWorkItem(workItemId) {
+    setTimeout(() => { execWorkItems.delete(workItemId); }, 3600000); // 1 hour
+}
+function isChatProvider(value) {
+    return typeof value === 'string' && CHAT_PROVIDERS.has(value);
+}
+function currentDashboardSurfaceConfig() {
+    return buildDashboardSurfaceConfig({
+        repoPaths: runnerRef?.getAllowedProjects() ?? [],
+        adapterSummary: runnerRef?.getAdapterSummary(),
+    });
+}
+// Pinned + enabled repos persistence
+const REPOS_FILE = join(homedir(), '.claude', 'enact-factory-repos.json');
+function loadReposConfig() {
+    try {
+        if (existsSync(REPOS_FILE)) {
+            return JSON.parse(readFileSync(REPOS_FILE, 'utf-8'));
+        }
+    }
+    catch (err) {
+        console.warn(`[Web] repos config 로드 실패:`, err instanceof Error ? err.message : err);
+    }
+    return { pinned: [], enabled: [], basePaths: [], removedConfigPaths: [] };
+}
+function saveReposConfig() {
+    try {
+        const cfg = {
+            pinned: Array.from(pinnedProjects),
+            enabled: runnerRef?.getEnabledProjects() ?? [],
+            basePaths: Array.from(customBasePaths),
+            removedConfigPaths: Array.from(removedConfigPaths),
+        };
+        writeFileSync(REPOS_FILE, JSON.stringify(cfg, null, 2));
+    }
+    catch (e) {
+        console.warn('[Web] Failed to save repos config:', e);
+    }
+}
+const _reposCfg = loadReposConfig();
+const pinnedProjects = new Set(_reposCfg.pinned);
+const customBasePaths = new Set(_reposCfg.basePaths ?? []);
+const removedConfigPaths = new Set(_reposCfg.removedConfigPaths ?? []);
+/** Expand a leading ~/ to the user's home directory (same logic as config.ts expandPath) */
+function expandConfigPath(p) {
+    if (p.startsWith('~/'))
+        return join(homedir(), p.slice(2));
+    return p;
+}
+/**
+ * Seed config.projects[] paths into pinnedProjects so the dashboard REPOSITORIES
+ * panel shows them even when the user has no [autonomous] section (allowedProjects
+ * defaults to ~/dev) and hasn't manually pinned anything.
+ *
+ * Runner-independent: this only mutates pinnedProjects and, when a runner is given,
+ * the runner's path cache. De-dupe by expanded path makes it safe to call from both
+ * startWebServer (dash mode) and setWebRunner (daemon mode) — second call is a no-op
+ * for already-seeded paths. The runner.enableProject() side (config enabled/paused)
+ * stays in setWebRunner and is NOT done here.
+ */
+export function seedConfigProjects(configProjects, runner) {
+    if (!configProjects || configProjects.length === 0)
+        return;
+    for (const project of configProjects) {
+        const resolvedPath = expandConfigPath(project.path);
+        // Skip paths the user explicitly removed from the dashboard
+        if (removedConfigPaths.has(resolvedPath))
+            continue;
+        // Pin if not already pinned (de-dupe by expanded path)
+        if (!pinnedProjects.has(resolvedPath)) {
+            pinnedProjects.add(resolvedPath);
+        }
+        // Register in path cache so Azdo project-name lookups resolve immediately
+        const name = resolvedPath.split('/').pop();
+        if (runner) {
+            runner.registerProjectPath(project.name, resolvedPath);
+            if (name && name !== project.name)
+                runner.registerProjectPath(name, resolvedPath);
+        }
+    }
+}
+/**
+ * Set runner reference (call after autonomous runner is initialized).
+ * @param configProjects - optional list from FactoryConfig.projects; when provided,
+ *   their expanded paths are seeded into pinnedProjects so the dashboard REPOSITORIES
+ *   panel shows them even before the user has manually pinned anything.
+ */
+export function setWebRunner(runner, configProjects) {
+    runnerRef = runner;
+    // Restore persisted enabled state
+    for (const path of _reposCfg.enabled) {
+        runner.enableProject(path);
+    }
+    // 대시보드에서 제거된 config 경로를 runner의 allowedProjects에서도 제거
+    if (removedConfigPaths.size > 0) {
+        const current = runner.getAllowedProjects();
+        const filtered = current.filter(p => !removedConfigPaths.has(p));
+        if (filtered.length !== current.length) {
+            runner.updateAllowedProjects(filtered);
+        }
+    }
+    // Seed config.projects[] paths into pinnedProjects + path cache (de-duped).
+    if (configProjects && configProjects.length > 0) {
+        seedConfigProjects(configProjects, runner);
+        // Apply config enabled/paused state — runner-dependent, so kept here.
+        // Only when the user hasn't explicitly managed this path via the UI
+        // (i.e. not in the persisted enabled list).
+        const persistedEnabled = new Set(_reposCfg.enabled);
+        for (const project of configProjects) {
+            const resolvedPath = expandConfigPath(project.path);
+            if (removedConfigPaths.has(resolvedPath))
+                continue;
+            if (!persistedEnabled.has(resolvedPath) && project.enabled && !project.paused) {
+                runner.enableProject(resolvedPath);
+            }
+        }
+    }
+    // Pre-seed path cache from pinned + enabled projects so workItems without execution history are still matched
+    const allSeeded = new Set([...pinnedProjects, ..._reposCfg.enabled]);
+    for (const path of allSeeded) {
+        const name = path.split('/').pop();
+        if (name)
+            runner.registerProjectPath(name, path);
+    }
+}
+// Read POST body helper
+function readBody(req) {
+    return new Promise((resolve) => {
+        let data = '';
+        req.on('data', (chunk) => { data += chunk.toString(); });
+        req.on('end', () => resolve(data));
+    });
+}
+// Start web server
+export async function startWebServer(port = defaultUiPort()) {
+    if (server) {
+        console.log('Web interface already running, skipping...');
+        return;
+    }
+    // Seed config.projects[] so the dashboard REPOSITORIES panel is populated even in
+    // dash mode (where setWebRunner is never called and there is no autonomous runner).
+    // De-dupe by expanded path means this is harmless if setWebRunner later runs too.
+    try {
+        const { loadRuntimeConfig } = await import('../core/runtimeConfig.js');
+        const config = await loadRuntimeConfig();
+        seedConfigProjects(config.projects, runnerRef);
+        // Always-on, in-process AzDO sync: opening the dashboard via EITHER `dash`
+        // or the daemon keeps Postgres live and gives instant in-process SSE. The
+        // shared runtime guards against a second heartbeat when the daemon's
+        // service path also calls this (idempotent singleton).
+        try {
+            await ensureAzdoSyncStarted(config.azureDevOps);
+        }
+        catch (err) {
+            console.warn('[Web] Could not start AzDO sync:', err instanceof Error ? err.message : err);
+        }
+    }
+    catch (err) {
+        console.warn('[Web] Could not seed config projects:', err instanceof Error ? err.message : err);
+    }
+    return new Promise((resolve, reject) => {
+        server = createServer(async (req, res) => {
+            const url = req.url?.split('?')[0] || '/';
+            // CORS: allow localhost, Tauri webview, and Tailscale network
+            const origin = req.headers.origin;
+            if (origin && isAllowedOrigin(origin)) {
+                res.setHeader('Access-Control-Allow-Origin', origin);
+                res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PATCH, DELETE');
+            }
+            if (await handleFactoryApiRequest(req, res)) {
+                return;
+            }
+            // ---- Work Item Board ----
+            if (url === '/workitems') {
+                res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                res.end(createWorkItemBoardHtml(currentDashboardSurfaceConfig()));
+                // ---- Work Item Board Sync (Azdo -> local sqlite) ----
+            }
+            else if (url === '/api/workitems/sync' && req.method === 'POST') {
+                if (!isAzdoBridgeReady()) {
+                    res.writeHead(202, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, reason: 'workitem_bridge_not_ready' }));
+                }
+                else {
+                    try {
+                        const result = await syncFromAzdo(await getWorkItemStore(), 'azdo', { limit: 250 });
+                        const syncedAt = Date.now();
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ ok: true, pulled: result.pulled, created: result.created, updated: result.updated, pruned: result.pruned, syncedAt }));
+                        broadcastEvent({ type: 'sync:complete', data: { syncedAt, pulled: result.pulled, pruned: result.pruned } });
+                    }
+                    catch (err) {
+                        res.writeHead(500, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ ok: false, error: safeErrorMessage(err) }));
+                    }
+                }
+                // ---- Dashboard ----
+            }
+            else if (url === '/' || url === '/index.html') {
+                res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                res.end(createDashboardHtml(currentDashboardSurfaceConfig()));
+                // ---- SSE stream ----
+            }
+            else if (url === '/api/events') {
+                const skipReplay = req.url?.includes('skipReplay=1') ?? false;
+                res.writeHead(200, {
+                    'Content-Type': 'text/event-stream',
+                    'Cache-Control': 'no-cache',
+                    'Connection': 'keep-alive',
+                });
+                res.write(':connected\n\n');
+                addSSEClient(res, skipReplay);
+                // ---- Stats ----
+            }
+            else if (url === '/api/stats') {
+                const stats = runnerRef?.getStats();
+                const state = runnerRef?.getState();
+                const adapters = runnerRef?.getAdapterSummary();
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    runningWorkItems: stats?.schedulerStats?.running ?? 0,
+                    queuedWorkItems: stats?.schedulerStats?.queued ?? 0,
+                    completedToday: stats?.schedulerStats?.completed ?? 0,
+                    uptime: state?.startedAt ? Date.now() - state.startedAt : 0,
+                    isRunning: stats?.isRunning ?? false,
+                    sseClients: getActiveSSECount(),
+                    adapters,
+                    turboMode: stats?.turboMode ?? false,
+                    turboExpiresAt: stats?.turboExpiresAt ?? null,
+                    dailyPace: stats?.dailyPace ?? null,
+                    executionPaused: runnerRef?.isExecutionPaused() ?? true,
+                }));
+                // ---- WorkItems ----
+            }
+            else if (url === '/api/workItems') {
+                const running = runnerRef?.getRunningWorkItems() ?? [];
+                const queued = runnerRef?.getQueuedWorkItems() ?? [];
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ running, queued }));
+                // ---- Pipeline GET (detailed pipeline stages) ----
+            }
+            else if (url === '/api/pipeline') {
+                const stages = getStageBuffer();
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ stages }));
+                // ---- Rate Limiter Metrics GET ----
+            }
+            else if (url === '/api/rate-limits') {
+                const metrics = getRateLimiterMetrics();
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(metrics));
+                // ---- Projects GET (pinned + active projects) ----
+            }
+            else if (url === '/api/projects' && req.method === 'GET') {
+                const enabledPaths = new Set(runnerRef?.getEnabledProjects() ?? []);
+                const workItemInfo = runnerRef?.getProjectsInfo() ?? [];
+                const byPath = new Map(workItemInfo.filter(p => p.path).map(p => [p.path, p]));
+                // Fallback: match by project name (for workItems not yet executed → path not cached)
+                const byName = new Map(workItemInfo.map(p => [p.name, p]));
+                // Start with pinned projects
+                const allPaths = new Set(pinnedProjects);
+                // Auto-include enabled projects and projects with active workItems
+                for (const path of enabledPaths)
+                    allPaths.add(path);
+                for (const info of workItemInfo) {
+                    if (info.path && (info.running.length > 0 || info.queued.length > 0)) {
+                        allPaths.add(info.path);
+                    }
+                }
+                const result = await Promise.all(Array.from(allPaths).map(async (p) => {
+                    const dirName = p.split('/').pop() ?? p;
+                    let info = byPath.get(p) ?? byName.get(dirName);
+                    if (!info) {
+                        // Fuzzy fallback: map enabled path basename (e.g. enact-runtime)
+                        // to Azdo project names (e.g. "Enact Runtime — ...") when
+                        // path cache isn't populated for that project yet.
+                        const normDir = dirName.toLowerCase().replace(/[^a-z0-9]/g, '');
+                        info = workItemInfo.find((candidate) => {
+                            const normName = candidate.name.toLowerCase().replace(/[^a-z0-9]/g, '');
+                            if (!normName || !normDir)
+                                return false;
+                            return normName.includes(normDir) || normDir.includes(normName);
+                        });
+                    }
+                    const gitInfo = await getProjectGitInfo(p);
+                    const pending = (info?.pending ?? []).map((workItem) => {
+                        const retry = runnerRef?.getRetryBackoff(workItem.id);
+                        const state = getWorkItemState(workItem.id);
+                        const enriched = {
+                            ...workItem,
+                            executionStatus: state?.execution?.status,
+                            blockedReason: state?.execution?.blockedReason,
+                        };
+                        if (!retry)
+                            return enriched;
+                        return {
+                            ...enriched,
+                            retryAt: retry.retryAt,
+                            retryRemainingMs: retry.remainingMs,
+                            retryFailedCount: retry.failedCount,
+                        };
+                    });
+                    return {
+                        path: p,
+                        name: dirName,
+                        enabled: enabledPaths.has(p),
+                        pinned: pinnedProjects.has(p),
+                        running: info?.running ?? [],
+                        queued: info?.queued ?? [],
+                        pending,
+                        git: gitInfo.git,
+                        prs: gitInfo.prs,
+                    };
+                }));
+                result.sort((a, b) => {
+                    const aActive = a.running.length + a.queued.length + a.pending.length;
+                    const bActive = b.running.length + b.queued.length + b.pending.length;
+                    if (aActive !== bActive)
+                        return bActive - aActive;
+                    return a.name.localeCompare(b.name);
+                });
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(result));
+                // ---- Local projects for picker ----
+            }
+            else if (url === '/api/local-projects' && req.method === 'GET') {
+                const configPaths = runnerRef?.getAllowedProjects() ?? [];
+                const allBasePaths = [...new Set([...configPaths, ...customBasePaths])];
+                try {
+                    const locals = await scanLocalProjects(allBasePaths);
+                    const SKIP = ['/node_modules/', '/.git/', '/dist/', '/build/', '/__pycache__/', '/venv/', '/.venv/'];
+                    const filtered = locals.filter(l => !SKIP.some(s => l.path.includes(s)));
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify(filtered.map(l => ({ path: l.path, name: l.name, pinned: pinnedProjects.has(l.path) }))));
+                }
+                catch (e) {
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: safeErrorMessage(e) }));
+                }
+                // ---- Pin project ----
+            }
+            else if (url === '/api/projects/pin' && req.method === 'POST') {
+                const body = await readBody(req);
+                try {
+                    const { projectPath } = JSON.parse(body);
+                    if (typeof projectPath === 'string' && projectPath) {
+                        pinnedProjects.add(projectPath);
+                        saveReposConfig();
+                        // Seed path cache so Azdo project name matches immediately
+                        const name = projectPath.split('/').pop();
+                        if (name && runnerRef)
+                            runnerRef.registerProjectPath(name, projectPath);
+                    }
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: true }));
+                }
+                catch {
+                    res.writeHead(400).end(JSON.stringify({ error: 'Invalid JSON' }));
+                }
+                // ---- Unpin project ----
+            }
+            else if (url === '/api/projects/unpin' && req.method === 'POST') {
+                const body = await readBody(req);
+                try {
+                    const { projectPath } = JSON.parse(body);
+                    if (typeof projectPath === 'string') {
+                        pinnedProjects.delete(projectPath);
+                        // Also disable the project so it doesn't reappear via enabledPaths
+                        runnerRef?.disableProject(projectPath);
+                        saveReposConfig();
+                    }
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: true }));
+                }
+                catch {
+                    res.writeHead(400).end(JSON.stringify({ error: 'Invalid JSON' }));
+                }
+                // ---- Projects Toggle ----
+            }
+            else if (url === '/api/projects/toggle' && req.method === 'POST') {
+                const body = await readBody(req);
+                try {
+                    const { projectPath, enabled } = JSON.parse(body);
+                    if (typeof projectPath === 'string' && typeof enabled === 'boolean') {
+                        if (enabled)
+                            runnerRef?.enableProject(projectPath);
+                        else
+                            runnerRef?.disableProject(projectPath);
+                        saveReposConfig();
+                        broadcastEvent({ type: 'project:toggled', data: { projectPath, enabled } });
+                    }
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: true }));
+                }
+                catch {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Invalid JSON' }));
+                }
+                // ---- Move WorkItem to Todo ----
+            }
+            else if ((url === '/api/workitems/move-to-todo')
+                && req.method === 'POST') {
+                const body = await readBody(req);
+                try {
+                    const { workItemId } = JSON.parse(body);
+                    if (!workItemId) {
+                        res.writeHead(400, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ error: 'Missing workItemId' }));
+                        return;
+                    }
+                    // Import azdo dynamically to avoid circular deps
+                    const azdoModule = await import('../azdo/index.js');
+                    await azdoModule.updateWorkItemState(workItemId, 'Todo');
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: true }));
+                }
+                catch (error) {
+                    console.error('[Web] Failed to move workitem to Todo:', error);
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: safeErrorMessage(error) }));
+                }
+                // ---- Heartbeat (manual trigger) ----
+            }
+            else if (url === '/api/heartbeat' && req.method === 'POST') {
+                res.writeHead(202, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: true }));
+                // Non-blocking heartbeat
+                runnerRef?.heartbeat().catch((e) => console.error('[Web] Heartbeat error:', e));
+                // ---- Provider toggle ----
+            }
+            else if (url === '/api/provider' && req.method === 'POST') {
+                const body = await readBody(req);
+                try {
+                    const { provider } = JSON.parse(body);
+                    const validProviders = ['claude', 'codex', 'cursor', 'hermes', 'opencode', 'responses'];
+                    if (!validProviders.includes(provider)) {
+                        res.writeHead(400, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ error: 'Invalid provider' }));
+                        return;
+                    }
+                    setDefaultAdapter(provider);
+                    runnerRef?.switchProvider(provider);
+                    broadcastEvent({
+                        type: 'log',
+                        data: { workItemId: 'system', stage: 'provider', line: `Provider switched to ${provider}` },
+                    });
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: true, provider }));
+                }
+                catch {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Invalid JSON' }));
+                }
+                // ---- Turbo Mode Toggle ----
+            }
+            else if (url === '/api/turbo' && req.method === 'POST') {
+                const body = await readBody(req);
+                try {
+                    const { enabled } = JSON.parse(body);
+                    if (typeof enabled !== 'boolean') {
+                        res.writeHead(400, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ error: 'enabled must be boolean' }));
+                        return;
+                    }
+                    runnerRef?.setTurboMode(enabled);
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: true, turboMode: enabled }));
+                }
+                catch {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Invalid JSON' }));
+                }
+                // ---- Execution Pause/Resume ----
+            }
+            else if (url === '/api/execution/pause' && req.method === 'POST') {
+                const body = await readBody(req);
+                let reason;
+                try {
+                    const parsed = JSON.parse(body);
+                    reason = parsed.reason;
+                }
+                catch { /* body is optional */ }
+                runnerRef?.pauseExecution(reason);
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: true, paused: runnerRef?.isExecutionPaused() ?? true, ...(runnerRef == null ? { note: 'no runner in this mode' } : {}) }));
+            }
+            else if (url === '/api/execution/resume' && req.method === 'POST') {
+                runnerRef?.resumeExecution();
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: true, paused: runnerRef?.isExecutionPaused() ?? true }));
+            }
+            else if (url === '/api/execution/status' && req.method === 'GET') {
+                const schedulerStats = runnerRef?.getStats()?.schedulerStats;
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    paused: runnerRef?.isExecutionPaused() ?? true,
+                    inFlightCount: schedulerStats?.running ?? 0,
+                }));
+                // ---- CI Executor Status (removed — AzDO-only) ----
+            }
+            else if (url === '/api/ci-executor-status' && req.method === 'GET') {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ running: false }));
+                // ---- Stuck/Failed Workitems ----
+            }
+            else if ((url === '/api/workitems/stuck')
+                && req.method === 'GET') {
+                try {
+                    const azdoModule = await import('../azdo/index.js');
+                    const result = await azdoModule.getStuckWorkItems();
+                    // Augment with runtime-local blocked/retry state (not always reflected
+                    // in Azdo labels), so dashboard STUCK/FAILED count stays truthful.
+                    const localFailed = (runnerRef?.getProjectsInfo() ?? []).flatMap((project) => {
+                        return project.pending.flatMap((workItem) => {
+                            const retry = runnerRef?.getRetryBackoff(workItem.id);
+                            const state = getWorkItemState(workItem.id);
+                            const isBlocked = state?.execution?.status === 'blocked';
+                            if (!retry && !isBlocked)
+                                return [];
+                            const reason = retry
+                                ? `Retry backoff (${retry.failedCount}/4) — next attempt in ${Math.max(1, Math.ceil(retry.remainingMs / 60000))}m`
+                                : (state?.execution?.blockedReason || 'Blocked');
+                            return [{
+                                    id: workItem.id,
+                                    identifier: workItem.workItemIdentifier || workItem.id,
+                                    title: workItem.title,
+                                    description: undefined,
+                                    state: workItem.azdoState ?? 'Unknown',
+                                    priority: workItem.priority,
+                                    labels: [],
+                                    comments: [],
+                                    project: { id: 'local', name: project.name },
+                                    reason,
+                                }];
+                        });
+                    });
+                    const known = new Set(result.failedWorkItems.map((i) => i.id));
+                    const mergedFailed = [
+                        ...result.failedWorkItems,
+                        ...localFailed.filter((i) => !known.has(i.id)),
+                    ];
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({
+                        stuckWorkItems: result.stuckWorkItems,
+                        failedWorkItems: mergedFailed,
+                    }));
+                }
+                catch (error) {
+                    console.error('[Web] Failed to fetch stuck work items:', error);
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: safeErrorMessage(error) }));
+                }
+                // ---- Chat history ----
+            }
+            else if (url === '/api/chat/history' && req.method === 'GET') {
+                const buf = getChatBuffer();
+                const history = buf
+                    .filter((ev) => ev.type === 'chat:user' || ev.type === 'chat:agent')
+                    .map(ev => ({
+                    role: ev.type === 'chat:user' ? 'user' : 'agent',
+                    text: ev.data.text,
+                    ts: ev.data.ts,
+                }));
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(history.slice(-50)));
+                // ---- Log buffer snapshot ----
+            }
+            else if (url === '/api/logs' && req.method === 'GET') {
+                // 성능 최적화: 최근 200개 로그만 반환 (응답 시간 단축)
+                const allLogs = getLogBuffer();
+                const recentLogs = allLogs.slice(-200);
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(recentLogs));
+                // ---- Stage buffer snapshot ----
+            }
+            else if (url === '/api/stages' && req.method === 'GET') {
+                // 성능 최적화: 최근 100개 스테이지만 반환 (응답 시간 단축)
+                const allStages = getStageBuffer();
+                const recentStages = allStages.slice(-100);
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(recentStages));
+                // ---- Chat message ----
+            }
+            else if (url === '/api/chat' && req.method === 'POST') {
+                const body = await readBody(req);
+                let message;
+                let providerOverride;
+                let modelOverride;
+                try {
+                    const payload = JSON.parse(body);
+                    message = payload.message?.trim() ?? '';
+                    providerOverride = isChatProvider(payload.provider) ? payload.provider : undefined;
+                    modelOverride = typeof payload.model === 'string' && payload.model.trim().length > 0
+                        ? payload.model.trim()
+                        : undefined;
+                }
+                catch {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Invalid JSON' }));
+                    return;
+                }
+                if (!message) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Empty message' }));
+                    return;
+                }
+                broadcastEvent({ type: 'chat:user', data: { text: message, ts: Date.now() } });
+                // Build context-aware prompt (including previous conversation)
+                const stats = runnerRef?.getStats();
+                const projects = runnerRef?.getProjectsInfo() ?? [];
+                const enabled = projects.filter(p => p.enabled).length;
+                const state = runnerRef?.getState();
+                const uptimeSec = state?.startedAt ? Math.floor((Date.now() - state.startedAt) / 1000) : 0;
+                // 1. Short-term memory: recent chat buffer
+                const chatBuf = getChatBuffer()
+                    .filter((ev) => ev.type === 'chat:user' || ev.type === 'chat:agent');
+                const recentHistory = chatBuf.slice(-11, -1);
+                const historyBlock = recentHistory.length > 0
+                    ? recentHistory.map(m => (m.type === 'chat:user' ? 'User' : 'EnactFactory') + ': ' + m.data.text).join('\n\n')
+                    : '';
+                const adapterSummary = runnerRef?.getAdapterSummary();
+                const provider = providerOverride ?? adapterSummary?.defaultAdapter ?? 'claude';
+                const model = modelOverride ?? adapterSummary?.coder?.model ?? getDefaultChatModel(provider);
+                const contextPrompt = [
+                    'You are EnactFactory, an autonomous code development factory.',
+                    'You manage a fleet of coding agents that autonomously work on Work Items.',
+                    `Current chat provider: ${provider}`,
+                    `Current chat model: ${model}`,
+                    '',
+                    'Current system status:',
+                    '- Running workItems: ' + (stats?.schedulerStats?.running ?? 0),
+                    '- Queued workItems: ' + (stats?.schedulerStats?.queued ?? 0),
+                    '- Completed today: ' + (stats?.schedulerStats?.completed ?? 0),
+                    '- Active repos: ' + enabled + '/' + projects.length,
+                    '- Uptime: ' + uptimeSec + 's',
+                    '',
+                    ...(historyBlock ? [
+                        'Conversation history (most recent first):',
+                        historyBlock,
+                        '',
+                    ] : []),
+                    'Answer the user concisely and helpfully in the same language they use. Use the status data above if relevant.',
+                    '',
+                    'User: ' + message,
+                ].join('\n');
+                const result = await runChatCompletion({
+                    prompt: contextPrompt,
+                    provider,
+                    model,
+                    cwd: process.cwd(),
+                    timeoutMs: 180000,
+                }).catch((error) => ({
+                    response: `[Error: ${error.message}]`,
+                    provider,
+                    model,
+                    cost: undefined,
+                    tokens: undefined,
+                }));
+                const response = result.response;
+                if (result.cost !== undefined) {
+                    console.log(`[Web Chat] Cost: ${formatCost({
+                        costUsd: result.cost,
+                        inputTokens: result.tokens ?? 0,
+                        outputTokens: 0,
+                        cacheReadTokens: 0,
+                        cacheCreationTokens: 0,
+                        durationMs: 0,
+                        model: result.model,
+                    })}`);
+                }
+                broadcastEvent({ type: 'chat:agent', data: { text: response, ts: Date.now() } });
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: true, response, provider: result.provider, model: result.model }));
+                // ---- App health check (lightweight DB ping) ----
+            }
+            else if (url === '/api/health' && req.method === 'GET') {
+                let dbOk = false;
+                try {
+                    const store = await getWorkItemStore();
+                    // Cheapest possible check: getSyncMeta with a non-existent key returns null, never throws for healthy DBs.
+                    await store.getSyncMeta('__health_ping__');
+                    dbOk = true;
+                    setDbHealthy(true);
+                }
+                catch {
+                    dbOk = false;
+                    setDbHealthy(false);
+                }
+                const syncService = (await import('../workItems/azdoSyncRuntime.js')).getAzdoSyncService();
+                const syncStatus = syncService?.getStatus();
+                const syncOk = !syncStatus || (!syncStatus.isStale && !syncStatus.lastError);
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    ok: dbOk,
+                    db: dbOk,
+                    sync: syncOk ? 'ok' : 'degraded',
+                }));
+                // ---- Service control: status ----
+            }
+            else if (url === '/api/service/status' && req.method === 'GET') {
+                const daemon = getDaemonStatus();
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    status: daemon.running ? 'active' : 'inactive',
+                    pid: daemon.pid,
+                    uptimeSeconds: daemon.uptimeSeconds,
+                    pidFile: daemon.pidFile,
+                    logFile: daemon.logFile,
+                }));
+                // ---- Service control: stop ----
+            }
+            else if (url === '/api/service/stop' && req.method === 'POST') {
+                try {
+                    const stopped = await stopDaemon();
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: true, stopped }));
+                }
+                catch (e) {
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: safeErrorMessage(e) }));
+                }
+                // ---- Service control: restart ----
+            }
+            else if (url === '/api/service/restart' && req.method === 'POST') {
+                try {
+                    await stopDaemon();
+                    const started = startDaemon();
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: true, pid: started.pid }));
+                }
+                catch (e) {
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: safeErrorMessage(e) }));
+                }
+                // ---- Pipeline history (time-ordered) ----
+            }
+            else if (url === '/api/pipeline/history' && req.method === 'GET') {
+                const limitParam = (req.url?.split('?')[1] || '').match(/limit=(\d+)/);
+                const limit = limitParam ? Math.min(Number(limitParam[1]), 100) : 50;
+                const history = runnerRef?.getPipelineHistory(limit) ?? [];
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(history));
+                // ---- Monitors: list ----
+            }
+            else if (url === '/api/monitors' && req.method === 'GET') {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(getActiveMonitors()));
+                // ---- Monitors: register ----
+            }
+            else if (url === '/api/monitors' && req.method === 'POST') {
+                const body = await readBody(req);
+                try {
+                    const config = JSON.parse(body);
+                    if (!config.id ||
+                        !config.name ||
+                        !Array.isArray(config.checkCommand) ||
+                        config.checkCommand.length === 0 ||
+                        !config.completionCheck) {
+                        res.writeHead(400, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({
+                            error: 'Missing or invalid required fields: id, name, checkCommand (string[]), completionCheck',
+                        }));
+                        return;
+                    }
+                    const monitor = registerMonitor(config);
+                    res.writeHead(201, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify(monitor));
+                }
+                catch (e) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: safeErrorMessage(e) }));
+                }
+                // ---- Monitors: delete ----
+            }
+            else if (url.startsWith('/api/monitors/') && req.method === 'DELETE') {
+                const monitorId = url.replace('/api/monitors/', '');
+                const deleted = unregisterMonitor(monitorId);
+                res.writeHead(deleted ? 200 : 404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: deleted }));
+                // ---- Processes: list ----
+            }
+            else if (url === '/api/processes' && req.method === 'GET') {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(getAllProcesses()));
+                // ---- Lane status (workspace truth: lanes + assignments + terminal sessions) ----
+            }
+            else if ((url === '/api/lanes' || url === '/api/lane-status') && req.method === 'GET') {
+                try {
+                    const payload = getLaneStatusSnapshot();
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify(payload));
+                }
+                catch {
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Lane status unavailable' }));
+                }
+                // ---- Processes: kill ----
+            }
+            else if (url.startsWith('/api/processes/') && req.method === 'DELETE') {
+                const pidStr = url.replace('/api/processes/', '');
+                const pid = parseInt(pidStr, 10);
+                if (isNaN(pid)) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Invalid PID' }));
+                }
+                else {
+                    const killed = await killProcess(pid);
+                    res.writeHead(killed ? 200 : 404, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: killed }));
+                }
+                // ---- Scan Paths: list ----
+            }
+            else if (url === '/api/scan-paths' && req.method === 'GET') {
+                // removedConfigPaths에 있는 경로는 UI에 표시하지 않음
+                const allConfigPaths = runnerRef?.getAllowedProjects() ?? [];
+                const configPaths = allConfigPaths.filter(p => !removedConfigPaths.has(p));
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    configPaths,
+                    customPaths: Array.from(customBasePaths),
+                }));
+                // ---- Scan Paths: add ----
+            }
+            else if (url === '/api/scan-paths' && req.method === 'POST') {
+                const body = await readBody(req);
+                try {
+                    const { path: newPath } = JSON.parse(body);
+                    if (typeof newPath !== 'string' || !newPath.trim()) {
+                        res.writeHead(400, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ error: 'Missing path' }));
+                    }
+                    else {
+                        customBasePaths.add(newPath.trim());
+                        invalidateProjectCache();
+                        // Update runner's allowedProjects with merged list
+                        const configPaths = runnerRef?.getAllowedProjects() ?? [];
+                        const merged = [...new Set([...configPaths, ...customBasePaths])];
+                        runnerRef?.updateAllowedProjects(merged);
+                        saveReposConfig();
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ ok: true }));
+                    }
+                }
+                catch {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Invalid JSON' }));
+                }
+                // ---- Scan Paths: remove ----
+            }
+            else if (url.startsWith('/api/scan-paths/') && req.method === 'DELETE') {
+                const encodedPath = url.replace('/api/scan-paths/', '');
+                const decodedPath = decodeURIComponent(encodedPath);
+                // customPaths에서 제거
+                customBasePaths.delete(decodedPath);
+                // configPaths에서도 제거: removedConfigPaths에 기록하고 runner에서 즉시 반영
+                const allConfigPaths = runnerRef?.getAllowedProjects() ?? [];
+                if (allConfigPaths.includes(decodedPath)) {
+                    removedConfigPaths.add(decodedPath);
+                    runnerRef?.updateAllowedProjects(allConfigPaths.filter(p => p !== decodedPath));
+                }
+                invalidateProjectCache();
+                saveReposConfig();
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: true }));
+                // ---- Claude Code Quota ----
+            }
+            else if (url === '/api/quota' && req.method === 'GET') {
+                const quota = await fetchQuota();
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(quota ?? { error: 'unavailable' }));
+                // ---- Chat history (event hub buffer) ----
+            }
+            else if (url === '/api/history') {
+                const history = getChatBuffer();
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(history));
+                // ---- Exec: submit workItem ----
+            }
+            else if (url === '/api/exec' && req.method === 'POST') {
+                const body = await readBody(req);
+                try {
+                    const { prompt, projectPath, pipeline, executorOnly, model } = JSON.parse(body);
+                    if (!prompt?.trim()) {
+                        res.writeHead(400, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ error: 'Missing prompt' }));
+                        return;
+                    }
+                    const workItemId = `exec-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+                    const resolvedPath = projectPath ?? process.cwd();
+                    const entry = {
+                        workItemId,
+                        status: 'queued',
+                        createdAt: Date.now(),
+                    };
+                    execWorkItems.set(workItemId, entry);
+                    res.writeHead(202, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ workItemId, status: 'queued' }));
+                    // Run pipeline asynchronously
+                    (async () => {
+                        try {
+                            initLocale('en');
+                            entry.status = 'running';
+                            // Determine stages
+                            let stages;
+                            if (executorOnly) {
+                                stages = ['coder'];
+                            }
+                            else if (pipeline) {
+                                stages = ['coder', 'critic', 'tester', 'documenter'];
+                            }
+                            else {
+                                stages = ['coder', 'critic'];
+                            }
+                            // Build role config
+                            const stageConfigs = {};
+                            if (model) {
+                                stageConfigs.coder = { enabled: true, model, timeoutMs: 0 };
+                            }
+                            const workItem = {
+                                id: workItemId,
+                                source: 'local',
+                                title: prompt,
+                                description: prompt,
+                                priority: 3,
+                                projectPath: resolvedPath,
+                                createdAt: Date.now(),
+                            };
+                            const pipelineInstance = new PairPipeline({
+                                stages,
+                                maxIterations: 3,
+                                stageConfigs: Object.keys(stageConfigs).length > 0 ? stageConfigs : undefined,
+                            });
+                            pipelineInstance.on('stage:start', ({ stage }) => {
+                                entry.currentStage = stage;
+                            });
+                            const result = await pipelineInstance.run(workItem, resolvedPath);
+                            entry.status = 'completed';
+                            entry.result = {
+                                success: result.success,
+                                summary: result.executorResult?.summary,
+                                finalStatus: result.finalStatus,
+                            };
+                        }
+                        catch (err) {
+                            entry.status = 'failed';
+                            entry.error = err instanceof Error ? err.message : String(err);
+                        }
+                        finally {
+                            cleanupExecWorkItem(workItemId);
+                        }
+                    })();
+                }
+                catch {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Invalid JSON' }));
+                }
+                // ---- Exec: workItem status ----
+            }
+            else if (url.startsWith('/api/exec/') && req.method === 'GET') {
+                const workItemId = url.replace('/api/exec/', '');
+                const entry = execWorkItems.get(workItemId);
+                if (!entry) {
+                    res.writeHead(404, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'WorkItem not found' }));
+                }
+                else {
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({
+                        workItemId: entry.workItemId,
+                        status: entry.status,
+                        currentStage: entry.currentStage,
+                        result: entry.result,
+                        error: entry.error,
+                    }));
+                }
+            }
+            else {
+                res.writeHead(404);
+                res.end('Not Found');
+            }
+        });
+        server.on('upgrade', (req, socket, head) => {
+            if (!handleTerminalWebSocketUpgrade(req, socket, head)) {
+                socket.write('HTTP/1.1 404 Not Found\r\n\r\n');
+                socket.destroy();
+            }
+        });
+        server.on('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                console.warn(`Port ${port} is already in use, skipping web server...`);
+                server = null;
+                resolve();
+            }
+            else {
+                reject(err);
+            }
+        });
+        server.listen(port, '0.0.0.0', () => {
+            const tailscaleIP = '100.95.200.28'; // Current Tailscale IP
+            console.log(`Web interface running at:`);
+            console.log(`  - http://127.0.0.1:${port} (localhost)`);
+            console.log(`  - http://${tailscaleIP}:${port} (Tailscale)`);
+            startGitStatusPoller(() => Array.from(pinnedProjects));
+            startHealthChecker(30000);
+            resolve();
+        });
+    });
+}
+/**
+ * Stop the web server
+ */
+export async function stopWebServer() {
+    if (server) {
+        server.close();
+        shutdownTerminalBridge();
+        server = null;
+    }
+    await stopAzdoSync();
+}
+//# sourceMappingURL=web.js.map