foliko 1.0.7 → 1.0.9

package/src/core/plugin-manager.js

@@ -4,6 +4,8 @@
  */
 
 const { Plugin } = require('./plugin-base')
+const fs = require('fs')
+const path = require('path')
 
 class PluginManager {
   /**
@@ -13,6 +15,53 @@ class PluginManager {
     this.framework = framework
     this._plugins = new Map()
     this._loading = false
+    this._stateFile = path.join(process.cwd(), '.agent', 'data', 'plugins-state.json')
+  }
+
+  /**
+   * 获取状态文件路径
+   */
+  _getStateFile() {
+    const dir = path.dirname(this._stateFile)
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true })
+    }
+    return this._stateFile
+  }
+
+  /**
+   * 保存插件状态到文件
+   */
+  _saveState() {
+    try {
+      const state = {}
+      for (const [name, entry] of this._plugins) {
+        state[name] = {
+          enabled: entry.enabled,
+          config: entry.instance?.config || {}
+        }
+      }
+      fs.writeFileSync(this._getStateFile(), JSON.stringify(state, null, 2))
+    } catch (err) {
+      console.error('[PluginManager] Failed to save state:', err.message)
+    }
+  }
+
+  /**
+   * 加载插件状态从文件
+   */
+  _loadState() {
+    try {
+      const stateFile = this._getStateFile()
+      if (fs.existsSync(stateFile)) {
+        const state = JSON.parse(fs.readFileSync(stateFile, 'utf-8'))
+        console.log('[PluginManager] Loaded plugin state from file')
+        return state
+      }
+    } catch (err) {
+      console.error('[PluginManager] Failed to load state:', err.message)
+    }
+    return {}
   }
 
   /**
@@ -30,9 +79,20 @@ class PluginManager {
       pluginInstance = this._createFromObject(plugin)
     }
 
+    // 加载保存的状态
+    const savedState = this._loadState()
+    const savedEnabled = savedState[pluginInstance.name]?.enabled
+    const savedConfig = savedState[pluginInstance.name]?.config
+
+    // 恢复保存的配置到插件实例
+    if (savedConfig && pluginInstance.config) {
+      pluginInstance.config = { ...pluginInstance.config, ...savedConfig }
+    }
+
     this._plugins.set(pluginInstance.name, {
       instance: pluginInstance,
-      status: 'registered'
+      status: 'registered',
+      enabled: savedEnabled !== undefined ? savedEnabled : true  // 使用保存的状态，默认启用
     })
 
     this.framework.emit('plugin:registered', pluginInstance)
@@ -61,6 +121,12 @@ class PluginManager {
       if (existing) {
         pluginInstance = existing.instance
 
+        // 如果插件被禁用，跳过加载
+        if (!existing.enabled) {
+          console.log(`[PluginManager] Plugin '${pluginInstance.name}' is disabled`)
+          return pluginInstance
+        }
+
         // 如果已加载且已启动，直接返回
         if (existing.status === 'loaded' && pluginInstance._started) {
           console.warn(`[PluginManager] Plugin '${pluginInstance.name}' already loaded`)
@@ -191,28 +257,108 @@ class PluginManager {
     await this.startAll()
   }
 
+  /**
+   * 解析插件路径
+   * 支持两种结构：
+   * 1. 文件夹结构: .agent/plugins/my-plugin/index.js
+   * 2. 单文件结构: .agent/plugins/my-plugin.js
+   * @param {string} pluginsDir - 插件目录
+   * @param {string} name - 插件名称
+   * @returns {{path: string, type: 'folder'|'file'}|null} 插件路径和类型
+   * @private
+   */
+  _resolvePluginPath(pluginsDir, name) {
+    const folderPath = path.join(pluginsDir, name)
+    const filePath = path.join(pluginsDir, `${name}.js`)
+
+    // 文件夹优先
+    if (fs.existsSync(folderPath) && fs.statSync(folderPath).isDirectory()) {
+      const pkgPath = path.join(folderPath, 'package.json')
+      if (fs.existsSync(pkgPath)) {
+        try {
+          const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'))
+          const main = pkg.main || 'index.js'
+          const mainPath = path.join(folderPath, main)
+          if (fs.existsSync(mainPath)) {
+            return { path: mainPath, type: 'folder' }
+          }
+        } catch (err) {
+          console.warn(`[_resolvePluginPath] Failed to parse package.json for ${name}:`, err.message)
+        }
+      }
+      // 默认加载 index.js
+      const indexPath = path.join(folderPath, 'index.js')
+      if (fs.existsSync(indexPath)) {
+        return { path: indexPath, type: 'folder' }
+      }
+      console.warn(`[_resolvePluginPath] No entry point found for plugin folder: ${name}`)
+      return null
+    }
+
+    // 单文件回退
+    if (fs.existsSync(filePath)) {
+      return { path: filePath, type: 'file' }
+    }
+
+    return null
+  }
+
+  /**
+   * 扫描插件目录，返回所有插件名称
+   * @param {string} pluginsDir - 插件目录
+   * @returns {string[]} 插件名称列表
+   * @private
+   */
+  _scanPluginNames(pluginsDir) {
+    if (!fs.existsSync(pluginsDir)) {
+      return []
+    }
+
+    const names = new Set()
+    const entries = fs.readdirSync(pluginsDir, { withFileTypes: true })
+
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        // 文件夹插件
+        names.add(entry.name)
+      } else if (entry.isFile() && entry.name.endsWith('.js')) {
+        // 单文件插件（排除与文件夹同名的）
+        const baseName = entry.name.replace(/\.js$/, '')
+        if (!names.has(baseName)) {
+          names.add(baseName)
+        }
+      }
+    }
+
+    return Array.from(names)
+  }
+
   /**
    * 发现并加载自定义插件
    * @private
    */
   async _discoverCustomPlugins() {
-    const fs = require('fs')
-    const path = require('path')
-
     const pluginsDir = path.resolve(process.cwd(), '.agent', 'plugins')
     if (!fs.existsSync(pluginsDir)) {
       return
     }
 
-    const files = fs.readdirSync(pluginsDir).filter(f => f.endsWith('.js'))
+    // 扫描所有插件名称（支持文件夹和单文件）
+    const pluginNames = this._scanPluginNames(pluginsDir)
 
     // 从 pluginsDir 推导 agentDir（pluginsDir = <agentDir>/plugins）
     const agentDir = path.dirname(pluginsDir)
     const agentNodeModules = path.join(agentDir, 'node_modules')
 
-    for (const file of files) {
+    for (const pluginName of pluginNames) {
       try {
-        const pluginPath = path.join(pluginsDir, file)
+        const resolved = this._resolvePluginPath(pluginsDir, pluginName)
+        if (!resolved) {
+          console.warn(`[PluginManager] Cannot resolve plugin: ${pluginName}`)
+          continue
+        }
+
+        const { path: pluginPath, type } = resolved
 
         // 添加模块路径到搜索路径（优先级从高到低）
         const modulePathsToAdd = [
@@ -239,24 +385,24 @@ class PluginManager {
         }
 
         // 获取插件名称
-        let pluginName
+        let resolvedPluginName
         try {
           const tempPlugin = plugin.prototype instanceof require('./plugin-base')
             ? new plugin() : (typeof plugin === 'function' ? plugin() : plugin)
-          pluginName = tempPlugin.name || file.replace('.js', '')
+          resolvedPluginName = tempPlugin.name || pluginName
         } catch {
-          pluginName = file.replace('.js', '')
+          resolvedPluginName = pluginName
         }
 
         // 如果插件已加载且已启动，跳过
-        if (this.has(pluginName) && this.get(pluginName)?._started) {
+        if (this.has(resolvedPluginName) && this.get(resolvedPluginName)?._started) {
           continue
         }
 
-        console.log(`[PluginManager] Loading new plugin: ${file}`)
+        console.log(`[PluginManager] Loading new plugin: ${pluginName} (${type})`)
         await this.load(plugin)
       } catch (err) {
-        console.error(`[PluginManager] Failed to load plugin ${file}:`, err.message)
+        console.error(`[PluginManager] Failed to load plugin ${pluginName}:`, err.message)
       }
     }
   }
@@ -270,11 +416,11 @@ class PluginManager {
   }
 
   /**
-   * 获取所有已加载插件
+   * 获取所有已加载且已启用的插件
    */
   getAll() {
     return Array.from(this._plugins.values())
-      .filter(e => e.status === 'loaded')
+      .filter(e => e.status === 'loaded' && e.enabled)
       .map(e => ({ name: e.instance.name, instance: e.instance }))
   }
 
@@ -294,12 +440,122 @@ class PluginManager {
     return this._plugins.get(name)?.status === 'loaded'
   }
 
+  /**
+   * 检查插件是否启用
+   * @param {string} name - 插件名称
+   */
+  isEnabled(name) {
+    return this._plugins.get(name)?.enabled === true
+  }
+
+  /**
+   * 启用插件
+   * @param {string} name - 插件名称
+   */
+  async enable(name) {
+    const entry = this._plugins.get(name)
+    if (!entry) {
+      throw new Error(`Plugin '${name}' not found`)
+    }
+
+    if (entry.enabled) {
+      console.log(`[PluginManager] Plugin '${name}' already enabled`)
+      return
+    }
+
+    entry.enabled = true
+
+    // 如果插件已加载，尝试重新启动（reload 会调用 start）
+    if (entry.status === 'loaded') {
+      try {
+        // 如果之前已经启动过，先调用 stop 停止旧实例
+        if (entry.instance._started) {
+          if (typeof entry.instance.stop === 'function') {
+            await entry.instance.stop()
+          } else if (typeof entry.instance.stopBot === 'function') {
+            await entry.instance.stopBot()
+          }
+        }
+        // 调用 reload 让插件重新初始化（会调用 install 和 start）
+        await this.reload(name)
+      } catch (err) {
+        console.error(`[PluginManager] Enable/reload failed for '${name}':`, err.message)
+      }
+    }
+
+    this.framework.emit('plugin:enabled', entry.instance)
+    this._saveState()
+    console.log(`[PluginManager] Plugin '${name}' enabled`)
+  }
+
+  /**
+   * 禁用插件
+   * @param {string} name - 插件名称
+   */
+  async disable(name) {
+    const entry = this._plugins.get(name)
+    if (!entry) {
+      throw new Error(`Plugin '${name}' not found`)
+    }
+
+    if (!entry.enabled) {
+      console.log(`[PluginManager] Plugin '${name}' already disabled`)
+      return
+    }
+
+    entry.enabled = false
+
+    // 如果插件正在运行，停止它
+    if (entry.instance._started) {
+      try {
+        // 优先调用 stop 方法，其次调用 stopBot 方法
+        if (typeof entry.instance.stop === 'function') {
+          await entry.instance.stop()
+        } else if (typeof entry.instance.stopBot === 'function') {
+          await entry.instance.stopBot()
+        }
+        entry.instance._started = false
+      } catch (err) {
+        console.error(`[PluginManager] Stop failed for '${name}':`, err.message)
+      }
+    }
+
+    this.framework.emit('plugin:disabled', entry.instance)
+    this._saveState()
+    console.log(`[PluginManager] Plugin '${name}' disabled`)
+  }
+
+  /**
+   * 更新插件配置
+   * @param {string} name - 插件名称
+   * @param {Object} config - 新配置（会合并到现有配置）
+   */
+  updatePluginConfig(name, config) {
+    const entry = this._plugins.get(name)
+    if (!entry) {
+      throw new Error(`Plugin '${name}' not found`)
+    }
+
+    if (!entry.instance.config) {
+      entry.instance.config = {}
+    }
+
+    // 合并配置
+    entry.instance.config = { ...entry.instance.config, ...config }
+
+    // 保存状态
+    this._saveState()
+    console.log(`[PluginManager] Plugin '${name}' config updated`)
+
+    return entry.instance.config
+  }
+
   /**
    * 启动所有已加载但未启动的插件（按优先级排序）
    */
   async startAll() {
     const entries = Array.from(this._plugins.values())
-      .filter(e => e.status === 'loaded')
+      .filter(e => e.status === 'loaded' && e.enabled)  // 只启动已启用且已加载的插件
       .sort((a, b) => (a.instance.priority || 100) - (b.instance.priority || 100))
 
     for (const entry of entries) {