@litmers/cursorflow-orchestrator 0.1.40 → 0.2.3

package/src/cli/resume.ts

@@ -18,6 +18,7 @@ import {
   ParsedMessage
 } from '../utils/enhanced-logger';
 import { formatMessageForConsole } from '../utils/log-formatter';
+import { MAIN_LOG_FILENAME } from '../utils/log-constants';
 
 interface ResumeOptions {
   lane: string | null;
@@ -30,6 +31,7 @@ interface ResumeOptions {
   maxConcurrent: number;
   help: boolean;
   executor: string | null;
+  browser: boolean;
 }
 
 function printHelp(): void {
@@ -48,6 +50,7 @@ Options:
   --restart              Restart from the first task (index 0)
   --skip-doctor          Skip environment/branch checks (not recommended)
   --executor <type>      Override executor (default: cursor-agent)
+  --browser              Enable browser automation for all resumed tasks
   --help, -h             Show help
 
 Examples:
@@ -56,6 +59,7 @@ Examples:
   cursorflow resume lane-1                   # Resume single lane
   cursorflow resume _cursorflow/flows/MyFeature  # Resume all lanes in flow
   cursorflow resume --all --restart          # Restart all incomplete lanes from task 0
+  cursorflow resume --all --browser          # Resume all lanes with browser mode enabled
   `);
 }
 
@@ -75,6 +79,7 @@ function parseArgs(args: string[]): ResumeOptions {
     maxConcurrent: maxConcurrentIdx >= 0 ? parseInt(args[maxConcurrentIdx + 1] || '3') : 3,
     help: args.includes('--help') || args.includes('-h'),
     executor: executorIdx >= 0 ? args[executorIdx + 1] || null : null,
+    browser: args.includes('--browser'),
   };
 }
 
@@ -103,7 +108,6 @@ const STATUS_COLORS: Record<string, string> = {
   failed: '\x1b[31m',    // red
   paused: '\x1b[35m',    // magenta
   waiting: '\x1b[33m',   // yellow
-  reviewing: '\x1b[36m', // cyan
   unknown: '\x1b[90m',   // gray
 };
 const RESET = '\x1b[0m';
@@ -396,6 +400,7 @@ function spawnLaneResume(
     restart: boolean;
     pipelineBranch?: string;
     executor?: string | null;
+    browser?: boolean;
     enhancedLogConfig?: any;
     laneIndex?: number;
   }
@@ -425,6 +430,11 @@ function spawnLaneResume(
     runnerArgs.push('--executor', options.executor);
   }
 
+  // Pass browser flag if provided
+  if (options.browser) {
+    runnerArgs.push('--browser');
+  }
+
   // Generate lane label: [laneIdx-taskIdx-laneName] format, padded to 18 chars
   // Note: taskName will be updated dynamically via logManager.setTask()
   let currentTaskName = '';
@@ -493,6 +503,7 @@ async function resumeLanes(
     maxConcurrent: number; 
     skipDoctor: boolean; 
     executor: string | null;
+    browser: boolean;
     enhancedLogConfig?: any;
   }
 ): Promise<{ succeeded: string[]; failed: string[]; skipped: string[] }> {
@@ -587,10 +598,21 @@ async function resumeLanes(
       const { child } = spawnLaneResume(lane.name, lane.dir, lane.state!, {
         restart: options.restart,
         executor: options.executor,
+        browser: options.browser,
         enhancedLogConfig: options.enhancedLogConfig,
         laneIndex: laneIndexMap.get(lane.name) ?? 1,
       });
       
+      // Update state.json with the new PID for monitor tracking
+      const statePath = safeJoin(lane.dir, 'state.json');
+      const updatedState: LaneState = {
+        ...lane.state!,
+        status: 'running',
+        pid: child.pid,
+        error: null,
+      };
+      saveState(statePath, updatedState);
+      
       active.set(lane.name, child);
       
       waitForChild(child).then(code => {
@@ -664,6 +686,9 @@ async function resume(args: string[]): Promise<void> {
   if (!runDir || !fs.existsSync(runDir)) {
     throw new Error(`Run directory not found: ${runDir || 'latest'}. Have you run any tasks yet?`);
   }
+
+  logger.setDefaultContext('MAIN');
+  logger.setLogFile(safeJoin(runDir, MAIN_LOG_FILENAME));
   
   const allLanes = getAllLaneStatuses(runDir);
   let lanesToResume: LaneInfo[] = [];
@@ -736,6 +761,7 @@ async function resume(args: string[]): Promise<void> {
     maxConcurrent: options.maxConcurrent,
     skipDoctor: options.skipDoctor,
     executor: options.executor,
+    browser: options.browser,
     enhancedLogConfig: config.enhancedLogging,
   });
   

package/src/cli/run.ts

@@ -10,7 +10,7 @@ import { getLogsDir, loadConfig } from '../utils/config';
 import { runDoctor, getDoctorStatus } from '../utils/doctor';
 import { areCommandsInstalled, setupCommands } from './setup-commands';
 import { safeJoin } from '../utils/path';
-import { findFlowDir } from '../utils/flow';
+import { findFlowDir, findLatestFlowOrTask } from '../utils/flow';
 import { loadState } from '../utils/state';
 import { LaneState } from '../types';
 
@@ -119,6 +119,7 @@ interface RunOptions {
   skipDoctor: boolean;
   skipPreflight: boolean;
   raw: boolean;
+  browser: boolean;
   help: boolean;
 }
 
@@ -138,6 +139,7 @@ Options:
   --skip-doctor          Skip environment checks (not recommended)
   --skip-preflight       Skip preflight checks (Git remote, etc.)
   --raw                  Save raw logs (absolute raw, no processing)
+  --browser              Enable browser automation for all tasks
   --dry-run              Show execution plan without starting agents
   --help, -h             Show help
 
@@ -160,6 +162,7 @@ function parseArgs(args: string[]): RunOptions {
     skipDoctor: args.includes('--skip-doctor') || args.includes('--no-doctor'),
     skipPreflight: args.includes('--skip-preflight'),
     raw: args.includes('--raw'),
+    browser: args.includes('--browser'),
     help: args.includes('--help') || args.includes('-h'),
   };
 }
@@ -182,11 +185,6 @@ async function run(args: string[]): Promise<void> {
     }
   }
 
-  if (!options.tasksDir) {
-    console.log('\nUsage: cursorflow run <tasks-dir> [options]');
-    throw new Error('Tasks directory required');
-  }
-  
   const config = loadConfig();
   const logsDir = getLogsDir(config);
   const originalCwd = process.cwd();
@@ -198,11 +196,22 @@ async function run(args: string[]): Promise<void> {
   }
 
   // Resolve tasks dir:
-  // 1. Prefer the exact path if it exists relative to original cwd
-  // 2. Search in flowsDir by name
-  // 3. Fall back to projectRoot-relative tasksDir for backward compatibility
+  // 1. If not provided, use the most recent flow or legacy task
+  // 2. Prefer the exact path if it exists relative to original cwd
+  // 3. Search in flowsDir by name
+  // 4. Fall back to projectRoot-relative tasksDir for backward compatibility
   let tasksDir = '';
-  if (path.isAbsolute(options.tasksDir)) {
+  
+  if (!options.tasksDir) {
+    const latestPath = findLatestFlowOrTask(config);
+    if (latestPath) {
+      logger.info(`No flow specified. Using the latest: ${path.basename(latestPath)}`);
+      tasksDir = latestPath;
+    } else {
+      console.log('\nUsage: cursorflow run <tasks-dir> [options]');
+      throw new Error('Tasks directory required (none found in flows or tasks directories)');
+    }
+  } else if (path.isAbsolute(options.tasksDir)) {
     tasksDir = options.tasksDir;
   } else {
     const relPath = path.resolve(originalCwd, options.tasksDir);
@@ -216,7 +225,15 @@ async function run(args: string[]): Promise<void> {
         tasksDir = foundFlow;
       } else {
         // Fallback to legacy tasksDir
-        tasksDir = safeJoin(config.projectRoot, options.tasksDir);
+        const legacyTasksDir = safeJoin(config.projectRoot, config.tasksDir);
+        const foundLegacy = findFlowDir(legacyTasksDir, options.tasksDir);
+        
+        if (foundLegacy) {
+          tasksDir = foundLegacy;
+        } else {
+          // Fallback to joining with project root
+          tasksDir = safeJoin(config.projectRoot, options.tasksDir);
+        }
       }
     }
   }
@@ -318,6 +335,7 @@ async function run(args: string[]): Promise<void> {
         ...(options.raw ? { raw: true } : {}),
       },
       skipPreflight: options.skipPreflight,
+      browser: options.browser,
     });
   } catch (error: any) {
     // Re-throw to be handled by the main entry point

package/src/cli/signal.ts

@@ -1,20 +1,33 @@
 /**
  * CursorFlow signal command
  * 
- * Send a direct message to a running lane
+ * 실행 중인 lane에 즉각적인 개입 메시지 전송
+ * 
+ * 동작 방식:
+ * - 현재 실행 중인 cursor-agent 프로세스를 중단 (SIGTERM)
+ * - 개입 메시지를 pending-intervention.json에 저장
+ * - Orchestrator가 프로세스 종료를 감지하고 개입 메시지와 함께 resume
  */
 
-import * as path from 'path';
 import * as fs from 'fs';
 import * as logger from '../utils/logger';
 import { loadConfig, getLogsDir } from '../utils/config';
-import { appendLog, createConversationEntry } from '../utils/state';
+import { appendLog, createConversationEntry, loadState } from '../utils/state';
 import { safeJoin } from '../utils/path';
+import { LaneState } from '../types';
+import {
+  executeUserIntervention,
+  isProcessAlive,
+  InterventionResult,
+  createInterventionRequest,
+  InterventionType,
+  wrapUserIntervention,
+} from '../core/intervention';
 
 interface SignalOptions {
   lane: string | null;
   message: string | null;
-  timeout: number | null; // New timeout in milliseconds
+  timeout: number | null;
   runDir: string | null;
   help: boolean;
 }
@@ -24,14 +37,26 @@ function printHelp(): void {
 Usage: cursorflow signal <lane> "<message>" [options]
        cursorflow signal <lane> --timeout <ms>
 
-Directly intervene in a running lane.
+Send an intervention message to a lane. For running lanes, the agent will be
+interrupted immediately and resume with your message. For pending/waiting/failed
+lanes, the message will be applied when the lane starts or resumes.
 
-Options:
+Note: Completed lanes cannot receive signals.
+      To re-run a completed lane, start a new run with: cursorflow run
+
+Arguments:
   <lane>                 Lane name to signal
   "<message>"            Message text to send to the agent
+
+Options:
   --timeout <ms>         Update execution timeout (in milliseconds)
   --run-dir <path>       Use a specific run directory (default: latest)
   --help, -h             Show help
+
+Examples:
+  cursorflow signal lane-1 "Please focus on error handling first"
+  cursorflow signal lane-2 "Skip the optional tasks and finish" 
+  cursorflow signal lane-1 --timeout 600000   # Set 10 minute timeout
   `);
 }
 
