coding-tool-x 3.7.2 → 3.7.4

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

@@ -6,6 +6,11 @@ const path = require('path');
 const { URL } = require('url');
 const { PATHS } = require('../../config/paths');
 const { loadUIConfig } = require('./ui-config');
+const {
+  getSnapshot,
+  refreshSnapshot,
+  invalidateSnapshot
+} = require('./snapshot-cache');
 
 const CACHE_TTL_MS = 5 * 60 * 1000;
 const REQUEST_TIMEOUT_MS = 8000;
@@ -1489,6 +1494,14 @@ function buildCacheKey(source, channel) {
   ].join(':');
 }
 
+function buildBalanceSnapshotKey(source, channel) {
+  return `channel-balances:${buildCacheKey(source, channel)}`;
+}
+
+function makeFallbackBalanceSnapshot(currentTime = Date.now()) {
+  return makeHiddenSnapshot(null, { stale: true, updatedAt: nowIso(currentTime) });
+}
+
 async function refreshChannelBalanceSnapshot(source, channel, options = {}) {
   const force = options.force === true;
   const currentTime = options.now || Date.now();
@@ -1588,6 +1601,7 @@ function clearChannelBalanceCache(source, channel) {
   let strategyChanged = false;
 
   balanceCache.delete(exactKey);
+  invalidateSnapshot(`channel-balances:${exactKey}`);
   for (const key of Array.from(balanceCache.keys())) {
     if (key.startsWith(prefix)) {
       balanceCache.delete(key);
@@ -1665,19 +1679,45 @@ async function mapWithConcurrency(items, limit, worker) {
 async function getChannelBalances(source, options = {}) {
   const normalizedSource = validateSource(source);
   if (!isBalanceDisplayEnabled()) {
-    return { enabled: false, source: normalizedSource, balances: {} };
+    return {
+      enabled: false,
+      source: normalizedSource,
+      balances: {},
+      refreshing: false,
+      updatedAt: null,
+      stale: false
+    };
   }
 
   const channels = getEnabledBalanceChannels(normalizedSource);
+  const currentTime = options.now || Date.now();
   const entries = await mapWithConcurrency(channels, 4, async (channel) => {
-    const snapshot = await refreshChannelBalanceSnapshot(normalizedSource, channel, options);
-    return [channel.id, snapshot];
+    const snapshot = await getSnapshot(buildBalanceSnapshotKey(normalizedSource, channel), {
+      ttlMs: CACHE_TTL_MS,
+      fallbackValue: makeFallbackBalanceSnapshot(currentTime),
+      refresh: () => refreshChannelBalanceSnapshot(normalizedSource, channel, { ...options, force: true, now: Date.now() })
+    });
+    const value = {
+      ...snapshot.value,
+      stale: Boolean(snapshot.value?.stale || snapshot.meta.stale)
+    };
+    return [channel.id, value, snapshot.meta];
   });
 
+  const metas = entries.map((entry) => entry[2]).filter(Boolean);
+  const updatedAt = metas
+    .map(meta => meta.generatedAt)
+    .filter(Boolean)
+    .sort()
+    .pop() || null;
+
   return {
     enabled: true,
     source: normalizedSource,
-    balances: Object.fromEntries(entries.filter(([id]) => id))
+    balances: Object.fromEntries(entries.filter(([id]) => id).map(([id, snapshot]) => [id, snapshot])),
+    refreshing: metas.some(meta => meta.refreshing),
+    updatedAt,
+    stale: metas.some(meta => meta.stale)
   };
 }
 
@@ -1695,7 +1735,11 @@ async function refreshChannelBalance(source, channelId) {
     throw error;
   }
 
-  const balance = await refreshChannelBalanceSnapshot(normalizedSource, channel, { force: true });
+  const entry = await refreshSnapshot(
+    buildBalanceSnapshotKey(normalizedSource, channel),
+    () => refreshChannelBalanceSnapshot(normalizedSource, channel, { force: true })
+  );
+  const balance = entry.value;
   return {
     enabled: true,
     source: normalizedSource,
@@ -1707,6 +1751,7 @@ async function refreshChannelBalance(source, channelId) {
 function clearBalanceCache() {
   balanceCache.clear();
   balanceStrategyCache.clear();
+  invalidateSnapshot('channel-balances:');
   strategyCacheLoaded = false;
 }
 
@@ -1739,6 +1784,7 @@ module.exports = {
     build88CodeSubscriptionSnapshot,
     buildNewCliDashboardSnapshot,
     buildBalanceProbeStrategies,
+    buildBalanceSnapshotKey,
     getEnabledBalanceChannels,
     runBalanceStrategy,
     refreshChannelBalanceSnapshot,

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

@@ -0,0 +1,368 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { PATHS, ensureStorageDirMigrated } = require('../../config/paths');
+
+function normalizeString(value) {
+  return String(value || '').trim();
+}
+
+function normalizeLower(value) {
+  return normalizeString(value).toLowerCase();
+}
+
+function normalizeUrl(value) {
+  const raw = normalizeString(value);
+  if (!raw) return '';
+  return raw.replace(/\/+$/, '').toLowerCase();
+}
+
+function isLocalProxyBaseUrl(value) {
+  const raw = normalizeString(value);
+  if (!raw) return false;
+  try {
+    const parsed = new URL(raw);
+    const host = normalizeLower(parsed.hostname).replace(/^\[|\]$/g, '');
+    return host === 'localhost' || host === '127.0.0.1' || host === '::1';
+  } catch {
+    return raw.includes('127.0.0.1') || raw.includes('localhost');
+  }
+}
+
+function isProxyCredential(value) {
+  const raw = normalizeString(value);
+  return raw === 'PROXY_KEY' || raw === 'CC_PROXY_KEY';
+}
+
+function parseEnvReference(value) {
+  const raw = normalizeString(value);
+  if (!raw) return '';
+  let match = raw.match(/^\$\{?([A-Z_][A-Z0-9_]*)\}?$/);
+  if (match) return match[1];
+  match = raw.match(/^env:([A-Z_][A-Z0-9_]*)$/i);
+  if (match) return match[1].toUpperCase();
+  match = raw.match(/^process\.env\.([A-Z_][A-Z0-9_]*)$/);
+  if (match) return match[1];
+  if (/^[A-Z_][A-Z0-9_]*$/.test(raw) && /(?:API|KEY|TOKEN|SECRET|AUTH)/.test(raw)) {
+    return raw;
+  }
+  return '';
+}
+
+function resolveApiKeyValue(value, env = process.env) {
+  const raw = normalizeString(value);
+  if (!raw || isProxyCredential(raw)) {
+    return { value: '', source: '', envName: '' };
+  }
+
+  const envName = parseEnvReference(raw);
+  if (envName) {
+    const envValue = normalizeString(env?.[envName]);
+    if (isProxyCredential(envValue)) {
+      return { value: '', source: 'proxy-env', envName };
+    }
+    return {
+      value: envValue,
+      source: envValue ? 'env' : 'env-missing',
+      envName
+    };
+  }
+
+  return { value: raw, source: 'config', envName: '' };
+}
+
+function readActiveChannelId(platform) {
+  try {
+    ensureStorageDirMigrated?.();
+    const filePath = PATHS.activeChannel?.[platform];
+    if (!filePath || !fs.existsSync(filePath)) return null;
+    const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    return data?.activeChannelId || null;
+  } catch {
+    return null;
+  }
+}
+
+function selectLatestEnabledChannel(channels = []) {
+  const enabledChannels = (Array.isArray(channels) ? channels : [])
+    .filter(channel => channel && channel.enabled !== false);
+  if (enabledChannels.length === 0) return null;
+  return enabledChannels.reduce((latest, current) => {
+    const latestTs = Number(latest?.updatedAt || latest?.createdAt || 0);
+    const currentTs = Number(current?.updatedAt || current?.createdAt || 0);
+    return currentTs > latestTs ? current : latest;
+  }, enabledChannels[0]);
+}
+
+function resolveExistingActiveChannel(platform, channels = []) {
+  const allChannels = Array.isArray(channels) ? channels : [];
+  const activeChannelId = readActiveChannelId(platform);
+  if (activeChannelId) {
+    const matched = allChannels.find(channel => channel.id === activeChannelId);
+    if (matched) return matched;
+  }
+  return selectLatestEnabledChannel(allChannels)
+    || allChannels.find(channel => channel.enabled !== false)
+    || allChannels[0]
+    || null;
+}
+
+function secretHash(value) {
+  const raw = normalizeString(value);
+  if (!raw) return '';
+  return crypto.createHash('sha256').update(raw).digest('hex');
+}
+
+function channelIdentity(channel = {}) {
+  return {
+    id: normalizeString(channel.id),
+    providerKey: normalizeLower(channel.providerKey || channel.provider),
+    baseUrl: normalizeUrl(channel.baseUrl),
+    apiKeyHash: secretHash(channel.apiKey || channel.key),
+    model: normalizeLower(channel.model),
+    name: normalizeLower(channel.name)
+  };
+}
+
+function defaultFindExistingChannel(channels = [], candidate = {}, options = {}) {
+  const target = channelIdentity(candidate);
+  const candidateId = normalizeString(candidate.id);
+  if (candidateId) {
+    const byId = channels.find(channel => channel.id === candidateId);
+    if (byId) return byId;
+  }
+
+  const matchers = Array.isArray(options.matchers) ? options.matchers : [];
+  for (const matcher of matchers) {
+    const matched = channels.find(channel => matcher(channel, candidate));
+    if (matched) return matched;
+  }
+
+  if (target.providerKey) {
+    const byProvider = channels.find(channel => channelIdentity(channel).providerKey === target.providerKey);
+    if (byProvider) return byProvider;
+  }
+
+  if (target.baseUrl && target.apiKeyHash) {
+    const byUrlAndKey = channels.find((channel) => {
+      const identity = channelIdentity(channel);
+      return identity.baseUrl === target.baseUrl && identity.apiKeyHash === target.apiKeyHash;
+    });
+    if (byUrlAndKey) return byUrlAndKey;
+  }
+
+  if (target.baseUrl && target.model) {
+    const byUrlAndModel = channels.find((channel) => {
+      const identity = channelIdentity(channel);
+      return identity.baseUrl === target.baseUrl && identity.model === target.model;
+    });
+    if (byUrlAndModel) return byUrlAndModel;
+  }
+
+  if (target.baseUrl) {
+    return channels.find(channel => channelIdentity(channel).baseUrl === target.baseUrl) || null;
+  }
+
+  return null;
+}
+
+function shouldPreserveField(field, existing, candidate) {
+  if (field === 'name') {
+    return normalizeString(existing?.name) && normalizeLower(existing.name) !== 'default';
+  }
+  return Object.prototype.hasOwnProperty.call(existing || {}, field)
+    && !Object.prototype.hasOwnProperty.call(candidate || {}, field);
+}
+
+function mergeSyncedChannel(existing, candidate, options = {}) {
+  const preserveFields = options.preserveFields || [
+    'id',
+    'createdAt',
+    'name',
+    'enabled',
+    'weight',
+    'maxConcurrency',
+    'balanceToken',
+    'balanceUserId'
+  ];
+
+  const merged = {
+    ...existing,
+    ...candidate,
+    id: existing.id,
+    createdAt: existing.createdAt || candidate.createdAt || Date.now(),
+    updatedAt: Date.now()
+  };
+
+  for (const field of preserveFields) {
+    if (shouldPreserveField(field, existing, candidate)) {
+      merged[field] = existing[field];
+    }
+  }
+
+  return merged;
+}
+
+function stableComparableValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(stableComparableValue);
+  }
+  if (!value || typeof value !== 'object') {
+    return value;
+  }
+  return Object.keys(value)
+    .sort()
+    .reduce((acc, key) => {
+      acc[key] = stableComparableValue(value[key]);
+      return acc;
+    }, {});
+}
+
+function comparableChannel(channel = {}) {
+  const copy = { ...channel };
+  delete copy.updatedAt;
+  delete copy.health;
+  delete copy.websiteUrl;
+  return JSON.stringify(stableComparableValue(copy));
+}
+
+function sanitizeChannel(channel) {
+  if (!channel) return null;
+  const sanitized = {
+    id: channel.id,
+    name: channel.name,
+    baseUrl: channel.baseUrl,
+    enabled: channel.enabled !== false
+  };
+  if (channel.providerKey) sanitized.providerKey = channel.providerKey;
+  if (channel.model) sanitized.model = channel.model;
+  if (channel.credentialSource) sanitized.credentialSource = channel.credentialSource;
+  return sanitized;
+}
+
+function createSkippedResult(toolType, warning, channel = null) {
+  return {
+    success: true,
+    toolType,
+    added: 0,
+    updated: 0,
+    skipped: 1,
+    channels: channel ? [sanitizeChannel(channel)] : [],
+    warnings: warning ? [warning] : []
+  };
+}
+
+function upsertSyncedChannels({
+  toolType,
+  loadChannels,
+  saveChannels,
+  applyDefaults,
+  candidates,
+  matchers,
+  preserveFields
+}) {
+  const data = loadChannels();
+  const channels = Array.isArray(data?.channels) ? [...data.channels] : [];
+  const result = {
+    success: true,
+    toolType,
+    added: 0,
+    updated: 0,
+    skipped: 0,
+    channels: [],
+    warnings: []
+  };
+
+  let changed = false;
+  for (const rawCandidate of candidates || []) {
+    const candidate = rawCandidate || {};
+    if (candidate.warning) {
+      result.warnings.push(candidate.warning);
+    }
+    if (candidate.skip) {
+      result.skipped += 1;
+      if (candidate.channel) result.channels.push(sanitizeChannel(candidate.channel));
+      continue;
+    }
+    if (!normalizeString(candidate.baseUrl)) {
+      result.skipped += 1;
+      result.warnings.push(`${toolType}: missing baseUrl, skipped current channel sync`);
+      continue;
+    }
+    if (!normalizeString(candidate.apiKey)) {
+      result.skipped += 1;
+      result.warnings.push(`${toolType}: missing API key or OAuth-only config, skipped current channel sync`);
+      continue;
+    }
+
+    const normalizedCandidate = applyDefaults ? applyDefaults(candidate) : candidate;
+    const existing = defaultFindExistingChannel(channels, normalizedCandidate, { matchers });
+    if (existing) {
+      const merged = applyDefaults
+        ? applyDefaults(mergeSyncedChannel(existing, normalizedCandidate, { preserveFields }))
+        : mergeSyncedChannel(existing, normalizedCandidate, { preserveFields });
+      if (comparableChannel(existing) === comparableChannel(merged)) {
+        result.skipped += 1;
+        result.channels.push(sanitizeChannel(existing));
+        continue;
+      }
+      const index = channels.findIndex(channel => channel.id === existing.id);
+      channels[index] = merged;
+      changed = true;
+      result.updated += 1;
+      result.channels.push(sanitizeChannel(merged));
+      continue;
+    }
+
+    const now = Date.now();
+    const created = applyDefaults ? applyDefaults({
+      id: candidate.id || crypto.randomUUID(),
+      enabled: candidate.enabled !== false,
+      weight: candidate.weight || 1,
+      maxConcurrency: candidate.maxConcurrency || null,
+      ...normalizedCandidate,
+      createdAt: now,
+      updatedAt: now
+    }) : {
+      id: candidate.id || crypto.randomUUID(),
+      enabled: candidate.enabled !== false,
+      weight: candidate.weight || 1,
+      maxConcurrency: candidate.maxConcurrency || null,
+      ...normalizedCandidate,
+      createdAt: now,
+      updatedAt: now
+    };
+    channels.push(created);
+    changed = true;
+    result.added += 1;
+    result.channels.push(sanitizeChannel(created));
+  }
+
+  if (changed) {
+    const dir = path.dirname(loadChannels.filePath || '');
+    if (dir && dir !== '.' && !fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    saveChannels({ ...data, channels });
+  }
+
+  result.warnings = [...new Set(result.warnings.filter(Boolean))];
+  return result;
+}
+
+module.exports = {
+  createSkippedResult,
+  defaultFindExistingChannel,
+  isLocalProxyBaseUrl,
+  isProxyCredential,
+  normalizeLower,
+  normalizeString,
+  normalizeUrl,
+  readActiveChannelId,
+  resolveApiKeyValue,
+  resolveExistingActiveChannel,
+  sanitizeChannel,
+  secretHash,
+  selectLatestEnabledChannel,
+  upsertSyncedChannels
+};

package/src/server/services/channels.js

@@ -6,6 +6,12 @@ const { PATHS, NATIVE_PATHS } = require('../../config/paths');
 const { clearNativeOAuth } = require('./native-oauth-adapters');
 const { isWindowsLikePlatform } = require('../../utils/home-dir');
 const { normalizeGatewaySourceType } = require('./base/proxy-utils');
+const {
+  createSkippedResult,
+  isLocalProxyBaseUrl,
+  resolveExistingActiveChannel,
+  upsertSyncedChannels
+} = require('./channel-sync-utils');
 
 // ── Claude 特有工具函数 ──
 
@@ -338,6 +344,118 @@ function getCurrentSettings() {
   };
 }
 
+function readClaudeNativeSettings() {
+  const settingsPath = getClaudeSettingsPath();
+  if (!fs.existsSync(settingsPath)) {
+    return {};
+  }
+  try {
+    return JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+  } catch (error) {
+    throw new Error(`Failed to read Claude settings.json: ${error.message}`);
+  }
+}
+
+function readClaudeNativeOAuth() {
+  try {
+    const adapters = require('./native-oauth-adapters');
+    return typeof adapters.readNativeOAuth === 'function'
+      ? adapters.readNativeOAuth('claude')
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+function buildClaudeSyncCandidate(settings, channels) {
+  const env = settings?.env && typeof settings.env === 'object' ? settings.env : {};
+  const baseUrl = String(env.ANTHROPIC_BASE_URL || '').trim();
+
+  if (isLocalProxyBaseUrl(baseUrl)) {
+    const existing = resolveExistingActiveChannel('claude', channels);
+    if (existing) {
+      return {
+        skip: true,
+        channel: existing,
+        warning: 'Claude 当前配置指向 ctx 代理；对应渠道已在列表中，未重复导入。'
+      };
+    }
+    return {
+      skip: true,
+      warning: 'Claude 当前配置指向 ctx 代理，但没有找到可匹配的现有渠道。请先确认 ctx 渠道列表。'
+    };
+  }
+
+  const helperKey = extractApiKeyFromHelper(settings?.apiKeyHelper);
+  const apiKey = String(env.ANTHROPIC_API_KEY || env.ANTHROPIC_AUTH_TOKEN || helperKey || '').trim();
+  const hasOAuth = Boolean(env.CLAUDE_CODE_OAUTH_TOKEN || readClaudeNativeOAuth());
+  const existingByBaseUrl = baseUrl
+    ? channels.find(ch => String(ch.baseUrl || '').trim() === baseUrl)
+    : null;
+
+  if (!apiKey) {
+    if (existingByBaseUrl) {
+      return {
+        skip: true,
+        channel: existingByBaseUrl,
+        warning: 'Claude 当前配置未暴露 API Key；已找到同 baseUrl 渠道，未重复导入。'
+      };
+    }
+    return {
+      skip: true,
+      warning: hasOAuth
+        ? 'Claude 当前配置是 OAuth/登录态，OAuth 渠道不支持同步导入。'
+        : 'Claude 当前配置缺少 API Key，无法同步导入。'
+    };
+  }
+
+  const modelConfig = {
+    model: env.ANTHROPIC_MODEL || '',
+    haikuModel: env.ANTHROPIC_DEFAULT_HAIKU_MODEL || '',
+    sonnetModel: env.ANTHROPIC_DEFAULT_SONNET_MODEL || '',
+    opusModel: env.ANTHROPIC_DEFAULT_OPUS_MODEL || ''
+  };
+  Object.keys(modelConfig).forEach((key) => {
+    if (!modelConfig[key]) delete modelConfig[key];
+  });
+
+  const finalBaseUrl = baseUrl || 'https://api.anthropic.com';
+  return {
+    name: existingByBaseUrl?.name || 'Claude 当前配置',
+    baseUrl: finalBaseUrl,
+    apiKey,
+    presetId: finalBaseUrl.includes('api.anthropic.com') ? 'official' : 'custom',
+    modelConfig,
+    proxyUrl: env.HTTPS_PROXY || env.HTTP_PROXY || '',
+    targetApi: 'responses',
+    gatewaySourceType: 'claude',
+    credentialSource: env.ANTHROPIC_API_KEY || env.ANTHROPIC_AUTH_TOKEN ? 'config' : 'apiKeyHelper'
+  };
+}
+
+function syncCurrentClaudeChannel() {
+  const data = service.loadChannels();
+  const channels = Array.isArray(data.channels) ? data.channels : [];
+  const settings = readClaudeNativeSettings();
+  const candidate = buildClaudeSyncCandidate(settings, channels);
+
+  if (candidate?.skip) {
+    return createSkippedResult('claude', candidate.warning, candidate.channel);
+  }
+
+  return upsertSyncedChannels({
+    toolType: 'claude',
+    loadChannels: () => service.loadChannels(),
+    saveChannels: payload => service.saveChannels(payload),
+    applyDefaults: channel => service._applyDefaults(channel),
+    candidates: [candidate],
+    matchers: [
+      (channel, current) => channel.baseUrl === current.baseUrl && channel.apiKey === current.apiKey,
+      (channel, current) => channel.baseUrl === current.baseUrl && channel.targetApi === current.targetApi
+    ]
+  });
+}
+
 function getBestChannelForRestore() {
   const channels = getAllChannels();
   const enabled = channels.filter(ch => ch.enabled !== false);
@@ -394,4 +512,5 @@ module.exports = {
   getEffectiveApiKey,
   disableAllChannels,
   extractApiKeyFromHelper,
+  syncCurrentClaudeChannel,
 };