codex-to-im 1.0.58 → 1.0.60

package/dist/cli.mjs

@@ -5,14 +5,15 @@ import { createRequire } from 'module'; const require = createRequire(import.met
 import { stdin as input, stdout as output } from "node:process";
 
 // src/service-manager.ts
-import fs3 from "node:fs";
+import fs4 from "node:fs";
 import os2 from "node:os";
 import path3 from "node:path";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 
 // 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";
 
@@ -39,10 +40,101 @@ 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 {
+    }
+  }
+}
+
 // src/config.ts
 function isSupportedChannelProvider(value) {
   return value === "feishu" || value === "weixin";
 }
+var RAW_CHANNELS = Symbol("rawConfigV2Channels");
 var DEFAULT_CTI_HOME = path.join(os.homedir(), ".codex-to-im");
 var DEFAULT_WORKSPACE_ROOT = path.join(os.homedir(), "cx2im");
 var CTI_HOME = process.env.CTI_HOME || DEFAULT_CTI_HOME;
@@ -76,7 +168,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();
   }
@@ -103,26 +195,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 {
+    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 {
-    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;
+    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";
@@ -143,6 +275,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)
       ),
@@ -242,44 +375,48 @@ function expandConfig(v2) {
 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);
+  });
 }
 
 // src/bridge-instance-lock.ts
-import fs2 from "node:fs";
+import fs3 from "node:fs";
 import path2 from "node:path";
 var runtimeDir = path2.join(CTI_HOME, "runtime");
 var bridgeInstanceLockFile = path2.join(runtimeDir, "bridge.instance.lock");
 function readJsonFile(filePath, fallback) {
   try {
-    return JSON.parse(fs2.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs3.readFileSync(filePath, "utf-8"));
   } catch {
     return fallback;
   }
 }
