@eoasmxd/freya 0.4.0 → 0.4.1

package/plugins/plugin-tool-mysql/dist/pool-manager.js

@@ -0,0 +1,113 @@
+import mysql from 'mysql2/promise';
+/** 安全解算嵌套或扁平配置值 */
+function getNestedConfig(config, keyPath) {
+    if (!config)
+        return undefined;
+    if (keyPath in config)
+        return config[keyPath];
+    const parts = keyPath.split('.');
+    let current = config;
+    for (const part of parts) {
+        if (current && typeof current === 'object' && part in current) {
+            current = current[part];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return current;
+}
+/** MySQL 多命名连接池管理器 */
+export class MysqlPoolManager {
+    ctx;
+    pools = new Map();
+    connectionConfigs = new Map();
+    defaultConnectionName = 'default';
+    constructor(ctx) {
+        this.ctx = ctx;
+        this.reloadConfigs();
+    }
+    /** 加载与同步配置 */
+    reloadConfigs() {
+        this.connectionConfigs.clear();
+        const config = this.ctx.config || {};
+        this.defaultConnectionName = getNestedConfig(config, 'mysql.defaultConnection') || 'default';
+        const connections = getNestedConfig(config, 'mysql.connections');
+        if (Array.isArray(connections)) {
+            for (const item of connections) {
+                if (item && typeof item === 'object' && item.name) {
+                    this.connectionConfigs.set(item.name, {
+                        name: String(item.name),
+                        host: item.host ? String(item.host) : '127.0.0.1',
+                        port: item.port ? Number(item.port) : 3306,
+                        user: item.user ? String(item.user) : 'root',
+                        password: item.password ? String(item.password) : '',
+                        database: item.database ? String(item.database) : undefined,
+                        connectionLimit: item.connectionLimit ? Number(item.connectionLimit) : 5,
+                        connectTimeout: item.connectTimeout ? Number(item.connectTimeout) : 10000
+                    });
+                }
+            }
+        }
+        if (this.connectionConfigs.size === 0) {
+            const singleHost = getNestedConfig(config, 'mysql.host');
+            if (singleHost) {
+                this.connectionConfigs.set(this.defaultConnectionName, {
+                    name: this.defaultConnectionName,
+                    host: String(singleHost),
+                    port: getNestedConfig(config, 'mysql.port') ? Number(getNestedConfig(config, 'mysql.port')) : 3306,
+                    user: getNestedConfig(config, 'mysql.user') ? String(getNestedConfig(config, 'mysql.user')) : 'root',
+                    password: getNestedConfig(config, 'mysql.password') ? String(getNestedConfig(config, 'mysql.password')) : '',
+                    database: getNestedConfig(config, 'mysql.database') ? String(getNestedConfig(config, 'mysql.database')) : undefined,
+                    connectionLimit: getNestedConfig(config, 'mysql.connectionLimit') ? Number(getNestedConfig(config, 'mysql.connectionLimit')) : 5,
+                    connectTimeout: getNestedConfig(config, 'mysql.connectTimeout') ? Number(getNestedConfig(config, 'mysql.connectTimeout')) : 10000
+                });
+            }
+        }
+    }
+    /** 获取指定名称的数据库连接池 */
+    getPool(targetName) {
+        this.reloadConfigs();
+        const connectionName = targetName || this.defaultConnectionName;
+        const conf = this.connectionConfigs.get(connectionName);
+        if (!conf) {
+            const available = Array.from(this.connectionConfigs.keys()).join(', ') || '无配置';
+            throw new Error(`未找到名为 "${connectionName}" 的 MySQL 连接配置。当前可用连接: [${available}]`);
+        }
+        let pool = this.pools.get(connectionName);
+        if (!pool) {
+            pool = mysql.createPool({
+                host: conf.host,
+                port: conf.port,
+                user: conf.user,
+                password: conf.password,
+                database: conf.database,
+                connectionLimit: conf.connectionLimit,
+                connectTimeout: conf.connectTimeout,
+                waitForConnections: true,
+                queueLimit: 0,
+                dateStrings: true
+            });
+            this.pools.set(connectionName, pool);
+            this.ctx.logger.info(`MySQL 连接池已创建: [${connectionName}] -> ${conf.user}@${conf.host}:${conf.port}/${conf.database || ''}`);
+        }
+        return { pool, config: conf };
+    }
+    /** 获取所有可用连接名称 */
+    getAvailableConnectionNames() {
+        return Array.from(this.connectionConfigs.keys());
+    }
+    /** 释放所有已建立的连接池资源 */
+    async closeAll() {
+        for (const [name, pool] of this.pools.entries()) {
+            try {
+                await pool.end();
+                this.ctx.logger.info(`MySQL 连接池已释放: [${name}]`);
+            }
+            catch (err) {
+                this.ctx.logger.warn(`关闭 MySQL 连接池 [${name}] 时发生异常: ${err?.message || err}`);
+            }
+        }
+        this.pools.clear();
+    }
+}

package/plugins/plugin-tool-mysql/dist/tools.d.ts

@@ -0,0 +1,11 @@
+import type { FreyaContext, ToolDefinition, FreyaTool } from '@eoasmxd/freya-sdk';
+import type { MysqlPoolManager } from './pool-manager.js';
+import type { SqlAuditService } from './audit.js';
+/** MySQL 数据库查询执行工具 */
+export declare class MysqlQueryTool implements FreyaTool {
+    private poolManager;
+    private auditService;
+    constructor(poolManager: MysqlPoolManager, auditService: SqlAuditService);
+    getDefinition(): ToolDefinition;
+    execute(args: Record<string, any>, ctx: FreyaContext): Promise<string>;
+}

package/plugins/plugin-tool-mysql/dist/tools.js

@@ -0,0 +1,88 @@
+/** 脱敏错误信息中的敏感凭据 */
+function sanitizeErrorMessage(err, password) {
+    let message = err?.message || String(err);
+    if (password) {
+        message = message.replaceAll(password, '******');
+    }
+    return message;
+}
+/** MySQL 数据库查询执行工具 */
+export class MysqlQueryTool {
+    poolManager;
+    auditService;
+    constructor(poolManager, auditService) {
+        this.poolManager = poolManager;
+        this.auditService = auditService;
+    }
+    getDefinition() {
+        return {
+            name: 'mysql_query',
+            description: '执行 MySQL SELECT 查询语句并返回结构化数据。执行前会进行独立 LLM 安全与完整性审核，支持通过 connection 指定目标连接。',
+            parameters: {
+                type: 'object',
+                properties: {
+                    sql: {
+                        type: 'string',
+                        description: '待执行的 SQL 查询语句'
+                    },
+                    connection: {
+                        type: 'string',
+                        description: '目标数据库连接名称（可选，若未指定则使用系统默认连接）'
+                    },
+                    params: {
+                        type: 'array',
+                        items: {},
+                        description: '可选的参数化查询参数列表'
+                    }
+                },
+                required: ['sql']
+            }
+        };
+    }
+    async execute(args, ctx) {
+        const rawSql = typeof args.sql === 'string' ? args.sql.trim() : '';
+        if (!rawSql) {
+            return '❌ 参数错误: sql 语句不能为空。';
+        }
+        const connectionName = typeof args.connection === 'string' && args.connection.trim()
+            ? args.connection.trim()
+            : undefined;
+        const queryParams = Array.isArray(args.params) ? args.params : undefined;
+        const auditResult = await this.auditService.audit(rawSql, connectionName || 'default', ctx);
+        if (!auditResult.passed) {
+            return `❌ SQL 审查未通过，已拒绝执行。\n原因: ${auditResult.reason}`;
+        }
+        let currentPassword = '';
+        try {
+            const { pool, config } = this.poolManager.getPool(connectionName);
+            currentPassword = config.password || '';
+            const maxRows = Number(ctx.config?.mysql?.maxRows ?? ctx.config?.['mysql.maxRows']) || 100;
+            const [rows] = await pool.query(rawSql, queryParams);
+            if (!Array.isArray(rows)) {
+                return JSON.stringify({
+                    connection: config.name,
+                    database: config.database || null,
+                    affectedRows: rows.affectedRows ?? 0,
+                    info: rows.info || '查询已完成'
+                }, null, 2);
+            }
+            const totalCount = rows.length;
+            const truncated = totalCount > maxRows;
+            const data = truncated ? rows.slice(0, maxRows) : rows;
+            return JSON.stringify({
+                connection: config.name,
+                database: config.database || null,
+                totalCount,
+                returnedCount: data.length,
+                truncated,
+                notice: truncated ? `结果集超过最大限制 ${maxRows} 条，已自动截断返回前 ${maxRows} 条记录。` : undefined,
+                data
+            }, null, 2);
+        }
+        catch (err) {
+            const safeMessage = sanitizeErrorMessage(err, currentPassword);
+            ctx.logger.error(`MySQL 查询执行异常: ${safeMessage}`);
+            return `❌ MySQL 查询执行失败: ${safeMessage}`;
+        }
+    }
+}

package/plugins/plugin-tool-mysql/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@eoasmxd/freya-plugin-tool-mysql",
+  "version": "0.1.0",
+  "private": false,
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Freya MySQL 数据库查询工具集插件",
+  "freya": {
+    "displayName": "MySQL 数据库查询工具集",
+    "defaultEnabled": false,
+    "schema": "./schema.json",
+    "prompts": [
+      "plugin.prompt.mysql.md",
+      "plugin.prompt.mysql.select.audit.md"
+    ]
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@eoasmxd/freya-sdk": "^0.4.1",
+    "mysql2": "^3.11.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.5.0"
+  }
+}

package/plugins/plugin-tool-mysql/schema.json

@@ -0,0 +1,83 @@
+[
+  {
+    "key": "mysql.defaultConnection",
+    "defaultValue": "default",
+    "description": "默认使用的数据库连接名称",
+    "type": "string",
+    "category": "MySQL 连接"
+  },
+  {
+    "key": "mysql.maxRows",
+    "defaultValue": 100,
+    "description": "单次查询最大返回记录条数（防止大模型上下文窗口溢出）",
+    "type": "number",
+    "min": 1,
+    "max": 1000,
+    "category": "MySQL 安全",
+    "uiHint": "slider"
+  },
+  {
+    "key": "mysql.connections",
+    "defaultValue": [],
+    "description": "MySQL 命名数据库连接配置列表",
+    "type": "array",
+    "category": "MySQL 连接",
+    "children": [
+      {
+        "key": "name",
+        "description": "连接名称 (例如 default、bi_db)",
+        "type": "string",
+        "required": true
+      },
+      {
+        "key": "host",
+        "description": "数据库主机 (例如 127.0.0.1)",
+        "type": "string",
+        "required": true
+      },
+      {
+        "key": "port",
+        "description": "数据库端口 (默认 3306)",
+        "type": "number",
+        "defaultValue": 3306,
+        "required": true
+      },
+      {
+        "key": "user",
+        "description": "数据库用户名",
+        "type": "string",
+        "required": true
+      },
+      {
+        "key": "password",
+        "description": "数据库密码",
+        "type": "string",
+        "required": true,
+        "sensitive": true,
+        "uiHint": "password"
+      },
+      {
+        "key": "database",
+        "description": "数据库名称",
+        "type": "string",
+        "required": false
+      },
+      {
+        "key": "connectionLimit",
+        "description": "连接池最大连接数 (默认 5)",
+        "type": "number",
+        "defaultValue": 5,
+        "min": 1,
+        "max": 50
+      },
+      {
+        "key": "connectTimeout",
+        "description": "连接超时时间 (毫秒，默认 10000)",
+        "type": "number",
+        "defaultValue": 10000,
+        "min": 1000,
+        "max": 60000
+      }
+    ]
+  }
+]

package/plugins/plugin-tool-web/package.json

@@ -22,7 +22,7 @@
     "clean": "rm -rf dist"
   },
   "dependencies": {
-    "@eoasmxd/freya-sdk": "^0.4.0"
+    "@eoasmxd/freya-sdk": "^0.4.1"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",

package/plugins/plugin-wecom-channel/package.json

@@ -19,7 +19,7 @@
     "clean": "rm -rf dist"
   },
   "dependencies": {
-    "@eoasmxd/freya-sdk": "^0.4.0",
+    "@eoasmxd/freya-sdk": "^0.4.1",
     "ws": "^8.18.0"
   },
   "devDependencies": {

package/plugins/plugin-weixin-channel/package.json

@@ -18,7 +18,7 @@
     "clean": "rm -rf dist"
   },
   "dependencies": {
-    "@eoasmxd/freya-sdk": "^0.4.0",
+    "@eoasmxd/freya-sdk": "^0.4.1",
     "qrcode-terminal": "^0.12.0"
   },
   "devDependencies": {

package/src/packages/core/src/command/commands/skill-commands.ts

@@ -22,11 +22,12 @@ export function registerSkillCommands(deps: SkillCommandDeps): void {
     };
 
     const handleList = async (): Promise<string> => {
-        if (skills.size === 0) {
+        const activeSkills = Array.from(skills.values()).filter((s) => s.enabled !== false);
+        if (activeSkills.length === 0) {
             return '📋 暂无可用技能。';
         }
-        const lines = Array.from(skills.values()).map((s) =>
-            `- **${s.name}** — ${s.description || '无描述'}`
+        const lines = activeSkills.map((s) =>
+            `- **${s.name}** \`${s.id}\` — ${s.description || '无描述'}`
         ).join('\n');
         return `### 📋 可用技能\n\n${lines}`;
     };
@@ -36,8 +37,8 @@ export function registerSkillCommands(deps: SkillCommandDeps): void {
             return '❌ 用法：`\`/skill set <skillId>\``。';
         }
         const skill = skills.get(skillId);
-        if (!skill) {
-            return `❌ 技能 \`${skillId}\` 不存在。请使用 \`/skill list\` 查看可用技能。`;
+        if (!skill || skill.enabled === false) {
+            return `❌ 技能 \`${skillId}\` 不存在或未启用。请使用 \`/skill list\` 查看可用技能。`;
         }
         await sessionManager.updateSession(sessionId, { activeSkillId: skillId });
         return `✅ 已激活技能: **${skill.name}** \`${skillId}\`。`;

package/src/packages/core/src/config/config-manager.ts

@@ -4,6 +4,7 @@ import type { FreyaPluginManager } from '../plugin/plugin-manager.js';
 import type { FreyaPromptManager } from '../prompt/prompt-manager.js';
 import { FreyaConfigFileHandler } from './file-handler.js';
 import { FreyaConfigSchemaRegistry } from './schema-registry.js';
+import type { FreyaSkillRegistry, FreyaSkill } from '../skill/skill-registry.js';
 import path from 'node:path';
 import { PROJECT_ROOT } from '../utils/paths.js';
 
@@ -155,19 +156,22 @@ export class FreyaConfigManager {
   private llmRegistry: FreyaLLMRegistry;
   private pluginManager: FreyaPluginManager;
   private promptManager: FreyaPromptManager;
+  private skillRegistry?: FreyaSkillRegistry;
 
   constructor(
     context: FreyaContext,
     schemaRegistry: FreyaConfigSchemaRegistry,
     promptManager: FreyaPromptManager,
     llmRegistry: FreyaLLMRegistry,
-    pluginManager: FreyaPluginManager
+    pluginManager: FreyaPluginManager,
+    skillRegistry?: FreyaSkillRegistry
   ) {
     this.context = context;
     this.schemaRegistry = schemaRegistry;
     this.promptManager = promptManager;
     this.llmRegistry = llmRegistry;
     this.pluginManager = pluginManager;
+    this.skillRegistry = skillRegistry;
   }
 
   /** 获取全部敏感字段的 keyPath 列表 */
@@ -480,6 +484,16 @@ export class FreyaConfigManager {
     return await this.pluginManager.togglePlugin(pluginId, enabled);
   }
 
+  listSkills(): FreyaSkill[] {
+    if (!this.skillRegistry) return [];
+    return this.skillRegistry.getAllSkills();
+  }
+
+  async toggleSkill(skillId: string, enabled: boolean): Promise<string> {
+    if (!this.skillRegistry) return '❌ 技能注册表服务未初始化。';
+    return await this.skillRegistry.toggleSkill(skillId, enabled);
+  }
+
   async readPrompt(name: string): Promise<string> {
     const promptName = String(name).trim().toUpperCase();
     if (!ALLOWED_PROMPTS.has(promptName)) {

package/src/packages/core/src/kernel.ts

@@ -68,7 +68,8 @@ export class FreyaKernel {
       configSchemaRegistry,
       promptManager,
       llmRegistry,
-      this.pluginManager
+      this.pluginManager,
+      skillRegistry
     );
 
     configManager.registerCoreSchema();
@@ -96,7 +97,7 @@ export class FreyaKernel {
 
     const configToolbox = new ConfigToolbox(configManager, ctx);
     const sessionToolbox = new SessionToolbox(this.sessionManager);
-    const metaToolbox = new FreyaMetaToolbox(this.sessionManager, toolRegistry);
+    const metaToolbox = new FreyaMetaToolbox(this.sessionManager, toolRegistry, skillRegistry);
     toolRegistry.registerToolbox(configToolbox);
     toolRegistry.registerToolbox(sessionToolbox);
     toolRegistry.registerToolbox(metaToolbox);

package/src/packages/core/src/skill/skill-registry.ts

@@ -8,27 +8,66 @@ export interface FreyaSkill {
   name: string;
   description: string;
   content: string;
+  enabled: boolean;
+  source: 'builtin' | 'runtime';
 }
 
-/** 技能注册表，从 skills/ 目录加载 Markdown 格式技能 */
+/** 技能注册表，从 skills/ 目录加载 Markdown 格式技能并管理软开关状态 */
 export class FreyaSkillRegistry {
   private skills = new Map<string, FreyaSkill>();
+  private context?: FreyaContext;
 
   async loadSkills(context: FreyaContext): Promise<void> {
+    this.context = context;
     const runtimeSkillsDir = path.join(PROJECT_ROOT, 'skills');
     const defaultSkillsDir = path.join(APP_ROOT, 'skills');
+    const configSkillsPath = path.join(PROJECT_ROOT, 'config', 'skills.json');
+
     try {
       await fs.mkdir(runtimeSkillsDir, { recursive: true });
-      await this.loadSkillsFromDirectory(defaultSkillsDir, context);
-      await this.loadSkillsFromDirectory(runtimeSkillsDir, context);
-      context.logger.info(`动态技能扫描完成。共加载了 ${this.skills.size} 个物理技能。`);
+      await this.loadSkillsFromDirectory(defaultSkillsDir, 'builtin', context);
+      await this.loadSkillsFromDirectory(runtimeSkillsDir, 'runtime', context);
+
+      let configList: Array<{ id: string; enabled: boolean }> = [];
+      try {
+        const raw = await fs.readFile(configSkillsPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed)) {
+          configList = parsed;
+        }
+      } catch {
+        configList = [];
+      }
+
+      const configMap = new Map<string, boolean>();
+      for (const item of configList) {
+        if (item && typeof item.id === 'string' && typeof item.enabled === 'boolean') {
+          configMap.set(item.id, item.enabled);
+        }
+      }
+
+      let configChanged = false;
+      for (const skill of this.skills.values()) {
+        if (configMap.has(skill.id)) {
+          skill.enabled = configMap.get(skill.id)!;
+        } else {
+          configChanged = true;
+        }
+      }
+
+      if (configChanged || configList.length !== this.skills.size) {
+        await this.persistSkillsConfig(configSkillsPath);
+      }
+
+      const enabledCount = Array.from(this.skills.values()).filter((s) => s.enabled).length;
+      context.logger.info(`动态技能扫描完成。共加载 ${this.skills.size} 个物理技能 (已启用: ${enabledCount})。`);
     } catch (err: any) {
       context.logger.error('扫描物理技能 skills 目录遭遇故障:', err);
     }
   }
 
   /** 从指定目录加载技能到内存注册表中 */
-  private async loadSkillsFromDirectory(dirPath: string, context: FreyaContext): Promise<void> {
+  private async loadSkillsFromDirectory(dirPath: string, source: 'builtin' | 'runtime', context: FreyaContext): Promise<void> {
     try {
       const files = await fs.readdir(dirPath);
       for (const file of files) {
@@ -36,11 +75,17 @@ export class FreyaSkillRegistry {
           const rawContent = await fs.readFile(path.join(dirPath, file), 'utf-8');
           const { metadata, content } = this.parseFrontmatter(rawContent);
           if (metadata.id) {
+            const defaultEnabled = metadata.defaultEnabled !== undefined
+              ? metadata.defaultEnabled !== 'false'
+              : source === 'builtin';
+
             this.skills.set(metadata.id, {
               id: metadata.id,
               name: metadata.name || file.replace('.md', ''),
               description: metadata.description || '',
-              content: content.trim()
+              content: content.trim(),
+              enabled: defaultEnabled,
+              source
             });
           }
         }
@@ -50,8 +95,55 @@ export class FreyaSkillRegistry {
     }
   }
 
-  getSkills(): Map<string, FreyaSkill> {
-    return this.skills;
+  /** 获取技能列表（默认只返回启用状态的技能） */
+  getSkills(onlyEnabled: boolean = true): Map<string, FreyaSkill> {
+    if (!onlyEnabled) {
+      return this.skills;
+    }
+    const filtered = new Map<string, FreyaSkill>();
+    for (const [id, skill] of this.skills.entries()) {
+      if (skill.enabled) {
+        filtered.set(id, skill);
+      }
+    }
+    return filtered;
+  }
+
+  /** 获取全量技能数组（供管理控制台使用） */
+  getAllSkills(): FreyaSkill[] {
+    return Array.from(this.skills.values());
+  }
+
+  /** 切换技能的启用/禁用状态并持久化 */
+  async toggleSkill(skillId: string, enabled: boolean): Promise<string> {
+    const skill = this.skills.get(skillId);
+    if (!skill) {
+      return `❌ 未找到 ID 为 "${skillId}" 的技能，请检查名称是否正确。`;
+    }
+
+    if (skill.enabled === enabled) {
+      return `ℹ️ 技能 "${skill.name || skillId}" 状态已是 ${enabled ? '启用' : '禁用'}。`;
+    }
+
+    skill.enabled = enabled;
+    const configSkillsPath = path.join(PROJECT_ROOT, 'config', 'skills.json');
+    try {
+      await this.persistSkillsConfig(configSkillsPath);
+      this.context?.logger.info(`技能 "${skill.name || skillId}" 已切换为: ${enabled ? '启用' : '禁用'}`);
+      return `✅ 技能 "${skill.name || skillId}" 已成功${enabled ? '启用' : '禁用'}。`;
+    } catch (err: any) {
+      return `❌ 技能状态变更成功，但写入 skills.json 失败: ${err.message}`;
+    }
+  }
+
+  /** 持久化当前所有技能启停状态至 skills.json */
+  private async persistSkillsConfig(configSkillsPath: string): Promise<void> {
+    await fs.mkdir(path.dirname(configSkillsPath), { recursive: true });
+    const payload = Array.from(this.skills.values()).map((s) => ({
+      id: s.id,
+      enabled: s.enabled
+    }));
+    await fs.writeFile(configSkillsPath, JSON.stringify(payload, null, 2) + '\n', 'utf-8');
   }
 
   get(id: string): FreyaSkill | undefined {

package/src/packages/core/src/tools/meta/index.ts

@@ -1,11 +1,13 @@
 import type { FreyaTool, FreyaToolbox } from '@eoasmxd/freya-sdk';
 import type { FreyaSessionManager } from '../../session/session-manager.js';
 import type { FreyaToolRegistry } from '../tool-registry.js';
+import type { FreyaSkillRegistry } from '../../skill/skill-registry.js';
 
 export class FreyaMetaToolbox implements FreyaToolbox {
   constructor(
     private sessionManager: FreyaSessionManager,
-    private toolRegistry?: FreyaToolRegistry
+    private toolRegistry?: FreyaToolRegistry,
+    private skillRegistry?: FreyaSkillRegistry
   ) {}
 
   getId(): string {
@@ -106,6 +108,12 @@ export class FreyaMetaToolbox implements FreyaToolbox {
           if (!sessionId) {
             return '❌ 错误：无法从执行上下文中提取当前会话ID。';
           }
+          if (this.skillRegistry) {
+            const skill = this.skillRegistry.get(skillId);
+            if (!skill || !skill.enabled) {
+              return `❌ 错误：技能 [${skillId}] 不存在或已被系统管理员禁用，无法切入该模式。`;
+            }
+          }
           await this.sessionManager.updateSession(sessionId, { activeSkillId: skillId });
           return `已成功切入 [${skillId}] 技能特长工作模式。`;
         }

package/src/packages/core/src/web/config-api.ts

@@ -199,6 +199,26 @@ export class FreyaConfigApi {
         return true;
       }
 
+      if (pathname === '/api/config/skills' && req.method === 'GET') {
+        const skills = this.configManager.listSkills();
+        res.writeHead(200, this.headers);
+        res.end(JSON.stringify({ success: true, data: skills }));
+        return true;
+      }
+
+      if (pathname === '/api/config/skills/toggle' && req.method === 'POST') {
+        const { skillId, enabled } = await this.getBody(req);
+        if (!skillId) {
+          res.writeHead(200, this.headers);
+          res.end(JSON.stringify({ success: false, error: '缺少必要参数: skillId' }));
+          return true;
+        }
+        const msg = await this.configManager.toggleSkill(skillId, enabled);
+        res.writeHead(200, this.headers);
+        res.end(JSON.stringify({ success: !msg.startsWith('❌'), message: msg }));
+        return true;
+      }
+
       const promptMatch = pathname.match(/^\/api\/config\/prompts\/([^/]+)$/);
       if (promptMatch && req.method === 'GET') {
         const promptName = decodeURIComponent(promptMatch[1]);