devbonzai 2.1.6 → 2.1.8

package/templates/handlers/prompt_agent_stream.js

@@ -0,0 +1,247 @@
+const { spawn, execSync } = require('child_process');
+const { ROOT } = require('../config');
+
+function promptAgentStreamHandler(req, res) {
+  console.log('🔵 [prompt_agent_stream] Endpoint hit');
+  const { prompt } = req.body;
+  console.log('🔵 [prompt_agent_stream] Received prompt:', prompt ? `${prompt.substring(0, 50)}...` : 'none');
+
+  if (!prompt || typeof prompt !== 'string') {
+    console.log('❌ [prompt_agent_stream] Error: prompt required');
+    return res.status(400).json({ error: 'prompt required' });
+  }
+
+  // Set up SSE headers
+  res.setHeader('Content-Type', 'text/event-stream');
+  res.setHeader('Cache-Control', 'no-cache');
+  res.setHeader('Connection', 'keep-alive');
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.flushHeaders();
+
+  // Helper to send SSE events with robustness checks
+  const sendEvent = (type, data) => {
+    try {
+      // Check if response is still writable - try to send even if clientDisconnected flag is set
+      // because the response stream might still be open
+      if (res.destroyed || res.closed) {
+        console.log(`⚠️ [prompt_agent_stream] Response already closed, cannot send ${type} event`);
+        return false;
+      }
+      res.write(`data: ${JSON.stringify({ type, ...data })}\n\n`);
+      return true;
+    } catch (e) {
+      console.log(`⚠️ [prompt_agent_stream] Error sending ${type} event:`, e.message);
+      return false;
+    }
+  };
+
+  // Capture beforeCommit
+  let beforeCommit = '';
+  try {
+    beforeCommit = execSync('git rev-parse HEAD', { cwd: ROOT }).toString().trim();
+    console.log('🔵 [prompt_agent_stream] beforeCommit:', beforeCommit);
+  } catch (e) {
+    console.log('⚠️ [prompt_agent_stream] Could not get beforeCommit:', e.message);
+  }
+
+  // Capture initial state of modified files
+  const initiallyModifiedFiles = new Set();
+  try {
+    const initialStatus = execSync('git status --short', { cwd: ROOT }).toString();
+    initialStatus.split('\n').filter(Boolean).forEach(line => {
+      const filePath = line.substring(3).trim();
+      if (filePath) initiallyModifiedFiles.add(filePath);
+    });
+  } catch (e) {
+    // Ignore
+  }
+
+  // Send starting event
+  sendEvent('start', { beforeCommit });
+
+  // Set up file change tracking with real-time updates
+  const changedFiles = new Set();
+  const pollInterval = setInterval(() => {
+    try {
+      const status = execSync('git status --short', { cwd: ROOT }).toString();
+      status.split('\n').filter(Boolean).forEach(line => {
+        const filePath = line.substring(3).trim();
+        if (filePath && !initiallyModifiedFiles.has(filePath)) {
+          if (!changedFiles.has(filePath)) {
+            changedFiles.add(filePath);
+            console.log('📁 [prompt_agent_stream] File changed:', filePath);
+            // Send real-time update to client
+            sendEvent('file_changed', { path: filePath });
+          }
+        }
+      });
+    } catch (e) {
+      // Ignore git status errors
+    }
+  }, 500);
+
+  const timeoutMs = parseInt(req.body.timeout) || 5 * 60 * 1000;
+  let timeoutId = null;
+  let responseSent = false;
+
+  const args = ['--print', '--force', '--workspace', '.', prompt];
+
+  console.log('🔵 [prompt_agent_stream] Spawning cursor-agent process...');
+  const proc = spawn(
+    'cursor-agent',
+    args,
+    {
+      cwd: ROOT,
+      env: process.env,
+      stdio: ['ignore', 'pipe', 'pipe']
+    }
+  );
+
+  console.log('🔵 [prompt_agent_stream] Process spawned, PID:', proc.pid);
+
+  let stdout = '';
+  let stderr = '';
+
+  timeoutId = setTimeout(() => {
+    if (!responseSent && proc && !proc.killed) {
+      console.log('⏱️ [prompt_agent_stream] Timeout reached');
+      clearInterval(pollInterval);
+      proc.kill('SIGTERM');
+      
+      setTimeout(() => {
+        if (!proc.killed) proc.kill('SIGKILL');
+      }, 5000);
+      
+      // Always try to send complete event when timeout occurs
+      // Only skip if we've already sent it
+      if (!responseSent) {
+        try {
+          // Check if response is still writable - try to send even if clientDisconnected flag is set
+          // because the response stream might still be open
+          if (res.destroyed || res.closed) {
+            console.log('⚠️ [prompt_agent_stream] Response already closed, cannot send timeout events');
+          } else {
+            responseSent = true;
+            sendEvent('error', {
+              error: 'Process timeout',
+              message: `cursor-agent exceeded timeout of ${timeoutMs / 1000} seconds`
+            });
+            sendEvent('complete', {
+              code: -1,
+              stdout,
+              stderr,
+              changedFiles: Array.from(changedFiles),
+              beforeCommit,
+              afterCommit: ''
+            });
+            // Send stop event after complete
+            sendEvent('stop', {});
+            res.end();
+            console.log('✅ [prompt_agent_stream] Sent timeout error, complete, and stop events');
+          }
+        } catch (e) {
+          console.log('⚠️ [prompt_agent_stream] Error sending timeout events:', e.message);
+          // Don't set responseSent = true on error, in case we can retry
+          // But realistically, if there's an error, the connection is probably dead
+        }
+      } else {
+        console.log('⚠️ [prompt_agent_stream] Timeout events already sent, skipping');
+      }
+    }
+  }, timeoutMs);
+
+  proc.stdout.on('data', (d) => {
+    stdout += d.toString();
+  });
+
+  proc.stderr.on('data', (d) => {
+    stderr += d.toString();
+  });
+
+  proc.on('error', (error) => {
+    console.log('❌ [prompt_agent_stream] Process error:', error.message);
+    clearInterval(pollInterval);
+    if (timeoutId) clearTimeout(timeoutId);
+    
+    // Always try to send error event when process error occurs
+    // Only skip if we've already sent it
+    if (!responseSent) {
+      try {
+        // Check if response is still writable - try to send even if clientDisconnected flag is set
+        // because the response stream might still be open
+        if (res.destroyed || res.closed) {
+          console.log('⚠️ [prompt_agent_stream] Response already closed, cannot send error event');
+        } else {
+          responseSent = true;
+          sendEvent('error', { error: error.message });
+          // Send stop event after error
+          sendEvent('stop', {});
+          res.end();
+          console.log('✅ [prompt_agent_stream] Sent error and stop events');
+        }
+      } catch (e) {
+        console.log('⚠️ [prompt_agent_stream] Error sending error event:', e.message);
+        // Don't set responseSent = true on error, in case we can retry
+        // But realistically, if there's an error, the connection is probably dead
+      }
+    } else {
+      console.log('⚠️ [prompt_agent_stream] Error event already sent, skipping');
+    }
+  });
+
+  proc.on('close', (code, signal) => {
+    console.log('🔵 [prompt_agent_stream] Process closed with code:', code);
+    clearInterval(pollInterval);
+    if (timeoutId) clearTimeout(timeoutId);
+    
+    let afterCommit = '';
+    try {
+      afterCommit = execSync('git rev-parse HEAD', { cwd: ROOT }).toString().trim();
+    } catch (e) {
+      // Ignore
+    }
+    
+    // Always try to send complete event when process finishes
+    // Check actual response stream state rather than relying on responseSent flag
+    // Only skip if we've already sent it (responseSent flag prevents duplicates)
+    if (!responseSent) {
+      try {
+        // Check if response is still writable - check actual stream state
+        if (res.destroyed || res.closed) {
+          console.log('⚠️ [prompt_agent_stream] Response already closed, cannot send complete event');
+        } else {
+          // Send events and only set flag after successful send
+          sendEvent('complete', {
+            code,
+            stdout,
+            stderr,
+            changedFiles: Array.from(changedFiles),
+            beforeCommit,
+            afterCommit
+          });
+          // Send stop event after complete
+          sendEvent('stop', {});
+          res.end();
+          responseSent = true;
+          console.log('✅ [prompt_agent_stream] Sent complete and stop events');
+        }
+      } catch (e) {
+        console.log('⚠️ [prompt_agent_stream] Error sending complete event:', e.message);
+        // Don't set responseSent = true on error, in case we can retry
+        // But realistically, if there's an error, the connection is probably dead
+      }
+    } else {
+      console.log('⚠️ [prompt_agent_stream] Complete event already sent, skipping');
+    }
+  });
+
+  // Handle client disconnect - DON'T kill the process, let it complete
+  req.on('close', () => {
+    console.log('🔵 [prompt_agent_stream] Client disconnected (process continues in background)');
+    // Don't kill the process - let it complete
+    // Don't set responseSent here - let proc.on('close') check actual stream state
+  });
+}
+
+module.exports = promptAgentStreamHandler;
+

