@becrafter/prompt-manager 0.0.16 → 0.0.19

package/app/desktop/src/services/module-loader.js

@@ -0,0 +1,193 @@
+const fs = require('fs');
+const path = require('path');
+const { pathToFileURL } = require('url');
+const { spawn } = require('child_process');
+
+class ModuleLoader {
+  constructor(logger, errorHandler) {
+    this.logger = logger;
+    this.errorHandler = errorHandler;
+    this.moduleCache = new Map();
+    this.loadingPromises = new Map();
+  }
+
+  async loadServerModule(serverRoot, forceReload = false) {
+    const cacheKey = serverRoot;
+    
+    // 如果正在加载，返回现有promise
+    if (this.loadingPromises.has(cacheKey) && !forceReload) {
+      this.logger.debug('Returning existing module loading promise');
+      return this.loadingPromises.get(cacheKey);
+    }
+
+    // 强制重新加载时清理缓存
+    if (forceReload) {
+      this.logger.debug('Force reloading server module');
+      this.moduleCache.delete(cacheKey);
+    }
+
+    // 检查缓存
+    if (this.moduleCache.has(cacheKey)) {
+      this.logger.debug('Returning cached server module');
+      return this.moduleCache.get(cacheKey);
+    }
+
+    const loadingPromise = this._loadModuleInternal(serverRoot);
+    this.loadingPromises.set(cacheKey, loadingPromise);
+
+    try {
+      const module = await loadingPromise;
+      this.moduleCache.set(cacheKey, module);
+      return module;
+    } catch (error) {
+      this.logger.error('Failed to load server module', error);
+      throw error;
+    } finally {
+      this.loadingPromises.delete(cacheKey);
+    }
+  }
+
+  async _loadModuleInternal(serverRoot) {
+    this.logger.info('Loading server module', { serverRoot });
+    
+    const serverEntry = path.join(serverRoot, 'packages', 'server', 'server.js');
+    
+    // 验证入口文件存在
+    await this._validateServerEntry(serverEntry);
+    
+    // 生成带版本号的URL
+    const entryUrl = pathToFileURL(serverEntry);
+    entryUrl.searchParams.set('v', Date.now().toString());
+    
+    this.logger.debug('Importing server module', { entryUrl: entryUrl.href });
+    
+    try {
+      const module = await import(entryUrl.href);
+      
+      // 验证模块结构
+      this._validateServerModule(module);
+      
+      this.logger.info('Server module loaded successfully');
+      return module;
+    } catch (error) {
+      this.logger.error('Failed to import server module', error);
+      throw new Error(`Failed to load server module: ${error.message}`);
+    }
+  }
+
+  async _validateServerEntry(serverEntry) {
+    try {
+      await fs.promises.access(serverEntry, fs.constants.F_OK);
+      this.logger.debug('Server entry file exists', { serverEntry });
+    } catch (error) {
+      this.logger.error('Server entry file does not exist', error);
+      throw new Error(`Server entry file not found: ${serverEntry}`);
+    }
+  }
+
+  _validateServerModule(module) {
+    if (!module || typeof module.startServer !== 'function') {
+      throw new Error('Invalid server module: missing startServer function');
+    }
+    
+    this.logger.debug('Server module validation passed');
+  }
+
+  async installDependencies(targetDir) {
+    this.logger.info('Installing server dependencies', { targetDir });
+    
+    // 验证 package.json 存在
+    await this._validatePackageJson(targetDir);
+    
+    // 检查并添加缺失的依赖
+    await this._ensureRequiredDependencies(targetDir);
+    
+    return new Promise((resolve, reject) => {
+      const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+      const args = ['install', '--omit=dev', '--no-audit', '--no-fund'];
+      
+      this.logger.debug('Running npm install', { command: npmCommand, args });
+      
+      const child = spawn(npmCommand, args, {
+        cwd: targetDir,
+        stdio: ['ignore', 'pipe', 'pipe']
+      });
+
+      let stdout = '';
+      let stderr = '';
+      
+      child.stdout.on('data', (data) => {
+        const output = data.toString().trim();
+        stdout += output;
+        this.logger.debug(`[npm stdout] ${output}`);
+      });
+      
+      child.stderr.on('data', (data) => {
+        const output = data.toString().trim();
+        stderr += output;
+        this.logger.warn(`[npm stderr] ${output}`);
+      });
+
+      child.on('error', (error) => {
+        this.logger.error('npm process error', error);
+        reject(new Error(`Failed to start npm process: ${error.message}`));
+      });
+
+      child.on('close', (code) => {
+        this.logger.debug('npm process exited', { code });
+        
+        if (code === 0) {
+          this.logger.info('Dependencies installed successfully');
+          resolve();
+        } else {
+          const errorMsg = `npm install failed with exit code ${code}`;
+          this.logger.error(errorMsg, new Error(stderr));
+          reject(new Error(errorMsg));
+        }
+      });
+    });
+  }
+
+  async _validatePackageJson(targetDir) {
+    const pkgPath = path.join(targetDir, 'package.json');
+    
+    try {
+      await fs.promises.access(pkgPath, fs.constants.F_OK);
+      this.logger.debug('package.json found in target directory');
+    } catch (error) {
+      this.logger.error('package.json not found in target directory', { pkgPath });
+      throw new Error(`package.json not found in ${targetDir}`);
+    }
+  }
+
+  async _ensureRequiredDependencies(targetDir) {
+    const pkgPath = path.join(targetDir, 'package.json');
+    
+    try {
+      const pkgContent = await fs.promises.readFile(pkgPath, 'utf8');
+      const pkg = JSON.parse(pkgContent);
+      
+      pkg.dependencies = pkg.dependencies || {};
+      
+      // 检查并添加 @modelcontextprotocol/sdk
+      if (!pkg.dependencies['@modelcontextprotocol/sdk']) {
+        pkg.dependencies['@modelcontextprotocol/sdk'] = '^1.20.2';
+        await fs.promises.writeFile(pkgPath, JSON.stringify(pkg, null, 2), 'utf8');
+        this.logger.info('Added @modelcontextprotocol/sdk to dependencies');
+      }
+    } catch (error) {
+      this.logger.error('Error checking/adding dependencies', error);
+      throw error;
+    }
+  }
+
+  clearCache(serverRoot) {
+    const cacheKey = serverRoot;
+    if (this.moduleCache.has(cacheKey)) {
+      this.moduleCache.delete(cacheKey);
+      this.logger.debug('Cleared module cache', { serverRoot });
+    }
+  }
+}
+
+module.exports = ModuleLoader;

