agent-window 1.3.9 → 1.4.1

package/src/bmad/participants.js

@@ -0,0 +1,148 @@
+/**
+ * BMAD Participant Manager
+ *
+ * Manages active experts per Discord channel (meeting room metaphor)
+ */
+
+import { getDefaultExpert, getExpert } from './experts.js';
+
+/**
+ * Participant Manager class
+ * Tracks active experts per channel with Master fallback
+ */
+export class ParticipantManager {
+  constructor() {
+    // Map<channelId, Map<expertName, expert>>
+    this.channels = new Map();
+  }
+
+  /**
+   * Get participants for a channel
+   * @param {string} channelId - Discord channel ID
+   * @returns {Array} Array of expert objects in the channel
+   */
+  getParticipants(channelId) {
+    const channel = this.channels.get(channelId);
+    if (!channel) return [];
+    return Array.from(channel.values());
+  }
+
+  /**
+   * Check if channel has any participants
+   * @param {string} channelId - Discord channel ID
+   * @returns {boolean} True if channel has participants
+   */
+  hasParticipants(channelId) {
+    const channel = this.channels.get(channelId);
+    return channel && channel.size > 0;
+  }
+
+  /**
+   * Add participant to channel
+   * @param {string} channelId - Discord channel ID
+   * @param {Object} expert - Expert object to add
+   * @returns {Object} { added: boolean }
+   */
+  addParticipant(channelId, expert) {
+    if (!expert || !expert.name) return { added: false };
+
+    if (!this.channels.has(channelId)) {
+      this.channels.set(channelId, new Map());
+    }
+
+    const channel = this.channels.get(channelId);
+
+    if (channel.has(expert.name)) {
+      return { added: false }; // Already in room
+    }
+
+    channel.set(expert.name, expert);
+    console.log(`[BMAD] Added ${expert.displayName || expert.name} to channel ${channelId}`);
+    return { added: true };
+  }
+
+  /**
+   * Remove participant from channel
+   * Enforces Master fallback rule: room cannot be empty
+   * @param {string} channelId - Discord channel ID
+   * @param {string} expertName - Expert name to remove
+   * @returns {Object} { removed: boolean, fallback: boolean, message: string }
+   */
+  removeParticipant(channelId, expertName) {
+    const channel = this.channels.get(channelId);
+    if (!channel) {
+      return { removed: false, fallback: false, message: 'Channel has no participants' };
+    }
+
+    if (!channel.has(expertName)) {
+      return { removed: false, fallback: false, message: 'Expert not in room' };
+    }
+
+    // Check if this is the last participant
+    if (channel.size === 1) {
+      const master = getDefaultExpert();
+
+      // If trying to remove Master and they're the only one
+      if (channel.has(master?.name)) {
+        return {
+          removed: false,
+          fallback: false,
+          message: 'Cannot dismiss Master - room cannot be empty'
+        };
+      }
+
+      // Remove the expert but add Master
+      channel.delete(expertName);
+      if (master) {
+        channel.set(master.name, master);
+        console.log(`[BMAD] Removed last expert, Master stays in channel ${channelId}`);
+        return {
+          removed: true,
+          fallback: true,
+          message: `Expert left. Master stays to keep the room open.`
+        };
+      }
+    }
+
+    // Normal removal
+    const expert = channel.get(expertName);
+    channel.delete(expertName);
+    console.log(`[BMAD] Removed ${expert?.displayName || expertName} from channel ${channelId}`);
+    return { removed: true, fallback: false, message: 'Expert left the room' };
+  }
+
+  /**
+   * Ensure Master is in the channel (add if not present)
+   * @param {string} channelId - Discord channel ID
+   * @returns {Object} Master expert object
+   */
+  ensureMaster(channelId) {
+    const master = getDefaultExpert();
+    if (!master) {
+      console.warn('[BMAD] Default expert (Master) not found in manifest');
+      return null;
+    }
+
+    this.addParticipant(channelId, master);
+    return master;
+  }
+
+  /**
+   * Clear all participants from a channel
+   * @param {string} channelId - Discord channel ID
+   */
+  clearChannel(channelId) {
+    this.channels.delete(channelId);
+  }
+
+  /**
+   * Get channel count
+   * @returns {number} Number of active channels
+   */
+  getActiveChannelCount() {
+    return this.channels.size;
+  }
+}
+
+// Singleton instance
+export const participantManager = new ParticipantManager();

