codex-to-im 1.0.58 → 1.0.60

package/dist/ui-server.mjs

@@ -4011,7 +4011,7 @@ var require_utils2 = __commonJS({
 // node_modules/qrcode/lib/renderer/png.js
 var require_png2 = __commonJS({
   "node_modules/qrcode/lib/renderer/png.js"(exports) {
-    var fs9 = __require("fs");
+    var fs10 = __require("fs");
     var PNG = require_png().PNG;
     var Utils = require_utils2();
     exports.render = function render(qrData, options) {
@@ -4063,7 +4063,7 @@ var require_png2 = __commonJS({
         called = true;
         cb.apply(null, args);
       };
-      const stream = fs9.createWriteStream(path10);
+      const stream = fs10.createWriteStream(path10);
       stream.on("error", done);
       stream.on("close", done);
       exports.renderToFileStream(stream, qrData, options);
@@ -4130,9 +4130,9 @@ var require_utf8 = __commonJS({
         cb = options;
         options = void 0;
       }
-      const fs9 = __require("fs");
+      const fs10 = __require("fs");
       const utf8 = exports.render(qrData, options);
-      fs9.writeFile(path10, utf8, cb);
+      fs10.writeFile(path10, utf8, cb);
     };
   }
 });
@@ -4306,10 +4306,10 @@ var require_svg = __commonJS({
         cb = options;
         options = void 0;
       }
-      const fs9 = __require("fs");
+      const fs10 = __require("fs");
       const svgTag = exports.render(qrData, options);
       const xmlStr = '<?xml version="1.0" encoding="utf-8"?><!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">' + svgTag;
-      fs9.writeFile(path10, xmlStr, cb);
+      fs10.writeFile(path10, xmlStr, cb);
     };
   }
 });
@@ -4566,12 +4566,13 @@ var require_lib = __commonJS({
 
 // src/ui-server.ts
 import http from "node:http";
-import crypto5 from "node:crypto";
+import crypto8 from "node:crypto";
 import net from "node:net";
 import os5 from "node:os";
 
 // src/config.ts
-import fs from "node:fs";
+import fs2 from "node:fs";
+import crypto2 from "node:crypto";
 import os from "node:os";
 import path from "node:path";
 
@@ -4598,10 +4599,109 @@ function normalizeChannelId(value) {
   return value.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || "channel";
 }
 
+// src/file-lock.ts
+import crypto from "node:crypto";
+import fs from "node:fs";
+var DEFAULT_LOCK_TIMEOUT_MS = 5e3;
+var DEFAULT_STALE_LOCK_MS = 3e4;
+var LOCK_RETRY_INTERVAL_MS = 25;
+var WAIT_ARRAY = new Int32Array(new SharedArrayBuffer(4));
+var ACTIVE_LOCKS = /* @__PURE__ */ new Map();
+function sleepSync(ms) {
+  Atomics.wait(WAIT_ARRAY, 0, 0, Math.max(1, ms));
+}
+function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function removeStaleLock(lockPath, staleAfterMs) {
+  try {
+    const stat = fs.statSync(lockPath);
+    if (Date.now() - stat.mtimeMs < staleAfterMs) return false;
+    let ownerPid = 0;
+    try {
+      const parsed = JSON.parse(fs.readFileSync(lockPath, "utf8"));
+      ownerPid = typeof parsed.pid === "number" ? parsed.pid : 0;
+    } catch {
+    }
+    if (ownerPid && isProcessAlive(ownerPid)) return false;
+    fs.rmSync(lockPath, { force: true });
+    return true;
+  } catch (error) {
+    return error.code === "ENOENT";
+  }
+}
+function withFileLock(targetPath, operation, options) {
+  const lockPath = `${targetPath}.lock`;
+  const activeDepth = ACTIVE_LOCKS.get(lockPath) || 0;
+  if (activeDepth > 0) {
+    ACTIVE_LOCKS.set(lockPath, activeDepth + 1);
+    try {
+      return operation();
+    } finally {
+      const nextDepth = (ACTIVE_LOCKS.get(lockPath) || 1) - 1;
+      if (nextDepth > 0) ACTIVE_LOCKS.set(lockPath, nextDepth);
+      else ACTIVE_LOCKS.delete(lockPath);
+    }
+  }
+  const timeoutMs = Math.max(0, options?.timeoutMs ?? DEFAULT_LOCK_TIMEOUT_MS);
+  const staleAfterMs = Math.max(timeoutMs, options?.staleAfterMs ?? DEFAULT_STALE_LOCK_MS);
+  const deadline = Date.now() + timeoutMs;
+  const record = {
+    token: crypto.randomUUID(),
+    pid: process.pid,
+    createdAt: Date.now()
+  };
+  let handle = null;
+  while (handle === null) {
+    try {
+      handle = fs.openSync(lockPath, "wx", 384);
+      fs.writeFileSync(handle, JSON.stringify(record), "utf8");
+    } catch (error) {
+      const code = error.code;
+      if (code !== "EEXIST") throw error;
+      if (removeStaleLock(lockPath, staleAfterMs)) continue;
+      if (Date.now() >= deadline) {
+        throw new Error(`Timed out waiting for file lock: ${lockPath}`);
+      }
+      sleepSync(Math.min(LOCK_RETRY_INTERVAL_MS, Math.max(1, deadline - Date.now())));
+    }
+  }
+  try {
+    ACTIVE_LOCKS.set(lockPath, 1);
+    return operation();
+  } finally {
+    ACTIVE_LOCKS.delete(lockPath);
+    try {
+      fs.closeSync(handle);
+    } catch {
+    }
+    try {
+      const current = JSON.parse(fs.readFileSync(lockPath, "utf8"));
+      if (current.token === record.token) fs.rmSync(lockPath, { force: true });
+    } catch {
+    }
+  }
+}
+function withFileLocks(targetPaths, operation) {
+  const paths = Array.from(new Set(targetPaths)).sort();
+  const acquire = (index) => {
+    if (index >= paths.length) return operation();
+    return withFileLock(paths[index], () => acquire(index + 1));
+  };
+  return acquire(0);
+}
+
 // src/config.ts
 function isSupportedChannelProvider(value) {
   return value === "feishu" || value === "weixin";
 }
+var RAW_CHANNELS = Symbol("rawConfigV2Channels");
 function toFeishuConfig(channel) {
   return channel?.provider === "feishu" ? channel.config : void 0;
 }
@@ -4641,7 +4741,7 @@ function parseEnvFile(content) {
 }
 function loadRawConfigEnv() {
   try {
-    return parseEnvFile(fs.readFileSync(CONFIG_PATH, "utf-8"));
+    return parseEnvFile(fs2.readFileSync(CONFIG_PATH, "utf-8"));
   } catch {
     return /* @__PURE__ */ new Map();
   }
@@ -4671,26 +4771,66 @@ function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
 function ensureConfigDir() {
-  fs.mkdirSync(CTI_HOME, { recursive: true });
+  fs2.mkdirSync(CTI_HOME, { recursive: true });
 }
 function readConfigV2File() {
+  if (!fs2.existsSync(CONFIG_V2_PATH)) return null;
+  let content;
   try {
-    const parsed = JSON.parse(fs.readFileSync(CONFIG_V2_PATH, "utf-8"));
-    if (parsed && parsed.schemaVersion === 2 && parsed.runtime && Array.isArray(parsed.channels)) {
-      parsed.runtime.provider = normalizeRuntimeProvider(parsed.runtime.provider);
-      parsed.channels = normalizeChannelInstances(parsed.channels);
-      return parsed;
+    content = fs2.readFileSync(CONFIG_V2_PATH, "utf-8");
+  } catch (error) {
+    throw new Error(`\u65E0\u6CD5\u8BFB\u53D6\u914D\u7F6E\u6587\u4EF6 ${CONFIG_V2_PATH}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  let raw;
+  try {
+    raw = JSON.parse(content);
+  } catch (error) {
+    throw new Error(`\u914D\u7F6E\u6587\u4EF6 ${CONFIG_V2_PATH} \u4E0D\u662F\u6709\u6548 JSON\uFF0C\u5DF2\u62D2\u7EDD\u8986\u76D6: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error(`\u914D\u7F6E\u6587\u4EF6 ${CONFIG_V2_PATH} \u7684\u6839\u8282\u70B9\u5FC5\u987B\u662F\u5BF9\u8C61\uFF0C\u5DF2\u62D2\u7EDD\u8986\u76D6\u3002`);
+  }
+  if (raw.schemaVersion !== 2) {
+    throw new Error(`\u4E0D\u652F\u6301\u914D\u7F6E schemaVersion=${String(raw.schemaVersion)}\uFF0C\u5DF2\u62D2\u7EDD\u7528\u5F53\u524D\u7248\u672C\u8986\u76D6\u3002`);
+  }
+  if (!raw.runtime || typeof raw.runtime !== "object" || Array.isArray(raw.runtime)) {
+    throw new Error(`\u914D\u7F6E\u6587\u4EF6 ${CONFIG_V2_PATH} \u7F3A\u5C11\u6709\u6548\u7684 runtime \u5BF9\u8C61\uFF0C\u5DF2\u62D2\u7EDD\u8986\u76D6\u3002`);
+  }
+  if (!Array.isArray(raw.channels)) {
+    throw new Error(`\u914D\u7F6E\u6587\u4EF6 ${CONFIG_V2_PATH} \u7F3A\u5C11 channels \u6570\u7EC4\uFF0C\u5DF2\u62D2\u7EDD\u8986\u76D6\u3002`);
+  }
+  const rawChannels = raw.channels;
+  const parsed = {
+    ...raw,
+    schemaVersion: 2,
+    runtime: {
+      ...raw.runtime,
+      provider: normalizeRuntimeProvider(raw.runtime.provider)
+    },
+    channels: normalizeChannelInstances(rawChannels)
+  };
+  Object.defineProperty(parsed, RAW_CHANNELS, { value: rawChannels, enumerable: false });
+  return parsed;
+}
+function atomicWriteFile(filePath, content) {
+  ensureConfigDir();
+  const tmpPath = `${filePath}.${process.pid}.${crypto2.randomUUID()}.tmp`;
+  try {
+    fs2.writeFileSync(tmpPath, content, { mode: 384 });
+    fs2.renameSync(tmpPath, filePath);
+  } finally {
+    try {
+      fs2.rmSync(tmpPath, { force: true });
+    } catch {
     }
-    return null;
-  } catch {
-    return null;
   }
 }
 function writeConfigV2File(config) {
-  ensureConfigDir();
-  const tmpPath = CONFIG_V2_PATH + ".tmp";
-  fs.writeFileSync(tmpPath, JSON.stringify(config, null, 2), { mode: 384 });
-  fs.renameSync(tmpPath, CONFIG_V2_PATH);
+  const serialized = {
+    ...config,
+    channels: config[RAW_CHANNELS] || config.channels
+  };
+  atomicWriteFile(CONFIG_V2_PATH, JSON.stringify(serialized, null, 2));
 }
 function defaultAliasForProvider(provider) {
   return provider === "feishu" ? "\u98DE\u4E66" : "\u5FAE\u4FE1";
@@ -4711,6 +4851,7 @@ function normalizeChannelInstances(value) {
     const config = record.config && typeof record.config === "object" ? record.config : {};
     const timestamp = nowIso();
     return [{
+      ...record,
       id: normalizeChannelId(
         typeof record.id === "string" && record.id.trim() ? record.id : buildDefaultChannelId(provider)
       ),
@@ -4811,13 +4952,45 @@ function expandConfig(v2) {
     uiAccessToken: v2.runtime.uiAccessToken || void 0
   };
 }
+function mergeRawChannelRecords(current, channels) {
+  const remaining = new Map(channels.map((channel) => [channel.id, channel]));
+  const rawChannels = current?.[RAW_CHANNELS] || current?.channels || [];
+  const merged = [];
+  for (const rawEntry of rawChannels) {
+    if (!rawEntry || typeof rawEntry !== "object" || Array.isArray(rawEntry)) continue;
+    const rawRecord = rawEntry;
+    if (!isSupportedChannelProvider(rawRecord.provider)) {
+      merged.push(rawEntry);
+      continue;
+    }
+    const rawId = normalizeChannelId(
+      typeof rawRecord.id === "string" && rawRecord.id.trim() ? rawRecord.id : buildDefaultChannelId(rawRecord.provider)
+    );
+    const replacement = remaining.get(rawId);
+    if (!replacement) continue;
+    remaining.delete(rawId);
+    const rawConfig = rawRecord.config && typeof rawRecord.config === "object" && !Array.isArray(rawRecord.config) ? rawRecord.config : {};
+    merged.push({
+      ...rawRecord,
+      ...replacement,
+      config: {
+        ...rawConfig,
+        ...replacement.config
+      }
+    });
+  }
+  merged.push(...remaining.values());
+  return merged;
+}
 function buildV2FileFromExpandedConfig(config, current) {
   const hasExplicitChannels = Array.isArray(config.channels);
   let channels = hasExplicitChannels ? [...config.channels || []] : [...current?.channels || []];
   channels = normalizeChannelInstances(channels);
-  return {
+  const next = {
+    ...current || {},
     schemaVersion: 2,
     runtime: {
+      ...current?.runtime || {},
       provider: config.runtime,
       defaultWorkspaceRoot: config.defaultWorkspaceRoot,
       defaultModel: config.defaultModel,
@@ -4837,33 +5010,42 @@ function buildV2FileFromExpandedConfig(config, current) {
       alias: channel.alias?.trim() || defaultAliasForProvider(channel.provider)
     }))
   };
+  Object.defineProperty(next, RAW_CHANNELS, {
+    value: mergeRawChannelRecords(current, next.channels),
+    enumerable: false
+  });
+  return next;
 }
 function loadConfig() {
   const current = readConfigV2File();
   if (current) return expandConfig(current);
-  const legacyEnv = loadRawConfigEnv();
-  if (legacyEnv.size > 0) {
-    const migrated = migrateLegacyEnvToV2(legacyEnv);
-    writeConfigV2File(migrated);
-    return expandConfig(migrated);
-  }
-  const empty = {
-    schemaVersion: 2,
-    runtime: {
-      provider: "codex",
-      defaultWorkspaceRoot: DEFAULT_WORKSPACE_ROOT,
-      defaultMode: "code",
-      historyMessageLimit: 8,
-      streamStatusIdleStartSeconds: DEFAULT_STREAM_STATUS_IDLE_START_SECONDS,
-      streamStatusCheckIntervalSeconds: DEFAULT_STREAM_STATUS_CHECK_INTERVAL_SECONDS,
-      codexSkipGitRepoCheck: true,
-      codexSandboxMode: "workspace-write",
-      codexReasoningEffort: "medium",
-      uiAllowLan: false
-    },
-    channels: []
-  };
-  return expandConfig(empty);
+  return withFileLock(CONFIG_V2_PATH, () => {
+    const concurrentlyCreated = readConfigV2File();
+    if (concurrentlyCreated) return expandConfig(concurrentlyCreated);
+    const legacyEnv = loadRawConfigEnv();
+    if (legacyEnv.size > 0) {
+      const migrated = migrateLegacyEnvToV2(legacyEnv);
+      writeConfigV2File(migrated);
+      return expandConfig(migrated);
+    }
+    const empty = {
+      schemaVersion: 2,
+      runtime: {
+        provider: "codex",
+        defaultWorkspaceRoot: DEFAULT_WORKSPACE_ROOT,
+        defaultMode: "code",
+        historyMessageLimit: 8,
+        streamStatusIdleStartSeconds: DEFAULT_STREAM_STATUS_IDLE_START_SECONDS,
+        streamStatusCheckIntervalSeconds: DEFAULT_STREAM_STATUS_CHECK_INTERVAL_SECONDS,
+        codexSkipGitRepoCheck: true,
+        codexSandboxMode: "workspace-write",
+        codexReasoningEffort: "medium",
+        uiAllowLan: false
+      },
+      channels: []
+    };
+    return expandConfig(empty);
+  });
 }
 function formatEnvLine(key, value) {
   if (value === void 0 || value === "") return "";
@@ -4871,64 +5053,63 @@ function formatEnvLine(key, value) {
 `;
 }
 function saveConfig(config) {
-  const current = readConfigV2File();
-  const next = buildV2FileFromExpandedConfig(config, current);
-  writeConfigV2File(next);
-  let out = "";
-  out += formatEnvLine("CTI_RUNTIME", next.runtime.provider);
-  out += formatEnvLine(
-    "CTI_ENABLED_CHANNELS",
-    Array.from(new Set(next.channels.filter((channel) => channel.enabled).map((channel) => channel.provider))).join(",")
-  );
-  out += formatEnvLine("CTI_DEFAULT_WORKSPACE_ROOT", next.runtime.defaultWorkspaceRoot);
-  out += formatEnvLine("CTI_DEFAULT_MODEL", next.runtime.defaultModel);
-  out += formatEnvLine("CTI_DEFAULT_MODE", next.runtime.defaultMode);
-  if (next.runtime.historyMessageLimit !== void 0) {
-    out += formatEnvLine("CTI_HISTORY_MESSAGE_LIMIT", String(next.runtime.historyMessageLimit));
-  }
-  if (next.runtime.streamStatusIdleStartSeconds !== void 0) {
-    out += formatEnvLine("CTI_STREAM_STATUS_IDLE_START_SECONDS", String(next.runtime.streamStatusIdleStartSeconds));
-  }
-  if (next.runtime.streamStatusCheckIntervalSeconds !== void 0) {
-    out += formatEnvLine("CTI_STREAM_STATUS_CHECK_INTERVAL_SECONDS", String(next.runtime.streamStatusCheckIntervalSeconds));
-  }
-  if (next.runtime.codexSkipGitRepoCheck !== void 0) {
-    out += formatEnvLine("CTI_CODEX_SKIP_GIT_REPO_CHECK", String(next.runtime.codexSkipGitRepoCheck));
-  }
-  out += formatEnvLine("CTI_CODEX_SANDBOX_MODE", next.runtime.codexSandboxMode);
-  out += formatEnvLine("CTI_CODEX_REASONING_EFFORT", next.runtime.codexReasoningEffort);
-  out += formatEnvLine("CTI_UI_ALLOW_LAN", String(next.runtime.uiAllowLan === true));
-  out += formatEnvLine("CTI_UI_ACCESS_TOKEN", next.runtime.uiAccessToken);
-  const feishu = getChannelByProvider(next, "feishu");
-  const feishuConfig = toFeishuConfig(feishu);
-  if (feishuConfig) {
-    out += formatEnvLine("CTI_FEISHU_APP_ID", feishuConfig.appId);
-    out += formatEnvLine("CTI_FEISHU_APP_SECRET", feishuConfig.appSecret);
-    out += formatEnvLine("CTI_FEISHU_SITE", feishuConfig.site);
-    out += formatEnvLine("CTI_FEISHU_ALLOWED_USERS", feishuConfig.allowedUsers?.join(","));
-    if (feishuConfig.streamingEnabled !== void 0) {
-      out += formatEnvLine("CTI_FEISHU_STREAMING_ENABLED", String(feishuConfig.streamingEnabled));
-    }
-    if (feishuConfig.feedbackMarkdownEnabled !== void 0) {
-      out += formatEnvLine("CTI_FEISHU_COMMAND_MARKDOWN_ENABLED", String(feishuConfig.feedbackMarkdownEnabled));
-    }
-  }
-  const weixin = getChannelByProvider(next, "weixin");
-  const weixinConfig = toWeixinConfig(weixin);
-  if (weixinConfig) {
-    out += formatEnvLine("CTI_WEIXIN_BASE_URL", weixinConfig.baseUrl);
-    out += formatEnvLine("CTI_WEIXIN_CDN_BASE_URL", weixinConfig.cdnBaseUrl);
-    if (weixinConfig.mediaEnabled !== void 0) {
-      out += formatEnvLine("CTI_WEIXIN_MEDIA_ENABLED", String(weixinConfig.mediaEnabled));
-    }
-    if (weixinConfig.feedbackMarkdownEnabled !== void 0) {
-      out += formatEnvLine("CTI_WEIXIN_COMMAND_MARKDOWN_ENABLED", String(weixinConfig.feedbackMarkdownEnabled));
-    }
-  }
-  ensureConfigDir();
-  const tmpPath = CONFIG_PATH + ".tmp";
-  fs.writeFileSync(tmpPath, out, { mode: 384 });
-  fs.renameSync(tmpPath, CONFIG_PATH);
+  withFileLock(CONFIG_V2_PATH, () => {
+    const current = readConfigV2File();
+    const next = buildV2FileFromExpandedConfig(config, current);
+    writeConfigV2File(next);
+    let out = "";
+    out += formatEnvLine("CTI_RUNTIME", next.runtime.provider);
+    out += formatEnvLine(
+      "CTI_ENABLED_CHANNELS",
+      Array.from(new Set(next.channels.filter((channel) => channel.enabled).map((channel) => channel.provider))).join(",")
+    );
+    out += formatEnvLine("CTI_DEFAULT_WORKSPACE_ROOT", next.runtime.defaultWorkspaceRoot);
+    out += formatEnvLine("CTI_DEFAULT_MODEL", next.runtime.defaultModel);
+    out += formatEnvLine("CTI_DEFAULT_MODE", next.runtime.defaultMode);
+    if (next.runtime.historyMessageLimit !== void 0) {
+      out += formatEnvLine("CTI_HISTORY_MESSAGE_LIMIT", String(next.runtime.historyMessageLimit));
+    }
+    if (next.runtime.streamStatusIdleStartSeconds !== void 0) {
+      out += formatEnvLine("CTI_STREAM_STATUS_IDLE_START_SECONDS", String(next.runtime.streamStatusIdleStartSeconds));
+    }
+    if (next.runtime.streamStatusCheckIntervalSeconds !== void 0) {
+      out += formatEnvLine("CTI_STREAM_STATUS_CHECK_INTERVAL_SECONDS", String(next.runtime.streamStatusCheckIntervalSeconds));
+    }
+    if (next.runtime.codexSkipGitRepoCheck !== void 0) {
+      out += formatEnvLine("CTI_CODEX_SKIP_GIT_REPO_CHECK", String(next.runtime.codexSkipGitRepoCheck));
+    }
+    out += formatEnvLine("CTI_CODEX_SANDBOX_MODE", next.runtime.codexSandboxMode);
+    out += formatEnvLine("CTI_CODEX_REASONING_EFFORT", next.runtime.codexReasoningEffort);
+    out += formatEnvLine("CTI_UI_ALLOW_LAN", String(next.runtime.uiAllowLan === true));
+    out += formatEnvLine("CTI_UI_ACCESS_TOKEN", next.runtime.uiAccessToken);
+    const feishu = getChannelByProvider(next, "feishu");
+    const feishuConfig = toFeishuConfig(feishu);
+    if (feishuConfig) {
+      out += formatEnvLine("CTI_FEISHU_APP_ID", feishuConfig.appId);
+      out += formatEnvLine("CTI_FEISHU_APP_SECRET", feishuConfig.appSecret);
+      out += formatEnvLine("CTI_FEISHU_SITE", feishuConfig.site);
+      out += formatEnvLine("CTI_FEISHU_ALLOWED_USERS", feishuConfig.allowedUsers?.join(","));
+      if (feishuConfig.streamingEnabled !== void 0) {
+        out += formatEnvLine("CTI_FEISHU_STREAMING_ENABLED", String(feishuConfig.streamingEnabled));
+      }
+      if (feishuConfig.feedbackMarkdownEnabled !== void 0) {
+        out += formatEnvLine("CTI_FEISHU_COMMAND_MARKDOWN_ENABLED", String(feishuConfig.feedbackMarkdownEnabled));
+      }
+    }
+    const weixin = getChannelByProvider(next, "weixin");
+    const weixinConfig = toWeixinConfig(weixin);
+    if (weixinConfig) {
+      out += formatEnvLine("CTI_WEIXIN_BASE_URL", weixinConfig.baseUrl);
+      out += formatEnvLine("CTI_WEIXIN_CDN_BASE_URL", weixinConfig.cdnBaseUrl);
+      if (weixinConfig.mediaEnabled !== void 0) {
+        out += formatEnvLine("CTI_WEIXIN_MEDIA_ENABLED", String(weixinConfig.mediaEnabled));
+      }
+      if (weixinConfig.feedbackMarkdownEnabled !== void 0) {
+        out += formatEnvLine("CTI_WEIXIN_COMMAND_MARKDOWN_ENABLED", String(weixinConfig.feedbackMarkdownEnabled));
+      }
+    }
+    atomicWriteFile(CONFIG_PATH, out);
+  });
 }
 function listChannelInstances(config) {
   return [...config?.channels || loadConfig().channels || []];
@@ -5025,10 +5206,10 @@ function configToSettings(config) {
 }
 
 // src/desktop-sessions.ts
-import fs2 from "node:fs";
+import fs3 from "node:fs";
 import os2 from "node:os";
 import path2 from "node:path";
-import crypto from "node:crypto";
+import crypto3 from "node:crypto";
 import { DatabaseSync } from "node:sqlite";
 var ACTIVE_WINDOW_MS = 15 * 60 * 1e3;
 var MAX_SESSION_META_BYTES = 4 * 1024 * 1024;
@@ -5053,13 +5234,13 @@ function getDesktopStateDbPath() {
   const codexHome = getCodexHome();
   let entries;
   try {
-    entries = fs2.readdirSync(codexHome, { withFileTypes: true });
+    entries = fs3.readdirSync(codexHome, { withFileTypes: true });
   } catch {
     return null;
   }
   const candidates = entries.filter((entry) => entry.isFile() && /^state_\d+\.sqlite$/i.test(entry.name)).map((entry) => path2.join(codexHome, entry.name)).sort((left, right) => {
     try {
-      return fs2.statSync(right).mtimeMs - fs2.statSync(left).mtimeMs;
+      return fs3.statSync(right).mtimeMs - fs3.statSync(left).mtimeMs;
     } catch {
       return 0;
     }
@@ -5084,10 +5265,10 @@ function isInternalSkillWorkspace(cwd) {
 }
 function loadSavedWorkspaceRoots() {
   const statePath = getCodexGlobalStatePath();
-  if (!fs2.existsSync(statePath)) return null;
+  if (!fs3.existsSync(statePath)) return null;
   let parsed;
   try {
-    parsed = JSON.parse(fs2.readFileSync(statePath, "utf-8"));
+    parsed = JSON.parse(fs3.readFileSync(statePath, "utf-8"));
   } catch {
     return null;
   }
@@ -5102,10 +5283,10 @@ function isWithinSavedWorkspaceRoots(cwd, roots) {
 }
 function loadArchivedThreadIds() {
   const archivedRoot = getArchivedSessionsRoot();
-  if (!fs2.existsSync(archivedRoot)) return /* @__PURE__ */ new Set();
+  if (!fs3.existsSync(archivedRoot)) return /* @__PURE__ */ new Set();
   let entries;
   try {
-    entries = fs2.readdirSync(archivedRoot, { withFileTypes: true });
+    entries = fs3.readdirSync(archivedRoot, { withFileTypes: true });
   } catch {
     return /* @__PURE__ */ new Set();
   }
@@ -5118,13 +5299,13 @@ function loadArchivedThreadIds() {
   return ids;
 }
 function readFirstLine(filePath, maxBytes = MAX_SESSION_META_BYTES) {
-  const fd = fs2.openSync(filePath, "r");
+  const fd = fs3.openSync(filePath, "r");
   try {
     const chunks = [];
     let bytesReadTotal = 0;
     const buffer = Buffer.alloc(4096);
     while (bytesReadTotal < maxBytes) {
-      const bytesRead = fs2.readSync(fd, buffer, 0, buffer.length, bytesReadTotal);
+      const bytesRead = fs3.readSync(fd, buffer, 0, buffer.length, bytesReadTotal);
       if (bytesRead <= 0) break;
       const slice = Buffer.from(buffer.subarray(0, bytesRead));
       chunks.push(slice);
@@ -5137,31 +5318,31 @@ function readFirstLine(filePath, maxBytes = MAX_SESSION_META_BYTES) {
     }
     return Buffer.concat(chunks).toString("utf-8").split(/\r?\n/, 1)[0] || "";
   } finally {
-    fs2.closeSync(fd);
+    fs3.closeSync(fd);
   }
 }
 function readFilePrefix(filePath, maxBytes = MAX_SESSION_TITLE_SCAN_BYTES) {
-  const fd = fs2.openSync(filePath, "r");
+  const fd = fs3.openSync(filePath, "r");
   try {
     const buffer = Buffer.alloc(Math.min(maxBytes, 64 * 1024));
     const chunks = [];
     let offset = 0;
     while (offset < maxBytes) {
       const bytesToRead = Math.min(buffer.length, maxBytes - offset);
-      const bytesRead = fs2.readSync(fd, buffer, 0, bytesToRead, offset);
+      const bytesRead = fs3.readSync(fd, buffer, 0, bytesToRead, offset);
       if (bytesRead <= 0) break;
       chunks.push(Buffer.from(buffer.subarray(0, bytesRead)));
       offset += bytesRead;
     }
     return Buffer.concat(chunks).toString("utf-8");
   } finally {
-    fs2.closeSync(fd);
+    fs3.closeSync(fd);
   }
 }
 function walkSessionFiles(dirPath, target) {
   let entries;
   try {
-    entries = fs2.readdirSync(dirPath, { withFileTypes: true });
+    entries = fs3.readdirSync(dirPath, { withFileTypes: true });
   } catch {
     return;
   }
@@ -5184,10 +5365,10 @@ function isDesktopLike(meta) {
 }
 function loadThreadIndexEntries(archivedThreadIds) {
   const indexPath = getSessionIndexPath();
-  if (!fs2.existsSync(indexPath)) return /* @__PURE__ */ new Map();
+  if (!fs3.existsSync(indexPath)) return /* @__PURE__ */ new Map();
   let content = "";
   try {
-    content = fs2.readFileSync(indexPath, "utf-8");
+    content = fs3.readFileSync(indexPath, "utf-8");
   } catch {
     return /* @__PURE__ */ new Map();
   }
@@ -5227,7 +5408,7 @@ function parseUpdatedAtValue(value) {
 }
 function loadVisibleDesktopThreads(limit) {
   const dbPath = getDesktopStateDbPath();
-  if (!dbPath || !fs2.existsSync(dbPath)) return null;
+  if (!dbPath || !fs3.existsSync(dbPath)) return null;
   let db = null;
   try {
     db = new DatabaseSync(dbPath, { readOnly: true });
@@ -5294,7 +5475,7 @@ function parseDesktopSession(filePath, threadIndexEntries, archivedThreadIds) {
   }
   let stat;
   try {
-    stat = fs2.statSync(filePath);
+    stat = fs3.statSync(filePath);
   } catch {
     return null;
   }
@@ -5369,7 +5550,7 @@ function isSessionEventLine(line) {
 }
 function listDesktopSessions(limit) {
   const root = getCodexSessionsRoot();
-  if (!fs2.existsSync(root)) return [];
+  if (!fs3.existsSync(root)) return [];
   const archivedThreadIds = loadArchivedThreadIds();
   const threadIndexEntries = loadThreadIndexEntries(archivedThreadIds);
   const savedWorkspaceRoots = loadSavedWorkspaceRoots();
@@ -5407,9 +5588,17 @@ function listDesktopSessions(limit) {
   }
   return sessions.sort((a, b) => b.lastEventAt.localeCompare(a.lastEventAt)).slice(0, typeof limit === "number" && Number.isFinite(limit) && limit > 0 ? Math.max(1, Math.floor(limit)) : void 0);
 }
+var DESKTOP_SESSION_LOOKUP_CACHE_TTL_MS = 1e3;
+var desktopSessionLookupCache = null;
 function getDesktopSessionByThreadId(threadId) {
-  const sessions = listDesktopSessions(200);
-  return sessions.find((session) => session.threadId === threadId) || null;
+  const timestamp = Date.now();
+  if (!desktopSessionLookupCache || desktopSessionLookupCache.expiresAt <= timestamp) {
+    desktopSessionLookupCache = {
+      expiresAt: timestamp + DESKTOP_SESSION_LOOKUP_CACHE_TTL_MS,
+      sessions: new Map(listDesktopSessions().map((session) => [session.threadId, session]))
+    };
+  }
+  return desktopSessionLookupCache.sessions.get(threadId) || null;
 }
 function isArchivedDesktopThread(threadId) {
   return loadArchivedThreadIds().has(threadId);
@@ -5727,25 +5916,25 @@ function removeBinding(store, bindingId) {
 }
 
 // src/service-manager.ts
-import fs4 from "node:fs";
+import fs5 from "node:fs";
 import os3 from "node:os";
 import path5 from "node:path";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 
 // src/bridge-instance-lock.ts
-import fs3 from "node:fs";
+import fs4 from "node:fs";
 import path4 from "node:path";
 var runtimeDir = path4.join(CTI_HOME, "runtime");
 var bridgeInstanceLockFile = path4.join(runtimeDir, "bridge.instance.lock");
 function readJsonFile(filePath, fallback) {
   try {
-    return JSON.parse(fs3.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs4.readFileSync(filePath, "utf-8"));
   } catch {
     return fallback;
   }
 }
-function isProcessAlive(pid) {
+function isProcessAlive2(pid) {
   if (!pid) return false;
   try {
     process.kill(pid, 0);
@@ -5761,11 +5950,11 @@ function readBridgeInstanceLock(filePath = bridgeInstanceLockFile) {
   if (!Number.isFinite(pid) || pid <= 0 || !createdAt) return null;
   return { pid, createdAt };
 }
-function clearStaleBridgeInstanceLock(filePath = bridgeInstanceLockFile, isAlive = isProcessAlive) {
+function clearStaleBridgeInstanceLock(filePath = bridgeInstanceLockFile, isAlive = isProcessAlive2) {
   const existing = readBridgeInstanceLock(filePath);
   if (existing && isAlive(existing.pid)) return;
   try {
-    fs3.unlinkSync(filePath);
+    fs4.unlinkSync(filePath);
   } catch {
   }
 }
@@ -5786,26 +5975,26 @@ var npmUninstallLogFile = path5.join(runtimeDir2, "npm-uninstall.log");
 var WINDOWS_HIDE = process.platform === "win32" ? { windowsHide: true } : {};
 var BRIDGE_START_LOCK_STALE_MS = 3e4;
 function ensureDirs() {
-  fs4.mkdirSync(runtimeDir2, { recursive: true });
-  fs4.mkdirSync(logsDir, { recursive: true });
+  fs5.mkdirSync(runtimeDir2, { recursive: true });
+  fs5.mkdirSync(logsDir, { recursive: true });
 }
 function readJsonFile2(filePath, fallback) {
   try {
-    return JSON.parse(fs4.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs5.readFileSync(filePath, "utf-8"));
   } catch {
     return fallback;
   }
 }
 function readPid(filePath) {
   try {
-    const raw = fs4.readFileSync(filePath, "utf-8").trim();
+    const raw = fs5.readFileSync(filePath, "utf-8").trim();
     const pid = Number(raw);
     return Number.isFinite(pid) ? pid : void 0;
   } catch {
     return void 0;
   }
 }
-function isProcessAlive2(pid) {
+function isProcessAlive3(pid) {
   if (!pid) return false;
   try {
     process.kill(pid, 0);
@@ -5823,7 +6012,7 @@ function collectTrackedBridgePids(bridgePid, statusPid, instanceLockPid) {
   }
   return [...unique];
 }
-function resolveTrackedBridgePid(bridgePid, statusPid, instanceLockPid, isAlive = isProcessAlive2) {
+function resolveTrackedBridgePid(bridgePid, statusPid, instanceLockPid, isAlive = isProcessAlive3) {
   if (isAlive(bridgePid)) return bridgePid;
   if (isAlive(statusPid)) return statusPid;
   if (isAlive(instanceLockPid)) return instanceLockPid;
@@ -5839,7 +6028,7 @@ function getTrackedBridgePids(status) {
 }
 function clearBridgePidFile() {
   try {
-    fs4.unlinkSync(bridgePidFile);
+    fs5.unlinkSync(bridgePidFile);
   } catch {
   }
 }
@@ -5854,7 +6043,7 @@ function isBridgeStartLockStale(lock, options = {}) {
   if (!lock) return true;
   const nowMs = options.nowMs ?? Date.now();
   const staleMs = options.staleMs ?? BRIDGE_START_LOCK_STALE_MS;
-  const isAlive = options.isAlive ?? isProcessAlive2;
+  const isAlive = options.isAlive ?? isProcessAlive3;
   const createdAtMs = Date.parse(lock.createdAt);
   if (!Number.isFinite(createdAtMs)) return true;
   if (!isAlive(lock.pid)) return true;
@@ -5870,7 +6059,7 @@ function tryAcquireBridgeStartLock(options = {}) {
   };
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      fs4.writeFileSync(filePath, JSON.stringify(payload, null, 2), { encoding: "utf-8", flag: "wx" });
+      fs5.writeFileSync(filePath, JSON.stringify(payload, null, 2), { encoding: "utf-8", flag: "wx" });
       return { acquired: true };
     } catch (error) {
       const code = error.code;
@@ -5884,7 +6073,7 @@ function tryAcquireBridgeStartLock(options = {}) {
         return { acquired: false, holderPid: existing2?.pid };
       }
       try {
-        fs4.unlinkSync(filePath);
+        fs5.unlinkSync(filePath);
       } catch {
       }
     }
@@ -5896,14 +6085,14 @@ function releaseBridgeStartLock(filePath = bridgeStartLockFile, ownerPid = proce
   const existing = readBridgeStartLock(filePath);
   if (!existing) {
     try {
-      fs4.unlinkSync(filePath);
+      fs5.unlinkSync(filePath);
     } catch {
     }
     return;
   }
   if (existing.pid !== ownerPid) return;
   try {
-    fs4.unlinkSync(filePath);
+    fs5.unlinkSync(filePath);
   } catch {
   }
 }
@@ -5966,7 +6155,7 @@ function getBridgeStatus() {
     status.pid,
     readBridgeInstanceLock()?.pid
   );
-  if (!isProcessAlive2(pid)) {
+  if (!isProcessAlive3(pid)) {
     return {
       ...status,
       pid,
@@ -5981,7 +6170,7 @@ function getBridgeStatus() {
 }
 function getUiServerStatus() {
   const status = readJsonFile2(uiStatusFile, { running: false, port: uiPort });
-  if (!isProcessAlive2(status.pid)) {
+  if (!isProcessAlive3(status.pid)) {
     return {
       ...status,
       running: false,
@@ -6051,7 +6240,7 @@ async function waitForBridgeStartupTurn(timeoutMs = 2e4) {
 async function startBridge() {
   ensureDirs();
   const current = getBridgeStatus();
-  const extraAlivePids = getTrackedBridgePids(current).filter((pid) => pid !== current.pid && isProcessAlive2(pid));
+  const extraAlivePids = getTrackedBridgePids(current).filter((pid) => pid !== current.pid && isProcessAlive3(pid));
   if (current.running && extraAlivePids.length === 0) return current;
   if (current.running && extraAlivePids.length > 0) {
     await stopBridge();
@@ -6076,17 +6265,17 @@ async function startBridge() {
   startLockHeld = true;
   try {
     const currentAfterLock = getBridgeStatus();
-    const extraAlivePidsAfterLock = getTrackedBridgePids(currentAfterLock).filter((pid) => pid !== currentAfterLock.pid && isProcessAlive2(pid));
+    const extraAlivePidsAfterLock = getTrackedBridgePids(currentAfterLock).filter((pid) => pid !== currentAfterLock.pid && isProcessAlive3(pid));
     if (currentAfterLock.running && extraAlivePidsAfterLock.length === 0) return currentAfterLock;
     if (currentAfterLock.running && extraAlivePidsAfterLock.length > 0) {
       await stopBridge();
     }
     const daemonEntry = path5.join(packageRoot, "dist", "daemon.mjs");
-    if (!fs4.existsSync(daemonEntry)) {
+    if (!fs5.existsSync(daemonEntry)) {
       throw new Error(`Daemon bundle not found at ${daemonEntry}. Run npm run build first.`);
     }
-    const stdoutFd = fs4.openSync(path5.join(logsDir, "bridge-launcher.out.log"), "a");
-    const stderrFd = fs4.openSync(path5.join(logsDir, "bridge-launcher.err.log"), "a");
+    const stdoutFd = fs5.openSync(path5.join(logsDir, "bridge-launcher.out.log"), "a");
+    const stderrFd = fs5.openSync(path5.join(logsDir, "bridge-launcher.err.log"), "a");
     const child = spawn(process.execPath, [daemonEntry], {
       cwd: packageRoot,
       detached: true,
@@ -6110,7 +6299,7 @@ async function startBridge() {
 }
 async function stopBridge() {
   const status = readJsonFile2(bridgeStatusFile, { running: false });
-  const pids = getTrackedBridgePids(status).filter((pid) => isProcessAlive2(pid));
+  const pids = getTrackedBridgePids(status).filter((pid) => isProcessAlive3(pid));
   if (pids.length === 0) {
     clearBridgePidFile();
     clearStaleBridgeInstanceLock();
@@ -6135,7 +6324,7 @@ async function stopBridge() {
   }
   const startedAt = Date.now();
   while (Date.now() - startedAt < 1e4) {
-    if (pids.every((pid) => !isProcessAlive2(pid))) {
+    if (pids.every((pid) => !isProcessAlive3(pid))) {
       clearBridgePidFile();
       clearStaleBridgeInstanceLock();
       return getBridgeStatus();
@@ -6207,30 +6396,30 @@ async function getBridgeAutostartStatus() {
 function getBridgeLogs(lines = 200) {
   ensureDirs();
   const filePath = path5.join(logsDir, "bridge.log");
-  if (!fs4.existsSync(filePath)) return "";
-  const all = fs4.readFileSync(filePath, "utf-8").split(/\r?\n/);
+  if (!fs5.existsSync(filePath)) return "";
+  const all = fs5.readFileSync(filePath, "utf-8").split(/\r?\n/);
   return all.slice(Math.max(0, all.length - lines)).join("\n");
 }
 function writeUiServerStatus(status) {
   ensureDirs();
-  fs4.writeFileSync(uiStatusFile, JSON.stringify(status, null, 2), "utf-8");
+  fs5.writeFileSync(uiStatusFile, JSON.stringify(status, null, 2), "utf-8");
 }
 async function installCodexIntegration() {
   const sourceSkill = path5.join(packageRoot, "SKILL.md");
-  if (!fs4.existsSync(sourceSkill)) {
+  if (!fs5.existsSync(sourceSkill)) {
     throw new Error(`SKILL.md not found at ${sourceSkill}`);
   }
   const skillsDir = path5.join(os3.homedir(), ".codex", "skills");
   const targetDir = path5.join(skillsDir, "codex-to-im");
-  fs4.mkdirSync(skillsDir, { recursive: true });
-  if (fs4.existsSync(targetDir)) {
+  fs5.mkdirSync(skillsDir, { recursive: true });
+  if (fs5.existsSync(targetDir)) {
     return { targetDir, method: "existing" };
   }
   try {
-    fs4.symlinkSync(packageRoot, targetDir, process.platform === "win32" ? "junction" : "dir");
+    fs5.symlinkSync(packageRoot, targetDir, process.platform === "win32" ? "junction" : "dir");
     return { targetDir, method: "junction" };
   } catch {
-    fs4.cpSync(packageRoot, targetDir, {
+    fs5.cpSync(packageRoot, targetDir, {
       recursive: true,
       filter: (source) => {
         const relative = path5.relative(packageRoot, source);
@@ -6245,36 +6434,55 @@ async function installCodexIntegration() {
 }
 function isCodexIntegrationInstalled() {
   const targetDir = path5.join(os3.homedir(), ".codex", "skills", "codex-to-im");
-  return fs4.existsSync(path5.join(targetDir, "SKILL.md"));
+  return fs5.existsSync(path5.join(targetDir, "SKILL.md"));
 }
 
 // src/store.ts
-import fs5 from "node:fs";
+import fs6 from "node:fs";
 import path6 from "node:path";
-import crypto2 from "node:crypto";
+import crypto4 from "node:crypto";
 var DATA_DIR = path6.join(CTI_HOME, "data");
 var MESSAGES_DIR = path6.join(DATA_DIR, "messages");
+var SESSIONS_PATH = path6.join(DATA_DIR, "sessions.json");
+var BINDINGS_PATH = path6.join(DATA_DIR, "bindings.json");
+var PERMISSIONS_PATH = path6.join(DATA_DIR, "permissions.json");
+var OFFSETS_PATH = path6.join(DATA_DIR, "offsets.json");
+var DEDUP_PATH = path6.join(DATA_DIR, "dedup.json");
+var AUDIT_PATH = path6.join(DATA_DIR, "audit.json");
+var DEFAULT_DEDUP_TTL_MS = 5 * 60 * 1e3;
+var INBOUND_DEDUP_TTL_MS = 24 * 60 * 60 * 1e3;
 function ensureDir(dir) {
-  fs5.mkdirSync(dir, { recursive: true });
+  fs6.mkdirSync(dir, { recursive: true });
 }
 function atomicWrite(filePath, data) {
-  const tmp = filePath + ".tmp";
-  fs5.writeFileSync(tmp, data, "utf-8");
-  fs5.renameSync(tmp, filePath);
+  const tmp = `${filePath}.${process.pid}.${crypto4.randomUUID()}.tmp`;
+  try {
+    fs6.writeFileSync(tmp, data, "utf-8");
+    fs6.renameSync(tmp, filePath);
+  } finally {
+    try {
+      fs6.rmSync(tmp, { force: true });
+    } catch {
+    }
+  }
+}
+function dedupTtlMs(key) {
+  return key.startsWith("inbound:") ? INBOUND_DEDUP_TTL_MS : DEFAULT_DEDUP_TTL_MS;
 }
 function readJson(filePath, fallback) {
   try {
-    const raw = fs5.readFileSync(filePath, "utf-8");
+    const raw = fs6.readFileSync(filePath, "utf-8");
     return JSON.parse(raw);
-  } catch {
-    return fallback;
+  } catch (error) {
+    if (error.code === "ENOENT") return fallback;
+    throw new Error(`\u65E0\u6CD5\u8BFB\u53D6 JSON \u6570\u636E\u6587\u4EF6 ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
   }
 }
 function writeJson(filePath, data) {
   atomicWrite(filePath, JSON.stringify(data, null, 2));
 }
 function uuid() {
-  return crypto2.randomUUID();
+  return crypto4.randomUUID();
 }
 function now() {
   return (/* @__PURE__ */ new Date()).toISOString();
@@ -6333,38 +6541,38 @@ var JsonFileStore = class {
     this.reloadSessions();
     this.reloadBindings();
     const perms = readJson(
-      path6.join(DATA_DIR, "permissions.json"),
+      PERMISSIONS_PATH,
       {}
     );
     for (const [id, p] of Object.entries(perms)) {
       this.permissionLinks.set(id, p);
     }
     const offsets = readJson(
-      path6.join(DATA_DIR, "offsets.json"),
+      OFFSETS_PATH,
       {}
     );
     for (const [k, v] of Object.entries(offsets)) {
       this.offsets.set(k, v);
     }
     const dedup = readJson(
-      path6.join(DATA_DIR, "dedup.json"),
+      DEDUP_PATH,
       {}
     );
     for (const [k, v] of Object.entries(dedup)) {
       this.dedupKeys.set(k, v);
     }
-    this.auditLog = readJson(path6.join(DATA_DIR, "audit.json"), []);
+    this.auditLog = readJson(AUDIT_PATH, []);
   }
   reloadSessions() {
     const sessions = readJson(
-      path6.join(DATA_DIR, "sessions.json"),
+      SESSIONS_PATH,
       {}
     );
     this.sessions = new Map(Object.entries(sessions));
   }
   reloadBindings() {
     const bindings = readJson(
-      path6.join(DATA_DIR, "bindings.json"),
+      BINDINGS_PATH,
       {}
     );
     const normalized = /* @__PURE__ */ new Map();
@@ -6378,41 +6586,62 @@ var JsonFileStore = class {
     }
     this.bindings = normalized;
     if (changed) {
-      this.persistBindings();
+      withFileLock(BINDINGS_PATH, () => {
+        const latest = readJson(BINDINGS_PATH, {});
+        this.bindings = new Map(Object.values(latest).map((binding) => {
+          const upgraded = upgradeLegacyBinding(binding);
+          return [`${upgraded.channelType}:${upgraded.chatId}`, upgraded];
+        }));
+        this.persistBindings();
+      });
     }
   }
+  reloadPermissions() {
+    this.permissionLinks = new Map(Object.entries(
+      readJson(PERMISSIONS_PATH, {})
+    ));
+  }
+  reloadOffsets() {
+    this.offsets = new Map(Object.entries(readJson(OFFSETS_PATH, {})));
+  }
+  reloadDedup() {
+    this.dedupKeys = new Map(Object.entries(readJson(DEDUP_PATH, {})));
+  }
+  reloadAudit() {
+    this.auditLog = readJson(AUDIT_PATH, []);
+  }
   persistSessions() {
     writeJson(
-      path6.join(DATA_DIR, "sessions.json"),
+      SESSIONS_PATH,
       Object.fromEntries(this.sessions)
     );
   }
   persistBindings() {
     writeJson(
-      path6.join(DATA_DIR, "bindings.json"),
+      BINDINGS_PATH,
       Object.fromEntries(this.bindings)
     );
   }
   persistPermissions() {
     writeJson(
-      path6.join(DATA_DIR, "permissions.json"),
+      PERMISSIONS_PATH,
       Object.fromEntries(this.permissionLinks)
     );
   }
   persistOffsets() {
     writeJson(
-      path6.join(DATA_DIR, "offsets.json"),
+      OFFSETS_PATH,
       Object.fromEntries(this.offsets)
     );
   }
   persistDedup() {
     writeJson(
-      path6.join(DATA_DIR, "dedup.json"),
+      DEDUP_PATH,
       Object.fromEntries(this.dedupKeys)
     );
   }
   persistAudit() {
-    writeJson(path6.join(DATA_DIR, "audit.json"), this.auditLog);
+    writeJson(AUDIT_PATH, this.auditLog);
   }
   persistMessages(sessionId) {
     const msgs = this.messages.get(sessionId) || [];
@@ -6429,6 +6658,32 @@ var JsonFileStore = class {
     this.messages.set(sessionId, msgs);
     return msgs;
   }
+  mutateBindings(mutation) {
+    return withFileLock(BINDINGS_PATH, () => {
+      this.reloadBindings();
+      const result = mutation();
+      this.persistBindings();
+      return result;
+    });
+  }
+  mutateSessions(mutation) {
+    return withFileLock(SESSIONS_PATH, () => {
+      this.reloadSessions();
+      const result = mutation();
+      this.persistSessions();
+      return result;
+    });
+  }
+  mutateMessages(sessionId, mutation) {
+    const messagePath = path6.join(MESSAGES_DIR, `${sessionId}.json`);
+    return withFileLock(messagePath, () => {
+      const messages = readJson(messagePath, []);
+      this.messages.set(sessionId, messages);
+      const result = mutation(messages);
+      this.persistMessages(sessionId);
+      return result;
+    });
+  }
   // ── Settings ──
   refreshSettings() {
     if (!this.dynamicSettings) return;
@@ -6451,66 +6706,65 @@ var JsonFileStore = class {
     return this.bindings.get(`${channelType}:${chatId}`) ?? null;
   }
   upsertChannelBinding(data) {
-    this.reloadBindings();
-    const key = `${data.channelType}:${data.chatId}`;
-    const existing = this.bindings.get(key);
-    if (existing) {
-      const updated = {
-        ...existing,
+    return this.mutateBindings(() => {
+      const key = `${data.channelType}:${data.chatId}`;
+      const existing = this.bindings.get(key);
+      if (existing) {
+        const updated = {
+          ...existing,
+          codepilotSessionId: data.codepilotSessionId,
+          sdkSessionId: data.sdkSessionId ?? existing.sdkSessionId,
+          channelProvider: data.channelProvider ?? existing.channelProvider,
+          channelAlias: data.channelAlias ?? existing.channelAlias,
+          chatUserId: data.chatUserId ?? existing.chatUserId,
+          chatDisplayName: data.chatDisplayName ?? existing.chatDisplayName,
+          workingDirectory: data.workingDirectory,
+          model: data.model,
+          mode: data.mode ?? existing.mode,
+          updatedAt: now()
+        };
+        this.bindings.set(key, updated);
+        return updated;
+      }
+      const binding = {
+        id: uuid(),
+        channelType: data.channelType,
+        channelProvider: data.channelProvider,
+        channelAlias: data.channelAlias,
+        chatId: data.chatId,
+        chatUserId: data.chatUserId,
+        chatDisplayName: data.chatDisplayName,
         codepilotSessionId: data.codepilotSessionId,
-        sdkSessionId: data.sdkSessionId ?? existing.sdkSessionId,
-        channelProvider: data.channelProvider ?? existing.channelProvider,
-        channelAlias: data.channelAlias ?? existing.channelAlias,
-        chatUserId: data.chatUserId ?? existing.chatUserId,
-        chatDisplayName: data.chatDisplayName ?? existing.chatDisplayName,
+        sdkSessionId: data.sdkSessionId ?? "",
         workingDirectory: data.workingDirectory,
         model: data.model,
-        mode: data.mode ?? existing.mode,
+        mode: data.mode || this.getSetting("bridge_default_mode") || "code",
+        active: true,
+        createdAt: now(),
         updatedAt: now()
       };
-      this.bindings.set(key, updated);
-      this.persistBindings();
-      return updated;
-    }
-    const binding = {
-      id: uuid(),
-      channelType: data.channelType,
-      channelProvider: data.channelProvider,
-      channelAlias: data.channelAlias,
-      chatId: data.chatId,
-      chatUserId: data.chatUserId,
-      chatDisplayName: data.chatDisplayName,
-      codepilotSessionId: data.codepilotSessionId,
-      sdkSessionId: data.sdkSessionId ?? "",
-      workingDirectory: data.workingDirectory,
-      model: data.model,
-      mode: data.mode || this.getSetting("bridge_default_mode") || "code",
-      active: true,
-      createdAt: now(),
-      updatedAt: now()
-    };
-    this.bindings.set(key, binding);
-    this.persistBindings();
-    return binding;
+      this.bindings.set(key, binding);
+      return binding;
+    });
   }
   deleteChannelBinding(id) {
-    this.reloadBindings();
-    for (const [key, binding] of this.bindings) {
-      if (binding.id !== id) continue;
-      this.bindings.delete(key);
-      this.persistBindings();
-      return;
-    }
+    this.mutateBindings(() => {
+      for (const [key, binding] of this.bindings) {
+        if (binding.id !== id) continue;
+        this.bindings.delete(key);
+        return;
+      }
+    });
   }
   updateChannelBinding(id, updates) {
-    this.reloadBindings();
-    for (const [key, b] of this.bindings) {
-      if (b.id === id) {
-        this.bindings.set(key, { ...b, ...updates, updatedAt: now() });
-        this.persistBindings();
-        break;
+    this.mutateBindings(() => {
+      for (const [key, b] of this.bindings) {
+        if (b.id === id) {
+          this.bindings.set(key, { ...b, ...updates, updatedAt: now() });
+          break;
+        }
       }
-    }
+    });
   }
   listChannelBindings(channelType) {
     this.reloadBindings();
@@ -6537,74 +6791,78 @@ var JsonFileStore = class {
     return null;
   }
   createSession(name, model, systemPrompt, cwd, mode, options) {
-    this.reloadSessions();
-    const timestamp = now();
-    const session = {
-      id: uuid(),
-      name,
-      working_directory: cwd || process.cwd(),
-      model,
-      preferred_mode: mode,
-      system_prompt: systemPrompt,
-      reasoning_effort: options?.reasoningEffort,
-      session_type: options?.sessionType || "normal",
-      hidden: options?.hidden === true,
-      parent_session_id: options?.parentSessionId,
-      expires_at: options?.expiresAt,
-      created_at: timestamp,
-      updated_at: timestamp
-    };
-    this.sessions.set(session.id, session);
-    this.persistSessions();
-    return session;
+    return this.mutateSessions(() => {
+      const timestamp = now();
+      const session = {
+        id: uuid(),
+        name,
+        working_directory: cwd || process.cwd(),
+        model,
+        preferred_mode: mode,
+        system_prompt: systemPrompt,
+        reasoning_effort: options?.reasoningEffort,
+        session_type: options?.sessionType || "normal",
+        hidden: options?.hidden === true,
+        parent_session_id: options?.parentSessionId,
+        expires_at: options?.expiresAt,
+        created_at: timestamp,
+        updated_at: timestamp
+      };
+      this.sessions.set(session.id, session);
+      return session;
+    });
   }
   updateSessionProviderId(sessionId, providerId) {
-    this.reloadSessions();
-    const s = this.sessions.get(sessionId);
-    if (s) {
+    this.mutateSessions(() => {
+      const s = this.sessions.get(sessionId);
+      if (!s) return;
       s.provider_id = providerId;
       s.updated_at = now();
-      this.persistSessions();
-    }
+    });
   }
   updateSession(sessionId, updates, options) {
-    this.reloadSessions();
-    const session = this.sessions.get(sessionId);
-    if (!session) return;
-    const next = {
-      ...session,
-      ...updates,
-      id: session.id,
-      updated_at: options?.touch === false ? session.updated_at : now()
-    };
-    this.sessions.set(sessionId, next);
-    this.persistSessions();
+    this.mutateSessions(() => {
+      const session = this.sessions.get(sessionId);
+      if (!session) return;
+      const next = {
+        ...session,
+        ...updates,
+        id: session.id,
+        updated_at: options?.touch === false ? session.updated_at : now()
+      };
+      this.sessions.set(sessionId, next);
+    });
   }
   deleteSession(sessionId) {
-    this.reloadSessions();
-    this.reloadBindings();
-    this.sessions.delete(sessionId);
-    for (const [key, binding] of this.bindings) {
-      if (binding.codepilotSessionId === sessionId) {
-        this.bindings.delete(key);
+    const messagePath = path6.join(MESSAGES_DIR, `${sessionId}.json`);
+    withFileLocks([SESSIONS_PATH, BINDINGS_PATH, messagePath], () => {
+      this.reloadSessions();
+      this.reloadBindings();
+      this.sessions.delete(sessionId);
+      for (const [key, binding] of this.bindings) {
+        if (binding.codepilotSessionId === sessionId) {
+          this.bindings.delete(key);
+        }
       }
-    }
-    this.messages.delete(sessionId);
-    try {
-      fs5.rmSync(path6.join(MESSAGES_DIR, `${sessionId}.json`), { force: true });
-    } catch {
-    }
-    this.persistSessions();
-    this.persistBindings();
+      this.messages.delete(sessionId);
+      try {
+        fs6.rmSync(messagePath, { force: true });
+      } catch {
+      }
+      this.persistSessions();
+      this.persistBindings();
+    });
   }
   // ── Messages ──
   addMessage(sessionId, role, content, _usage) {
-    const msgs = this.loadMessages(sessionId);
-    msgs.push({ role, content });
-    this.persistMessages(sessionId);
+    this.mutateMessages(sessionId, (messages) => {
+      messages.push({ role, content });
+    });
   }
   getMessages(sessionId, opts) {
-    const msgs = this.loadMessages(sessionId);
+    const messagePath = path6.join(MESSAGES_DIR, `${sessionId}.json`);
+    const msgs = readJson(messagePath, []);
+    this.messages.set(sessionId, msgs);
     if (opts?.limit && opts.limit > 0) {
       return { messages: msgs.slice(-opts.limit) };
     }
@@ -6636,61 +6894,62 @@ var JsonFileStore = class {
     }
   }
   setSessionRuntimeStatus(_sessionId, _status) {
-    this.reloadSessions();
-    const session = this.sessions.get(_sessionId);
-    if (!session) return;
-    const queuedCount = session.queued_count && session.queued_count > 0 ? session.queued_count : 0;
-    let runtimeStatus;
-    if (_status === "running") {
-      runtimeStatus = queuedCount > 0 ? "queued" : "running";
-    } else if (_status === "idle") {
-      runtimeStatus = queuedCount > 0 ? "queued" : "idle";
-    } else {
-      runtimeStatus = session.runtime_status;
-    }
-    const next = {
-      ...session,
-      runtime_status: runtimeStatus,
-      last_runtime_update_at: now(),
-      updated_at: now()
-    };
-    this.sessions.set(_sessionId, next);
-    this.persistSessions();
+    this.mutateSessions(() => {
+      const session = this.sessions.get(_sessionId);
+      if (!session) return;
+      const queuedCount = session.queued_count && session.queued_count > 0 ? session.queued_count : 0;
+      let runtimeStatus;
+      if (_status === "running") {
+        runtimeStatus = queuedCount > 0 ? "queued" : "running";
+      } else if (_status === "idle") {
+        runtimeStatus = queuedCount > 0 ? "queued" : "idle";
+      } else {
+        runtimeStatus = session.runtime_status;
+      }
+      const next = {
+        ...session,
+        runtime_status: runtimeStatus,
+        last_runtime_update_at: now(),
+        updated_at: now()
+      };
+      this.sessions.set(_sessionId, next);
+    });
   }
   // ── SDK Session ──
   updateSdkSessionId(sessionId, sdkSessionId) {
-    this.reloadSessions();
-    this.reloadBindings();
-    const s = this.sessions.get(sessionId);
-    if (s) {
-      s.sdk_session_id = sdkSessionId;
-      if (sdkSessionId) {
-        s.codex_thread_id = sdkSessionId;
-        s.thread_origin = s.thread_origin || "bridge";
-      } else {
-        delete s.codex_thread_id;
-        if (s.thread_origin !== "desktop") {
-          delete s.thread_origin;
+    withFileLocks([SESSIONS_PATH, BINDINGS_PATH], () => {
+      this.reloadSessions();
+      this.reloadBindings();
+      const s = this.sessions.get(sessionId);
+      if (s) {
+        s.sdk_session_id = sdkSessionId;
+        if (sdkSessionId) {
+          s.codex_thread_id = sdkSessionId;
+          s.thread_origin = s.thread_origin || "bridge";
+        } else {
+          delete s.codex_thread_id;
+          if (s.thread_origin !== "desktop") {
+            delete s.thread_origin;
+          }
         }
+        s.updated_at = now();
       }
-      s.updated_at = now();
-      this.persistSessions();
-    }
-    for (const [key, b] of this.bindings) {
-      if (b.codepilotSessionId === sessionId) {
-        this.bindings.set(key, { ...b, sdkSessionId, updatedAt: now() });
+      for (const [key, b] of this.bindings) {
+        if (b.codepilotSessionId === sessionId) {
+          this.bindings.set(key, { ...b, sdkSessionId, updatedAt: now() });
+        }
       }
-    }
-    this.persistBindings();
+      this.persistSessions();
+      this.persistBindings();
+    });
   }
   updateSessionModel(sessionId, model) {
-    this.reloadSessions();
-    const s = this.sessions.get(sessionId);
-    if (s) {
+    this.mutateSessions(() => {
+      const s = this.sessions.get(sessionId);
+      if (!s) return;
       s.model = model;
       s.updated_at = now();
-      this.persistSessions();
-    }
+    });
   }
   syncSdkTasks(_sessionId, _todos) {
   }
@@ -6703,66 +6962,84 @@ var JsonFileStore = class {
   }
   // ── Audit & Dedup ──
   insertAuditLog(entry) {
-    this.auditLog.push({
-      ...entry,
-      id: uuid(),
-      createdAt: now()
+    withFileLock(AUDIT_PATH, () => {
+      this.reloadAudit();
+      this.auditLog.push({
+        ...entry,
+        id: uuid(),
+        createdAt: now()
+      });
+      if (this.auditLog.length > 1e3) {
+        this.auditLog = this.auditLog.slice(-1e3);
+      }
+      this.persistAudit();
     });
-    if (this.auditLog.length > 1e3) {
-      this.auditLog = this.auditLog.slice(-1e3);
-    }
-    this.persistAudit();
   }
   checkDedup(key) {
+    this.reloadDedup();
     const ts = this.dedupKeys.get(key);
     if (ts === void 0) return false;
-    if (Date.now() - ts > 5 * 60 * 1e3) {
+    if (Date.now() - ts > dedupTtlMs(key)) {
       this.dedupKeys.delete(key);
       return false;
     }
     return true;
   }
   insertDedup(key) {
-    this.dedupKeys.set(key, Date.now());
-    this.persistDedup();
+    withFileLock(DEDUP_PATH, () => {
+      this.reloadDedup();
+      this.dedupKeys.set(key, Date.now());
+      this.persistDedup();
+    });
   }
   cleanupExpiredDedup() {
-    const cutoff = Date.now() - 5 * 60 * 1e3;
-    let changed = false;
-    for (const [key, ts] of this.dedupKeys) {
-      if (ts < cutoff) {
-        this.dedupKeys.delete(key);
-        changed = true;
+    withFileLock(DEDUP_PATH, () => {
+      this.reloadDedup();
+      const timestamp = Date.now();
+      let changed = false;
+      for (const [key, ts] of this.dedupKeys) {
+        if (timestamp - ts > dedupTtlMs(key)) {
+          this.dedupKeys.delete(key);
+          changed = true;
+        }
       }
-    }
-    if (changed) this.persistDedup();
+      if (changed) this.persistDedup();
+    });
   }
   insertOutboundRef(_ref) {
   }
   // ── Permission Links ──
   insertPermissionLink(link) {
-    const record = {
-      permissionRequestId: link.permissionRequestId,
-      chatId: link.chatId,
-      messageId: link.messageId,
-      sessionId: link.sessionId,
-      resolved: false,
-      suggestions: link.suggestions
-    };
-    this.permissionLinks.set(link.permissionRequestId, record);
-    this.persistPermissions();
+    withFileLock(PERMISSIONS_PATH, () => {
+      this.reloadPermissions();
+      const record = {
+        permissionRequestId: link.permissionRequestId,
+        chatId: link.chatId,
+        messageId: link.messageId,
+        sessionId: link.sessionId,
+        resolved: false,
+        suggestions: link.suggestions
+      };
+      this.permissionLinks.set(link.permissionRequestId, record);
+      this.persistPermissions();
+    });
   }
   getPermissionLink(permissionRequestId) {
+    this.reloadPermissions();
     return this.permissionLinks.get(permissionRequestId) ?? null;
   }
   markPermissionLinkResolved(permissionRequestId) {
-    const link = this.permissionLinks.get(permissionRequestId);
-    if (!link || link.resolved) return false;
-    link.resolved = true;
-    this.persistPermissions();
-    return true;
+    return withFileLock(PERMISSIONS_PATH, () => {
+      this.reloadPermissions();
+      const link = this.permissionLinks.get(permissionRequestId);
+      if (!link || link.resolved) return false;
+      link.resolved = true;
+      this.persistPermissions();
+      return true;
+    });
   }
   listPendingPermissionLinksByChat(chatId) {
+    this.reloadPermissions();
     const result = [];
     for (const link of this.permissionLinks.values()) {
       if (link.chatId === chatId && !link.resolved) {
@@ -6773,23 +7050,27 @@ var JsonFileStore = class {
   }
   // ── Channel Offsets ──
   getChannelOffset(key) {
+    this.reloadOffsets();
     return this.offsets.get(key) ?? "0";
   }
   setChannelOffset(key, offset) {
-    this.offsets.set(key, offset);
-    this.persistOffsets();
+    withFileLock(OFFSETS_PATH, () => {
+      this.reloadOffsets();
+      this.offsets.set(key, offset);
+      this.persistOffsets();
+    });
   }
 };
 
 // src/weixin-login.ts
 var import_qrcode = __toESM(require_lib(), 1);
-import fs7 from "node:fs";
+import fs8 from "node:fs";
 import path8 from "node:path";
-import crypto4 from "node:crypto";
+import crypto7 from "node:crypto";
 import { spawn as spawn2 } from "node:child_process";
 
 // src/adapters/weixin/weixin-api.ts
-import crypto3 from "node:crypto";
+import crypto5 from "node:crypto";
 
 // src/adapters/weixin/weixin-types.ts
 var DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com";
@@ -6838,7 +7119,8 @@ async function pollLoginQrStatus(qrcode, baseUrl) {
 }
 
 // src/weixin-store.ts
-import fs6 from "node:fs";
+import fs7 from "node:fs";
+import crypto6 from "node:crypto";
 import path7 from "node:path";
 var DATA_DIR2 = path7.join(CTI_HOME, "data");
 var ACCOUNTS_PATH = path7.join(DATA_DIR2, "weixin-accounts.json");
@@ -6846,19 +7128,27 @@ var CONTEXT_TOKENS_PATH = path7.join(DATA_DIR2, "weixin-context-tokens.json");
 var DEFAULT_BASE_URL2 = "https://ilinkai.weixin.qq.com";
 var DEFAULT_CDN_BASE_URL2 = "https://novac2c.cdn.weixin.qq.com/c2c";
 function ensureDir2(dir) {
-  fs6.mkdirSync(dir, { recursive: true });
+  fs7.mkdirSync(dir, { recursive: true });
 }
 function atomicWrite2(filePath, data) {
-  const tmpPath = `${filePath}.tmp`;
-  fs6.writeFileSync(tmpPath, data, "utf-8");
-  fs6.renameSync(tmpPath, filePath);
+  const tmpPath = `${filePath}.${process.pid}.${crypto6.randomUUID()}.tmp`;
+  try {
+    fs7.writeFileSync(tmpPath, data, "utf-8");
+    fs7.renameSync(tmpPath, filePath);
+  } finally {
+    try {
+      fs7.rmSync(tmpPath, { force: true });
+    } catch {
+    }
+  }
 }
 function readJson2(filePath, fallback) {
   try {
-    const raw = fs6.readFileSync(filePath, "utf-8");
+    const raw = fs7.readFileSync(filePath, "utf-8");
     return JSON.parse(raw);
-  } catch {
-    return fallback;
+  } catch (error) {
+    if (error.code === "ENOENT") return fallback;
+    throw new Error(`\u65E0\u6CD5\u8BFB\u53D6\u5FAE\u4FE1\u6570\u636E\u6587\u4EF6 ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
   }
 }
 function now2() {
@@ -6907,37 +7197,38 @@ function listWeixinAccounts() {
   return sortAccountsByRecency(readAccounts());
 }
 function upsertWeixinAccount(params) {
-  const accounts = readAccounts();
-  const existing = accounts.find((account2) => account2.accountId === params.accountId);
-  const timestamp = now2();
-  const account = existing ? {
-    ...existing,
-    userId: params.userId ?? existing.userId,
-    baseUrl: params.baseUrl ?? existing.baseUrl,
-    cdnBaseUrl: params.cdnBaseUrl ?? existing.cdnBaseUrl,
-    token: params.token ?? existing.token,
-    name: params.name ?? existing.name,
-    enabled: params.enabled ?? existing.enabled,
-    lastLoginAt: timestamp,
-    updatedAt: timestamp
-  } : {
-    accountId: params.accountId,
-    userId: params.userId ?? "",
-    baseUrl: params.baseUrl ?? DEFAULT_BASE_URL2,
-    cdnBaseUrl: params.cdnBaseUrl ?? DEFAULT_CDN_BASE_URL2,
-    token: params.token ?? "",
-    name: params.name ?? params.accountId,
-    enabled: params.enabled ?? true,
-    lastLoginAt: timestamp,
-    createdAt: timestamp,
-    updatedAt: timestamp
-  };
-  const nextAccounts = [
-    account,
-    ...accounts.filter((item) => item.accountId !== account.accountId)
-  ];
-  writeAccounts(nextAccounts);
-  return account;
+  return withFileLock(ACCOUNTS_PATH, () => {
+    const accounts = readAccounts();
+    const existing = accounts.find((account2) => account2.accountId === params.accountId);
+    const timestamp = now2();
+    const account = existing ? {
+      ...existing,
+      userId: params.userId ?? existing.userId,
+      baseUrl: params.baseUrl ?? existing.baseUrl,
+      cdnBaseUrl: params.cdnBaseUrl ?? existing.cdnBaseUrl,
+      token: params.token ?? existing.token,
+      name: params.name ?? existing.name,
+      enabled: params.enabled ?? existing.enabled,
+      lastLoginAt: timestamp,
+      updatedAt: timestamp
+    } : {
+      accountId: params.accountId,
+      userId: params.userId ?? "",
+      baseUrl: params.baseUrl ?? DEFAULT_BASE_URL2,
+      cdnBaseUrl: params.cdnBaseUrl ?? DEFAULT_CDN_BASE_URL2,
+      token: params.token ?? "",
+      name: params.name ?? params.accountId,
+      enabled: params.enabled ?? true,
+      lastLoginAt: timestamp,
+      createdAt: timestamp,
+      updatedAt: timestamp
+    };
+    writeAccounts([
+      account,
+      ...accounts.filter((item) => item.accountId !== account.accountId)
+    ]);
+    return account;
+  });
 }
 
 // src/weixin-login.ts
@@ -6949,7 +7240,7 @@ var RUNTIME_DIR = path8.join(CTI_HOME, "runtime");
 var HTML_PATH = path8.join(RUNTIME_DIR, "weixin-login.html");
 var webLoginSessions = /* @__PURE__ */ new Map();
 function ensureRuntimeDir() {
-  fs7.mkdirSync(RUNTIME_DIR, { recursive: true });
+  fs8.mkdirSync(RUNTIME_DIR, { recursive: true });
 }
 function escapeHtml(text2) {
   return text2.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
@@ -7262,7 +7553,7 @@ function buildWeixinLoginPopupHtml(sessionId) {
 async function writeQrHtml(session) {
   ensureRuntimeDir();
   const qrSvg = await buildQrSvg(session.qrImageUrl);
-  fs7.writeFileSync(HTML_PATH, buildQrHtml(qrSvg), "utf-8");
+  fs8.writeFileSync(HTML_PATH, buildQrHtml(qrSvg), "utf-8");
 }
 function openQrHtml() {
   try {
@@ -7451,7 +7742,7 @@ async function startWeixinLoginWebSession(options = {}) {
   ensureRuntimeDir();
   const config = options.config || {};
   const seed = await createSession(0, config.baseUrl);
-  const sessionId = crypto4.randomUUID();
+  const sessionId = crypto7.randomUUID();
   const qrSvg = await buildQrSvg(seed.qrImageUrl);
   const session = {
     id: sessionId,
@@ -7533,14 +7824,60 @@ if (isMainModule) {
 }
 
 // src/codex-models.ts
-import fs8 from "node:fs";
+import fs9 from "node:fs";
 import os4 from "node:os";
 import path9 from "node:path";
 var DEFAULT_CODEX_CONFIG_PATH = path9.join(os4.homedir(), ".codex", "config.toml");
 var DEFAULT_CODEX_MODELS_CACHE_PATH = path9.join(os4.homedir(), ".codex", "models_cache.json");
+var REASONING_LEVEL_DESCRIPTIONS = {
+  low: "Fast responses with lighter reasoning",
+  medium: "Balances speed and reasoning depth for everyday tasks",
+  high: "Greater reasoning depth for complex problems",
+  xhigh: "Extra high reasoning depth for complex problems",
+  max: "Maximum reasoning depth for very hard problems",
+  ultra: "Ultra reasoning depth for the hardest problems"
+};
+function buildReasoningLevels(efforts) {
+  return efforts.map((effort) => ({
+    effort,
+    description: REASONING_LEVEL_DESCRIPTIONS[effort] || ""
+  }));
+}
+function cloneCodexModel(model) {
+  return {
+    ...model,
+    supportedReasoningLevels: model.supportedReasoningLevels.map((level) => ({ ...level }))
+  };
+}
+var KNOWN_CODEX_MODEL_FALLBACKS = [
+  {
+    slug: "gpt-5.6-sol",
+    displayName: "GPT-5.6-Sol",
+    visibility: "list",
+    supportedInApi: true,
+    defaultReasoningLevel: "low",
+    supportedReasoningLevels: buildReasoningLevels(["low", "medium", "high", "xhigh", "max", "ultra"])
+  },
+  {
+    slug: "gpt-5.6-terra",
+    displayName: "GPT-5.6-Terra",
+    visibility: "list",
+    supportedInApi: true,
+    defaultReasoningLevel: "medium",
+    supportedReasoningLevels: buildReasoningLevels(["low", "medium", "high", "xhigh", "max", "ultra"])
+  },
+  {
+    slug: "gpt-5.6-luna",
+    displayName: "GPT-5.6-Luna",
+    visibility: "list",
+    supportedInApi: true,
+    defaultReasoningLevel: "medium",
+    supportedReasoningLevels: buildReasoningLevels(["low", "medium", "high", "xhigh", "max"])
+  }
+];
 function readConfiguredCodexModel(configPath = DEFAULT_CODEX_CONFIG_PATH) {
   try {
-    const raw = fs8.readFileSync(configPath, "utf-8");
+    const raw = fs9.readFileSync(configPath, "utf-8");
     let inSection = false;
     for (const line of raw.split(/\r?\n/)) {
       const trimmed = line.trim();
@@ -7584,7 +7921,7 @@ function parseSupportedReasoningLevels(value) {
 }
 function listCachedCodexModels(cachePath = DEFAULT_CODEX_MODELS_CACHE_PATH) {
   try {
-    const raw = fs8.readFileSync(cachePath, "utf-8");
+    const raw = fs9.readFileSync(cachePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed.models)) return [];
     const seen = /* @__PURE__ */ new Set();
@@ -7609,8 +7946,113 @@ function listCachedCodexModels(cachePath = DEFAULT_CODEX_MODELS_CACHE_PATH) {
     return [];
   }
 }
-function listSelectableCodexModels(cachePath = DEFAULT_CODEX_MODELS_CACHE_PATH) {
-  return listCachedCodexModels(cachePath).filter((model) => model.visibility !== "hide");
+function buildSyntheticCodexModel(slug) {
+  const normalized = slug.trim();
+  if (!normalized) return null;
+  return {
+    slug: normalized,
+    displayName: normalized,
+    visibility: "list",
+    supportedInApi: true,
+    supportedReasoningLevels: []
+  };
+}
+function listAvailableCodexModels(cachePath = DEFAULT_CODEX_MODELS_CACHE_PATH, additionalModelSlugs = []) {
+  const cachedModels = listCachedCodexModels(cachePath);
+  const hiddenCachedSlugs = new Set(
+    cachedModels.filter((model) => model.visibility === "hide").map((model) => model.slug)
+  );
+  const merged = [];
+  const seen = /* @__PURE__ */ new Set();
+  const addModel = (model, force = false) => {
+    if (!force && hiddenCachedSlugs.has(model.slug)) return;
+    if (seen.has(model.slug)) return;
+    seen.add(model.slug);
+    merged.push(cloneCodexModel(model));
+  };
+  for (const model of cachedModels) {
+    if (model.visibility !== "hide") {
+      addModel(model, true);
+    }
+  }
+  for (const model of KNOWN_CODEX_MODEL_FALLBACKS) {
+    addModel(model);
+  }
+  for (const slug of additionalModelSlugs) {
+    const syntheticModel = buildSyntheticCodexModel(slug);
+    if (syntheticModel) {
+      addModel(syntheticModel, true);
+    }
+  }
+  return merged;
+}
+
+// src/ui-http-security.ts
+var DEFAULT_JSON_BODY_LIMIT_BYTES = 1024 * 1024;
+var HttpRequestError = class extends Error {
+  constructor(statusCode, message) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "HttpRequestError";
+  }
+};
+function isMutationMethod(method) {
+  return method === "POST" || method === "PUT" || method === "PATCH" || method === "DELETE";
+}
+function getExpectedOrigin(headers) {
+  const host = headers.host?.trim();
+  if (!host) throw new HttpRequestError(400, "\u8BF7\u6C42\u7F3A\u5C11 Host header\u3002");
+  return `http://${host}`;
+}
+function assertTrustedMutationRequest(request) {
+  if (!isMutationMethod(request.method)) return;
+  const fetchSite = request.headers["sec-fetch-site"];
+  if (fetchSite === "cross-site") {
+    throw new HttpRequestError(403, "\u5DF2\u62D2\u7EDD\u8DE8\u7AD9\u7BA1\u7406\u8BF7\u6C42\u3002");
+  }
+  const origin = request.headers.origin;
+  if (!origin) return;
+  if (origin === "null") {
+    throw new HttpRequestError(403, "\u5DF2\u62D2\u7EDD\u6765\u6E90\u4E0D\u660E\u7684\u7BA1\u7406\u8BF7\u6C42\u3002");
+  }
+  let normalizedOrigin;
+  try {
+    normalizedOrigin = new URL(origin).origin;
+  } catch {
+    throw new HttpRequestError(403, "\u8BF7\u6C42 Origin \u65E0\u6548\u3002");
+  }
+  if (normalizedOrigin !== getExpectedOrigin(request.headers)) {
+    throw new HttpRequestError(403, "\u5DF2\u62D2\u7EDD\u975E\u540C\u6E90\u7BA1\u7406\u8BF7\u6C42\u3002");
+  }
+}
+async function readJsonBody(request, maxBytes = DEFAULT_JSON_BODY_LIMIT_BYTES) {
+  const boundedMaxBytes = Math.max(1, maxBytes);
+  const declaredLength = Number(request.headers["content-length"]);
+  if (Number.isFinite(declaredLength) && declaredLength > boundedMaxBytes) {
+    throw new HttpRequestError(413, `\u8BF7\u6C42\u4F53\u8D85\u8FC7 ${boundedMaxBytes} \u5B57\u8282\u9650\u5236\u3002`);
+  }
+  const chunks = [];
+  let receivedBytes = 0;
+  for await (const chunk of request) {
+    const buffer = Buffer.from(chunk);
+    receivedBytes += buffer.length;
+    if (receivedBytes > boundedMaxBytes) {
+      request.resume();
+      throw new HttpRequestError(413, `\u8BF7\u6C42\u4F53\u8D85\u8FC7 ${boundedMaxBytes} \u5B57\u8282\u9650\u5236\u3002`);
+    }
+    chunks.push(buffer);
+  }
+  const raw = Buffer.concat(chunks).toString("utf-8").trim();
+  if (!raw) return {};
+  const contentType = request.headers["content-type"] || "";
+  if (!/^application\/json(?:\s*;|$)/i.test(contentType)) {
+    throw new HttpRequestError(415, "\u8BF7\u6C42\u4F53\u5FC5\u987B\u4F7F\u7528 application/json\u3002");
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new HttpRequestError(400, "\u8BF7\u6C42\u4F53\u4E0D\u662F\u6709\u6548 JSON\u3002");
+  }
 }
 
 // src/ui-server.ts
@@ -7626,8 +8068,8 @@ function parsePreferredPort() {
   if (!Number.isInteger(raw) || raw <= 0 || raw > 65535) return 4781;
   return raw;
 }
-function getAvailableCodexModels() {
-  return listSelectableCodexModels();
+function getAvailableCodexModels(additionalModelSlugs = []) {
+  return listAvailableCodexModels(void 0, additionalModelSlugs);
 }
 function getAvailableCodexModelSlugs(models = getAvailableCodexModels()) {
   return new Set(models.map((model) => model.slug));
@@ -7698,14 +8140,6 @@ function text(response, statusCode, body) {
   response.writeHead(statusCode, { "Content-Type": "text/plain; charset=utf-8" });
   response.end(body);
 }
-async function readJsonBody(request) {
-  const chunks = [];
-  for await (const chunk of request) {
-    chunks.push(Buffer.from(chunk));
-  }
-  const raw = Buffer.concat(chunks).toString("utf-8").trim();
-  return raw ? JSON.parse(raw) : {};
-}
 function asString(value) {
   if (typeof value !== "string") return void 0;
   const trimmed = value.trim();
@@ -7786,14 +8220,14 @@ function channelToPayload(channel) {
   };
 }
 function generateAccessToken() {
-  return crypto5.randomBytes(18).toString("base64url");
+  return crypto8.randomBytes(18).toString("base64url");
 }
 function timingSafeMatch(left, right) {
   if (!left || !right) return false;
   const leftBuffer = Buffer.from(left);
   const rightBuffer = Buffer.from(right);
   if (leftBuffer.length !== rightBuffer.length) return false;
-  return crypto5.timingSafeEqual(leftBuffer, rightBuffer);
+  return crypto8.timingSafeEqual(leftBuffer, rightBuffer);
 }
 function parseCookies(request) {
   const header = request.headers.cookie;
@@ -7854,8 +8288,8 @@ function isRemoteAuthenticated(request, config) {
   return timingSafeMatch(parseCookies(request).get(AUTH_COOKIE_NAME), config.uiAccessToken);
 }
 function configToPayload(config) {
-  const availableModels = getAvailableCodexModels();
   const codexDefaultModel = readConfiguredCodexModel() || "";
+  const availableModels = getAvailableCodexModels([config.defaultModel || "", codexDefaultModel]);
   const effectiveModel = config.defaultModel || codexDefaultModel;
   return {
     runtime: config.runtime,
@@ -7878,10 +8312,14 @@ function configToPayload(config) {
 }
 function mergeConfig(payload) {
   const current = loadConfig();
-  const availableCodexModels = getAvailableCodexModels();
-  const availableCodexModelSlugs = getAvailableCodexModelSlugs(availableCodexModels);
   const codexDefaultModel = readConfiguredCodexModel() || "";
   const rawDefaultModel = typeof payload.defaultModel === "string" ? payload.defaultModel.trim() : void 0;
+  const availableCodexModels = getAvailableCodexModels([
+    current.defaultModel || "",
+    codexDefaultModel,
+    rawDefaultModel || ""
+  ]);
+  const availableCodexModelSlugs = getAvailableCodexModelSlugs(availableCodexModels);
   const nextDefaultModel = rawDefaultModel === void 0 ? current.defaultModel : rawDefaultModel === "" ? void 0 : availableCodexModelSlugs.has(rawDefaultModel) ? rawDefaultModel : current.defaultModel;
   const currentEffectiveModel = current.defaultModel || codexDefaultModel;
   const nextEffectiveModel = nextDefaultModel || codexDefaultModel;
@@ -11540,6 +11978,11 @@ function renderHtml() {
 }
 var server = http.createServer(async (request, response) => {
   try {
+    response.setHeader("X-Content-Type-Options", "nosniff");
+    response.setHeader("X-Frame-Options", "DENY");
+    response.setHeader("Referrer-Policy", "no-referrer");
+    response.setHeader("Cache-Control", "no-store");
+    assertTrustedMutationRequest(request);
     const url = new URL(request.url || "/", getUiServerUrl(port));
     const config = loadConfig();
     const localRequest = isLocalRequest(request);
@@ -11877,16 +12320,18 @@ var server = http.createServer(async (request, response) => {
     }
     text(response, 404, "Not found");
   } catch (error) {
-    json(response, 500, {
+    const statusCode = error instanceof HttpRequestError ? error.statusCode : 500;
+    json(response, statusCode, {
       error: error instanceof Error ? error.message : String(error)
     });
   }
 });
 async function startServer() {
   port = await resolveUiPort(parsePreferredPort());
+  const listenHost = loadConfig().uiAllowLan === true ? "0.0.0.0" : "127.0.0.1";
   await new Promise((resolve, reject) => {
     server.once("error", reject);
-    server.listen(port, "0.0.0.0", () => {
+    server.listen(port, listenHost, () => {
       server.removeListener("error", reject);
       resolve();
     });