vg-coder-cli 2.0.11 → 2.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vg-coder-cli",
-  "version": "2.0.11",
+  "version": "2.0.14",
   "description": "🚀 CLI tool to analyze projects, concatenate source files, count tokens, and export HTML with syntax highlighting and copy functionality",
   "main": "src/index.js",
   "bin": {
@@ -21,19 +21,8 @@
     "code-analysis",
     "token-counter",
     "ai-helper",
-    "gitignore",
-    "html-export",
-    "syntax-highlighting",
-    "project-analyzer",
-    "source-code",
-    "tiktoken",
-    "spring-boot",
-    "angular",
-    "react",
-    "vue",
-    "java",
-    "javascript",
-    "typescript"
+    "terminal",
+    "web-terminal"
   ],
   "author": "VG Coder",
   "license": "MIT",
@@ -41,10 +30,6 @@
     "type": "git",
     "url": "https://github.com/tinhthanh/vg-coder-cli.git"
   },
-  "bugs": {
-    "url": "https://github.com/tinhthanh/vg-coder-cli/issues"
-  },
-  "homepage": "https://github.com/tinhthanh/vg-coder-cli#readme",
   "dependencies": {
     "commander": "^11.1.0",
     "directory-tree": "^3.5.1",
@@ -57,7 +42,9 @@
     "ora": "^5.4.1",
     "express": "^4.18.2",
     "cors": "^2.8.5",
-    "body-parser": "^1.20.2"
+    "body-parser": "^1.20.2",
+    "node-pty": "^1.0.0",
+    "socket.io": "^4.7.2"
   },
   "devDependencies": {
     "jest": "^29.7.0",

package/src/server/api-server.js

@@ -4,379 +4,175 @@ const bodyParser = require('body-parser');
 const path = require('path');
 const fs = require('fs-extra');
 const chalk = require('chalk');
+const http = require('http');
+const { Server } = require('socket.io');
+const { exec } = require('child_process');
+const util = require('util');
+const execAsync = util.promisify(exec);
 const packageJson = require('../../package.json');
 
 const ProjectDetector = require('../detectors/project-detector');
 const FileScanner = require('../scanner/file-scanner');
 const TokenManager = require('../tokenizer/token-manager');
 const BashExecutor = require('../utils/bash-executor');
+const terminalManager = require('./terminal-manager');
 
-/**
- * API Server for VG Coder CLI
- */
 class ApiServer {
   constructor(port = 6868) {
     this.port = port;
     this.app = express();
+    
+    // Create HTTP server for Socket.IO
+    this.httpServer = http.createServer(this.app);
+    this.io = new Server(this.httpServer, {
+        cors: { origin: "*" }
+    });
+    
     this.server = null;
-    this.workingDir = process.cwd(); // Track working directory
+    this.workingDir = process.cwd();
     this.setupMiddleware();
     this.setupRoutes();
+    this.setupSocketIO();
   }
 
-  /**
-   * Setup Express middleware
-   */
   setupMiddleware() {
     this.app.use(cors());
-    this.app.use(bodyParser.json({ limit: '50mb' })); // Increase limit for large file lists
+    this.app.use(bodyParser.json({ limit: '50mb' }));
     this.app.use(bodyParser.urlencoded({ extended: true, limit: '50mb' }));
-    
-    // Serve static files from views directory (CSS, JS)
     this.app.use(express.static(path.join(__dirname, 'views')));
     
-    // Request logging
     this.app.use((req, res, next) => {
-      console.log(chalk.blue(`[${new Date().toISOString()}] ${req.method} ${req.path}`));
+      if (!req.path.includes('.')) {
+          console.log(chalk.blue(`[REQ] ${req.method} ${req.path}`));
+      }
       next();
     });
   }
 
-  /**
-   * Setup API routes
-   */
-  setupRoutes() {
-    // Dashboard - serve HTML interface
-    this.app.get('/', (req, res) => {
-      res.sendFile(path.join(__dirname, 'views', 'dashboard.html'));
-    });
+  setupSocketIO() {
+    this.io.on('connection', (socket) => {
+        // Nhận event init với termId
+        // FIX: Thêm default value = {} để tránh crash khi data undefined
+        socket.on('terminal:init', (data) => {
+            if (!data || !data.termId) {
+                // console.warn('[Socket] Ignored invalid terminal:init', data);
+                return;
+            }
+            const { termId, cols, rows } = data;
+            terminalManager.createTerminal(socket, termId, cols, rows, this.workingDir);
+        });
 
-    // Health check
-    this.app.get('/health', (req, res) => {
-      res.json({
-        status: 'ok',
-        version: packageJson.version,
-        timestamp: new Date().toISOString()
-      });
+        socket.on('terminal:input', (data) => {
+             if (data && data.termId) {
+                terminalManager.write(data.termId, data.data);
+             }
+        });
+
+        socket.on('terminal:resize', (data) => {
+            if (data && data.termId) {
+                terminalManager.resize(data.termId, data.cols, data.rows);
+            }
+        });
+        
+        socket.on('terminal:kill', (data) => {
+            if (data && data.termId) {
+                terminalManager.kill(data.termId);
+            }
+        });
+
+        socket.on('disconnect', () => {
+            terminalManager.cleanupSocket(socket.id);
+        });
     });
+  }
+
+  setupRoutes() {
+    this.app.get('/', (req, res) => res.sendFile(path.join(__dirname, 'views', 'dashboard.html')));
+    this.app.get('/health', (req, res) => res.json({ status: 'ok', version: packageJson.version }));
 
-    // NEW: Get Extension Path
     this.app.get('/api/extension-path', (req, res) => {
       try {
         const extensionPath = path.join(__dirname, 'views', 'vg-coder');
-        const exists = fs.existsSync(extensionPath);
-        
-        res.json({
-          path: extensionPath,
-          exists: exists
-        });
+        res.json({ path: extensionPath, exists: fs.existsSync(extensionPath) });
       } catch (error) {
         res.status(500).json({ error: error.message });
       }
     });
 
-    // Analyze endpoint - returns project.txt file
-    this.app.post('/api/analyze', async (req, res) => {
+    this.app.get('/api/git/diff', async (req, res) => {
       try {
-        const { path: projectPath, options = {}, specificFiles } = req.body;
-
-        if (!projectPath) {
-          return res.status(400).json({
-            error: 'Missing required field: path'
-          });
-        }
-
-        const resolvedPath = path.resolve(projectPath);
-
-        // Validate project path
-        if (!await fs.pathExists(resolvedPath)) {
-          return res.status(404).json({
-            error: `Project path does not exist: ${projectPath}`
-          });
-        }
-
-        console.log(chalk.yellow(`Analyzing project: ${resolvedPath}`));
-        if (specificFiles) {
-             console.log(chalk.yellow(`Filtering for ${specificFiles.length} specific files`));
-        }
-
-        // Detect project type
-        const detector = new ProjectDetector(resolvedPath);
-        const projectInfo = await detector.detectAll();
-
-        // Scan files (no token limit, get all files)
-        const scannerOptions = {
-          extensions: options.extensions ? options.extensions.split(',').map(ext => ext.trim()) : undefined,
-          includeHidden: options.includeHidden || false
-        };
-
-        const scanner = new FileScanner(resolvedPath, scannerOptions);
-        const scanResult = await scanner.scanProject();
-
-        let filesToProcess = scanResult.files;
-
-        // Filter specific files if requested
-        if (specificFiles && Array.isArray(specificFiles) && specificFiles.length > 0) {
-            filesToProcess = filesToProcess.filter(file => specificFiles.includes(file.relativePath));
-        }
-
-        // Create AI-friendly content
-        const aiContent = await scanner.createCombinedContentForAI(filesToProcess, {
-          includeStats: true,
-          includeTree: true,
-          preserveLineNumbers: true
+        const { stdout, stderr } = await execAsync('git diff HEAD', { 
+            cwd: this.workingDir,
+            maxBuffer: 20 * 1024 * 1024 
         });
-
-        // Set response headers for file download
-        res.setHeader('Content-Type', 'text/plain; charset=utf-8');
-        res.setHeader('Content-Disposition', 'attachment; filename="project.txt"');
-        res.send(aiContent);
-
-        console.log(chalk.green(`✓ Analysis completed: ${filesToProcess.length} files`));
-
+        res.json({ diff: stdout });
       } catch (error) {
-        console.error(chalk.red('Error during analysis:'), error);
-        res.status(500).json({
-          error: 'Analysis failed',
-          message: error.message
-        });
+        console.error(chalk.red('❌ [GIT] Error:'), error.message);
+        res.json({ diff: '', error: error.message });
       }
     });
 
-    // Info endpoint
+    this.app.post('/api/analyze', async (req, res) => {
+        const { path: projectPath, options = {}, specificFiles } = req.body;
+        if (!projectPath) return res.status(400).json({ error: 'Missing path' });
+        const resolvedPath = path.resolve(projectPath);
+        if (!await fs.pathExists(resolvedPath)) return res.status(404).json({ error: 'Path not found' });
+        const scanner = new FileScanner(resolvedPath, {
+          extensions: options.extensions ? options.extensions.split(',') : undefined,
+          includeHidden: options.includeHidden
+        });
+        let scanResult = await scanner.scanProject();
+        let filesToProcess = scanResult.files;
+        if (specificFiles?.length) filesToProcess = filesToProcess.filter(f => specificFiles.includes(f.relativePath));
+        const content = await scanner.createCombinedContentForAI(filesToProcess, { includeStats: true, preserveLineNumbers: true });
+        res.send(content);
+    });
+
     this.app.get('/api/info', async (req, res) => {
-      try {
         const projectPath = req.query.path;
-
-        if (!projectPath) {
-          return res.status(400).json({
-            error: 'Missing required query parameter: path'
-          });
-        }
-
+        if (!projectPath) return res.status(400).json({ error: 'Missing path' });
         const resolvedPath = path.resolve(projectPath);
-
-        if (!await fs.pathExists(resolvedPath)) {
-          return res.status(404).json({
-            error: `Project path does not exist: ${projectPath}`
-          });
-        }
-
-        // Detect project
         const detector = new ProjectDetector(resolvedPath);
         const projectInfo = await detector.detectAll();
-
-        // Quick scan
         const scanner = new FileScanner(resolvedPath);
         const scanResult = await scanner.scanProject();
-
-        // Token analysis
-        const tokenManager = new TokenManager();
-        const tokenAnalysis = tokenManager.analyzeFiles(scanResult.files);
-        tokenManager.cleanup();
-
-        const extensions = [...new Set(scanResult.files.map(f => f.extension))].filter(Boolean);
-
-        res.json({
-          path: resolvedPath,
-          primaryType: projectInfo.primary,
-          detectedTechnologies: projectInfo.detected,
-          stats: {
-            totalFiles: scanResult.stats.processedFiles,
-            totalSize: scanResult.files.reduce((sum, f) => sum + f.size, 0),
-            totalLines: scanResult.files.reduce((sum, f) => sum + f.lines, 0),
-            extensions: extensions
-          },
-          tokens: {
-            total: tokenAnalysis.summary.totalTokens,
-            averagePerFile: tokenAnalysis.summary.averageTokensPerFile,
-            filesExceedingLimit: tokenAnalysis.summary.filesExceedingLimit,
-            estimatedChunks: tokenAnalysis.summary.estimatedChunks
-          }
-        });
-
-        console.log(chalk.green(`✓ Info retrieved for: ${resolvedPath}`));
-
-      } catch (error) {
-        console.error(chalk.red('Error getting info:'), error);
-        res.status(500).json({
-          error: 'Failed to get project info',
-          message: error.message
-        });
-      }
+        res.json({ path: resolvedPath, primaryType: projectInfo.primary, stats: { totalFiles: scanResult.files.length } });
     });
 
-    // Structure endpoint
     this.app.get('/api/structure', async (req, res) => {
-      try {
         const projectPath = req.query.path || '.';
         const resolvedPath = path.resolve(projectPath);
-
-        // Validate path
-        if (!await fs.pathExists(resolvedPath)) {
-          return res.status(404).json({
-            error: `Project path does not exist: ${projectPath}`
-          });
-        }
-
-        console.log(chalk.yellow(`Analyzing structure for: ${resolvedPath}`));
-
-        // 1. Scan files
         const scanner = new FileScanner(resolvedPath);
         const scanResult = await scanner.scanProject();
-
-        // 2. Tokenize tree
         const tokenManager = new TokenManager();
         const enrichedTree = tokenManager.analyzeTree(scanResult.tree, scanResult.files);
-        
-        tokenManager.cleanup();
-
-        // 3. Return result
-        res.json({
-          path: resolvedPath,
-          totalFiles: scanResult.files.length,
-          rootTokens: enrichedTree.tokens,
-          structure: enrichedTree
-        });
-
-        console.log(chalk.green(`✓ Structure analysis completed: ${scanResult.files.length} files`));
-
-      } catch (error) {
-        console.error(chalk.red('Error getting structure:'), error);
-        res.status(500).json({
-          error: 'Failed to get structure',
-          message: error.message
-        });
-      }
+        res.json({ path: resolvedPath, structure: enrichedTree });
     });
 
-    // Clean endpoint
-    this.app.delete('/api/clean', async (req, res) => {
-      try {
-        const { output } = req.body;
-
-        if (!output) {
-          return res.status(400).json({
-            error: 'Missing required field: output'
-          });
-        }
-
-        const outputPath = path.resolve(output);
-
-        if (await fs.pathExists(outputPath)) {
-          await fs.remove(outputPath);
-          res.json({
-            success: true,
-            message: `Cleaned: ${outputPath}`
-          });
-          console.log(chalk.green(`✓ Cleaned: ${outputPath}`));
-        } else {
-          res.json({
-            success: true,
-            message: 'Output directory does not exist'
-          });
-        }
-
-      } catch (error) {
-        console.error(chalk.red('Error cleaning:'), error);
-        res.status(500).json({
-          error: 'Failed to clean',
-          message: error.message
-        });
-      }
-    });
-
-    // Execute bash script endpoint
     this.app.post('/api/execute', async (req, res) => {
-      try {
         const { bash } = req.body;
-
-        if (!bash) {
-          return res.status(400).json({
-            error: 'Missing required field: bash'
-          });
-        }
-
-        console.log(chalk.yellow(`Executing bash script (${bash.length} chars)...`));
-
-        // Create executor with working directory
         const executor = new BashExecutor(this.workingDir);
-
-        // Execute script (validates syntax first, then executes)
         const result = await executor.execute(bash);
-
-        if (result.success) {
-          console.log(chalk.green(`✓ Bash execution completed in ${result.executionTime}ms`));
-          res.json(result);
-        } else {
-          // Check if it's a syntax error
-          const isSyntaxError = result.error === 'Syntax validation failed';
-          console.log(chalk.red(`✗ Bash execution failed: ${result.error || 'Exit code ' + result.exitCode}`));
-          res.status(400).json({
-            ...result,
-            syntaxError: isSyntaxError
-          });
-        }
-
-      } catch (error) {
-        console.error(chalk.red('Error executing bash:'), error);
-        res.status(500).json({
-          error: 'Execution failed',
-          message: error.message
-        });
-      }
-    });
-
-    // 404 handler
-    this.app.use((req, res) => {
-      res.status(404).json({
-        error: 'Not found',
-        message: `Route ${req.method} ${req.path} not found`
-      });
+        res.status(result.success ? 200 : 400).json(result);
     });
-
-    // Error handler
-    this.app.use((err, req, res, next) => {
-      console.error(chalk.red('Server error:'), err);
-      res.status(500).json({
-        error: 'Internal server error',
-        message: err.message
-      });
+    
+    this.app.delete('/api/clean', async (req, res) => {
+        await fs.remove(path.resolve(req.body.output));
+        res.json({ success: true });
     });
   }
 
-  /**
-   * Start the server
-   */
   async start() {
-    return new Promise((resolve, reject) => {
-      this.server = this.app.listen(this.port, () => {
-        console.log(chalk.green(`\n🚀 VG Coder API Server started!`));
-        console.log(chalk.blue(`📡 Listening on: http://localhost:${this.port}`));
-        console.log(chalk.cyan(`\n🎨 Dashboard: http://localhost:${this.port}`));
+    return new Promise((resolve) => {
+      this.server = this.httpServer.listen(this.port, () => {
+        console.log(chalk.green(`\n🚀 VG Coder API Server & Socket.IO started on port ${this.port}`));
         resolve();
       });
-
-      this.server.on('error', (err) => {
-        reject(err);
-      });
     });
   }
 
-  /**
-   * Stop the server
-   */
   async stop() {
-    return new Promise((resolve) => {
-      if (this.server) {
-        this.server.close(() => {
-          console.log(chalk.yellow('\n👋 Server stopped\n'));
-          resolve();
-        });
-      } else {
-        resolve();
-      }
-    });
+    if (this.server) this.server.close();
   }
 }
 

package/src/server/terminal-manager.js

@@ -0,0 +1,82 @@
+const os = require('os');
+const pty = require('node-pty');
+
+class TerminalManager {
+    constructor() {
+        // Map: termId -> { process: pty, socketId: string }
+        this.sessions = new Map();
+        this.shell = os.platform() === 'win32' ? 'powershell.exe' : 'bash';
+    }
+
+    createTerminal(socket, termId, cols = 80, rows = 24, cwd) {
+        try {
+            const term = pty.spawn(this.shell, [], {
+                name: 'xterm-256color',
+                cols: cols,
+                rows: rows,
+                cwd: cwd || process.cwd(),
+                env: process.env
+            });
+
+            this.sessions.set(termId, {
+                process: term,
+                socketId: socket.id
+            });
+
+            // Gửi dữ liệu kèm theo termId để Frontend biết của cửa sổ nào
+            term.onData((data) => {
+                socket.emit('terminal:data', { termId, data });
+            });
+
+            term.onExit(() => {
+                if (this.sessions.has(termId)) {
+                    socket.emit('terminal:exit', { termId });
+                    this.sessions.delete(termId);
+                }
+            });
+
+            return term;
+        } catch (error) {
+            console.error('Failed to create terminal:', error);
+            socket.emit('terminal:error', { termId, error: 'Failed to create process' });
+        }
+    }
+
+    write(termId, data) {
+        const session = this.sessions.get(termId);
+        if (session) {
+            session.process.write(data);
+        }
+    }
+
+    resize(termId, cols, rows) {
+        const session = this.sessions.get(termId);
+        if (session) {
+            try {
+                session.process.resize(cols, rows);
+            } catch (err) {
+                // Ignore resize errors
+            }
+        }
+    }
+
+    kill(termId) {
+        const session = this.sessions.get(termId);
+        if (session) {
+            session.process.kill();
+            this.sessions.delete(termId);
+        }
+    }
+
+    // Dọn dẹp tất cả terminal của một socket khi client disconnect
+    cleanupSocket(socketId) {
+        for (const [termId, session] of this.sessions.entries()) {
+            if (session.socketId === socketId) {
+                session.process.kill();
+                this.sessions.delete(termId);
+            }
+        }
+    }
+}
+
+module.exports = new TerminalManager();