@cluesmith/codev 3.0.6 → 3.1.1

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

@@ -22,17 +22,20 @@ import { readCloudConfig } from '../lib/cloud-config.js';
 import { fileURLToPath } from 'node:url';
 import { version } from '../../version.js';
 const execAsync = promisify(exec);
+import { getBuilders, setArchitectByName } from '../state.js';
 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 { getWorktreeConfig } from '../utils/config.js';
+import { ensureWorktreeConfigWatcher } from './worktree-config-watcher.js';
 import { hasTeam, loadTeamMembers, loadMessages } from '../../lib/team.js';
 import { fetchTeamGitHubData } from '../../lib/team-github.js';
 import { resolveTarget, broadcastMessage, isResolveError } from './tower-messages.js';
 import { formatArchitectMessage, formatBuilderMessage } from '../utils/message-format.js';
 import { SendBuffer } from './send-buffer.js';
 import { writeMessageToSession } from './message-write.js';
-import { getKnownWorkspacePaths, getInstances, getDirectorySuggestions, launchInstance, killTerminalWithShellper, stopInstance, addArchitect, } from './tower-instances.js';
+import { getKnownWorkspacePaths, getInstances, getDirectorySuggestions, launchInstance, killTerminalWithShellper, stopInstance, addArchitect, removeArchitect, } from './tower-instances.js';
 import { OverviewCache } from './overview.js';
 import { fetchIssue } from '../../lib/github.js';
 import { computeAnalytics } from './analytics.js';
@@ -66,8 +69,9 @@ const ROUTES = {
     '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),
+    'GET /api/overview': (_req, res, url, ctx) => handleOverview(res, url, undefined, ctx),
     'GET /api/issue': (_req, res, url) => handleIssueView(res, url),
+    'GET /api/worktree-config': (_req, res, url) => handleWorktreeConfigView(res, url),
     'GET /api/analytics': (_req, res, url) => handleAnalytics(res, url),
     'POST /api/overview/refresh': (_req, res, _url, ctx) => handleOverviewRefresh(res, ctx),
     'GET /api/events': (req, res, _url, ctx) => handleSSEEvents(req, res, ctx),
@@ -129,7 +133,12 @@ export async function handleRequest(req, res, ctx) {
         // Workspace API: /api/workspaces/:encodedPath/architects (Spec 755 — multi-architect)
         const architectsMatch = url.pathname.match(/^\/api\/workspaces\/([^/]+)\/architects$/);
         if (architectsMatch) {
-            return await handleAddArchitect(req, res, architectsMatch);
+            return await handleAddArchitect(req, res, architectsMatch, ctx);
+        }
+        // Workspace API: DELETE /api/workspaces/:encodedPath/architects/:name (Spec 786)
+        const architectRemoveMatch = url.pathname.match(/^\/api\/workspaces\/([^/]+)\/architects\/([^/]+)$/);
+        if (architectRemoveMatch) {
+            return await handleRemoveArchitect(req, res, architectRemoveMatch, ctx);
         }
         // Terminal-specific routes: /api/terminals/:id/* (Spec 0090 Phase 2)
         const terminalRouteMatch = url.pathname.match(/^\/api\/terminals\/([^/]+)(\/.*)?$/);
@@ -190,7 +199,7 @@ async function handleListWorkspaces(res) {
  * Returns 200 { success: true, name, terminalId } on success,
  * 400 / 404 with { success: false, error } otherwise.
  */
-async function handleAddArchitect(req, res, match) {
+async function handleAddArchitect(req, res, match, ctx) {
     if (req.method !== 'POST') {
         res.writeHead(405, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ error: 'Method not allowed' }));
@@ -221,6 +230,16 @@ async function handleAddArchitect(req, res, match) {
     }
     const result = await addArchitect(workspacePath, body.name);
     if (result.success) {
+        // Spec 823: emit an `architects-updated` SSE event so VSCode's
+        // WorkspaceProvider tree refreshes when the add happens via the CLI
+        // (today the tree only refreshes when add is triggered from within
+        // VSCode itself). Mirrors `worktree-config-updated`'s broadcast shape.
+        ctx.broadcastNotification({
+            type: 'architects-updated',
+            title: 'Architects updated',
+            body: JSON.stringify({ workspace: workspacePath }),
+            workspace: workspacePath,
+        });
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ success: true, name: result.name, terminalId: result.terminalId }));
     }
@@ -231,6 +250,59 @@ async function handleAddArchitect(req, res, match) {
         res.end(JSON.stringify({ success: false, error: result.error }));
     }
 }
