@litmers/cursorflow-orchestrator 0.1.13 → 0.1.14

package/src/core/runner.ts

@@ -12,6 +12,10 @@ import * as git from '../utils/git';
 import * as logger from '../utils/logger';
 import { ensureCursorAgent, checkCursorAuth, printAuthHelp } from '../utils/cursor-agent';
 import { saveState, appendLog, createConversationEntry } from '../utils/state';
+import { events } from '../utils/events';
+import { loadConfig } from '../utils/config';
+import { registerWebhooks } from '../utils/webhook';
+import { stripAnsi } from '../utils/enhanced-logger';
 import { 
   RunnerConfig, 
   Task, 
@@ -107,8 +111,8 @@ function parseJsonFromStdout(stdout: string): any {
   return null;
 }
 
-/** Default timeout: 5 minutes */
-const DEFAULT_TIMEOUT_MS = 300000;
+/** Default timeout: 10 minutes */
+const DEFAULT_TIMEOUT_MS = 600000;
 
 /** Heartbeat interval: 30 seconds */
 const HEARTBEAT_INTERVAL_MS = 30000;
@@ -181,9 +185,10 @@ export async function cursorAgentSend({ workspaceDir, chatId, prompt, model, sig
   /** Enable stdin piping for intervention feature (may cause buffering issues on some systems) */
   enableIntervention?: boolean;
 }): Promise<AgentSendResult> {
+  // Use stream-json format for structured output with tool calls and results
   const args = [
     '--print',
-    '--output-format', 'json',
+    '--output-format', 'stream-json',
     '--workspace', workspaceDir,
     ...(model ? ['--model', model] : []),
     '--resume', chatId,
@@ -240,6 +245,7 @@ export async function cursorAgentSend({ workspaceDir, chatId, prompt, model, sig
 
     let fullStdout = '';
     let fullStderr = '';
+    let timeoutHandle: NodeJS.Timeout;
 
     // Heartbeat logging to show progress
     let lastHeartbeat = Date.now();
@@ -251,13 +257,15 @@ export async function cursorAgentSend({ workspaceDir, chatId, prompt, model, sig
     }, HEARTBEAT_INTERVAL_MS);
     const startTime = Date.now();
 
-    // Watch for "intervention.txt" signal file if any
+    // Watch for "intervention.txt" or "timeout.txt" signal files
     const interventionPath = signalDir ? path.join(signalDir, 'intervention.txt') : null;
-    let interventionWatcher: fs.FSWatcher | null = null;
+    const timeoutPath = signalDir ? path.join(signalDir, 'timeout.txt') : null;
+    let signalWatcher: fs.FSWatcher | null = null;
 
-    if (interventionPath && fs.existsSync(path.dirname(interventionPath))) {
-      interventionWatcher = fs.watch(path.dirname(interventionPath), (event, filename) => {
-        if (filename === 'intervention.txt' && fs.existsSync(interventionPath)) {
+    if (signalDir && fs.existsSync(signalDir)) {
+      signalWatcher = fs.watch(signalDir, (event, filename) => {
+        // Handle intervention
+        if (filename === 'intervention.txt' && interventionPath && fs.existsSync(interventionPath)) {
           try {
             const message = fs.readFileSync(interventionPath, 'utf8').trim();
             if (message) {
@@ -274,6 +282,40 @@ export async function cursorAgentSend({ workspaceDir, chatId, prompt, model, sig
             logger.warn('Failed to read intervention file');
           }
         }
+        
+        // Handle dynamic timeout update
+        if (filename === 'timeout.txt' && timeoutPath && fs.existsSync(timeoutPath)) {
+          try {
+            const newTimeoutStr = fs.readFileSync(timeoutPath, 'utf8').trim();
+            const newTimeoutMs = parseInt(newTimeoutStr);
+            
+            if (!isNaN(newTimeoutMs) && newTimeoutMs > 0) {
+              logger.info(`⏱ Dynamic timeout update: ${Math.round(newTimeoutMs / 1000)}s`);
+              
+              // Clear old timeout
+              if (timeoutHandle) clearTimeout(timeoutHandle);
+              
+              // Set new timeout based on total elapsed time
+              const elapsed = Date.now() - startTime;
+              const remaining = Math.max(1000, newTimeoutMs - elapsed);
+              
+              timeoutHandle = setTimeout(() => {
+                clearInterval(heartbeatInterval);
+                child.kill();
+                const totalSec = Math.round(newTimeoutMs / 1000);
+                resolve({
+                  ok: false,
+                  exitCode: -1,
+                  error: `cursor-agent timed out after updated limit of ${totalSec} seconds.`,
+                });
+              }, remaining);
+              
+              fs.unlinkSync(timeoutPath); // Clear it
+            }
+          } catch (e) {
+            logger.warn('Failed to read timeout update file');
+          }
+        }
       });
     }
 
@@ -295,7 +337,7 @@ export async function cursorAgentSend({ workspaceDir, chatId, prompt, model, sig
       });
     }
 
-    const timeoutHandle = setTimeout(() => {
+    timeoutHandle = setTimeout(() => {
       clearInterval(heartbeatInterval);
       child.kill();
       const timeoutSec = Math.round(timeoutMs / 1000);
@@ -309,7 +351,7 @@ export async function cursorAgentSend({ workspaceDir, chatId, prompt, model, sig
     child.on('close', (code) => {
       clearTimeout(timeoutHandle);
       clearInterval(heartbeatInterval);
-      if (interventionWatcher) interventionWatcher.close();
+      if (signalWatcher) signalWatcher.close();
       
       const json = parseJsonFromStdout(fullStdout);
       
@@ -469,6 +511,12 @@ export async function runTask({
   logger.info(`Model: ${model}`);
   logger.info(`Branch: ${taskBranch}`);
   
+  events.emit('task.started', {
+    taskName: task.name,
+    taskBranch,
+    index,
+  });
+
   // Checkout task branch
   git.runGit(['checkout', '-B', taskBranch], { cwd: worktreeDir });
   
@@ -484,6 +532,13 @@ export async function runTask({
   }));
   
   logger.info('Sending prompt to agent...');
+  const startTime = Date.now();
+  events.emit('agent.prompt_sent', {
+    taskName: task.name,
+    model,
+    promptLength: prompt1.length,
+  });
+
   const r1 = await cursorAgentSend({
     workspaceDir: worktreeDir,
     chatId,
@@ -494,12 +549,26 @@ export async function runTask({
     enableIntervention: config.enableIntervention,
   });
   
+  const duration = Date.now() - startTime;
+  events.emit('agent.response_received', {
+    taskName: task.name,
+    ok: r1.ok,
+    duration,
+    responseLength: r1.resultText?.length || 0,
+    error: r1.error,
+  });
+
   appendLog(convoPath, createConversationEntry('assistant', r1.resultText || r1.error || 'No response', {
     task: task.name,
     model,
   }));
   
   if (!r1.ok) {
+    events.emit('task.failed', {
+      taskName: task.name,
+      taskBranch,
+      error: r1.error,
+    });
     return {
       taskName: task.name,
       taskBranch,
@@ -522,6 +591,12 @@ export async function runTask({
   // Push task branch
   git.push(taskBranch, { cwd: worktreeDir, setUpstream: true });
   
+  events.emit('task.completed', {
+    taskName: task.name,
+    taskBranch,
+    status: 'FINISHED',
+  });
+
   return {
     taskName: task.name,
     taskBranch,
@@ -667,6 +742,12 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
             noFf: true, 
             message: `chore: merge dependency ${depName} (${depState.pipelineBranch})` 
           });
+
+          // Log changed files
+          const stats = git.getLastOperationStats(worktreeDir);
+          if (stats) {
+            logger.info('Changed files:\n' + stats);
+          }
         }
       } catch (e) {
         logger.error(`Failed to merge dependency ${depName}: ${e}`);
@@ -706,6 +787,14 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
       state.status = 'failed';
       state.dependencyRequest = result.dependencyRequest || null;
       saveState(statePath, state);
+      
+      if (result.dependencyRequest) {
+        events.emit('lane.dependency_requested', {
+          laneName: state.label,
+          dependencyRequest: result.dependencyRequest,
+        });
+      }
+      
       logger.warn('Task blocked on dependency change');
       process.exit(2);
     }
@@ -721,6 +810,13 @@ export async function runTasks(tasksFile: string, config: RunnerConfig, runDir:
     // Merge into pipeline
     logger.info(`Merging ${taskBranch} → ${pipelineBranch}`);
     git.merge(taskBranch, { cwd: worktreeDir, noFf: true });
+
+    // Log changed files
+    const stats = git.getLastOperationStats(worktreeDir);
+    if (stats) {
+      logger.info('Changed files:\n' + stats);
+    }
+
     git.push(pipelineBranch, { cwd: worktreeDir });
   }
   
@@ -747,11 +843,28 @@ if (require.main === module) {
   const tasksFile = args[0]!;
   const runDirIdx = args.indexOf('--run-dir');
   const startIdxIdx = args.indexOf('--start-index');
-  // const executorIdx = args.indexOf('--executor');
+  const pipelineBranchIdx = args.indexOf('--pipeline-branch');
   
   const runDir = runDirIdx >= 0 ? args[runDirIdx + 1]! : '.';
   const startIndex = startIdxIdx >= 0 ? parseInt(args[startIdxIdx + 1] || '0') : 0;
-  // const executor = executorIdx >= 0 ? args[executorIdx + 1] : 'cursor-agent';
+  const forcedPipelineBranch = pipelineBranchIdx >= 0 ? args[pipelineBranchIdx + 1] : null;
+
+  // Extract runId from runDir (format: .../runs/run-123/lanes/lane-name)
+  const parts = runDir.split(path.sep);
+  const runsIdx = parts.lastIndexOf('runs');
+  const runId = runsIdx >= 0 && parts[runsIdx + 1] ? parts[runsIdx + 1]! : `run-${Date.now()}`;
+  
+  events.setRunId(runId);
+
+  // Load global config to register webhooks in this process
+  try {
+    const globalConfig = loadConfig();
+    if (globalConfig.webhooks) {
+      registerWebhooks(globalConfig.webhooks);
+    }
+  } catch (e) {
+    // Non-blocking
+  }
   
   if (!fs.existsSync(tasksFile)) {
     console.error(`Tasks file not found: ${tasksFile}`);
@@ -762,6 +875,9 @@ if (require.main === module) {
   let config: RunnerConfig;
   try {
     config = JSON.parse(fs.readFileSync(tasksFile, 'utf8')) as RunnerConfig;
+    if (forcedPipelineBranch) {
+      config.pipelineBranch = forcedPipelineBranch;
+    }
   } catch (error: any) {
     console.error(`Failed to load tasks file: ${error.message}`);
     process.exit(1);

package/src/utils/config.ts

@@ -73,6 +73,21 @@ export function loadConfig(projectRoot: string | null = null): CursorFlowConfig
     worktreePrefix: 'cursorflow-',
     maxConcurrentLanes: 10,
     
+    // Webhooks
+    webhooks: [],
+    
+    // Enhanced logging
+    enhancedLogging: {
+      enabled: true,
+      stripAnsi: true,
+      addTimestamps: true,
+      maxFileSize: 50 * 1024 * 1024, // 50MB
+      maxFiles: 5,
+      keepRawLogs: true,
+      writeJsonLog: true,
+      timestampFormat: 'iso',
+    },
+    
     // Internal
     projectRoot,
   };
@@ -179,6 +194,27 @@ export function createDefaultConfig(projectRoot: string, force = false): string
   // Advanced
   worktreePrefix: 'cursorflow-',
   maxConcurrentLanes: 10,
+
+  // Webhook configuration
+  // webhooks: [
+  //   {
+  //     enabled: true,
+  //     url: 'https://api.example.com/events',
+  //     events: ['*'],
+  //   }
+  // ],
+
+  // Enhanced logging configuration
+  enhancedLogging: {
+    enabled: true,           // Enable enhanced logging features
+    stripAnsi: true,         // Strip ANSI codes for clean logs
+    addTimestamps: true,     // Add timestamps to each line
+    maxFileSize: 52428800,   // 50MB max file size before rotation
+    maxFiles: 5,             // Number of rotated files to keep
+    keepRawLogs: true,       // Keep raw logs with ANSI codes
+    writeJsonLog: true,      // Write structured JSON logs
+    timestampFormat: 'iso',  // 'iso' | 'relative' | 'short'
+  },
 };
 `;