dr-claw 1.1.2

package/server/cursor-cli.js

@@ -0,0 +1,340 @@
+import { spawn } from 'child_process';
+import crossSpawn from 'cross-spawn';
+import { resolveCursorCliCommand } from './utils/cursorCommand.js';
+import { applyStageTagsToSession, recordIndexedSession } from './utils/sessionIndex.js';
+
+// Use cross-spawn on Windows for better command execution
+const spawnFunction = process.platform === 'win32' ? crossSpawn : spawn;
+
+let activeCursorProcesses = new Map(); // Track active processes by session ID
+
+async function spawnCursor(command, options = {}, ws) {
+  return new Promise(async (resolve, reject) => {
+    const { sessionId, projectPath, cwd, resume, toolsSettings, skipPermissions, model, images, sessionMode, stageTagKeys, stageTagSource = 'task_context', env } = options;
+    let capturedSessionId = sessionId; // Track session ID throughout the process
+    let sessionCreatedSent = false; // Track if we've already sent session-created event
+    let messageBuffer = ''; // Buffer for accumulating assistant messages
+    
+    // Use tools settings passed from frontend, or defaults
+    const settings = toolsSettings || {
+      allowedShellCommands: [],
+      skipPermissions: false
+    };
+    
+    // Build Cursor CLI command
+    const args = [];
+    
+    // Build flags allowing both resume and prompt together (reply in existing session)
+    // Treat presence of sessionId as intention to resume, regardless of resume flag
+    if (sessionId) {
+      args.push('--resume=' + sessionId);
+    }
+
+    if (command && command.trim()) {
+      // Provide a prompt (works for both new and resumed sessions)
+      args.push('-p', command);
+
+      // Add model flag if specified (only meaningful for new sessions; harmless on resume)
+      if (!sessionId && model) {
+        args.push('--model', model);
+      }
+
+      // Request streaming JSON when we are providing a prompt
+      args.push('--output-format', 'stream-json');
+    }
+    
+    // Always trust the workspace directory since the user explicitly chose it
+    args.push('--trust');
+
+    // Add skip permissions flag if enabled
+    if (skipPermissions || settings.skipPermissions) {
+      args.push('-f');
+      console.log('⚠️  Using -f flag (skip permissions)');
+    }
+    
+    // Use cwd (actual project directory) instead of projectPath
+    const workingDir = cwd || projectPath || process.cwd();
+    const cursorCommand = resolveCursorCliCommand();
+
+    // Synchronous (better-sqlite3) — no await needed.
+    if (sessionId && workingDir) {
+      applyStageTagsToSession({
+        sessionId,
+        projectPath: workingDir,
+        stageTagKeys,
+        source: stageTagSource,
+      });
+    }
+
+    if (!cursorCommand) {
+      const errorMessage = 'Cursor CLI not found. Install Cursor CLI or set CURSOR_CLI_PATH to `agent` or `cursor-agent`.';
+      ws.send({
+        type: 'cursor-error',
+        error: errorMessage,
+        sessionId: capturedSessionId || sessionId || null
+      });
+      reject(new Error(errorMessage));
+      return;
+    }
+    
+    console.log('Spawning Cursor CLI:', cursorCommand, args.join(' '));
+    console.log('Working directory:', workingDir);
+    console.log('Session info - Input sessionId:', sessionId, 'Resume:', resume);
+    
+    const cursorProcess = spawnFunction(cursorCommand, args, {
+      cwd: workingDir,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...(env || process.env) }
+    });
+    
+    // Store process reference for potential abort
+    const processKey = capturedSessionId || Date.now().toString();
+    activeCursorProcesses.set(processKey, {
+      process: cursorProcess,
+      startTime: Date.now()
+    });
+    
+    const getSessionStartTime = () => {
+      const sessionData = activeCursorProcesses.get(capturedSessionId || processKey);
+      return sessionData?.startTime;
+    };
+
+    // Handle stdout (streaming JSON responses)
+    cursorProcess.stdout.on('data', (data) => {
+      const rawOutput = data.toString();
+      console.log('📤 Cursor CLI stdout:', rawOutput);
+      
+      const lines = rawOutput.split('\n').filter(line => line.trim());
+      
+      for (const line of lines) {
+        try {
+          const response = JSON.parse(line);
+          console.log('📄 Parsed JSON response:', response);
+          
+          // Handle different message types
+          switch (response.type) {
+            case 'system':
+              if (response.subtype === 'init') {
+                // Capture session ID
+                if (response.session_id && !capturedSessionId) {
+                  capturedSessionId = response.session_id;
+                  console.log('📝 Captured session ID:', capturedSessionId);
+                  
+                  // Update process key with captured session ID
+                  if (processKey !== capturedSessionId) {
+                    const sessionData = activeCursorProcesses.get(processKey);
+                    if (sessionData) {
+                      activeCursorProcesses.delete(processKey);
+                      sessionData.sessionId = capturedSessionId;
+                      activeCursorProcesses.set(capturedSessionId, sessionData);
+                    } else {
+                      // Fallback if somehow not found
+                      activeCursorProcesses.set(capturedSessionId, {
+                        process: cursorProcess,
+                        startTime: Date.now()
+                      });
+                    }
+                  }
+                  
+                  // Set session ID on writer (for API endpoint compatibility)
+                  if (ws.setSessionId && typeof ws.setSessionId === 'function') {
+                    ws.setSessionId(capturedSessionId);
+                  }
+
+                  // Send session-created event only once for new sessions
+                  if (!sessionId && !sessionCreatedSent) {
+                    sessionCreatedSent = true;
+                    recordIndexedSession({
+                      sessionId: capturedSessionId,
+                      provider: 'cursor',
+                      projectPath: workingDir,
+                      sessionMode: sessionMode || 'research',
+                      displayName: response.session_title || response.title || null,
+                      stageTagKeys,
+                      tagSource: stageTagSource,
+                    });
+                    ws.send({
+                      type: 'session-created',
+                      sessionId: capturedSessionId,
+                      model: response.model,
+                      cwd: response.cwd,
+                      mode: sessionMode || 'research',
+                      startTime: getSessionStartTime()
+                    });
+                  }
+                }
+                
+                // Send system info to frontend
+                ws.send({
+                  type: 'cursor-system',
+                  data: response,
+                  sessionId: capturedSessionId || sessionId || null,
+                  startTime: getSessionStartTime()
+                });
+              }
+              break;
+              
+            case 'user':
+              // Forward user message
+              ws.send({
+                type: 'cursor-user',
+                data: response,
+                sessionId: capturedSessionId || sessionId || null,
+                startTime: getSessionStartTime()
+              });
+              break;
+              
+            case 'assistant':
+              // Accumulate assistant message chunks
+              if (response.message && response.message.content && response.message.content.length > 0) {
+                const textContent = response.message.content[0].text;
+                messageBuffer += textContent;
+                
+                // Send as Claude-compatible format for frontend
+                ws.send({
+                  type: 'claude-response',
+                  data: {
+                    type: 'content_block_delta',
+                    startTime: getSessionStartTime(),
+                    delta: {
+                      type: 'text_delta',
+                      text: textContent
+                    }
+                  },
+                  sessionId: capturedSessionId || sessionId || null
+                });
+              }
+              break;
+              
+            case 'result':
+              // Session complete
+              console.log('Cursor session result:', response);
+              
+              // Send final message if we have buffered content
+              if (messageBuffer) {
+                ws.send({
+                  type: 'claude-response',
+                  data: {
+                    type: 'content_block_stop',
+                    startTime: getSessionStartTime(),
+                  },
+                  sessionId: capturedSessionId || sessionId || null
+                });
+              }
+              
+              // Send completion event
+              ws.send({
+                type: 'cursor-result',
+                sessionId: capturedSessionId || sessionId,
+                data: response,
+                success: response.subtype === 'success',
+                startTime: getSessionStartTime(),
+              });
+              break;
+              
+            default:
+              // Forward any other message types
+              ws.send({
+                type: 'cursor-response',
+                data: response,
+                sessionId: capturedSessionId || sessionId || null,
+                startTime: getSessionStartTime(),
+              });
+          }
+        } catch (parseError) {
+          console.log('📄 Non-JSON response:', line);
+          // If not JSON, send as raw text
+          ws.send({
+            type: 'cursor-output',
+            data: line,
+            sessionId: capturedSessionId || sessionId || null,
+            startTime: getSessionStartTime()
+          });
+        }
+      }
+    });
+    
+    // Handle stderr
+    cursorProcess.stderr.on('data', (data) => {
+      console.error('Cursor CLI stderr:', data.toString());
+      ws.send({
+        type: 'cursor-error',
+        error: data.toString(),
+        sessionId: capturedSessionId || sessionId || null
+      });
+    });
+    
+    // Handle process completion
+    cursorProcess.on('close', async (code) => {
+      console.log(`Cursor CLI process exited with code ${code}`);
+      
+      // Clean up process reference
+      const finalSessionId = capturedSessionId || sessionId || processKey;
+      ws.send({
+        type: 'claude-complete',
+        sessionId: finalSessionId,
+        exitCode: code,
+        isNewSession: !sessionId && !!command // Flag to indicate this was a new session
+      });
+      activeCursorProcesses.delete(finalSessionId);
+      
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Cursor CLI exited with code ${code}`));
+      }
+    });
+    
+    // Handle process errors
+    cursorProcess.on('error', (error) => {
+      console.error('Cursor CLI process error:', error);
+      
+      // Clean up process reference on error
+      const finalSessionId = capturedSessionId || sessionId || processKey;
+      activeCursorProcesses.delete(finalSessionId);
+
+      ws.send({
+        type: 'cursor-error',
+        error: error.message,
+        sessionId: capturedSessionId || sessionId || null
+      });
+
+      reject(error);
+    });
+    
+    // Close stdin since Cursor doesn't need interactive input
+    cursorProcess.stdin.end();
+  });
+}
+
+function abortCursorSession(sessionId) {
+  const sessionData = activeCursorProcesses.get(sessionId);
+  if (sessionData && sessionData.process) {
+    console.log(`🛑 Aborting Cursor session: ${sessionId}`);
+    sessionData.process.kill('SIGTERM');
+    activeCursorProcesses.delete(sessionId);
+    return true;
+  }
+  return false;
+}
+
+function isCursorSessionActive(sessionId) {
+  return activeCursorProcesses.has(sessionId);
+}
+
+function getCursorSessionStartTime(sessionId) {
+  const sessionData = activeCursorProcesses.get(sessionId);
+  return sessionData ? sessionData.startTime : null;
+}
+
+function getActiveCursorSessions() {
+  return Array.from(activeCursorProcesses.keys());
+}
+
+export {
+  spawnCursor,
+  abortCursorSession,
+  isCursorSessionActive,
+  getCursorSessionStartTime,
+  getActiveCursorSessions
+};