agent-window 1.3.3 → 1.3.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-window",
-  "version": "1.3.3",
+  "version": "1.3.5",
   "description": "A window to interact with AI agents through chat interfaces. Simplified interaction, powerful backend capabilities.",
   "type": "module",
   "main": "src/bot.js",

package/src/api/routes/instances.js

@@ -16,7 +16,8 @@ import {
   removeInstance,
   updateInstance,
   discoverInstances,
-  importInstance
+  importInstance,
+  importFromPath
 } from '../../core/instance/manager.js';
 import {
   getStatus,
@@ -244,7 +245,10 @@ export async function registerInstanceRoutes(fastify) {
 
       // Use botName for PM2 lookup, default to bot-{name}
       const botName = instance.botName || `bot-${name}`;
-      const status = await getStatus(botName, { instanceType: instance.instanceType });
+      const status = await getStatus(botName, {
+        instanceType: instance.instanceType,
+        configPath: instance.configPath
+      });
       return { ...status, instanceName: name };
     } catch (error) {
       reply.code(500).send({
@@ -352,6 +356,54 @@ export async function registerInstanceRoutes(fastify) {
     }
   });
 
+  /**
+   * POST /api/instances/import-from-path
+   * Manually import a BMAD plugin by providing its path
+   *
+   * This is the second registration method for BMAD plugins:
+   * - User manually provides the project path
+   * - System validates it's a valid BMAD plugin
+   * - If valid, registers it in instances.json
+   */
+  fastify.post('/api/instances/import-from-path', {
+    schema: {
+      description: 'Manually import a BMAD plugin by path',
+      body: {
+        type: 'object',
+        required: ['name', 'projectPath'],
+        properties: {
+          name: { type: 'string' },
+          projectPath: { type: 'string' },
+          displayName: { type: 'string' },
+          tags: { type: 'array', items: { type: 'string' } }
+        }
+      }
+    }
+  }, async (request, reply) => {
+    try {
+      const { name, projectPath, displayName, tags } = request.body;
+
+      const result = await importFromPath(name, projectPath, {
+        displayName,
+        tags
+      });
+
+      if (!result.success) {
+        return reply.code(400).send({
+          error: result.error,
+          validation: result.validation
+        });
+      }
+
+      reply.code(201).send(result.instance);
+    } catch (error) {
+      reply.code(500).send({
+        error: 'Failed to import from path',
+        message: error.message
+      });
+    }
+  });
+
   /**
    * GET /api/instances/:name/config
    * Get instance configuration

package/src/core/instance/manager.js

@@ -246,9 +246,73 @@ export async function removeInstance(name) {
  * @param {string} name - Instance name
  * @returns {Promise<Object|null>} Instance or null
  */
+/**
+ * Get a specific instance by name
+ * Also includes auto-discovered instances from PM2
+ *
+ * @param {string} name - Instance name
+ * @returns {Promise<Object|null>} Instance or null
+ */
 export async function getInstance(name) {
+  // First, try to find in registered instances
   const data = await readInstances();
-  return data.instances.find(i => i.name === name) || null;
+  const registered = data.instances.find(i => i.name === name);
+  if (registered) {
+    return registered;
+  }
+
+  // If not found, check if it exists as an auto-discovered instance in PM2
+  // This allows status checks for simple-config instances that aren't permanently registered
+  try {
+    const processes = await getProcesses();
+    const botName = `bot-${name}`;
+    const proc = processes.find(p => p.name === botName);
+
+    if (proc) {
+      // Determine instance type
+      let projectPath = null;
+      let configPath = proc.configPath;
+      let instanceType = 'simple-config';
+
+      if (configPath && existsSync(configPath)) {
+        try {
+          const configContent = await fs.readFile(configPath, 'utf8');
+          const config = JSON.parse(configContent);
+          projectPath = config.PROJECT_DIR || path.dirname(configPath);
+
+          // Detect instance type
+          if (projectPath && existsSync(projectPath)) {
+            instanceType = detectInstanceType(projectPath);
+          }
+        } catch {
+          projectPath = proc.cwd || null;
+        }
+      }
+
+      // Only return simple-config instances (BMAD plugins need explicit registration)
+      if (instanceType === 'simple-config') {
+        return {
+          name,
+          displayName: name.charAt(0).toUpperCase() + name.slice(1),
+          projectPath,
+          configPath,
+          pluginPath: null,
+          botName,
+          instanceType,
+          platform: 'discord',
+          aiProvider: null,
+          addedAt: new Date().toISOString(),
+          tags: ['auto-discovered'],
+          enabled: true,
+          _unregistered: true
+        };
+      }
+    }
+  } catch (error) {
+    console.debug('[Manager] Failed to look up auto-discovered instance:', error.message);
+  }
+
+  return null;
 }
 
 /**
@@ -258,10 +322,95 @@ export async function getInstance(name) {
  * @param {string} options.tag - Filter by tag
  * @returns {Promise<Array>} List of instances
  */
+/**
+ * List all instances
+ *
+ * For BMAD-plugin instances: returns only registered instances from instances.json
+ * For simple-config instances: automatically scans PM2 and includes all bot-* processes
+ *
+ * This ensures simple-config instances (managed by AgentWindow) appear automatically
+ * while BMAD-plugin instances require explicit registration.
+ *
+ * @param {Object} options - Options
+ * @param {boolean} options.enabledOnly - Filter to enabled instances only
+ * @param {string} options.tag - Filter by tag
+ * @param {boolean} options.includeUnregistered - Include PM2 processes not in instances.json
+ * @returns {Promise<Array>} List of instances
+ */
 export async function listInstances(options = {}) {
   const data = await readInstances();
-  let instances = data.instances;
+  const registeredNames = new Set(data.instances.map(i => i.botName || `bot-${i.name}`));
+
+  // Start with registered instances
+  let instances = [...data.instances];
+
+  // Auto-discover simple-config instances from PM2 (unless explicitly disabled)
+  // Simple-config instances should appear automatically as they are managed by AgentWindow
+  if (options.includeUnregistered !== false) {
+    try {
+      const processes = await getProcesses();
+      const botProcesses = processes.filter(p => p.name && p.name.startsWith('bot-'));
+
+      for (const proc of botProcesses) {
+        // Skip if already registered
+        if (registeredNames.has(proc.name)) {
+          continue;
+        }
+
+        // Extract instance name from bot-name
+        const instanceName = proc.name.replace(/^bot-/, '');
+
+        // Determine project path and config path from PM2 process
+        let projectPath = null;
+        let configPath = null;
+        let hasValidConfig = false;
+
+        // Get config path from PM2 environment
+        if (proc.configPath && existsSync(proc.configPath)) {
+          configPath = proc.configPath;
+          try {
+            const configContent = await fs.readFile(proc.configPath, 'utf8');
+            const config = JSON.parse(configContent);
+            projectPath = config.PROJECT_DIR || path.dirname(configPath);
+            hasValidConfig = true;
+          } catch {
+            projectPath = proc.cwd || null;
+          }
+        }
+
+        // Detect instance type - if it has _agent-bridge, it's a BMAD plugin
+        // BMAD plugins should NOT be auto-added (require explicit import)
+        if (projectPath && existsSync(projectPath)) {
+          const detectedType = detectInstanceType(projectPath);
+
+          // Only auto-add simple-config instances, skip BMAD plugins
+          if (detectedType === 'simple-config' && hasValidConfig) {
+            instances.push({
+              name: instanceName,
+              displayName: instanceName.charAt(0).toUpperCase() + instanceName.slice(1),
+              projectPath,
+              configPath,
+              pluginPath: null,
+              botName: proc.name,
+              instanceType: 'simple-config',
+              platform: 'discord',
+              aiProvider: null,
+              addedAt: new Date().toISOString(),
+              tags: ['auto-discovered'],
+              enabled: true,
+              // Mark as unregistered so frontend knows it's not permanently saved
+              _unregistered: true
+            });
+          }
+        }
+      }
+    } catch (error) {
+      // If PM2 scan fails, just return registered instances
+      console.debug('[Manager] PM2 scan failed, returning registered instances only:', error.message);
+    }
+  }
 
+  // Apply filters
   if (options.enabledOnly) {
     instances = instances.filter(i => i.enabled);
   }
@@ -416,16 +565,18 @@ export async function discoverInstances() {
 
       // Detect instance type based on project structure
       // Business Logic:
-      // - simple-config: Auto-discovered, managed by AgentWindow
-      // - bmad-plugin: Discovered but needs user confirmation
+      // - simple-config: Auto-discovered in listInstances() - NOT in discover
+      // - bmad-plugin: Only shown here for user to import
       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
+      // IMPORTANT: Only return bmad-plugin instances in discover
+      // simple-config instances are auto-shown in listInstances()
+      if (instanceType !== 'bmad-plugin') {
+        continue;
+      }
 
       discovered.push({
         botName: proc.name,
@@ -434,7 +585,7 @@ export async function discoverInstances() {
         projectPath,
         configPath,
         pluginPath,
-        instanceType,  // 'bmad' | 'simple' | 'unknown'
+        instanceType: 'bmad-plugin',
         status: proc.status || 'unknown',
         pid: proc.pid,
         memory: proc.memory || 0,
@@ -451,6 +602,91 @@ export async function discoverInstances() {
   return discovered;
 }
 
+/**
+ * Import a BMAD plugin by manually providing its path
+ *
+ * This is the second registration method for BMAD plugins.
+ * Unlike discover+import, this allows users to directly specify a path.
+ *
+ * @param {string} name - Instance name
+ * @param {string} projectPath - Path to the BMAD project
+ * @param {Object} options - Additional options
+ * @param {string} options.displayName - Display name
+ * @param {string[]} options.tags - Tags
+ * @returns {Promise<Object>} Result with success and instance
+ */
+export async function importFromPath(name, projectPath, options = {}) {
+  // Validate name format
+  if (!name || !name.match(/^[a-z0-9-]+$/)) {
+    return {
+      success: false,
+      error: '实例名称只能包含小写字母、数字和连字符'
+    };
+  }
+
+  // Check if instance already exists
+  const data = await readInstances();
+  if (data.instances.find(i => i.name === name)) {
+    return {
+      success: false,
+      error: `实例 "${name}" 已存在`
+    };
+  }
+
+  // Validate project path exists
+  if (!existsSync(projectPath)) {
+    return {
+      success: false,
+      error: '项目路径不存在'
+    };
+  }
+
+  // Validate it's a valid BMAD plugin
+  const validation = await validateInstance(projectPath);
+  if (!validation.valid) {
+    return {
+      success: false,
+      error: '不是有效的 BMAD 插件：' + (validation.error || '验证失败'),
+      validation
+    };
+  }
+
+  // Only BMAD plugins can be imported via manual path
+  if (validation.instanceType !== 'bmad-plugin') {
+    return {
+      success: false,
+      error: '此功能仅支持导入 BMAD 插件。基础版实例请使用 "Discover" 功能。',
+      validation
+    };
+  }
+
+  // Determine config path for BMAD plugin
+  const agentBridgeConfigPath = path.join(validation.projectPath, '_agent-bridge', 'config', 'config.json');
+
+  const newInstance = {
+    name,
+    displayName: options.displayName || name,
+    projectPath: validation.projectPath,
+    pluginPath: validation.pluginPath,
+    configPath: agentBridgeConfigPath,
+    botName: `bot-${name}`,
+    instanceType: 'bmad-plugin',
+    platform: 'discord',
+    aiProvider: null,
+    addedAt: new Date().toISOString(),
+    tags: [...(options.tags || []), 'manually-imported'],
+    enabled: true
+  };
+
+  data.instances.push(newInstance);
+  await writeInstances(data);
+
+  return {
+    success: true,
+    instance: newInstance
+  };
+}
+
 /**
  * Import a discovered instance into instances.json
  * @param {Object} discovered - Discovered instance object

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

@@ -157,10 +157,11 @@ export async function getLogs(name, options = {}) {
  * @param {string} name - Process name
  * @param {Object} options - Options
  * @param {string} options.instanceType - Instance type for type-aware checks
+ * @param {string} options.configPath - Config path for Docker container name
  * @returns {Promise<Object>} Status info
  */
 export async function getStatus(name, options = {}) {
-  const { instanceType } = options;
+  const { instanceType, configPath } = options;
   const proc = await getProcess(name);
 
   if (!proc) {
@@ -189,12 +190,13 @@ export async function getStatus(name, options = {}) {
   const procStatus = proc.status || 'stopped';
 
   // Get container name from config for Docker check
+  // Priority: options.configPath > proc.configPath
   try {
     const { readFileSync } = await import('fs');
-    const configPath = proc.configPath;
+    const effectiveConfigPath = configPath || proc.configPath;
 
-    if (configPath) {
-      const configContent = JSON.parse(readFileSync(configPath, 'utf-8'));
+    if (effectiveConfigPath) {
+      const configContent = JSON.parse(readFileSync(effectiveConfigPath, 'utf-8'));
       containerName = configContent.workspace?.containerName || null;
     }
   } catch (e) {
@@ -224,12 +226,14 @@ export async function getStatus(name, options = {}) {
     if (containerName && procStatus === 'online') {
       try {
         const { execSync } = await import('child_process');
+        // Use shorter timeout (2s) to avoid blocking status check
         const result = execSync(
           `docker inspect -f '{{.State.Running}}' ${containerName} 2>/dev/null`,
-          { encoding: 'utf-8', timeout: 5000 }
+          { encoding: 'utf-8', timeout: 2000 }
         ).trim();
         dockerRunning = result === 'true';
       } catch (e) {
+        // Docker inspect failed (container not running or Docker daemon issue)
         dockerRunning = false;
       }
     }