@mrpatronz/nexusflow 1.7.0 → 1.9.0

package/dist/server.js

@@ -7,6 +7,7 @@ import { serve } from '@hono/node-server';
 import { serveStatic } from '@hono/node-server/serve-static';
 import { cors } from 'hono/cors';
 import { streamSSE } from 'hono/streaming';
+import { createNodeWebSocket } from '@hono/node-ws';
 import * as fs from 'node:fs/promises';
 import { createWriteStream, existsSync } from 'node:fs';
 import * as path from 'node:path';
@@ -19,16 +20,18 @@ import { loadConfig, saveConfig, getConfigDir } from './core/config.js';
 import { listStorageProviders } from './core/adapters/registry.js';
 import { scanForRepos } from './core/scanner.js';
 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 { loadWorkspaceState } from './core/workspace-state.js';
 import { analyzeAllRepos } from './analyzers/index.js';
 import { generateContextFiles } from './generators/index.js';
-import { isOllamaModelAvailable, getOpenAiCompatibleUrl, callLocalLlm } from './utils/local-ai.js';
 import { detectAIAssistants } from './utils/detect-ai.js';
 import { detectEditors } from './utils/detect-editors.js';
 import { findSessions, getSessionTranscript } from './utils/session-finder.js';
-import { scanSystemSpecs } from './utils/system-scanner.js';
+import { ProviderRegistry } from './agent/adapters.js';
+import { isValidSessionUuid } from './agent/session.js';
 import { getRepoStatus } from './utils/multi-git.js';
 import { syncWorkspace } from './core/sync.js';
 import { commitWorkspace } from './core/commit.js';
@@ -36,7 +39,7 @@ import { refreshWorkspace } from './core/refresh.js';
 import { writeWorkspaceFile } from './core/storage.js';
 import { readWorkspaceKnowledge, addWorkspaceKnowledge, addBaseKnowledge, } from './core/knowledge.js';
 import { addSchedule, loadSchedules, nextDueAt, parseInterval, removeSchedule, runJob, setScheduleEnabled, startScheduler, } from './core/scheduler.js';
-import { detectAllServices, detectOrchestrationTools, startServices, stopServices, loadRunningState, getPm2List, } from './orchestration/index.js';
+import { detectAllServices, detectOrchestrationTools, startServices, stopServices, startService, stopService, restartService, startOrchestrator, stopOrchestrator, tailLogFile, loadRunningState, getPm2List, } from './orchestration/index.js';
 import { checkForUpdates, getCurrentVersion, getToolsStatus } from './utils/update-check.js';
 import { getWorkflowTemplates, saveWorkflowTemplate, deleteWorkflowTemplate } from './utils/workflows.js';
 import { suggestWorkflow } from './utils/workflow-advisor.js';
@@ -47,6 +50,109 @@ const __dirname = path.dirname(__filename);
 // In production, it will be served from dist/gui as well
 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());