-function isProcessAlive(pid) {
+function isProcessAlive2(pid) {
   if (!pid) return false;
   try {
     process.kill(pid, 0);
@@ -295,11 +432,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 {
-    fs2.unlinkSync(filePath);
+    fs3.unlinkSync(filePath);
   } catch {
   }
 }
@@ -320,26 +457,26 @@ var npmUninstallLogFile = path3.join(runtimeDir2, "npm-uninstall.log");
 var WINDOWS_HIDE = process.platform === "win32" ? { windowsHide: true } : {};
 var BRIDGE_START_LOCK_STALE_MS = 3e4;
 function ensureDirs() {
-  fs3.mkdirSync(runtimeDir2, { recursive: true });
-  fs3.mkdirSync(logsDir, { recursive: true });
+  fs4.mkdirSync(runtimeDir2, { recursive: true });
+  fs4.mkdirSync(logsDir, { recursive: true });
 }
 function readJsonFile2(filePath, fallback) {
   try {
-    return JSON.parse(fs3.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs4.readFileSync(filePath, "utf-8"));
   } catch {
     return fallback;
   }
 }
 function readPid(filePath) {
   try {
-    const raw = fs3.readFileSync(filePath, "utf-8").trim();
+    const raw = fs4.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);
@@ -357,7 +494,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;
@@ -373,7 +510,7 @@ function getTrackedBridgePids(status) {
 }
 function clearBridgePidFile() {
   try {
-    fs3.unlinkSync(bridgePidFile);
+    fs4.unlinkSync(bridgePidFile);
   } catch {
   }
 }
@@ -388,7 +525,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;
@@ -404,7 +541,7 @@ function tryAcquireBridgeStartLock(options = {}) {
   };
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      fs3.writeFileSync(filePath, JSON.stringify(payload, null, 2), { encoding: "utf-8", flag: "wx" });
+      fs4.writeFileSync(filePath, JSON.stringify(payload, null, 2), { encoding: "utf-8", flag: "wx" });
       return { acquired: true };
     } catch (error) {
       const code = error.code;
@@ -418,7 +555,7 @@ function tryAcquireBridgeStartLock(options = {}) {
         return { acquired: false, holderPid: existing2?.pid };
       }
       try {
-        fs3.unlinkSync(filePath);
+        fs4.unlinkSync(filePath);
       } catch {
       }
     }
@@ -430,14 +567,14 @@ function releaseBridgeStartLock(filePath = bridgeStartLockFile, ownerPid = proce
   const existing = readBridgeStartLock(filePath);
   if (!existing) {
     try {
-      fs3.unlinkSync(filePath);
+      fs4.unlinkSync(filePath);
     } catch {
     }
     return;
   }
   if (existing.pid !== ownerPid) return;
   try {
-    fs3.unlinkSync(filePath);
+    fs4.unlinkSync(filePath);
   } catch {
   }
 }
@@ -523,7 +660,7 @@ function ensureBridgeAutostartLauncher() {
     "exit $LASTEXITCODE",
     ""
   ].join("\r\n");
-  fs3.writeFileSync(bridgeAutostartLauncherFile, content, "utf-8");
+  fs4.writeFileSync(bridgeAutostartLauncherFile, content, "utf-8");
   return bridgeAutostartLauncherFile;
 }
 function parsePowerShellJson(raw) {
@@ -567,7 +704,7 @@ function buildDeferredGlobalNpmUninstallLaunch(options = {}) {
 async function launchDeferredGlobalNpmUninstall() {
   ensureDirs();
   const launch = buildDeferredGlobalNpmUninstallLaunch();
-  fs3.writeFileSync(
+  fs4.writeFileSync(
     launch.logPath,
     [
       `[${(/* @__PURE__ */ new Date()).toISOString()}] Scheduling global uninstall.`,
@@ -606,7 +743,7 @@ function getBridgeStatus() {
     status.pid,
     readBridgeInstanceLock()?.pid
   );
-  if (!isProcessAlive2(pid)) {
+  if (!isProcessAlive3(pid)) {
     return {
       ...status,
       pid,
@@ -621,7 +758,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,
@@ -706,7 +843,7 @@ async function waitForUiServer(timeoutMs = 15e3) {
 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();
@@ -731,17 +868,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 = path3.join(packageRoot, "dist", "daemon.mjs");
-    if (!fs3.existsSync(daemonEntry)) {
+    if (!fs4.existsSync(daemonEntry)) {
       throw new Error(`Daemon bundle not found at ${daemonEntry}. Run npm run build first.`);
     }
-    const stdoutFd = fs3.openSync(path3.join(logsDir, "bridge-launcher.out.log"), "a");
-    const stderrFd = fs3.openSync(path3.join(logsDir, "bridge-launcher.err.log"), "a");
+    const stdoutFd = fs4.openSync(path3.join(logsDir, "bridge-launcher.out.log"), "a");
+    const stderrFd = fs4.openSync(path3.join(logsDir, "bridge-launcher.err.log"), "a");
     const child = spawn(process.execPath, [daemonEntry], {
       cwd: packageRoot,
       detached: true,
@@ -765,7 +902,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();
@@ -790,7 +927,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();
@@ -887,8 +1024,8 @@ async function uninstallBridgeAutostart() {
   ].join("; ");
   await runPowerShell(script);
   try {
-    if (fs3.existsSync(bridgeAutostartLauncherFile)) {
-      fs3.unlinkSync(bridgeAutostartLauncherFile);
+    if (fs4.existsSync(bridgeAutostartLauncherFile)) {
+      fs4.unlinkSync(bridgeAutostartLauncherFile);
     }
   } catch {
   }
@@ -920,11 +1057,11 @@ async function ensureUiServerRunning() {
   const current = getUiServerStatus();
   if (current.running) return current;
   const serverEntry = path3.join(packageRoot, "dist", "ui-server.mjs");
-  if (!fs3.existsSync(serverEntry)) {
+  if (!fs4.existsSync(serverEntry)) {
     throw new Error(`UI server bundle not found at ${serverEntry}. Run npm run build first.`);
   }
-  const stdoutFd = fs3.openSync(path3.join(logsDir, "ui-server.out.log"), "a");
-  const stderrFd = fs3.openSync(path3.join(logsDir, "ui-server.err.log"), "a");
+  const stdoutFd = fs4.openSync(path3.join(logsDir, "ui-server.out.log"), "a");
+  const stderrFd = fs4.openSync(path3.join(logsDir, "ui-server.err.log"), "a");
   const child = spawn(process.execPath, [serverEntry], {
     cwd: packageRoot,
     detached: true,
@@ -944,7 +1081,7 @@ async function ensureUiServerRunning() {
 }
 async function stopUiServer() {
   const status = getUiServerStatus();
-  if (!status.pid || !isProcessAlive2(status.pid)) {
+  if (!status.pid || !isProcessAlive3(status.pid)) {
     const next2 = { ...status, running: false };
     writeUiServerStatus(next2);
     return next2;
@@ -981,7 +1118,7 @@ async function stopUiServer() {
 }
 function writeUiServerStatus(status) {
   ensureDirs();
-  fs3.writeFileSync(uiStatusFile, JSON.stringify(status, null, 2), "utf-8");
+  fs4.writeFileSync(uiStatusFile, JSON.stringify(status, null, 2), "utf-8");
 }
 function openBrowser(url) {
   if (process.platform === "win32") {