@litmers/cursorflow-orchestrator 0.1.40 → 0.2.3

package/src/types/index.ts

@@ -27,12 +27,58 @@ export {
 // Agent
 export * from './agent';
 
-// Review
-export * from './review';
-
-// Events
+// Events (기존 - 호환성 유지)
 export * from './events';
 
+// Event Categories (v2.1 - 카테고리별 분류, 새 아키텍처)
+// 중복 이름은 명시적으로 제외하고 새 카테고리 관련 타입만 export
+export {
+  // Event Categories
+  EventCategory,
+  
+  // Event Type Enums
+  OrchestrationEventType,
+  LaneEventType,
+  TaskEventType,
+  GitEventType,
+  RecoveryEventType,
+  AgentEventType,
+  StateEventType,
+  SystemEventType,
+  AllEventTypes,
+  
+  // Event Payload Map & Typed Event
+  EventPayloadMap,
+  TypedCursorFlowEvent,
+  TypedEventHandler,
+  GenericEventHandler,
+  getCategoryFromEventType,
+  
+  // New Payload Types (이름 충돌 없는 것들)
+  CycleDetectedPayload,
+  LaneWaitingPayload,
+  LaneBlockedPayload,
+  TaskRetryPayload,
+  TaskWaitingDependencyPayload,
+  GitBranchCreatedPayload,
+  GitCommittedPayload,
+  GitPushedPayload,
+  GitMergeStartedPayload,
+  GitMergeCompletedPayload,
+  GitMergeConflictPayload,
+  GitPushRejectedPayload,
+  GitErrorPayload,
+  RecoveryStartedPayload,
+  RecoveryConflictResolvedPayload,
+  AgentConnectionErrorPayload,
+  StateTransitionPayload,
+  StateTransitionFailedPayload,
+  StateCorruptedPayload,
+  StateRepairedPayload,
+  SystemHealthCheckPayload,
+  SystemSignalReceivedPayload,
+} from './event-categories';
+
 // Logging
 export * from './logging';
 

package/src/types/lane.ts

@@ -10,8 +10,7 @@ export type LaneStatus =
   | 'completed' 
   | 'failed' 
   | 'paused' 
-  | 'waiting' 
-  | 'reviewing';
+  | 'waiting';
 
 export interface LaneInfo {
   name: string;

package/src/types/logging.ts

@@ -26,7 +26,8 @@ export type MessageType =
   | 'debug'
   | 'progress'
   | 'stdout' 
-  | 'stderr';
+  | 'stderr'
+  | 'raw';  // Pre-formatted output that should be printed as-is
 
 export interface ParsedMessage {
   type: MessageType;

package/src/types/task.ts

@@ -13,6 +13,8 @@ export interface Task {
   dependsOn?: string[];
   /** Task execution timeout in milliseconds. Overrides lane-level timeout. */
   timeout?: number;
+  /** Enable browser automation for this task. Required for web testing/scraping. */
+  browser?: boolean;
 }
 
 export interface RunnerConfig {
@@ -26,7 +28,7 @@ export interface RunnerConfig {
   model?: string;
   dependencyPolicy: DependencyPolicy;
   /** Output format for cursor-agent (default: 'json') */
-  agentOutputFormat?: 'json' | 'plain' | 'stream-json';
+  agentOutputFormat?: 'json' | 'stream-json';
   /** Task execution timeout in milliseconds. Default: 600000 (10 minutes) */
   timeout?: number;
   /** 
@@ -40,6 +42,15 @@ export interface RunnerConfig {
    * Default: false
    */
   verboseGit?: boolean;
+  /** 
+   * Enable browser automation for all tasks in this config. 
+   * 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 interface TaskDirInfo {

package/src/ui/log-viewer.ts

@@ -8,6 +8,9 @@
  * - Importance filtering
  * - Text search
  * - Readable format toggle
+ *
+ * Note: This viewer only reads lane/subprocess logs. Main process logs are
+ * written to the run-level main log file and shown by default in CLI logs.
  */
 
 import * as readline from 'readline';

package/src/utils/config.ts

@@ -96,6 +96,11 @@ export function loadConfig(projectRoot: string | null = null): CursorFlowConfig
     // Default AI model
     defaultModel: 'gemini-3-flash',
     
+    // Agent execution flags (cursor-agent CLI options)
+    autoApproveCommands: true,  // --force flag
+    autoApproveMcps: true,      // --approve-mcps flag
+    browser: true,             // --browser flag
+    
     // Internal
     projectRoot,
   };
@@ -212,7 +217,7 @@ export function createDefaultConfig(projectRoot: string, force = false): string
   // Advanced
   worktreePrefix: 'cursorflow-',
   maxConcurrentLanes: 10,
-  agentOutputFormat: 'json', // 'json' | 'plain'
+  agentOutputFormat: 'stream-json', // 'json' | 'stream-json'
 
   // Webhook configuration
   // webhooks: [
@@ -234,6 +239,11 @@ export function createDefaultConfig(projectRoot: string, force = false): string
     writeJsonLog: true,      // Write structured JSON logs
     timestampFormat: 'iso',  // 'iso' | 'relative' | 'short'
   },
+
+  // Agent execution flags (cursor-agent CLI options)
+  autoApproveCommands: true,  // --force flag
+  autoApproveMcps: true,      // --approve-mcps flag
+  browser: false,             // --browser flag
 };
 `;
   

package/src/utils/cursor-agent.ts

@@ -110,19 +110,45 @@ export function validateSetup(executor = 'cursor-agent'): { valid: boolean; erro
   };
 }
 
+/**
+ * Known models in cursor-agent (2025.12 version)
+ * Reference: docs/CURSOR_AGENT_GUIDE.md
+ */
+export const KNOWN_MODELS = [
+  // Special modes
+  'composer-1',
+  'auto',
+  // Anthropic Claude models
+  'sonnet-4.5',
+  'sonnet-4.5-thinking',
+  'opus-4.5',
+  'opus-4.5-thinking',
+  'opus-4.1',
+  // Google Gemini models
+  'gemini-3-flash',
+  'gemini-3-pro',
+  // OpenAI GPT models
+  'gpt-5.2',
+  'gpt-5.2-high',
+  'gpt-5.1',
+  'gpt-5.1-high',
+  // OpenAI Codex models
+  'gpt-5.1-codex',
+  'gpt-5.1-codex-high',
+  'gpt-5.1-codex-max',
+  'gpt-5.1-codex-max-high',
+  // xAI
+  'grok',
+] as const;
+
+export type KnownModel = typeof KNOWN_MODELS[number];
+
 /**
  * Get available models (if cursor-agent supports it)
  */
 export function getAvailableModels(): string[] {
-  // Known models in the current version of cursor-agent
-  const knownModels = [
-    'sonnet-4.5',
-    'sonnet-4.5-thinking',
-    'opus-4.5',
-    'opus-4.5-thinking',
-    'gpt-5.2',
-    'gpt-5.2-high',
-  ];
+  // Use the known models list
+  const knownModels = [...KNOWN_MODELS];
 
   try {
     // Try to trigger a model list by using an invalid model with --print
@@ -236,34 +262,49 @@ export interface AuthCheckResult {
 }
 
 /**
- * Check cursor-agent authentication
+ * Check cursor-agent authentication using status/whoami command
+ * This is faster and has no side effects (unlike create-chat which creates a session)
+ * 
+ * Reference: docs/CURSOR_AGENT_GUIDE.md
+ * Expected output: " ✓ Logged in as user@email.com"
  */
 export function checkCursorAuth(): AuthCheckResult {
   try {
-    const result = spawnSync('cursor-agent', ['create-chat'], {
+    // Use 'status' command (or 'whoami' alias) - faster than create-chat
+    const result = spawnSync('cursor-agent', ['status'], {
       encoding: 'utf8',
       stdio: 'pipe',
       timeout: 10000, // 10 second timeout
     });
     
-    if (result.status === 0 && result.stdout.trim()) {
+    const output = (result.stdout?.trim() || '').toString();
+    const errorOutput = (result.stderr?.trim() || '').toString();
+    
+    // Check for successful login (output contains "Logged in as")
+    if (result.status === 0 && output.includes('Logged in')) {
+      // Extract email if present
+      const emailMatch = output.match(/Logged in as\s+(\S+)/i);
+      const email = emailMatch ? emailMatch[1] : undefined;
+      
       return {
         authenticated: true,
         message: 'Cursor authentication OK',
+        details: email ? `Logged in as ${email}` : undefined,
       };
     }
     
-    const errorMsg = (result.stderr?.trim() || result.stdout?.trim() || '').toString();
+    const errorMsg = errorOutput || output;
     
     // Check for authentication errors
     if (errorMsg.includes('not authenticated') || 
+        errorMsg.includes('not logged') ||
         errorMsg.includes('login') || 
         errorMsg.includes('auth')) {
       return {
         authenticated: false,
         message: 'Not authenticated with Cursor',
         details: errorMsg,
-        help: 'Please open Cursor IDE and sign in to your account',
+        help: 'Run: cursor-agent login',
       };
     }
     
@@ -279,13 +320,24 @@ export function checkCursorAuth(): AuthCheckResult {
       };
     }
     
+    // If status command failed but no specific error, might still be authenticated
+    // Fall back to checking if cursor-agent is responsive
+    if (result.status !== 0) {
+      return {
+        authenticated: false,
+        message: 'Authentication status check failed',
+        details: errorMsg || `Exit code: ${result.status}`,
+        help: 'Try running: cursor-agent status',
+      };
+    }
+    
     return {
       authenticated: false,
-      message: 'Unknown error',
+      message: 'Unknown authentication status',
       details: errorMsg,
     };
   } catch (error: any) {
-    if (error.code === 'ETIMEDOUT') {
+    if (error.code === 'ETIMEDOUT' || error.killed) {
       return {
         authenticated: false,
         message: 'Connection timeout',

package/src/utils/enhanced-logger.ts

@@ -11,6 +11,7 @@ import * as path from 'path';
 import { EnhancedLogConfig, ParsedMessage, LogSession } from '../types';
 import { formatMessageForConsole } from './log-formatter';
 import { safeJoin } from './path';
+import { getLaneLogPath } from '../services/logging/paths';
 
 export { EnhancedLogConfig, ParsedMessage, LogSession };
 
@@ -115,9 +116,11 @@ export class EnhancedLogManager {
     // Ensure log directory exists
     fs.mkdirSync(logDir, { recursive: true });
     
+    // Subprocess (lane) logs live in the lane run directory to avoid nesting with main logs.
+    // Main process logs are written separately to a run-level file (see utils/logger.ts).
     // Set up log file paths (simplified)
-    this.rawLogPath = safeJoin(logDir, 'terminal-raw.log');
-    this.readableLogPath = safeJoin(logDir, 'terminal-readable.log');
+    this.rawLogPath = getLaneLogPath(logDir, 'raw');
+    this.readableLogPath = getLaneLogPath(logDir, 'readable');
     
     // Initialize log files
     this.initLogFiles();
@@ -131,13 +134,13 @@ export class EnhancedLogManager {
   }
 
   /**
-   * Get lane-task label like [1-1-lanename10]
+   * Get lane-task label like [1-1-refactor]
    */
   private getLaneTaskLabel(): string {
     const laneNum = (this.session.laneIndex ?? 0) + 1;
     const taskNum = (this.session.taskIndex ?? 0) + 1;
-    const shortLaneName = this.session.laneName.substring(0, 10);
-    return `${laneNum}-${taskNum}-${shortLaneName}`.substring(0, 18).padEnd(18);
+    const shortLaneName = this.session.laneName.substring(0, 8);
+    return `${laneNum}-${taskNum}-${shortLaneName}`;
   }
 
   /**
@@ -308,6 +311,17 @@ export class EnhancedLogManager {
             this.writeReadableMessage(msg);
             continue;
           }
+          // parseJsonToMessage returned null - create fallback message for known JSON
+          if (json.type) {
+            const fallbackMsg: ParsedMessage = {
+              type: 'info',
+              role: 'system',
+              content: `[${json.type}] ${json.subtype || ''} ${JSON.stringify(json).substring(0, 150)}...`,
+              timestamp: json.timestamp_ms || Date.now(),
+            };
+            this.writeReadableMessage(fallbackMsg);
+            continue;
+          }
         } catch {
           // Not valid JSON, fall through
         }
@@ -318,16 +332,38 @@ export class EnhancedLogManager {
       if (cleanLine && !this.isNoiseLog(cleanLine)) {
         const hasTimestamp = /^\[(\d{4}-\d{2}-\d{2}T|\d{2}:\d{2}:\d{2})\]/.test(cleanLine);
         const label = this.getLaneTaskLabel();
+        const ts = this.getShortTime();
         
+        // For file output, use clean line (no ANSI codes)
+        let fileFormattedLine: string;
         if (hasTimestamp) {
-          // If already has timestamp, just ensure label is present
-          const formatted = cleanLine.includes(`[${label}]`) 
+          fileFormattedLine = cleanLine.includes(`[${label}]`) 
             ? cleanLine 
             : cleanLine.replace(/^(\[[^\]]+\])/, `$1 [${label}]`);
-          this.writeToReadableLog(`${formatted}\n`);
         } else {
-          const ts = this.getShortTime();
-          this.writeToReadableLog(`[${ts}] [${label}] ${cleanLine}\n`);
+          fileFormattedLine = `[${ts}] [${label}] ${cleanLine}`;
+        }
+        
+        this.writeToReadableLog(`${fileFormattedLine}\n`);
+        
+        // For console output, preserve ANSI colors from original line
+        if (this.onParsedMessage) {
+          let consoleFormattedLine: string;
+          if (hasTimestamp) {
+            consoleFormattedLine = trimmed.includes(`[${label}]`) 
+              ? trimmed 
+              : trimmed.replace(/^(\[[^\]]+\])/, `$1 [${label}]`);
+          } else {
+            consoleFormattedLine = `[${ts}] [${label}] ${trimmed}`;
+          }
+          
+          const rawMsg: ParsedMessage = {
+            type: 'raw',
+            role: 'system',
+            content: consoleFormattedLine,
+            timestamp: Date.now(),
+          };
+          this.onParsedMessage(rawMsg);
         }
       }
     }
@@ -426,6 +462,15 @@ export class EnhancedLogManager {
         return null;
         
       default:
+        // Fallback: show unknown JSON types with basic formatting
+        if (type) {
+          return {
+            type: 'info',
+            role: 'system',
+            content: `[${type}] ${JSON.stringify(json).substring(0, 200)}`,
+            timestamp,
+          };
+        }
         return null;
     }
   }
@@ -439,27 +484,68 @@ export class EnhancedLogManager {
     // Write raw log
     this.writeToRawLog(data);
     
-    // Write to readable log with error prefix
+    // Write to readable log - treat stderr same as stdout
+    // Git and many tools use stderr for non-error output
     const lines = text.split('\n');
     for (const line of lines) {
       const cleanLine = stripAnsi(line).trim();
       if (cleanLine && !this.isNoiseLog(cleanLine)) {
         const hasTimestamp = /^\[(\d{4}-\d{2}-\d{2}T|\d{2}:\d{2}:\d{2})\]/.test(cleanLine);
         const label = this.getLaneTaskLabel();
+        const ts = this.getShortTime();
         
+        // Determine if this is actually an error message
+        const isError = this.isErrorLine(cleanLine);
+        const prefix = isError ? '❌ ERR' : '';
+        
+        let formattedLine: string;
         if (hasTimestamp) {
-          const formatted = cleanLine.includes(`[${label}]`) 
+          formattedLine = cleanLine.includes(`[${label}]`) 
             ? cleanLine 
-            : cleanLine.replace(/^(\[[^\]]+\])/, `$1 [${label}] ❌ ERR`);
-          this.writeToReadableLog(`${formatted}\n`);
+            : cleanLine.replace(/^(\[[^\]]+\])/, `$1 [${label}]${prefix ? ' ' + prefix : ''}`);
         } else {
-          const ts = this.getShortTime();
-          this.writeToReadableLog(`[${ts}] [${label}] ❌ ERR ${cleanLine}\n`);
+          formattedLine = prefix 
+            ? `[${ts}] [${label}] ${prefix} ${cleanLine}`
+            : `[${ts}] [${label}] ${cleanLine}`;
+        }
+        
+        this.writeToReadableLog(`${formattedLine}\n`);
+        
+        // Output to console
+        if (this.onParsedMessage) {
+          const rawMsg: ParsedMessage = {
+            type: 'raw',
+            role: 'system',
+            content: formattedLine,
+            timestamp: Date.now(),
+          };
+          this.onParsedMessage(rawMsg);
         }
       }
     }
   }
 
+  /**
+   * Check if a line is actually an error message
+   */
+  private isErrorLine(text: string): boolean {
+    const errorPatterns = [
+      /^error:/i,
+      /^fatal:/i,
+      /^panic:/i,
+      /\berror\b.*:/i,
+      /\bfailed\b/i,
+      /\bexception\b/i,
+      /^ENOENT:/i,
+      /^EACCES:/i,
+      /^EPERM:/i,
+      /^ERR!/i,
+      /npm ERR!/i,
+    ];
+    
+    return errorPatterns.some(p => p.test(text));
+  }
+
   /**
    * Write a custom log entry
    */
@@ -644,12 +730,12 @@ export function exportLogs(
   format: 'text' | 'json' | 'markdown' | 'html',
   outputPath?: string
 ): string {
-  const readableLogPath = safeJoin(laneRunDir, 'terminal-readable.log');
+  const logPath = getLaneLogPath(laneRunDir, 'raw');
   
   let output = '';
   
-  if (fs.existsSync(readableLogPath)) {
-    output = fs.readFileSync(readableLogPath, 'utf8');
+  if (fs.existsSync(logPath)) {
+    output = fs.readFileSync(logPath, 'utf8');
   }
   
   if (outputPath) {