claude-code-workflow 6.0.5 → 6.1.1

package/ccw/src/core/server.js

@@ -1,6 +1,6 @@
 import http from 'http';
 import { URL } from 'url';
-import { readFileSync, writeFileSync, existsSync, readdirSync, mkdirSync, promises as fsPromises } from 'fs';
+import { readFileSync, writeFileSync, existsSync, readdirSync, mkdirSync, statSync, promises as fsPromises } from 'fs';
 import { join, dirname } from 'path';
 import { homedir } from 'os';
 import { createHash } from 'crypto';
@@ -14,14 +14,40 @@ const CLAUDE_SETTINGS_DIR = join(homedir(), '.claude');
 const CLAUDE_GLOBAL_SETTINGS = join(CLAUDE_SETTINGS_DIR, 'settings.json');
 const CLAUDE_GLOBAL_SETTINGS_LOCAL = join(CLAUDE_SETTINGS_DIR, 'settings.local.json');
 
+// Enterprise managed MCP paths (platform-specific)
+function getEnterpriseMcpPath() {
+  const platform = process.platform;
+  if (platform === 'darwin') {
+    return '/Library/Application Support/ClaudeCode/managed-mcp.json';
+  } else if (platform === 'win32') {
+    return 'C:\\Program Files\\ClaudeCode\\managed-mcp.json';
+  } else {
+    // Linux and WSL
+    return '/etc/claude-code/managed-mcp.json';
+  }
+}
+
 // WebSocket clients for real-time notifications
 const wsClients = new Set();
 
 const TEMPLATE_PATH = join(import.meta.dirname, '../templates/dashboard.html');
-const CSS_FILE = join(import.meta.dirname, '../templates/dashboard.css');
+const MODULE_CSS_DIR = join(import.meta.dirname, '../templates/dashboard-css');
 const JS_FILE = join(import.meta.dirname, '../templates/dashboard.js');
 const MODULE_JS_DIR = join(import.meta.dirname, '../templates/dashboard-js');
 
+// Modular CSS files in load order
+const MODULE_CSS_FILES = [
+  '01-base.css',
+  '02-session.css',
+  '03-tasks.css',
+  '04-lite-tasks.css',
+  '05-context.css',
+  '06-cards.css',
+  '07-managers.css',
+  '08-review.css',
+  '09-explorer.css'
+];
+
 /**
  * Handle POST request with JSON body
  */
