claude-codex-wechat 0.1.0

package/dist/server/cli.js

@@ -0,0 +1,4130 @@
+#!/usr/bin/env node
+import { createRequire as __cjsCreateRequire } from 'node:module'; const require = __cjsCreateRequire(import.meta.url);
+
+// src/cli.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname10, join as join10 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/daemon/bootstrap.ts
+import { networkInterfaces } from "node:os";
+
+// src/daemon/server.ts
+import { mkdtempSync } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { dirname as dirname9, join as join8 } from "node:path";
+import Fastify from "fastify";
+
+// src/channels/platforms.ts
+var PRIMARY_WEIXIN_PLATFORM = "weixin";
+
+// src/channels/weixin-direct/loginClient.ts
+var DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com";
+var WeixinDirectLoginClient = class {
+  baseUrl;
+  fetchImpl;
+  pollIntervalMs;
+  constructor(input = {}) {
+    this.baseUrl = (input.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.fetchImpl = input.fetchImpl ?? fetch;
+    this.pollIntervalMs = input.pollIntervalMs ?? 2e3;
+  }
+  async fetchQrCode() {
+    const data = await this.getJson("ilink/bot/get_bot_qrcode?bot_type=3");
+    const ticket = data.qrcode?.trim();
+    const qrcodeData = data.qrcode_img_content?.trim();
+    if (!ticket || !qrcodeData) throw new Error("weixin_qrcode_missing_fields");
+    return { ticket, qrcodeData };
+  }
+  async pollQrCodeStatus(ticket) {
+    const data = await this.getJson(`ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(ticket)}`);
+    const status = data.status?.trim().toLowerCase() ?? "wait";
+    if (status === "scaned") return { status: "scanned" };
+    if (status === "confirmed") {
+      return {
+        status: "confirmed",
+        accountId: data.ilink_bot_id?.trim() ?? "",
+        botToken: data.bot_token?.trim() ?? "",
+        baseUrl: data.baseurl?.trim() || this.baseUrl
+      };
+    }
+    if (status === "expired") return { status: "expired" };
+    return { status: "waiting" };
+  }
+  async getJson(path) {
+    const response = await this.fetchImpl(`${this.baseUrl}/${path}`, {
+      headers: {
+        "iLink-App-ClientVersion": "1"
+      }
+    });
+    if (!response.ok) throw new Error(`weixin_login_request_failed:${response.status}`);
+    const payload = await response.json();
+    return payload.data ?? payload;
+  }
+};
+
+// src/daemon/config.ts
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+function defaultConfigPath() {
+  return join(homedir(), ".claude-codex-wechat", "config.json");
+}
+function loadBridgeConfig(path = process.env.BRIDGE_CONFIG ?? defaultConfigPath()) {
+  if (!existsSync(path)) return normalizeBridgeConfig({}, process.env, path);
+  const raw = JSON.parse(readFileSync(path, "utf8"));
+  return normalizeBridgeConfig(raw, process.env, path);
+}
+function normalizeBridgeConfig(raw, env, path) {
+  const record = raw && typeof raw === "object" ? raw : {};
+  return {
+    wechat: normalizeWechatConfig(record.wechat, env),
+    bridge: normalizeBridgeDefaultsConfig(record.bridge),
+    providers: normalizeProvidersConfig(record.providers, env)
+  };
+}
+function normalizeProvidersConfig(raw, env) {
+  const record = raw && typeof raw === "object" ? raw : {};
+  const claude = normalizeProviderCommand(record.claude, env.BRIDGE_CLAUDE_COMMAND);
+  const codex = normalizeProviderCommand(record.codex, env.BRIDGE_CODEX_COMMAND);
+  if (!claude && !codex) return void 0;
+  return {
+    ...claude ? { claude } : {},
+    ...codex ? { codex } : {}
+  };
+}
+function normalizeBridgeDefaultsConfig(raw) {
+  const record = raw && typeof raw === "object" ? raw : {};
+  const defaultProvider = record.defaultProvider === "codex" ? "codex" : record.defaultProvider === "claude-code" ? "claude-code" : void 0;
+  const defaultWorkspace = typeof record.defaultWorkspace === "string" && record.defaultWorkspace.trim() ? record.defaultWorkspace : void 0;
+  if (!defaultProvider && !defaultWorkspace) return void 0;
+  return {
+    ...defaultProvider ? { defaultProvider } : {},
+    ...defaultWorkspace ? { defaultWorkspace } : {}
+  };
+}
+function normalizeProviderCommand(raw, envFallback) {
+  const record = raw && typeof raw === "object" ? raw : {};
+  const command = typeof record.command === "string" && record.command ? record.command : typeof envFallback === "string" && envFallback ? envFallback : void 0;
+  return command ? { command } : void 0;
+}
+function normalizeWechatConfig(raw, env) {
+  const record = raw && typeof raw === "object" ? raw : {};
+  const enabled = record.enabled === true || env.BRIDGE_WECHAT_ENABLED === "1" || env.BRIDGE_WECHAT_ENABLED === "true";
+  const baseUrl = typeof record.baseUrl === "string" && record.baseUrl ? record.baseUrl : typeof env.BRIDGE_WECHAT_BASE_URL === "string" && env.BRIDGE_WECHAT_BASE_URL ? env.BRIDGE_WECHAT_BASE_URL : void 0;
+  const token = typeof record.token === "string" && record.token ? record.token : typeof env.BRIDGE_WECHAT_TOKEN === "string" && env.BRIDGE_WECHAT_TOKEN ? env.BRIDGE_WECHAT_TOKEN : void 0;
+  const accountId = typeof record.accountId === "string" && record.accountId ? record.accountId : typeof env.BRIDGE_WECHAT_ACCOUNT_ID === "string" && env.BRIDGE_WECHAT_ACCOUNT_ID ? env.BRIDGE_WECHAT_ACCOUNT_ID : void 0;
+  if (!enabled && !baseUrl && !token && !accountId) return void 0;
+  return {
+    enabled,
+    baseUrl,
+    token,
+    accountId
+  };
+}
+
+// src/daemon/configPersistence.ts
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+async function persistWechatCredentialsToConfigFile(input) {
+  const currentConfig = await readConfigFile(input.configPath);
+  const nextConfig = {
+    ...currentConfig,
+    wechat: {
+      ...isRecord(currentConfig.wechat) ? currentConfig.wechat : {},
+      enabled: true,
+      baseUrl: input.baseUrl,
+      token: input.token,
+      accountId: input.accountId
+    }
+  };
+  await mkdir(dirname(input.configPath), { recursive: true });
+  await writeFile(input.configPath, `${JSON.stringify(nextConfig, null, 2)}
+`, "utf8");
+}
+async function deleteConfigFile(configPath) {
+  try {
+    await rm(configPath);
+  } catch (error) {
+    if (isMissingFileError(error)) return;
+    throw error;
+  }
+}
+async function persistBridgeDefaultsToConfigFile(input) {
+  const currentConfig = await readConfigFile(input.configPath);
+  const nextConfig = {
+    ...currentConfig,
+    bridge: {
+      ...isRecord(currentConfig.bridge) ? currentConfig.bridge : {},
+      defaultProvider: input.defaultProvider,
+      defaultWorkspace: input.defaultWorkspace
+    }
+  };
+  await mkdir(dirname(input.configPath), { recursive: true });
+  await writeFile(input.configPath, `${JSON.stringify(nextConfig, null, 2)}
+`, "utf8");
+}
+async function persistProviderCommandsToConfigFile(input) {
+  const currentConfig = await readConfigFile(input.configPath);
+  const normalizedProviders = normalizeProvidersForPersistence(input.providers);
+  const nextConfig = {
+    ...currentConfig,
+    providers: normalizedProviders
+  };
+  await mkdir(dirname(input.configPath), { recursive: true });
+  await writeFile(input.configPath, `${JSON.stringify(nextConfig, null, 2)}
+`, "utf8");
+}
+async function readConfigFile(path) {
+  try {
+    const raw = await readFile(path, "utf8");
+    const parsed = JSON.parse(raw);
+    return isRecord(parsed) ? parsed : {};
+  } catch (error) {
+    if (isMissingFileError(error)) return {};
+    throw error;
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isMissingFileError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function normalizeProvidersForPersistence(providers) {
+  const claude = providers?.claude?.command ? { command: providers.claude.command } : void 0;
+  const codex = providers?.codex?.command ? { command: providers.codex.command } : void 0;
+  if (!claude && !codex) return void 0;
+  return {
+    ...claude ? { claude } : {},
+    ...codex ? { codex } : {}
+  };
+}
+
+// src/channels/weixin-direct/weixinStateStore.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+var PUSH_QUOTA_LIMIT = 10;
+var PUSH_WINDOW_MS = 24 * 60 * 60 * 1e3;
+var FileWeixinStateStore = class {
+  constructor(configPath) {
+    this.configPath = configPath;
+  }
+  configPath;
+  load() {
+    const channel = this.readChannel();
+    const contextTokens = {};
+    for (const [userId, user] of Object.entries(channel.users ?? {})) {
+      if (user?.contextToken) contextTokens[userId] = user.contextToken;
+    }
+    return { contextTokens, cursor: channel.cursor ?? "" };
+  }
+  setContextToken(userId, token) {
+    if (!userId || !token) return;
+    const state = this.readState();
+    const channel = state.bridge?.weixinChannel ?? {};
+    const users = { ...channel.users ?? {} };
+    users[userId] = { contextToken: token, windowStartAt: Date.now(), sentCount: 0 };
+    this.writeChannel(state, { ...channel, users });
+  }
+  setCursor(cursor) {
+    const state = this.readState();
+    const channel = state.bridge?.weixinChannel ?? {};
+    if ((channel.cursor ?? "") === cursor) return;
+    this.writeChannel(state, { ...channel, cursor });
+  }
+  canSend(userId) {
+    const user = this.readChannel().users?.[userId];
+    if (!user?.contextToken) return false;
+    if (Date.now() - user.windowStartAt >= PUSH_WINDOW_MS) return false;
+    return user.sentCount < PUSH_QUOTA_LIMIT;
+  }
+  recordSent(userId) {
+    const state = this.readState();
+    const channel = state.bridge?.weixinChannel ?? {};
+    const user = channel.users?.[userId];
+    if (!user) return;
+    const users = { ...channel.users, [userId]: { ...user, sentCount: user.sentCount + 1 } };
+    this.writeChannel(state, { ...channel, users });
+  }
+  getQuota(userId) {
+    const user = this.readChannel().users?.[userId];
+    if (!user?.contextToken) return { remaining: 0, sentCount: 0, windowStartAt: 0, expired: true };
+    const expired = Date.now() - user.windowStartAt >= PUSH_WINDOW_MS;
+    const remaining = expired ? 0 : Math.max(0, PUSH_QUOTA_LIMIT - user.sentCount);
+    return { remaining, sentCount: user.sentCount, windowStartAt: user.windowStartAt, expired };
+  }
+  enqueueOutbound(chatId, item) {
+    if (!chatId) return;
+    const state = this.readState();
+    const channel = state.bridge?.weixinChannel ?? {};
+    const outbox = { ...channel.outbox ?? {} };
+    outbox[chatId] = [...outbox[chatId] ?? [], item];
+    this.writeChannel(state, { ...channel, outbox });
+  }
+  peekOutbound(chatId) {
+    return this.readChannel().outbox?.[chatId] ?? [];
+  }
+  shiftOutbound(chatId) {
+    const state = this.readState();
+    const channel = state.bridge?.weixinChannel ?? {};
+    const list = channel.outbox?.[chatId];
+    if (!list?.length) return;
+    const outbox = { ...channel.outbox };
+    const rest = list.slice(1);
+    if (rest.length) outbox[chatId] = rest;
+    else delete outbox[chatId];
+    this.writeChannel(state, { ...channel, outbox });
+  }
+  hasPendingOutbound(chatId) {
+    return (this.readChannel().outbox?.[chatId]?.length ?? 0) > 0;
+  }
+  clearOutbound(chatId) {
+    const state = this.readState();
+    const channel = state.bridge?.weixinChannel ?? {};
+    if (!channel.outbox?.[chatId]) return;
+    const outbox = { ...channel.outbox };
+    delete outbox[chatId];
+    this.writeChannel(state, { ...channel, outbox });
+  }
+  clear() {
+    const state = this.readState();
+    if (!state.bridge?.weixinChannel) return;
+    this.writeChannel(state, { cursor: "", users: {}, outbox: {} });
+  }
+  readChannel() {
+    return this.readState().bridge?.weixinChannel ?? {};
+  }
+  readState() {
+    if (!existsSync2(this.configPath)) return {};
+    try {
+      const raw = JSON.parse(readFileSync2(this.configPath, "utf8"));
+      return raw && typeof raw === "object" ? raw : {};
+    } catch {
+      return {};
+    }
+  }
+  writeChannel(state, channel) {
+    const next = {
+      ...state,
+      bridge: { ...state.bridge ?? {}, weixinChannel: channel }
+    };
+    mkdirSync(dirname2(this.configPath), { recursive: true });
+    writeFileSync(this.configPath, `${JSON.stringify(next, null, 2)}
+`, "utf8");
+  }
+};
+
+// src/providers/claude-code/nativeSessions.ts
+import { appendFile, mkdir as mkdir2, readdir, readFile as readFile2, stat, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { basename, dirname as dirname3, join as join2 } from "node:path";
+
+// src/session/sessionBridgeTag.ts
+function buildSessionBridgeName(input) {
+  const summary = input.summary?.trim();
+  return summary ? summary : void 0;
+}
+function parseSessionBridgeName(value) {
+  if (!value) return null;
+  const match = value.match(/\[claude-codex-wechat:([A-Za-z0-9_-]+)\]/);
+  if (!match?.[1]) return null;
+  try {
+    const decoded = JSON.parse(Buffer.from(match[1], "base64url").toString("utf8"));
+    if (decoded.platform !== "weixin") return null;
+    if (typeof decoded.platformUserId !== "string" || typeof decoded.chatId !== "string") return null;
+    return {
+      platform: "weixin",
+      platformUserId: decoded.platformUserId,
+      chatId: decoded.chatId
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/providers/claude-code/nativeSessions.ts
+function resolveClaudeConfigDir(env = process.env) {
+  return join2(env.HOME || homedir2(), ".claude");
+}
+async function listRecoverableClaudeSessions(env = process.env) {
+  const projectsDir = join2(resolveClaudeConfigDir(env), "projects");
+  const historyIndex = await readClaudeHistoryIndex(env);
+  const candidates = [];
+  try {
+    const projectEntries = await readdir(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(() => []);
+      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 parsedMeta = await readClaudeSessionMetadata(filePath).catch(() => null);
+        const historyMeta = historyIndex.get(basename(fileName, ".jsonl"));
+        const sessionId = basename(fileName, ".jsonl");
+        const bridgeTag = historyMeta?.bridgeTag ?? parseSessionBridgeName(parsedMeta?.sessionName);
+        const cwd = parsedMeta?.cwd ?? historyMeta?.project;
+        candidates.push({
+          id: sessionId,
+          providerId: "claude-code",
+          ...cwd ? { cwd } : {},
+          title: parsedMeta?.aiTitle ?? parsedMeta?.lastPrompt ?? fileName,
+          ...parsedMeta?.sessionName ? { resumeTitle: parsedMeta.sessionName } : historyMeta?.display ? { resumeTitle: historyMeta.display } : {},
+          ...historyMeta?.timestamp ? { lastActivityAt: historyMeta.timestamp } : metadata ? { lastActivityAt: Math.trunc(metadata.mtimeMs) } : {},
+          ...bridgeTag ? { bridgeBindingSource: "bridge_tag", bridgeTag } : {}
+        });
+      }
+    }
+  } catch {
+    return [];
+  }
+  return candidates.sort((a, b) => (b.lastActivityAt ?? 0) - (a.lastActivityAt ?? 0));
+}
+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");
+  try {
+    const projectEntries = await readdir(projectsDir, { withFileTypes: true });
+    for (const entry of projectEntries) {
+      if (!entry.isDirectory() || entry.isSymbolicLink()) continue;
+      const sessionPath = join2(projectsDir, String(entry.name), `${trimmed}.jsonl`);
+      try {
+        const metadata = await stat(sessionPath);
+        if (metadata.isFile()) return sessionPath;
+      } catch {
+      }
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+async function ensureClaudeSessionBridgeMetadata(input) {
+  const env = input.env ?? process.env;
+  const sessionPath = await findRecoverableClaudeSessionPath(input.sessionId, env);
+  let changed = false;
+  let metadata = null;
+  if (sessionPath) {
+    changed = await normalizeClaudeSessionFileForResume(sessionPath);
+    metadata = await readClaudeSessionMetadata(sessionPath).catch(() => null);
+    if (metadata?.sessionName !== input.resumeTitle) {
+      const suffix = [
+        JSON.stringify({ type: "custom-title", customTitle: input.resumeTitle, sessionId: input.sessionId }),
+        JSON.stringify({ type: "agent-name", agentName: input.resumeTitle, sessionId: input.sessionId })
+      ].join("\n");
+      const prefix = (await readFile2(sessionPath, "utf8")).endsWith("\n") ? "" : "\n";
+      await appendFile(sessionPath, `${prefix}${suffix}
+`, "utf8");
+      changed = true;
+    }
+  }
+  changed = await upsertClaudeHistoryDisplay({
+    sessionId: input.sessionId,
+    resumeTitle: input.resumeTitle,
+    project: input.cwd ?? metadata?.cwd,
+    env
+  }) || changed;
+  return changed;
+}
+async function hasClaudeSessionBridgeMetadata(input) {
+  const env = input.env ?? process.env;
+  const sessionPath = await findRecoverableClaudeSessionPath(input.sessionId, env);
+  if (!sessionPath) return false;
+  const metadata = await readClaudeSessionMetadata(sessionPath).catch(() => null);
+  return metadata?.sessionName === input.resumeTitle;
+}
+async function hasClaudeHistoryDisplay(input) {
+  const env = input.env ?? process.env;
+  const historyPath = join2(resolveClaudeConfigDir(env), "history.jsonl");
+  try {
+    const content = await readFile2(historyPath, "utf8");
+    for (const line of content.split(/\r?\n/)) {
+      if (!line.trim()) continue;
+      try {
+        const record = JSON.parse(line);
+        if (record.sessionId === input.sessionId) {
+          return typeof record.display === "string" && record.display.trim() === input.resumeTitle;
+        }
+      } catch {
+      }
+    }
+  } catch {
+    return false;
+  }
+  return false;
+}
+async function readClaudeSessionMetadata(filePath) {
+  const content = await readFile2(filePath, "utf8");
+  let aiTitle;
+  let lastPrompt;
+  let sessionName;
+  let cwd;
+  for (const line of content.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    try {
+      const record = JSON.parse(line);
+      if (typeof record.cwd === "string" && record.cwd.trim()) {
+        cwd = record.cwd.trim();
+      }
+      if (record.type === "ai-title" && typeof record.aiTitle === "string" && record.aiTitle.trim()) {
+        aiTitle = record.aiTitle.trim();
+      }
+      if (record.type === "last-prompt" && typeof record.lastPrompt === "string" && record.lastPrompt.trim()) {
+        lastPrompt = record.lastPrompt.trim();
+      }
+      if (record.type === "custom-title" && typeof record.customTitle === "string" && record.customTitle.trim()) {
+        sessionName = record.customTitle.trim();
+      }
+      if (record.type === "agent-name" && typeof record.agentName === "string" && record.agentName.trim()) {
+        sessionName = record.agentName.trim();
+      }
+      if (record.type === "user" && record.message && typeof record.message === "object") {
+        const message = record.message;
+        if (typeof message.sessionName === "string" && message.sessionName.trim()) {
+          sessionName = message.sessionName.trim();
+        }
+      }
+    } catch {
+    }
+  }
+  return { aiTitle, lastPrompt, sessionName, cwd };
+}
+async function readClaudeHistoryIndex(env) {
+  const historyPath = join2(resolveClaudeConfigDir(env), "history.jsonl");
+  const index = /* @__PURE__ */ new Map();
+  try {
+    const content = await readFile2(historyPath, "utf8");
+    for (const line of content.split(/\r?\n/)) {
+      if (!line.trim()) continue;
+      try {
+        const record = JSON.parse(line);
+        if (typeof record.sessionId !== "string" || !record.sessionId.trim()) continue;
+        const sessionId = record.sessionId.trim();
+        const previous = index.get(sessionId);
+        const timestamp = typeof record.timestamp === "number" ? record.timestamp : previous?.timestamp;
+        const project = typeof record.project === "string" && record.project.trim() ? record.project.trim() : previous?.project;
+        const display = typeof record.display === "string" ? record.display.trim() : "";
+        const bridgeTag = parseSessionBridgeName(display) ?? previous?.bridgeTag;
+        index.set(sessionId, { project, timestamp, display: display || previous?.display, bridgeTag });
+      } catch {
+      }
+    }
+  } catch {
+    return index;
+  }
+  return index;
+}
+async function upsertClaudeHistoryDisplay(input) {
+  const historyPath = join2(resolveClaudeConfigDir(input.env), "history.jsonl");
+  const lines = [];
+  let replaced = false;
+  let changed = false;
+  try {
+    const content = await readFile2(historyPath, "utf8");
+    for (const line of content.split(/\r?\n/)) {
+      if (!line.trim()) continue;
+      try {
+        const record = JSON.parse(line);
+        if (record.sessionId === input.sessionId) {
+          replaced = true;
+          if (record.display !== input.resumeTitle) changed = true;
+          if (typeof record.project !== "string" && input.project) changed = true;
+          lines.push(JSON.stringify({
+            ...record,
+            display: input.resumeTitle,
+            ...typeof record.project !== "string" && input.project ? { project: input.project } : {}
+          }));
+        } else {
+          lines.push(line);
+        }
+      } catch {
+        lines.push(line);
+      }
+    }
+  } catch {
+  }
+  if (!replaced) {
+    changed = true;
+    lines.push(JSON.stringify({
+      display: input.resumeTitle,
+      pastedContents: {},
+      timestamp: Date.now(),
+      sessionId: input.sessionId,
+      ...input.project ? { project: input.project } : {}
+    }));
+  }
+  if (!changed) return false;
+  await mkdir2(dirname3(historyPath), { recursive: true });
+  await writeFile2(historyPath, `${lines.join("\n")}
+`, "utf8");
+  return true;
+}
+async function normalizeClaudeSessionFileForResume(sessionPath) {
+  const content = await readFile2(sessionPath, "utf8");
+  const nextLines = [];
+  let changed = false;
+  let hasPermissionMode = false;
+  let sawSdkCliEntrypoint = false;
+  for (const line of content.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    try {
+      const record = JSON.parse(line);
+      if (record.type === "permission-mode") hasPermissionMode = true;
+      if (record.entrypoint === "sdk-cli") {
+        sawSdkCliEntrypoint = true;
+        nextLines.push(JSON.stringify({
+          ...record,
+          entrypoint: "cli"
+        }));
+        changed = true;
+        continue;
+      }
+    } catch {
+      nextLines.push(line);
+      continue;
+    }
+    nextLines.push(line);
+  }
+  if (sawSdkCliEntrypoint && !hasPermissionMode) {
+    const sessionId = basename(sessionPath, ".jsonl");
+    nextLines.unshift(JSON.stringify({
+      type: "permission-mode",
+      permissionMode: "bypassPermissions",
+      sessionId
+    }));
+    changed = true;
+  }
+  if (!changed) return false;
+  await writeFile2(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 { existsSync as existsSync3 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { basename as basename2, join as join3 } from "node:path";
+function resolveCodexSessionsRoot(env = process.env) {
+  return join3(env.CODEX_HOME || join3(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 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];
+}
+async function listRecoverableCodexSessions(env = process.env) {
+  const root = resolveCodexSessionsRoot(env);
+  const index = await readCodexSessionIndex(env);
+  const threadMeta = readCodexThreadMetadata(env);
+  const candidates = [];
+  async function walk(currentDir, depth) {
+    if (depth > 8) return;
+    const entries = await readdir2(currentDir, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+      if (entry.isSymbolicLink()) continue;
+      const name = String(entry.name);
+      const path = join3(currentDir, name);
+      if (entry.isDirectory()) {
+        await walk(path, depth + 1);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      const sessionId = extractCodexSessionId(name);
+      if (!sessionId) continue;
+      const indexed = index.get(sessionId);
+      const threaded = threadMeta.get(sessionId);
+      const sessionMeta = await readCodexSessionMeta(path);
+      const resolvedTitle = indexed?.threadName ?? threaded?.title ?? name;
+      const resolvedLastActivityAt = indexed?.updatedAtMs ?? threaded?.updatedAtMs ?? sessionMeta.lastActivityAt;
+      candidates.push({
+        id: sessionId,
+        providerId: "codex",
+        ...sessionMeta.cwd ? { cwd: sessionMeta.cwd } : {},
+        ...resolvedLastActivityAt ? { lastActivityAt: resolvedLastActivityAt } : {},
+        title: resolvedTitle,
+        ...indexed?.threadName ?? threaded?.title ? { resumeTitle: indexed?.threadName ?? threaded?.title } : {}
+      });
+    }
+  }
+  await walk(root, 0);
+  return candidates.sort((a, b) => (b.lastActivityAt ?? 0) - (a.lastActivityAt ?? 0));
+}
+async function findRecoverableCodexSessionPath(sessionId, env = process.env) {
+  const root = resolveCodexSessionsRoot(env);
+  const trimmed = sessionId.trim();
+  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(() => []);
+    for (const entry of entries) {
+      if (entry.isSymbolicLink()) continue;
+      const name = String(entry.name);
+      const path = join3(currentDir, name);
+      if (entry.isDirectory()) {
+        const found = await walk(path, depth + 1);
+        if (found) return found;
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      if (extractCodexSessionId(name) === trimmed) return path;
+    }
+    return null;
+  }
+  return await walk(root, 0);
+}
+async function readCodexSessionIndex(env) {
+  const indexPath = join3(env.CODEX_HOME || join3(env.HOME || homedir3(), ".codex"), "session_index.jsonl");
+  const index = /* @__PURE__ */ new Map();
+  try {
+    const content = await readFile3(indexPath, "utf8");
+    for (const line of content.split(/\r?\n/)) {
+      if (!line.trim()) continue;
+      try {
+        const record = JSON.parse(line);
+        if (typeof record.id !== "string" || !record.id.trim()) continue;
+        const updatedAtMs = typeof record.updated_at === "string" ? Date.parse(record.updated_at) : void 0;
+        index.set(record.id.trim(), {
+          threadName: typeof record.thread_name === "string" && record.thread_name.trim() ? record.thread_name.trim() : void 0,
+          updatedAtMs: Number.isFinite(updatedAtMs) ? Math.trunc(updatedAtMs) : void 0
+        });
+      } catch {
+      }
+    }
+  } catch {
+    return index;
+  }
+  return index;
+}
+function readCodexThreadMetadata(env) {
+  const dbPath = join3(env.CODEX_HOME || join3(env.HOME || homedir3(), ".codex"), "state_5.sqlite");
+  const metadata = /* @__PURE__ */ new Map();
+  if (!existsSync3(dbPath)) return metadata;
+  let db = null;
+  try {
+    db = new Database(dbPath, { readonly: true });
+    const columns = db.prepare("PRAGMA table_info(threads)").all();
+    if (!columns.some((column) => column.name === "id")) return metadata;
+    const rows = db.prepare("SELECT id, title, updated_at_ms FROM threads").all();
+    for (const row of rows) {
+      if (typeof row.id !== "string" || !row.id.trim()) continue;
+      metadata.set(row.id.trim(), {
+        title: typeof row.title === "string" && row.title.trim() ? row.title.trim() : void 0,
+        updatedAtMs: typeof row.updated_at_ms === "number" ? Math.trunc(row.updated_at_ms) : typeof row.updated_at_ms === "bigint" ? Number(row.updated_at_ms) : void 0
+      });
+    }
+  } catch {
+    return metadata;
+  } finally {
+    db?.close();
+  }
+  return metadata;
+}
+async function readCodexSessionMeta(filePath) {
+  try {
+    const content = await readFile3(filePath, "utf8");
+    let cwd;
+    for (const line of content.split(/\r?\n/)) {
+      if (!line.trim()) continue;
+      try {
+        const record = JSON.parse(line);
+        if (typeof record.cwd === "string" && record.cwd.trim()) {
+          cwd = record.cwd.trim();
+          break;
+        }
+        if (record.payload && typeof record.payload === "object") {
+          const payload = record.payload;
+          if (typeof payload.cwd === "string" && payload.cwd.trim()) {
+            cwd = payload.cwd.trim();
+            break;
+          }
+        }
+      } catch {
+      }
+    }
+    const metadata = await stat2(filePath).catch(() => null);
+    return {
+      cwd,
+      lastActivityAt: metadata ? Math.trunc(metadata.mtimeMs) : void 0
+    };
+  } catch {
+    return {};
+  }
+}
+
+// src/session/providerAutoAttach.ts
+import { nanoid } from "nanoid";
+
+// src/providers/codex/sessionIndex.ts
+import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname4, join as join4 } from "node:path";
+function resolveCodexIndexPath(env = process.env) {
+  return join4(env.CODEX_HOME || join4(env.HOME || homedir4(), ".codex"), "session_index.jsonl");
+}
+async function upsertCodexSessionIndexEntry(input, env = process.env) {
+  const indexPath = resolveCodexIndexPath(env);
+  const lines = [];
+  let replaced = false;
+  try {
+    const content = await readFile4(indexPath, "utf8");
+    for (const line of content.split(/\r?\n/)) {
+      if (!line.trim()) continue;
+      try {
+        const record = JSON.parse(line);
+        if (record.id === input.sessionId) {
+          lines.push(JSON.stringify({
+            ...record,
+            id: input.sessionId,
+            thread_name: input.threadName,
+            updated_at: input.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+          }));
+          replaced = true;
+        } else {
+          lines.push(line);
+        }
+      } catch {
+        lines.push(line);
+      }
+    }
+  } catch {
+  }
+  if (!replaced) {
+    lines.push(JSON.stringify({
+      id: input.sessionId,
+      thread_name: input.threadName,
+      updated_at: input.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+    }));
+  }
+  await mkdir3(dirname4(indexPath), { recursive: true });
+  await writeFile3(indexPath, `${lines.join("\n")}
+`, "utf8");
+}
+
+// src/providers/codex/nativeThreads.ts
+import Database2 from "better-sqlite3";
+import { existsSync as existsSync4 } from "node:fs";
+import { readFile as readFile5, writeFile as writeFile4 } from "node:fs/promises";
+import { homedir as homedir5 } from "node:os";
+import { join as join5 } from "node:path";
+function resolveCodexStateDbPath(env = process.env) {
+  return join5(env.CODEX_HOME || join5(env.HOME || homedir5(), ".codex"), "state_5.sqlite");
+}
+async function syncCodexThreadForResume(input) {
+  const env = input.env ?? process.env;
+  const dbPath = resolveCodexStateDbPath(env);
+  if (!existsSync4(dbPath)) return false;
+  for (let attempt = 0; attempt < 50; attempt += 1) {
+    const db = new Database2(dbPath);
+    try {
+      const columns = db.prepare("PRAGMA table_info(threads)").all();
+      if (!columns.some((column) => column.name === "id")) return false;
+      const updatedAtMs = Date.now();
+      const updatedAt = Math.trunc(updatedAtMs / 1e3);
+      const result = db.prepare(`
+        UPDATE threads
+        SET
+          source = 'cli',
+          cwd = @cwd,
+          title = @resumeTitle,
+          updated_at = @updatedAt,
+          updated_at_ms = @updatedAtMs
+        WHERE id = @sessionId
+      `).run({
+        sessionId: input.sessionId,
+        cwd: input.cwd,
+        resumeTitle: input.resumeTitle,
+        updatedAt,
+        updatedAtMs
+      });
+      if (result.changes > 0) {
+        const row = db.prepare("SELECT rollout_path FROM threads WHERE id = ?").get(input.sessionId);
+        if (typeof row?.rollout_path === "string" && row.rollout_path) {
+          await syncCodexRolloutSessionMeta(row.rollout_path);
+        }
+        return true;
+      }
+    } finally {
+      db.close();
+    }
+    await delay(100);
+  }
+  return false;
+}
+async function syncCodexRolloutSessionMeta(rolloutPath) {
+  if (!existsSync4(rolloutPath)) return;
+  const content = await readFile5(rolloutPath, "utf8");
+  const lines = content.split(/\r?\n/);
+  if (!lines[0]?.trim()) return;
+  try {
+    const first = JSON.parse(lines[0]);
+    if (first.type !== "session_meta" || !first.payload || typeof first.payload !== "object") return;
+    const payload = first.payload;
+    payload.source = "cli";
+    payload.originator = "codex-tui";
+    first.payload = payload;
+    lines[0] = JSON.stringify(first);
+    await writeFile4(rolloutPath, lines.join("\n"), "utf8");
+  } catch {
+  }
+}
+async function delay(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/session/providerAutoAttach.ts
+async function listUnattachedRecoverableSessions(input) {
+  if (!input.provider.listRecoverableSessions) return [];
+  const attachedIds = new Set(
+    [input.currentSession].filter((session) => Boolean(session && session.providerId === input.providerId)).map((session) => session.providerSessionId).filter((value) => typeof value === "string" && value.length > 0)
+  );
+  return (await input.provider.listRecoverableSessions()).filter((candidate) => !attachedIds.has(candidate.id));
+}
+async function selectBestRecoverableSession(input) {
+  const persistedBinding = input.lastProviderSessions?.get(input.providerId) ?? null;
+  if (persistedBinding) {
+    const candidates2 = await listUnattachedRecoverableSessions({
+      provider: input.provider,
+      providerId: input.providerId,
+      currentSession: input.currentSession
+    });
+    const exact = candidates2.find((candidate2) => candidate2.id === persistedBinding.providerSessionId);
+    if (exact) return { candidate: exact, matchedBinding: true, bindingSource: "binding_table" };
+  }
+  if (input.allowHeuristicMatch === false) return null;
+  const candidates = await listUnattachedRecoverableSessions({
+    provider: input.provider,
+    providerId: input.providerId,
+    currentSession: input.currentSession
+  });
+  candidates.sort((a, b) => {
+    const aMatch = a.cwd === input.targetCwd ? 1 : 0;
+    const bMatch = b.cwd === input.targetCwd ? 1 : 0;
+    if (aMatch !== bMatch) return bMatch - aMatch;
+    return (b.lastActivityAt ?? 0) - (a.lastActivityAt ?? 0);
+  });
+  const candidate = candidates[0];
+  if (!candidate) return null;
+  if (candidate.cwd && candidate.cwd !== input.targetCwd) return null;
+  return {
+    candidate,
+    matchedBinding: false,
+    bindingSource: candidate.bridgeBindingSource === "sidecar" ? "sidecar" : "heuristic"
+  };
+}
+async function attachProviderSessionToBridge(input) {
+  const bridgeSessionId = `bs_${nanoid(10)}`;
+  const resumeTitle = input.resumeTitle ?? buildSessionBridgeName({
+    platform: "weixin",
+    platformUserId: input.user.platformUserId,
+    chatId: input.chatId
+  });
+  const attached = await input.provider.attachSession?.({
+    candidateId: input.providerSessionId,
+    bridgeSessionId,
+    cwd: input.cwd
+  });
+  const now = Date.now();
+  const updated = {
+    id: bridgeSessionId,
+    chatId: input.chatId,
+    ownerUserId: input.user.id,
+    providerId: input.providerId,
+    cwd: input.cwd,
+    recoverySource: input.recoverySource,
+    resumeTitle,
+    providerSessionId: attached?.providerSessionId,
+    status: attached?.status ?? "starting",
+    createdAt: now,
+    lastActivityAt: now
+  };
+  if (input.shouldCommit && !input.shouldCommit()) return updated;
+  input.conversationStore.setCurrent(updated);
+  input.lastProviderSessions?.set(input.providerId, {
+    providerSessionId: updated.providerSessionId ?? input.providerSessionId,
+    cwd: updated.cwd
+  });
+  if (updated.providerSessionId) {
+    if (updated.providerId === "codex" && updated.resumeTitle) {
+      await upsertCodexSessionIndexEntry({
+        sessionId: updated.providerSessionId,
+        threadName: updated.resumeTitle
+      });
+      await syncCodexThreadForResume({
+        sessionId: updated.providerSessionId,
+        resumeTitle: updated.resumeTitle,
+        cwd: updated.cwd
+      });
+    }
+  }
+  return updated;
+}
+async function autoAttachProviderSessionForMessage(input) {
+  const selection = await selectBestRecoverableSession({
+    provider: input.provider,
+    providerId: input.defaultProviderId,
+    targetCwd: input.user.currentConversation?.cwd ?? input.defaultCwd,
+    lastProviderSessions: input.lastProviderSessions,
+    currentSession: input.conversationStore.getCurrent(),
+    allowHeuristicMatch: false
+  });
+  if (!selection) return null;
+  const session = await attachProviderSessionToBridge({
+    conversationStore: input.conversationStore,
+    lastProviderSessions: input.lastProviderSessions,
+    provider: input.provider,
+    user: input.user,
+    providerId: input.defaultProviderId,
+    providerSessionId: selection.candidate.id,
+    chatId: input.message.chatId,
+    cwd: selection.candidate.cwd ?? input.user.currentConversation?.cwd ?? input.defaultCwd,
+    recoverySource: selection.bindingSource,
+    resumeTitle: selection.candidate.resumeTitle,
+    shouldCommit: input.shouldCommit
+  });
+  return { session, matchedBinding: selection.matchedBinding, bindingSource: selection.bindingSource };
+}
+
+// src/admin/channelAdminRoutes.ts
+function registerChannelAdminRoutes(input) {
+  let wechat = input.wechat;
+  const configPath = input.configPath ?? process.env.BRIDGE_CONFIG ?? defaultConfigPath();
+  input.channel?.onHealthChange?.(() => {
+    input.events?.emit({
+      type: "channel.plugin-status-changed",
+      plugin_id: "weixin",
+      status: toWechatPluginStatus(wechat, input.users, input.channel)
+    });
+  });
+  input.app.get("/api/channel/plugins", async () => [toWechatPluginStatus(wechat, input.users, input.channel)]);
+  input.app.get("/api/channel/wechat/runtime-config", async () => wechat ?? { enabled: false });
+  input.app.get("/api/channel/state", async () => ({
+    activeUser: input.users.getActiveUser(),
+    plugin: toWechatPluginStatus(wechat, input.users, input.channel),
+    settings: input.defaults ?? { defaultProvider: "claude-code", defaultWorkspace: process.cwd() },
+    runtimeConfig: wechat ?? null,
+    lastProviderSessions: input.lastProviderSessions?.list() ?? {},
+    quota: toQuotaView(input.users, input.weixinStateStore)
+  }));
+  input.app.post("/api/channel/plugins/enable", async (request, reply) => {
+    if (request.body.plugin_id !== "weixin") {
+      return reply.code(400).send({ ok: false, error: "unknown_channel_plugin" });
+    }
+    const config = request.body.config ?? {};
+    const credentials = typeof config.credentials === "object" && config.credentials ? config.credentials : {};
+    const previousWechat = wechat;
+    const baseUrl = typeof config.baseUrl === "string" ? config.baseUrl : typeof credentials.baseUrl === "string" ? credentials.baseUrl : previousWechat?.baseUrl;
+    const token = typeof config.token === "string" ? config.token : typeof credentials.bot_token === "string" ? credentials.bot_token : void 0;
+    const accountId = typeof credentials.account_id === "string" ? credentials.account_id : previousWechat?.accountId;
+    if (!baseUrl) return reply.code(400).send({ ok: false, error: "wechat_base_url_required" });
+    const nextWechat = { enabled: true, baseUrl, token, accountId };
+    await input.onWechatConfigChanged?.(nextWechat);
+    if (token && accountId) {
+      await persistWechatCredentialsToConfigFile({
+        configPath,
+        accountId,
+        token,
+        baseUrl
+      });
+    }
+    wechat = nextWechat;
+    input.events?.emit({
+      type: "channel.plugin-status-changed",
+      plugin_id: "weixin",
+      status: toWechatPluginStatus(wechat, input.users, input.channel)
+    });
+    return { ok: true };
+  });
+  input.app.get("/api/channel/weixin/login", async (_request, reply) => {
+    const client = new WeixinDirectLoginClient();
+    reply.raw.writeHead(200, {
+      "content-type": "text/event-stream; charset=utf-8",
+      "cache-control": "no-cache",
+      connection: "keep-alive"
+    });
+    try {
+      const qr = await client.fetchQrCode();
+      reply.raw.write(`event: qr
+`);
+      reply.raw.write(`data: ${JSON.stringify({ qrcodeData: qr.qrcodeData })}
+
+`);
+      while (true) {
+        await new Promise((resolve) => setTimeout(resolve, client.pollIntervalMs));
+        const status = await client.pollQrCodeStatus(qr.ticket);
+        if (status.status === "waiting") continue;
+        if (status.status === "scanned") {
+          reply.raw.write(`event: scanned
+`);
+          reply.raw.write("data: {}\n\n");
+          continue;
+        }
+        if (status.status === "confirmed") {
+          reply.raw.write(`event: done
+`);
+          reply.raw.write(`data: ${JSON.stringify({
+            accountId: status.accountId,
+            botToken: status.botToken,
+            baseUrl: status.baseUrl
+          })}
+
+`);
+          break;
+        }
+        reply.raw.write(`event: error
+`);
+        reply.raw.write(`data: ${JSON.stringify({ message: "QR code expired" })}
+
+`);
+        break;
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      reply.raw.write(`event: error
+`);
+      reply.raw.write(`data: ${JSON.stringify({ message })}
+
+`);
+    }
+    reply.raw.end();
+    return reply.hijack();
+  });
+  input.app.post("/api/channel/plugins/disable", async (request, reply) => {
+    if (request.body.plugin_id !== "weixin") {
+      return reply.code(400).send({ ok: false, error: "unknown_channel_plugin" });
+    }
+    try {
+      const runtimeSession = input.conversation?.getCurrent();
+      if (runtimeSession) {
+        const provider = input.providers?.find((candidate) => candidate.id === runtimeSession.providerId);
+        await provider?.stopSession(runtimeSession.id);
+      }
+      input.conversation?.clear();
+      input.events?.emit({ type: "channel.current-session-changed" });
+      const activeUser = input.users.getActiveUser();
+      if (activeUser) {
+        input.users.clearActiveUser(activeUser.id);
+      }
+      const nextWechat = { enabled: false };
+      await input.onWechatConfigChanged?.(nextWechat);
+      wechat = nextWechat;
+      input.events?.emit({
+        type: "channel.plugin-status-changed",
+        plugin_id: "weixin",
+        status: toWechatPluginStatus(wechat, input.users, input.channel)
+      });
+      await deleteConfigFile(configPath);
+      return { ok: true };
+    } catch (err) {
+      input.app.log.error({ err }, "[disable] failed");
+      return reply.code(500).send({ ok: false, error: err instanceof Error ? err.message : String(err) });
+    }
+  });
+  input.app.get("/api/channel/active-user", async () => input.users.getActiveUser());
+  input.app.get("/api/channel/providers/:providerId/recoverable-sessions", async (request, reply) => {
+    const provider = input.providers?.find((candidate) => candidate.id === request.params.providerId);
+    if (!provider?.listRecoverableSessions) {
+      return reply.code(404).send({ ok: false, error: "provider_session_listing_not_supported" });
+    }
+    const sessions = await Promise.all((await listUnattachedRecoverableSessions({
+      provider,
+      providerId: request.params.providerId === "codex" ? "codex" : "claude-code",
+      currentSession: input.conversation?.getCurrent()
+    })).map(async (session) => ({
+      ...session,
+      preferredResumeMode: buildPreferredResumeMode(session.providerId, session.resumeTitle),
+      preferredResumeCommand: buildPreferredResumeCommand(session.providerId, session.id, session.resumeTitle),
+      providerResumeCommand: buildProviderResumeCommand(session.providerId, session.id),
+      providerResumeByTitleCommand: buildProviderResumeByTitleCommand(session.providerId, session.resumeTitle),
+      providerResumeTitleSynced: await resolveRecoverableProviderResumeTitleSynced(session),
+      providerResumeHistorySynced: await resolveRecoverableProviderResumeHistorySynced(session),
+      providerResumeRepairable: session.providerId === "claude-code" && Boolean(session.id && session.resumeTitle && await findRecoverableClaudeSessionPath(session.id))
+    })));
+    const limit = Number.parseInt(request.query.limit ?? "", 10);
+    if (!Number.isFinite(limit) || limit <= 0) return sessions;
+    const cursor = typeof request.query.cursor === "string" && request.query.cursor.trim() ? request.query.cursor.trim() : null;
+    const startIndex = cursor ? sessions.findIndex((session) => session.id === cursor) + 1 : 0;
+    const safeStart = startIndex > 0 ? startIndex : 0;
+    const items = sessions.slice(safeStart, safeStart + limit);
+    const nextCursor = safeStart + items.length < sessions.length ? items.at(-1)?.id ?? null : null;
+    return { items, nextCursor };
+  });
+  input.app.post("/api/channel/sessions/attach", async (request, reply) => {
+    const provider = input.providers?.find((candidate) => candidate.id === request.body.providerId);
+    if (!provider?.attachSession) {
+      return reply.code(404).send({ ok: false, error: "provider_session_attach_not_supported" });
+    }
+    const user = input.users.isActiveUser(PRIMARY_WEIXIN_PLATFORM, request.body.platformUserId);
+    if (!user) {
+      return reply.code(404).send({ ok: false, error: "active_wechat_user_not_found" });
+    }
+    if (!input.conversation) {
+      return reply.code(500).send({ ok: false, error: "current_conversation_store_unavailable" });
+    }
+    const recoverableCandidate = provider.listRecoverableSessions ? (await provider.listRecoverableSessions()).find((candidate) => candidate.id === request.body.providerSessionId) : void 0;
+    const attached = await attachProviderSessionToBridge({
+      conversationStore: input.conversation,
+      lastProviderSessions: input.lastProviderSessions,
+      provider,
+      user,
+      providerId: request.body.providerId === "codex" ? "codex" : "claude-code",
+      providerSessionId: request.body.providerSessionId,
+      chatId: request.body.chatId ?? user.platformUserId,
+      cwd: request.body.cwd ?? recoverableCandidate?.cwd ?? input.defaults?.defaultWorkspace ?? process.cwd(),
+      recoverySource: "manual_attach",
+      resumeTitle: recoverableCandidate?.resumeTitle
+    });
+    input.events?.emit({ type: "channel.current-session-changed" });
+    return {
+      ok: true,
+      session: {
+        ...attached,
+        preferredResumeMode: buildPreferredResumeMode(attached.providerId, attached.resumeTitle),
+        preferredResumeCommand: buildPreferredResumeCommand(attached.providerId, attached.providerSessionId, attached.resumeTitle),
+        providerResumeCommand: buildProviderResumeCommand(attached.providerId, attached.providerSessionId),
+        providerResumeByTitleCommand: buildProviderResumeByTitleCommand(attached.providerId, attached.resumeTitle)
+      }
+    };
+  });
+  input.app.post("/api/channel/sessions/new", async (request, reply) => {
+    const user = input.users.isActiveUser(PRIMARY_WEIXIN_PLATFORM, request.body.platformUserId);
+    if (!user) {
+      return reply.code(404).send({ ok: false, error: "active_wechat_user_not_found" });
+    }
+    if (!input.conversation) {
+      return reply.code(500).send({ ok: false, error: "current_conversation_store_unavailable" });
+    }
+    const providerId = request.body.providerId === "codex" ? "codex" : "claude-code";
+    const cwd = typeof request.body.cwd === "string" && request.body.cwd.trim() ? request.body.cwd : input.defaults?.defaultWorkspace ?? process.cwd();
+    const chatId = request.body.chatId ?? user.platformUserId;
+    const session = input.conversation.create({
+      chatId,
+      ownerUserId: user.id,
+      providerId,
+      cwd
+    });
+    input.events?.emit({ type: "channel.current-session-changed" });
+    const providerLabel = providerId === "codex" ? "Codex" : "Claude Code";
+    try {
+      await input.channel?.sendMessage({
+        chatId,
+        kind: "status",
+        text: `\u5DF2\u65B0\u5EFA ${providerLabel} \u4F1A\u8BDD\uFF0C\u9879\u76EE\u76EE\u5F55\uFF1A${cwd}\u3002`
+      });
+    } catch (error) {
+      request.log.warn({ err: error }, "sessions_new_notify_failed");
+    }
+    return {
+      ok: true,
+      session: {
+        id: session.id,
+        providerId: session.providerId,
+        cwd: session.cwd,
+        status: session.status
+      }
+    };
+  });
+  input.app.post("/api/channel/sessions/auto-attach", async (request, reply) => {
+    const provider = input.providers?.find((candidate) => candidate.id === request.body.providerId);
+    if (!provider?.attachSession || !provider.listRecoverableSessions) {
+      return reply.code(404).send({ ok: false, error: "provider_session_attach_not_supported" });
+    }
+    const user = input.users.isActiveUser(PRIMARY_WEIXIN_PLATFORM, request.body.platformUserId);
+    if (!user) {
+      return reply.code(404).send({ ok: false, error: "active_wechat_user_not_found" });
+    }
+    if (!input.conversation) {
+      return reply.code(500).send({ ok: false, error: "current_conversation_store_unavailable" });
+    }
+    const targetCwd = request.body.cwd ?? input.defaults?.defaultWorkspace ?? process.cwd();
+    const selection = await selectBestRecoverableSession({
+      provider,
+      providerId: request.body.providerId === "codex" ? "codex" : "claude-code",
+      targetCwd,
+      lastProviderSessions: input.lastProviderSessions,
+      currentSession: input.conversation.getCurrent()
+    });
+    if (!selection) {
+      return reply.code(404).send({ ok: false, error: "recoverable_provider_session_not_found" });
+    }
+    const attached = await attachProviderSessionToBridge({
+      conversationStore: input.conversation,
+      lastProviderSessions: input.lastProviderSessions,
+      provider,
+      user,
+      providerId: request.body.providerId === "codex" ? "codex" : "claude-code",
+      providerSessionId: selection.candidate.id,
+      chatId: request.body.chatId ?? user.platformUserId,
+      cwd: request.body.cwd ?? selection.candidate.cwd ?? input.defaults?.defaultWorkspace ?? process.cwd(),
+      recoverySource: selection.bindingSource,
+      resumeTitle: selection.candidate.resumeTitle
+    });
+    return {
+      ok: true,
+      session: {
+        ...attached,
+        bindingMatched: selection.matchedBinding,
+        bindingSource: selection.bindingSource,
+        preferredResumeMode: buildPreferredResumeMode(attached.providerId, attached.resumeTitle),
+        preferredResumeCommand: buildPreferredResumeCommand(attached.providerId, attached.providerSessionId, attached.resumeTitle),
+        providerResumeCommand: buildProviderResumeCommand(attached.providerId, attached.providerSessionId),
+        providerResumeByTitleCommand: buildProviderResumeByTitleCommand(attached.providerId, attached.resumeTitle)
+      }
+    };
+  });
+  input.app.get("/api/channel/current-session", async () => {
+    const session = input.conversation?.getCurrent();
+    if (!session) return null;
+    const provider = input.providers?.find((candidate) => candidate.id === session.providerId);
+    const nativeTitle = session.providerSessionId && provider?.listRecoverableSessions ? (await provider.listRecoverableSessions().catch(() => [])).find((candidate) => candidate.id === session.providerSessionId)?.title : void 0;
+    const providerNativePath = await resolveProviderNativePath(session.providerId, session.providerSessionId);
+    const providerResumeTitleSynced = await resolveProviderResumeTitleSynced(session);
+    const providerResumeHistorySynced = await resolveProviderResumeHistorySynced(session);
+    const binding = input.lastProviderSessions?.get(session.providerId);
+    return {
+      ...session,
+      ...nativeTitle ? { nativeTitle } : {},
+      preferredResumeMode: buildPreferredResumeMode(session.providerId, session.resumeTitle),
+      preferredResumeCommand: buildPreferredResumeCommand(session.providerId, session.providerSessionId, session.resumeTitle),
+      providerResumeCommand: buildProviderResumeCommand(session.providerId, session.providerSessionId),
+      providerResumeByTitleCommand: buildProviderResumeByTitleCommand(session.providerId, session.resumeTitle),
+      bindingMatched: input.getSessionBindingMatch?.(session.id) === true,
+      bindingSource: session.recoverySource,
+      ...binding ? {
+        bindingProviderSessionId: binding.providerSessionId,
+        bindingUpdatedAt: binding.updatedAt
+      } : {},
+      providerNativeReachable: Boolean(providerNativePath),
+      providerResumeTitleSynced,
+      providerResumeHistorySynced,
+      providerResumeRepairable: session.providerId === "claude-code" && Boolean(session.providerSessionId && session.resumeTitle && providerNativePath),
+      ...providerNativePath ? { providerNativePath } : {}
+    };
+  });
+  input.app.get("/api/channel/sessions", async () => {
+    const session = await input.app.inject({ method: "GET", url: "/api/channel/current-session" });
+    if (session.statusCode === 404) return [];
+    const payload = session.json();
+    return payload ? [payload] : [];
+  });
+  input.app.post("/api/channel/settings/sync", async (_request) => {
+    input.conversation?.clear();
+    input.events?.emit({ type: "channel.current-session-changed" });
+    return { ok: true };
+  });
+}
+function toQuotaView(activeUserStore, store) {
+  if (!store) return null;
+  const activeUser = activeUserStore.getActiveUser();
+  if (activeUser?.platform !== PRIMARY_WEIXIN_PLATFORM) return null;
+  const quota = store.getQuota(activeUser.platformUserId);
+  return {
+    remaining: quota.remaining,
+    sentCount: quota.sentCount,
+    limit: PUSH_QUOTA_LIMIT,
+    expired: quota.expired,
+    windowEndsAt: quota.windowStartAt ? quota.windowStartAt + PUSH_WINDOW_MS : 0
+  };
+}
+function toWechatPluginStatus(wechat, activeUserStore, channel) {
+  const health = channel?.getHealth?.();
+  return {
+    id: PRIMARY_WEIXIN_PLATFORM,
+    type: "weixin",
+    name: "WeChat channel",
+    enabled: wechat?.enabled === true,
+    connected: health ? health.connected : wechat?.enabled === true && Boolean(wechat.baseUrl),
+    status: health ? health.status : wechat?.enabled === true ? "configured" : "disabled",
+    ...health?.lastError ? { lastError: health.lastError } : {},
+    activeUsers: activeUserStore.getActiveUser()?.platform === PRIMARY_WEIXIN_PLATFORM ? 1 : 0,
+    hasToken: Boolean(wechat?.token),
+    botUsername: wechat?.accountId
+  };
+}
+function buildProviderResumeCommand(providerId, providerSessionId) {
+  if (!providerSessionId) return void 0;
+  if (providerId === "claude-code") return `claude --resume ${providerSessionId}`;
+  if (providerId === "codex") return `codex resume ${providerSessionId}`;
+  return void 0;
+}
+function buildProviderResumeByTitleCommand(providerId, title) {
+  if (!title) return void 0;
+  if (providerId === "claude-code") return `claude -r ${title}`;
+  if (providerId === "codex") return `codex resume ${title}`;
+  return void 0;
+}
+function buildPreferredResumeCommand(providerId, providerSessionId, title) {
+  return buildProviderResumeByTitleCommand(providerId, title) ?? buildProviderResumeCommand(providerId, providerSessionId);
+}
+function buildPreferredResumeMode(providerId, title) {
+  return buildProviderResumeByTitleCommand(providerId, title) ? "title" : "id";
+}
+async function resolveProviderNativePath(providerId, providerSessionId) {
+  if (!providerSessionId) return null;
+  if (providerId === "claude-code") return await findRecoverableClaudeSessionPath(providerSessionId);
+  if (providerId === "codex") return await findRecoverableCodexSessionPath(providerSessionId);
+  return null;
+}
+async function resolveProviderResumeTitleSynced(session) {
+  if (session.providerId !== "claude-code" || !session.providerSessionId || !session.resumeTitle) return void 0;
+  return await hasClaudeSessionBridgeMetadata({
+    sessionId: session.providerSessionId,
+    resumeTitle: session.resumeTitle
+  });
+}
+async function resolveRecoverableProviderResumeTitleSynced(session) {
+  if (session.providerId !== "claude-code" || !session.resumeTitle) return void 0;
+  return await hasClaudeSessionBridgeMetadata({
+    sessionId: session.id,
+    resumeTitle: session.resumeTitle
+  });
+}
+async function resolveProviderResumeHistorySynced(session) {
+  if (session.providerId !== "claude-code" || !session.providerSessionId || !session.resumeTitle) return void 0;
+  return await hasClaudeHistoryDisplay({
+    sessionId: session.providerSessionId,
+    resumeTitle: session.resumeTitle
+  });
+}
+async function resolveRecoverableProviderResumeHistorySynced(session) {
+  if (session.providerId !== "claude-code" || !session.resumeTitle) return void 0;
+  return await hasClaudeHistoryDisplay({
+    sessionId: session.id,
+    resumeTitle: session.resumeTitle
+  });
+}
+
+// src/admin/settingsRoutes.ts
+function registerSettingsRoutes(input) {
+  input.app.get("/api/settings", async () => input.defaults);
+  input.app.post("/api/settings", async (request) => {
+    const current = { ...input.defaults };
+    const next = normalizeSettings({
+      ...current,
+      ...request.body
+    }, current.defaultWorkspace);
+    input.defaults.defaultProvider = next.defaultProvider;
+    input.defaults.defaultWorkspace = next.defaultWorkspace;
+    await persistBridgeDefaultsToConfigFile({
+      configPath: input.configPath,
+      defaultProvider: next.defaultProvider,
+      defaultWorkspace: next.defaultWorkspace
+    });
+    return { ok: true };
+  });
+}
+function normalizeSettings(input, defaultWorkspace) {
+  return {
+    defaultProvider: input.defaultProvider === "codex" ? "codex" : "claude-code",
+    defaultWorkspace: typeof input.defaultWorkspace === "string" && input.defaultWorkspace.trim() ? input.defaultWorkspace : defaultWorkspace
+  };
+}
+
+// src/channels/weixin-direct/apiClient.ts
+import { randomUUID } from "node:crypto";
+function collectInboundItems(itemList) {
+  const texts = [];
+  const attachments = [];
+  let quoted;
+  for (const item of itemList ?? []) {
+    if (item.type === 1 && item.text_item?.text?.trim()) texts.push(item.text_item.text.trim());
+    else if (item.type === 3 && item.voice_item?.text?.trim()) texts.push(item.voice_item.text.trim());
+    else if (item.type === 2 && item.image_item) attachments.push({ kind: "image", media: item.image_item.media, aeskey: item.image_item.aeskey });
+    else if (item.type === 4 && item.file_item) attachments.push({ kind: "file", media: item.file_item.media, fileName: item.file_item.file_name });
+    else if (item.type === 5 && item.video_item) attachments.push({ kind: "video", media: item.video_item.media });
+    if (item.ref_msg?.message_item) {
+      const inner = collectInboundItems([item.ref_msg.message_item]);
+      const text = [item.ref_msg.title, ...inner.texts].filter(Boolean).join(" ") || void 0;
+      quoted = {
+        ...text ? { text } : {},
+        ...inner.attachments.length ? { attachments: inner.attachments } : {}
+      };
+    }
+  }
+  return { texts, attachments, quoted };
+}
+var WeixinDirectApiClient = class {
+  baseUrl;
+  botToken;
+  wechatUin;
+  channelVersion;
+  fetchImpl;
+  constructor(input) {
+    this.baseUrl = input.baseUrl.replace(/\/+$/, "");
+    this.botToken = input.botToken;
+    this.wechatUin = input.wechatUin;
+    this.channelVersion = input.channelVersion ?? "0.1.0";
+    this.fetchImpl = input.fetchImpl ?? fetch;
+  }
+  async sendTextMessage(input) {
+    const response = await this.fetchImpl(`${this.baseUrl}/ilink/bot/sendmessage`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        AuthorizationType: "ilink_bot_token",
+        Authorization: `Bearer ${this.botToken}`,
+        "X-WECHAT-UIN": this.wechatUin
+      },
+      body: JSON.stringify({
+        msg: {
+          to_user_id: input.toUserId,
+          client_id: randomUUID(),
+          message_type: 2,
+          message_state: 2,
+          item_list: [
+            {
+              type: 1,
+              text_item: {
+                text: input.text
+              }
+            }
+          ],
+          ...input.contextToken ? { context_token: input.contextToken } : {}
+        },
+        base_info: { channel_version: this.channelVersion }
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`weixin_send_message_failed:${response.status}`);
+    }
+    const payload = await response.json();
+    if ((payload.errcode ?? 0) !== 0 || (payload.ret ?? 0) !== 0) {
+      throw new Error(`weixin_send_message_failed:${payload.errcode ?? payload.ret ?? -1}:${payload.errmsg ?? "unknown_error"}`);
+    }
+  }
+  async getUpdates(buffer, signal) {
+    const response = await this.fetchImpl(`${this.baseUrl}/ilink/bot/getupdates`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        AuthorizationType: "ilink_bot_token",
+        Authorization: `Bearer ${this.botToken}`,
+        "X-WECHAT-UIN": this.wechatUin
+      },
+      body: JSON.stringify({
+        get_updates_buf: buffer,
+        base_info: { channel_version: this.channelVersion }
+      }),
+      ...signal ? { signal } : {}
+    });
+    if (!response.ok) {
+      throw new Error(`weixin_get_updates_failed:${response.status}`);
+    }
+    const payload = await response.json();
+    if ((payload.errcode ?? 0) !== 0 || (payload.ret ?? 0) !== 0) {
+      throw new Error(`weixin_get_updates_failed:${payload.errcode ?? payload.ret ?? -1}:${payload.errmsg ?? "unknown_error"}`);
+    }
+    const messages = (payload.msgs ?? []).map((message) => {
+      if (!message.from_user_id) return null;
+      const { texts, attachments, quoted } = collectInboundItems(message.item_list);
+      const text = texts.join("\n\n");
+      if (!text && attachments.length === 0 && !quoted) return null;
+      return {
+        id: message.msg_id ?? "",
+        chatId: message.from_user_id,
+        userId: message.from_user_id,
+        text,
+        ...message.context_token ? { contextToken: message.context_token } : {},
+        ...attachments.length ? { attachments } : {},
+        ...quoted ? { quoted } : {}
+      };
+    }).filter((value) => value !== null);
+    return {
+      nextBuffer: payload.get_updates_buf ?? "",
+      messages
+    };
+  }
+  async getConfig(input) {
+    const response = await this.fetchImpl(`${this.baseUrl}/ilink/bot/getconfig`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        AuthorizationType: "ilink_bot_token",
+        Authorization: `Bearer ${this.botToken}`,
+        "X-WECHAT-UIN": this.wechatUin
+      },
+      body: JSON.stringify({
+        ilink_user_id: input.ilinkUserId,
+        ...input.contextToken ? { context_token: input.contextToken } : {},
+        base_info: { channel_version: this.channelVersion }
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`weixin_get_config_failed:${response.status}`);
+    }
+    const raw = await response.text();
+    const payload = JSON.parse(raw);
+    if ((payload.ret ?? 0) !== 0) {
+      throw new Error(`weixin_get_config_failed:${payload.ret ?? -1}:${payload.errmsg ?? "unknown_error"}`);
+    }
+    return {
+      typingTicket: payload.typing_ticket?.trim() ?? ""
+    };
+  }
+  async sendTyping(input) {
+    const response = await this.fetchImpl(`${this.baseUrl}/ilink/bot/sendtyping`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        AuthorizationType: "ilink_bot_token",
+        Authorization: `Bearer ${this.botToken}`,
+        "X-WECHAT-UIN": this.wechatUin
+      },
+      body: JSON.stringify({
+        ilink_user_id: input.ilinkUserId,
+        typing_ticket: input.typingTicket,
+        status: input.status,
+        base_info: { channel_version: this.channelVersion }
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`weixin_send_typing_failed:${response.status}`);
+    }
+    const payload = await response.json();
+    if ((payload.ret ?? 0) !== 0) {
+      throw new Error(`weixin_send_typing_failed:${payload.ret ?? -1}:${payload.errmsg ?? "unknown_error"}`);
+    }
+  }
+};
+
+// src/channels/weixin-direct/adapter.ts
+import { setTimeout as delay2 } from "node:timers/promises";
+import { join as join6 } from "node:path";
+
+// src/channels/weixin-direct/typingController.ts
+var CONFIG_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var CONFIG_CACHE_INITIAL_RETRY_MS = 2e3;
+var CONFIG_CACHE_MAX_RETRY_MS = 60 * 60 * 1e3;
+var TypingController = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  tickets = /* @__PURE__ */ new Map();
+  chain = /* @__PURE__ */ new Map();
+  disposed = false;
+  set(chatId, active) {
+    if (this.disposed) return Promise.resolve();
+    const previous = this.chain.get(chatId) ?? Promise.resolve();
+    const next = previous.then(
+      () => this.attempt(chatId, active),
+      () => this.attempt(chatId, active)
+    );
+    this.chain.set(chatId, next);
+    next.finally(() => {
+      if (this.chain.get(chatId) === next) this.chain.delete(chatId);
+    });
+    return next;
+  }
+  dispose() {
+    this.disposed = true;
+    this.chain.clear();
+  }
+  async attempt(chatId, active) {
+    if (this.disposed) return;
+    const ticket = await this.getTicket(chatId);
+    if (!ticket || this.disposed) return;
+    try {
+      await this.deps.sendTyping({ ilinkUserId: chatId, typingTicket: ticket, status: active ? 1 : 2 });
+    } catch (err) {
+      this.deps.log?.(`typing send failed (status=${active ? 1 : 2}): ${String(err)}`);
+    }
+  }
+  async getTicket(chatId) {
+    const now = Date.now();
+    const entry = this.tickets.get(chatId);
+    if (entry && now < entry.nextFetchAt) return entry.ticket;
+    try {
+      const config = await this.deps.getConfig({
+        ilinkUserId: chatId,
+        contextToken: this.deps.getContextToken(chatId)
+      });
+      const ticket = config.typingTicket.trim();
+      this.tickets.set(chatId, {
+        ticket,
+        nextFetchAt: now + Math.random() * CONFIG_CACHE_TTL_MS,
+        retryDelayMs: CONFIG_CACHE_INITIAL_RETRY_MS
+      });
+      return ticket;
+    } catch (err) {
+      this.deps.log?.(`getConfig failed for ${chatId}: ${String(err)}`);
+      if (entry) {
+        entry.retryDelayMs = Math.min(entry.retryDelayMs * 2, CONFIG_CACHE_MAX_RETRY_MS);
+        entry.nextFetchAt = now + entry.retryDelayMs;
+        return entry.ticket;
+      }
+      this.tickets.set(chatId, {
+        ticket: "",
+        nextFetchAt: now + CONFIG_CACHE_INITIAL_RETRY_MS,
+        retryDelayMs: CONFIG_CACHE_INITIAL_RETRY_MS
+      });
+      return "";
+    }
+  }
+};
+
+// src/channels/weixin-direct/adapter.ts
+var MAX_TEXT_LENGTH = 4e3;
+var DEFAULT_CHUNK_DELAY_MS = 300;
+var DEDUP_WINDOW_MS = 5 * 6e4;
+var MAX_RETRY_DELAY_MS = 3e4;
+var VIDEO_MAX_BYTES = 25 * 1024 * 1024;
+var WeixinDirectAdapter = class _WeixinDirectAdapter {
+  constructor(options) {
+    this.options = options;
+    const { api } = options;
+    this.typing = api.getConfig && api.sendTyping ? new TypingController({
+      getConfig: (input) => api.getConfig(input),
+      sendTyping: (input) => api.sendTyping(input),
+      getContextToken: (chatId) => this.contextTokens.get(chatId),
+      log: (msg) => console.warn("[weixin][typing]", msg)
+    }) : null;
+  }
+  options;
+  id = "weixin-direct";
+  static SESSION_TIMEOUT_THRESHOLD = 3;
+  handler = null;
+  stopped = true;
+  buffer = "";
+  contextTokens = /* @__PURE__ */ new Map();
+  seenMessageIds = /* @__PURE__ */ new Map();
+  retryDelayMs = 0;
+  typing;
+  runningTask = null;
+  pollAbort = null;
+  healthy = false;
+  lastError = null;
+  consecutiveSessionTimeouts = 0;
+  healthListeners = /* @__PURE__ */ new Set();
+  lastNotifiedStatus = null;
+  onMessage(handler) {
+    this.handler = handler;
+  }
+  onHealthChange(listener) {
+    this.healthListeners.add(listener);
+  }
+  notifyHealthChange() {
+    const status = this.getHealth().status;
+    if (status === this.lastNotifiedStatus) return;
+    this.lastNotifiedStatus = status;
+    for (const listener of this.healthListeners) listener();
+  }
+  async start(input) {
+    if (!this.handler) throw new Error("weixin_direct_handler_not_registered");
+    if (this.options.stateStore) {
+      const persisted = this.options.stateStore.load();
+      for (const [userId, token] of Object.entries(persisted.contextTokens)) {
+        this.contextTokens.set(userId, token);
+      }
+      if (persisted.cursor) this.buffer = persisted.cursor;
+    }
+    this.stopped = false;
+    const loop = this.runLoop();
+    this.runningTask = loop;
+    if (input?.background) return;
+    await loop;
+  }
+  async stop() {
+    this.stopped = true;
+    this.pollAbort?.abort();
+    await this.runningTask;
+    this.runningTask = null;
+    this.typing?.dispose();
+    this.notifyHealthChange();
+  }
+  async sendMessage(message) {
+    const contextToken = this.contextTokens.get(message.chatId);
+    if (!contextToken) {
+      throw new Error(`weixin_no_context_token:${message.chatId}`);
+    }
+    if (this.options.stateStore && !this.options.stateStore.canSend(message.chatId)) {
+      throw new Error(`weixin_push_quota_exceeded:${message.chatId}`);
+    }
+    const chunks = chunkText(message.text ?? "", MAX_TEXT_LENGTH);
+    const chunkDelayMs = this.options.chunkDelayMs ?? DEFAULT_CHUNK_DELAY_MS;
+    for (let i = 0; i < chunks.length; i += 1) {
+      if (i > 0 && chunkDelayMs > 0) await delay2(chunkDelayMs);
+      await this.options.api.sendTextMessage({
+        toUserId: message.chatId,
+        text: chunks[i],
+        contextToken
+      });
+    }
+    this.options.stateStore?.recordSent(message.chatId);
+  }
+  async setTyping(chatId, active) {
+    await this.typing?.set(chatId, active);
+  }
+  getHealth() {
+    if (this.lastError) {
+      const status = this.consecutiveSessionTimeouts >= _WeixinDirectAdapter.SESSION_TIMEOUT_THRESHOLD ? "session_timeout" : "poll_error";
+      return {
+        connected: false,
+        status,
+        lastError: this.lastError
+      };
+    }
+    if (this.healthy) return { connected: true, status: "connected" };
+    if (this.stopped) return { connected: false, status: "stopped" };
+    return { connected: false, status: "connecting" };
+  }
+  async runLoop() {
+    while (!this.stopped) {
+      let updates;
+      try {
+        this.pollAbort = new AbortController();
+        if (!this.healthy && !this.lastError) {
+          this.healthy = true;
+          this.notifyHealthChange();
+        }
+        updates = await this.options.api.getUpdates(this.buffer, this.pollAbort.signal);
+        this.healthy = true;
+        this.lastError = null;
+        this.consecutiveSessionTimeouts = 0;
+        this.retryDelayMs = 0;
+        this.notifyHealthChange();
+      } catch (error) {
+        if (this.stopped) break;
+        this.healthy = false;
+        this.lastError = error instanceof Error ? error.message : String(error);
+        if (this.lastError.includes("session timeout")) this.consecutiveSessionTimeouts += 1;
+        else this.consecutiveSessionTimeouts = 0;
+        this.notifyHealthChange();
+        const base = this.options.pollIntervalMs ?? 1e3;
+        this.retryDelayMs = this.retryDelayMs === 0 ? base : Math.min(this.retryDelayMs * 2, MAX_RETRY_DELAY_MS);
+        await delay2(this.retryDelayMs);
+        continue;
+      }
+      this.buffer = updates.nextBuffer;
+      this.options.stateStore?.setCursor(this.buffer);
+      for (const message of updates.messages) {
+        if (this.isDuplicate(message.id)) continue;
+        if (message.contextToken) {
+          this.contextTokens.set(message.chatId, message.contextToken);
+          this.options.stateStore?.setContextToken(message.chatId, message.contextToken);
+        }
+        const inbound = message;
+        void (async () => {
+          const content = await this.buildIncomingContent(inbound);
+          await this.handler?.({
+            id: inbound.id,
+            platform: PRIMARY_WEIXIN_PLATFORM,
+            chatId: inbound.chatId,
+            user: { id: inbound.userId },
+            content,
+            timestamp: Date.now(),
+            raw: inbound
+          });
+        })().catch((error) => {
+          console.error("[weixin] message handler failed:", error);
+        });
+        if (this.stopped) break;
+      }
+      if (this.stopped) break;
+      await delay2(this.options.pollIntervalMs ?? 1e3);
+    }
+  }
+  async buildIncomingContent(message) {
+    const attachments = await this.downloadAttachments(message.attachments, message.id);
+    let quoted;
+    if (message.quoted) {
+      const quotedAttachments = await this.downloadAttachments(message.quoted.attachments, `${message.id}_q`);
+      quoted = {
+        ...message.quoted.text ? { text: message.quoted.text } : {},
+        ...quotedAttachments.length ? { attachments: quotedAttachments } : {}
+      };
+    }
+    const type = attachments.length === 0 ? "text" : message.text ? "mixed" : attachments[0]?.kind ?? "mixed";
+    return {
+      type,
+      ...message.text ? { text: message.text } : {},
+      ...attachments.length ? { attachments } : {},
+      ...quoted ? { quoted } : {}
+    };
+  }
+  async downloadAttachments(metas, idPrefix) {
+    if (!metas?.length) return [];
+    const downloader = this.options.mediaDownloader;
+    const mediaDir = this.options.mediaDir;
+    const out = [];
+    for (let i = 0; i < metas.length; i += 1) {
+      const meta = metas[i];
+      if (!downloader || !mediaDir) {
+        out.push({ kind: meta.kind, ...meta.fileName ? { fileName: meta.fileName } : {}, failed: true, failReason: "downloader_unavailable" });
+        continue;
+      }
+      const { ext, mimeType } = mediaExtAndMime(meta);
+      const destPath = join6(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) {
+        out.push({ kind: meta.kind, localPath: result.localPath, ...meta.fileName ? { fileName: meta.fileName } : {}, ...mimeType ? { mimeType } : {} });
+      } else {
+        out.push({ kind: meta.kind, ...meta.fileName ? { fileName: meta.fileName } : {}, failed: true, failReason: result.reason });
+      }
+    }
+    return out;
+  }
+  isDuplicate(id) {
+    if (!id) return false;
+    const now = Date.now();
+    for (const [seenId, ts] of this.seenMessageIds) {
+      if (now - ts > DEDUP_WINDOW_MS) this.seenMessageIds.delete(seenId);
+    }
+    if (this.seenMessageIds.has(id)) return true;
+    this.seenMessageIds.set(id, now);
+    return false;
+  }
+};
+function mediaExtAndMime(meta) {
+  if (meta.fileName) {
+    const dot = meta.fileName.lastIndexOf(".");
+    if (dot > 0) return { ext: meta.fileName.slice(dot) };
+  }
+  if (meta.kind === "image") return { ext: ".jpg", mimeType: "image/jpeg" };
+  if (meta.kind === "video") return { ext: ".mp4", mimeType: "video/mp4" };
+  return { ext: ".bin" };
+}
+function chunkText(text, limit) {
+  if (text.length <= limit) return [text];
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    if (remaining.length <= limit) {
+      chunks.push(remaining);
+      break;
+    }
+    let splitAt = -1;
+    const win = remaining.slice(0, limit);
+    const para = win.lastIndexOf("\n\n");
+    if (para > limit * 0.3) splitAt = para + 2;
+    if (splitAt === -1) {
+      const line = win.lastIndexOf("\n");
+      if (line > limit * 0.3) splitAt = line + 1;
+    }
+    if (splitAt === -1) {
+      const space = win.lastIndexOf(" ");
+      if (space > limit * 0.3) splitAt = space + 1;
+    }
+    if (splitAt === -1) splitAt = limit;
+    chunks.push(remaining.slice(0, splitAt));
+    remaining = remaining.slice(splitAt);
+  }
+  return chunks.length > 0 ? chunks : [""];
+}
+
+// src/channels/weixin-direct/mediaDownloader.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname5 } from "node:path";
+
+// src/channels/weixin-direct/mediaCrypto.ts
+import { createDecipheriv } from "node:crypto";
+function decodeAesKey(encoded) {
+  if (/^[0-9a-fA-F]{32}$/.test(encoded)) {
+    return Buffer.from(encoded, "hex");
+  }
+  const decoded = Buffer.from(encoded, "base64");
+  if (decoded.length === 16) {
+    return decoded;
+  }
+  if (decoded.length === 32) {
+    const hex = decoded.toString("ascii");
+    if (/^[0-9a-fA-F]{32}$/.test(hex)) {
+      return Buffer.from(hex, "hex");
+    }
+  }
+  throw new Error(`weixin_media_aes_key_invalid:len=${decoded.length}`);
+}
+function decryptAesEcb(ciphertext, key) {
+  if (key.length !== 16) {
+    throw new Error(`weixin_media_aes_key_size:${key.length}`);
+  }
+  const decipher = createDecipheriv("aes-128-ecb", key, null);
+  return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+}
+
+// src/channels/weixin-direct/mediaDownloader.ts
+var CDN_BASE_URL = "https://novac2c.cdn.weixin.qq.com/c2c";
+var WeixinMediaDownloader = class {
+  cdnBaseUrl;
+  fetchImpl;
+  constructor(options = {}) {
+    this.cdnBaseUrl = (options.cdnBaseUrl ?? CDN_BASE_URL).replace(/\/+$/, "");
+    this.fetchImpl = options.fetchImpl ?? fetch;
+  }
+  async download(media, input) {
+    const url = media.full_url?.trim() || (media.encrypt_query_param ? `${this.cdnBaseUrl}/download?encrypted_query_param=${encodeURIComponent(media.encrypt_query_param)}` : "");
+    if (!url) return { ok: false, reason: "no_url" };
+    const keySource = input.aeskeyOverride ?? media.aes_key;
+    if (!keySource) return { ok: false, reason: "no_key" };
+    let response;
+    try {
+      response = await this.fetchImpl(url, { signal: AbortSignal.timeout(6e4) });
+    } catch {
+      return { ok: false, reason: "fetch_failed" };
+    }
+    if (!response.ok) return { ok: false, reason: `http_${response.status}` };
+    const declaredLen = Number(response.headers.get("content-length") ?? "");
+    if (input.maxBytes && Number.isFinite(declaredLen) && declaredLen > input.maxBytes) {
+      return { ok: false, reason: "too_large" };
+    }
+    const ciphertext = Buffer.from(await response.arrayBuffer());
+    if (input.maxBytes && ciphertext.length > input.maxBytes) {
+      return { ok: false, reason: "too_large" };
+    }
+    let plaintext;
+    try {
+      plaintext = decryptAesEcb(ciphertext, decodeAesKey(keySource));
+    } catch {
+      return { ok: false, reason: "decrypt_failed" };
+    }
+    mkdirSync2(dirname5(input.destPath), { recursive: true });
+    writeFileSync2(input.destPath, plaintext);
+    return { ok: true, localPath: input.destPath, bytes: plaintext.length };
+  }
+};
+
+// src/channels/weixin-direct/managedAdapter.ts
+var ManagedWeixinDirectAdapter = class {
+  id = "weixin-managed";
+  handler = null;
+  adapter = null;
+  running = false;
+  operation = Promise.resolve();
+  healthListeners = /* @__PURE__ */ new Set();
+  stateStore;
+  mediaDir;
+  constructor(initialConfig, stateStore, mediaDir) {
+    this.stateStore = stateStore;
+    this.mediaDir = mediaDir;
+    this.adapter = createWeixinAdapter(initialConfig, stateStore, mediaDir);
+  }
+  onMessage(handler) {
+    this.handler = handler;
+    this.adapter?.onMessage(handler);
+  }
+  onHealthChange(listener) {
+    this.healthListeners.add(listener);
+    this.adapter?.onHealthChange?.(listener);
+  }
+  attachHealthListeners() {
+    if (!this.adapter?.onHealthChange) return;
+    for (const listener of this.healthListeners) this.adapter.onHealthChange(listener);
+  }
+  async start(options) {
+    await this.enqueue(async () => {
+      this.running = true;
+      if (!this.adapter) return;
+      await this.adapter.start(options ?? { background: true });
+    });
+  }
+  async stop() {
+    await this.enqueue(async () => {
+      this.running = false;
+      if (!this.adapter) return;
+      await this.adapter.stop();
+    });
+  }
+  async configure(config) {
+    await this.enqueue(async () => {
+      if (this.adapter) {
+        await this.adapter.stop();
+      }
+      this.adapter = createWeixinAdapter(config, this.stateStore, this.mediaDir);
+      if (this.adapter && this.handler) {
+        this.adapter.onMessage(this.handler);
+      }
+      this.attachHealthListeners();
+      if (this.running && this.adapter) {
+        await this.adapter.start({ background: true });
+      }
+    });
+  }
+  async sendMessage(message) {
+    if (!this.adapter) throw new Error("weixin_channel_not_configured");
+    await this.adapter.sendMessage(message);
+  }
+  async setTyping(chatId, active) {
+    await this.adapter?.setTyping?.(chatId, active);
+  }
+  getHealth() {
+    if (!this.adapter) return { connected: false, status: this.running ? "not_configured" : "disabled" };
+    return this.adapter.getHealth?.() ?? { connected: this.running, status: this.running ? "configured" : "stopped" };
+  }
+  enqueue(task) {
+    const result = this.operation.then(task, task);
+    this.operation = result.then(() => void 0, () => void 0);
+    return result;
+  }
+};
+function createWeixinAdapter(config, stateStore, mediaDir) {
+  if (config?.enabled !== true) return null;
+  if (!config.baseUrl || !config.token) return null;
+  const wechatUin = buildTransientWeixinUin();
+  return new WeixinDirectAdapter({
+    api: new WeixinDirectApiClient({
+      baseUrl: config.baseUrl,
+      botToken: config.token,
+      wechatUin
+    }),
+    stateStore,
+    ...mediaDir ? { mediaDownloader: new WeixinMediaDownloader(), mediaDir } : {}
+  });
+}
+function buildTransientWeixinUin() {
+  const value = new Uint32Array(1);
+  crypto.getRandomValues(value);
+  return Buffer.from(String(value[0])).toString("base64");
+}
+
+// src/channels/weixin-direct/outboundGate.ts
+var CONTINUATION_HINT = "\n\n\uFF08\u6D88\u606F\u8F83\u591A\u672A\u53D1\u5B8C\uFF0C\u8BF7\u56DE\u590D\u4EFB\u610F\u6D88\u606F\u7EE7\u7EED\u63A5\u6536\uFF09";
+var WeixinOutboundGate = class _WeixinOutboundGate {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  hintedReplies = /* @__PURE__ */ new Map();
+  /** The message held back on the final quota slot, pending proof of a follow-up. */
+  pendingLast = /* @__PURE__ */ new Map();
+  static HINT_REPLY_TTL_MS = 2 * 60 * 60 * 1e3;
+  hasPending(chatId) {
+    return this.options.store.hasPendingOutbound(chatId);
+  }
+  shouldInterceptReply(chatId) {
+    const hintedAt = this.hintedReplies.get(chatId);
+    if (!hintedAt) return false;
+    if (Date.now() - hintedAt > _WeixinOutboundGate.HINT_REPLY_TTL_MS) {
+      this.hintedReplies.delete(chatId);
+      return false;
+    }
+    this.hintedReplies.delete(chatId);
+    return true;
+  }
+  async deliver(chatId, message) {
+    const { store } = this.options;
+    const buffered = this.pendingLast.get(chatId);
+    if (buffered) {
+      this.pendingLast.delete(chatId);
+      await this.options.send(chatId, { kind: buffered.kind, text: buffered.text + CONTINUATION_HINT });
+      this.hintedReplies.set(chatId, Date.now());
+      store.enqueueOutbound(chatId, message);
+      return;
+    }
+    if (store.hasPendingOutbound(chatId)) {
+      store.enqueueOutbound(chatId, message);
+      return;
+    }
+    const quota = store.getQuota(chatId);
+    if (quota.expired || quota.remaining <= 0) {
+      store.enqueueOutbound(chatId, message);
+      return;
+    }
+    if (quota.remaining === 1) {
+      this.pendingLast.set(chatId, message);
+      return;
+    }
+    await this.options.send(chatId, message);
+  }
+  /**
+   * Flush any message buffered on the final slot, sent WITHOUT a hint because the
+   * turn ended with no follow-up. Called when a logical batch (a generation or a
+   * command) finishes producing output.
+   */
+  async finalize(chatId) {
+    const buffered = this.pendingLast.get(chatId);
+    if (!buffered) return;
+    this.pendingLast.delete(chatId);
+    await this.options.send(chatId, buffered);
+  }
+  async drain(chatId) {
+    const { store } = this.options;
+    while (store.hasPendingOutbound(chatId)) {
+      const quota = store.getQuota(chatId);
+      if (quota.expired || quota.remaining <= 0) break;
+      const pending = store.peekOutbound(chatId);
+      const next = pending[0];
+      const isLastSlot = quota.remaining === 1;
+      const hasMore = pending.length > 1;
+      if (isLastSlot && hasMore) {
+        await this.options.send(chatId, { kind: next.kind, text: next.text + CONTINUATION_HINT });
+        this.hintedReplies.set(chatId, Date.now());
+        store.shiftOutbound(chatId);
+        break;
+      }
+      await this.options.send(chatId, next);
+      store.shiftOutbound(chatId);
+    }
+    if (!store.hasPendingOutbound(chatId)) this.hintedReplies.delete(chatId);
+  }
+};
+
+// src/providers/claude-code/claudeStreamingRunner.ts
+import { spawn as spawn2 } from "node:child_process";
+import { randomUUID as randomUUID2 } from "node:crypto";
+
+// src/shared/expandTilde.ts
+import { homedir as homedir6 } from "node:os";
+function expandTilde(target) {
+  if (!target) return target;
+  if (target === "~") return homedir6();
+  if (target.startsWith("~/")) return homedir6() + target.slice(1);
+  return target;
+}
+
+// src/shared/platform.ts
+import { access, constants } from "node:fs/promises";
+import { delimiter, join as join7 } from "node:path";
+import { tmpdir } from "node:os";
+import { spawn } from "node:child_process";
+var isWindows = process.platform === "win32";
+async function isExecutableFile(candidate) {
+  try {
+    await access(candidate, isWindows ? constants.F_OK : constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function executableExtensions() {
+  if (!isWindows) return [""];
+  const pathext = process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD";
+  return ["", ...pathext.split(";").filter(Boolean)];
+}
+async function findExecutable(command) {
+  const extensions = executableExtensions();
+  if (command.includes("/") || command.includes("\\")) {
+    for (const ext of extensions) {
+      if (await isExecutableFile(command + ext)) return command + ext;
+    }
+    return void 0;
+  }
+  const dirs = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
+  for (const dir of dirs) {
+    for (const ext of extensions) {
+      const candidate = join7(dir, command + ext);
+      if (await isExecutableFile(candidate)) return candidate;
+    }
+  }
+  return void 0;
+}
+function terminateChild(child, signal = "SIGTERM") {
+  if (child.pid === void 0 || child.exitCode !== null || child.signalCode !== null) {
+    return;
+  }
+  if (isWindows) {
+    try {
+      spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore" });
+      return;
+    } catch {
+    }
+  }
+  try {
+    child.kill(signal);
+  } catch {
+  }
+}
+function defaultWorkspaceDir() {
+  return join7(tmpdir(), "project");
+}
+function statePath(filename) {
+  return join7(tmpdir(), filename);
+}
+
+// src/providers/claude-code/claudeStreamingRunner.ts
+var ClaudeStreamingRunner = class {
+  sessions = /* @__PURE__ */ new Map();
+  command;
+  spawner;
+  constructor(input = {}) {
+    this.command = input.command ?? "claude";
+    this.spawner = input.spawner ?? defaultClaudeStreamSpawner;
+  }
+  async startSession(input) {
+    const resumeId = input.options?.providerSessionId;
+    const session = {
+      bridgeSessionId: input.bridgeSessionId,
+      providerId: "claude-code",
+      providerSessionId: resumeId,
+      claudeSessionId: resumeId,
+      sessionName: input.options?.sessionName,
+      cwd: input.cwd,
+      status: "idle",
+      resumeId,
+      pendingFollowUps: 0
+    };
+    this.sessions.set(input.bridgeSessionId, session);
+    return session;
+  }
+  async *sendMessage(input) {
+    const session = this.sessions.get(input.bridgeSessionId);
+    if (!session) throw new Error(`claude_session_not_found:${input.bridgeSessionId}`);
+    const handle = this.ensureHandle(session);
+    session.pendingFollowUps = 0;
+    handle.write(userEnvelope(input.text));
+    while (true) {
+      const chunk = await handle.read();
+      if (chunk.type === "exit") {
+        session.handle = void 0;
+        yield { type: "error", error: chunk.stderr || `claude stream exited with ${chunk.code}` };
+        return;
+      }
+      const value = parseJsonLine(chunk.line);
+      if (!value) continue;
+      const record = value;
+      const type = record.type;
+      if (type === "user" && record.isReplay === true) continue;
+      if (type === "system" && record.subtype === "init") {
+        const sessionId = typeof record.session_id === "string" ? record.session_id : void 0;
+        if (sessionId) {
+          session.providerSessionId = sessionId;
+          session.claudeSessionId = sessionId;
+          session.resumeId = sessionId;
+          yield {
+            type: "session_state",
+            state: {
+              bridgeSessionId: input.bridgeSessionId,
+              providerId: "claude-code",
+              providerSessionId: sessionId,
+              cwd: session.cwd,
+              status: "running"
+            }
+          };
+        }
+        continue;
+      }
+      if (type === "assistant") {
+        let emitted = false;
+        for (const text of extractAssistantText(record.message)) {
+          yield { type: "text_delta", text };
+          emitted = true;
+        }
+        if (emitted) yield { type: "message_done" };
+        continue;
+      }
+      if (type === "result") {
+        const sessionId = typeof record.session_id === "string" ? record.session_id : void 0;
+        if (sessionId) {
+          session.providerSessionId = sessionId;
+          session.claudeSessionId = sessionId;
+          session.resumeId = sessionId;
+        }
+        yield { type: "message_done" };
+        if (session.pendingFollowUps > 0) {
+          session.pendingFollowUps -= 1;
+          continue;
+        }
+        return;
+      }
+      if (type === "error") {
+        yield { type: "error", error: extractError(record) };
+      }
+    }
+  }
+  // Native steer for Claude = write a follow-up user envelope into the live
+  // process. Claude queues it and processes it as the next turn; the active
+  // sendMessage keeps consuming so its output reaches the channel.
+  async steerSession(bridgeSessionId, text) {
+    const session = this.sessions.get(bridgeSessionId);
+    if (!session?.handle) return;
+    session.handle.write(userEnvelope(text));
+    session.pendingFollowUps += 1;
+  }
+  async interruptSession(bridgeSessionId) {
+    const session = this.sessions.get(bridgeSessionId);
+    session?.handle?.write(`${JSON.stringify({ type: "control_request", request_id: `int_${randomUUID2()}`, request: { subtype: "interrupt" } })}
+`);
+  }
+  async stopSession(bridgeSessionId) {
+    const session = this.sessions.get(bridgeSessionId);
+    session?.handle?.close();
+    this.sessions.delete(bridgeSessionId);
+  }
+  ensureHandle(session) {
+    if (session.handle) return session.handle;
+    const args = buildStreamingArgs(session);
+    session.handle = this.spawner({ command: this.command, args, cwd: session.cwd });
+    return session.handle;
+  }
+};
+function buildStreamingArgs(session) {
+  const args = [
+    "-p",
+    "--input-format",
+    "stream-json",
+    "--output-format",
+    "stream-json",
+    "--include-partial-messages",
+    "--verbose",
+    "--dangerously-skip-permissions",
+    "--replay-user-messages"
+  ];
+  if (session.resumeId) {
+    args.push("--resume", session.resumeId);
+  } else {
+    const minted = randomUUID2();
+    session.resumeId = minted;
+    session.providerSessionId = minted;
+    session.claudeSessionId = minted;
+    args.push("--session-id", minted);
+  }
+  if (session.sessionName) args.push("-n", session.sessionName);
+  return args;
+}
+function userEnvelope(text) {
+  return `${JSON.stringify({ type: "user", message: { role: "user", content: text }, parent_tool_use_id: null })}
+`;
+}
+function extractAssistantText(message) {
+  if (!message || typeof message !== "object") return [];
+  const content = message.content;
+  if (!Array.isArray(content)) return [];
+  return content.flatMap((item) => {
+    if (!item || typeof item !== "object") return [];
+    const record = item;
+    return record.type === "text" && typeof record.text === "string" ? [record.text] : [];
+  });
+}
+function extractError(record) {
+  if (typeof record.message === "string") return record.message;
+  if (record.error && typeof record.error === "object") {
+    const error = record.error;
+    if (typeof error.message === "string") return error.message;
+  }
+  return JSON.stringify(record);
+}
+function parseJsonLine(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+function defaultClaudeStreamSpawner(call) {
+  const child = spawn2(call.command, call.args, { cwd: expandTilde(call.cwd) ?? call.cwd, stdio: ["pipe", "pipe", "pipe"] });
+  let stderr = "";
+  let buffer = "";
+  const queue = [];
+  let resolveNext = null;
+  const push = (chunk) => {
+    const resolve = resolveNext;
+    if (resolve) {
+      resolveNext = null;
+      resolve(chunk);
+    } else {
+      queue.push(chunk);
+    }
+  };
+  child.stdout.on("data", (data) => {
+    buffer += String(data);
+    const parts = buffer.split(/\r?\n/);
+    buffer = parts.pop() ?? "";
+    for (const line of parts) {
+      if (line.trim()) push({ type: "line", line });
+    }
+  });
+  child.stderr.on("data", (data) => {
+    stderr += String(data);
+  });
+  child.on("error", (error) => {
+    push({ type: "exit", code: error.code ?? "ERROR", stderr: stderr || error.message });
+  });
+  child.on("close", (code) => {
+    if (buffer.trim()) push({ type: "line", line: buffer });
+    push({ type: "exit", code: code ?? "SIGNAL", stderr });
+  });
+  return {
+    write(line) {
+      child.stdin.write(line);
+    },
+    read() {
+      const next = queue.shift();
+      if (next) return Promise.resolve(next);
+      return new Promise((resolve) => {
+        resolveNext = resolve;
+      });
+    },
+    close() {
+      try {
+        child.stdin.end();
+      } catch {
+      }
+      terminateChild(child);
+    }
+  };
+}
+
+// src/providers/claude-code/claudeProvider.ts
+var ClaudeCodeProvider = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  id = "claude-code";
+  async startSession(input) {
+    return await this.options.runner.startSession({
+      bridgeSessionId: input.bridgeSessionId,
+      cwd: input.cwd,
+      initialPrompt: input.initialPrompt,
+      options: typeof input.options === "object" && input.options ? {
+        providerSessionId: typeof input.options.providerSessionId === "string" ? input.options.providerSessionId : void 0,
+        sessionName: typeof input.options.sessionName === "string" ? input.options.sessionName : void 0
+      } : void 0
+    });
+  }
+  async *sendMessage(input) {
+    yield* this.options.runner.sendMessage({
+      bridgeSessionId: input.bridgeSessionId,
+      text: input.text
+    });
+  }
+  async stopSession(bridgeSessionId) {
+    await this.options.runner.stopSession(bridgeSessionId);
+  }
+  async interruptSession(bridgeSessionId) {
+    await this.options.runner.interruptSession?.(bridgeSessionId);
+  }
+  async steerSession(bridgeSessionId, text) {
+    await this.options.runner.steerSession?.(bridgeSessionId, text);
+  }
+  async listRecoverableSessions() {
+    return await listRecoverableClaudeSessions();
+  }
+  async attachSession(input) {
+    return await this.options.runner.startSession({
+      bridgeSessionId: input.bridgeSessionId,
+      cwd: input.cwd,
+      options: { providerSessionId: input.candidateId }
+    });
+  }
+};
+
+// src/providers/codex/codexAppServerClient.ts
+import { spawn as spawn3 } from "node:child_process";
+var CodexAppServerClient = class {
+  child;
+  pending = /* @__PURE__ */ new Map();
+  notificationHandlers = /* @__PURE__ */ new Map();
+  requestHandlers = /* @__PURE__ */ new Map();
+  nextId = 1;
+  disposed = false;
+  buffer = "";
+  constructor(input) {
+    const command = input.command ?? "codex";
+    this.child = spawn3(command, ["app-server", "--listen", "stdio://"], {
+      cwd: input.cwd,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.child.stdout.on("data", (chunk) => this.onStdout(String(chunk)));
+    this.child.stderr.on("data", () => {
+    });
+    this.child.on("error", (error) => this.failAll(error instanceof Error ? error : new Error(String(error))));
+    this.child.on("close", (code) => {
+      this.failAll(new Error(`codex_app_server_closed:${code ?? "signal"}`));
+    });
+  }
+  async initialize() {
+    await this.request("initialize", {
+      clientInfo: {
+        name: "claude-codex-wechat",
+        version: "0.1.0"
+      },
+      capabilities: {
+        experimentalApi: true
+      }
+    });
+    await this.notify("initialized");
+  }
+  async request(method, params) {
+    if (this.disposed) throw new Error("codex_app_server_disposed");
+    const id = this.nextId++;
+    const key = String(id);
+    const payload = { id, method, ...params !== void 0 ? { params } : {} };
+    const response = new Promise((resolve, reject) => {
+      this.pending.set(key, { resolve, reject });
+    });
+    this.child.stdin.write(`${JSON.stringify(payload)}
+`);
+    return await response;
+  }
+  async notify(method, params) {
+    if (this.disposed) throw new Error("codex_app_server_disposed");
+    const payload = { method, ...params !== void 0 ? { params } : {} };
+    this.child.stdin.write(`${JSON.stringify(payload)}
+`);
+  }
+  onNotification(method, handler) {
+    const handlers = this.notificationHandlers.get(method) ?? /* @__PURE__ */ new Set();
+    handlers.add(handler);
+    this.notificationHandlers.set(method, handlers);
+    return () => {
+      handlers.delete(handler);
+      if (handlers.size === 0) this.notificationHandlers.delete(method);
+    };
+  }
+  onRequest(method, handler) {
+    this.requestHandlers.set(method, handler);
+    return () => {
+      if (this.requestHandlers.get(method) === handler) {
+        this.requestHandlers.delete(method);
+      }
+    };
+  }
+  async dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    terminateChild(this.child);
+    this.failAll(new Error("codex_app_server_disposed"));
+  }
+  onStdout(chunk) {
+    this.buffer += chunk;
+    for (; ; ) {
+      const newline = this.buffer.indexOf("\n");
+      if (newline === -1) break;
+      const line = this.buffer.slice(0, newline).trim();
+      this.buffer = this.buffer.slice(newline + 1);
+      if (!line) continue;
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      void this.handleMessage(message);
+    }
+  }
+  async handleMessage(message) {
+    if (message.method && message.id !== void 0 && message.id !== null) {
+      const handler = this.requestHandlers.get(message.method);
+      if (!handler) {
+        this.child.stdin.write(`${JSON.stringify({
+          id: message.id,
+          error: { code: -32601, message: `unhandled_method:${message.method}` }
+        })}
+`);
+        return;
+      }
+      try {
+        const result = await handler(message.id, message.params);
+        this.child.stdin.write(`${JSON.stringify({ id: message.id, result })}
+`);
+      } catch (error) {
+        this.child.stdin.write(`${JSON.stringify({
+          id: message.id,
+          error: { code: -32e3, message: error instanceof Error ? error.message : String(error) }
+        })}
+`);
+      }
+      return;
+    }
+    if (message.method) {
+      const handlers = this.notificationHandlers.get(message.method);
+      if (!handlers) return;
+      for (const handler of handlers) handler(message.params);
+      return;
+    }
+    if (message.id === void 0 || message.id === null) return;
+    const key = String(message.id);
+    const pending = this.pending.get(key);
+    if (!pending) return;
+    this.pending.delete(key);
+    if (message.error) {
+      pending.reject(new Error(message.error.message || `codex_app_server_error:${message.error.code ?? "unknown"}`));
+      return;
+    }
+    pending.resolve(message.result);
+  }
+  failAll(error) {
+    if (this.pending.size === 0) return;
+    for (const { reject } of this.pending.values()) reject(error);
+    this.pending.clear();
+  }
+};
+
+// src/providers/codex/codexInteractiveRunner.ts
+function readThreadId(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const record = value;
+  if (typeof record.threadId === "string" && record.threadId) return record.threadId;
+  if (typeof record.id === "string" && record.id) return record.id;
+  if (record.thread && typeof record.thread === "object") {
+    const thread = record.thread;
+    if (typeof thread.threadId === "string" && thread.threadId) return thread.threadId;
+    if (typeof thread.id === "string" && thread.id) return thread.id;
+  }
+  return void 0;
+}
+function readTurnId(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const record = value;
+  if (record.turn && typeof record.turn === "object") {
+    const turn = record.turn;
+    if (typeof turn.id === "string" && turn.id) return turn.id;
+    if (typeof turn.turnId === "string" && turn.turnId) return turn.turnId;
+  }
+  if (typeof record.turnId === "string" && record.turnId) return record.turnId;
+  return void 0;
+}
+var CodexInteractiveRunner = class {
+  sessions = /* @__PURE__ */ new Map();
+  command;
+  syncThreadForResume;
+  constructor(input = {}) {
+    this.command = input.command;
+    this.syncThreadForResume = input.syncThreadForResume ?? syncCodexThreadForResume;
+  }
+  async startSession(input) {
+    const session = {
+      bridgeSessionId: input.bridgeSessionId,
+      providerId: "codex",
+      providerSessionId: input.options?.providerSessionId,
+      threadId: input.options?.providerSessionId,
+      sessionName: input.options?.sessionName,
+      cwd: input.cwd,
+      status: "idle",
+      pendingText: []
+    };
+    this.sessions.set(input.bridgeSessionId, session);
+    return session;
+  }
+  async *sendMessage(input) {
+    const session = this.sessions.get(input.bridgeSessionId);
+    if (!session) throw new Error(`codex_session_not_found:${input.bridgeSessionId}`);
+    const client = await this.ensureClient(session);
+    session.pendingText = [];
+    session.activeTurnId = void 0;
+    session.turnCompletedPromise = new Promise((resolve) => {
+      session.turnCompletedResolver = resolve;
+    });
+    if (session.threadId) {
+      await client.request("thread/resume", {
+        threadId: session.threadId,
+        cwd: session.cwd,
+        persistExtendedHistory: true
+      }).catch(() => void 0);
+    } else {
+      const started = await client.request("thread/start", {
+        cwd: session.cwd,
+        threadSource: "user",
+        persistExtendedHistory: true,
+        experimentalRawEvents: true,
+        sandboxPolicy: { type: "disabled" },
+        approvalMode: "never"
+      });
+      session.threadId = readThreadId(started);
+      session.providerSessionId = session.threadId;
+      if (!session.threadId) throw new Error("codex_app_server_missing_thread_id");
+      yield {
+        type: "session_state",
+        state: {
+          bridgeSessionId: session.bridgeSessionId,
+          providerId: "codex",
+          providerSessionId: session.threadId,
+          cwd: session.cwd,
+          status: "idle"
+        }
+      };
+    }
+    const response = await client.request("turn/start", {
+      threadId: session.threadId,
+      cwd: session.cwd,
+      input: [{ type: "text", text: input.text }]
+    });
+    const maybeTurnId = readTurnId(response);
+    if (maybeTurnId) session.activeTurnId = maybeTurnId;
+    await session.turnCompletedPromise;
+    if (session.threadId) {
+      await this.syncThreadForResume({
+        sessionId: session.threadId,
+        resumeTitle: session.sessionName ?? input.text,
+        cwd: session.cwd
+      });
+    }
+    for (const text of session.pendingText) {
+      yield { type: "text_delta", text };
+    }
+    yield {
+      type: "session_state",
+      state: {
+        bridgeSessionId: session.bridgeSessionId,
+        providerId: "codex",
+        providerSessionId: session.threadId,
+        cwd: session.cwd,
+        status: "idle"
+      }
+    };
+    yield { type: "message_done" };
+  }
+  async stopSession(bridgeSessionId) {
+    const session = this.sessions.get(bridgeSessionId);
+    this.sessions.delete(bridgeSessionId);
+    await session?.client?.dispose();
+  }
+  async interruptTurn(bridgeSessionId) {
+    const session = this.sessions.get(bridgeSessionId);
+    if (!session?.client) return;
+    if (session.threadId && session.activeTurnId) {
+      await session.client.request("turn/interrupt", {
+        threadId: session.threadId,
+        turnId: session.activeTurnId
+      }).catch(() => void 0);
+    }
+    session.turnCompletedResolver?.();
+    session.turnCompletedResolver = void 0;
+  }
+  async steerTurn(bridgeSessionId, text) {
+    const session = this.sessions.get(bridgeSessionId);
+    if (!session?.client || !session.threadId || !session.activeTurnId) return;
+    await session.client.request("turn/steer", {
+      threadId: session.threadId,
+      expectedTurnId: session.activeTurnId,
+      input: [{ type: "text", text }]
+    }).catch(() => void 0);
+  }
+  async ensureClient(session) {
+    if (session.client) return session.client;
+    const client = new CodexAppServerClient({
+      command: this.command,
+      cwd: session.cwd
+    });
+    await client.initialize();
+    client.onNotification("item/agentMessage/delta", (params) => {
+      const record = params;
+      if (typeof record.delta === "string" && record.delta) session.pendingText.push(record.delta);
+    });
+    client.onNotification("turn/started", (params) => {
+      const turnId = readTurnId(params);
+      if (turnId) session.activeTurnId = turnId;
+    });
+    client.onNotification("turn/completed", () => {
+      session.turnCompletedResolver?.();
+      session.turnCompletedResolver = void 0;
+    });
+    client.onRequest("item/commandExecution/requestApproval", async (_id, params) => {
+      return { decision: "approve" };
+    });
+    client.onRequest("item/fileChange/requestApproval", async (_id, params) => {
+      return { decision: "approve" };
+    });
+    session.client = client;
+    return client;
+  }
+};
+
+// src/providers/codex/codexProvider.ts
+var CodexProvider = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  id = "codex";
+  async startSession(input) {
+    return await this.options.runner.startSession({
+      bridgeSessionId: input.bridgeSessionId,
+      cwd: input.cwd,
+      initialPrompt: input.initialPrompt,
+      options: typeof input.options === "object" && input.options ? {
+        providerSessionId: typeof input.options.providerSessionId === "string" ? input.options.providerSessionId : void 0,
+        sessionName: typeof input.options.sessionName === "string" ? input.options.sessionName : void 0
+      } : void 0
+    });
+  }
+  async *sendMessage(input) {
+    yield* this.options.runner.sendMessage({
+      bridgeSessionId: input.bridgeSessionId,
+      text: input.text
+    });
+  }
+  async stopSession(bridgeSessionId) {
+    await this.options.runner.stopSession(bridgeSessionId);
+  }
+  async listRecoverableSessions() {
+    return await listRecoverableCodexSessions();
+  }
+  async attachSession(input) {
+    return await this.options.runner.startSession({
+      bridgeSessionId: input.bridgeSessionId,
+      cwd: input.cwd,
+      options: { providerSessionId: input.candidateId }
+    });
+  }
+  async interruptSession(bridgeSessionId) {
+    await this.options.runner.interruptTurn?.(bridgeSessionId);
+  }
+  async steerSession(bridgeSessionId, text) {
+    await this.options.runner.steerTurn?.(bridgeSessionId, text);
+  }
+};
+
+// src/providers/defaultProviders.ts
+function createDefaultProviders(input = {}) {
+  return [
+    new ClaudeCodeProvider({ runner: new ClaudeStreamingRunner({ command: input.claudeCommand }) }),
+    new CodexProvider({ runner: new CodexInteractiveRunner({ command: input.codexCommand }) })
+  ];
+}
+
+// src/providers/claude-code/claudeDetection.ts
+import { spawn as spawn4 } from "node:child_process";
+async function defaultCommandRunner(command, args) {
+  return await new Promise((resolve) => {
+    const child = spawn4(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", (error) => {
+      resolve({ ok: false, code: error.code ?? "ERROR", stdout, stderr: stderr || error.message });
+    });
+    child.on("close", (code) => {
+      if (code === 0) resolve({ ok: true, stdout, stderr });
+      else resolve({ ok: false, code: code ?? "SIGNAL", stdout, stderr });
+    });
+  });
+}
+function parseClaudeVersion(output) {
+  const match = output.match(/(\d+\.\d+\.\d+(?:[-+][\w.-]+)?)/);
+  return match?.[1] ?? null;
+}
+async function detectClaudeCode(input = {}) {
+  const runner = input.commandRunner ?? defaultCommandRunner;
+  const result = await runner(input.command ?? "claude", ["--version"]);
+  if (!result.ok) {
+    return result.code === "ENOENT" ? { detected: false, reason: "missing_binary" } : { detected: false, reason: "command_failed" };
+  }
+  return { detected: true, version: parseClaudeVersion(`${result.stdout}
+${result.stderr}`) };
+}
+
+// src/providers/codex/codexDetection.ts
+import { spawn as spawn5 } from "node:child_process";
+async function defaultCodexCommandRunner(command, args) {
+  return await new Promise((resolve) => {
+    const child = spawn5(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", (error) => {
+      resolve({ ok: false, code: error.code ?? "ERROR", stdout, stderr: stderr || error.message });
+    });
+    child.on("close", (code) => {
+      if (code === 0) resolve({ ok: true, stdout, stderr });
+      else resolve({ ok: false, code: code ?? "SIGNAL", stdout, stderr });
+    });
+  });
+}
+async function detectCodexCli(input = {}) {
+  const runner = input.commandRunner ?? defaultCodexCommandRunner;
+  const result = await runner(input.command ?? "codex", ["--version"]);
+  if (!result.ok) {
+    return result.code === "ENOENT" ? { detected: false, reason: "missing_binary" } : { detected: false, reason: "command_failed" };
+  }
+  return { detected: true, version: parseCodexVersion(`${result.stdout}
+${result.stderr}`) };
+}
+function parseCodexVersion(output) {
+  const match = output.match(/(\d+\.\d+\.\d+(?:[-+][\w.-]+)?)/);
+  return match?.[1] ?? null;
+}
+
+// src/providers/providerRegistry.ts
+var ProviderRegistry = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  options;
+  async getStatus() {
+    const detectClaude = this.options.detectClaude ?? detectClaudeCode;
+    const detectCodex = this.options.detectCodex ?? detectCodexCli;
+    const checkedAt = this.options.now ? this.options.now() : Date.now();
+    return {
+      claude: {
+        ...await detectClaude({ command: this.options.claudeCommand }),
+        command: this.options.claudeCommand,
+        checkedAt
+      },
+      codex: {
+        ...await detectCodex({ command: this.options.codexCommand }),
+        command: this.options.codexCommand,
+        checkedAt
+      }
+    };
+  }
+};
+
+// src/session/commandParser.ts
+function parseProvider(value) {
+  if (value === "claude" || value === "claude-code") return "claude-code";
+  if (value === "codex") return "codex";
+  return null;
+}
+function looksLikePath(value) {
+  return value.startsWith("/") || value.startsWith("~");
+}
+function parseBridgeCommand(input) {
+  const text = input.trim();
+  if (!text.startsWith("/")) return { kind: "chat", text };
+  const [command, ...rest] = text.split(/\s+/);
+  const first = rest[0];
+  if (command === "/help") return { kind: "help" };
+  if (command === "/status") return { kind: "status" };
+  if (command === "/stop") return { kind: "cancel_generation" };
+  if (command === "/sessions") {
+    if (first === "mine") return { kind: "chat", text };
+    let page = 1;
+    let parts = rest;
+    const last = rest.at(-1);
+    if (last && /^p[1-9]\d*$/i.test(last)) {
+      page = Number.parseInt(last.slice(1), 10);
+      parts = rest.slice(0, -1);
+    }
+    const keyword = parts.join(" ").trim();
+    return { kind: "list_sessions", scope: "all", keyword: keyword || null, page };
+  }
+  if (command === "/resume") {
+    return { kind: "resume_session", ref: first ?? "" };
+  }
+  if (command === "/new") {
+    if (!first) return { kind: "new_session", providerId: null, cwd: null };
+    const colonIndex = first.indexOf(":");
+    if (colonIndex !== -1) {
+      const providerId2 = parseProvider(first.slice(0, colonIndex));
+      const cwd = first.slice(colonIndex + 1);
+      if (providerId2 && looksLikePath(cwd)) return { kind: "new_session", providerId: providerId2, cwd };
+      return { kind: "chat", text };
+    }
+    const providerId = parseProvider(first);
+    if (providerId) return { kind: "new_session", providerId, cwd: null };
+    if (looksLikePath(first)) return { kind: "new_session", providerId: null, cwd: first };
+    return { kind: "chat", text };
+  }
+  return { kind: "chat", text };
+}
+
+// src/shared/bridgeCommandHelp.ts
+var BRIDGE_COMMAND_HELP_INTRO = "\u76F4\u63A5\u53D1\u9001\u6587\u5B57\u5373\u53EF\u4E0E AI \u5BF9\u8BDD\u3002";
+var BRIDGE_COMMAND_HELP_GROUPS = [
+  {
+    title: "\u4F1A\u8BDD\u7BA1\u7406",
+    entries: [
+      { command: "/help", desc: "\u663E\u793A\u672C\u5E2E\u52A9" },
+      { command: "/status", desc: "\u67E5\u770B\u5F53\u524D\u4F1A\u8BDD\uFF08provider\u3001\u5DE5\u4F5C\u76EE\u5F55\u3001\u72B6\u6001\uFF09" },
+      { command: "/new", desc: "\u65B0\u5EFA\u9ED8\u8BA4 provider \u4F1A\u8BDD" },
+      { command: "/new claude|codex", desc: "\u65B0\u5EFA\u6307\u5B9A provider \u4F1A\u8BDD" },
+      { command: "/new <\u76EE\u5F55>", desc: "\u5728\u6307\u5B9A\u76EE\u5F55\u65B0\u5EFA\u9ED8\u8BA4 provider \u4F1A\u8BDD" },
+      { command: "/new claude:<\u76EE\u5F55>", desc: "\u65B0\u5EFA\u6307\u5B9A provider + \u6307\u5B9A\u76EE\u5F55\u4F1A\u8BDD" },
+      { command: "/stop", desc: "\u4E2D\u65AD\u5F53\u524D\u6B63\u5728\u751F\u6210\u7684\u56DE\u590D\uFF08\u4F1A\u8BDD\u4FDD\u7559\uFF09" }
+    ]
+  },
+  {
+    title: "\u5386\u53F2\u4F1A\u8BDD",
+    entries: [
+      { command: "/sessions", desc: "\u5217\u51FA\u6700\u8FD1\u7684\u5386\u53F2\u4F1A\u8BDD\u7B2C 1 \u9875\uFF08\u6309\u66F4\u65B0\u65F6\u95F4\u5012\u5E8F\uFF09" },
+      { command: "/sessions p2", desc: "\u67E5\u770B\u7B2C 2 \u9875\uFF1B\u9875\u7801\u8BED\u6CD5\u56FA\u5B9A\u4E3A `p<number>`" },
+      { command: "/sessions <\u5173\u952E\u8BCD>", desc: "\u6309\u6807\u9898/\u76EE\u5F55\u7B5B\u9009\uFF0C\u7B2C 1 \u9875" },
+      { command: "/sessions <\u5173\u952E\u8BCD> p2", desc: "\u67E5\u770B\u7B5B\u9009\u7ED3\u679C\u7684\u7B2C 2 \u9875" },
+      { command: "/resume <\u7F16\u53F7>", desc: "\u6309 /sessions \u5217\u8868\u7F16\u53F7\u6062\u590D\uFF08\u4E5F\u53EF\u76F4\u63A5\u7528\u4F1A\u8BDD id\uFF09" }
+    ]
+  }
+];
+function buildBridgeCommandHelpMarkdown() {
+  const lines = ["**\u53EF\u7528\u547D\u4EE4**", "", BRIDGE_COMMAND_HELP_INTRO];
+  for (const group of BRIDGE_COMMAND_HELP_GROUPS) {
+    lines.push("", `**${group.title}**${group.note ? `\uFF08${group.note}\uFF09` : ""}`);
+    for (const entry of group.entries) {
+      lines.push(`- \`${entry.command}\` \u2014 ${entry.desc}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/session/currentConversationStore.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname6 } from "node:path";
+import { nanoid as nanoid2 } from "nanoid";
+var CurrentConversationStore = class {
+  constructor(configPath, defaults) {
+    this.configPath = configPath;
+    this.defaults = defaults;
+  }
+  configPath;
+  defaults;
+  getCurrent() {
+    return this.readState().bridge?.activeWeChatUser?.currentConversation ?? null;
+  }
+  getActiveSession(chatId) {
+    const current = this.getCurrent();
+    return current?.chatId === chatId ? current : null;
+  }
+  listSessions() {
+    const current = this.getCurrent();
+    return current ? [current] : [];
+  }
+  create(input) {
+    const now = Date.now();
+    const record = {
+      id: `bs_${nanoid2(10)}`,
+      chatId: input.chatId,
+      ownerUserId: input.ownerUserId,
+      providerId: input.providerId ?? this.defaults.defaultProviderId,
+      cwd: input.cwd ?? this.defaults.defaultCwd,
+      recoverySource: input.recoverySource ?? "runtime",
+      resumeTitle: input.resumeTitle,
+      status: "starting",
+      createdAt: now,
+      lastActivityAt: now
+    };
+    this.writeCurrent(record);
+    return record;
+  }
+  setCurrent(record) {
+    this.writeCurrent(record);
+    return record;
+  }
+  update(patch, expectId) {
+    const existing = this.getCurrent();
+    if (!existing) return null;
+    if (expectId && existing.id !== expectId) return null;
+    const next = { ...existing, ...patch };
+    this.writeCurrent(next);
+    return next;
+  }
+  clear() {
+    const state = this.readState();
+    const activeWeChatUser = state.bridge?.activeWeChatUser;
+    state.bridge = {
+      ...state.bridge ?? {},
+      activeWeChatUser: activeWeChatUser ? { ...activeWeChatUser, currentConversation: void 0 } : void 0
+    };
+    this.writeState(state);
+  }
+  readState() {
+    if (!existsSync5(this.configPath)) return {};
+    const raw = JSON.parse(readFileSync3(this.configPath, "utf8"));
+    return raw && typeof raw === "object" ? raw : {};
+  }
+  writeCurrent(record) {
+    const normalized = { ...record, cwd: expandTilde(record.cwd) ?? record.cwd };
+    const state = this.readState();
+    const activeWeChatUser = state.bridge?.activeWeChatUser;
+    state.bridge = {
+      ...state.bridge ?? {},
+      activeWeChatUser: activeWeChatUser ? { ...activeWeChatUser, currentConversation: normalized } : {
+        id: `user_${nanoid2(10)}`,
+        platform: "weixin",
+        platformUserId: normalized.chatId,
+        role: "user",
+        createdAt: normalized.createdAt,
+        updatedAt: normalized.lastActivityAt,
+        currentConversation: normalized
+      }
+    };
+    this.writeState(state);
+  }
+  writeState(state) {
+    mkdirSync3(dirname6(this.configPath), { recursive: true });
+    writeFileSync3(this.configPath, `${JSON.stringify(state, null, 2)}
+`, "utf8");
+  }
+};
+
+// src/session/messageRouter.ts
+var MessageRouter = class _MessageRouter {
+  constructor(options) {
+    this.options = options;
+    for (const provider of options.providers) this.providers.set(provider.id, provider);
+    if (!this.options.conversation) {
+      const fallbackSessions = this.options.sessions;
+      this.options.conversation = fallbackSessions?.store ? fallbackSessions.store : new CurrentConversationStore(statePath("claude-codex-wechat-message-router.json"), {
+        defaultCwd: defaultWorkspaceDir(),
+        defaultProviderId: "claude-code"
+      });
+    }
+  }
+  options;
+  static SESSION_LIST_LIMIT = 8;
+  providers = /* @__PURE__ */ new Map();
+  sessionListCache = /* @__PURE__ */ new Map();
+  // Single global lock: the bridge stores one current conversation, so every
+  // session-mutating operation (chat generation + state-changing commands) must
+  // run one at a time. /stop and read-only commands bypass this lock.
+  sessionOpChain = Promise.resolve();
+  // Commands run on their own chain, independent of sessionOpChain, so a hung
+  // generation can never block /new, /stop, etc.
+  commandChain = Promise.resolve();
+  generationSeq = 0;
+  // 每条消息到达时按顺序分配一个全局序号；latestMutatingSeq 记录每个 chat
+  // 最近一次会话变更命令的序号。聊天用它判断自己是否已被更晚到达的命令取代，
+  // 从而消除「命令从 commandChain 插队到排队中的聊天前面」导致的串话。
+  opSeq = 0;
+  latestMutatingSeq = /* @__PURE__ */ new Map();
+  activeGenerations = /* @__PURE__ */ new Map();
+  get conversation() {
+    return this.options.conversation;
+  }
+  /**
+   * Single outbound exit. With a quota gate (WeChat), messages flow through it
+   * (sent now, hinted, or queued). Without a gate, sent directly.
+   */
+  async sendToChat(message) {
+    if (this.options.outboundGate) {
+      await this.options.outboundGate.deliver(message.chatId, { kind: message.kind, text: message.text });
+    } else {
+      await this.options.channel.sendMessage(message);
+    }
+  }
+  conversationSignature() {
+    const current = this.conversation.getCurrent();
+    if (!current) return "";
+    return `${current.id}|${current.providerId}|${current.providerSessionId ?? ""}|${current.cwd}|${current.status}`;
+  }
+  async withSessionChangeNotification(run) {
+    const before = this.conversationSignature();
+    try {
+      return await run();
+    } finally {
+      if (this.conversationSignature() !== before) {
+        this.options.events?.emit({ type: "channel.current-session-changed" });
+      }
+    }
+  }
+  async handleMessage(message) {
+    return this.withSessionChangeNotification(() => this.handleMessageInner(message));
+  }
+  async handleMessageInner(message) {
+    let user = this.options.resolveUser(message);
+    if (!user) {
+      user = this.options.autoAuthorizeUser?.(message) ?? null;
+    }
+    if (!user) {
+      return { status: "pairing_required", code: "pairing_required" };
+    }
+    if (this.options.outboundGate?.hasPending(message.chatId)) {
+      await this.options.outboundGate.drain(message.chatId);
+      return { status: "accepted" };
+    }
+    if (this.options.outboundGate?.shouldInterceptReply?.(message.chatId)) {
+      return { status: "accepted" };
+    }
+    const composedText = composeInboundText(message.content);
+    if (!composedText) return { status: "accepted" };
+    const isPlainText = message.content.type === "text" && !message.content.attachments?.length && !message.content.quoted;
+    const command = isPlainText ? parseBridgeCommand(message.content.text ?? "") : { kind: "chat", text: composedText };
+    const seq = ++this.opSeq;
+    if (command.kind !== "chat") {
+      if (!isImmediateCommand(command.kind)) {
+        this.latestMutatingSeq.set(message.chatId, seq);
+      }
+      const runWithTyping = async () => {
+        await this.options.channel.setTyping?.(message.chatId, true);
+        try {
+          await this.handleCommand(message.chatId, user, command);
+        } finally {
+          await Promise.resolve(this.options.outboundGate?.finalize?.(message.chatId)).catch(() => void 0);
+          await this.options.channel.setTyping?.(message.chatId, false);
+        }
+      };
+      if (isImmediateCommand(command.kind)) {
+        await runWithTyping();
+      } else {
+        await this.runOnCommandChain(runWithTyping);
+      }
+      return { status: "accepted" };
+    }
+    if ((this.latestMutatingSeq.get(message.chatId) ?? 0) > seq) {
+      return { status: "accepted" };
+    }
+    if (await this.maybeSteer(message.chatId, command.text)) {
+      return { status: "accepted" };
+    }
+    await this.runExclusive(() => this.runChatGeneration(message, user, command.text, seq));
+    return { status: "accepted" };
+  }
+  // A chat message arriving while a turn is in flight: if the provider supports
+  // native steer (Codex turn/steer), inject it into the running turn instead of
+  // queueing a new turn. Otherwise fall back to the serialized lock (queue).
+  maybeSteer(chatId, text) {
+    const active = this.activeGenerations.get(chatId);
+    if (!active) return Promise.resolve(false);
+    const provider = this.providers.get(active.providerId);
+    if (!provider?.steerSession) return Promise.resolve(false);
+    return provider.steerSession(active.bridgeSessionId, text).then(() => true);
+  }
+  // Serialize session-mutating work onto one global chain. The chain is updated
+  // synchronously (no await before the assignment) so two non-blocking channel
+  // dispatches enqueue in arrival order without racing.
+  runExclusive(run) {
+    const result = this.sessionOpChain.then(() => run());
+    this.sessionOpChain = result.then(() => void 0, () => void 0);
+    return result;
+  }
+  // Commands serialize among themselves on a chain that is independent of the
+  // generation chain, so they never wait behind a (possibly hung) generation.
+  runOnCommandChain(run) {
+    const result = this.commandChain.then(() => run());
+    this.commandChain = result.then(() => void 0, () => void 0);
+    return result;
+  }
+  // Abandon the live generation for a chat before a command swaps/clears the
+  // current session. Signalling abort makes the generation loop release
+  // sessionOpChain immediately even if the provider can't be interrupted (a hung
+  // CLI or a provider without interruptSession), so later chats never queue
+  // forever behind it. Interrupting the provider is then best-effort cleanup.
+  async preemptActiveGeneration(chatId) {
+    const active = this.activeGenerations.get(chatId);
+    if (!active) return;
+    this.activeGenerations.delete(chatId);
+    active.abort();
+    void Promise.resolve(this.providers.get(active.providerId)?.interruptSession?.(active.bridgeSessionId)).catch(() => void 0);
+  }
+  async runChatGeneration(message, user, text, seq) {
+    const superseded = () => (this.latestMutatingSeq.get(message.chatId) ?? 0) > seq;
+    if (superseded()) return;
+    const sessionResumeTitle = buildSessionBridgeName({
+      platform: "weixin",
+      platformUserId: message.user.id,
+      chatId: message.chatId,
+      summary: resumeTitleFromContent(message.content)
+    });
+    let session = this.conversation.getCurrent();
+    if (!session) {
+      if (superseded()) return;
+      const attached = await this.options.autoAttachSession?.(message, user, { shouldCommit: () => !superseded() });
+      if (superseded()) return;
+      session = this.conversation.getCurrent() ?? attached ?? this.conversation.create({
+        chatId: message.chatId,
+        ownerUserId: user.id,
+        ...this.options.defaults?.defaultProvider ? { providerId: this.options.defaults.defaultProvider } : {},
+        ...this.options.defaults?.defaultWorkspace ? { cwd: this.options.defaults.defaultWorkspace } : {},
+        resumeTitle: sessionResumeTitle
+      });
+    }
+    const provider = this.providers.get(session.providerId);
+    if (!provider) throw new Error(`provider_not_registered:${session.providerId}`);
+    if (!session.providerSessionId) {
+      const resumeTitle = session.resumeTitle ?? sessionResumeTitle;
+      this.conversation.update({
+        resumeTitle,
+        lastActivityAt: Date.now()
+      }, session.id);
+      const providerSession = await provider.startSession({
+        bridgeSessionId: session.id,
+        cwd: session.cwd,
+        options: {
+          sessionName: resumeTitle
+        }
+      });
+      const updated = this.conversation.update({
+        providerSessionId: providerSession.providerSessionId,
+        resumeTitle,
+        status: providerSession.status,
+        lastActivityAt: Date.now()
+      }, session.id) ?? session;
+      if (updated.providerId === "codex" && updated.providerSessionId && updated.resumeTitle) {
+        await upsertCodexSessionIndexEntry({
+          sessionId: updated.providerSessionId,
+          threadName: updated.resumeTitle
+        });
+      }
+      await this.persistBridgeMetadata(updated);
+    }
+    const genId = ++this.generationSeq;
+    let abortGeneration;
+    const aborted = new Promise((resolve) => {
+      abortGeneration = () => resolve("aborted");
+    });
+    this.activeGenerations.set(message.chatId, {
+      genId,
+      providerId: session.providerId,
+      bridgeSessionId: session.id,
+      abort: abortGeneration
+    });
+    const isLive = () => this.activeGenerations.get(message.chatId)?.genId === genId && (this.latestMutatingSeq.get(message.chatId) ?? 0) <= seq;
+    let bufferedText = "";
+    const typingMinIntervalMs = this.options.typingKeepaliveMs ?? 5e3;
+    let lastTypingAt = Date.now();
+    await this.options.channel.setTyping?.(message.chatId, true);
+    const refreshTyping = () => {
+      const now = Date.now();
+      if (now - lastTypingAt < typingMinIntervalMs) return;
+      lastTypingAt = now;
+      void this.options.channel.setTyping?.(message.chatId, true);
+    };
+    let iterator = null;
+    try {
+      iterator = provider.sendMessage({ bridgeSessionId: session.id, text })[Symbol.asyncIterator]();
+      while (isLive()) {
+        const step = await Promise.race([iterator.next(), aborted]);
+        if (step === "aborted" || step.done) break;
+        if (!isLive()) break;
+        refreshTyping();
+        const event = step.value;
+        if (event.type === "text_delta" && event.text) {
+          bufferedText += event.text;
+        }
+        if (event.type === "message_done" && bufferedText.trim()) {
+          await this.sendToChat({ chatId: message.chatId, kind: "text", text: bufferedText });
+          bufferedText = "";
+        }
+        if (event.type === "session_state") {
+          const updated = this.conversation.update({
+            providerSessionId: event.state.providerSessionId,
+            status: event.state.status,
+            lastActivityAt: Date.now()
+          }, session.id) ?? session;
+          if (updated.providerId === "codex" && updated.providerSessionId && updated.resumeTitle) {
+            await upsertCodexSessionIndexEntry({
+              sessionId: updated.providerSessionId,
+              threadName: updated.resumeTitle
+            });
+          }
+          await this.persistBridgeMetadata(updated);
+        }
+        if (event.type === "error" && event.error) {
+          if (bufferedText.trim()) {
+            await this.sendToChat({ chatId: message.chatId, kind: "text", text: bufferedText });
+            bufferedText = "";
+          }
+          const errorText = `Provider error: ${event.error}`;
+          await this.sendToChat({
+            chatId: message.chatId,
+            kind: "status",
+            text: errorText
+          });
+        }
+      }
+      if (isLive() && bufferedText.trim()) {
+        await this.sendToChat({ chatId: message.chatId, kind: "text", text: bufferedText });
+        bufferedText = "";
+      }
+      if (isLive()) {
+        const finalBinding = this.conversation.getCurrent();
+        if (finalBinding?.id === session.id && finalBinding.providerSessionId) {
+          await this.persistBridgeMetadata(finalBinding).catch(() => void 0);
+        }
+      }
+    } finally {
+      void iterator?.return?.().catch(() => void 0);
+      const stillMine = this.activeGenerations.get(message.chatId)?.genId === genId;
+      if (stillMine) this.activeGenerations.delete(message.chatId);
+      await Promise.resolve(this.options.outboundGate?.finalize?.(message.chatId)).catch(() => void 0);
+      if (stillMine) await this.options.channel.setTyping?.(message.chatId, false);
+    }
+  }
+  async handleCommand(chatId, user, command) {
+    if (command.kind === "help") {
+      await this.sendToChat({
+        chatId,
+        kind: "markdown",
+        text: buildBridgeCommandHelpMarkdown()
+      });
+      return;
+    }
+    if (command.kind === "cancel_generation") {
+      const active = this.activeGenerations.get(chatId);
+      if (!active) {
+        await this.sendToChat({ chatId, kind: "status", text: "\u5F53\u524D\u6CA1\u6709\u6B63\u5728\u8FDB\u884C\u7684\u751F\u6210" });
+        return;
+      }
+      const provider = this.providers.get(active.providerId);
+      if (!provider?.interruptSession) {
+        await this.sendToChat({ chatId, kind: "status", text: `${active.providerId} \u6682\u4E0D\u652F\u6301\u4E2D\u65AD` });
+        return;
+      }
+      await provider.interruptSession(active.bridgeSessionId);
+      await this.sendToChat({ chatId, kind: "status", text: "\u5DF2\u4E2D\u65AD\u5F53\u524D\u751F\u6210\uFF0C\u4F1A\u8BDD\u4FDD\u7559" });
+      return;
+    }
+    if (command.kind === "new_session") {
+      await this.preemptActiveGeneration(chatId);
+      const providerId = command.providerId ?? this.options.defaults?.defaultProvider ?? "claude-code";
+      const cwd = command.cwd ?? this.conversation.getCurrent()?.cwd ?? this.options.defaults?.defaultWorkspace ?? defaultWorkspaceDir();
+      const session = this.conversation.create({
+        chatId,
+        ownerUserId: user.id,
+        providerId,
+        cwd
+      });
+      await this.sendToChat({
+        chatId,
+        kind: "status",
+        text: `Started new ${providerId} session: ${session.id}`
+      });
+      return;
+    }
+    if (command.kind === "status") {
+      const session = this.conversation.getCurrent();
+      await this.sendToChat({
+        chatId,
+        kind: "status",
+        text: session ? `Active session ${session.id} \xB7 ${session.providerId} \xB7 ${session.cwd} \xB7 ${session.status}` : "No active session"
+      });
+      return;
+    }
+    if (command.kind === "list_sessions") {
+      const current = this.conversation.getCurrent();
+      const providerId = current?.providerId ?? this.options.defaults?.defaultProvider ?? "claude-code";
+      const provider = this.providers.get(providerId);
+      if (!provider?.listRecoverableSessions) {
+        await this.sendToChat({ chatId, kind: "status", text: `\u5F53\u524D provider\uFF08${providerId}\uFF09\u4E0D\u652F\u6301\u4F1A\u8BDD\u5217\u8868` });
+        return;
+      }
+      let candidates = await listUnattachedRecoverableSessions({ provider, providerId, currentSession: current });
+      if (command.keyword) {
+        const keyword = command.keyword.toLowerCase();
+        candidates = candidates.filter(
+          (candidate) => (candidate.resumeTitle ?? candidate.title ?? "").toLowerCase().includes(keyword) || (candidate.cwd ?? "").toLowerCase().includes(keyword)
+        );
+      }
+      candidates.sort((a, b) => (b.lastActivityAt ?? 0) - (a.lastActivityAt ?? 0));
+      const totalPages = Math.max(1, Math.ceil(candidates.length / _MessageRouter.SESSION_LIST_LIMIT));
+      const page = Math.min(command.page, totalPages);
+      const start = (page - 1) * _MessageRouter.SESSION_LIST_LIMIT;
+      const shown = candidates.slice(start, start + _MessageRouter.SESSION_LIST_LIMIT);
+      if (shown.length === 0) {
+        await this.sendToChat({ chatId, kind: "status", text: "\u6CA1\u6709\u53EF\u6062\u590D\u7684\u4F1A\u8BDD" });
+        return;
+      }
+      this.sessionListCache.set(chatId, { providerId, ids: shown.map((candidate) => candidate.id) });
+      const lines = [`**\u53EF\u6062\u590D\u4F1A\u8BDD\uFF08${providerId}\uFF09**`, `\u7B2C ${page}/${totalPages} \u9875`, ""];
+      shown.forEach((candidate, index) => {
+        lines.push(`${index + 1}. ${this.formatSessionLine(candidate)}`);
+      });
+      if (page < totalPages) {
+        const nextPageCommand = command.keyword ? `/sessions ${command.keyword} p${page + 1}` : `/sessions p${page + 1}`;
+        lines.push("", `\u56DE\u590D \`${nextPageCommand}\` \u67E5\u770B\u4E0B\u4E00\u9875`);
+      } else if (candidates.length > shown.length) {
+        lines.push("", `\uFF08\u8FD8\u6709 ${candidates.length - shown.length} \u6761\uFF0C\u7528 \`/sessions <\u5173\u952E\u8BCD>\` \u7B5B\u9009\uFF09`);
+      }
+      lines.push("", "\u56DE\u590D `/resume <\u7F16\u53F7>` \u6062\u590D");
+      await this.sendToChat({ chatId, kind: "markdown", text: lines.join("\n") });
+      return;
+    }
+    if (command.kind === "resume_session") {
+      const ref = command.ref.trim();
+      if (!ref) {
+        await this.sendToChat({ chatId, kind: "status", text: "\u7528\u6CD5\uFF1A/resume <\u7F16\u53F7>" });
+        return;
+      }
+      await this.preemptActiveGeneration(chatId);
+      let providerId = this.conversation.getCurrent()?.providerId ?? this.options.defaults?.defaultProvider ?? "claude-code";
+      let resolvedId = ref;
+      if (/^\d+$/.test(ref)) {
+        const cached = this.sessionListCache.get(chatId);
+        if (!cached) {
+          await this.sendToChat({ chatId, kind: "status", text: "\u8BF7\u5148\u7528 /sessions \u5217\u51FA\u4F1A\u8BDD\uFF0C\u518D\u7528 /resume <\u7F16\u53F7> \u6062\u590D" });
+          return;
+        }
+        const target = cached.ids[Number(ref) - 1];
+        if (!target) {
+          await this.sendToChat({ chatId, kind: "status", text: `\u7F16\u53F7 ${ref} \u8D85\u51FA\u8303\u56F4\uFF0C\u8BF7\u7528 /sessions \u91CD\u65B0\u5217\u51FA` });
+          return;
+        }
+        resolvedId = target;
+        providerId = cached.providerId;
+      }
+      const previousCwd = this.conversation.getCurrent()?.cwd;
+      const provider = this.providers.get(providerId);
+      if (!provider?.attachSession || !provider.listRecoverableSessions) {
+        await this.sendToChat({ chatId, kind: "status", text: `\u5F53\u524D provider\uFF08${providerId}\uFF09\u4E0D\u652F\u6301\u4F1A\u8BDD\u6062\u590D` });
+        return;
+      }
+      const candidate = (await provider.listRecoverableSessions()).find((item) => item.id === resolvedId);
+      if (!candidate) {
+        await this.sendToChat({ chatId, kind: "status", text: `\u627E\u4E0D\u5230\u4F1A\u8BDD ${ref}` });
+        return;
+      }
+      const cwdUnresolved = !candidate.cwd;
+      const attached = await attachProviderSessionToBridge({
+        conversationStore: this.conversation,
+        lastProviderSessions: this.options.lastProviderSessions,
+        provider,
+        user,
+        providerId,
+        providerSessionId: resolvedId,
+        chatId,
+        cwd: candidate.cwd ?? this.options.defaults?.defaultWorkspace ?? defaultWorkspaceDir(),
+        recoverySource: "manual_attach",
+        resumeTitle: candidate.resumeTitle
+      });
+      const head = `\u5DF2\u6062\u590D\u4F1A\u8BDD ${attached.id} \xB7 ${attached.providerId}`;
+      const text = cwdUnresolved ? `${head}
+\u26A0\uFE0F \u65E0\u6CD5\u786E\u5B9A\u8BE5\u4F1A\u8BDD\u7684\u539F\u59CB\u76EE\u5F55\uFF0C\u5DF2\u4F7F\u7528\u9ED8\u8BA4\u76EE\u5F55 ${attached.cwd}\uFF0C\u5982\u9700\u5207\u6362\u8BF7\u7528 /new <\u76EE\u5F55> \u5F00\u65B0\u4F1A\u8BDD` : previousCwd && previousCwd !== attached.cwd ? `${head}
+\u5DF2\u5207\u6362\u5DE5\u4F5C\u76EE\u5F55\u5230 ${attached.cwd}` : `${head} \xB7 ${attached.cwd}`;
+      await this.sendToChat({ chatId, kind: "status", text });
+      return;
+    }
+  }
+  formatSessionLine(candidate) {
+    const title = candidate.resumeTitle ?? candidate.title ?? candidate.id;
+    const cwd = candidate.cwd ? ` \xB7 ${candidate.cwd}` : "";
+    const when = candidate.lastActivityAt ? ` \xB7 ${formatRelativeTime(candidate.lastActivityAt)}` : "";
+    return `${title}${cwd}${when}`;
+  }
+  async persistBridgeMetadata(session) {
+    if (!session.providerSessionId || !session.resumeTitle) return;
+    this.options.lastProviderSessions?.set(session.providerId, {
+      providerSessionId: session.providerSessionId,
+      cwd: session.cwd
+    });
+    if (session.providerId === "claude-code") {
+      await ensureClaudeSessionBridgeMetadata({
+        sessionId: session.providerSessionId,
+        resumeTitle: session.resumeTitle,
+        cwd: session.cwd
+      });
+    }
+  }
+};
+function summarizeResumeTitle(text) {
+  const normalized = text.replace(/\s+/g, " ").trim();
+  if (!normalized) return void 0;
+  return normalized.length > 32 ? `${normalized.slice(0, 32).trimEnd()}\u2026` : normalized;
+}
+function resumeTitleFromContent(content) {
+  const fromText = summarizeResumeTitle(content.text ?? "");
+  if (fromText) return fromText;
+  const kinds = new Set((content.attachments ?? []).map((att) => att.kind));
+  const labels = [];
+  if (kinds.has("image")) labels.push("\u56FE\u7247");
+  if (kinds.has("video")) labels.push("\u89C6\u9891");
+  if (kinds.has("file")) labels.push("\u6587\u4EF6");
+  if (labels.length) return `\u5FAE\u4FE1\u4F1A\u8BDD \xB7 ${labels.join("\u3001")}`;
+  if (content.quoted) return "\u5FAE\u4FE1\u4F1A\u8BDD \xB7 \u5F15\u7528";
+  return "\u5FAE\u4FE1\u4F1A\u8BDD";
+}
+function isImmediateCommand(kind) {
+  return kind === "cancel_generation" || kind === "help" || kind === "status" || kind === "list_sessions";
+}
+function formatRelativeTime(ts) {
+  const diff = Date.now() - ts;
+  if (diff < 6e4) return "\u521A\u521A";
+  const minutes = Math.floor(diff / 6e4);
+  if (minutes < 60) return `${minutes}\u5206\u949F\u524D`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}\u5C0F\u65F6\u524D`;
+  const days = Math.floor(hours / 24);
+  if (days < 30) return `${days}\u5929\u524D`;
+  return `${Math.floor(days / 30)}\u4E2A\u6708\u524D`;
+}
+function formatAttachment(att) {
+  const label = att.kind === "image" ? "\u56FE\u7247" : att.kind === "video" ? "\u89C6\u9891" : "\u6587\u4EF6";
+  const name = att.fileName ? `${att.fileName} ` : "";
+  if (att.failed) return `[${label}] ${name}[\u4E0B\u8F7D\u5931\u8D25${att.failReason ? `:${att.failReason}` : ""}]`;
+  if (att.localPath) return `[${label}] ${name}@${att.localPath}`;
+  return `[${label}] ${name}[\u65E0\u6CD5\u83B7\u53D6]`;
+}
+function composeInboundText(content) {
+  const parts = [];
+  if (content.text) parts.push(content.text);
+  for (const att of content.attachments ?? []) parts.push(formatAttachment(att));
+  if (content.quoted) {
+    const quotedParts = [];
+    if (content.quoted.text) quotedParts.push(content.quoted.text);
+    for (const att of content.quoted.attachments ?? []) quotedParts.push(formatAttachment(att));
+    if (quotedParts.length) parts.push(`[\u5F15\u7528] ${quotedParts.join(" ")}`);
+  }
+  return parts.join("\n");
+}
+
+// src/storage/lastProviderSessionStore.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { dirname as dirname7 } from "node:path";
+var LastProviderSessionStore = class {
+  constructor(configPath) {
+    this.configPath = configPath;
+  }
+  configPath;
+  get(providerId) {
+    return this.readState().bridge?.lastProviderSessions?.[providerId] ?? null;
+  }
+  set(providerId, input, updatedAt = Date.now()) {
+    const record = { ...input, updatedAt };
+    const state = this.readState();
+    state.bridge = {
+      ...state.bridge ?? {},
+      lastProviderSessions: {
+        ...state.bridge?.lastProviderSessions ?? {},
+        [providerId]: record
+      }
+    };
+    this.writeState(state);
+    return record;
+  }
+  list() {
+    return this.readState().bridge?.lastProviderSessions ?? {};
+  }
+  readState() {
+    if (!existsSync6(this.configPath)) return {};
+    const raw = JSON.parse(readFileSync4(this.configPath, "utf8"));
+    return raw && typeof raw === "object" ? raw : {};
+  }
+  writeState(state) {
+    mkdirSync4(dirname7(this.configPath), { recursive: true });
+    writeFileSync4(this.configPath, `${JSON.stringify(state, null, 2)}
+`, "utf8");
+  }
+};
+
+// src/storage/runtimeUserStore.ts
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync5, existsSync as existsSync7 } from "node:fs";
+import { dirname as dirname8 } from "node:path";
+import { nanoid as nanoid3 } from "nanoid";
+var RuntimeUserStore = class {
+  constructor(configPath) {
+    this.configPath = configPath;
+  }
+  configPath;
+  setActiveUser(input) {
+    const state = this.readState();
+    const existing = state.bridge?.activeWeChatUser;
+    const sameIdentity = existing && existing.platform === input.platform && existing.platformUserId === input.platformUserId;
+    const record = {
+      ...sameIdentity ? existing : {},
+      ...input,
+      id: sameIdentity ? existing.id : `user_${nanoid3(10)}`,
+      createdAt: sameIdentity ? existing.createdAt : Date.now(),
+      currentConversation: input.currentConversation ?? (sameIdentity ? existing.currentConversation : void 0),
+      updatedAt: Date.now()
+    };
+    state.bridge = {
+      ...state.bridge ?? {},
+      activeWeChatUser: record
+    };
+    this.writeState(state);
+    return record;
+  }
+  isActiveUser(platform, platformUserId) {
+    const activeUser = this.readState().bridge?.activeWeChatUser;
+    if (!activeUser) return null;
+    return activeUser.platform === platform && activeUser.platformUserId === platformUserId ? activeUser : null;
+  }
+  getActiveUser() {
+    return this.readState().bridge?.activeWeChatUser ?? null;
+  }
+  updateActiveUser(platform, patch) {
+    const state = this.readState();
+    const activeUser = state.bridge?.activeWeChatUser;
+    if (!activeUser || activeUser.platform !== platform) return;
+    state.bridge = {
+      ...state.bridge ?? {},
+      activeWeChatUser: {
+        ...activeUser,
+        ...patch.currentConversation !== void 0 ? { currentConversation: patch.currentConversation } : {},
+        updatedAt: Date.now()
+      }
+    };
+    this.writeState(state);
+  }
+  clearActiveUser(id) {
+    const state = this.readState();
+    const activeUser = state.bridge?.activeWeChatUser;
+    if (!activeUser || activeUser.id !== id) return { ok: false, error: "user_not_found" };
+    state.bridge = {
+      ...state.bridge ?? {},
+      activeWeChatUser: void 0
+    };
+    this.writeState(state);
+    return { ok: true };
+  }
+  readState() {
+    if (!existsSync7(this.configPath)) return {};
+    const raw = JSON.parse(readFileSync5(this.configPath, "utf8"));
+    return raw && typeof raw === "object" ? raw : {};
+  }
+  writeState(state) {
+    mkdirSync5(dirname8(this.configPath), { recursive: true });
+    writeFileSync5(this.configPath, `${JSON.stringify(state, null, 2)}
+`, "utf8");
+  }
+};
+
+// src/daemon/events.ts
+var BridgeEventHub = class {
+  listeners = /* @__PURE__ */ new Set();
+  emit(event) {
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch {
+      }
+    }
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+};
+
+// src/daemon/server.ts
+function createDaemonServer(options = {}) {
+  const app = Fastify({ logger: true });
+  const events = new BridgeEventHub();
+  const bridgeDefaults = {
+    defaultProvider: options.bridgeDefaults?.defaultProvider ?? "claude-code",
+    defaultWorkspace: options.bridgeDefaults?.defaultWorkspace ?? process.cwd()
+  };
+  const configPath = options.configPath ?? process.env.BRIDGE_CONFIG ?? join8(mkdtempSync(join8(tmpdir2(), "claude-codex-wechat-")), "config.json");
+  const conversation = new CurrentConversationStore(configPath, {
+    defaultCwd: bridgeDefaults.defaultWorkspace,
+    defaultProviderId: bridgeDefaults.defaultProvider
+  });
+  const providers = new ProviderRegistry({
+    claudeCommand: options.providerCommands?.claude?.command,
+    codexCommand: options.providerCommands?.codex?.command
+  });
+  const activeUserStore = options.activeUserStore ?? new RuntimeUserStore(configPath);
+  const lastProviderSessions = new LastProviderSessionStore(configPath);
+  const sessionBindingMatch = /* @__PURE__ */ new Map();
+  const providerAdapters = options.providers ?? createDefaultProviders({
+    claudeCommand: options.providerCommands?.claude?.command,
+    codexCommand: options.providerCommands?.codex?.command
+  });
+  let currentConversation = conversation.getCurrent();
+  if (currentConversation) {
+    if (currentConversation.providerId === "claude-code" && currentConversation.providerSessionId && currentConversation.resumeTitle) {
+      void ensureClaudeSessionBridgeMetadata({
+        sessionId: currentConversation.providerSessionId,
+        resumeTitle: currentConversation.resumeTitle,
+        cwd: currentConversation.cwd
+      });
+    }
+    const provider = providerAdapters.find((candidate) => candidate.id === currentConversation.providerId);
+    void provider?.startSession({
+      bridgeSessionId: currentConversation.id,
+      cwd: currentConversation.cwd,
+      options: currentConversation.providerSessionId ? { providerSessionId: currentConversation.providerSessionId } : void 0
+    });
+  }
+  const weixinStateStore = configPath ? new FileWeixinStateStore(configPath) : void 0;
+  const weixinMediaDir = configPath ? join8(dirname9(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({
+    store: weixinStateStore,
+    send: async (chatId, msg) => {
+      await managedWechatChannel.sendMessage({ chatId, kind: msg.kind, text: msg.text });
+    }
+  }) : void 0;
+  const messageRouter = channel ? new MessageRouter({
+    channel,
+    providers: providerAdapters,
+    conversation,
+    outboundGate: weixinOutboundGate,
+    resolveUser: (message) => activeUserStore.isActiveUser(PRIMARY_WEIXIN_PLATFORM, message.user.id),
+    autoAuthorizeUser: (message) => {
+      const existing = activeUserStore.isActiveUser(PRIMARY_WEIXIN_PLATFORM, message.user.id);
+      if (existing) return existing;
+      const created = activeUserStore.setActiveUser({
+        platform: PRIMARY_WEIXIN_PLATFORM,
+        platformUserId: message.user.id,
+        displayName: message.user.displayName,
+        role: "user"
+      });
+      events.emit({
+        type: "channel.user-authorized",
+        user: {
+          id: created.id,
+          platformUserId: created.platformUserId,
+          platformType: "weixin",
+          display_name: created.displayName,
+          authorizedAt: created.createdAt,
+          lastActive: created.updatedAt,
+          provider: bridgeDefaults.defaultProvider,
+          cwd: bridgeDefaults.defaultWorkspace
+        }
+      });
+      return created;
+    },
+    autoAttachSession: async (message, user, opts) => {
+      if (conversation.getCurrent()) return null;
+      const provider = providerAdapters.find((candidate) => candidate.id === bridgeDefaults.defaultProvider);
+      if (!provider?.attachSession || !provider.listRecoverableSessions) return null;
+      const attached = await autoAttachProviderSessionForMessage({
+        message,
+        user,
+        provider,
+        conversationStore: conversation,
+        lastProviderSessions,
+        defaultProviderId: bridgeDefaults.defaultProvider,
+        defaultCwd: bridgeDefaults.defaultWorkspace,
+        ...opts?.shouldCommit ? { shouldCommit: opts.shouldCommit } : {}
+      });
+      if (attached) {
+        sessionBindingMatch.set(attached.session.id, attached.matchedBinding);
+        return attached.session;
+      }
+      return null;
+    },
+    lastProviderSessions,
+    events,
+    defaults: bridgeDefaults
+  }) : void 0;
+  if (channel && messageRouter) {
+    channel.onMessage(async (message) => {
+      await messageRouter.handleMessage(message);
+    });
+  }
+  registerChannelAdminRoutes({
+    app,
+    users: activeUserStore,
+    ...weixinStateStore ? { weixinStateStore } : {},
+    ...channel ? { channel } : {},
+    lastProviderSessions,
+    conversation,
+    defaults: bridgeDefaults,
+    providers: providerAdapters,
+    getSessionBindingMatch: (sessionId) => sessionBindingMatch.get(sessionId) === true,
+    wechat: options.wechat,
+    events,
+    configPath,
+    onWechatConfigChanged: managedWechatChannel ? async (next) => {
+      await managedWechatChannel.configure(next);
+    } : void 0
+  });
+  registerSettingsRoutes({
+    app,
+    defaults: bridgeDefaults,
+    configPath
+  });
+  app.get("/api/status", async () => ({
+    ok: true,
+    sessions: conversation.getCurrent() ? [conversation.getCurrent()] : []
+  }));
+  app.get("/api/providers/status", async () => providers.getStatus());
+  app.post("/api/bridge-events", async (request, reply) => {
+    reply.raw.writeHead(200, {
+      "content-type": "text/event-stream; charset=utf-8",
+      "cache-control": "no-cache",
+      connection: "keep-alive"
+    });
+    const write = (event) => {
+      try {
+        reply.raw.write(`data: ${JSON.stringify(event)}
+
+`);
+      } catch {
+      }
+    };
+    write({ type: "connected" });
+    const unsubscribe = events.subscribe(write);
+    const heartbeat = setInterval(() => write({ type: "ping" }), 15e3);
+    const cleanup = () => {
+      clearInterval(heartbeat);
+      unsubscribe();
+    };
+    request.raw.on("close", cleanup);
+    request.raw.on("error", cleanup);
+    return reply.hijack();
+  });
+  app.addHook("onReady", async () => {
+    await channel?.start({ background: true });
+  });
+  app.addHook("onClose", async () => {
+    await channel?.stop();
+  });
+  return { app, conversation, sessions: conversation, events, activeUserStore };
+}
+
+// src/daemon/bootstrap.ts
+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();
+  const config = loadBridgeConfig(configPath);
+  const providerCommands = await resolveProviderCommands(config.providers);
+  await persistProviderCommandsToConfigFile({
+    configPath,
+    providers: providerCommands
+  });
+  const { app } = createDaemonServer({
+    wechat: config.wechat,
+    providerCommands,
+    bridgeDefaults: {
+      defaultProvider: config.bridge?.defaultProvider ?? "claude-code",
+      defaultWorkspace: config.bridge?.defaultWorkspace ?? process.cwd()
+    },
+    configPath
+  });
+  await options.attachFrontend(app);
+  await app.listen({ host, port });
+  console.log("claude-codex-wechat listening:");
+  console.log(`  Local:   http://127.0.0.1:${port}`);
+  for (const ip of listLanIpv4Addresses()) {
+    console.log(`  Network: http://${ip}:${port}`);
+  }
+  console.log(`config path: ${configPath}`);
+  return { app, port, host, configPath };
+}
+function listLanIpv4Addresses() {
+  return Object.values(networkInterfaces()).flat().filter((iface) => Boolean(iface)).filter((iface) => iface.family === "IPv4" && !iface.internal).map((iface) => iface.address);
+}
+async function resolveProviderCommands(providers) {
+  const claudeCommand = providers?.claude?.command ?? await findExecutable("claude");
+  const codexCommand = providers?.codex?.command ?? await findExecutable("codex");
+  if (!claudeCommand && !codexCommand) return void 0;
+  return {
+    ...claudeCommand ? { claude: { command: claudeCommand } } : {},
+    ...codexCommand ? { codex: { command: codexCommand } } : {}
+  };
+}
+
+// src/daemon/staticFrontend.ts
+import { readFileSync as readFileSync6 } from "node:fs";
+import { join as join9 } from "node:path";
+import fastifyStatic from "@fastify/static";
+function attachStaticFrontend(webRoot2) {
+  return async (app) => {
+    await app.register(fastifyStatic, {
+      root: webRoot2,
+      wildcard: false
+    });
+    const indexHtml = readFileSync6(join9(webRoot2, "index.html"), "utf8");
+    app.setNotFoundHandler((request, reply) => {
+      if (request.url.startsWith("/api")) {
+        reply.code(404).send({ error: "not_found" });
+        return;
+      }
+      reply.type("text/html").send(indexHtml);
+    });
+  };
+}
+
+// src/cli.ts
+var here = dirname10(fileURLToPath(import.meta.url));
+var webRoot = join10(here, "..", "web");
+async function main() {
+  const command = process.argv[2];
+  switch (command) {
+    case void 0:
+    case "start":
+      await cmdStart();
+      return;
+    case "init":
+      cmdInit();
+      return;
+    case "doctor":
+      await cmdDoctor();
+      return;
+    case "print-config":
+      cmdPrintConfig();
+      return;
+    case "help":
+    case "--help":
+    case "-h":
+      printUsage();
+      return;
+    default:
+      console.error(`\u672A\u77E5\u547D\u4EE4: ${command}
+`);
+      printUsage();
+      process.exitCode = 1;
+  }
+}
+async function cmdStart() {
+  if (!existsSync8(webRoot)) {
+    console.error(`\u627E\u4E0D\u5230\u524D\u7AEF\u6784\u5EFA\u4EA7\u7269: ${webRoot}`);
+    console.error("\u8BF7\u5148\u8FD0\u884C\u6784\u5EFA (pnpm build) \u540E\u518D\u542F\u52A8\uFF0C\u6216\u91CD\u65B0\u5B89\u88C5\u5B8C\u6574\u7684 npm \u5305\u3002");
+    process.exitCode = 1;
+    return;
+  }
+  await startDaemon({
+    attachFrontend: attachStaticFrontend(webRoot)
+  });
+}
+function cmdInit() {
+  const configPath = process.env.BRIDGE_CONFIG ?? defaultConfigPath();
+  const dir = dirname10(configPath);
+  mkdirSync6(dir, { recursive: true });
+  if (existsSync8(configPath)) {
+    console.log(`\u914D\u7F6E\u5DF2\u5B58\u5728\uFF0C\u672A\u8986\u76D6: ${configPath}`);
+    return;
+  }
+  const template = {
+    wechat: {
+      enabled: true,
+      baseUrl: "https://ilinkai.weixin.qq.com",
+      token: "replace-with-weixin-bot-token",
+      accountId: "replace-with-weixin-account-id"
+    },
+    providers: {},
+    bridge: {
+      defaultProvider: "claude-code",
+      defaultWorkspace: process.cwd()
+    }
+  };
+  writeFileSync6(configPath, `${JSON.stringify(template, null, 2)}
+`, "utf8");
+  console.log(`\u5DF2\u521B\u5EFA\u914D\u7F6E: ${configPath}`);
+  console.log("\u8BF7\u586B\u5165\u5FAE\u4FE1 token / accountId \u540E\u8FD0\u884C: claude-codex-wechat start");
+}
+async function cmdDoctor() {
+  const configPath = process.env.BRIDGE_CONFIG ?? defaultConfigPath();
+  console.log("claude-codex-wechat doctor\n");
+  report("\u914D\u7F6E\u6587\u4EF6", existsSync8(configPath) ? configPath : `\u7F3A\u5931 (${configPath})\uFF0C\u8FD0\u884C init \u521B\u5EFA`);
+  report("\u524D\u7AEF\u4EA7\u7269", existsSync8(webRoot) ? webRoot : `\u7F3A\u5931 (${webRoot})`);
+  const claude = await findExecutable("claude");
+  report("claude \u53EF\u6267\u884C", claude ?? "\u672A\u627E\u5230\uFF0C\u9700\u5148\u5B89\u88C5\u5E76\u767B\u5F55 Claude Code");
+  const codex = await findExecutable("codex");
+  report("codex \u53EF\u6267\u884C", codex ?? "\u672A\u627E\u5230\uFF08\u4EC5\u4F7F\u7528 Claude \u65F6\u53EF\u5FFD\u7565\uFF09");
+  if (existsSync8(configPath)) {
+    const config = loadBridgeConfig(configPath);
+    const wechat = config.wechat;
+    report("\u5FAE\u4FE1\u542F\u7528", wechat?.enabled ? "\u662F" : "\u5426");
+    report("\u5FAE\u4FE1 token", wechat?.token ? "\u5DF2\u914D\u7F6E" : "\u672A\u914D\u7F6E");
+    report("\u5FAE\u4FE1 accountId", wechat?.accountId ? "\u5DF2\u914D\u7F6E" : "\u672A\u914D\u7F6E");
+  }
+}
+function cmdPrintConfig() {
+  const configPath = process.env.BRIDGE_CONFIG ?? defaultConfigPath();
+  if (!existsSync8(configPath)) {
+    console.error(`\u914D\u7F6E\u4E0D\u5B58\u5728: ${configPath}\uFF08\u8FD0\u884C init \u521B\u5EFA\uFF09`);
+    process.exitCode = 1;
+    return;
+  }
+  console.log(readFileSync7(configPath, "utf8"));
+}
+function report(label, value) {
+  console.log(`  ${label.padEnd(14)}: ${value}`);
+}
+function printUsage() {
+  console.log(`claude-codex-wechat \u2014 \u672C\u5730 WeChat \u2194 Claude/Codex bridge daemon
+
+\u7528\u6CD5:
+  claude-codex-wechat <command>
+
+\u547D\u4EE4:
+  start          \u542F\u52A8 daemon\uFF08\u9ED8\u8BA4\u547D\u4EE4\uFF0C\u524D\u53F0\u8FD0\u884C\uFF09
+  init           \u5728 ~/.claude-codex-wechat/ \u521B\u5EFA\u9ED8\u8BA4\u914D\u7F6E
+  doctor         \u68C0\u67E5\u914D\u7F6E\u3001\u524D\u7AEF\u4EA7\u7269\u4E0E claude/codex \u53EF\u6267\u884C\u6587\u4EF6
+  print-config   \u6253\u5370\u5F53\u524D\u914D\u7F6E\u6587\u4EF6\u5185\u5BB9
+  help           \u663E\u793A\u672C\u5E2E\u52A9
+
+\u73AF\u5883\u53D8\u91CF:
+  BRIDGE_PORT    \u76D1\u542C\u7AEF\u53E3\uFF08\u9ED8\u8BA4 8787\uFF09
+  BRIDGE_CONFIG  \u914D\u7F6E\u6587\u4EF6\u8DEF\u5F84\uFF08\u9ED8\u8BA4 ~/.claude-codex-wechat/config.json\uFF09
+
+\u5E38\u9A7B\u8FD0\u884C\u8BF7\u7528\u8FDB\u7A0B\u7BA1\u7406\u5668\u6258\u7BA1\uFF0C\u4F8B\u5982:
+  pm2 start claude-codex-wechat -- start`);
+}
+await main();