@cluesmith/codev 2.0.3 → 2.0.7

package/dist/agent-farm/servers/tower-routes.js

@@ -14,38 +14,40 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';
-import { execSync } from 'node:child_process';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
 import { homedir, tmpdir } from 'node:os';
+import { encodeWorkspacePath, decodeWorkspacePath } from '../lib/tower-client.js';
 import { fileURLToPath } from 'node:url';
+const execAsync = promisify(exec);
+import { DEFAULT_COLS, defaultSessionOptions } from '../../terminal/index.js';
 import { parseJsonBody, isRequestAllowed } from '../utils/server-utils.js';
 import { isRateLimited, normalizeWorkspacePath, getLanguageForExt, getMimeTypeForFile, serveStaticFile, } from './tower-utils.js';
 import { handleTunnelEndpoint } from './tower-tunnel.js';
+import { resolveTarget, broadcastMessage, isResolveError } from './tower-messages.js';
+import { formatArchitectMessage, formatBuilderMessage } from '../utils/message-format.js';
 import { getKnownWorkspacePaths, getInstances, getDirectorySuggestions, launchInstance, killTerminalWithShellper, stopInstance, } from './tower-instances.js';
-import { getWorkspaceTerminals, getTerminalManager, getWorkspaceTerminalsEntry, getNextShellId, saveTerminalSession, isSessionPersistent, deleteTerminalSession, deleteWorkspaceTerminalSessions, saveFileTab, deleteFileTab, getTerminalsForWorkspace, } from './tower-terminals.js';
+import { OverviewCache } from './overview.js';
+import { getWorkspaceTerminals, getTerminalManager, getWorkspaceTerminalsEntry, getNextShellId, saveTerminalSession, isSessionPersistent, deleteTerminalSession, removeTerminalFromRegistry, deleteWorkspaceTerminalSessions, saveFileTab, deleteFileTab, getTerminalsForWorkspace, } from './tower-terminals.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-// ============================================================================
-// Helper: read raw request body
-// ============================================================================
-async function readBody(req) {
-    return new Promise((resolve) => {
-        let data = '';
-        req.on('data', (chunk) => data += chunk.toString());
-        req.on('end', () => resolve(data));
-    });
-}
+// Singleton cache for overview endpoint (Spec 0126 Phase 4)
+const overviewCache = new OverviewCache();
 const ROUTES = {
     'GET /health': (_req, res) => handleHealthCheck(res),
     'GET /api/workspaces': (_req, res) => handleListWorkspaces(res),
     'POST /api/terminals': (req, res, _url, ctx) => handleTerminalCreate(req, res, ctx),
     'GET /api/terminals': (_req, res) => handleTerminalList(res),
     'GET /api/status': (_req, res) => handleStatus(res),
+    'GET /api/overview': (_req, res, url) => handleOverview(res, url),
+    'POST /api/overview/refresh': (_req, res, _url, ctx) => handleOverviewRefresh(res, ctx),
     'GET /api/events': (req, res, _url, ctx) => handleSSEEvents(req, res, ctx),
     'POST /api/notify': (req, res, _url, ctx) => handleNotify(req, res, ctx),
     'GET /api/browse': (_req, res, url) => handleBrowse(res, url),
     'POST /api/create': (req, res, _url, ctx) => handleCreateWorkspace(req, res, ctx),
     'POST /api/launch': (req, res) => handleLaunchInstance(req, res),
     'POST /api/stop': (req, res) => handleStopInstance(req, res),
+    'POST /api/send': (req, res, _url, ctx) => handleSend(req, res, ctx),
     'GET /': (_req, res, _url, ctx) => handleDashboard(res, ctx),
     'GET /index.html': (_req, res, _url, ctx) => handleDashboard(res, ctx),
 };
@@ -145,7 +147,7 @@ async function handleWorkspaceAction(req, res, ctx, match) {
     const [, encodedPath, action] = match;
     let workspacePath;
     try {
-        workspacePath = Buffer.from(encodedPath, 'base64url').toString('utf-8');
+        workspacePath = decodeWorkspacePath(encodedPath);
         if (!workspacePath || (!workspacePath.startsWith('/') && !/^[A-Za-z]:[\\/]/.test(workspacePath))) {
             throw new Error('Invalid path');
         }
@@ -171,7 +173,6 @@ async function handleWorkspaceAction(req, res, ctx, match) {
             name: instance.workspaceName,
             active: instance.running,
             terminals: instance.terminals,
-            gateStatus: instance.gateStatus,
         }));
         return;
     }