package/src/bot.js

@@ -21,15 +21,26 @@
 
 import { Client, GatewayIntentBits, Partials, Events, ActionRowBuilder, ButtonBuilder, ButtonStyle } from 'discord.js';
 import { spawn, execSync } from 'child_process';
-import { readFileSync, writeFileSync, existsSync, readdirSync, unlinkSync, mkdirSync } from 'fs';
+import { readFileSync, writeFileSync, existsSync, readdirSync, unlinkSync, mkdirSync, chmodSync } from 'fs';
 import { join } from 'path';
-
-// Import centralized configuration
+import { homedir } from 'os';
+import { https } from 'https';
+import { http } from 'http';
+import { createWriteStream } from 'fs';
+
+// Import performance monitoring utilities (local)
+import {
+  createMonitor,
+  formatMonitorSummary
+} from './core/perf-monitor.js';
+
+import {
+  syncMCPConfigLogged
+} from './core/mcp-sync.js';
+
+// Import centralized configuration (local, project-specific)
 import config from './core/config.js';
 
-// Import performance monitoring
-import { createMonitor, formatMonitorSummary } from './core/perf-monitor.js';
-
 // Extract commonly used config values for convenience
 const BOT_TOKEN = config.discord.token;
 const PROJECT_DIR = config.workspace.projectDir;
@@ -38,6 +49,7 @@ const ALLOWED_CHANNELS = config.discord.allowedChannels;
 const CHANNEL_SESSIONS_FILE = config.paths.sessions;
 const PENDING_DIR = config.paths.pending;
 const HOOK_DIR = config.paths.hooks;
+const USE_DOCKER = config.workspace.useDocker; // Whether to use Docker or run locally
 const CONTAINER_NAME = config.workspace.containerName;
 const DOCKER_IMAGE = config.workspace.dockerImage;
 
@@ -47,6 +59,8 @@ const CONTAINER_CONFIG_DIR = config.docker.containerPaths.configDir;
 const CONTAINER_HOOK_DIR = config.docker.containerPaths.hookDir;
 const CONTAINER_PENDING_DIR = config.docker.containerPaths.pendingDir;
 const CONTAINER_SETTINGS_FILE = config.docker.containerPaths.settingsFile;
+const CONTAINER_UPLOADS_DIR = config.docker.containerPaths.uploadsDir;
+const UPLOADS_DIR = config.paths.uploads;
 const PORT_MAPPINGS = config.workspace.portMappings;
 const CLI_MAX_TURNS = config.cli.maxTurns;
 const CLI_COMMAND = config.cli.command;
