@cmdctrl/cursor-cli 0.1.1 → 0.2.0

package/src/adapter/cursor-cli.ts

@@ -1,13 +1,23 @@
+/**
+ * Cursor CLI Adapter
+ *
+ * Spawns cursor-agent in headless mode with --output-format stream-json
+ * and translates the NDJSON event stream into CmdCtrl daemon events.
+ *
+ * Cursor CLI commands:
+ *   New session:    cursor-agent -p "instruction" --output-format stream-json
+ *   Resume session: cursor-agent --resume=<session-id> -p "message" --output-format stream-json
+ */
+
 import { spawn, ChildProcess } from 'child_process';
 import * as readline from 'readline';
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
-import { StreamEvent, extractProgressFromAction } from './events';
+import { StreamEvent, extractProgressFromToolCall } from './events';
 
 const DEFAULT_TIMEOUT = 10 * 60 * 1000; // 10 minutes
 
-// Find cursor-agent CLI in common locations
 function findCursorCli(): string {
   if (process.env.CURSOR_CLI_PATH) {
     return process.env.CURSOR_CLI_PATH;
@@ -15,34 +25,28 @@ function findCursorCli(): string {
 
   const home = os.homedir();
   const commonPaths = [
-    path.join(home, '.cursor', 'bin', 'cursor-agent'),
     path.join(home, '.local', 'bin', 'cursor-agent'),
+    path.join(home, '.cursor', 'bin', 'cursor-agent'),
     '/usr/local/bin/cursor-agent',
     '/opt/homebrew/bin/cursor-agent',
-    'cursor-agent' // Fall back to PATH
+    'cursor-agent'
   ];
 
   for (const p of commonPaths) {
-    if (p === 'cursor-agent') return p; // PATH fallback
+    if (p === 'cursor-agent') return p;
     try {
-      if (fs.existsSync(p)) {
-        return p;
-      }
+      if (fs.existsSync(p)) return p;
     } catch {
       continue;
     }
   }
 
-  return 'cursor-agent'; // Fall back to PATH
+  return 'cursor-agent';
 }
 
-const CLI_PATH = findCursorCli();
-console.log(`[CursorAdapter] Using CLI path: ${CLI_PATH}`);
-
 interface RunningTask {
   taskId: string;
   sessionId: string;
-  question: string;
   context: string;
   process: ChildProcess | null;
   timeoutHandle: NodeJS.Timeout | null;
@@ -62,199 +66,170 @@ export class CursorAdapter {
     this.onEvent = onEvent;
   }
 
-  /**
-   * Start a new task
-   */
   async startTask(
     taskId: string,
     instruction: string,
     projectPath?: string
   ): Promise<void> {
-    console.log(`[${taskId}] Starting task: ${instruction.substring(0, 50)}...`);
+    console.log(`[${taskId}] Starting Cursor task: ${instruction.substring(0, 50)}...`);
 
     const rt: RunningTask = {
       taskId,
       sessionId: '',
-      question: '',
       context: '',
       process: null,
-      timeoutHandle: null
+      timeoutHandle: null,
     };
-
     this.running.set(taskId, rt);
 
-    // Validate cwd exists
     let cwd: string | undefined = undefined;
     if (projectPath && fs.existsSync(projectPath)) {
       cwd = projectPath;
     } else if (projectPath) {
-      console.log(`[${taskId}] Warning: project path does not exist: ${projectPath}, using home dir`);
+      console.log(`[${taskId}] Warning: project path does not exist: ${projectPath}`);
       cwd = os.homedir();
-      this.onEvent(taskId, 'WARNING', {
-        warning: `Project path "${projectPath}" does not exist. Running in home directory instead.`
-      });
     }
 
-    // Build command arguments for Cursor CLI
-    // cursor-agent -p "instruction" --output-format stream-json
     const args = [
       '-p', instruction,
       '--output-format', 'stream-json'
     ];
 
-    console.log(`[${taskId}] Spawning: ${CLI_PATH} with cwd: ${cwd || 'default'}`);
+    console.log(`[${taskId}] Spawning: ${findCursorCli()} with cwd: ${cwd || 'default'}`);
 
-    // Spawn Cursor CLI
-    const proc = spawn(CLI_PATH, args, {
+    const proc = spawn(findCursorCli(), args, {
       cwd,
       stdio: ['ignore', 'pipe', 'pipe'],
       env: {
         ...process.env,
-        // Pass through Cursor API key if set
-        CURSOR_API_KEY: process.env.CURSOR_API_KEY
-      }
+        CURSOR_API_KEY: process.env.CURSOR_API_KEY,
+      },
     });
 
     rt.process = proc;
-
-    // Set timeout
     rt.timeoutHandle = setTimeout(() => {
       console.log(`[${taskId}] Task timed out`);
       proc.kill('SIGKILL');
       this.onEvent(taskId, 'ERROR', { error: 'execution timeout' });
     }, DEFAULT_TIMEOUT);
 
-    // Handle process events
     this.handleProcessOutput(taskId, proc, rt);
   }
 
-  /**
-   * Resume a task with user's reply
-   */
   async resumeTask(
     taskId: string,
     sessionId: string,
     message: string,
     projectPath?: string
   ): Promise<void> {
-    console.log(`[${taskId}] Resuming task with session ${sessionId}`);
+    console.log(`[${taskId}] Resuming Cursor session ${sessionId}: ${message.substring(0, 50)}...`);
 
     const rt: RunningTask = {
       taskId,
       sessionId,
-      question: '',
       context: '',
       process: null,
-      timeoutHandle: null
+      timeoutHandle: null,
     };
-
     this.running.set(taskId, rt);
 
-    // Validate cwd exists
     let cwd: string | undefined = undefined;
     if (projectPath && fs.existsSync(projectPath)) {
       cwd = projectPath;
     } else if (projectPath) {
-      console.log(`[${taskId}] Warning: project path does not exist: ${projectPath}, using home dir`);
       cwd = os.homedir();
     }
 
-    // Build command arguments with --resume
-    // cursor-agent --resume="session-id" -p "user response" --output-format stream-json
     const args = [
       `--resume=${sessionId}`,
       '-p', message,
       '--output-format', 'stream-json'
     ];
 
-    console.log(`[${taskId}] Spawning resume: ${CLI_PATH} --resume=${sessionId} with cwd: ${cwd || 'default'}`);
+    console.log(`[${taskId}] Spawning resume: cursor-agent --resume ${sessionId}`);
 
-    // Spawn Cursor CLI
-    const proc = spawn(CLI_PATH, args, {
+    const proc = spawn(findCursorCli(), args, {
       cwd,
       stdio: ['ignore', 'pipe', 'pipe'],
       env: {
         ...process.env,
-        CURSOR_API_KEY: process.env.CURSOR_API_KEY
-      }
+        CURSOR_API_KEY: process.env.CURSOR_API_KEY,
+      },
     });
 
     rt.process = proc;
 
-    // Set timeout
+    let sessionNotFound = false;
+
+    proc.stderr?.on('data', (data) => {
+      const text = data.toString();
+      console.log(`[${taskId}] stderr: ${text}`);
+      if (text.includes('not found') || text.includes('No session') || text.includes('invalid session')) {
+        sessionNotFound = true;
+      }
+    });
+
+    proc.on('close', (code) => {
+      if (code !== 0 && sessionNotFound) {
+        console.log(`[${taskId}] Session not found, falling back to new session`);
+        if (rt.timeoutHandle) clearTimeout(rt.timeoutHandle);
+        this.running.delete(taskId);
+        this.startTask(taskId, message, projectPath);
+        return;
+      }
+      console.log(`[${taskId}] Process exited with code ${code}`);
+      if (rt.timeoutHandle) clearTimeout(rt.timeoutHandle);
+      if (this.running.has(taskId) && code === 0) {
+        this.onEvent(taskId, 'TASK_COMPLETE', {
+          session_id: rt.sessionId,
+          result: rt.context || '',
+        });
+      }
+      this.running.delete(taskId);
+    });
+
     rt.timeoutHandle = setTimeout(() => {
       console.log(`[${taskId}] Task timed out`);
       proc.kill('SIGKILL');
       this.onEvent(taskId, 'ERROR', { error: 'execution timeout' });
     }, DEFAULT_TIMEOUT);
 
-    // Handle process events
-    this.handleProcessOutput(taskId, proc, rt);
+    this.handleProcessOutputWithoutClose(taskId, proc, rt);
   }
 
-  /**
-   * Cancel a running task
-   */
   async cancelTask(taskId: string): Promise<void> {
     const rt = this.running.get(taskId);
-    if (!rt) {
-      console.log(`[${taskId}] Task not found for cancellation`);
-      return;
-    }
-
-    if (rt.process) {
-      rt.process.kill('SIGTERM');
-    }
-    if (rt.timeoutHandle) {
-      clearTimeout(rt.timeoutHandle);
-    }
-
+    if (!rt) return;
+    if (rt.process) rt.process.kill('SIGTERM');
+    if (rt.timeoutHandle) clearTimeout(rt.timeoutHandle);
     this.running.delete(taskId);
     console.log(`[${taskId}] Task cancelled`);
   }
 
-  /**
-   * Stop all running tasks
-   */
   async stopAll(): Promise<void> {
     for (const [taskId, rt] of this.running) {
       console.log(`[${taskId}] Stopping task`);
-      if (rt.process) {
-        rt.process.kill('SIGTERM');
-      }
-      if (rt.timeoutHandle) {
-        clearTimeout(rt.timeoutHandle);
-      }
+      if (rt.process) rt.process.kill('SIGTERM');
+      if (rt.timeoutHandle) clearTimeout(rt.timeoutHandle);
     }
     this.running.clear();
   }
 
-  /**
-   * Get list of running task IDs
-   */
   getRunningTasks(): string[] {
     return Array.from(this.running.keys());
   }
 
-  /**
-   * Handle process stdout/stderr and emit events
-   */
   private handleProcessOutput(
     taskId: string,
     proc: ChildProcess,
     rt: RunningTask
   ): void {
-    // Create readline interface for NDJSON parsing
     const rl = readline.createInterface({
       input: proc.stdout!,
-      crlfDelay: Infinity
+      crlfDelay: Infinity,
     });
 
-    // Parse each line as JSON
     rl.on('line', (line) => {
-      // Emit raw output for verbose mode
-      this.onEvent(taskId, 'OUTPUT', { output: line });
-
       try {
         const event = JSON.parse(line) as StreamEvent;
         this.handleStreamEvent(taskId, event, rt);
@@ -263,17 +238,16 @@ export class CursorAdapter {
       }
     });
 
-    // Log stderr
     proc.stderr?.on('data', (data) => {
       console.log(`[${taskId}] stderr: ${data.toString()}`);
     });
 
-    // Handle process exit
     proc.on('close', (code) => {
       console.log(`[${taskId}] Process exited with code ${code}`);
-
-      if (rt.timeoutHandle) {
-        clearTimeout(rt.timeoutHandle);
+      if (rt.timeoutHandle) clearTimeout(rt.timeoutHandle);
+      // Emit error if process exited non-zero and we haven't already emitted a result
+      if (this.running.has(taskId) && code !== 0) {
+        this.onEvent(taskId, 'ERROR', { error: `cursor-agent exited with code ${code}` });
       }
       this.running.delete(taskId);
     });
@@ -281,90 +255,134 @@ export class CursorAdapter {
     proc.on('error', (err) => {
       console.error(`[${taskId}] Process error:`, err);
       this.onEvent(taskId, 'ERROR', { error: err.message });
+      if (rt.timeoutHandle) clearTimeout(rt.timeoutHandle);
+      this.running.delete(taskId);
+    });
+  }
+
+  private handleProcessOutputWithoutClose(
+    taskId: string,
+    proc: ChildProcess,
+    rt: RunningTask
+  ): void {
+    const rl = readline.createInterface({
+      input: proc.stdout!,
+      crlfDelay: Infinity,
+    });
 
-      if (rt.timeoutHandle) {
-        clearTimeout(rt.timeoutHandle);
+    rl.on('line', (line) => {
+      try {
+        const event = JSON.parse(line) as StreamEvent;
+        this.handleStreamEvent(taskId, event, rt);
+      } catch {
+        // skip
       }
+    });
+
+    proc.on('error', (err) => {
+      console.error(`[${taskId}] Process error:`, err);
+      this.onEvent(taskId, 'ERROR', { error: err.message });
+      if (rt.timeoutHandle) clearTimeout(rt.timeoutHandle);
       this.running.delete(taskId);
     });
   }
 
   /**
-   * Handle a parsed stream event from Cursor CLI
+   * Handle a parsed stream event from cursor-agent and translate to CmdCtrl events.
+   *
+   * cursor-agent events → CmdCtrl events:
+   *   system (init)        → SESSION_STARTED
+   *   user                 → (ignored, echo of input)
+   *   thinking (delta)     → (accumulate context)
+   *   thinking (completed) → (ignored)
+   *   assistant            → OUTPUT
+   *   tool_call            → PROGRESS
+   *   tool_result          → OUTPUT (verbose)
+   *   result (success)     → TASK_COMPLETE
+   *   result (error)       → ERROR
    */
   private handleStreamEvent(
     taskId: string,
     event: StreamEvent,
     rt: RunningTask
   ): void {
+    console.log(`[${taskId}] Cursor event: type=${event.type} subtype=${event.subtype || ''}`);
+
     switch (event.type) {
-      case 'start':
-        if (event.session_id) {
+      case 'system':
+        if (event.subtype === 'init' && event.session_id) {
           rt.sessionId = event.session_id;
-          console.log(`[${taskId}] Session initialized: ${event.session_id}`);
+          console.log(`[${taskId}] Session initialized: ${event.session_id} (model: ${event.model})`);
+          this.onEvent(taskId, 'SESSION_STARTED', {
+            session_id: event.session_id,
+          });
         }
         break;
 
+      case 'user':
+        // Echo of user input, ignore
+        break;
+
       case 'thinking':
-        // Accumulate thinking content for context
-        if (event.content) {
-          if (rt.context) {
-            rt.context += '\n\n';
+        // Accumulate thinking text but don't send as output (too noisy with deltas)
+        if (event.subtype === 'delta' && event.text) {
+          rt.context += event.text;
+        }
+        break;
+
+      case 'assistant':
+        if (event.message?.content) {
+          const text = event.message.content
+            .map(block => block.text || '')
+            .join('')
+            .trim();
+          if (text) {
+            // Reset context to assistant response (thinking was intermediate)
+            rt.context = text;
+            this.onEvent(taskId, 'OUTPUT', { output: text });
           }
-          rt.context += event.content;
         }
         break;
 
-      case 'action':
-        // Track action for progress
-        const progress = extractProgressFromAction(event);
+      case 'tool_call': {
+        const progress = extractProgressFromToolCall(event);
         if (progress) {
           this.onEvent(taskId, 'PROGRESS', {
             action: progress.action,
-            target: progress.target
+            target: progress.target,
           });
         }
         break;
+      }
 
-      case 'approval_request':
-        // User input needed - pause and wait
-        console.log(`[${taskId}] Approval requested: ${event.action}`);
-        rt.question = event.action || 'Approve this action?';
-
-        this.onEvent(taskId, 'WAIT_FOR_USER', {
-          session_id: rt.sessionId,
-          prompt: rt.question,
-          options: [],
-          context: rt.context,
-          approval_details: {
-            action: event.action,
-            tool: event.tool,
-            file: event.file
-          }
-        });
-        break;
-
-      case 'action_complete':
-        // Action was approved and completed
-        console.log(`[${taskId}] Action complete: ${event.status}`);
-        break;
-
-      case 'result':
-        // Task completed
-        console.log(`[${taskId}] Task completed`);
-        this.onEvent(taskId, 'TASK_COMPLETE', {
-          session_id: rt.sessionId,
-          result: event.content || ''
-        });
+      case 'tool_result':
+        if (event.output) {
+          const truncated = event.output.length > 500
+            ? event.output.substring(0, 500) + '...'
+            : event.output;
+          this.onEvent(taskId, 'OUTPUT', {
+            output: `[${event.status || 'done'}] ${truncated}`,
+          });
+        }
         break;
 
-      case 'error':
-        // Error occurred
-        console.error(`[${taskId}] Error: ${event.error}`);
-        this.onEvent(taskId, 'ERROR', {
-          error: event.error || 'Unknown error'
-        });
+      case 'result': {
+        if (event.is_error || event.subtype === 'error') {
+          console.error(`[${taskId}] Cursor error: ${event.result}`);
+          this.onEvent(taskId, 'ERROR', {
+            error: event.result || 'Unknown Cursor error',
+          });
+        } else {
+          const finalResult = event.result || rt.context || '';
+          console.log(`[${taskId}] Task complete, result length: ${finalResult.length}`);
+          this.onEvent(taskId, 'TASK_COMPLETE', {
+            session_id: rt.sessionId,
+            result: finalResult,
+          });
+        }
+        this.running.delete(taskId);
         break;
+      }
     }
   }
 }

package/src/adapter/events.ts

@@ -1,28 +1,46 @@
 /**
- * Types for Cursor CLI stream-json output
- * Note: These are based on research and may need adjustment
- * once we verify actual Cursor CLI output format
+ * Types for Cursor CLI (cursor-agent) stream-json output.
+ *
+ * cursor-agent --output-format stream-json emits NDJSON events:
+ *   system    (subtype: init)      - Session metadata (session_id, model, cwd)
+ *   user                           - Echo of user message
+ *   thinking  (subtype: delta)     - Streaming thinking text chunks
+ *   thinking  (subtype: completed) - Thinking finished
+ *   assistant                      - Assistant response message
+ *   tool_call                      - Tool invocation (file edit, shell, etc.)
+ *   tool_result                    - Tool execution result
+ *   result    (subtype: success)   - Final result with aggregated response
+ *   result    (subtype: error)     - Error result
  */
 
 export interface StreamEvent {
-  type: 'start' | 'thinking' | 'action' | 'approval_request' | 'action_complete' | 'result' | 'error';
+  type: 'system' | 'user' | 'thinking' | 'assistant' | 'tool_call' | 'tool_result' | 'result';
+  subtype?: string;
   session_id?: string;
-  timestamp?: string;
-  content?: string;
-  tool?: string;
-  file?: string;
-  diff?: string;
-  action?: string;
+  timestamp_ms?: number;
+  // system init fields
+  model?: string;
+  cwd?: string;
+  apiKeySource?: string;
+  permissionMode?: string;
+  // thinking delta fields
+  text?: string;
+  // assistant fields
+  message?: {
+    role: string;
+    content: Array<{ type: string; text?: string }>;
+  };
+  // tool_call fields
+  tool_name?: string;
+  tool_call_id?: string;
+  parameters?: Record<string, unknown>;
+  // tool_result fields
   status?: string;
-  error?: string;
-}
-
-export interface ApprovalRequest {
-  action: string;
-  tool: string;
-  file?: string;
-  command?: string;
-  description?: string;
+  output?: string;
+  // result fields
+  result?: string;
+  duration_ms?: number;
+  is_error?: boolean;
 }
 
 export interface ProgressInfo {
@@ -31,47 +49,43 @@ export interface ProgressInfo {
 }
 
 /**
- * Extract progress info from action event
+ * Extract progress info from a tool_call event.
  */
-export function extractProgressFromAction(event: StreamEvent): ProgressInfo | null {
-  if (event.type !== 'action' || !event.tool) {
-    return null;
-  }
+export function extractProgressFromToolCall(event: StreamEvent): ProgressInfo | null {
+  if (event.type !== 'tool_call' || !event.tool_name) return null;
+
+  const params = event.parameters || {};
 
-  switch (event.tool) {
+  switch (event.tool_name) {
     case 'file_read':
-      return {
-        action: 'Reading',
-        target: event.file || 'file'
-      };
+    case 'ReadFile':
+    case 'read_file':
+      return { action: 'Reading', target: (params.path as string) || 'file' };
     case 'file_write':
+    case 'WriteFile':
+    case 'write_file':
+      return { action: 'Writing', target: (params.path as string) || 'file' };
     case 'file_edit':
-      return {
-        action: 'Editing',
-        target: event.file || 'file'
-      };
+    case 'EditFile':
+    case 'edit_file':
+      return { action: 'Editing', target: (params.path as string) || 'file' };
     case 'shell':
     case 'terminal':
-      const cmd = event.content || '';
-      return {
-        action: 'Running',
-        target: cmd.length > 30 ? cmd.substring(0, 30) + '...' : cmd
-      };
+    case 'Shell':
+    case 'Bash': {
+      const cmd = String(params.command || '').substring(0, 40);
+      return { action: 'Running', target: cmd };
+    }
     case 'search':
     case 'grep':
-      return {
-        action: 'Searching',
-        target: event.content || 'files'
-      };
-    case 'web_search':
-      return {
-        action: 'Searching web',
-        target: event.content || ''
-      };
+    case 'GrepTool':
+    case 'SearchFiles':
+      return { action: 'Searching', target: (params.pattern as string) || (params.query as string) || 'files' };
+    case 'list_directory':
+    case 'GlobTool':
+    case 'glob':
+      return { action: 'Searching', target: (params.pattern as string) || (params.path as string) || 'files' };
     default:
-      return {
-        action: event.tool,
-        target: event.file || event.content || ''
-      };
+      return { action: event.tool_name, target: '' };
   }
 }