@mrpatronz/nexusflow 2.0.0 → 2.2.0

package/dist/server.js

@@ -23,13 +23,14 @@ import { createNewRepo } from './core/new-repo.js';
 import { loadProjects, createProject, updateProject, removeProject, slugifyProjectName } from './core/projects.js';
 import { getSessionCwd, isInPlace, resolveFeatureRepoPath } from './utils/feature.js';
 import { listBranches } from './utils/git.js';
-import { createWorkspace, listWorkspaces, loadFeatureConfig, deleteWorkspace, addRepoToWorkspace } from './core/workspace.js';
+import { createWorkspace, listWorkspaces, loadFeatureConfig, loadWorkspaceManifest, deleteWorkspace, addRepoToWorkspace } from './core/workspace.js';
 import { loadWorkspaceState } from './core/workspace-state.js';
 import { analyzeAllRepos } from './analyzers/index.js';
 import { generateContextFiles } from './generators/index.js';
 import { detectAIAssistants } from './utils/detect-ai.js';
 import { detectEditors } from './utils/detect-editors.js';
-import { findSessions, getSessionTranscript } from './utils/session-finder.js';
+import { buildWorkspaceLaunchPrompt, detectWorkspaceLaunchTargets, launchTargetIdForEditorCommand, launchWorkspaceTarget, } from './utils/workspace-launch.js';
+import { canOpenCodexSessionInWorkspace, findSessions, getSessionTranscript } from './utils/session-finder.js';
 import { ProviderRegistry } from './agent/adapters.js';
 import { isValidSessionUuid } from './agent/session.js';
 import { getRepoStatus } from './utils/multi-git.js';
@@ -51,9 +52,45 @@ const __dirname = path.dirname(__filename);
 const guiPath = path.join(__dirname, 'gui');
 export const app = new Hono();
 const { injectWebSocket, upgradeWebSocket } = createNodeWebSocket({ app });
