agent-window 1.2.1 → 1.2.4

package/src/bot.js

@@ -6,6 +6,7 @@
  * - Permission system with chat-based approval buttons
  * - Session management with channel binding
  * - Multi-agent support (Claude Code, Codex, OpenCode)
+ * - Model selection (opus/sonnet/haiku, default: opus)
  *
  * Commands:
  *   @bot <message>       - Send message (continues last conversation)
@@ -14,6 +15,7 @@
  *   @bot /pick           - Choose session (button UI)
  *   @bot /sessions       - List recent sessions
  *   @bot /status         - Check bot status
+ *   @bot /model [model]  - View or change AI model (opus/sonnet/haiku)
  *   @bot /help           - Show help
  */
 
@@ -67,6 +69,59 @@ const pendingPermissions = new Map(); // requestId -> { channelId, message }
 
 let containerReady = false;
 
+// Model configuration
+const AVAILABLE_MODELS = {
+  opus: 'claude-opus-4-20250514',
+  sonnet: 'claude-sonnet-4-20250514',
+  haiku: 'claude-haiku-4-20250514'
+};
+
+// Per-channel model selection (channelId -> modelKey)
+const channelModels = new Map();
+
+// Default model (opus as requested)
+const DEFAULT_MODEL = 'opus';
+
+// Health status tracking
+const HEALTH_STATUS_FILE = join(PROJECT_DIR, '.health-status.json');
+const healthStatus = {
+  pm2: false,
+  discord: false,
+  docker: false,
+  startTime: Date.now(),
+  lastUpdate: Date.now()
+};
+
+// Update health status
+function updateHealthStatus(component, status) {
+  healthStatus[component] = status;
+  healthStatus.lastUpdate = Date.now();
+  try {
+    writeFileSync(HEALTH_STATUS_FILE, JSON.stringify(healthStatus, null, 2));
+  } catch (e) {
+    console.error('[Health] Failed to write status file:', e.message);
+  }
+}
+
+// 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
+  } else {
+    return 'failed';
+  }
+}
+
 // Ensure pending directory exists
 try {
   mkdirSync(PENDING_DIR, { recursive: true });
@@ -147,9 +202,26 @@ function ensureContainer() {
 
     execSync(dockerCmd);
     console.log('[Docker] Container started successfully');
+    updateHealthStatus('docker', true);
     return true;
   } catch (e) {
-    console.error('[Docker] Failed to start container:', e.message);
+    const errorMsg = e.message || '';
+    console.error('[Docker] Failed to start container:', errorMsg);
+
+    // Provide helpful guidance for common Docker issues
+    if (errorMsg.includes('ECONNREFUSED') || errorMsg.includes('Cannot connect') || errorMsg.includes('connect')) {
+      console.error('[Docker] Docker daemon is not running!');
+      console.error('[Docker] Please restart Docker Desktop:');
+      console.error('[Docker]   1. Click Docker Desktop icon in menu bar');
+      console.error('[Docker]   2. Select "Restart" or wait for daemon to start');
+    } else if (errorMsg.includes('image not found') || errorMsg.includes('no such image')) {
+      console.error('[Docker] Docker image not found.');
+      console.error('[Docker] Pull the image first: docker pull', DOCKER_IMAGE);
+    } else if (errorMsg.includes('permission denied')) {
+      console.error('[Docker] Permission denied. Try: sudo docker pull', DOCKER_IMAGE);
+    }
+
+    updateHealthStatus('docker', false);
     return false;
   }
 }
