vg-coder-cli 2.0.24 → 2.0.26

package/src/server/project-manager.js

@@ -0,0 +1,353 @@
+const path = require('path');
+const fs = require('fs-extra');
+const os = require('os');
+const crypto = require('crypto');
+const chalk = require('chalk');
+const http = require('http');
+
+/**
+ * ProjectManager - Singleton for managing multiple projects in one server
+ */
+class ProjectManager {
+  constructor() {
+    if (ProjectManager.instance) {
+      return ProjectManager.instance;
+    }
+
+    this.projects = new Map(); // projectId -> ProjectContext
+    this.currentProjectId = null;
+    this.lockFilePath = path.join(os.homedir(), '.vg', 'vg-leader.lock');
+    
+    ProjectManager.instance = this;
+  }
+
+  /**
+   * Register a new project
+   * @param {string} workingDir - Absolute path to project directory
+   * @returns {string} projectId
+   */
+  registerProject(workingDir) {
+    const resolvedPath = path.resolve(workingDir);
+    const projectId = this.generateProjectId(resolvedPath);
+    
+    // Check if already registered
+    if (this.projects.has(projectId)) {
+      console.log(chalk.yellow(`⚠️  Project already registered: ${path.basename(resolvedPath)}`));
+      return projectId;
+    }
+
+    const projectContext = {
+      id: projectId,
+      name: path.basename(resolvedPath),
+      workingDir: resolvedPath,
+      active: this.projects.size === 0, // First project is active by default
+      createdAt: Date.now(),
+      lastActive: Date.now()
+    };
+
+    this.projects.set(projectId, projectContext);
+    
+    // Set as current if first project
+    if (this.projects.size === 1) {
+      this.currentProjectId = projectId;
+    }
+
+    console.log(chalk.green(`✓ Registered project: ${chalk.cyan(projectContext.name)} (${this.projects.size} total)`));
+    
+    return projectId;
+  }
+
+  /**
+   * Switch to a different project
+   * @param {string} projectId
+   * @returns {boolean} success
+   */
+  switchProject(projectId) {
+    if (!this.projects.has(projectId)) {
+      console.error(chalk.red(`❌ Project not found: ${projectId}`));
+      return false;
+    }
+
+    // Deactivate current project
+    if (this.currentProjectId) {
+      const current = this.projects.get(this.currentProjectId);
+      if (current) {
+        current.active = false;
+      }
+    }
+
+    // Activate new project
+    const newProject = this.projects.get(projectId);
+    newProject.active = true;
+    newProject.lastActive = Date.now();
+    this.currentProjectId = projectId;
+
+    console.log(chalk.blue(`Switched to project: ${chalk.cyan(newProject.name)}`));
+    
+    return true;
+  }
+
+  /**
+   * Get currently active project
+   * @returns {ProjectContext|null}
+   */
+  getActiveProject() {
+    if (!this.currentProjectId) {
+      return null;
+    }
+    return this.projects.get(this.currentProjectId);
+  }
+
+  /**
+   * Get all projects
+   * @returns {Array<ProjectContext>}
+   */
+  getAllProjects() {
+    return Array.from(this.projects.values())
+      .sort((a, b) => b.lastActive - a.lastActive); // Sort by last active
+  }
+
+  /**
+   * Remove a project
+   * @param {string} projectId
+   */
+  removeProject(projectId) {
+    const project = this.projects.get(projectId);
+    if (!project) return;
+
+    this.projects.delete(projectId);
+    console.log(chalk.yellow(`Removed project: ${project.name}`));
+
+    // If removed project was active, switch to another
+    if (projectId === this.currentProjectId) {
+      const remaining = Array.from(this.projects.keys());
+      if (remaining.length > 0) {
+        this.switchProject(remaining[0]);
+      } else {
+        this.currentProjectId = null;
+      }
+    }
+  }
+
+  /**
+   * Generate unique project ID from path
+   * @param {string} projectPath
+   * @returns {string}
+   */
+  generateProjectId(projectPath) {
+    return crypto
+      .createHash('md5')
+      .update(projectPath)
+      .digest('hex')
+      .substring(0, 8);
+  }
+
+  /**
+   * Acquire leader lock
+   * @param {number} port
+   * @param {number} pid
+   * @returns {Promise<boolean>}
+   */
+  async acquireLock(port, pid = process.pid) {
+    try {
+      // Ensure .vg directory exists
+      await fs.ensureDir(path.dirname(this.lockFilePath));
+
+      // Check if lock already exists
+      if (await fs.pathExists(this.lockFilePath)) {
+        const existingLock = await fs.readJson(this.lockFilePath);
+        
+        // Check if existing leader is still alive
+        const isAlive = await this.checkLeaderHealth(existingLock.port);
+        if (isAlive) {
+          console.log(chalk.yellow('⚠️  Leader already exists'));
+          return false;
+        } else {
+          console.log(chalk.yellow('⚠️  Stale lock file detected, cleaning up...'));
+          await fs.remove(this.lockFilePath);
+        }
+      }
+
+      // Write lock file
+      const lockData = {
+        port,
+        pid,
+        startTime: Date.now(),
+        hostname: os.hostname()
+      };
+
+      await fs.writeJson(this.lockFilePath, lockData, { spaces: 2 });
+      console.log(chalk.green(`✓ Acquired leader lock (PID: ${pid}, Port: ${port})`));
+      
+      return true;
+    } catch (error) {
+      console.error(chalk.red('❌ Failed to acquire lock:'), error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Release leader lock
+   * @returns {Promise<void>}
+   */
+  async releaseLock() {
+    try {
+      if (await fs.pathExists(this.lockFilePath)) {
+        await fs.remove(this.lockFilePath);
+        console.log(chalk.green('✓ Released leader lock'));
+      }
+    } catch (error) {
+      console.error(chalk.red('❌ Failed to release lock:'), error.message);
+    }
+  }
+
+  /**
+   * Check if leader exists and is healthy
+   * @returns {Promise<Object|null>} Leader info or null
+   */
+  async checkLeader() {
+    try {
+      if (!await fs.pathExists(this.lockFilePath)) {
+        return null;
+      }
+
+      const lockData = await fs.readJson(this.lockFilePath);
+      
+      // Check if leader is healthy
+      const isHealthy = await this.checkLeaderHealth(lockData.port);
+      
+      if (isHealthy) {
+        return lockData;
+      } else {
+        // Stale lock file
+        console.log(chalk.yellow('⚠️  Leader not responding, cleaning up stale lock...'));
+        await fs.remove(this.lockFilePath);
+        return null;
+      }
+    } catch (error) {
+      console.error(chalk.red('❌ Error checking leader:'), error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Check if leader server is healthy
+   * @param {number} port
+   * @returns {Promise<boolean>}
+   */
+  async checkLeaderHealth(port) {
+    return new Promise((resolve) => {
+      const req = http.get(`http://localhost:${port}/health`, (res) => {
+        resolve(res.statusCode === 200);
+      });
+
+      req.on('error', () => {
+        resolve(false);
+      });
+
+      req.setTimeout(2000, () => {
+        req.destroy();
+        resolve(false);
+      });
+    });
+  }
+
+  /**
+   * Join existing leader as follower
+   * @param {Object} leaderInfo
+   * @param {string} projectPath
+   * @returns {Promise<boolean>}
+   */
+  async joinLeader(leaderInfo, projectPath) {
+    try {
+      const { port } = leaderInfo;
+      const resolvedPath = path.resolve(projectPath);
+      const projectName = path.basename(resolvedPath);
+
+      console.log(chalk.blue(`\n📡 Joining leader at port ${port}...`));
+      
+      // Send registration request to leader
+      const response = await this.sendHttpRequest(port, '/api/projects/register', {
+        method: 'POST',
+        body: JSON.stringify({
+          workingDir: resolvedPath,
+          name: projectName
+        })
+      });
+
+      if (response.success) {
+        console.log(chalk.green('\n──────────────────────────────────────────────────'));
+        console.log(`🔗 ${chalk.bold('Project Registered')}    ${chalk.green('● Joined')}`);
+        console.log(chalk.gray('──────────────────────────────────────────────────'));
+        console.log(`📁 Project:   ${chalk.cyan(projectName)}`);
+        console.log(`🌐 Dashboard: ${chalk.blue(`http://localhost:${port}`)}`);
+        console.log(`📊 Total:     ${chalk.yellow(response.totalProjects)} project(s)`);
+        console.log(chalk.green('──────────────────────────────────────────────────\n'));
+        console.log(chalk.blue('💡 Open the dashboard to switch between projects.'));
+        return true;
+      } else {
+        throw new Error(response.error || 'Failed to register project');
+      }
+    } catch (error) {
+      console.error(chalk.red('❌ Failed to join leader:'), error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Send HTTP request to server
+   * @param {number} port
+   * @param {string} path
+   * @param {Object} options
+   * @returns {Promise<Object>}
+   */
+  sendHttpRequest(port, path, options = {}) {
+    return new Promise((resolve, reject) => {
+      const postData = options.body || '';
+      
+      const req = http.request({
+        hostname: 'localhost',
+        port: port,
+        path: path,
+        method: options.method || 'GET',
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(postData)
+        }
+      }, (res) => {
+        let data = '';
+        
+        res.on('data', (chunk) => {
+          data += chunk;
+        });
+        
+        res.on('end', () => {
+          try {
+            const parsed = JSON.parse(data);
+            resolve(parsed);
+          } catch (error) {
+            reject(new Error('Invalid JSON response'));
+          }
+        });
+      });
+
+      req.on('error', (error) => {
+        reject(error);
+      });
+
+      req.setTimeout(5000, () => {
+        req.destroy();
+        reject(new Error('Request timeout'));
+      });
+
+      if (postData) {
+        req.write(postData);
+      }
+      
+      req.end();
+    });
+  }
+}
+
+// Export singleton instance
+module.exports = new ProjectManager();

package/src/server/terminal-manager.js

@@ -1,10 +1,15 @@
 const os = require('os');
 const pty = require('node-pty');
+const path = require('path');
+const { stripAnsiCodes, classifyLogLine, extractErrors } = require(path.join(__dirname, 'views/js/utils/log-utils'));
 
 class TerminalManager {
     constructor() {
-        // Map: termId -> { process: pty, socketId: string }
+        // Map: termId -> { process: pty, socketId: string, projectId: string }
         this.sessions = new Map();
+        // Map: termId -> Array of log lines (circular buffer, max 10000)
+        this.logBuffers = new Map();
+        this.MAX_LOG_LINES = 10000;
         // Use full path to shell to avoid posix_spawnp errors
         if (os.platform() === 'win32') {
             this.shell = 'powershell.exe';
@@ -17,7 +22,7 @@ class TerminalManager {
         }
     }
 
-    createTerminal(socket, termId, cols = 80, rows = 24, cwd) {
+    createTerminal(socket, termId, cols = 80, rows = 24, cwd, projectId = null) {
         try {
             const term = pty.spawn(this.shell, [], {
                 name: 'xterm-256color',
@@ -29,11 +34,19 @@ class TerminalManager {
 
             this.sessions.set(termId, {
                 process: term,
-                socketId: socket.id
+                socketId: socket.id,
+                projectId: projectId  // Store project association
             });
 
+            // Initialize log buffer for this terminal
+            this.logBuffers.set(termId, []);
+
             // Gửi dữ liệu kèm theo termId để Frontend biết của cửa sổ nào
             term.onData((data) => {
+                // Store in log buffer (strip ANSI for storage)
+                this.addToLogBuffer(termId, data);
+                
+                // Send raw data to frontend (keep ANSI for display)
                 socket.emit('terminal:data', { termId, data });
             });
 
@@ -41,6 +54,8 @@ class TerminalManager {
                 if (this.sessions.has(termId)) {
                     socket.emit('terminal:exit', { termId });
                     this.sessions.delete(termId);
+                    // Clean up log buffer
+                    this.logBuffers.delete(termId);
                 }
             });
 
@@ -83,8 +98,120 @@ class TerminalManager {
             if (session.socketId === socketId) {
                 session.process.kill();
                 this.sessions.delete(termId);
+                this.logBuffers.delete(termId);
+            }
+        }
+    }
+
+    /**
+     * Add data to log buffer (circular buffer with max 10000 lines)
+     * @param {string} termId - Terminal ID
+     * @param {string} data - Raw terminal data (may contain ANSI codes)
+     */
+    addToLogBuffer(termId, data) {
+        if (!this.logBuffers.has(termId)) {
+            this.logBuffers.set(termId, []);
+        }
+
+        const buffer = this.logBuffers.get(termId);
+        
+        // Strip ANSI codes before storing
+        const cleanData = stripAnsiCodes(data);
+        
+        // Split by newlines and add to buffer
+        const lines = cleanData.split(/\r?\n/);
+        
+        lines.forEach(line => {
+            // Only add non-empty lines
+            if (line.trim().length > 0) {
+                buffer.push(line);
+                
+                // Maintain circular buffer - remove oldest if exceeds limit
+                if (buffer.length > this.MAX_LOG_LINES) {
+                    buffer.shift();
+                }
             }
+        });
+    }
+
+    /**
+     * Get log buffer for a terminal
+     * @param {string} termId - Terminal ID
+     * @returns {string[]} Array of log lines
+     */
+    getLogBuffer(termId) {
+        return this.logBuffers.get(termId) || [];
+    }
+
+    /**
+     * Analyze log buffer and return statistics
+     * @param {string} termId - Terminal ID
+     * @returns {Object} Analysis with error counts, line counts, etc.
+     */
+    analyzeLogBuffer(termId) {
+        const lines = this.getLogBuffer(termId);
+        
+        if (lines.length === 0) {
+            return {
+                totalLines: 0,
+                errorLines: 0,
+                warningLines: 0,
+                normalLines: 0,
+                errors: []
+            };
         }
+
+        let errorCount = 0;
+        let warningCount = 0;
+        let normalCount = 0;
+
+        lines.forEach(line => {
+            const type = classifyLogLine(line);
+            if (type === 'ERROR') errorCount++;
+            else if (type === 'WARNING') warningCount++;
+            else normalCount++;
+        });
+
+        const errors = extractErrors(lines, 2);
+
+        return {
+            totalLines: lines.length,
+            errorLines: errorCount,
+            warningLines: warningCount,
+            normalLines: normalCount,
+            errors: errors.map(e => ({
+                line: e.line,
+                type: e.type,
+                lineIndex: e.lineIndex
+            }))
+        };
+    }
+
+    /**
+     * Get all terminal IDs for a specific project
+     * @param {string} projectId - Project ID
+     * @returns {string[]} Array of terminal IDs
+     */
+    getProjectTerminals(projectId) {
+        const terminals = [];
+        for (const [termId, session] of this.sessions.entries()) {
+            if (session.projectId === projectId) {
+                terminals.push(termId);
+            }
+        }
+        return terminals;
+    }
+
+    /**
+     * Clean up all terminals for a project
+     * @param {string} projectId - Project ID
+     */
+    cleanupProject(projectId) {
+        const terminalsToRemove = this.getProjectTerminals(projectId);
+        terminalsToRemove.forEach(termId => {
+            this.kill(termId);
+        });
+        console.log(`Cleaned up ${terminalsToRemove.length} terminal(s) for project ${projectId}`);
     }
 }
 

package/src/server/views/css/iframe.css

@@ -251,6 +251,7 @@
     .right-panel {
         flex: 1;
         height: 50vh;
+        display: none;
     }
 
     .extension-guide-center {

package/src/server/views/css/terminal.css

@@ -69,6 +69,94 @@
     text-overflow: ellipsis;
 }
 
+/* Copy Button Group */
+.terminal-copy-group {
+    display: flex;
+    gap: 4px;
+    margin-left: auto;
+    margin-right: 8px;
+    align-items: center;
+}
+
+.copy-btn {
+    padding: 3px 6px;
+    font-size: 10px;
+    border-radius: 3px;
+    background: #2d2d30;
+    border: 1px solid #3e3e42;
+    color: #ccc;
+    cursor: pointer;
+    transition: all 0.2s;
+    display: flex;
+    align-items: center;
+    gap: 3px;
+    white-space: nowrap;
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+}
+
+.copy-btn:hover {
+    background: #3e3e42;
+    border-color: #555;
+    transform: translateY(-1px);
+}
+
+.copy-btn:active {
+    transform: translateY(0);
+}
+
+.token-badge {
+    font-size: 9px;
+    color: #888;
+    font-weight: 600;
+    min-width: 20px;
+    text-align: right;
+}
+
+/* Specific button colors */
+.copy-smart:hover {
+    border-color: #4a9eff;
+}
+
+.copy-errors:hover {
+    border-color: #f48771;
+}
+
+.copy-recent:hover {
+    border-color: #89d185;
+}
+
+.copy-all:hover {
+    border-color: #dcdcaa;
+}
+
+/* Clear Button */
+.term-btn-clear {
+    width: 24px;
+    height: 24px;
+    border-radius: 4px;
+    background: #2d2d30;
+    border: 1px solid #3e3e42;
+    color: #ccc;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 14px;
+    margin-left: 4px;
+    margin-right: 8px;
+    transition: all 0.2s;
+}
+
+.term-btn-clear:hover {
+    background: #3e3e42;
+    border-color: #f48771;
+    transform: translateY(-1px);
+}
+
+.term-btn-clear:active {
+    transform: translateY(0);
+}
+
 .terminal-controls {
     display: flex;
     gap: 6px;