@@ -59,6 +85,7 @@ const MODULE_FILES = [
   'components/sidebar.js',
   'components/carousel.js',
   'components/notifications.js',
+  'components/global-notifications.js',
   'components/mcp-manager.js',
   'components/hook-manager.js',
   'components/_exp_helpers.js',
@@ -77,6 +104,7 @@ const MODULE_FILES = [
   'views/fix-session.js',
   'views/mcp-manager.js',
   'views/hook-manager.js',
+  'views/explorer.js',
   'main.js'
 ];
 /**
@@ -374,6 +402,41 @@ export async function startServer(options = {}) {
         return;
       }
 
+      // API: List directory files with .gitignore filtering (Explorer view)
+      if (pathname === '/api/files') {
+        const dirPath = url.searchParams.get('path') || initialPath;
+        const filesData = await listDirectoryFiles(dirPath);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(filesData));
+        return;
+      }
+
+      // API: Get file content for preview (Explorer view)
+      if (pathname === '/api/file-content') {
+        const filePath = url.searchParams.get('path');
+        if (!filePath) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'File path is required' }));
+          return;
+        }
+        const fileData = await getFileContent(filePath);
+        res.writeHead(fileData.error ? 404 : 200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(fileData));
+        return;
+      }
+
+      // API: Update CLAUDE.md using CLI tools (Explorer view)
+      if (pathname === '/api/update-claude-md' && req.method === 'POST') {
+        handlePostRequest(req, res, async (body) => {
+          const { path: targetPath, tool = 'gemini', strategy = 'single-layer' } = body;
+          if (!targetPath) {
+            return { error: 'path is required', status: 400 };
+          }
+          return await triggerUpdateClaudeMd(targetPath, tool, strategy);
+        });
+        return;
+      }
+
       // Serve dashboard HTML
       if (pathname === '/' || pathname === '/index.html') {
         const html = generateServerDashboard(initialPath);
@@ -444,9 +507,31 @@ function handleWebSocketUpgrade(req, socket, head) {
   // Handle incoming messages
   socket.on('data', (buffer) => {
     try {
-      const message = parseWebSocketFrame(buffer);
-      if (message) {
-        console.log('[WS] Received:', message);
+      const frame = parseWebSocketFrame(buffer);
+      if (!frame) return;
+      
+      const { opcode, payload } = frame;
+      
+      switch (opcode) {
+        case 0x1: // Text frame
+          if (payload) {
+            console.log('[WS] Received:', payload);
+          }
+          break;
+        case 0x8: // Close frame
+          socket.end();
+          break;
+        case 0x9: // Ping frame - respond with Pong
+          const pongFrame = Buffer.alloc(2);
+          pongFrame[0] = 0x8A; // Pong opcode with FIN bit
+          pongFrame[1] = 0x00; // No payload
+          socket.write(pongFrame);
+          break;
+        case 0xA: // Pong frame - ignore
+          break;
+        default:
+          // Ignore other frame types (binary, continuation)
+          break;
       }
     } catch (e) {
       // Ignore parse errors
@@ -466,10 +551,18 @@ function handleWebSocketUpgrade(req, socket, head) {
 
 /**
  * Parse WebSocket frame (simplified)
+ * Returns { opcode, payload } or null
  */
 function parseWebSocketFrame(buffer) {
   if (buffer.length < 2) return null;
 
+  const firstByte = buffer[0];
+  const opcode = firstByte & 0x0f; // Extract opcode (bits 0-3)
+  
+  // Opcode types:
+  // 0x0 = continuation, 0x1 = text, 0x2 = binary
+  // 0x8 = close, 0x9 = ping, 0xA = pong
+  
   const secondByte = buffer[1];
   const isMasked = (secondByte & 0x80) !== 0;
   let payloadLength = secondByte & 0x7f;
@@ -497,7 +590,7 @@ function parseWebSocketFrame(buffer) {
     }
   }
 
-  return payload.toString('utf8');
+  return { opcode, payload: payload.toString('utf8') };
 }
 
 /**
@@ -952,8 +1045,11 @@ async function updateTaskStatus(sessionPath, taskId, newStatus) {
 function generateServerDashboard(initialPath) {
   let html = readFileSync(TEMPLATE_PATH, 'utf8');
 
-  // Read CSS file
-  const cssContent = existsSync(CSS_FILE) ? readFileSync(CSS_FILE, 'utf8') : '';
+  // Read and concatenate modular CSS files in load order
+  const cssContent = MODULE_CSS_FILES.map(file => {
+    const filePath = join(MODULE_CSS_DIR, file);
+    return existsSync(filePath) ? readFileSync(filePath, 'utf8') : '';
+  }).join('\n\n');
 
   // Read and concatenate modular JS files in dependency order
   let jsContent = MODULE_FILES.map(file => {
@@ -1042,67 +1138,99 @@ function safeReadJson(filePath) {
 }
 
 /**
- * Get MCP servers from a settings file
+ * Get MCP servers from a JSON file (expects mcpServers key at top level)
  * @param {string} filePath
  * @returns {Object} mcpServers object or empty object
  */
