@eoasmxd/freya 0.3.0 → 0.4.1

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

@@ -0,0 +1,87 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+/** 前置 SQL 安全与完整性审查审计服务 */
+export class SqlAuditService {
+    cachedPrompt = null;
+    /** 双通道探针加载审计提示词模板 */
+    async loadAuditPrompt(ctx) {
+        if (this.cachedPrompt) {
+            return this.cachedPrompt;
+        }
+        const promptFileName = 'plugin.prompt.mysql.select.audit.md';
+        const runtimeOverridePath = path.join(ctx.paths.projectRoot, 'config', 'prompts', promptFileName);
+        try {
+            const content = await fs.readFile(runtimeOverridePath, 'utf-8');
+            if (content.trim()) {
+                this.cachedPrompt = content;
+                return content;
+            }
+        }
+        catch {
+            // 运行时覆盖不存在，继续降级读取内置模板
+        }
+        const currentDir = path.dirname(fileURLToPath(import.meta.url));
+        const packageDefaultPath = path.resolve(currentDir, '..', 'config', 'prompts', promptFileName);
+        try {
+            const content = await fs.readFile(packageDefaultPath, 'utf-8');
+            this.cachedPrompt = content;
+            return content;
+        }
+        catch (err) {
+            ctx.logger.error(`加载内置 SQL 审计提示词模板失败: ${packageDefaultPath}`, err);
+            return '';
+        }
+    }
+    /** 执行前置独立 LLM 分析审查 */
+    async audit(sql, connectionName, ctx) {
+        const trimmedSql = sql.trim();
+        if (!trimmedSql) {
+            return { passed: false, reason: 'SQL 语句内容不能为空。' };
+        }
+        const auditPrompt = await this.loadAuditPrompt(ctx);
+        if (!auditPrompt) {
+            return { passed: false, reason: 'SQL 审计提示词模板未就绪，安全拒绝执行。' };
+        }
+        const messages = [
+            {
+                role: 'system',
+                content: auditPrompt
+            },
+            {
+                role: 'user',
+                content: JSON.stringify({
+                    connection: connectionName,
+                    sql: trimmedSql
+                }, null, 2)
+            }
+        ];
+        try {
+            const response = await ctx.llm.chat(messages);
+            const rawOutput = response.message?.content?.trim() || '';
+            const cleaned = rawOutput
+                .replace(/^```json\s*/i, '')
+                .replace(/^```\s*/i, '')
+                .replace(/\s*```$/i, '')
+                .trim();
+            const parsed = JSON.parse(cleaned);
+            if (typeof parsed.passed === 'boolean') {
+                return {
+                    passed: parsed.passed,
+                    reason: parsed.reason ? String(parsed.reason) : (parsed.passed ? '审查通过' : '未提供拦截原因')
+                };
+            }
+            return {
+                passed: false,
+                reason: `审查响应结构不符合预期: ${rawOutput}`
+            };
+        }
+        catch (err) {
+            ctx.logger.error('前置 LLM SQL 审计过程发生异常', err);
+            return {
+                passed: false,
+                reason: `SQL 安全审查服务调用失败: ${err?.message || err}`
+            };
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+import type { FreyaContext, ToolPlugin, FreyaTool } from '@eoasmxd/freya-sdk';
+/** MySQL 数据库查询工具箱插件 */
+export default class MysqlToolsPlugin implements ToolPlugin {
+    type: "tool";
+    private poolManager?;
+    private auditService;
+    private tools;
+    setup(ctx: FreyaContext): Promise<void>;
+    getId(): string;
+    getInstructionPrompt(): string;
+    getTools(): FreyaTool[];
+    stop(ctx: FreyaContext): Promise<void>;
+}
+export declare const Plugin: typeof MysqlToolsPlugin;

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

@@ -0,0 +1,34 @@
+import { MysqlPoolManager } from './pool-manager.js';
+import { SqlAuditService } from './audit.js';
+import { MysqlQueryTool } from './tools.js';
+/** MySQL 数据库查询工具箱插件 */
+export default class MysqlToolsPlugin {
+    type = 'tool';
+    poolManager;
+    auditService = new SqlAuditService();
+    tools = [];
+    async setup(ctx) {
+        this.poolManager = new MysqlPoolManager(ctx);
+        this.tools = [
+            new MysqlQueryTool(this.poolManager, this.auditService)
+        ];
+        const available = this.poolManager.getAvailableConnectionNames();
+        ctx.logger.info(`MySQL 工具箱插件初始化就绪，已注册连接: [${available.join(', ') || '暂未配置'}]`);
+    }
+    getId() {
+        return 'mysql';
+    }
+    getInstructionPrompt() {
+        return 'plugin.prompt.mysql';
+    }
+    getTools() {
+        return this.tools;
+    }
+    async stop(ctx) {
+        if (this.poolManager) {
+            await this.poolManager.closeAll();
+            ctx.logger.info('MySQL 工具箱连接资源已全部释放。');
+        }
+    }
+}
+export const Plugin = MysqlToolsPlugin;

package/plugins/plugin-tool-mysql/dist/pool-manager.d.ts

@@ -0,0 +1,32 @@
+import mysql from 'mysql2/promise';
+import type { FreyaContext } from '@eoasmxd/freya-sdk';
+/** MySQL 连接配置契约 */
+export interface MysqlConnectionConfig {
+    name: string;
+    host?: string;
+    port?: number;
+    user?: string;
+    password?: string;
+    database?: string;
+    connectionLimit?: number;
+    connectTimeout?: number;
+}
+/** MySQL 多命名连接池管理器 */
+export declare class MysqlPoolManager {
+    private ctx;
+    private pools;
+    private connectionConfigs;
+    private defaultConnectionName;
+    constructor(ctx: FreyaContext);
+    /** 加载与同步配置 */
+    reloadConfigs(): void;
+    /** 获取指定名称的数据库连接池 */
+    getPool(targetName?: string): {
+        pool: mysql.Pool;
+        config: MysqlConnectionConfig;
+    };
+    /** 获取所有可用连接名称 */
+    getAvailableConnectionNames(): string[];
+    /** 释放所有已建立的连接池资源 */
+    closeAll(): Promise<void>;
+}

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.3.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.3.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.3.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);