package/templates/handlers/read.js

@@ -0,0 +1,120 @@
+const fs = require('fs');
+const path = require('path');
+const { ROOT } = require('../config');
+const { extractPythonFunctions, extractJavaScriptFunctions, extractVueFunctions } = require('../utils/parsers');
+
+function readHandler(req, res) {
+  try {
+    const requestedPath = req.query.path || '';
+    const filePath = path.join(ROOT, requestedPath);
+    
+    if (!filePath.startsWith(ROOT)) {
+      return res.status(400).send('Invalid path');
+    }
+    
+    // Helper function to find and return content from parse result
+    const findAndReturn = (parseResult, name, type) => {
+      if (type === 'function') {
+        const target = parseResult.functions.find(f => f.name === name);
+        if (target) return target.content;
+      } else if (type === 'method') {
+        // Method name format: ClassName.methodName
+        for (const cls of parseResult.classes) {
+          const method = cls.methods.find(m => m.name === name);
+          if (method) return method.content;
+        }
+      } else if (type === 'class') {
+        const target = parseResult.classes.find(c => c.name === name);
+        if (target) return target.content;
+      }
+      return null;
+    };
+    
+    // Check if this is a virtual file request (.function, .method, or .class)
+    if (requestedPath.endsWith('.function') || requestedPath.endsWith('.method') || requestedPath.endsWith('.class')) {
+      // Traverse up the path to find the actual source file
+      let currentPath = filePath;
+      let sourceFilePath = null;
+      let parser = null;
+      
+      // Keep going up until we find a source file (.py, .js, .jsx, .ts, .tsx, .vue)
+      while (currentPath !== ROOT && currentPath !== path.dirname(currentPath)) {
+        const stat = fs.existsSync(currentPath) ? fs.statSync(currentPath) : null;
+        
+        // Check if current path is a file with a supported extension
+        if (stat && stat.isFile()) {
+          if (currentPath.endsWith('.py')) {
+            parser = extractPythonFunctions;
+            sourceFilePath = currentPath;
+            break;
+          } else if (currentPath.endsWith('.js') || currentPath.endsWith('.jsx') || 
+                     currentPath.endsWith('.ts') || currentPath.endsWith('.tsx')) {
+            parser = extractJavaScriptFunctions;
+            sourceFilePath = currentPath;
+            break;
+          } else if (currentPath.endsWith('.vue')) {
+            parser = extractVueFunctions;
+            sourceFilePath = currentPath;
+            break;
+          }
+        }
+        
+        // Move up one level
+        const parentPath = path.dirname(currentPath);
+        if (parentPath === currentPath) break; // Reached root
+        currentPath = parentPath;
+      }
+      
+      if (!sourceFilePath || !parser) {
+        return res.status(404).send('Source file not found for virtual file');
+      }
+      
+      // Extract the requested item name from the requested path
+      let itemName = '';
+      let itemType = '';
+      
+      if (requestedPath.endsWith('.function')) {
+        itemName = path.basename(requestedPath, '.function');
+        itemType = 'function';
+      } else if (requestedPath.endsWith('.method')) {
+        itemName = path.basename(requestedPath, '.method');
+        itemType = 'method';
+      } else if (requestedPath.endsWith('.class')) {
+        itemName = path.basename(requestedPath, '.class');
+        itemType = 'class';
+      }
+      
+      // Check if the source file exists
+      try {
+        if (!fs.existsSync(sourceFilePath)) {
+          return res.status(404).send('Source file not found');
+        }
+        
+        // Parse the file
+        const parseResult = parser(sourceFilePath);
+        
+        // Find and return the content
+        const content = findAndReturn(parseResult, itemName, itemType);
+        
+        if (!content) {
+          return res.status(404).send(`${itemType} '${itemName}' not found in file`);
+        }
+        
+        return res.json({ content });
+      } catch (e) {
+        const errorType = requestedPath.endsWith('.function') ? 'function' : 
+                         requestedPath.endsWith('.method') ? 'method' : 'class';
+        return res.status(500).send('Error reading ' + errorType + ': ' + e.message);
+      }
+    }
+    
+    // Regular file read
+    const content = fs.readFileSync(filePath, 'utf8');
+    res.json({ content });
+  } catch (e) {
+    res.status(500).send(e.message);
+  }
+}
+
+module.exports = readHandler;
+

