@becrafter/prompt-manager 0.0.16 → 0.0.18

package/app/desktop/main.js

@@ -7,6 +7,59 @@ const { pathToFileURL } = require('url');
 const tar = require('tar');
 const { spawn } = require('child_process');
 
+// 设置日志文件
+const logFilePath = path.join(app.getPath('userData'), 'prompt-manager-desktop.log');
+let logStream;
+
+// 初始化日志流
+function initLogStream() {
+  try {
+    // 确保日志目录存在
+    const logDir = path.dirname(logFilePath);
+    if (!fs.existsSync(logDir)) {
+      fs.mkdirSync(logDir, { recursive: true });
+    }
+    
+    // 创建或追加到日志文件
+    logStream = fs.createWriteStream(logFilePath, { flags: 'a' });
+    console.log = function(...args) {
+      const message = `[${new Date().toISOString()}] [INFO] ${args.join(' ')}\n`;
+      process.stdout.write(message);
+      if (logStream) {
+        logStream.write(message);
+      }
+    };
+    
+    console.error = function(...args) {
+      const message = `[${new Date().toISOString()}] [ERROR] ${args.join(' ')}\n`;
+      process.stderr.write(message);
+      if (logStream) {
+        logStream.write(message);
+      }
+    };
+    
+    console.warn = function(...args) {
+      const message = `[${new Date().toISOString()}] [WARN] ${args.join(' ')}\n`;
+      process.stdout.write(message);
+      if (logStream) {
+        logStream.write(message);
+      }
+    };
+    
+    console.debug = function(...args) {
+      const message = `[${new Date().toISOString()}] [DEBUG] ${args.join(' ')}\n`;
+      process.stdout.write(message);
+      if (logStream) {
+        logStream.write(message);
+      }
+    };
+    
+    console.log(`Logging initialized. Log file: ${logFilePath}`);
+  } catch (error) {
+    console.error('Failed to initialize logging:', error);
+  }
+}
+
 let tray = null;
 let adminWindow = null;
 let serviceState = 'stopped';
@@ -16,6 +69,7 @@ let serverModuleVersion = 0;
 let serverModuleLoading = null;
 let isQuitting = false;
 let runtimeServerRoot = null;
