devbonzai 1.6.5

package/README.md

@@ -0,0 +1,16 @@
+
+# Dev Bonzai
+
+This repository contains the code behind the command:
+
+```bash
+npx devbonzai
+```
+
+npm publish
+
+# how to test:
+- node cli.js 
+- this will setup a receiver in this directory
+
+Used for Bonzai's linking functionality from web to local development environment. 

package/cli.js

@@ -0,0 +1,811 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { spawn, exec } = require('child_process');
+
+const IGNORE_FILE_CONTENT = `# Ignore patterns for file listing
+# Lines starting with # are comments
+# Use * for wildcards and ** for recursive patterns
+
+# Dependencies
+node_modules/
+package.json
+package-lock.json
+
+# IDE and editor files
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Environment and config files
+.env
+.env.local
+.env.production
+.env.staging
+
+# Version control
+.git/
+.gitignore
+.ignore
+
+# Logs
+*.log
+logs/
+
+# Build outputs
+dist/
+build/
+*.min.js
+*.min.css
+
+# Temporary files
+*.tmp
+*.temp
+
+# Project-specific files
+receiver.js
+bonzai/
+`;
+
+const RECEIVER_JS_CONTENT = `#!/usr/bin/env node
+
+const express = require('./node_modules/express');
+const cors = require('./node_modules/cors');
+const fs = require('fs');
+const path = require('path');
+const { exec, spawn } = require('child_process');
+
+const app = express();
+const ROOT = path.join(__dirname, '..');
+
+app.use(cors());
+app.use(express.json());
+
+// Root route - simple API documentation
+app.get('/', (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 /prompt_agent': 'Execute cursor-agent command (body: {prompt})',
+      'POST /shutdown': 'Gracefully shutdown the server'
+    },
+    example: 'Try: /list or /read?path=README.md'
+  });
+});
+
+// Read and parse ignore patterns from .ignore file
+function getIgnorePatterns() {
+  try {
+    const ignorePath = path.join(__dirname, '.ignore');
+    if (fs.existsSync(ignorePath)) {
+      const content = fs.readFileSync(ignorePath, 'utf8');
+      return content
+        .split('\\n')
+        .map(line => line.trim())
+        .filter(line => line && !line.startsWith('#'))
+        .map(pattern => {
+          // Convert simple glob patterns to regex
+          if (pattern.endsWith('/')) {
+            // Directory pattern
+            pattern = pattern.slice(0, -1);
+          }
+          
+          // Simple approach: escape dots and convert globs
+          pattern = pattern.replace(/\\./g, '\\\\.');
+          pattern = pattern.replace(/\\*\\*/g, '|||DOUBLESTAR|||');
+          pattern = pattern.replace(/\\*/g, '[^/]*');
+          pattern = pattern.replace(/\\|\\|\\|DOUBLESTAR\\|\\|\\|/g, '.*');
+          
+          return new RegExp('^' + pattern + '(/.*)?$');
+        });
+    }
+  } catch (e) {
+    console.warn('Could not read .ignore file:', e.message);
+  }
+  
+  // Default ignore patterns if no .ignore file exists
+  return [
+    /^node_modules(\\/.*)?$/,
+    /^\\.git(\\/.*)?$/,
+    /^\\.DS_Store$/,
+    /^\\.env$/
+  ];
+}
+
+// Check if a path should be ignored
+function shouldIgnore(relativePath, ignorePatterns) {
+  return ignorePatterns.some(pattern => pattern.test(relativePath));
+}
+
+// Extract top-level functions from a Python file
+function extractPythonFunctions(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lines = content.split('\\n');
+    const functions = [];
+    let currentFunction = null;
+    let decorators = [];
+    
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+      
+      // Calculate indentation level
+      const match = line.match(/^\\s*/);
+      const currentIndent = match ? match[0].length : 0;
+      
+      // Check for decorators (only at top level, before function)
+      if (trimmed.startsWith('@') && currentIndent === 0) {
+        decorators.push(line);
+        continue;
+      }
+      
+      // Check if this is a top-level function definition
+      const funcMatch = trimmed.match(/^def\\s+(\\w+)\\s*\\(/);
+      
+      if (funcMatch && currentIndent === 0) {
+        // Save previous function if exists
+        if (currentFunction) {
+          currentFunction.content = currentFunction.content.trim();
+          functions.push(currentFunction);
+        }
+        
+        // Start new function
+        const functionName = funcMatch[1];
+        let functionContent = '';
+        
+        // Add decorators if any
+        if (decorators.length > 0) {
+          functionContent = decorators.join('\\n') + '\\n';
+          decorators = [];
+        }
+        
+        functionContent += line;
+        
+        currentFunction = {
+          name: functionName,
+          content: functionContent,
+          startLine: i + 1,
+          endLine: i + 1
+        };
+      } else if (currentFunction) {
+        // We're processing lines after a function definition
+        if (currentIndent === 0 && trimmed && !trimmed.startsWith('#')) {
+          // Back to top level with non-comment content - function ended
+          currentFunction.content = currentFunction.content.trim();
+          functions.push(currentFunction);
+          currentFunction = null;
+          
+          // Check if this line starts a new function
+          if (funcMatch) {
+            const functionName = funcMatch[1];
+            let functionContent = '';
+            
+            if (decorators.length > 0) {
+              functionContent = decorators.join('\\n') + '\\n';
+              decorators = [];
+            }
+            
+            functionContent += line;
+            
+            currentFunction = {
+              name: functionName,
+              content: functionContent,
+              startLine: i + 1,
+              endLine: i + 1
+            };
+          } else if (trimmed.startsWith('@')) {
+            decorators.push(line);
+          }
+        } else {
+          // Still inside function (indented or empty/comment line)
+          currentFunction.content += '\\n' + line;
+          currentFunction.endLine = i + 1;
+        }
+      }
+    }
+    
+    // Don't forget the last function
+    if (currentFunction) {
+      currentFunction.content = currentFunction.content.trim();
+      functions.push(currentFunction);
+    }
+    
+    return functions;
+  } catch (e) {
+    // If parsing fails (invalid Python, etc.), return empty array
+    console.warn('Failed to parse Python file:', filePath, e.message);
+    return [];
+  }
+}
+
+// Recursively list all files in a directory, respecting ignore patterns
+function listAllFiles(dir, base = '', ignorePatterns = null) {
+  if (ignorePatterns === null) {
+    ignorePatterns = getIgnorePatterns();
+  }
+  
+  let results = [];
+  const list = fs.readdirSync(dir);
+  
+  for (const file of list) {
+    const fullPath = path.join(dir, file);
+    const relativePath = path.join(base, file);
+    
+    // Check if this path should be ignored
+    if (shouldIgnore(relativePath, ignorePatterns)) {
+      continue;
+    }
+    
+    const stat = fs.statSync(fullPath);
+    if (stat && stat.isDirectory()) {
+      // Add the directory itself to results
+      results.push(relativePath + '/');
+      // Recursively list files inside the directory
+      results = results.concat(listAllFiles(fullPath, relativePath, ignorePatterns));
+    } else {
+      results.push(relativePath);
+      
+      // If this is a Python file, extract functions and add them as virtual files
+      if (file.endsWith('.py')) {
+        const functions = extractPythonFunctions(fullPath);
+        for (const func of functions) {
+          // Add function file as downstream from the Python file
+          // Format: <python_file_path>/<function_name.function>
+          const functionFileName = func.name + '.function';
+          const functionFilePath = relativePath + '/' + functionFileName;
+          results.push(functionFilePath);
+        }
+      }
+    }
+  }
+  return results;
+}
+
+app.get('/list', (req, res) => {
+  try {
+    const rootName = path.basename(ROOT);
+    const files = listAllFiles(ROOT, rootName);
+    res.json({ files });
+  } catch (e) {
+    res.status(500).send(e.message);
+  }
+});
+
+app.get('/read', (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');
+    }
+    
+    // Check if this is a .function file request
+    if (requestedPath.endsWith('.function')) {
+      // Extract function name and Python file path
+      // Path format: <python_file_path>/<function_name.function>
+      const functionFileName = path.basename(requestedPath, '.function');
+      const pythonFilePath = path.dirname(filePath);
+      
+      // Check if the Python file exists
+      try {
+        if (!fs.existsSync(pythonFilePath) || !pythonFilePath.endsWith('.py')) {
+          return res.status(404).send('Parent Python file not found');
+        }
+        
+        // Extract functions from the Python file
+        const functions = extractPythonFunctions(pythonFilePath);
+        const targetFunction = functions.find(f => f.name === functionFileName);
+        
+        if (!targetFunction) {
+          return res.status(404).send('Function not found in Python file');
+        }
+        
+        return res.json({ content: targetFunction.content });
+      } catch (e) {
+        return res.status(500).send('Error reading function: ' + e.message);
+      }
+    }
+    
+    // Regular file read
+    const content = fs.readFileSync(filePath, 'utf8');
+    res.json({ content });
+  } catch (e) {
+    res.status(500).send(e.message);
+  }
+});
+
+app.get('/git-churn', (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 });
+  }
+});
+
+app.post('/write', (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);
+  }
+});
+
+app.post('/write_dir', (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);
+  }
+});
+
+app.post('/delete', (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);
+  }
+});
+
+app.post('/move', (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);
+  }
+});
+
+app.post('/open-cursor', (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 });
+  }
+});
+
+app.post('/prompt_agent', (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' });
+  }
+
+  // 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...');
+      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
+        });
+      }
+    }
+  }, 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);
+    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);
+    
+    if (timeoutId) clearTimeout(timeoutId);
+    
+    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
+        });
+      } else {
+        res.json({
+          code,
+          stdout,
+          stderr
+        });
+      }
+    }
+  });
+});
+
+// Shutdown endpoint to kill the server
+app.post('/shutdown', (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
+});
+
+const port = 3001;
+app.listen(port, () => {
+  console.log('📂 File server running on http://localhost:' + port);
+});
+`;
+
+async function main() {
+  const currentDir = process.cwd();
+  const bonzaiDir = path.join(currentDir, 'bonzai');
+  const receiverPath = path.join(bonzaiDir, 'receiver.js');
+  
+  console.log('🚀 Setting up local file server...');
+  
+  // Create bonzai directory
+  if (!fs.existsSync(bonzaiDir)) {
+    console.log('📁 Creating bonzai directory...');
+    fs.mkdirSync(bonzaiDir);
+  }
+  
+  // Write receiver.js to current directory (root level)
+  console.log('📝 Writing receiver.js...');
+  fs.writeFileSync(receiverPath, RECEIVER_JS_CONTENT);
+  
+  // Make it executable
+  fs.chmodSync(receiverPath, '755');
+  
+  // Write .ignore file in bonzai directory
+  const ignoreTargetPath = path.join(bonzaiDir, '.ignore');
+  
+  if (!fs.existsSync(ignoreTargetPath)) {
+    console.log('📝 Writing .ignore file...');
+    fs.writeFileSync(ignoreTargetPath, IGNORE_FILE_CONTENT);
+  }
+  
+  console.log('📦 Installing dependencies...');
+  
+  // Check if package.json exists in bonzai directory
+  const packageJsonPath = path.join(bonzaiDir, 'package.json');
+  let packageJson = {};
+  
+  if (fs.existsSync(packageJsonPath)) {
+    packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  } else {
+    packageJson = {
+      name: "bonzai-server",
+      version: "1.0.0",
+      description: "Dependencies for devbonzai file server",
+      main: "../receiver.js",
+      scripts: {
+        test: "echo \"Error: no test specified\" && exit 1"
+      },
+      author: "",
+      license: "ISC"
+    };
+  }
+  
+  // Add dependencies
+  if (!packageJson.dependencies) {
+    packageJson.dependencies = {};
+  }
+  packageJson.dependencies.express = "^4.18.2";
+  packageJson.dependencies.cors = "^2.8.5";
+  packageJson.dependencies["body-parser"] = "^1.20.2";
+  packageJson.dependencies["raw-body"] = "^2.5.2";
+  
+  // Add script to run receiver
+  if (!packageJson.scripts) {
+    packageJson.scripts = {};
+  }
+  packageJson.scripts["file-server"] = "node receiver.js";
+  
+  // Write package.json to bonzai directory
+  fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+  
+  // Install dependencies in bonzai directory
+  return new Promise((resolve, reject) => {
+    const npm = spawn('npm', ['install'], { 
+      stdio: 'inherit',
+      cwd: bonzaiDir 
+    });
+    
+    npm.on('close', (code) => {
+      if (code === 0) {
+        console.log('Listner end points successfully deployed');
+        console.log('');
+        console.log('All code stays on your machine');
+        console.log('');
+        console.log('');
+        console.log('');
+        console.log('Relay server running on localhost:3001');
+        console.log('');
+        console.log('Diagram avaialble at https://www.codemaps.me/ ');
+        console.log('');
+        
+        // Start the server automatically
+        const server = spawn('node', ['receiver.js'], { 
+          stdio: 'inherit',
+          cwd: bonzaiDir 
+        });
+        
+        // Open browser automatically
+        exec('open https://www.codemaps.me/');
+        
+        // Handle server process
+        server.on('close', (serverCode) => {
+          console.log(`\n📡 Server stopped with code ${serverCode}`);
+          process.exit(serverCode);
+        });
+        
+        server.on('error', (err) => {
+          console.error('❌ Error starting server:', err.message);
+          process.exit(1);
+        });
+        
+        // Handle cleanup on exit
+        process.on('SIGINT', () => {
+          console.log('\n🛑 Shutting down server...');
+          server.kill('SIGINT');
+        });
+        
+        process.on('SIGTERM', () => {
+          console.log('\n🛑 Shutting down server...');
+          server.kill('SIGTERM');
+        });
+        
+        resolve();
+      } else {
+        reject(new Error('npm install failed with code ' + code));
+      }
+    });
+    
+    npm.on('error', (err) => {
+      reject(err);
+    });
+  });
+}
+
+main().catch(console.error);

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "devbonzai",
+  "version": "1.6.5",
+  "description": "Quickly set up a local file server in any repository for browser-based file access",
+  "main": "cli.js",
+  "bin": {
+    "devbonzai": "./cli.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "file-server",
+    "local-development",
+    "browser-access",
+    "cli"
+  ],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "express": "^4.18.2",
+    "cors": "^2.8.5",
+    "body-parser": "^1.20.2",
+    "raw-body": "^2.5.2"
+  }
+}