@hirohsu/user-web-feedback 2.8.15 → 2.8.17

package/dist/index.cjs

@@ -20517,7 +20517,9 @@ var init_stdio = __esm({
 // src/utils/crypto-helper.ts
 function loadPasswordFromConfig() {
   try {
-    const configPath = import_path.default.join(process.cwd(), "data", "config.json");
+    const envDir = process.env["MCP_DATA_DIR"];
+    const dataDir = envDir || import_path.default.join(import_os.default.homedir(), ".user-web-feedback", "data");
+    const configPath = import_path.default.join(dataDir, "config.json");
     if (import_fs.default.existsSync(configPath)) {
       const configData = import_fs.default.readFileSync(configPath, "utf8");
       const config2 = JSON.parse(configData);
@@ -20609,7 +20611,7 @@ function maskApiKey(apiKey) {
   const masked = "*".repeat(maskedLength);
   return `${prefix}${masked}${suffix}`;
 }
-var import_crypto, import_fs, import_path, ALGORITHM, IV_LENGTH, SALT, encryptionKeyLogged, cachedPassword;
+var import_crypto, import_fs, import_path, import_os, ALGORITHM, IV_LENGTH, SALT, encryptionKeyLogged, cachedPassword;
 var init_crypto_helper = __esm({
   "src/utils/crypto-helper.ts"() {
     "use strict";
@@ -20617,6 +20619,7 @@ var init_crypto_helper = __esm({
     import_crypto = __toESM(require("crypto"), 1);
     import_fs = __toESM(require("fs"), 1);
     import_path = __toESM(require("path"), 1);
+    import_os = __toESM(require("os"), 1);
     init_logger();
     ALGORITHM = "aes-256-gcm";
     IV_LENGTH = 16;
@@ -20698,6 +20701,11 @@ __export(database_exports, {
   updatePromptConfigs: () => updatePromptConfigs,
   updateUserPreferences: () => updateUserPreferences
 });
+function getGlobalDataDir() {
+  const envDir = process.env["MCP_DATA_DIR"];
+  if (envDir) return envDir;
+  return import_path2.default.join(import_os2.default.homedir(), ".user-web-feedback", "data");
+}
 function hashPrompt(prompt) {
   return import_crypto2.default.createHash("sha256").update(prompt.trim()).digest("hex").substring(0, 16);
 }
@@ -22560,7 +22568,7 @@ function cleanupExpiredPendingResponses() {
     `).run(now, deliveredCutoff);
   return result.changes;
 }
-var import_better_sqlite3, import_path2, import_fs2, import_crypto2, DB_DIR, DB_PATH, db, SYSTEM_PROMPT_VERSIONS, CURRENT_PROMPT_VERSION, DEFAULT_PROMPT_CONFIGS;
+var import_better_sqlite3, import_path2, import_fs2, import_os2, import_crypto2, DB_DIR, DB_PATH, db, SYSTEM_PROMPT_VERSIONS, CURRENT_PROMPT_VERSION, DEFAULT_PROMPT_CONFIGS;
 var init_database = __esm({
   "src/utils/database.ts"() {
     "use strict";
@@ -22568,10 +22576,11 @@ var init_database = __esm({
     import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
     import_path2 = __toESM(require("path"), 1);
     import_fs2 = __toESM(require("fs"), 1);
+    import_os2 = __toESM(require("os"), 1);
     import_crypto2 = __toESM(require("crypto"), 1);
     init_crypto_helper();
     init_logger();
-    DB_DIR = import_path2.default.join(process.cwd(), "data");
+    DB_DIR = getGlobalDataDir();
     DB_PATH = import_path2.default.join(DB_DIR, "feedback.db");
     db = null;
     SYSTEM_PROMPT_VERSIONS = {
@@ -44205,7 +44214,7 @@ var require_application = __commonJS({
     };
     app.del = deprecate.function(app.delete, "app.del: Use app.delete instead");
     app.render = function render(name, options, callback) {
-      var cache2 = this.cache;
+      var cache3 = this.cache;
       var done = callback;
       var engines = this.engines;
       var opts = options;
@@ -44224,7 +44233,7 @@ var require_application = __commonJS({
         renderOptions.cache = this.enabled("view cache");
       }
       if (renderOptions.cache) {
-        view = cache2[name];
+        view = cache3[name];
       }
       if (!view) {
         var View2 = this.get("view");
@@ -44240,7 +44249,7 @@ var require_application = __commonJS({
           return done(err);
         }
         if (renderOptions.cache) {
-          cache2[name] = view;
+          cache3[name] = view;
         }
       }
       tryRender(view, renderOptions, done);
@@ -47732,7 +47741,7 @@ var require_supports_color = __commonJS({
   "node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js"(exports2, module2) {
     "use strict";
     init_cjs_shims();
-    var os3 = require("os");
+    var os6 = require("os");
     var tty = require("tty");
     var hasFlag = require_has_flag();
     var { env } = process;
@@ -47780,7 +47789,7 @@ var require_supports_color = __commonJS({
         return min;
       }
       if (process.platform === "win32") {
-        const osRelease = os3.release().split(".");
+        const osRelease = os6.release().split(".");
         if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -80049,14 +80058,14 @@ var require_is_wsl = __commonJS({
   "node_modules/.pnpm/is-wsl@2.2.0/node_modules/is-wsl/index.js"(exports2, module2) {
     "use strict";
     init_cjs_shims();
-    var os3 = require("os");
+    var os6 = require("os");
     var fs9 = require("fs");
     var isDocker2 = require_is_docker();
     var isWsl2 = () => {
       if (process.platform !== "linux") {
         return false;
       }
-      if (os3.release().toLowerCase().includes("microsoft")) {
+      if (os6.release().toLowerCase().includes("microsoft")) {
         if (isDocker2()) {
           return false;
         }
@@ -81688,8 +81697,8 @@ var require_untildify = __commonJS({
   "node_modules/.pnpm/untildify@4.0.0/node_modules/untildify/index.js"(exports2, module2) {
     "use strict";
     init_cjs_shims();
-    var os3 = require("os");
-    var homeDirectory = os3.homedir();
+    var os6 = require("os");
+    var homeDirectory = os6.homedir();
     module2.exports = (pathWithTilde) => {
       if (typeof pathWithTilde !== "string") {
         throw new TypeError(`Expected a string, got ${typeof pathWithTilde}`);
@@ -81727,16 +81736,16 @@ async function defaultBrowserId() {
   }
   return bundleId;
 }
-var import_os, import_fs6, import_bplist_parser, import_untildify, macOsVersion, filePath;
+var import_os4, import_fs6, import_bplist_parser, import_untildify, macOsVersion, filePath;
 var init_default_browser_id = __esm({
   "node_modules/.pnpm/default-browser-id@3.0.0/node_modules/default-browser-id/index.js"() {
     "use strict";
     init_cjs_shims();
-    import_os = __toESM(require("os"), 1);
+    import_os4 = __toESM(require("os"), 1);
     import_fs6 = require("fs");
     import_bplist_parser = __toESM(require_bplistParser(), 1);
     import_untildify = __toESM(require_untildify(), 1);
-    macOsVersion = Number(import_os.default.release().split(".")[0]);
+    macOsVersion = Number(import_os4.default.release().split(".")[0]);
     filePath = (0, import_untildify.default)(macOsVersion >= 14 ? "~/Library/Preferences/com.apple.LaunchServices/com.apple.launchservices.secure.plist" : "~/Library/Preferences/com.apple.LaunchServices.plist");
   }
 });
@@ -82585,7 +82594,7 @@ var require_kill = __commonJS({
   "node_modules/.pnpm/execa@5.1.1/node_modules/execa/lib/kill.js"(exports2, module2) {
     "use strict";
     init_cjs_shims();
-    var os3 = require("os");
+    var os6 = require("os");
     var onExit2 = require_signal_exit();
     var DEFAULT_FORCE_KILL_TIMEOUT2 = 1e3 * 5;
     var spawnedKill2 = (kill, signal = "SIGTERM", options = {}) => {
@@ -82609,7 +82618,7 @@ var require_kill = __commonJS({
       return isSigterm2(signal) && forceKillAfterTimeout !== false && killResult;
     };
     var isSigterm2 = (signal) => {
-      return signal === os3.constants.signals.SIGTERM || typeof signal === "string" && signal.toUpperCase() === "SIGTERM";
+      return signal === os6.constants.signals.SIGTERM || typeof signal === "string" && signal.toUpperCase() === "SIGTERM";
     };
     var getForceKillAfterTimeout2 = ({ forceKillAfterTimeout = true }) => {
       if (forceKillAfterTimeout === true) {
@@ -85654,7 +85663,7 @@ var require_main2 = __commonJS({
     init_cjs_shims();
     var fs9 = require("fs");
     var path9 = require("path");
-    var os3 = require("os");
+    var os6 = require("os");
     var crypto5 = require("crypto");
     var packageJson = require_package2();
     var version2 = packageJson.version;
@@ -85777,7 +85786,7 @@ var require_main2 = __commonJS({
       return null;
     }
     function _resolveHome(envPath) {
-      return envPath[0] === "~" ? path9.join(os3.homedir(), envPath.slice(1)) : envPath;
+      return envPath[0] === "~" ? path9.join(os6.homedir(), envPath.slice(1)) : envPath;
     }
     function _configVault(options) {
       const debug = Boolean(options && options.debug);
@@ -88365,6 +88374,10 @@ var PortManager = class {
   PORT_RANGE_START = 5e3;
   PORT_RANGE_END = 5099;
   MAX_RETRIES = 20;
+  BROWSER_UNSAFE_PORTS = /* @__PURE__ */ new Set([
+    5060,
+    5061
+  ]);
   /**
    * 檢查連接埠是否可用（增強版本）
    */
@@ -88418,6 +88431,10 @@ var PortManager = class {
    */
   async resolvePortConflict(port) {
     logger.info(`\u6AA2\u67E5\u9023\u63A5\u57E0 ${port} \u662F\u5426\u53EF\u7528`);
+    if (this.BROWSER_UNSAFE_PORTS.has(port)) {
+      logger.warn(`\u9023\u63A5\u57E0 ${port} \u662F\u700F\u89BD\u5668\u4E0D\u5B89\u5168\u7AEF\u53E3\uFF0C\u81EA\u52D5\u5C0B\u627E\u66FF\u4EE3`);
+      return await this.findAlternativePort(port);
+    }
     if (await this.isPortAvailable(port)) {
       logger.info(`\u9023\u63A5\u57E0 ${port} \u53EF\u7528\uFF0C\u76F4\u63A5\u4F7F\u7528`);
       return port;
@@ -88435,6 +88452,10 @@ var PortManager = class {
       if (port > 65535) {
         break;
       }
+      if (this.BROWSER_UNSAFE_PORTS.has(port)) {
+        logger.debug(`\u9023\u63A5\u57E0 ${port} \u662F\u700F\u89BD\u5668\u4E0D\u5B89\u5168\u7AEF\u53E3\uFF0C\u8DF3\u904E`);
+        continue;
+      }
       logger.debug(`\u5617\u8A66\u9023\u63A5\u57E0 ${port}...`);
       if (await this.isPortAvailable(port)) {
         logger.info(`\u627E\u5230\u53EF\u7528\u9023\u63A5\u57E0: ${port}`);
@@ -88449,16 +88470,21 @@ var PortManager = class {
    */
   async findAvailablePort(preferredPort) {
     if (preferredPort) {
-      logger.debug(`\u6AA2\u67E5\u9996\u9078\u9023\u63A5\u57E0: ${preferredPort}`);
-      const available = await this.isPortAvailable(preferredPort);
-      if (available) {
-        logger.info(`\u4F7F\u7528\u9996\u9078\u9023\u63A5\u57E0: ${preferredPort}`);
-        return preferredPort;
+      if (this.BROWSER_UNSAFE_PORTS.has(preferredPort)) {
+        logger.warn(`\u9996\u9078\u9023\u63A5\u57E0 ${preferredPort} \u662F\u700F\u89BD\u5668\u4E0D\u5B89\u5168\u7AEF\u53E3\uFF0C\u8DF3\u904E`);
       } else {
-        logger.warn(`\u9996\u9078\u9023\u63A5\u57E0 ${preferredPort} \u4E0D\u53EF\u7528\uFF0C\u5C0B\u627E\u5176\u4ED6\u9023\u63A5\u57E0...`);
+        logger.debug(`\u6AA2\u67E5\u9996\u9078\u9023\u63A5\u57E0: ${preferredPort}`);
+        const available = await this.isPortAvailable(preferredPort);
+        if (available) {
+          logger.info(`\u4F7F\u7528\u9996\u9078\u9023\u63A5\u57E0: ${preferredPort}`);
+          return preferredPort;
+        } else {
+          logger.warn(`\u9996\u9078\u9023\u63A5\u57E0 ${preferredPort} \u4E0D\u53EF\u7528\uFF0C\u5C0B\u627E\u5176\u4ED6\u9023\u63A5\u57E0...`);
+        }
       }
     }
     for (let port = this.PORT_RANGE_START; port <= this.PORT_RANGE_END; port++) {
+      if (this.BROWSER_UNSAFE_PORTS.has(port)) continue;
       logger.debug(`\u6AA2\u67E5\u9023\u63A5\u57E0: ${port}`);
       if (await this.isPortAvailable(port)) {
         logger.info(`\u627E\u5230\u53EF\u7528\u9023\u63A5\u57E0: ${port}`);
@@ -88467,6 +88493,7 @@ var PortManager = class {
     }
     for (let i = 0; i < this.MAX_RETRIES; i++) {
       const randomPort = Math.floor(Math.random() * (65535 - 1024) + 1024);
+      if (this.BROWSER_UNSAFE_PORTS.has(randomPort)) continue;
       logger.debug(`\u5617\u8A66\u96A8\u6A5F\u9023\u63A5\u57E0: ${randomPort}`);
       if (await this.isPortAvailable(randomPort)) {
         logger.info(`\u627E\u5230\u96A8\u6A5F\u53EF\u7528\u9023\u63A5\u57E0: ${randomPort}`);
@@ -89610,6 +89637,7 @@ function getPackageVersion() {
 init_cjs_shims();
 var import_fs5 = require("fs");
 var import_path5 = __toESM(require("path"), 1);
+var import_os3 = __toESM(require("os"), 1);
 init_logger();
 var DEFAULT_LOCK_FILENAME = ".user-feedback.lock";
 var DEFAULT_HEALTH_CHECK_TIMEOUT = 3e3;
@@ -89619,7 +89647,8 @@ var InstanceLock = class {
     if (this.lockFilePath) {
       return this.lockFilePath;
     }
-    const dataDir = import_path5.default.resolve(process.cwd(), "data");
+    const envDir = process.env["MCP_DATA_DIR"];
+    const dataDir = envDir || import_path5.default.join(import_os3.default.homedir(), ".user-web-feedback", "data");
     if (!(0, import_fs5.existsSync)(dataDir)) {
       (0, import_fs5.mkdirSync)(dataDir, { recursive: true });
     }
@@ -89889,6 +89918,424 @@ var SelfProbeService = class {
 // src/server/web-server.ts
 init_crypto_helper();
 init_ai_service();
+
+// src/utils/ai-provider-factory.ts
+init_cjs_shims();
+init_database();
+init_logger();
+
+// src/utils/api-provider.ts
+init_cjs_shims();
+init_dist();
+init_database();
+init_logger();
+init_mcp_client_manager();
+init_prompt_aggregator2();
+var MAX_RETRIES2 = 3;
+var RETRY_DELAYS2 = [1e3, 2e3, 4e3];
+var cache2 = /* @__PURE__ */ new Map();
+var CACHE_TTL3 = 5 * 60 * 1e3;
+function getProviderFromUrl2(apiUrl) {
+  if (!apiUrl) return "google";
+  const normalizedUrl = apiUrl.toLowerCase();
+  if (normalizedUrl.includes("api.openai.com")) return "openai";
+  if (normalizedUrl.includes("api.anthropic.com")) return "anthropic";
+  if (normalizedUrl.includes("generativelanguage.googleapis.com")) return "google";
+  if (normalizedUrl.includes("nvidia.com")) return "nvidia";
+  if (normalizedUrl.includes("bigmodel.cn") || normalizedUrl.includes("z.ai")) return "zai";
+  return "openai";
+}
+var APIProvider = class {
+  getName() {
+    return "API Provider";
+  }
+  getMode() {
+    return "api";
+  }
+  async isAvailable() {
+    const settings = getAISettings();
+    return !!(settings?.apiKey && settings.apiKey !== "YOUR_API_KEY_HERE");
+  }
+  async generateReply(request) {
+    try {
+      const cacheKey = `${request.aiMessage}:${request.userContext || ""}`;
+      if (!request.toolResults) {
+        const cached2 = cache2.get(cacheKey);
+        if (cached2 && Date.now() - cached2.timestamp < CACHE_TTL3) {
+          logger.debug("[APIProvider] \u4F7F\u7528\u5FEB\u53D6\u56DE\u8986");
+          return { success: true, reply: cached2.reply, mode: "api" };
+        }
+      }
+      const settings = getAISettings();
+      if (!settings || !settings.apiKey || settings.apiKey === "YOUR_API_KEY_HERE") {
+        logger.warn("[APIProvider] API Key \u672A\u8A2D\u5B9A\u6216\u7121\u6548");
+        return { success: false, error: "\u8ACB\u5148\u5728\u8A2D\u5B9A\u4E2D\u914D\u7F6E AI API Key", mode: "api" };
+      }
+      const aggregator = getPromptAggregator();
+      const cliSettings = getCLISettings();
+      let mcpTools = [];
+      if (request.includeMCPTools) {
+        try {
+          const allTools = mcpClientManager.getAllTools();
+          mcpTools = allTools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.inputSchema
+          }));
+        } catch (error2) {
+          logger.warn("[APIProvider] \u7121\u6CD5\u53D6\u5F97 MCP \u5DE5\u5177", error2);
+        }
+      }
+      const context = aggregator.buildContextSync(request, settings, cliSettings, mcpTools);
+      context.mode = "api";
+      const aggregated = aggregator.aggregate(context);
+      const promptSent = aggregated.fullPrompt;
+      const provider = getProviderFromUrl2(settings.apiUrl);
+      logger.info(`[APIProvider] \u4F7F\u7528 ${provider} \u63D0\u4F9B\u5546, apiUrl: ${settings.apiUrl || "(\u9810\u8A2D)"}`);
+      let reply;
+      if (provider !== "google") {
+        reply = await this.generateWithOpenAI(
+          settings.apiKey,
+          settings.model,
+          settings.apiUrl,
+          promptSent,
+          settings.temperature,
+          settings.maxTokens
+        );
+      } else {
+        reply = await this.generateWithGoogle(
+          settings.apiKey,
+          settings.model,
+          promptSent,
+          settings.temperature,
+          settings.maxTokens
+        );
+      }
+      if (!request.toolResults) {
+        cache2.set(cacheKey, { reply, timestamp: Date.now() });
+        this.cleanExpiredCache();
+      }
+      return { success: true, reply, promptSent, mode: "api" };
+    } catch (error2) {
+      logger.error("[APIProvider] \u751F\u6210\u56DE\u8986\u5931\u6557", error2);
+      return {
+        success: false,
+        error: error2 instanceof Error ? error2.message : "\u672A\u77E5\u932F\u8AA4",
+        mode: "api"
+      };
+    }
+  }
+  async generateWithGoogle(apiKey, model, prompt, temperature, maxTokens, retryCount = 0) {
+    try {
+      const genAI = new GoogleGenerativeAI(apiKey);
+      const generativeModel = genAI.getGenerativeModel({
+        model,
+        generationConfig: {
+          temperature: temperature ?? 0.7,
+          maxOutputTokens: maxTokens ?? 1e3
+        }
+      });
+      const result = await generativeModel.generateContent(prompt);
+      const response = await result.response;
+      const text = response.text();
+      if (!text) throw new Error("AI \u56DE\u8986\u70BA\u7A7A");
+      return text;
+    } catch (error2) {
+      if (error2 instanceof Error) {
+        if (error2.message.includes("429") || error2.message.includes("quota")) {
+          if (retryCount < MAX_RETRIES2) {
+            await this.sleep(RETRY_DELAYS2[retryCount] || 4e3);
+            return this.generateWithGoogle(apiKey, model, prompt, temperature, maxTokens, retryCount + 1);
+          }
+          throw new Error("API \u914D\u984D\u5DF2\u7528\u76E1\u6216\u901F\u7387\u9650\u5236\uFF0C\u8ACB\u7A0D\u5F8C\u518D\u8A66");
+        }
+        if (error2.message.includes("API key") || error2.message.includes("401")) {
+          throw new Error("API Key \u7121\u6548\uFF0C\u8ACB\u6AA2\u67E5\u8A2D\u5B9A");
+        }
+        if (retryCount < MAX_RETRIES2) {
+          await this.sleep(RETRY_DELAYS2[retryCount] || 4e3);
+          return this.generateWithGoogle(apiKey, model, prompt, temperature, maxTokens, retryCount + 1);
+        }
+      }
+      throw error2;
+    }
+  }
+  async generateWithOpenAI(apiKey, model, apiUrl, prompt, temperature, maxTokens, retryCount = 0) {
+    try {
+      const OpenAI = (await import("openai")).default;
+      const client = new OpenAI({
+        apiKey,
+        baseURL: apiUrl || "https://api.openai.com/v1"
+      });
+      const response = await client.chat.completions.create({
+        model,
+        messages: [{ role: "user", content: prompt }],
+        temperature: temperature ?? 0.7,
+        max_tokens: maxTokens ?? 1e3
+      });
+      const text = response.choices?.[0]?.message?.content;
+      if (!text) throw new Error("AI \u56DE\u8986\u70BA\u7A7A");
+      return text;
+    } catch (error2) {
+      if (error2 instanceof Error) {
+        if (error2.message.includes("429") || error2.message.includes("quota") || error2.message.includes("rate")) {
+          if (retryCount < MAX_RETRIES2) {
+            await this.sleep(RETRY_DELAYS2[retryCount] || 4e3);
+            return this.generateWithOpenAI(apiKey, model, apiUrl, prompt, temperature, maxTokens, retryCount + 1);
+          }
+          throw new Error("API \u914D\u984D\u5DF2\u7528\u76E1\u6216\u901F\u7387\u9650\u5236\uFF0C\u8ACB\u7A0D\u5F8C\u518D\u8A66");
+        }
+        if (error2.message.includes("API key") || error2.message.includes("401") || error2.message.includes("Unauthorized")) {
+          throw new Error("API Key \u7121\u6548\uFF0C\u8ACB\u6AA2\u67E5\u8A2D\u5B9A");
+        }
+        if (retryCount < MAX_RETRIES2) {
+          await this.sleep(RETRY_DELAYS2[retryCount] || 4e3);
+          return this.generateWithOpenAI(apiKey, model, apiUrl, prompt, temperature, maxTokens, retryCount + 1);
+        }
+      }
+      throw error2;
+    }
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  cleanExpiredCache() {
+    const now = Date.now();
+    for (const [key, entry] of cache2.entries()) {
+      if (now - entry.timestamp > CACHE_TTL3) cache2.delete(key);
+    }
+  }
+};
+
+// src/utils/cli-provider.ts
+init_cjs_shims();
+init_database();
+init_logger();
+init_cli_executor();
+init_cli_detector();
+init_mcp_client_manager();
+init_prompt_aggregator2();
+var CLIProvider = class {
+  cliSettings;
+  constructor(cliSettings) {
+    this.cliSettings = cliSettings;
+  }
+  getName() {
+    return `CLI (${this.cliSettings.cliTool})`;
+  }
+  getMode() {
+    return "cli";
+  }
+  async isAvailable() {
+    return isToolAvailable(this.cliSettings.cliTool);
+  }
+  async generateReply(request) {
+    const tool = this.cliSettings.cliTool;
+    const available = await this.isAvailable();
+    if (!available) {
+      logger.warn(`[CLIProvider] CLI tool not available: ${tool}`);
+      return {
+        success: false,
+        error: `CLI \u5DE5\u5177 ${tool} \u672A\u5B89\u88DD\u6216\u4E0D\u53EF\u7528`,
+        mode: "cli",
+        cliTool: tool
+      };
+    }
+    const terminalId = `${request.projectPath || "default"}-${tool}`.replace(/[^a-zA-Z0-9-]/g, "_");
+    let terminal = getCLITerminalById(terminalId);
+    if (!terminal) {
+      terminal = createCLITerminal({
+        id: terminalId,
+        projectName: request.projectName || "\u672A\u547D\u540D\u5C08\u6848",
+        projectPath: request.projectPath || "",
+        tool,
+        status: "running",
+        pid: void 0
+      });
+    } else {
+      updateCLITerminal(terminalId, { status: "running" });
+    }
+    const aggregator = getPromptAggregator();
+    const settings = getAISettings();
+    const cliSettings = getCLISettings();
+    let mcpTools = [];
+    if (request.includeMCPTools) {
+      try {
+        const allTools = mcpClientManager.getAllTools();
+        mcpTools = allTools.map((t) => ({
+          name: t.name,
+          description: t.description,
+          inputSchema: t.inputSchema
+        }));
+      } catch {
+        logger.warn("[CLIProvider] \u7121\u6CD5\u7372\u53D6 MCP \u5DE5\u5177");
+      }
+    }
+    const context = aggregator.buildContextSync(request, settings ?? null, cliSettings, mcpTools);
+    context.mode = "cli";
+    const aggregated = aggregator.aggregate(context);
+    const prompt = aggregated.fullPrompt;
+    logger.info(`[CLIProvider] Prompt \u5927\u5C0F\u5206\u6790:`, {
+      totalLength: prompt.length,
+      totalKB: (prompt.length / 1024).toFixed(2) + " KB",
+      mcpToolsCount: mcpTools.length,
+      mcpToolsSize: JSON.stringify(mcpTools).length,
+      systemPromptLength: settings?.systemPrompt?.length || 0,
+      aiMessageLength: request.aiMessage?.length || 0,
+      userContextLength: request.userContext?.length || 0,
+      timeout: this.cliSettings.cliTimeout
+    });
+    try {
+      const result = await executeCLI({
+        tool,
+        prompt,
+        timeout: this.cliSettings.cliTimeout,
+        workingDirectory: request.projectPath,
+        outputFormat: "text"
+      });
+      insertCLIExecutionLog({
+        terminalId,
+        prompt: prompt.substring(0, 1e3),
+        response: result.success ? result.output.substring(0, 5e3) : null,
+        executionTime: result.executionTime,
+        success: result.success,
+        error: result.error
+      });
+      if (!result.success) {
+        updateCLITerminal(terminalId, { status: "error" });
+        return {
+          success: false,
+          error: result.error || "CLI \u57F7\u884C\u5931\u6557",
+          mode: "cli",
+          cliTool: tool,
+          promptSent: prompt
+        };
+      }
+      if (request.includeMCPTools) {
+        const mcpHandler = createCLIMCPHandler(settings?.maxToolRounds || 10);
+        updateCLITerminal(terminalId, { status: "mcp-processing" });
+        const handlerResult = await mcpHandler.handleResponse(result.output, (call) => {
+          logger.info(`[CLIProvider] \u57F7\u884C MCP \u5DE5\u5177: ${call.toolName}`);
+        });
+        if (handlerResult.toolCallsDetected) {
+          insertCLIExecutionLog({
+            terminalId,
+            prompt: `[MCP] ${handlerResult.toolResults.length} \u500B\u5DE5\u5177\u547C\u53EB`,
+            response: handlerResult.finalResponse.substring(0, 5e3),
+            executionTime: handlerResult.toolResults.reduce((sum, r) => sum + r.executionTime, 0),
+            success: true,
+            error: void 0
+          });
+        }
+        updateCLITerminal(terminalId, { status: "idle" });
+        return {
+          success: true,
+          reply: handlerResult.finalResponse,
+          mode: "cli",
+          cliTool: tool,
+          promptSent: prompt
+        };
+      }
+      updateCLITerminal(terminalId, { status: "idle" });
+      return {
+        success: true,
+        reply: result.output,
+        mode: "cli",
+        cliTool: tool,
+        promptSent: prompt
+      };
+    } catch (error2) {
+      insertCLIExecutionLog({
+        terminalId,
+        prompt: prompt.substring(0, 1e3),
+        response: null,
+        executionTime: 0,
+        success: false,
+        error: error2 instanceof Error ? error2.message : "\u672A\u77E5\u932F\u8AA4"
+      });
+      updateCLITerminal(terminalId, { status: "error" });
+      return {
+        success: false,
+        error: error2 instanceof Error ? error2.message : "\u672A\u77E5\u932F\u8AA4",
+        mode: "cli",
+        cliTool: tool,
+        promptSent: prompt
+      };
+    }
+  }
+};
+
+// src/utils/ai-provider-factory.ts
+var AIProviderFactory = class _AIProviderFactory {
+  static instance;
+  currentProvider = null;
+  fallbackProvider = null;
+  constructor() {
+  }
+  /**
+   * 取得工廠實例 (Singleton)
+   */
+  static getInstance() {
+    if (!_AIProviderFactory.instance) {
+      _AIProviderFactory.instance = new _AIProviderFactory();
+    }
+    return _AIProviderFactory.instance;
+  }
+  /**
+   * 根據設定取得適當的 Provider
+   */
+  async getProvider() {
+    const cliSettings = getCLISettings();
+    const mode = cliSettings?.aiMode === "cli" ? "cli" : "api";
+    logger.debug("[AIProviderFactory] \u53D6\u5F97 Provider", { mode, cliTool: cliSettings?.cliTool });
+    if (mode === "cli") {
+      const cliProvider = new CLIProvider(cliSettings);
+      const available = await cliProvider.isAvailable();
+      if (!available) {
+        logger.warn("[AIProviderFactory] CLI Provider \u4E0D\u53EF\u7528");
+        if (cliSettings?.cliFallbackToApi) {
+          logger.info("[AIProviderFactory] \u56DE\u9000\u5230 API Provider");
+          return new APIProvider();
+        }
+        throw new Error(`CLI \u5DE5\u5177 ${cliSettings?.cliTool} \u4E0D\u53EF\u7528\uFF0C\u4E14\u672A\u555F\u7528 API \u56DE\u9000`);
+      }
+      return cliProvider;
+    }
+    return new APIProvider();
+  }
+  /**
+   * 取得當前模式
+   */
+  getCurrentMode() {
+    const cliSettings = getCLISettings();
+    return cliSettings?.aiMode === "cli" ? "cli" : "api";
+  }
+  /**
+   * 取得當前 CLI 工具名稱
+   */
+  getCurrentCLITool() {
+    const cliSettings = getCLISettings();
+    return cliSettings?.cliTool;
+  }
+  /**
+   * 使用工廠生成 AI 回覆
+   */
+  async generateReply(request) {
+    try {
+      const provider = await this.getProvider();
+      logger.info(`[AIProviderFactory] \u4F7F\u7528 ${provider.getName()} \u751F\u6210\u56DE\u8986`);
+      return provider.generateReply(request);
+    } catch (error2) {
+      logger.error("[AIProviderFactory] \u751F\u6210\u56DE\u8986\u5931\u6557", error2);
+      return {
+        success: false,
+        error: error2 instanceof Error ? error2.message : "\u672A\u77E5\u932F\u8AA4"
+      };
+    }
+  }
+};
+
+// src/server/web-server.ts
 init_mcp_client_manager();
 init_cli_detector();
 
@@ -90927,8 +91374,9 @@ var WebServer = class {
           });
           return;
         }
-        logger.info("\u958B\u59CB\u751F\u6210 AI \u56DE\u8986");
-        const result = await generateAIReply(data);
+        logger.info("\u958B\u59CB\u751F\u6210 AI \u56DE\u8986 (AIProviderFactory)");
+        const factory = AIProviderFactory.getInstance();
+        const result = await factory.generateReply(data);
         if (result.success) {
           logger.info("AI \u56DE\u8986\u751F\u6210\u6210\u529F");
         } else {
@@ -92306,7 +92754,8 @@ var WebServer = class {
     const autoReplyTimer = setTimeout(async () => {
       logger.info(`\u89F8\u767C\u81EA\u52D5\u56DE\u8986: \u6703\u8A71 ${sessionId}`);
       try {
-        const result = await generateAIReply({
+        const factory = AIProviderFactory.getInstance();
+        const result = await factory.generateReply({
           aiMessage: workSummary,
           userContext: "\u4F7F\u7528\u8005\u672A\u5728\u6642\u9593\u5167\u56DE\u61C9\uFF0C\u7CFB\u7D71\u81EA\u52D5\u751F\u6210\u56DE\u8986"
         });