+});
+app.get('/ws', async (c, next) => {
+    // Prevent Cross-Site WebSocket Hijacking (CSWSH)
+    const origin = c.req.header('origin');
+    if (origin) {
+        try {
+            const { hostname } = new URL(origin);
+            const isLocal = ['localhost', '127.0.0.1', '::1', '[::1]'].includes(hostname);
+            if (!isLocal)
+                return c.text('Forbidden', 403);
+        }
+        catch {
+            return c.text('Forbidden', 403);
+        }
+    }
+    // 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'}
+    return upgradeWebSocket((c) => {
+        let agent = null;
+        return {
+            onMessage(event, ws) {
+                if (typeof event.data === 'string') {
+                    if (event.data === 'ping') {
+                        ws.send(JSON.stringify({ type: 'pong' }));
+                        return;
+                    }
+                    try {
+                        const payload = JSON.parse(event.data);
+                        if (payload.type === 'ping') {
+                            ws.send(JSON.stringify({ type: 'pong' }));
+                        }
+                        else if (payload.type === 'start') {
+                            if (agent) {
+                                agent.stop();
+                            }
+                            const provider = ProviderRegistry.getProvider(payload.command);
+                            if (!provider) {
+                                ws.send(JSON.stringify({ type: 'error', message: `No provider found for ${payload.command}. Please create a dedicated adapter.` }));
+                                return;
+                            }
+                            let session;
+                            if (payload.sessionId !== undefined && payload.sessionId !== null) {
+                                if (!isValidSessionUuid(payload.sessionId)) {
+                                    ws.send(JSON.stringify({ type: 'error', message: 'Invalid session id.' }));
+                                    return;
+                                }
+                                session = { id: payload.sessionId, resume: Boolean(payload.resume) };
+                            }
+                            agent = provider.createInstance();
+                            agent.on('data', (text) => {
+                                ws.send(JSON.stringify({ type: 'stream', text }));
+                            });
+                            agent.on('system', (message) => {
+                                ws.send(JSON.stringify({ type: 'system', message }));
+                            });
+                            agent.on('idle', () => {
+                                ws.send(JSON.stringify({ type: 'status', state: 'idle' }));
+                            });
+                            agent.on('close', (code) => {
+                                ws.send(JSON.stringify({ type: 'close', code }));
+                            });
+                            agent.on('error', (error) => {
+                                ws.send(JSON.stringify({ type: 'error', message: error?.message ?? String(error) }));
+                                ws.send(JSON.stringify({ type: 'status', state: 'idle' }));
+                            });
+                            agent.start(payload.cwd, session);
+                        }
+                        else if (payload.type === 'input') {
+                            if (agent) {
+                                agent.send(payload.input);
+                                ws.send(JSON.stringify({ type: 'status', state: 'busy' }));
+                            }
+                        }
+                        else if (payload.type === 'stop') {
+                            if (agent) {
+                                agent.stop();
+                                agent = null;
+                            }
+                        }
+                    }
+                    catch (err) {
+                        console.error('[WS] Failed to parse message', err);
+                    }
+                }
+            },
+            onOpen(_event, _ws) {
+                console.log('[WS] Client connected');
+            },
+            onClose(_event, _ws) {
+                console.log('[WS] Client disconnected');
+                if (agent) {
+                    agent.stop();
+                    agent = null;
+                }
+            },
+        };
+    })(c, next);
+});
 // Allowed editor binaries/scripts to prevent command injection
 const ALLOWED_EDITORS = new Set(['code', 'code-insiders', 'cursor', 'antigravity', 'agy', 'idea', 'charm', 'webstorm', 'subl', 'nano', 'vim', 'nvim', 'emacs']);
 // ─── Path containment guards ──────────────────────────────────────────────
@@ -157,35 +263,10 @@ app.get('/api/adapters', async (c) => {
         return errorResponse(c, error);
     }
 });
