@shareai-lab/kode-sdk 2.7.2 → 2.7.3

package/dist/core/skills/management-manager.js

@@ -1,16 +1,18 @@
 "use strict";
 /**
- * 技能管理器模块（路径1 - 技能管理）
+ * 技能管理器模块(路径1 - 技能管理)
  *
  * 设计原则 (UNIX哲学):
- * - 简洁: 只负责技能文件系统的CRUD操作
- * - 模块化: 协调OperationQueue、SandboxFileManager进行文件系统操作
- * - 隔离: 与Agent运行时完全隔离，不参与Agent使用
+ * - 简洁: 只负责技能文件系统的管理操作
+ * - 模块化: 单一职责,易于测试和维护
+ * - 隔离: 与Agent运行时完全隔离,不参与Agent使用
  *
  * ⚠️ 重要说明:
- * - 此模块专门用于路径1（技能管理）
- * - 与路径2（Agent运行时）完全独立
+ * - 此模块专门用于路径1(技能管理)
+ * - 与路径2(Agent运行时)完全独立
  * - 请勿与SkillsManager混淆
+ *
+ * @see docs/skills-management-implementation-plan.md
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -49,468 +51,690 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SkillsManagementManager = void 0;
 const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
+const os = __importStar(require("os"));
 const crypto = __importStar(require("crypto"));
-const manager_1 = require("./manager");
-const operation_queue_1 = require("./operation-queue");
-const sandbox_file_manager_1 = require("./sandbox-file-manager");
-const sandbox_factory_1 = require("../../infra/sandbox-factory");
+const child_process_1 = require("child_process");
+const util_1 = require("util");
 const logger_1 = require("../../utils/logger");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
 /**
  * 技能管理器类
  *
  * 职责:
- * - 提供所有技能管理操作的统一接口（CRUD操作）
- * - 协调OperationQueue、SandboxFileManager进行文件系统操作
+ * - 提供所有技能管理操作的统一接口(导入、复制、重命名、归档、导出)
  * - 处理业务逻辑和权限验证
+ * - 所有操作严格遵循Specification.md规范
  * - ❌ 不参与Agent运行时
  * - ❌ 不提供技能加载、扫描等Agent使用的功能
  */
 class SkillsManagementManager {
-    constructor(skillsDir, sandboxFactory, archivedDir // 可选，默认为 skills/.archived/
+    constructor(skillsDir, archivedDir // 可选,默认为 skills/.archived/
     ) {
         this.skillsDir = path.resolve(skillsDir);
         this.archivedDir = archivedDir ? path.resolve(archivedDir) : path.join(this.skillsDir, '.archived');
-        this.skillsManager = new manager_1.SkillsManager(this.skillsDir);
-        this.operationQueue = new operation_queue_1.OperationQueue();
-        this.sandboxFileManager = new sandbox_file_manager_1.SandboxFileManager(sandboxFactory || new sandbox_factory_1.SandboxFactory());
         logger_1.logger.log(`[SkillsManagementManager] Initialized with skills directory: ${this.skillsDir}`);
         logger_1.logger.log(`[SkillsManagementManager] Archived directory: ${this.archivedDir}`);
     }
+    // ==================== 公共方法(8个核心操作) ====================
     /**
-     * 获取所有在线技能列表（不包含archived技能）
+     * 1. 列出在线技能
+     * 扫描skills目录,排除.archived子目录
+     * 返回技能清单及其元数据信息
      */
     async listSkills() {
-        // 扫描所有技能
-        const allSkills = await this.skillsManager.getSkillsMetadata();
-        // 过滤掉archived技能（排除.archived目录）
-        const onlineSkills = allSkills.filter((skill) => {
-            return !skill.baseDir.includes('/.archived/') &&
-                !skill.baseDir.includes('\\.archived\\');
-        });
-        // 添加文件统计信息
-        const skillsWithInfo = [];
-        for (const skill of onlineSkills) {
-            const stat = await this.safeGetFileStat(skill.path);
-            skillsWithInfo.push({
-                ...skill,
-                createdAt: stat?.birthtime?.toISOString(),
-                updatedAt: stat?.mtime?.toISOString(),
-            });
+        const skills = [];
+        try {
+            // 1. 读取skills目录
+            const entries = await fs.readdir(this.skillsDir, { withFileTypes: true });
+            // 2. 遍历每个子目录
+            for (const entry of entries) {
+                // 排除.archived目录
+                if (entry.name === '.archived')
+                    continue;
+                // 只处理目录
+                if (!entry.isDirectory())
+                    continue;
+                const skillDir = path.join(this.skillsDir, entry.name);
+                // 3. 读取SKILL.md
+                const skillMdPath = path.join(skillDir, 'SKILL.md');
+                const exists = await this.fileExists(skillMdPath);
+                if (!exists)
+                    continue; // 跳过没有SKILL.md的目录
+                const content = await fs.readFile(skillMdPath, 'utf-8');
+                // 4. 解析YAML frontmatter
+                const metadata = this.parseSkillMd(content);
+                if (!metadata)
+                    continue; // 跳过无效的SKILL.md
+                // 获取文件统计信息
+                const stat = await this.safeGetFileStat(skillMdPath);
+                skills.push({
+                    name: metadata.name || entry.name,
+                    description: metadata.description || '',
+                    path: skillMdPath,
+                    baseDir: skillDir,
+                    folderName: entry.name,
+                    createdAt: stat?.birthtime?.toISOString(),
+                    updatedAt: stat?.mtime?.toISOString(),
+                });
+            }
+            return skills;
+        }
+        catch (error) {
+            logger_1.logger.error('[SkillsManagementManager] Error listing skills:', error);
+            throw error;
         }
-        return skillsWithInfo;
     }
     /**
-     * 获取单个在线技能详细信息
-     * @param skillName 技能名称
+     * 2. 安装新技能
+     * @param source 技能来源(名称/GitHub仓库/Git URL/本地路径)
+     * @param onProgress 可选的进度回调函数，用于实时传递安装日志
+     * 执行命令: npx -y ai-agent-skills install --agent project [source]
+     * 直接安装到.skills目录
      */
-    async getSkillInfo(skillName) {
-        // 检查技能是否在线（不在archived中）
-        const skill = await this.skillsManager.loadSkillContent(skillName);
-        if (!skill) {
-            return null;
+    async installSkill(source, onProgress) {
+        try {
+            // 验证source参数
+            if (!source || source.trim().length === 0) {
+                throw new Error('技能来源不能为空');
+            }
+            // 构建命令
+            const command = `npx -y ai-agent-skills install --agent project ${source.trim()}`;
+            logger_1.logger.log(`[SkillsManagementManager] 正在安装技能: ${source}`);
+            onProgress?.({ type: 'log', message: `正在安装技能: ${source}` });
+            // 使用spawn替代execAsync以获取实时输出
+            const { spawn } = require('child_process');
+            return new Promise((resolve, reject) => {
+                // 使用父目录作为工作目录，避免在.skills内再创建.skills
+                const cwd = path.dirname(this.skillsDir);
+                const child = spawn(command, [], {
+                    cwd,
+                    shell: true,
+                    env: { ...process.env }
+                });
+                let stdout = '';
+                let stderr = '';
+                let hasError = false;
+                // 检测错误关键词的辅助函数
+                const checkErrorKeywords = (text) => {
+                    const trimmed = text.trim();
+                    // 移除ANSI颜色码
+                    const cleanText = trimmed.replace(/\u001b\[\d+m/g, '');
+                    return cleanText.includes('not found') ||
+                        cleanText.includes('ERROR') ||
+                        cleanText.includes('error:') ||
+                        cleanText.includes('Failed to') ||
+                        cleanText.includes('Cannot find');
+                };
+                // 监听标准输出
+                child.stdout?.on('data', (data) => {
+                    const message = data.toString();
+                    stdout += message;
+                    const trimmed = message.trim();
+                    // 检测stdout中的错误关键词
+                    if (checkErrorKeywords(trimmed)) {
+                        hasError = true;
+                    }
+                    logger_1.logger.log(`[SkillsManagementManager] ${trimmed}`);
+                    onProgress?.({ type: 'log', message: trimmed });
+                });
+                // 监听错误输出
+                child.stderr?.on('data', (data) => {
+                    const message = data.toString();
+                    stderr += message;
+                    const trimmed = message.trim();
+                    // 检测stderr中的错误关键词
+                    if (checkErrorKeywords(trimmed)) {
+                        hasError = true;
+                    }
+                    logger_1.logger.warn(`[SkillsManagementManager] ${trimmed}`);
+                    onProgress?.({ type: 'error', message: trimmed });
+                });
+                // 监听进程退出
+                child.on('close', (code) => {
+                    // 检查是否有错误标识或退出码非0
+                    if (code !== 0 || hasError) {
+                        let errorMsg = '';
+                        if (hasError) {
+                            // 从stderr中提取关键错误信息
+                            const errorLines = stderr.split('\n').filter((line) => line.includes('not found') ||
+                                line.includes('ERROR') ||
+                                line.includes('error:') ||
+                                line.includes('Failed') ||
+                                line.includes('Cannot'));
+                            errorMsg = errorLines.length > 0 ? errorLines[0].trim() : '安装过程中出现错误';
+                        }
+                        else {
+                            errorMsg = `安装进程退出码: ${code}`;
+                        }
+                        logger_1.logger.error(`[SkillsManagementManager] 安装失败: ${errorMsg}`);
+                        reject(new Error(`安装技能失败: ${errorMsg}`));
+                    }
+                    else {
+                        logger_1.logger.log(`[SkillsManagementManager] 技能已安装: ${source}`);
+                        resolve();
+                    }
+                });
+                // 监听错误
+                child.on('error', (error) => {
+                    const errorMsg = `启动安装进程失败: ${error.message}`;
+                    logger_1.logger.error(`[SkillsManagementManager] ${errorMsg}`);
+                    onProgress?.({ type: 'error', message: errorMsg });
+                    reject(new Error(`安装技能失败: ${errorMsg}`));
+                });
+            });
         }
-        // 验证技能不是archived（排除.archived目录）
-        if (skill.metadata.baseDir.includes('/.archived/') ||
-            skill.metadata.baseDir.includes('\\.archived\\')) {
-            throw new Error(`Cannot get info for archived skill: ${skillName}`);
+        catch (error) {
+            logger_1.logger.error(`[SkillsManagementManager] 安装技能失败: ${error.message}`);
+            onProgress?.({ type: 'error', message: error.message });
+            throw new Error(`安装技能失败: ${error.message}`);
         }
-        // 获取文件树
-        const files = await this.getSkillFileTree(skillName);
-        // 获取文件统计信息
-        const stat = await this.safeGetFileStat(skill.metadata.path);
-        return {
-            name: skill.metadata.name,
-            description: skill.metadata.description,
-            path: skill.metadata.path,
-            baseDir: skill.metadata.baseDir,
-            createdAt: stat?.birthtime?.toISOString(),
-            updatedAt: stat?.mtime?.toISOString(),
-            files,
-            references: skill.references,
-            scripts: skill.scripts,
-            assets: skill.assets,
-        };
     }
     /**
-     * 获取已归档技能列表（只读，不支持修改）
+     * 3. 列出归档技能
+     * 扫描.archived目录
+     * 返回归档技能清单及其元数据信息
      */
     async listArchivedSkills() {
-        // 使用配置的归档目录
-        const archivedDir = this.archivedDir;
-        // 检查archived目录是否存在
-        const exists = await this.fileExists(archivedDir);
-        if (!exists) {
-            return [];
-        }
+        const skills = [];
         try {
-            // 读取archived目录
-            const entries = await fs.readdir(archivedDir, { withFileTypes: true });
-            const archivedSkills = [];
+            // 1. 确保.archived目录存在
+            const exists = await this.fileExists(this.archivedDir);
+            if (!exists) {
+                return skills; // 返回空列表
+            }
+            // 2. 读取.archived目录
+            const entries = await fs.readdir(this.archivedDir, { withFileTypes: true });
+            // 3. 遍历每个子目录
             for (const entry of entries) {
-                if (!entry.isDirectory()) {
-                    continue;
-                }
-                const archivedPath = path.join(archivedDir, entry.name);
-                // 检查是否包含SKILL.md
-                const skillMdPath = path.join(archivedPath, 'SKILL.md');
-                if (!(await this.fileExists(skillMdPath))) {
+                // 只处理目录
+                if (!entry.isDirectory())
                     continue;
-                }
-                // 提取原始名称和归档时间（支持带毫秒和不带毫秒两种格式）
-                const match = entry.name.match(/^(.+?)_(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}(?:-\d{3})?Z)$/);
-                if (!match) {
-                    continue;
-                }
-                const originalName = match[1];
-                // 解析时间戳（支持带毫秒和不带毫秒两种格式）
-                // 格式1: 2026-01-15T05-05-01-350Z (带毫秒)
-                // 格式2: 2026-01-15T05-05-01Z (不带毫秒)
-                const timestampMatch = match[2].match(/^(\d{4}-\d{2}-\d{2})T(\d{2})-(\d{2})-(\d{2})(?:-(\d{3}))?Z$/);
-                if (!timestampMatch) {
-                    continue;
-                }
-                const [, date, hour, min, sec, ms] = timestampMatch;
-                const isoTimestamp = ms
-                    ? `${date}T${hour}:${min}:${sec}.${ms}Z`
-                    : `${date}T${hour}:${min}:${sec}Z`;
-                const archivedAt = new Date(isoTimestamp).toISOString();
+                const skillDir = path.join(this.archivedDir, entry.name);
+                // 4. 读取SKILL.md
+                const skillMdPath = path.join(skillDir, 'SKILL.md');
+                const skillExists = await this.fileExists(skillMdPath);
+                if (!skillExists)
+                    continue; // 跳过没有SKILL.md的目录
+                const content = await fs.readFile(skillMdPath, 'utf-8');
+                // 5. 解析YAML frontmatter
+                const metadata = this.parseSkillMd(content);
+                if (!metadata)
+                    continue; // 跳过无效的SKILL.md
+                // 6. 提取原始技能名称(去除-XXXXXXXX后缀)
+                const match = entry.name.match(/^(.+)-[a-f0-9]{8}$/);
+                const originalName = match ? match[1] : entry.name;
                 // 获取文件统计信息
-                const stat = await this.safeGetFileStat(archivedPath);
-                archivedSkills.push({
-                    originalName,
+                const stat = await this.safeGetFileStat(skillDir);
+                skills.push({
+                    originalName: originalName,
                     archivedName: entry.name,
-                    archivedPath,
-                    archivedAt: stat?.mtime?.toISOString() || archivedAt,
+                    archivedPath: skillDir,
+                    folderName: entry.name,
+                    archivedAt: stat?.mtime?.toISOString() || new Date().toISOString(),
+                    name: metadata.name,
+                    description: metadata.description,
+                    license: metadata.license,
                 });
             }
-            return archivedSkills.sort((a, b) => b.archivedAt.localeCompare(a.archivedAt));
+            return skills;
         }
         catch (error) {
             logger_1.logger.error('[SkillsManagementManager] Error listing archived skills:', error);
-            return [];
+            throw error;
         }
     }
     /**
-     * 创建新技能
+     * 4. 导入技能
+     * @param zipFilePath zip文件路径
+     * @param originalFileName 原始上传文件名（可选，用于无嵌套目录时的技能命名）
+     * 验证SKILL.md格式,解压并放置在在线技能目录中
+     *
+     * 检测逻辑：
+     * - 如果解压后根目录直接包含SKILL.md，视为无嵌套目录，使用originalFileName作为技能名称
+     * - 如果根目录不包含SKILL.md但包含多个子目录，每个子目录都有SKILL.md，则批量导入
+     */
+    async importSkill(zipFilePath, originalFileName) {
+        try {
+            // 1. 验证zip文件存在
+            const exists = await this.fileExists(zipFilePath);
+            if (!exists) {
+                throw new Error(`Zip文件不存在: ${zipFilePath}`);
+            }
+            // 2. 创建临时目录
+            const tempDir = path.join(os.tmpdir(), `skill-import-${Date.now()}`);
+            await fs.mkdir(tempDir, { recursive: true });
+            try {
+                // 3. 解压zip文件
+                await this.extractZip(zipFilePath, tempDir);
+                // 4. 检测结构
+                const rootSkillMdPath = path.join(tempDir, 'SKILL.md');
+                const hasRootSkillMd = await this.fileExists(rootSkillMdPath);
+                if (hasRootSkillMd && originalFileName) {
+                    // 4.1 无嵌套目录结构：根目录直接包含SKILL.md
+                    // 使用原始文件名（去除.zip扩展名）作为技能名称
+                    let skillName = originalFileName.replace(/\.zip$/i, '');
+                    // 验证SKILL.md
+                    const valid = await this.validateSkillMd(rootSkillMdPath);
+                    if (!valid) {
+                        throw new Error('技能格式无效, SKILL.md不符合Specification.md规范');
+                    }
+                    // 检测重名，如重名则添加后缀
+                    let targetDir = path.join(this.skillsDir, skillName);
+                    if (await this.fileExists(targetDir)) {
+                        const suffix = await this.generateRandomSuffix();
+                        const newName = `${skillName}-${suffix}`;
+                        targetDir = path.join(this.skillsDir, newName);
+                        logger_1.logger.log(`[SkillsManagementManager] 导入技能重名，已添加后缀: ${skillName} -> ${newName}`);
+                        skillName = newName;
+                    }
+                    // 移动到在线技能目录
+                    await this.safeRename(tempDir, targetDir);
+                    logger_1.logger.log(`[SkillsManagementManager] 技能已导入: ${skillName}`);
+                }
+                else {
+                    // 4.2 嵌套目录结构：批量导入多个技能目录
+                    const entries = await fs.readdir(tempDir, { withFileTypes: true });
+                    for (const entry of entries) {
+                        if (!entry.isDirectory())
+                            continue;
+                        const skillDir = path.join(tempDir, entry.name);
+                        // 验证SKILL.md
+                        const skillMdPath = path.join(skillDir, 'SKILL.md');
+                        const valid = await this.validateSkillMd(skillMdPath);
+                        if (!valid) {
+                            throw new Error(`技能格式无效: ${entry.name}, SKILL.md不符合Specification.md规范`);
+                        }
+                        // 检测重名，如重名则添加后缀
+                        let targetName = entry.name;
+                        let targetDir = path.join(this.skillsDir, targetName);
+                        if (await this.fileExists(targetDir)) {
+                            // 重名，添加随机后缀
+                            const suffix = await this.generateRandomSuffix();
+                            targetName = `${entry.name}-${suffix}`;
+                            targetDir = path.join(this.skillsDir, targetName);
+                            logger_1.logger.log(`[SkillsManagementManager] 导入技能重名，已添加后缀: ${entry.name} -> ${targetName}`);
+                        }
+                        // 移动到在线技能目录
+                        await this.safeRename(skillDir, targetDir);
+                        logger_1.logger.log(`[SkillsManagementManager] 技能已导入: ${targetName}`);
+                    }
+                }
+            }
+            finally {
+                // 5. 清理临时目录
+                await fs.rm(tempDir, { recursive: true, force: true });
+            }
+        }
+        catch (error) {
+            logger_1.logger.error('[SkillsManagementManager] Error importing skill:', error);
+            throw error;
+        }
+    }
+    /**
+     * 5. 复制技能
      * @param skillName 技能名称
-     * @param options 技能配置（名称、描述等）
+     * 新技能名称: {原技能名称}-{XXXXXXXX}
      */
-    async createSkill(skillName, options) {
-        // 包装为操作任务
-        const task = {
-            id: crypto.randomUUID(),
-            type: operation_queue_1.OperationType.CREATE,
-            targetSkill: skillName,
-            status: 'pending',
-            execute: async () => {
-                await this.doCreateSkill(skillName, options);
-            },
-            createdAt: new Date(),
-        };
-        // 入队并等待完成
-        await this.operationQueue.enqueue(task);
-        await this.waitForTask(task);
-        // 检查是否有错误
-        if (task.error) {
-            throw task.error;
-        }
-        // 返回创建的技能详细信息
-        const skillDetail = await this.getSkillInfo(skillName);
-        if (!skillDetail) {
-            throw new Error(`Failed to get skill info after creation: ${skillName}`);
-        }
-        return skillDetail;
+    async copySkill(skillName) {
+        try {
+            // 1. 验证技能存在
+            const sourceDir = path.join(this.skillsDir, skillName);
+            const exists = await this.fileExists(sourceDir);
+            if (!exists) {
+                throw new Error(`技能不存在: ${skillName}`);
+            }
+            // 2. 生成8位随机后缀
+            const suffix = await this.generateRandomSuffix();
+            const newSkillName = `${skillName}-${suffix}`;
+            const targetDir = path.join(this.skillsDir, newSkillName);
+            // 3. 递归复制目录
+            await fs.cp(sourceDir, targetDir, { recursive: true });
+            logger_1.logger.log(`[SkillsManagementManager] 技能已复制: ${skillName} -> ${newSkillName}`);
+            return newSkillName;
+        }
+        catch (error) {
+            logger_1.logger.error('[SkillsManagementManager] Error copying skill:', error);
+            throw error;
+        }
     }
     /**
-     * 重命名技能
-     * @param oldName 旧技能名称
-     * @param newName 新技能名称
+     * 6. 重命名技能
+     * @param oldName 旧技能文件夹名称
+     * @param newName 新技能文件夹名称
+     * 不支持操作归档技能
      */
     async renameSkill(oldName, newName) {
-        // 包装为操作任务
-        const task = {
-            id: crypto.randomUUID(),
-            type: operation_queue_1.OperationType.RENAME,
-            targetSkill: `${oldName} -> ${newName}`,
-            status: 'pending',
-            execute: async () => {
-                await this.doRenameSkill(oldName, newName);
-            },
-            createdAt: new Date(),
-        };
-        // 入队并等待完成
-        await this.operationQueue.enqueue(task);
-        await this.waitForTask(task);
-        // 检查是否有错误
-        if (task.error) {
-            throw task.error;
+        try {
+            // 1. 验证旧技能存在
+            const oldPath = path.join(this.skillsDir, oldName);
+            const exists = await this.fileExists(oldPath);
+            if (!exists) {
+                throw new Error(`技能不存在: ${oldName}`);
+            }
+            // 2. 验证新名称
+            if (!this.isValidSkillName(newName)) {
+                throw new Error(`无效的技能名称: ${newName}`);
+            }
+            const newPath = path.join(this.skillsDir, newName);
+            if (await this.fileExists(newPath)) {
+                throw new Error(`技能已存在: ${newName}`);
+            }
+            // 3. 重命名目录（仅修改文件夹名称，不修改SKILL.md内容）
+            await this.safeRename(oldPath, newPath);
+            logger_1.logger.log(`[SkillsManagementManager] 技能已重命名: ${oldName} -> ${newName}`);
+        }
+        catch (error) {
+            logger_1.logger.error('[SkillsManagementManager] Error renaming skill:', error);
+            throw error;
         }
     }
     /**
-     * 编辑技能文件
+     * 7. 在线技能转归档
      * @param skillName 技能名称
-     * @param filePath 文件路径（相对于技能根目录，如"SKILL.md"）
-     * @param content 文件内容
-     * @param useSandbox 是否使用sandbox（默认true）
+     * 归档名称: {原技能名称}-{XXXXXXXX}
      */
-    async editSkillFile(skillName, filePath, content, useSandbox = true) {
-        // 包装为操作任务
-        const task = {
-            id: crypto.randomUUID(),
-            type: operation_queue_1.OperationType.EDIT,
-            targetSkill: skillName,
-            status: 'pending',
-            execute: async () => {
-                await this.doEditSkillFile(skillName, filePath, content, useSandbox);
-            },
-            createdAt: new Date(),
-        };
-        // 入队并等待完成
-        await this.operationQueue.enqueue(task);
-        await this.waitForTask(task);
-        // 检查是否有错误
-        if (task.error) {
-            throw task.error;
+    async archiveSkill(skillName) {
+        try {
+            // 1. 验证技能存在
+            const skillDir = path.join(this.skillsDir, skillName);
+            const exists = await this.fileExists(skillDir);
+            if (!exists) {
+                throw new Error(`技能不存在: ${skillName}`);
+            }
+            // 2. 生成8位随机后缀
+            const suffix = await this.generateRandomSuffix();
+            const archivedName = `${skillName}-${suffix}`;
+            // 3. 确保.archived目录存在
+            await fs.mkdir(this.archivedDir, { recursive: true });
+            // 4. 移动到.archived目录
+            const archivedPath = path.join(this.archivedDir, archivedName);
+            await this.safeRename(skillDir, archivedPath);
+            logger_1.logger.log(`[SkillsManagementManager] 技能已归档: ${skillName} -> ${archivedName}`);
+        }
+        catch (error) {
+            logger_1.logger.error('[SkillsManagementManager] Error archiving skill:', error);
+            throw error;
+        }
+    }
+    /**
+     * 8. 归档技能转在线
+     * @param archivedSkillName archived中的技能名称(含后缀)
+     * 移入前检测重名
+     */
+    async unarchiveSkill(archivedSkillName) {
+        try {
+            // 1. 验证.archived技能存在
+            const archivedPath = path.join(this.archivedDir, archivedSkillName);
+            const exists = await this.fileExists(archivedPath);
+            if (!exists) {
+                throw new Error(`归档技能不存在: ${archivedSkillName}`);
+            }
+            // 2. 提取原始名称(去除-XXXXXXXX后缀)
+            const match = archivedSkillName.match(/^(.+)-[a-f0-9]{8}$/);
+            if (!match) {
+                throw new Error(`无效的归档技能名称: ${archivedSkillName}`);
+            }
+            const originalName = match[1];
+            // 3. 检测重名
+            const targetPath = path.join(this.skillsDir, originalName);
+            if (await this.fileExists(targetPath)) {
+                throw new Error(`技能已存在: ${originalName}`);
+            }
+            // 4. 移回skills目录
+            await this.safeRename(archivedPath, targetPath);
+            logger_1.logger.log(`[SkillsManagementManager] 技能已恢复: ${archivedSkillName} -> ${originalName}`);
+        }
+        catch (error) {
+            logger_1.logger.error('[SkillsManagementManager] Error unarchiving skill:', error);
+            throw error;
         }
     }
     /**
-     * 删除技能（移动到archived）
+     * 9. 查看在线技能内容
      * @param skillName 技能名称
+     * 返回SKILL.md完整内容(包含frontmatter和正文)
      */
-    async deleteSkill(skillName) {
-        // 包装为操作任务
-        const task = {
-            id: crypto.randomUUID(),
-            type: operation_queue_1.OperationType.DELETE,
-            targetSkill: skillName,
-            status: 'pending',
-            execute: async () => {
-                await this.doDeleteSkill(skillName);
-            },
-            createdAt: new Date(),
-        };
-        // 入队并等待完成
-        await this.operationQueue.enqueue(task);
-        await this.waitForTask(task);
-        // 检查是否有错误
-        if (task.error) {
-            throw task.error;
+    async getOnlineSkillContent(skillName) {
+        try {
+            // 1. 验证技能存在
+            const skillDir = path.join(this.skillsDir, skillName);
+            const exists = await this.fileExists(skillDir);
+            if (!exists) {
+                throw new Error(`技能不存在: ${skillName}`);
+            }
+            // 2. 读取SKILL.md
+            const skillMdPath = path.join(skillDir, 'SKILL.md');
+            const skillExists = await this.fileExists(skillMdPath);
+            if (!skillExists) {
+                throw new Error(`SKILL.md不存在: ${skillName}`);
+            }
+            // 3. 返回完整内容
+            const content = await fs.readFile(skillMdPath, 'utf-8');
+            return content;
+        }
+        catch (error) {
+            logger_1.logger.error('[SkillsManagementManager] Error getting online skill content:', error);
+            throw error;
         }
     }
     /**
-     * 恢复已删除的技能
-     * @param archivedSkillName archived中的技能名称（含时间戳）
+     * 10. 查看归档技能内容
+     * @param archivedSkillName 归档技能名称(含8位后缀)
+     * 返回SKILL.md完整内容(包含frontmatter和正文)
      */
-    async restoreSkill(archivedSkillName) {
-        // 包装为操作任务
-        const task = {
-            id: crypto.randomUUID(),
-            type: operation_queue_1.OperationType.RESTORE,
-            targetSkill: archivedSkillName,
-            status: 'pending',
-            execute: async () => {
-                await this.doRestoreSkill(archivedSkillName);
-            },
-            createdAt: new Date(),
-        };
-        // 入队并等待完成
-        await this.operationQueue.enqueue(task);
-        await this.waitForTask(task);
-        // 检查是否有错误
-        if (task.error) {
-            throw task.error;
+    async getArchivedSkillContent(archivedSkillName) {
+        try {
+            // 1. 验证归档技能存在
+            const skillDir = path.join(this.archivedDir, archivedSkillName);
+            const exists = await this.fileExists(skillDir);
+            if (!exists) {
+                throw new Error(`归档技能不存在: ${archivedSkillName}`);
+            }
+            // 2. 读取SKILL.md
+            const skillMdPath = path.join(skillDir, 'SKILL.md');
+            const skillExists = await this.fileExists(skillMdPath);
+            if (!skillExists) {
+                throw new Error(`SKILL.md不存在: ${archivedSkillName}`);
+            }
+            // 3. 返回完整内容
+            const content = await fs.readFile(skillMdPath, 'utf-8');
+            return content;
+        }
+        catch (error) {
+            logger_1.logger.error('[SkillsManagementManager] Error getting archived skill content:', error);
+            throw error;
         }
     }
     /**
-     * 获取技能文件树（仅在线技能）
+     * 11. 查看在线技能文件目录结构
      * @param skillName 技能名称
+     * 返回JSON格式的目录树结构
      */
-    async getSkillFileTree(skillName) {
-        // 获取技能信息
-        const skill = await this.skillsManager.loadSkillContent(skillName);
-        if (!skill) {
-            throw new Error(`Skill not found: ${skillName}`);
-        }
-        // 验证技能不是archived（排除.archived目录）
-        if (skill.metadata.baseDir.includes('/.archived/') ||
-            skill.metadata.baseDir.includes('\\.archived\\')) {
-            throw new Error(`Cannot get file tree for archived skill: ${skillName}`);
-        }
-        // 使用SandboxFileManager获取文件树
-        return await this.sandboxFileManager.listFiles(skill.metadata.baseDir, '.');
+    async getOnlineSkillStructure(skillName) {
+        try {
+            // 1. 验证技能存在
+            const skillDir = path.join(this.skillsDir, skillName);
+            const exists = await this.fileExists(skillDir);
+            if (!exists) {
+                throw new Error(`技能不存在: ${skillName}`);
+            }
+            // 2. 构建目录树
+            return await this.buildDirectoryTree(skillDir, skillName);
+        }
+        catch (error) {
+            logger_1.logger.error('[SkillsManagementManager] Error getting online skill structure:', error);
+            throw error;
+        }
     }
     /**
-     * 获取队列状态
+     * 12. 查看归档技能文件目录结构
+     * @param archivedSkillName 归档技能名称(含8位后缀)
+     * 返回JSON格式的目录树结构
      */
-    getQueueStatus() {
-        return this.operationQueue.getQueueStatus();
+    async getArchivedSkillStructure(archivedSkillName) {
+        try {
+            // 1. 验证归档技能存在
+            const skillDir = path.join(this.archivedDir, archivedSkillName);
+            const exists = await this.fileExists(skillDir);
+            if (!exists) {
+                throw new Error(`归档技能不存在: ${archivedSkillName}`);
+            }
+            // 2. 构建目录树
+            return await this.buildDirectoryTree(skillDir, archivedSkillName);
+        }
+        catch (error) {
+            logger_1.logger.error('[SkillsManagementManager] Error getting archived skill structure:', error);
+            throw error;
+        }
     }
-    // ==================== 私有方法 ====================
     /**
-     * 执行创建技能
+     * 13. 导出技能
+     * @param skillName 技能名称(在线或归档)
+     * @param isArchived 是否为归档技能
+     * 使用系统zip命令打包,放入临时目录
      */
-    async doCreateSkill(skillName, options) {
-        // 1. 验证技能名称
-        if (!this.isValidSkillName(skillName)) {
-            throw new Error(`Invalid skill name: ${skillName}`);
-        }
-        // 优先检查archived技能是否已存在（因为 SkillsManager 也会扫描 .archived 目录）
-        const archivedSkills = await this.listArchivedSkills();
-        const archivedSkill = archivedSkills.find(s => s.originalName === skillName);
-        if (archivedSkill) {
-            throw new Error(`Archived skill with name '${skillName}' already exists. Please restore or permanently delete it first.`);
-        }
-        // 检查在线技能是否已存在（排除 .archived 目录中的技能）
-        const existingSkill = await this.skillsManager.loadSkillContent(skillName);
-        if (existingSkill) {
-            // 二次验证：确保技能不在 .archived 目录中
-            if (existingSkill.metadata.baseDir.includes('/.archived/') ||
-                existingSkill.metadata.baseDir.includes('\\.archived\\')) {
-                throw new Error(`Archived skill with name '${skillName}' already exists. Please restore or permanently delete it first.`);
-            }
-            throw new Error(`Skill already exists: ${skillName}`);
-        }
-        // 2. 创建目录结构
-        const skillDir = path.join(this.skillsDir, skillName);
-        await fs.mkdir(skillDir, { recursive: true });
-        await fs.mkdir(path.join(skillDir, 'references'));
-        await fs.mkdir(path.join(skillDir, 'scripts'));
-        await fs.mkdir(path.join(skillDir, 'assets'));
-        // 3. 生成SKILL.md
-        const skillMdContent = this.generateSkillMd(options);
-        await fs.writeFile(path.join(skillDir, 'SKILL.md'), skillMdContent, 'utf-8');
-        logger_1.logger.log(`[SkillsManagementManager] Skill created: ${skillName}`);
+    async exportSkill(skillName, isArchived) {
+        try {
+            // 1. 确定技能路径
+            let skillDir;
+            if (isArchived) {
+                skillDir = path.join(this.archivedDir, skillName);
+            }
+            else {
+                skillDir = path.join(this.skillsDir, skillName);
+            }
+            const exists = await this.fileExists(skillDir);
+            if (!exists) {
+                throw new Error(`技能不存在: ${skillName}`);
+            }
+            // 2. 生成zip文件路径
+            const zipFileName = `${skillName}.zip`;
+            const zipFilePath = path.join(os.tmpdir(), zipFileName);
+            // 3. 使用系统zip命令打包
+            await this.createZip(skillDir, zipFilePath);
+            logger_1.logger.log(`[SkillsManagementManager] 技能已导出: ${skillName} -> ${zipFilePath}`);
+            return zipFilePath;
+        }
+        catch (error) {
+            logger_1.logger.error('[SkillsManagementManager] Error exporting skill:', error);
+            throw error;
+        }
     }
+    // ==================== 私有辅助方法 ====================
     /**
-     * 执行重命名技能
+     * 递归构建目录树
      */
-    async doRenameSkill(oldName, newName) {
-        // 1. 验证旧技能存在
-        const oldSkill = await this.skillsManager.loadSkillContent(oldName);
-        if (!oldSkill) {
-            throw new Error(`Skill not found: ${oldName}`);
-        }
-        // 2. 验证新名称
-        if (!this.isValidSkillName(newName)) {
-            throw new Error(`Invalid skill name: ${newName}`);
-        }
-        const newSkill = await this.skillsManager.loadSkillContent(newName);
-        if (newSkill) {
-            throw new Error(`Skill already exists: ${newName}`);
-        }
-        // 3. 重命名目录
-        const oldPath = path.join(this.skillsDir, oldName);
-        const newPath = path.join(this.skillsDir, newName);
-        await fs.rename(oldPath, newPath);
-        // 4. 更新SKILL.md中的name字段
-        const skillMdPath = path.join(newPath, 'SKILL.md');
-        let content = await fs.readFile(skillMdPath, 'utf-8');
-        content = content.replace(/^name:\s*.+$/m, `name: ${newName}`);
-        await fs.writeFile(skillMdPath, content, 'utf-8');
-        logger_1.logger.log(`[SkillsManagementManager] Skill renamed: ${oldName} -> ${newName}`);
+    async buildDirectoryTree(dirPath, relativePath = '') {
+        try {
+            const stats = await fs.stat(dirPath);
+            const name = path.basename(dirPath);
+            if (!stats.isDirectory()) {
+                return {
+                    name,
+                    type: 'file',
+                    path: relativePath || name,
+                    size: stats.size,
+                    modifiedTime: stats.mtime.toISOString(),
+                };
+            }
+            const entries = await fs.readdir(dirPath, { withFileTypes: true });
+            const children = [];
+            for (const entry of entries) {
+                const fullPath = path.join(dirPath, entry.name);
+                const entryRelativePath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+                if (entry.isDirectory()) {
+                    children.push(await this.buildDirectoryTree(fullPath, entryRelativePath));
+                }
+                else {
+                    const stat = await fs.stat(fullPath);
+                    children.push({
+                        name: entry.name,
+                        type: 'file',
+                        path: entryRelativePath,
+                        size: stat.size,
+                        modifiedTime: stat.mtime.toISOString(),
+                    });
+                }
+            }
+            return {
+                name,
+                type: 'directory',
+                path: relativePath || name,
+                children,
+            };
+        }
+        catch (error) {
+            logger_1.logger.error('[SkillsManagementManager] Error building directory tree:', error);
+            throw error;
+        }
     }
     /**
-     * 执行编辑技能文件
+     * 解析SKILL.md的YAML frontmatter
      */
-    async doEditSkillFile(skillName, filePath, content, useSandbox) {
-        // 1. 获取技能信息
-        const skill = await this.skillsManager.loadSkillContent(skillName);
-        if (!skill) {
-            throw new Error(`Skill not found: ${skillName}`);
-        }
-        // 1.1 验证技能是否为archived（不支持编辑.archived中的技能）
-        if (skill.metadata.baseDir.includes('/.archived/') ||
-            skill.metadata.baseDir.includes('\\.archived\\')) {
-            throw new Error(`Cannot edit archived skill: ${skillName}. Please restore it first.`);
-        }
-        // 2. 验证文件路径（防止路径穿越）
-        const normalizedPath = path.normalize(filePath);
-        if (normalizedPath.startsWith('..') || path.isAbsolute(normalizedPath)) {
-            throw new Error(`Invalid file path: ${filePath}`);
-        }
-        // 3. 写入文件
-        if (useSandbox) {
-            // 使用sandbox写入（安全）
-            await this.sandboxFileManager.writeFile(skill.metadata.baseDir, normalizedPath, content);
-        }
-        else {
-            // 直接写入（不推荐）
-            const fullPath = path.join(skill.metadata.baseDir, normalizedPath);
-            await fs.writeFile(fullPath, content, 'utf-8');
-        }
-        logger_1.logger.log(`[SkillsManagementManager] File edited: ${skillName}/${filePath}`);
+    parseSkillMd(content) {
+        const match = content.match(/^---\n([\s\S]+?)\n---/);
+        if (!match)
+            return null;
+        const yamlContent = match[1];
+        // 简单YAML解析(只解析基本字段)
+        const nameMatch = yamlContent.match(/^name:\s*(.+)$/m);
+        const descMatch = yamlContent.match(/^description:\s*(.+)$/m);
+        const licenseMatch = yamlContent.match(/^license:\s*(.+)$/m);
+        if (!nameMatch)
+            return null;
+        return {
+            name: nameMatch[1].trim(),
+            description: descMatch ? descMatch[1].trim() : '',
+            license: licenseMatch ? licenseMatch[1].trim() : undefined,
+        };
     }
     /**
-     * 执行删除技能
+     * 验证SKILL.md格式(遵循Specification.md规范)
      */
-    async doDeleteSkill(skillName) {
-        // 1. 验证技能存在
-        const skill = await this.skillsManager.loadSkillContent(skillName);
-        if (!skill) {
-            throw new Error(`Skill not found: ${skillName}`);
-        }
-        // 2. 确保archived目录存在（使用配置的归档目录）
-        const archivedDir = this.archivedDir;
-        await fs.mkdir(archivedDir, { recursive: true });
-        // 3. 生成归档名称
-        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-        const archivedName = `${skillName}_${timestamp}`;
-        const archivedPath = path.join(archivedDir, archivedName);
-        // 4. 移动到archived
-        await fs.rename(skill.metadata.baseDir, archivedPath);
-        logger_1.logger.log(`[SkillsManagementManager] Skill archived: ${skillName} -> ${archivedName}`);
+    async validateSkillMd(skillMdPath) {
+        const exists = await this.fileExists(skillMdPath);
+        if (!exists)
+            return false;
+        const content = await fs.readFile(skillMdPath, 'utf-8');
+        const metadata = this.parseSkillMd(content);
+        if (!metadata)
+            return false;
+        // 验证必需字段
+        if (!metadata.name || !metadata.description)
+            return false;
+        // 验证name字段格式(1-64字符,小写字母数字和连字符)
+        const nameRegex = /^[a-z0-9-]{1,64}$/;
+        if (!nameRegex.test(metadata.name))
+            return false;
+        // 验证name不以连字符开头或结尾
+        if (metadata.name.startsWith('-') || metadata.name.endsWith('-'))
+            return false;
+        return true;
     }
     /**
-     * 执行恢复技能
+     * 生成8位随机后缀
+     * 规则: uuidv4 → sha256 → 全小写 → 取前8位
      */
-    async doRestoreSkill(archivedSkillName) {
-        // 1. 查找archived技能（使用配置的归档目录）
-        const archivedDir = this.archivedDir;
-        const archivedPath = path.join(archivedDir, archivedSkillName);
-        const exists = await this.fileExists(archivedPath);
-        if (!exists) {
-            throw new Error(`Archived skill not found: ${archivedSkillName}`);
-        }
-        // 2. 提取原始名称（去掉时间戳后缀，支持带毫秒和不带毫秒两种格式）
-        const originalName = archivedSkillName.replace(/_\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}(?:-\d{3})?Z$/, '');
-        // 3. 检查目标位置是否已存在
-        const targetPath = path.join(this.skillsDir, originalName);
-        if (await this.fileExists(targetPath)) {
-            throw new Error(`Skill already exists: ${originalName}`);
-        }
-        // 4. 移回skills目录
-        await fs.rename(archivedPath, targetPath);
-        logger_1.logger.log(`[SkillsManagementManager] Skill restored: ${archivedSkillName} -> ${originalName}`);
+    async generateRandomSuffix() {
+        // 1. 生成UUID v4
+        const uuid = crypto.randomUUID();
+        // 2. 计算SHA256
+        const hash = crypto.createHash('sha256').update(uuid).digest('hex');
+        // 3. 全小写并取前8位
+        return hash.toLowerCase().substring(0, 8);
     }
     /**
      * 验证技能名称
      */
     isValidSkillName(name) {
-        // 只允许字母、数字、连字符、下划线
-        return /^[a-zA-Z0-9_-]+$/.test(name) && name.length > 0 && name.length <= 50;
-    }
-    /**
-     * 生成SKILL.md内容
-     */
-    generateSkillMd(options) {
-        const { name, description = '' } = options;
-        return `---
-name: ${name}
-description: ${description}
----
-
-# ${name}
-
-This is a custom skill created for ${name}.
-
-## Usage
-
-Describe how to use this skill here.
-
-## Configuration
-
-Add any configuration details here.
-`;
+        // 只允许小写字母、数字、连字符
+        const nameRegex = /^[a-z0-9-]+$/;
+        return nameRegex.test(name) &&
+            name.length > 0 &&
+            name.length <= 64 &&
+            !name.startsWith('-') &&
+            !name.endsWith('-') &&
+            !name.includes('--');
     }
     /**
      * 检查文件是否存在
@@ -536,21 +760,67 @@ Add any configuration details here.
         }
     }
     /**
-     * 等待任务完成
+     * 解压zip文件
+     */
+    async extractZip(zipFilePath, targetDir) {
+        const platform = os.platform();
+        try {
+            let cmd;
+            if (platform === 'win32') {
+                // Windows: 使用tar命令(Windows 10+内置)
+                cmd = `tar -xf "${zipFilePath}" -C "${targetDir}"`;
+            }
+            else {
+                // Linux/Mac: 使用unzip命令
+                cmd = `unzip -q "${zipFilePath}" -d "${targetDir}"`;
+            }
+            await execAsync(cmd);
+        }
+        catch (error) {
+            throw new Error(`解压失败: ${error.message}`);
+        }
+    }
+    /**
+     * 跨平台的安全重命名方法
+     * Windows上使用"复制-删除"方式避免EPERM错误
+     */
+    async safeRename(oldPath, newPath) {
+        const platform = os.platform();
+        try {
+            if (platform === 'win32') {
+                // Windows: 使用复制-删除方式（更可靠）
+                await fs.cp(oldPath, newPath, { recursive: true });
+                await fs.rm(oldPath, { recursive: true, force: true });
+            }
+            else {
+                // Unix-like系统: 直接使用rename
+                await fs.rename(oldPath, newPath);
+            }
+        }
+        catch (error) {
+            logger_1.logger.error(`[SkillsManagementManager] safeRename failed: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * 创建zip文件
      */
-    async waitForTask(task) {
-        // 轮询任务状态，最多等待30秒
-        const maxWaitTime = 30000;
-        const pollInterval = 100;
-        let totalWaited = 0;
-        while (task.status !== 'completed' &&
-            task.status !== 'failed' &&
-            totalWaited < maxWaitTime) {
-            await new Promise(resolve => setTimeout(resolve, pollInterval));
-            totalWaited += pollInterval;
-        }
-        if (task.status !== 'completed' && task.status !== 'failed') {
-            throw new Error(`Operation timeout: ${task.type} - ${task.targetSkill}`);
+    async createZip(sourceDir, zipFilePath) {
+        const platform = os.platform();
+        try {
+            let cmd;
+            if (platform === 'win32') {
+                // Windows: 使用PowerShell的Compress-Archive
+                cmd = `powershell -Command "Compress-Archive -Path '${sourceDir}\\*' -DestinationPath '${zipFilePath}' -Force"`;
+            }
+            else {
+                // Linux/Mac: 使用zip命令
+                cmd = `cd "${sourceDir}" && zip -r "${zipFilePath}" .`;
+            }
+            await execAsync(cmd);
+        }
+        catch (error) {
+            throw new Error(`创建zip失败: ${error.message}`);
         }
     }
 }