codex-to-im 1.0.29 → 1.0.31

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));
@@ -308,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) {
@@ -340,6 +538,11 @@ async function startBridge() {
   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.`);
@@ -356,7 +559,9 @@ 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;
 }

package/dist/daemon.mjs

@@ -7818,11 +7818,8 @@ function readJson(filePath, fallback) {
 function getAccountRecency(account) {
   return account.lastLoginAt ?? account.updatedAt ?? account.createdAt;
 }
-function normalizeAccounts(accounts) {
-  if (accounts.length <= 1) {
-    return { accounts, removedAccountIds: [] };
-  }
-  const sorted = [...accounts].sort((a, b) => {
+function sortAccountsByRecency(accounts) {
+  return [...accounts].sort((a, b) => {
     const recencyDiff = getAccountRecency(b).localeCompare(getAccountRecency(a));
     if (recencyDiff !== 0) return recencyDiff;
     const updatedDiff = b.updatedAt.localeCompare(a.updatedAt);
@@ -7831,16 +7828,14 @@ function normalizeAccounts(accounts) {
     if (createdDiff !== 0) return createdDiff;
     return 0;
   });
-  const kept = sorted[0];
-  const removedAccountIds = [
-    ...new Set(
-      sorted.slice(1).map((account) => account.accountId).filter((accountId) => accountId !== kept.accountId)
-    )
-  ];
-  return {
-    accounts: [kept],
-    removedAccountIds
-  };
+}
+function normalizeAccounts(accounts) {
+  const deduped = /* @__PURE__ */ new Map();
+  for (const account of sortAccountsByRecency(accounts)) {
+    if (!account?.accountId || deduped.has(account.accountId)) continue;
+    deduped.set(account.accountId, account);
+  }
+  return Array.from(deduped.values());
 }
 function readStoredAccounts() {
   ensureDir(DATA_DIR);
@@ -7848,7 +7843,7 @@ function readStoredAccounts() {
   return Array.isArray(raw) ? raw : [];
 }
 function readAccounts() {
-  return normalizeAccounts(readStoredAccounts()).accounts;
+  return normalizeAccounts(readStoredAccounts());
 }
 function readContextTokens() {
   ensureDir(DATA_DIR);
@@ -7862,7 +7857,7 @@ function contextKey(accountId, peerUserId) {
   return `${accountId}::${peerUserId}`;
 }
 function listWeixinAccounts() {
-  return readAccounts().sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+  return sortAccountsByRecency(readAccounts());
 }
 function getWeixinAccount(accountId) {
   return readAccounts().find((account) => account.accountId === accountId);
@@ -14234,6 +14229,22 @@ var WeixinAdapter = class extends BaseChannelAdapter {
     }
   }
   validateConfig() {
+    const configuredAccountId = this.configuredAccountId;
+    const accounts = listWeixinAccounts();
+    const enabledAccounts = accounts.filter((account) => account.enabled && account.token);
+    if (configuredAccountId) {
+      const configured = getWeixinAccount(configuredAccountId);
+      if (!configured) {
+        return `Linked WeChat account ${configuredAccountId} not found`;
+      }
+      if (!configured.enabled || !configured.token) {
+        return `Linked WeChat account ${configuredAccountId} is disabled or missing token`;
+      }
+      return null;
+    }
+    if (enabledAccounts.length > 1) {
+      return "Multiple linked WeChat accounts detected. Please select a WeChat account for this channel.";
+    }
     return null;
   }
   isAuthorized(_userId, _chatId) {
@@ -15370,7 +15381,7 @@ function bindStoreToSdkSession(store, channelType, chatId, sdkSessionId, opts) {
 import fs5 from "node:fs";
 import path6 from "node:path";
 var DRAFT_TTL_MS = 24 * 60 * 60 * 1e3;
-var MAX_HIDDEN_DRAFT_SESSIONS = 20;
+var MAX_HIDDEN_DRAFT_SESSIONS = 64;
 var INTERNAL_SESSION_ROOT = path6.join(CTI_HOME, "runtime", "internal-sessions");
 var DRAFT_SESSION_PREFIX = "Draft";
 var HISTORY_SESSION_PREFIX = "History Summary";
@@ -18164,6 +18175,29 @@ function buildMirrorTitle(threadTitle, markdown = false) {
 function buildMirrorSpeakerLabel(label, markdown = false) {
   return markdown ? `**${label}:**` : `${label}:`;
 }
+var MIRROR_USER_WRAPPER_LABELS = /* @__PURE__ */ new Map([
+  ["# Review findings:", "Review findings"],
+  ["# Context from my IDE setup:", "IDE setup"],
+  ["# Files mentioned by the user:", "Files"]
+]);
+var MIRROR_USER_REQUEST_MARKER = "## My request for Codex:";
+function formatMirrorUserText(text2) {
+  const normalized = (text2 || "").replace(/\r\n?/g, "\n").trim();
+  if (!normalized) return null;
+  const lines = normalized.split("\n");
+  const firstNonEmptyIndex = lines.findIndex((line) => line.trim().length > 0);
+  if (firstNonEmptyIndex < 0) return null;
+  const wrapperLabel = MIRROR_USER_WRAPPER_LABELS.get(lines[firstNonEmptyIndex].trim());
+  if (!wrapperLabel) return normalized;
+  const requestMarkerIndex = lines.findIndex(
+    (line, index) => index > firstNonEmptyIndex && line.trim() === MIRROR_USER_REQUEST_MARKER
+  );
+  if (requestMarkerIndex < 0) return normalized;
+  const requestBody = lines.slice(requestMarkerIndex + 1).join("\n").trim();
+  if (!requestBody) return normalized;
+  return `\uFF08\u57FA\u4E8E ${wrapperLabel}\uFF09
+${requestBody}`;
+}
 function formatMirrorSpeakerBlock(label, text2, markdown = false, forceLabel = false) {
   const normalized = (text2 || "").trim();
   if (!normalized) {
@@ -18342,7 +18376,7 @@ function createMirrorTurnState(sessionId, timestamp, turnId) {
   };
 }
 function appendMirrorUserText(turnState, chunk) {
-  const normalized = chunk.trim();
+  const normalized = formatMirrorUserText(chunk);
   if (!normalized) return;
   if (!turnState.userText) {
     turnState.userText = normalized;
@@ -18416,7 +18450,6 @@ function consumeMirrorRecords(subscription, records) {
           subscription.pendingTurn.lastActivityAt = record.timestamp;
         }
       }
-      startMirrorStreaming(subscription, subscription.pendingTurn);
       continue;
     }
     if (record.type === "task_complete") {