-function isSafeLocalEndpoint(urlStr) {
-    try {
-        const url = new URL(urlStr);
-        const hostname = url.hostname.toLowerCase();
-        if (url.protocol === 'https:') {
-            return true;
-        }
-        if (hostname === 'localhost' || hostname === '127.0.0.1' || hostname === '[::1]') {
-            return true;
-        }
-        const ipv4Pattern = /^(?:10|127|192\.168|172\.(?:1[6-9]|2[0-9]|3[01]))\.\d+\.\d+\.\d+$/;
-        if (ipv4Pattern.test(hostname)) {
-            return true;
-        }
-        return false;
-    }
-    catch {
-        return false;
-    }
-}
 // 2. Save configuration
 app.post('/api/config', async (c) => {
     try {
         const newConfig = await c.req.json();
-        if (newConfig?.localLlm?.enabled && newConfig.localLlm.endpoint) {
-            if (!isSafeLocalEndpoint(newConfig.localLlm.endpoint)) {
-                return c.json({ error: 'Local AI endpoint must be HTTPS, localhost, 127.0.0.1, or a private LAN IP.' }, 400);
-            }
-        }
         await saveConfig(newConfig);
         return c.json({ success: true, config: newConfig });
     }
@@ -236,6 +317,72 @@ app.post('/api/repos/new', async (c) => {
         return errorResponse(c, error);
     }
 });
+// 3c. Project registry — named groups of source repos that features start from.
+app.get('/api/projects', async (c) => {
+    try {
+        return c.json(await loadProjects({ quiet: true }));
+    }
+    catch (error) {
+        return errorResponse(c, error);
+    }
+});
+app.post('/api/projects', async (c) => {
+    try {
+        const body = await c.req.json();
+        if (!body.name || typeof body.name !== 'string') {
+            return c.json({ error: 'Missing "name" in request body' }, 400);
+        }
+        if (!Array.isArray(body.repos) || body.repos.length === 0) {
+            return c.json({ error: 'Missing "repos" in request body' }, 400);
+        }
+        const config = await loadConfig();
+        // Only repos under devDir are offered by the scanner; refuse anything else.
+        const repos = body.repos.map((r) => assertWithin(config.devDir, r));
+        const project = await createProject(body.name, repos, body.description);
+        return c.json(project, 201);
+    }
+    catch (error) {
+        return errorResponse(c, error);
+    }
+});
+app.put('/api/projects/:id', async (c) => {
+    try {
+        const body = await c.req.json();
+        let repoPaths;
+        if (body.repos !== undefined) {
+            if (!Array.isArray(body.repos) || body.repos.length === 0) {
+                return c.json({ error: '"repos" must be a non-empty array' }, 400);
+            }
+            const config = await loadConfig();
+            repoPaths = body.repos.map((r) => assertWithin(config.devDir, r));
+        }
+        const project = await updateProject(c.req.param('id'), {
+            name: body.name,
+            description: body.description,
+            repoPaths,
+        });
+        return c.json(project);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith('No project')) {
+            return c.json({ error: error.message }, 404);
+        }
+        return errorResponse(c, error);
+    }
+});
+// Registry-only delete — never touches repos or workspaces on disk.
+app.delete('/api/projects/:id', async (c) => {
+    try {
+        const removed = await removeProject(c.req.param('id'));
+        if (!removed) {
+            return c.json({ error: `No project with id "${c.req.param('id')}"` }, 404);
+        }
+        return c.json({ success: true });
+    }
+    catch (error) {
+        return errorResponse(c, error);
+    }
+});
 // 4. List existing workspaces
 app.get('/api/workspaces', async (c) => {
     try {
@@ -291,9 +438,10 @@ app.get('/api/workspaces/status', async (c) => {
                 pendingValidation: false,
             };
             try {
-                // Uncommitted changes across the workspace's repo worktrees.
+                // Uncommitted changes across the workspace's repos: worktrees inside
+                // the workspace dir, or the source repos themselves for in-place.
                 for (const repoPath of ws.repos) {
-                    const worktreePath = path.join(workspacePath, path.basename(repoPath));
+                    const worktreePath = resolveFeatureRepoPath(ws, workspacePath, repoPath);
                     const repoStatus = await getRepoStatus(worktreePath);
                     if (repoStatus.hasChanges) {
                         status.dirtyRepos += 1;
@@ -303,7 +451,8 @@ app.get('/api/workspaces/status', async (c) => {
                 // Running services (cached running-state, PM2-verified — same source as
                 // the Services tab; only workspaces that ever started services touch PM2).
                 const runningState = await loadRunningState(workspacePath, pm2List);
-                status.runningServices = runningState?.services?.length ?? 0;
+                status.runningServices =
+                    (runningState?.services?.length ?? 0) + (runningState?.orchestrators?.length ?? 0);
                 // Sync state: worst-case classification + any repo pending validation.
                 const wsState = await loadWorkspaceState(workspacePath);
                 const repoStates = Object.values(wsState.repos);
@@ -346,63 +495,6 @@ app.get('/api/editor-detect', async (c) => {
         return errorResponse(c, error);
     }
 });
-// 6.5. Local LLM test & recommendation
-app.post('/api/local-llm/test', async (c) => {
-    try {
-        const { provider, endpoint, model, apiKey, shoot } = await c.req.json();
-        if (!endpoint || !isSafeLocalEndpoint(endpoint)) {
-            return c.json({ success: false, error: 'Local AI endpoint must be HTTPS, localhost, 127.0.0.1, or a private LAN IP.' }, 400);
-        }
-        const cleanEndpoint = endpoint.replace(/\/$/, '');
-        if (shoot) {
-            const responseText = await callLocalLlm({ enabled: true, provider, endpoint, model, apiKey }, [{ role: 'user', content: 'Respond with the exact word "OK" and nothing else.' }]);
-            const cleanResponse = responseText.trim();
-            return c.json({
-                success: true,
-                modelReady: true,
-                message: `Inference test succeeded! Response from model: "${cleanResponse}"`
-            });
-        }
-        if (provider === 'ollama') {
-            const res = await fetch(`${cleanEndpoint}/api/tags`);
-            if (!res.ok)
-                throw new Error(`Ollama responded with status ${res.status}`);
-            const data = await res.json();
-            const models = data?.models || [];
-            const isModelLoaded = isOllamaModelAvailable(models, model);
-            return c.json({
-                success: true,
-                modelReady: isModelLoaded,
-                message: isModelLoaded ? 'Connected successfully! Model is ready.' : `Connected successfully, but model "${model}" is not pulled. Run "ollama pull ${model}" to install it.`
-            });
-        }
-        else {
-            const testUrl = getOpenAiCompatibleUrl(cleanEndpoint, '/v1/models');
-            const res = await fetch(testUrl);
-            if (!res.ok)
-                throw new Error(`OpenAI-compatible server responded with status ${res.status}`);
-            return c.json({ success: true, modelReady: true, message: 'Connected successfully to OpenAI-compatible server!' });
-        }
-    }
-    catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        return c.json({ success: false, error: msg }, 400);
-    }
-});
-app.get('/api/local-llm/recommend', async (c) => {
-    try {
-        const specs = await scanSystemSpecs();
-        return c.json(specs);
-    }
-    catch (error) {
-        return c.json({
-            totalRamGb: 8,
-            gpuName: 'Unknown/Integrated',
-            hasHardwareAcceleration: false,
-            recommendedModel: 'qwen2.5-coder:1.5b',
-        });
-    }
-});
 const creationJobs = new Map();
 // Keep a finished job around briefly so a late SSE reconnect can still read its
 // final state, then drop it so the map doesn't grow unbounded.
@@ -459,7 +551,11 @@ function updateJobStep(jobId, stepId, status, message, extraData) {
 }
 async function runCreationJob(jobId, body, config) {
     try {
-        const workspacePath = resolveWorkspacePath(config.workspacesDir, body.branchName);
+        const inPlace = body.mode === 'in-place';
+        // Workspace id doubles as the directory name: the branch for worktree
+        // mode, the (slugified) workspace name for in-place mode.
+        const workspaceId = inPlace ? jobId : body.branchName;
+        const workspacePath = resolveWorkspacePath(config.workspacesDir, workspaceId);
         const job = creationJobs.get(jobId);
         if (job) {
             job.workspacePath = workspacePath;
@@ -472,32 +568,40 @@ async function runCreationJob(jobId, body, config) {
             }
         }
         const feature = {
-            id: body.branchName,
-            branchName: body.branchName,
+            id: workspaceId,
+            mode: inPlace ? 'in-place' : 'worktree',
+            projectId: body.projectId,
+            // In-place features never create a branch; keeping branchName populated
+            // (= id) avoids breaking every consumer of the non-optional field.
+            branchName: inPlace ? workspaceId : body.branchName,
             description: body.description,
-            repos: body.repos.map((r) => path.join(workspacePath, r.name)),
+            repos: inPlace
+                ? body.repos.map((r) => r.path)
+                : body.repos.map((r) => path.join(workspacePath, r.name)),
             originalRepos: body.repos.map((r) => r.path),
-            repoBranches: Object.keys(repoBranches).length > 0 ? repoBranches : undefined,
+            repoBranches: !inPlace && Object.keys(repoBranches).length > 0 ? repoBranches : undefined,
             assistants: body.assistants,
             workspacePath,
             createdAt: new Date().toISOString(),
             resumption: body.resumption,
-            localLlmEnabled: body.localLlmEnabled,
             teamworkInstructions: body.teamworkInstructions,
         };
         if (job) {
             job.feature = feature;
         }
-        // Step 1: Create worktrees
-        updateJobStep(jobId, 'worktrees', 'running', 'Creating git worktrees...');
+        // Step 1: Materialize the workspace (worktrees, or just the lightweight
+        // dir). One stable step id for both modes — only the wording differs.
+        updateJobStep(jobId, 'workspace', 'running', inPlace ? 'Registering workspace...' : 'Creating git worktrees...');
         await createWorkspace(feature, body.repos);
-        updateJobStep(jobId, 'worktrees', 'completed', 'Git worktrees created successfully.');
-        // Step 2: Analyze repos
+        updateJobStep(jobId, 'workspace', 'completed', inPlace ? 'Workspace registered — working in-place in the source repos.' : 'Git worktrees created successfully.');
+        // Step 2: Analyze repos — against the worktrees, or the source repos in-place.
         updateJobStep(jobId, 'analysis', 'running', 'Analyzing projects and dependencies...');
-        const workspaceRepos = body.repos.map((repo) => ({
-            ...repo,
-            path: path.join(workspacePath, repo.name),
-        }));
+        const workspaceRepos = inPlace
+            ? body.repos
+            : body.repos.map((repo) => ({
+                ...repo,
+                path: path.join(workspacePath, repo.name),
+            }));
         const analysis = await analyzeAllRepos(workspaceRepos);
         updateJobStep(jobId, 'analysis', 'completed', 'Project analysis complete.');
         // Step 3: Generate AI context files
@@ -506,7 +610,6 @@ async function runCreationJob(jobId, body, config) {
             feature,
             repos: workspaceRepos,
             analysis,
-            localLlm: config.localLlm,
         };
         await generateContextFiles(ctx, body.assistants, workspacePath);
         updateJobStep(jobId, 'context', 'completed', 'AI context files generated.');
@@ -517,7 +620,7 @@ async function runCreationJob(jobId, body, config) {
         const job = creationJobs.get(jobId);
         if (job) {
             const runningStep = job.steps.find((s) => s.status === 'running');
-            const failedStepId = runningStep ? runningStep.id : 'worktrees';
+            const failedStepId = runningStep ? runningStep.id : 'workspace';
             updateJobStep(jobId, failedStepId, 'failed', msg);
         }
     }
@@ -526,8 +629,19 @@ async function runCreationJob(jobId, body, config) {
 app.post('/api/workspace', async (c) => {
     try {
         const body = await c.req.json();
+        const inPlace = body.mode === 'in-place';
+        if (inPlace && !body.name?.trim()) {
+            return c.json({ error: 'In-place workspaces need a "name"' }, 400);
+        }
+        if (!inPlace && !body.branchName) {
+            return c.json({ error: 'Missing "branchName" in request body' }, 400);
+        }
         const config = await loadConfig();
-        const jobId = body.branchName;
+        // The job id doubles as the workspace directory name.
+        const jobId = inPlace ? slugifyProjectName(body.name) : body.branchName;
+        if (!jobId) {
+            return c.json({ error: `Workspace name "${body.name}" contains no usable characters` }, 400);
+        }
         if (creationJobs.has(jobId)) {
             const existing = creationJobs.get(jobId);
             if (existing.status === 'running') {
@@ -535,7 +649,9 @@ app.post('/api/workspace', async (c) => {
             }
         }
         const steps = [
-            { id: 'worktrees', name: 'Create Git Worktrees', status: 'pending', message: 'Waiting...' },
+            // Stable id 'workspace' in both modes so progress consumers never need
+            // to know the mode; only the display name differs.
+            { id: 'workspace', name: inPlace ? 'Register Workspace' : 'Create Git Worktrees', status: 'pending', message: 'Waiting...' },
             { id: 'analysis', name: 'Analyze Repositories', status: 'pending', message: 'Waiting...' },
             { id: 'context', name: 'Generate AI Context Files', status: 'pending', message: 'Waiting...' },
         ];
@@ -604,10 +720,27 @@ app.get('/api/workspace/create-stream/:jobId', async (c) => {
                 }
             };
             job.listeners.add(listener);
-            // Guard against the job finishing between the initial state write and now.
+            // Guard against the job finishing between the initial state write and
+            // now: the client only saw a 'running' frame, so send the terminal
+            // state before closing — silently ending the stream here would leave
+            // the client believing the connection dropped mid-run.
             if (job.status === 'completed' || job.status === 'failed') {
                 job.listeners.delete(listener);
-                resolve();
+                stream
+                    .writeSSE({
+                    event: 'progress',
+                    data: JSON.stringify({
+                        id: job.id,
+                        status: job.status,
+                        progress: job.progress,
+                        error: job.error,
+                        steps: job.steps,
+                        workspacePath: job.workspacePath,
+                        feature: job.feature,
+                    }),
+                })
+                    .catch(() => { })
+                    .finally(() => resolve());
             }
         });
     });
@@ -644,7 +777,7 @@ app.post('/api/workspace/suggest-workflow', async (c) => {
     try {
         const { description, repos } = await c.req.json();
         const config = await loadConfig();
-        const suggestion = await suggestWorkflow(description, repos, config.localLlm);
+        const suggestion = await suggestWorkflow(description, repos);
         return c.json({
             success: true,
             ...suggestion
@@ -705,20 +838,22 @@ app.get('/api/workspace/:id/services', async (c) => {
             services,
             orchestrationTools: tools,
             runningState: runningState?.services || [],
+            runningOrchestrators: runningState?.orchestrators || [],
         });
     }
     catch (error) {
         return errorResponse(c, error);
     }
 });
-// 10. Start services in workspace
+// 10. Start services in workspace. Configs are re-detected server-side —
+// the client only says "start", never what to execute.
 app.post('/api/workspace/:id/services/start', async (c) => {
     try {
         const id = c.req.param('id');
-        const { services } = await c.req.json();
         const config = await loadConfig();
         const workspacePath = resolveWorkspacePath(config.workspacesDir, id);
         const logDir = path.join(workspacePath, '.nexusflow-logs');
+        const services = await detectAllServices(workspacePath);
         await startServices(services, workspacePath, logDir);
         return c.json({ success: true });
     }
@@ -739,19 +874,53 @@ app.post('/api/workspace/:id/services/stop', async (c) => {
         return errorResponse(c, error);
     }
 });
-// 12. Get service logs
+// 11b. Per-service start / stop / restart. The service config is re-detected
+// by name server-side; the client never supplies a command.
+app.post('/api/workspace/:id/services/:serviceName/:action{start|stop|restart}', async (c) => {
+    try {
+        const id = c.req.param('id');
+        const serviceName = decodeURIComponent(c.req.param('serviceName'));
+        const action = c.req.param('action');
+        const config = await loadConfig();
+        const workspacePath = resolveWorkspacePath(config.workspacesDir, id);
+        const logDir = path.join(workspacePath, '.nexusflow-logs');
+        if (action === 'stop') {
+            const stopped = await stopService(workspacePath, serviceName);
+            return c.json({ success: true, stopped });
+        }
+        const services = await detectAllServices(workspacePath);
+        const service = services.find((s) => s.name === serviceName);
+        if (!service) {
+            return c.json({ error: `Unknown service "${serviceName}" in this workspace.` }, 404);
+        }
+        const running = action === 'restart'
+            ? await restartService(service, workspacePath, logDir)
+            : await startService(service, workspacePath, logDir);
+        return c.json({ success: running !== null, service: running });
+    }
+    catch (error) {
+        return errorResponse(c, error);
+    }
+});
+/** Resolve + contain a service log path; names may contain '/' (repo/sub). */
+function resolveServiceLogFile(workspacePath, serviceName) {
+    const logDir = path.join(workspacePath, '.nexusflow-logs');
+    return assertWithin(logDir, path.join(logDir, `${serviceName}.log`));
+}
+// 12. Get service logs (backfill). Returns the trailing 50KB and the byte
+// offset the read ended at, so the SSE stream can resume exactly there.
 app.get('/api/workspace/:id/services/logs/:serviceName', async (c) => {
     try {
         const id = c.req.param('id');
-        const serviceName = c.req.param('serviceName');
+        const serviceName = decodeURIComponent(c.req.param('serviceName'));
         const config = await loadConfig();
         const workspacePath = resolveWorkspacePath(config.workspacesDir, id);
-        const logFile = path.join(workspacePath, '.nexusflow-logs', `${serviceName}.log`);
+        const logFile = resolveServiceLogFile(workspacePath, serviceName);
         let content = '';
+        let size = 0;
         try {
-            // Read last 200 lines or 50KB
             const stats = await fs.stat(logFile);
-            const size = stats.size;
+            size = stats.size;
             const start = Math.max(0, size - 50000);
             const fd = await fs.open(logFile, 'r');
             const buffer = Buffer.alloc(size - start);
@@ -762,7 +931,82 @@ app.get('/api/workspace/:id/services/logs/:serviceName', async (c) => {
         catch {
             content = 'No logs available yet.';
         }
-        return c.json({ logs: content });
+        return c.json({ logs: content, size });
+    }
+    catch (error) {
+        return errorResponse(c, error);
+    }
+});
+// 12b. Live log stream (SSE): tails the log file from ?offset onward,
+// emitting 'log' events with JSON-encoded chunks (raw SSE frames would mangle
+// embedded newlines). A 15s ping keeps idle streams alive.
+app.get('/api/workspace/:id/services/logs/:serviceName/stream', async (c) => {
+    // Resolve + validate the log path BEFORE opening the stream so a bad name
+    // (e.g. a traversal attempt) returns a clean error, mirroring the backfill
+    // route, rather than a raw 500 from an uncaught throw.
+    let logFile;
+    let startOffset;
+    try {
+        const id = c.req.param('id');
+        const serviceName = decodeURIComponent(c.req.param('serviceName'));
+        const config = await loadConfig();
+        const workspacePath = resolveWorkspacePath(config.workspacesDir, id);
+        logFile = resolveServiceLogFile(workspacePath, serviceName);
+        const offsetParam = Number.parseInt(c.req.query('offset') ?? '', 10);
+        startOffset = Number.isFinite(offsetParam) && offsetParam >= 0 ? offsetParam : undefined;
+    }
+    catch (error) {
+        return errorResponse(c, error);
+    }
+    c.header('Content-Type', 'text/event-stream');
+    c.header('Cache-Control', 'no-cache');
+    c.header('Connection', 'keep-alive');
+    return streamSSE(c, async (stream) => {
+        await stream.writeSSE({ event: 'init', data: JSON.stringify({ offset: startOffset ?? null }) });
+        await new Promise((resolve) => {
+            let done = false;
+            const cleanup = () => {
+                if (done)
+                    return;
+                done = true;
+                tail.stop();
+                clearInterval(heartbeat);
+                resolve();
+            };
+            const tail = tailLogFile(logFile, (chunk) => {
+                stream.writeSSE({ event: 'log', data: JSON.stringify({ chunk }) }).catch(cleanup);
+            }, { startOffset });
+            const heartbeat = setInterval(() => {
+                stream.writeSSE({ event: 'ping', data: '{}' }).catch(cleanup);
+            }, 15_000);
+            stream.onAbort(cleanup);
+        });
+    });
+});
+// 12c. Orchestration tools: start/stop by detection id only — the tool is
+// re-detected server-side and the client can never supply a command.
+app.post('/api/workspace/:id/orchestrators/:action{start|stop}', async (c) => {
+    try {
+        const id = c.req.param('id');
+        const action = c.req.param('action');
+        const body = await c.req.json();
+        if (!body.id || typeof body.id !== 'string') {
+            return c.json({ error: 'Missing orchestrator "id" in request body' }, 400);
+        }
+        const config = await loadConfig();
+        const workspacePath = resolveWorkspacePath(config.workspacesDir, id);
+        const logDir = path.join(workspacePath, '.nexusflow-logs');
+        const tools = await detectOrchestrationTools(workspacePath);
+        const detection = tools.find((t) => t.id === body.id);
+        if (!detection) {
+            return c.json({ error: `Unknown orchestration tool "${body.id}" in this workspace.` }, 404);
+        }
+        if (action === 'start') {
+            const running = await startOrchestrator(detection, workspacePath, logDir);
+            return c.json({ success: true, orchestrator: running });
+        }
+        await stopOrchestrator(detection, workspacePath);
+        return c.json({ success: true });
     }
     catch (error) {
         return errorResponse(c, error);
@@ -780,10 +1024,10 @@ app.get('/api/workspace/:id/changes', async (c) => {
             return c.json({ error: 'Workspace configuration not found.' }, 404);
         }
         const results = [];
-        // Check git status in each repo
+        // Check git status in each repo (worktree, or source repo for in-place)
         for (const repoPath of feature.repos) {
             const repoName = path.basename(repoPath);
-            const worktreePath = path.join(workspacePath, repoName);
+            const worktreePath = resolveFeatureRepoPath(feature, workspacePath, repoPath);
             try {
                 const { stdout } = await execa('git', ['status', '--porcelain'], { cwd: worktreePath });
                 const lines = stdout.split('\n').map((l) => l.trim()).filter(Boolean);
@@ -857,8 +1101,25 @@ app.get('/api/workspace/:id/changes/diff', async (c) => {
         }
         const config = await loadConfig();
         const workspacePath = resolveWorkspacePath(config.workspacesDir, id);
-        // Contained within the workspace; rejects `..` and sibling-prefix escapes.
-        const worktreePath = resolveRepoPath(workspacePath, repoName);
+        // Resolve by mode, manifest first: an in-place repo name may only resolve
+        // to an exact manifest entry (its repos live outside the workspace), and
+        // must never be shadowed by a stray same-named subdirectory inside the
+        // workspace dir. Worktree mode keeps the path-containment guard.
+        const feature = await loadFeatureConfig(workspacePath);
+        let worktreePath;
+        if (feature && isInPlace(feature)) {
+            const matches = feature.repos.filter((r) => path.basename(r) === repoName);
+            if (matches.length === 0) {
+                return c.json({ error: `Unknown repo "${repoName}" in this workspace.` }, 404);
+            }
+            if (matches.length > 1) {
+                return c.json({ error: `Repo name "${repoName}" is ambiguous in this workspace.` }, 400);
+            }
+            worktreePath = matches[0];
+        }
+        else {
+            worktreePath = resolveRepoPath(workspacePath, repoName);
+        }
         let diff = '';
         // Check git status for the file to know if it's untracked
         try {
@@ -1090,7 +1351,9 @@ app.post('/api/workspace/:id/resume', async (c) => {
                 console.error(`Failed to launch editor ${body.command} for path ${workspacePath}:`, err);
             });
         }
-        return c.json({ success: true, resumeCommand, workspacePath });
+        // Where the resume command should be run: the workspace dir, or the repo
+        // root for single-repo in-place features.
+        return c.json({ success: true, resumeCommand, workspacePath, sessionCwd: getSessionCwd(feature) });
     }
     catch (error) {
         return errorResponse(c, error);
@@ -1115,9 +1378,9 @@ app.get('/api/workspace/:id/sessions', async (c) => {
 });
 // 16. Fetch transcript for a specific AI session
 app.get('/api/session/:assistant/:sessionId/transcript', async (c) => {
+    const assistant = c.req.param('assistant');
+    const sessionId = c.req.param('sessionId');
     try {
-        const assistant = c.req.param('assistant');
-        const sessionId = c.req.param('sessionId');
         const messages = await getSessionTranscript(assistant, sessionId);
         return c.json({ messages });
     }
@@ -1219,9 +1482,14 @@ app.post('/api/updates/apply', async (c) => {
     try {
         const isWin = process.platform === 'win32';
         if (isWin) {
-            // Inno Setup silent install flags
+            // The desktop app ships an electron-builder NSIS installer (build target
+            // 'nsis'), whose silent-install switch is `/S` — NOT Inno Setup's
+            // /VERYSILENT. With the wrong flags the one-click installer waits for UI
+            // that a detached (stdio: 'ignore') process can never provide, so the
+            // update silently fails to apply. `/S` runs it unattended and relaunches
+            // the app on finish (electron-builder default).
             console.log(`Applying update: Spawning detached installer at: ${downloadedInstallerPath}`);
-            const child = spawn(downloadedInstallerPath, ['/VERYSILENT', '/SUPPRESSMSGBOXES', '/NORESTART'], {
+            const child = spawn(downloadedInstallerPath, ['/S'], {
                 detached: true,
                 stdio: 'ignore',
             });
@@ -1452,6 +1720,7 @@ export function startServer(port = 3000, opts = {}) {
             startScheduler({ log: (message) => console.log(`[scheduler] ${message}`) });
             resolve({ port: info.port, server });
         });
+        injectWebSocket(server);
         server.on('error', (e) => {
             if (e.code === 'EADDRINUSE') {
                 // Callers that own their backend (desktop/extension) pass strictPort so