@@ -742,6 +814,7 @@ const commands = {
 \`@bot /pick\` - Choose session (new or resume)
 \`@bot /sessions\` - List all recent sessions
 \`@bot /status\` - Check bot status
+\`@bot /model\` - View or change AI model (opus/sonnet/haiku)
 \`@bot /help\` - Show this help`;
 
     await message.channel.send({
@@ -762,9 +835,11 @@ const commands = {
     const hours = Math.floor(uptime / 3600);
     const minutes = Math.floor((uptime % 3600) / 60);
     const containerRunning = isContainerRunning();
+    const currentModel = channelModels.get(message.channel.id) || DEFAULT_MODEL;
 
     const statusText = `**Status**: Online
 **Mode**: Docker Sandbox + Hooks Permission
+**Model**: ${currentModel} (${AVAILABLE_MODELS[currentModel]})
 **Uptime**: ${hours}h ${minutes}m
 **Container**: ${CONTAINER_NAME} (${containerRunning ? '🟢 running' : '🔴 stopped'})
 **Project**: ${PROJECT_DIR}
@@ -824,6 +899,56 @@ const commands = {
     }
   },
 
+  async model(message, args) {
+    const channelId = message.channel.id;
+    const action = args[0];
+
+    // Show current model
+    if (!action) {
+      const currentModel = channelModels.get(channelId) || DEFAULT_MODEL;
+      const modelId = AVAILABLE_MODELS[currentModel];
+
+      const modelText = `**Current Model:** ${currentModel} (${modelId})
+
+**Available Models:**
+• **opus** - Most capable, best for complex tasks
+• **sonnet** - Balanced performance and speed
+• **haiku** - Fastest, for simple tasks
+
+**Usage:**
+\`@bot /model opus\` - Switch to Opus
+\`@bot /model sonnet\` - Switch to Sonnet
+\`@bot /model haiku\` - Switch to Haiku`;
+
+      await message.channel.send({
+        embeds: [{
+          title: 'AI Model Configuration',
+          description: modelText,
+          color: currentModel === 'opus' ? 0x9B59B6 : currentModel === 'sonnet' ? 0x3498DB : 0x2ECC71,
+        }]
+      });
+      return;
+    }
+
+    // Switch model
+    const newModel = action.toLowerCase();
+    if (!AVAILABLE_MODELS[newModel]) {
+      await message.channel.send(`Invalid model: ${action}\nAvailable models: opus, sonnet, haiku`);
+      return;
+    }
+
+    channelModels.set(channelId, newModel);
+    const modelId = AVAILABLE_MODELS[newModel];
+
+    await message.channel.send({
+      embeds: [{
+        title: 'Model Changed',
+        description: `Switched to **${newModel}** (${modelId})\n\nThis model will be used for new conversations in this channel.`,
+        color: newModel === 'opus' ? 0x9B59B6 : newModel === 'sonnet' ? 0x3498DB : 0x2ECC71,
+      }]
+    });
+  },
+
   // Show session selection card with buttons
   async showSessionPicker(message) {
     try {
@@ -1016,6 +1141,12 @@ const commands = {
         '--settings', CONTAINER_SETTINGS_FILE,
       ];
 
+      // Add model selection (defaults to opus)
+      const selectedModel = channelModels.get(channelId) || DEFAULT_MODEL;
+      const modelId = AVAILABLE_MODELS[selectedModel];
+      cliArgs.push('--model', modelId);
+      console.log('[Claude] Using model:', selectedModel, `(${modelId})`);
+
       // Track if we're forcing a new session or resuming a specific one
       if (userMessage.startsWith('-n ') || userMessage.startsWith('--new ')) {
         // Force new session
@@ -1439,7 +1570,7 @@ client.on(Events.MessageCreate, async (message) => {
 });
 
 // Ready event
-client.on(Events.ClientReady, () => {
+client.on(Events.ClientReady, async () => {
   console.log(`AgentBridge logged in as ${client.user.tag}`);
   console.log(`Bot User ID: ${client.user.id}`);
   console.log(`Project: ${PROJECT_DIR}`);
@@ -1447,6 +1578,10 @@ client.on(Events.ClientReady, () => {
   console.log(`Container: ${CONTAINER_NAME}`);
   console.log(`OAuth: ${OAUTH_TOKEN ? 'configured' : 'not set'}`);
 
+  // Update PM2 and Discord health status
+  updateHealthStatus('pm2', true);
+  updateHealthStatus('discord', true);
+
   // Start persistent container (non-blocking)
   console.log('[Docker] Attempting to start container...');
   containerReady = ensureContainer();
@@ -1455,6 +1590,12 @@ client.on(Events.ClientReady, () => {
     console.warn('[Docker] AI commands will not work without the container.');
     console.warn('[Docker] To fix: 1) Login to ghcr.io, 2) Restart bot');
   }
+
+  // Log overall health status
+  const overallHealth = getOverallHealth();
+  console.log(`[Health] Overall status: ${overallHealth.toUpperCase()}`);
+  console.log(`[Health] Components: PM2=${healthStatus.pm2 ? '✓' : '✗'} Discord=${healthStatus.discord ? '✓' : '✗'} Docker=${healthStatus.docker ? '✓' : '✗'}`);
+
   console.log(`Allowed Channels Config: ${ALLOWED_CHANNELS ? ALLOWED_CHANNELS.join(', ') : 'All'}`);
   console.log(`Guilds: ${client.guilds.cache.size}`);
   client.guilds.cache.forEach(guild => {
@@ -1471,6 +1612,63 @@ client.on(Events.ClientReady, () => {
   startPermissionWatcher();
 
   console.log(`Ready! @${client.user.username} to interact`);
+
+  // 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 startup message
+    const startupMessage = {
+      embeds: [{
+        title: '🤖 AgentWindow Bot Started',
+        color: overallStatus === 'HEALTHY' ? 0x00FF00 : overallStatus === 'DEGRADED' ? 0xFFFF00 : 0xFF0000,
+        fields: [
+          {
+            name: 'Status',
+            value: overallStatus,
+            inline: true
+          },
+          {
+            name: 'Docker',
+            value: dockerStatus,
+            inline: true
+          },
+          {
+            name: 'Startup Time',
+            value: `${uptime}s`,
+            inline: true
+          },
+          {
+            name: 'Components',
+            value: `PM2: ✓\nDiscord: ✓\nDocker: ${healthStatus.docker ? '✓' : '✗'}`,
+            inline: false
+          }
+        ],
+        timestamp: new Date().toISOString(),
+        footer: {
+          text: `AgentWindow v1.2.1`
+        }
+      }]
+    };
+
+    // Send to all allowed channels
+    const channels = ALLOWED_CHANNELS || [];
+    for (const channelId of channels) {
+      try {
+        const channel = await client.channels.fetch(channelId);
+        if (channel && channel.isTextBased()) {
+          await channel.send(startupMessage);
+          console.log(`[Notification] Startup message sent to #${channel.name}`);
+        }
+      } catch (e) {
+        console.error(`[Notification] Failed to send to channel ${channelId}:`, e.message);
+      }
+    }
+  } catch (e) {
+    console.error('[Notification] Failed to send startup notification:', e.message);
+  }
 });
 
 // Error handling

package/src/core/instance/manager.js

@@ -1,7 +1,35 @@
 /**
  * Instance Manager
  *
- * Manages AgentWindow BMAD plugin instances - add, list, remove, get info.
+ * Manages AgentWindow bot instances with clear separation between two types:
+ *
+ * ## Instance Types
+ *
+ * ### 1. Simple-Config (基础版)
+ * - **Discovery**: Auto-discovered from PM2 processes
+ * - **Config Location**: ~/.agent-window/bots/{name}/config.json
+ * - **Management**: Unified management by AgentWindow
+ * - **Use Case**: Simple bots managed through Web UI
+ * - **Import Method**: Discovered via "Discover" button in UI
+ *
+ * ### 2. BMAD-Plugin (BMAD 插件版)
+ * - **Discovery**: Manually added by user
+ * - **Config Location**: User's project directory
+ * - **Management**: User manages their BMAD project
+ * - **Use Case**: Development projects with BMAD framework
+ * - **Import Method**: Added via "Add Instance" button with validation
+ * - **Requirements**:
+ *   - Must have _agent-bridge/ directory
+ *   - Must have _agent-bridge/src/bot.js
+ *   - Must pass validateInstance() check
+ *
+ * ## Business Rules
+ *
+ * 1. Simple-config instances are auto-discovered from PM2
+ * 2. BMAD-plugin instances must be manually added through UI
+ * 3. BMAD-plugin instances require strict validation
+ * 4. Simple-config instances cannot be manually added (must be discovered)
+ *
  * Uses platform abstraction layer for cross-platform compatibility.
  */
 
@@ -63,12 +91,19 @@ export async function writeInstances(data) {
 
 /**
  * Add a new instance
+ *
+ * Business Logic:
+ * - For creating NEW simple-config instances: Pass createConfig option with config data
+ * - For importing EXISTING BMAD plugins: Pass projectPath, will be validated
+ *
  * @param {string} name - Instance name (identifier)
- * @param {string} projectPath - Path to BMAD project
+ * @param {string} projectPath - Path to project (for BMAD plugins) or working directory
  * @param {Object} options - Additional options
  * @param {string} options.displayName - Display name
  * @param {string[]} options.tags - Tags for categorization
  * @param {string} options.configPath - Path to config file (optional)
+ * @param {string} options.instanceType - Explicit instance type ('simple-config' | 'bmad-plugin')
+ * @param {boolean} options.createConfig - Whether this is creating a new simple-config instance
  * @returns {Promise<Object>} Result with success and message
  */
 export async function addInstance(name, projectPath, options = {}) {
@@ -89,14 +124,49 @@ export async function addInstance(name, projectPath, options = {}) {
     };
   }
 
+  const botsDir = paths.getBotsDir();
+  let newInstance;
+  let configPath;
+
+  // Case 1: Creating a NEW simple-config instance from scratch
+  if (options.instanceType === 'simple-config' || options.createConfig) {
+    // Config path for simple-config instances
+    configPath = options.configPath || path.join(botsDir, name, 'config.json');
+
+    // Ensure config directory exists
+    await fs.mkdir(path.dirname(configPath), { recursive: true });
+
+    newInstance = {
+      name,
+      displayName: options.displayName || name,
+      projectPath: projectPath, // For simple-config, this is the working directory
+      configPath,
+      pluginPath: null,
+      botName: `bot-${name}`,
+      instanceType: 'simple-config',
+      addedAt: new Date().toISOString(),
+      tags: options.tags || [],
+      enabled: true
+    };
+
+    data.instances.push(newInstance);
+    await writeInstances(data);
+
+    return {
+      success: true,
+      instance: newInstance
+    };
+  }
+
+  // Case 2: Importing an EXISTING BMAD plugin
   // Validate the instance
   const validation = await validateInstance(projectPath);
   if (!validation.valid) {
-    // Provide helpful error message based on instance type
+    // Only BMAD plugins can be manually added
     const typeMsg = validation.instanceType === 'simple-config'
-      ? '简单配置实例无法通过"添加实例"功能添加。请先使用 PM2 启动 bot，然后在 Web UI 中导入。'
+      ? '简单配置实例无法通过"添加实例"功能添加。请使用"Discover"功能导入。'
       : validation.instanceType === 'unknown'
-      ? '无法识别的项目类型'
+      ? '无法识别的项目类型，必须是有效的 BMAD 插件'
       : '项目不是有效的 AgentWindow BMAD 插件';
 
     return {
@@ -106,21 +176,26 @@ export async function addInstance(name, projectPath, options = {}) {
     };
   }
 
-  // Determine config path
-  const botsDir = paths.getBotsDir();
-  const defaultConfigPath = path.join(botsDir, name, 'config.json');
-  const configPath = options.configPath ||
-    (existsSync(defaultConfigPath) ? defaultConfigPath : null);
+  // Only allow importing BMAD plugins via Add Instance
+  if (validation.instanceType !== 'bmad-plugin') {
+    return {
+      success: false,
+      error: '只能通过"添加实例"功能导入 BMAD 插件。基础版实例请使用"Discover"功能导入。',
+      validation
+    };
+  }
 
-  // Add instance
-  const newInstance = {
+  // Determine config path for BMAD plugin
+  configPath = options.configPath || null;
+
+  newInstance = {
     name,
     displayName: options.displayName || name,
     projectPath: validation.projectPath,
     pluginPath: validation.pluginPath,
     configPath,
     botName: `bot-${name}`,
-    instanceType: validation.instanceType,  // Save instance type
+    instanceType: validation.instanceType,
     addedAt: new Date().toISOString(),
     tags: options.tags || [],
     enabled: true
@@ -256,6 +331,7 @@ export async function discoverInstances() {
       let projectPath = null;
       let configPath = null;
       let pluginPath = null;
+      let hasValidConfig = false;
 
       // Priority 1: Read CONFIG_PATH and extract PROJECT_DIR from config
       if (proc.configPath && existsSync(proc.configPath)) {
@@ -271,6 +347,7 @@ export async function discoverInstances() {
             // Fallback to config directory
             projectPath = path.dirname(configPath);
           }
+          hasValidConfig = true;
         } catch {
           // If config read fails, use directory name
           projectPath = path.dirname(configPath);
@@ -296,17 +373,33 @@ export async function discoverInstances() {
               // Fallback to cwd if available
               projectPath = proc.cwd || null;
             }
+            hasValidConfig = true;
           } catch {
             // If config read fails, use cwd
             projectPath = proc.cwd || null;
           }
         }
       }
-      // Priority 3: Use cwd
+      // Priority 3: Use cwd (but this is NOT a valid AgentWindow instance)
       else if (proc.cwd) {
         projectPath = proc.cwd;
       }
 
+      // CRITICAL: Skip processes without a valid configuration
+      // A valid AgentWindow instance MUST have either:
+      // 1. A CONFIG_PATH env variable pointing to a valid config file, OR
+      // 2. An inferred config file that exists
+      if (!hasValidConfig || !configPath) {
+        console.debug(`[Discover] Skipping ${proc.name}: no valid config file (CONFIG_PATH not set, no inferred config found)`);
+        continue;
+      }
+
+      // Additional validation: project path must exist
+      if (!projectPath || !existsSync(projectPath)) {
+        console.debug(`[Discover] Skipping ${proc.name}: project path does not exist (${projectPath})`);
+        continue;
+      }
+
       // Check if it's a BMAD project (has _bmad directory)
       if (projectPath && existsSync(path.join(projectPath, '_bmad'))) {
         pluginPath = path.join(projectPath, '_agent-bridge', 'src');
@@ -316,12 +409,18 @@ export async function discoverInstances() {
       }
 
       // Detect instance type based on project structure
-      // projectPath already points to PROJECT_DIR from config if available
+      // Business Logic:
+      // - simple-config: Auto-discovered, managed by AgentWindow
+      // - bmad-plugin: Discovered but needs user confirmation
       let instanceType = 'unknown';
       if (projectPath && existsSync(projectPath)) {
         instanceType = detectInstanceType(projectPath);
       }
 
+      // NOTE: We allow both types to be discovered
+      // - simple-config: Can be imported directly
+      // - bmad-plugin: Shown in discover list for user to review and import
+
       discovered.push({
         botName: proc.name,
         name: instanceName,

package/src/core/instance/pm2-bridge.js

@@ -6,6 +6,7 @@
  */
 
 import { pm2 as platformPM2 } from '../platform/index.js';
+import { existsSync } from 'fs';
 
 /**
  * PM2 process info
@@ -162,21 +163,90 @@ export async function getStatus(name) {
   if (!proc) {
     return {
       name,
-      status: 'unknown',
-      exists: false
+      status: 'stopped',
+      exists: false,
+      health: {
+        pm2: false,
+        discord: false,
+        docker: false,
+        overall: 'stopped'
+      }
     };
   }
 
+  // Try to read health status file
+  let healthStatus = {
+    pm2: proc.status === 'online',
+    discord: false,
+    docker: false,
+    overall: 'stopped'
+  };
+
+  let containerName = null;
+
+  try {
+    const { readFileSync } = await import('fs');
+    const { join } = await import('path');
+    const configPath = proc.configPath; // Use configPath from platform abstraction layer
+
+    if (configPath) {
+      // Read the config file to get PROJECT_DIR and container name
+      try {
+        const configContent = JSON.parse(readFileSync(configPath, 'utf-8'));
+        const projectDir = configContent.PROJECT_DIR;
+        containerName = configContent.workspace?.containerName || null;
+
+        if (projectDir) {
+          // Health file is in the project directory
+          const healthFile = join(projectDir, '.health-status.json');
+
+          if (existsSync(healthFile)) {
+            const healthData = JSON.parse(readFileSync(healthFile, 'utf-8'));
+            healthStatus = {
+              pm2: proc.status === 'online',
+              discord: healthData.discord || false,
+              docker: healthData.docker || false,
+              overall: healthData.docker ? 'healthy' : 'degraded'
+            };
+          }
+        }
+      } catch (e) {
+        console.debug('[Health] Could not read project from config:', e.message);
+      }
+    }
+  } catch (e) {
+    // If health file doesn't exist or can't be read, use PM2 status only
+    console.debug('[Health] Could not read health status file:', e.message);
+  }
+
+  // If Docker status is still false and we have a container name, check directly
+  if (!healthStatus.docker && containerName && proc.status === 'online') {
+    try {
+      const { execSync } = await import('child_process');
+      const result = execSync(
+        `docker inspect -f '{{.State.Running}}' ${containerName} 2>/dev/null`,
+        { encoding: 'utf-8' }
+      ).trim();
+      healthStatus.docker = result === 'true';
+      healthStatus.overall = healthStatus.docker ? 'healthy' : 'degraded';
+    } catch (e) {
+      // Docker container not running or doesn't exist
+      healthStatus.docker = false;
+      healthStatus.overall = 'degraded';
+    }
+  }
+
   // platformPM2 returns simplified format with direct properties
   return {
     name: proc.name,
-    status: proc.status || 'unknown',
+    status: proc.status || 'stopped',
     exists: true,
     pid: proc.pid,
     uptime: proc.uptime || 0,
     memory: proc.memory || 0,
     cpu: proc.cpu || 0,
-    restarts: proc.restarts || 0
+    restarts: proc.restarts || 0,
+    health: healthStatus
   };
 }
 
@@ -194,8 +264,8 @@ export function formatStatus(status) {
     online: '✓',
     stopped: '○',
     errored: '✗',
-    unknown: '?'
-  }[status.status] || '?';
+    restarting: '⟳'
+  }[status.status] || '○';
 
   const memoryMB = Math.round(status.memory / 1024 / 1024);
   const uptimeSec = Math.floor((Date.now() - status.uptime) / 1000);

package/src/core/instance/validator.js

@@ -19,18 +19,18 @@ import { existsSync } from 'fs';
 export function detectInstanceType(projectPath) {
   const normalizedPath = path.resolve(projectPath);
 
-  // Check if it has BMAD framework (_bmad directory)
-  const hasBmad = existsSync(path.join(normalizedPath, '_bmad'));
+  // Check if it has BMAD plugin (_agent-bridge directory with bot.js)
+  const agentBridgePath = path.join(normalizedPath, '_agent-bridge');
+  const hasPlugin = existsSync(agentBridgePath) && existsSync(path.join(agentBridgePath, 'src', 'bot.js'));
 
-  // Check if it has BMAD plugin (_agent-bridge directory)
-  const hasPlugin = existsSync(path.join(normalizedPath, '_agent-bridge'));
-
-  // BMAD plugin instance (has either _bmad or _agent-bridge)
-  if (hasBmad || hasPlugin) {
+  // BMAD plugin instance (has _agent-bridge with bot.js)
+  if (hasPlugin) {
     return 'bmad-plugin';
   }
 
   // Check if it has config.json (simple config instance)
+  // This takes precedence over _bmad directory, as many BMAD projects
+  // are run as simple-config bots
   const hasConfig = existsSync(path.join(normalizedPath, 'config.json'));
   if (hasConfig) {
     return 'simple-config';

package/src/core/platform/pm2-bridge.js

@@ -129,6 +129,11 @@ async function start(scriptPath, options = {}) {
     }
   }
 
+  // Note: PM2 CLI doesn't support --max-restarts or --min-uptime as direct options
+  // These must be set via ecosystem config file or app configuration
+  // For now, we skip these to avoid errors
+  // Users can configure restart behavior in ecosystem.config.js
+
   if (options.instances) {
     args.push('-i', String(options.instances));
   }