package/templates/handlers/revert_job.js

@@ -0,0 +1,31 @@
+const { execSync } = require('child_process');
+const { ROOT } = require('../config');
+
+function revertJobHandler(req, res) {
+  console.log('🔵 [revert_job] Endpoint hit');
+  const { beforeCommit } = req.body;
+  
+  if (!beforeCommit || typeof beforeCommit !== 'string') {
+    console.log('❌ [revert_job] Error: beforeCommit required');
+    return res.status(400).json({ error: 'beforeCommit required' });
+  }
+  
+  // Validate commit hash format (basic sanitization to prevent command injection)
+  if (!/^[a-f0-9]{7,40}$/i.test(beforeCommit)) {
+    console.log('❌ [revert_job] Error: invalid commit hash format');
+    return res.status(400).json({ error: 'Invalid commit hash format' });
+  }
+  
+  try {
+    console.log('🔵 [revert_job] Resetting to commit:', beforeCommit);
+    execSync(`git reset --hard ${beforeCommit}`, { cwd: ROOT });
+    console.log('✅ [revert_job] Successfully reverted to commit:', beforeCommit);
+    res.json({ success: true });
+  } catch (e) {
+    console.log('❌ [revert_job] Error:', e.message);
+    res.status(500).json({ error: e.message });
+  }
+}
+
+module.exports = revertJobHandler;
+