package/app/desktop/src/services/runtime-manager.js

@@ -0,0 +1,152 @@
+const fs = require('fs');
+const path = require('path');
+const { app } = require('electron');
+
+class RuntimeManager {
+  constructor(logger, errorHandler) {
+    this.logger = logger;
+    this.errorHandler = errorHandler;
+    this.runtimeRoot = null;
+    this.isPackaged = app.isPackaged;
+  }
+
+  async ensureRuntimeEnvironment() {
+    if (this.runtimeRoot) {
+      this.logger.debug('Using cached runtime root', { path: this.runtimeRoot });
+      return this.runtimeRoot;
+    }
+
+    try {
+      if (this.isPackaged) {
+        this.runtimeRoot = await this._setupPackagedEnvironment();
+      } else {
+        this.runtimeRoot = await this._setupDevelopmentEnvironment();
+      }
+
+      this.logger.info('Runtime environment ensured', { 
+        root: this.runtimeRoot,
+        isPackaged: this.isPackaged 
+      });
+
+      return this.runtimeRoot;
+    } catch (error) {
+      this.logger.error('Failed to ensure runtime environment', error);
+      throw error;
+    }
+  }
+
+  async _setupDevelopmentEnvironment() {
+    this.logger.info('Setting up development environment');
+    
+    // Go from app/desktop/src/services -> project root
+    const devRoot = path.resolve(__dirname, '..', '..', '..', '..');
+    
+    // 验证开发环境
+    await this._validateDevelopmentEnvironment(devRoot);
+    
+    this.runtimeRoot = devRoot;
+    return devRoot;
+  }
+
+  async _setupPackagedEnvironment() {
+    this.logger.info('Setting up packaged environment');
+    
+    const packagedRoot = path.join(process.resourcesPath, 'prompt-manager');
+    const runtimeRoot = path.join(app.getPath('userData'), 'prompt-manager');
+    
+    this.logger.debug('Environment paths', { packagedRoot, runtimeRoot });
+    
+    // 验证打包资源
+    await this._validatePackagedResources(packagedRoot);
+    
+    // 设置运行时目录
+    await this._setupRuntimeDirectory(packagedRoot, runtimeRoot);
+    
+    this.runtimeRoot = runtimeRoot;
+    return runtimeRoot;
+  }
+
+  async _validateDevelopmentEnvironment(devRoot) {
+    const requiredPaths = [
+      path.join(devRoot, 'package.json'),
+      path.join(devRoot, 'packages', 'server', 'server.js')
+    ];
+
+    for (const requiredPath of requiredPaths) {
+      try {
+        await fs.promises.access(requiredPath, fs.constants.F_OK);
+      } catch (error) {
+        throw new Error(`Development environment validation failed: ${requiredPath} not found`);
+      }
+    }
+    
+    this.logger.debug('Development environment validation passed');
+  }
+
+  async _validatePackagedResources(packagedRoot) {
+    try {
+      await fs.promises.access(packagedRoot, fs.constants.F_OK);
+      this.logger.debug('Packaged root exists', { path: packagedRoot });
+    } catch (error) {
+      throw new Error(`Packaged resources not found: ${packagedRoot}`);
+    }
+  }
+
+  async _setupRuntimeDirectory(packagedRoot, runtimeRoot) {
+    try {
+      await fs.promises.access(runtimeRoot, fs.constants.F_OK);
+      this.logger.debug('Runtime root already exists');
+    } catch (error) {
+      this.logger.info('Creating runtime directory', { path: runtimeRoot });
+      await fs.promises.mkdir(runtimeRoot, { recursive: true });
+      
+      this.logger.info('Copying packaged resources to runtime directory');
+      await fs.promises.cp(packagedRoot, runtimeRoot, { recursive: true });
+    }
+  }
+
+  async _installDependencies(runtimeRoot) {
+    this.logger.info('Installing dependencies in runtime directory');
+    
+    const ModuleLoader = require('./module-loader');
+    const moduleLoader = new ModuleLoader(this.logger, this.errorHandler);
+    
+    try {
+      await moduleLoader.installDependencies(runtimeRoot);
+      this.logger.info('Dependencies installed successfully');
+    } catch (error) {
+      this.logger.error('Failed to install dependencies', error);
+      throw error;
+    }
+  }
+
+  getServerRoot() {
+    if (!this.runtimeRoot) {
+      throw new Error('Runtime environment not initialized');
+    }
+    return this.runtimeRoot;
+  }
+
+  getPackageInfo() {
+    if (!this.runtimeRoot) {
+      throw new Error('Runtime environment not initialized');
+    }
+    
+    const packagePath = path.join(this.runtimeRoot, 'package.json');
+    
+    try {
+      const packageContent = fs.readFileSync(packagePath, 'utf8');
+      return JSON.parse(packageContent);
+    } catch (error) {
+      this.logger.error('Failed to read package info', error);
+      return { version: 'unknown' };
+    }
+  }
+
+  async cleanup() {
+    this.logger.info('Cleaning up runtime environment');
+    this.runtimeRoot = null;
+  }
+}
+
+module.exports = RuntimeManager;