+/**
+ * DELETE /api/workspaces/:encodedPath/architects/:name (Spec 786)
+ *
+ * Removes a named sibling architect from an active workspace. Refuses to
+ * remove `main` (returns 400). Returns 404 when the workspace isn't active or
+ * the named architect isn't registered.
+ *
+ * Removing an architect with in-flight builders is allowed (per OQ-A) — the
+ * builders fall back to `main` via the existing `tower-messages.ts:336` chain.
+ */
+async function handleRemoveArchitect(req, res, match, ctx) {
+    if (req.method !== 'DELETE') {
+        res.writeHead(405, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Method not allowed' }));
+        return;
+    }
+    const [, encodedPath, encodedName] = match;
+    let workspacePath;
+    try {
+        workspacePath = decodeWorkspacePath(encodedPath);
+        if (!workspacePath || (!workspacePath.startsWith('/') && !/^[A-Za-z]:[\\/]/.test(workspacePath))) {
+            throw new Error('Invalid path');
+        }
+        workspacePath = normalizeWorkspacePath(workspacePath);
+    }
+    catch {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Invalid workspace path encoding' }));
+        return;
+    }
+    const name = decodeURIComponent(encodedName);
+    const result = await removeArchitect(workspacePath, name);
+    if (result.success) {
+        // Spec 823: emit `architects-updated` so VSCode's WorkspaceProvider
+        // refreshes when remove happens via CLI (the dashboard polls and
+        // doesn't need an explicit event; VSCode subscribes to this notification).
+        ctx.broadcastNotification({
+            type: 'architects-updated',
+            title: 'Architects updated',
+            body: JSON.stringify({ workspace: workspacePath }),
+            workspace: workspacePath,
+        });
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: true }));
+    }
+    else {
+        // Distinguish "not registered" / "not running" (404) from validation
+        // errors like "Cannot remove main" (400).
+        const status = result.error?.includes('not running') || result.error?.includes('not found') ? 404 : 400;
+        res.writeHead(status, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ success: false, error: result.error }));
+    }
+}
 async function handleWorkspaceAction(req, res, ctx, match) {
     const [, encodedPath, action] = match;
     let workspacePath;
@@ -578,7 +650,7 @@ async function handleStatus(res) {
     res.writeHead(200, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify({ instances }));
 }
-async function handleOverview(res, url, workspaceOverride) {
+async function handleOverview(res, url, workspaceOverride, ctx) {
     // Accept workspace from: explicit override (workspace-scoped route), ?workspace= param, or first known path.
     let workspaceRoot = workspaceOverride || url.searchParams.get('workspace');
     if (!workspaceRoot) {
@@ -601,6 +673,29 @@ async function handleOverview(res, url, workspaceOverride) {
         activeBuilderRoleIds.add(key.toLowerCase());
     }
     const data = await overviewCache.getOverview(workspaceRoot, activeBuilderRoleIds);
+    // Enrich each builder with `lastDataAt` — the wall-clock time Tower
+    // last received a DATA frame from that builder's shellper. The UI uses
+    // this to flag builders silent past a threshold as "waiting for input"
+    // (separate from formal porch gates, which `blocked` already covers).
+    //
+    // Pattern mirrors /api/state's builder loop (around line 1572): iterate
+    // `entry.builders` (Map<roleId, PtySession ID>), look up the session,
+    // do the work. Discovery already stamps `roleId` on each builder, so
+    // matching the runtime registry back to the discovery list is a single
+    // `find`. Builders with no attached session keep `lastDataAt = null`
+    // (the discover-time default).
+    const terminalManager = getTerminalManager();
+    for (const [builderId, terminalId] of entry.builders) {
+        const ptySession = terminalManager.getSession(terminalId);
+        if (!ptySession) {
+            continue;
+        }
+        const builder = data.builders.find(b => b.roleId === builderId.toLowerCase());
+        if (!builder) {
+            continue;
+        }
+        builder.lastDataAt = new Date(ptySession.lastDataAt).toISOString();
+    }
     res.writeHead(200, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify(data));
 }
@@ -628,6 +723,42 @@ async function handleIssueView(res, url) {
     res.writeHead(200, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify(issue));
 }
+/**
+ * GET /api/worktree-config — returns the canonical `ResolvedWorktreeConfig`
+ * for the requested workspace (defaults / cache / global / project /
+ * project-local, deep-merged per `lib/config.ts:loadConfig`). This is
+ * the single source of truth for any client that needs to act on
+ * worktree config (currently the VSCode extension's "Open Dev URL"
+ * surface; the dashboard is welcome to use it too).
+ *
+ * Side effect: lazily installs a directory watcher on the workspace's
+ * `.codev/` so any subsequent edit to `config.json` /
+ * `config.local.json` fans out a `worktree-config-updated` SSE event
+ * — clients refetch via this same endpoint and re-render.
+ */
+function handleWorktreeConfigView(res, url) {
+    let workspaceRoot = url.searchParams.get('workspace');
+    if (!workspaceRoot) {
+        const knownPaths = getKnownWorkspacePaths();
+        workspaceRoot = knownPaths.find(p => !p.includes('/.builders/')) || null;
+    }
+    if (!workspaceRoot) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Missing workspace' }));
+        return;
+    }
+    try {
+        const config = getWorktreeConfig(workspaceRoot);
+        ensureWorktreeConfigWatcher(workspaceRoot);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(config));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: `Failed to resolve worktree config: ${message}` }));
+    }
+}
 function handleOverviewRefresh(res, ctx) {
     overviewCache.invalidate();
     // Bugfix #388: Broadcast SSE event so all connected dashboard clients
@@ -1082,6 +1213,36 @@ async function handleWorkspaceRoutes(req, res, ctx, url) {
         if (req.method === 'POST' && apiPath === 'stop') {
             return handleWorkspaceStopAll(res, workspacePath);
         }
+        // DELETE /api/architects/:name - Remove a sibling architect (Spec 786 Phase 4)
+        // Workspace-scoped variant of /api/workspaces/:encoded/architects/:name —
+        // the workspace path comes from the /workspace/<base64>/ URL prefix already
+        // resolved above. Used by the dashboard's close-button → confirmation
+        // modal flow.
+        const archDeleteMatch = apiPath.match(/^architects\/([^/]+)$/);
+        if (req.method === 'DELETE' && archDeleteMatch) {
+            const name = decodeURIComponent(archDeleteMatch[1]);
+            const result = await removeArchitect(workspacePath, name);
+            if (result.success) {
+                // Spec 823 Phase 4 (iter-1 Codex): emit architects-updated from
+                // every successful remove path, not just the /api/workspaces/
+                // route, so the VSCode tree refreshes when the dashboard's
+                // close-button → confirmation modal triggers the remove.
+                ctx.broadcastNotification({
+                    type: 'architects-updated',
+                    title: 'Architects updated',
+                    body: JSON.stringify({ workspace: workspacePath }),
+                    workspace: workspacePath,
+                });
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ success: true }));
+            }
+            else {
+                const status = result.error?.includes('not running') || result.error?.includes('not found') ? 404 : 400;
+                res.writeHead(status, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ success: false, error: result.error }));
+            }
+            return;
+        }
         // GET /api/files - Return workspace directory tree for file browser (Spec 0092)
         if (req.method === 'GET' && apiPath === 'files') {
             return handleWorkspaceFiles(res, url, workspacePath);
@@ -1156,7 +1317,7 @@ async function handleWorkspaceRoutes(req, res, ctx, url) {
         }
         // GET /api/overview - Work view overview data (Spec 0126 Phase 4)
         if (req.method === 'GET' && apiPath === 'overview') {
-            return handleOverview(res, url, workspacePath);
+            return handleOverview(res, url, workspacePath, ctx);
         }
         // POST /api/overview/refresh - Invalidate overview cache (Spec 0126 Phase 4)
         if (req.method === 'POST' && apiPath === 'overview/refresh') {
@@ -1260,6 +1421,23 @@ async function handleWorkspaceState(res, workspacePath) {
             });
         }
     }
