@hirohsu/user-web-feedback 2.6.10 → 2.7.0

package/dist/index.cjs

@@ -20661,6 +20661,7 @@ __export(database_exports, {
   getPinnedPrompts: () => getPinnedPrompts,
   getPromptById: () => getPromptById,
   getRecentMCPServerErrors: () => getRecentMCPServerErrors,
+  getSelfProbeSettings: () => getSelfProbeSettings,
   getToolEnableConfigs: () => getToolEnableConfigs,
   getUserPreferences: () => getUserPreferences,
   initDatabase: () => initDatabase,
@@ -20676,6 +20677,7 @@ __export(database_exports, {
   queryLogs: () => queryLogs,
   queryMCPServerLogs: () => queryMCPServerLogs,
   reorderPrompts: () => reorderPrompts,
+  saveSelfProbeSettings: () => saveSelfProbeSettings,
   setToolEnabled: () => setToolEnabled,
   toggleMCPServerEnabled: () => toggleMCPServerEnabled,
   togglePromptPin: () => togglePromptPin,
@@ -20974,6 +20976,14 @@ function createTables() {
     }
   } catch {
   }
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS self_probe_settings (
+      id INTEGER PRIMARY KEY CHECK (id = 1),
+      enabled INTEGER DEFAULT 0,
+      interval_seconds INTEGER DEFAULT 300,
+      updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
 }
 function initDefaultSettings() {
   if (!db) throw new Error("Database not initialized");
@@ -22319,6 +22329,55 @@ function cleanupOldCLIExecutionLogs(daysToKeep = 7) {
     `).run(cutoffDate.toISOString());
   return result.changes;
 }
+function getSelfProbeSettings() {
+  const db2 = tryGetDb();
+  if (!db2) return void 0;
+  const row = db2.prepare(`
+        SELECT 
+            id,
+            enabled,
+            interval_seconds as intervalSeconds,
+            updated_at as updatedAt
+        FROM self_probe_settings
+        WHERE id = 1
+    `).get();
+  if (!row) return void 0;
+  return {
+    id: row.id,
+    enabled: row.enabled === 1,
+    intervalSeconds: row.intervalSeconds,
+    updatedAt: row.updatedAt
+  };
+}
+function saveSelfProbeSettings(settings) {
+  const db2 = tryGetDb();
+  if (!db2) throw new Error("Database not initialized");
+  const existing = getSelfProbeSettings();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (existing) {
+    db2.prepare(`
+            UPDATE self_probe_settings
+            SET enabled = COALESCE(?, enabled),
+                interval_seconds = COALESCE(?, interval_seconds),
+                updated_at = ?
+            WHERE id = 1
+        `).run(
+      settings.enabled !== void 0 ? settings.enabled ? 1 : 0 : null,
+      settings.intervalSeconds ?? null,
+      now
+    );
+  } else {
+    db2.prepare(`
+            INSERT INTO self_probe_settings (id, enabled, interval_seconds, updated_at)
+            VALUES (1, ?, ?, ?)
+        `).run(
+      settings.enabled ? 1 : 0,
+      settings.intervalSeconds ?? 300,
+      now
+    );
+  }
+  return getSelfProbeSettings();
+}
 var import_better_sqlite3, import_path2, import_fs2, import_crypto2, DB_DIR, DB_PATH, db, SYSTEM_PROMPT_VERSIONS, CURRENT_PROMPT_VERSION;
 var init_database = __esm({
   "src/utils/database.ts"() {
@@ -89361,6 +89420,127 @@ var InstanceLock = class {
 
 // src/server/web-server.ts
 init_database();
+
+// src/utils/self-probe-service.ts
+init_cjs_shims();
+init_logger();
+init_database();
+var SelfProbeService = class {
+  constructor(config2) {
+    this.config = config2;
+    this.enabled = config2.enableSelfProbe ?? false;
+    this.intervalSeconds = config2.selfProbeIntervalSeconds ?? 300;
+  }
+  timer = null;
+  lastProbeTime = null;
+  probeCount = 0;
+  enabled = false;
+  intervalSeconds = 300;
+  context = null;
+  setContext(context) {
+    this.context = context;
+  }
+  start() {
+    if (this.timer) {
+      this.stop();
+    }
+    const dbSettings = getSelfProbeSettings();
+    if (dbSettings) {
+      this.enabled = dbSettings.enabled;
+      this.intervalSeconds = dbSettings.intervalSeconds;
+    }
+    if (!this.enabled) {
+      logger.debug("Self-probe is disabled, not starting");
+      return;
+    }
+    const intervalMs = this.intervalSeconds * 1e3;
+    this.timer = setInterval(() => this.probe(), intervalMs);
+    logger.info(`Self-probe started with interval: ${this.intervalSeconds}s`);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+      logger.info("Self-probe stopped");
+    }
+  }
+  restart() {
+    this.stop();
+    this.start();
+  }
+  updateSettings(settings) {
+    if (settings.enabled !== void 0) {
+      this.enabled = settings.enabled;
+    }
+    if (settings.intervalSeconds !== void 0) {
+      if (settings.intervalSeconds < 60 || settings.intervalSeconds > 600) {
+        throw new Error("Interval must be between 60 and 600 seconds");
+      }
+      this.intervalSeconds = settings.intervalSeconds;
+    }
+    saveSelfProbeSettings(settings);
+    if (this.enabled) {
+      this.restart();
+    } else {
+      this.stop();
+    }
+  }
+  async probe() {
+    this.lastProbeTime = /* @__PURE__ */ new Date();
+    this.probeCount++;
+    try {
+      if (this.context) {
+        this.checkSocketIO();
+        this.checkMCPStatus();
+        this.triggerSessionCleanup();
+      }
+      logger.debug(`Self-probe #${this.probeCount} completed`);
+    } catch (error2) {
+      logger.warn("Self-probe encountered an issue:", error2);
+    }
+  }
+  checkSocketIO() {
+    if (!this.context) return;
+    const connectedSockets = this.context.getSocketIOConnectionCount();
+    logger.debug(`Self-probe: Socket.IO connected clients: ${connectedSockets}`);
+  }
+  checkMCPStatus() {
+    if (!this.context) return;
+    const mcpStatus = this.context.getMCPServerStatus();
+    logger.debug(`Self-probe: MCP Server running: ${mcpStatus?.running ?? "N/A"}`);
+  }
+  triggerSessionCleanup() {
+    if (!this.context) return;
+    const sessionCount = this.context.getSessionCount();
+    if (sessionCount > 0) {
+      this.context.cleanupExpiredSessions();
+      logger.debug(`Self-probe: Triggered session cleanup, active sessions: ${sessionCount}`);
+    }
+  }
+  getStats() {
+    return {
+      enabled: this.enabled,
+      intervalSeconds: this.intervalSeconds,
+      lastProbeTime: this.lastProbeTime,
+      probeCount: this.probeCount,
+      isRunning: this.timer !== null
+    };
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  isRunning() {
+    return this.timer !== null;
+  }
+  getProbeCount() {
+    return this.probeCount;
+  }
+  getLastProbeTime() {
+    return this.lastProbeTime;
+  }
+};
+
+// src/server/web-server.ts
 init_crypto_helper();
 init_ai_service();
 init_mcp_client_manager();
@@ -89536,6 +89716,7 @@ var WebServer = class {
   sseTransports = /* @__PURE__ */ new Map();
   sseTransportsList = [];
   dbInitialized = false;
+  selfProbeService;
   /**
    * 延遲載入 ImageProcessor
    */
@@ -89577,6 +89758,7 @@ var WebServer = class {
     this.config = config2;
     this.portManager = new PortManager();
     this.sessionStorage = new SessionStorage();
+    this.selfProbeService = new SelfProbeService(config2);
     this.app = (0, import_express.default)();
     this.server = (0, import_http.createServer)(this.app);
     this.io = new Server2(this.server, {
@@ -89841,6 +90023,7 @@ var WebServer = class {
       });
     });
     this.app.get("/api/health", (req, res) => {
+      const selfProbeStats = this.selfProbeService.getStats();
       res.json({
         status: "ok",
         pid: process.pid,
@@ -89848,7 +90031,14 @@ var WebServer = class {
         uptime: process.uptime(),
         version: VERSION,
         activeSessions: this.sessionStorage.getSessionCount(),
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        selfProbe: {
+          enabled: selfProbeStats.enabled,
+          isRunning: selfProbeStats.isRunning,
+          probeCount: selfProbeStats.probeCount,
+          lastProbeTime: selfProbeStats.lastProbeTime?.toISOString() ?? null,
+          intervalSeconds: selfProbeStats.intervalSeconds
+        }
       });
     });
     this.app.get("/api/dashboard/overview", (req, res) => {
@@ -90376,6 +90566,46 @@ var WebServer = class {
         });
       }
     });
+    this.app.get("/api/settings/self-probe", (req, res) => {
+      try {
+        const settings = getSelfProbeSettings();
+        const stats = this.selfProbeService.getStats();
+        res.json({
+          success: true,
+          settings: settings ?? { enabled: false, intervalSeconds: 300 },
+          stats
+        });
+      } catch (error2) {
+        logger.error("\u7372\u53D6 Self-Probe \u8A2D\u5B9A\u5931\u6557:", error2);
+        res.status(500).json({
+          success: false,
+          error: error2 instanceof Error ? error2.message : "\u7372\u53D6 Self-Probe \u8A2D\u5B9A\u5931\u6557"
+        });
+      }
+    });
+    this.app.post("/api/settings/self-probe", (req, res) => {
+      try {
+        const { enabled, intervalSeconds } = req.body;
+        if (intervalSeconds !== void 0 && (intervalSeconds < 60 || intervalSeconds > 600)) {
+          res.status(400).json({
+            success: false,
+            error: "Interval must be between 60 and 600 seconds"
+          });
+          return;
+        }
+        this.selfProbeService.updateSettings({ enabled, intervalSeconds });
+        const settings = getSelfProbeSettings();
+        const stats = this.selfProbeService.getStats();
+        logger.info(`Self-Probe \u8A2D\u5B9A\u5DF2\u66F4\u65B0: enabled=${enabled}, interval=${intervalSeconds}s`);
+        res.json({ success: true, settings, stats });
+      } catch (error2) {
+        logger.error("\u66F4\u65B0 Self-Probe \u8A2D\u5B9A\u5931\u6557:", error2);
+        res.status(500).json({
+          success: false,
+          error: error2 instanceof Error ? error2.message : "\u66F4\u65B0 Self-Probe \u8A2D\u5B9A\u5931\u6557"
+        });
+      }
+    });
     this.app.get("/api/logs", (req, res) => {
       try {
         const options = {};
@@ -91733,6 +91963,13 @@ var WebServer = class {
       }
       logger.mcpServerStarted(this.port, serverUrl);
       await this.autoStartMCPServers();
+      this.selfProbeService.setContext({
+        getSocketIOConnectionCount: () => this.io.sockets.sockets.size,
+        getMCPServerStatus: () => this.mcpServerRef?.getStatus(),
+        getSessionCount: () => this.sessionStorage.getSessionCount(),
+        cleanupExpiredSessions: () => this.sessionStorage.cleanupExpiredSessions()
+      });
+      this.selfProbeService.start();
     } catch (error2) {
       logger.error("Web\u4F3A\u670D\u5668\u555F\u52D5\u5931\u6557:", error2);
       throw new MCPError(
@@ -91909,6 +92146,7 @@ var WebServer = class {
           logger.warn("\u7B49\u5F85\u6D3B\u8E8D\u6703\u8A71\u5B8C\u6210\u6642\u767C\u751F\u932F\u8AA4\u6216\u8D85\u6642\uFF0C\u5C07\u7E7C\u7E8C\u505C\u6B62\u6D41\u7A0B", waitErr);
         }
       }
+      this.selfProbeService.stop();
       this.sessionStorage.clear();
       this.sessionStorage.stopCleanupTimer();
       this.io.disconnectSockets(true);
@@ -91952,6 +92190,24 @@ var WebServer = class {
   getPort() {
     return this.port;
   }
+  /**
+   * 取得 Self-Probe 服務實例
+   */
+  getSelfProbeService() {
+    return this.selfProbeService;
+  }
+  /**
+   * 取得 Socket.IO 伺服器實例
+   */
+  getIO() {
+    return this.io;
+  }
+  /**
+   * 取得 Session Storage 實例
+   */
+  getSessionStorage() {
+    return this.sessionStorage;
+  }
 };
 
 // src/server/mcp-server.ts
@@ -92393,6 +92649,26 @@ var MCPServer = class {
 // src/config/index.ts
 init_cjs_shims();
 var import_dotenv = __toESM(require_main2(), 1);
+
+// src/shared/ipc-constants.ts
+init_cjs_shims();
+var SUPERVISOR_DEFAULTS = {
+  MAX_RESTART_ATTEMPTS: 5,
+  RESTART_DELAY_MS: 2e3,
+  HEALTH_CHECK_INTERVAL_MS: 3e4,
+  HEALTH_CHECK_TIMEOUT_MS: 5e3,
+  REQUEST_TIMEOUT_MS: 3e4,
+  CONSECUTIVE_FAILURES_BEFORE_RESTART: 3
+};
+var SUPERVISOR_ENV_KEYS = {
+  ENABLED: "SUPERVISOR_ENABLED",
+  MAX_RESTART_ATTEMPTS: "SUPERVISOR_MAX_RESTART_ATTEMPTS",
+  RESTART_DELAY_MS: "SUPERVISOR_RESTART_DELAY_MS",
+  HEALTH_CHECK_INTERVAL_MS: "SUPERVISOR_HEALTH_CHECK_INTERVAL_MS",
+  HEALTH_CHECK_TIMEOUT_MS: "SUPERVISOR_HEALTH_CHECK_TIMEOUT_MS"
+};
+
+// src/config/index.ts
 (0, import_dotenv.config)();
 function getEnvVar(key, defaultValue) {
   return process.env[key] || defaultValue;
@@ -92415,6 +92691,27 @@ function getEnvBoolean(key, defaultValue) {
   if (!value) return defaultValue;
   return value.toLowerCase() === "true";
 }
+function createSupervisorConfig() {
+  return {
+    enabled: getEnvBoolean(SUPERVISOR_ENV_KEYS.ENABLED, false),
+    maxRestartAttempts: getEnvNumber(
+      SUPERVISOR_ENV_KEYS.MAX_RESTART_ATTEMPTS,
+      SUPERVISOR_DEFAULTS.MAX_RESTART_ATTEMPTS
+    ),
+    restartDelayMs: getEnvNumber(
+      SUPERVISOR_ENV_KEYS.RESTART_DELAY_MS,
+      SUPERVISOR_DEFAULTS.RESTART_DELAY_MS
+    ),
+    healthCheckIntervalMs: getEnvNumber(
+      SUPERVISOR_ENV_KEYS.HEALTH_CHECK_INTERVAL_MS,
+      SUPERVISOR_DEFAULTS.HEALTH_CHECK_INTERVAL_MS
+    ),
+    healthCheckTimeoutMs: getEnvNumber(
+      SUPERVISOR_ENV_KEYS.HEALTH_CHECK_TIMEOUT_MS,
+      SUPERVISOR_DEFAULTS.HEALTH_CHECK_TIMEOUT_MS
+    )
+  };
+}
 function createDefaultConfig() {
   return {
     apiKey: process.env["MCP_API_KEY"],
@@ -92446,7 +92743,12 @@ function createDefaultConfig() {
     healthCheckTimeout: getEnvNumber("MCP_HEALTH_CHECK_TIMEOUT", 3e3),
     forceNewInstance: getEnvBoolean("MCP_FORCE_NEW_INSTANCE", false),
     // MCP Server 傳輸模式
-    mcpTransport: getEnvVar("MCP_TRANSPORT", "stdio")
+    mcpTransport: getEnvVar("MCP_TRANSPORT", "stdio"),
+    // Self-Probe (Keep-Alive) 設定
+    enableSelfProbe: getEnvBoolean("MCP_ENABLE_SELF_PROBE", false),
+    selfProbeIntervalSeconds: getEnvNumber("MCP_SELF_PROBE_INTERVAL", 300),
+    // Supervisor 配置
+    supervisor: createSupervisorConfig()
   };
 }
 function validateConfig(config2) {
@@ -92483,6 +92785,41 @@ function validateConfig(config2) {
       "INVALID_LOG_LEVEL"
     );
   }
+  if (config2.selfProbeIntervalSeconds !== void 0) {
+    if (config2.selfProbeIntervalSeconds < 60 || config2.selfProbeIntervalSeconds > 600) {
+      throw new MCPError(
+        `Invalid self-probe interval: ${config2.selfProbeIntervalSeconds}. Must be between 60 and 600 seconds.`,
+        "INVALID_SELF_PROBE_INTERVAL"
+      );
+    }
+  }
+  if (config2.supervisor) {
+    const sup = config2.supervisor;
+    if (sup.maxRestartAttempts < 0 || sup.maxRestartAttempts > 20) {
+      throw new MCPError(
+        `Invalid supervisor max restart attempts: ${sup.maxRestartAttempts}. Must be between 0 and 20.`,
+        "INVALID_SUPERVISOR_CONFIG"
+      );
+    }
+    if (sup.restartDelayMs < 100 || sup.restartDelayMs > 3e4) {
+      throw new MCPError(
+        `Invalid supervisor restart delay: ${sup.restartDelayMs}. Must be between 100ms and 30000ms.`,
+        "INVALID_SUPERVISOR_CONFIG"
+      );
+    }
+    if (sup.healthCheckIntervalMs < 5e3 || sup.healthCheckIntervalMs > 3e5) {
+      throw new MCPError(
+        `Invalid supervisor health check interval: ${sup.healthCheckIntervalMs}. Must be between 5s and 300s.`,
+        "INVALID_SUPERVISOR_CONFIG"
+      );
+    }
+    if (sup.healthCheckTimeoutMs < 1e3 || sup.healthCheckTimeoutMs > 3e4) {
+      throw new MCPError(
+        `Invalid supervisor health check timeout: ${sup.healthCheckTimeoutMs}. Must be between 1s and 30s.`,
+        "INVALID_SUPERVISOR_CONFIG"
+      );
+    }
+  }
 }
 function getConfig() {
   const config2 = createDefaultConfig();

package/dist/static/settings.html

@@ -342,6 +342,42 @@
                 <button id="savePreferencesBtn" class="btn btn-primary">儲存偏好設定</button>
             </div>
         </section>
+
+        <!-- Self-Probe 設定 -->
+        <section class="settings-section">
+            <h2 class="section-title">
+                <span class="icon">💓</span>
+                自我探查 (Keep-Alive)
+            </h2>
+            
+            <div class="form-group">
+                <div class="checkbox-group">
+                    <input type="checkbox" id="enableSelfProbe" />
+                    <label for="enableSelfProbe">啟用自我探查</label>
+                </div>
+                <p class="form-help">定期檢查服務狀態，防止因閒置被系統回收</p>
+            </div>
+
+            <div class="form-group" id="selfProbeIntervalGroup">
+                <label class="form-label" for="selfProbeInterval">探查間隔（秒）</label>
+                <input type="number" id="selfProbeInterval" class="form-input" 
+                       min="60" max="600" step="30" value="300">
+                <p class="form-help">60-600 秒，預設 300 秒（5 分鐘）</p>
+            </div>
+
+            <div class="form-group" id="selfProbeStatus" style="display: none;">
+                <label class="form-label">狀態資訊</label>
+                <div class="status-info" style="font-size: 13px; color: var(--text-muted); padding: 8px; background: var(--bg-secondary); border-radius: var(--radius-sm);">
+                    <div id="selfProbeRunning">執行狀態: --</div>
+                    <div id="selfProbeCount">探查次數: --</div>
+                    <div id="selfProbeLastTime">上次探查: --</div>
+                </div>
+            </div>
+
+            <div class="form-actions">
+                <button id="saveSelfProbeBtn" class="btn btn-primary">儲存設定</button>
+            </div>
+        </section>
     </div>
 
     <!-- Toast Container -->

package/dist/static/settings.js

@@ -63,6 +63,15 @@
     confirmBeforeSubmit: document.getElementById("confirmBeforeSubmit"),
     defaultLanguage: document.getElementById("defaultLanguage"),
     savePreferencesBtn: document.getElementById("savePreferencesBtn"),
+    // Self-Probe Settings
+    enableSelfProbe: document.getElementById("enableSelfProbe"),
+    selfProbeInterval: document.getElementById("selfProbeInterval"),
+    selfProbeIntervalGroup: document.getElementById("selfProbeIntervalGroup"),
+    selfProbeStatus: document.getElementById("selfProbeStatus"),
+    selfProbeRunning: document.getElementById("selfProbeRunning"),
+    selfProbeCount: document.getElementById("selfProbeCount"),
+    selfProbeLastTime: document.getElementById("selfProbeLastTime"),
+    saveSelfProbeBtn: document.getElementById("saveSelfProbeBtn"),
     toastContainer: document.getElementById("toastContainer"),
   };
 
@@ -76,6 +85,7 @@
     loadAISettings();
     loadCLISettings();
     loadPreferences();
+    loadSelfProbeSettings();
   }
 
   function setupEventListeners() {
@@ -92,6 +102,21 @@
 
     // User Preferences
     elements.savePreferencesBtn.addEventListener("click", savePreferences);
+
+    // Self-Probe Settings
+    if (elements.enableSelfProbe) {
+      elements.enableSelfProbe.addEventListener("change", handleSelfProbeToggle);
+    }
+    if (elements.saveSelfProbeBtn) {
+      elements.saveSelfProbeBtn.addEventListener("click", saveSelfProbeSettings);
+    }
+  }
+
+  function handleSelfProbeToggle() {
+    const isEnabled = elements.enableSelfProbe.checked;
+    if (elements.selfProbeIntervalGroup) {
+      elements.selfProbeIntervalGroup.style.opacity = isEnabled ? "1" : "0.5";
+    }
   }
 
   function handleAIModeChange() {
@@ -397,6 +422,99 @@
     }
   }
 
+  // ============ Self-Probe Settings ============
+
+  async function loadSelfProbeSettings() {
+    try {
+      const response = await fetch(`${API_BASE}/api/settings/self-probe`);
+      const data = await response.json();
+
+      if (data.success) {
+        const settings = data.settings || {};
+        const stats = data.stats || {};
+
+        if (elements.enableSelfProbe) {
+          elements.enableSelfProbe.checked = settings.enabled || false;
+        }
+        if (elements.selfProbeInterval) {
+          elements.selfProbeInterval.value = settings.intervalSeconds || 300;
+        }
+
+        // 更新狀態資訊
+        updateSelfProbeStatus(stats);
+        handleSelfProbeToggle();
+      }
+    } catch (error) {
+      console.error("Failed to load Self-Probe settings:", error);
+    }
+  }
+
+  function updateSelfProbeStatus(stats) {
+    if (!elements.selfProbeStatus) return;
+
+    if (stats.enabled) {
+      elements.selfProbeStatus.style.display = "block";
+      
+      if (elements.selfProbeRunning) {
+        elements.selfProbeRunning.textContent = `執行狀態: ${stats.isRunning ? "✅ 運行中" : "⏸️ 已停止"}`;
+      }
+      if (elements.selfProbeCount) {
+        elements.selfProbeCount.textContent = `探查次數: ${stats.probeCount || 0}`;
+      }
+      if (elements.selfProbeLastTime) {
+        const lastTime = stats.lastProbeTime 
+          ? new Date(stats.lastProbeTime).toLocaleString() 
+          : "尚未執行";
+        elements.selfProbeLastTime.textContent = `上次探查: ${lastTime}`;
+      }
+    } else {
+      elements.selfProbeStatus.style.display = "none";
+    }
+  }
+
+  async function saveSelfProbeSettings() {
+    const settings = {
+      enabled: elements.enableSelfProbe?.checked || false,
+      intervalSeconds: parseInt(elements.selfProbeInterval?.value) || 300,
+    };
+
+    // 驗證間隔
+    if (settings.intervalSeconds < 60 || settings.intervalSeconds > 600) {
+      showToast("探查間隔必須在 60-600 秒之間", "error");
+      return;
+    }
+
+    if (elements.saveSelfProbeBtn) {
+      elements.saveSelfProbeBtn.disabled = true;
+      elements.saveSelfProbeBtn.textContent = "儲存中...";
+    }
+
+    try {
+      const response = await fetch(`${API_BASE}/api/settings/self-probe`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(settings),
+      });
+
+      const data = await response.json();
+
+      if (response.ok && data.success) {
+        showToast("Self-Probe 設定已儲存", "success");
+        updateSelfProbeStatus(data.stats);
+      } else {
+        showToast(`儲存失敗: ${data.error || "未知錯誤"}`, "error");
+      }
+    } catch (error) {
+      console.error("Save Self-Probe settings failed:", error);
+      showToast("儲存失敗", "error");
+    } finally {
+      if (elements.saveSelfProbeBtn) {
+        elements.saveSelfProbeBtn.disabled = false;
+        elements.saveSelfProbeBtn.textContent = "儲存設定";
+      }
+    }
+  }
+
   function showToast(message, type = "info") {
     const toast = document.createElement("div");
     toast.className = `toast toast-${type}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hirohsu/user-web-feedback",
-  "version": "2.6.10",
+  "version": "2.7.0",
   "description": "基於Node.js的MCP回饋收集器 - 支持AI工作彙報和用戶回饋收集",
   "main": "dist/index.cjs",
   "bin": {