package/templates/handlers/shutdown.js

@@ -0,0 +1,16 @@
+function shutdownHandler(req, res) {
+  console.log('🛑 Shutdown endpoint called - terminating server...');
+  
+  res.json({ 
+    success: true, 
+    message: 'Server shutting down...' 
+  });
+  
+  // Close the server gracefully
+  setTimeout(() => {
+    process.exit(0);
+  }, 100); // Small delay to ensure response is sent
+}
+
+module.exports = shutdownHandler;
+

package/templates/handlers/write.js

@@ -0,0 +1,19 @@
+const fs = require('fs');
+const path = require('path');
+const { ROOT } = require('../config');
+
+function writeHandler(req, res) {
+  try {
+    const filePath = path.join(ROOT, req.body.path || '');
+    if (!filePath.startsWith(ROOT)) {
+      return res.status(400).send('Invalid path');
+    }
+    fs.writeFileSync(filePath, req.body.content, 'utf8');
+    res.json({ status: 'ok' });
+  } catch (e) {
+    res.status(500).send(e.message);
+  }
+}
+
+module.exports = writeHandler;
+

package/templates/handlers/write_dir.js

@@ -0,0 +1,20 @@
+const fs = require('fs');
+const path = require('path');
+const { ROOT } = require('../config');
+
+function writeDirHandler(req, res) {
+  try {
+    const dirPath = path.join(ROOT, req.body.path || '');
+    if (!dirPath.startsWith(ROOT)) {
+      return res.status(400).send('Invalid path');
+    }
+    // Create directory recursively (creates parent directories if they don't exist)
+    fs.mkdirSync(dirPath, { recursive: true });
+    res.json({ status: 'ok' });
+  } catch (e) {
+    res.status(500).send(e.message);
+  }
+}
+
+module.exports = writeDirHandler;
+