codehere 0.6.0-alpha.1 → 0.6.0

package/dist/infrastructure/protocols/mcp-server-impl.js

@@ -26,6 +26,7 @@ import { collectFilesForMCP, scoreFileForMCP } from './mcp-helpers.js';
 import { scanPayload, calculateRiskScore, AUDIT_FILE, verifyAuditChain, } from '../hooks/claude-sdk-hook.js';
 import { getVersion } from '../../utils/version.js';
 import { TASK_HTML, HISTORY_HTML, THREAD_HTML } from './ui-page.js';
+import { TASK_HTML_V2 } from './ui-page-v2.js';
 import { SessionManager, availableAgents, readinessForAllAgents, getAdapter, allAdapters, } from '../orchestration/session-manager.js';
 import { isAbsolute } from 'path';
 import { readCrossToolAgents } from '../storage/cross-tool-agents.js';
@@ -319,8 +320,14 @@ export function startMCPServer(options = {}) {
             res.end(JSON.stringify({ status: 'ok', server: 'codehere-mcp', version: getVersion(), tools: TOOLS.length }));
             return;
         }
-        // v0.3 primary UI: task intake + active sessions
+        // v2 Task-Centric PM UI (primary — served at /)
         if (req.method === 'GET' && (req.url === '/' || req.url === '/index.html')) {
+            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end(withDevElu(TASK_HTML_V2));
+            return;
+        }
+        // v1 dashboard (legacy — at /v1)
+        if (req.method === 'GET' && (req.url === '/v1' || req.url === '/v1/')) {
             res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
             res.end(withDevElu(TASK_HTML));
             return;
@@ -394,6 +401,58 @@ export function startMCPServer(options = {}) {
             });
             return;
         }
