codex-to-im 1.0.28 → 1.0.30

package/dist/cli.mjs

@@ -20,6 +20,14 @@ var DEFAULT_WORKSPACE_ROOT = path.join(os.homedir(), "cx2im");
 var CTI_HOME = process.env.CTI_HOME || DEFAULT_CTI_HOME;
 var CONFIG_PATH = path.join(CTI_HOME, "config.env");
 var CONFIG_V2_PATH = path.join(CTI_HOME, "config.v2.json");
+function expandHomePath(value) {
+  if (!value) return value;
+  if (value === "~") return os.homedir();
+  if (value.startsWith("~/") || value.startsWith("~\\")) {
+    return path.join(os.homedir(), value.slice(2));
+  }
+  return value;
+}
 function parseEnvFile(content) {
   const entries = /* @__PURE__ */ new Map();
   for (const line of content.split("\n")) {
@@ -43,6 +51,175 @@ function loadRawConfigEnv() {
     return /* @__PURE__ */ new Map();
   }
 }
+function splitCsv(value) {
+  if (!value) return void 0;
+  return value.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function parsePositiveInt(value) {
+  if (!value) return void 0;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) return void 0;
+  return Math.floor(parsed);
+}
+function parseSandboxMode(value) {
+  if (value === "read-only" || value === "workspace-write" || value === "danger-full-access") {
+    return value;
+  }
+  return void 0;
+}
+function parseReasoningEffort(value) {
+  if (value === "minimal" || value === "low" || value === "medium" || value === "high" || value === "xhigh") {
+    return value;
+  }
+  return void 0;
+}
+function normalizeFeishuSite(value) {
+  const normalized = (value || "").trim().replace(/\/+$/, "").toLowerCase();
+  if (!normalized) return "feishu";
+  if (normalized === "lark") return "lark";
+  if (normalized === "feishu") return "feishu";
+  if (normalized.includes("open.larksuite.com")) return "lark";
+  return "feishu";
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function ensureConfigDir() {
+  fs.mkdirSync(CTI_HOME, { recursive: true });
+}
+function readConfigV2File() {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(CONFIG_V2_PATH, "utf-8"));
+    if (parsed && parsed.schemaVersion === 2 && parsed.runtime && Array.isArray(parsed.channels)) {
+      return parsed;
+    }
+    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);
+}
+function defaultAliasForProvider(provider) {
+  return provider === "feishu" ? "\u98DE\u4E66" : "\u5FAE\u4FE1";
+}
+function buildDefaultChannelId(provider) {
+  return `${provider}-default`;
+}
+function migrateLegacyEnvToV2(env) {
+  const rawRuntime = env.get("CTI_RUNTIME") || "codex";
+  const runtime = ["claude", "codex", "auto"].includes(rawRuntime) ? rawRuntime : "codex";
+  const enabledChannels = splitCsv(env.get("CTI_ENABLED_CHANNELS")) ?? ["feishu"];
+  const timestamp = nowIso();
+  const channels = [];
+  const hasFeishuConfig = Boolean(
+    env.get("CTI_FEISHU_APP_ID") || env.get("CTI_FEISHU_APP_SECRET") || env.get("CTI_FEISHU_ALLOWED_USERS") || enabledChannels.includes("feishu")
+  );
+  if (hasFeishuConfig) {
+    channels.push({
+      id: buildDefaultChannelId("feishu"),
+      alias: defaultAliasForProvider("feishu"),
+      provider: "feishu",
+      enabled: enabledChannels.includes("feishu"),
+      createdAt: timestamp,
+      updatedAt: timestamp,
+      config: {
+        appId: env.get("CTI_FEISHU_APP_ID") || void 0,
+        appSecret: env.get("CTI_FEISHU_APP_SECRET") || void 0,
+        site: normalizeFeishuSite(env.get("CTI_FEISHU_SITE") || env.get("CTI_FEISHU_DOMAIN")),
+        allowedUsers: splitCsv(env.get("CTI_FEISHU_ALLOWED_USERS")),
+        streamingEnabled: env.has("CTI_FEISHU_STREAMING_ENABLED") ? env.get("CTI_FEISHU_STREAMING_ENABLED") === "true" : true,
+        feedbackMarkdownEnabled: env.has("CTI_FEISHU_COMMAND_MARKDOWN_ENABLED") ? env.get("CTI_FEISHU_COMMAND_MARKDOWN_ENABLED") === "true" : true
+      }
+    });
+  }
+  const hasWeixinConfig = Boolean(
+    env.get("CTI_WEIXIN_BASE_URL") || env.get("CTI_WEIXIN_CDN_BASE_URL") || env.get("CTI_WEIXIN_MEDIA_ENABLED") || enabledChannels.includes("weixin")
+  );
+  if (hasWeixinConfig) {
+    channels.push({
+      id: buildDefaultChannelId("weixin"),
+      alias: defaultAliasForProvider("weixin"),
+      provider: "weixin",
+      enabled: enabledChannels.includes("weixin"),
+      createdAt: timestamp,
+      updatedAt: timestamp,
+      config: {
+        baseUrl: env.get("CTI_WEIXIN_BASE_URL") || void 0,
+        cdnBaseUrl: env.get("CTI_WEIXIN_CDN_BASE_URL") || void 0,
+        mediaEnabled: env.has("CTI_WEIXIN_MEDIA_ENABLED") ? env.get("CTI_WEIXIN_MEDIA_ENABLED") === "true" : void 0,
+        feedbackMarkdownEnabled: env.has("CTI_WEIXIN_COMMAND_MARKDOWN_ENABLED") ? env.get("CTI_WEIXIN_COMMAND_MARKDOWN_ENABLED") === "true" : false
+      }
+    });
+  }
+  return {
+    schemaVersion: 2,
+    runtime: {
+      provider: runtime,
+      defaultWorkspaceRoot: expandHomePath(env.get("CTI_DEFAULT_WORKSPACE_ROOT")) || void 0,
+      defaultModel: env.get("CTI_DEFAULT_MODEL") || void 0,
+      defaultMode: env.get("CTI_DEFAULT_MODE") || "code",
+      historyMessageLimit: parsePositiveInt(env.get("CTI_HISTORY_MESSAGE_LIMIT")) ?? 8,
+      codexSkipGitRepoCheck: env.has("CTI_CODEX_SKIP_GIT_REPO_CHECK") ? env.get("CTI_CODEX_SKIP_GIT_REPO_CHECK") === "true" : true,
+      codexSandboxMode: parseSandboxMode(env.get("CTI_CODEX_SANDBOX_MODE")) ?? "workspace-write",
+      codexReasoningEffort: parseReasoningEffort(env.get("CTI_CODEX_REASONING_EFFORT")) ?? "medium",
+      uiAllowLan: env.get("CTI_UI_ALLOW_LAN") === "true",
+      uiAccessToken: env.get("CTI_UI_ACCESS_TOKEN") || void 0,
+      autoApprove: env.get("CTI_AUTO_APPROVE") === "true"
+    },
+    channels
+  };
+}
+function expandConfig(v2) {
+  return {
+    schemaVersion: 2,
+    channels: v2.channels,
+    runtime: v2.runtime.provider,
+    enabledChannels: Array.from(new Set(
+      v2.channels.filter((channel) => channel.enabled).map((channel) => channel.provider)
+    )),
+    defaultWorkspaceRoot: v2.runtime.defaultWorkspaceRoot,
+    defaultModel: v2.runtime.defaultModel,
+    defaultMode: v2.runtime.defaultMode || "code",
+    historyMessageLimit: v2.runtime.historyMessageLimit ?? 8,
+    codexSkipGitRepoCheck: v2.runtime.codexSkipGitRepoCheck ?? true,
+    codexSandboxMode: v2.runtime.codexSandboxMode ?? "workspace-write",
+    codexReasoningEffort: v2.runtime.codexReasoningEffort ?? "medium",
+    uiAllowLan: v2.runtime.uiAllowLan === true,
+    uiAccessToken: v2.runtime.uiAccessToken || void 0,
+    autoApprove: v2.runtime.autoApprove === true
+  };
+}
+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,
+      codexSkipGitRepoCheck: true,
+      codexSandboxMode: "workspace-write",
+      codexReasoningEffort: "medium",
+      uiAllowLan: false,
+      autoApprove: false
+    },
+    channels: []
+  };
+  return expandConfig(empty);
+}
 
 // src/service-manager.ts
 var moduleDir = path2.dirname(fileURLToPath(import.meta.url));
