codex-to-im 1.0.60 → 1.0.61

package/dist/daemon.mjs

@@ -324,9 +324,9 @@ __export(codex_provider_exports, {
   CodexProvider: () => CodexProvider,
   mapCodexUsage: () => mapCodexUsage
 });
-import fs15 from "node:fs";
+import fs17 from "node:fs";
 import os4 from "node:os";
-import path17 from "node:path";
+import path18 from "node:path";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -543,13 +543,13 @@ var init_codex_provider = __esm({
                     { type: "text", text: params.prompt }
                   ];
                   for (const file of imageFiles) {
-                    if (file.filePath && fs15.existsSync(file.filePath)) {
+                    if (file.filePath && fs17.existsSync(file.filePath)) {
                       parts.push({ type: "local_image", path: file.filePath });
                       continue;
                     }
                     const ext = MIME_EXT[file.type] || ".png";
-                    const tmpPath = path17.join(os4.tmpdir(), `cti-img-${Date.now()}-${Math.random().toString(36).slice(2)}${ext}`);
-                    fs15.writeFileSync(tmpPath, Buffer.from(file.data, "base64"));
+                    const tmpPath = path18.join(os4.tmpdir(), `cti-img-${Date.now()}-${Math.random().toString(36).slice(2)}${ext}`);
+                    fs17.writeFileSync(tmpPath, Buffer.from(file.data, "base64"));
                     tempFiles.push(tmpPath);
                     parts.push({ type: "local_image", path: tmpPath });
                   }
@@ -715,7 +715,7 @@ var init_codex_provider = __esm({
               } finally {
                 for (const tmp of tempFiles) {
                   try {
-                    fs15.unlinkSync(tmp);
+                    fs17.unlinkSync(tmp);
                   } catch {
                   }
                 }
@@ -845,9 +845,9 @@ var init_codex_provider = __esm({
 });
 
 // src/main.ts
-import fs16 from "node:fs";
-import path18 from "node:path";
-import crypto10 from "node:crypto";
+import fs18 from "node:fs";
+import path19 from "node:path";
+import crypto11 from "node:crypto";
 
 // src/lib/bridge/context.ts
 var CONTEXT_KEY = "__bridge_context__";
@@ -3286,20 +3286,20 @@ ${trimmedResponse}`;
         buffer = Buffer.concat(chunks);
       } catch (streamErr) {
         console.warn("[feishu-adapter] Stream read failed, falling back to writeFile:", streamErr instanceof Error ? streamErr.message : streamErr);
-        const fs17 = await import("fs");
+        const fs19 = await import("fs");
         const os5 = await import("os");
-        const path19 = await import("path");
-        const tmpPath = path19.join(os5.tmpdir(), `feishu-dl-${crypto3.randomUUID()}`);
+        const path20 = await import("path");
+        const tmpPath = path20.join(os5.tmpdir(), `feishu-dl-${crypto3.randomUUID()}`);
         try {
           await res.writeFile(tmpPath);
-          buffer = fs17.readFileSync(tmpPath);
+          buffer = fs19.readFileSync(tmpPath);
           if (buffer.length > MAX_FILE_SIZE) {
             console.warn(`[feishu-adapter] Resource too large (>${MAX_FILE_SIZE} bytes), key: ${fileKey}`);
             return null;
           }
         } finally {
           try {
-            fs17.unlinkSync(tmpPath);
+            fs19.unlinkSync(tmpPath);
           } catch {
           }
         }
@@ -10837,8 +10837,10 @@ var IGNORED_RESPONSE_ITEM_TYPES = /* @__PURE__ */ new Set([
   "web_search_call"
 ]);
 var IGNORED_TOP_LEVEL_TYPES = /* @__PURE__ */ new Set([
+  "compacted",
   "session_meta",
-  "turn_context"
+  "turn_context",
+  "world_state"
 ]);
 var TERMINAL_COMPLETION_EVENT_TYPES = /* @__PURE__ */ new Set([
   "task_complete",
@@ -10865,6 +10867,10 @@ function extractTerminalCompletionText(payload) {
   }
   return "";
 }
+function isSyntheticDesktopUserContext(text2) {
+  const normalized = text2.trim();
+  return normalized.startsWith("<environment_context>") && normalized.endsWith("</environment_context>");
+}
 function isIgnoredMirrorLineKind(line) {
   if (isSessionEventLine(line)) {
     const payloadType = typeof line.payload?.type === "string" ? line.payload.type.trim() : "";
@@ -11177,7 +11183,7 @@ function pushDesktopMirrorEventRecord(records, parsed, rawLine, activeTurnId) {
   }
   if (parsed.payload?.type === "user_message") {
     const text2 = extractNormalizedStructuredText(parsed.payload.message);
-    if (!text2) return true;
+    if (!text2 || isSyntheticDesktopUserContext(text2)) return true;
     records.push({
       signature,
       type: "message",
@@ -11234,7 +11240,7 @@ function pushDesktopMirrorResponseRecord(records, parsed, rawLine, activeTurnId,
   }
   if (parsed.payload?.type === "message" && parsed.payload.role === "user") {
     const text2 = extractDesktopMessageText(parsed);
-    if (!text2) return true;
+    if (!text2 || isSyntheticDesktopUserContext(text2)) return true;
     const previous = records.at(-1);
     if (previous?.type === "message" && previous.role === "user" && previous.content === text2 && previous.turnId === (activeTurnId || void 0)) {
       return true;
@@ -11249,6 +11255,9 @@ function pushDesktopMirrorResponseRecord(records, parsed, rawLine, activeTurnId,
     });
     return true;
   }
+  if (parsed.payload?.type === "message") {
+    return true;
+  }
   if (parsed.payload?.type === "tool_search_call") {
     const toolId = extractNormalizedFreeText(parsed.payload.call_id) || signature;
     records.push({
@@ -13165,6 +13174,10 @@ function filterSuppressedMirrorRecords(store, sessionId, records, config2, nowMs
           break;
         }
         if (record.type === "message" && record.role === "user") {
+          if (isSyntheticDesktopUserContext(record.content || "")) {
+            handled = true;
+            break;
+          }
           if (suppression.promptText && normalizedContent === suppression.promptText) {
             suppression.awaitingPromptMatch = false;
             suppression.droppingTurn = true;
@@ -16677,6 +16690,44 @@ async function runMirrorReconcileBatch(deps) {
 
 // src/lib/bridge/mirror-runtime.ts
 function createMirrorRuntime(getState2, options, deps) {
+  function isAtOrBefore(timestamp, boundary) {
+    if (!timestamp) return true;
+    const timestampMs = Date.parse(timestamp);
+    const boundaryMs = Date.parse(boundary);
+    if (Number.isFinite(timestampMs) && Number.isFinite(boundaryMs)) {
+      return timestampMs <= boundaryMs;
+    }
+    return timestamp <= boundary;
+  }
+  function discardClaimedMirrorTurn(subscription, routeResult) {
+    if (!routeResult.terminalClaimed) return;
+    const claimedTurnId = routeResult.claimedTurnId;
+    if (claimedTurnId) {
+      const claimedStreamKey = buildMirrorStreamKey(subscription.sessionId, claimedTurnId, "");
+      subscription.bufferedRecords = subscription.bufferedRecords.filter(
+        (record) => record.turnId !== claimedTurnId
+      );
+      subscription.pendingDeliveries = subscription.pendingDeliveries.filter(
+        (turn) => turn.streamKey !== claimedStreamKey
+      );
+      if (subscription.pendingTurn?.turnId === claimedTurnId) {
+        deps.stopMirrorStreaming(subscription, "interrupted");
+        subscription.pendingTurn = null;
+      }
+    }
+    const claimedAt = routeResult.claimedAt;
+    if (!claimedAt) return;
+    const retainedAtOrBeforeClaim = [
+      ...subscription.bufferedRecords.map((record) => record.timestamp),
+      ...subscription.pendingDeliveries.map((turn) => turn.timestamp),
+      ...routeResult.unclaimed.map((record) => record.timestamp),
+      ...subscription.pendingTurn ? [subscription.pendingTurn.lastActivityAt] : []
+    ].some((timestamp) => isAtOrBefore(timestamp, claimedAt));
+    if (retainedAtOrBeforeClaim) return;
+    if (!subscription.lastDeliveredAt || !isAtOrBefore(claimedAt, subscription.lastDeliveredAt)) {
+      subscription.lastDeliveredAt = claimedAt;
+    }
+  }
   function closeMirrorWatcher(subscription) {
     if (subscription.watcher) {
       try {
@@ -16864,7 +16915,14 @@ function createMirrorRuntime(getState2, options, deps) {
         `[bridge-manager] Unhandled desktop mirror event for thread ${subscription.threadId}: ${kind}`
       );
     }
-    const routeResult = deliverableRecords.length > 0 && deps.routeDesktopRecords ? await deps.routeDesktopRecords(subscription.sessionId, subscription.threadId, deliverableRecords) : { claimed: [], unclaimed: deliverableRecords, terminalClaimed: false };
+    const routeResult = deliverableRecords.length > 0 && deps.routeDesktopRecords ? await deps.routeDesktopRecords(subscription.sessionId, subscription.threadId, deliverableRecords) : {
+      claimed: [],
+      unclaimed: deliverableRecords,
+      terminalClaimed: false,
+      claimedTurnId: null,
+      claimedAt: null
+    };
+    discardClaimedMirrorTurn(subscription, routeResult);
     const mirrorRecords = routeResult.unclaimed;
     if (mirrorRecords.length > 0) {
       deps.observeSessionHealthRecords(subscription.sessionId, subscription.threadId, mirrorRecords);
@@ -17930,7 +17988,9 @@ async function routeDesktopRecords(sessionId, desktopThreadId, records, coordina
     return {
       claimed: [],
       unclaimed: records,
-      terminalClaimed: false
+      terminalClaimed: false,
+      claimedTurnId: null,
+      claimedAt: null
     };
   }
   const claim = await coordinator.claimDesktopTerminal(
@@ -17940,7 +18000,9 @@ async function routeDesktopRecords(sessionId, desktopThreadId, records, coordina
     return {
       claimed: [],
       unclaimed: records,
-      terminalClaimed: false
+      terminalClaimed: false,
+      claimedTurnId: null,
+      claimedAt: null
     };
   }
   const claimedTurnId = terminalRecord.turnId;
@@ -17949,7 +18011,9 @@ async function routeDesktopRecords(sessionId, desktopThreadId, records, coordina
   return {
     claimed,
     unclaimed: records.filter((record) => !claimedSet.has(record.signature)),
-    terminalClaimed: true
+    terminalClaimed: true,
+    claimedTurnId: claimedTurnId || null,
+    claimedAt: terminalRecord.timestamp || null
   };
 }
 
@@ -18579,40 +18643,76 @@ function persistSdkSessionUpdate(sessionId, sdkSessionId, hasError) {
 }
 
 // src/store.ts
+import fs13 from "node:fs";
+import path15 from "node:path";
+import crypto10 from "node:crypto";
+
+// src/atomic-file.ts
+import crypto9 from "node:crypto";
 import fs12 from "node:fs";
 import path14 from "node:path";
-import crypto9 from "node:crypto";
-var DATA_DIR2 = path14.join(CTI_HOME, "data");
-var MESSAGES_DIR = path14.join(DATA_DIR2, "messages");
-var SESSIONS_PATH = path14.join(DATA_DIR2, "sessions.json");
-var BINDINGS_PATH = path14.join(DATA_DIR2, "bindings.json");
-var PERMISSIONS_PATH = path14.join(DATA_DIR2, "permissions.json");
-var OFFSETS_PATH = path14.join(DATA_DIR2, "offsets.json");
-var DEDUP_PATH = path14.join(DATA_DIR2, "dedup.json");
-var AUDIT_PATH = path14.join(DATA_DIR2, "audit.json");
-var DEFAULT_DEDUP_TTL_MS = 5 * 60 * 1e3;
-var INBOUND_DEDUP_TTL_MS = 24 * 60 * 60 * 1e3;
-function ensureDir2(dir) {
-  fs12.mkdirSync(dir, { recursive: true });
+var RETRYABLE_RENAME_CODES = /* @__PURE__ */ new Set(["EACCES", "EBUSY", "EPERM"]);
+var WAIT_ARRAY2 = new Int32Array(new SharedArrayBuffer(4));
+function defaultSleepSync(delayMs) {
+  Atomics.wait(WAIT_ARRAY2, 0, 0, Math.max(1, delayMs));
+}
+function isRetryableRenameError(error) {
+  return RETRYABLE_RENAME_CODES.has(error?.code || "");
+}
+function renameFileWithRetrySync(source, destination, options = {}) {
+  const maxAttempts = Math.max(1, options.maxAttempts ?? 8);
+  const baseDelayMs = Math.max(1, options.baseDelayMs ?? 15);
+  const renameSync = options.renameSync ?? fs12.renameSync;
+  const sleepSync2 = options.sleepSync ?? defaultSleepSync;
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    try {
+      renameSync(source, destination);
+      return;
+    } catch (error) {
+      if (!isRetryableRenameError(error) || attempt === maxAttempts - 1) {
+        throw error;
+      }
+      sleepSync2(Math.min(250, baseDelayMs * 2 ** attempt));
+    }
+  }
 }
-function atomicWrite2(filePath, data) {
-  const tmp = `${filePath}.${process.pid}.${crypto9.randomUUID()}.tmp`;
+function atomicWriteFileSync(filePath, data) {
+  fs12.mkdirSync(path14.dirname(filePath), { recursive: true });
+  const tmpPath = `${filePath}.${process.pid}.${crypto9.randomUUID()}.tmp`;
   try {
-    fs12.writeFileSync(tmp, data, "utf-8");
-    fs12.renameSync(tmp, filePath);
+    fs12.writeFileSync(tmpPath, data, "utf-8");
+    renameFileWithRetrySync(tmpPath, filePath);
   } finally {
     try {
-      fs12.rmSync(tmp, { force: true });
+      fs12.rmSync(tmpPath, { force: true });
     } catch {
     }
   }
 }
+
+// src/store.ts
+var DATA_DIR2 = path15.join(CTI_HOME, "data");
+var MESSAGES_DIR = path15.join(DATA_DIR2, "messages");
+var SESSIONS_PATH = path15.join(DATA_DIR2, "sessions.json");
+var BINDINGS_PATH = path15.join(DATA_DIR2, "bindings.json");
+var PERMISSIONS_PATH = path15.join(DATA_DIR2, "permissions.json");
+var OFFSETS_PATH = path15.join(DATA_DIR2, "offsets.json");
+var DEDUP_PATH = path15.join(DATA_DIR2, "dedup.json");
+var AUDIT_PATH = path15.join(DATA_DIR2, "audit.json");
+var DEFAULT_DEDUP_TTL_MS = 5 * 60 * 1e3;
+var INBOUND_DEDUP_TTL_MS = 24 * 60 * 60 * 1e3;
+function ensureDir2(dir) {
+  fs13.mkdirSync(dir, { recursive: true });
+}
+function atomicWrite2(filePath, data) {
+  atomicWriteFileSync(filePath, data);
+}
 function dedupTtlMs(key) {
   return key.startsWith("inbound:") ? INBOUND_DEDUP_TTL_MS : DEFAULT_DEDUP_TTL_MS;
 }
 function readJson2(filePath, fallback) {
   try {
-    const raw = fs12.readFileSync(filePath, "utf-8");
+    const raw = fs13.readFileSync(filePath, "utf-8");
     return JSON.parse(raw);
   } catch (error) {
     if (error.code === "ENOENT") return fallback;
@@ -18623,7 +18723,7 @@ function writeJson(filePath, data) {
   atomicWrite2(filePath, JSON.stringify(data, null, 2));
 }
 function uuid() {
-  return crypto9.randomUUID();
+  return crypto10.randomUUID();
 }
 function now() {
   return (/* @__PURE__ */ new Date()).toISOString();
@@ -18786,14 +18886,14 @@ var JsonFileStore = class {
   }
   persistMessages(sessionId) {
     const msgs = this.messages.get(sessionId) || [];
-    writeJson(path14.join(MESSAGES_DIR, `${sessionId}.json`), msgs);
+    writeJson(path15.join(MESSAGES_DIR, `${sessionId}.json`), msgs);
   }
   loadMessages(sessionId) {
     if (this.messages.has(sessionId)) {
       return this.messages.get(sessionId);
     }
     const msgs = readJson2(
-      path14.join(MESSAGES_DIR, `${sessionId}.json`),
+      path15.join(MESSAGES_DIR, `${sessionId}.json`),
       []
     );
     this.messages.set(sessionId, msgs);
@@ -18816,7 +18916,7 @@ var JsonFileStore = class {
     });
   }
   mutateMessages(sessionId, mutation) {
-    const messagePath = path14.join(MESSAGES_DIR, `${sessionId}.json`);
+    const messagePath = path15.join(MESSAGES_DIR, `${sessionId}.json`);
     return withFileLock(messagePath, () => {
       const messages = readJson2(messagePath, []);
       this.messages.set(sessionId, messages);
@@ -18975,7 +19075,7 @@ var JsonFileStore = class {
     });
   }
   deleteSession(sessionId) {
-    const messagePath = path14.join(MESSAGES_DIR, `${sessionId}.json`);
+    const messagePath = path15.join(MESSAGES_DIR, `${sessionId}.json`);
     withFileLocks([SESSIONS_PATH, BINDINGS_PATH, messagePath], () => {
       this.reloadSessions();
       this.reloadBindings();
@@ -18987,7 +19087,7 @@ var JsonFileStore = class {
       }
       this.messages.delete(sessionId);
       try {
-        fs12.rmSync(messagePath, { force: true });
+        fs13.rmSync(messagePath, { force: true });
       } catch {
       }
       this.persistSessions();
@@ -19001,7 +19101,7 @@ var JsonFileStore = class {
     });
   }
   getMessages(sessionId, opts) {
-    const messagePath = path14.join(MESSAGES_DIR, `${sessionId}.json`);
+    const messagePath = path15.join(MESSAGES_DIR, `${sessionId}.json`);
     const msgs = readJson2(messagePath, []);
     this.messages.set(sessionId, msgs);
     if (opts?.limit && opts.limit > 0) {
@@ -19242,8 +19342,8 @@ var PendingPermissions = class {
 };
 
 // src/logger.ts
-import fs13 from "node:fs";
-import path15 from "node:path";
+import fs14 from "node:fs";
+import path16 from "node:path";
 import { inspect as inspect2 } from "node:util";
 var MASK_PATTERNS = [
   /(?:token|secret|password|api_key)["']?\s*[:=]\s*["']?([^\s"',]+)/gi,
@@ -19261,8 +19361,8 @@ function maskSecrets(text2) {
   }
   return result;
 }
-var LOG_DIR = path15.join(CTI_HOME, "logs");
-var LOG_PATH = path15.join(LOG_DIR, "bridge.log");
+var LOG_DIR = path16.join(CTI_HOME, "logs");
+var LOG_PATH = path16.join(LOG_DIR, "bridge.log");
 var MAX_LOG_SIZE = 10 * 1024 * 1024;
 var MAX_ROTATED = 3;
 var logStream = null;
@@ -19283,11 +19383,11 @@ function formatLogArg(value) {
   return String(value);
 }
 function openLogStream() {
-  return fs13.createWriteStream(LOG_PATH, { flags: "a" });
+  return fs14.createWriteStream(LOG_PATH, { flags: "a" });
 }
 function rotateIfNeeded() {
   try {
-    const stat = fs13.statSync(LOG_PATH);
+    const stat = fs14.statSync(LOG_PATH);
     if (stat.size < MAX_LOG_SIZE) return;
   } catch {
     return;
@@ -19297,17 +19397,17 @@ function rotateIfNeeded() {
     logStream = null;
   }
   const path32 = `${LOG_PATH}.${MAX_ROTATED}`;
-  if (fs13.existsSync(path32)) fs13.unlinkSync(path32);
+  if (fs14.existsSync(path32)) fs14.unlinkSync(path32);
   for (let i = MAX_ROTATED - 1; i >= 1; i--) {
     const src = `${LOG_PATH}.${i}`;
     const dst = `${LOG_PATH}.${i + 1}`;
-    if (fs13.existsSync(src)) fs13.renameSync(src, dst);
+    if (fs14.existsSync(src)) fs14.renameSync(src, dst);
   }
-  fs13.renameSync(LOG_PATH, `${LOG_PATH}.1`);
+  fs14.renameSync(LOG_PATH, `${LOG_PATH}.1`);
   logStream = openLogStream();
 }
 function setupLogger() {
-  fs13.mkdirSync(LOG_DIR, { recursive: true });
+  fs14.mkdirSync(LOG_DIR, { recursive: true });
   logStream = openLogStream();
   const write = (level, args) => {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
@@ -19323,13 +19423,13 @@ function setupLogger() {
 }
 
 // src/bridge-instance-lock.ts
-import fs14 from "node:fs";
-import path16 from "node:path";
-var runtimeDir = path16.join(CTI_HOME, "runtime");
-var bridgeInstanceLockFile = path16.join(runtimeDir, "bridge.instance.lock");
+import fs15 from "node:fs";
+import path17 from "node:path";
+var runtimeDir = path17.join(CTI_HOME, "runtime");
+var bridgeInstanceLockFile = path17.join(runtimeDir, "bridge.instance.lock");
 function readJsonFile(filePath, fallback) {
   try {
-    return JSON.parse(fs14.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs15.readFileSync(filePath, "utf-8"));
   } catch {
     return fallback;
   }
@@ -19361,8 +19461,8 @@ function tryAcquireBridgeInstanceLock(options = {}) {
   };
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      fs14.mkdirSync(path16.dirname(filePath), { recursive: true });
-      fs14.writeFileSync(filePath, JSON.stringify(payload, null, 2), { encoding: "utf-8", flag: "wx" });
+      fs15.mkdirSync(path17.dirname(filePath), { recursive: true });
+      fs15.writeFileSync(filePath, JSON.stringify(payload, null, 2), { encoding: "utf-8", flag: "wx" });
       return { acquired: true };
     } catch (error) {
       const code2 = error.code;
@@ -19372,7 +19472,7 @@ function tryAcquireBridgeInstanceLock(options = {}) {
         return { acquired: false, holderPid: existing2.pid };
       }
       try {
-        fs14.unlinkSync(filePath);
+        fs15.unlinkSync(filePath);
       } catch {
       }
     }
@@ -19387,37 +19487,46 @@ function releaseBridgeInstanceLock(filePath = bridgeInstanceLockFile, ownerPid =
   const existing = readBridgeInstanceLock(filePath);
   if (!existing) {
     try {
-      fs14.unlinkSync(filePath);
+      fs15.unlinkSync(filePath);
     } catch {
     }
     return;
   }
   if (existing.pid !== ownerPid) return;
   try {
-    fs14.unlinkSync(filePath);
+    fs15.unlinkSync(filePath);
   } catch {
   }
 }
 
-// src/main.ts
-var RUNTIME_DIR = path18.join(CTI_HOME, "runtime");
-var STATUS_FILE = path18.join(RUNTIME_DIR, "status.json");
-var PID_FILE = path18.join(RUNTIME_DIR, "bridge.pid");
-async function resolveProvider() {
-  const { CodexProvider: CodexProvider2 } = await Promise.resolve().then(() => (init_codex_provider(), codex_provider_exports));
-  return new CodexProvider2();
-}
-function writeStatus(info) {
-  fs16.mkdirSync(RUNTIME_DIR, { recursive: true });
+// src/runtime-status.ts
+import fs16 from "node:fs";
+function writeRuntimeStatus(filePath, info, options = {}) {
   let existing = {};
   try {
-    existing = JSON.parse(fs16.readFileSync(STATUS_FILE, "utf-8"));
+    existing = JSON.parse(fs16.readFileSync(filePath, "utf-8"));
   } catch {
   }
+  const existingRunId = typeof existing.runId === "string" ? existing.runId : "";
+  if (options.expectedRunId && existingRunId && existingRunId !== options.expectedRunId && options.allowRunIdTakeover !== true) {
+    return false;
+  }
   const merged = { ...existing, ...info };
-  const tmp = STATUS_FILE + ".tmp";
-  fs16.writeFileSync(tmp, JSON.stringify(merged, null, 2), "utf-8");
-  fs16.renameSync(tmp, STATUS_FILE);
+  atomicWriteFileSync(filePath, JSON.stringify(merged, null, 2));
+  return true;
+}
+
+// src/main.ts
+var RUNTIME_DIR = path19.join(CTI_HOME, "runtime");
+var STATUS_FILE = path19.join(RUNTIME_DIR, "status.json");
+var PID_FILE = path19.join(RUNTIME_DIR, "bridge.pid");
+var runId = crypto11.randomUUID();
+async function resolveProvider() {
+  const { CodexProvider: CodexProvider2 } = await Promise.resolve().then(() => (init_codex_provider(), codex_provider_exports));
+  return new CodexProvider2();
+}
+function writeStatus(info, options = {}) {
+  return writeRuntimeStatus(STATUS_FILE, info, options);
 }
 function getRunningChannels() {
   return getStatus().adapters.map((adapter) => adapter.channelType).sort();
@@ -19429,10 +19538,6 @@ async function main() {
   const lockState = tryAcquireBridgeInstanceLock();
   if (!lockState.acquired) {
     const holderPid = lockState.holderPid;
-    writeStatus({
-      running: true,
-      ...Number.isFinite(holderPid) && holderPid ? { pid: holderPid } : {}
-    });
     console.log(
       `[codex-to-im] Another bridge daemon is already running${holderPid ? ` (PID: ${holderPid})` : ""}. Exiting duplicate launcher.`
     );
@@ -19444,9 +19549,15 @@ async function main() {
     releaseBridgeInstanceLock(void 0, process.pid);
     instanceLockHeld = false;
   };
+  writeStatus({
+    running: false,
+    pid: process.pid,
+    runId,
+    channels: [],
+    adapters: []
+  }, { expectedRunId: runId, allowRunIdTakeover: true });
   const config2 = loadConfig();
   setupLogger();
-  const runId = crypto10.randomUUID();
   console.log(`[codex-to-im] Starting bridge (run_id: ${runId})`);
   const settings = configToSettings(config2);
   const store = new JsonFileStore(settings, { dynamicSettings: true });
@@ -19462,8 +19573,8 @@ async function main() {
     permissions: gateway,
     lifecycle: {
       onBridgeStart: () => {
-        fs16.mkdirSync(RUNTIME_DIR, { recursive: true });
-        fs16.writeFileSync(PID_FILE, String(process.pid), "utf-8");
+        fs18.mkdirSync(RUNTIME_DIR, { recursive: true });
+        fs18.writeFileSync(PID_FILE, String(process.pid), "utf-8");
         const channels = getRunningChannels();
         writeStatus({
           running: true,
@@ -19472,7 +19583,7 @@ async function main() {
           startedAt: (/* @__PURE__ */ new Date()).toISOString(),
           channels,
           adapters: getAdapterStatuses()
-        });
+        }, { expectedRunId: runId });
         console.log(`[codex-to-im] Bridge started (PID: ${process.pid}, channels: ${channels.join(", ")})`);
       },
       onBridgeAdaptersChanged: (channels) => {
@@ -19482,41 +19593,60 @@ async function main() {
           runId,
           channels,
           adapters: getAdapterStatuses()
-        });
+        }, { expectedRunId: runId });
         console.log(`[codex-to-im] Active channels updated: ${channels.join(", ") || "none"}`);
       },
       onBridgeStop: () => {
         releaseInstanceLock();
-        writeStatus({ running: false, channels: [], adapters: [] });
+        writeStatus({ running: false, channels: [], adapters: [] }, { expectedRunId: runId });
         console.log("[codex-to-im] Bridge stopped");
       }
     }
   });
   await start();
   let shuttingDown = false;
-  const shutdown = async (signal) => {
+  const shutdown = async (reason, exitCode = 0) => {
     if (shuttingDown) return;
     shuttingDown = true;
-    const reason = signal ? `signal: ${signal}` : "shutdown requested";
     console.log(`[codex-to-im] Shutting down (${reason})...`);
     pendingPerms.denyAll();
-    await stop();
-    releaseInstanceLock();
-    writeStatus({ running: false, lastExitReason: reason });
-    process.exit(0);
+    try {
+      await stop();
+    } catch (error) {
+      console.error("[codex-to-im] Graceful bridge stop failed:", error instanceof Error ? error.stack || error.message : error);
+    } finally {
+      releaseInstanceLock();
+      try {
+        writeStatus({ running: false, lastExitReason: reason }, { expectedRunId: runId });
+      } catch (error) {
+        console.error("[codex-to-im] Failed to write final runtime status:", error instanceof Error ? error.message : error);
+      }
+      process.exit(exitCode);
+    }
   };
-  process.on("SIGTERM", () => shutdown("SIGTERM"));
-  process.on("SIGINT", () => shutdown("SIGINT"));
-  process.on("SIGHUP", () => shutdown("SIGHUP"));
+  process.on("SIGTERM", () => {
+    void shutdown("signal: SIGTERM");
+  });
+  process.on("SIGINT", () => {
+    void shutdown("signal: SIGINT");
+  });
+  process.on("SIGHUP", () => {
+    void shutdown("signal: SIGHUP");
+  });
   process.on("unhandledRejection", (reason) => {
     console.error("[codex-to-im] unhandledRejection:", reason instanceof Error ? reason.stack || reason.message : reason);
-    writeStatus({ running: false, lastExitReason: `unhandledRejection: ${reason instanceof Error ? reason.message : String(reason)}` });
+    writeStatus({
+      running: true,
+      pid: process.pid,
+      runId,
+      channels: getRunningChannels(),
+      adapters: getAdapterStatuses(),
+      lastExitReason: `unhandledRejection: ${reason instanceof Error ? reason.message : String(reason)}`
+    }, { expectedRunId: runId });
   });
   process.on("uncaughtException", (err) => {
     console.error("[codex-to-im] uncaughtException:", err.stack || err.message);
-    releaseInstanceLock();
-    writeStatus({ running: false, lastExitReason: `uncaughtException: ${err.message}` });
-    process.exit(1);
+    void shutdown(`uncaughtException: ${err.message}`, 1);
   });
   process.on("beforeExit", (code2) => {
     console.log(`[codex-to-im] beforeExit (code: ${code2})`);
@@ -19532,7 +19662,10 @@ main().catch((err) => {
   console.error("[codex-to-im] Fatal error:", err instanceof Error ? err.stack || err.message : err);
   releaseBridgeInstanceLock(void 0, process.pid);
   try {
-    writeStatus({ running: false, lastExitReason: `fatal: ${err instanceof Error ? err.message : String(err)}` });
+    writeStatus(
+      { running: false, lastExitReason: `fatal: ${err instanceof Error ? err.message : String(err)}` },
+      { expectedRunId: runId }
+    );
   } catch {
   }
   process.exit(1);

package/dist/ui-server.mjs

@@ -1572,10 +1572,10 @@ var require_segments = __commonJS({
       const segs = getSegmentsFromString(data, Utils.isKanjiModeEnabled());
       const nodes = buildNodes(segs);
       const graph = buildGraph(nodes, version);
-      const path10 = dijkstra.find_path(graph.map, "start", "end");
+      const path11 = dijkstra.find_path(graph.map, "start", "end");
       const optimizedSegs = [];
-      for (let i = 1; i < path10.length - 1; i++) {
-        optimizedSegs.push(graph.table[path10[i]].node);
+      for (let i = 1; i < path11.length - 1; i++) {
+        optimizedSegs.push(graph.table[path11[i]].node);
       }
       return exports.fromArray(mergeSegments(optimizedSegs));
     };
@@ -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 fs10 = __require("fs");
+    var fs11 = __require("fs");
     var PNG = require_png().PNG;
     var Utils = require_utils2();
     exports.render = function render(qrData, options) {
@@ -4052,7 +4052,7 @@ var require_png2 = __commonJS({
       });
       png.pack();
     };
-    exports.renderToFile = function renderToFile(path10, qrData, options, cb) {
+    exports.renderToFile = function renderToFile(path11, qrData, options, cb) {
       if (typeof cb === "undefined") {
         cb = options;
         options = void 0;
@@ -4063,7 +4063,7 @@ var require_png2 = __commonJS({
         called = true;
         cb.apply(null, args);
       };
-      const stream = fs10.createWriteStream(path10);
+      const stream = fs11.createWriteStream(path11);
       stream.on("error", done);
       stream.on("close", done);
       exports.renderToFileStream(stream, qrData, options);
@@ -4125,14 +4125,14 @@ var require_utf8 = __commonJS({
       }
       return output;
     };
-    exports.renderToFile = function renderToFile(path10, qrData, options, cb) {
+    exports.renderToFile = function renderToFile(path11, qrData, options, cb) {
       if (typeof cb === "undefined") {
         cb = options;
         options = void 0;
       }
-      const fs10 = __require("fs");
+      const fs11 = __require("fs");
       const utf8 = exports.render(qrData, options);
-      fs10.writeFile(path10, utf8, cb);
+      fs11.writeFile(path11, utf8, cb);
     };
   }
 });
@@ -4253,7 +4253,7 @@ var require_svg_tag = __commonJS({
       return str;
     }
     function qrToPath(data, size, margin) {
-      let path10 = "";
+      let path11 = "";
       let moveBy = 0;
       let newRow = false;
       let lineLength = 0;
@@ -4264,19 +4264,19 @@ var require_svg_tag = __commonJS({
         if (data[i]) {
           lineLength++;
           if (!(i > 0 && col > 0 && data[i - 1])) {
-            path10 += newRow ? svgCmd("M", col + margin, 0.5 + row + margin) : svgCmd("m", moveBy, 0);
+            path11 += newRow ? svgCmd("M", col + margin, 0.5 + row + margin) : svgCmd("m", moveBy, 0);
             moveBy = 0;
             newRow = false;
           }
           if (!(col + 1 < size && data[i + 1])) {
-            path10 += svgCmd("h", lineLength);
+            path11 += svgCmd("h", lineLength);
             lineLength = 0;
           }
         } else {
           moveBy++;
         }
       }
-      return path10;
+      return path11;
     }
     exports.render = function render(qrData, options, cb) {
       const opts = Utils.getOptions(options);
@@ -4284,10 +4284,10 @@ var require_svg_tag = __commonJS({
       const data = qrData.modules.data;
       const qrcodesize = size + opts.margin * 2;
       const bg = !opts.color.light.a ? "" : "<path " + getColorAttrib(opts.color.light, "fill") + ' d="M0 0h' + qrcodesize + "v" + qrcodesize + 'H0z"/>';
-      const path10 = "<path " + getColorAttrib(opts.color.dark, "stroke") + ' d="' + qrToPath(data, size, opts.margin) + '"/>';
+      const path11 = "<path " + getColorAttrib(opts.color.dark, "stroke") + ' d="' + qrToPath(data, size, opts.margin) + '"/>';
       const viewBox = 'viewBox="0 0 ' + qrcodesize + " " + qrcodesize + '"';
       const width = !opts.width ? "" : 'width="' + opts.width + '" height="' + opts.width + '" ';
-      const svgTag = '<svg xmlns="http://www.w3.org/2000/svg" ' + width + viewBox + ' shape-rendering="crispEdges">' + bg + path10 + "</svg>\n";
+      const svgTag = '<svg xmlns="http://www.w3.org/2000/svg" ' + width + viewBox + ' shape-rendering="crispEdges">' + bg + path11 + "</svg>\n";
       if (typeof cb === "function") {
         cb(null, svgTag);
       }
@@ -4301,15 +4301,15 @@ var require_svg = __commonJS({
   "node_modules/qrcode/lib/renderer/svg.js"(exports) {
     var svgTagRenderer = require_svg_tag();
     exports.render = svgTagRenderer.render;
-    exports.renderToFile = function renderToFile(path10, qrData, options, cb) {
+    exports.renderToFile = function renderToFile(path11, qrData, options, cb) {
       if (typeof cb === "undefined") {
         cb = options;
         options = void 0;
       }
-      const fs10 = __require("fs");
+      const fs11 = __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;
-      fs10.writeFile(path10, xmlStr, cb);
+      fs11.writeFile(path11, xmlStr, cb);
     };
   }
 });
@@ -4467,8 +4467,8 @@ var require_server = __commonJS({
         cb
       };
     }
-    function getTypeFromFilename(path10) {
-      return path10.slice((path10.lastIndexOf(".") - 1 >>> 0) + 2).toLowerCase();
+    function getTypeFromFilename(path11) {
+      return path11.slice((path11.lastIndexOf(".") - 1 >>> 0) + 2).toLowerCase();
     }
     function getRendererFromType(type) {
       switch (type) {
@@ -4532,17 +4532,17 @@ var require_server = __commonJS({
       const renderer = getRendererFromType(params.opts.type);
       return render(renderer.renderToBuffer, text2, params);
     };
-    exports.toFile = function toFile(path10, text2, opts, cb) {
-      if (typeof path10 !== "string" || !(typeof text2 === "string" || typeof text2 === "object")) {
+    exports.toFile = function toFile(path11, text2, opts, cb) {
+      if (typeof path11 !== "string" || !(typeof text2 === "string" || typeof text2 === "object")) {
         throw new Error("Invalid argument");
       }
       if (arguments.length < 3 && !canPromise()) {
         throw new Error("Too few arguments provided");
       }
       const params = checkParams(text2, opts, cb);
-      const type = params.opts.type || getTypeFromFilename(path10);
+      const type = params.opts.type || getTypeFromFilename(path11);
       const renderer = getRendererFromType(type);
-      const renderToFile = renderer.renderToFile.bind(null, path10);
+      const renderToFile = renderer.renderToFile.bind(null, path11);
       return render(renderToFile, text2, params);
     };
     exports.toFileStream = function toFileStream(stream, text2, opts) {
@@ -4566,7 +4566,7 @@ var require_lib = __commonJS({
 
 // src/ui-server.ts
 import http from "node:http";
-import crypto8 from "node:crypto";
+import crypto9 from "node:crypto";
 import net from "node:net";
 import os5 from "node:os";
 
@@ -6438,40 +6438,76 @@ function isCodexIntegrationInstalled() {
 }
 
 // src/store.ts
+import fs7 from "node:fs";
+import path7 from "node:path";
+import crypto5 from "node:crypto";
+
+// src/atomic-file.ts
+import crypto4 from "node:crypto";
 import fs6 from "node:fs";
 import path6 from "node:path";
-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) {
-  fs6.mkdirSync(dir, { recursive: true });
+var RETRYABLE_RENAME_CODES = /* @__PURE__ */ new Set(["EACCES", "EBUSY", "EPERM"]);
+var WAIT_ARRAY2 = new Int32Array(new SharedArrayBuffer(4));
+function defaultSleepSync(delayMs) {
+  Atomics.wait(WAIT_ARRAY2, 0, 0, Math.max(1, delayMs));
+}
+function isRetryableRenameError(error) {
+  return RETRYABLE_RENAME_CODES.has(error?.code || "");
+}
+function renameFileWithRetrySync(source, destination, options = {}) {
+  const maxAttempts = Math.max(1, options.maxAttempts ?? 8);
+  const baseDelayMs = Math.max(1, options.baseDelayMs ?? 15);
+  const renameSync = options.renameSync ?? fs6.renameSync;
+  const sleepSync2 = options.sleepSync ?? defaultSleepSync;
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    try {
+      renameSync(source, destination);
+      return;
+    } catch (error) {
+      if (!isRetryableRenameError(error) || attempt === maxAttempts - 1) {
+        throw error;
+      }
+      sleepSync2(Math.min(250, baseDelayMs * 2 ** attempt));
+    }
+  }
 }
-function atomicWrite(filePath, data) {
-  const tmp = `${filePath}.${process.pid}.${crypto4.randomUUID()}.tmp`;
+function atomicWriteFileSync(filePath, data) {
+  fs6.mkdirSync(path6.dirname(filePath), { recursive: true });
+  const tmpPath = `${filePath}.${process.pid}.${crypto4.randomUUID()}.tmp`;
   try {
-    fs6.writeFileSync(tmp, data, "utf-8");
-    fs6.renameSync(tmp, filePath);
+    fs6.writeFileSync(tmpPath, data, "utf-8");
+    renameFileWithRetrySync(tmpPath, filePath);
   } finally {
     try {
-      fs6.rmSync(tmp, { force: true });
+      fs6.rmSync(tmpPath, { force: true });
     } catch {
     }
   }
 }
+
+// src/store.ts
+var DATA_DIR = path7.join(CTI_HOME, "data");
+var MESSAGES_DIR = path7.join(DATA_DIR, "messages");
+var SESSIONS_PATH = path7.join(DATA_DIR, "sessions.json");
+var BINDINGS_PATH = path7.join(DATA_DIR, "bindings.json");
+var PERMISSIONS_PATH = path7.join(DATA_DIR, "permissions.json");
+var OFFSETS_PATH = path7.join(DATA_DIR, "offsets.json");
+var DEDUP_PATH = path7.join(DATA_DIR, "dedup.json");
+var AUDIT_PATH = path7.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) {
+  fs7.mkdirSync(dir, { recursive: true });
+}
+function atomicWrite(filePath, data) {
+  atomicWriteFileSync(filePath, data);
+}
 function dedupTtlMs(key) {
   return key.startsWith("inbound:") ? INBOUND_DEDUP_TTL_MS : DEFAULT_DEDUP_TTL_MS;
 }
 function readJson(filePath, fallback) {
   try {
-    const raw = fs6.readFileSync(filePath, "utf-8");
+    const raw = fs7.readFileSync(filePath, "utf-8");
     return JSON.parse(raw);
   } catch (error) {
     if (error.code === "ENOENT") return fallback;
@@ -6482,7 +6518,7 @@ function writeJson(filePath, data) {
   atomicWrite(filePath, JSON.stringify(data, null, 2));
 }
 function uuid() {
-  return crypto4.randomUUID();
+  return crypto5.randomUUID();
 }
 function now() {
   return (/* @__PURE__ */ new Date()).toISOString();
@@ -6645,14 +6681,14 @@ var JsonFileStore = class {
   }
   persistMessages(sessionId) {
     const msgs = this.messages.get(sessionId) || [];
-    writeJson(path6.join(MESSAGES_DIR, `${sessionId}.json`), msgs);
+    writeJson(path7.join(MESSAGES_DIR, `${sessionId}.json`), msgs);
   }
   loadMessages(sessionId) {
     if (this.messages.has(sessionId)) {
       return this.messages.get(sessionId);
     }
     const msgs = readJson(
-      path6.join(MESSAGES_DIR, `${sessionId}.json`),
+      path7.join(MESSAGES_DIR, `${sessionId}.json`),
       []
     );
     this.messages.set(sessionId, msgs);
@@ -6675,7 +6711,7 @@ var JsonFileStore = class {
     });
   }
   mutateMessages(sessionId, mutation) {
-    const messagePath = path6.join(MESSAGES_DIR, `${sessionId}.json`);
+    const messagePath = path7.join(MESSAGES_DIR, `${sessionId}.json`);
     return withFileLock(messagePath, () => {
       const messages = readJson(messagePath, []);
       this.messages.set(sessionId, messages);
@@ -6834,7 +6870,7 @@ var JsonFileStore = class {
     });
   }
   deleteSession(sessionId) {
-    const messagePath = path6.join(MESSAGES_DIR, `${sessionId}.json`);
+    const messagePath = path7.join(MESSAGES_DIR, `${sessionId}.json`);
     withFileLocks([SESSIONS_PATH, BINDINGS_PATH, messagePath], () => {
       this.reloadSessions();
       this.reloadBindings();
@@ -6846,7 +6882,7 @@ var JsonFileStore = class {
       }
       this.messages.delete(sessionId);
       try {
-        fs6.rmSync(messagePath, { force: true });
+        fs7.rmSync(messagePath, { force: true });
       } catch {
       }
       this.persistSessions();
@@ -6860,7 +6896,7 @@ var JsonFileStore = class {
     });
   }
   getMessages(sessionId, opts) {
-    const messagePath = path6.join(MESSAGES_DIR, `${sessionId}.json`);
+    const messagePath = path7.join(MESSAGES_DIR, `${sessionId}.json`);
     const msgs = readJson(messagePath, []);
     this.messages.set(sessionId, msgs);
     if (opts?.limit && opts.limit > 0) {
@@ -7064,13 +7100,13 @@ var JsonFileStore = class {
 
 // src/weixin-login.ts
 var import_qrcode = __toESM(require_lib(), 1);
-import fs8 from "node:fs";
-import path8 from "node:path";
-import crypto7 from "node:crypto";
+import fs9 from "node:fs";
+import path9 from "node:path";
+import crypto8 from "node:crypto";
 import { spawn as spawn2 } from "node:child_process";
 
 // src/adapters/weixin/weixin-api.ts
-import crypto5 from "node:crypto";
+import crypto6 from "node:crypto";
 
 // src/adapters/weixin/weixin-types.ts
 var DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com";
@@ -7119,32 +7155,32 @@ async function pollLoginQrStatus(qrcode, baseUrl) {
 }
 
 // src/weixin-store.ts
-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");
-var CONTEXT_TOKENS_PATH = path7.join(DATA_DIR2, "weixin-context-tokens.json");
+import fs8 from "node:fs";
+import crypto7 from "node:crypto";
+import path8 from "node:path";
+var DATA_DIR2 = path8.join(CTI_HOME, "data");
+var ACCOUNTS_PATH = path8.join(DATA_DIR2, "weixin-accounts.json");
+var CONTEXT_TOKENS_PATH = path8.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) {
-  fs7.mkdirSync(dir, { recursive: true });
+  fs8.mkdirSync(dir, { recursive: true });
 }
 function atomicWrite2(filePath, data) {
-  const tmpPath = `${filePath}.${process.pid}.${crypto6.randomUUID()}.tmp`;
+  const tmpPath = `${filePath}.${process.pid}.${crypto7.randomUUID()}.tmp`;
   try {
-    fs7.writeFileSync(tmpPath, data, "utf-8");
-    fs7.renameSync(tmpPath, filePath);
+    fs8.writeFileSync(tmpPath, data, "utf-8");
+    fs8.renameSync(tmpPath, filePath);
   } finally {
     try {
-      fs7.rmSync(tmpPath, { force: true });
+      fs8.rmSync(tmpPath, { force: true });
     } catch {
     }
   }
 }
 function readJson2(filePath, fallback) {
   try {
-    const raw = fs7.readFileSync(filePath, "utf-8");
+    const raw = fs8.readFileSync(filePath, "utf-8");
     return JSON.parse(raw);
   } catch (error) {
     if (error.code === "ENOENT") return fallback;
@@ -7236,11 +7272,11 @@ var MAX_REFRESHES = 3;
 var QR_TTL_MS = 5 * 6e4;
 var POLL_INTERVAL_MS = 3e3;
 var WEB_SESSION_TTL_MS = 15 * 6e4;
-var RUNTIME_DIR = path8.join(CTI_HOME, "runtime");
-var HTML_PATH = path8.join(RUNTIME_DIR, "weixin-login.html");
+var RUNTIME_DIR = path9.join(CTI_HOME, "runtime");
+var HTML_PATH = path9.join(RUNTIME_DIR, "weixin-login.html");
 var webLoginSessions = /* @__PURE__ */ new Map();
 function ensureRuntimeDir() {
-  fs8.mkdirSync(RUNTIME_DIR, { recursive: true });
+  fs9.mkdirSync(RUNTIME_DIR, { recursive: true });
 }
 function escapeHtml(text2) {
   return text2.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
@@ -7553,7 +7589,7 @@ function buildWeixinLoginPopupHtml(sessionId) {
 async function writeQrHtml(session) {
   ensureRuntimeDir();
   const qrSvg = await buildQrSvg(session.qrImageUrl);
-  fs8.writeFileSync(HTML_PATH, buildQrHtml(qrSvg), "utf-8");
+  fs9.writeFileSync(HTML_PATH, buildQrHtml(qrSvg), "utf-8");
 }
 function openQrHtml() {
   try {
@@ -7742,7 +7778,7 @@ async function startWeixinLoginWebSession(options = {}) {
   ensureRuntimeDir();
   const config = options.config || {};
   const seed = await createSession(0, config.baseUrl);
-  const sessionId = crypto7.randomUUID();
+  const sessionId = crypto8.randomUUID();
   const qrSvg = await buildQrSvg(seed.qrImageUrl);
   const session = {
     id: sessionId,
@@ -7814,7 +7850,7 @@ async function runWeixinLogin(config = {}) {
 }
 var isMainModule = (() => {
   const entry = process.argv[1];
-  return !!entry && path8.resolve(entry) === path8.resolve(new URL(import.meta.url).pathname);
+  return !!entry && path9.resolve(entry) === path9.resolve(new URL(import.meta.url).pathname);
 })();
 if (isMainModule) {
   runWeixinLogin().catch((err) => {
@@ -7824,11 +7860,11 @@ if (isMainModule) {
 }
 
 // src/codex-models.ts
-import fs9 from "node:fs";
+import fs10 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");
+import path10 from "node:path";
+var DEFAULT_CODEX_CONFIG_PATH = path10.join(os4.homedir(), ".codex", "config.toml");
+var DEFAULT_CODEX_MODELS_CACHE_PATH = path10.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",
@@ -7877,7 +7913,7 @@ var KNOWN_CODEX_MODEL_FALLBACKS = [
 ];
 function readConfiguredCodexModel(configPath = DEFAULT_CODEX_CONFIG_PATH) {
   try {
-    const raw = fs9.readFileSync(configPath, "utf-8");
+    const raw = fs10.readFileSync(configPath, "utf-8");
     let inSection = false;
     for (const line of raw.split(/\r?\n/)) {
       const trimmed = line.trim();
@@ -7921,7 +7957,7 @@ function parseSupportedReasoningLevels(value) {
 }
 function listCachedCodexModels(cachePath = DEFAULT_CODEX_MODELS_CACHE_PATH) {
   try {
-    const raw = fs9.readFileSync(cachePath, "utf-8");
+    const raw = fs10.readFileSync(cachePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed.models)) return [];
     const seen = /* @__PURE__ */ new Set();
@@ -8220,14 +8256,14 @@ function channelToPayload(channel) {
   };
 }
 function generateAccessToken() {
-  return crypto8.randomBytes(18).toString("base64url");
+  return crypto9.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 crypto8.timingSafeEqual(leftBuffer, rightBuffer);
+  return crypto9.timingSafeEqual(leftBuffer, rightBuffer);
 }
 function parseCookies(request) {
   const header = request.headers.cookie;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-to-im",
-  "version": "1.0.60",
+  "version": "1.0.61",
   "description": "Installable Codex-to-IM bridge with local setup UI and background service",
   "license": "MIT",
   "homepage": "https://github.com/zhangle1987/codex-to-im#readme",