ac-framework 1.9.6 → 1.9.8

package/src/mcp/collab-server.js

@@ -7,6 +7,11 @@
 
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { z } from 'zod';
 import { COLLAB_ROLES } from '../agents/constants.js';
 import { buildEffectiveRoleModels, sanitizeRoleModels } from '../agents/model-selection.js';
@@ -25,6 +30,43 @@ import {
 } from '../agents/state-store.js';
 import { hasCommand, resolveCommandPath } from '../services/dependency-installer.js';
 
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const runnerPath = resolve(__dirname, '../../bin/acfm.js');
+
+function summarizeRun(state) {
+  const run = state.run || null;
+  return {
+    status: run?.status || 'idle',
+    runId: run?.runId || null,
+    currentRole: run?.currentRole || state.activeAgent || null,
+    round: run?.round || state.round,
+    policy: run?.policy || null,
+    lastError: run?.lastError || null,
+    eventCount: Array.isArray(run?.events) ? run.events.length : 0,
+  };
+}
+
+function latestRunEvent(state) {
+  const events = state?.run?.events;
+  if (!Array.isArray(events) || events.length === 0) return null;
+  return events[events.length - 1];
+}
+
+async function readSessionArtifact(sessionId, filename) {
+  const path = resolve(getSessionDir(sessionId), filename);
+  if (!existsSync(path)) return null;
+  return readFile(path, 'utf8');
+}
+
+function launchAutopilot(sessionId) {
+  const child = spawn('node', [runnerPath, 'agents', 'autopilot', '--session', sessionId], {
+    cwd: process.cwd(),
+    detached: true,
+    stdio: 'ignore',
+  });
+  child.unref();
+}
+
 class MCPCollabServer {
   constructor() {
     this.server = new McpServer({
@@ -51,8 +93,13 @@ class MCPCollabServer {
         }).partial().optional().describe('Optional per-role models (provider/model)'),
         cwd: z.string().optional().describe('Working directory for agents'),
         spawnWorkers: z.boolean().default(true).describe('Create tmux workers and panes'),
+        runPolicy: z.object({
+          timeoutPerRoleMs: z.number().int().positive().optional(),
+          retryOnTimeout: z.number().int().min(0).optional(),
+          fallbackOnFailure: z.enum(['retry', 'skip', 'abort']).optional(),
+        }).partial().optional().describe('Optional run execution policy'),
       },
-      async ({ task, maxRounds, model, roleModels, cwd, spawnWorkers }) => {
+      async ({ task, maxRounds, model, roleModels, cwd, spawnWorkers, runPolicy }) => {
         try {
           const workingDirectory = cwd || process.cwd();
           const opencodeBin = resolveCommandPath('opencode');
@@ -71,6 +118,7 @@ class MCPCollabServer {
             roleModels: sanitizeRoleModels(roleModels),
             workingDirectory,
             opencodeBin,
+            runPolicy,
           });
           let updated = state;
           if (spawnWorkers) {
@@ -93,6 +141,7 @@ class MCPCollabServer {
                 model: updated.model || null,
                 roleModels: updated.roleModels || {},
                 effectiveRoleModels: buildEffectiveRoleModels(updated, updated.model || null),
+                run: summarizeRun(updated),
                 tmuxSessionName,
                 attachCommand,
               }, null, 2),
@@ -104,6 +153,186 @@ class MCPCollabServer {
       }
     );
 
+    this.server.tool(
+      'collab_invoke_team',
+      'Invoke full 4-agent collaborative run and return async run handle',
+      {
+        sessionId: z.string().optional().describe('Session ID (defaults to current session)'),
+        waitMs: z.number().int().min(0).max(30000).default(0).describe('Optional wait for progress before returning'),
+      },
+      async ({ sessionId, waitMs }) => {
+        try {
+          const id = sessionId || await loadCurrentSessionId();
+          if (!id) throw new Error('No active session found');
+          let state = await loadSessionState(id);
+          if (state.status !== 'running') {
+            throw new Error(`Session is ${state.status}. Resume/start before invoking.`);
+          }
+
+          if (!state.tmuxSessionName) {
+            launchAutopilot(state.sessionId);
+          }
+
+          if (waitMs > 0) {
+            const started = Date.now();
+            const initialEvents = state.run?.events?.length || 0;
+            while (Date.now() - started < waitMs) {
+              await new Promise((r) => setTimeout(r, 250));
+              state = await loadSessionState(id);
+              const currentEvents = state.run?.events?.length || 0;
+              if (state.status !== 'running' || currentEvents > initialEvents) break;
+            }
+          }
+
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                success: true,
+                sessionId: state.sessionId,
+                status: state.status,
+                run: summarizeRun(state),
+                latestEvent: latestRunEvent(state),
+                tmuxSessionName: state.tmuxSessionName || null,
+                attachCommand: state.tmuxSessionName ? `tmux attach -t ${state.tmuxSessionName}` : null,
+              }, null, 2),
+            }],
+          };
+        } catch (error) {
+          return { content: [{ type: 'text', text: JSON.stringify({ error: error.message }) }], isError: true };
+        }
+      }
+    );
+
+    this.server.tool(
+      'collab_wait_run',
+      'Wait for collaborative run to complete/fail or timeout',
+      {
+        sessionId: z.string().optional().describe('Session ID (defaults to current session)'),
+        waitMs: z.number().int().positive().max(60000).default(10000).describe('Max wait in milliseconds'),
+      },
+      async ({ sessionId, waitMs }) => {
+        try {
+          const id = sessionId || await loadCurrentSessionId();
+          if (!id) throw new Error('No active session found');
+          const started = Date.now();
+          let state = await loadSessionState(id);
+
+          while (Date.now() - started < waitMs) {
+            const runStatus = state.run?.status || 'idle';
+            if (state.status !== 'running' || ['completed', 'failed', 'cancelled'].includes(runStatus)) break;
+            await new Promise((r) => setTimeout(r, 300));
+            state = await loadSessionState(id);
+          }
+
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                success: true,
+                sessionId: state.sessionId,
+                status: state.status,
+                run: summarizeRun(state),
+                latestEvent: latestRunEvent(state),
+                timedOut: state.status === 'running' && !['completed', 'failed', 'cancelled'].includes(state.run?.status || 'idle'),
+              }, null, 2),
+            }],
+          };
+        } catch (error) {
+          return { content: [{ type: 'text', text: JSON.stringify({ error: error.message }) }], isError: true };
+        }
+      }
+    );
+
+    this.server.tool(
+      'collab_get_result',
+      'Get final consolidated team output and run diagnostics',
+      {
+        sessionId: z.string().optional().describe('Session ID (defaults to current session)'),
+      },
+      async ({ sessionId }) => {
+        try {
+          const id = sessionId || await loadCurrentSessionId();
+          if (!id) throw new Error('No active session found');
+          const state = await loadSessionState(id);
+          const transcript = await loadTranscript(id);
+          const run = summarizeRun(state);
+
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                success: true,
+                sessionId: state.sessionId,
+                status: state.status,
+                run,
+                latestEvent: latestRunEvent(state),
+                finalSummary: state.run?.finalSummary || null,
+                sharedContext: state.run?.sharedContext || null,
+                meetingSummary: await readSessionArtifact(id, 'meeting-summary.md'),
+                meetingLog: await readSessionArtifact(id, 'meeting-log.md'),
+                lastMessage: state.messages?.[state.messages.length - 1] || null,
+                transcriptCount: transcript.length,
+              }, null, 2),
+            }],
+          };
+        } catch (error) {
+          return { content: [{ type: 'text', text: JSON.stringify({ error: error.message }) }], isError: true };
+        }
+      }
+    );
+
+    this.server.tool(
+      'collab_cancel_run',
+      'Cancel active collaborative run while keeping session state',
+      {
+        sessionId: z.string().optional().describe('Session ID (defaults to current session)'),
+      },
+      async ({ sessionId }) => {
+        try {
+          const id = sessionId || await loadCurrentSessionId();
+          if (!id) throw new Error('No active session found');
+          const state = await loadSessionState(id);
+          const run = state.run || {};
+          const updated = await saveSessionState({
+            ...state,
+            status: 'running',
+            activeAgent: null,
+            run: {
+              ...run,
+              status: 'cancelled',
+              currentRole: null,
+              finishedAt: new Date().toISOString(),
+              lastError: {
+                code: 'RUN_CANCELLED',
+                message: 'Cancelled by MCP caller',
+              },
+              events: [
+                ...(Array.isArray(run.events) ? run.events : []),
+                {
+                  id: `evt-${Date.now()}`,
+                  type: 'run_cancelled',
+                  timestamp: new Date().toISOString(),
+                },
+              ],
+            },
+          });
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                success: true,
+                sessionId: updated.sessionId,
+                run: summarizeRun(updated),
+              }, null, 2),
+            }],
+          };
+        } catch (error) {
+          return { content: [{ type: 'text', text: JSON.stringify({ error: error.message }) }], isError: true };
+        }
+      }
+    );
+
     this.server.tool(
       'collab_send_message',
       'Send a user message to the active collaborative session',
@@ -150,6 +379,7 @@ class MCPCollabServer {
           const state = await runWorkerIteration(id, role, {
             cwd: process.cwd(),
             opencodeBin: loaded.opencodeBin || resolveCommandPath('opencode') || undefined,
+            timeoutMs: loaded.run?.policy?.timeoutPerRoleMs || 180000,
           });
 
           return {
@@ -164,6 +394,8 @@ class MCPCollabServer {
                 model: state.model || null,
                 roleModels: state.roleModels || {},
                 effectiveRoleModels: buildEffectiveRoleModels(state, state.model || null),
+                run: summarizeRun(state),
+                latestEvent: latestRunEvent(state),
                 messageCount: state.messages.length,
               }, null, 2),
             }],
