codex-to-im 1.0.20 → 1.0.21

package/dist/ui-server.mjs

@@ -4575,6 +4575,12 @@ import fs9 from "node:fs";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+function toFeishuConfig(channel) {
+  return channel?.provider === "feishu" ? channel.config : void 0;
+}
+function toWeixinConfig(channel) {
+  return channel?.provider === "weixin" ? channel.config : void 0;
+}
 var LEGACY_CTI_HOME = path.join(os.homedir(), ".claude-to-im");
 var DEFAULT_CTI_HOME = path.join(os.homedir(), ".codex-to-im");
 var DEFAULT_WORKSPACE_ROOT = path.join(os.homedir(), "cx2im");
@@ -4585,6 +4591,7 @@ function resolveDefaultCtiHome() {
 }
 var CTI_HOME = process.env.CTI_HOME || resolveDefaultCtiHome();
 var CONFIG_PATH = path.join(CTI_HOME, "config.env");
+var CONFIG_V2_PATH = path.join(CTI_HOME, "config.v2.json");
 function expandHomePath(value) {
   if (!value) return value;
   if (value === "~") return os.homedir();
@@ -4638,48 +4645,187 @@ function parseReasoningEffort(value) {
   }
   return void 0;
 }
-function loadConfig() {
-  const env = loadRawConfigEnv();
+function normalizeFeishuSite(value) {
+  const normalized = (value || "").trim().replace(/\/+$/, "").toLowerCase();
+  if (!normalized) return "feishu";
+  if (normalized === "lark") return "lark";
+  if (normalized === "feishu") return "feishu";
+  if (normalized.includes("open.larksuite.com")) return "lark";
+  return "feishu";
+}
+function feishuSiteToApiBaseUrl(site) {
+  return normalizeFeishuSite(site) === "lark" ? "https://open.larksuite.com" : "https://open.feishu.cn";
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function ensureConfigDir() {
+  fs.mkdirSync(CTI_HOME, { recursive: true });
+}
+function readConfigV2File() {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(CONFIG_V2_PATH, "utf-8"));
+    if (parsed && parsed.schemaVersion === 2 && parsed.runtime && Array.isArray(parsed.channels)) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function writeConfigV2File(config) {
+  ensureConfigDir();
+  const tmpPath = CONFIG_V2_PATH + ".tmp";
+  fs.writeFileSync(tmpPath, JSON.stringify(config, null, 2), { mode: 384 });
+  fs.renameSync(tmpPath, CONFIG_V2_PATH);
+}
+function normalizeChannelId(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || "channel";
+}
+function defaultAliasForProvider(provider) {
+  return provider === "feishu" ? "\u98DE\u4E66" : "\u5FAE\u4FE1";
+}
+function buildDefaultChannelId(provider) {
+  return `${provider}-default`;
+}
+function migrateLegacyEnvToV2(env) {
   const rawRuntime = env.get("CTI_RUNTIME") || "codex";
   const runtime = ["claude", "codex", "auto"].includes(rawRuntime) ? rawRuntime : "codex";
+  const enabledChannels = splitCsv(env.get("CTI_ENABLED_CHANNELS")) ?? ["feishu"];
+  const timestamp = nowIso();
+  const channels = [];
+  const hasFeishuConfig = Boolean(
+    env.get("CTI_FEISHU_APP_ID") || env.get("CTI_FEISHU_APP_SECRET") || env.get("CTI_FEISHU_ALLOWED_USERS") || enabledChannels.includes("feishu")
+  );
+  if (hasFeishuConfig) {
+    channels.push({
+      id: buildDefaultChannelId("feishu"),
+      alias: defaultAliasForProvider("feishu"),
+      provider: "feishu",
+      enabled: enabledChannels.includes("feishu"),
+      createdAt: timestamp,
+      updatedAt: timestamp,
+      config: {
+        appId: env.get("CTI_FEISHU_APP_ID") || void 0,
+        appSecret: env.get("CTI_FEISHU_APP_SECRET") || void 0,
+        site: normalizeFeishuSite(env.get("CTI_FEISHU_SITE") || env.get("CTI_FEISHU_DOMAIN")),
+        allowedUsers: splitCsv(env.get("CTI_FEISHU_ALLOWED_USERS")),
+        streamingEnabled: env.has("CTI_FEISHU_STREAMING_ENABLED") ? env.get("CTI_FEISHU_STREAMING_ENABLED") === "true" : true,
+        feedbackMarkdownEnabled: env.has("CTI_FEISHU_COMMAND_MARKDOWN_ENABLED") ? env.get("CTI_FEISHU_COMMAND_MARKDOWN_ENABLED") === "true" : true
+      }
+    });
+  }
+  const hasWeixinConfig = Boolean(
+    env.get("CTI_WEIXIN_BASE_URL") || env.get("CTI_WEIXIN_CDN_BASE_URL") || env.get("CTI_WEIXIN_MEDIA_ENABLED") || enabledChannels.includes("weixin")
+  );
+  if (hasWeixinConfig) {
+    channels.push({
+      id: buildDefaultChannelId("weixin"),
+      alias: defaultAliasForProvider("weixin"),
+      provider: "weixin",
+      enabled: enabledChannels.includes("weixin"),
+      createdAt: timestamp,
+      updatedAt: timestamp,
+      config: {
+        baseUrl: env.get("CTI_WEIXIN_BASE_URL") || void 0,
+        cdnBaseUrl: env.get("CTI_WEIXIN_CDN_BASE_URL") || void 0,
+        mediaEnabled: env.has("CTI_WEIXIN_MEDIA_ENABLED") ? env.get("CTI_WEIXIN_MEDIA_ENABLED") === "true" : void 0,
+        feedbackMarkdownEnabled: env.has("CTI_WEIXIN_COMMAND_MARKDOWN_ENABLED") ? env.get("CTI_WEIXIN_COMMAND_MARKDOWN_ENABLED") === "true" : false
+      }
+    });
+  }
+  return {
+    schemaVersion: 2,
+    runtime: {
+      provider: runtime,
+      defaultWorkspaceRoot: expandHomePath(env.get("CTI_DEFAULT_WORKSPACE_ROOT")) || void 0,
+      defaultModel: env.get("CTI_DEFAULT_MODEL") || void 0,
+      defaultMode: env.get("CTI_DEFAULT_MODE") || "code",
+      historyMessageLimit: parsePositiveInt(env.get("CTI_HISTORY_MESSAGE_LIMIT")) ?? 8,
+      codexSkipGitRepoCheck: env.has("CTI_CODEX_SKIP_GIT_REPO_CHECK") ? env.get("CTI_CODEX_SKIP_GIT_REPO_CHECK") === "true" : true,
+      codexSandboxMode: parseSandboxMode(env.get("CTI_CODEX_SANDBOX_MODE")) ?? "workspace-write",
+      codexReasoningEffort: parseReasoningEffort(env.get("CTI_CODEX_REASONING_EFFORT")) ?? "medium",
+      uiAllowLan: env.get("CTI_UI_ALLOW_LAN") === "true",
+      uiAccessToken: env.get("CTI_UI_ACCESS_TOKEN") || void 0,
+      autoApprove: env.get("CTI_AUTO_APPROVE") === "true"
+    },
+    channels
+  };
+}
+function getChannelByProvider(config, provider) {
+  const preferredId = buildDefaultChannelId(provider);
+  return config.channels.find((channel) => channel.id === preferredId) || config.channels.find((channel) => channel.provider === provider);
+}
+function expandConfig(v2) {
+  return {
+    schemaVersion: 2,
+    channels: v2.channels,
+    runtime: v2.runtime.provider,
+    enabledChannels: Array.from(new Set(
+      v2.channels.filter((channel) => channel.enabled).map((channel) => channel.provider)
+    )),
+    defaultWorkspaceRoot: v2.runtime.defaultWorkspaceRoot,
+    defaultModel: v2.runtime.defaultModel,
+    defaultMode: v2.runtime.defaultMode || "code",
+    historyMessageLimit: v2.runtime.historyMessageLimit ?? 8,
+    codexSkipGitRepoCheck: v2.runtime.codexSkipGitRepoCheck ?? true,
+    codexSandboxMode: v2.runtime.codexSandboxMode ?? "workspace-write",
+    codexReasoningEffort: v2.runtime.codexReasoningEffort ?? "medium",
+    uiAllowLan: v2.runtime.uiAllowLan === true,
+    uiAccessToken: v2.runtime.uiAccessToken || void 0,
+    autoApprove: v2.runtime.autoApprove === true
+  };
+}
+function buildV2FileFromExpandedConfig(config, current) {
+  const hasExplicitChannels = Array.isArray(config.channels);
+  let channels = hasExplicitChannels ? [...config.channels || []] : [...current?.channels || []];
   return {
-    runtime,
-    enabledChannels: splitCsv(env.get("CTI_ENABLED_CHANNELS")) ?? ["feishu"],
-    defaultWorkspaceRoot: expandHomePath(env.get("CTI_DEFAULT_WORKSPACE_ROOT")) || void 0,
-    defaultModel: env.get("CTI_DEFAULT_MODEL") || void 0,
-    defaultMode: env.get("CTI_DEFAULT_MODE") || "code",
-    historyMessageLimit: parsePositiveInt(env.get("CTI_HISTORY_MESSAGE_LIMIT")) ?? 8,
-    codexSkipGitRepoCheck: env.has("CTI_CODEX_SKIP_GIT_REPO_CHECK") ? env.get("CTI_CODEX_SKIP_GIT_REPO_CHECK") === "true" : true,
-    codexSandboxMode: parseSandboxMode(env.get("CTI_CODEX_SANDBOX_MODE")) ?? "workspace-write",
-    codexReasoningEffort: parseReasoningEffort(env.get("CTI_CODEX_REASONING_EFFORT")) ?? "medium",
-    uiAllowLan: env.get("CTI_UI_ALLOW_LAN") === "true",
-    uiAccessToken: env.get("CTI_UI_ACCESS_TOKEN") || void 0,
-    tgBotToken: env.get("CTI_TG_BOT_TOKEN") || void 0,
-    tgChatId: env.get("CTI_TG_CHAT_ID") || void 0,
-    tgAllowedUsers: splitCsv(env.get("CTI_TG_ALLOWED_USERS")),
-    feishuAppId: env.get("CTI_FEISHU_APP_ID") || void 0,
-    feishuAppSecret: env.get("CTI_FEISHU_APP_SECRET") || void 0,
-    feishuDomain: env.get("CTI_FEISHU_DOMAIN") || void 0,
-    feishuAllowedUsers: splitCsv(env.get("CTI_FEISHU_ALLOWED_USERS")),
-    feishuStreamingEnabled: env.has("CTI_FEISHU_STREAMING_ENABLED") ? env.get("CTI_FEISHU_STREAMING_ENABLED") === "true" : true,
-    feishuCommandMarkdownEnabled: env.has("CTI_FEISHU_COMMAND_MARKDOWN_ENABLED") ? env.get("CTI_FEISHU_COMMAND_MARKDOWN_ENABLED") === "true" : true,
-    discordBotToken: env.get("CTI_DISCORD_BOT_TOKEN") || void 0,
-    discordAllowedUsers: splitCsv(env.get("CTI_DISCORD_ALLOWED_USERS")),
-    discordAllowedChannels: splitCsv(
-      env.get("CTI_DISCORD_ALLOWED_CHANNELS")
-    ),
-    discordAllowedGuilds: splitCsv(env.get("CTI_DISCORD_ALLOWED_GUILDS")),
-    qqAppId: env.get("CTI_QQ_APP_ID") || void 0,
-    qqAppSecret: env.get("CTI_QQ_APP_SECRET") || void 0,
-    qqAllowedUsers: splitCsv(env.get("CTI_QQ_ALLOWED_USERS")),
-    qqImageEnabled: env.has("CTI_QQ_IMAGE_ENABLED") ? env.get("CTI_QQ_IMAGE_ENABLED") === "true" : void 0,
-    qqMaxImageSize: env.get("CTI_QQ_MAX_IMAGE_SIZE") ? Number(env.get("CTI_QQ_MAX_IMAGE_SIZE")) : void 0,
-    weixinBaseUrl: env.get("CTI_WEIXIN_BASE_URL") || void 0,
-    weixinCdnBaseUrl: env.get("CTI_WEIXIN_CDN_BASE_URL") || void 0,
-    weixinMediaEnabled: env.has("CTI_WEIXIN_MEDIA_ENABLED") ? env.get("CTI_WEIXIN_MEDIA_ENABLED") === "true" : void 0,
-    weixinCommandMarkdownEnabled: env.has("CTI_WEIXIN_COMMAND_MARKDOWN_ENABLED") ? env.get("CTI_WEIXIN_COMMAND_MARKDOWN_ENABLED") === "true" : false,
-    autoApprove: env.get("CTI_AUTO_APPROVE") === "true"
+    schemaVersion: 2,
+    runtime: {
+      provider: config.runtime,
+      defaultWorkspaceRoot: config.defaultWorkspaceRoot,
+      defaultModel: config.defaultModel,
+      defaultMode: config.defaultMode,
+      historyMessageLimit: config.historyMessageLimit,
+      codexSkipGitRepoCheck: config.codexSkipGitRepoCheck,
+      codexSandboxMode: config.codexSandboxMode,
+      codexReasoningEffort: config.codexReasoningEffort,
+      uiAllowLan: config.uiAllowLan,
+      uiAccessToken: config.uiAccessToken,
+      autoApprove: config.autoApprove
+    },
+    channels: channels.map((channel) => ({
+      ...channel,
+      id: normalizeChannelId(channel.id),
+      alias: channel.alias?.trim() || defaultAliasForProvider(channel.provider)
+    }))
+  };
+}
+function loadConfig() {
+  const current = readConfigV2File();
+  if (current) return expandConfig(current);
+  const legacyEnv = loadRawConfigEnv();
+  if (legacyEnv.size > 0) {
+    const migrated = migrateLegacyEnvToV2(legacyEnv);
+    writeConfigV2File(migrated);
+    return expandConfig(migrated);
+  }
+  const empty = {
+    schemaVersion: 2,
+    runtime: {
+      provider: "codex",
+      defaultWorkspaceRoot: DEFAULT_WORKSPACE_ROOT,
+      defaultMode: "code",
+      historyMessageLimit: 8,
+      codexSkipGitRepoCheck: true,
+      codexSandboxMode: "workspace-write",
+      codexReasoningEffort: "medium",
+      uiAllowLan: false,
+      autoApprove: false
+    },
+    channels: []
   };
+  return expandConfig(empty);
 }
 function formatEnvLine(key, value) {
   if (value === void 0 || value === "") return "";
@@ -4687,130 +4833,139 @@ function formatEnvLine(key, value) {
 `;
 }
 function saveConfig(config) {
+  const current = readConfigV2File();
+  const next = buildV2FileFromExpandedConfig(config, current);
+  writeConfigV2File(next);
   let out = "";
-  out += formatEnvLine("CTI_RUNTIME", config.runtime);
+  out += formatEnvLine("CTI_RUNTIME", next.runtime.provider);
   out += formatEnvLine(
     "CTI_ENABLED_CHANNELS",
-    config.enabledChannels.join(",")
-  );
-  out += formatEnvLine("CTI_DEFAULT_WORKSPACE_ROOT", config.defaultWorkspaceRoot);
-  if (config.defaultModel) out += formatEnvLine("CTI_DEFAULT_MODEL", config.defaultModel);
-  out += formatEnvLine("CTI_DEFAULT_MODE", config.defaultMode);
-  if (config.historyMessageLimit !== void 0)
-    out += formatEnvLine("CTI_HISTORY_MESSAGE_LIMIT", String(config.historyMessageLimit));
-  if (config.codexSkipGitRepoCheck !== void 0)
-    out += formatEnvLine("CTI_CODEX_SKIP_GIT_REPO_CHECK", String(config.codexSkipGitRepoCheck));
-  out += formatEnvLine("CTI_CODEX_SANDBOX_MODE", config.codexSandboxMode);
-  out += formatEnvLine("CTI_CODEX_REASONING_EFFORT", config.codexReasoningEffort);
-  out += formatEnvLine("CTI_UI_ALLOW_LAN", String(config.uiAllowLan === true));
-  out += formatEnvLine("CTI_UI_ACCESS_TOKEN", config.uiAccessToken);
-  out += formatEnvLine("CTI_TG_BOT_TOKEN", config.tgBotToken);
-  out += formatEnvLine("CTI_TG_CHAT_ID", config.tgChatId);
-  out += formatEnvLine(
-    "CTI_TG_ALLOWED_USERS",
-    config.tgAllowedUsers?.join(",")
-  );
-  out += formatEnvLine("CTI_FEISHU_APP_ID", config.feishuAppId);
-  out += formatEnvLine("CTI_FEISHU_APP_SECRET", config.feishuAppSecret);
-  out += formatEnvLine("CTI_FEISHU_DOMAIN", config.feishuDomain);
-  out += formatEnvLine(
-    "CTI_FEISHU_ALLOWED_USERS",
-    config.feishuAllowedUsers?.join(",")
-  );
-  if (config.feishuStreamingEnabled !== void 0)
-    out += formatEnvLine(
-      "CTI_FEISHU_STREAMING_ENABLED",
-      String(config.feishuStreamingEnabled)
-    );
-  if (config.feishuCommandMarkdownEnabled !== void 0)
-    out += formatEnvLine(
-      "CTI_FEISHU_COMMAND_MARKDOWN_ENABLED",
-      String(config.feishuCommandMarkdownEnabled)
-    );
-  out += formatEnvLine("CTI_DISCORD_BOT_TOKEN", config.discordBotToken);
-  out += formatEnvLine(
-    "CTI_DISCORD_ALLOWED_USERS",
-    config.discordAllowedUsers?.join(",")
-  );
-  out += formatEnvLine(
-    "CTI_DISCORD_ALLOWED_CHANNELS",
-    config.discordAllowedChannels?.join(",")
-  );
-  out += formatEnvLine(
-    "CTI_DISCORD_ALLOWED_GUILDS",
-    config.discordAllowedGuilds?.join(",")
-  );
-  out += formatEnvLine("CTI_QQ_APP_ID", config.qqAppId);
-  out += formatEnvLine("CTI_QQ_APP_SECRET", config.qqAppSecret);
-  out += formatEnvLine(
-    "CTI_QQ_ALLOWED_USERS",
-    config.qqAllowedUsers?.join(",")
+    Array.from(new Set(next.channels.filter((channel) => channel.enabled).map((channel) => channel.provider))).join(",")
   );
-  if (config.qqImageEnabled !== void 0)
-    out += formatEnvLine("CTI_QQ_IMAGE_ENABLED", String(config.qqImageEnabled));
-  if (config.qqMaxImageSize !== void 0)
-    out += formatEnvLine("CTI_QQ_MAX_IMAGE_SIZE", String(config.qqMaxImageSize));
-  out += formatEnvLine("CTI_WEIXIN_BASE_URL", config.weixinBaseUrl);
-  out += formatEnvLine("CTI_WEIXIN_CDN_BASE_URL", config.weixinCdnBaseUrl);
-  if (config.weixinMediaEnabled !== void 0)
-    out += formatEnvLine("CTI_WEIXIN_MEDIA_ENABLED", String(config.weixinMediaEnabled));
-  if (config.weixinCommandMarkdownEnabled !== void 0)
-    out += formatEnvLine(
-      "CTI_WEIXIN_COMMAND_MARKDOWN_ENABLED",
-      String(config.weixinCommandMarkdownEnabled)
-    );
-  out += formatEnvLine("CTI_AUTO_APPROVE", String(config.autoApprove === true));
-  fs.mkdirSync(CTI_HOME, { recursive: true });
+  out += formatEnvLine("CTI_DEFAULT_WORKSPACE_ROOT", next.runtime.defaultWorkspaceRoot);
+  out += formatEnvLine("CTI_DEFAULT_MODEL", next.runtime.defaultModel);
+  out += formatEnvLine("CTI_DEFAULT_MODE", next.runtime.defaultMode);
+  if (next.runtime.historyMessageLimit !== void 0) {
+    out += formatEnvLine("CTI_HISTORY_MESSAGE_LIMIT", String(next.runtime.historyMessageLimit));
+  }
+  if (next.runtime.codexSkipGitRepoCheck !== void 0) {
+    out += formatEnvLine("CTI_CODEX_SKIP_GIT_REPO_CHECK", String(next.runtime.codexSkipGitRepoCheck));
+  }
+  out += formatEnvLine("CTI_CODEX_SANDBOX_MODE", next.runtime.codexSandboxMode);
+  out += formatEnvLine("CTI_CODEX_REASONING_EFFORT", next.runtime.codexReasoningEffort);
+  out += formatEnvLine("CTI_UI_ALLOW_LAN", String(next.runtime.uiAllowLan === true));
+  out += formatEnvLine("CTI_UI_ACCESS_TOKEN", next.runtime.uiAccessToken);
+  const feishu = getChannelByProvider(next, "feishu");
+  const feishuConfig = toFeishuConfig(feishu);
+  if (feishuConfig) {
+    out += formatEnvLine("CTI_FEISHU_APP_ID", feishuConfig.appId);
+    out += formatEnvLine("CTI_FEISHU_APP_SECRET", feishuConfig.appSecret);
+    out += formatEnvLine("CTI_FEISHU_SITE", feishuConfig.site);
+    out += formatEnvLine("CTI_FEISHU_ALLOWED_USERS", feishuConfig.allowedUsers?.join(","));
+    if (feishuConfig.streamingEnabled !== void 0) {
+      out += formatEnvLine("CTI_FEISHU_STREAMING_ENABLED", String(feishuConfig.streamingEnabled));
+    }
+    if (feishuConfig.feedbackMarkdownEnabled !== void 0) {
+      out += formatEnvLine("CTI_FEISHU_COMMAND_MARKDOWN_ENABLED", String(feishuConfig.feedbackMarkdownEnabled));
+    }
+  }
+  const weixin = getChannelByProvider(next, "weixin");
+  const weixinConfig = toWeixinConfig(weixin);
+  if (weixinConfig) {
+    out += formatEnvLine("CTI_WEIXIN_BASE_URL", weixinConfig.baseUrl);
+    out += formatEnvLine("CTI_WEIXIN_CDN_BASE_URL", weixinConfig.cdnBaseUrl);
+    if (weixinConfig.mediaEnabled !== void 0) {
+      out += formatEnvLine("CTI_WEIXIN_MEDIA_ENABLED", String(weixinConfig.mediaEnabled));
+    }
+    if (weixinConfig.feedbackMarkdownEnabled !== void 0) {
+      out += formatEnvLine("CTI_WEIXIN_COMMAND_MARKDOWN_ENABLED", String(weixinConfig.feedbackMarkdownEnabled));
+    }
+  }
+  out += formatEnvLine("CTI_AUTO_APPROVE", String(next.runtime.autoApprove === true));
+  ensureConfigDir();
   const tmpPath = CONFIG_PATH + ".tmp";
   fs.writeFileSync(tmpPath, out, { mode: 384 });
   fs.renameSync(tmpPath, CONFIG_PATH);
 }
+function listChannelInstances(config) {
+  return [...config?.channels || loadConfig().channels || []];
+}
+function findChannelInstance(channelId, config) {
+  return listChannelInstances(config).find((channel) => channel.id === channelId);
+}
 function configToSettings(config) {
   const m = /* @__PURE__ */ new Map();
+  const current = {
+    schemaVersion: 2,
+    runtime: {
+      provider: config.runtime,
+      defaultMode: config.defaultMode
+    },
+    channels: config.channels || []
+  };
+  const feishu = getChannelByProvider(current, "feishu");
+  const weixin = getChannelByProvider(current, "weixin");
+  const feishuConfig = toFeishuConfig(feishu);
+  const weixinConfig = toWeixinConfig(weixin);
   m.set("remote_bridge_enabled", "true");
+  if (config.defaultWorkspaceRoot) {
+    m.set("bridge_default_workspace_root", config.defaultWorkspaceRoot);
+  }
+  if (config.defaultModel) {
+    m.set("bridge_default_model", config.defaultModel);
+    m.set("default_model", config.defaultModel);
+  }
+  m.set("bridge_default_mode", config.defaultMode);
+  m.set(
+    "bridge_history_message_limit",
+    String(config.historyMessageLimit && config.historyMessageLimit > 0 ? config.historyMessageLimit : 8)
+  );
+  m.set(
+    "bridge_codex_skip_git_repo_check",
+    config.codexSkipGitRepoCheck === true ? "true" : "false"
+  );
+  m.set(
+    "bridge_codex_sandbox_mode",
+    config.codexSandboxMode || "workspace-write"
+  );
+  m.set(
+    "bridge_codex_reasoning_effort",
+    config.codexReasoningEffort || "medium"
+  );
+  m.set(
+    "bridge_channel_instances_json",
+    JSON.stringify(config.channels || [])
+  );
   m.set(
     "bridge_telegram_enabled",
     config.enabledChannels.includes("telegram") ? "true" : "false"
   );
   if (config.tgBotToken) m.set("telegram_bot_token", config.tgBotToken);
-  if (config.tgAllowedUsers)
-    m.set("telegram_bridge_allowed_users", config.tgAllowedUsers.join(","));
+  if (config.tgAllowedUsers) m.set("telegram_bridge_allowed_users", config.tgAllowedUsers.join(","));
   if (config.tgChatId) m.set("telegram_chat_id", config.tgChatId);
   m.set(
     "bridge_discord_enabled",
     config.enabledChannels.includes("discord") ? "true" : "false"
   );
-  if (config.discordBotToken)
-    m.set("bridge_discord_bot_token", config.discordBotToken);
-  if (config.discordAllowedUsers)
-    m.set("bridge_discord_allowed_users", config.discordAllowedUsers.join(","));
-  if (config.discordAllowedChannels)
-    m.set(
-      "bridge_discord_allowed_channels",
-      config.discordAllowedChannels.join(",")
-    );
-  if (config.discordAllowedGuilds)
-    m.set(
-      "bridge_discord_allowed_guilds",
-      config.discordAllowedGuilds.join(",")
-    );
+  if (config.discordBotToken) m.set("bridge_discord_bot_token", config.discordBotToken);
+  if (config.discordAllowedUsers) m.set("bridge_discord_allowed_users", config.discordAllowedUsers.join(","));
+  if (config.discordAllowedChannels) m.set("bridge_discord_allowed_channels", config.discordAllowedChannels.join(","));
+  if (config.discordAllowedGuilds) m.set("bridge_discord_allowed_guilds", config.discordAllowedGuilds.join(","));
   m.set(
     "bridge_feishu_enabled",
-    config.enabledChannels.includes("feishu") ? "true" : "false"
+    feishu?.enabled === true ? "true" : "false"
   );
-  if (config.feishuAppId) m.set("bridge_feishu_app_id", config.feishuAppId);
-  if (config.feishuAppSecret)
-    m.set("bridge_feishu_app_secret", config.feishuAppSecret);
-  if (config.feishuDomain) m.set("bridge_feishu_domain", config.feishuDomain);
-  if (config.feishuAllowedUsers)
-    m.set("bridge_feishu_allowed_users", config.feishuAllowedUsers.join(","));
+  if (feishuConfig?.appId) m.set("bridge_feishu_app_id", feishuConfig.appId);
+  if (feishuConfig?.appSecret) m.set("bridge_feishu_app_secret", feishuConfig.appSecret);
+  if (feishuConfig?.site) m.set("bridge_feishu_site", feishuConfig.site);
+  if (feishuConfig?.allowedUsers) m.set("bridge_feishu_allowed_users", feishuConfig.allowedUsers.join(","));
   m.set(
     "bridge_feishu_streaming_enabled",
-    config.feishuStreamingEnabled === false ? "false" : "true"
+    feishuConfig?.streamingEnabled === false ? "false" : "true"
   );
   m.set(
     "bridge_feishu_command_markdown_enabled",
-    config.feishuCommandMarkdownEnabled === false ? "false" : "true"
+    feishuConfig?.feedbackMarkdownEnabled === false ? "false" : "true"
   );
   m.set(
     "bridge_qq_enabled",
@@ -4818,50 +4973,26 @@ function configToSettings(config) {
   );
   if (config.qqAppId) m.set("bridge_qq_app_id", config.qqAppId);
   if (config.qqAppSecret) m.set("bridge_qq_app_secret", config.qqAppSecret);
-  if (config.qqAllowedUsers)
-    m.set("bridge_qq_allowed_users", config.qqAllowedUsers.join(","));
-  if (config.qqImageEnabled !== void 0)
+  if (config.qqAllowedUsers) m.set("bridge_qq_allowed_users", config.qqAllowedUsers.join(","));
+  if (config.qqImageEnabled !== void 0) {
     m.set("bridge_qq_image_enabled", String(config.qqImageEnabled));
-  if (config.qqMaxImageSize !== void 0)
+  }
+  if (config.qqMaxImageSize !== void 0) {
     m.set("bridge_qq_max_image_size", String(config.qqMaxImageSize));
+  }
   m.set(
     "bridge_weixin_enabled",
-    config.enabledChannels.includes("weixin") ? "true" : "false"
-  );
-  if (config.weixinMediaEnabled !== void 0)
-    m.set("bridge_weixin_media_enabled", String(config.weixinMediaEnabled));
-  m.set(
-    "bridge_weixin_command_markdown_enabled",
-    config.weixinCommandMarkdownEnabled === true ? "true" : "false"
+    weixin?.enabled === true ? "true" : "false"
   );
-  if (config.weixinBaseUrl)
-    m.set("bridge_weixin_base_url", config.weixinBaseUrl);
-  if (config.weixinCdnBaseUrl)
-    m.set("bridge_weixin_cdn_base_url", config.weixinCdnBaseUrl);
-  if (config.defaultWorkspaceRoot) {
-    m.set("bridge_default_workspace_root", config.defaultWorkspaceRoot);
+  if (weixinConfig?.mediaEnabled !== void 0) {
+    m.set("bridge_weixin_media_enabled", String(weixinConfig.mediaEnabled));
   }
-  if (config.defaultModel) {
-    m.set("bridge_default_model", config.defaultModel);
-    m.set("default_model", config.defaultModel);
-  }
-  m.set("bridge_default_mode", config.defaultMode);
-  m.set(
-    "bridge_history_message_limit",
-    String(config.historyMessageLimit && config.historyMessageLimit > 0 ? config.historyMessageLimit : 8)
-  );
-  m.set(
-    "bridge_codex_skip_git_repo_check",
-    config.codexSkipGitRepoCheck === true ? "true" : "false"
-  );
-  m.set(
-    "bridge_codex_sandbox_mode",
-    config.codexSandboxMode || "workspace-write"
-  );
   m.set(
-    "bridge_codex_reasoning_effort",
-    config.codexReasoningEffort || "medium"
+    "bridge_weixin_command_markdown_enabled",
+    weixinConfig?.feedbackMarkdownEnabled === true ? "true" : "false"
   );
+  if (weixinConfig?.baseUrl) m.set("bridge_weixin_base_url", weixinConfig.baseUrl);
+  if (weixinConfig?.cdnBaseUrl) m.set("bridge_weixin_cdn_base_url", weixinConfig.cdnBaseUrl);
   return m;
 }
 
@@ -5598,8 +5729,24 @@ function isArchivedDesktopThread(threadId) {
 
 // src/session-bindings.ts
 import path4 from "node:path";
-function formatChannelLabel(channelType) {
-  return channelType === "weixin" ? "\u5FAE\u4FE1" : channelType === "feishu" ? "\u98DE\u4E66" : channelType;
+function asChannelProvider(value) {
+  return value === "feishu" || value === "weixin" ? value : void 0;
+}
+function resolveChannelMeta(channelType, provider) {
+  const instance = findChannelInstance(channelType, loadConfig());
+  if (instance) {
+    return {
+      provider: instance.provider,
+      alias: instance.alias
+    };
+  }
+  return {
+    provider,
+    alias: channelType
+  };
+}
+function formatChannelLabel(binding) {
+  return binding.channelAlias?.trim() || resolveChannelMeta(binding.channelType, asChannelProvider(binding.channelProvider)).alias || binding.channelType;
 }
 function formatBindingChatTarget(binding) {
   return binding.chatDisplayName?.trim() || binding.chatId;
@@ -5620,7 +5767,7 @@ function assertBindingTargetAvailable(store, current, opts) {
   );
   if (!conflict) return;
   throw new Error(
-    `\u8BE5\u4F1A\u8BDD\u5DF2\u7ED1\u5B9A\u5230 ${formatChannelLabel(conflict.channelType)} \u804A\u5929 ${formatBindingChatTarget(conflict)}\u3002\u4E00\u4E2A\u4F1A\u8BDD\u53EA\u80FD\u7ED1\u5B9A\u4E00\u4E2A\u804A\u5929\u3002`
+    `\u8BE5\u4F1A\u8BDD\u5DF2\u7ED1\u5B9A\u5230 ${formatChannelLabel(conflict)} \u804A\u5929 ${formatBindingChatTarget(conflict)}\u3002\u4E00\u4E2A\u4F1A\u8BDD\u53EA\u80FD\u7ED1\u5B9A\u4E00\u4E2A\u804A\u5929\u3002`
   );
 }
 function getSessionName(session) {
@@ -5641,8 +5788,11 @@ function bindStoreToSession(store, channelType, chatId, sessionId) {
     { channelType, chatId },
     { sessionId: session.id, sdkSessionId: session.sdk_session_id || void 0 }
   );
+  const meta = resolveChannelMeta(channelType);
   return store.upsertChannelBinding({
     channelType,
+    channelProvider: meta.provider,
+    channelAlias: meta.alias,
     chatId,
     codepilotSessionId: session.id,
     sdkSessionId: session.sdk_session_id || "",
@@ -5657,10 +5807,13 @@ function bindStoreToSdkSession(store, channelType, chatId, sdkSessionId, opts) {
     { channelType, chatId },
     { sdkSessionId }
   );
+  const meta = resolveChannelMeta(channelType);
   const existing = store.findSessionBySdkSessionId(sdkSessionId);
   if (existing) {
     return store.upsertChannelBinding({
       channelType,
+      channelProvider: meta.provider,
+      channelAlias: meta.alias,
       chatId,
       codepilotSessionId: existing.id,
       sdkSessionId,
@@ -5682,6 +5835,8 @@ function bindStoreToSdkSession(store, channelType, chatId, sdkSessionId, opts) {
   store.updateSdkSessionId(session.id, sdkSessionId);
   return store.upsertChannelBinding({
     channelType,
+    channelProvider: meta.provider,
+    channelAlias: meta.alias,
     chatId,
     codepilotSessionId: session.id,
     sdkSessionId,
@@ -5716,6 +5871,8 @@ function listBindingSummaries(store) {
     return {
       id: binding.id,
       channelType: binding.channelType,
+      channelProvider: binding.channelProvider,
+      channelAlias: binding.channelAlias,
       chatId: binding.chatId,
       chatUserId: binding.chatUserId,
       chatDisplayName: binding.chatDisplayName,
@@ -5733,7 +5890,9 @@ function listBindingSummaries(store) {
       mirrorLastEventAt: session?.mirror_last_event_at
     };
   }).sort((a, b) => {
-    if (a.channelType !== b.channelType) return a.channelType.localeCompare(b.channelType);
+    const aLabel = a.channelAlias || a.channelType;
+    const bLabel = b.channelAlias || b.channelType;
+    if (aLabel !== bLabel) return aLabel.localeCompare(bLabel);
     return a.chatId.localeCompare(b.chatId);
   });
 }
@@ -5788,6 +5947,8 @@ var bridgePidFile = path5.join(runtimeDir, "bridge.pid");
 var bridgeStatusFile = path5.join(runtimeDir, "status.json");
 var uiStatusFile = path5.join(runtimeDir, "ui-server.json");
 var uiPort = 4781;
+var bridgeAutostartTaskName = "CodexToIMBridge";
+var bridgeAutostartLauncherFile = path5.join(runtimeDir, "bridge-autostart.ps1");
 var WINDOWS_HIDE = process.platform === "win32" ? { windowsHide: true } : {};
 function ensureDirs() {
   fs4.mkdirSync(runtimeDir, { recursive: true });
@@ -5821,6 +5982,49 @@ function isProcessAlive(pid) {
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function getCurrentWindowsUser() {
+  const user = process.env.USERNAME || os4.userInfo().username;
+  const domain = process.env.USERDOMAIN;
+  return domain ? `${domain}\\${user}` : user;
+}
+function escapePowerShellSingleQuoted(value) {
+  return value.replace(/'/g, "''");
+}
+function runCommand(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      stdio: ["ignore", "pipe", "pipe"],
+      ...WINDOWS_HIDE
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      resolve({ code: code ?? 0, stdout, stderr });
+    });
+  });
+}
+async function runPowerShell(script) {
+  const result = await runCommand(
+    "powershell.exe",
+    ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", script]
+  );
+  if (result.code !== 0) {
+    throw new Error((result.stderr || result.stdout || "PowerShell command failed.").trim());
+  }
+  return result.stdout.trim();
+}
+function parsePowerShellJson(raw) {
+  return JSON.parse(raw);
+}
 function getPackageRoot() {
   return packageRoot;
 }
@@ -5932,6 +6136,60 @@ async function restartBridge() {
   await stopBridge();
   return await startBridge();
 }
+async function getBridgeAutostartStatus() {
+  const base = {
+    supported: process.platform === "win32",
+    installed: false,
+    enabled: false,
+    mode: "startup",
+    taskName: bridgeAutostartTaskName,
+    runAsUser: process.platform === "win32" ? getCurrentWindowsUser() : void 0,
+    launcherPath: bridgeAutostartLauncherFile
+  };
+  if (process.platform !== "win32") {
+    return {
+      ...base,
+      error: "\u5F53\u524D\u53EA\u652F\u6301 Windows \u81EA\u52A8\u542F\u52A8\u3002"
+    };
+  }
+  const script = [
+    `$task = Get-ScheduledTask -TaskName '${escapePowerShellSingleQuoted(bridgeAutostartTaskName)}' -ErrorAction SilentlyContinue`,
+    "if (-not $task) {",
+    "  [pscustomobject]@{",
+    "    supported = $true",
+    "    installed = $false",
+    "    enabled = $false",
+    `    mode = 'startup'`,
+    `    taskName = '${escapePowerShellSingleQuoted(bridgeAutostartTaskName)}'`,
+    `    launcherPath = '${escapePowerShellSingleQuoted(bridgeAutostartLauncherFile)}'`,
+    "  } | ConvertTo-Json -Compress",
+    "  exit 0",
+    "}",
+    `$info = Get-ScheduledTaskInfo -TaskName '${escapePowerShellSingleQuoted(bridgeAutostartTaskName)}' -ErrorAction SilentlyContinue`,
+    "[pscustomobject]@{",
+    "  supported = $true",
+    "  installed = $true",
+    "  enabled = [bool]$task.Settings.Enabled",
+    `  mode = 'startup'`,
+    `  taskName = '${escapePowerShellSingleQuoted(bridgeAutostartTaskName)}'`,
+    `  launcherPath = '${escapePowerShellSingleQuoted(bridgeAutostartLauncherFile)}'`,
+    "  runAsUser = $task.Principal.UserId",
+    "  state = [string]$task.State",
+    "} | ConvertTo-Json -Compress"
+  ].join("\n");
+  try {
+    const raw = await runPowerShell(script);
+    return {
+      ...base,
+      ...parsePowerShellJson(raw)
+    };
+  } catch (error) {
+    return {
+      ...base,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
 function getBridgeLogs(lines = 200) {
   ensureDirs();
   const filePath = path5.join(logsDir, "bridge.log");
@@ -6007,6 +6265,35 @@ function uuid() {
 function now() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
+function defaultAliasForProvider2(provider) {
+  if (provider === "feishu") return "\u98DE\u4E66";
+  if (provider === "weixin") return "\u5FAE\u4FE1";
+  return void 0;
+}
+function normalizeLegacyBinding(binding) {
+  const config = loadConfig();
+  const legacyProvider = binding.channelType === "feishu" || binding.channelType === "weixin" ? binding.channelType : void 0;
+  const resolvedInstance = legacyProvider ? (config.channels || []).find((channel) => channel.provider === legacyProvider) : findChannelInstance(binding.channelType, config);
+  if (!resolvedInstance && !legacyProvider) {
+    return {
+      ...binding,
+      active: binding.active !== false
+    };
+  }
+  const channelType = resolvedInstance?.id || binding.channelType;
+  const channelProvider = resolvedInstance?.provider || legacyProvider || binding.channelProvider;
+  const channelAlias = resolvedInstance?.alias || binding.channelAlias || defaultAliasForProvider2(channelProvider);
+  return {
+    ...binding,
+    channelType,
+    channelProvider,
+    channelAlias,
+    active: binding.active !== false
+  };
+}
+function didBindingChange(before, after) {
+  return before.channelType !== after.channelType || before.channelProvider !== after.channelProvider || before.channelAlias !== after.channelAlias || before.active !== false !== after.active;
+}
 var JsonFileStore = class {
   settings;
   dynamicSettings;
@@ -6064,7 +6351,19 @@ var JsonFileStore = class {
       path6.join(DATA_DIR, "bindings.json"),
       {}
     );
-    this.bindings = new Map(Object.entries(bindings));
+    const normalized = /* @__PURE__ */ new Map();
+    let changed = false;
+    for (const binding of Object.values(bindings)) {
+      const normalizedBinding = normalizeLegacyBinding(binding);
+      if (didBindingChange(binding, normalizedBinding)) {
+        changed = true;
+      }
+      normalized.set(`${normalizedBinding.channelType}:${normalizedBinding.chatId}`, normalizedBinding);
+    }
+    this.bindings = normalized;
+    if (changed) {
+      this.persistBindings();
+    }
   }
   persistSessions() {
     writeJson(
@@ -6144,6 +6443,8 @@ var JsonFileStore = class {
         ...existing,
         codepilotSessionId: data.codepilotSessionId,
         sdkSessionId: data.sdkSessionId ?? existing.sdkSessionId,
+        channelProvider: data.channelProvider ?? existing.channelProvider,
+        channelAlias: data.channelAlias ?? existing.channelAlias,
         chatUserId: data.chatUserId ?? existing.chatUserId,
         chatDisplayName: data.chatDisplayName ?? existing.chatDisplayName,
         workingDirectory: data.workingDirectory,
@@ -6158,6 +6459,8 @@ var JsonFileStore = class {
     const binding = {
       id: uuid(),
       channelType: data.channelType,
+      channelProvider: data.channelProvider,
+      channelAlias: data.channelAlias,
       chatId: data.chatId,
       chatUserId: data.chatUserId,
       chatDisplayName: data.chatDisplayName,
@@ -6791,10 +7094,9 @@ async function refreshSession(previous, baseUrl) {
   console.log(`[weixin-login] QR code refreshed (${next.refreshCount}/${MAX_REFRESHES})`);
   return next;
 }
-async function runWeixinLogin() {
+async function runWeixinLogin(config = {}) {
   ensureRuntimeDir();
-  const config = loadConfig();
-  let session = await createSession(0, config.weixinBaseUrl);
+  let session = await createSession(0, config.baseUrl);
   await writeQrHtml(session);
   const opened = openQrHtml();
   console.log("[weixin-login] WeChat QR login started");
@@ -6805,10 +7107,10 @@ async function runWeixinLogin() {
   let lastStatus = session.status;
   while (true) {
     if (Date.now() - session.startedAt > QR_TTL_MS) {
-      session = await refreshSession(session, config.weixinBaseUrl);
+      session = await refreshSession(session, config.baseUrl);
       lastStatus = session.status;
     }
-    const response = await pollLoginQrStatus(session.qrcode, config.weixinBaseUrl);
+    const response = await pollLoginQrStatus(session.qrcode, config.baseUrl);
     switch (response.status) {
       case "wait":
         session.status = "waiting";
@@ -6826,8 +7128,8 @@ async function runWeixinLogin() {
         upsertWeixinAccount({
           accountId,
           userId: response.ilink_user_id || "",
-          baseUrl: config.weixinBaseUrl || response.baseurl || DEFAULT_BASE_URL,
-          cdnBaseUrl: config.weixinCdnBaseUrl || DEFAULT_CDN_BASE_URL,
+          baseUrl: config.baseUrl || response.baseurl || DEFAULT_BASE_URL,
+          cdnBaseUrl: config.cdnBaseUrl || DEFAULT_CDN_BASE_URL,
           token: response.bot_token,
           name: accountId,
           enabled: true
@@ -6840,7 +7142,7 @@ async function runWeixinLogin() {
         return { accountId, htmlPath: HTML_PATH };
       }
       case "expired":
-        session = await refreshSession(session, config.weixinBaseUrl);
+        session = await refreshSession(session, config.baseUrl);
         lastStatus = session.status;
         continue;
       default:
@@ -6928,13 +7230,12 @@ function listSelectableCodexModels(cachePath = DEFAULT_CODEX_MODELS_CACHE_PATH)
 // src/ui-server.ts
 var port = 4781;
 var serverStartTime = (/* @__PURE__ */ new Date()).toISOString();
-var supportedChannels = ["feishu", "weixin"];
 var AUTH_COOKIE_NAME = "cti_ui_auth";
 var availableCodexModels = listSelectableCodexModels();
 var availableCodexModelSlugs = new Set(availableCodexModels.map((model) => model.slug));
 var FEISHU_CHAT_LABEL_TTL_MS = 5 * 60 * 1e3;
 var feishuChatLabelCache = /* @__PURE__ */ new Map();
-var feishuTenantTokenCache = null;
+var feishuTenantTokenCache = /* @__PURE__ */ new Map();
 function parsePreferredPort() {
   const raw = Number(process.env.CTI_UI_PORT || "4781");
   if (!Number.isInteger(raw) || raw <= 0 || raw > 65535) return 4781;
@@ -7019,9 +7320,47 @@ function parsePositiveInt2(value, fallback) {
   if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
   return Math.floor(parsed);
 }
+function normalizeChannelAlias(value, provider) {
+  const trimmed = value?.trim();
+  if (trimmed) return trimmed;
+  return provider === "feishu" ? "\u98DE\u4E66" : "\u5FAE\u4FE1";
+}
+function normalizeChannelId2(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || "channel";
+}
+function buildChannelId(provider, alias, takenIds, currentId) {
+  const base = normalizeChannelId2(`${provider}-${alias}`);
+  if (!takenIds.has(base) || base === currentId) return base;
+  let suffix = 2;
+  while (takenIds.has(`${base}-${suffix}`) && `${base}-${suffix}` !== currentId) {
+    suffix += 1;
+  }
+  return `${base}-${suffix}`;
+}
+function parseChannelProvider(value) {
+  if (value === "feishu" || value === "weixin") return value;
+  return void 0;
+}
 function createUiStore() {
   return new JsonFileStore(configToSettings(loadConfig()));
 }
+function cloneChannel(channel) {
+  return {
+    ...channel,
+    config: { ...channel.config }
+  };
+}
+function channelToPayload(channel) {
+  return {
+    id: channel.id,
+    alias: channel.alias,
+    provider: channel.provider,
+    enabled: channel.enabled,
+    createdAt: channel.createdAt,
+    updatedAt: channel.updatedAt,
+    config: { ...channel.config }
+  };
+}
 function generateAccessToken() {
   return crypto4.randomBytes(18).toString("base64url");
 }
@@ -7093,7 +7432,6 @@ function isRemoteAuthenticated(request, config) {
 function configToPayload(config) {
   return {
     runtime: config.runtime,
-    enabledChannels: config.enabledChannels,
     defaultWorkspaceRoot: config.defaultWorkspaceRoot || "",
     defaultModel: config.defaultModel || "",
     codexDefaultModel: readConfiguredCodexModel() || "",
@@ -7106,27 +7444,19 @@ function configToPayload(config) {
     uiAllowLan: config.uiAllowLan === true,
     uiAccessToken: config.uiAccessToken || "",
     autoApprove: config.autoApprove === true,
-    feishuAppId: config.feishuAppId || "",
-    feishuAppSecret: config.feishuAppSecret || "",
-    feishuDomain: config.feishuDomain || "https://open.feishu.cn",
-    feishuAllowedUsers: config.feishuAllowedUsers?.join(",") || "",
-    feishuStreamingEnabled: config.feishuStreamingEnabled !== false,
-    feishuCommandMarkdownEnabled: config.feishuCommandMarkdownEnabled !== false,
-    weixinMediaEnabled: config.weixinMediaEnabled === true,
-    weixinCommandMarkdownEnabled: config.weixinCommandMarkdownEnabled === true
+    channels: (config.channels || []).map(channelToPayload)
   };
 }
 function mergeConfig(payload) {
   const current = loadConfig();
   const rawDefaultModel = typeof payload.defaultModel === "string" ? payload.defaultModel.trim() : void 0;
-  const requestedChannels = Array.isArray(payload.enabledChannels) ? payload.enabledChannels.filter((value) => typeof value === "string") : current.enabledChannels;
   const uiAllowLan = payload.uiAllowLan === true;
   const requestedUiAccessToken = asString(payload.uiAccessToken);
   const uiAccessToken = requestedUiAccessToken || current.uiAccessToken || (uiAllowLan ? generateAccessToken() : void 0);
   return {
     ...current,
     runtime: payload.runtime === "claude" || payload.runtime === "auto" ? payload.runtime : "codex",
-    enabledChannels: requestedChannels.filter((channel) => supportedChannels.includes(channel)),
+    enabledChannels: current.enabledChannels,
     defaultWorkspaceRoot: asString(payload.defaultWorkspaceRoot),
     defaultModel: rawDefaultModel === void 0 ? current.defaultModel : rawDefaultModel === "" ? void 0 : availableCodexModelSlugs.has(rawDefaultModel) ? rawDefaultModel : current.defaultModel,
     defaultMode: payload.defaultMode === "plan" || payload.defaultMode === "ask" ? payload.defaultMode : "code",
@@ -7137,14 +7467,57 @@ function mergeConfig(payload) {
     uiAllowLan,
     uiAccessToken,
     autoApprove: payload.autoApprove === true,
-    feishuAppId: asString(payload.feishuAppId),
-    feishuAppSecret: asString(payload.feishuAppSecret),
-    feishuDomain: asString(payload.feishuDomain) || "https://open.feishu.cn",
-    feishuAllowedUsers: parseCsv(payload.feishuAllowedUsers),
-    feishuStreamingEnabled: payload.feishuStreamingEnabled !== false,
-    feishuCommandMarkdownEnabled: payload.feishuCommandMarkdownEnabled !== false,
-    weixinMediaEnabled: payload.weixinMediaEnabled === true,
-    weixinCommandMarkdownEnabled: payload.weixinCommandMarkdownEnabled === true
+    channels: current.channels
+  };
+}
+function mergeChannelInstance(payload, current) {
+  const provider = parseChannelProvider(payload.provider);
+  if (!provider) {
+    throw new Error("\u901A\u9053\u63D0\u4F9B\u65B9\u53EA\u80FD\u662F\u98DE\u4E66\u6216\u5FAE\u4FE1\u3002");
+  }
+  const existingId = asString(payload.id);
+  const existing = existingId ? findChannelInstance(existingId, current) : void 0;
+  const alias = normalizeChannelAlias(asString(payload.alias), provider);
+  const baseChannels = (current.channels || []).map(cloneChannel);
+  const takenIds = new Set(baseChannels.map((channel) => channel.id));
+  const channelId = existing?.id || buildChannelId(provider, alias, takenIds);
+  const now3 = (/* @__PURE__ */ new Date()).toISOString();
+  let nextConfig;
+  if (provider === "feishu") {
+    nextConfig = {
+      appId: asString(payload.appId),
+      appSecret: asString(payload.appSecret),
+      site: normalizeFeishuSite(asString(payload.site) || asString(payload.domain)),
+      allowedUsers: parseCsv(payload.allowedUsers),
+      streamingEnabled: payload.streamingEnabled !== false,
+      feedbackMarkdownEnabled: payload.feedbackMarkdownEnabled !== false
+    };
+  } else {
+    nextConfig = {
+      accountId: asString(payload.accountId),
+      baseUrl: asString(payload.baseUrl),
+      cdnBaseUrl: asString(payload.cdnBaseUrl),
+      mediaEnabled: payload.mediaEnabled === true,
+      feedbackMarkdownEnabled: payload.feedbackMarkdownEnabled === true
+    };
+  }
+  const nextChannel = {
+    id: channelId,
+    alias,
+    provider,
+    enabled: payload.enabled !== false,
+    createdAt: existing?.createdAt || now3,
+    updatedAt: now3,
+    config: nextConfig
+  };
+  const nextChannels = existing ? baseChannels.map((channel) => channel.id === existing.id ? nextChannel : channel) : [...baseChannels, nextChannel];
+  return {
+    config: {
+      ...current,
+      channels: nextChannels,
+      enabledChannels: Array.from(new Set(nextChannels.filter((channel) => channel.enabled).map((channel) => channel.provider)))
+    },
+    channel: nextChannel
   };
 }
 function getWeixinAccountsPayload() {
@@ -7159,17 +7532,38 @@ function getWeixinAccountsPayload() {
     updatedAt: account.updatedAt
   }));
 }
-async function validateFeishuCredentials(config) {
-  if (!config.feishuAppId || !config.feishuAppSecret) {
+function getChannelLabel(channel) {
+  const providerLabel = channel.provider === "weixin" ? "\u5FAE\u4FE1" : "\u98DE\u4E66";
+  return channel.alias?.trim() ? `${channel.alias} \xB7 ${providerLabel}` : providerLabel;
+}
+function getFeishuSite(channel) {
+  const feishu = channel.config;
+  return normalizeFeishuSite(feishu.site);
+}
+function getFeishuDomain(channel) {
+  return feishuSiteToApiBaseUrl(getFeishuSite(channel));
+}
+function getFeishuTokenCacheKey(channel) {
+  const feishu = channel.config;
+  return [
+    channel.id,
+    feishu.appId || "",
+    feishu.appSecret || "",
+    getFeishuDomain(channel)
+  ].join(":");
+}
+async function validateFeishuCredentials(channel) {
+  const feishu = channel.config;
+  if (!feishu.appId || !feishu.appSecret) {
     return { ok: false, message: "Feishu App ID / App Secret \u4E0D\u80FD\u4E3A\u7A7A\u3002" };
   }
-  const domain = config.feishuDomain || "https://open.feishu.cn";
+  const domain = getFeishuDomain(channel);
   const response = await fetch(`${domain}/open-apis/auth/v3/tenant_access_token/internal`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({
-      app_id: config.feishuAppId,
-      app_secret: config.feishuAppSecret
+      app_id: feishu.appId,
+      app_secret: feishu.appSecret
     })
   });
   const data = await response.json();
@@ -7178,42 +7572,40 @@ async function validateFeishuCredentials(config) {
   }
   return {
     ok: false,
-    message: data.msg || `\u98DE\u4E66\u6821\u9A8C\u5931\u8D25\uFF0CHTTP ${response.status}`
+    message: `${getChannelLabel(channel)} \u6821\u9A8C\u5931\u8D25\uFF1A${data.msg || `HTTP ${response.status}`}`
   };
 }
-function getFeishuDomain(config) {
-  return (config.feishuDomain || "https://open.feishu.cn").replace(/\/+$/, "");
-}
-async function getFeishuTenantAccessToken(config) {
-  if (!config.feishuAppId || !config.feishuAppSecret) return null;
-  const domain = getFeishuDomain(config);
+async function getFeishuTenantAccessToken(channel) {
+  const feishu = channel.config;
+  if (!feishu.appId || !feishu.appSecret) return null;
+  const domain = getFeishuDomain(channel);
+  const cacheKey = getFeishuTokenCacheKey(channel);
   const now3 = Date.now();
-  if (feishuTenantTokenCache && feishuTenantTokenCache.appId === config.feishuAppId && feishuTenantTokenCache.appSecret === config.feishuAppSecret && feishuTenantTokenCache.domain === domain && feishuTenantTokenCache.expiresAt > now3 + 6e4) {
-    return feishuTenantTokenCache.token;
+  const cached = feishuTenantTokenCache.get(cacheKey);
+  if (cached && cached.expiresAt > now3 + 6e4) {
+    return cached.token;
   }
   const response = await fetch(`${domain}/open-apis/auth/v3/tenant_access_token/internal`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({
-      app_id: config.feishuAppId,
-      app_secret: config.feishuAppSecret
+      app_id: feishu.appId,
+      app_secret: feishu.appSecret
     })
   });
   const data = await response.json();
   if (!response.ok || data.code !== 0 || !data.tenant_access_token) {
     return null;
   }
-  feishuTenantTokenCache = {
-    appId: config.feishuAppId,
-    appSecret: config.feishuAppSecret,
-    domain,
+  feishuTenantTokenCache.set(cacheKey, {
     token: data.tenant_access_token,
     expiresAt: now3 + Math.max(60, Number(data.expire || 7200)) * 1e3
-  };
+  });
   return data.tenant_access_token;
 }
 async function resolveFeishuBindingDisplay(config, binding) {
-  if (binding.channelType !== "feishu") {
+  const channel = findChannelInstance(binding.channelType, config);
+  if (!channel || channel.provider !== "feishu") {
     return {
       chatDisplayName: binding.chatDisplayName,
       chatUserId: binding.chatUserId
@@ -7226,14 +7618,14 @@ async function resolveFeishuBindingDisplay(config, binding) {
       chatUserId: cached.userId || binding.chatUserId
     };
   }
-  const token = await getFeishuTenantAccessToken(config);
+  const token = await getFeishuTenantAccessToken(channel);
   if (!token) {
     return {
       chatDisplayName: binding.chatDisplayName,
       chatUserId: binding.chatUserId
     };
   }
-  const domain = getFeishuDomain(config);
+  const domain = getFeishuDomain(channel);
   try {
     const chatResponse = await fetch(
       `${domain}/open-apis/im/v1/chats/${encodeURIComponent(binding.chatId)}`,
@@ -7283,7 +7675,7 @@ async function buildBindingsPayload(store, config) {
   const bindings = listBindingSummaries(store);
   const enriched = await Promise.all(bindings.map(async (binding) => {
     const resolved = await resolveFeishuBindingDisplay(config, binding);
-    if (binding.channelType === "feishu" && (resolved.chatDisplayName !== binding.chatDisplayName || resolved.chatUserId !== binding.chatUserId) && (resolved.chatDisplayName || resolved.chatUserId)) {
+    if ((resolved.chatDisplayName !== binding.chatDisplayName || resolved.chatUserId !== binding.chatUserId) && (resolved.chatDisplayName || resolved.chatUserId)) {
       store.updateChannelBinding(binding.id, {
         chatDisplayName: resolved.chatDisplayName,
         chatUserId: resolved.chatUserId
@@ -7297,13 +7689,29 @@ async function buildBindingsPayload(store, config) {
   }));
   return {
     bindings: enriched,
-    channels: {
-      feishu: enriched.filter((binding) => binding.channelType === "feishu"),
-      weixin: enriched.filter((binding) => binding.channelType === "weixin")
-    },
     options: listBindingTargetOptions(store, 12)
   };
 }
+function syncBindingChannelMeta(store, channel) {
+  for (const binding of store.listChannelBindings(channel.id)) {
+    store.updateChannelBinding(binding.id, {
+      channelProvider: channel.provider,
+      channelAlias: channel.alias
+    });
+  }
+}
+function deleteChannelInstance(current, channelId) {
+  const channels = current.channels || [];
+  const nextChannels = channels.filter((channel) => channel.id !== channelId);
+  if (nextChannels.length === channels.length) {
+    throw new Error("\u6307\u5B9A\u7684\u901A\u9053\u4E0D\u5B58\u5728\u3002");
+  }
+  return {
+    ...current,
+    channels: nextChannels,
+    enabledChannels: Array.from(new Set(nextChannels.filter((channel) => channel.enabled).map((channel) => channel.provider)))
+  };
+}
 async function testCodexConnection(config) {
   const provider = new CodexProvider(new PendingPermissions());
   const abortController = new AbortController();
@@ -8202,63 +8610,212 @@ function renderHtml() {
         overflow: hidden;
       }
 
-      .channel-tabs {
-        display: flex;
-        align-items: flex-end;
-        gap: 0;
-        padding: 0 20px;
-        border-bottom: 1px solid var(--border);
-        background: #ffffff;
+      .channel-layout {
+        display: grid;
+        grid-template-columns: 280px minmax(0, 1fr);
+        gap: 20px;
       }
 
-      .command-sections {
+      .channel-sidebar {
+        border-right: 1px solid var(--border);
+        padding-right: 20px;
         display: grid;
-        gap: 14px;
+        gap: 12px;
+        align-content: start;
       }
 
-      .command-section {
-        border: 1px solid var(--border);
-        border-radius: 8px;
-        background: var(--surface-soft);
-        overflow: hidden;
+      .channel-sidebar-meta {
+        color: var(--muted);
+        font-size: 12px;
       }
 
-      .command-section-title {
-        margin: 0;
-        padding: 10px 14px;
-        font-size: 14px;
-        font-weight: 700;
-        border-bottom: 1px solid var(--border);
-        background: #ffffff;
+      .channel-list {
+        display: grid;
+        gap: 8px;
       }
 
-      .command-list {
+      .channel-list-item {
+        width: 100%;
+        text-align: left;
+        border-radius: 10px;
+        padding: 12px 14px;
         display: grid;
+        gap: 8px;
       }
 
-      .command-list-head,
-      .command-item {
-        display: grid;
-        grid-template-columns: 220px 320px minmax(0, 1fr);
-        gap: 16px;
-        padding: 10px 14px;
-        align-items: start;
+      .channel-list-item.active {
+        border-color: rgba(22, 119, 255, 0.30);
+        background: rgba(22, 119, 255, 0.06);
+        color: var(--text);
       }
 
-      .command-list-head {
-        padding-top: 12px;
-        padding-bottom: 8px;
-        color: var(--muted);
-        font-size: 12px;
-        font-weight: 700;
-        text-transform: uppercase;
-        letter-spacing: .04em;
-        background: #fcfcfd;
-        border-top: 1px solid var(--border);
+      .channel-list-item-head {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        gap: 10px;
       }
 
-      .command-item:first-child {
-        border-top: 0;
+      .channel-list-item-title {
+        font-weight: 700;
+        min-width: 0;
+        word-break: break-word;
+      }
+
+      .channel-list-item-provider,
+      .channel-list-item-meta {
+        color: var(--muted);
+        font-size: 12px;
+      }
+
+      .channel-list-item-stats {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        gap: 12px;
+        font-size: 12px;
+        color: var(--muted);
+      }
+
+      .channel-list-item-status {
+        color: var(--text);
+        font-weight: 600;
+      }
+
+      .channel-editor {
+        min-width: 0;
+      }
+
+      .channel-editor-summary {
+        display: grid;
+        grid-template-columns: repeat(3, minmax(0, 1fr));
+        gap: 12px;
+        margin-bottom: 18px;
+      }
+
+      .channel-editor-stat {
+        border: 1px solid var(--border);
+        border-radius: 8px;
+        background: var(--surface-soft);
+        padding: 12px 14px;
+        display: grid;
+        gap: 4px;
+      }
+
+      .channel-editor-stat strong {
+        font-size: 12px;
+        color: var(--muted);
+        font-weight: 600;
+      }
+
+      .channel-editor-stat span {
+        font-size: 14px;
+        font-weight: 700;
+        color: var(--text);
+      }
+
+      .editor-section {
+        border-top: 1px solid var(--border);
+        padding-top: 16px;
+        display: grid;
+        gap: 14px;
+      }
+
+      .editor-section-title {
+        margin: 0;
+        font-size: 14px;
+        font-weight: 700;
+      }
+
+      .toolbar-split {
+        display: flex;
+        justify-content: space-between;
+        align-items: flex-start;
+        gap: 12px;
+        flex-wrap: wrap;
+      }
+
+      .toolbar-danger {
+        display: flex;
+        gap: 10px;
+        flex-wrap: wrap;
+      }
+
+      button.danger {
+        border-color: rgba(220, 38, 38, 0.24);
+        color: var(--danger);
+      }
+
+      button.danger:hover {
+        border-color: var(--danger);
+        color: var(--danger);
+      }
+
+      .inline-select {
+        display: inline-grid;
+        gap: 6px;
+        color: var(--muted);
+        font-size: 12px;
+        font-weight: 500;
+      }
+
+      .channel-tabs {
+        display: flex;
+        align-items: flex-end;
+        gap: 0;
+        padding: 0 20px;
+        border-bottom: 1px solid var(--border);
+        background: #ffffff;
+      }
+
+      .command-sections {
+        display: grid;
+        gap: 14px;
+      }
+
+      .command-section {
+        border: 1px solid var(--border);
+        border-radius: 8px;
+        background: var(--surface-soft);
+        overflow: hidden;
+      }
+
+      .command-section-title {
+        margin: 0;
+        padding: 10px 14px;
+        font-size: 14px;
+        font-weight: 700;
+        border-bottom: 1px solid var(--border);
+        background: #ffffff;
+      }
+
+      .command-list {
+        display: grid;
+      }
+
+      .command-list-head,
+      .command-item {
+        display: grid;
+        grid-template-columns: 220px 320px minmax(0, 1fr);
+        gap: 16px;
+        padding: 10px 14px;
+        align-items: start;
+      }
+
+      .command-list-head {
+        padding-top: 12px;
+        padding-bottom: 8px;
+        color: var(--muted);
+        font-size: 12px;
+        font-weight: 700;
+        text-transform: uppercase;
+        letter-spacing: .04em;
+        background: #fcfcfd;
+        border-top: 1px solid var(--border);
+      }
+
+      .command-item:first-child {
+        border-top: 0;
       }
 
       .command-item code {
@@ -8464,6 +9021,9 @@ function renderHtml() {
         .sidebar { border-right: 0; border-bottom: 1px solid var(--sidebar-border); }
         .nav { grid-template-columns: repeat(6, minmax(0, 1fr)); }
         .main { padding: 20px 20px 28px; }
+        .channel-layout { grid-template-columns: 1fr; }
+        .channel-sidebar { border-right: 0; padding-right: 0; }
+        .channel-editor-summary { grid-template-columns: 1fr; }
         .field-row,
         .field-row.triple,
         .command-item,
@@ -8516,6 +9076,10 @@ function renderHtml() {
               <strong>Bridge</strong>
               <div class="status-value" id="bridgeStatus">-</div>
             </div>
+            <div class="status-card">
+              <strong>Bridge \u5F00\u673A\u81EA\u542F\u52A8</strong>
+              <div class="status-value" id="autostartStatus">-</div>
+            </div>
             <div class="status-card">
               <strong>Codex Skill</strong>
               <div class="status-value" id="integrationStatus">-</div>
@@ -8559,6 +9123,14 @@ function renderHtml() {
                 <div class="notice">\u5DF2\u63A5\u901A\uFF1A\u4FDD\u5B58\u914D\u7F6E\u3001\u540E\u53F0\u542F\u505C\u3001\u98DE\u4E66\u51ED\u636E\u6D4B\u8BD5\u3001\u5FAE\u4FE1\u626B\u7801\u3001Codex \u8FDE\u63A5\u6D4B\u8BD5\u3001\u684C\u9762\u4F1A\u8BDD\u53D1\u73B0\u3001IM \u7ED1\u5B9A\u67E5\u770B\u4E0E\u7F51\u9875\u4FA7\u5207\u6362\u3002</div>
               </div>
 
+              <div class="panel-block">
+                <p class="panel-subtitle">Bridge \u5F00\u673A\u81EA\u542F\u52A8</p>
+                <div class="notice" id="autostartNotice">\u6B63\u5728\u68C0\u67E5\u5F53\u524D Windows \u4EFB\u52A1\u8BA1\u5212\u7A0B\u5E8F\u72B6\u6001\u2026</div>
+                <div class="actions" style="margin-top: 12px;">
+                  <button id="refreshAutostartBtn">\u5237\u65B0\u5F00\u673A\u81EA\u542F\u52A8\u72B6\u6001</button>
+                </div>
+              </div>
+
               <div class="panel-block">
                 <p class="panel-subtitle">\u53EF\u9009 Codex Skill</p>
                 <div class="notice">bridge \u4E0D\u518D\u6CE8\u5165\u53D1\u9001\u9644\u4EF6\u7684\u63D0\u793A\u8BCD\u3002\u9700\u8981\u8BA9 Codex \u77E5\u9053\u201C\u53EF\u4EE5\u628A\u672C\u5730\u56FE\u7247/\u6587\u4EF6\u56DE\u53D1\u5230 IM\u201D\u65F6\uFF0C\u8BF7\u5B89\u88C5\u8FD9\u4E2A\u53EF\u9009 skill\u3002</div>
@@ -8705,10 +9277,8 @@ function renderHtml() {
                 </label>
               </div>
               <div class="small">\u672A\u7ED1\u5B9A\u7684 IM \u804A\u5929\u4F1A\u5148\u8FDB\u5165\u4E34\u65F6\u8349\u7A3F\u7EBF\u7A0B\uFF08\u7B49\u540C <code>/t 0</code>\uFF09\uFF1B\u201C\u9ED8\u8BA4\u5DE5\u4F5C\u7A7A\u95F4\u201D\u53EA\u7528\u4E8E <code>/new proj1</code> \u8FD9\u7C7B\u76F8\u5BF9\u9879\u76EE\u540D\u3002\u7559\u7A7A\u65F6\u4F1A\u6309\u5F53\u524D\u7CFB\u7EDF\u81EA\u52A8\u56DE\u9000\u5230 <code>~/cx2im</code>\u3002\u9ED8\u8BA4\u6A21\u578B\u5019\u9009\u9879\u6765\u81EA\u542F\u52A8\u65F6\u8BFB\u53D6\u7684 Codex \u6A21\u578B\u7F13\u5B58\uFF1A\u9690\u85CF\u6A21\u578B\u4E0D\u4F1A\u5C55\u793A\uFF0CCLI only \u6A21\u578B\u4F1A\u6807\u6210\u201C\u4EC5 IM / CLI\u201D\u3002\u7559\u7A7A\u5219\u7EE7\u7EED\u8DDF\u968F Codex \u5F53\u524D\u9ED8\u8BA4\u6A21\u578B\u3002\u6587\u4EF6\u7CFB\u7EDF\u6743\u9650\u662F\u5168\u5C40\u9ED8\u8BA4\u503C\uFF0C\u601D\u8003\u7EA7\u522B\u53EF\u5728 IM \u4F1A\u8BDD\u91CC\u518D\u5355\u72EC\u8986\u76D6\u3002</div>
-              <div class="small">\u5F53\u524D\u9700\u8981\u91CD\u542F Bridge \u7684\u914D\u7F6E\uFF1A<code>Runtime</code>\u3001<code>\u81EA\u52A8\u6279\u51C6\u5DE5\u5177\u6743\u9650</code>\u3001<code>\u5141\u8BB8\u5728\u672A\u4FE1\u4EFB Git \u76EE\u5F55\u8FD0\u884C Codex</code>\u3001\u98DE\u4E66 <code>App ID</code>/<code>App Secret</code>/<code>Domain</code>\u3002</div>
+              <div class="small">\u5F53\u524D\u9700\u8981\u91CD\u542F Bridge \u7684\u914D\u7F6E\uFF1A<code>Runtime</code>\u3001<code>\u81EA\u52A8\u6279\u51C6\u5DE5\u5177\u6743\u9650</code>\u3001<code>\u5141\u8BB8\u5728\u672A\u4FE1\u4EFB Git \u76EE\u5F55\u8FD0\u884C Codex</code>\u3002\u901A\u9053\u5B9E\u4F8B\u7684\u63A5\u5165\u914D\u7F6E\u8BF7\u5728\u201C\u901A\u9053\u201D\u9875\u7EF4\u62A4\u3002</div>
               <div class="checkbox-row">
-                <label class="checkbox"><input id="channelFeishu" type="checkbox" checked /> \u542F\u7528\u98DE\u4E66</label>
-                <label class="checkbox"><input id="channelWeixin" type="checkbox" /> \u542F\u7528\u5FAE\u4FE1</label>
                 <label class="checkbox"><input id="autoApprove" type="checkbox" /> \u81EA\u52A8\u6279\u51C6\u5DE5\u5177\u6743\u9650</label>
               </div>
               <div class="checkbox-row">
@@ -8813,112 +9383,35 @@ function renderHtml() {
             </div>
           </div>
 
-          <section class="panel channel-shell">
-            <div class="channel-tabs" role="tablist" aria-label="\u901A\u9053\u914D\u7F6E">
-              <button type="button" class="channel-tab active" data-channel="feishu" role="tab" aria-selected="true">\u98DE\u4E66</button>
-              <button type="button" class="channel-tab" data-channel="weixin" role="tab" aria-selected="false">\u5FAE\u4FE1</button>
-            </div>
-
-            <div class="channel-view active" data-channel="feishu" role="tabpanel">
-              <section id="feishu">
-              <div class="panel-header">
-                <div>
-                  <h2>\u98DE\u4E66 / Lark</h2>
-                  <p>\u586B\u5199\u51ED\u636E\u3001\u6D4B\u8BD5\u53EF\u7528\u6027\uFF0C\u5E76\u67E5\u770B\u5F53\u524D\u98DE\u4E66\u804A\u5929\u7ED1\u5B9A\u5230\u54EA\u6761\u4F1A\u8BDD\u3002</p>
-                </div>
-                <div class="toolbar">
-                  <button id="saveFeishuChannelBtn">\u4FDD\u5B58\u901A\u9053\u914D\u7F6E</button>
-                  <button id="testFeishuBtn">\u6D4B\u8BD5\u98DE\u4E66\u51ED\u636E</button>
-                  <button id="refreshFeishuStateBtn">\u5237\u65B0\u72B6\u6001</button>
-                </div>
-              </div>
-
-              <div class="fields">
-                <div class="field-row">
-                  <label>
-                    App ID
-                    <input id="feishuAppId" />
-                  </label>
-                  <label>
-                    App Secret
-                    <input id="feishuAppSecret" />
-                  </label>
-                </div>
-                <div class="field-row">
-                  <label>
-                    Domain
-                    <input id="feishuDomain" value="https://open.feishu.cn" />
-                  </label>
-                  <label>
-                    Allowed Users
-                    <input id="feishuAllowedUsers" placeholder="\u591A\u4E2A user_id \u7528\u9017\u53F7\u5206\u9694" />
-                  </label>
-                </div>
-                <div class="checkbox-row">
-                  <label class="checkbox"><input id="feishuStreamingEnabled" type="checkbox" checked /> \u542F\u7528\u98DE\u4E66\u6D41\u5F0F\u54CD\u5E94\u5361\u7247</label>
-                </div>
-                <div class="checkbox-row">
-                  <label class="checkbox"><input id="feishuCommandMarkdownEnabled" type="checkbox" checked /> \u53CD\u9988\u4F7F\u7528markdown</label>
-                </div>
-                <div class="small">\u9700\u8981\u98DE\u4E66\u4FA7\u5DF2\u5F00\u901A\u53EF\u66F4\u65B0\u5361\u7247\u7684\u76F8\u5173\u80FD\u529B\uFF1B\u5982\u679C\u6743\u9650\u4E0D\u8DB3\uFF0C\u4F1A\u81EA\u52A8\u56DE\u9000\u4E3A\u6700\u7EC8\u7ED3\u679C\u6D88\u606F\u3002</div>
-                <div class="small">\u5F71\u54CD\u901A\u8FC7 bridge \u53D1\u9001\u5230\u98DE\u4E66\u7684\u6587\u672C\u53CD\u9988\uFF0C\u5305\u62EC\u666E\u901A\u56DE\u590D\u3001\u5171\u4EAB\u684C\u9762\u7EBF\u7A0B\u955C\u50CF\u548C <code>/h</code>\u3001<code>/status</code>\u3001<code>/threads</code> \u8FD9\u7C7B\u7CFB\u7EDF\u53CD\u9988\u3002</div>
-                <div class="small">\u4FEE\u6539\u98DE\u4E66 <code>App ID</code>\u3001<code>App Secret</code>\u3001<code>Domain</code> \u540E\uFF0C\u9700\u8981\u91CD\u542F Bridge \u8BA9\u5BA2\u6237\u7AEF\u91CD\u65B0\u521D\u59CB\u5316\uFF1B\u767D\u540D\u5355\u3001\u6D41\u5F0F\u5F00\u5173\u3001markdown \u5F00\u5173\u4F1A\u5373\u65F6\u751F\u6548\u3002</div>
-              </div>
-
-              <div class="panel-block">
-                <p class="panel-subtitle">\u901A\u9053\u72B6\u6001</p>
-                <div class="small" id="feishuRuntimeMeta">\u6B63\u5728\u52A0\u8F7D\u2026</div>
+          <section class="panel channel-workspace">
+            <div class="panel-header">
+              <div>
+                <h2>\u901A\u9053\u5B9E\u4F8B</h2>
+                <p>\u8FD9\u91CC\u7BA1\u7406\u591A\u4E2A\u98DE\u4E66\u6216\u5FAE\u4FE1\u673A\u5668\u4EBA\u5B9E\u4F8B\u3002\u5B9E\u4F8B\u53EA\u662F\u4E0D\u540C\u804A\u5929\u5165\u53E3\uFF0C\u4E0D\u4F1A\u6539\u53D8 Codex \u7684\u4F1A\u8BDD\u8BED\u4E49\u3002</p>
               </div>
-              <div class="panel-block">
-                <p class="panel-subtitle">\u5F53\u524D\u98DE\u4E66\u7ED1\u5B9A</p>
-                <div class="small" id="feishuBindingMeta">\u6B63\u5728\u52A0\u8F7D\u2026</div>
-                <div class="binding-list" id="feishuBindings" style="margin-top: 12px;"></div>
+              <div class="toolbar">
+                <label class="inline-select">
+                  \u65B0\u901A\u9053
+                  <select id="newChannelProvider">
+                    <option value="feishu">\u98DE\u4E66</option>
+                    <option value="weixin">\u5FAE\u4FE1</option>
+                  </select>
+                </label>
+                <button id="createChannelBtn">\u65B0\u589E\u901A\u9053</button>
+                <button id="refreshChannelsBtn">\u5237\u65B0\u72B6\u6001</button>
               </div>
-
-              <div class="message" id="feishuMessage"></div>
-              </section>
             </div>
 
-            <div class="channel-view" data-channel="weixin" role="tabpanel">
-              <section id="wechat">
-              <div class="panel-header">
-                <div>
-                  <h2>\u5FAE\u4FE1</h2>
-                  <p>\u626B\u7801\u767B\u5F55\u5FAE\u4FE1\u5E76\u67E5\u770B\u5F53\u524D\u804A\u5929\u7ED1\u5B9A\u7684\u4F1A\u8BDD\u3002</p>
-                </div>
-                <div class="toolbar">
-                  <button id="saveWeixinChannelBtn">\u4FDD\u5B58\u901A\u9053\u914D\u7F6E</button>
-                  <button id="weixinLoginBtn">\u5F00\u59CB\u5FAE\u4FE1\u626B\u7801</button>
-                  <button id="refreshWeixinStateBtn">\u5237\u65B0\u72B6\u6001</button>
-                </div>
-              </div>
-
-              <div class="fields">
-                <div class="checkbox-row">
-                  <label class="checkbox"><input id="weixinMediaEnabled" type="checkbox" /> \u542F\u7528\u56FE\u7247 / \u6587\u4EF6 / \u89C6\u9891\u5165\u7AD9\u4E0B\u8F7D</label>
-                </div>
-                <div class="checkbox-row">
-                  <label class="checkbox"><input id="weixinCommandMarkdownEnabled" type="checkbox" /> \u53CD\u9988\u4F7F\u7528markdown</label>
-                </div>
-              </div>
-              <div class="small">\u5F71\u54CD\u901A\u8FC7 bridge \u53D1\u9001\u5230\u5FAE\u4FE1\u7684\u6587\u672C\u53CD\u9988\uFF0C\u5305\u62EC\u666E\u901A\u56DE\u590D\u3001\u5171\u4EAB\u684C\u9762\u7EBF\u7A0B\u955C\u50CF\u548C <code>/h</code>\u3001<code>/status</code>\u3001<code>/threads</code> \u8FD9\u7C7B\u7CFB\u7EDF\u53CD\u9988\u3002\u9ED8\u8BA4\u5173\u95ED\u3002</div>
-              <div class="panel-block">
-                <p class="panel-subtitle">\u901A\u9053\u72B6\u6001</p>
-                <div class="small" id="weixinRuntimeMeta">\u6B63\u5728\u52A0\u8F7D\u2026</div>
-              </div>
-              <div class="panel-block">
-                <p class="panel-subtitle">\u5DF2\u767B\u5F55\u5FAE\u4FE1\u8D26\u53F7</p>
-                <div class="small" id="weixinAccountMeta">\u6B63\u5728\u52A0\u8F7D\u2026</div>
-                <div class="binding-list" id="weixinAccounts" style="margin-top: 12px;"></div>
-              </div>
-              <div class="panel-block">
-                <p class="panel-subtitle">\u5F53\u524D\u5FAE\u4FE1\u7ED1\u5B9A</p>
-                <div class="small" id="weixinBindingMeta">\u6B63\u5728\u52A0\u8F7D\u2026</div>
-                <div class="binding-list" id="weixinBindings" style="margin-top: 12px;"></div>
-              </div>
-              <div class="message" id="weixinMessage"></div>
+            <div class="channel-layout">
+              <aside class="channel-sidebar">
+                <div class="channel-sidebar-meta" id="channelListMeta">\u6B63\u5728\u52A0\u8F7D\u2026</div>
+                <div class="channel-list" id="channelList"></div>
+              </aside>
+              <section class="channel-editor" id="channelEditor">
+                <div class="binding-empty">\u6B63\u5728\u52A0\u8F7D\u901A\u9053\u914D\u7F6E\u2026</div>
               </section>
             </div>
+            <div class="message" id="channelMessage"></div>
           </section>
         </section>
 
@@ -8947,17 +9440,16 @@ function renderHtml() {
         availableModels: [],
         uiAccess: null,
         bridgeStatus: null,
+        autostartStatus: null,
         desktopSessions: [],
         bindings: [],
         bindingOptions: [],
-        activeBindingByChannel: {
-          feishu: '',
-          weixin: '',
-        },
+        activeBindingByChannelId: {},
         weixinAccounts: [],
         desktopRoot: '',
         activePage: 'overview',
-        activeChannel: 'feishu',
+        activeChannelId: '',
+        channelDraft: null,
       };
 
       function escapeHtml(value) {
@@ -9068,16 +9560,6 @@ function renderHtml() {
         return binding.chatDisplayName || binding.chatId || binding.id;
       }
 
-      function ensureActiveBinding(channelType, bindings) {
-        const current = state.activeBindingByChannel[channelType];
-        if (current && bindings.some((binding) => binding.id === current)) {
-          return current;
-        }
-        const next = bindings[0] ? bindings[0].id : '';
-        state.activeBindingByChannel[channelType] = next;
-        return next;
-      }
-
       function renderBindingCard(binding) {
         return ''
           + '<article class="binding-item" data-binding-id="' + escapeHtml(binding.id) + '">'
@@ -9099,13 +9581,6 @@ function renderHtml() {
           + '</article>';
       }
 
-      function enabledChannelsFromForm() {
-        const channels = [];
-        if (document.getElementById('channelFeishu').checked) channels.push('feishu');
-        if (document.getElementById('channelWeixin').checked) channels.push('weixin');
-        return channels;
-      }
-
       function formPayload() {
         return {
           runtime: document.getElementById('runtime').value,
@@ -9118,16 +9593,7 @@ function renderHtml() {
           codexReasoningEffort: document.getElementById('codexReasoningEffort').value,
           uiAllowLan: document.getElementById('uiAllowLan').checked,
           uiAccessToken: document.getElementById('uiAccessToken').value,
-          enabledChannels: enabledChannelsFromForm(),
           autoApprove: document.getElementById('autoApprove').checked,
-          feishuAppId: document.getElementById('feishuAppId').value,
-          feishuAppSecret: document.getElementById('feishuAppSecret').value,
-          feishuDomain: document.getElementById('feishuDomain').value,
-          feishuAllowedUsers: document.getElementById('feishuAllowedUsers').value,
-          feishuStreamingEnabled: document.getElementById('feishuStreamingEnabled').checked,
-          feishuCommandMarkdownEnabled: document.getElementById('feishuCommandMarkdownEnabled').checked,
-          weixinMediaEnabled: document.getElementById('weixinMediaEnabled').checked,
-          weixinCommandMarkdownEnabled: document.getElementById('weixinCommandMarkdownEnabled').checked,
         };
       }
 
@@ -9179,7 +9645,7 @@ function renderHtml() {
 
         if (syncHash !== false) {
           const hash = nextPage === 'channels'
-            ? '#channels/' + state.activeChannel
+            ? '#channels/' + (state.activeChannelId || '')
             : '#' + nextPage;
           if (window.location.hash !== hash) {
             history.replaceState(null, '', hash);
@@ -9187,26 +9653,12 @@ function renderHtml() {
         }
       }
 
-      function setActiveChannel(channel, syncHash) {
-        const nextChannel = channel === 'weixin' ? 'weixin' : 'feishu';
-        state.activeChannel = nextChannel;
-
-        document.querySelectorAll('.channel-tab').forEach((element) => {
-          const node = element;
-          const active = node.dataset.channel === nextChannel;
-          node.classList.toggle('active', active);
-          node.setAttribute('aria-selected', active ? 'true' : 'false');
-        });
-
-        document.querySelectorAll('.channel-view').forEach((element) => {
-          const node = element;
-          const active = node.dataset.channel === nextChannel;
-          node.classList.toggle('active', active);
-          node.hidden = !active;
-        });
+      function setActiveChannel(channelId, syncHash) {
+        state.activeChannelId = channelId || '';
+        renderChannelsWorkspace();
 
         if (syncHash !== false && state.activePage === 'channels') {
-          const hash = '#channels/' + nextChannel;
+          const hash = '#channels/' + (state.activeChannelId || '');
           if (window.location.hash !== hash) {
             history.replaceState(null, '', hash);
           }
@@ -9217,13 +9669,12 @@ function renderHtml() {
         const raw = String(window.location.hash || '').replace(/^#/, '');
         if (!raw) {
           setActivePage('overview', false);
-          setActiveChannel('feishu', false);
           return;
         }
 
         if (raw.startsWith('channels/')) {
           setActivePage('channels', false);
-          setActiveChannel(raw.split('/')[1] || 'feishu', false);
+          setActiveChannel(raw.split('/')[1] || '', false);
           return;
         }
 
@@ -9270,21 +9721,44 @@ function renderHtml() {
           });
       }
 
-      function isChannelEnabled(channelType) {
-        return Boolean(state.config && (state.config.enabledChannels || []).includes(channelType));
+      function providerLabel(provider) {
+        if (provider === 'weixin') return '\u5FAE\u4FE1';
+        if (provider === 'feishu') return '\u98DE\u4E66';
+        return '\u901A\u9053';
       }
 
-      function runningChannels() {
-        return state.bridgeStatus && Array.isArray(state.bridgeStatus.channels) ? state.bridgeStatus.channels : [];
+      function configuredChannels() {
+        return Array.isArray(state.config && state.config.channels) ? state.config.channels : [];
       }
 
-      function isChannelRunning(channelType) {
-        return Boolean(state.bridgeStatus && state.bridgeStatus.running && runningChannels().includes(channelType));
+      function visibleChannels() {
+        const channels = configuredChannels().slice();
+        if (state.channelDraft) {
+          channels.push(state.channelDraft);
+        }
+        return channels;
+      }
+
+      function getChannelById(channelId) {
+        if (state.channelDraft && state.channelDraft.id === channelId) return state.channelDraft;
+        return configuredChannels().find((channel) => channel.id === channelId) || null;
+      }
+
+      function adapterStatuses() {
+        return state.bridgeStatus && Array.isArray(state.bridgeStatus.adapters) ? state.bridgeStatus.adapters : [];
+      }
+
+      function getAdapterStatus(channelId) {
+        return adapterStatuses().find((item) => item.channelType === channelId) || null;
+      }
+
+      function isChannelRunning(channelId) {
+        const status = getAdapterStatus(channelId);
+        return Boolean(state.bridgeStatus && state.bridgeStatus.running && status && status.running);
       }
 
       const CONFIG_FIELD_LABELS = {
         runtime: 'Runtime',
-        enabledChannels: '\u901A\u9053\u542F\u7528\u72B6\u6001',
         defaultWorkspaceRoot: '\u9ED8\u8BA4\u5DE5\u4F5C\u7A7A\u95F4',
         defaultModel: '\u9ED8\u8BA4\u6A21\u578B',
         defaultMode: '\u9ED8\u8BA4\u6A21\u5F0F',
@@ -9295,28 +9769,15 @@ function renderHtml() {
         uiAllowLan: '\u5141\u8BB8\u5C40\u57DF\u7F51\u8BBF\u95EE Web \u63A7\u5236\u53F0',
         uiAccessToken: '\u5C40\u57DF\u7F51\u8BBF\u95EE token',
         autoApprove: '\u81EA\u52A8\u6279\u51C6\u5DE5\u5177\u6743\u9650',
-        feishuAppId: '\u98DE\u4E66 App ID',
-        feishuAppSecret: '\u98DE\u4E66 App Secret',
-        feishuDomain: '\u98DE\u4E66 Domain',
-        feishuAllowedUsers: '\u98DE\u4E66 Allowed Users',
-        feishuStreamingEnabled: '\u98DE\u4E66\u6D41\u5F0F\u54CD\u5E94\u5361\u7247',
-        feishuCommandMarkdownEnabled: '\u98DE\u4E66\u53CD\u9988markdown',
-        weixinMediaEnabled: '\u5FAE\u4FE1\u56FE\u7247/\u6587\u4EF6/\u89C6\u9891\u5165\u7AD9\u4E0B\u8F7D',
-        weixinCommandMarkdownEnabled: '\u5FAE\u4FE1\u53CD\u9988markdown',
       };
 
       const BRIDGE_RESTART_FIELDS = new Set([
         'runtime',
         'codexSkipGitRepoCheck',
         'autoApprove',
-        'feishuAppId',
-        'feishuAppSecret',
-        'feishuDomain',
       ]);
 
-      const AUTO_SYNC_FIELDS = new Set([
-        'enabledChannels',
-      ]);
+      const AUTO_SYNC_FIELDS = new Set([]);
 
       const IMMEDIATE_FIELDS = new Set([
         'defaultWorkspaceRoot',
@@ -9327,29 +9788,12 @@ function renderHtml() {
         'codexReasoningEffort',
         'uiAllowLan',
         'uiAccessToken',
-        'feishuAllowedUsers',
-        'feishuStreamingEnabled',
-        'feishuCommandMarkdownEnabled',
-        'weixinMediaEnabled',
-        'weixinCommandMarkdownEnabled',
       ]);
 
       const SAVE_SCOPE_FIELDS = {
         all: null,
-        feishu: new Set([
-          'enabledChannels',
-          'feishuAppId',
-          'feishuAppSecret',
-          'feishuDomain',
-          'feishuAllowedUsers',
-          'feishuStreamingEnabled',
-          'feishuCommandMarkdownEnabled',
-        ]),
-        weixin: new Set([
-          'enabledChannels',
-          'weixinMediaEnabled',
-          'weixinCommandMarkdownEnabled',
-        ]),
+        feishu: new Set([]),
+        weixin: new Set([]),
       };
 
       function normalizeConfigValue(value) {
@@ -9412,63 +9856,40 @@ function renderHtml() {
         return '\u914D\u7F6E\u5DF2\u4FDD\u5B58\u3002' + (notes.length > 0 ? ' ' + notes.join('\uFF1B') + '\u3002' : '');
       }
 
-      function channelLabel(channelType) {
-        return channelType === 'weixin' ? '\u5FAE\u4FE1' : '\u98DE\u4E66';
+      function channelDisplayLabel(channel) {
+        const alias = String(channel.alias || '').trim();
+        const provider = providerLabel(channel.provider);
+        if (!alias) return provider;
+        return alias === provider ? alias : alias + ' \xB7 ' + provider;
       }
 
-      function channelRuntimeText(channelType) {
-        const label = channelLabel(channelType);
-        if (!isChannelEnabled(channelType)) {
-          return label + '\u5728\u914D\u7F6E\u4E2D\u672A\u542F\u7528\u3002';
+      function formatChannelRuntimeLabel(channel) {
+        const label = channelDisplayLabel(channel);
+        if (channel.enabled === false) {
+          return label + '\u5DF2\u505C\u7528\u3002';
         }
         if (!state.bridgeStatus || !state.bridgeStatus.running) {
-          return label + '\u5DF2\u542F\u7528\uFF0C\u4F46 Bridge \u8FD8\u6CA1\u542F\u52A8\u3002\u542F\u52A8 Bridge \u540E\u624D\u4F1A\u771F\u6B63\u63A5\u901A\u3002';
+          return label + '\u5DF2\u914D\u7F6E\uFF0C\u4F46 Bridge \u8FD8\u6CA1\u542F\u52A8\u3002';
         }
-        if (!isChannelRunning(channelType)) {
-          return label + '\u5DF2\u5199\u5165\u914D\u7F6E\uFF0CBridge \u4F1A\u5728\u51E0\u79D2\u5185\u81EA\u52A8\u540C\u6B65\u8FD9\u4E2A\u901A\u9053\uFF1B\u5982\u679C\u9875\u9762\u8FD8\u6CA1\u66F4\u65B0\uFF0C\u53EF\u624B\u52A8\u70B9\u201C\u5237\u65B0\u72B6\u6001\u201D\u3002';
+        const status = getAdapterStatus(channel.id);
+        if (!status || !status.running) {
+          return label + '\u5DF2\u4FDD\u5B58\uFF0CBridge \u4F1A\u5728\u51E0\u79D2\u5185\u81EA\u52A8\u540C\u6B65\u3002';
         }
         return label + '\u5DF2\u63A5\u901A\u5230\u5F53\u524D\u8FD0\u884C\u4E2D\u7684 Bridge\u3002';
       }
 
-      function emptyBindingText(channelType) {
-        const label = channelLabel(channelType);
-        if (!isChannelEnabled(channelType)) {
-          return label + '\u672A\u542F\u7528\u3002\u5148\u5728\u201C\u914D\u7F6E\u201D\u91CC\u52FE\u9009\u540E\u4FDD\u5B58\u3002';
-        }
-        if (!state.bridgeStatus || !state.bridgeStatus.running) {
-          return label + '\u5DF2\u542F\u7528\uFF0C\u4F46 Bridge \u8FD8\u6CA1\u542F\u52A8\u3002\u542F\u52A8\u540E\u624D\u4F1A\u521B\u5EFA\u7ED1\u5B9A\u3002';
-        }
-        if (!isChannelRunning(channelType)) {
-          return label + '\u5DF2\u542F\u7528\uFF0CBridge \u4F1A\u5728\u51E0\u79D2\u5185\u81EA\u52A8\u540C\u6B65\u8FD9\u4E2A\u901A\u9053\uFF1B\u5982\u679C\u9875\u9762\u8FD8\u6CA1\u66F4\u65B0\uFF0C\u53EF\u624B\u52A8\u70B9\u201C\u5237\u65B0\u72B6\u6001\u201D\u3002';
-        }
-        return label + '\u5F53\u524D\u8FD8\u6CA1\u6709\u804A\u5929\u63A5\u5165\u3002\u5148\u4ECE' + label + '\u53D1\u4E00\u6761\u6D88\u606F\uFF0Cbridge \u624D\u4F1A\u521B\u5EFA\u7ED1\u5B9A\u3002';
-      }
-
-      function quickSwitchState(channelType) {
-        const label = channelLabel(channelType);
-        if (!isChannelEnabled(channelType)) {
-          return { disabled: true, title: label + '\u672A\u542F\u7528\u3002' };
+      function emptyBindingText(channel) {
+        const label = channelDisplayLabel(channel);
+        if (channel.enabled === false) {
+          return label + '\u5DF2\u505C\u7528\u3002\u542F\u7528\u540E\u624D\u4F1A\u521B\u5EFA\u804A\u5929\u7ED1\u5B9A\u3002';
         }
         if (!state.bridgeStatus || !state.bridgeStatus.running) {
-          return { disabled: true, title: 'Bridge \u8FD8\u6CA1\u542F\u52A8\u3002\u542F\u52A8\u540E\u518D\u5207\u6362' + label + '\u4F1A\u8BDD\u3002' };
+          return label + '\u5DF2\u914D\u7F6E\uFF0C\u4F46 Bridge \u8FD8\u6CA1\u542F\u52A8\u3002\u542F\u52A8\u540E\u624D\u4F1A\u521B\u5EFA\u7ED1\u5B9A\u3002';
         }
-        if (!isChannelRunning(channelType)) {
-          return { disabled: true, title: label + '\u5DF2\u5199\u5165\u914D\u7F6E\uFF0CBridge \u4F1A\u5728\u51E0\u79D2\u5185\u81EA\u52A8\u540C\u6B65\uFF1B\u540C\u6B65\u5B8C\u6210\u540E\u518D\u5207\u6362\u4F1A\u8BDD\u3002' };
+        if (!isChannelRunning(channel.id)) {
+          return label + '\u5DF2\u914D\u7F6E\uFF0CBridge \u4F1A\u5728\u51E0\u79D2\u5185\u81EA\u52A8\u540C\u6B65\uFF1B\u5982\u679C\u9875\u9762\u8FD8\u6CA1\u66F4\u65B0\uFF0C\u53EF\u624B\u52A8\u70B9\u201C\u5237\u65B0\u72B6\u6001\u201D\u3002';
         }
-
-        const bindings = state.bindings.filter((item) => item.channelType === channelType);
-        if (bindings.length === 0) {
-          return { disabled: true, title: '\u5F53\u524D\u8FD8\u6CA1\u6709' + label + '\u804A\u5929\u7ED1\u5B9A\u3002\u5148\u8BA9' + label + '\u53D1\u6765\u4E00\u6761\u6D88\u606F\u3002' };
-        }
-        if (bindings.length > 1) {
-          return { disabled: true, title: label + '\u6709\u591A\u4E2A\u7ED1\u5B9A\uFF0C\u8BF7\u5230\u901A\u9053\u9875\u5207\u6362\u3002' };
-        }
-
-        return {
-          disabled: false,
-          title: '\u5207\u6362' + label + '\u5230\u5F53\u524D\u4F1A\u8BDD',
-          bindingId: bindings[0].id,
-        };
+        return label + '\u5F53\u524D\u8FD8\u6CA1\u6709\u804A\u5929\u63A5\u5165\u3002\u5148\u4ECE\u8FD9\u4E2A\u673A\u5668\u4EBA\u53D1\u4E00\u6761\u6D88\u606F\u3002';
       }
 
       function currentThreadMarks(threadId) {
@@ -9479,11 +9900,11 @@ function renderHtml() {
         for (const binding of state.bindings || []) {
           const matchesThread = binding.currentThreadId === threadId || binding.currentTargetKey === currentTargetKey;
           if (!matchesThread) continue;
-          counts.set(binding.channelType, (counts.get(binding.channelType) || 0) + 1);
+          const label = (binding.channelAlias || providerLabel(binding.channelProvider)) + ' \u5F53\u524D';
+          counts.set(label, (counts.get(label) || 0) + 1);
         }
 
-        for (const [channelType, count] of counts.entries()) {
-          const label = channelType === 'weixin' ? '\u5FAE\u4FE1\u5F53\u524D' : '\u98DE\u4E66\u5F53\u524D';
+        for (const [label, count] of counts.entries()) {
           marks.push(count > 1 ? label + ' x' + count : label);
         }
 
@@ -9505,7 +9926,10 @@ function renderHtml() {
       }
 
       function formatBindingAccount(binding) {
-        return channelLabel(binding.channelType) + ' \xB7 ' + (binding.chatDisplayName || binding.chatId);
+        const alias = String(binding.channelAlias || '').trim();
+        const provider = providerLabel(binding.channelProvider);
+        const channel = alias ? (alias === provider ? alias : alias + ' \xB7 ' + provider) : provider;
+        return channel + ' \xB7 ' + (binding.chatDisplayName || binding.chatId);
       }
 
       function bindingRuntimeText(binding) {
@@ -9533,9 +9957,6 @@ function renderHtml() {
       }
 
       function renderDesktopSessionCard(session) {
-        const feishuSwitch = quickSwitchState('feishu');
-        const weixinSwitch = quickSwitchState('weixin');
-        const targetKey = 'desktop:' + session.threadId;
         const originator = session.originator || 'Codex Desktop';
         const marks = currentThreadMarks(session.threadId);
         const markHtml = marks.map((mark) => '<span class="session-mark">' + escapeHtml(mark) + '</span>').join('');
@@ -9556,8 +9977,7 @@ function renderHtml() {
           +       '<div class="session-path">' + escapeHtml(session.cwd || '(no cwd)') + '</div>'
           +     '</div>'
           +     '<div class="session-actions">'
-          +       '<button type="button" data-action="bind-channel" data-channel="feishu" data-binding-id="' + escapeHtml(feishuSwitch.bindingId || '') + '" data-target-key="' + escapeHtml(targetKey) + '" title="' + escapeHtml(feishuSwitch.title) + '"' + (feishuSwitch.disabled ? ' disabled' : '') + '>\u98DE\u4E66\u5207\u5230\u6B64\u4F1A\u8BDD</button>'
-          +       '<button type="button" data-action="bind-channel" data-channel="weixin" data-binding-id="' + escapeHtml(weixinSwitch.bindingId || '') + '" data-target-key="' + escapeHtml(targetKey) + '" title="' + escapeHtml(weixinSwitch.title) + '"' + (weixinSwitch.disabled ? ' disabled' : '') + '>\u5FAE\u4FE1\u5207\u5230\u6B64\u4F1A\u8BDD</button>'
+          +       '<button type="button" data-action="copy-thread" data-thread-id="' + escapeHtml(session.threadId) + '">\u590D\u5236 thread</button>'
           +       '<button type="button" data-action="copy-bind-command" data-thread-id="' + escapeHtml(session.threadId) + '">\u590D\u5236\u547D\u4EE4</button>'
           +   '</div>'
           + '</div>'
@@ -9642,14 +10062,14 @@ function renderHtml() {
         allMeta.textContent = '\u6309\u6700\u8FD1\u6D3B\u52A8\u6392\u5E8F\uFF0C\u5171 ' + sessions.length + ' \u6761\u3002';
 
         if (boundSessions.length === 0) {
-          boundList.innerHTML = '<div class="binding-empty">\u5F53\u524D\u6CA1\u6709\u4EFB\u4F55\u684C\u9762\u4F1A\u8BDD\u6B63\u5728\u7ED1\u5B9A\u5230\u98DE\u4E66\u6216\u5FAE\u4FE1\u804A\u5929\u3002</div>';
+          boundList.innerHTML = '<div class="binding-empty">\u5F53\u524D\u6CA1\u6709\u4EFB\u4F55\u684C\u9762\u4F1A\u8BDD\u6B63\u5728\u7ED1\u5B9A\u5230\u804A\u5929\u5165\u53E3\u3002</div>';
         } else {
           boundList.innerHTML = boundSessions.map((session) => renderBoundDesktopSessionCard(session)).join('');
         }
 
         if (state.desktopSessions.length === 0) {
           list.innerHTML = '<div class="notice ghost">\u5F53\u524D\u6CA1\u6709\u53D1\u73B0\u684C\u9762\u7AEF\u4F1A\u8BDD\u3002\u5148\u5728 Codex Desktop App \u4E2D\u6253\u5F00\u6216\u8FD0\u884C\u4E00\u4E2A\u4F1A\u8BDD\uFF0C\u518D\u56DE\u5230\u8FD9\u91CC\u5237\u65B0\u3002</div>';
-          rerenderBindingPanels();
+          renderChannelsWorkspace();
           return;
         }
 
@@ -9657,7 +10077,7 @@ function renderHtml() {
           + sessions.map((session) => renderDesktopSessionListItem(session)).join('')
           + '</div>';
 
-        rerenderBindingPanels();
+        renderChannelsWorkspace();
       }
 
       function rerenderDesktopSessions() {
@@ -9668,42 +10088,91 @@ function renderHtml() {
         });
       }
 
-      function rerenderBindingPanels() {
-        renderChannelBindings(
-          'feishu',
-          'feishuBindings',
-          'feishuBindingMeta',
-          emptyBindingText('feishu')
-        );
-        renderChannelBindings(
-          'weixin',
-          'weixinBindings',
-          'weixinBindingMeta',
-          emptyBindingText('weixin')
-        );
+      function bindingsForChannel(channelId) {
+        return (state.bindings || []).filter((item) => item.channelType === channelId);
       }
 
-      function renderChannelBindings(channelType, listId, metaId, emptyText) {
-        const bindings = state.bindings.filter((item) => item.channelType === channelType);
-        const list = document.getElementById(listId);
-        const meta = document.getElementById(metaId);
-        meta.textContent = bindings.length > 0
-          ? '\u5F53\u524D\u5DF2\u53D1\u73B0 ' + bindings.length + ' \u4E2A\u804A\u5929\u7ED1\u5B9A\u3002\u4E00\u4E2A\u4F1A\u8BDD\u53EA\u80FD\u7ED1\u5B9A\u4E00\u4E2A\u804A\u5929\u3002\u8FD9\u91CC\u53EA\u663E\u793A\u548C\u4F1A\u8BDD\u9875\u4E00\u81F4\u7684\u547D\u540D\u684C\u9762\u7EBF\u7A0B\u3002'
-          : emptyText;
+      function ensureActiveBinding(channelId, bindings) {
+        const current = state.activeBindingByChannelId[channelId];
+        if (current && bindings.some((binding) => binding.id === current)) {
+          return current;
+        }
+        const next = bindings[0] ? bindings[0].id : '';
+        state.activeBindingByChannelId[channelId] = next;
+        return next;
+      }
 
-        if (bindings.length === 0) {
-          state.activeBindingByChannel[channelType] = '';
-          list.innerHTML = '<div class="binding-empty">' + escapeHtml(emptyText) + '</div>';
+      function ensureActiveChannelId() {
+        if (state.channelDraft && state.activeChannelId === state.channelDraft.id) {
+          return state.activeChannelId;
+        }
+        const channels = visibleChannels();
+        if (state.activeChannelId && channels.some((channel) => channel.id === state.activeChannelId)) {
+          return state.activeChannelId;
+        }
+        state.activeChannelId = channels[0] ? channels[0].id : '';
+        return state.activeChannelId;
+      }
+
+      function getWeixinAccountOptions() {
+        return Array.isArray(state.weixinAccounts) ? state.weixinAccounts : [];
+      }
+
+      function renderChannelList() {
+        const list = document.getElementById('channelList');
+        const meta = document.getElementById('channelListMeta');
+        const channels = visibleChannels();
+
+        meta.textContent = channels.length > 0
+          ? '\u5171 ' + channels.length + ' \u4E2A\u901A\u9053\u5B9E\u4F8B\u3002\u6BCF\u4E2A\u5B9E\u4F8B\u662F\u4E00\u4E2A\u72EC\u7ACB\u804A\u5929\u5165\u53E3\u3002'
+          : '\u5F53\u524D\u8FD8\u6CA1\u6709\u901A\u9053\u5B9E\u4F8B\u3002\u5148\u65B0\u589E\u4E00\u4E2A\u98DE\u4E66\u6216\u5FAE\u4FE1\u673A\u5668\u4EBA\u3002';
+
+        if (channels.length === 0) {
+          list.innerHTML = '<div class="binding-empty">\u5F53\u524D\u8FD8\u6CA1\u6709\u53EF\u7528\u901A\u9053\u5B9E\u4F8B\u3002</div>';
           return;
         }
 
-        const activeBindingId = ensureActiveBinding(channelType, bindings);
+        ensureActiveChannelId();
+        list.innerHTML = channels.map((channel) => {
+          const adapter = getAdapterStatus(channel.id);
+          const active = channel.id === state.activeChannelId;
+          const bindingCount = bindingsForChannel(channel.id).length;
+          const statusText = channel.enabled === false
+            ? '\u5DF2\u505C\u7528'
+            : adapter && adapter.running
+              ? '\u8FD0\u884C\u4E2D'
+              : state.bridgeStatus && state.bridgeStatus.running
+                ? '\u7B49\u5F85\u540C\u6B65'
+                : 'Bridge \u672A\u542F\u52A8';
+          return ''
+            + '<button type="button" class="channel-list-item' + (active ? ' active' : '') + '" data-action="select-channel" data-channel-id="' + escapeHtml(channel.id) + '">'
+            +   '<div class="channel-list-item-head">'
+            +     '<div class="channel-list-item-title">' + escapeHtml(channel.alias) + '</div>'
+            +     '<span class="channel-list-item-provider">' + escapeHtml(providerLabel(channel.provider)) + '</span>'
+            +   '</div>'
+            +   '<div class="channel-list-item-stats">'
+            +     '<span class="channel-list-item-status">' + escapeHtml(statusText) + '</span>'
+            +     '<span>' + escapeHtml(bindingCount === 0 ? '\u672A\u7ED1\u5B9A\u804A\u5929' : ('\u5DF2\u7ED1\u5B9A ' + bindingCount + ' \u4E2A\u804A\u5929')) + '</span>'
+            +   '</div>'
+            +   '<div class="channel-list-item-meta">' + escapeHtml(channel.id) + '</div>'
+            + '</button>';
+        }).join('');
+      }
+
+      function renderChannelBindingsV2(channel) {
+        const bindings = bindingsForChannel(channel.id);
+        const emptyText = emptyBindingText(channel);
+        if (bindings.length === 0) {
+          return '<div class="binding-empty">' + escapeHtml(emptyText) + '</div>';
+        }
+
+        const activeBindingId = ensureActiveBinding(channel.id, bindings);
         const activeBinding = bindings.find((binding) => binding.id === activeBindingId) || bindings[0];
         const tabs = bindings.length > 1
           ? '<div class="binding-tabs">' + bindings.map((binding) => (
               '<button type="button" class="binding-tab' + (binding.id === activeBinding.id ? ' active' : '') + '"'
                 + ' data-action="select-binding-tab"'
-                + ' data-channel="' + escapeHtml(channelType) + '"'
+                + ' data-channel-id="' + escapeHtml(channel.id) + '"'
                 + ' data-binding-id="' + escapeHtml(binding.id) + '"'
                 + ' title="' + escapeHtml(binding.chatId) + '">'
                 + escapeHtml(bindingTabLabel(binding))
@@ -9711,51 +10180,129 @@ function renderHtml() {
             )).join('') + '</div>'
           : '';
 
-        list.innerHTML = tabs + renderBindingCard(activeBinding);
+        return ''
+          + '<div class="small">\u5F53\u524D\u5DF2\u53D1\u73B0 ' + bindings.length + ' \u4E2A\u804A\u5929\u7ED1\u5B9A\u3002\u4E00\u4E2A\u4F1A\u8BDD\u540C\u4E00\u65F6\u523B\u53EA\u80FD\u7ED1\u5B9A\u4E00\u4E2A\u804A\u5929\u3002</div>'
+          + tabs
+          + renderBindingCard(activeBinding);
       }
 
-      function renderWeixinAccounts() {
-        const meta = document.getElementById('weixinAccountMeta');
-        const list = document.getElementById('weixinAccounts');
-        const accounts = state.weixinAccounts || [];
-
-        if (accounts.length === 0) {
-          meta.textContent = '\u5F53\u524D\u8FD8\u6CA1\u6709\u5DF2\u4FDD\u5B58\u7684\u5FAE\u4FE1\u8D26\u53F7\u3002\u5148\u70B9\u51FB\u201C\u5F00\u59CB\u5FAE\u4FE1\u626B\u7801\u201D\uFF0C\u7136\u540E\u5728\u624B\u673A\u4E0A\u786E\u8BA4\u3002';
-          list.innerHTML = '<div class="binding-empty">\u626B\u7801\u6210\u529F\u540E\uFF0C\u8FD9\u91CC\u4F1A\u663E\u793A\u5F53\u524D\u5DF2\u4FDD\u5B58\u7684\u5FAE\u4FE1\u8D26\u53F7\u3002</div>';
+      function renderChannelEditor() {
+        const editor = document.getElementById('channelEditor');
+        const channel = getChannelById(ensureActiveChannelId());
+        if (!channel) {
+          editor.innerHTML = '<div class="binding-empty">\u8BF7\u9009\u62E9\u4E00\u4E2A\u901A\u9053\u5B9E\u4F8B\uFF0C\u6216\u5148\u521B\u5EFA\u65B0\u901A\u9053\u3002</div>';
           return;
         }
 
-        meta.textContent = '\u5F53\u524D\u5DF2\u4FDD\u5B58 ' + accounts.length + ' \u4E2A\u5FAE\u4FE1\u8D26\u53F7\u3002\u5FAE\u4FE1\u6865\u63A5\u662F\u5355\u8D26\u53F7\u6A21\u5F0F\uFF0C\u6700\u65B0\u542F\u7528\u7684\u8D26\u53F7\u4F1A\u751F\u6548\u3002';
-        list.innerHTML = accounts.map((account) => ''
-          + '<article class="binding-item">'
-          +   '<div class="binding-head">'
-          +     '<div class="binding-title">' + escapeHtml(account.name || account.accountId) + '</div>'
-          +     '<div class="small">' + (account.enabled ? '\u5DF2\u542F\u7528' : '\u5DF2\u505C\u7528') + '</div>'
-          +   '</div>'
-          +   '<div class="binding-detail">\u8D26\u53F7 ID\uFF1A<code>' + escapeHtml(account.accountId) + '</code></div>'
-          +   '<div class="binding-detail">\u7528\u6237 ID\uFF1A<code>' + escapeHtml(account.userId || '-') + '</code></div>'
-          +   '<div class="binding-detail">Base URL\uFF1A' + escapeHtml(account.baseUrl || '-') + '</div>'
-          +   '<div class="binding-detail">\u6700\u8FD1\u767B\u5F55\uFF1A' + escapeHtml(formatTime(account.lastLoginAt || account.updatedAt)) + '</div>'
-          + '</article>'
+        const adapter = getAdapterStatus(channel.id);
+        const statusText = formatChannelRuntimeLabel(channel);
+        const feishu = channel.provider === 'feishu' ? (channel.config || {}) : {};
+        const weixin = channel.provider === 'weixin' ? (channel.config || {}) : {};
+        const weixinAccounts = getWeixinAccountOptions();
+        const weixinAccountOptions = ['<option value="">\u672A\u7ED1\u5B9A\u8D26\u53F7</option>'].concat(
+          weixinAccounts.map((account) => (
+            '<option value="' + escapeHtml(account.accountId) + '"' + (account.accountId === weixin.accountId ? ' selected' : '') + '>'
+              + escapeHtml(account.name || account.accountId)
+            + '</option>'
+          )),
         ).join('');
+        const bindingsHtml = renderChannelBindingsV2(channel);
+        const bindingCount = bindingsForChannel(channel.id).length;
+        const detailsHtml = channel.provider === 'feishu'
+          ? ''
+            + '<div class="editor-section">'
+            +   '<p class="editor-section-title">\u8FDE\u63A5\u914D\u7F6E</p>'
+            +   '<div class="field-row">'
+            +     '<label>App ID<input id="channelAppId" value="' + escapeHtml(feishu.appId || '') + '" /></label>'
+            +     '<label>App Secret<input id="channelAppSecret" value="' + escapeHtml(feishu.appSecret || '') + '" /></label>'
+            +   '</div>'
+            +   '<div class="field-row">'
+            +     '<label>\u7AD9\u70B9<select id="channelSite">'
+            +       '<option value="feishu"' + ((feishu.site || 'feishu') === 'feishu' ? ' selected' : '') + '>Feishu</option>'
+            +       '<option value="lark"' + (feishu.site === 'lark' ? ' selected' : '') + '>Lark</option>'
+            +     '</select></label>'
+            +     '<label>Allowed Users<input id="channelAllowedUsers" value="' + escapeHtml(Array.isArray(feishu.allowedUsers) ? feishu.allowedUsers.join(', ') : '') + '" placeholder="\u591A\u4E2A user_id \u7528\u9017\u53F7\u5206\u9694" /></label>'
+            +   '</div>'
+            + '</div>'
+            + '<div class="editor-section">'
+            +   '<p class="editor-section-title">\u884C\u4E3A\u5F00\u5173</p>'
+            +   '<div class="checkbox-row">'
+            +     '<label class="checkbox"><input id="channelStreamingEnabled" type="checkbox"' + (feishu.streamingEnabled !== false ? ' checked' : '') + ' /> \u542F\u7528\u98DE\u4E66\u6D41\u5F0F\u54CD\u5E94\u5361\u7247</label>'
+            +     '<label class="checkbox"><input id="channelFeedbackMarkdownEnabled" type="checkbox"' + (feishu.feedbackMarkdownEnabled !== false ? ' checked' : '') + ' /> \u53CD\u9988\u4F7F\u7528markdown</label>'
+            +   '</div>'
+            + '</div>'
+          : ''
+            + '<div class="editor-section">'
+            +   '<p class="editor-section-title">\u8FDE\u63A5\u914D\u7F6E</p>'
+            +   '<div class="field-row">'
+            +     '<label>\u5FAE\u4FE1\u8D26\u53F7<select id="channelAccountId">' + weixinAccountOptions + '</select></label>'
+            +     '<label>Base URL<input id="channelBaseUrl" value="' + escapeHtml(weixin.baseUrl || '') + '" /></label>'
+            +   '</div>'
+            +   '<div class="field-row">'
+            +     '<label>CDN Base URL<input id="channelCdnBaseUrl" value="' + escapeHtml(weixin.cdnBaseUrl || '') + '" /></label>'
+            +     '<div></div>'
+            +   '</div>'
+            + '</div>'
+            + '<div class="editor-section">'
+            +   '<p class="editor-section-title">\u884C\u4E3A\u5F00\u5173</p>'
+            +   '<div class="checkbox-row">'
+            +     '<label class="checkbox"><input id="channelMediaEnabled" type="checkbox"' + (weixin.mediaEnabled === true ? ' checked' : '') + ' /> \u542F\u7528\u56FE\u7247 / \u6587\u4EF6 / \u89C6\u9891\u5165\u7AD9\u4E0B\u8F7D</label>'
+            +     '<label class="checkbox"><input id="channelFeedbackMarkdownEnabled" type="checkbox"' + (weixin.feedbackMarkdownEnabled === true ? ' checked' : '') + ' /> \u53CD\u9988\u4F7F\u7528markdown</label>'
+            +   '</div>'
+            + '</div>';
+
+        editor.innerHTML = ''
+          + '<div class="panel-header">'
+          +   '<div>'
+            +     '<h2>' + escapeHtml(channel.alias) + '</h2>'
+            +     '<p>' + escapeHtml(statusText) + (adapter && adapter.lastMessageAt ? ' \xB7 \u6700\u8FD1\u6D88\u606F ' + escapeHtml(formatTime(adapter.lastMessageAt)) : '') + '</p>'
+          +   '</div>'
+          +   '<div class="toolbar-split">'
+          +     '<div class="toolbar">'
+          +       '<button type="button" data-action="channel-save" data-channel-id="' + escapeHtml(channel.id) + '" class="primary">\u4FDD\u5B58\u901A\u9053</button>'
+          +       '<button type="button" data-action="channel-test" data-channel-id="' + escapeHtml(channel.id) + '">\u6D4B\u8BD5\u5F53\u524D\u901A\u9053</button>'
+          +       (channel.provider === 'weixin' ? '<button type="button" data-action="channel-weixin-login" data-channel-id="' + escapeHtml(channel.id) + '">\u5F00\u59CB\u5FAE\u4FE1\u626B\u7801</button>' : '')
+          +     '</div>'
+          +     '<div class="toolbar-danger">'
+          +       '<button type="button" data-action="channel-delete" data-channel-id="' + escapeHtml(channel.id) + '" class="danger">\u5220\u9664\u901A\u9053</button>'
+          +     '</div>'
+          +   '</div>'
+          + '</div>'
+          + '<div class="channel-editor-summary">'
+          +   '<div class="channel-editor-stat"><strong>\u5F53\u524D\u72B6\u6001</strong><span>' + escapeHtml(statusText) + '</span></div>'
+          +   '<div class="channel-editor-stat"><strong>\u804A\u5929\u7ED1\u5B9A</strong><span>' + escapeHtml(String(bindingCount)) + '</span></div>'
+          +   '<div class="channel-editor-stat"><strong>Provider</strong><span>' + escapeHtml(providerLabel(channel.provider)) + '</span></div>'
+          + '</div>'
+          + '<div class="fields">'
+          +   '<div class="editor-section">'
+          +     '<p class="editor-section-title">\u57FA\u7840\u4FE1\u606F</p>'
+          +     '<div class="field-row triple">'
+          +       '<label>\u522B\u540D<input id="channelAliasInput" value="' + escapeHtml(channel.alias) + '" /></label>'
+          +       '<label>\u5B9E\u4F8B ID<input value="' + escapeHtml(channel.id) + '" disabled /></label>'
+          +       '<label>Provider<input value="' + escapeHtml(providerLabel(channel.provider)) + '" disabled /></label>'
+          +     '</div>'
+          +     '<div class="checkbox-row">'
+          +       '<label class="checkbox"><input id="channelEnabledInput" type="checkbox"' + (channel.enabled !== false ? ' checked' : '') + ' /> \u542F\u7528\u5F53\u524D\u901A\u9053</label>'
+          +     '</div>'
+          +   '</div>'
+          +   detailsHtml
+          + '</div>'
+          + '<div class="panel-block">'
+          +   '<p class="panel-subtitle">\u5F53\u524D\u7ED1\u5B9A</p>'
+          +   bindingsHtml
+          + '</div>';
+      }
+
+      function renderChannelsWorkspace() {
+        renderChannelList();
+        renderChannelEditor();
       }
 
       function renderBindings(result) {
         state.bindings = result.bindings || [];
         state.bindingOptions = result.options || [];
         document.getElementById('bindingCount').textContent = String(state.bindings.length);
-        renderChannelBindings(
-          'feishu',
-          'feishuBindings',
-          'feishuBindingMeta',
-          emptyBindingText('feishu')
-        );
-        renderChannelBindings(
-          'weixin',
-          'weixinBindings',
-          'weixinBindingMeta',
-          emptyBindingText('weixin')
-        );
+        renderChannelsWorkspace();
         rerenderDesktopSessions();
       }
 
@@ -9815,18 +10362,10 @@ function renderHtml() {
         document.getElementById('codexReasoningEffort').value = config.codexReasoningEffort || 'medium';
         document.getElementById('uiAllowLan').checked = config.uiAllowLan === true;
         document.getElementById('uiAccessToken').value = config.uiAccessToken || '';
-        document.getElementById('channelFeishu').checked = (config.enabledChannels || []).includes('feishu');
-        document.getElementById('channelWeixin').checked = (config.enabledChannels || []).includes('weixin');
         document.getElementById('autoApprove').checked = config.autoApprove === true;
-        document.getElementById('feishuAppId').value = config.feishuAppId || '';
-        document.getElementById('feishuAppSecret').value = config.feishuAppSecret || '';
-        document.getElementById('feishuDomain').value = config.feishuDomain || 'https://open.feishu.cn';
-        document.getElementById('feishuAllowedUsers').value = config.feishuAllowedUsers || '';
-        document.getElementById('feishuStreamingEnabled').checked = config.feishuStreamingEnabled !== false;
-        document.getElementById('feishuCommandMarkdownEnabled').checked = config.feishuCommandMarkdownEnabled !== false;
-        document.getElementById('weixinMediaEnabled').checked = config.weixinMediaEnabled === true;
-        document.getElementById('weixinCommandMarkdownEnabled').checked = config.weixinCommandMarkdownEnabled === true;
         renderUiAccess();
+        ensureActiveChannelId();
+        renderChannelsWorkspace();
         rerenderDesktopSessions();
       }
 
@@ -9847,24 +10386,68 @@ function renderHtml() {
         const config = await api('/api/config');
         state.uiAccess = status.uiAccess || null;
         state.bridgeStatus = status.bridge || null;
+        state.autostartStatus = status.autostart || null;
         state.weixinAccounts = status.weixin && Array.isArray(status.weixin.linkedAccounts) ? status.weixin.linkedAccounts : [];
         fillForm(config);
-        const runningChannelText = runningChannels().length ? ' \xB7 ' + runningChannels().join(', ') : '';
+        const runningChannelText = adapterStatuses().length
+          ? ' \xB7 ' + adapterStatuses().filter((item) => item.running).map((item) => item.channelAlias || item.channelType).join(', ')
+          : '';
         document.getElementById('bridgeStatus').textContent = status.bridge.running ? 'Running' + runningChannelText : 'Stopped';
+        renderAutostartStatus(status.autostart || null);
         document.getElementById('integrationStatus').textContent = status.codexIntegrationInstalled ? '\u5DF2\u5B89\u88C5' : '\u672A\u5B89\u88C5';
         document.getElementById('runtimeStatus').textContent = config.runtime || 'codex';
         document.getElementById('homeStatus').textContent = status.home;
         document.getElementById('overviewHomeStatus').textContent = status.home;
         document.getElementById('packageRoot').textContent = status.packageRoot;
-        document.getElementById('feishuRuntimeMeta').textContent = channelRuntimeText('feishu');
-        document.getElementById('weixinRuntimeMeta').textContent = channelRuntimeText('weixin');
-        renderWeixinAccounts();
         renderBindings({
           bindings: state.bindings,
           options: state.bindingOptions,
         });
       }
 
+      function renderAutostartStatus(status) {
+        const valueEl = document.getElementById('autostartStatus');
+        const noticeEl = document.getElementById('autostartNotice');
+        const refreshBtn = document.getElementById('refreshAutostartBtn');
+
+        if (!status || status.supported !== true) {
+          valueEl.textContent = '\u4E0D\u652F\u6301';
+          noticeEl.textContent = status && status.error
+            ? status.error
+            : '\u5F53\u524D\u7CFB\u7EDF\u6682\u4E0D\u652F\u6301 Bridge \u5F00\u673A\u81EA\u542F\u52A8\u3002';
+          refreshBtn.disabled = true;
+          return;
+        }
+
+        if (status.error) {
+          valueEl.textContent = '\u914D\u7F6E\u5F02\u5E38';
+          noticeEl.textContent = status.error;
+          refreshBtn.disabled = false;
+          return;
+        }
+
+        if (!status.installed) {
+          valueEl.textContent = '\u672A\u542F\u7528';
+          noticeEl.textContent = [
+            '\u5982\u9700\u542F\u7528\uFF0C\u8BF7\u4EE5\u7BA1\u7406\u5458\u8EAB\u4EFD\u6253\u5F00 PowerShell \u6216\u7EC8\u7AEF\u6267\u884C\uFF1A',
+            'codex-to-im autostart install',
+            status.runAsUser ? '\u8FD0\u884C\u8D26\u53F7\uFF1A' + status.runAsUser : '',
+            '\u5B89\u88C5\u65F6\u4F1A\u8981\u6C42\u8F93\u5165\u5F53\u524D Windows \u767B\u5F55\u5BC6\u7801\u3002',
+          ].filter(Boolean).join('\\n');
+          refreshBtn.disabled = false;
+          return;
+        }
+
+        valueEl.textContent = status.enabled ? '\u5DF2\u542F\u7528' : '\u5DF2\u7981\u7528';
+        noticeEl.textContent = [
+          '\u65B9\u5F0F\uFF1AWindows \u4EFB\u52A1\u8BA1\u5212\u7A0B\u5E8F\uFF08\u5F00\u673A\u89E6\u53D1\uFF09',
+          status.runAsUser ? '\u8FD0\u884C\u8D26\u53F7\uFF1A' + status.runAsUser : '',
+          status.state ? '\u4EFB\u52A1\u72B6\u6001\uFF1A' + status.state : '',
+          '\u5982\u9700\u5173\u95ED\uFF0C\u8BF7\u4EE5\u7BA1\u7406\u5458\u8EAB\u4EFD\u6267\u884C\uFF1Acodex-to-im autostart uninstall',
+        ].filter(Boolean).join(' \xB7 ');
+        refreshBtn.disabled = false;
+      }
+
       async function loadLogs() {
         const logs = await api('/api/logs?lines=220');
         document.getElementById('logsOutput').textContent = logs.logs || '\u6682\u65E0\u65E5\u5FD7';
@@ -9898,16 +10481,187 @@ function renderHtml() {
         return saved;
       }
 
-      document.querySelectorAll('.nav-link').forEach((element) => {
-        element.addEventListener('click', () => {
-          setActivePage(element.dataset.page || 'overview', true);
+      function createChannelDraft(provider) {
+        state.channelDraft = {
+          id: '__draft__:' + provider,
+          alias: providerLabel(provider),
+          provider,
+          enabled: true,
+          createdAt: new Date().toISOString(),
+          updatedAt: new Date().toISOString(),
+          config: provider === 'feishu'
+            ? {
+                appId: '',
+                appSecret: '',
+                site: 'feishu',
+                allowedUsers: [],
+                streamingEnabled: true,
+                feedbackMarkdownEnabled: true,
+              }
+            : {
+                accountId: '',
+                baseUrl: '',
+                cdnBaseUrl: '',
+                mediaEnabled: false,
+                feedbackMarkdownEnabled: false,
+              },
+        };
+        state.activeChannelId = state.channelDraft.id;
+        renderChannelsWorkspace();
+      }
+
+      function currentChannelEditorPayload(channel) {
+        const payload = {
+          provider: channel.provider,
+          alias: document.getElementById('channelAliasInput').value,
+          enabled: document.getElementById('channelEnabledInput').checked,
+        };
+
+        if (!String(channel.id || '').startsWith('__draft__:')) {
+          payload.id = channel.id;
+        }
+
+        if (channel.provider === 'feishu') {
+          payload.appId = document.getElementById('channelAppId').value;
+          payload.appSecret = document.getElementById('channelAppSecret').value;
+          payload.site = document.getElementById('channelSite').value;
+          payload.allowedUsers = document.getElementById('channelAllowedUsers').value;
+          payload.streamingEnabled = document.getElementById('channelStreamingEnabled').checked;
+          payload.feedbackMarkdownEnabled = document.getElementById('channelFeedbackMarkdownEnabled').checked;
+          return payload;
+        }
+
+        payload.accountId = document.getElementById('channelAccountId').value;
+        payload.baseUrl = document.getElementById('channelBaseUrl').value;
+        payload.cdnBaseUrl = document.getElementById('channelCdnBaseUrl').value;
+        payload.mediaEnabled = document.getElementById('channelMediaEnabled').checked;
+        payload.feedbackMarkdownEnabled = document.getElementById('channelFeedbackMarkdownEnabled').checked;
+        return payload;
+      }
+
+      async function saveChannel(channel) {
+        const result = await api('/api/channels/save', {
+          method: 'POST',
+          body: JSON.stringify(currentChannelEditorPayload(channel)),
         });
-      });
+        state.channelDraft = null;
+        fillForm(result.config);
+        renderBindings(result);
+        setActiveChannel(result.channel.id, false);
+        return result;
+      }
+
+      async function deleteCurrentChannel(channel) {
+        if (String(channel.id || '').startsWith('__draft__:')) {
+          state.channelDraft = null;
+          state.activeChannelId = '';
+          renderChannelsWorkspace();
+          showMessage('channelMessage', 'success', '\u672A\u4FDD\u5B58\u7684\u65B0\u901A\u9053\u5DF2\u53D6\u6D88\u3002');
+          return;
+        }
 
-      document.querySelectorAll('.channel-tab').forEach((element) => {
+        const result = await api('/api/channels/delete', {
+          method: 'POST',
+          body: JSON.stringify({ channelId: channel.id }),
+        });
+        state.channelDraft = null;
+        fillForm(result.config);
+        renderBindings(result);
+        showMessage('channelMessage', 'success', '\u901A\u9053\u5DF2\u5220\u9664\u3002');
+      }
+
+      async function testCurrentChannel(channel) {
+        if (String(channel.id || '').startsWith('__draft__:')) {
+          const saved = await saveChannel(channel);
+          channel = getChannelById(saved.channel.id);
+        } else {
+          await saveChannel(channel);
+          channel = getChannelById(channel.id);
+        }
+        const result = await api('/api/channels/test', {
+          method: 'POST',
+          body: JSON.stringify({ channelId: channel.id }),
+        });
+        showMessage('channelMessage', result.ok ? 'success' : 'error', result.message);
+      }
+
+      async function loginWeixinForChannel(channel) {
+        if (String(channel.id || '').startsWith('__draft__:')) {
+          const saved = await saveChannel(channel);
+          channel = getChannelById(saved.channel.id);
+        } else {
+          await saveChannel(channel);
+          channel = getChannelById(channel.id);
+        }
+        const result = await api('/api/channels/weixin-login', {
+          method: 'POST',
+          body: JSON.stringify({ channelId: channel.id }),
+        });
+        fillForm(result.config || state.config);
+        await loadStatus();
+        showMessage('channelMessage', result.ok ? 'success' : 'error', result.message);
+      }
+
+      async function handleChannelEditorAction(event) {
+        const source = event.target instanceof Element ? event.target : null;
+        const target = source ? source.closest('button[data-action]') : null;
+        if (!target) return;
+
+        const channelId = target.dataset.channelId || state.activeChannelId;
+        const channel = getChannelById(channelId);
+        if (!channel) return;
+
+        try {
+          if (target.dataset.action === 'channel-save') {
+            await saveChannel(channel);
+            showMessage('channelMessage', 'success', '\u901A\u9053\u5DF2\u4FDD\u5B58\u3002');
+            return;
+          }
+          if (target.dataset.action === 'channel-test') {
+            await testCurrentChannel(channel);
+            return;
+          }
+          if (target.dataset.action === 'channel-delete') {
+            await deleteCurrentChannel(channel);
+            return;
+          }
+          if (target.dataset.action === 'channel-weixin-login') {
+            await loginWeixinForChannel(channel);
+            return;
+          }
+          if (target.dataset.action === 'select-binding-tab') {
+            state.activeBindingByChannelId[channel.id] = target.dataset.bindingId || '';
+            renderChannelsWorkspace();
+            return;
+          }
+          if (target.dataset.action === 'unbind-binding') {
+            const result = await api('/api/bindings/delete', {
+              method: 'POST',
+              body: JSON.stringify({ bindingId: target.dataset.bindingId }),
+            });
+            renderBindings(result);
+            showMessage('channelMessage', 'success', '\u804A\u5929\u7ED1\u5B9A\u5DF2\u89E3\u7ED1\u3002');
+            return;
+          }
+          if (target.dataset.action === 'switch-binding-target') {
+            const result = await api('/api/bindings/update', {
+              method: 'POST',
+              body: JSON.stringify({
+                bindingId: target.dataset.bindingId,
+                targetKey: target.dataset.targetKey,
+              }),
+            });
+            renderBindings(result);
+            showMessage('channelMessage', 'success', '\u804A\u5929\u7ED1\u5B9A\u5DF2\u66F4\u65B0\u3002');
+          }
+        } catch (error) {
+          showMessage('channelMessage', 'error', error.message);
+        }
+      }
+
+      document.querySelectorAll('.nav-link').forEach((element) => {
         element.addEventListener('click', () => {
-          setActivePage('channels', false);
-          setActiveChannel(element.dataset.channel || 'feishu', true);
+          setActivePage(element.dataset.page || 'overview', true);
         });
       });
 
@@ -9955,76 +10709,6 @@ function renderHtml() {
         }
       });
 
-      document.getElementById('saveFeishuChannelBtn').addEventListener('click', async () => {
-        try {
-          await saveConfig({ messageId: 'feishuMessage', scope: 'feishu' });
-          await loadStatus();
-          await loadBindings();
-        } catch (error) {
-          showMessage('feishuMessage', 'error', error.message);
-        }
-      });
-
-      document.getElementById('testFeishuBtn').addEventListener('click', async () => {
-        try {
-          await saveConfig();
-          await loadStatus();
-          await loadBindings();
-          const result = await api('/api/test/feishu', { method: 'POST' });
-          showMessage('feishuMessage', result.ok ? 'success' : 'error', result.message);
-        } catch (error) {
-          showMessage('feishuMessage', 'error', error.message);
-        }
-      });
-
-      document.getElementById('refreshFeishuStateBtn').addEventListener('click', async () => {
-        try {
-          await loadStatus();
-          await loadBindings();
-          await loadDesktopSessions();
-          showMessage('feishuMessage', 'success', '\u98DE\u4E66\u901A\u9053\u72B6\u6001\u5DF2\u5237\u65B0\u3002');
-        } catch (error) {
-          showMessage('feishuMessage', 'error', error.message);
-        }
-      });
-
-      document.getElementById('saveWeixinChannelBtn').addEventListener('click', async () => {
-        try {
-          await saveConfig({ messageId: 'weixinMessage', scope: 'weixin' });
-          await loadStatus();
-          await loadBindings();
-        } catch (error) {
-          showMessage('weixinMessage', 'error', error.message);
-        }
-      });
-
-      document.getElementById('refreshWeixinStateBtn').addEventListener('click', async () => {
-        try {
-          await loadStatus();
-          await loadBindings();
-          await loadDesktopSessions();
-          showMessage('weixinMessage', 'success', '\u5FAE\u4FE1\u901A\u9053\u72B6\u6001\u5DF2\u5237\u65B0\u3002');
-        } catch (error) {
-          showMessage('weixinMessage', 'error', error.message);
-        }
-      });
-
-      document.getElementById('weixinLoginBtn').addEventListener('click', async () => {
-        try {
-          await saveConfig();
-          showMessage('weixinMessage', 'success', '\u5FAE\u4FE1\u626B\u7801\u6D41\u7A0B\u5DF2\u542F\u52A8\uFF0C\u6D4F\u89C8\u5668\u4F1A\u6253\u5F00\u4E8C\u7EF4\u7801\u9875\u9762\u3002');
-          const result = await api('/api/test/weixin', { method: 'POST' });
-          await loadStatus();
-          await loadBindings();
-          const followup = isChannelRunning('weixin')
-            ? '\u5FAE\u4FE1\u8D26\u53F7\u5DF2\u4FDD\u5B58\u3002\u5F53\u524D Bridge \u5DF2\u52A0\u8F7D\u5FAE\u4FE1\u901A\u9053\uFF0C\u51E0\u79D2\u540E\u4F1A\u81EA\u52A8\u63A5\u5165\u65B0\u8D26\u53F7\u3002'
-            : '\u5FAE\u4FE1\u8D26\u53F7\u5DF2\u4FDD\u5B58\u3002Bridge \u4F1A\u5728\u51E0\u79D2\u5185\u81EA\u52A8\u540C\u6B65\u5FAE\u4FE1\u901A\u9053\uFF1B\u5982\u679C\u9875\u9762\u8FD8\u6CA1\u66F4\u65B0\uFF0C\u53EF\u624B\u52A8\u70B9\u201C\u5237\u65B0\u72B6\u6001\u201D\u3002';
-          showMessage('weixinMessage', result.ok ? 'success' : 'error', followup);
-        } catch (error) {
-          showMessage('weixinMessage', 'error', error.message);
-        }
-      });
-
       document.getElementById('startBridgeBtn').addEventListener('click', async () => {
         try {
           await saveConfig();
@@ -10086,6 +10770,15 @@ function renderHtml() {
         }
       });
 
+      document.getElementById('refreshAutostartBtn').addEventListener('click', async () => {
+        try {
+          await loadStatus();
+          showMessage('opsMessage', 'success', '\u5F00\u673A\u81EA\u542F\u52A8\u72B6\u6001\u5DF2\u5237\u65B0\u3002');
+        } catch (error) {
+          showMessage('opsMessage', 'error', error.message);
+        }
+      });
+
       document.getElementById('installIntegrationBtn').addEventListener('click', async () => {
         try {
           const result = await api('/api/install-codex-integration', { method: 'POST' });
@@ -10113,6 +10806,35 @@ function renderHtml() {
         }
       });
 
+      document.getElementById('createChannelBtn').addEventListener('click', () => {
+        const provider = document.getElementById('newChannelProvider').value === 'weixin' ? 'weixin' : 'feishu';
+        createChannelDraft(provider);
+        setActivePage('channels', false);
+        setActiveChannel(state.activeChannelId, true);
+      });
+
+      document.getElementById('refreshChannelsBtn').addEventListener('click', async () => {
+        try {
+          await loadStatus();
+          await loadBindings();
+          showMessage('channelMessage', 'success', '\u901A\u9053\u72B6\u6001\u5DF2\u5237\u65B0\u3002');
+        } catch (error) {
+          showMessage('channelMessage', 'error', error.message);
+        }
+      });
+
+      document.getElementById('channelList').addEventListener('click', (event) => {
+        const source = event.target instanceof Element ? event.target : null;
+        const target = source ? source.closest('button[data-channel-id]') : null;
+        if (!target) return;
+        setActivePage('channels', false);
+        setActiveChannel(target.dataset.channelId || '', true);
+      });
+
+      document.getElementById('channelEditor').addEventListener('click', (event) => {
+        handleChannelEditorAction(event);
+      });
+
       async function handleSessionListAction(event) {
         const source = event.target instanceof Element ? event.target : null;
         const target = source ? source.closest('button[data-action]') : null;
@@ -10139,59 +10861,20 @@ function renderHtml() {
         if (!target) return;
 
         if (target.dataset.action === 'unbind-binding') {
-          const channelType = target.dataset.channel || 'feishu';
-          await handleBindingAction(event, channelType, 'desktopMessage');
-          return;
-        }
-
-        await handleSessionListAction(event);
-      });
-
-      async function handleBindingAction(event, channelType, messageId) {
-        const source = event.target instanceof Element ? event.target : null;
-        const target = source ? source.closest('button[data-action]') : null;
-        if (!target) return;
-
-        try {
-          if (target.dataset.action === 'select-binding-tab') {
-            state.activeBindingByChannel[channelType] = target.dataset.bindingId || '';
-            rerenderBindingPanels();
-            return;
-          }
-          if (target.dataset.action === 'unbind-binding') {
+          try {
             const result = await api('/api/bindings/delete', {
               method: 'POST',
-              body: JSON.stringify({
-                bindingId: target.dataset.bindingId,
-              }),
+              body: JSON.stringify({ bindingId: target.dataset.bindingId }),
             });
             renderBindings(result);
-            showMessage(messageId, 'success', channelType === 'feishu' ? '\u98DE\u4E66\u7ED1\u5B9A\u5DF2\u89E3\u7ED1\u3002' : '\u5FAE\u4FE1\u7ED1\u5B9A\u5DF2\u89E3\u7ED1\u3002');
-            return;
-          }
-          if (target.dataset.action !== 'switch-binding-target') {
-            return;
+            showMessage('desktopMessage', 'success', '\u804A\u5929\u7ED1\u5B9A\u5DF2\u89E3\u7ED1\u3002');
+          } catch (error) {
+            showMessage('desktopMessage', 'error', error.message);
           }
-          const result = await api('/api/bindings/update', {
-            method: 'POST',
-            body: JSON.stringify({
-              bindingId: target.dataset.bindingId,
-              targetKey: target.dataset.targetKey,
-            }),
-          });
-          renderBindings(result);
-          showMessage(messageId, 'success', channelType === 'feishu' ? '\u98DE\u4E66\u7ED1\u5B9A\u5DF2\u66F4\u65B0\u3002' : '\u5FAE\u4FE1\u7ED1\u5B9A\u5DF2\u66F4\u65B0\u3002');
-        } catch (error) {
-          showMessage(messageId, 'error', error.message);
+          return;
         }
-      }
 
-      document.getElementById('feishuBindings').addEventListener('click', (event) => {
-        handleBindingAction(event, 'feishu', 'feishuMessage');
-      });
-
-      document.getElementById('weixinBindings').addEventListener('click', (event) => {
-        handleBindingAction(event, 'weixin', 'weixinMessage');
+        await handleSessionListAction(event);
       });
 
       syncPageFromHash();
@@ -10287,6 +10970,7 @@ var server = http.createServer(async (request, response) => {
     if (request.method === "GET" && url.pathname === "/api/status") {
       json(response, 200, {
         bridge: getBridgeStatus(),
+        autostart: await getBridgeAutostartStatus(),
         ui: getUiServerStatus(),
         uiAccess: buildUiAccessInfo(port, config, request),
         home: CTI_HOME,
@@ -10324,17 +11008,93 @@ var server = http.createServer(async (request, response) => {
       json(response, 200, { ok: true, config: configToPayload(loadConfig()) });
       return;
     }
-    if (request.method === "POST" && url.pathname === "/api/test/feishu") {
-      const result = await validateFeishuCredentials(loadConfig());
-      json(response, 200, result);
+    if (request.method === "POST" && url.pathname === "/api/channels/save") {
+      const payload = await readJsonBody(request);
+      const current = loadConfig();
+      const merged = mergeChannelInstance(payload, current);
+      saveConfig(merged.config);
+      const store = createUiStore();
+      syncBindingChannelMeta(store, merged.channel);
+      json(response, 200, {
+        ok: true,
+        channel: channelToPayload(merged.channel),
+        config: configToPayload(loadConfig()),
+        ...await buildBindingsPayload(store, loadConfig())
+      });
+      return;
+    }
+    if (request.method === "POST" && url.pathname === "/api/channels/delete") {
+      const payload = await readJsonBody(request);
+      const channelId = asString(payload.channelId);
+      if (!channelId) {
+        json(response, 400, { error: "channelId \u4E0D\u80FD\u4E3A\u7A7A\u3002" });
+        return;
+      }
+      const store = createUiStore();
+      const bindings = store.listChannelBindings(channelId);
+      if (bindings.length > 0) {
+        json(response, 400, { error: "\u8BE5\u901A\u9053\u4ECD\u6709\u804A\u5929\u7ED1\u5B9A\uFF0C\u8BF7\u5148\u89E3\u7ED1\u540E\u518D\u5220\u9664\u3002" });
+        return;
+      }
+      const next = deleteChannelInstance(loadConfig(), channelId);
+      saveConfig(next);
+      json(response, 200, {
+        ok: true,
+        config: configToPayload(loadConfig()),
+        ...await buildBindingsPayload(store, loadConfig())
+      });
       return;
     }
-    if (request.method === "POST" && url.pathname === "/api/test/weixin") {
-      const result = await runWeixinLogin();
+    if (request.method === "POST" && url.pathname === "/api/channels/test") {
+      const payload = await readJsonBody(request);
+      const channelId = asString(payload.channelId);
+      if (!channelId) {
+        json(response, 400, { error: "channelId \u4E0D\u80FD\u4E3A\u7A7A\u3002" });
+        return;
+      }
+      const channel = findChannelInstance(channelId, loadConfig());
+      if (!channel) {
+        json(response, 404, { error: "\u6307\u5B9A\u7684\u901A\u9053\u4E0D\u5B58\u5728\u3002" });
+        return;
+      }
+      if (channel.provider === "feishu") {
+        json(response, 200, await validateFeishuCredentials(channel));
+        return;
+      }
+      json(response, 200, {
+        ok: true,
+        message: "\u5FAE\u4FE1\u901A\u9053\u8BF7\u4F7F\u7528\u201C\u5F00\u59CB\u5FAE\u4FE1\u626B\u7801\u201D\u5E76\u9009\u62E9\u767B\u5F55\u8D26\u53F7\u8FDB\u884C\u9A8C\u8BC1\u3002"
+      });
+      return;
+    }
+    if (request.method === "POST" && url.pathname === "/api/channels/weixin-login") {
+      const payload = await readJsonBody(request);
+      const channelId = asString(payload.channelId);
+      const current = loadConfig();
+      const channel = channelId ? findChannelInstance(channelId, current) : void 0;
+      const loginConfig = channel?.provider === "weixin" ? channel.config : {};
+      const result = await runWeixinLogin(loginConfig);
+      if (channelId) {
+        if (channel && channel.provider === "weixin") {
+          const merged = mergeChannelInstance({
+            id: channel.id,
+            provider: channel.provider,
+            alias: channel.alias,
+            enabled: channel.enabled,
+            accountId: result.accountId,
+            baseUrl: channel.config.baseUrl,
+            cdnBaseUrl: channel.config.cdnBaseUrl,
+            mediaEnabled: channel.config.mediaEnabled === true,
+            feedbackMarkdownEnabled: channel.config.feedbackMarkdownEnabled === true
+          }, current);
+          saveConfig(merged.config);
+        }
+      }
       json(response, 200, {
         ok: true,
         message: `\u5FAE\u4FE1\u626B\u7801\u6210\u529F\uFF0C\u8D26\u53F7 ${result.accountId} \u5DF2\u4FDD\u5B58\u3002`,
-        htmlPath: result.htmlPath
+        htmlPath: result.htmlPath,
+        config: configToPayload(loadConfig())
       });
       return;
     }