@litmers/cursorflow-orchestrator 0.1.39 → 0.2.2

package/src/core/orchestrator.ts

@@ -21,6 +21,7 @@ import { loadConfig, getLogsDir } from '../utils/config';
 import * as git from '../utils/git';
 import { execSync } from 'child_process';
 import { safeJoin } from '../utils/path';
+import { getLaneLogPath } from '../services/logging/paths';
 import { 
   EnhancedLogManager, 
   createLogManager, 
@@ -28,6 +29,7 @@ import {
   ParsedMessage,
   stripAnsi
 } from '../utils/enhanced-logger';
+import { MAIN_LOG_FILENAME } from '../utils/log-constants';
 import { formatMessageForConsole } from '../utils/log-formatter';
 import { FailureType, analyzeFailure as analyzeFailureFromPolicy } from './failure-policy';
 import { 
@@ -169,6 +171,7 @@ async function handleDoctorDiagnostics(
       // Note: StallPhase and RecoveryStage have compatible numeric values (0-5)
       const recoveryState: LaneRecoveryState = {
         laneName,
+        runId,
         stage: stallState.phase as unknown as number,  // Both enums use 0-5
         lastActivityTime: stallState.lastRealActivityTime,
         lastBytesReceived: stallState.bytesSinceLastCheck,
@@ -226,8 +229,10 @@ export function spawnLane({
   worktreeDir,
   enhancedLogConfig,
   noGit = false,
+  skipPreflight = false,
   onActivity,
   laneIndex = 0,
+  browser,
 }: { 
   laneName: string; 
   tasksFile: string; 
@@ -238,8 +243,10 @@ export function spawnLane({
   worktreeDir?: string;
   enhancedLogConfig?: Partial<EnhancedLogConfig>;
   noGit?: boolean;
+  skipPreflight?: boolean;
   onActivity?: () => void;
   laneIndex?: number;
+  browser?: boolean;
 }): SpawnLaneResult {
   fs.mkdirSync(laneRunDir, { recursive: true});
   
@@ -265,6 +272,14 @@ export function spawnLane({
   if (noGit) {
     args.push('--no-git');
   }
+
+  if (skipPreflight) {
+    args.push('--skip-preflight');
+  }
+
+  if (browser) {
+    args.push('--browser');
+  }
   
   // Create enhanced log manager if enabled
   const logConfig = { ...DEFAULT_LOG_CONFIG, ...enhancedLogConfig };
@@ -278,11 +293,11 @@ export function spawnLane({
   };
   
   if (logConfig.enabled) {
-    // Helper to get dynamic lane label like [L1-T1-lanename10]
+    // Helper to get dynamic lane label like [1-1-refactor]
     const getDynamicLabel = () => {
-      const laneNum = `L${laneIndex + 1}`;
-      const taskPart = info.currentTaskIndex ? `-T${info.currentTaskIndex}` : '';
-      const shortLaneName = laneName.substring(0, 10);
+      const laneNum = `${laneIndex + 1}`;
+      const taskPart = `-${info.currentTaskIndex || 1}`;
+      const shortLaneName = laneName.substring(0, 8);
       return `[${laneNum}${taskPart}-${shortLaneName}]`;
     };
 
@@ -316,15 +331,17 @@ export function spawnLane({
       currentTaskIndex: startIndex > 0 ? startIndex + 1 : 0
     };
 
-    // Buffer for non-JSON lines
+    // Buffer for task progress detection
     let lineBuffer = '';
 
     // Pipe stdout and stderr through enhanced logger
+    // Note: Console output is handled by onParsedMessage callback via logManager
+    // Do NOT write to stdout/stderr directly here to avoid duplicate output
     if (child.stdout) {
       child.stdout.on('data', (data: Buffer) => {
         logManager!.writeStdout(data);
         
-        // Filter out JSON lines from console output to keep it clean
+        // Track task progress for label updates (but don't output here)
         const str = data.toString();
         lineBuffer += str;
         const lines = lineBuffer.split('\n');
@@ -346,39 +363,12 @@ export function spawnLane({
             }
           }
 
-          // Show if it's a timestamped log line (starts with [YYYY-MM-DD... or [HH:MM:SS])
-          // or if it's NOT a noisy JSON line
+          // Track activity for stall detection (non-heartbeat lines only)
           const isJson = trimmed.startsWith('{') || trimmed.includes('{"type"');
-          // Filter out heartbeats - they should NOT reset the idle timer
           const isHeartbeat = trimmed.includes('Heartbeat') && trimmed.includes('bytes received');
           
-          if (!isJson) {
-            // Only trigger activity for non-heartbeat lines
-            if (onActivity && !isHeartbeat) onActivity();
-
-            const currentLabel = getDynamicLabel();
-            const coloredLabel = `${logger.COLORS.magenta}${currentLabel}${logger.COLORS.reset}`;
-            
-            // Regex that matches timestamp even if it has ANSI color codes
-            // Matches: [24:39:14] or \x1b[90m[24:39:14]\x1b[0m
-            const timestampRegex = /^((?:\x1b\[[0-9;]*m)*)\[(\d{4}-\d{2}-\d{2}T|\d{2}:\d{2}:\d{2})\]/;
-            const tsMatch = trimmed.match(timestampRegex);
-
-            if (tsMatch) {
-              // If line already has timestamp format, just add lane prefix
-              // Check if lane label is already present to avoid triple duplication
-              if (!trimmed.includes(currentLabel)) {
-                // Insert label after the timestamp part
-                const tsPart = tsMatch[0];
-                const formatted = trimmed.replace(tsPart, `${tsPart} ${coloredLabel}`);
-                process.stdout.write(formatted + '\n');
-              } else {
-                process.stdout.write(trimmed + '\n');
-              }
-            } else {
-              // Add full prefix: timestamp + lane
-              process.stdout.write(`${logger.COLORS.gray}[${new Date().toLocaleTimeString('en-US', { hour12: false })}]${logger.COLORS.reset} ${coloredLabel} ${line}\n`);
-            }
+          if (!isJson && !isHeartbeat && onActivity) {
+            onActivity();
           }
         }
       });
@@ -386,30 +376,8 @@ export function spawnLane({
     
     if (child.stderr) {
       child.stderr.on('data', (data: Buffer) => {
+        // Console output is handled by logManager's onParsedMessage callback
         logManager!.writeStderr(data);
-        const str = data.toString();
-        const lines = str.split('\n');
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (trimmed) {
-            // Check if it's a real error or just git/status output on stderr
-            const isStatus = trimmed.startsWith('Preparing worktree') || 
-                             trimmed.startsWith('Switched to a new branch') ||
-                             trimmed.startsWith('HEAD is now at') ||
-                             trimmed.includes('actual output');
-            
-            const ts = new Date().toLocaleTimeString('en-US', { hour12: false });
-            const currentLabel = getDynamicLabel();
-            const coloredLabel = `${logger.COLORS.magenta}${currentLabel}${logger.COLORS.reset}`;
-
-            if (isStatus) {
-              process.stdout.write(`${logger.COLORS.gray}[${ts}]${logger.COLORS.reset} ${coloredLabel} ${trimmed}\n`);
-            } else {
-              if (onActivity) onActivity();
-              process.stderr.write(`${logger.COLORS.gray}[${ts}]${logger.COLORS.reset} ${coloredLabel} ${logger.COLORS.red}❌ ERR ${trimmed}${logger.COLORS.reset}\n`);
-            }
-          }
-        }
       });
     }
     
@@ -421,7 +389,7 @@ export function spawnLane({
     return { child, logPath, logManager, info };
   } else {
     // Fallback to simple file logging
-    logPath = safeJoin(laneRunDir, 'terminal-readable.log');
+    logPath = getLaneLogPath(laneRunDir, 'raw');
     const logFd = fs.openSync(logPath, 'a');
     
     child = spawn('node', args, {
@@ -634,6 +602,7 @@ export async function orchestrate(tasksDir: string, options: {
   noGit?: boolean;
   skipPreflight?: boolean;
   stallConfig?: Partial<StallDetectionConfig>;
+  browser?: boolean;
 } = {}): Promise<{ lanes: LaneInfo[]; exitCodes: Record<string, number>; runRoot: string }> {
   const lanes = listLaneFiles(tasksDir);
   
@@ -682,6 +651,9 @@ export async function orchestrate(tasksDir: string, options: {
     : safeJoin(logsDir, 'runs', runId);
   
   fs.mkdirSync(runRoot, { recursive: true });
+  // Main process logs live at the run root; lane/subprocess logs stay in per-lane directories.
+  logger.setDefaultContext('MAIN');
+  logger.setLogFile(safeJoin(runRoot, MAIN_LOG_FILENAME));
   
   // Clean stale locks before starting
   try {
@@ -838,8 +810,10 @@ export async function orchestrate(tasksDir: string, options: {
       const now = Date.now();
       
       // Register lane with unified stall detection service FIRST
+      // Pass intervention capability so stall service knows if continue signals will work
       stallService.registerLane(lane.name, {
         laneRunDir: laneRunDirs[lane.name]!,
+        interventionEnabled: config.enableIntervention ?? true,
       });
       
       const laneIdx = lanes.findIndex(l => l.name === lane.name);
@@ -863,7 +837,9 @@ export async function orchestrate(tasksDir: string, options: {
         worktreeDir: laneWorktreeDirs[lane.name],
         enhancedLogConfig: options.enhancedLogging,
         noGit: options.noGit,
+        skipPreflight: options.skipPreflight,
         laneIndex: laneIdx >= 0 ? laneIdx : 0,
+        browser: options.browser,
         onActivity: () => {
           // Record state file update activity
           stallService.recordStateUpdate(lane.name);
@@ -931,13 +907,19 @@ export async function orchestrate(tasksDir: string, options: {
         for (const [laneName, info] of running.entries()) {
           const lane = lanes.find(l => l.name === laneName)!;
           
-          // Check state file for progress updates
+          // Check state file for progress updates and sync lane status
           try {
             const stateStat = fs.statSync(info.statePath);
             const stallState = stallService.getState(laneName);
             if (stallState && stateStat.mtimeMs > stallState.lastStateUpdateTime) {
               stallService.recordStateUpdate(laneName);
             }
+            
+            // Sync lane status to stall service (skips stall detection when 'waiting' for dependencies)
+            const laneState = loadState<LaneState>(info.statePath);
+            if (laneState && stallState && laneState.status !== stallState.laneStatus) {
+              stallService.setLaneStatus(laneName, laneState.status || 'running');
+            }
           } catch {
             // State file might not exist yet
           }
@@ -948,7 +930,8 @@ export async function orchestrate(tasksDir: string, options: {
           }
           
           // Run stall analysis and recovery (all logic is in StallDetectionService)
-          const analysis = stallService.checkAndRecover(laneName);
+          // Note: checkAndRecover is now async as it may kill processes
+          const analysis = await stallService.checkAndRecover(laneName);
           
           // Log to lane log manager if there was an action
           if (analysis.action !== RecoveryAction.NONE) {

package/src/core/runner/agent.ts

@@ -131,7 +131,7 @@ function parseJsonFromStdout(stdout: string): any {
 /**
  * Execute cursor-agent command with timeout and better error handling
  */
-async function cursorAgentSendRaw({ workspaceDir, chatId, prompt, model, signalDir, timeout, enableIntervention, outputFormat, taskName }: { 
+async function cursorAgentSendRaw({ workspaceDir, chatId, prompt, model, signalDir, timeout, enableIntervention, outputFormat, taskName, browser, autoApproveCommands, autoApproveMcps }: { 
   workspaceDir: string; 
   chatId: string; 
   prompt: string; 
@@ -139,50 +139,79 @@ async function cursorAgentSendRaw({ workspaceDir, chatId, prompt, model, signalD
   signalDir?: string;
   timeout?: number;
   enableIntervention?: boolean;
-  outputFormat?: 'json' | 'plain' | 'stream-json';
+  outputFormat?: 'json' | 'stream-json';
   taskName?: string;
+  /** Enable browser automation (--browser flag) */
+  browser?: boolean;
+  /** Auto-approve commands (--force flag). Default: true */
+  autoApproveCommands?: boolean;
+  /** Auto-approve MCP servers (--approve-mcps flag). Default: true */
+  autoApproveMcps?: boolean;
 }): Promise<AgentSendResult> {
   const timeoutMs = timeout || 10 * 60 * 1000; // 10 minutes default
-  const args = ['send', chatId, prompt];
+  
+  // Build args: cursor-agent [options] [prompt]
+  // Note: 'send' command no longer exists in cursor-agent CLI
+  // Use --resume <chatId> to continue an existing chat session
+  const args: string[] = [];
+  
+  // Resume existing chat session
+  args.push('--resume', chatId);
   
   if (model) {
     args.push('--model', model);
   }
   
   if (outputFormat === 'json' || outputFormat === 'stream-json') {
-    args.push('--print', '--output-format', 'json');
+    args.push('--print', '--output-format', outputFormat);
+  }
+
+  // Auto-approve commands if enabled (default: true for automation)
+  if (autoApproveCommands !== false) {
+    args.push('--force');
+  }
+  
+  // Auto-approve MCP servers if enabled (default: true for automation)
+  if (autoApproveMcps !== false) {
+    args.push('--approve-mcps');
   }
 
-  // Ensure non-interactive execution with automatic approvals
-  args.push('--force', '--approve-mcps');
+  // Enable browser automation if requested (required for web testing/scraping)
+  if (browser) {
+    args.push('--browser');
+  }
 
   // Add worktree context if provided
   if (workspaceDir) {
     args.push('--workspace', workspaceDir);
   }
+  
+  // NOTE: In latest cursor-agent, prompt must be sent via stdin, not as positional argument
 
   return new Promise((resolve) => {
     logger.info(`Sending prompt to cursor-agent (timeout: ${Math.round(timeoutMs / 1000)}s)...`);
     
+    // stdin must always be 'pipe' to send prompt via stdin (required by latest cursor-agent)
     const child = spawn('cursor-agent', args, {
       cwd: workspaceDir || process.cwd(),
-      stdio: enableIntervention ? ['pipe', 'pipe', 'pipe'] : ['ignore', 'pipe', 'pipe'],
+      stdio: ['pipe', 'pipe', 'pipe'],
     });
 
     activeChildren.add(child);
-
-    if (!enableIntervention) {
-      logger.info('ℹ️ Intervention is disabled. Stall recovery using "continue" will not be available for this agent session.');
+    
+    // Send prompt via stdin (latest cursor-agent requires this)
+    // Note: stdin is closed after sending prompt, so intervention via stdin is not supported
+    if (child.stdin) {
+      child.stdin.write(prompt);
+      child.stdin.end();
     }
 
     let fullStdout = '';
     let fullStderr = '';
     let timeoutHandle: NodeJS.Timeout;
-    let heartbeatInterval: NodeJS.Timeout | undefined;
-    let lastActivity = Date.now();
-    let bytesReceived = 0;
 
-    // Signal watching for intervention and timeout
+    // Signal watching for dynamic timeout adjustment
+    // Note: Intervention via stdin is no longer supported (stdin is closed after prompt)
     let signalWatcher: fs.FSWatcher | null = null;
     if (signalDir) {
       if (!fs.existsSync(signalDir)) {
@@ -192,25 +221,21 @@ async function cursorAgentSendRaw({ workspaceDir, chatId, prompt, model, signalD
       const interventionPath = path.join(signalDir, 'intervention.txt');
       const timeoutPath = path.join(signalDir, 'timeout.txt');
       
-      // Watch for intervention or timeout signals from UI
+      // Watch for timeout signals from UI (intervention via stdin no longer works)
       signalWatcher = fs.watch(signalDir, (event, filename) => {
         if (filename === 'intervention.txt' && fs.existsSync(interventionPath)) {
           try {
             const message = fs.readFileSync(interventionPath, 'utf8').trim();
             if (message) {
-              logger.info(`👋 Human intervention received: ${message.substring(0, 50)}...`);
-              if (child.stdin && child.stdin.writable) {
-                child.stdin.write(message + '\n');
-                
-                if (signalDir) {
-                  const convoPath = path.join(signalDir, 'conversation.jsonl');
-                  appendLog(convoPath, createConversationEntry('intervention', `[HUMAN INTERVENTION]: ${message}`, {
-                    task: taskName || 'AGENT_TURN',
-                    model: 'manual'
-                  }));
-                }
-              } else {
-                logger.warn(`Intervention requested but stdin not available: ${message}`);
+              // Log intervention but cannot send via stdin (already closed)
+              logger.warn(`👋 Intervention received but stdin is closed (cursor-agent CLI limitation): ${message.substring(0, 50)}...`);
+              
+              if (signalDir) {
+                const convoPath = path.join(signalDir, 'conversation.jsonl');
+                appendLog(convoPath, createConversationEntry('intervention', `[INTERVENTION IGNORED - stdin closed]: ${message}`, {
+                  task: taskName || 'AGENT_TURN',
+                  model: 'manual'
+                }));
               }
               fs.unlinkSync(interventionPath);
             }
@@ -227,7 +252,6 @@ async function cursorAgentSendRaw({ workspaceDir, chatId, prompt, model, signalD
               const elapsed = Date.now() - startTime;
               const remaining = Math.max(1000, newTimeoutMs - elapsed);
               timeoutHandle = setTimeout(() => {
-                clearInterval(heartbeatInterval);
                 child.kill();
                 resolve({ ok: false, exitCode: -1, error: `cursor-agent timed out after updated limit.` });
               }, remaining);
@@ -241,7 +265,6 @@ async function cursorAgentSendRaw({ workspaceDir, chatId, prompt, model, signalD
     if (child.stdout) {
       child.stdout.on('data', (data) => {
         fullStdout += data.toString();
-        bytesReceived += data.length;
         process.stdout.write(data);
       });
     }
@@ -255,7 +278,6 @@ async function cursorAgentSendRaw({ workspaceDir, chatId, prompt, model, signalD
 
     const startTime = Date.now();
     timeoutHandle = setTimeout(() => {
-      clearInterval(heartbeatInterval);
       child.kill();
       resolve({
         ok: false,
@@ -267,7 +289,6 @@ async function cursorAgentSendRaw({ workspaceDir, chatId, prompt, model, signalD
     child.on('close', (code) => {
       activeChildren.delete(child);
       clearTimeout(timeoutHandle);
-      clearInterval(heartbeatInterval);
       if (signalWatcher) signalWatcher.close();
       
       const json = parseJsonFromStdout(fullStdout);
@@ -281,6 +302,12 @@ async function cursorAgentSendRaw({ workspaceDir, chatId, prompt, model, signalD
           exitCode: code ?? 0,
           sessionId: json.session_id || chatId,
           resultText: json.result || '',
+          // Extended fields from cursor-agent result
+          durationMs: json.duration_ms,
+          durationApiMs: json.duration_api_ms,
+          requestId: json.request_id,
+          subtype: json.subtype,
+          model: json.model,
         });
       }
     });
@@ -305,8 +332,14 @@ export async function cursorAgentSend(options: {
   signalDir?: string;
   timeout?: number;
   enableIntervention?: boolean;
-  outputFormat?: 'json' | 'plain' | 'stream-json';
+  outputFormat?: 'json' | 'stream-json';
   taskName?: string;
+  /** Enable browser automation (--browser flag) */
+  browser?: boolean;
+  /** Auto-approve commands (--force flag). Default: true */
+  autoApproveCommands?: boolean;
+  /** Auto-approve MCP servers (--approve-mcps flag). Default: true */
+  autoApproveMcps?: boolean;
 }): Promise<AgentSendResult> {
   const laneName = options.signalDir ? path.basename(path.dirname(options.signalDir)) : 'agent';