@becrafter/prompt-manager 0.1.12 → 0.1.15

package/app/desktop/package.json

@@ -0,0 +1,119 @@
+{
+  "name": "@becrafter/prompt-desktop",
+  "version": "0.1.15",
+  "description": "Menu bar desktop wrapper for @becrafter/prompt-manager",
+  "author": "BeCrafter",
+  "homepage": "https://github.com/BeCrafter/prompt-manager",
+  "private": true,
+  "main": "main.js",
+  "scripts": {
+    "dev": "electron .",
+    "start": "npm run dev",
+    "prebuild": "cd ../.. && npm run build:icons",
+    "build": "electron-builder"
+  },
+  "devDependencies": {
+    "@electron/rebuild": "^4.0.2",
+    "electron": "39.0.0",
+    "electron-builder": "^24.13.3",
+    "electron-rebuild": "^3.2.9"
+  },
+  "dependencies": {
+    "@becrafter/prompt-manager-core": "file:../../packages/server",
+    "@modelcontextprotocol/sdk": "^1.20.2",
+    "cors": "^2.8.5",
+    "dotenv": "^17.2.3",
+    "express": "^5.1.0",
+    "fs-extra": "^11.2.0",
+    "http-proxy-middleware": "^3.0.5",
+    "js-yaml": "^4.1.0",
+    "multer": "^2.0.2",
+    "node-pty": "^1.0.0",
+    "tar": "^7.5.2",
+    "ws": "^8.18.0",
+    "yaml": "^2.4.1",
+    "zod": "^3.23.8"
+  },
+  "build": {
+    "appId": "com.becrafter.promptserver",
+    "productName": "Prompt Manager",
+    "icon": "assets/icons/icon.png",
+    "npmRebuild": true,
+    "files": [
+      "**/*",
+      "assets/**/*",
+      "!docs",
+      "!.npmignore",
+      "!assets/**/*.1.png",
+      "!node_modules/**/test/**",
+      "!node_modules/**/example/**",
+      "!node_modules/**/*.md",
+      "!node_modules/**/LICENSE",
+      {
+        "from": "../../packages/web/",
+        "to": "web/",
+        "filter": [
+          "**/*"
+        ]
+      }
+    ],
+    "directories": {
+      "output": "../../dist",
+      "buildResources": "assets"
+    },
+    "extraResources": [
+      {
+        "from": "../../packages/resources/tools/",
+        "to": "runtime/toolbox/",
+        "filter": [
+          "**/*"
+        ]
+      },
+      {
+        "from": "../../env.example",
+        "to": "runtime/.env"
+      },
+      {
+        "from": "../../packages/server/configs/",
+        "to": "runtime/configs/"
+      }
+    ],
+    "mac": {
+      "category": "public.app-category.productivity",
+      "icon": "assets/icons/icon.icns",
+      "target": [
+        {
+          "target": "dmg",
+          "arch": [
+            "x64",
+            "arm64"
+          ]
+        }
+      ]
+    },
+    "win": {
+      "target": [
+        {
+          "target": "nsis",
+          "arch": [
+            "x64",
+            "arm64"
+          ]
+        }
+      ],
+      "icon": "assets/icons/icon.ico"
+    },
+    "linux": {
+      "target": [
+        "AppImage",
+        "tar.xz"
+      ],
+      "category": "Utility",
+      "maintainer": "support@becrafter.com",
+      "synopsis": "Menu bar desktop wrapper for Prompt Manager",
+      "description": "Prompt Manager is a desktop application that provides a menu bar interface for managing prompts via MCP (Model Context Protocol).",
+      "desktop": {},
+      "artifactName": "${productName}-${version}.${ext}"
+    }
+  }
+}

package/app/desktop/preload.js

@@ -0,0 +1,7 @@
+const { contextBridge, ipcRenderer } = require('electron');
+
+// 安全地暴露API到渲染进程
+contextBridge.exposeInMainWorld('electronAPI', {
+  sendAboutWindowClick: (data) => ipcRenderer.send('about-window-click', data),
+  onAboutWindowClick: (callback) => ipcRenderer.on('about-window-click-response', callback)
+});

package/app/desktop/src/core/error-handler.js

