@cicctencent/agent-midway 0.1.1

package/dist/service/ai-skill.service.js

@@ -0,0 +1,457 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var AISkillService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AISkillService = void 0;
+const core_1 = require("@midwayjs/core");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+/**
+ * AI Skill 管理 Service（本地文件版）
+ *
+ * 从 data/skills/ 目录递归加载 Markdown 文件作为 Skills。
+ * 每个 .md 文件使用 YAML frontmatter 定义元数据，正文为 Skill 内容。
+ *
+ * 支持两种注入方式：
+ * - prompt: 将 skill 内容拼接到 system prompt
+ * - tool: 将 skill 注册为 Tool，AI 主动调用获取内容
+ * - both: 两者兼具
+ *
+ * 缓存策略：
+ * - 文件加载结果缓存在内存中，TTL 5 分钟
+ * - 文件变更后自动刷新缓存
+ */
+let AISkillService = AISkillService_1 = class AISkillService {
+    constructor() {
+        /** skills 根目录 */
+        this.skillsDir = '';
+        /** 加载的 Skills */
+        this.skills = [];
+        /** 自增 ID 计数器 */
+        this.nextId = 1;
+        /** 上次扫描时间 */
+        this._lastScanTime = 0;
+    }
+    get lastScanTime() {
+        return this._lastScanTime;
+    }
+    async init() {
+        // 解析 skills 目录：基于应用根目录，不受源文件位置影响
+        this.skillsDir = path.join(this.app.getAppDir(), 'data/skills');
+        await this.reloadSkills();
+    }
+    // ===================== 文件扫描与解析 =====================
+    /** 重新扫描并加载所有 Skills */
+    async reloadSkills() {
+        this.skills = [];
+        this.nextId = 1;
+        if (!fs.existsSync(this.skillsDir)) {
+            console.warn(`[AISkillService] Skills 目录不存在: ${this.skillsDir}`);
+            return;
+        }
+        const files = this.scanDirectory(this.skillsDir);
+        for (const filePath of files) {
+            try {
+                const skill = this.parseSkillFile(filePath);
+                if (skill) {
+                    this.skills.push(skill);
+                }
+            }
+            catch (e) {
+                console.error(`[AISkillService] 解析 Skill 文件失败: ${filePath}`, e.message);
+            }
+        }
+        // 按 sort 排序
+        this.skills.sort((a, b) => a.sort - b.sort);
+        this._lastScanTime = Date.now();
+        this.clearCache();
+        console.log(`[AISkillService] 已加载 ${this.skills.length} 个 Skills`);
+    }
+    /** 递归扫描目录获取所有 .md 文件 */
+    scanDirectory(dir) {
+        const results = [];
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                results.push(...this.scanDirectory(fullPath));
+            }
+            else if (entry.isFile() &&
+                entry.name.endsWith('.md') &&
+                entry.name !== 'README.md') {
+                results.push(fullPath);
+            }
+        }
+        return results;
+    }
+    /** 解析单个 Skill 文件 */
+    parseSkillFile(filePath) {
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        const { frontmatter, body } = this.parseFrontmatter(raw);
+        if (!frontmatter.name) {
+            console.warn(`[AISkillService] 文件缺少 name 字段，跳过: ${filePath}`);
+            return null;
+        }
+        const relativePath = path.relative(this.skillsDir, filePath);
+        return {
+            id: this.nextId++,
+            name: frontmatter.name || '',
+            description: frontmatter.description || '',
+            category: frontmatter.category || 'prompt',
+            contentType: 'text',
+            content: body.trim(),
+            agentTypes: frontmatter.agentTypes || '',
+            injectionMode: frontmatter.injectionMode || 'prompt',
+            sort: Number(frontmatter.sort) || 100,
+            isActive: 1,
+            isDeleted: 0,
+            toolSchema: frontmatter.toolSchema
+                ? JSON.parse(frontmatter.toolSchema)
+                : undefined,
+            filePath: relativePath,
+        };
+    }
+    /** 解析 YAML frontmatter */
+    parseFrontmatter(raw) {
+        const fmRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
+        const match = raw.match(fmRegex);
+        if (!match) {
+            return { frontmatter: {}, body: raw };
+        }
+        const fmBlock = match[1];
+        const body = match[2];
+        const frontmatter = {};
+        // 简单 YAML key: value 解析
+        for (const line of fmBlock.split('\n')) {
+            const colonIdx = line.indexOf(':');
+            if (colonIdx > 0) {
+                const key = line.substring(0, colonIdx).trim();
+                const value = line.substring(colonIdx + 1).trim();
+                frontmatter[key] = value;
+            }
+        }
+        return { frontmatter, body };
+    }
+    // ===================== 缓存管理 =====================
+    clearCache() {
+        AISkillService_1.cache.clear();
+    }
+    getFromCache(key) {
+        const cached = AISkillService_1.cache.get(key);
+        if (cached && cached.expiresAt > Date.now()) {
+            return cached.data;
+        }
+        if (cached)
+            AISkillService_1.cache.delete(key);
+        return undefined;
+    }
+    setCache(key, data) {
+        AISkillService_1.cache.set(key, {
+            data,
+            expiresAt: Date.now() + AISkillService_1.CACHE_TTL,
+        });
+    }
+    // ===================== 查询接口 =====================
+    /** 查询所有 Skills */
+    async getSkills(options) {
+        await this.ensureLoaded();
+        let result = this.skills.filter(s => s.isActive === 1);
+        if (options?.category) {
+            result = result.filter(s => s.category === options.category);
+        }
+        if (options?.agentType) {
+            result = result.filter(s => this.matchesAgentType(s, options.agentType));
+        }
+        return result;
+    }
+    /** 获取单个 Skill */
+    async getSkill(id) {
+        await this.ensureLoaded();
+        return this.skills.find(s => s.id === id) || null;
+    }
+    /** 根据 name 获取 Skill */
+    async getSkillByName(name) {
+        await this.ensureLoaded();
+        return this.skills.find(s => s.name === name) || null;
+    }
+    // ===================== CRUD（文件操作） =====================
+    /** 创建 Skill（写入新文件） */
+    async createSkill(data) {
+        const name = data.name || `skill-${Date.now()}`;
+        const category = data.category || 'prompt';
+        const fileName = `${name}.md`;
+        const dirPath = path.join(this.skillsDir, category === 'component'
+            ? 'components'
+            : category === 'datasource'
+                ? 'datasources'
+                : category === 'rule'
+                    ? 'rules'
+                    : 'prompts');
+        // 确保目录存在
+        if (!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath, { recursive: true });
+        }
+        const filePath = path.join(dirPath, fileName);
+        const content = this.buildSkillFileContent({
+            name,
+            description: data.description || '',
+            category,
+            agentTypes: data.agentTypes || '',
+            injectionMode: data.injectionMode || 'prompt',
+            sort: data.sort || 100,
+        }, data.content || '');
+        fs.writeFileSync(filePath, content, 'utf-8');
+        await this.reloadSkills();
+        return this.skills.find(s => s.name === name) || null;
+    }
+    /** 更新 Skill（覆写文件） */
+    async updateSkill(id, data) {
+        const skill = this.skills.find(s => s.id === id);
+        if (!skill)
+            return null;
+        const filePath = path.join(this.skillsDir, skill.filePath);
+        const content = this.buildSkillFileContent({
+            name: data.name ?? skill.name,
+            description: data.description ?? skill.description,
+            category: data.category ?? skill.category,
+            agentTypes: data.agentTypes ?? skill.agentTypes,
+            injectionMode: data.injectionMode ?? skill.injectionMode,
+            sort: data.sort ?? skill.sort,
+        }, data.content ?? skill.content);
+        fs.writeFileSync(filePath, content, 'utf-8');
+        await this.reloadSkills();
+        return (this.skills.find(s => s.name === (data.name || skill.name)) || null);
+    }
+    /** 删除 Skill（删除文件） */
+    async deleteSkill(id) {
+        const skill = this.skills.find(s => s.id === id);
+        if (!skill)
+            return;
+        const filePath = path.join(this.skillsDir, skill.filePath);
+        if (fs.existsSync(filePath)) {
+            fs.unlinkSync(filePath);
+        }
+        await this.reloadSkills();
+    }
+    /** 生成 Skill 文件内容 */
+    buildSkillFileContent(meta, body) {
+        return [
+            '---',
+            `name: ${meta.name}`,
+            `description: ${meta.description}`,
+            `category: ${meta.category}`,
+            `agentTypes: ${meta.agentTypes}`,
+            `injectionMode: ${meta.injectionMode}`,
+            `sort: ${meta.sort}`,
+            '---',
+            '',
+            body,
+        ].join('\n');
+    }
+    // ===================== 运行时加载 =====================
+    /** 确保 Skills 已加载 */
+    async ensureLoaded() {
+        if (this.skills.length === 0) {
+            await this.reloadSkills();
+        }
+    }
+    /**
+     * 获取指定 Agent 类型的 Skills
+     */
+    async getSkillsForAgent(agentType, injectionMode) {
+        const cacheKey = `skills:${agentType}:${injectionMode || 'all'}`;
+        const cached = this.getFromCache(cacheKey);
+        if (cached)
+            return cached;
+        await this.ensureLoaded();
+        let filtered = this.skills.filter(s => s.isActive === 1);
+        // 注入方式过滤
+        if (injectionMode) {
+            if (injectionMode === 'both') {
+                filtered = filtered.filter(s => s.injectionMode === 'both' ||
+                    s.injectionMode === 'prompt' ||
+                    s.injectionMode === 'tool');
+            }
+            else {
+                filtered = filtered.filter(s => s.injectionMode === injectionMode ||
+                    s.injectionMode === 'both');
+            }
+        }
+        // 按 agentType 过滤
+        const result = filtered.filter(s => this.matchesAgentType(s, agentType));
+        this.setCache(cacheKey, result);
+        return result;
+    }
+    /**
+     * 构建 Skill Context（用于注入到 system prompt）
+     */
+    async buildSkillContext(agentType) {
+        const cacheKey = `context:${agentType}`;
+        const cached = this.getFromCache(cacheKey);
+        if (cached)
+            return cached;
+        const skills = await this.getSkillsForAgent(agentType, 'prompt');
+        if (skills.length === 0)
+            return '';
+        const parts = [];
+        // 按 category 分组
+        const groups = this.groupByCategory(skills);
+        for (const [category, items] of groups) {
+            const categoryLabel = {
+                component: '可用组件',
+                datasource: '可用数据源',
+                prompt: '扩展说明',
+                rule: '规则约束',
+                tool: '可调用工具',
+            };
+            parts.push(`\n## ${categoryLabel[category] || category}`);
+            for (const skill of items) {
+                parts.push(skill.content);
+            }
+        }
+        const context = parts.join('\n');
+        this.setCache(cacheKey, context);
+        return context;
+    }
+    /**
+     * 将 Skills 转换为 ToolDefinition（供 Agent 自动调用）
+     */
+    async getSkillsAsTools(agentType) {
+        const cacheKey = `tools:${agentType}`;
+        const cached = this.getFromCache(cacheKey);
+        if (cached)
+            return cached;
+        const skills = await this.getSkillsForAgent(agentType, 'tool');
+        const tools = skills.map(skill => this.skillToTool(skill));
+        this.setCache(cacheKey, tools);
+        return tools;
+    }
+    /**
+     * 预览指定 Agent 的 Skills Context
+     */
+    async previewSkillContext(agentType) {
+        const all = await this.getSkillsForAgent(agentType);
+        const promptSkills = all.filter(s => s.injectionMode === 'prompt' || s.injectionMode === 'both');
+        const toolSkills = all.filter(s => s.injectionMode === 'tool' || s.injectionMode === 'both');
+        return {
+            agentType,
+            total: all.length,
+            promptSkills: promptSkills.length,
+            toolSkills: toolSkills.length,
+            context: await this.buildSkillContext(agentType),
+            tools: toolSkills.map(s => ({
+                id: `skill_${s.id}`,
+                name: s.name,
+                description: s.description,
+            })),
+        };
+    }
+    // ===================== 私有方法 =====================
+    /** 判断 skill 是否匹配指定 agent 类型 */
+    matchesAgentType(skill, agentType) {
+        if (agentType === 'all' || agentType === '*')
+            return true;
+        if (!skill.agentTypes)
+            return true;
+        const types = skill.agentTypes.split(',').map(t => t.trim());
+        return types.some(t => {
+            if (t === '*')
+                return true;
+            if (t === agentType)
+                return true;
+            if (agentType.startsWith(t + '-'))
+                return true;
+            return false;
+        });
+    }
+    /** 按 category 分组 */
+    groupByCategory(skills) {
+        const groups = new Map();
+        for (const skill of skills) {
+            const list = groups.get(skill.category) || [];
+            list.push(skill);
+            groups.set(skill.category, list);
+        }
+        return groups;
+    }
+    /** 将 Skill 转换为 ToolDefinition */
+    skillToTool(skill) {
+        return {
+            id: `skill_${skill.id}`,
+            name: skill.name,
+            description: skill.description || `获取 ${skill.name} 的详细内容`,
+            category: 'utility',
+            parameters: skill.toolSchema || {
+                type: 'object',
+                properties: {},
+            },
+            async execute() {
+                return {
+                    skillId: skill.id,
+                    name: skill.name,
+                    content: skill.content,
+                    contentType: skill.contentType,
+                };
+            },
+        };
+    }
+};
+exports.AISkillService = AISkillService;
+/** 缓存 */
+AISkillService.cache = new Map();
+AISkillService.CACHE_TTL = 5 * 60 * 1000;
+__decorate([
+    (0, core_1.App)(),
+    __metadata("design:type", Object)
+], AISkillService.prototype, "app", void 0);
+__decorate([
+    (0, core_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], AISkillService.prototype, "init", null);
+exports.AISkillService = AISkillService = AISkillService_1 = __decorate([
+    (0, core_1.Provide)(),
+    (0, core_1.Scope)(core_1.ScopeEnum.Singleton)
+], AISkillService);

package/dist/service/application.service.d.ts

@@ -0,0 +1,42 @@
+import { BaseService } from '@cicctencent/midwayjs-base';
+import { DataSource, Repository } from 'typeorm';
+import AIApplicationEntity from '../model/ai-application.entity';
+/**
+ * AI 应用服务
+ * 管理应用配置、Agent Profile 绑定等
+ */
+export declare class ApplicationService extends BaseService {
+    dataSource: DataSource;
+    private repo?;
+    get model(): Repository<AIApplicationEntity>;
+    /** 获取所有应用 */
+    list(options?: {
+        status?: string;
+    }): Promise<AIApplicationEntity[]>;
+    /** 获取单个应用 */
+    get(id: number): Promise<AIApplicationEntity>;
+    /** 根据 Key 获取应用 */
+    getByKey(key: string): Promise<AIApplicationEntity>;
+    /** 获取默认应用 */
+    getDefault(): Promise<AIApplicationEntity>;
+    /** 创建应用 */
+    create(data: Partial<AIApplicationEntity>): Promise<AIApplicationEntity>;
+    /** 更新应用 */
+    update(id: number, data: Partial<AIApplicationEntity>): Promise<AIApplicationEntity>;
+    /** 删除应用 */
+    delete(id: number): Promise<void>;
+    /** 设置为默认 */
+    setDefault(id: number): Promise<AIApplicationEntity>;
+    /** 归档应用 */
+    archive(id: number): Promise<AIApplicationEntity>;
+    /** 激活应用 */
+    activate(id: number): Promise<AIApplicationEntity>;
+    /** 获取应用完整配置（包含 Agent Profile） */
+    getFullConfig(idOrKey: number | string): Promise<{
+        application: AIApplicationEntity;
+        agentProfiles: any[];
+        defaultProfile: any;
+    }>;
+    /** 解析应用（支持 ID 或 Key） */
+    resolveApp(idOrKey: number | string): Promise<AIApplicationEntity>;
+}

package/dist/service/application.service.js

@@ -0,0 +1,139 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationService = void 0;
+const core_1 = require("@midwayjs/core");
+const midwayjs_base_1 = require("@cicctencent/midwayjs-base");
+const typeorm_1 = require("@midwayjs/typeorm");
+const typeorm_2 = require("typeorm");
+const ai_application_entity_1 = __importDefault(require("../model/ai-application.entity"));
+/**
+ * AI 应用服务
+ * 管理应用配置、Agent Profile 绑定等
+ */
+let ApplicationService = class ApplicationService extends midwayjs_base_1.BaseService {
+    get model() {
+        if (this.repo)
+            return this.repo;
+        return (this.repo = this.dataSource.getRepository(ai_application_entity_1.default));
+    }
+    /** 获取所有应用 */
+    async list(options) {
+        const where = {};
+        if (options?.status) {
+            where.status = options.status;
+        }
+        return this.model.find({
+            where,
+            order: { isDefault: 'DESC', createTime: 'DESC' },
+        });
+    }
+    /** 获取单个应用 */
+    async get(id) {
+        return this.model.findOne({ where: { id } });
+    }
+    /** 根据 Key 获取应用 */
+    async getByKey(key) {
+        return this.model.findOne({ where: { key } });
+    }
+    /** 获取默认应用 */
+    async getDefault() {
+        return this.model.findOne({
+            where: { isDefault: 1, status: 'active' },
+        });
+    }
+    /** 创建应用 */
+    async create(data) {
+        // 如果设置为默认，先清除其他默认
+        if (data.isDefault === 1) {
+            await this.model.update({ isDefault: 1 }, { isDefault: 0 });
+        }
+        const app = this.model.create(data);
+        return this.model.save(app);
+    }
+    /** 更新应用 */
+    async update(id, data) {
+        // 如果设置为默认，先清除其他默认
+        if (data.isDefault === 1) {
+            await this.model.update({ isDefault: 1 }, { isDefault: 0 });
+        }
+        await this.model.update({ id }, data);
+        return this.get(id);
+    }
+    /** 删除应用 */
+    async delete(id) {
+        await this.model.delete({ id });
+    }
+    /** 设置为默认 */
+    async setDefault(id) {
+        await this.model.update({ isDefault: 1 }, { isDefault: 0 });
+        await this.model.update({ id }, { isDefault: 1 });
+        return this.get(id);
+    }
+    /** 归档应用 */
+    async archive(id) {
+        await this.model.update({ id }, { status: 'archived' });
+        return this.get(id);
+    }
+    /** 激活应用 */
+    async activate(id) {
+        await this.model.update({ id }, { status: 'active' });
+        return this.get(id);
+    }
+    /** 获取应用完整配置（包含 Agent Profile） */
+    async getFullConfig(idOrKey) {
+        const app = typeof idOrKey === 'number'
+            ? await this.get(idOrKey)
+            : await this.getByKey(idOrKey);
+        if (!app)
+            return null;
+        // 加载关联的 Agent Profile
+        let agentProfiles = [];
+        if (app.agentProfileIds && app.agentProfileIds.length > 0) {
+            agentProfiles = await this.dataSource.query('SELECT * FROM t_agent_profile WHERE id IN (?)', [app.agentProfileIds]);
+        }
+        // 加载默认 Agent Profile
+        let defaultProfile = null;
+        if (app.defaultAgentProfileId) {
+            const profiles = await this.dataSource.query('SELECT * FROM t_agent_profile WHERE id = ?', [app.defaultAgentProfileId]);
+            defaultProfile = profiles[0] || null;
+        }
+        return {
+            application: app,
+            agentProfiles,
+            defaultProfile,
+        };
+    }
+    /** 解析应用（支持 ID 或 Key） */
+    async resolveApp(idOrKey) {
+        if (typeof idOrKey === 'number') {
+            return this.get(idOrKey);
+        }
+        // 尝试解析为数字
+        const num = parseInt(idOrKey, 10);
+        if (!isNaN(num)) {
+            return this.get(num);
+        }
+        // 按 Key 查找
+        return this.getByKey(idOrKey);
+    }
+};
+exports.ApplicationService = ApplicationService;
+__decorate([
+    (0, typeorm_1.InjectDataSource)('default'),
+    __metadata("design:type", typeorm_2.DataSource)
+], ApplicationService.prototype, "dataSource", void 0);
+exports.ApplicationService = ApplicationService = __decorate([
+    (0, core_1.Provide)()
+], ApplicationService);

package/dist/service/automation.service.d.ts

@@ -0,0 +1,37 @@
+import { BaseService } from '@cicctencent/midwayjs-base';
+import type { DataSource } from 'typeorm';
+import { AgentServerService } from './agent-server.service';
+/** 自动化任务实体（从 DB 查询） */
+interface AutomationEntity {
+    id: number;
+    name: string;
+    description?: string;
+    type: string;
+    config: any;
+    status: string;
+    schedule?: string;
+    prompt?: string;
+    agent_profile_id?: number;
+}
+export declare class AutomationService extends BaseService {
+    dataSource: DataSource;
+    agentServerService: AgentServerService;
+    private initialized;
+    /** 初始化自动化调度器：加载所有已启用任务并注册 cron */
+    initAutomationScheduler(): Promise<void>;
+    /** 确保调度器已初始化 */
+    ensureInitialized(): Promise<void>;
+    /** 为单个任务注册 cron 调度 */
+    scheduleJob(automation: AutomationEntity): void;
+    /** 注销调度 */
+    unscheduleJob(id: number): void;
+    /** 实际执行自动化任务：创建 Agent 会话 + 运行 Agent + 记录结果 */
+    executeAutomation(id: number, triggerType?: 'schedule' | 'manual'): Promise<string>;
+    /** 刷新所有调度 */
+    refreshScheduler(): Promise<void>;
+    /** 获取活跃任务数 */
+    getActiveJobCount(): number;
+    /** 停止所有调度任务（服务关闭时调用） */
+    stopAll(): void;
+}
+export {};