@becrafter/prompt-manager 0.1.18 → 0.1.21

package/app/desktop/src/utils/resource-sync.js

@@ -1,260 +0,0 @@
-/**
- * 通用资源同步工具
- * 支持将代码中的内容同步到运行环境中
- * 支持目录同步、文件同步和基于内容的文件创建
- */
-
-const fs = require('fs').promises;
-const path = require('path');
-const os = require('os');
-const { app } = require('electron');
-const PathUtils = require('./path-utils');
-
-class ResourceSync {
-  /**
-   * 检查是否为打包应用
-   */
-  static _checkIfPackaged() {
-    const appPath = app.getAppPath();
-    const isDev = appPath.includes('node_modules/electron') || 
-                 process.env.NODE_ENV === 'development' ||
-                 process.defaultApp;
-    
-    return !isDev && app.isPackaged;
-  }
-
-  /**
-   * 获取项目根目录（开发模式）
-   */
-  static _getProjectRoot() {
-    // 从 app/desktop/src/utils -> 项目根目录
-    return path.resolve(__dirname, '..', '..', '..', '..');
-  }
-
-  /**
-   * 获取用户配置根目录
-   */
-  static _getUserConfigRoot() {
-    return path.join(os.homedir(), '.prompt-manager');
-  }
-
-  /**
-   * 查找实际存在的源路径
-   * @param {Object} options - 查找选项
-   * @param {string|Function} options.devPath - 开发模式下的路径（字符串或返回路径的函数）
-   * @param {string[]|Function} options.packagedPaths - 打包模式下的可能路径数组（或返回路径数组的函数）
-   * @returns {Promise<string|null>} 找到的源路径，如果不存在则返回 null
-   */
-  static async findSourcePath({ devPath, packagedPaths }) {
-    const isPackaged = this._checkIfPackaged();
-    
-    if (isPackaged) {
-      // 打包模式
-      let paths;
-      if (typeof packagedPaths === 'function') {
-        paths = packagedPaths();
-      } else {
-        paths = packagedPaths || [];
-      }
-
-      // 尝试每个路径，返回第一个存在的
-      for (const possiblePath of paths) {
-        try {
-          if (await PathUtils.pathExists(possiblePath)) {
-            return possiblePath;
-          }
-        } catch (error) {
-          // 继续尝试下一个路径
-          continue;
-        }
-      }
-      
-      console.warn('在打包模式下未找到源路径，尝试的路径:', paths);
-      return null;
-    } else {
-      // 开发模式
-      let sourcePath;
-      if (typeof devPath === 'function') {
-        sourcePath = devPath();
-      } else {
-        sourcePath = devPath;
-      }
-
-      if (sourcePath && await PathUtils.pathExists(sourcePath)) {
-        return sourcePath;
-      }
-      
-      console.warn('在开发模式下未找到源路径:', sourcePath);
-      return null;
-    }
-  }
-
-  /**
-   * 同步目录
-   * @param {Object} config - 同步配置
-   * @param {string} config.targetPath - 目标目录路径
-   * @param {string|Function} config.devPath - 开发模式下的源路径
-   * @param {string[]|Function} config.packagedPaths - 打包模式下的可能源路径
-   * @param {boolean} config.skipIfExists - 如果目标已存在则跳过（默认: true）
-   * @param {string} config.name - 资源名称（用于日志）
-   * @returns {Promise<Object>} 同步结果
-   */
-  static async syncDirectory({
-    targetPath,
-    devPath,
-    packagedPaths,
-    skipIfExists = true,
-    name = '目录'
-  }) {
-    try {
-      // 检查目标目录是否已存在
-      const targetExists = await PathUtils.pathExists(targetPath);
-      if (targetExists && skipIfExists) {
-        console.log(`${name}目录已存在，跳过同步: ${targetPath}`);
-        return { success: true, skipped: true, targetPath };
-      }
-
-      // 查找源路径
-      const sourcePath = await this.findSourcePath({ devPath, packagedPaths });
-      
-      if (!sourcePath) {
-        console.warn(`未找到源${name}目录，跳过同步`);
-        return { success: false, error: `Source ${name} directory not found` };
-      }
-
-      // 创建目标目录的父目录
-      await PathUtils.ensureDir(path.dirname(targetPath));
-      
-      // 如果目标已存在但不跳过，先删除
-      if (targetExists && !skipIfExists) {
-        await PathUtils.safeRemoveDir(targetPath);
-      }
-
-      // 创建目标目录
-      await PathUtils.ensureDir(targetPath);
-      console.log(`已创建${name}目录: ${targetPath}`);
-
-      // 复制目录内容
-      await PathUtils.copyDir(sourcePath, targetPath);
-      console.log(`已同步${name}: ${sourcePath} -> ${targetPath}`);
-
-      return { 
-        success: true, 
-        skipped: false, 
-        targetPath, 
-        sourcePath 
-      };
-    } catch (error) {
-      console.error(`${name}同步失败:`, error);
-      return { success: false, error: error.message };
-    }
-  }
-
-  /**
-   * 同步文件（从源文件复制）
-   * @param {Object} config - 同步配置
-   * @param {string} config.targetPath - 目标文件路径
-   * @param {string|Function} config.devPath - 开发模式下的源文件路径
-   * @param {string[]|Function} config.packagedPaths - 打包模式下的可能源文件路径
-   * @param {boolean} config.skipIfExists - 如果目标已存在则跳过（默认: true）
-   * @param {string} config.name - 资源名称（用于日志）
-   * @returns {Promise<Object>} 同步结果
-   */
-  static async syncFile({
-    targetPath,
-    devPath,
-    packagedPaths,
-    skipIfExists = true,
-    name = '文件'
-  }) {
-    try {
-      // 检查目标文件是否已存在
-      const targetExists = await PathUtils.pathExists(targetPath);
-      if (targetExists && skipIfExists) {
-        console.log(`${name}文件已存在，跳过同步: ${targetPath}`);
-        return { success: true, skipped: true, targetPath };
-      }
-
-      // 查找源路径
-      const sourcePath = await this.findSourcePath({ devPath, packagedPaths });
-      
-      if (!sourcePath) {
-        console.warn(`未找到源${name}文件，跳过同步`);
-        return { success: false, error: `Source ${name} file not found` };
-      }
-
-      // 创建目标文件的父目录
-      await PathUtils.ensureDir(path.dirname(targetPath));
-
-      // 复制文件
-      await fs.copyFile(sourcePath, targetPath);
-      console.log(`已同步${name}文件: ${sourcePath} -> ${targetPath}`);
-
-      return { 
-        success: true, 
-        skipped: false, 
-        targetPath, 
-        sourcePath 
-      };
-    } catch (error) {
-      console.error(`${name}文件同步失败:`, error);
-      return { success: false, error: error.message };
-    }
-  }
-
-  /**
-   * 基于内容创建文件
-   * @param {Object} config - 同步配置
-   * @param {string} config.targetPath - 目标文件路径
-   * @param {string|Function} config.content - 文件内容（字符串或返回内容的函数）
-   * @param {boolean} config.skipIfExists - 如果目标已存在则跳过（默认: true）
-   * @param {string} config.name - 资源名称（用于日志）
-   * @returns {Promise<Object>} 同步结果
-   */
-  static async syncContent({
-    targetPath,
-    content,
-    skipIfExists = true,
-    name = '文件'
-  }) {
-    try {
-      // 检查目标文件是否已存在
-      const targetExists = await PathUtils.pathExists(targetPath);
-      if (targetExists && skipIfExists) {
-        console.log(`${name}文件已存在，跳过创建: ${targetPath}`);
-        return { success: true, skipped: true, targetPath };
-      }
-
-      // 获取文件内容
-      let fileContent;
-      if (typeof content === 'function') {
-        fileContent = content();
-      } else {
-        fileContent = content;
-      }
-
-      if (!fileContent) {
-        return { success: false, error: 'Content is required' };
-      }
-
-      // 创建目标文件的父目录
-      await PathUtils.ensureDir(path.dirname(targetPath));
-
-      // 写入文件
-      await fs.writeFile(targetPath, fileContent, 'utf8');
-      console.log(`已创建${name}文件: ${targetPath}`);
-
-      return { 
-        success: true, 
-        skipped: false, 
-        targetPath 
-      };
-    } catch (error) {
-      console.error(`${name}文件创建失败:`, error);
-      return { success: false, error: error.message };
-    }
-  }
-}
-
-module.exports = ResourceSync;
-