+    // Spec 786 Phase 4: build a lookup from builder id → spawned_by_architect so
+    // the dashboard's remove-architect confirmation modal can show which builders
+    // would lose their spawning architect (informational; per OQ-A removal
+    // proceeds regardless and they fall back to `main` routing). The data lives
+    // in `state.db.builders.spawned_by_architect` but the in-memory cache used by
+    // /api/state doesn't carry it — we read it explicitly here. Single query
+    // amortised across all builders rather than per-builder lookups.
+    const spawnedByMap = new Map();
+    try {
+        for (const b of getBuilders()) {
+            spawnedByMap.set(b.id, b.spawnedByArchitect ?? null);
+        }
+    }
+    catch {
+        // DB unavailable — modal degrades to "no in-flight builders" display.
+        // Acceptable since the modal text is informational per OQ-A.
+    }
     // Add builders from refreshed cache
     for (const [builderId, terminalId] of entry.builders) {
         const session = manager.getSession(terminalId);
@@ -1276,6 +1454,10 @@ async function handleWorkspaceState(res, workspacePath) {
                 type: 'spec',
                 terminalId,
                 persistent: isSessionPersistent(terminalId, session),
+                // Spec 786 Phase 4: surface spawning architect to the dashboard so the
+                // remove-architect modal can show affected builders. May be undefined
+                // when the builder row isn't in state.db (e.g. ephemeral test builders).
+                spawnedByArchitect: spawnedByMap.get(builderId) ?? null,
             });
         }
     }
