bonzai-burn 1.0.39 → 1.0.40

package/dist/bconfig.js

@@ -0,0 +1,224 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+import { spawn, exec } from 'child_process';
+import { fileURLToPath } from 'url';
+import { ENABLED_LOOPS } from './loops.config.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Template folder in the package
+const TEMPLATE_DIR = path.join(__dirname, 'graph-templates');
+
+// Helper function to recursively copy directory
+function copyDirectory(src, dest) {
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDirectory(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+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
+  console.log('Writing receiver.js...');
+  const receiverContent = fs.readFileSync(path.join(TEMPLATE_DIR, 'receiver.js'), 'utf8');
+  fs.writeFileSync(receiverPath, receiverContent);
+  fs.chmodSync(receiverPath, '755');
+
+  // Write config.js
+  console.log('Writing config.js...');
+  const configContent = fs.readFileSync(path.join(TEMPLATE_DIR, 'config.js'), 'utf8');
+  fs.writeFileSync(path.join(bonzaiDir, 'config.js'), configContent);
+
+  // Copy handlers from enabled loops
+  console.log('Copying handlers...');
+  const handlersDest = path.join(bonzaiDir, 'handlers');
+  if (!fs.existsSync(handlersDest)) {
+    fs.mkdirSync(handlersDest, { recursive: true });
+  }
+
+  // Copy visualization loop handlers
+  if (ENABLED_LOOPS.includes('visualization')) {
+    const vizSrc = path.join(TEMPLATE_DIR, 'loops', 'visualization');
+    if (fs.existsSync(vizSrc)) {
+      for (const file of fs.readdirSync(vizSrc)) {
+        fs.copyFileSync(path.join(vizSrc, file), path.join(handlersDest, file));
+      }
+    }
+  }
+
+  // Copy backend loop handlers
+  if (ENABLED_LOOPS.includes('backend')) {
+    const backendSrc = path.join(TEMPLATE_DIR, 'loops', 'backend');
+    if (fs.existsSync(backendSrc)) {
+      for (const file of fs.readdirSync(backendSrc)) {
+        fs.copyFileSync(path.join(backendSrc, file), path.join(handlersDest, file));
+      }
+    }
+  }
+
+  // Copy utils directory
+  console.log('Copying utils...');
+  const utilsSrc = path.join(TEMPLATE_DIR, 'utils');
+  const utilsDest = path.join(bonzaiDir, 'utils');
+  copyDirectory(utilsSrc, utilsDest);
+
+  // Write .ignore file in bonzai directory
+  const ignoreTargetPath = path.join(bonzaiDir, '.ignore');
+  if (!fs.existsSync(ignoreTargetPath)) {
+    console.log('Writing .ignore file...');
+    const ignoreContent = fs.readFileSync(path.join(TEMPLATE_DIR, 'ignore.txt'), 'utf8');
+    fs.writeFileSync(ignoreTargetPath, ignoreContent);
+  }
+
+  // Setup package.json 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 bonzai graph 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["@babel/parser"] = "^7.23.0";
+  packageJson.dependencies.ws = "^8.14.2";
+  packageJson.dependencies["node-pty"] = "^1.0.0";
+
+  // Add script to run receiver
+  if (!packageJson.scripts) {
+    packageJson.scripts = {};
+  }
+  packageJson.scripts["file-server"] = "node receiver.js";
+
+  fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+
+  console.log('Installing dependencies...');
+
+  // 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) {
+        // Fix node-pty spawn-helper permissions (npm doesn't preserve execute bits)
+        const nodePtyPrebuilds = path.join(bonzaiDir, 'node_modules', 'node-pty', 'prebuilds');
+        if (fs.existsSync(nodePtyPrebuilds)) {
+          const archDirs = ['darwin-arm64', 'darwin-x64', 'linux-x64', 'linux-arm64'];
+          for (const arch of archDirs) {
+            const spawnHelperPath = path.join(nodePtyPrebuilds, arch, 'spawn-helper');
+            if (fs.existsSync(spawnHelperPath)) {
+              try {
+                fs.chmodSync(spawnHelperPath, '755');
+                console.log(`Fixed node-pty spawn-helper permissions (${arch})`);
+              } catch (e) {
+                console.warn(`Warning: Could not fix spawn-helper permissions for ${arch}:`, e.message);
+              }
+            }
+          }
+        }
+
+        console.log('\nListener endpoints successfully deployed');
+        console.log('All code stays on your machine\n');
+        console.log('Relay server running on localhost:3001');
+        console.log('Terminal WebSocket available at ws://localhost:3001/terminal');
+        console.log('Diagram available at https://bonzai.dev/\n');
+
+        // Start the server automatically
+        const server = spawn('node', ['receiver.js'], {
+          stdio: 'inherit',
+          cwd: bonzaiDir,
+          env: {
+            ...process.env,
+            BONZAI_REPO_DIR: currentDir
+          }
+        });
+
+        // Open browser automatically
+        exec('open https://bonzai.dev/');
+
+        // Handle server process
+        server.on('close', (serverCode) => {
+          console.log(`\nServer 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('\nShutting down server...');
+          server.kill('SIGINT');
+        });
+
+        process.on('SIGTERM', () => {
+          console.log('\nShutting down server...');
+          server.kill('SIGTERM');
+        });
+
+        resolve();
+      } else {
+        reject(new Error('npm install failed with code ' + code));
+      }
+    });
+
+    npm.on('error', (err) => {
+      reject(err);
+    });
+  });
+}
+
+// Export for use via index.js flags
+export { main };
+
+// Run directly if called as standalone command
+const isDirectRun = process.argv[1]?.endsWith('bconfig.js');
+if (isDirectRun) {
+  main().catch(console.error);
+}

package/dist/graph-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/dist/graph-templates/ignore.txt

@@ -0,0 +1,58 @@
+# 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/
+static/
+out/
+.next/
+*.min.js
+*.min.css
+*.bundle.js
+*.chunk.js
+
+# Temporary files
+*.tmp
+*.temp
+
+# Project-specific files
+receiver.js
+bonzai/
+

package/dist/graph-templates/loops/backend/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/dist/graph-templates/loops/backend/git.js

@@ -0,0 +1,72 @@
+const { execSync } = require('child_process');
+
+// GET /git/burns - List all bonzai-burn branches
+function listBurns(req, res) {
+  try {
+    // Get all bonzai-burn branches
+    let branchOutput;
+    try {
+      branchOutput = execSync('git branch --list "bonzai-burn*"', { encoding: 'utf-8' });
+    } catch (e) {
+      // No matching branches
+      branchOutput = '';
+    }
+
+    const branches = branchOutput
+      .split('\n')
+      .filter(b => b.trim())
+      .map(b => b.trim().replace('* ', ''));
+
+    if (branches.length === 0) {
+      return res.json({ burns: [] });
+    }
+
+    // Get timestamp for each branch
+    const burns = branches.map(branch => {
+      const timestamp = execSync(`git log -1 --format=%at ${branch}`, { encoding: 'utf-8' }).trim();
+      return {
+        name: branch,
+        timestamp: parseInt(timestamp) * 1000
+      };
+    });
+
+    // Sort chronologically (oldest first)
+    burns.sort((a, b) => a.timestamp - b.timestamp);
+
+    // Get current branch
+    const currentBranch = execSync('git branch --show-current', { encoding: 'utf-8' }).trim();
+
+    res.json({
+      burns: burns.map(b => ({
+        ...b,
+        current: b.name === currentBranch
+      }))
+    });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+}
+
+// POST /git/checkout - Checkout a branch
+function checkoutBranch(req, res) {
+  try {
+    const { branchName } = req.body;
+
+    if (!branchName) {
+      return res.status(400).json({ error: 'branchName is required' });
+    }
+
+    // Validate branch name to prevent command injection
+    if (!/^[a-zA-Z0-9_\-\.\/]+$/.test(branchName)) {
+      return res.status(400).json({ error: 'Invalid branch name' });
+    }
+
+    execSync(`git checkout ${branchName}`, { encoding: 'utf-8' });
+
+    res.json({ checkedOut: branchName });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+}
+
+module.exports = { listBurns, checkoutBranch };

package/dist/graph-templates/loops/backend/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/dist/graph-templates/loops/backend/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/dist/graph-templates/loops/backend/terminal.js

@@ -0,0 +1,140 @@
+let pty;
+try {
+  pty = require('node-pty');
+} catch (err) {
+  pty = null;
+}
+
+// Store active terminal sessions
+const terminals = new Map();
+
+// Get default shell based on platform
+function getDefaultShell() {
+  if (process.platform === 'win32') {
+    return process.env.COMSPEC || 'powershell.exe';
+  }
+  const shell = process.env.SHELL || '/bin/bash';
+  if (!shell.startsWith('/')) {
+    return '/bin/bash';
+  }
+  return shell;
+}
+
+// Create a new terminal session
+function createTerminal(sessionId, cols = 80, rows = 24) {
+  if (!pty) {
+    throw new Error('node-pty is not available. Native binaries may not have installed correctly.');
+  }
+
+  const shell = getDefaultShell();
+  const cwd = process.env.BONZAI_REPO_DIR || process.cwd();
+
+  let ptyProcess;
+  try {
+    ptyProcess = pty.spawn(shell, [], {
+      name: 'xterm-256color',
+      cols,
+      rows,
+      cwd,
+      env: {
+        ...process.env,
+        TERM: 'xterm-256color',
+        PATH: process.env.PATH || '/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin'
+      }
+    });
+  } catch (spawnErr) {
+    try {
+      ptyProcess = pty.spawn('/bin/bash', [], {
+        name: 'xterm-256color',
+        cols,
+        rows,
+        cwd,
+        env: {
+          ...process.env,
+          TERM: 'xterm-256color',
+          PATH: process.env.PATH || '/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin'
+        }
+      });
+    } catch (bashErr) {
+      throw spawnErr;
+    }
+  }
+
+  terminals.set(sessionId, {
+    pty: ptyProcess,
+    buffer: ''
+  });
+
+  return ptyProcess;
+}
+
+// HTTP handler for terminal info
+function terminalHandler(req, res) {
+  res.json({
+    message: 'Terminal WebSocket API',
+    usage: {
+      websocket: 'ws://localhost:3001/terminal',
+      events: {
+        'input': 'Send terminal input (data: string)',
+        'resize': 'Resize terminal (cols: number, rows: number)',
+        'output': 'Receive terminal output'
+      }
+    }
+  });
+}
+
+// WebSocket handler for terminal sessions
+function setupTerminalWebSocket(wss) {
+  wss.on('connection', (ws) => {
+    const sessionId = Date.now().toString();
+    let ptyProcess;
+
+    try {
+      ptyProcess = createTerminal(sessionId);
+    } catch (err) {
+      ws.send(JSON.stringify({ type: 'error', message: 'Failed to create terminal: ' + err.message }));
+      ws.close();
+      return;
+    }
+
+    // Send terminal output to WebSocket client
+    ptyProcess.onData((data) => {
+      try {
+        ws.send(JSON.stringify({ type: 'output', data }));
+      } catch (e) {
+        // Client disconnected
+      }
+    });
+
+    ptyProcess.onExit(({ exitCode }) => {
+      ws.send(JSON.stringify({ type: 'exit', exitCode }));
+      ws.close();
+    });
+
+    // Handle incoming messages from client
+    ws.on('message', (message) => {
+      try {
+        const msg = JSON.parse(message);
+
+        switch (msg.type) {
+          case 'input':
+            ptyProcess.write(msg.data);
+            break;
+          case 'resize':
+            ptyProcess.resize(msg.cols, msg.rows);
+            break;
+        }
+      } catch (e) {
+        // Parse error
+      }
+    });
+
+    // Cleanup on disconnect
+    ws.on('close', () => {
+      ptyProcess.kill();
+      terminals.delete(sessionId);
+    });
+  });
+}
+
+module.exports = { terminalHandler, setupTerminalWebSocket };

package/dist/graph-templates/loops/backend/write.js

@@ -0,0 +1,18 @@
+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/dist/graph-templates/loops/visualization/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;
+