@@ -39,8 +64,18 @@ function parseArgs(args: string[]): SignalOptions {
   const runDirIdx = args.indexOf('--run-dir');
   const timeoutIdx = args.indexOf('--timeout');
   
+  // Collect indices of option values to exclude from nonOptions
+  const optionValueIndices = new Set<number>();
+  if (runDirIdx >= 0 && runDirIdx + 1 < args.length) {
+    optionValueIndices.add(runDirIdx + 1);
+  }
+  if (timeoutIdx >= 0 && timeoutIdx + 1 < args.length) {
+    optionValueIndices.add(timeoutIdx + 1);
+  }
+  
   // First non-option is lane, second (or rest joined) is message
-  const nonOptions = args.filter(a => !a.startsWith('--'));
+  // Exclude option flags and their values
+  const nonOptions = args.filter((a, i) => !a.startsWith('--') && !optionValueIndices.has(i));
   
   return {
     lane: nonOptions[0] || null,
@@ -63,6 +98,39 @@ function findLatestRunDir(logsDir: string): string | null {
   return runs.length > 0 ? safeJoin(runsDir, runs[0]!) : null;
 }
 
+/**
+ * Lane 상태 및 PID 확인
+ */
+function getLaneStatus(laneDir: string): { state: LaneState | null; isRunning: boolean; pid?: number } {
+  const statePath = safeJoin(laneDir, 'state.json');
+  
+  if (!fs.existsSync(statePath)) {
+    return { state: null, isRunning: false };
+  }
+
+  const state = loadState<LaneState>(statePath);
+  if (!state) {
+    return { state: null, isRunning: false };
+  }
+
+  const pid = state.pid;
+  const isRunning = pid ? isProcessAlive(pid) : false;
+
+  return { state, isRunning, pid };
+}
+
+/**
+ * 개입 요청 파일 작성 (비실행 중인 lane용)
+ */
+function sendInterventionRequest(laneDir: string, message: string): void {
+  createInterventionRequest(laneDir, {
+    type: InterventionType.USER_MESSAGE,
+    message: wrapUserIntervention(message),
+    source: 'user',
+    priority: 10
+  });
+}
+
 async function signal(args: string[]): Promise<void> {
   const options = parseArgs(args);
   
@@ -92,32 +160,67 @@ async function signal(args: string[]): Promise<void> {
     throw new Error(`Lane directory not found: ${laneDir}`);
   }
 
-  // Case 1: Timeout update
+  // Case 1: Timeout update (기존 로직 유지)
   if (options.timeout !== null) {
     const timeoutPath = safeJoin(laneDir, 'timeout.txt');
     fs.writeFileSync(timeoutPath, String(options.timeout));
-    logger.success(`Timeout update signal sent to ${options.lane}: ${options.timeout}ms`);
+    logger.success(`⏱ Timeout update signal sent to ${options.lane}: ${options.timeout}ms`);
     return;
   }
 
   // Case 2: Intervention message
   if (options.message) {
-    const interventionPath = safeJoin(laneDir, 'intervention.txt');
+    const { state, isRunning, pid } = getLaneStatus(laneDir);
     const convoPath = safeJoin(laneDir, 'conversation.jsonl');
     
-    logger.info(`Sending signal to lane: ${options.lane}`);
-    logger.info(`Message: "${options.message}"`);
+    logger.info(`📨 Sending intervention to lane: ${options.lane}`);
+    logger.info(`   Message: "${options.message.substring(0, 50)}${options.message.length > 50 ? '...' : ''}"`);
     
-    // 1. Write to intervention.txt for live agents to pick up immediately via stdin
-    fs.writeFileSync(interventionPath, options.message);
-    
-    // 2. Also append to conversation log for visibility and history
+    // Completed 레인은 signal 거부 (브랜치 충돌 방지)
+    if (state?.status === 'completed') {
+      logger.error(`❌ Cannot signal a completed lane.`);
+      logger.info('   To re-run this lane, start a new run with: cursorflow run');
+      throw new Error('Lane is already completed');
+    }
+
+    // Log to conversation for history
     const entry = createConversationEntry('intervention', `[HUMAN INTERVENTION]: ${options.message}`, {
       task: 'DIRECT_SIGNAL'
     });
     appendLog(convoPath, entry);
+
+    // Lane이 실행 중이 아닌 경우 (pending/waiting/failed/paused)
+    if (!isRunning) {
+      // 실행 중이 아니면 다음 시작/resume 시 적용되도록 파일만 작성
+      sendInterventionRequest(laneDir, options.message);
+      logger.info(`ℹ Lane ${options.lane} is not currently running (status: ${state?.status || 'unknown'}).`);
+      logger.success('✅ Signal queued. Message will be applied when lane starts or resumes.');
+      return;
+    }
+
+    // 즉각 개입 실행: 프로세스 종료 + pending-intervention.json 생성
+    logger.info(`🛑 Interrupting running process (PID: ${pid})...`);
+    
+    const result: InterventionResult = await executeUserIntervention(laneDir, options.message, pid);
+    
+    if (result.success) {
+      if (result.killedPid) {
+        logger.success(`✅ Process ${result.killedPid} interrupted successfully.`);
+        logger.info('   The agent will resume with your intervention message.');
+        logger.info('   Monitor progress with: cursorflow monitor');
+      } else {
+        logger.success('✅ Intervention request created.');
+        logger.info('   Message will be applied on next agent turn.');
+      }
+    } else {
+      logger.error(`❌ Failed to send intervention: ${result.error}`);
+      
+      // 실패해도 파일은 작성되었으므로 다음 기회에 적용됨
+      if (result.pendingFile) {
+        logger.info('   Intervention file was created and will be applied on next opportunity.');
+      }
+    }
     
-    logger.success('Signal sent successfully. The agent will see this message in its current turn or next step.');
     return;
   }
 
@@ -125,4 +228,3 @@ async function signal(args: string[]): Promise<void> {
 }
 
 export = signal;
-

package/src/cli/tasks.ts

@@ -15,18 +15,11 @@ import * as logger from '../utils/logger';
 import { TaskService, TaskDirInfo, ValidationStatus } from '../utils/task-service';
 import { findProjectRoot, loadConfig, getTasksDir, getFlowsDir } from '../utils/config';
 import { safeJoin } from '../utils/path';
+import { listFlows } from '../utils/flow';
+import { FlowInfo } from '../types/flow';
 
 const COLORS = logger.COLORS;
 
-interface FlowInfo {
-  id: string;
-  name: string;
-  path: string;
-  timestamp: Date;
-  lanes: string[];
-  status: string;
-}
-
 interface TasksCliOptions {
   validate: boolean;
   taskName: string | null;
@@ -75,56 +68,6 @@ function parseArgs(args: string[]): TasksCliOptions {
   return options;
 }
 
-/**
- * List flows from _cursorflow/flows/
- */
-function listFlows(flowsDir: string): FlowInfo[] {
-  if (!fs.existsSync(flowsDir)) {
-    return [];
-  }
-
-  const dirs = fs.readdirSync(flowsDir)
-    .filter(name => {
-      const dirPath = safeJoin(flowsDir, name);
-      return fs.statSync(dirPath).isDirectory() && !name.startsWith('.');
-    })
-    .sort((a, b) => b.localeCompare(a)); // Most recent first
-
-  return dirs.map(name => {
-    const flowPath = safeJoin(flowsDir, name);
-    const metaPath = safeJoin(flowPath, 'flow.meta.json');
-    
-    let meta: any = {};
-    try {
-      if (fs.existsSync(metaPath)) {
-        meta = JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
-      }
-    } catch {}
-
-    // Parse flow name from directory (e.g., "001_TestFeature" -> "TestFeature")
-    const match = name.match(/^(\d+)_(.+)$/);
-    const id = match ? match[1] : name;
-    const flowName = match ? match[2] : name;
-
-    // Get lane files
-    const laneFiles = fs.readdirSync(flowPath)
-      .filter(f => f.endsWith('.json') && f !== 'flow.meta.json')
-      .map(f => {
-        const laneMatch = f.match(/^\d+-([^.]+)\.json$/);
-        return laneMatch ? laneMatch[1] : f.replace('.json', '');
-      });
-
-    return {
-      id,
-      name: flowName,
-      path: flowPath,
-      timestamp: meta.createdAt ? new Date(meta.createdAt) : new Date(),
-      lanes: laneFiles,
-      status: meta.status || 'pending',
-    };
-  });
-}
-
 /**
  * Get flow info by name
  */

package/src/core/agent-supervisor.ts

@@ -0,0 +1,64 @@
+import { cursorAgentCreateChat, cursorAgentSend } from './runner/agent';
+import { events } from '../utils/events';
+import { AgentSendResult } from '../types';
+import { analyzeFailure, logFailure } from './failure-policy';
+
+export interface AgentPromptOptions {
+  workspaceDir: string;
+  chatId: string;
+  prompt: string;
+  model?: string;
+  laneName?: string;
+  signalDir?: string;
+  timeout?: number;
+  enableIntervention?: boolean;
+  outputFormat?: 'json' | 'stream-json';
+  taskName?: string;
+  /** Enable browser automation (--browser flag). Required for web testing/scraping. */
+  browser?: boolean;
+  /** Auto-approve commands (--force flag). Default: true */
+  autoApproveCommands?: boolean;
+  /** Auto-approve MCP servers (--approve-mcps flag). Default: true */
+  autoApproveMcps?: boolean;
+}
+
+export class AgentSupervisor {
+  createChat(workspaceDir?: string): string {
+    return cursorAgentCreateChat(workspaceDir);
+  }
+
+  async sendTaskPrompt(options: AgentPromptOptions): Promise<AgentSendResult> {
+    const startTime = Date.now();
+
+    events.emit('agent.prompt_sent', {
+      taskName: options.taskName || 'task',
+      model: options.model || 'unknown',
+      promptLength: options.prompt.length,
+    });
+
+    const result = await cursorAgentSend(options);
+    const duration = Date.now() - startTime;
+
+    events.emit('agent.response_received', {
+      taskName: options.taskName || 'task',
+      ok: result.ok,
+      duration,
+      responseLength: result.resultText?.length || 0,
+      error: result.error,
+    });
+
+    if (!result.ok) {
+      const analysis = analyzeFailure(result.error, {
+        circuitBreakerName: options.laneName,
+      });
+      logFailure(options.laneName || options.taskName || 'agent', analysis);
+      events.emit('agent.recovery_suggested', {
+        laneName: options.laneName,
+        taskName: options.taskName || 'task',
+        analysis,
+      });
+    }
+
+    return result;
+  }
+}