@@ -244,6 +476,9 @@ class MCPCollabServer {
               text: JSON.stringify({
                 state,
                 effectiveRoleModels: buildEffectiveRoleModels(state, state.model || null),
+                run: summarizeRun(state),
+                latestEvent: latestRunEvent(state),
+                sharedContext: state.run?.sharedContext || null,
                 transcript,
               }, null, 2),
             }],
@@ -254,6 +489,71 @@ class MCPCollabServer {
       }
     );
 
+    this.server.tool(
+      'collab_get_transcript',
+      'Get transcript messages with optional role filtering',
+      {
+        sessionId: z.string().optional().describe('Session ID (defaults to current session)'),
+        role: z.enum(['planner', 'critic', 'coder', 'reviewer', 'all']).default('all').describe('Role filter'),
+        limit: z.number().int().positive().max(500).default(100).describe('Max messages to return'),
+      },
+      async ({ sessionId, role, limit }) => {
+        try {
+          const id = sessionId || await loadCurrentSessionId();
+          if (!id) throw new Error('No active session found');
+          const transcript = await loadTranscript(id);
+          const filtered = transcript
+            .filter((msg) => role === 'all' || msg.from === role)
+            .slice(-limit);
+
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                sessionId: id,
+                role,
+                count: filtered.length,
+                transcript: filtered,
+              }, null, 2),
+            }],
+          };
+        } catch (error) {
+          return { content: [{ type: 'text', text: JSON.stringify({ error: error.message }) }], isError: true };
+        }
+      }
+    );
+
+    this.server.tool(
+      'collab_get_meeting_log',
+      'Get generated meeting log and summary artifacts',
+      {
+        sessionId: z.string().optional().describe('Session ID (defaults to current session)'),
+      },
+      async ({ sessionId }) => {
+        try {
+          const id = sessionId || await loadCurrentSessionId();
+          if (!id) throw new Error('No active session found');
+          const state = await loadSessionState(id);
+
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({
+                sessionId: id,
+                status: state.status,
+                finalSummary: state.run?.finalSummary || null,
+                sharedContext: state.run?.sharedContext || null,
+                meetingSummary: await readSessionArtifact(id, 'meeting-summary.md'),
+                meetingLog: await readSessionArtifact(id, 'meeting-log.md'),
+              }, null, 2),
+            }],
+          };
+        } catch (error) {
+          return { content: [{ type: 'text', text: JSON.stringify({ error: error.message }) }], isError: true };
+        }
+      }
+    );
+
     this.server.tool(
       'collab_stop_session',
       'Stop current collaborative session',
@@ -271,7 +571,12 @@ class MCPCollabServer {
           return {
             content: [{
               type: 'text',
-              text: JSON.stringify({ success: true, sessionId: id, status: updated.status }, null, 2),
+              text: JSON.stringify({
+                success: true,
+                sessionId: id,
+                status: updated.status,
+                run: summarizeRun(updated),
+              }, null, 2),
             }],
           };
         } catch (error) {