coding-tool-x 3.7.12 → 3.8.0

package/CHANGELOG.md

@@ -4,6 +4,12 @@
 
 该项目遵循 [Semantic Versioning](https://semver.org/)。
 
+## [Unreleased]
+
+### Fixed
+- **OMP 渠道失败不再冻结** - OMP 动态切换开启后，失败渠道不再进入冻结状态。OMP 网关按请求即时回退其他渠道，冻结会导致短暂故障的渠道在恢复前被排除在后续分配之外
+- **OMP 动态切换凭据稳定** - 同步当前 OMP 渠道时不再把动态切换生成的本地网关 `base_url` 和 capability API Key 覆盖真实渠道配置；同一渠道的受管 provider 生成值现在复用持久化网关密钥保持稳定
+
 ## [3.6.7] - 2026-05-16
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coding-tool-x",
-  "version": "3.7.12",
+  "version": "3.8.0",
   "description": "Vibe Coding 增强工作助手 - 智能会话管理、动态渠道切换、全局搜索、实时监控",
   "main": "src/index.js",
   "bin": {

package/src/config/paths.js

@@ -447,6 +447,7 @@ const PATHS = {
     opencode: path.join(RUNTIME_DIR, 'opencode-proxy.json'),
     omp: path.join(RUNTIME_DIR, 'omp-proxy.json')
   },
+  ompGatewaySecret: path.join(RUNTIME_DIR, 'omp-gateway-secret'),
 
   // 请求记录
   requestSnapshots: {

package/src/server/omp-proxy-server.js

@@ -1,4 +1,3 @@
-const crypto = require('crypto');
 const { loadConfig } = require('../config/loader');
 const { saveProxyStartTime, clearProxyStartTime, getProxyStartTime, getProxyRuntime } = require('./services/proxy-runtime');
 const {
@@ -10,7 +9,8 @@ const {
   enableManagedOmpMode,
   disableManagedOmpMode,
   loadManagedOmpActiveChannelId,
-  loadManagedOmpModeState
+  loadManagedOmpModeState,
+  getOrCreateOmpGatewaySecret
 } = require('./services/omp-channels');
 const {
   startOmpSessionLogObserver,
@@ -52,7 +52,7 @@ async function startOmpProxyServerUnlocked(options = {}) {
     activeChannelId: loadManagedOmpActiveChannelId()
   };
   const channels = getEnabledChannels();
-  const secret = crypto.randomBytes(32).toString('hex');
+  const secret = getOrCreateOmpGatewaySecret();
   const desiredPort = options.port ?? config.ports?.ompProxy ?? 20092;
   const gatewayStatus = await gateway.start({
     host: '127.0.0.1',

package/src/server/services/channel-health.js

@@ -143,6 +143,11 @@ function recordFailure(channelId, source = 'claude', error) {
   health.consecutiveSuccesses = 0;
   health.lastCheckTime = now;
 
+  // omp 动态切换按请求即时回退其他渠道，失败渠道无需冻结（冻结会将其排除在后续分配之外）
+  if (source === 'omp') {
+    return;
+  }
+
   // 如果当前是健康状态或检测中状态，检查是否需要冻结
   if (health.status === 'healthy' || health.status === 'checking') {
     if (health.consecutiveFailures >= healthConfig.failureThreshold) {

package/src/server/services/channel-sync-utils.js

@@ -289,7 +289,7 @@ function upsertSyncedChannels({
       result.warnings.push(`${toolType}: missing baseUrl, skipped current channel sync`);
       continue;
     }
-    if (!normalizeString(candidate.apiKey)) {
+    if (!normalizeString(candidate.apiKey) && candidate.authMode !== 'none') {
       result.skipped += 1;
       result.warnings.push(`${toolType}: missing API key or OAuth-only config, skipped current channel sync`);
       continue;

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

@@ -1,3 +1,4 @@
+const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
 const { execFileSync } = require('child_process');
@@ -15,6 +16,7 @@ const {
 } = require('./omp-settings-manager');
 const {
   createSkippedResult,
+  isLocalProxyBaseUrl,
   resolveApiKeyValue,
   resolveExistingActiveChannel,
   upsertSyncedChannels
@@ -74,6 +76,54 @@ function writeManagedOmpModeState(filePath, state) {
   }
 }
 
+function getOmpGatewaySecretPath() {
+  return PATHS.ompGatewaySecret
+    || path.join(path.dirname(PATHS.activeChannel.omp), 'omp-gateway-secret');
+}
+
+function writeOmpGatewaySecret(filePath, secret) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  const temporaryPath = `${filePath}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  try {
+    fs.writeFileSync(temporaryPath, `${secret}\n`, { encoding: 'utf8', mode: 0o600 });
+    fs.chmodSync(temporaryPath, 0o600);
+    fs.renameSync(temporaryPath, filePath);
+  } catch (error) {
+    if (fs.existsSync(temporaryPath)) fs.unlinkSync(temporaryPath);
+    throw error;
+  }
+}
+
+function getOrCreateOmpGatewaySecret() {
+  ensureStorageDirMigrated();
+  const filePath = getOmpGatewaySecretPath();
+  const previousStateSecret = loadManagedOmpModeState()?.gateway?.secret;
+  const fileExists = fs.existsSync(filePath);
+
+  if (fileExists) {
+    try {
+      const stored = fs.readFileSync(filePath, 'utf8').trim();
+      if (stored) return stored;
+    } catch (error) {
+      if (previousStateSecret) {
+        writeOmpGatewaySecret(filePath, previousStateSecret);
+        return previousStateSecret;
+      }
+      throw new Error(`Failed to read persisted OMP gateway secret: ${error.message}`);
+    }
+    if (!previousStateSecret) {
+      throw new Error('Persisted OMP gateway secret is empty');
+    }
+    writeOmpGatewaySecret(filePath, previousStateSecret);
+    return previousStateSecret;
+  }
+
+  const secret = String(previousStateSecret || crypto.randomBytes(32).toString('hex'));
+  writeOmpGatewaySecret(filePath, secret);
+  return secret;
+}
+
 function enableManagedOmpMode(activeChannelId = null, gateway = null) {
   ensureStorageDirMigrated();
   const filePath = PATHS.activeChannel.omp;
@@ -267,6 +317,24 @@ function getOriginalOmpProviderId(providerId = '') {
   return normalized.startsWith('ctx-') ? normalized.slice(4) : normalized;
 }
 
+function isManagedOmpProviderId(providerId = '') {
+  return String(providerId || '').trim().startsWith('ctx-');
+}
+
+function isGeneratedOmpApiKey(value = '') {
+  return /^ctx_[a-f0-9]{40}$/i.test(String(value || '').trim());
+}
+
+function isGeneratedOmpBaseUrl(value = '') {
+  const raw = String(value || '').trim();
+  if (!isLocalProxyBaseUrl(raw)) return false;
+  try {
+    return /^\/omp\/[a-f0-9]{24}(?:\/|$)/i.test(new URL(raw).pathname);
+  } catch {
+    return false;
+  }
+}
+
 function normalizeOmpModelId(value = '') {
   return String(value || '').trim().replace(OMP_THINKING_SUFFIX_RE, '');
 }
@@ -355,6 +423,28 @@ function collectOmpSyncSelections(modelsConfig = {}, settings = {}) {
   return [...selections.values()];
 }
 
+function findOmpOriginalProvider(providers = {}, providerId = '') {
+  const normalizedProviderId = normalizeProviderId(getOriginalOmpProviderId(providerId));
+  const candidates = Object.entries(providers)
+    .filter(([key]) => !isManagedOmpProviderId(key))
+    .map(([id, provider]) => ({
+      id,
+      provider,
+      normalizedId: normalizeProviderId(id)
+    }));
+  const exactMatches = candidates.filter(item => item.normalizedId === normalizedProviderId);
+  if (exactMatches.length === 1) return exactMatches[0];
+  if (exactMatches.length > 1) return null;
+
+  const prefixMatches = candidates
+    .filter(item => normalizedProviderId.startsWith(`${item.normalizedId}-`))
+    .sort((left, right) => right.normalizedId.length - left.normalizedId.length);
+  if (prefixMatches.length === 0) return null;
+  const longestLength = prefixMatches[0].normalizedId.length;
+  const longestMatches = prefixMatches.filter(item => item.normalizedId.length === longestLength);
+  return longestMatches.length === 1 ? longestMatches[0] : null;
+}
+
 function findOmpExistingChannel(channels = [], providerId = '', baseUrl = '') {
   const rawProvider = String(providerId || '').trim();
   const originalProvider = getOriginalOmpProviderId(rawProvider);
@@ -444,9 +534,18 @@ function readOmpApiKeyCredential(providerId = '') {
   return { value: '', source: '', envName: '' };
 }
 
+function resolveOmpAuthMode(provider = {}, sourceProvider = {}, existing = null) {
+  const rawAuth = String(sourceProvider.auth || provider.auth || '').trim().toLowerCase();
+  if (rawAuth === 'none') return 'none';
+  if (existing?.authMode === 'none') return 'none';
+  if (existing?.authMode === 'oauth') return 'oauth';
+  return 'api_key';
+}
+
 function buildOmpSyncCandidate(modelsConfig, selection, channels) {
+  const providers = getOmpProviders(modelsConfig);
   const providerId = selection?.providerId || '';
-  const provider = modelsConfig?.providers?.[providerId] || null;
+  const provider = providers[providerId] || null;
   if (!provider || typeof provider !== 'object') {
     return {
       skip: true,
@@ -454,14 +553,42 @@ function buildOmpSyncCandidate(modelsConfig, selection, channels) {
     };
   }
 
-  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 || '');
+  const managedProvider = isManagedOmpProviderId(providerId);
+  const originalProviderEntry = managedProvider
+    ? findOmpOriginalProvider(providers, providerId)
+    : null;
+  const sourceProvider = originalProviderEntry?.provider || (managedProvider ? {} : provider);
+  const originalProviderId = originalProviderEntry?.id || getOriginalOmpProviderId(providerId);
+  const providerBaseUrl = String(sourceProvider.baseUrl || sourceProvider.base_url || '').trim();
+  const managedBaseUrl = String(provider.baseUrl || provider.base_url || '').trim();
+  const existing = findOmpExistingChannel(
+    channels,
+    originalProviderId || providerId,
+    managedProvider ? '' : managedBaseUrl
+  );
+  const baseUrl = managedProvider && (
+    !providerBaseUrl || isGeneratedOmpBaseUrl(providerBaseUrl)
+  )
+    ? existing?.baseUrl || ''
+    : providerBaseUrl || existing?.baseUrl || managedBaseUrl;
+  const authMode = resolveOmpAuthMode(provider, sourceProvider, existing);
+
+  let credential = resolveApiKeyValue(sourceProvider.apiKey || sourceProvider.api_key || '');
   if (!credential.value) {
-    credential = readOmpApiKeyCredential(providerId);
+    credential = readOmpApiKeyCredential(originalProviderId || providerId);
+  }
+  const existingCredential = resolveApiKeyValue(existing?.apiKey || '');
+  const apiKey = credential.value && !isGeneratedOmpApiKey(credential.value)
+    ? credential.value
+    : existingCredential.value && !isGeneratedOmpApiKey(existingCredential.value)
+      ? existingCredential.value
+      : '';
+  if (!credential.value || isGeneratedOmpApiKey(credential.value)) {
+    credential = existingCredential.value && !isGeneratedOmpApiKey(existingCredential.value)
+      ? { ...existingCredential, source: 'existing-channel' }
+      : credential;
   }
-  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;
@@ -470,11 +597,11 @@ function buildOmpSyncCandidate(modelsConfig, selection, channels) {
     || existing?.model
     || allowedModels[0]
     || null;
-  if (!apiKey) {
+  if (!baseUrl || (authMode !== 'none' && !apiKey)) {
     return {
       skip: true,
       channel: existing || null,
-      warning: `OMP 当前 provider "${providerId}" 缺少可解析 API Key，OAuth/登录态渠道不支持同步导入。`
+      warning: `OMP 当前 provider "${providerId}" 缺少可解析的上游 Base URL 或 API Key，OAuth/登录态渠道不支持同步导入。`
     };
   }
 
@@ -482,11 +609,11 @@ function buildOmpSyncCandidate(modelsConfig, selection, channels) {
     name: existing?.name || originalProviderId || providerId,
     providerKey: originalProviderId || providerId,
     baseUrl,
-    apiKey,
-    providerApi: normalizeProviderApi(provider.api),
-    wireApi: provider.api || 'openai-completions',
-    authMode: 'api_key',
-    oauthProviderId: '',
+    apiKey: authMode === 'none' ? '' : apiKey,
+    providerApi: normalizeProviderApi(sourceProvider.api || provider.api),
+    wireApi: sourceProvider.api || provider.api || 'openai-completions',
+    authMode,
+    oauthProviderId: authMode === 'oauth' ? (existing?.oauthProviderId || originalProviderId || providerId) : '',
     model: preferredModel,
     allowedModels,
     models: filterOmpProviderModels(provider.models, allowedModels),
@@ -552,6 +679,7 @@ module.exports = {
   syncManagedProviderExtension: (channels) => service.syncManagedProviderExtension(channels),
   disableManagedProviderExtension: () => service.disableManagedProviderExtension(),
   isManagedOmpModeEnabled,
+  getOrCreateOmpGatewaySecret,
   enableManagedOmpMode,
   disableManagedOmpMode,
   loadManagedOmpModeState,