@@ -244,9 +245,8 @@ async function handleTerminalCreate(req, res, ctx) {
                     args: args || [],
                     cwd,
                     env: sessionEnv,
-                    cols: cols || 200,
-                    rows: 50,
-                    restartOnExit: false,
+                    ...defaultSessionOptions(),
+                    cols: cols || DEFAULT_COLS,
                 });
                 const replayData = client.getReplayData() ?? Buffer.alloc(0);
                 const shellperInfo = shellperManager.getSessionInfo(sessionId);
@@ -333,6 +333,9 @@ async function handleTerminalRoutes(req, res, url, match) {
         }
         // TICK-001: Delete from SQLite
         deleteTerminalSession(terminalId);
+        // Bugfix #290: Also remove from in-memory registry so dashboard
+        // stops showing tabs for cleaned-up builders
+        removeTerminalFromRegistry(terminalId);
         res.writeHead(204);
         res.end();
         return;
@@ -406,6 +409,41 @@ async function handleStatus(res) {
     res.writeHead(200, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify({ instances }));
 }
+async function handleOverview(res, url, workspaceOverride) {
+    // Accept workspace from: explicit override (workspace-scoped route), ?workspace= param, or first known path.
+    let workspaceRoot = workspaceOverride || url.searchParams.get('workspace');
+    if (!workspaceRoot) {
+        const knownPaths = getKnownWorkspacePaths();
+        workspaceRoot = knownPaths.find(p => !p.includes('/.builders/')) || null;
+    }
+    if (!workspaceRoot) {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ builders: [], pendingPRs: [], backlog: [] }));
+        return;
+    }
+    // Build set of active builder role_ids (lowercased) from live terminal sessions
+    const wsTerminals = getWorkspaceTerminals();
+    const entry = wsTerminals.get(normalizeWorkspacePath(workspaceRoot));
+    const activeBuilderRoleIds = new Set();
+    if (entry) {
+        for (const key of entry.builders.keys()) {
+            activeBuilderRoleIds.add(key.toLowerCase());
+        }
+    }
+    const data = await overviewCache.getOverview(workspaceRoot, activeBuilderRoleIds);
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(data));
+}
+function handleOverviewRefresh(res, ctx) {
+    overviewCache.invalidate();
+    // Bugfix #388: Broadcast SSE event so all connected dashboard clients
+    // immediately re-fetch instead of waiting for the next poll cycle.
+    if (ctx) {
+        ctx.broadcastNotification({ type: 'overview-changed', title: 'Overview updated', body: 'Cache invalidated' });
+    }
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ ok: true }));
+}
 function handleSSEEvents(req, res, ctx) {
     const clientId = crypto.randomBytes(8).toString('hex');
     res.writeHead(200, {
@@ -446,6 +484,107 @@ async function handleNotify(req, res, ctx) {
     res.writeHead(200, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify({ success: true }));
 }
+// ============================================================================
+// POST /api/send — send a message to a resolved agent terminal
+// ============================================================================
+async function handleSend(req, res, ctx) {
+    const body = await parseJsonBody(req);
+    // Validate required fields
+    const to = typeof body.to === 'string' ? body.to.trim() : '';
+    const message = typeof body.message === 'string' ? body.message.trim() : '';
+    if (!to) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'INVALID_PARAMS', message: 'Missing or empty "to" field' }));
+        return;
+    }
+    if (!message) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'INVALID_PARAMS', message: 'Missing or empty "message" field' }));
+        return;
+    }
+    // Optional fields
+    const from = typeof body.from === 'string' ? body.from : undefined;
+    const workspace = typeof body.workspace === 'string' ? body.workspace : undefined;
+    const fromWorkspace = typeof body.fromWorkspace === 'string' ? body.fromWorkspace : undefined;
+    const options = typeof body.options === 'object' && body.options !== null
+        ? body.options
+        : {};
+    const raw = options.raw === true;
+    const noEnter = options.noEnter === true;
+    const interrupt = options.interrupt === true;
+    // Resolve the target address to a terminal ID
+    const result = resolveTarget(to, workspace);
+    if (isResolveError(result)) {
+        const statusCode = result.code === 'AMBIGUOUS' ? 409
+            : result.code === 'NO_CONTEXT' ? 400
+                : 404;
+        // Map NO_CONTEXT to INVALID_PARAMS per plan's error contract
+        const errorCode = result.code === 'NO_CONTEXT' ? 'INVALID_PARAMS' : result.code;
+        res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: errorCode, message: result.message }));
+        return;
+    }
+    // Get the terminal session
+    const manager = getTerminalManager();
+    const session = manager.getSession(result.terminalId);
+    if (!session) {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+            error: 'NOT_FOUND',
+            message: `Terminal session ${result.terminalId} not found (agent '${result.agent}' resolved but terminal is gone).`,
+        }));
+        return;
+    }
+    // Format the message based on sender/target
+    const isArchitectTarget = result.agent === 'architect';
+    let formattedMessage;
+    if (isArchitectTarget && from) {
+        // Builder → Architect
+        formattedMessage = formatBuilderMessage(from, message, undefined, raw);
+    }
+    else if (!isArchitectTarget) {
+        // Architect → Builder (or any → builder)
+        formattedMessage = formatArchitectMessage(message, undefined, raw);
+    }
+    else {
+        // Unknown sender to architect — use raw
+        formattedMessage = raw ? message : formatArchitectMessage(message, undefined, false);
+    }
+    // Optionally interrupt first
+    if (interrupt) {
+        session.write('\x03'); // Ctrl+C
+        await new Promise(resolve => setTimeout(resolve, 100));
+    }
+    // Write the message to the terminal
+    session.write(formattedMessage);
+    // Send Enter to submit (unless noEnter)
+    if (!noEnter) {
+        session.write('\r');
+    }
+    // Broadcast structured message to WebSocket subscribers
+    const senderWorkspace = fromWorkspace ?? workspace ?? 'unknown';
+    broadcastMessage({
+        type: 'message',
+        from: {
+            project: path.basename(senderWorkspace),
+            agent: from ?? 'unknown',
+        },
+        to: {
+            project: path.basename(result.workspacePath),
+            agent: result.agent,
+        },
+        content: message,
+        metadata: { raw, source: 'api' },
+        timestamp: new Date().toISOString(),
+    });
+    ctx.log('INFO', `Message sent: ${from ?? 'unknown'} → ${result.agent} (terminal ${result.terminalId.slice(0, 8)}...)`);
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+        ok: true,
+        terminalId: result.terminalId,
+        resolvedTo: result.agent,
+    }));
+}
 async function handleBrowse(res, url) {
     const inputPath = url.searchParams.get('path') || '';
     try {
@@ -493,9 +632,8 @@ async function handleCreateWorkspace(req, res, ctx) {
     }
     try {
         // Run codev init (it creates the directory)
-        execSync(`codev init --yes "${workspaceName}"`, {
+        await execAsync(`codev init --yes "${workspaceName}"`, {
             cwd: expandedParent,
-            stdio: 'pipe',
             timeout: 60000,
         });
         // Launch the instance
@@ -593,7 +731,7 @@ async function handleWorkspaceRoutes(req, res, ctx, url) {
     // Decode Base64URL (RFC 4648)
     let workspacePath;
     try {
-        workspacePath = Buffer.from(encodedPath, 'base64url').toString('utf-8');
+        workspacePath = decodeWorkspacePath(encodedPath);
         // Support both POSIX (/) and Windows (C:\) paths
         if (!workspacePath || (!workspacePath.startsWith('/') && !/^[A-Za-z]:[\\/]/.test(workspacePath))) {
             throw new Error('Invalid workspace path');
@@ -618,7 +756,7 @@ async function handleWorkspaceRoutes(req, res, ctx, url) {
         await handleTunnelEndpoint(req, res, tunnelSub);
         return;
     }
-    // GET /file?path=<relative-path> — Read workspace file by path (for StatusPanel workspace list)
+    // GET /file?path=<relative-path> — Read workspace file by path
     if (req.method === 'GET' && subPath === 'file' && url.searchParams.has('path')) {
         const relPath = url.searchParams.get('path');
         const fullPath = path.resolve(workspacePath, relPath);
@@ -771,6 +909,18 @@ async function handleWorkspaceRoutes(req, res, ctx, url) {
             });
             return;
         }
+        // GET /api/overview - Work view overview data (Spec 0126 Phase 4)
+        if (req.method === 'GET' && apiPath === 'overview') {
+            return handleOverview(res, url, workspacePath);
+        }
+        // POST /api/overview/refresh - Invalidate overview cache (Spec 0126 Phase 4)
+        if (req.method === 'POST' && apiPath === 'overview/refresh') {
+            return handleOverviewRefresh(res, ctx);
+        }
+        // GET /api/events - SSE push notifications (Bugfix #388)
+        if (req.method === 'GET' && apiPath === 'events') {
+            return handleSSEEvents(req, res, ctx);
+        }
         // Unhandled API route
         res.writeHead(404, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ error: 'API endpoint not found', path: apiPath }));
@@ -799,9 +949,9 @@ async function handleWorkspaceRoutes(req, res, ctx, url) {
 async function handleWorkspaceState(res, workspacePath) {
     // Refresh cache via getTerminalsForWorkspace (handles SQLite sync
     // and shellper reconnection in one place)
-    const encodedPath = Buffer.from(workspacePath).toString('base64url');
+    const encodedPath = encodeWorkspacePath(workspacePath);
     const proxyUrl = `/workspace/${encodedPath}/`;
-    const { gateStatus } = await getTerminalsForWorkspace(workspacePath, proxyUrl);
+    await getTerminalsForWorkspace(workspacePath, proxyUrl);
     // Now read from the refreshed cache
     const entry = getWorkspaceTerminalsEntry(workspacePath);
     const manager = getTerminalManager();
@@ -811,7 +961,6 @@ async function handleWorkspaceState(res, workspacePath) {
         utils: [],
         annotations: [],
         workspaceName: path.basename(workspacePath),
-        gateStatus,
     };
     // Add architect if exists
     if (entry.architect) {
@@ -845,7 +994,7 @@ async function handleWorkspaceState(res, workspacePath) {
         if (session) {
             state.builders.push({
                 id: builderId,
-                name: `Builder ${builderId}`,
+                name: builderId,
                 port: 0,
                 pid: session.pid || 0,
                 status: 'running',
@@ -891,9 +1040,7 @@ async function handleWorkspaceShellCreate(res, ctx, workspacePath) {
                     args: shellArgs,
                     cwd: workspacePath,
                     env: shellEnv,
-                    cols: 200,
-                    rows: 50,
-                    restartOnExit: false,
+                    ...defaultSessionOptions(),
                 });
                 const replayData = client.getReplayData() ?? Buffer.alloc(0);
                 const shellperInfo = shellperManager.getSessionInfo(sessionId);
@@ -954,8 +1101,10 @@ async function handleWorkspaceShellCreate(res, ctx, workspacePath) {
 }
 async function handleWorkspaceFileTabCreate(req, res, ctx, workspacePath) {
     try {
-        const body = await readBody(req);
-        const { path: filePath, line, terminalId } = JSON.parse(body || '{}');
+        const body = await parseJsonBody(req);
+        const filePath = body.path;
+        const line = body.line;
+        const terminalId = body.terminalId;
         if (!filePath || typeof filePath !== 'string') {
             res.writeHead(400, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({ error: 'Missing path parameter' }));
@@ -1116,8 +1265,7 @@ async function handleWorkspaceFileSave(req, res, ctx, workspacePath, tabId) {
         return;
     }
     try {
-        const body = await readBody(req);
-        const { content } = JSON.parse(body || '{}');
+        const { content } = await parseJsonBody(req);
         if (typeof content !== 'string') {
             res.writeHead(400, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({ error: 'Missing content parameter' }));
@@ -1241,10 +1389,10 @@ function handleWorkspaceFiles(res, url, workspacePath) {
     res.writeHead(200, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify(tree));
 }
-function handleWorkspaceGitStatus(res, ctx, workspacePath) {
+async function handleWorkspaceGitStatus(res, ctx, workspacePath) {
     try {
         // Get git status in porcelain format for parsing
-        const result = execSync('git status --porcelain', {
+        const { stdout: result } = await execAsync('git status --porcelain', {
             cwd: workspacePath,
             encoding: 'utf-8',
             timeout: 5000,