coding-tool-x 3.7.2 → 3.7.3

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

@@ -5,6 +5,13 @@ const { PATHS, NATIVE_PATHS } = require('../../config/paths');
 const { resolveChannelWebsiteUrl } = require('../../config/channel-preset-websites');
 const { clearNativeOAuth } = require('./native-oauth-adapters');
 const { normalizeGatewaySourceType } = require('./base/proxy-utils');
+const {
+  createSkippedResult,
+  isLocalProxyBaseUrl,
+  resolveApiKeyValue,
+  resolveExistingActiveChannel,
+  upsertSyncedChannels
+} = require('./channel-sync-utils');
 
 const GEMINI_API_FORMATS = new Set(['gemini_api', 'vertex_ai_v1']);
 
@@ -516,6 +523,121 @@ function disableAllChannels() {
   saveChannels(data);
 }
 
+function readGeminiSettings() {
+  const settingsPath = NATIVE_PATHS.gemini.settings;
+  if (!settingsPath || !fs.existsSync(settingsPath)) {
+    return {};
+  }
+  try {
+    return JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function normalizeGeminiChannel(channel = {}) {
+  const normalized = {
+    ...channel,
+    enabled: channel.enabled !== false,
+    weight: channel.weight || 1,
+    maxConcurrency: channel.maxConcurrency || null,
+    balanceToken: channel.balanceToken || '',
+    balanceUserId: channel.balanceUserId || null,
+    modelRedirects: channel.modelRedirects || [],
+    speedTestModel: channel.speedTestModel || null,
+    apiFormat: normalizeGeminiApiFormat(channel.apiFormat),
+    gatewaySourceType: normalizeGatewaySourceType(channel.gatewaySourceType, 'gemini')
+  };
+  normalized.websiteUrl = resolveChannelWebsiteUrl('gemini', normalized);
+  return normalized;
+}
+
+function loadStoredGeminiChannels() {
+  const filePath = getChannelsFilePath();
+  if (!fs.existsSync(filePath)) {
+    return { channels: [] };
+  }
+  try {
+    const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    return {
+      ...data,
+      channels: Array.isArray(data?.channels)
+        ? data.channels.map(normalizeGeminiChannel)
+        : []
+    };
+  } catch (error) {
+    console.error('[Gemini Channels] Failed to parse channels file for sync:', error.message);
+    return { channels: [] };
+  }
+}
+
+function buildGeminiSyncCandidate(env, channels) {
+  const baseUrl = String(env.GOOGLE_GEMINI_BASE_URL || '').trim();
+  if (isLocalProxyBaseUrl(baseUrl)) {
+    const existing = resolveExistingActiveChannel('gemini', channels);
+    if (existing) {
+      return {
+        skip: true,
+        channel: existing,
+        warning: 'Gemini 当前配置指向 ctx 代理；对应渠道已在列表中，未重复导入。'
+      };
+    }
+    return {
+      skip: true,
+      warning: 'Gemini 当前配置指向 ctx 代理，但没有找到可匹配的现有渠道。'
+    };
+  }
+
+  const settings = readGeminiSettings();
+  const selectedAuthType = String(settings?.security?.auth?.selectedType || '').trim();
+  const existing = baseUrl
+    ? channels.find(channel => String(channel.baseUrl || '').trim() === baseUrl)
+    : null;
+  const credential = resolveApiKeyValue(env.GEMINI_API_KEY || '');
+  const apiKey = credential.value || existing?.apiKey || '';
+  if (!apiKey) {
+    return {
+      skip: true,
+      channel: existing || null,
+      warning: selectedAuthType.includes('oauth')
+        ? 'Gemini 当前配置是 OAuth/登录态，OAuth 渠道不支持同步导入。'
+        : 'Gemini 当前 .env 缺少 GEMINI_API_KEY，无法同步导入。'
+    };
+  }
+
+  return {
+    name: existing?.name || 'Gemini 当前配置',
+    baseUrl: baseUrl || 'https://generativelanguage.googleapis.com/v1beta',
+    apiKey,
+    model: env.GEMINI_MODEL || existing?.model || 'gemini-2.5-pro',
+    apiFormat: existing?.apiFormat || 'gemini_api',
+    gatewaySourceType: existing?.gatewaySourceType || 'gemini',
+    credentialSource: credential.value ? credential.source : 'existing-channel'
+  };
+}
+
+function syncCurrentGeminiChannel() {
+  const data = loadStoredGeminiChannels();
+  const channels = Array.isArray(data.channels) ? data.channels : [];
+  const env = readExistingGeminiEnv();
+  const candidate = buildGeminiSyncCandidate(env, channels);
+  if (candidate?.skip) {
+    return createSkippedResult('gemini', candidate.warning, candidate.channel);
+  }
+
+  return upsertSyncedChannels({
+    toolType: 'gemini',
+    loadChannels: loadStoredGeminiChannels,
+    saveChannels,
+    applyDefaults: normalizeGeminiChannel,
+    candidates: [candidate],
+    matchers: [
+      (channel, current) => channel.baseUrl === current.baseUrl && channel.apiKey === current.apiKey,
+      (channel, current) => channel.baseUrl === current.baseUrl && channel.model === current.model
+    ]
+  });
+}
+
 module.exports = {
   getChannels,
   createChannel,
@@ -529,6 +651,7 @@ module.exports = {
   getGeminiDir,
   applyChannelToSettings,
   disableAllChannels,
+  syncCurrentGeminiChannel,
   _test: {
     normalizeGeminiApiFormat
   }

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

@@ -1,11 +1,27 @@
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
 const { PATHS } = require('../../config/paths');
 const BaseChannelService = require('./base/base-channel-service');
+const ompConfig = require('./omp-config');
 const {
   writeManagedOmpProviders,
   removeManagedOmpProviders,
   isManagedOmpProvidersActive,
-  getLastManagedOmpSyncResult
+  getLastManagedOmpSyncResult,
+  readModelsConfig,
+  readOmpSettingsConfig,
+  normalizeProviderId,
+  normalizeProviderApi
 } = require('./omp-settings-manager');
+const {
+  createSkippedResult,
+  resolveApiKeyValue,
+  resolveExistingActiveChannel,
+  upsertSyncedChannels
+} = require('./channel-sync-utils');
+
+const OMP_THINKING_SUFFIX_RE = /:(minimal|low|medium|high|xhigh)$/;
 
 class OmpChannelService extends BaseChannelService {
   constructor() {
@@ -76,6 +92,286 @@ class OmpChannelService extends BaseChannelService {
 
 const service = new OmpChannelService();
 
+function splitOmpModelRef(value = '') {
+  const raw = String(value || '').trim();
+  if (!raw || !raw.includes('/')) {
+    return { providerId: '', modelId: normalizeOmpModelId(raw) };
+  }
+  const index = raw.indexOf('/');
+  return {
+    providerId: raw.slice(0, index).trim(),
+    modelId: normalizeOmpModelId(raw.slice(index + 1))
+  };
+}
+
+function getOriginalOmpProviderId(providerId = '') {
+  const normalized = String(providerId || '').trim();
+  return normalized.startsWith('ctx-') ? normalized.slice(4) : normalized;
+}
+
+function normalizeOmpModelId(value = '') {
+  return String(value || '').trim().replace(OMP_THINKING_SUFFIX_RE, '');
+}
+
+function pushUnique(values, value) {
+  const item = String(value || '').trim();
+  if (item && !values.includes(item)) {
+    values.push(item);
+  }
+}
+
+function collectOmpModelIds(provider = {}) {
+  const models = Array.isArray(provider.models) ? provider.models : [];
+  return models
+    .map(model => typeof model === 'string' ? model : (model?.id || model?.name || ''))
+    .map(normalizeOmpModelId)
+    .filter(Boolean);
+}
+
+function getOmpProviders(modelsConfig = {}) {
+  return modelsConfig?.providers && typeof modelsConfig.providers === 'object' && !Array.isArray(modelsConfig.providers)
+    ? modelsConfig.providers
+    : {};
+}
+
+function getKnownOmpProviderId(providers = {}, providerId = '') {
+  const raw = String(providerId || '').trim();
+  if (providers[raw]) return raw;
+  const normalizedRaw = normalizeProviderId(raw);
+  return Object.keys(providers).find((key) => {
+    return normalizeProviderId(key) === normalizedRaw
+      || normalizeProviderId(getOriginalOmpProviderId(key)) === normalizedRaw;
+  }) || raw;
+}
+
+function createOmpSelection(providerId = '') {
+  return {
+    providerId,
+    modelIds: [],
+    roleModelIds: []
+  };
+}
+
+function collectOmpSyncSelections(modelsConfig = {}, settings = {}) {
+  const providers = getOmpProviders(modelsConfig);
+  const selections = new Map();
+
+  const addRef = (value, source = 'enabled') => {
+    const { providerId, modelId } = splitOmpModelRef(value);
+    if (!providerId) return;
+    const knownProviderId = getKnownOmpProviderId(providers, providerId);
+    const selection = selections.get(knownProviderId) || createOmpSelection(knownProviderId);
+    if (modelId) {
+      pushUnique(selection.modelIds, modelId);
+      if (source === 'role') {
+        pushUnique(selection.roleModelIds, modelId);
+      }
+    }
+    selections.set(knownProviderId, selection);
+  };
+
+  (Array.isArray(settings.enabledModels) ? settings.enabledModels : []).forEach(item => addRef(item, 'enabled'));
+
+  const roles = settings?.modelRoles && typeof settings.modelRoles === 'object' && !Array.isArray(settings.modelRoles)
+    ? settings.modelRoles
+    : {};
+  addRef(roles.default, 'role');
+  Object.entries(roles).forEach(([roleName, value]) => {
+    if (roleName !== 'default') addRef(value, 'role');
+  });
+
+  const fallbackChains = settings?.retry?.fallbackChains;
+  if (fallbackChains && typeof fallbackChains === 'object' && !Array.isArray(fallbackChains)) {
+    Object.values(fallbackChains).forEach((chain) => {
+      (Array.isArray(chain) ? chain : [chain]).forEach(item => addRef(item, 'fallback'));
+    });
+  }
+
+  if (selections.size === 0) {
+    const providerIds = Object.keys(providers);
+    if (providerIds.length === 1) {
+      selections.set(providerIds[0], createOmpSelection(providerIds[0]));
+    }
+  }
+
+  return [...selections.values()];
+}
+
+function findOmpExistingChannel(channels = [], providerId = '', baseUrl = '') {
+  const rawProvider = String(providerId || '').trim();
+  const originalProvider = getOriginalOmpProviderId(rawProvider);
+  const normalizedProvider = normalizeProviderId(originalProvider || rawProvider);
+  return channels.find(channel => {
+    const keys = [
+      channel.providerKey,
+      channel.provider,
+      channel.name,
+      getOriginalOmpProviderId(channel.providerKey)
+    ].map(value => normalizeProviderId(value || '')).filter(Boolean);
+    return keys.includes(normalizedProvider);
+  }) || channels.find(channel => baseUrl && channel.baseUrl === baseUrl) || null;
+}
+
+function filterOmpProviderModels(models = [], allowedModels = []) {
+  if (!Array.isArray(models) || allowedModels.length === 0) return Array.isArray(models) ? models : [];
+  const allowed = new Set(allowedModels.map(normalizeOmpModelId));
+  return models.filter((model) => {
+    const id = normalizeOmpModelId(typeof model === 'string' ? model : (model?.id || model?.name || ''));
+    return allowed.has(id);
+  });
+}
+
+function parseOmpApiKeyCredentialData(data) {
+  if (!data) return '';
+  try {
+    const parsed = JSON.parse(String(data));
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return '';
+    return String(parsed.key || parsed.apiKey || parsed.api_key || parsed.value || parsed.token || '').trim();
+  } catch {
+    return '';
+  }
+}
+
+function runOmpAuthDbQuery(dbPath, providerIds = []) {
+  if (!dbPath || !fs.existsSync(dbPath) || providerIds.length === 0) return [];
+  const escapedProviders = providerIds
+    .map(providerId => `'${String(providerId || '').replace(/'/g, "''")}'`)
+    .join(',');
+  const sql = [
+    'select provider, credential_type, data',
+    'from auth_credentials',
+    `where provider in (${escapedProviders})`,
+    "and credential_type = 'api_key'",
+    'and (disabled_cause is null or disabled_cause = \'\')',
+    'order by updated_at desc',
+    'limit 5'
+  ].join(' ');
+
+  try {
+    const output = execFileSync('sqlite3', ['-json', dbPath, sql], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+      maxBuffer: 1024 * 1024,
+      windowsHide: true
+    }).trim();
+    if (!output) return [];
+    const parsed = JSON.parse(output);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+function readOmpApiKeyCredential(providerId = '') {
+  const rawProviderId = String(providerId || '').trim();
+  const originalProviderId = getOriginalOmpProviderId(rawProviderId);
+  const providerIds = [...new Set([rawProviderId, originalProviderId].filter(Boolean))];
+  if (providerIds.length === 0) return { value: '', source: '', envName: '' };
+
+  let dbPath = '';
+  try {
+    const paths = typeof ompConfig.getOmpPaths === 'function' ? ompConfig.getOmpPaths() : {};
+    dbPath = path.join(paths.agentDir || path.dirname(paths.modelsYml || ''), 'agent.db');
+  } catch {
+    dbPath = '';
+  }
+
+  const rows = runOmpAuthDbQuery(dbPath, providerIds);
+  for (const row of rows) {
+    const value = parseOmpApiKeyCredentialData(row?.data);
+    if (value) {
+      return { value, source: 'omp-auth-db', envName: '' };
+    }
+  }
+  return { value: '', source: '', envName: '' };
+}
+
+function buildOmpSyncCandidate(modelsConfig, selection, channels) {
+  const providerId = selection?.providerId || '';
+  const provider = modelsConfig?.providers?.[providerId] || null;
+  if (!provider || typeof provider !== 'object') {
+    return {
+      skip: true,
+      warning: `OMP 当前 provider "${providerId}" 未在 models.yml 中定义。`
+    };
+  }
+
+  const baseUrl = String(provider.baseUrl || provider.base_url || '').trim();
+  const originalProviderId = getOriginalOmpProviderId(providerId);
+  const existing = findOmpExistingChannel(channels, providerId, baseUrl);
+  let credential = resolveApiKeyValue(provider.apiKey || provider.api_key || '');
+  if (!credential.value) {
+    credential = readOmpApiKeyCredential(providerId);
+  }
+  const apiKey = credential.value || existing?.apiKey || '';
+  const providerModelIds = collectOmpModelIds(provider);
+  const selectedModelIds = Array.isArray(selection?.modelIds) ? selection.modelIds : [];
+  const allowedModels = selectedModelIds.length > 0 ? selectedModelIds : providerModelIds;
+  const preferredModel = selection?.roleModelIds?.[0]
+    || selectedModelIds[0]
+    || existing?.model
+    || allowedModels[0]
+    || null;
+  if (!apiKey) {
+    return {
+      skip: true,
+      channel: existing || null,
+      warning: `OMP 当前 provider "${providerId}" 缺少可解析 API Key，OAuth/登录态渠道不支持同步导入。`
+    };
+  }
+
+  return {
+    name: existing?.name || originalProviderId || providerId,
+    providerKey: originalProviderId || providerId,
+    baseUrl,
+    apiKey,
+    providerApi: normalizeProviderApi(provider.api),
+    wireApi: provider.api || 'openai-completions',
+    authMode: 'api_key',
+    oauthProviderId: '',
+    model: preferredModel,
+    allowedModels,
+    models: filterOmpProviderModels(provider.models, allowedModels),
+    gatewaySourceType: existing?.gatewaySourceType || 'openai_compatible',
+    credentialSource: credential.value ? credential.source : 'existing-channel'
+  };
+}
+
+function syncCurrentOmpChannel() {
+  let modelsConfig = { providers: {} };
+  let settings = {};
+  try {
+    modelsConfig = readModelsConfig();
+    settings = readOmpSettingsConfig();
+  } catch (error) {
+    return createSkippedResult('omp', `OMP 配置读取失败：${error.message}`);
+  }
+
+  const data = service.loadChannels();
+  const channels = Array.isArray(data.channels) ? data.channels : [];
+  const selections = collectOmpSyncSelections(modelsConfig, settings);
+  if (selections.length === 0) {
+    const active = resolveExistingActiveChannel('omp', channels);
+    if (active) {
+      return createSkippedResult('omp', 'OMP 当前配置未明确 provider；已找到当前面板中的 active 渠道，未重复导入。', active);
+    }
+    return createSkippedResult('omp', 'OMP 当前配置未明确 provider，无法同步当前渠道。');
+  }
+  const candidates = selections.map(selection => buildOmpSyncCandidate(modelsConfig, selection, channels));
+
+  return upsertSyncedChannels({
+    toolType: 'omp',
+    loadChannels: () => service.loadChannels(),
+    saveChannels: payload => service.saveChannels(payload),
+    applyDefaults: channel => service._applyDefaults(channel),
+    candidates,
+    matchers: [
+      (channel, current) => channel.providerKey && channel.providerKey === current.providerKey,
+      (channel, current) => channel.baseUrl === current.baseUrl && channel.apiKey === current.apiKey
+    ]
+  });
+}
+
 module.exports = {
   getChannels: () => service.getChannels(),
   createChannel: (name, baseUrl, apiKey, extra = {}) => service.createChannel({
@@ -95,5 +391,6 @@ module.exports = {
   syncManagedOmpProviders: (channels) => service.syncManagedOmpProviders(channels),
   disableManagedOmpProviders: () => service.disableManagedOmpProviders(),
   syncManagedProviderExtension: (channels) => service.syncManagedProviderExtension(channels),
-  disableManagedProviderExtension: () => service.disableManagedProviderExtension()
+  disableManagedProviderExtension: () => service.disableManagedProviderExtension(),
+  syncCurrentOmpChannel
 };

package/src/server/services/omp-settings-manager.js

@@ -965,6 +965,8 @@ module.exports = {
   isManagedOmpProvidersActive,
   isManagedProviderExtensionActive: isManagedOmpProvidersActive,
   normalizeProviderId,
+  normalizeProviderApi,
+  readOmpSettingsConfig,
   readModelsConfig,
   removeManagedOmpProviders,
   removeManagedProviderExtension: removeManagedOmpProviders,

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

@@ -5,9 +5,18 @@ const { PATHS } = require('../../config/paths');
 const { resolveChannelWebsiteUrl } = require('../../config/channel-preset-websites');
 const {
   setChannelConfig,
-  clearManagedChannelConfig
+  clearManagedChannelConfig,
+  readConfig,
+  selectConfigPath
 } = require('./opencode-settings-manager');
 const { normalizeGatewaySourceType } = require('./base/proxy-utils');
+const {
+  createSkippedResult,
+  isLocalProxyBaseUrl,
+  resolveApiKeyValue,
+  resolveExistingActiveChannel,
+  upsertSyncedChannels
+} = require('./channel-sync-utils');
 
 function clearChannelBalanceCache(channel) {
   try {
@@ -93,7 +102,7 @@ function loadChannels() {
           gatewaySourceType: normalizeGatewaySourceType(ch.gatewaySourceType, 'codex'),
           allowedModels: ch.allowedModels || []
         };
-        normalized.providerKey = deriveProviderKey(normalized);
+        normalized.providerKey = ch.providerKey || deriveProviderKey(normalized);
         normalized.websiteUrl = resolveChannelWebsiteUrl('opencode', normalized);
         return normalized;
       });
@@ -113,6 +122,15 @@ function deriveProviderKey(channel) {
   return `opencode_${base}`;
 }
 
+function sanitizeOpenCodeProviderId(value) {
+  return String(value || '')
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '')
+    || 'channel';
+}
+
 function getOpenCodeProxyRunning() {
   const { getOpenCodeProxyStatus } = require('../opencode-proxy-server');
   return Boolean(getOpenCodeProxyStatus()?.running);
@@ -229,7 +247,7 @@ function updateChannel(channelId, updates) {
     ),
     updatedAt: Date.now()
   };
-  merged.providerKey = updates.providerKey || deriveProviderKey(merged);
+  merged.providerKey = updates.providerKey || oldChannel.providerKey || deriveProviderKey(merged);
   merged.websiteUrl = resolveChannelWebsiteUrl('opencode', merged);
   data.channels[index] = merged;
 
@@ -463,6 +481,155 @@ function disableAllChannels() {
   saveChannels(data);
 }
 
+function getCurrentOpenCodeProviderId(config = {}) {
+  const modelRef = String(config?.model || '').trim();
+  if (modelRef.includes('/')) {
+    return modelRef.split('/')[0].trim();
+  }
+  const providers = config?.provider && typeof config.provider === 'object'
+    ? Object.keys(config.provider).filter(Boolean)
+    : [];
+  return providers.length === 1 ? providers[0] : '';
+}
+
+function findOpenCodeExistingByProvider(channels = [], providerId = '', baseUrl = '') {
+  const normalizedProviderId = sanitizeOpenCodeProviderId(providerId);
+  const url = String(baseUrl || '').trim();
+  return channels.find(channel => {
+    const providerKeys = [
+      channel.providerKey,
+      sanitizeOpenCodeProviderId(channel.providerKey),
+      sanitizeOpenCodeProviderId(channel.name)
+    ].filter(Boolean);
+    return providerKeys.includes(providerId) || providerKeys.includes(normalizedProviderId);
+  }) || channels.find(channel => url && channel.baseUrl === url) || null;
+}
+
+function normalizeOpenCodeChannel(channel = {}) {
+  const normalized = {
+    ...channel,
+    enabled: channel.enabled !== false,
+    weight: channel.weight || 1,
+    maxConcurrency: channel.maxConcurrency || null,
+    balanceToken: channel.balanceToken || '',
+    balanceUserId: channel.balanceUserId || null,
+    modelRedirects: channel.modelRedirects || [],
+    speedTestModel: channel.speedTestModel || null,
+    wireApi: channel.wireApi || 'openai',
+    gatewaySourceType: normalizeGatewaySourceType(channel.gatewaySourceType, 'codex'),
+    allowedModels: Array.isArray(channel.allowedModels) ? channel.allowedModels : []
+  };
+  normalized.providerKey = normalized.providerKey || deriveProviderKey(normalized);
+  normalized.websiteUrl = resolveChannelWebsiteUrl('opencode', normalized);
+  return normalized;
+}
+
+function collectOpenCodeProviderModels(provider = {}) {
+  const models = provider?.models && typeof provider.models === 'object' && !Array.isArray(provider.models)
+    ? Object.keys(provider.models)
+    : [];
+  return models.map(model => String(model || '').trim()).filter(Boolean);
+}
+
+function buildOpenCodeSyncCandidate(config, channels) {
+  const providerId = getCurrentOpenCodeProviderId(config);
+  if (!providerId) {
+    return {
+      skip: true,
+      warning: 'OpenCode 原生配置未明确当前 provider，无法同步当前渠道。'
+    };
+  }
+
+  const provider = config?.provider?.[providerId] || null;
+  if (!provider || typeof provider !== 'object') {
+    return {
+      skip: true,
+      warning: `OpenCode 当前 provider "${providerId}" 未在配置中定义。`
+    };
+  }
+
+  const baseUrl = String(provider?.options?.baseURL || provider?.options?.baseUrl || provider?.baseUrl || provider?.baseURL || '').trim();
+  const rawApiKey = provider?.options?.apiKey || provider?.apiKey || provider?.key || '';
+  const existing = findOpenCodeExistingByProvider(channels, providerId, baseUrl);
+  const providerIsProxy = providerId === 'ctx-proxy'
+    || rawApiKey === 'PROXY_KEY'
+    || isLocalProxyBaseUrl(baseUrl);
+
+  if (providerIsProxy) {
+    const activeExisting = resolveExistingActiveChannel('opencode', channels)
+      || existing;
+    if (activeExisting) {
+      return {
+        skip: true,
+        channel: activeExisting,
+        warning: 'OpenCode 当前配置指向 ctx 代理；对应渠道已在列表中，未重复导入。'
+      };
+    }
+    return {
+      skip: true,
+      warning: 'OpenCode 当前配置指向 ctx 代理，但没有找到可匹配的现有渠道。'
+    };
+  }
+
+  const credential = resolveApiKeyValue(rawApiKey);
+  const apiKey = credential.value || getEffectiveApiKeyCandidates(existing || {})[0] || '';
+  if (!apiKey) {
+    return {
+      skip: true,
+      channel: existing || null,
+      warning: `OpenCode 当前 provider "${providerId}" 缺少可解析 API Key，无法同步导入。`
+    };
+  }
+
+  const modelRef = String(config?.model || '').trim();
+  const model = modelRef.startsWith(`${providerId}/`) ? modelRef.slice(providerId.length + 1) : '';
+  const allowedModels = collectOpenCodeProviderModels(provider);
+  return {
+    name: existing?.name || provider.name || providerId,
+    providerKey: providerId,
+    baseUrl,
+    apiKey,
+    wireApi: existing?.wireApi || 'openai',
+    model: model || existing?.model || allowedModels[0] || null,
+    allowedModels,
+    gatewaySourceType: existing?.gatewaySourceType || 'codex',
+    credentialSource: credential.value ? credential.source : 'existing-channel'
+  };
+}
+
+function syncCurrentOpenCodeChannel() {
+  if (typeof readConfig !== 'function' || typeof selectConfigPath !== 'function') {
+    return createSkippedResult('opencode', 'OpenCode 配置读取能力不可用，无法同步当前渠道。');
+  }
+
+  const data = loadChannels();
+  const channels = Array.isArray(data.channels) ? data.channels : [];
+  let config = {};
+  try {
+    const configPath = selectConfigPath();
+    config = readConfig(configPath);
+  } catch (error) {
+    return createSkippedResult('opencode', `OpenCode 配置读取失败：${error.message}`);
+  }
+
+  const candidate = buildOpenCodeSyncCandidate(config, channels);
+  if (candidate?.skip) {
+    return createSkippedResult('opencode', candidate.warning, candidate.channel);
+  }
+
+  return upsertSyncedChannels({
+    toolType: 'opencode',
+    loadChannels,
+    saveChannels,
+    applyDefaults: normalizeOpenCodeChannel,
+    candidates: [candidate],
+    matchers: [
+      (channel, current) => channel.providerKey && channel.providerKey === current.providerKey,
+      (channel, current) => channel.baseUrl === current.baseUrl && channel.apiKey === current.apiKey
+    ]
+  });
+}
+
 module.exports = {
   getChannels,
   createChannel,
@@ -474,5 +641,6 @@ module.exports = {
   applyChannelToSettings,
   getEffectiveApiKey,
   getEffectiveApiKeyCandidates,
-  disableAllChannels
+  disableAllChannels,
+  syncCurrentOpenCodeChannel
 };