foliko 1.0.25 → 1.0.27

package/.claude/settings.local.json

@@ -57,7 +57,14 @@
       "Bash(node -e \"const { WeixinBot } = require\\('@chnak/weixin-bot'\\); console.log\\(typeof WeixinBot\\)\" 2>&1)",
       "Bash(node -e \"import\\('@chnak/weixin-bot'\\).then\\(m => console.log\\('OK:', typeof m.WeixinBot\\)\\).catch\\(e => console.error\\('Error:', e.message\\)\\)\" 2>&1)",
       "Bash(ls -la D:/code/vb-agent/cli/bin/ && cat D:/code/vb-agent/cli/bin/*.js 2>/dev/null | head -50)",
-      "Bash(npm config:*)"
+      "Bash(npm config:*)",
+      "Bash(node -c plugins/subagent-plugin.js 2>&1)",
+      "Bash(node -c plugins/default-plugins.js 2>&1)",
+      "Bash(node -c plugins/default-plugins.js && node -c src/core/plugin-manager.js && node -c plugins/tools-plugin.js 2>&1)",
+      "Bash(node -c src/core/plugin-base.js && node -c src/core/plugin-manager.js 2>&1)",
+      "Bash(node -c plugins/telegram-plugin.js && node -c plugins/weixin-plugin.js 2>&1)",
+      "Bash(node -c src/core/plugin-manager.js 2>&1)",
+      "Bash(node -c src/core/plugin-manager.js && node -c src/core/plugin-base.js && node -c plugins/default-plugins.js && node -c plugins/telegram-plugin.js && node -c plugins/weixin-plugin.js 2>&1)"
     ]
   }
 }

package/README.md

@@ -11,15 +11,42 @@
 - **技能系统** - 可扩展的 Skill 管理
 - **会话管理** - 支持多会话切换
 - **规则引擎** - 可配置的行为规则
+- **子 Agent** - 支持多子 Agent 分工协作
+
+## 安装
+
+```bash
+# 方式一：npm 安装
+npm install -g foliko
+
+# 方式二：Windows 一键脚本安装
+irm https://folikoai.com/install.ps1 | iex
+
+# 方式三：Mac/Linux 一键脚本安装
+curl -fsSL https://folikoai.com/install.sh | bash
+```
 
 ## 快速开始
 
 ```bash
-# 安装
-npm install
+# 全局安装后
+foliko chat
+```
+
+## CLI 命令
+
+```bash
+# 聊天模式（使用 .env 中的配置）
+foliko chat
+
+# 指定完整配置
+foliko chat --provider deepseek --model deepseek-chat --base-url https://api.deepseek.com/v1 --api-key sk-xxx
+
+# 只指定 provider（使用 provider 默认 model 和 baseURL）
+foliko chat --provider deepseek --api-key sk-xxx
 
-# 启动聊天
-npm run chat
+# 列出所有子Agent配置
+foliko list
 ```
 
 ## 项目结构
@@ -30,7 +57,7 @@ foliko/
 │   └── bin/foliko.js    # CLI 入口
 ├── src/                 # 核心框架
 │   ├── core/            # 核心组件
-│   ├── capabilities/    # 能力插件
+│   ├── capabilities/     # 能力插件
 │   └── executors/       # 执行器
 ├── plugins/             # 内置插件
 ├── skills/              # 技能目录
@@ -50,19 +77,19 @@ FOLIKO_PROVIDER=minimax
 # AI Model（可选，不填则使用 provider 默认值）
 # MiniMax: MiniMax-M2.7
 # DeepSeek: deepseek-chat, deepseek-coder 等
-FOLIKO_MODEL=
+FOLIKO_MODEL=MiniMax-M2.7
 
 # API Base URL（可选，不填则使用 provider 默认值）
 # MiniMax: https://api.minimaxi.com/v1
 # DeepSeek: https://api.deepseek.com/v1
