devbonzai 2.1.6 → 2.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devbonzai",
-  "version": "2.1.6",
+  "version": "2.1.7",
   "description": "Quickly set up a local file server in any repository for browser-based file access",
   "main": "cli.js",
   "bin": {

package/templates/config.js

@@ -0,0 +1,18 @@
+const path = require('path');
+
+// Root directory (one level up from templates/)
+const ROOT = path.join(__dirname, '..');
+
+// Initialize babelParser (optional dependency)
+let babelParser = null;
+try {
+  babelParser = require('./node_modules/@babel/parser');
+} catch (e) {
+  // Babel parser not available, will fall back gracefully
+}
+
+module.exports = {
+  ROOT,
+  babelParser
+};
+

package/templates/handlers/analyze_prompt.js

@@ -0,0 +1,118 @@
+const { spawn } = require('child_process');
+const { ROOT } = require('../config');
+
+function analyzePromptHandler(req, res) {
+  console.log('🔵 [analyze_prompt] Endpoint hit');
+  const { prompt } = req.body;
+  console.log('🔵 [analyze_prompt] Received prompt:', prompt ? `${prompt.substring(0, 50)}...` : 'none');
+
+  if (!prompt || typeof prompt !== 'string') {
+    console.log('❌ [analyze_prompt] Error: prompt required');
+    return res.status(400).json({ error: 'prompt required' });
+  }
+
+  // Configurable timeout (default 2 minutes for analysis)
+  const timeoutMs = parseInt(req.body.timeout) || 2 * 60 * 1000;
+  let timeoutId = null;
+  let responseSent = false;
+
+  // Build analysis prompt - ask agent to list files without making changes
+  const analysisPrompt = `You are analyzing a coding task. Do NOT make any changes to any files. Only analyze and list the files you would need to modify to complete this task.
+
+Respond ONLY with valid JSON in this exact format (no other text):
+{"files": [{"path": "path/to/file.ext", "reason": "brief reason for modification"}]}
+
+If no files need modification, respond with: {"files": []}
+
+Task to analyze: ${prompt}`;
+
+  const args = ['--print', '--force', '--workspace', '.', analysisPrompt];
+
+  console.log('🔵 [analyze_prompt] Spawning cursor-agent process...');
+  const proc = spawn(
+    'cursor-agent',
+    args,
+    {
+      cwd: ROOT,
+      env: process.env,
+      stdio: ['ignore', 'pipe', 'pipe']
+    }
+  );
+
+  console.log('🔵 [analyze_prompt] Process spawned, PID:', proc.pid);
+
+  let stdout = '';
+  let stderr = '';
+
+  timeoutId = setTimeout(() => {
+    if (!responseSent && proc && !proc.killed) {
+      console.log('⏱️  [analyze_prompt] Timeout reached, killing process...');
+      proc.kill('SIGTERM');
+      setTimeout(() => {
+        if (!proc.killed) proc.kill('SIGKILL');
+      }, 5000);
+      
+      if (!responseSent) {
+        responseSent = true;
+        res.status(500).json({
+          error: 'Process timeout',
+          message: `Analysis exceeded timeout of ${timeoutMs / 1000} seconds`
+        });
+      }
+    }
+  }, timeoutMs);
+
+  proc.stdout.on('data', (d) => {
+    stdout += d.toString();
+  });
+
+  proc.stderr.on('data', (d) => {
+    stderr += d.toString();
+  });
+
+  proc.on('error', (error) => {
+    console.log('❌ [analyze_prompt] Process error:', error.message);
+    if (timeoutId) clearTimeout(timeoutId);
+    if (!responseSent) {
+      responseSent = true;
+      return res.status(500).json({ error: error.message });
+    }
+  });
+
+  proc.on('close', (code, signal) => {
+    console.log('🔵 [analyze_prompt] Process closed with code:', code);
+    if (timeoutId) clearTimeout(timeoutId);
+    
+    if (!responseSent) {
+      responseSent = true;
+      
+      // Try to parse JSON from the output
+      try {
+        // Look for JSON in the output - it might be wrapped in other text
+        const jsonMatch = stdout.match(/\{[\s\S]*"files"[\s\S]*\}/);
+        if (jsonMatch) {
+          const parsed = JSON.parse(jsonMatch[0]);
+          console.log('✅ [analyze_prompt] Parsed files:', parsed.files);
+          res.json({ files: parsed.files || [] });
+        } else {
+          console.log('⚠️ [analyze_prompt] No JSON found in output, returning raw');
+          res.json({ 
+            files: [],
+            raw: stdout,
+            warning: 'Could not parse structured response'
+          });
+        }
+      } catch (parseError) {
+        console.log('⚠️ [analyze_prompt] JSON parse error:', parseError.message);
+        res.json({ 
+          files: [],
+          raw: stdout,
+          warning: 'Could not parse JSON: ' + parseError.message
+        });
+      }
+    }
+  });
+}
+
+module.exports = analyzePromptHandler;
+

package/templates/handlers/delete.js

@@ -0,0 +1,20 @@
+const fs = require('fs');
+const path = require('path');
+const { ROOT } = require('../config');
+
+function deleteHandler(req, res) {
+  try {
+    const targetPath = path.join(ROOT, req.body.path || '');
+    if (!targetPath.startsWith(ROOT)) {
+      return res.status(400).send('Invalid path');
+    }
+    // Delete file or directory recursively
+    fs.rmSync(targetPath, { recursive: true, force: true });
+    res.json({ status: 'ok' });
+  } catch (e) {
+    res.status(500).send(e.message);
+  }
+}
+
+module.exports = deleteHandler;
+

package/templates/handlers/git-churn.js

@@ -0,0 +1,44 @@
+const path = require('path');
+const { exec } = require('child_process');
+const { ROOT } = require('../config');
+
+function gitChurnHandler(req, res) {
+  try {
+    const filePath = path.join(ROOT, req.query.path || '');
+    if (!filePath.startsWith(ROOT)) {
+      return res.status(400).json({ error: 'Invalid path' });
+    }
+    
+    // Get commits parameter, default to 30
+    const commits = parseInt(req.query.commits) || 30;
+    
+    // Get relative path from ROOT for git command
+    const relativePath = path.relative(ROOT, filePath);
+    
+    // Build git log command with relative path
+    const gitCommand = `git log --oneline --all -${commits} -- "${relativePath}"`;
+    
+    exec(gitCommand, { cwd: ROOT }, (error, stdout, stderr) => {
+      // If git command fails (no repo, file not tracked, etc.), return 0 churn
+      if (error) {
+        // Check if it's because file is not in git or no git repo
+        if (error.code === 128 || stderr.includes('not a git repository')) {
+          return res.json({ churn: 0 });
+        }
+        // For other errors, still return 0 churn gracefully
+        return res.json({ churn: 0 });
+      }
+      
+      // Count non-empty lines (each line is a commit)
+      const commitCount = stdout.trim().split('\n').filter(line => line.trim().length > 0).length;
+      
+      res.json({ churn: commitCount });
+    });
+  } catch (e) {
+    // Handle any other errors gracefully
+    res.status(500).json({ error: e.message, churn: 0 });
+  }
+}
+
+module.exports = gitChurnHandler;
+

package/templates/handlers/index.js

@@ -0,0 +1,25 @@
+// Root route - simple API documentation
+function indexHandler(req, res) {
+  res.json({
+    message: 'Local File Server API',
+    endpoints: {
+      'GET /list': 'List all files in the directory',
+      'GET /read?path=<filepath>': 'Read file content',
+      'GET /git-churn?path=<filepath>&commits=30': 'Get git commit churn for a file',
+      'POST /write': 'Write file content (body: {path, content})',
+      'POST /write_dir': 'Create directory (body: {path})',
+      'POST /delete': 'Delete file or directory (body: {path})',
+      'POST /move': 'Move file or folder (body: {source, destination})',
+      'POST /open-cursor': 'Open Cursor (body: {path, line?})',
+      'POST /analyze_prompt': 'Analyze what files would be modified (body: {prompt})',
+      'POST /prompt_agent': 'Execute cursor-agent command (body: {prompt})',
+      'POST /prompt_agent_stream': 'Execute cursor-agent with SSE streaming (body: {prompt})',
+      'POST /revert_job': 'Revert to a previous commit (body: {beforeCommit})',
+      'POST /shutdown': 'Gracefully shutdown the server'
+    },
+    example: 'Try: /list or /read?path=README.md'
+  });
+}
+
+module.exports = indexHandler;
+

package/templates/handlers/list.js

@@ -0,0 +1,16 @@
+const path = require('path');
+const { ROOT } = require('../config');
+const { listAllFiles } = require('../utils/fileList');
+
+function listHandler(req, res) {
+  try {
+    const rootName = path.basename(ROOT);
+    const files = listAllFiles(ROOT, rootName);
+    res.json({ files });
+  } catch (e) {
+    res.status(500).send(e.message);
+  }
+}
+
+module.exports = listHandler;
+

package/templates/handlers/move.js

@@ -0,0 +1,35 @@
+const fs = require('fs');
+const path = require('path');
+const { ROOT } = require('../config');
+
+function moveHandler(req, res) {
+  try {
+    const sourcePath = path.join(ROOT, req.body.source || '');
+    const destinationPath = path.join(ROOT, req.body.destination || '');
+    
+    // Validate both paths are within ROOT directory
+    if (!sourcePath.startsWith(ROOT) || !destinationPath.startsWith(ROOT)) {
+      return res.status(400).send('Invalid path');
+    }
+    
+    // Check if source exists
+    if (!fs.existsSync(sourcePath)) {
+      return res.status(400).send('Source path does not exist');
+    }
+    
+    // Ensure destination directory exists
+    const destinationDir = path.dirname(destinationPath);
+    if (!fs.existsSync(destinationDir)) {
+      fs.mkdirSync(destinationDir, { recursive: true });
+    }
+    
+    // Move the file or folder
+    fs.renameSync(sourcePath, destinationPath);
+    res.json({ status: 'ok' });
+  } catch (e) {
+    res.status(500).send(e.message);
+  }
+}
+
+module.exports = moveHandler;
+

package/templates/handlers/open-cursor.js

@@ -0,0 +1,108 @@
+const path = require('path');
+const { exec } = require('child_process');
+const { ROOT } = require('../config');
+
+function openCursorHandler(req, res) {
+  try {
+    const requestedPath = req.body.path || '';
+    
+    // Resolve path relative to ROOT (similar to other endpoints)
+    // If path is absolute and within ROOT, use it directly
+    // Otherwise, resolve it relative to ROOT
+    let filePath;
+    if (path.isAbsolute(requestedPath)) {
+      // If absolute path, check if it's within ROOT
+      if (requestedPath.startsWith(ROOT)) {
+        filePath = requestedPath;
+      } else {
+        // Path might contain incorrect segments (like "codemaps")
+        // Try to find ROOT in the path and extract the relative part
+        const rootIndex = requestedPath.indexOf(ROOT);
+        if (rootIndex !== -1) {
+          // Extract the part after ROOT and remove leading slashes
+          let relativePart = requestedPath.substring(rootIndex + ROOT.length);
+          while (relativePart.startsWith('/')) {
+            relativePart = relativePart.substring(1);
+          }
+          filePath = path.join(ROOT, relativePart);
+        } else {
+          return res.status(400).json({ error: 'Invalid path: path must be within project root' });
+        }
+      }
+    } else {
+      // Relative path - resolve relative to ROOT
+      // Remove root directory name prefix if present (from /list endpoint format)
+      const rootName = path.basename(ROOT);
+      let relativePath = requestedPath;
+      if (relativePath.startsWith(rootName + '/')) {
+        relativePath = relativePath.substring(rootName.length + 1);
+      }
+      filePath = path.join(ROOT, relativePath);
+    }
+    
+    // Validate the resolved path is within ROOT
+    if (!filePath.startsWith(ROOT)) {
+      return res.status(400).json({ error: 'Invalid path' });
+    }
+    
+    const { line } = req.body;
+    
+    // Always use cursor CLI command first (it handles line numbers correctly)
+    const cursorCommands = [
+      'cursor',
+      '/Applications/Cursor.app/Contents/Resources/app/bin/cursor',
+      '/usr/local/bin/cursor',
+      'code'
+    ];
+    
+    const tryCommand = (commandIndex = 0) => {
+      if (commandIndex >= cursorCommands.length) {
+        return res.status(500).json({ 
+          error: 'Cursor not found. Please install Cursor CLI or check Cursor installation.' 
+        });
+      }
+      
+      // Use proper Cursor CLI syntax for line numbers
+      const command = line 
+        ? `${cursorCommands[commandIndex]} --goto "${filePath}:${line}"`
+        : `${cursorCommands[commandIndex]} "${filePath}"`;
+    
+    exec(command, (error, stdout, stderr) => {
+      if (error && error.code === 127) {
+        // Command not found, try next one
+        tryCommand(commandIndex + 1);
+      } else if (error) {
+        console.error('Error opening Cursor:', error);
+        return res.status(500).json({ error: error.message });
+      } else {
+        // File opened successfully, now bring Cursor to front
+        const isMac = process.platform === 'darwin';
+        if (isMac) {
+          // Use AppleScript to bring Cursor to the front
+          exec('osascript -e "tell application \\"Cursor\\" to activate"', (activateError) => {
+            if (activateError) {
+              console.log('Could not activate Cursor, but file opened successfully');
+            }
+          });
+          
+          // Additional command to ensure it's really in front
+          setTimeout(() => {
+            exec('osascript -e "tell application \\"System Events\\" to set frontmost of process \\"Cursor\\" to true"', () => {
+              // Don't worry if this fails
+            });
+          }, 500);
+        }
+        
+        res.json({ success: true, message: 'Cursor opened and focused successfully' });
+      }
+    });
+  };
+  
+  tryCommand();
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+}
+
+module.exports = openCursorHandler;
+

package/templates/handlers/prompt_agent.js

@@ -0,0 +1,181 @@
+const { spawn, execSync } = require('child_process');
+const { ROOT } = require('../config');
+
+function promptAgentHandler(req, res) {
+  console.log('🔵 [prompt_agent] Endpoint hit');
+  const { prompt } = req.body;
+  console.log('🔵 [prompt_agent] Received prompt:', prompt ? `${prompt.substring(0, 50)}...` : 'none');
+
+  if (!prompt || typeof prompt !== 'string') {
+    console.log('❌ [prompt_agent] Error: prompt required');
+    return res.status(400).json({ error: 'prompt required' });
+  }
+
+  // Capture beforeCommit
+  let beforeCommit = '';
+  try {
+    beforeCommit = execSync('git rev-parse HEAD', { cwd: ROOT }).toString().trim();
+    console.log('🔵 [prompt_agent] beforeCommit:', beforeCommit);
+  } catch (e) {
+    console.log('⚠️ [prompt_agent] Could not get beforeCommit:', e.message);
+  }
+
+  // Capture initial state of modified files (files already dirty before job starts)
+  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);
+    });
+    console.log('🔵 [prompt_agent] Initially modified files:', Array.from(initiallyModifiedFiles));
+  } catch (e) {
+    console.log('⚠️ [prompt_agent] Could not get initial status:', e.message);
+  }
+
+  // Set up file change tracking - only track NEW changes during job
+  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(); // Remove status prefix (XY + space)
+        // Only add if this file was NOT already modified before the job started
+        if (filePath && !initiallyModifiedFiles.has(filePath)) {
+          const wasNew = !changedFiles.has(filePath);
+          changedFiles.add(filePath);
+          if (wasNew) {
+            console.log('📁 [prompt_agent] New file changed:', filePath);
+          }
+        }
+      });
+    } catch (e) {
+      // Ignore git status errors
+    }
+  }, 500);
+
+  // Configurable timeout (default 5 minutes)
+  const timeoutMs = parseInt(req.body.timeout) || 5 * 60 * 1000;
+  let timeoutId = null;
+  let responseSent = false;
+
+  // Build command arguments
+  const args = ['--print', '--force', '--workspace', '.', prompt];
+
+  console.log('🔵 [prompt_agent] Spawning cursor-agent process...');
+  const proc = spawn(
+    'cursor-agent',
+    args,
+    {
+      cwd: ROOT,
+      env: process.env,
+      stdio: ['ignore', 'pipe', 'pipe'] // Ignore stdin, pipe stdout/stderr
+    }
+  );
+
+  console.log('🔵 [prompt_agent] Process spawned, PID:', proc.pid);
+
+  let stdout = '';
+  let stderr = '';
+
+  // Set up timeout to kill process if it takes too long
+  timeoutId = setTimeout(() => {
+    if (!responseSent && proc && !proc.killed) {
+      console.log('⏱️  [prompt_agent] Timeout reached, killing process...');
+      clearInterval(pollInterval);
+      proc.kill('SIGTERM');
+      
+      // Force kill after a short grace period if SIGTERM doesn't work
+      setTimeout(() => {
+        if (!proc.killed) {
+          console.log('💀 [prompt_agent] Force killing process...');
+          proc.kill('SIGKILL');
+        }
+      }, 5000);
+      
+      if (!responseSent) {
+        responseSent = true;
+        res.status(500).json({
+          error: 'Process timeout',
+          message: `cursor-agent exceeded timeout of ${timeoutMs / 1000} seconds`,
+          code: -1,
+          stdout,
+          stderr,
+          changedFiles: Array.from(changedFiles),
+          beforeCommit,
+          afterCommit: ''
+        });
+      }
+    }
+  }, timeoutMs);
+
+  proc.stdout.on('data', (d) => {
+    const data = d.toString();
+    console.log('📤 [prompt_agent] stdout data received:', data.length, 'bytes');
+    stdout += data;
+  });
+
+  proc.stderr.on('data', (d) => {
+    const data = d.toString();
+    console.log('⚠️  [prompt_agent] stderr data received:', data.length, 'bytes');
+    stderr += data;
+  });
+
+  proc.on('error', (error) => {
+    console.log('❌ [prompt_agent] Process error:', error.message);
+    clearInterval(pollInterval);
+    if (timeoutId) clearTimeout(timeoutId);
+    if (!responseSent) {
+      responseSent = true;
+      return res.status(500).json({ error: error.message });
+    }
+  });
+
+  proc.on('close', (code, signal) => {
+    console.log('🔵 [prompt_agent] Process closed with code:', code, 'signal:', signal);
+    console.log('🔵 [prompt_agent] stdout length:', stdout.length);
+    console.log('🔵 [prompt_agent] stderr length:', stderr.length);
+    
+    // Stop polling for file changes
+    clearInterval(pollInterval);
+    if (timeoutId) clearTimeout(timeoutId);
+    
+    // Capture afterCommit
+    let afterCommit = '';
+    try {
+      afterCommit = execSync('git rev-parse HEAD', { cwd: ROOT }).toString().trim();
+      console.log('🔵 [prompt_agent] afterCommit:', afterCommit);
+    } catch (e) {
+      console.log('⚠️ [prompt_agent] Could not get afterCommit:', e.message);
+    }
+    
+    if (!responseSent) {
+      responseSent = true;
+      // Check if process was killed due to timeout
+      if (signal === 'SIGTERM' || signal === 'SIGKILL') {
+        res.status(500).json({
+          error: 'Process terminated',
+          message: signal === 'SIGTERM' ? 'Process was terminated due to timeout' : 'Process was force killed',
+          code: code || -1,
+          stdout,
+          stderr,
+          changedFiles: Array.from(changedFiles),
+          beforeCommit,
+          afterCommit
+        });
+      } else {
+        res.json({
+          code,
+          stdout,
+          stderr,
+          changedFiles: Array.from(changedFiles),
+          beforeCommit,
+          afterCommit
+        });
+      }
+    }
+  });
+}
+
+module.exports = promptAgentHandler;
+