specweave 1.0.259 → 1.0.260

package/dist/src/dashboard/server/dashboard-server.js

@@ -0,0 +1,812 @@
+import * as http from 'http';
+import * as net from 'net';
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { Router, sendJson, readBody } from './router.js';
+import { SSEManager } from './sse-manager.js';
+import { FileWatcher } from './file-watcher.js';
+import { CommandRunner } from './command-runner.js';
+import { DashboardDataAggregator } from './data/dashboard-data-aggregator.js';
+import { ClaudeLogParser } from './data/claude-log-parser.js';
+import { PluginScanner } from './data/plugin-scanner.js';
+import { SyncAuditReader } from './data/sync-audit-reader.js';
+import { ActivityStream } from './data/activity-stream.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const MIME_TYPES = {
+    '.html': 'text/html; charset=utf-8',
+    '.js': 'application/javascript; charset=utf-8',
+    '.css': 'text/css; charset=utf-8',
+    '.json': 'application/json',
+    '.svg': 'image/svg+xml',
+    '.png': 'image/png',
+    '.ico': 'image/x-icon',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+};
+export class DashboardServer {
+    constructor(options) {
+        this.options = options;
+        this.server = null;
+        this.projects = new Map();
+        this.sseManager = new SSEManager();
+        this.router = new Router();
+        // Register initial projects
+        for (const root of options.projectRoots) {
+            this.addProject(root);
+        }
+        this.registerRoutes();
+    }
+    /** Add a new project to the dashboard */
+    addProject(projectRoot) {
+        const id = pathToProjectId(projectRoot);
+        if (this.projects.has(id)) {
+            return this.getProjectInfo(id, projectRoot);
+        }
+        const aggregator = new DashboardDataAggregator(projectRoot);
+        const logParser = new ClaudeLogParser(projectRoot);
+        const pluginScanner = new PluginScanner(projectRoot);
+        const auditReader = new SyncAuditReader(projectRoot);
+        const activityStream = new ActivityStream(projectRoot);
+        const commandRunner = new CommandRunner(projectRoot, {
+            onOutput: (execId, line, stream) => {
+                this.sseManager.broadcast('command-output', { projectId: id, executionId: execId, line, stream });
+            },
+            onComplete: (execId, exitCode) => {
+                this.sseManager.broadcast('command-complete', { projectId: id, executionId: execId, exitCode });
+            },
+        });
+        const watcher = new FileWatcher(projectRoot, (event) => {
+            this.sseManager.broadcast(event.type, { projectId: id, ...event.data });
+            this.sseManager.broadcast('activity', {
+                projectId: id,
+                category: this.mapEventToCategory(event.type),
+                severity: 'info',
+                title: `File changed: ${event.type}`,
+                ...event.data,
+            });
+        });
+        this.projects.set(id, { root: projectRoot, watcher, aggregator, commandRunner, logParser, pluginScanner, auditReader, activityStream });
+        return this.getProjectInfo(id, projectRoot);
+    }
+    /** Remove a project from the dashboard */
+    removeProject(projectId) {
+        const project = this.projects.get(projectId);
+        if (project) {
+            project.watcher.close();
+            project.commandRunner.cancel();
+            this.projects.delete(projectId);
+        }
+    }
+    getProjectInfo(id, projectRoot) {
+        let name = path.basename(projectRoot);
+        try {
+            const config = JSON.parse(fs.readFileSync(path.join(projectRoot, '.specweave/config.json'), 'utf-8'));
+            if (config?.project?.name)
+                name = config.project.name;
+        }
+        catch { /* use dir name */ }
+        return { id, path: projectRoot, name, hasSpecweave: true };
+    }
+    async start() {
+        return new Promise((resolve, reject) => {
+            this.server = http.createServer((req, res) => this.handleRequest(req, res));
+            this.server.on('error', (err) => {
+                reject(err);
+            });
+            this.server.listen(this.options.port, () => {
+                const url = `http://localhost:${this.options.port}`;
+                resolve({
+                    url,
+                    port: this.options.port,
+                    stop: () => this.stop(),
+                });
+            });
+        });
+    }
+    async stop() {
+        for (const project of this.projects.values()) {
+            project.watcher.close();
+            project.commandRunner.cancel();
+        }
+        this.sseManager.closeAll();
+        return new Promise((resolve) => {
+            if (this.server) {
+                this.server.close(() => resolve());
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    async handleRequest(req, res) {
+        const url = req.url || '/';
+        // CORS preflight — only allow localhost origins
+        if (req.method === 'OPTIONS') {
+            const origin = req.headers.origin || '';
+            const headers = {
+                'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
+                'Access-Control-Allow-Headers': 'Content-Type',
+                'Vary': 'Origin',
+            };
+            if (/^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/.test(origin)) {
+                headers['Access-Control-Allow-Origin'] = origin;
+            }
+            res.writeHead(204, headers);
+            res.end();
+            return;
+        }
+        // SSE endpoint
+        if (url.startsWith('/api/events') && req.method === 'GET') {
+            this.sseManager.addConnection(res);
+            return;
+        }
+        // API routes
+        if (url.startsWith('/api/')) {
+            const handled = await this.router.handle(req, res);
+            if (!handled) {
+                sendJson(res, { ok: false, error: 'Not found' }, 404);
+            }
+            return;
+        }
+        // Static files
+        await this.serveStaticFile(req, res, url);
+    }
+    /** Resolve project from query string ?project=<id> */
+    resolveProject(req) {
+        const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+        const projectId = url.searchParams.get('project');
+        const pick = (id, p) => ({
+            aggregator: p.aggregator,
+            commandRunner: p.commandRunner,
+            logParser: p.logParser,
+            pluginScanner: p.pluginScanner,
+            auditReader: p.auditReader,
+            activityStream: p.activityStream,
+            id,
+            root: p.root,
+        });
+        if (projectId) {
+            const project = this.projects.get(projectId);
+            if (project)
+                return pick(projectId, project);
+        }
+        const first = this.projects.entries().next().value;
+        if (first) {
+            const [id, project] = first;
+            return pick(id, project);
+        }
+        return null;
+    }
+    registerRoutes() {
+        // === Global routes (not project-scoped) ===
+        // Health
+        this.router.get('/api/health', async (_req, res) => {
+            sendJson(res, {
+                ok: true,
+                uptime: process.uptime(),
+                connections: this.sseManager.connectionCount,
+                projectCount: this.projects.size,
+            });
+        });
+        // Project management
+        this.router.get('/api/projects', async (_req, res) => {
+            const projects = [];
+            for (const [id, proj] of this.projects) {
+                projects.push(this.getProjectInfo(id, proj.root));
+            }
+            sendJson(res, { ok: true, data: projects });
+        });
+        this.router.post('/api/projects', async (req, res) => {
+            const body = await readBody(req);
+            if (!body?.path || typeof body.path !== 'string') {
+                sendJson(res, { ok: false, error: 'Missing path' }, 400);
+                return;
+            }
+            // Validate: must be an absolute path
+            const resolvedPath = path.resolve(body.path);
+            if (!path.isAbsolute(resolvedPath)) {
+                sendJson(res, { ok: false, error: 'Path must be absolute' }, 400);
+                return;
+            }
+            const specweavePath = path.join(resolvedPath, '.specweave');
+            if (!fs.existsSync(specweavePath)) {
+                sendJson(res, { ok: false, error: 'Not a SpecWeave project' }, 400);
+                return;
+            }
+            const info = this.addProject(resolvedPath);
+            sendJson(res, { ok: true, data: info });
+        });
+        this.router.delete('/api/projects/:id', async (_req, res, params) => {
+            this.removeProject(params.id);
+            sendJson(res, { ok: true });
+        });
+        // === Project-scoped routes (use ?project=<id> query param) ===
+        // Overview
+        this.router.get('/api/overview', async (req, res) => {
+            const project = this.resolveProject(req);
+            if (!project)
+                return sendJson(res, { ok: false, error: 'No projects registered' }, 404);
+            const data = await project.aggregator.getOverview();
+            sendJson(res, { ok: true, data });
+        });
+        // Increments
+        this.router.get('/api/increments', async (req, res) => {
+            const project = this.resolveProject(req);
+            if (!project)
+                return sendJson(res, { ok: false, error: 'No projects registered' }, 404);
+            const data = await project.aggregator.getIncrements();
+            sendJson(res, { ok: true, data });
+        });
+        // Analytics
+        this.router.get('/api/analytics/summary', async (req, res) => {
+            const project = this.resolveProject(req);
+            if (!project)
+                return sendJson(res, { ok: false, error: 'No projects registered' }, 404);
+            const data = await project.aggregator.getAnalyticsSummary();
+            sendJson(res, { ok: true, data });
+        });
+        this.router.get('/api/analytics/skills', async (req, res) => {
+            const project = this.resolveProject(req);
+            if (!project)
+                return sendJson(res, { ok: false, error: 'No projects registered' }, 404);
+            const data = await project.aggregator.getSkillUsage();
+            sendJson(res, { ok: true, data });
+        });
+        // Costs
+        this.router.get('/api/costs/summary', async (req, res) => {
+            const project = this.resolveProject(req);
+            if (!project)
+                return sendJson(res, { ok: false, error: 'No projects registered' }, 404);
+            const data = await project.aggregator.getCostsSummary();
+            sendJson(res, { ok: true, data });
+        });
+        // Sync
+        this.router.get('/api/sync/status', async (req, res) => {
+            const project = this.resolveProject(req);
+            if (!project)
+                return sendJson(res, { ok: false, error: 'No projects registered' }, 404);
+            const data = await project.aggregator.getSyncStatus();
+            sendJson(res, { ok: true, data });
+        });
+        // Notifications
+        this.router.get('/api/notifications', async (req, res) => {
+            const project = this.resolveProject(req);
+            if (!project)
+                return sendJson(res, { ok: false, error: 'No projects registered' }, 404);
+            const data = await project.aggregator.getNotifications();
+            sendJson(res, { ok: true, data });
+        });
+        // Config
+        this.router.get('/api/config', async (req, res) => {
+            const project = this.resolveProject(req);
+            if (!project)
+                return sendJson(res, { ok: false, error: 'No projects registered' }, 404);
+            const data = await project.aggregator.getConfig();
+            sendJson(res, { ok: true, data });
+        });
+        // Plugins & LSP
+        this.router.get('/api/plugins', async (req, res) => {
+            const project = this.resolveProject(req);
+            if (!project)
+                return sendJson(res, { ok: false, error: 'No projects registered' }, 404);
+            const data = await project.aggregator.getPlugins();
+            sendJson(res, { ok: true, data });
+        });
+        this.router.get('/api/lsp', async (req, res) => {
+            const project = this.resolveProject(req);
+            if (!project)
+                return sendJson(res, { ok: false, error: 'No projects registered' }, 404);
+            const data = await project.aggregator.getLspStatus();
+            sendJson(res, { ok: true, data });
+        });
+        // Commands
+        this.router.post('/api/commands/:name', async (req, res, params) => {
+            const project = this.resolveProject(req);
+            if (!project)
+                return sendJson(res, { ok: false, error: 'No projects registered' }, 404);
+            const execution = project.commandRunner.execute(params.name);
+            if (!execution) {
+                sendJson(res, { ok: false, error: 'Command not available or already running' }, 400);
+                return;
+            }
+            sendJson(res, { ok: true, data: execution });
+        });
+        this.router.get('/api/commands/active', async (req, res) => {
+            const project = this.resolveProject(req);
+            if (!project)
+                return sendJson(res, { ok: true, data: null });
+            const active = project.commandRunner.getActive();
+            sendJson(res, { ok: true, data: active });
+        });
+        this.router.get('/api/commands/allowed', async (_req, res) => {
+            sendJson(res, { ok: true, data: CommandRunner.getAllowedCommands() });
+        });
+        // === Config Validate ===
+        this.router.post('/api/config/validate', async (req, res) => {
+            const project = this.resolveProject(req);
+            if (!project)
+                return sendJson(res, { ok: false, error: 'No projects registered' }, 404);
+            try {
+                const body = await readBody(req);
+                if (!body || typeof body !== 'object')
+                    return sendJson(res, { ok: false, error: 'Invalid body' }, 400);
+                // Read schema expectations from existing config structure
+                const currentConfig = await project.aggregator.getConfig();
+                const errors = [];
+                // Validate known typed fields
+                if (body.testing && typeof body.testing === 'object') {
+                    const testing = body.testing;
+                    if (testing.defaultTestMode && !['test-after', 'TDD', 'coverage-only'].includes(String(testing.defaultTestMode))) {
+                        errors.push('testing.defaultTestMode must be one of: test-after, TDD, coverage-only');
+                    }
+                    if (testing.tddEnforcement && !['strict', 'warn', 'off'].includes(String(testing.tddEnforcement))) {
+                        errors.push('testing.tddEnforcement must be one of: strict, warn, off');
+                    }
+                }
+                if (body.limits && typeof body.limits === 'object') {
+                    const limits = body.limits;
+                    if (limits.maxActiveIncrements != null && (typeof limits.maxActiveIncrements !== 'number' || limits.maxActiveIncrements < 1)) {
+                        errors.push('limits.maxActiveIncrements must be a positive number');
+                    }
+                }
+                sendJson(res, { ok: errors.length === 0, errors, currentConfig });
+            }
+            catch {
+                sendJson(res, { ok: false, error: 'Validation failed' }, 500);
+            }
+        });
+        // === Command Cancel ===
+        this.router.post('/api/commands/:id/cancel', async (req, res) => {
+            const project = this.resolveProject(req);
+            if (!project)
+                return sendJson(res, { ok: false, error: 'No projects registered' }, 404);
+            const cancelled = project.commandRunner.cancel();
+            if (!cancelled) {
+                sendJson(res, { ok: false, error: 'No running command to cancel' }, 400);
+                return;
+            }
+            sendJson(res, { ok: true });
+        });
+        // === Analytics Events ===
+        this.router.get('/api/analytics/events', async (req, res) => {
+            const project = this.resolveProject(req);
+            if (!project)
+                return sendJson(res, { ok: false, error: 'No projects registered' }, 404);
+            const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+            const limit = Math.min(parseInt(url.searchParams.get('limit') || '200', 10) || 200, 1000);
+            const type = url.searchParams.get('type') || undefined;
+            const since = url.searchParams.get('since') || undefined;
+            const eventsPath = path.join(project.root, '.specweave/state/analytics/events.jsonl');
+            const events = [];
+            try {
+                if (fs.existsSync(eventsPath)) {
+                    const lines = fs.readFileSync(eventsPath, 'utf-8').split('\n').filter(Boolean);
+                    // Read from end for efficiency
+                    for (let i = lines.length - 1; i >= 0 && events.length < limit; i--) {
+                        try {
+                            const event = JSON.parse(lines[i]);
+                            if (type && event.type !== type)
+                                continue;
+                            if (since && event.timestamp && event.timestamp < since)
+                                break;
+                            events.push(event);
+                        }
+                        catch { /* skip bad lines */ }
+                    }
+                }
+            }
+            catch { /* */ }
+            sendJson(res, { ok: true, data: events });
+        });
+        // === Phase 2: Error Tracing ===
+        this.router.get('/api/errors/recent', async (req, res) => {
+            const project = this.resolveProject(req);
+            if (!project)
+                return sendJson(res, { ok: false, error: 'No projects registered' }, 404);
+            const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+            const limit = parseInt(url.searchParams.get('limit') || '50', 10);
+            const data = await project.logParser.getRecentErrors(limit);
+            sendJson(res, { ok: true, data });
+        });
+        this.router.get('/api/errors/groups', async (req, res) => {
+            const project = this.resolveProject(req);
+            if (!project)
+                return sendJson(res, { ok: false, error: 'No projects registered' }, 404);
+            const data = await project.logParser.getErrorGroups();
+            sendJson(res, { ok: true, data });
+        });
+        this.router.get('/api/errors/sessions', async (req, res) => {
+            const project = this.resolveProject(req);
+            if (!project)
+                return sendJson(res, { ok: false, error: 'No projects registered' }, 404);
+            const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+            const limit = parseInt(url.searchParams.get('limit') || '30', 10);
+            const data = await project.logParser.getSessionSummaries(limit);
+            sendJson(res, { ok: true, data });
+        });
+        this.router.get('/api/errors/sessions/:sessionId', async (req, res, params) => {
+            const project = this.resolveProject(req);
+            if (!project)
+                return sendJson(res, { ok: false, error: 'No projects registered' }, 404);
+            const data = await project.logParser.getSessionDetail(params.sessionId);
+            if (!data)
+                return sendJson(res, { ok: false, error: 'Session not found' }, 404);
+            sendJson(res, { ok: true, data });
+        });
+        // === Phase 2: Sync Audit ===
+        this.router.get('/api/sync/audit', async (req, res) => {
+            const project = this.resolveProject(req);
+            if (!project)
+                return sendJson(res, { ok: false, error: 'No projects registered' }, 404);
+            const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+            const data = await project.auditReader.getRecentEntries({
+                limit: parseInt(url.searchParams.get('limit') || '100', 10),
+                platform: url.searchParams.get('platform') || undefined,
+                result: url.searchParams.get('result') || undefined,
+                since: url.searchParams.get('since') || undefined,
+            });
+            sendJson(res, { ok: true, data });
+        });
+        this.router.get('/api/sync/audit/summary', async (req, res) => {
+            const project = this.resolveProject(req);
+            if (!project)
+                return sendJson(res, { ok: false, error: 'No projects registered' }, 404);
+            const data = await project.auditReader.getSummary();
+            sendJson(res, { ok: true, data });
+        });
+        // === Phase 2: Enhanced Plugins ===
+        this.router.get('/api/plugins/full', async (req, res) => {
+            const project = this.resolveProject(req);
+            if (!project)
+                return sendJson(res, { ok: false, error: 'No projects registered' }, 404);
+            const data = project.pluginScanner.getFullPluginData();
+            sendJson(res, { ok: true, data });
+        });
+        // === Phase 3: Activity Stream ===
+        this.router.get('/api/activity/stream', async (req, res) => {
+            const project = this.resolveProject(req);
+            if (!project)
+                return sendJson(res, { ok: false, error: 'No projects registered' }, 404);
+            const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+            const categoriesParam = url.searchParams.get('categories');
+            const data = await project.activityStream.getRecentActivity({
+                limit: parseInt(url.searchParams.get('limit') || '100', 10),
+                categories: categoriesParam ? categoriesParam.split(',') : undefined,
+                severity: url.searchParams.get('severity') || undefined,
+                since: url.searchParams.get('since') || undefined,
+            });
+            sendJson(res, { ok: true, data });
+        });
+        // === Phase 3: Notification Dismiss ===
+        this.router.post('/api/notifications/:id/dismiss', async (req, res, params) => {
+            const project = this.resolveProject(req);
+            if (!project)
+                return sendJson(res, { ok: false, error: 'No projects registered' }, 404);
+            const notifPath = path.join(project.root, '.specweave/state/notifications.json');
+            try {
+                if (!fs.existsSync(notifPath))
+                    return sendJson(res, { ok: false, error: 'No notifications file' }, 404);
+                const data = JSON.parse(fs.readFileSync(notifPath, 'utf-8'));
+                const notifications = data?.notifications || data || [];
+                if (!Array.isArray(notifications))
+                    return sendJson(res, { ok: false, error: 'Invalid format' }, 400);
+                const notif = notifications.find((n) => n.id === params.id);
+                if (!notif)
+                    return sendJson(res, { ok: false, error: 'Notification not found' }, 404);
+                notif.dismissedAt = new Date().toISOString();
+                if (data?.notifications) {
+                    data.notifications = notifications;
+                }
+                fs.writeFileSync(notifPath, JSON.stringify(data?.notifications ? data : notifications, null, 2));
+                sendJson(res, { ok: true });
+            }
+            catch {
+                sendJson(res, { ok: false, error: 'Failed to dismiss' }, 500);
+            }
+        });
+        // === Phase 2: Cost Sessions ===
+        this.router.get('/api/costs/sessions', async (req, res) => {
+            const project = this.resolveProject(req);
+            if (!project)
+                return sendJson(res, { ok: false, error: 'No projects registered' }, 404);
+            const costs = await project.aggregator.getCostsSummary();
+            const sessions = costs?.sessions || [];
+            sendJson(res, { ok: true, data: sessions });
+        });
+        // === Phase 4: Config Write ===
+        this.router.put('/api/config', async (req, res) => {
+            const project = this.resolveProject(req);
+            if (!project)
+                return sendJson(res, { ok: false, error: 'No projects registered' }, 404);
+            const configPath = path.join(project.root, '.specweave/config.json');
+            try {
+                const body = await readBody(req);
+                if (!body || typeof body !== 'object')
+                    return sendJson(res, { ok: false, error: 'Invalid body' }, 400);
+                // Read current config, merge with updates
+                let current = {};
+                if (fs.existsSync(configPath)) {
+                    current = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+                }
+                const merged = deepMerge(current, body);
+                fs.writeFileSync(configPath, JSON.stringify(merged, null, 2));
+                sendJson(res, { ok: true, data: merged });
+            }
+            catch {
+                sendJson(res, { ok: false, error: 'Failed to save config' }, 500);
+            }
+        });
+        // === Phase 4: Increment Detail ===
+        this.router.get('/api/increments/:id', async (req, res, params) => {
+            const project = this.resolveProject(req);
+            if (!project)
+                return sendJson(res, { ok: false, error: 'No projects registered' }, 404);
+            const data = await getIncrementDetail(project.root, params.id);
+            if (!data)
+                return sendJson(res, { ok: false, error: 'Increment not found' }, 404);
+            sendJson(res, { ok: true, data });
+        });
+        // === Phase 4: Repos ===
+        this.router.get('/api/repos', async (req, res) => {
+            const project = this.resolveProject(req);
+            if (!project)
+                return sendJson(res, { ok: true, data: [] });
+            const data = scanRepositories(project.root);
+            sendJson(res, { ok: true, data });
+        });
+        // === Phase 4: Services ===
+        this.router.get('/api/services', async (req, res) => {
+            const project = this.resolveProject(req);
+            if (!project)
+                return sendJson(res, { ok: true, data: [] });
+            const config = await project.aggregator.getConfig();
+            const docsPort = config?.documentation?.previewPort ?? 3000;
+            const services = [
+                { name: 'Dashboard Server', status: 'running', detail: `http://localhost:${this.options.port}`, port: this.options.port },
+                { name: 'Docs Preview', status: await checkPort(docsPort) ? 'running' : 'stopped', detail: `http://localhost:${docsPort}`, port: docsPort },
+            ];
+            sendJson(res, { ok: true, data: services });
+        });
+        // Links (derived from config)
+        this.router.get('/api/links', async (req, res) => {
+            const project = this.resolveProject(req);
+            if (!project)
+                return sendJson(res, { ok: true, data: [] });
+            const config = await project.aggregator.getConfig();
+            const links = [
+                { name: 'Public Docs', url: 'https://spec-weave.com', type: 'docs' },
+            ];
+            if (config?.sync?.github?.owner && config?.sync?.github?.repo) {
+                links.push({
+                    name: 'GitHub Repository',
+                    url: `https://github.com/${config.sync.github.owner}/${config.sync.github.repo}`,
+                    type: 'github',
+                });
+            }
+            if (config?.sync?.jira?.domain) {
+                links.push({
+                    name: 'JIRA Board',
+                    url: `https://${config.sync.jira.domain}/browse/${config.sync.jira.projectKey || ''}`,
+                    type: 'jira',
+                });
+            }
+            if (config?.sync?.ado?.organization) {
+                links.push({
+                    name: 'Azure DevOps',
+                    url: `https://dev.azure.com/${config.sync.ado.organization}/${config.sync.ado.project || ''}`,
+                    type: 'ado',
+                });
+            }
+            sendJson(res, { ok: true, data: links });
+        });
+    }
+    async serveStaticFile(_req, res, url) {
+        const dashboardDir = path.resolve(__dirname, '../../../dashboard');
+        // Strip query params for static file resolution
+        const cleanUrl = url.split('?')[0];
+        let filePath = path.resolve(dashboardDir, cleanUrl === '/' ? 'index.html' : '.' + cleanUrl);
+        // SECURITY: prevent path traversal (e.g. /../../../etc/passwd)
+        if (!filePath.startsWith(dashboardDir + path.sep) && filePath !== dashboardDir) {
+            res.writeHead(403, { 'Content-Type': 'text/plain' });
+            res.end('Forbidden');
+            return;
+        }
+        // SPA fallback: serve index.html for all non-file routes
+        if (!fs.existsSync(filePath) || fs.statSync(filePath).isDirectory()) {
+            filePath = path.join(dashboardDir, 'index.html');
+        }
+        if (!fs.existsSync(filePath)) {
+            res.writeHead(404, { 'Content-Type': 'text/plain' });
+            res.end('Dashboard not built. Run: npm run build:dashboard');
+            return;
+        }
+        const ext = path.extname(filePath);
+        const contentType = MIME_TYPES[ext] || 'application/octet-stream';
+        res.writeHead(200, {
+            'Content-Type': contentType,
+            'Cache-Control': ext === '.html' ? 'no-cache' : 'public, max-age=31536000, immutable',
+        });
+        const stream = fs.createReadStream(filePath);
+        stream.on('error', () => {
+            if (!res.headersSent) {
+                res.writeHead(500, { 'Content-Type': 'text/plain' });
+            }
+            res.end('Internal server error');
+        });
+        stream.pipe(res);
+    }
+    mapEventToCategory(eventType) {
+        const map = {
+            'increment-update': 'command',
+            'analytics-event': 'command',
+            'cost-update': 'cost',
+            'notification': 'notification',
+            'sync-update': 'sync',
+            'sync-audit': 'sync',
+            'config-changed': 'command',
+            'error-detected': 'error',
+        };
+        return map[eventType] || 'command';
+    }
+}
+function pathToProjectId(p) {
+    return p.replace(/^\//, '').replace(/\//g, '-');
+}
+/** Deep merge objects (target mutated). Filters prototype pollution keys. */
+function deepMerge(target, source) {
+    const DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+    for (const key of Object.keys(source)) {
+        if (DANGEROUS_KEYS.has(key))
+            continue;
+        const sv = source[key];
+        const tv = target[key];
+        if (sv && typeof sv === 'object' && !Array.isArray(sv) && tv && typeof tv === 'object' && !Array.isArray(tv)) {
+            target[key] = deepMerge(tv, sv);
+        }
+        else {
+            target[key] = sv;
+        }
+    }
+    return target;
+}
+/** Get increment detail by reading metadata.json, tasks.md, and spec.md */
+async function getIncrementDetail(projectRoot, incrementId) {
+    // Search for increment directory
+    const incrementsDir = path.join(projectRoot, '.specweave/increments');
+    if (!fs.existsSync(incrementsDir))
+        return null;
+    let incDir = null;
+    try {
+        const dirs = fs.readdirSync(incrementsDir, { withFileTypes: true });
+        for (const d of dirs) {
+            if (!d.isDirectory())
+                continue;
+            if (d.name === incrementId || d.name.startsWith(incrementId)) {
+                incDir = path.join(incrementsDir, d.name);
+                break;
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+    if (!incDir)
+        return null;
+    // Read metadata
+    let metadata = {};
+    const metadataPath = path.join(incDir, 'metadata.json');
+    if (fs.existsSync(metadataPath)) {
+        try {
+            metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf-8'));
+        }
+        catch { /* */ }
+    }
+    // Parse tasks from tasks.md
+    const tasks = [];
+    const tasksPath = path.join(incDir, 'tasks.md');
+    if (fs.existsSync(tasksPath)) {
+        const content = fs.readFileSync(tasksPath, 'utf-8');
+        const taskRegex = /###\s+(T-\d+):\s*(.+)/g;
+        let match;
+        while ((match = taskRegex.exec(content)) !== null) {
+            const id = match[1];
+            const title = match[2].trim();
+            // Find status: look for [x] or [ ] nearby
+            const afterMatch = content.slice(match.index, match.index + 500);
+            const statusMatch = afterMatch.match(/\*\*Status\*\*:\s*\[([ x])\]/);
+            const usMatch = afterMatch.match(/\*\*User Story\*\*:\s*(US-\d+)/);
+            const acMatch = afterMatch.match(/\*\*(?:Satisfies ACs?|AC)\*\*:\s*(AC-[^\n]+)/);
+            tasks.push({
+                id,
+                title,
+                status: statusMatch?.[1] === 'x' ? 'completed' : 'pending',
+                userStory: usMatch?.[1],
+                acs: acMatch?.[1]?.split(',').map(s => s.trim()),
+            });
+        }
+    }
+    // Parse ACs from spec.md
+    const acs = [];
+    const specPath = path.join(incDir, 'spec.md');
+    if (fs.existsSync(specPath)) {
+        const content = fs.readFileSync(specPath, 'utf-8');
+        const acRegex = /- \[([ x])\] \*\*(AC-[^*]+)\*\*:\s*(.+)/g;
+        let match;
+        while ((match = acRegex.exec(content)) !== null) {
+            acs.push({
+                id: match[2].trim(),
+                text: match[3].trim(),
+                completed: match[1] === 'x',
+            });
+        }
+    }
+    const taskSummary = {
+        total: tasks.length,
+        completed: tasks.filter(t => t.status === 'completed').length,
+        pending: tasks.filter(t => t.status === 'pending').length,
+    };
+    const acSummary = {
+        total: acs.length,
+        completed: acs.filter(a => a.completed).length,
+    };
+    return {
+        id: incrementId,
+        metadata,
+        tasks,
+        taskSummary,
+        acs,
+        acSummary,
+        dirName: path.basename(incDir),
+    };
+}
+/** Scan repositories/ directory for cloned repos */
+function scanRepositories(projectRoot) {
+    const reposDir = path.join(projectRoot, 'repositories');
+    if (!fs.existsSync(reposDir))
+        return [];
+    const repos = [];
+    try {
+        const orgs = fs.readdirSync(reposDir, { withFileTypes: true });
+        for (const org of orgs) {
+            if (!org.isDirectory())
+                continue;
+            const orgDir = path.join(reposDir, org.name);
+            const repoEntries = fs.readdirSync(orgDir, { withFileTypes: true });
+            for (const repo of repoEntries) {
+                if (!repo.isDirectory())
+                    continue;
+                const repoPath = path.join(orgDir, repo.name);
+                const hasSpecweave = fs.existsSync(path.join(repoPath, '.specweave'));
+                let lastModified = '';
+                try {
+                    const stat = fs.statSync(repoPath);
+                    lastModified = stat.mtime.toISOString();
+                }
+                catch { /* */ }
+                repos.push({
+                    name: repo.name,
+                    org: org.name,
+                    path: repoPath,
+                    hasSpecweave,
+                    lastModified,
+                });
+            }
+        }
+    }
+    catch { /* */ }
+    return repos.sort((a, b) => a.name.localeCompare(b.name));
+}
+/** Check if a port is in use (service running) */
+async function checkPort(port) {
+    return new Promise((resolve) => {
+        const socket = new net.Socket();
+        socket.setTimeout(500);
+        socket.once('connect', () => { socket.destroy(); resolve(true); });
+        socket.once('timeout', () => { socket.destroy(); resolve(false); });
+        socket.once('error', () => { socket.destroy(); resolve(false); });
+        socket.connect(port, '127.0.0.1');
+    });
+}
+//# sourceMappingURL=dashboard-server.js.map