@@ -105,23 +119,231 @@ function updateHealthStatus(component, status) {
 
 // Get overall health status
 function getOverallHealth() {
-  const checks = [
-    healthStatus.pm2 ? '✓' : '✗',
-    healthStatus.discord ? '✓' : '✗',
-    healthStatus.docker ? '✓' : '✗'
-  ].join(' ');
-
-  if (healthStatus.pm2 && healthStatus.discord && healthStatus.docker) {
-    return 'healthy';
-  } else if (healthStatus.pm2 && healthStatus.discord) {
-    return 'degraded'; // Running but Docker failed
-  } else if (healthStatus.pm2) {
-    return 'unhealthy'; // PM2 running but Discord disconnected
+  // Build health check string
+  const checks = [healthStatus.pm2 ? '✓' : '✗', healthStatus.discord ? '✓' : '✗'];
+
+  // Only check Docker if enabled
+  if (USE_DOCKER) {
+    checks.push(healthStatus.docker ? '✓' : '✗');
+  }
+
+  const healthString = checks.join(' ');
+
+  // Determine overall status
+  if (USE_DOCKER) {
+    // Docker mode: all components must be healthy
+    if (healthStatus.pm2 && healthStatus.discord && healthStatus.docker) {
+      return 'healthy';
+    } else if (healthStatus.pm2 && healthStatus.discord) {
+      return 'degraded'; // Running but Docker failed
+    } else if (healthStatus.pm2) {
+      return 'unhealthy'; // PM2 running but Discord disconnected
+    } else {
+      return 'failed';
+    }
   } else {
-    return 'failed';
+    // Non-Docker mode: only PM2 and Discord required
+    if (healthStatus.pm2 && healthStatus.discord) {
+      return 'healthy';
+    } else if (healthStatus.pm2) {
+      return 'unhealthy'; // PM2 running but Discord disconnected
+    } else {
+      return 'failed';
+    }
   }
 }
 
+// ============================================================================
+// File Attachment Handling
+// ============================================================================
+
+// Supported file types for processing
+const SUPPORTED_FILE_TYPES = {
+  images: ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg'],
+  videos: ['.mp4', '.mov', '.webm', '.avi', '.mkv'],
+  documents: ['.pdf', '.doc', '.docx', '.txt', '.md', '.json', '.yaml', '.yml', '.xml', '.csv'],
+  code: ['.js', '.ts', '.py', '.java', '.c', '.cpp', '.h', '.go', '.rs', '.rb', '.php', '.sh', '.bat'],
+  archives: ['.zip', '.tar', '.gz', '.7z', '.rar'],
+};
+
+// Download file from URL to local path
+function downloadFile(url, destPath) {
+  return new Promise((resolve, reject) => {
+    const protocol = url.startsWith('https') ? https : http;
+    const file = createWriteStream(destPath);
+
+    protocol.get(url, {
+      headers: {
+        'User-Agent': 'DiscordBot (https://discord.js.org)'
+      }
+    }, (response) => {
+      if (response.statusCode === 302 || response.statusCode === 301) {
+        // Follow redirect
+        downloadFile(response.headers.location, destPath)
+          .then(resolve)
+          .catch(reject);
+        return;
+      }
+
+      if (response.statusCode !== 200) {
+        reject(new Error(`Failed to download: ${response.statusCode}`));
+        return;
+      }
+
+      response.pipe(file);
+
+      file.on('finish', () => {
+        file.close();
+        resolve(destPath);
+      });
+
+      file.on('error', (err) => {
+        unlinkSync(destPath);
+        reject(err);
+      });
+    }).on('error', (err) => {
+      unlinkSync(destPath);
+      reject(err);
+    });
+  });
+}
+
+// Process Discord message attachments
+async function processAttachments(message, channelId) {
+  if (!message.attachments || message.attachments.size === 0) {
+    return [];
+  }
+
+  const uploadedFiles = [];
+
+  // Ensure uploads directory exists
+  const date = new Date();
+  const dateStr = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`;
+  const instanceUploadDir = join(UPLOADS_DIR, CONTAINER_NAME, dateStr, channelId);
+
+  try {
+    mkdirSync(instanceUploadDir, { recursive: true });
+  } catch (e) {
+    console.error('[Upload] Failed to create upload directory:', e);
+    return [];
+  }
+
+  console.log(`[Upload] Processing ${message.attachments.size} attachment(s)`);
+
+  for (const [attachmentId, attachment] of message.attachments) {
+    try {
+      const url = attachment.url;
+      const filename = attachment.name;
+      const filesize = attachment.size;
+
+      console.log(`[Upload] Processing: ${filename} (${Math.round(filesize / 1024)}KB)`);
+
+      // Check file size (max 50MB)
+      if (filesize > 50 * 1024 * 1024) {
+        console.warn(`[Upload] Skipping ${filename}: file too large (${Math.round(filesize / 1024 / 1024)}MB)`);
+        await message.channel.send(`⚠️ File \`${filename}\` is too large (max 50MB)`);
+        continue;
+      }
+
+      // Determine file type
+      const ext = filename.toLowerCase().substring(filename.lastIndexOf('.'));
+      const fileType = Object.entries(SUPPORTED_FILE_TYPES).find(([_, exts]) => exts.includes(ext));
+
+      if (!fileType) {
+        console.warn(`[Upload] Skipping ${filename}: unsupported file type`);
+        await message.channel.send(`⚠️ Unsupported file type: \`${filename}\``);
+        continue;
+      }
+
+      const [type, _] = fileType;
+      const destPath = join(instanceUploadDir, filename);
+
+      // Download file
+      console.log(`[Upload] Downloading ${url} to ${destPath}`);
+      await downloadFile(url, destPath);
+
+      // Make file readable
+      try {
+        chmodSync(destPath, 0o644);
+      } catch (e) {
+        // Ignore
+      }
+
+      // Calculate container path
+      const relativePath = destPath.replace(UPLOADS_DIR, '').replace(/^\//, '');
+      const containerPath = join(CONTAINER_UPLOADS_DIR, CONTAINER_NAME, dateStr, channelId, filename);
+
+      uploadedFiles.push({
+        hostPath: destPath,
+        containerPath: containerPath,
+        filename: filename,
+        type: type,
+        size: filesize,
+        url: url,
+        description: attachment.description || null,
+      });
+
+      console.log(`[Upload] ✓ Saved: ${filename} (${type})`);
+    } catch (err) {
+      console.error(`[Upload] Failed to process attachment:`, err);
+      await message.channel.send(`❌ Failed to download \`${attachment.name}\`: ${err.message}`);
+    }
+  }
+
+  return uploadedFiles;
+}
+
+// Format file information for Claude prompt
+function formatFilesForPrompt(uploadedFiles) {
+  if (uploadedFiles.length === 0) {
+    return '';
+  }
+
+  const lines = [
+    '',
+    '--- ATTACHED FILES ---',
+  ];
+
+  uploadedFiles.forEach((file, idx) => {
+    const sizeKB = Math.round(file.size / 1024);
+    const sizeMB = (file.size / 1024 / 1024).toFixed(2);
+
+    let sizeStr = sizeKB > 1024 ? `${sizeMB}MB` : `${sizeKB}KB`;
+
+    lines.push(`${idx + 1}. **${file.filename}** (${file.type}, ${sizeStr})`);
+    lines.push(`   - Container path: \`${file.containerPath}\``);
+
+    if (file.description) {
+      lines.push(`   - Description: ${file.description}`);
+    }
+
+    // Add specific instructions based on file type
+    if (file.type === 'images') {
+      lines.push(`   - ⚠️ This is an image file. You can view it using the Read tool or analyze it with vision capabilities.`);
+    } else if (file.type === 'videos') {
+      lines.push(`   - ⚠️ This is a video file. You may need to extract frames or use video analysis tools.`);
+    } else if (file.type === 'documents') {
+      lines.push(`   - ⚠️ This is a document. You can read it with the Read tool for analysis.`);
+    } else if (file.type === 'code') {
+      lines.push(`   - ⚠️ This is a code file. You can review and analyze it using Read and Grep tools.`);
+    }
+
+    lines.push('');
+  });
+
+  lines.push('--- END OF ATTACHED FILES ---');
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+// Ensure uploads directory exists
+try {
+  mkdirSync(UPLOADS_DIR, { recursive: true });
+} catch (e) {
+  console.error('[Upload] Failed to create uploads directory:', e);
+}
+
 // Ensure pending directory exists
 try {
   mkdirSync(PENDING_DIR, { recursive: true });
@@ -142,6 +364,13 @@ function isContainerRunning() {
 
 // Start or ensure persistent container is running
 function ensureContainer() {
+  // Skip Docker operations if not using Docker
+  if (!USE_DOCKER) {
+    console.log('[Docker] Docker is disabled (useDocker: false). Running in local mode.');
+    updateHealthStatus('docker', true); // Mark as "healthy" since we don't need Docker
+    return true;
+  }
+
   // Log the paths being used
   console.log('[Docker] PENDING_DIR (host):', PENDING_DIR);
   console.log('[Docker] HOOK_DIR (host):', HOOK_DIR);
@@ -193,6 +422,7 @@ function ensureContainer() {
       '-v', `${config.backend.configDir}:${CONTAINER_CONFIG_DIR}:rw`,
       '-v', `${HOOK_DIR}:${CONTAINER_HOOK_DIR}:ro`,
       '-v', `${PENDING_DIR}:${CONTAINER_PENDING_DIR}:rw`,
+      '-v', `${UPLOADS_DIR}:${CONTAINER_UPLOADS_DIR}:rw`,
       `-e 'CLAUDE_CODE_OAUTH_TOKEN=${OAUTH_TOKEN || ''}'`,
       envArgs,
       '--entrypoint', 'tail',
@@ -202,6 +432,10 @@ function ensureContainer() {
 
     execSync(dockerCmd);
     console.log('[Docker] Container started successfully');
+
+    // Sync MCP configuration from host to container
+    syncMCPConfig();
+
     updateHealthStatus('docker', true);
     return true;
   } catch (e) {
@@ -228,6 +462,11 @@ function ensureContainer() {
 
 // Stop persistent container (call on bot shutdown)
 function stopContainer() {
+  if (!USE_DOCKER) {
+    console.log('[Docker] Docker is disabled. No container to stop.');
+    return;
+  }
+
   try {
     execSync(`docker stop ${CONTAINER_NAME} 2>/dev/null`);
     execSync(`docker rm ${CONTAINER_NAME} 2>/dev/null`);
@@ -235,6 +474,11 @@ function stopContainer() {
   } catch (e) {}
 }
 
+// Sync MCP configuration (wrapper for npm package function)
+function syncMCPConfig() {
+  syncMCPConfigLogged(CONTAINER_NAME, PENDING_DIR, CONTAINER_PENDING_DIR, DOCKER_CHECK_TIMEOUT);
+}
+
 // Cleanup on exit
 process.on('SIGINT', () => {
   console.log('Shutting down...');
@@ -1011,13 +1255,19 @@ const commands = {
 
   async claude(message, args) {
     const userMessage = args.join(' ').trim();
-    if (!userMessage) {
+    const channelId = message.channel.id;
+
+    // Process attachments first
+    const uploadedFiles = await processAttachments(message, channelId);
+
+    // If no text message but have attachments, provide a default message
+    const actualMessage = userMessage || (uploadedFiles.length > 0 ? 'Please analyze the attached file(s)' : '');
+
+    if (!actualMessage) {
       await commands.help(message);
       return;
     }
 
-    const channelId = message.channel.id;
-
     // Check if there's an active task
     if (activeTasks.has(channelId)) {
       const task = activeTasks.get(channelId);
@@ -1078,7 +1328,7 @@ const commands = {
         messageQueues.delete(channelId);
 
         // Start new task
-        await commands._processClaudeMessage(message, userMessage, channelId);
+        await commands._processClaudeMessage(message, actualMessage, channelId, uploadedFiles);
         return;
       }
 
@@ -1086,16 +1336,16 @@ const commands = {
       if (!messageQueues.has(channelId)) {
         messageQueues.set(channelId, []);
       }
-      messageQueues.get(channelId).push({ content: userMessage, timestamp: Date.now() });
+      messageQueues.get(channelId).push({ content: actualMessage, timestamp: Date.now(), files: uploadedFiles });
       const queueSize = messageQueues.get(channelId).length;
       await message.channel.send(`📥 Queued (#${queueSize}) - will process after current task`);
       return;
     }
 
-    await commands._processClaudeMessage(message, userMessage, channelId);
+    await commands._processClaudeMessage(message, actualMessage, channelId, uploadedFiles);
   },
 
-  async _processClaudeMessage(message, userMessage, channelId) {
+  async _processClaudeMessage(message, userMessage, channelId, uploadedFiles = []) {
     // Create stop button
     const stopButton = new ActionRowBuilder()
       .addComponents(
@@ -1131,6 +1381,13 @@ const commands = {
       // Parse flags
       let actualMessage = userMessage;
 
+      // Add file information to the message if there are attachments
+      if (uploadedFiles.length > 0) {
+        const fileInfo = formatFilesForPrompt(uploadedFiles);
+        actualMessage = fileInfo + userMessage;
+        console.log(`[Claude] Added ${uploadedFiles.length} file(s) to prompt`);
+      }
+
       // Base CLI args with PreToolUse hook for permission control
       // Hook handles: auto-approve safe tools, request Discord approval for risky tools
       const cliArgs = [
@@ -1139,6 +1396,7 @@ const commands = {
         '--verbose',
         '--max-turns', String(CLI_MAX_TURNS),
         '--settings', CONTAINER_SETTINGS_FILE,
+        '--model', config.cli.model, // Add model selection
       ];
 
       // Add model selection (defaults to opus)
@@ -1217,21 +1475,42 @@ const commands = {
         let lastStatusUpdate = 0;
         const task = activeTasks.get(channelId);
 
-        // Use docker exec to run CLI in the persistent container
-        const dockerArgs = [
-          'exec', '-i',
-          CONTAINER_NAME,
-          CLI_COMMAND,
-          ...cliArgs
-        ];
+        // Execute CLI command (either in Docker or locally based on configuration)
+        let child;
 
-        console.log('[Docker] Executing in container:', CONTAINER_NAME);
+        if (USE_DOCKER) {
+          // Use docker exec to run CLI in the persistent container
+          const dockerArgs = [
+            'exec', '-i',
+            CONTAINER_NAME,
+            CLI_COMMAND,
+            ...cliArgs
+          ];
 
-        const child = spawn('docker', dockerArgs, {
-          stdio: ['pipe', 'pipe', 'pipe'],
-        });
+          console.log('[Docker] Executing in container:', CONTAINER_NAME);
 
-        child.stdin.end();
+          child = spawn('docker', dockerArgs, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+          });
+
+          child.stdin.end();
+        } else {
+          // Run CLI directly on local host
+          console.log('[Local] Executing locally:', CLI_COMMAND, ...cliArgs);
+
+          child = spawn(CLI_COMMAND, cliArgs, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            cwd: PROJECT_DIR,
+            env: {
+              ...process.env,
+              CLAUDE_CODE_OAUTH_TOKEN: OAUTH_TOKEN || '',
+              HOME: process.env.HOME,
+              PATH: process.env.PATH
+            }
+          });
+
+          child.stdin.end();
+        }
 
         // Update status periodically (with stop button)
         // forceUpdate=true bypasses throttle for important state changes
@@ -1616,9 +1895,14 @@ client.on(Events.ClientReady, async () => {
   // Send startup notification to Discord channels
   try {
     const uptime = Math.floor((Date.now() - healthStatus.startTime) / 1000);
-    const dockerStatus = healthStatus.docker ? '✓ Connected' : '✗ Not Available';
     const overallStatus = overallHealth.toUpperCase();
 
+    // Build execution mode info
+    const execMode = USE_DOCKER ? 'Docker Container' : 'Local Host';
+    const dockerStatus = USE_DOCKER
+      ? (healthStatus.docker ? '✓ Connected' : '✗ Not Available')
+      : '⊘ Disabled (Local Mode)';
+
     // Build startup message
     const startupMessage = {
       embeds: [{
@@ -1630,6 +1914,11 @@ client.on(Events.ClientReady, async () => {
             value: overallStatus,
             inline: true
           },
+          {
+            name: 'Execution Mode',
+            value: execMode,
+            inline: true
+          },
           {
             name: 'Docker',
             value: dockerStatus,
@@ -1642,7 +1931,9 @@ client.on(Events.ClientReady, async () => {
           },
           {
             name: 'Components',
-            value: `PM2: ✓\nDiscord: ✓\nDocker: ${healthStatus.docker ? '✓' : '✗'}`,
+            value: USE_DOCKER
+              ? `PM2: ✓\nDiscord: ✓\nDocker: ${healthStatus.docker ? '✓' : '✗'}`
+              : `PM2: ✓\nDiscord: ✓\nDocker: ⊘ (Local Mode)`,
             inline: false
           }
         ],