-function getMcpServersFromSettings(filePath) {
+function getMcpServersFromFile(filePath) {
   const config = safeReadJson(filePath);
   if (!config) return {};
   return config.mcpServers || {};
 }
 
 /**
- * Get MCP configuration from multiple sources:
- * 1. ~/.claude.json (project-level MCP servers)
- * 2. ~/.claude/settings.json and settings.local.json (global MCP servers)
- * 3. Each workspace's .claude/settings.json and settings.local.json
+ * Get MCP configuration from multiple sources (per official Claude Code docs):
+ *
+ * Priority (highest to lowest):
+ * 1. Enterprise managed-mcp.json (cannot be overridden)
+ * 2. Local scope (project-specific private in ~/.claude.json)
+ * 3. Project scope (.mcp.json in project root)
+ * 4. User scope (mcpServers in ~/.claude.json)
+ *
+ * Note: ~/.claude/settings.json is for MCP PERMISSIONS, NOT definitions!
+ *
  * @returns {Object}
  */
 function getMcpConfig() {
   try {
-    const result = { projects: {}, globalServers: {} };
+    const result = {
+      projects: {},
+      userServers: {},        // User-level servers from ~/.claude.json mcpServers
+      enterpriseServers: {},  // Enterprise managed servers (highest priority)
+      configSources: []       // Track where configs came from for debugging
+    };
 
-    // 1. Read from ~/.claude.json (primary source for project MCP)
-    if (existsSync(CLAUDE_CONFIG_PATH)) {
-      const content = readFileSync(CLAUDE_CONFIG_PATH, 'utf8');
-      const config = JSON.parse(content);
-      result.projects = config.projects || {};
+    // 1. Read Enterprise managed MCP servers (highest priority)
+    const enterprisePath = getEnterpriseMcpPath();
+    if (existsSync(enterprisePath)) {
+      const enterpriseConfig = safeReadJson(enterprisePath);
+      if (enterpriseConfig?.mcpServers) {
+        result.enterpriseServers = enterpriseConfig.mcpServers;
+        result.configSources.push({ type: 'enterprise', path: enterprisePath, count: Object.keys(enterpriseConfig.mcpServers).length });
+      }
     }
 
-    // 2. Read global MCP servers from ~/.claude/settings.json and settings.local.json
-    const globalSettings = getMcpServersFromSettings(CLAUDE_GLOBAL_SETTINGS);
-    const globalSettingsLocal = getMcpServersFromSettings(CLAUDE_GLOBAL_SETTINGS_LOCAL);
-    result.globalServers = { ...globalSettings, ...globalSettingsLocal };
-
-    // 3. For each project, also check .claude/settings.json and settings.local.json
-    for (const projectPath of Object.keys(result.projects)) {
-      const projectClaudeDir = join(projectPath, '.claude');
-      const projectSettings = join(projectClaudeDir, 'settings.json');
-      const projectSettingsLocal = join(projectClaudeDir, 'settings.local.json');
-
-      // Merge MCP servers from workspace settings into project config
-      const workspaceServers = {
-        ...getMcpServersFromSettings(projectSettings),
-        ...getMcpServersFromSettings(projectSettingsLocal)
-      };
+    // 2. Read from ~/.claude.json
+    if (existsSync(CLAUDE_CONFIG_PATH)) {
+      const claudeConfig = safeReadJson(CLAUDE_CONFIG_PATH);
+      if (claudeConfig) {
+        // 2a. User-level mcpServers (top-level mcpServers key)
+        if (claudeConfig.mcpServers) {
+          result.userServers = claudeConfig.mcpServers;
+          result.configSources.push({ type: 'user', path: CLAUDE_CONFIG_PATH, count: Object.keys(claudeConfig.mcpServers).length });
+        }
 
-      if (Object.keys(workspaceServers).length > 0) {
-        // Merge workspace servers with existing project servers (workspace takes precedence)
-        result.projects[projectPath] = {
-          ...result.projects[projectPath],
-          mcpServers: {
-            ...(result.projects[projectPath]?.mcpServers || {}),
-            ...workspaceServers
-          }
-        };
+        // 2b. Project-specific configurations (projects[path].mcpServers)
+        if (claudeConfig.projects) {
+          result.projects = claudeConfig.projects;
+        }
+      }
+    }
+
+    // 3. For each known project, check for .mcp.json (project-level config)
+    const projectPaths = Object.keys(result.projects);
+    for (const projectPath of projectPaths) {
+      const mcpJsonPath = join(projectPath, '.mcp.json');
+      if (existsSync(mcpJsonPath)) {
+        const mcpJsonConfig = safeReadJson(mcpJsonPath);
+        if (mcpJsonConfig?.mcpServers) {
+          // Merge .mcp.json servers into project config
+          // Project's .mcp.json has lower priority than ~/.claude.json projects[path].mcpServers
+          const existingServers = result.projects[projectPath]?.mcpServers || {};
+          result.projects[projectPath] = {
+            ...result.projects[projectPath],
+            mcpServers: {
+              ...mcpJsonConfig.mcpServers,  // .mcp.json (lower priority)
+              ...existingServers             // ~/.claude.json projects[path] (higher priority)
+            },
+            mcpJsonPath: mcpJsonPath  // Track source for debugging
+          };
+          result.configSources.push({ type: 'project-mcp-json', path: mcpJsonPath, count: Object.keys(mcpJsonConfig.mcpServers).length });
+        }
       }
     }
 
+    // Build globalServers by merging user and enterprise servers
+    // Enterprise servers override user servers
+    result.globalServers = {
+      ...result.userServers,
+      ...result.enterpriseServers
+    };
+
     return result;
   } catch (error) {
     console.error('Error reading MCP config:', error);
-    return { projects: {}, globalServers: {}, error: error.message };
+    return { projects: {}, globalServers: {}, userServers: {}, enterpriseServers: {}, configSources: [], error: error.message };
   }
 }
 
@@ -1461,3 +1589,360 @@ function deleteHookFromSettings(projectPath, scope, event, hookIndex) {
     return { error: error.message };
   }
 }
+
+// ========================================
+// Explorer View Functions
+// ========================================
+
+// Directories to always exclude from file tree
+const EXPLORER_EXCLUDE_DIRS = [
+  '.git', '__pycache__', 'node_modules', '.venv', 'venv', 'env',
+  'dist', 'build', '.cache', '.pytest_cache', '.mypy_cache',
+  'coverage', '.nyc_output', 'logs', 'tmp', 'temp', '.next',
+  '.nuxt', '.output', '.turbo', '.parcel-cache'
+];
+
+// File extensions to language mapping for syntax highlighting
+const EXT_TO_LANGUAGE = {
+  '.js': 'javascript',
+  '.jsx': 'javascript',
+  '.ts': 'typescript',
+  '.tsx': 'typescript',
+  '.py': 'python',
+  '.rb': 'ruby',
+  '.java': 'java',
+  '.go': 'go',
+  '.rs': 'rust',
+  '.c': 'c',
+  '.cpp': 'cpp',
+  '.h': 'c',
+  '.hpp': 'cpp',
+  '.cs': 'csharp',
+  '.php': 'php',
+  '.swift': 'swift',
+  '.kt': 'kotlin',
+  '.scala': 'scala',
+  '.sh': 'bash',
+  '.bash': 'bash',
+  '.zsh': 'bash',
+  '.ps1': 'powershell',
+  '.sql': 'sql',
+  '.html': 'html',
+  '.htm': 'html',
+  '.css': 'css',
+  '.scss': 'scss',
+  '.sass': 'sass',
+  '.less': 'less',
+  '.json': 'json',
+  '.xml': 'xml',
+  '.yaml': 'yaml',
+  '.yml': 'yaml',
+  '.toml': 'toml',
+  '.ini': 'ini',
+  '.cfg': 'ini',
+  '.conf': 'nginx',
+  '.md': 'markdown',
+  '.markdown': 'markdown',
+  '.txt': 'plaintext',
+  '.log': 'plaintext',
+  '.env': 'bash',
+  '.dockerfile': 'dockerfile',
+  '.vue': 'html',
+  '.svelte': 'html'
+};
+
+/**
+ * Parse .gitignore file and return patterns
+ * @param {string} gitignorePath - Path to .gitignore file
+ * @returns {string[]} Array of gitignore patterns
+ */
+function parseGitignore(gitignorePath) {
+  try {
+    if (!existsSync(gitignorePath)) return [];
+    const content = readFileSync(gitignorePath, 'utf8');
+    return content
+      .split('\n')
+      .map(line => line.trim())
+      .filter(line => line && !line.startsWith('#'));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Check if a file/directory should be ignored based on gitignore patterns
+ * Simple pattern matching (supports basic glob patterns)
+ * @param {string} name - File or directory name
+ * @param {string[]} patterns - Gitignore patterns
+ * @param {boolean} isDirectory - Whether the entry is a directory
+ * @returns {boolean}
+ */
+function shouldIgnore(name, patterns, isDirectory) {
+  // Always exclude certain directories
+  if (isDirectory && EXPLORER_EXCLUDE_DIRS.includes(name)) {
+    return true;
+  }
+  
+  // Skip hidden files/directories (starting with .)
+  if (name.startsWith('.') && name !== '.claude' && name !== '.workflow') {
+    return true;
+  }
+
+  for (const pattern of patterns) {
+    let p = pattern;
+    
+    // Handle negation patterns (we skip them for simplicity)
+    if (p.startsWith('!')) continue;
+    
+    // Handle directory-only patterns
+    if (p.endsWith('/')) {
+      if (!isDirectory) continue;
+      p = p.slice(0, -1);
+    }
+    
+    // Simple pattern matching
+    if (p === name) return true;
+    
+    // Handle wildcard patterns
+    if (p.includes('*')) {
+      const regex = new RegExp('^' + p.replace(/\./g, '\\.').replace(/\*/g, '.*') + '$');
+      if (regex.test(name)) return true;
+    }
+    
+    // Handle extension patterns like *.log
+    if (p.startsWith('*.')) {
+      const ext = p.slice(1);
+      if (name.endsWith(ext)) return true;
+    }
+  }
+  
+  return false;
+}
+
+/**
+ * List directory files with .gitignore filtering
+ * @param {string} dirPath - Directory path to list
+ * @returns {Promise<Object>}
+ */
+async function listDirectoryFiles(dirPath) {
+  try {
+    // Normalize path
+    let normalizedPath = dirPath.replace(/\\/g, '/');
+    if (normalizedPath.match(/^\/[a-zA-Z]\//)) {
+      normalizedPath = normalizedPath.charAt(1).toUpperCase() + ':' + normalizedPath.slice(2);
+    }
+    
+    if (!existsSync(normalizedPath)) {
+      return { error: 'Directory not found', files: [] };
+    }
+    
+    if (!statSync(normalizedPath).isDirectory()) {
+      return { error: 'Not a directory', files: [] };
+    }
+    
+    // Parse .gitignore patterns
+    const gitignorePath = join(normalizedPath, '.gitignore');
+    const gitignorePatterns = parseGitignore(gitignorePath);
+    
+    // Read directory entries
+    const entries = readdirSync(normalizedPath, { withFileTypes: true });
+    
+    const files = [];
+    for (const entry of entries) {
+      const isDirectory = entry.isDirectory();
+      
+      // Check if should be ignored
+      if (shouldIgnore(entry.name, gitignorePatterns, isDirectory)) {
+        continue;
+      }
+      
+      const entryPath = join(normalizedPath, entry.name);
+      const fileInfo = {
+        name: entry.name,
+        type: isDirectory ? 'directory' : 'file',
+        path: entryPath.replace(/\\/g, '/')
+      };
+      
+      // Check if directory has CLAUDE.md
+      if (isDirectory) {
+        const claudeMdPath = join(entryPath, 'CLAUDE.md');
+        fileInfo.hasClaudeMd = existsSync(claudeMdPath);
+      }
+      
+      files.push(fileInfo);
+    }
+    
+    // Sort: directories first, then alphabetically
+    files.sort((a, b) => {
+      if (a.type === 'directory' && b.type !== 'directory') return -1;
+      if (a.type !== 'directory' && b.type === 'directory') return 1;
+      return a.name.localeCompare(b.name);
+    });
+    
+    return {
+      path: normalizedPath.replace(/\\/g, '/'),
+      files,
+      gitignorePatterns
+    };
+  } catch (error) {
+    console.error('Error listing directory:', error);
+    return { error: error.message, files: [] };
+  }
+}
+
+/**
+ * Get file content for preview
+ * @param {string} filePath - Path to file
+ * @returns {Promise<Object>}
+ */
+async function getFileContent(filePath) {
+  try {
+    // Normalize path
+    let normalizedPath = filePath.replace(/\\/g, '/');
+    if (normalizedPath.match(/^\/[a-zA-Z]\//)) {
+      normalizedPath = normalizedPath.charAt(1).toUpperCase() + ':' + normalizedPath.slice(2);
+    }
+    
+    if (!existsSync(normalizedPath)) {
+      return { error: 'File not found' };
+    }
+    
+    const stats = statSync(normalizedPath);
+    if (stats.isDirectory()) {
+      return { error: 'Cannot read directory' };
+    }
+    
+    // Check file size (limit to 1MB for preview)
+    if (stats.size > 1024 * 1024) {
+      return { error: 'File too large for preview (max 1MB)', size: stats.size };
+    }
+    
+    // Read file content
+    const content = readFileSync(normalizedPath, 'utf8');
+    const ext = normalizedPath.substring(normalizedPath.lastIndexOf('.')).toLowerCase();
+    const language = EXT_TO_LANGUAGE[ext] || 'plaintext';
+    const isMarkdown = ext === '.md' || ext === '.markdown';
+    const fileName = normalizedPath.split('/').pop();
+    
+    return {
+      content,
+      language,
+      isMarkdown,
+      fileName,
+      path: normalizedPath,
+      size: stats.size,
+      lines: content.split('\n').length
+    };
+  } catch (error) {
+    console.error('Error reading file:', error);
+    return { error: error.message };
+  }
+}
+
+/**
+ * Trigger update-module-claude tool (async execution)
+ * @param {string} targetPath - Directory path to update
+ * @param {string} tool - CLI tool to use (gemini, qwen, codex)
+ * @param {string} strategy - Update strategy (single-layer, multi-layer)
+ * @returns {Promise<Object>}
+ */
+async function triggerUpdateClaudeMd(targetPath, tool, strategy) {
+  const { spawn } = await import('child_process');
+  
+  // Normalize path
+  let normalizedPath = targetPath.replace(/\\/g, '/');
+  if (normalizedPath.match(/^\/[a-zA-Z]\//)) {
+    normalizedPath = normalizedPath.charAt(1).toUpperCase() + ':' + normalizedPath.slice(2);
+  }
+  
+  if (!existsSync(normalizedPath)) {
+    return { error: 'Directory not found' };
+  }
+  
+  if (!statSync(normalizedPath).isDirectory()) {
+    return { error: 'Not a directory' };
+  }
+  
+  // Build ccw tool command with JSON parameters
+  const params = JSON.stringify({
+    strategy,
+    path: normalizedPath,
+    tool
+  });
+  
+  console.log(`[Explorer] Running async: ccw tool exec update_module_claude with ${tool} (${strategy})`);
+  
+  return new Promise((resolve) => {
+    const isWindows = process.platform === 'win32';
+    
+    // Spawn the process
+    const child = spawn('ccw', ['tool', 'exec', 'update_module_claude', params], {
+      cwd: normalizedPath,
+      shell: isWindows,
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+    
+    let stdout = '';
+    let stderr = '';
+    
+    child.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+    
+    child.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+    
+    child.on('close', (code) => {
+      if (code === 0) {
+        // Parse the JSON output from the tool
+        let result;
+        try {
+          result = JSON.parse(stdout);
+        } catch {
+          result = { output: stdout };
+        }
+        
+        if (result.success === false || result.error) {
+          resolve({
+            success: false,
+            error: result.error || result.message || 'Update failed',
+            output: stdout
+          });
+        } else {
+          resolve({
+            success: true,
+            message: result.message || `CLAUDE.md updated successfully using ${tool} (${strategy})`,
+            output: stdout,
+            path: normalizedPath
+          });
+        }
+      } else {
+        resolve({
+          success: false,
+          error: stderr || `Process exited with code ${code}`,
+          output: stdout + stderr
+        });
+      }
+    });
+    
+    child.on('error', (error) => {
+      console.error('Error spawning process:', error);
+      resolve({
+        success: false,
+        error: error.message,
+        output: ''
+      });
+    });
+    
+    // Timeout after 5 minutes
+    setTimeout(() => {
+      child.kill();
+      resolve({
+        success: false,
+        error: 'Timeout: Process took longer than 5 minutes',
+        output: stdout
+      });
+    }, 300000);
+  });
+}