+let startFailureCount = 0;
 
 const desktopPackageJson = JSON.parse(
   fs.readFileSync(path.join(__dirname, 'package.json'), 'utf8')
@@ -27,55 +81,153 @@ function resolveBaseServerRoot() {
 
 async function ensureRuntimeServerRoot() {
   if (runtimeServerRoot) {
+    console.log('Using cached runtimeServerRoot:', runtimeServerRoot);
     return runtimeServerRoot;
   }
 
   if (!app.isPackaged) {
+    console.log('App is not packaged, using development server root');
     runtimeServerRoot = resolveBaseServerRoot();
+    console.log('Development server root:', runtimeServerRoot);
     return runtimeServerRoot;
   }
 
+  console.log('App is packaged, setting up runtime server root');
+  console.log('process.resourcesPath:', process.resourcesPath);
+  console.log('app.getPath("userData"):', app.getPath('userData'));
+  
   const packagedRoot = path.join(process.resourcesPath, 'prompt-manager');
   const runtimeRoot = path.join(app.getPath('userData'), 'prompt-manager');
+  
+  console.log('packagedRoot:', packagedRoot);
+  console.log('runtimeRoot:', runtimeRoot);
 
   try {
-    await fs.promises.access(runtimeRoot, fs.constants.F_OK);
+    // 检查打包的资源目录是否存在
+    try {
+      await fs.promises.access(packagedRoot, fs.constants.F_OK);
+      console.log('Packaged root exists');
+    } catch (error) {
+      console.error('Packaged root does not exist:', packagedRoot);
+      throw new Error(`Packaged root not found: ${packagedRoot}`);
+    }
+    
+    // 检查运行时目录是否存在
+    let needsInstall = false;
+    try {
+      await fs.promises.access(runtimeRoot, fs.constants.F_OK);
+      console.log('Runtime root already exists');
+      
+      // 检查是否需要安装依赖
+      try {
+        await fs.promises.access(path.join(runtimeRoot, 'node_modules'), fs.constants.F_OK);
+        console.log('node_modules already exists in runtime root');
+      } catch (error) {
+        console.log('node_modules not found in runtime root, will install dependencies');
+        needsInstall = true;
+      }
+    } catch (error) {
+      console.log('Runtime root does not exist, creating and copying files');
+      await fs.promises.mkdir(runtimeRoot, { recursive: true });
+      console.log('Created runtime root directory');
+      
+      // 复制文件并显示进度
+      console.log('Copying files from packaged root to runtime root...');
+      await fs.promises.cp(packagedRoot, runtimeRoot, { recursive: true });
+      console.log('File copy completed');
+      needsInstall = true;
+    }
+    
+    // 如果需要安装依赖
+    if (needsInstall) {
+      console.log('Installing dependencies in runtime root');
+      try {
+        await installServerDependencies(runtimeRoot);
+        console.log('Dependencies installed successfully');
+      } catch (error) {
+        console.error('Failed to install dependencies:', error);
+        dialog.showErrorBox('依赖安装失败', `无法安装服务器依赖: ${error.message}\n\n请查看日志文件: ${logFilePath}`);
+        throw error;
+      }
+    }
   } catch (error) {
-    await fs.promises.mkdir(runtimeRoot, { recursive: true });
-    await fs.promises.cp(packagedRoot, runtimeRoot, { recursive: true });
+    console.error('Error in ensureRuntimeServerRoot:', error);
+    dialog.showErrorBox('服务器初始化失败', `无法设置服务器运行环境: ${error.message}\n\n请查看日志文件: ${logFilePath}`);
+    throw error;
   }
 
   runtimeServerRoot = runtimeRoot;
+  console.log('Final runtimeServerRoot:', runtimeServerRoot);
   return runtimeServerRoot;
 }
 
 async function loadServerModule(options = {}) {
-  if (options.forceReload) {
+  console.log('loadServerModule called with options:', options);
+  console.log('Current serviceState:', serviceState);
+  console.log('serverModule exists:', !!serverModule);
+  console.log('serverModuleLoading exists:', !!serverModuleLoading);
+  
+  // 如果强制重新加载或服务状态异常，则清理缓存
+  if (options.forceReload || serviceState === 'error') {
+    console.log('Forcing module reload, clearing cache');
     serverModule = null;
     serverModuleVersion += 1;
+    serverModuleLoading = null;
   }
 
   if (serverModule) {
+    console.log('Returning cached server module');
     return serverModule;
   }
 
   if (serverModuleLoading) {
+    console.log('Module loading in progress, returning promise');
     return serverModuleLoading;
   }
 
-  const serverRoot = await ensureRuntimeServerRoot();
-  const serverEntry = path.join(serverRoot, 'packages', 'server', 'server.js');
-  const entryUrl = pathToFileURL(serverEntry);
-  entryUrl.searchParams.set('v', String(serverModuleVersion));
-  serverModuleLoading = import(entryUrl.href)
-    .then((mod) => {
-      serverModule = mod;
-      return mod;
-    })
-    .finally(() => {
-      serverModuleLoading = null;
-    });
-  return serverModuleLoading;
+  try {
+    const serverRoot = await ensureRuntimeServerRoot();
+    console.log('Server root resolved to:', serverRoot);
+    
+    const serverEntry = path.join(serverRoot, 'packages', 'server', 'server.js');
+    console.log('Server entry file:', serverEntry);
+    
+    // 检查入口文件是否存在
+    try {
+      await fs.promises.access(serverEntry, fs.constants.F_OK);
+      console.log('Server entry file exists');
+    } catch (error) {
+      console.error('Server entry file does not exist:', serverEntry);
+      throw new Error(`Server entry file not found: ${serverEntry}`);
+    }
+    
+    const entryUrl = pathToFileURL(serverEntry);
+    entryUrl.searchParams.set('v', String(serverModuleVersion));
+    console.log('Entry URL:', entryUrl.href);
+    
+    serverModuleLoading = import(entryUrl.href)
+      .then((mod) => {
+        console.log('Module loaded successfully');
+        serverModule = mod;
+        return mod;
+      })
+      .catch((error) => {
+        console.error('Module loading failed:', error);
+        // 清理加载状态，以便下次重试
+        serverModuleLoading = null;
+        serverModule = null;
+        throw new Error(`Failed to load server module: ${error.message}`);
+      })
+      .finally(() => {
+        serverModuleLoading = null;
+      });
+      
+    return serverModuleLoading;
+  } catch (error) {
+    console.error('Error in loadServerModule:', error);
+    dialog.showErrorBox('模块加载失败', error.message);
+    throw error;
+  }
 }
 
 function getServerStatusLabel() {
@@ -94,29 +246,57 @@ function getServerStatusLabel() {
 }
 
 async function startService() {
+  console.log('startService called');
+  // 如果正在运行或正在启动，直接返回
   if (serviceState === 'running' || serviceState === 'starting') {
+    console.log('Service is already running or starting, returning');
     return;
   }
 
   serviceState = 'starting';
+  console.log('Service state set to starting');
   refreshTrayMenu();
 
   try {
-    const module = await loadServerModule();
+    console.log('Loading server module with force reload');
+    // 强制重新加载模块以确保获取最新状态
+    const module = await loadServerModule({ forceReload: true });
+    console.log('Server module loaded, starting server');
+    
+    if (!module || typeof module.startServer !== 'function') {
+      throw new Error('Invalid server module or missing startServer function');
+    }
+    
     await module.startServer();
+    console.log('Server started successfully');
     currentServerState = module.getServerState();
     serviceState = 'running';
+    startFailureCount = 0; // 重置失败计数
+    console.log('Service state set to running');
   } catch (error) {
     serviceState = 'error';
     currentServerState = null;
-    dialog.showErrorBox('服务启动失败', error?.message || String(error));
+    startFailureCount++;
+    
+    console.error('服务启动失败:', error);
+    console.error('Error stack:', error.stack);
+    
+    // 如果连续失败3次，提示用户重启应用
+    if (startFailureCount >= 3) {
+      console.log('Too many start failures, prompting for restart');
+      await promptForRestart();
+    } else {
+      dialog.showErrorBox('服务启动失败', `${error?.message || String(error)}\n\n请查看控制台日志获取更多信息。`);
+    }
   } finally {
+    console.log('Refreshing tray menu');
     refreshTrayMenu();
   }
 }
 
 async function stopService() {
-  if (serviceState !== 'running') {
+  // 如果服务未运行或正在停止，直接返回
+  if (serviceState !== 'running' && serviceState !== 'error') {
     return;
   }
 
@@ -125,10 +305,16 @@ async function stopService() {
 
   try {
     const module = await loadServerModule();
-    await module.stopServer();
+    if (module && typeof module.stopServer === 'function') {
+      await module.stopServer();
+    }
     currentServerState = null;
     serviceState = 'stopped';
+    
+    // 清理MCP会话和传输
+    console.log('Clearing MCP sessions and transports');
   } catch (error) {
+    console.error('停止服务失败:', error);
     dialog.showErrorBox('停止服务失败', error?.message || String(error));
     serviceState = 'error';
   } finally {
@@ -228,6 +414,16 @@ function refreshTrayMenu() {
       click: () => openAdminWindow(adminUrl)
     },
     { type: 'separator' },
+    {
+      label: '查看日志文件',
+      click: () => {
+        try {
+          shell.openPath(logFilePath);
+        } catch (error) {
+          dialog.showErrorBox('打开日志文件失败', error.message);
+        }
+      }
+    },
     {
       label: '检查更新',
       click: () => checkForUpdates()
@@ -242,6 +438,9 @@ function refreshTrayMenu() {
       click: async () => {
         isQuitting = true;
         await stopService();
+        if (logStream) {
+          logStream.end();
+        }
         app.quit();
       }
     }
@@ -358,43 +557,63 @@ async function checkForUpdates() {
 }
 
 async function performInPlaceUpgrade(version) {
+  console.log('Performing in-place upgrade to version:', version);
   const tarballUrl = `https://registry.npmjs.org/@becrafter/prompt-manager/-/@becrafter/prompt-manager-${version}.tgz`;
   const tmpDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'prompt-manager-upgrade-'));
   const tarballPath = path.join(tmpDir, `${version}.tgz`);
+  
+  console.log('Temporary directory:', tmpDir);
 
   try {
+    console.log('Downloading tarball from:', tarballUrl);
     const response = await fetch(tarballUrl);
     if (!response.ok) {
-      throw new Error('无法下载升级包');
+      throw new Error(`Failed to download tarball: ${response.status} ${response.statusText}`);
     }
 
     const buffer = Buffer.from(await response.arrayBuffer());
     await fs.promises.writeFile(tarballPath, buffer);
+    console.log('Tarball downloaded to:', tarballPath);
 
     await tar.x({ file: tarballPath, cwd: tmpDir });
     const extractedPath = path.join(tmpDir, 'package');
+    console.log('Tarball extracted to:', extractedPath);
 
     const serverRoot = await ensureRuntimeServerRoot();
     const examplesDir = path.join(serverRoot, 'examples', 'prompts');
     const examplesBackup = path.join(tmpDir, 'examples-prompts');
 
     if (await pathExists(examplesDir)) {
+      console.log('Backing up examples directory');
       await fs.promises.cp(examplesDir, examplesBackup, { recursive: true });
     }
 
+    console.log('Removing old server root');
     await fs.promises.rm(serverRoot, { recursive: true, force: true });
     await fs.promises.mkdir(serverRoot, { recursive: true });
+    
+    console.log('Copying extracted package to server root');
     await fs.promises.cp(extractedPath, serverRoot, { recursive: true });
 
     if (await pathExists(examplesBackup)) {
+      console.log('Restoring examples directory');
       const targetExamples = path.join(serverRoot, 'examples', 'prompts');
       await fs.promises.mkdir(path.dirname(targetExamples), { recursive: true });
       await fs.promises.cp(examplesBackup, targetExamples, { recursive: true });
     }
 
+    console.log('Installing server dependencies');
     await installServerDependencies(serverRoot);
+    
+    console.log('Reloading server module');
     await loadServerModule({ forceReload: true });
+    
+    console.log('Upgrade completed successfully');
+  } catch (error) {
+    console.error('Upgrade failed:', error);
+    throw error;
   } finally {
+    console.log('Cleaning up temporary directory');
     await fs.promises.rm(tmpDir, { recursive: true, force: true });
   }
 }
@@ -409,8 +628,36 @@ async function pathExists(targetPath) {
 }
 
 async function installServerDependencies(targetDir) {
+  console.log('Installing server dependencies in:', targetDir);
+  
+  // 检查 targetDir 是否存在 package.json
+  const pkgPath = path.join(targetDir, 'package.json');
+  try {
+    await fs.promises.access(pkgPath, fs.constants.F_OK);
+    console.log('package.json found in target directory');
+  } catch (error) {
+    console.error('package.json not found in target directory:', pkgPath);
+    throw new Error(`package.json not found in ${targetDir}`);
+  }
+  
+  // 检查 @modelcontextprotocol/sdk 是否在 dependencies 中
+  try {
+    const pkgContent = await fs.promises.readFile(pkgPath, 'utf8');
+    const pkg = JSON.parse(pkgContent);
+    if (!pkg.dependencies || !pkg.dependencies['@modelcontextprotocol/sdk']) {
+      console.warn('@modelcontextprotocol/sdk not found in dependencies, adding it');
+      pkg.dependencies = pkg.dependencies || {};
+      pkg.dependencies['@modelcontextprotocol/sdk'] = '^1.20.2';
+      await fs.promises.writeFile(pkgPath, JSON.stringify(pkg, null, 2), 'utf8');
+    }
+  } catch (error) {
+    console.error('Error checking/adding @modelcontextprotocol/sdk to package.json:', error);
+  }
+  
   const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm';
-  const args = ['install', '--omit=dev'];
+  const args = ['install', '--omit=dev', '--no-audit', '--no-fund'];
+  
+  console.log('Running npm install with args:', args);
 
   await new Promise((resolve, reject) => {
     const child = spawn(npmCommand, args, {
@@ -418,29 +665,56 @@ async function installServerDependencies(targetDir) {
       stdio: ['ignore', 'pipe', 'pipe']
     });
 
+    let stdout = '';
     let stderr = '';
+    
     child.stdout.on('data', (data) => {
-      console.log(`[npm] ${data.toString().trim()}`);
+      const output = data.toString().trim();
+      stdout += output;
+      console.log(`[npm stdout] ${output}`);
     });
+    
     child.stderr.on('data', (data) => {
-      stderr += data.toString();
-      console.error(`[npm] ${data.toString().trim()}`);
+      const output = data.toString().trim();
+      stderr += output;
+      console.error(`[npm stderr] ${output}`);
     });
 
     child.on('error', (error) => {
-      reject(error);
+      console.error('npm process error:', error);
+      reject(new Error(`Failed to start npm process: ${error.message}`));
     });
 
     child.on('close', (code) => {
+      console.log('npm process exited with code:', code);
       if (code === 0) {
+        console.log('npm install completed successfully');
         resolve();
       } else {
-        reject(new Error(`npm install failed with exit code ${code}: ${stderr}`));
+        const errorMsg = `npm install failed with exit code ${code}: ${stderr}`;
+        console.error(errorMsg);
+        reject(new Error(errorMsg));
       }
     });
   });
 }
 
+async function promptForRestart() {
+  const { response } = await dialog.showMessageBox({
+    type: 'error',
+    buttons: ['重启应用', '取消'],
+    defaultId: 0,
+    cancelId: 1,
+    message: '服务启动失败',
+    detail: '多次尝试启动服务均失败，建议重启应用以恢复正常状态。'
+  });
+
+  if (response === 0) {
+    app.relaunch();
+    app.exit(0);
+  }
+}
+
 async function showAboutDialog() {
   const serviceVersion = await getCurrentServiceVersion();
   const lines = [
@@ -460,19 +734,32 @@ async function showAboutDialog() {
 }
 
 app.whenReady().then(async () => {
+  // 初始化日志
+  initLogStream();
   console.log('App is packaged:', app.isPackaged);
   console.log('App data path:', app.getPath('userData'));
   console.log('Resources path:', process.resourcesPath);
   console.log('__dirname:', __dirname);
+  console.log('Process platform:', process.platform);
+  console.log('Process version:', process.version);
+  console.log('Electron version:', process.versions.electron);
   
   Menu.setApplicationMenu(null);
   if (process.platform === 'darwin') {
     app.dock.hide();
   }
 
-  await ensureRuntimeServerRoot();
-  ensureTray();
-  await startService();
+  try {
+    await ensureRuntimeServerRoot();
+    console.log('Runtime server root ensured successfully');
+    ensureTray();
+    console.log('System tray ensured successfully');
+    await startService();
+    console.log('Service started successfully');
+  } catch (error) {
+    console.error('Error during app initialization:', error);
+    dialog.showErrorBox('应用初始化失败', `启动过程中发生错误: ${error.message}\n\n请查看日志文件: ${logFilePath}`);
+  }
 });
 
 app.on('window-all-closed', (event) => {
@@ -486,6 +773,9 @@ app.on('before-quit', async (event) => {
   event.preventDefault();
   isQuitting = true;
   await stopService();
+  if (logStream) {
+    logStream.end();
+  }
   app.quit();
 });