@@ -0,0 +1,108 @@
+const { dialog } = require('electron');
+
+class ErrorHandler {
+  constructor(logger) {
+    this.logger = logger;
+    this.errorMessages = {
+      MODULE_LOAD_FAILED: '模块加载失败',
+      SERVER_INIT_FAILED: '服务器初始化失败',
+      DEPENDENCY_INSTALL_FAILED: '依赖安装失败',
+      SERVICE_START_FAILED: '服务启动失败',
+      SERVICE_STOP_FAILED: '服务停止失败',
+      UPGRADE_FAILED: '升级失败',
+      ICON_LOAD_FAILED: '图标加载失败'
+    };
+  }
+
+  handleError(errorType, error, context = {}) {
+    const errorMessage = this.formatErrorMessage(errorType, error, context);
+    
+    // 记录错误日志
+    this.logger.error(errorMessage, error, {
+      errorType,
+      context,
+      timestamp: new Date().toISOString()
+    });
+
+    // 显示用户友好的错误提示
+    this.showErrorDialog(errorType, errorMessage, context);
+    
+    return errorMessage;
+  }
+
+  formatErrorMessage(errorType, error, context) {
+    const baseMessage = this.errorMessages[errorType] || '发生未知错误';
+    const detailMessage = error?.message || String(error);
+    
+    let fullMessage = `${baseMessage}: ${detailMessage}`;
+    
+    if (context.logFilePath) {
+      fullMessage += `\n\n请查看日志文件: ${context.logFilePath}`;
+    }
+    
+    return fullMessage;
+  }
+
+  showErrorDialog(errorType, message, context = {}) {
+    const options = {
+      type: 'error',
+      title: '错误',
+      message: message.split('\n')[0], // 第一行作为标题
+      detail: message.split('\n').slice(1).join('\n') // 其余作为详情
+    };
+
+    // 特殊错误类型的自定义处理
+    switch (errorType) {
+      case 'SERVICE_START_FAILED':
+        if (context.failureCount >= 3) {
+          options.buttons = ['重启应用', '取消'];
+          options.defaultId = 0;
+          options.cancelId = 1;
+          options.message = '服务启动失败';
+          options.detail = '多次尝试启动服务均失败，建议重启应用以恢复正常状态。';
+        }
+        break;
+        
+      case 'DEPENDENCY_INSTALL_FAILED':
+        options.message = '依赖安装失败';
+        options.detail = `无法安装服务器依赖: ${context.detail || '未知错误'}\n\n请查看日志文件获取更多信息。`;
+        break;
+    }
+
+    return dialog.showMessageBox(options);
+  }
+
+  async handleServiceStartError(error, failureCount, logFilePath) {
+    const context = { failureCount, logFilePath };
+    
+    if (failureCount >= 3) {
+      const { response } = await this.showErrorDialog('SERVICE_START_FAILED', '', context);
+      return response === 0; // 返回是否需要重启
+    } else {
+      this.handleError('SERVICE_START_FAILED', error, context);
+      return false;
+    }
+  }
+
+  handleModuleLoadError(error, context = {}) {
+    return this.handleError('MODULE_LOAD_FAILED', error, context);
+  }
+
+  handleServerInitError(error, context = {}) {
+    return this.handleError('SERVER_INIT_FAILED', error, context);
+  }
+
+  handleDependencyInstallError(error, context = {}) {
+    return this.handleError('DEPENDENCY_INSTALL_FAILED', error, context);
+  }
+
+  handleUpgradeError(error, context = {}) {
+    return this.handleError('UPGRADE_FAILED', error, context);
+  }
+
+  handleIconLoadError(error, context = {}) {
+    return this.handleError('ICON_LOAD_FAILED', error, context);
+  }
+}
+
+module.exports = ErrorHandler;

package/app/desktop/src/core/event-emitter.js

