@cmdctrl/cursor-cli 0.1.1

package/src/adapter/cursor-cli.ts

@@ -0,0 +1,370 @@
+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';
+
+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;
+  }
+
+  const home = os.homedir();
+  const commonPaths = [
+    path.join(home, '.cursor', 'bin', 'cursor-agent'),
+    path.join(home, '.local', 'bin', 'cursor-agent'),
+    '/usr/local/bin/cursor-agent',
+    '/opt/homebrew/bin/cursor-agent',
+    'cursor-agent' // Fall back to PATH
+  ];
+
+  for (const p of commonPaths) {
+    if (p === 'cursor-agent') return p; // PATH fallback
+    try {
+      if (fs.existsSync(p)) {
+        return p;
+      }
+    } catch {
+      continue;
+    }
+  }
+
+  return 'cursor-agent'; // Fall back to PATH
+}
+
+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;
+}
+
+type EventCallback = (
+  taskId: string,
+  eventType: string,
+  data: Record<string, unknown>
+) => void;
+
+export class CursorAdapter {
+  private running: Map<string, RunningTask> = new Map();
+  private onEvent: EventCallback;
+
+  constructor(onEvent: EventCallback) {
+    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)}...`);
+
+    const rt: RunningTask = {
+      taskId,
+      sessionId: '',
+      question: '',
+      context: '',
+      process: 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();
+      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'}`);
+
+    // Spawn Cursor CLI
+    const proc = spawn(CLI_PATH, args, {
+      cwd,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: {
+        ...process.env,
+        // Pass through Cursor API key if set
+        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}`);
+
+    const rt: RunningTask = {
+      taskId,
+      sessionId,
+      question: '',
+      context: '',
+      process: 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'}`);
+
+    // Spawn Cursor CLI
+    const proc = spawn(CLI_PATH, args, {
+      cwd,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: {
+        ...process.env,
+        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);
+  }
+
+  /**
+   * 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);
+    }
+
+    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);
+      }
+    }
+    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
+    });
+
+    // 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);
+      } catch {
+        // Not valid JSON, skip
+      }
+    });
+
+    // 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);
+      }
+      this.running.delete(taskId);
+    });
+
+    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
+   */
+  private handleStreamEvent(
+    taskId: string,
+    event: StreamEvent,
+    rt: RunningTask
+  ): void {
+    switch (event.type) {
+      case 'start':
+        if (event.session_id) {
+          rt.sessionId = event.session_id;
+          console.log(`[${taskId}] Session initialized: ${event.session_id}`);
+        }
+        break;
+
+      case 'thinking':
+        // Accumulate thinking content for context
+        if (event.content) {
+          if (rt.context) {
+            rt.context += '\n\n';
+          }
+          rt.context += event.content;
+        }
+        break;
+
+      case 'action':
+        // Track action for progress
+        const progress = extractProgressFromAction(event);
+        if (progress) {
+          this.onEvent(taskId, 'PROGRESS', {
+            action: progress.action,
+            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 || ''
+        });
+        break;
+
+      case 'error':
+        // Error occurred
+        console.error(`[${taskId}] Error: ${event.error}`);
+        this.onEvent(taskId, 'ERROR', {
+          error: event.error || 'Unknown error'
+        });
+        break;
+    }
+  }
+}

package/src/adapter/events.ts

@@ -0,0 +1,77 @@
+/**
+ * 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
+ */
+
+export interface StreamEvent {
+  type: 'start' | 'thinking' | 'action' | 'approval_request' | 'action_complete' | 'result' | 'error';
+  session_id?: string;
+  timestamp?: string;
+  content?: string;
+  tool?: string;
+  file?: string;
+  diff?: string;
+  action?: string;
+  status?: string;
+  error?: string;
+}
+
+export interface ApprovalRequest {
+  action: string;
+  tool: string;
+  file?: string;
+  command?: string;
+  description?: string;
+}
+
+export interface ProgressInfo {
+  action: string;
+  target: string;
+}
+
+/**
+ * Extract progress info from action event
+ */
+export function extractProgressFromAction(event: StreamEvent): ProgressInfo | null {
+  if (event.type !== 'action' || !event.tool) {
+    return null;
+  }
+
+  switch (event.tool) {
+    case 'file_read':
+      return {
+        action: 'Reading',
+        target: event.file || 'file'
+      };
+    case 'file_write':
+    case 'file_edit':
+      return {
+        action: 'Editing',
+        target: event.file || 'file'
+      };
+    case 'shell':
+    case 'terminal':
+      const cmd = event.content || '';
+      return {
+        action: 'Running',
+        target: cmd.length > 30 ? cmd.substring(0, 30) + '...' : cmd
+      };
+    case 'search':
+    case 'grep':
+      return {
+        action: 'Searching',
+        target: event.content || 'files'
+      };
+    case 'web_search':
+      return {
+        action: 'Searching web',
+        target: event.content || ''
+      };
+    default:
+      return {
+        action: event.tool,
+        target: event.file || event.content || ''
+      };
+  }
+}

package/src/client/messages.ts

@@ -0,0 +1,75 @@
+/**
+ * Message types for daemon <-> server communication
+ */
+
+// Server -> Daemon messages
+
+export interface PingMessage {
+  type: 'ping';
+}
+
+export interface TaskStartMessage {
+  type: 'task_start';
+  task_id: string;
+  instruction: string;
+  project_path?: string;
+}
+
+export interface TaskResumeMessage {
+  type: 'task_resume';
+  task_id: string;
+  session_id: string;
+  message: string;
+  project_path?: string;
+}
+
+export interface TaskCancelMessage {
+  type: 'task_cancel';
+  task_id: string;
+}
+
+export interface VersionStatusMessage {
+  type: 'version_status';
+  status: 'current' | 'update_available' | 'update_required';
+  your_version: string;
+  min_version?: string;
+  recommended_version?: string;
+  latest_version?: string;
+  changelog_url?: string;
+  message?: string;
+}
+
+export type ServerMessage =
+  | PingMessage
+  | TaskStartMessage
+  | TaskResumeMessage
+  | TaskCancelMessage
+  | VersionStatusMessage;
+
+// Daemon -> Server messages
+
+export interface PongMessage {
+  type: 'pong';
+}
+
+export interface StatusMessage {
+  type: 'status';
+  running_tasks: string[];
+}
+
+export interface EventMessage {
+  type: 'event';
+  task_id: string;
+  event_type: string;
+  [key: string]: unknown;
+}
+
+export type DaemonMessage = PongMessage | StatusMessage | EventMessage;
+
+// Event types sent from daemon to server
+export type EventType =
+  | 'WAIT_FOR_USER'
+  | 'TASK_COMPLETE'
+  | 'OUTPUT'
+  | 'PROGRESS'
+  | 'ERROR';