-FOLIKO_BASE_URL=
+FOLIKO_BASE_URL=https://api.minimaxi.com/v1
 
 # API Key（通用，不填则使用 provider 专用 key）
-FOLIKO_API_KEY=
+FOLIKO_API_KEY=sk-your-minimax-api-key
 
 # Provider 专用 API Key（可选）
-DEEPSEEK_API_KEY=sk-your-deepseek-api-key
-MINIMAX_API_KEY=sk-your-minimax-api-key
+# DEEPSEEK_API_KEY=sk-your-deepseek-api-key
+# MINIMAX_API_KEY=sk-your-minimax-api-key
 ```
 
 **配置优先级**：命令行参数 > .env配置 > provider默认值
@@ -74,11 +101,49 @@ MINIMAX_API_KEY=sk-your-minimax-api-key
 ├── config              # 配置文件
 ├── ai.json            # AI 配置
 ├── mcp_config.json    # MCP 服务器配置
+├── agents/            # 子Agent配置目录
 ├── plugins/           # 用户插件目录
 ├── skills/            # 用户技能目录
 └── data/              # 数据目录
 ```
 
+### 子 Agent 配置 (.agent/agents/)
+
+在 `.agent/agents/` 目录下放置子 Agent 配置文件，支持 `.js`、`.json`、`.md` 格式：
+
+```
+.agent/agents/
+├── backend-specialist.md
+├── frontend-specialist.md
+└── database-architect.md
+```
+
+#### JSON 格式
+
+```json
+{
+  "name": "backend-specialist",
+  "role": "Backend Specialist",
+  "description": "Expert in backend development",
+  "parentTools": ["read_file", "run_command"]
+}
+```
+
+#### Markdown 格式
+
+```markdown
+# Backend Specialist
+
+```json
+{
+  "name": "backend-specialist",
+  "role": "Backend Specialist",
+  "description": "Expert in backend development",
+  "parentTools": ["read_file", "run_command"]
+}
+```
+```
+
 ### ai.json 格式
 
 ```json
@@ -191,37 +256,57 @@ allowed-tools: tool1,tool2
 技能内容...
 ```
 
-## CLI 命令
-
-```bash
-# 聊天模式（使用 .env 中的配置）
-npm run chat
-
-# 指定完整配置
-foliko chat --provider deepseek --model deepseek-chat --base-url https://api.deepseek.com/v1 --api-key sk-xxx
-
-# 只指定 provider（使用 provider 默认 model 和 baseURL）
-foliko chat --provider deepseek --api-key sk-xxx
-
-# 只指定 api-key（使用 FOLIKO_PROVIDER 设定的 provider）
-foliko chat --api-key sk-xxx
-```
-
 ## 内置工具
 
+### 通用工具
+
 | 工具 | 说明 |
 |------|------|
 | `loadSkill` | 加载技能 |
-| `mcp_execute` | 执行 MCP 工具 |
-| `shell_execute` | 执行 Shell 命令 |
-| `python_execute` | 执行 Python 代码 |
+| `list_plugins` | 列出所有插件 |
+| `list_tools` | 列出所有工具 |
+| `reload_plugins` | 重载插件 |
+| `shell` | 执行 Shell 命令 |
+| `powershell` | 执行 PowerShell 命令 |
+| `python-execute` | 执行 Python 代码 |
+| `python_script` | 执行 Python 脚本 |
+| `pip_install` | 安装 Python 包 |
 | `install` | 安装 npm 包 |
 | `mcp_reload` | 重载 MCP 服务器 |
 | `audit_query` | 查询审计日志 |
 