@@ -0,0 +1,84 @@
+/**
+ * 事件发射器基类
+ * 提供标准化的事件处理功能
+ */
+
+class EventEmitter {
+  constructor() {
+    this.listeners = {};
+  }
+
+  /**
+   * 添加事件监听器
+   * @param {string} event - 事件名称
+   * @param {function} listener - 监听器函数
+   */
+  on(event, listener) {
+    if (!this.listeners[event]) {
+      this.listeners[event] = [];
+    }
+    this.listeners[event].push(listener);
+  }
+
+  /**
+   * 移除事件监听器
+   * @param {string} event - 事件名称
+   * @param {function} listener - 监听器函数
+   */
+  off(event, listener) {
+    if (!this.listeners[event]) return;
+    
+    const index = this.listeners[event].indexOf(listener);
+    if (index > -1) {
+      this.listeners[event].splice(index, 1);
+    }
+  }
+
+  /**
+   * 发射事件
+   * @param {string} event - 事件名称
+   * @param {...any} args - 传递给监听器的参数
+   */
+  emit(event, ...args) {
+    if (!this.listeners[event]) return;
+    
+    this.listeners[event].forEach(listener => {
+      try {
+        listener(...args);
+      } catch (error) {
+        console.error(`Error in event listener for ${event}:`, error);
+      }
+    });
+  }
+
+  /**
+   * 移除指定事件的所有监听器
+   * @param {string} event - 事件名称
+   */
+  removeAllListeners(event) {
+    if (event) {
+      delete this.listeners[event];
+    } else {
+      this.listeners = {};
+    }
+  }
+
+  /**
+   * 获取指定事件的监听器数量
+   * @param {string} event - 事件名称
+   * @returns {number} - 监听器数量
+   */
+  listenerCount(event) {
+    return this.listeners[event] ? this.listeners[event].length : 0;
+  }
+
+  /**
+   * 获取所有事件名称
+   * @returns {string[]} - 事件名称数组
+   */
+  eventNames() {
+    return Object.keys(this.listeners);
+  }
+}
+
+module.exports = EventEmitter;

package/app/desktop/src/core/logger.js

@@ -0,0 +1,130 @@
+const fs = require('fs');
+const path = require('path');
+const { app } = require('electron');
+
+class Logger {
+  constructor(options = {}) {
+    this.logFilePath = options.logFilePath || path.join(app.getPath('userData'), 'prompt-manager-desktop.log');
+    this.debugEnabled = options.debugEnabled || false;
+    this.logStream = null;
+    this.initialized = false;
+  }
+
+  async initialize() {
+    if (this.initialized) return;
+
+    try {
+      const logDir = path.dirname(this.logFilePath);
+      if (!fs.existsSync(logDir)) {
+        fs.mkdirSync(logDir, { recursive: true });
+      }
+
+      this.logStream = fs.createWriteStream(this.logFilePath, { flags: 'a' });
+      this.initialized = true;
+      
+      this.info('Logging initialized', { logFile: this.logFilePath });
+      this.info(`Debug logging is ${this.debugEnabled ? 'enabled' : 'disabled'}`);
+    } catch (error) {
+      console.error('Failed to initialize logging:', error);
+      throw error;
+    }
+  }
+
+  formatMessage(level, message, meta = {}) {
+    const timestamp = new Date().toISOString();
+    const metaStr = Object.keys(meta).length ? ` ${JSON.stringify(meta)}` : '';
+    return `[${timestamp}] [${level.toUpperCase()}] ${message}${metaStr}\n`;
+  }
+
+  write(level, message, meta = {}) {
+    if (!this.initialized && level !== 'error') return;
+
+    const formattedMessage = this.formatMessage(level, message, meta);
+    
+    try {
+      // 始终输出到控制台，但先检查流是否可写
+      if (level === 'error') {
+        if (process.stderr && process.stderr.writable) {
+          process.stderr.write(formattedMessage);
+        } else {
+          // 如果 stderr 不可用，使用 console.error 作为后备
+          console.error(formattedMessage.trim());
+        }
+      } else {
+        if (process.stdout && process.stdout.writable) {
+          process.stdout.write(formattedMessage);
+        } else {
+          // 如果 stdout 不可用，使用 console.log 作为后备
+          console.log(formattedMessage.trim());
+        }
+      }
+
+      // 写入日志文件，检查流是否可写
+      if (this.logStream && this.logStream.writable) {
+        const shouldWrite = level === 'error' || 
+                           (this.debugEnabled && ['debug', 'warn'].includes(level)) ||
+                           (!this.debugEnabled && ['info'].includes(level));
+        
+        if (shouldWrite) {
+          this.logStream.write(formattedMessage);
+        }
+      }
+    } catch (error) {
+      // 静默处理写入错误，避免应用崩溃
+      // 只在调试模式下记录错误
+      if (this.debugEnabled) {
+        try {
+          console.error(`Logger write error: ${error.message}`);
+        } catch (e) {
+          // 如果连 console.error 都失败，就放弃
+        }
+      }
+    }
+  }
+
+  info(message, meta = {}) {
+    this.write('info', message, meta);
+  }
+
+  error(message, error = null, meta = {}) {
+    const errorMeta = { ...meta };
+    if (error) {
+      errorMeta.error = error.message || String(error);
+      errorMeta.stack = error.stack;
+    }
+    this.write('error', message, errorMeta);
+  }
+
+  warn(message, meta = {}) {
+    this.write('warn', message, meta);
+  }
+
+  debug(message, meta = {}) {
+    if (this.debugEnabled) {
+      this.write('debug', message, meta);
+    }
+  }
+
+  setDebugEnabled(enabled) {
+    this.debugEnabled = enabled;
+    this.info(`Debug logging ${enabled ? 'enabled' : 'disabled'}`);
+  }
+
+  getLogFilePath() {
+    return this.logFilePath;
+  }
+
+  async close() {
+    if (this.logStream) {
+      return new Promise((resolve) => {
+        this.logStream.end(() => {
+          this.logStream = null;
+          this.initialized = false;
+          resolve();
+        });
+      });
+    }
+  }
+}
+
+module.exports = Logger;

