claude-codex-wechat 0.1.23 → 0.1.25

package/dist/server/cli.js

@@ -3,7 +3,7 @@ import { createRequire as __cjsCreateRequire } from 'node:module'; const require
 
 // src/cli.ts
 import { existsSync as existsSync10, readFileSync as readFileSync9 } from "node:fs";
-import { dirname as dirname13, join as join13 } from "node:path";
+import { dirname as dirname9, join as join14 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/daemon/bootstrap.ts
@@ -12,7 +12,7 @@ import { networkInterfaces } from "node:os";
 // src/daemon/server.ts
 import { mkdtempSync } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { dirname as dirname11, join as join10 } from "node:path";
+import { dirname as dirname7, join as join11 } from "node:path";
 import Fastify from "fastify";
 
 // src/channels/platforms.ts
@@ -151,10 +151,109 @@ function normalizeWechatConfig(raw, env) {
 }
 
 // src/daemon/configPersistence.ts
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { readFile, rm } from "node:fs/promises";
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+
+// src/shared/atomicFile.ts
+import { closeSync, fsyncSync, mkdirSync, openSync, renameSync, unlinkSync, writeSync } from "node:fs";
+import { mkdir, open, readdir, rename, stat, unlink } from "node:fs/promises";
 import { randomBytes } from "node:crypto";
-import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
+import { basename, dirname, join as join2 } from "node:path";
+var FILE_MODE = 384;
+function tempPathFor(path) {
+  return join2(dirname(path), `.${basename(path)}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`);
+}
+var RENAME_RETRY_CODES = /* @__PURE__ */ new Set(["EPERM", "EACCES", "EBUSY"]);
+var MAX_RENAME_RETRIES = 10;
+function isRetriableRenameError(error) {
+  if (process.platform !== "win32") return false;
+  const code = error?.code ?? "";
+  return RENAME_RETRY_CODES.has(code);
+}
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function sleep(ms) {
+  return new Promise((resolve2) => {
+    setTimeout(resolve2, ms);
+  });
+}
+function writeFileAtomicSync(path, data) {
+  const tmp = tempPathFor(path);
+  mkdirSync(dirname(path), { recursive: true });
+  try {
+    const fd = openSync(tmp, "w", FILE_MODE);
+    try {
+      writeSync(fd, data, null, "utf8");
+      fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
+    for (let attempt = 0; ; attempt++) {
+      try {
+        renameSync(tmp, path);
+        return;
+      } catch (error) {
+        if (attempt >= MAX_RENAME_RETRIES || !isRetriableRenameError(error)) throw error;
+        sleepSync((attempt + 1) * 10);
+      }
+    }
+  } catch (error) {
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    throw error;
+  }
+}
+async function writeFileAtomic(path, data) {
+  const tmp = tempPathFor(path);
+  await mkdir(dirname(path), { recursive: true });
+  try {
+    const handle = await open(tmp, "w", FILE_MODE);
+    try {
+      await handle.writeFile(data, "utf8");
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    for (let attempt = 0; ; attempt++) {
+      try {
+        await rename(tmp, path);
+        return;
+      } catch (error) {
+        if (attempt >= MAX_RENAME_RETRIES || !isRetriableRenameError(error)) throw error;
+        await sleep((attempt + 1) * 10);
+      }
+    }
+  } catch (error) {
+    await unlink(tmp).catch(() => void 0);
+    throw error;
+  }
+}
+async function cleanupStaleTempFiles(targetPath, maxAgeMs = 36e5) {
+  const dir = dirname(targetPath);
+  const prefix = `.${basename(targetPath)}.`;
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return;
+  }
+  const now = Date.now();
+  await Promise.all(entries.map(async (name) => {
+    if (!name.startsWith(prefix) || !name.endsWith(".tmp")) return;
+    const full = join2(dir, name);
+    try {
+      const info = await stat(full);
+      if (now - info.mtimeMs >= maxAgeMs) await unlink(full);
+    } catch {
+    }
+  }));
+}
+
+// src/daemon/configPersistence.ts
 async function persistWechatCredentialsToConfigFile(input) {
   const currentConfig = await readConfigFile(input.configPath);
   const nextConfig = {
@@ -167,9 +266,8 @@ async function persistWechatCredentialsToConfigFile(input) {
       accountId: input.accountId
     }
   };
-  await mkdir(dirname(input.configPath), { recursive: true });
-  await writeFile(input.configPath, `${JSON.stringify(nextConfig, null, 2)}
-`, "utf8");
+  await writeFileAtomic(input.configPath, `${JSON.stringify(nextConfig, null, 2)}
+`);
 }
 async function deleteConfigFile(configPath) {
   try {
@@ -190,9 +288,8 @@ function persistUpdateStatusToConfigFile(input) {
       ...input.status.lastCheckedAt !== void 0 ? { lastCheckedAt: input.status.lastCheckedAt } : {}
     }
   };
-  mkdirSync(dirname(input.configPath), { recursive: true });
-  writeFileSync(input.configPath, `${JSON.stringify(nextConfig, null, 2)}
-`, "utf8");
+  writeFileAtomicSync(input.configPath, `${JSON.stringify(nextConfig, null, 2)}
+`);
 }
 async function persistBridgeDefaultsToConfigFile(input) {
   const currentConfig = await readConfigFile(input.configPath);
@@ -215,9 +312,8 @@ async function persistBridgeDefaultsToConfigFile(input) {
       }
     } : {}
   };
-  await mkdir(dirname(input.configPath), { recursive: true });
-  await writeFile(input.configPath, `${JSON.stringify(nextConfig, null, 2)}
-`, "utf8");
+  await writeFileAtomic(input.configPath, `${JSON.stringify(nextConfig, null, 2)}
+`);
 }
 function ensureRelayAuthTokenSync(input) {
   const currentConfig = readConfigFileSync(input.configPath);
@@ -225,7 +321,7 @@ function ensureRelayAuthTokenSync(input) {
   const currentRelay = isRecord(currentTunnel?.relay) ? currentTunnel.relay : void 0;
   const existing = typeof currentRelay?.authToken === "string" && currentRelay.authToken.trim() ? currentRelay.authToken.trim() : "";
   if (existing) return existing;
-  const authToken = `clrt_${randomBytes(12).toString("hex")}`;
+  const authToken = `clrt_${randomBytes2(12).toString("hex")}`;
   const nextConfig = {
     ...currentConfig,
     tunnel: {
@@ -236,9 +332,8 @@ function ensureRelayAuthTokenSync(input) {
       }
     }
   };
-  mkdirSync(dirname(input.configPath), { recursive: true });
-  writeFileSync(input.configPath, `${JSON.stringify(nextConfig, null, 2)}
-`, "utf8");
+  writeFileAtomicSync(input.configPath, `${JSON.stringify(nextConfig, null, 2)}
+`);
   return authToken;
 }
 async function persistProviderCommandsToConfigFile(input) {
@@ -248,9 +343,8 @@ async function persistProviderCommandsToConfigFile(input) {
     ...currentConfig,
     providers: normalizedProviders
   };
-  await mkdir(dirname(input.configPath), { recursive: true });
-  await writeFile(input.configPath, `${JSON.stringify(nextConfig, null, 2)}
-`, "utf8");
+  await writeFileAtomic(input.configPath, `${JSON.stringify(nextConfig, null, 2)}
+`);
 }
 async function readConfigFile(path) {
   try {
@@ -290,8 +384,7 @@ function normalizeProvidersForPersistence(providers) {
 }
 
 // src/channels/weixin-direct/weixinStateStore.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname2 } from "node:path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
 var PUSH_QUOTA_LIMIT = 10;
 var PUSH_WINDOW_MS = 24 * 60 * 60 * 1e3;
 var FileWeixinStateStore = class {
@@ -397,16 +490,15 @@ var FileWeixinStateStore = class {
       ...state,
       bridge: { ...state.bridge ?? {}, weixinChannel: channel }
     };
-    mkdirSync2(dirname2(this.configPath), { recursive: true });
-    writeFileSync2(this.configPath, `${JSON.stringify(next, null, 2)}
-`, "utf8");
+    writeFileAtomicSync(this.configPath, `${JSON.stringify(next, null, 2)}
+`);
   }
 };
 
 // src/providers/claude-code/nativeSessions.ts
-import { appendFile, mkdir as mkdir2, readdir, readFile as readFile2, stat, writeFile as writeFile2 } from "node:fs/promises";
+import { appendFile, mkdir as mkdir2, readdir as readdir2, readFile as readFile2, stat as stat2, writeFile } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { basename, dirname as dirname3, join as join2 } from "node:path";
+import { basename as basename2, dirname as dirname2, join as join3 } from "node:path";
 
 // src/session/sessionBridgeTag.ts
 function buildSessionBridgeName(input) {
@@ -433,27 +525,27 @@ function parseSessionBridgeName(value) {
 
 // src/providers/claude-code/nativeSessions.ts
 function resolveClaudeConfigDir(env = process.env) {
-  return join2(env.HOME || homedir2(), ".claude");
+  return join3(env.HOME || homedir2(), ".claude");
 }
 async function listRecoverableClaudeSessions(env = process.env) {
-  const projectsDir = join2(resolveClaudeConfigDir(env), "projects");
+  const projectsDir = join3(resolveClaudeConfigDir(env), "projects");
   const historyIndex = await readClaudeHistoryIndex(env);
   const candidates = [];
   try {
-    const projectEntries = await readdir(projectsDir, { withFileTypes: true });
+    const projectEntries = await readdir2(projectsDir, { withFileTypes: true });
     for (const entry of projectEntries) {
       if (!entry.isDirectory() || entry.isSymbolicLink()) continue;
-      const projectDir = join2(projectsDir, String(entry.name));
-      const sessionEntries = await readdir(projectDir, { withFileTypes: true }).catch(() => []);
+      const projectDir = join3(projectsDir, String(entry.name));
+      const sessionEntries = await readdir2(projectDir, { withFileTypes: true }).catch(() => []);
       for (const sessionEntry of sessionEntries) {
         if (!sessionEntry.isFile() || sessionEntry.isSymbolicLink()) continue;
         const fileName = String(sessionEntry.name);
         if (!fileName.endsWith(".jsonl")) continue;
-        const filePath = join2(projectDir, fileName);
-        const metadata = await stat(filePath).catch(() => null);
+        const filePath = join3(projectDir, fileName);
+        const metadata = await stat2(filePath).catch(() => null);
         const parsedMeta = await readClaudeSessionMetadata(filePath).catch(() => null);
-        const historyMeta = historyIndex.get(basename(fileName, ".jsonl"));
-        const sessionId = basename(fileName, ".jsonl");
+        const historyMeta = historyIndex.get(basename2(fileName, ".jsonl"));
+        const sessionId = basename2(fileName, ".jsonl");
         const bridgeTag = historyMeta?.bridgeTag ?? parseSessionBridgeName(parsedMeta?.sessionName);
         const cwd = parsedMeta?.cwd ?? historyMeta?.project;
         candidates.push({
@@ -475,14 +567,14 @@ async function listRecoverableClaudeSessions(env = process.env) {
 async function findRecoverableClaudeSessionPath(sessionId, env = process.env) {
   const trimmed = sessionId.trim();
   if (!trimmed || trimmed.includes("/") || trimmed.includes("\\")) return null;
-  const projectsDir = join2(resolveClaudeConfigDir(env), "projects");
+  const projectsDir = join3(resolveClaudeConfigDir(env), "projects");
   try {
-    const projectEntries = await readdir(projectsDir, { withFileTypes: true });
+    const projectEntries = await readdir2(projectsDir, { withFileTypes: true });
     for (const entry of projectEntries) {
       if (!entry.isDirectory() || entry.isSymbolicLink()) continue;
-      const sessionPath = join2(projectsDir, String(entry.name), `${trimmed}.jsonl`);
+      const sessionPath = join3(projectsDir, String(entry.name), `${trimmed}.jsonl`);
       try {
-        const metadata = await stat(sessionPath);
+        const metadata = await stat2(sessionPath);
         if (metadata.isFile()) return sessionPath;
       } catch {
       }
@@ -528,7 +620,7 @@ async function hasClaudeSessionBridgeMetadata(input) {
 }
 async function hasClaudeHistoryDisplay(input) {
   const env = input.env ?? process.env;
-  const historyPath = join2(resolveClaudeConfigDir(env), "history.jsonl");
+  const historyPath = join3(resolveClaudeConfigDir(env), "history.jsonl");
   try {
     const content = await readFile2(historyPath, "utf8");
     for (const line of content.split(/\r?\n/)) {
@@ -583,7 +675,7 @@ async function readClaudeSessionMetadata(filePath) {
   return { aiTitle, lastPrompt, sessionName, cwd };
 }
 async function readClaudeHistoryIndex(env) {
-  const historyPath = join2(resolveClaudeConfigDir(env), "history.jsonl");
+  const historyPath = join3(resolveClaudeConfigDir(env), "history.jsonl");
   const index = /* @__PURE__ */ new Map();
   try {
     const content = await readFile2(historyPath, "utf8");
@@ -608,7 +700,7 @@ async function readClaudeHistoryIndex(env) {
   return index;
 }
 async function upsertClaudeHistoryDisplay(input) {
-  const historyPath = join2(resolveClaudeConfigDir(input.env), "history.jsonl");
+  const historyPath = join3(resolveClaudeConfigDir(input.env), "history.jsonl");
   const lines = [];
   let replaced = false;
   let changed = false;
@@ -647,8 +739,8 @@ async function upsertClaudeHistoryDisplay(input) {
     }));
   }
   if (!changed) return false;
-  await mkdir2(dirname3(historyPath), { recursive: true });
-  await writeFile2(historyPath, `${lines.join("\n")}
+  await mkdir2(dirname2(historyPath), { recursive: true });
+  await writeFile(historyPath, `${lines.join("\n")}
 `, "utf8");
   return true;
 }
@@ -679,7 +771,7 @@ async function normalizeClaudeSessionFileForResume(sessionPath) {
     nextLines.push(line);
   }
   if (sawSdkCliEntrypoint && !hasPermissionMode) {
-    const sessionId = basename(sessionPath, ".jsonl");
+    const sessionId = basename2(sessionPath, ".jsonl");
     nextLines.unshift(JSON.stringify({
       type: "permission-mode",
       permissionMode: "bypassPermissions",
@@ -688,26 +780,26 @@ async function normalizeClaudeSessionFileForResume(sessionPath) {
     changed = true;
   }
   if (!changed) return false;
-  await writeFile2(sessionPath, `${nextLines.join("\n")}
+  await writeFile(sessionPath, `${nextLines.join("\n")}
 `, "utf8");
   return true;
 }
 
 // src/providers/codex/nativeSessions.ts
 import Database from "better-sqlite3";
-import { readdir as readdir2, readFile as readFile3, stat as stat2 } from "node:fs/promises";
+import { readdir as readdir3, readFile as readFile3, stat as stat3 } from "node:fs/promises";
 import { existsSync as existsSync4 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { basename as basename2, join as join3 } from "node:path";
+import { basename as basename3, join as join4 } from "node:path";
 function resolveCodexSessionsRoot(env = process.env) {
-  return join3(env.CODEX_HOME || join3(env.HOME || homedir3(), ".codex"), "sessions");
+  return join4(env.CODEX_HOME || join4(env.HOME || homedir3(), ".codex"), "sessions");
 }
 function isMatchingCodexRolloutFile(name) {
   return name.startsWith("rollout-") && name.endsWith(".jsonl");
 }
 function extractCodexSessionId(name) {
   if (!isMatchingCodexRolloutFile(name)) return null;
-  const withoutExt = basename2(name, ".jsonl");
+  const withoutExt = basename3(name, ".jsonl");
   const match = withoutExt.match(/^rollout-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-(.+)$/);
   if (!match?.[1]) return null;
   return match[1];
@@ -719,11 +811,11 @@ async function listRecoverableCodexSessions(env = process.env) {
   const candidates = [];
   async function walk(currentDir, depth) {
     if (depth > 8) return;
-    const entries = await readdir2(currentDir, { withFileTypes: true }).catch(() => []);
+    const entries = await readdir3(currentDir, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
       if (entry.isSymbolicLink()) continue;
       const name = String(entry.name);
-      const path = join3(currentDir, name);
+      const path = join4(currentDir, name);
       if (entry.isDirectory()) {
         await walk(path, depth + 1);
         continue;
@@ -755,11 +847,11 @@ async function findRecoverableCodexSessionPath(sessionId, env = process.env) {
   if (!trimmed || trimmed.includes("/") || trimmed.includes("\\")) return null;
   async function walk(currentDir, depth) {
     if (depth > 8) return null;
-    const entries = await readdir2(currentDir, { withFileTypes: true }).catch(() => []);
+    const entries = await readdir3(currentDir, { withFileTypes: true }).catch(() => []);
     for (const entry of entries) {
       if (entry.isSymbolicLink()) continue;
       const name = String(entry.name);
-      const path = join3(currentDir, name);
+      const path = join4(currentDir, name);
       if (entry.isDirectory()) {
         const found = await walk(path, depth + 1);
         if (found) return found;
@@ -773,7 +865,7 @@ async function findRecoverableCodexSessionPath(sessionId, env = process.env) {
   return await walk(root, 0);
 }
 async function readCodexSessionIndex(env) {
-  const indexPath = join3(env.CODEX_HOME || join3(env.HOME || homedir3(), ".codex"), "session_index.jsonl");
+  const indexPath = join4(env.CODEX_HOME || join4(env.HOME || homedir3(), ".codex"), "session_index.jsonl");
   const index = /* @__PURE__ */ new Map();
   try {
     const content = await readFile3(indexPath, "utf8");
@@ -796,7 +888,7 @@ async function readCodexSessionIndex(env) {
   return index;
 }
 function readCodexThreadMetadata(env) {
-  const dbPath = join3(env.CODEX_HOME || join3(env.HOME || homedir3(), ".codex"), "state_5.sqlite");
+  const dbPath = join4(env.CODEX_HOME || join4(env.HOME || homedir3(), ".codex"), "state_5.sqlite");
   const metadata = /* @__PURE__ */ new Map();
   if (!existsSync4(dbPath)) return metadata;
   let db = null;
@@ -841,7 +933,7 @@ async function readCodexSessionMeta(filePath) {
       } catch {
       }
     }
-    const metadata = await stat2(filePath).catch(() => null);
+    const metadata = await stat3(filePath).catch(() => null);
     return {
       cwd,
       lastActivityAt: metadata ? Math.trunc(metadata.mtimeMs) : void 0
@@ -855,11 +947,11 @@ async function readCodexSessionMeta(filePath) {
 import { nanoid } from "nanoid";
 
 // src/providers/codex/sessionIndex.ts
-import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
+import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import { dirname as dirname4, join as join4 } from "node:path";
+import { dirname as dirname3, join as join5 } from "node:path";
 function resolveCodexIndexPath(env = process.env) {
-  return join4(env.CODEX_HOME || join4(env.HOME || homedir4(), ".codex"), "session_index.jsonl");
+  return join5(env.CODEX_HOME || join5(env.HOME || homedir4(), ".codex"), "session_index.jsonl");
 }
 async function upsertCodexSessionIndexEntry(input, env = process.env) {
   const indexPath = resolveCodexIndexPath(env);
@@ -895,19 +987,19 @@ async function upsertCodexSessionIndexEntry(input, env = process.env) {
       updated_at: input.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
     }));
   }
-  await mkdir3(dirname4(indexPath), { recursive: true });
-  await writeFile3(indexPath, `${lines.join("\n")}
+  await mkdir3(dirname3(indexPath), { recursive: true });
+  await writeFile2(indexPath, `${lines.join("\n")}
 `, "utf8");
 }
 
 // src/providers/codex/nativeThreads.ts
 import Database2 from "better-sqlite3";
 import { existsSync as existsSync5 } from "node:fs";
-import { readFile as readFile5, writeFile as writeFile4 } from "node:fs/promises";
+import { readFile as readFile5, writeFile as writeFile3 } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 function resolveCodexStateDbPath(env = process.env) {
-  return join5(env.CODEX_HOME || join5(env.HOME || homedir5(), ".codex"), "state_5.sqlite");
+  return join6(env.CODEX_HOME || join6(env.HOME || homedir5(), ".codex"), "state_5.sqlite");
 }
 async function syncCodexThreadForResume(input) {
   const env = input.env ?? process.env;
@@ -963,7 +1055,7 @@ async function syncCodexRolloutSessionMeta(rolloutPath) {
     payload.originator = "codex-tui";
     first.payload = payload;
     lines[0] = JSON.stringify(first);
-    await writeFile4(rolloutPath, lines.join("\n"), "utf8");
+    await writeFile3(rolloutPath, lines.join("\n"), "utf8");
   } catch {
   }
 }
@@ -1568,9 +1660,9 @@ function normalizeSettings(input, defaultWorkspace) {
 }
 
 // src/admin/fsBrowseRoutes.ts
-import { readdir as readdir3 } from "node:fs/promises";
+import { readdir as readdir4 } from "node:fs/promises";
 import { homedir as homedir7 } from "node:os";
-import { dirname as dirname5, join as join6, resolve } from "node:path";
+import { dirname as dirname4, join as join7, resolve } from "node:path";
 
 // src/shared/expandTilde.ts
 import { homedir as homedir6 } from "node:os";
@@ -1591,13 +1683,13 @@ function registerFsBrowseRoutes(input) {
     const isOnKeepChain = (path) => keep !== null && (keep === path || keep.startsWith(path + "/"));
     let dirents;
     try {
-      dirents = await readdir3(target, { withFileTypes: true });
+      dirents = await readdir4(target, { withFileTypes: true });
     } catch {
       reply.code(400);
       return { error: "cannot_read_directory", path: target };
     }
-    const entries = dirents.filter((dirent) => dirent.isDirectory()).map((dirent) => ({ name: dirent.name, path: join6(target, dirent.name), isDirectory: true })).filter((entry) => !entry.name.startsWith(".") || isOnKeepChain(entry.path)).sort((a, b) => a.name.localeCompare(b.name));
-    const parent = dirname5(target);
+    const entries = dirents.filter((dirent) => dirent.isDirectory()).map((dirent) => ({ name: dirent.name, path: join7(target, dirent.name), isDirectory: true })).filter((entry) => !entry.name.startsWith(".") || isOnKeepChain(entry.path)).sort((a, b) => a.name.localeCompare(b.name));
+    const parent = dirname4(target);
     const isRoot = parent === target;
     const listing = {
       path: target,
@@ -1778,7 +1870,7 @@ var WeixinDirectApiClient = class {
 
 // src/channels/weixin-direct/adapter.ts
 import { setTimeout as delay2 } from "node:timers/promises";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 
 // src/channels/weixin-direct/typingController.ts
 var CONFIG_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
@@ -2043,7 +2135,7 @@ var WeixinDirectAdapter = class _WeixinDirectAdapter {
         continue;
       }
       const { ext, mimeType } = mediaExtAndMime(meta);
-      const destPath = join7(mediaDir, `${idPrefix}_${i}${ext}`);
+      const destPath = join8(mediaDir, `${idPrefix}_${i}${ext}`);
       const maxBytes = meta.kind === "video" ? VIDEO_MAX_BYTES : void 0;
       const result = await downloader.download(meta.media ?? {}, { destPath, aeskeyOverride: meta.aeskey, maxBytes });
       if (result.ok) {
@@ -2103,8 +2195,8 @@ function chunkText(text, limit) {
 }
 
 // src/channels/weixin-direct/mediaDownloader.ts
-import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "node:fs";
-import { dirname as dirname6 } from "node:path";
+import { mkdirSync as mkdirSync2, writeFileSync } from "node:fs";
+import { dirname as dirname5 } from "node:path";
 
 // src/channels/weixin-direct/mediaCrypto.ts
 import { createDecipheriv } from "node:crypto";
@@ -2167,8 +2259,8 @@ var WeixinMediaDownloader = class {
     } catch {
       return { ok: false, reason: "decrypt_failed" };
     }
-    mkdirSync3(dirname6(input.destPath), { recursive: true });
-    writeFileSync3(input.destPath, plaintext);
+    mkdirSync2(dirname5(input.destPath), { recursive: true });
+    writeFileSync(input.destPath, plaintext);
     return { ok: true, localPath: input.destPath, bytes: plaintext.length };
   }
 };
@@ -2354,7 +2446,7 @@ import { randomUUID as randomUUID2 } from "node:crypto";
 
 // src/shared/platform.ts
 import { access, constants } from "node:fs/promises";
-import { delimiter, join as join8 } from "node:path";
+import { delimiter, join as join9 } from "node:path";
 import { tmpdir } from "node:os";
 import { spawn } from "node:child_process";
 var isWindows = process.platform === "win32";
@@ -2382,7 +2474,7 @@ async function findExecutable(command) {
   const dirs = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
   for (const dir of dirs) {
     for (const ext of extensions) {
-      const candidate = join8(dir, command + ext);
+      const candidate = join9(dir, command + ext);
       if (await isExecutableFile(candidate)) return candidate;
     }
   }
@@ -2405,13 +2497,13 @@ function terminateChild(child, signal = "SIGTERM") {
   }
 }
 function defaultWorkspaceDir() {
-  return join8(tmpdir(), "project");
+  return join9(tmpdir(), "project");
 }
 function useShellForCli() {
   return isWindows;
 }
 function statePath(filename) {
-  return join8(tmpdir(), filename);
+  return join9(tmpdir(), filename);
 }
 
 // src/providers/claude-code/assistantContent.ts
@@ -3399,8 +3491,7 @@ function buildBridgeCommandHelpMarkdown(input) {
 }
 
 // src/session/currentConversationStore.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname7 } from "node:path";
+import { existsSync as existsSync6, readFileSync as readFileSync4 } from "node:fs";
 import { nanoid as nanoid2 } from "nanoid";
 var CurrentConversationStore = class {
   constructor(configPath, defaults) {
@@ -3482,9 +3573,8 @@ var CurrentConversationStore = class {
     this.writeState(state);
   }
   writeState(state) {
-    mkdirSync4(dirname7(this.configPath), { recursive: true });
-    writeFileSync4(this.configPath, `${JSON.stringify(state, null, 2)}
-`, "utf8");
+    writeFileAtomicSync(this.configPath, `${JSON.stringify(state, null, 2)}
+`);
   }
 };
 
@@ -4017,8 +4107,7 @@ function composeInboundText(content) {
 }
 
 // src/storage/lastProviderSessionStore.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname8 } from "node:path";
+import { existsSync as existsSync7, readFileSync as readFileSync5 } from "node:fs";
 var LastProviderSessionStore = class {
   constructor(configPath) {
     this.configPath = configPath;
@@ -4049,15 +4138,13 @@ var LastProviderSessionStore = class {
     return raw && typeof raw === "object" ? raw : {};
   }
   writeState(state) {
-    mkdirSync5(dirname8(this.configPath), { recursive: true });
-    writeFileSync5(this.configPath, `${JSON.stringify(state, null, 2)}
-`, "utf8");
+    writeFileAtomicSync(this.configPath, `${JSON.stringify(state, null, 2)}
+`);
   }
 };
 
 // src/storage/runtimeUserStore.ts
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync6, existsSync as existsSync8 } from "node:fs";
-import { dirname as dirname9 } from "node:path";
+import { readFileSync as readFileSync6, existsSync as existsSync8 } from "node:fs";
 import { nanoid as nanoid3 } from "nanoid";
 var RuntimeUserStore = class {
   constructor(configPath) {
@@ -4122,9 +4209,8 @@ var RuntimeUserStore = class {
     return raw && typeof raw === "object" ? raw : {};
   }
   writeState(state) {
-    mkdirSync6(dirname9(this.configPath), { recursive: true });
-    writeFileSync6(this.configPath, `${JSON.stringify(state, null, 2)}
-`, "utf8");
+    writeFileAtomicSync(this.configPath, `${JSON.stringify(state, null, 2)}
+`);
   }
 };
 
@@ -4452,12 +4538,12 @@ var RelayTunnelRouter = class {
 
 // src/shared/version.ts
 import { readFileSync as readFileSync7 } from "node:fs";
-import { dirname as dirname10, join as join9 } from "node:path";
+import { dirname as dirname6, join as join10 } from "node:path";
 import { fileURLToPath } from "node:url";
 function readClientVersion() {
   try {
-    const here2 = dirname10(fileURLToPath(import.meta.url));
-    const pkg = JSON.parse(readFileSync7(join9(here2, "..", "..", "package.json"), "utf8"));
+    const here2 = dirname6(fileURLToPath(import.meta.url));
+    const pkg = JSON.parse(readFileSync7(join10(here2, "..", "..", "package.json"), "utf8"));
     return typeof pkg.version === "string" && pkg.version ? pkg.version : "0.0.0";
   } catch {
     return "0.0.0";
@@ -4476,7 +4562,7 @@ function readUpdateStatusBestEffort(configPath) {
 function createDaemonServer(options = {}) {
   const app = Fastify({ logger: true });
   const events = new BridgeEventHub();
-  const configPath = options.configPath ?? process.env.BRIDGE_CONFIG ?? join10(mkdtempSync(join10(tmpdir2(), "claude-codex-wechat-")), "config.json");
+  const configPath = options.configPath ?? process.env.BRIDGE_CONFIG ?? join11(mkdtempSync(join11(tmpdir2(), "claude-codex-wechat-")), "config.json");
   const persistedConfig = loadBridgeConfig(configPath);
   const bridgeDefaults = {
     defaultProvider: options.bridgeDefaults?.defaultProvider ?? persistedConfig.bridge?.defaultProvider ?? "claude-code",
@@ -4533,7 +4619,7 @@ function createDaemonServer(options = {}) {
     });
   }
   const weixinStateStore = configPath ? new FileWeixinStateStore(configPath) : void 0;
-  const weixinMediaDir = configPath ? join10(dirname11(configPath), "media") : void 0;
+  const weixinMediaDir = configPath ? join11(dirname7(configPath), "media") : void 0;
   const managedWechatChannel = options.channel ? null : new ManagedWeixinDirectAdapter(options.wechat, weixinStateStore, weixinMediaDir);
   const channel = options.channel ?? managedWechatChannel;
   const weixinOutboundGate = managedWechatChannel && weixinStateStore ? new WeixinOutboundGate({
@@ -4770,6 +4856,7 @@ async function startDaemon(options) {
   const port = options.port ?? Number(process.env.BRIDGE_PORT ?? 8787);
   const host = options.host ?? "0.0.0.0";
   const configPath = options.configPath ?? process.env.BRIDGE_CONFIG ?? defaultConfigPath();
+  await cleanupStaleTempFiles(configPath).catch(() => void 0);
   const config = loadBridgeConfig(configPath);
   const providerCommands = await resolveProviderCommands(config.providers);
   await persistProviderCommandsToConfigFile({
@@ -4824,7 +4911,7 @@ async function resolveProviderCommands(providers) {
 
 // src/daemon/staticFrontend.ts
 import { readFileSync as readFileSync8 } from "node:fs";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 import fastifyStatic from "@fastify/static";
 function attachStaticFrontend(webRoot2) {
   return async (app) => {
@@ -4832,7 +4919,7 @@ function attachStaticFrontend(webRoot2) {
       root: webRoot2,
       wildcard: false
     });
-    const indexHtml = readFileSync8(join11(webRoot2, "index.html"), "utf8");
+    const indexHtml = readFileSync8(join12(webRoot2, "index.html"), "utf8");
     app.setNotFoundHandler((request, reply) => {
       if (request.url.startsWith("/api")) {
         reply.code(404).send({ error: "not_found" });
@@ -4844,10 +4931,10 @@ function attachStaticFrontend(webRoot2) {
 }
 
 // src/daemon/service.ts
-import { existsSync as existsSync9, statSync, openSync, closeSync, watchFile } from "node:fs";
-import { mkdir as mkdir4, readFile as readFile6, rm as rm2, writeFile as writeFile5 } from "node:fs/promises";
+import { existsSync as existsSync9, statSync, openSync as openSync2, closeSync as closeSync2, watchFile } from "node:fs";
+import { mkdir as mkdir4, readFile as readFile6, rm as rm2, writeFile as writeFile4 } from "node:fs/promises";
 import { homedir as homedir8 } from "node:os";
-import { dirname as dirname12, join as join12 } from "node:path";
+import { dirname as dirname8, join as join13 } from "node:path";
 import { createReadStream } from "node:fs";
 import { execFile, spawn as spawn7 } from "node:child_process";
 import { createInterface } from "node:readline";
@@ -4856,19 +4943,20 @@ var execFileAsync = promisify(execFile);
 async function installService(context) {
   if (process.platform === "darwin") {
     const spec = buildLaunchdSpec(context);
-    await mkdir4(dirname12(spec.plistPath), { recursive: true });
-    await mkdir4(dirname12(spec.stdoutPath), { recursive: true });
-    await writeFile5(spec.plistPath, renderLaunchdPlist(spec), "utf8");
-    await runLaunchctl(["unload", spec.plistPath]).catch(() => void 0);
-    await runLaunchctl(["load", spec.plistPath]);
-    await runLaunchctl(["kickstart", "-k", `gui/${process.getuid?.() ?? 0}/${spec.label}`]);
+    await mkdir4(dirname8(spec.plistPath), { recursive: true });
+    await mkdir4(dirname8(spec.stdoutPath), { recursive: true });
+    await writeFile4(spec.plistPath, renderLaunchdPlist(spec), "utf8");
+    const guiDomain = `gui/${process.getuid?.() ?? 0}`;
+    await runLaunchctl(["bootout", guiDomain, spec.plistPath]).catch(() => void 0);
+    await runLaunchctl(["bootstrap", guiDomain, spec.plistPath]);
+    await runLaunchctl(["kickstart", "-k", `${guiDomain}/${spec.label}`]);
     return await readServiceStatus(context);
   }
   if (process.platform === "linux") {
     const spec = buildSystemdUserSpec(context);
-    await mkdir4(dirname12(spec.unitPath), { recursive: true });
-    await mkdir4(dirname12(spec.stdoutPath), { recursive: true });
-    await writeFile5(spec.unitPath, renderSystemdUnit(spec), "utf8");
+    await mkdir4(dirname8(spec.unitPath), { recursive: true });
+    await mkdir4(dirname8(spec.stdoutPath), { recursive: true });
+    await writeFile4(spec.unitPath, renderSystemdUnit(spec), "utf8");
     await runSystemctl(["--user", "daemon-reload"]);
     await runSystemctl(["--user", "enable", "--now", spec.unitName]);
     return await readServiceStatus(context);
@@ -4882,8 +4970,9 @@ async function startService(context) {
   if (process.platform === "darwin") {
     const spec = buildLaunchdSpec(context);
     await ensureFileExists(spec.plistPath, "service_not_installed");
-    await runLaunchctl(["load", spec.plistPath]).catch(() => void 0);
-    await runLaunchctl(["kickstart", "-k", `gui/${process.getuid?.() ?? 0}/${spec.label}`]);
+    const guiDomain = `gui/${process.getuid?.() ?? 0}`;
+    await runLaunchctl(["bootstrap", guiDomain, spec.plistPath]).catch(() => void 0);
+    await runLaunchctl(["kickstart", "-k", `${guiDomain}/${spec.label}`]);
     return await readServiceStatus(context);
   }
   if (process.platform === "linux") {
@@ -4954,8 +5043,9 @@ async function restartService(context) {
   if (process.platform === "darwin") {
     const spec = buildLaunchdSpec(context);
     await ensureFileExists(spec.plistPath, "service_not_installed");
-    await runLaunchctl(["load", spec.plistPath]).catch(() => void 0);
-    await runLaunchctl(["kickstart", "-k", `gui/${process.getuid?.() ?? 0}/${spec.label}`]);
+    const guiDomain = `gui/${process.getuid?.() ?? 0}`;
+    await runLaunchctl(["bootstrap", guiDomain, spec.plistPath]).catch(() => void 0);
+    await runLaunchctl(["kickstart", "-k", `${guiDomain}/${spec.label}`]);
     return await readServiceStatus(context);
   }
   if (process.platform === "linux") {
@@ -5034,37 +5124,37 @@ async function readServiceStatus(context) {
   throw new Error("service_status_not_supported_on_this_platform");
 }
 function buildLaunchdSpec(context) {
-  const stateDir = join12(homedir8(), ".claude-codex-wechat");
+  const stateDir = join13(homedir8(), ".claude-codex-wechat");
   return {
     label: "com.claude-codex-wechat",
-    plistPath: join12(homedir8(), "Library", "LaunchAgents", "com.claude-codex-wechat.plist"),
+    plistPath: join13(homedir8(), "Library", "LaunchAgents", "com.claude-codex-wechat.plist"),
     programArgs: [context.nodePath ?? process.execPath, context.cliEntrypointPath, "__daemon"],
     workingDirectory: homedir8(),
-    stdoutPath: join12(stateDir, "logs", "service.stdout.log"),
-    stderrPath: join12(stateDir, "logs", "service.stderr.log"),
+    stdoutPath: join13(stateDir, "logs", "service.stdout.log"),
+    stderrPath: join13(stateDir, "logs", "service.stderr.log"),
     environment: buildServiceEnvironment(context)
   };
 }
 function buildSystemdUserSpec(context) {
-  const stateDir = join12(homedir8(), ".claude-codex-wechat");
+  const stateDir = join13(homedir8(), ".claude-codex-wechat");
   return {
     unitName: "claude-codex-wechat.service",
-    unitPath: join12(homedir8(), ".config", "systemd", "user", "claude-codex-wechat.service"),
+    unitPath: join13(homedir8(), ".config", "systemd", "user", "claude-codex-wechat.service"),
     execStart: [context.nodePath ?? process.execPath, context.cliEntrypointPath, "__daemon"],
     workingDirectory: homedir8(),
-    stdoutPath: join12(stateDir, "logs", "service.stdout.log"),
-    stderrPath: join12(stateDir, "logs", "service.stderr.log"),
+    stdoutPath: join13(stateDir, "logs", "service.stdout.log"),
+    stderrPath: join13(stateDir, "logs", "service.stderr.log"),
     environment: buildServiceEnvironment(context)
   };
 }
 function buildProcessSpec(context) {
-  const stateDir = join12(homedir8(), ".claude-codex-wechat");
+  const stateDir = join13(homedir8(), ".claude-codex-wechat");
   return {
-    pidPath: join12(stateDir, "service.pid"),
+    pidPath: join13(stateDir, "service.pid"),
     command: [context.nodePath ?? process.execPath, context.cliEntrypointPath, "__daemon"],
     workingDirectory: homedir8(),
-    stdoutPath: join12(stateDir, "logs", "service.stdout.log"),
-    stderrPath: join12(stateDir, "logs", "service.stderr.log"),
+    stdoutPath: join13(stateDir, "logs", "service.stdout.log"),
+    stderrPath: join13(stateDir, "logs", "service.stderr.log"),
     environment: buildServiceEnvironment(context)
   };
 }
@@ -5185,8 +5275,8 @@ async function readPidFile(pidPath) {
   }
 }
 async function writePidFile(pidPath, pid) {
-  await mkdir4(dirname12(pidPath), { recursive: true });
-  await writeFile5(pidPath, `${pid}
+  await mkdir4(dirname8(pidPath), { recursive: true });
+  await writeFile4(pidPath, `${pid}
 `, "utf8");
 }
 async function removePidFile(pidPath) {
@@ -5200,9 +5290,9 @@ async function killPid(pid) {
   process.kill(pid, "SIGTERM");
 }
 async function spawnDetachedDaemon(spec) {
-  await mkdir4(dirname12(spec.stdoutPath), { recursive: true });
-  const outFd = openSync(spec.stdoutPath, "a");
-  const errFd = openSync(spec.stderrPath, "a");
+  await mkdir4(dirname8(spec.stdoutPath), { recursive: true });
+  const outFd = openSync2(spec.stdoutPath, "a");
+  const errFd = openSync2(spec.stderrPath, "a");
   try {
     const [command, ...args] = spec.command;
     const child = spawn7(command, args, {
@@ -5221,8 +5311,8 @@ async function spawnDetachedDaemon(spec) {
     child.unref();
     return child.pid;
   } finally {
-    closeSync(outFd);
-    closeSync(errFd);
+    closeSync2(outFd);
+    closeSync2(errFd);
   }
 }
 async function ensureFileExists(path, errorCode) {
@@ -5286,8 +5376,8 @@ function fileSizeHint(path) {
 }
 
 // src/cli.ts
-var here = dirname13(fileURLToPath2(import.meta.url));
-var webRoot = join13(here, "..", "web");
+var here = dirname9(fileURLToPath2(import.meta.url));
+var webRoot = join14(here, "..", "web");
 async function main() {
   const command = process.argv[2];
   switch (command) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-codex-wechat",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "private": false,
   "type": "module",
   "packageManager": "pnpm@11.5.0",