package/app/desktop/src/utils/runtime-sync.js

@@ -1,241 +0,0 @@
-/**
- * 运行时环境同步工具
- * 负责将打包的 runtime 目录同步到 ~/.prompt-manager 目录
- * runtime 目录包含所有运行时需要的资源（toolbox、.env 等）
- * 
- * 优化方案：直接同步整个 runtime 目录内容，避免逐个文件处理
- */
-
-const path = require('path');
-const { app } = require('electron');
-const ResourceSync = require('./resource-sync');
-const PathUtils = require('./path-utils');
-
-class RuntimeSync {
-  /**
-   * 同步运行时环境
-   * 将 runtime 目录下的所有内容同步到 ~/.prompt-manager 目录
-   * 支持选择性同步（只同步不存在的文件/目录）
-   */
-  static async syncRuntime() {
-    const configRoot = ResourceSync._getUserConfigRoot();
-    
-    // 确保配置目录存在
-    await PathUtils.ensureDir(configRoot);
-    
-    const isPackaged = ResourceSync._checkIfPackaged();
-    
-    if (isPackaged) {
-      // 打包模式：从 runtime 目录同步
-      return await this._syncFromRuntime(configRoot);
-    } else {
-      // 开发模式：从源文件同步（构建 runtime 结构）
-      return await this._syncFromDev(configRoot);
-    }
-  }
-  
-  /**
-   * 从打包的 runtime 目录同步
-   */
-  static async _syncFromRuntime(configRoot) {
-    const resourcesPath = process.resourcesPath;
-    const possiblePaths = [
-      path.join(resourcesPath, 'runtime'), // extraResources 中的 runtime（最常见）
-      path.join(app.getAppPath(), 'runtime'), // 备用路径
-    ];
-    
-    // 查找 runtime 目录
-    const runtimePath = await ResourceSync.findSourcePath({
-      devPath: null,
-      packagedPaths: () => possiblePaths
-    });
-    
-    if (!runtimePath) {
-      console.warn('未找到 runtime 目录，跳过同步');
-      return { success: false, error: 'Runtime directory not found' };
-    }
-    
-    // 同步 runtime 目录下的所有内容到 configRoot
-    // 逐个同步子目录和文件，避免覆盖已存在的文件
-    const results = await this._syncContents(runtimePath, configRoot);
-    
-    return {
-      success: true,
-      configRoot,
-      runtimePath,
-      results
-    };
-  }
-  
-  /**
-   * 从开发环境源文件同步（模拟 runtime 结构）
-   */
-  static async _syncFromDev(configRoot) {
-    const projectRoot = ResourceSync._getProjectRoot();
-    const results = {};
-    
-    // 同步 toolbox（对应 runtime/toolbox）
-    // 使用递归同步，确保新增的工具能够被同步
-    const toolboxSource = path.join(projectRoot, 'packages', 'resources', 'tools');
-    const toolboxTarget = path.join(configRoot, 'toolbox');
-    if (await PathUtils.pathExists(toolboxSource)) {
-      const result = await this._syncDirectoryRecursive(toolboxSource, toolboxTarget, 'toolbox');
-      results.toolbox = result;
-    }
-    
-    // 同步 .env（对应 runtime/.env）
-    const envSource = path.join(projectRoot, 'env.example');
-    const envTarget = path.join(configRoot, '.env');
-    if (await PathUtils.pathExists(envSource)) {
-      const result = await ResourceSync.syncFile({
-        targetPath: envTarget,
-        devPath: () => envSource,
-        packagedPaths: () => [],
-        skipIfExists: true,
-        name: '环境配置'
-      });
-      results['.env'] = result;
-    }
-    
-    return {
-      success: true,
-      configRoot,
-      results
-    };
-  }
-  
-  /**
-   * 递归同步目录
-   * 确保新增的子目录和文件能够被同步到运行环境
-   * @param {string} sourceDir - 源目录路径
-   * @param {string} targetDir - 目标目录路径
-   * @param {string} dirName - 目录名称（用于日志）
-   * @returns {Promise<Object>} 同步结果
-   */
-  static async _syncDirectoryRecursive(sourceDir, targetDir, dirName = '目录') {
-    const fs = require('fs').promises;
-    const results = {
-      synced: [],
-      skipped: [],
-      errors: []
-    };
-    
-    try {
-      // 确保目标目录存在
-      await PathUtils.ensureDir(targetDir);
-      
-      // 读取源目录下的所有条目
-      const entries = await fs.readdir(sourceDir, { withFileTypes: true });
-      
-      for (const entry of entries) {
-        const sourcePath = path.join(sourceDir, entry.name);
-        const targetPath = path.join(targetDir, entry.name);
-        
-        try {
-          if (entry.isDirectory()) {
-            // 递归同步子目录
-            const subResult = await this._syncDirectoryRecursive(sourcePath, targetPath, entry.name);
-            
-            // 合并结果
-            results.synced.push(...subResult.details.synced);
-            results.skipped.push(...subResult.details.skipped);
-            results.errors.push(...subResult.details.errors);
-          } else if (entry.isFile()) {
-            // 同步文件
-            const targetExists = await PathUtils.pathExists(targetPath);
-            let needsSync = !targetExists;
-            
-            if (targetExists) {
-              // 比较文件修改时间
-              try {
-                const sourceStat = await fs.stat(sourcePath);
-                const targetStat = await fs.stat(targetPath);
-                if (sourceStat.mtime > targetStat.mtime) {
-                  needsSync = true;
-                }
-              } catch (statError) {
-                // 如果无法获取文件状态，默认需要同步
-                needsSync = true;
-              }
-            }
-            
-            if (needsSync) {
-              // 确保目标文件的父目录存在
-              await PathUtils.ensureDir(path.dirname(targetPath));
-              
-              // 复制文件
-              await fs.copyFile(sourcePath, targetPath);
-              console.log(`已同步文件: ${entry.name} -> ${targetPath}`);
-              
-              results.synced.push(entry.name);
-            } else {
-              console.log(`文件已存在且无需更新，跳过: ${entry.name}`);
-              results.skipped.push({ item: entry.name, reason: '已存在且无需更新' });
-            }
-          }
-        } catch (error) {
-          console.error(`同步失败: ${entry.name}`, error);
-          results.errors.push({ item: entry.name, error: error.message });
-        }
-      }
-      
-      return {
-        success: results.errors.length === 0,
-        synced: results.synced.length,
-        skipped: results.skipped.length,
-        errors: results.errors.length,
-        details: results
-      };
-    } catch (error) {
-      console.error(`递归同步 ${dirName} 失败:`, error);
-      return {
-        success: false,
-        error: error.message,
-        details: results
-      };
-    }
-  }
-
-  /**
-   * 同步 runtime 目录下的所有内容到目标目录
-   * 逐个同步子目录和文件，避免覆盖已存在的文件
-   */
-  static async _syncContents(runtimePath, configRoot) {
-    const fs = require('fs').promises;
-    const results = {};
-    
-    try {
-      // 读取 runtime 目录下的所有条目
-      const entries = await fs.readdir(runtimePath, { withFileTypes: true });
-      
-      for (const entry of entries) {
-        const sourcePath = path.join(runtimePath, entry.name);
-        const targetPath = path.join(configRoot, entry.name);
-        
-        if (entry.isDirectory()) {
-          // 所有目录都使用递归同步，确保新增的子目录和文件能够被同步
-          const result = await this._syncDirectoryRecursive(sourcePath, targetPath, entry.name);
-          results[entry.name] = result;
-        } else if (entry.isFile()) {
-          // 同步文件（如 .env）
-          const result = await ResourceSync.syncFile({
-            targetPath,
-            devPath: () => sourcePath,
-            packagedPaths: () => [sourcePath],
-            skipIfExists: true,
-            name: entry.name
-          });
-          results[entry.name] = result;
-        }
-      }
-      
-      return results;
-    } catch (error) {
-      console.error('同步 runtime 内容失败:', error);
-      throw error;
-    }
-  }
-}
-
-module.exports = RuntimeSync;
-