@@ -86,6 +263,30 @@ function isProcessAlive(pid) {
     return false;
   }
 }
+function collectTrackedBridgePids(bridgePid, statusPid) {
+  const unique = /* @__PURE__ */ new Set();
+  for (const pid of [bridgePid, statusPid]) {
+    if (Number.isFinite(pid) && pid > 0) {
+      unique.add(pid);
+    }
+  }
+  return [...unique];
+}
+function resolveTrackedBridgePid(bridgePid, statusPid, isAlive = isProcessAlive) {
+  if (isAlive(bridgePid)) return bridgePid;
+  if (isAlive(statusPid)) return statusPid;
+  return bridgePid ?? statusPid;
+}
+function getTrackedBridgePids(status) {
+  const resolvedStatus = status ?? readJsonFile(bridgeStatusFile, { running: false });
+  return collectTrackedBridgePids(readPid(bridgePidFile), resolvedStatus.pid);
+}
+function clearBridgePidFile() {
+  try {
+    fs2.unlinkSync(bridgePidFile);
+  } catch {
+  }
+}
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -246,7 +447,7 @@ function getCurrentUiServerUrl() {
 }
 function getBridgeStatus() {
   const status = readJsonFile(bridgeStatusFile, { running: false });
-  const pid = readPid(bridgePidFile) ?? status.pid;
+  const pid = resolveTrackedBridgePid(readPid(bridgePidFile), status.pid);
   if (!isProcessAlive(pid)) {
     return {
       ...status,
@@ -284,6 +485,27 @@ function buildDaemonEnv() {
   delete env.CLAUDECODE;
   return env;
 }
+function describeBridgeStartupPreflightFailure(channels) {
+  const configured = Array.isArray(channels) ? channels : [];
+  if (configured.length === 0) {
+    return "\u672A\u914D\u7F6E\u4EFB\u4F55\u901A\u9053\u5B9E\u4F8B\u3002\u8BF7\u5148\u5728 Web \u63A7\u5236\u53F0\u521B\u5EFA\u5E76\u4FDD\u5B58\u81F3\u5C11\u4E00\u4E2A\u98DE\u4E66\u6216\u5FAE\u4FE1\u901A\u9053\uFF0C\u7136\u540E\u518D\u542F\u52A8\u6865\u63A5\u670D\u52A1\u3002";
+  }
+  const enabled = configured.filter((channel) => channel.enabled !== false);
+  if (enabled.length === 0) {
+    return "\u5F53\u524D\u6240\u6709\u901A\u9053\u5B9E\u4F8B\u90FD\u5DF2\u7981\u7528\u3002\u8BF7\u5148\u542F\u7528\u81F3\u5C11\u4E00\u4E2A\u901A\u9053\u5B9E\u4F8B\uFF0C\u7136\u540E\u518D\u542F\u52A8\u6865\u63A5\u670D\u52A1\u3002";
+  }
+  return null;
+}
+function describeBridgeActivationFailure(status, channels) {
+  const statusReason = status.lastExitReason?.trim();
+  if (statusReason) return statusReason;
+  const preflightFailure = describeBridgeStartupPreflightFailure(channels);
+  if (preflightFailure) return preflightFailure;
+  const enabled = (channels || []).filter((channel) => channel.enabled !== false);
+  if (enabled.length === 0) return null;
+  const labels = enabled.map((channel) => channel.alias?.trim() || channel.id).join("\u3001");
+  return `\u6CA1\u6709\u4EFB\u4F55\u901A\u9053\u9002\u914D\u5668\u542F\u52A8\u6210\u529F\u3002\u8BF7\u68C0\u67E5\u901A\u9053\u914D\u7F6E\u3001\u51ED\u636E\u548C\u65E5\u5FD7\u3002\u5F53\u524D\u5DF2\u542F\u7528\u901A\u9053\uFF1A${labels}`;
+}
 async function waitForBridgeRunning(timeoutMs = 2e4) {
   const startedAt = Date.now();
   while (Date.now() - startedAt < timeoutMs) {
@@ -311,7 +533,16 @@ async function waitForUiServer(timeoutMs = 15e3) {
 async function startBridge() {
   ensureDirs();
   const current = getBridgeStatus();
-  if (current.running) return current;
+  const extraAlivePids = getTrackedBridgePids(current).filter((pid) => pid !== current.pid && isProcessAlive(pid));
+  if (current.running && extraAlivePids.length === 0) return current;
+  if (current.running && extraAlivePids.length > 0) {
+    await stopBridge();
+  }
+  const config = loadConfig();
+  const preflightFailure = describeBridgeStartupPreflightFailure(config.channels);
+  if (preflightFailure) {
+    throw new Error(preflightFailure);
+  }
   const daemonEntry = path2.join(packageRoot, "dist", "daemon.mjs");
   if (!fs2.existsSync(daemonEntry)) {
     throw new Error(`Daemon bundle not found at ${daemonEntry}. Run npm run build first.`);
@@ -328,36 +559,45 @@ async function startBridge() {
   child.unref();
   const status = await waitForBridgeRunning();
   if (!status.running) {
-    throw new Error(status.lastExitReason || "Bridge failed to report running=true.");
+    throw new Error(
+      describeBridgeActivationFailure(status, config.channels) || "Bridge failed to report running=true."
+    );
   }
   return status;
 }
 async function stopBridge() {
-  const status = getBridgeStatus();
-  if (!status.pid || !isProcessAlive(status.pid)) {
-    return { ...status, running: false };
-  }
-  if (process.platform === "win32") {
-    await new Promise((resolve) => {
-      const killer = spawn("cmd", ["/c", "taskkill", "/PID", String(status.pid), "/T", "/F"], {
-        stdio: "ignore",
-        ...WINDOWS_HIDE
+  const status = readJsonFile(bridgeStatusFile, { running: false });
+  const pids = getTrackedBridgePids(status).filter((pid) => isProcessAlive(pid));
+  if (pids.length === 0) {
+    clearBridgePidFile();
+    return { ...getBridgeStatus(), running: false };
+  }
+  for (const pid of pids) {
+    if (process.platform === "win32") {
+      await new Promise((resolve) => {
+        const killer = spawn("cmd", ["/c", "taskkill", "/PID", String(pid), "/T", "/F"], {
+          stdio: "ignore",
+          ...WINDOWS_HIDE
+        });
+        killer.on("exit", () => resolve());
+        killer.on("error", () => resolve());
       });
-      killer.on("exit", () => resolve());
-      killer.on("error", () => resolve());
-    });
-  } else {
-    try {
-      process.kill(status.pid, "SIGTERM");
-    } catch {
+    } else {
+      try {
+        process.kill(pid, "SIGTERM");
+      } catch {
+      }
     }
   }
   const startedAt = Date.now();
   while (Date.now() - startedAt < 1e4) {
-    const next = getBridgeStatus();
-    if (!next.running) return next;
+    if (pids.every((pid) => !isProcessAlive(pid))) {
+      clearBridgePidFile();
+      return getBridgeStatus();
+    }
     await sleep(300);
   }
+  clearBridgePidFile();
   return getBridgeStatus();
 }
 async function getBridgeAutostartStatus() {