+### 子 Agent 管理工具
+
+| 工具 | 说明 |
+|------|------|
+| `subagent_list` | 列出所有子Agent |
+| `subagent_call` | 调用指定的子Agent处理任务 |
+| `subagent_reload` | 重新加载子Agent配置 |
+
+### 会话工具
+
+| 工具 | 说明 |
+|------|------|
+| `session_create` | 创建会话 |
+| `session_get` | 获取会话 |
+| `session_list` | 列出所有会话 |
+| `session_delete` | 删除会话 |
+| `session_history` | 获取会话历史 |
+
+### 定时任务工具
+
+| 工具 | 说明 |
+|------|------|
+| `schedule_task` | 创建定时任务 |
+| `schedule_list` | 列出定时任务 |
+| `schedule_cancel` | 取消定时任务 |
+| `cron_examples` | 显示 cron 示例 |
+
 ## 工作目录
 
 CLI 工作目录默认使用执行命令的目录。
+- `.agent/` 目录会创建在工作目录下
+- 配置文件、插件、技能等都放在工作目录的 `.agent/` 下
 
 ## 许可证
 

package/cli/src/commands/chat.js

@@ -81,20 +81,8 @@ function parseArgs(args) {
  * Chat 命令入口
  */
 async function chatCommand(args) {
-  console.log('[chatCommand] Starting with env:', {
-    FOLIKO_PROVIDER: process.env.FOLIKO_PROVIDER,
-    FOLIKO_MODEL: process.env.FOLIKO_MODEL,
-    MINIMAX_API_KEY: process.env.MINIMAX_API_KEY ? '***' + process.env.MINIMAX_API_KEY.slice(-4) : 'null'
-  })
 
   const options = parseArgs(args)
-  console.log('[chatCommand] Parsed options:', {
-    provider: options.provider,
-    model: options.model,
-    baseURL: options.baseURL,
-    apiKey: options.apiKey ? '***' + options.apiKey.slice(-4) : 'null'
-  })
-
   console.log('=== Foliko 持续对话 ===\n')
   console.log('输入 exit 或 quit 退出\n')
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "foliko",
-  "version": "1.0.25",
+  "version": "1.0.27",
   "description": "简约的插件化 Agent 框架",
   "main": "src/index.js",
   "bin": {

package/plugins/ai-plugin.js

@@ -38,13 +38,6 @@ class AIPlugin extends Plugin {
   }
 
   _initAIClient() {
-    console.log('[AIPlugin] initAIClient called')
-    console.log('[AIPlugin] config:', JSON.stringify({
-      provider: this.config.provider,
-      model: this.config.model,
-      apiKey: this.config.apiKey ? '***' + this.config.apiKey.slice(-4) : 'null',
-      baseURL: this.config.baseURL
-    }))
 
     if (!this.config.apiKey) {
       console.warn('[AIPlugin] No API key provided, AI features disabled')

package/plugins/default-plugins.js

@@ -393,19 +393,18 @@ async function bootstrapDefaults(framework, config = {}) {
     console.log('[Bootstrap] Python Plugin Loader loaded')
   }
 
-  // 12.6 Telegram 插件（如果配置了Token）
+  // 12.6 Telegram 插件（默认禁用，需要在 plugins.json 中设置 enabled: true）
   if (shouldLoad('telegram')) {
-    const telegramToken = process.env.TELEGRAM_BOT_TOKEN || agentConfig.telegram?.botToken
-    if (telegramToken) {
-      const { Plugin } = require('../src/core/plugin-base')
-      const createTelegramPlugin = require('./telegram-plugin')
-      const TelegramPlugin = createTelegramPlugin(Plugin)
-      await framework.loadPlugin(new TelegramPlugin({ botToken: telegramToken }))
-      console.log('[Bootstrap] Telegram Plugin loaded')
+    const { Plugin } = require('../src/core/plugin-base')
+    const createTelegramPlugin = require('./telegram-plugin')
+    const TelegramPlugin = createTelegramPlugin(Plugin)
+    const telegramConfig = {
+      botToken: process.env.TELEGRAM_BOT_TOKEN || agentConfig.telegram?.botToken
     }
+    await framework.loadPlugin(new TelegramPlugin(telegramConfig))
   }
 
-  // 12.7 WeChat 插件（始终加载，由配置控制是否扫码）
+  // 12.7 WeChat 插件（默认禁用，需要在 plugins.json 中设置 enabled: true）
   if (shouldLoad('weixin')) {
     try {
       const { Plugin } = require('../src/core/plugin-base')
@@ -417,13 +416,12 @@ async function bootstrapDefaults(framework, config = {}) {
         allowedUsers: agentConfig.weixin?.allowedUsers || []
       }
       await framework.loadPlugin(new WeixinPlugin(weixinConfig))
-      console.log('[Bootstrap] WeChat Plugin loaded')
     } catch (err) {
       console.warn('[Bootstrap] WeChat Plugin not available:', err.message)
     }
   }
 
-  // 12.8 SubAgent 管理器（加载 .agent/agents 目录下的子Agent）
+  // 12.8 SubAgent 管理器
   if (shouldLoad('subagent-manager')) {
     try {
       const { SubAgentManagerPlugin } = require('./subagent-plugin')

package/plugins/subagent-plugin.js

@@ -40,7 +40,7 @@ class SubAgentPlugin extends Plugin {
   }
 
   start(framework) {
-    // 创建子Agent
+    // 创建子Agent（可能需要等待父agent准备好）
     this._createSubAgent()
 
     // 注册委托工具到主Agent（通过framework获取父agent）
@@ -56,7 +56,30 @@ class SubAgentPlugin extends Plugin {
     // 获取父Agent（主Agent）
     const parentAgent = this._getParentAgent()
     if (!parentAgent) {
-      console.warn(`[SubAgent:${this.config.name}] Parent agent not found`)
+      // 父agent还没创建，监听事件等其创建
+      if (this._framework) {
+        const framework = this._framework
+        framework.on('agent:created', (agent) => {
+          if (framework._mainAgent && agent === framework._mainAgent) {
+            // 父agent已创建，重新尝试创建子agent
+            this._doCreateSubAgent(agent)
+            // 注册委托工具
+            this._registerDelegateTool()
+          }
+        })
+      }
+      return
+    }
+
+    this._doCreateSubAgent(parentAgent)
+  }
+
+  /**
+   * 实际执行创建子Agent
+   */
+  _doCreateSubAgent(parentAgent) {
+    // 避免重复创建
+    if (this._agent) {
       return
     }
 
@@ -79,7 +102,7 @@ class SubAgentPlugin extends Plugin {
 
     // 注册从父Agent继承的工具
     for (const tool of parentTools) {
-      this._agent.registerTool(tool)
+      this._framework.registerTool(tool)
     }
 
     // 注册自定义工具（只属于此子Agent，不污染全局）
@@ -88,10 +111,10 @@ class SubAgentPlugin extends Plugin {
       for (const [toolName, toolDef] of Object.entries(this.config.tools)) {
         const tool = typeof toolDef === 'function' ? toolDef() : toolDef
         if (typeof tool === 'object' && tool.name) {
-          this._agent.registerTool(tool)
+          this._framework.registerTool(tool)
         } else {
           // 假设是简化的工具定义，需要补充 name
-          this._agent.registerTool({ name: toolName, ...tool })
+          this._framework.registerTool({ name: toolName, ...tool })
         }
       }
     }
@@ -186,27 +209,31 @@ class SubAgentPlugin extends Plugin {
   }
 
   /**
-   * 注册委托工具到父Agent
+   * 注册委托工具到框架和主Agent
    */
   _registerDelegateTool() {
-    const parentAgent = this._getParentAgent()
-    if (!parentAgent) return
+    const framework = this._framework
+    if (!framework) return
 
     const agentName = this.config.name
     const role = this.config.role
 
-    // 注册工具到父Agent
-    parentAgent.registerTool({
+    const toolDef = {
       name: agentName,
       description: `${role}：当需要${role}时，调用此工具执行任务。如：编译代码、运行测试、代码重构等。`,
       inputSchema: z.object({
         task: z.string().describe('给子Agent的具体任务描述')
       }),
-      execute: async (args, framework) => {
+      execute: async (args, fw) => {
         if (!this._agent) {
           return { error: `SubAgent ${agentName} not initialized` }
         }
 
+        const parentAgent = fw._mainAgent
+        if (!parentAgent) {
+          return { error: `Parent agent not found` }
+        }
+
         // 发射子Agent开始处理事件
         parentAgent.emit('subagent:chat:start', {
           parentAgent,
@@ -244,9 +271,17 @@ class SubAgentPlugin extends Plugin {
           }
         }
       }
-    })
+    }
+
+    // 注册到框架（供后续创建的 Agent 同步）
+    framework.registerTool(toolDef)
 
-    console.log(`[SubAgent:${this.config.name}] Delegate tool registered on parent agent`)
+    // 如果主 Agent 已存在，直接注册到它
+    if (framework._mainAgent) {
+      framework._mainAgent.registerTool(toolDef)
+    }
+
+    console.log(`[SubAgent:${this.config.name}] Delegate tool registered`)
   }
 
   /**
@@ -323,11 +358,20 @@ class SubAgentManagerPlugin extends Plugin {
       this._subAgents.set(agentConfig.name, plugin)
     }
 
-    // 注册管理工具到主 Agent，确保可用
-    const mainAgent = framework._mainAgent
-    if (mainAgent) {
-      this._registerToolsToAgent(mainAgent)
+    // 注册管理工具
+    // 如果主 Agent 已存在，直接注册到它（因为它不会自动同步框架工具）
+    if (framework._mainAgent) {
+      this._registerToolsToAgent(framework._mainAgent)
     }
+    // 同时注册到框架（供后续创建的 Agent 同步）
+    this._registerTools(framework)
+
+    // 监听主 Agent 创建事件，为后续创建的主 Agent 注册工具
+    framework.on('agent:created', (agent) => {
+      if (framework._mainAgent && agent === framework._mainAgent) {
+        this._registerToolsToAgent(agent)
+      }
+    })
 
     // 启动文件监控
     this._startFileWatcher()
@@ -339,8 +383,6 @@ class SubAgentManagerPlugin extends Plugin {
    * 注册管理工具到指定 Agent
    */
   _registerToolsToAgent(agent) {
-    if (!agent) return
-
     agent.registerTool({
       name: 'subagent_list',
       description: '列出所有子Agent',
@@ -400,16 +442,82 @@ class SubAgentManagerPlugin extends Plugin {
     console.log('[SubAgentManager] Management tools registered to agent')
   }
 
+  /**
+   * 注册管理工具到框架工具注册表
+   */
+  _registerTools(framework) {
+    framework.registerTool({
+      name: 'subagent_list',
+      description: '列出所有子Agent',
+      inputSchema: z.object({}),
+      execute: async () => {
+        const agents = Array.from(this._subAgents.values()).map(p => ({
+          name: p.config.name,
+          role: p.config.role,
+          description: p.config.description,
+          toolCount: p._agent ? p._agent.getTools().length : 0
+        }))
+        return { success: true, agents }
+      }
+    })
+
+    framework.registerTool({
+      name: 'subagent_call',
+      description: '调用指定的子Agent处理任务',
+      inputSchema: z.object({
+        agentName: z.string().describe('子Agent名称'),
+        task: z.string().describe('任务描述')
+      }),
+      execute: async (args) => {
+        const plugin = this._subAgents.get(args.agentName)
+        if (!plugin) {
+          return { success: false, error: `SubAgent ${args.agentName} not found` }
+        }
+
+        try {
+          const result = await plugin.chat(args.task)
+          return {
+            success: true,
+            agent: args.agentName,
+            result: result.message || result,
+            success: result.success !== false
+          }
+        } catch (err) {
+          return { success: false, error: err.message }
+        }
+      }
+    })
+
+    framework.registerTool({
+      name: 'subagent_reload',
+      description: '重新加载子Agent配置（当新增或删除.agent/agents下的文件后使用）',
+      inputSchema: z.object({}),
+      execute: async () => {
+        try {
+          this.reload(this._framework)
+          return { success: true, message: '子Agent配置已重新加载' }
+        } catch (err) {
+          return { success: false, error: err.message }
+        }
+      }
+    })
+
+    console.log('[SubAgentManager] Management tools registered to framework')
+  }
+
   /**
    * 从 agentsDir 目录加载子Agent配置
    */
   _loadAgentsFromDir() {
     const agentsDir = this.config.agentsDir
+    console.log('[SubAgentManager] _loadAgentsFromDir called, agentsDir:', agentsDir)
     if (!agentsDir || !fs.existsSync(agentsDir)) {
+      console.log('[SubAgentManager] agentsDir not found or does not exist')
       return
     }
 
     const entries = fs.readdirSync(agentsDir, { withFileTypes: true })
+    console.log('[SubAgentManager] Found entries:', entries.length)
 
     for (const entry of entries) {
       if (entry.isFile() && (entry.name.endsWith('.js') || entry.name.endsWith('.json') || entry.name.endsWith('.md'))) {
@@ -429,6 +537,7 @@ class SubAgentManagerPlugin extends Plugin {
           } else if (entry.name.endsWith('.md')) {
             // 解析 markdown 文件，提取 JSON 配置
             agentConfig = this._parseMarkdownConfig(filePath, baseName)
+            console.log('[SubAgentManager] Parsed md:', baseName, agentConfig)
           } else {
             // 清除缓存并加载
             delete require.cache[require.resolve(filePath)]
@@ -439,9 +548,12 @@ class SubAgentManagerPlugin extends Plugin {
           if (agentConfig && agentConfig.name) {
             agentConfig._fromDir = true
             this.config.agents.push(agentConfig)
+            console.log('[SubAgentManager] Loaded agent:', agentConfig.name)
+          } else {
+            console.warn('[SubAgentManager] Agent config has no name:', baseName, agentConfig)
           }
         } catch (err) {
-          console.warn(`[SubAgentManager] Failed to load agent config from ${filePath}:`, err.message)
+          console.warn(`[SubAgentManager] Failed to load agent config from ${filePath}:`, err.message, err.stack)
         }
       }
     }
@@ -457,48 +569,34 @@ class SubAgentManagerPlugin extends Plugin {
    */
   _parseMarkdownConfig(filePath, defaultName) {
     const content = fs.readFileSync(filePath, 'utf-8')
+    console.log('[SubAgentManager] _parseMarkdownConfig:', filePath)
 
     // 尝试从 code block 中提取 JSON
     const jsonMatch = content.match(/```(?:json)?\s*\n([\s\S]*?)\n\s*```/)
     if (jsonMatch) {
       try {
         const config = JSON.parse(jsonMatch[1].trim())
+        console.log('[SubAgentManager] Found JSON in code block')
         return config
       } catch (err) {
         // JSON 解析失败，继续
       }
     }
 
-    // 尝试从 content 部分提取配置
-    // 格式：key: value
-    const config = { name: defaultName }
-    const lines = content.split('\n')
-    let inFrontmatter = false
-    let frontmatterContent = ''
-
-    for (const line of lines) {
-      // 检查是否在 frontmatter 中
-      if (line.trim() === '---') {
-        if (inFrontmatter) {
-          // 解析 frontmatter
-          try {
-            const parsed = this._parseYamlLike(frontmatterContent)
-            return { ...config, ...parsed }
-          } catch (err) {
-            // 解析失败
-          }
-        }
-        inFrontmatter = true
-        frontmatterContent = ''
-        continue
-      }
-
-      if (inFrontmatter) {
-        frontmatterContent += line + '\n'
+    // 尝试从 frontmatter 格式中提取
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/)
+    if (frontmatterMatch) {
+      console.log('[SubAgentManager] Found frontmatter')
+      const frontmatterContent = frontmatterMatch[1]
+      const parsed = this._parseYamlLike(frontmatterContent)
+      if (parsed && parsed.name) {
+        console.log('[SubAgentManager] Parsed frontmatter:', parsed)
+        return { name: parsed.name || defaultName, ...parsed }
       }
     }
 
     // 从 markdown 内容中提取配置（key: value 格式）
+    const config = { name: defaultName }
     const yamlMatch = content.match(/^(name|role|description|parentTools|tools):\s*(.+)$/m)
     if (yamlMatch) {
       config[yamlMatch[1]] = yamlMatch[2].trim()

package/plugins/telegram-plugin.js

@@ -27,6 +27,8 @@ module.exports = function(Plugin) {
       this.version = '2.0.0'
       this.description = 'Telegram 对话插件，绑定主Agent进行持续对话'
       this.priority = 80
+      // 默认不启用，需要在 plugins.json 中设置 enabled: true
+      this.enabled = false
 
       this.config = {
         botToken: config.botToken || process.env.TELEGRAM_BOT_TOKEN,

package/plugins/tools-plugin.js

@@ -61,18 +61,20 @@ class ToolsPlugin extends Plugin {
       }
     })
 
-    // 列出已加载插件工具
+    // 列出所有插件工具（包括未加载的）
     framework.registerTool({
       name: 'list_plugins',
-      description: '列出所有已加载的插件',
+      description: '列出所有插件（包括未加载的）',
       inputSchema: z.object({}),
       execute: async () => {
-        const plugins = framework.pluginManager.getAll()
+        const plugins = framework.pluginManager.getAllKnown()
         return {
           success: true,
           plugins: plugins.map(p => ({
             name: p.name,
-            version: p.instance?.version
+            status: p.status,
+            enabled: p.enabled,
+            version: p.version
           }))
         }
       }

package/plugins/weixin-plugin.js

@@ -1,6 +1,6 @@
 /**
  * WeChat 插件
- * 使用@chnak/weixin-bot 实现微信对话
+ * 使用 @chnak/weixin-bot 实现微信对话
  *
  * 配置：
  * - forceLogin: 是否强制重新扫码登录
@@ -18,6 +18,8 @@ module.exports = function(Plugin) {
       this.version = '1.0.0'
       this.description = '微信对话插件，使用微信网页账号进行对话'
       this.priority = 80
+      // 默认不启用，需要在 plugins.json 中设置 enabled: true
+      this.enabled = false
 
       this.config = {
         forceLogin: config.forceLogin || process.env.WEIXIN_FORCE_LOGIN === 'true',
@@ -73,8 +75,8 @@ module.exports = function(Plugin) {
         const module = await import('@chnak/weixin-bot')
         WeixinBot = module.WeixinBot
       } catch (err) {
-        console.warn('[WeChat] Failed to load@chnak/weixin-bot:', err.message)
-        console.warn('[WeChat] Make sure@chnak/weixin-bot is installed: npm install@chnak/weixin-bot qrcode-terminal')
+        console.warn('[WeChat] Failed to load @chnak/weixin-bot:', err.message)
+        console.warn('[WeChat] Make sure @chnak/weixin-bot is installed: npm install @chnak/weixin-bot qrcode-terminal')
         return
       }
 

package/src/core/plugin-base.js

@@ -35,6 +35,13 @@ class Plugin {
    */
   agents = []
 
+  /**
+   * 插件是否启用，默认为 true
+   * 设置为 false 时插件不会被加载，但在列表中仍可见
+   * @type {boolean}
+   */
+  enabled = true
+
   _framework = null
   _subAgents = []
 

package/src/core/plugin-manager.js

@@ -16,6 +16,7 @@ class PluginManager {
     this._plugins = new Map()
     this._loading = false
     this._stateFile = path.join(process.cwd(), '.agent', 'data', 'plugins-state.json')
+    this._knownPlugins = new Set()  // 已知插件列表（包括未加载的）
   }
 
   /**
@@ -89,10 +90,13 @@ class PluginManager {
       pluginInstance.config = { ...pluginInstance.config, ...savedConfig }
     }
 
+    // 使用保存的状态，否则使用插件实例的 enabled，默认 true
+    const finalEnabled = savedEnabled !== undefined ? savedEnabled : (pluginInstance.enabled !== undefined ? pluginInstance.enabled : true)
+
     this._plugins.set(pluginInstance.name, {
       instance: pluginInstance,
       status: 'registered',
-      enabled: savedEnabled !== undefined ? savedEnabled : true  // 使用保存的状态，默认启用
+      enabled: finalEnabled
     })
 
     this.framework.emit('plugin:registered', pluginInstance)
@@ -116,7 +120,7 @@ class PluginManager {
         pluginInstance = this._createFromObject(plugin)
       }
 
-      // 如果已注册，使用已注册的实例
+      // 如果已注册，使用已注册的实例和状态
       const existing = this._plugins.get(pluginInstance.name)
       if (existing) {
         pluginInstance = existing.instance
@@ -424,12 +428,59 @@ class PluginManager {
       .map(e => ({ name: e.instance.name, instance: e.instance }))
   }
 
+  /**
+   * 注册一个已知插件（但不加载）
+   * 用于显示所有可用插件列表
+   * @param {string} name - 插件名称
+   * @param {Object} info - 插件信息
+   */
+  registerKnownPlugin(name, info = {}) {
+    this._knownPlugins.add(name)
+    // 如果插件还没注册过，记录它的信息
+    if (!this._plugins.has(name)) {
+      this._plugins.set(name, {
+        instance: { name, ...info },
+        status: 'known',
+        enabled: info.enabled !== undefined ? info.enabled : false
+      })
+    }
+  }
+
+  /**
+   * 获取所有已知插件（包括未加载的）
+   * @returns {Array} 插件列表，包含 name, status, enabled
+   */
+  getAllKnown() {
+    const result = []
+    for (const name of this._knownPlugins) {
+      const entry = this._plugins.get(name)
+      result.push({
+        name,
+        status: entry?.status || 'unknown',
+        enabled: entry?.enabled || false,
+        version: entry?.instance?.version
+      })
+    }
+    // 也加入已加载但不在 knownPlugins 中的
+    for (const [name, entry] of this._plugins) {
+      if (!result.find(p => p.name === name)) {
+        result.push({
+          name,
+          status: entry.status,
+          enabled: entry.enabled,
+          version: entry.instance?.version
+        })
+      }
+    }
+    return result
+  }
+
   /**
    * 检查插件是否存在
    * @param {string} name - 插件名称
    */
   has(name) {
-    return this._plugins.has(name)
+    return this._plugins.has(name) || this._knownPlugins.has(name)
   }
 
   /**
@@ -464,8 +515,12 @@ class PluginManager {
     }
 
     entry.enabled = true
+    // 同步更新插件实例的 enabled 属性，避免 load() 时被跳过
+    if (entry.instance) {
+      entry.instance.enabled = true
+    }
 
-    // 如果插件已加载，尝试重新启动（reload 会调用 start）
+    // 如果插件已加载，尝试重新启动
     if (entry.status === 'loaded') {
       try {
         // 如果之前已经启动过，先调用 stop 停止旧实例
@@ -481,6 +536,13 @@ class PluginManager {
       } catch (err) {
         console.error(`[PluginManager] Enable/reload failed for '${name}':`, err.message)
       }
+    } else if (entry.status === 'registered' || entry.status === 'known') {
+      // 插件只注册过但未加载，现在加载它
+      try {
+        await this.load(entry.instance)
+      } catch (err) {
+        console.error(`[PluginManager] Enable/load failed for '${name}':`, err.message)
+      }
     }
 
     this.framework.emit('plugin:enabled', entry.instance)
@@ -504,6 +566,10 @@ class PluginManager {
     }
 
     entry.enabled = false
+    // 同步更新插件实例的 enabled 属性
+    if (entry.instance) {
+      entry.instance.enabled = false
+    }
 
     // 如果插件正在运行，停止它
     if (entry.instance._started) {