-app.get('/api/adapters/status', (c) => {
-    return c.json(ProviderRegistry.getAllStatus());
-});
+function hasTrustedLocalOrigin(origin) {
+    if (!origin)
+        return false;
+    try {
+        const { hostname } = new URL(origin);
+        return ['localhost', '127.0.0.1', '::1', '[::1]'].includes(hostname);
+    }
+    catch {
+        return false;
+    }
+}
+/** Validate and dispatch one renderer turn without letting malformed authority reach a harness. */
+export function dispatchAgentInput(agent, provider, payload) {
+    if (typeof payload.input !== 'string' || !payload.input.trim()) {
+        return 'A non-empty input message is required.';
+    }
+    const executionProfile = ProviderRegistry.resolveExecutionProfile(provider, payload.executionProfile);
+    if (executionProfile === null) {
+        return 'Select a supported execution profile before sending this turn.';
+    }
+    void agent.send(payload.input, executionProfile);
+    return null;
+}
+/** Per-socket admission guard so a second prompt is rejected, never dropped. */
+export class AgentTurnGate {
+    active = false;
+    tryBegin() {
+        if (this.active)
+            return false;
+        this.active = true;
+        return true;
+    }
+    settle() {
+        this.active = false;
+    }
+    isActive() {
+        return this.active;
+    }
+}
 app.get('/ws', async (c, next) => {
     // Prevent Cross-Site WebSocket Hijacking (CSWSH)
     const origin = c.req.header('origin');
@@ -69,11 +106,16 @@ app.get('/ws', async (c, next) => {
         }
     }
     // Chat protocol:
-    //   client -> server: {type:'start', command, cwd, sessionId?, resume?} | {type:'input', input} | {type:'stop'} | 'ping'
-    //   server -> client: {type:'stream', text} | {type:'status', state:'busy'|'idle'} | {type:'system', message}
-    //                     | {type:'error', message} | {type:'close', code} | {type:'pong'}
+    //   client -> server: {type:'start', command, cwd, sessionId?, resume?}
+    //                    | {type:'input', input, turnId?, executionProfile?} | {type:'stop'} | 'ping'
+    //   server -> client: {type:'stream', text} | {type:'session', id} | {type:'status', state:'busy'|'idle'} | {type:'system', message}
+    //                     | {type:'accepted', turnId?} | {type:'error', message}
+    //                     | {type:'rejected', reason:'busy', message, turnId?}
+    //                     | {type:'close', code} | {type:'pong'}
     return upgradeWebSocket((c) => {
         let agent = null;
+        let activeProvider = null;
+        const turnGate = new AgentTurnGate();
         return {
             onMessage(event, ws) {
                 if (typeof event.data === 'string') {
@@ -87,8 +129,12 @@ app.get('/ws', async (c, next) => {
                             ws.send(JSON.stringify({ type: 'pong' }));
                         }
                         else if (payload.type === 'start') {
+                            turnGate.settle();
                             if (agent) {
-                                agent.stop();
+                                const previousAgent = agent;
+                                agent = null;
+                                activeProvider = null;
+                                previousAgent.stop();
                             }
                             const provider = ProviderRegistry.getProvider(payload.command);
                             if (!provider) {
@@ -103,35 +149,86 @@ app.get('/ws', async (c, next) => {
                                 }
                                 session = { id: payload.sessionId, resume: Boolean(payload.resume) };
                             }
-                            agent = provider.createInstance();
-                            agent.on('data', (text) => {
+                            const startedAgent = provider.createInstance();
+                            agent = startedAgent;
+                            activeProvider = provider;
+                            const isCurrentAgent = () => agent === startedAgent;
+                            startedAgent.on('data', (text) => {
+                                if (!isCurrentAgent())
+                                    return;
                                 ws.send(JSON.stringify({ type: 'stream', text }));
                             });
-                            agent.on('system', (message) => {
+                            startedAgent.on('system', (message) => {
+                                if (!isCurrentAgent())
+                                    return;
                                 ws.send(JSON.stringify({ type: 'system', message }));
                             });
-                            agent.on('idle', () => {
+                            startedAgent.on('session', (id) => {
+                                if (!isCurrentAgent())
+                                    return;
+                                // Provider output is still boundary input. Only inert UUIDs
+                                // may be persisted by the renderer and sent back in argv.
+                                if (isValidSessionUuid(id)) {
+                                    ws.send(JSON.stringify({ type: 'session', id }));
+                                }
+                            });
+                            startedAgent.on('idle', () => {
+                                if (!isCurrentAgent())
+                                    return;
+                                turnGate.settle();
                                 ws.send(JSON.stringify({ type: 'status', state: 'idle' }));
                             });
-                            agent.on('close', (code) => {
+                            startedAgent.on('close', (code) => {
+                                if (!isCurrentAgent())
+                                    return;
+                                turnGate.settle();
                                 ws.send(JSON.stringify({ type: 'close', code }));
                             });
-                            agent.on('error', (error) => {
+                            startedAgent.on('error', (error) => {
+                                if (!isCurrentAgent())
+                                    return;
                                 ws.send(JSON.stringify({ type: 'error', message: error?.message ?? String(error) }));
-                                ws.send(JSON.stringify({ type: 'status', state: 'idle' }));
                             });
-                            agent.start(payload.cwd, session);
+                            startedAgent.start(payload.cwd, session);
                         }
                         else if (payload.type === 'input') {
-                            if (agent) {
-                                agent.send(payload.input);
-                                ws.send(JSON.stringify({ type: 'status', state: 'busy' }));
+                            if (agent && activeProvider) {
+                                if (!turnGate.tryBegin()) {
+                                    const turnId = isValidSessionUuid(payload.turnId) ? payload.turnId : undefined;
+                                    ws.send(JSON.stringify({
+                                        type: 'rejected',
+                                        reason: 'busy',
+                                        message: 'The agent is still processing the current turn.',
+                                        ...(turnId ? { turnId } : {}),
+                                    }));
+                                    return;
+                                }
+                                const error = dispatchAgentInput(agent, activeProvider, payload);
+                                if (error) {
+                                    turnGate.settle();
+                                    ws.send(JSON.stringify({ type: 'error', message: error }));
+                                    return;
+                                }
+                                // Some harness validation failures emit error + idle
+                                // synchronously from send(); do not overwrite that settled
+                                // state with a late busy frame.
+                                if (turnGate.isActive()) {
+                                    const turnId = isValidSessionUuid(payload.turnId) ? payload.turnId : undefined;
+                                    ws.send(JSON.stringify({
+                                        type: 'accepted',
+                                        ...(turnId ? { turnId } : {}),
+                                    }));
+                                    ws.send(JSON.stringify({ type: 'status', state: 'busy' }));
+                                }
                             }
                         }
                         else if (payload.type === 'stop') {
+                            turnGate.settle();
                             if (agent) {
-                                agent.stop();
+                                const stoppedAgent = agent;
                                 agent = null;
+                                activeProvider = null;
+                                stoppedAgent.stop();
                             }
                         }
                     }
@@ -145,9 +242,12 @@ app.get('/ws', async (c, next) => {
             },
             onClose(_event, _ws) {
                 console.log('[WS] Client disconnected');
+                turnGate.settle();
                 if (agent) {
-                    agent.stop();
+                    const disconnectedAgent = agent;
                     agent = null;
+                    activeProvider = null;
+                    disconnectedAgent.stop();
                 }
             },
         };
@@ -182,6 +282,31 @@ function assertWithin(baseDir, target) {
 export function resolveWorkspacePath(workspacesDir, id) {
     return assertWithin(workspacesDir, path.join(workspacesDir, id));
 }
+/**
+ * Resolve a launch path through the filesystem and require it to be the exact
+ * workspace declared by its manifest. This prevents symlink escapes and stops
+ * loadFeatureConfig's parent-directory fallback from authorizing a child path.
+ */
+async function resolveExactLaunchWorkspace(workspacesDir, candidatePath) {
+    const lexicalPath = assertWithin(workspacesDir, candidatePath);
+    const [canonicalRoot, canonicalWorkspace] = await Promise.all([
+        fs.realpath(workspacesDir),
+        fs.realpath(lexicalPath),
+    ]);
+    const safeWorkspacePath = assertWithin(canonicalRoot, canonicalWorkspace);
+    const feature = await loadWorkspaceManifest(safeWorkspacePath);
+    if (!feature || typeof feature.workspacePath !== 'string')
+        return null;
+    try {
+        const declaredWorkspace = await fs.realpath(path.resolve(feature.workspacePath));
+        return path.resolve(declaredWorkspace) === path.resolve(safeWorkspacePath)
+            ? safeWorkspacePath
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
 /** Safe sub-repo path for a repo name, contained within the workspace. */
 export function resolveRepoPath(workspacePath, repoName) {
     return assertWithin(workspacePath, path.join(workspacePath, repoName));
@@ -236,6 +361,29 @@ app.use('/api/*', cors({
     },
 }));
 // ─── API Endpoints ────────────────────────────────────────────────────────
+// Status checks may execute a trusted local CLI from PATH. Keep that work
+// behind a non-simple, same-machine POST so a remote page cannot trigger it
+// with an image, link, or cross-origin fetch. These routes intentionally sit
+// after the API CORS middleware so the separate Vite dev origin can read them.
+app.get('/api/adapters/status', (c) => {
+    return c.json({ error: 'Use the same-origin POST status endpoint.' }, 405);
+});
+app.post('/api/adapters/status', (c) => {
+    if (!hasTrustedLocalOrigin(c.req.header('origin'))) {
+        return c.json({ error: 'A local browser origin is required.' }, 403);
+    }
+    return c.json(ProviderRegistry.getAllStatus());
+});
+app.post('/api/adapters/status/refresh', async (c) => {
+    if (!hasTrustedLocalOrigin(c.req.header('origin'))) {
+        return c.json({ error: 'A local browser origin is required.' }, 403);
+    }
+    const body = await c.req.json().catch(() => null);
+    if (body?.providerId !== 'claude-cli' && body?.providerId !== 'codex-cli') {
+        return c.json({ error: 'Only Claude Code and Codex status can be refreshed.' }, 400);
+    }
+    return c.json(ProviderRegistry.getAllStatus({ refreshProviderId: body.providerId }));
+});
 // 1. Get current configuration
 app.get('/api/config', async (c) => {
     try {
@@ -787,16 +935,93 @@ app.post('/api/workspace/suggest-workflow', async (c) => {
         return errorResponse(c, error);
     }
 });
-// 8. Open workspace in editor
+// 8. List the closed, server-owned launch catalog.
+app.get('/api/workspace-launch-targets', async (c) => {
+    try {
+        return c.json(await detectWorkspaceLaunchTargets());
+    }
+    catch (error) {
+        return errorResponse(c, error);
+    }
+});
+// 8a. Open a real NexusFlow workspace in a selected desktop app or editor.
+app.post('/api/workspace/:id/launch', async (c) => {
+    try {
+        const id = decodeURIComponent(c.req.param('id'));
+        const { targetId, action = 'new', sessionId } = await c.req.json().catch(() => ({}));
+        if (typeof targetId !== 'string' || !targetId) {
+            return c.json({ error: 'A workspace launch target is required.' }, 400);
+        }
+        if (action !== 'new' && action !== 'resume') {
+            return c.json({ error: 'Unknown workspace launch action.' }, 400);
+        }
+        if (action === 'new' && sessionId !== undefined) {
+            return c.json({ error: 'A new workspace launch cannot include a session id.' }, 400);
+        }
+        const config = await loadConfig();
+        const requestedWorkspacePath = resolveWorkspacePath(config.workspacesDir, id);
+        let workspacePath;
+        try {
+            workspacePath = await resolveExactLaunchWorkspace(config.workspacesDir, requestedWorkspacePath);
+        }
+        catch (error) {
+            if (error instanceof PathAccessError)
+                throw error;
+            return c.json({ error: 'Workspace configuration not found.' }, 404);
+        }
+        if (!workspacePath) {
+            return c.json({ error: 'Workspace configuration not found.' }, 404);
+        }
+        const feature = await loadWorkspaceManifest(workspacePath);
+        if (!feature) {
+            return c.json({ error: 'Workspace configuration not found.' }, 404);
+        }
+        const targets = await detectWorkspaceLaunchTargets();
+        const target = targets.find((candidate) => candidate.id === targetId);
+        if (!target)
+            return c.json({ error: 'Unknown workspace launch target.' }, 400);
+        if (!target.available) {
+            return c.json({ error: target.unavailableReason ?? `${target.name} is unavailable.` }, 409);
+        }
+        if (action === 'resume') {
+            if (targetId !== 'codex-desktop') {
+                return c.json({ error: 'This app cannot open an existing coding session.' }, 400);
+            }
+            if (typeof sessionId !== 'string' || !isValidSessionUuid(sessionId)) {
+                return c.json({ error: 'A valid Codex session id is required.' }, 400);
+            }
+            const ownsSession = await canOpenCodexSessionInWorkspace(workspacePath, feature.repos, sessionId);
+            if (!ownsSession) {
+                return c.json({ error: 'Codex session not found in this workspace.' }, 404);
+            }
+            await launchWorkspaceTarget(targetId, workspacePath, { kind: 'resume-session', sessionId });
+            return c.json({ success: true, targetId, action, sessionId });
+        }
+        await launchWorkspaceTarget(targetId, workspacePath, {
+            kind: 'new-workspace',
+            prompt: buildWorkspaceLaunchPrompt(feature),
+        });
+        return c.json({ success: true, targetId, action });
+    }
+    catch (error) {
+        return errorResponse(c, error);
+    }
+});
+// 8b. Legacy editor route retained for older GUI clients using recognized
+// graphical editors. Interactive terminal editors are intentionally rejected:
+// a detached HTTP request cannot safely provide their required TTY.
 app.post('/api/open-editor', async (c) => {
     try {
         const { workspacePath, command } = await c.req.json();
-        if (!ALLOWED_EDITORS.has(command)) {
+        const targetId = launchTargetIdForEditorCommand(command);
+        if (!ALLOWED_EDITORS.has(command) || !targetId) {
             return c.json({ error: 'Forbidden editor command' }, 400);
         }
-        // Validate path exists and is a directory
+        const config = await loadConfig();
+        const safeWorkspacePath = assertWithin(config.workspacesDir, workspacePath);
+        // Validate this is an existing NexusFlow workspace, not an arbitrary path.
         try {
-            const stats = await fs.stat(workspacePath);
+            const stats = await fs.stat(safeWorkspacePath);
             if (!stats.isDirectory()) {
                 return c.json({ error: 'Workspace path is not a directory' }, 400);
             }
@@ -804,18 +1029,11 @@ app.post('/api/open-editor', async (c) => {
         catch {
             return c.json({ error: 'Workspace path does not exist' }, 400);
         }
-        // Spawn editor process
-        const isWin = process.platform === 'win32';
-        const child = execa(command, [workspacePath], {
-            detached: true,
-            stdio: 'ignore',
-            shell: isWin,
-            cleanup: false,
-        });
-        child.unref();
-        child.catch((err) => {
-            console.error(`Failed to launch editor ${command} for path ${workspacePath}:`, err);
-        });
+        const exactWorkspacePath = await resolveExactLaunchWorkspace(config.workspacesDir, safeWorkspacePath);
+        if (!exactWorkspacePath) {
+            return c.json({ error: 'Workspace configuration not found.' }, 404);
+        }
+        await launchWorkspaceTarget(targetId, exactWorkspacePath);
         return c.json({ success: true });
     }
     catch (error) {
@@ -1380,6 +1598,9 @@ app.get('/api/session/:assistant/:sessionId/transcript', async (c) => {
     const assistant = c.req.param('assistant');
     const sessionId = c.req.param('sessionId');
     try {
+        if (assistant === 'codex' && !isValidSessionUuid(sessionId)) {
+            return c.json({ error: 'Invalid Codex session id.' }, 400);
+        }
         const messages = await getSessionTranscript(assistant, sessionId);
         return c.json({ messages });
     }
@@ -1559,6 +1780,7 @@ app.post('/api/workflows/templates/:id/analyze', async (c) => {
         const selectedAssistant = assistant || 'antigravity';
         let command = '';
         let args = [];
+        let commandInput = '';
         let prompt = `You are an expert AI system engineering reviewer. Analyze the following Agent Teamwork Strategy guidelines.
 Evaluate its instructions, identify any ambiguities or contradictions, rate its expected effectiveness for orchestrating subagents, and provide specific recommendations or improvements. Format your analysis in clean Markdown with clear headings (e.g. Overview, Strengths, Weaknesses, Recommendations).
 
@@ -1585,11 +1807,17 @@ and suffix it with:
         else if (command === 'agy') {
             args = [prompt];
         }
+        else if (command === 'codex') {
+            // Captured stdio cannot host the interactive TUI. `codex exec` is the
+            // supported non-interactive surface and reuses the user's CLI login.
+            args = ['exec', '--color', 'never', '-'];
+            commandInput = prompt;
+        }
         else {
             args = [prompt];
         }
         const result = await execa(command, args, {
-            input: '',
+            input: commandInput,
             shell: false,
             reject: false
         });