devbonzai 2.2.302 → 2.2.304

package/cli.js

@@ -109,6 +109,8 @@ async function main() {
   packageJson.dependencies.express = "^4.18.2";
   packageJson.dependencies.cors = "^2.8.5";
   packageJson.dependencies["@babel/parser"] = "^7.23.0";
+  packageJson.dependencies["node-pty"] = "^1.0.0";
+  packageJson.dependencies.ws = "^8.16.0";
   
   // Add script to run receiver
   if (!packageJson.scripts) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devbonzai",
-  "version": "2.2.302",
+  "version": "2.2.304",
   "description": "Quickly set up a local file server in any repository for browser-based file access",
   "main": "cli.js",
   "bin": {
@@ -24,6 +24,8 @@
   "dependencies": {
     "express": "^4.18.2",
     "cors": "^2.8.5",
-    "@babel/parser": "^7.23.0"
+    "@babel/parser": "^7.23.0",
+    "node-pty": "^1.0.0",
+    "ws": "^8.16.0"
   }
 }

package/templates/handlers/index.js

@@ -7,7 +7,9 @@ function indexHandler(req, res) {
       'GET /read?path=<filepath>': 'Read file content',
       'POST /delete': 'Delete file or directory (body: {path})',
       'POST /open-cursor': 'Open Cursor (body: {path, line?})',
-      'POST /shutdown': 'Gracefully shutdown the server'
+      'POST /shutdown': 'Gracefully shutdown the server',
+      'POST /scan_code_quality': 'Scan code quality (body: {projectPath})',
+      'WS /terminal?cwd=<path>': 'WebSocket terminal connection (optional cwd query param)'
     },
     example: 'Try: /list or /read?path=README.md'
   });

package/templates/handlers/scan_code_quality.js

@@ -0,0 +1,144 @@
+const fs = require('fs');
+const path = require('path');
+const { ROOT } = require('../config');
+
+function scanCodeQualityHandler(req, res) {
+  try {
+    const { projectPath } = req.body;
+    
+    if (!projectPath) {
+      return res.status(400).json({ error: 'projectPath is required' });
+    }
+    
+    const targetPath = path.join(ROOT, projectPath);
+    
+    if (!targetPath.startsWith(ROOT)) {
+      return res.status(400).json({ error: 'Invalid path' });
+    }
+    
+    if (!fs.existsSync(targetPath)) {
+      return res.status(404).json({ error: 'Path not found' });
+    }
+    
+    const issues = [];
+    
+    // Basic code quality checks
+    function scanDirectory(dir) {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        const relativePath = path.relative(ROOT, fullPath);
+        
+        // Skip node_modules and other ignored directories
+        if (entry.name === 'node_modules' || entry.name === '.git' || entry.name === 'bonzai') {
+          continue;
+        }
+        
+        if (entry.isDirectory()) {
+          scanDirectory(fullPath);
+        } else if (entry.isFile()) {
+          // Check file size (warn if > 500KB)
+          const stats = fs.statSync(fullPath);
+          if (stats.size > 500 * 1024) {
+            issues.push({
+              file: relativePath,
+              severity: 'warning',
+              message: `Large file detected (${(stats.size / 1024).toFixed(2)}KB). Consider splitting into smaller modules.`,
+              type: 'file-size'
+            });
+          }
+          
+          // Check for common code quality issues in JS/TS files
+          if (entry.name.endsWith('.js') || entry.name.endsWith('.jsx') || 
+              entry.name.endsWith('.ts') || entry.name.endsWith('.tsx')) {
+            try {
+              const content = fs.readFileSync(fullPath, 'utf8');
+              const lines = content.split('\n');
+              
+              // Check for very long lines
+              lines.forEach((line, index) => {
+                if (line.length > 200) {
+                  issues.push({
+                    file: relativePath,
+                    line: index + 1,
+                    severity: 'info',
+                    message: `Long line detected (${line.length} characters). Consider breaking into multiple lines.`,
+                    type: 'line-length'
+                  });
+                }
+              });
+              
+              // Check for TODO/FIXME comments
+              lines.forEach((line, index) => {
+                if (line.match(/TODO|FIXME|XXX|HACK/i)) {
+                  issues.push({
+                    file: relativePath,
+                    line: index + 1,
+                    severity: 'info',
+                    message: `TODO/FIXME comment found: ${line.trim().substring(0, 100)}`,
+                    type: 'todo-comment'
+                  });
+                }
+              });
+              
+              // Check for console.log statements (potential debug code)
+              lines.forEach((line, index) => {
+                if (line.match(/console\.(log|debug|info|warn|error)/) && !line.includes('//')) {
+                  issues.push({
+                    file: relativePath,
+                    line: index + 1,
+                    severity: 'warning',
+                    message: `Console statement found. Consider removing or using a proper logging library.`,
+                    type: 'console-statement'
+                  });
+                }
+              });
+              
+            } catch (e) {
+              // Skip files that can't be read
+            }
+          }
+        }
+      }
+    }
+    
+    const stat = fs.statSync(targetPath);
+    if (stat.isDirectory()) {
+      scanDirectory(targetPath);
+    } else {
+      // Single file scan
+      const relativePath = path.relative(ROOT, targetPath);
+      const content = fs.readFileSync(targetPath, 'utf8');
+      const lines = content.split('\n');
+      
+      lines.forEach((line, index) => {
+        if (line.length > 200) {
+          issues.push({
+            file: relativePath,
+            line: index + 1,
+            severity: 'info',
+            message: `Long line detected (${line.length} characters)`,
+            type: 'line-length'
+          });
+        }
+      });
+    }
+    
+    res.json({
+      success: true,
+      issues: issues,
+      totalIssues: issues.length,
+      summary: {
+        errors: issues.filter(i => i.severity === 'error').length,
+        warnings: issues.filter(i => i.severity === 'warning').length,
+        info: issues.filter(i => i.severity === 'info').length
+      }
+    });
+    
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+}
+
+module.exports = scanCodeQualityHandler;