package/app/desktop/src/core/state-manager.js

@@ -0,0 +1,125 @@
+const { app } = require('electron');
+
+/**
+ * 应用状态管理器
+ * 遵循单一职责原则，集中管理应用状态
+ */
+
+class AppState {
+  constructor() {
+    this.state = {
+      service: 'stopped', // stopped | starting | running | stopping | error
+      server: null,
+      module: null,
+      moduleVersion: 0,
+      moduleLoading: null,
+      isQuitting: false,
+      runtimeRoot: null,
+      failureCount: 0,
+      debugEnabled: false
+    };
+    
+    this.clickCounters = {
+      aboutButton: { count: 0, lastTime: 0 },
+      aboutWindow: { count: 0, lastTime: 0 }
+    };
+    
+    this.ui = {
+      tray: null,
+      adminWindow: null,
+      aboutWindow: null
+    };
+  }
+
+  get(key) {
+    return key ? this.state[key] : { ...this.state };
+  }
+
+  set(key, value) {
+    if (typeof key === 'object') {
+      Object.assign(this.state, key);
+    } else {
+      this.state[key] = value;
+    }
+    return this;
+  }
+
+  getServiceStatus() {
+    const statusMap = {
+      running: '运行中',
+      starting: '启动中',
+      stopping: '停止中',
+      error: '启动失败',
+      stopped: '已停止'
+    };
+    return statusMap[this.state.service] || '未知状态';
+  }
+
+  getClickCounter(type) {
+    return this.clickCounters[type] || { count: 0, lastTime: 0 };
+  }
+
+  updateClickCounter(type, increment = 1) {
+    const now = Date.now();
+    const counter = this.clickCounters[type];
+    
+    if (now - counter.lastTime > 3000) {
+      counter.count = 0;
+    }
+    
+    counter.count += increment;
+    counter.lastTime = now;
+    
+    return counter.count;
+  }
+
+  resetClickCounter(type) {
+    this.clickCounters[type] = { count: 0, lastTime: 0 };
+    return this;
+  }
+
+  getUI(component) {
+    return component ? this.ui[component] : { ...this.ui };
+  }
+
+  setUI(component, instance) {
+    this.ui[component] = instance;
+    return this;
+  }
+
+  isServiceRunning() {
+    return this.state.service === 'running';
+  }
+
+  isServiceStarting() {
+    return this.state.service === 'starting';
+  }
+
+  isServiceStopping() {
+    return this.state.service === 'stopping';
+  }
+
+  canStartService() {
+    return ['stopped', 'error'].includes(this.state.service);
+  }
+
+  canStopService() {
+    return ['running', 'error'].includes(this.state.service);
+  }
+
+  incrementFailureCount() {
+    this.state.failureCount++;
+    return this.state.failureCount;
+  }
+
+  resetFailureCount() {
+    this.state.failureCount = 0;
+    return this;
+  }
+
+  shouldPromptForRestart() {
+    return this.state.failureCount >= 3;
+  }
+}
+
+module.exports = AppState;