@@ -1614,6 +1796,36 @@ async function handleWorkspaceTabDelete(res, ctx, workspacePath, tabId) {
             entry.architects.delete(name);
         }
     }
+    else if (tabId.startsWith('architect:')) {
+        // Spec 786 Phase 4 / PR iter-1 review fix: sibling architect tabs (Spec
+        // 761 ids `architect:<name>`) are closable from the mobile TabBar, which
+        // dispatches `DELETE /api/tabs/<tabId>`. Route the sibling close through
+        // `removeArchitect()` so the full lifecycle (kills PTY, deletes state.db
+        // row, suppresses cascaded delete via intentional-stop flag) runs the
+        // same way as the desktop close button + CLI.
+        const name = tabId.slice('architect:'.length);
+        const result = await removeArchitect(workspacePath, name);
+        if (result.success) {
+            // Spec 823 Phase 4 (iter-1 Codex): emit architects-updated so the
+            // VSCode tree refreshes when the remove originates from the mobile
+            // TabBar close (which doesn't trigger the dashboard's add/remove
+            // SSE event from within VSCode).
+            ctx.broadcastNotification({
+                type: 'architects-updated',
+                title: 'Architects updated',
+                body: JSON.stringify({ workspace: workspacePath }),
+                workspace: workspacePath,
+            });
+            res.writeHead(204);
+            res.end();
+        }
+        else {
+            const status = result.error?.includes('not found') || result.error?.includes('not running') ? 404 : 400;
+            res.writeHead(status, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: false, error: result.error }));
+        }
+        return;
+    }
     if (terminalId) {
         // Disable shellper auto-restart if applicable, then kill the PtySession
         await killTerminalWithShellper(manager, terminalId);
@@ -1630,6 +1842,28 @@ async function handleWorkspaceTabDelete(res, ctx, workspacePath, tabId) {
 async function handleWorkspaceStopAll(res, workspacePath) {
     const entry = getWorkspaceTerminalsEntry(workspacePath);
     const manager = getTerminalManager();
+    // Spec 786 PR iter-2 race-fix (Codex): explicitly delete every architect's
+    // `state.db.architect` row BEFORE killing or clearing the registry. The
+    // cascaded architect exit handlers in tower-instances.ts (lines 452-...,
+    // 501-..., etc.) and tower-terminals.ts work by scanning
+    // `currentEntry.architects` to recover the architect name from a dead
+    // terminal id. But stop-all clears that registry synchronously after the
+    // kills, before node-pty's async 'exit' events fire — so by the time the
+    // exit handlers look up the name, it's already gone, and they silently
+    // skip the row deletion. Result: stale `state.db.architect` rows survive
+    // what's supposed to be a full wipe, and `launchInstance` reconciliation
+    // re-spawns them on the next workspace start.
+    //
+    // The intentional-stop flag isn't the right tool here either — stop-all
+    // explicitly wants the rows gone. Pre-emptive deletion makes it
+    // explicit and order-independent: even if the exit handler somehow runs
+    // first, `setArchitectByName(name, null)` is idempotent.
+    for (const name of entry.architects.keys()) {
+        try {
+            setArchitectByName(name, null);
+        }
+        catch { /* best-effort cleanup */ }
+    }
     // Kill all terminals (disable shellper auto-restart if applicable).
     // Spec 755: iterate all named architects, not just the singleton.
     for (const terminalId of entry.architects.values()) {