package/templates/handlers/terminal.js

@@ -0,0 +1,92 @@
+const pty = require('node-pty');
+
+// Store active terminal sessions
+const terminals = new Map();
+
+function handleTerminalConnection(ws, workingDirectory) {
+  const shell = process.platform === 'win32' ? 'powershell.exe' : 'zsh';
+  const cwd = workingDirectory || process.env.HOME;
+  
+  console.log('🖥️  Terminal session started in:', cwd);
+  
+  const ptyProcess = pty.spawn(shell, [], {
+    name: 'xterm-256color',
+    cols: 80,
+    rows: 24,
+    cwd: cwd,
+    env: {
+      ...process.env,
+      TERM: 'xterm-256color',
+      COLORTERM: 'truecolor',
+    },
+  });
+
+  const terminalId = Date.now().toString();
+  terminals.set(terminalId, { pty: ptyProcess, ws });
+
+  // Send PTY output to WebSocket
+  ptyProcess.onData((data) => {
+    try {
+      if (ws.readyState === 1) { // WebSocket.OPEN
+        ws.send(data);
+      }
+    } catch (err) {
+      console.error('Error sending to WebSocket:', err);
+    }
+  });
+
+  // Handle incoming messages from WebSocket
+  ws.on('message', (msg) => {
+    try {
+      const message = msg.toString();
+      
+      // Check if it's a resize command
+      if (message.startsWith('\x1b[8;')) {
+        // Parse resize: ESC[8;rows;colst
+        const match = message.match(/\x1b\[8;(\d+);(\d+)t/);
+        if (match) {
+          const rows = parseInt(match[1], 10);
+          const cols = parseInt(match[2], 10);
+          ptyProcess.resize(cols, rows);
+          return;
+        }
+      }
+      
+      // Check for JSON resize command
+      if (message.startsWith('{')) {
+        try {
+          const json = JSON.parse(message);
+          if (json.type === 'resize' && json.cols && json.rows) {
+            ptyProcess.resize(json.cols, json.rows);
+            return;
+          }
+        } catch (e) {
+          // Not JSON, treat as regular input
+        }
+      }
+      
+      // Regular terminal input
+      ptyProcess.write(message);
+    } catch (err) {
+      console.error('Error processing message:', err);
+    }
+  });
+
+  // Clean up on WebSocket close
+  ws.on('close', () => {
+    console.log('🖥️  Terminal session closed');
+    ptyProcess.kill();
+    terminals.delete(terminalId);
+  });
+
+  // Handle PTY exit
+  ptyProcess.onExit(({ exitCode, signal }) => {
+    console.log(`🖥️  Terminal process exited (code: ${exitCode}, signal: ${signal})`);
+    terminals.delete(terminalId);
+    if (ws.readyState === 1) {
+      ws.close();
+    }
+  });
+}
+
+module.exports = { handleTerminalConnection };

package/templates/receiver.js

@@ -2,6 +2,8 @@
 
 const express = require('./node_modules/express');
 const cors = require('./node_modules/cors');
+const WebSocket = require('./node_modules/ws');
+const { ROOT } = require('./config');
 
 // Import handlers
 const indexHandler = require('./handlers/index');
@@ -10,6 +12,8 @@ const readHandler = require('./handlers/read');
 const deleteHandler = require('./handlers/delete');
 const openCursorHandler = require('./handlers/open-cursor');
 const shutdownHandler = require('./handlers/shutdown');
+const scanCodeQualityHandler = require('./handlers/scan_code_quality');
+const { handleTerminalConnection } = require('./handlers/terminal');
 
 const app = express();
 
@@ -23,8 +27,33 @@ app.get('/read', readHandler);
 app.post('/delete', deleteHandler);
 app.post('/open-cursor', openCursorHandler);
 app.post('/shutdown', shutdownHandler);
+app.post('/scan_code_quality', scanCodeQualityHandler);
 
 const port = 3001;
-app.listen(port, () => {
+const server = app.listen(port, () => {
   console.log('📂 File server running on http://localhost:' + port);
 });
+
+// WebSocket server for terminal
+const wss = new WebSocket.Server({ 
+  server,
+  path: '/terminal'
+});
+
+wss.on('connection', (ws, req) => {
+  // Extract working directory from query string if provided
+  let workingDirectory = ROOT;
+  
+  if (req.url) {
+    const urlMatch = req.url.match(/[?&]cwd=([^&]+)/);
+    if (urlMatch) {
+      try {
+        workingDirectory = decodeURIComponent(urlMatch[1]);
+      } catch (e) {
+        console.warn('Invalid cwd parameter, using default:', e.message);
+      }
+    }
+  }
+  
+  handleTerminalConnection(ws, workingDirectory);
+});