coding-tool-x 3.4.0 → 3.4.1

package/src/server/services/codex-channels.js

@@ -8,602 +8,237 @@ const { getCodexDir } = require('./codex-config');
 const { isProxyConfig } = require('./codex-settings-manager');
 const { clearNativeOAuth } = require('./native-oauth-adapters');
 const { syncCodexUserEnvironment } = require('./codex-env-manager');
+const BaseChannelService = require('./base/base-channel-service');
 
 const CODEX_PROXY_ENV_KEY = 'CC_PROXY_KEY';
 const CODEX_PROXY_ENV_VALUE = 'PROXY_KEY';
 
-/**
- * Codex 渠道管理服务（多渠道架构）
- *
- * Codex 配置结构:
- * - config.toml: 主配置,包含 model_provider 和各提供商配置
- * - 用户级环境变量: env_key 对应的 API Key 存储
- * - 我们的 codex-channels.json: 完整渠道信息(用于管理)
- *
- * 多渠道模式：
- * - 使用 enabled 字段标记渠道是否启用
- * - 使用 weight 和 maxConcurrency 控制负载均衡
- */
-
-function normalizeGatewaySourceType(value, fallback = 'codex') {
-  const normalized = String(value || '').trim().toLowerCase();
-  if (normalized === 'claude') return 'claude';
-  if (normalized === 'codex') return 'codex';
-  if (normalized === 'gemini') return 'gemini';
-  return fallback;
-}
+// ── Codex 特有工具函数 ──
 
 function buildManagedCodexEnvMap(channels = [], { includeProxyKey = false } = {}) {
-  // 代理模式：只写代理 Key，不暴露真实 API Key
   if (includeProxyKey) {
     return { [CODEX_PROXY_ENV_KEY]: CODEX_PROXY_ENV_VALUE };
   }
-
-  // 直连模式：只写当前激活渠道的 Key，环境中有且只有一条记录
-  const activeChannel = channels.find(ch => ch.enabled && ch.envKey && ch.apiKey);
-  if (!activeChannel) return {};
-  return { [activeChannel.envKey]: activeChannel.apiKey };
-}
-
-// 获取渠道存储文件路径
-function getChannelsFilePath() {
-  const channelsDir = path.dirname(PATHS.channels.codex);
-  if (!fs.existsSync(channelsDir)) {
-    fs.mkdirSync(channelsDir, { recursive: true });
+  const envMap = {};
+  for (const ch of channels) {
+    if (ch.enabled !== false && ch.envKey && ch.apiKey) {
+      envMap[ch.envKey] = ch.apiKey;
+    }
   }
-  return PATHS.channels.codex;
+  return envMap;
 }
 
-// 读取所有渠道(从我们的存储文件)
-function loadChannels() {
-  const filePath = getChannelsFilePath();
-
-  if (!fs.existsSync(filePath)) {
-    // 尝试从 config.toml 初始化
-    return initializeFromConfig();
-  }
-
+function syncAllChannelEnvVars() {
   try {
-    const content = fs.readFileSync(filePath, 'utf8');
-    const data = JSON.parse(content);
-    // 确保渠道有 enabled 字段（兼容旧数据）
-    if (data.channels) {
-      data.channels = data.channels.map(ch => {
-        return {
-          ...ch,
-          enabled: ch.enabled !== false, // 默认启用
-          weight: ch.weight || 1,
-          maxConcurrency: ch.maxConcurrency || null,
-          modelRedirects: ch.modelRedirects || [],
-          speedTestModel: ch.speedTestModel || null,
-          gatewaySourceType: normalizeGatewaySourceType(ch.gatewaySourceType, 'codex')
-        };
-      });
-    }
-    return data;
+    const svc = getServiceInstance();
+    const data = svc.loadChannels();
+    const proxyRunning = isProxyConfig();
+    const envMap = buildManagedCodexEnvMap(data.channels, {
+      includeProxyKey: proxyRunning
+    });
+    syncCodexUserEnvironment(envMap, { replace: true });
   } catch (err) {
-    console.error('[Codex Channels] Failed to parse channels file:', err);
-    return { channels: [] };
+    console.warn('[Codex Channels] syncAllChannelEnvVars failed:', err.message);
   }
 }
 
-// 从现有 config.toml 初始化渠道
-function initializeFromConfig() {
-  const configPath = path.join(getCodexDir(), 'config.toml');
-  const authPath = path.join(getCodexDir(), 'auth.json');
-
-  const defaultData = { channels: [] };
-
-  if (!fs.existsSync(configPath)) {
-    saveChannels(defaultData);
-    return defaultData;
+function writeAnnotatedCodexConfig(configPath, config, comments = []) {
+  let tomlContent = tomlStringify(config);
+  if (comments.length > 0) {
+    tomlContent = comments.join('\n') + '\n\n' + tomlContent;
   }
+  fs.writeFileSync(configPath, tomlContent, 'utf8');
+}
 
-  try {
-    // 读取 config.toml
-    const configContent = fs.readFileSync(configPath, 'utf8');
-    const config = toml.parse(configContent);
-
-    // 读取 auth.json
-    let auth = {};
-    if (fs.existsSync(authPath)) {
-      auth = JSON.parse(fs.readFileSync(authPath, 'utf8'));
-    }
-
-    // 从 model_providers 提取渠道
-    const channels = [];
-    if (config.model_providers) {
-      for (const [providerKey, providerConfig] of Object.entries(config.model_providers)) {
-        // env_key 优先级：配置的 env_key > PROVIDER_API_KEY > OPENAI_API_KEY
-        let envKey = providerConfig.env_key || `${providerKey.toUpperCase()}_API_KEY`;
-        let apiKey = process.env[envKey] || auth[envKey] || '';
-
-        // 如果没找到，尝试 OPENAI_API_KEY 作为通用 fallback
-        if (!apiKey && (process.env.OPENAI_API_KEY || auth['OPENAI_API_KEY'])) {
-          apiKey = process.env.OPENAI_API_KEY || auth['OPENAI_API_KEY'];
-          envKey = 'OPENAI_API_KEY';
-        }
-
-        channels.push({
-          id: crypto.randomUUID(),
-          name: providerConfig.name || providerKey,
-          providerKey,
-          baseUrl: providerConfig.base_url || '',
-          wireApi: providerConfig.wire_api || 'responses',
-          envKey,
-          apiKey,
-          websiteUrl: providerConfig.website_url || '',
-          requiresOpenaiAuth: providerConfig.requires_openai_auth !== false,
-          queryParams: providerConfig.query_params || null,
-          enabled: config.model_provider === providerKey, // 当前激活的渠道启用
-          weight: 1,
-          maxConcurrency: null,
-          gatewaySourceType: 'codex',
-          createdAt: Date.now(),
-          updatedAt: Date.now()
-        });
-      }
+function pruneManagedProviders(existingProviders, currentProviderKey, allChannels) {
+  const knownKeys = new Set(allChannels.map(ch => ch.providerKey).filter(Boolean));
+  for (const key of Object.keys(existingProviders)) {
+    if (key !== currentProviderKey && !knownKeys.has(key)) {
+      delete existingProviders[key];
     }
-
-    const data = {
-      channels
-    };
-
-    saveChannels(data);
-    return data;
-  } catch (err) {
-    console.error('[Codex Channels] Failed to initialize from config:', err);
-    saveChannels(defaultData);
-    return defaultData;
   }
 }
 
-// 保存渠道数据
-function saveChannels(data) {
-  const filePath = getChannelsFilePath();
-  fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf8');
-}
-
-function getDefaultCodexConfig() {
-  return {
-    model: 'gpt-4',
-    model_reasoning_effort: 'high',
-    model_reasoning_summary_format: 'experimental',
-    network_access: 'enabled',
-    disable_response_storage: false,
-    show_raw_agent_reasoning: true
-  };
-}
-
-function cloneConfigValue(value) {
-  return JSON.parse(JSON.stringify(value));
-}
-
-function readCodexConfigOrThrow(configPath, fallbackConfig = {}) {
-  if (!fs.existsSync(configPath)) {
-    return cloneConfigValue(fallbackConfig);
-  }
-
-  const content = fs.readFileSync(configPath, 'utf8');
+function writeCodexConfigForMultiChannel(channels) {
+  const codexDir = getCodexDir();
+  const configPath = path.join(codexDir, 'config.toml');
 
-  try {
-    return toml.parse(content);
-  } catch (err) {
-    throw new Error(`Failed to parse existing config.toml: ${err.message}`);
+  let config = {};
+  if (fs.existsSync(configPath)) {
+    try {
+      config = toml.parse(fs.readFileSync(configPath, 'utf8'));
+    } catch (err) {
+      console.warn('[Codex Channels] Failed to parse existing config.toml:', err.message);
+      config = {};
+    }
   }
-}
 
-function writeTextAtomic(filePath, content) {
-  const dirPath = path.dirname(filePath);
-  if (!fs.existsSync(dirPath)) {
-    fs.mkdirSync(dirPath, { recursive: true });
+  if (!config.model_providers || typeof config.model_providers !== 'object') {
+    config.model_providers = {};
   }
 
-  const tempPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+  const enabledChannels = channels.filter(ch => ch.enabled !== false);
+  if (enabledChannels.length > 0) {
+    const primary = enabledChannels[0];
+    config.model_provider = primary.providerKey;
 
-  try {
-    fs.writeFileSync(tempPath, content, 'utf8');
-    fs.renameSync(tempPath, filePath);
-  } finally {
-    if (fs.existsSync(tempPath)) {
-      try {
-        fs.unlinkSync(tempPath);
-      } catch {
-        // ignore temp cleanup errors
+    for (const ch of enabledChannels) {
+      config.model_providers[ch.providerKey] = {
+        name: ch.name,
+        base_url: ch.baseUrl,
+        wire_api: ch.wireApi || 'responses',
+        env_key: ch.envKey,
+        requires_openai_auth: ch.requiresOpenaiAuth !== false
+      };
+      if (ch.queryParams && Object.keys(ch.queryParams).length > 0) {
+        config.model_providers[ch.providerKey].query_params = ch.queryParams;
       }
     }
   }
-}
 
-function writeAnnotatedCodexConfig(configPath, config, headerLines = []) {
-  const tomlContent = tomlStringify(config);
-  const prefix = headerLines.length > 0 ? `${headerLines.join('\n')}\n\n` : '';
-  writeTextAtomic(configPath, `${prefix}${tomlContent}`);
-}
-
-function getManagedProviderKeys(channels = []) {
-  const keys = new Set(['cc-proxy']);
-  for (const channel of channels) {
-    if (channel?.providerKey) {
-      keys.add(channel.providerKey);
-    }
-  }
-  return keys;
+  writeAnnotatedCodexConfig(configPath, config, [
+    '# Codex Configuration',
+    '# Managed by Coding-Tool (multi-channel)'
+  ]);
 }
 
-function pruneManagedProviders(existingProviders = {}, currentProviderKey, channels = []) {
-  const managedProviderKeys = getManagedProviderKeys(channels);
-  const preservedProviders = {};
+// ── CodexChannelService ──
 
-  for (const [providerKey, providerConfig] of Object.entries(existingProviders)) {
-    if (!managedProviderKeys.has(providerKey) || providerKey === currentProviderKey) {
-      preservedProviders[providerKey] = providerConfig;
-    }
+class CodexChannelService extends BaseChannelService {
+  constructor() {
+    super({
+      platform: 'codex',
+      channelsFilePath: PATHS.channels.codex,
+      defaultGatewaySource: 'codex',
+      isProxyRunning: () => isProxyConfig(),
+    });
   }
 
-  return preservedProviders;
-}
-
-// 获取所有渠道
-function getChannels() {
-  const data = loadChannels();
-  return {
-    channels: data.channels || []
-  };
-}
-
-// 添加渠道
-function createChannel(name, providerKey, baseUrl, apiKey, wireApi = 'responses', extraConfig = {}) {
-  const data = loadChannels();
-
-  // 检查 providerKey 是否已存在
-  const existing = data.channels.find(c => c.providerKey === providerKey);
-  if (existing) {
-    throw new Error(`Provider key "${providerKey}" already exists`);
+  _generateId() {
+    return crypto.randomUUID();
   }
 
-  const envKey = extraConfig.envKey || `${providerKey.toUpperCase()}_API_KEY`;
-
-  const newChannel = {
-    id: crypto.randomUUID(),
-    name,
-    providerKey,
-    baseUrl,
-    wireApi,
-    envKey,
-    apiKey,
-    websiteUrl: extraConfig.websiteUrl || '',
-    requiresOpenaiAuth: extraConfig.requiresOpenaiAuth !== false,
-    queryParams: extraConfig.queryParams || null,
-    enabled: extraConfig.enabled !== false, // 默认启用
-    weight: extraConfig.weight || 1,
-    maxConcurrency: extraConfig.maxConcurrency || null,
-    modelRedirects: extraConfig.modelRedirects || [],
-    speedTestModel: extraConfig.speedTestModel || null,
-    gatewaySourceType: normalizeGatewaySourceType(extraConfig.gatewaySourceType, 'codex'),
-    createdAt: Date.now(),
-    updatedAt: Date.now()
-  };
-
-  data.channels.push(newChannel);
-  saveChannels(data);
-  syncAllChannelEnvVars(data.channels);
-
-  // 注意：不再自动写入 config.toml，只在开启代理控制时才同步
-  // writeCodexConfigForMultiChannel(data.channels);
-
-  return newChannel;
-}
-
-// 更新渠道
-function updateChannel(channelId, updates) {
-  const data = loadChannels();
-  const index = data.channels.findIndex(c => c.id === channelId);
-
-  if (index === -1) {
-    throw new Error('Channel not found');
+  _applyDefaults(channel) {
+    const ch = super._applyDefaults(channel);
+    ch.providerKey = ch.providerKey || '';
+    ch.envKey = ch.envKey || '';
+    ch.wireApi = ch.wireApi || 'responses';
+    ch.model = ch.model || '';
+    ch.speedTestModel = ch.speedTestModel || null;
+    ch.modelRedirects = Array.isArray(ch.modelRedirects) ? ch.modelRedirects : [];
+    ch.gatewaySourceType = ch.gatewaySourceType || 'codex';
+    ch.requiresOpenaiAuth = ch.requiresOpenaiAuth !== false;
+    ch.queryParams = ch.queryParams || {};
+    return ch;
   }
 
-  const oldChannel = data.channels[index];
-
-  // 检查 providerKey 冲突
-  if (updates.providerKey && updates.providerKey !== oldChannel.providerKey) {
-    const existing = data.channels.find(c => c.providerKey === updates.providerKey && c.id !== channelId);
-    if (existing) {
-      throw new Error(`Provider key "${updates.providerKey}" already exists`);
+  _validateUniqueness(channels, fields, excludeId) {
+    if (!fields.providerKey) return;
+    const dup = channels.find(ch =>
+      ch.providerKey === fields.providerKey && ch.id !== excludeId
+    );
+    if (dup) {
+      throw new Error(`Provider key "${fields.providerKey}" already exists`);
     }
   }
 
-  const merged = { ...oldChannel, ...updates };
-  const newChannel = {
-    ...merged,
-    id: channelId, // 保持 ID 不变
-    createdAt: oldChannel.createdAt, // 保持创建时间
-    modelRedirects: merged.modelRedirects || [],
-    speedTestModel: merged.speedTestModel !== undefined ? merged.speedTestModel : (oldChannel.speedTestModel || null),
-    gatewaySourceType: normalizeGatewaySourceType(merged.gatewaySourceType, 'codex'),
-    updatedAt: Date.now()
-  };
-
-  data.channels[index] = newChannel;
-
-  // Get proxy status
-  const { getCodexProxyStatus } = require('../codex-proxy-server');
-  const proxyStatus = getCodexProxyStatus();
-  const isProxyRunning = proxyStatus.running;
-
-  // Single-channel enforcement: enabling a channel disables all others ONLY when proxy is OFF
-  // When proxy is ON (dynamic switching), multiple channels can be enabled simultaneously
-  if (!isProxyRunning && newChannel.enabled && !oldChannel.enabled) {
-    data.channels.forEach((ch, i) => {
-      if (i !== index && ch.enabled) {
-        ch.enabled = false;
-      }
-    });
-    console.log(`[Codex Single-channel mode] Enabled "${newChannel.name}", disabled all others`);
+  _onAfterCreate(_channel, _allChannels) {
+    syncAllChannelEnvVars();
+    // 注意：不再自动写入 config.toml，只在开启代理控制时才同步
   }
 
-  saveChannels(data);
-
-  // Sync config.toml only when proxy is OFF.
-  // In dynamic switching mode, defer local config writes until proxy stop.
-  if (!isProxyRunning && newChannel.enabled) {
-    console.log(`[Codex Settings-sync] Channel "${newChannel.name}" enabled, syncing config.toml...`);
-    applyChannelToSettings(channelId);
+  _onAfterUpdate(_old, _next, _allChannels) {
+    syncAllChannelEnvVars();
+    // 注意：不再自动写入 config.toml，只在开启代理控制时才同步
   }
 
-  syncAllChannelEnvVars(data.channels);
-
-  // 注意：不再自动写入 config.toml，只在开启代理控制时才同步
-  // writeCodexConfigForMultiChannel(data.channels);
-
-  return data.channels[index];
-}
-
-// 删除渠道
-async function deleteChannel(channelId) {
-  const data = loadChannels();
-
-  const index = data.channels.findIndex(c => c.id === channelId);
-  if (index === -1) {
-    throw new Error('Channel not found');
+  _onAfterDelete(_channel, _allChannels) {
+    clearNativeOAuth('codex');
+    syncAllChannelEnvVars();
+    // 注意：不再自动写入 config.toml，只在开启代理控制时才同步
   }
 
-  const deletedChannel = data.channels[index];
-  data.channels.splice(index, 1);
-  saveChannels(data);
-  syncAllChannelEnvVars(data.channels);
+  _applyToNativeSettings(channel) {
+    clearNativeOAuth('codex');
+    const codexDir = getCodexDir();
+    const configPath = path.join(codexDir, 'config.toml');
 
-  // 注意：不再自动写入 config.toml，只在开启代理控制时才同步
-  // writeCodexConfigForMultiChannel(data.channels);
-
-  return { success: true };
-}
-
-/**
- * 写入 Codex 配置文件（多渠道模式）
- *
- * 关键改进：
- * 1. 完整保留现有配置（mcp_servers, projects 等）
- * 2. 如果已启用动态切换（cc-proxy），不覆盖 model_provider
- * 3. 使用 TOML 序列化而不是字符串拼接，确保配置完整性
- */
-function writeCodexConfigForMultiChannel(allChannels) {
-  const codexDir = getCodexDir();
-
-  if (!fs.existsSync(codexDir)) {
-    fs.mkdirSync(codexDir, { recursive: true });
-  }
-
-  const configPath = path.join(codexDir, 'config.toml');
+    let config = {};
+    if (fs.existsSync(configPath)) {
+      try {
+        config = toml.parse(fs.readFileSync(configPath, 'utf8'));
+      } catch (err) {
+        config = {};
+      }
+    }
 
-  // 读取现有配置，保留所有现有字段（特别是 mcp_servers, projects 等）
-  const defaultConfig = getDefaultCodexConfig();
-  const parsedConfig = readCodexConfigOrThrow(configPath, defaultConfig);
-  let config = {
-    ...parsedConfig,
-    model: parsedConfig.model || defaultConfig.model,
-    model_reasoning_effort: parsedConfig.model_reasoning_effort || defaultConfig.model_reasoning_effort,
-    model_reasoning_summary_format: parsedConfig.model_reasoning_summary_format || defaultConfig.model_reasoning_summary_format,
-    network_access: parsedConfig.network_access || defaultConfig.network_access,
-    disable_response_storage: parsedConfig.disable_response_storage !== undefined ? parsedConfig.disable_response_storage : defaultConfig.disable_response_storage,
-    show_raw_agent_reasoning: parsedConfig.show_raw_agent_reasoning !== undefined ? parsedConfig.show_raw_agent_reasoning : defaultConfig.show_raw_agent_reasoning
-  };
-
-  // 判断是否已启用动态切换
-  const isProxyMode = config.model_provider === 'cc-proxy';
-  const existingProviders = (config && typeof config.model_providers === 'object') ? config.model_providers : {};
-  const existingProxyProvider = existingProviders['cc-proxy'];
-
-  // 只有当未启用动态切换时，才更新 model_provider
-  if (!isProxyMode) {
-    const enabledChannels = allChannels.filter(c => c.enabled !== false);
-    const defaultProvider = enabledChannels[0]?.providerKey || allChannels[0]?.providerKey || 'openai';
-    config.model_provider = defaultProvider;
-  }
+    config.model_provider = channel.providerKey;
 
-  // 重建 model_providers 配置，先保留已有的非渠道 provider，避免丢失用户自定义配置
-  config.model_providers = { ...existingProviders };
-
-  // 在代理模式下，先保留 cc-proxy provider，避免被覆盖导致缺少 provider
-  if (isProxyMode) {
-    if (existingProxyProvider) {
-      config.model_providers['cc-proxy'] = existingProxyProvider;
-    } else {
-      // 回退默认的代理配置（使用默认端口），确保 provider 存在
-      config.model_providers['cc-proxy'] = {
-        name: 'cc-proxy',
-        base_url: 'http://127.0.0.1:20089/v1',
-        wire_api: 'responses',
-        env_key: 'CC_PROXY_KEY'
-      };
+    if (!config.model_providers || typeof config.model_providers !== 'object') {
+      config.model_providers = {};
     }
-  }
+    const data = this.loadChannels();
+    pruneManagedProviders(config.model_providers, channel.providerKey, data.channels);
 
-  for (const channel of allChannels) {
     config.model_providers[channel.providerKey] = {
       name: channel.name,
       base_url: channel.baseUrl,
-      wire_api: channel.wireApi,
+      wire_api: channel.wireApi || 'responses',
       env_key: channel.envKey,
       requires_openai_auth: channel.requiresOpenaiAuth !== false
     };
 
-    // 添加额外查询参数(如 Azure 的 api-version)
     if (channel.queryParams && Object.keys(channel.queryParams).length > 0) {
       config.model_providers[channel.providerKey].query_params = channel.queryParams;
     }
-  }
-
-  writeAnnotatedCodexConfig(configPath, config, [
-    '# Codex Configuration',
-    '# Managed by Coding-Tool',
-    '# WARNING: MCP servers and projects are preserved automatically'
-  ]);
-  syncCodexUserEnvironment(
-    buildManagedCodexEnvMap(allChannels, { includeProxyKey: isProxyMode }),
-    { replace: true }
-  );
-}
 
-// 获取所有启用的渠道（供调度器使用）
-function getEnabledChannels() {
-  const data = loadChannels();
-  return data.channels.filter(c => c.enabled !== false);
-}
-
-// 保存渠道顺序
-function saveChannelOrder(order) {
-  const data = loadChannels();
-
-  // 按照给定的顺序重新排列
-  const orderedChannels = [];
-  for (const id of order) {
-    const channel = data.channels.find(c => c.id === id);
-    if (channel) {
-      orderedChannels.push(channel);
-    }
-  }
-
-  // 添加不在顺序中的渠道(新添加的)
-  for (const channel of data.channels) {
-    if (!orderedChannels.find(c => c.id === channel.id)) {
-      orderedChannels.push(channel);
-    }
+    writeAnnotatedCodexConfig(configPath, config, [
+      '# Codex Configuration',
+      '# Managed by Coding-Tool',
+      `# Current provider: ${channel.name}`
+    ]);
+    console.log(`[Codex Channels] Applied channel ${channel.name} to config.toml`);
+    syncAllChannelEnvVars();
   }
-
-  data.channels = orderedChannels;
-  saveChannels(data);
 }
 
-/**
- * 同步所有渠道的环境变量到 shell 配置文件
- * 确保用户可以直接使用 codex 命令而无需手动设置环境变量
- * 这个函数会在服务启动时自动调用
- */
-function syncAllChannelEnvVars(channels = null) {
-  const data = channels ? { channels } : loadChannels();
-  return syncCodexUserEnvironment(
-    buildManagedCodexEnvMap(data.channels || [], { includeProxyKey: isProxyConfig() }),
-    { replace: true }
-  );
+// ── 单例 + 兼容导出 ──
+
+let _instance = null;
+function getServiceInstance() {
+  if (!_instance) _instance = new CodexChannelService();
+  return _instance;
 }
 
-/**
- * 将指定渠道应用到 Codex 配置文件
- * 类似 Claude 的"写入配置"功能，将渠道设置为当前激活的 provider
- *
- * @param {string} channelId - 渠道 ID
- * @param {Object} options - 可选参数
- * @param {boolean} options.pruneProviders - 是否清理 model_providers 仅保留当前渠道
- * @returns {Object} 应用结果
- */
-function applyChannelToSettings(channelId, options = {}) {
-  const data = loadChannels();
-  const channel = data.channels.find(c => c.id === channelId);
-
-  if (!channel) {
-    throw new Error('Channel not found');
-  }
+const service = getServiceInstance();
 
-  // In single-channel mode, only this channel should be enabled
-  data.channels.forEach(ch => {
-    ch.enabled = ch.id === channelId;
+function getChannels() { return service.getChannels(); }
+function getEnabledChannels() { return service.getEnabledChannels(); }
+function createChannel(name, providerKey, baseUrl, apiKey, wireApi, extraConfig = {}) {
+  const envKey = extraConfig.envKey || `${providerKey.toUpperCase()}_API_KEY`;
+  return service.createChannel({
+    name, providerKey, baseUrl, apiKey, wireApi,
+    envKey,
+    ...extraConfig,
   });
-  saveChannels(data);
-  clearNativeOAuth('codex');
-
-  const codexDir = getCodexDir();
-
-  if (!fs.existsSync(codexDir)) {
-    fs.mkdirSync(codexDir, { recursive: true });
-  }
-
-  const configPath = path.join(codexDir, 'config.toml');
-
-  // 读取现有配置，保留 mcp_servers, projects 等
-  let config = readCodexConfigOrThrow(configPath, getDefaultCodexConfig());
-
-  // 设置当前渠道为 model_provider
-  config.model_provider = channel.providerKey;
-
-  // 可选：清理 provider，关闭动态切换后只保留当前渠道配置
-  if (options.pruneProviders === true) {
-    const existingProviders = (config.model_providers && typeof config.model_providers === 'object')
-      ? config.model_providers
-      : {};
-    config.model_providers = pruneManagedProviders(existingProviders, channel.providerKey, data.channels);
-  } else if (!config.model_providers || typeof config.model_providers !== 'object') {
-    // 默认兼容历史行为：保留已有 provider
-    config.model_providers = {};
-  }
-
-  // 添加/更新当前渠道的 provider 配置
-  config.model_providers[channel.providerKey] = {
-    name: channel.name,
-    base_url: channel.baseUrl,
-    wire_api: channel.wireApi || 'responses',
-    env_key: channel.envKey,
-    requires_openai_auth: channel.requiresOpenaiAuth !== false
-  };
-
-  // 添加额外查询参数(如 Azure 的 api-version)
-  if (channel.queryParams && Object.keys(channel.queryParams).length > 0) {
-    config.model_providers[channel.providerKey].query_params = channel.queryParams;
-  }
-
-  writeAnnotatedCodexConfig(configPath, config, [
-    '# Codex Configuration',
-    '# Managed by Coding-Tool',
-    `# Current provider: ${channel.name}`
-  ]);
-  console.log(`[Codex Channels] Applied channel ${channel.name} to config.toml`);
-  syncAllChannelEnvVars();
-
-  return channel;
 }
+function updateChannel(id, updates) { return service.updateChannel(id, updates); }
+function deleteChannel(id) { return service.deleteChannel(id); }
+function saveChannelOrder(order) { return service.saveChannelOrder(order); }
+function applyChannelToSettings(id) { return service.applyChannelToSettings(id); }
+function getEffectiveApiKey(channel) { return service.getEffectiveApiKey(channel); }
+function disableAllChannels() { return service.disableAllChannels(); }
 
-// 服务启动时自动同步环境变量（静默执行，不影响其他功能）
+// 服务启动时自动同步环境变量
 try {
-  const data = loadChannels();
+  const data = service.loadChannels();
   if (data.channels && data.channels.length > 0) {
     syncAllChannelEnvVars();
   }
 } catch (err) {
-  // 静默失败，不影响模块加载
   console.warn('[Codex Channels] Auto sync env vars failed:', err.message);
 }
 
-function getEffectiveApiKey(channel) {
-  return channel.apiKey || null;
-}
-
-function disableAllChannels() {
-  const data = loadChannels();
-  data.channels.forEach(ch => { ch.enabled = false; });
-  saveChannels(data);
-}
-
 module.exports = {
   getChannels,
   createChannel,
@@ -615,5 +250,5 @@ module.exports = {
   writeCodexConfigForMultiChannel,
   applyChannelToSettings,
   getEffectiveApiKey,
-  disableAllChannels
+  disableAllChannels,
 };