package/app/desktop/src/services/service-manager.js

@@ -0,0 +1,169 @@
+const { dialog, shell } = require('electron');
+const EventEmitter = require('../core/event-emitter');
+
+class ServiceManager extends EventEmitter {
+  constructor(logger, errorHandler, moduleLoader) {
+    super();
+    this.logger = logger;
+    this.errorHandler = errorHandler;
+    this.moduleLoader = moduleLoader;
+    this.currentModule = null;
+    this.serverState = null;
+  }
+
+  async startService(serverRoot, stateManager) {
+    this.logger.info('Starting service', { serverRoot });
+    
+    try {
+      // 验证服务状态
+      if (!stateManager.canStartService()) {
+        this.logger.warn('Service cannot be started in current state', { 
+          currentState: stateManager.get('service') 
+        });
+        return false;
+      }
+
+      // 更新状态
+      stateManager.set('service', 'starting');
+      this.emitStatusUpdate(stateManager);
+
+      // 加载服务器模块
+      const module = await this.moduleLoader.loadServerModule(serverRoot, true);
+      
+      // 停止现有服务实例
+      await this.stopExistingService(module);
+      
+      // 启动新服务
+      await module.startServer();
+      
+      // 获取服务器状态
+      this.serverState = module.getServerState();
+      this.currentModule = module;
+      
+      // 更新状态
+      stateManager.set({
+        service: 'running',
+        server: this.serverState,
+        module: module
+      });
+      stateManager.resetFailureCount();
+      
+      this.logger.info('Service started successfully', { serverState: this.serverState });
+      this.emitStatusUpdate(stateManager);
+      
+      return true;
+      
+    } catch (error) {
+      this.logger.error('Failed to start service', error);
+      
+      // 更新状态
+      stateManager.set('service', 'error');
+      const failureCount = stateManager.incrementFailureCount();
+      
+      // 处理错误
+      const shouldRestart = await this.errorHandler.handleServiceStartError(
+        error, 
+        failureCount, 
+        this.logger.getLogFilePath()
+      );
+      
+      if (shouldRestart) {
+        this.logger.info('User requested application restart');
+        this.emitRestartRequested();
+      }
+      
+      this.emitStatusUpdate(stateManager);
+      return false;
+    }
+  }
+
+  async stopService(stateManager) {
+    this.logger.info('Stopping service');
+    
+    try {
+      // 验证服务状态
+      if (!stateManager.canStopService()) {
+        this.logger.warn('Service cannot be stopped in current state', { 
+          currentState: stateManager.get('service') 
+        });
+        return false;
+      }
+
+      // 更新状态
+      stateManager.set('service', 'stopping');
+      this.emitStatusUpdate(stateManager);
+
+      // 停止服务
+      if (this.currentModule && typeof this.currentModule.stopServer === 'function') {
+        await this.currentModule.stopServer();
+        this.logger.info('Server stopped successfully');
+      }
+
+      // 清理状态
+      this.currentModule = null;
+      this.serverState = null;
+      
+      // 更新状态
+      stateManager.set({
+        service: 'stopped',
+        server: null,
+        module: null
+      });
+      
+      // 清理模块缓存
+      const serverRoot = stateManager.get('runtimeRoot');
+      if (serverRoot) {
+        this.moduleLoader.clearCache(serverRoot);
+      }
+      
+      this.logger.info('Service stopped successfully');
+      this.emitStatusUpdate(stateManager);
+      
+      return true;
+      
+    } catch (error) {
+      this.logger.error('Failed to stop service', error);
+      
+      // 更新状态
+      stateManager.set('service', 'error');
+      this.errorHandler.handleError('SERVICE_STOP_FAILED', error);
+      this.emitStatusUpdate(stateManager);
+      
+      return false;
+    }
+  }
+
+  async stopExistingService(module) {
+    if (!module || typeof module.stopServer !== 'function') {
+      this.logger.debug('No existing service to stop');
+      return;
+    }
+
+    try {
+      this.logger.debug('Stopping existing service instance');
+      await module.stopServer();
+      this.logger.info('Existing service instance stopped');
+    } catch (error) {
+      this.logger.warn('Failed to stop existing service instance', error);
+      // 不抛出错误，继续启动新服务
+    }
+  }
+
+  getServiceStatus() {
+    return {
+      state: this.serverState,
+      module: this.currentModule,
+      isRunning: this.currentModule !== null
+    };
+  }
+
+  emitStatusUpdate(stateManager) {
+    this.emit('status-update', stateManager.getServiceStatus());
+  }
+
+  emitRestartRequested() {
+    this.emit('restart-requested');
+  }
+}
+
+module.exports = ServiceManager;