+        // ── P4 SSE — session lifecycle events (realtime /v2 updates) ────────────
+        // Tails sessions.jsonl and pushes "change" events so the /v2 UI can
+        // re-fetch task state instantly instead of waiting 8s for the next poll.
+        // Same pattern as /events (audit log tail) but for sessions.
+        const SESSIONS_FILE = join(homedir(), '.codehere', 'sessions.jsonl');
+        if (req.method === 'GET' && req.url === '/api/events/sessions') {
+            res.writeHead(200, {
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                Connection: 'keep-alive',
+            });
+            // Send current session state on connect
+            try {
+                const manager = SessionManager.getInstance();
+                const sessions = manager.list().map(s => ({
+                    sessionId: s.sessionId,
+                    status: s.status,
+                    agent: s.agent,
+                }));
+                res.write(`data: ${JSON.stringify({ type: 'init', sessions })}\n\n`);
+            }
+            catch {
+                res.write(`data: ${JSON.stringify({ type: 'init', sessions: [] })}\n\n`);
+            }
+            // Tail sessions.jsonl for changes
+            let lastSize = 0;
+            if (existsSync(SESSIONS_FILE)) {
+                try {
+                    lastSize = statSync(SESSIONS_FILE).size;
+                }
+                catch { /* first time */ }
+            }
+            const onChange = () => {
+                try {
+                    if (!existsSync(SESSIONS_FILE))
+                        return;
+                    const currentSize = statSync(SESSIONS_FILE).size;
+                    if (currentSize <= lastSize)
+                        return;
+                    lastSize = currentSize;
+                    res.write(`data: ${JSON.stringify({ type: 'change' })}\n\n`);
+                }
+                catch { /* transient */ }
+            };
+            watchFile(SESSIONS_FILE, { interval: 500 }, onChange);
+            const ping = setInterval(() => res.write(': ping\n\n'), 15000);
+            req.on('close', () => {
+                clearInterval(ping);
+                unwatchFile(SESSIONS_FILE, onChange);
+            });
+            return;
+        }
         // ── F2 agent registry ─────────────────────────────────────────────────────
         if (req.method === 'GET' && req.url === '/api/agents') {
             res.writeHead(200, { 'Content-Type': 'application/json' });
@@ -1013,13 +1072,12 @@ export function startMCPServer(options = {}) {
             }
             if (req.method === 'GET' && req.url === '/api/tasks') {
                 const spawned = manager.list().map((s) => {
-                    // Bug 2 sister-fix (May 2): include completedAt for in-memory exited
-                    // sessions so the UI can compute duration. TaskSession interface
-                    // intentionally lacks completedAt; SessionManager tracks it separately
-                    // in completedAtBySession map (populated when exit event fires).
                     const completedAt = manager.getCompletedAt(s.sessionId);
                     const finalReport = manager.getFinalReport(s.sessionId);
                     const cwd = manager.getCwd(s.sessionId);
+                    const continuedFrom = manager.getContinuedFrom(s.sessionId);
+                    const continuedAs = manager.getContinuedAs(s.sessionId);
+                    const failedReport = manager.hasFailedReport(s.sessionId);
                     return {
                         sessionId: s.sessionId,
                         prompt: s.prompt,
@@ -1030,13 +1088,11 @@ export function startMCPServer(options = {}) {
                         artifacts: s.artifacts,
                         ...(completedAt !== undefined ? { completedAt, durationMs: completedAt - s.startedAt } : {}),
                         ...(finalReport !== undefined ? { finalReport } : {}),
-                        // Iter 12 — surface canAppendMessage so the UI knows whether to
-                        // render the reply input or a disabled "follow-up unsupported" state.
+                        ...(failedReport ? { failedReport: true } : {}),
                         canAppendMessage: s.canAppendMessage === true,
-                        // v0.6.x Slack-shape spike — surface cwd so the dashboard's
-                        // "Continue thread" intake button can find the most recent
-                        // in-memory session for the current folder.
                         ...(cwd !== undefined ? { cwd } : {}),
+                        ...(continuedFrom !== undefined ? { continuedFrom } : {}),
+                        ...(continuedAs !== undefined ? { continuedAs } : {}),
                         provenance: 'spawned',
                     };
                 });
@@ -1207,6 +1263,62 @@ export function startMCPServer(options = {}) {
             res.end(JSON.stringify({ error: 'Method not allowed for this path' }));
             return;
         }
+        // v0.6.x P0 — GET /api/failover-offers
+        // Returns active failover offers so the dashboard can surface a
+        // "Claude rate-limited — switch to Codex?" banner. Offers expire
+        // after 60 s (handled by SessionManager).
+        if (req.method === 'GET' && req.url === '/api/failover-offers') {
+            const offers = SessionManager.getInstance().getFailoverOffers();
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ offers }));
+            return;
+        }
+        // v0.6.x P0 — POST /api/failover-accept
+        // User clicked "Switch" on the failoffer banner. Spawns a
+        // replacement session on the target agent, preserving the
+        // original prompt + cwd.
+        if (req.method === 'POST' && req.url === '/api/failover-accept') {
+            let body = '';
+            req.on('data', (c) => { body += c; });
+            req.on('end', () => {
+                let parsed;
+                try {
+                    const raw = JSON.parse(body);
+                    if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+                        res.writeHead(400, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ error: 'invalid_body' }));
+                        return;
+                    }
+                    parsed = raw;
+                }
+                catch {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'invalid_body' }));
+                    return;
+                }
+                if (typeof parsed.sessionId !== 'string' || typeof parsed.targetAgent !== 'string') {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'missing_sessionId_or_targetAgent' }));
+                    return;
+                }
+                try {
+                    const result = SessionManager.getInstance().acceptFailover(parsed.sessionId, parsed.targetAgent);
+                    if (result) {
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ ok: true, newSessionId: result.sessionId }));
+                    }
+                    else {
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ ok: false, error: 'target_unavailable', detail: `Could not spawn ${parsed.targetAgent}. Check if it's installed and authenticated.` }));
+                    }
+                }
+                catch (e) {
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'failover_failed', detail: String(e) }));
+                }
+            });
+            return;
+        }
         // MCP endpoint — POST jsonrpc; reject other verbs with 405 + Allow header
         // (rc.17: was 404, which is wrong HTTP semantic — UX_OBSERVATIONS P3).
         if (req.url === '/mcp') {