coding-tool-x 3.8.4 → 3.8.6

package/src/{server/services/gemini-channels.js → platforms/drivers/gemini/channels-implementation.js}

@@ -1,28 +1,112 @@
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
-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 { PATHS, NATIVE_PATHS } = require('../../../config/paths');
+const { resolveChannelWebsiteUrl } = require('../../../config/channel-preset-websites');
+const { clearNativeOAuth, readNativeOAuth, clearGeminiChannelConfig } = require('../../native-oauth-adapters');
+const { normalizeGatewaySourceType } = require('../../../shared/proxy-utils');
 const {
   createSkippedResult,
   isLocalProxyBaseUrl,
   resolveApiKeyValue,
   resolveExistingActiveChannel,
   upsertSyncedChannels
-} = require('./channel-sync-utils');
+} = require('../../../server/services/channel-sync-utils');
+
+let configuredNative = NATIVE_PATHS.gemini;
+let configuredState = { channels: PATHS.channels?.gemini };
+
+function configure({ pathContext } = {}) {
+  const custom = pathContext?.customized === true;
+  configuredNative = custom && pathContext.native?.env
+    ? { ...NATIVE_PATHS.gemini, ...pathContext.native }
+    : NATIVE_PATHS.gemini;
+  configuredState = {
+    channels: custom ? (pathContext.state?.channels || PATHS.channels?.gemini) : PATHS.channels?.gemini
+  };
+  require('../../native-oauth-adapters').configure?.({ pathContext });
+}
 
 const GEMINI_API_FORMATS = new Set(['gemini_api', 'vertex_ai_v1']);
 
 function clearChannelBalanceCache(channel) {
   try {
-    require('./channel-balance').clearChannelBalanceCache('gemini', channel);
+    require('../../../server/services/channel-balance').clearChannelBalanceCache('gemini', channel);
   } catch (_) {
     // Balance cache invalidation is best-effort and should not block channel updates.
   }
 }
 
+function createGeminiOAuthError(message, code, statusCode) {
+  const error = new Error(message);
+  error.code = code;
+  error.statusCode = statusCode;
+  return error;
+}
+
+function getGeminiProxyState() {
+  return require('./proxy-implementation').getGeminiProxyStatus();
+}
+
+function assertGeminiOAuthIsNativeOnly() {
+  if (getGeminiProxyState().running) {
+    throw createGeminiOAuthError(
+      'Gemini OAuth channels are native-only',
+      'gemini_oauth_proxy_unsupported',
+      409
+    );
+  }
+}
+
+function assertNativeGeminiOAuthAvailable() {
+  if (!readNativeOAuth('gemini')) {
+    throw createGeminiOAuthError(
+      'Gemini native OAuth credential is unavailable',
+      'gemini_oauth_credential_unavailable',
+      422
+    );
+  }
+}
+
+function validateGeminiOAuthMutation(channel, operation) {
+  if (channel?.authMode !== 'oauth') {
+    return;
+  }
+  if (operation !== 'apply' && channel.enabled === false) {
+    return;
+  }
+  assertGeminiOAuthIsNativeOnly();
+  assertNativeGeminiOAuthAvailable();
+}
+
+function applyNativeGeminiOAuth(channel) {
+  validateGeminiOAuthMutation(channel, 'apply');
+  clearGeminiChannelConfig();
+
+  const settingsPath = configuredNative.settings;
+  const settings = readGeminiSettings();
+  settings.security = settings.security || {};
+  settings.security.auth = settings.security.auth || {};
+  settings.security.auth.selectedType = 'oauth-personal';
+  fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
+  console.log(`[Gemini Channels] Applied native OAuth channel ${channel.name}`);
+  return channel;
+}
+
+function assertGeminiEnabledChannelsAreValid(channels = []) {
+  const enabledChannels = channels.filter(channel => channel?.enabled !== false);
+  const oauthChannels = enabledChannels.filter(channel => channel?.authMode === 'oauth');
+  if (oauthChannels.length && enabledChannels.some(channel => channel?.authMode !== 'oauth')) {
+    throw createGeminiOAuthError(
+      'Gemini OAuth channels cannot be mixed with API-key channels',
+      'gemini_oauth_mixed_channels',
+      409
+    );
+  }
+}
+
+
 function normalizeGeminiApiFormat(value) {
   const normalized = String(value || '').trim().toLowerCase();
   return GEMINI_API_FORMATS.has(normalized) ? normalized : 'gemini_api';
@@ -45,16 +129,16 @@ function normalizeGeminiApiFormat(value) {
 
 // 获取 Gemini 配置目录
 function getGeminiDir() {
-  return path.dirname(NATIVE_PATHS.gemini.env);
+  return configuredNative.dir || path.dirname(configuredNative.env);
 }
 
 // 获取渠道存储文件路径
 function getChannelsFilePath() {
-  const channelsDir = path.dirname(PATHS.channels.gemini);
+  const channelsDir = path.dirname(configuredState.channels);
   if (!fs.existsSync(channelsDir)) {
     fs.mkdirSync(channelsDir, { recursive: true });
   }
-  return PATHS.channels.gemini;
+  return configuredState.channels;
 }
 
 function readExistingGeminiEnv() {
@@ -216,10 +300,17 @@ function initializeFromEnv() {
   }
 }
 
+function invalidateDashboardSource() {
+  try {
+    require('../../../server/services/snapshot-cache').invalidateDashboardSourceSnapshot('gemini');
+  } catch (_) {}
+}
+
 // 保存渠道数据
 function saveChannels(data) {
   const filePath = getChannelsFilePath();
   fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf8');
+  invalidateDashboardSource();
 }
 
 // 获取所有渠道
@@ -230,24 +321,61 @@ function getChannels() {
   };
 }
 
+function normalizeAuthConfig(extraConfig = {}, existing = null) {
+  const unsafeField = Object.keys(extraConfig).find(key => /token|secret|password|refresh|access/i.test(key));
+  if (unsafeField) {
+    const error = new Error('Invalid OAuth auth payload');
+    error.statusCode = 400;
+    error.code = 'invalid_auth_payload';
+    throw error;
+  }
+  const mode = extraConfig.authMode || existing?.authMode || 'api_key';
+  if (!['api_key', 'oauth', 'none'].includes(mode)) {
+    const error = new Error('Invalid auth mode');
+    error.statusCode = 400;
+    error.code = 'invalid_auth_payload';
+    throw error;
+  }
+  if (existing && extraConfig.authMode && extraConfig.authMode !== (existing.authMode || 'api_key')) {
+    const error = new Error('Channel authMode is immutable');
+    error.statusCode = 409;
+    error.code = 'auth_mode_immutable';
+    throw error;
+  }
+  if (mode === 'oauth') {
+    const allowed = ['credentialId', 'providerId', 'accountId', 'identityKey', 'accountEmail'];
+    const ref = extraConfig.authRef || existing?.authRef;
+    if (!ref || Object.keys(ref).some(key => !allowed.includes(key)) || !ref.credentialId) {
+      const error = new Error('OAuth reference unavailable');
+      error.statusCode = 422;
+      error.code = 'oauth_reference_unavailable';
+      throw error;
+    }
+    return { authMode: mode, authRef: Object.fromEntries(allowed.map(key => [key, String(ref[key] || '')])), authSource: 'synced-local', authStatus: existing?.authStatus || 'available' };
+  }
+  return { authMode: mode };
+}
+
 // 添加渠道
 function createChannel(name, baseUrl, apiKey, model = 'gemini-2.5-pro', extraConfig = {}) {
   const data = loadChannels();
-
-  // 检查名称是否已存在
+  const auth = normalizeAuthConfig(extraConfig);
   const existing = data.channels.find(c => c.name === name);
-  if (existing) {
-    throw new Error(`Channel name "${name}" already exists`);
+  if (existing) throw new Error(`Channel name "${name}" already exists`);
+  if (auth.authMode !== 'oauth' && auth.authMode !== 'none' && (!baseUrl || !apiKey)) {
+    const error = new Error('Base URL and API key are required');
+    error.statusCode = 400;
+    throw error;
   }
-
   const newChannel = {
     id: crypto.randomUUID(),
     name,
-    baseUrl,
-    apiKey,
+    baseUrl: auth.authMode === 'oauth' ? '' : baseUrl,
+    apiKey: auth.authMode === 'oauth' || auth.authMode === 'none' ? '' : apiKey,
     model,
+    ...auth,
     websiteUrl: extraConfig.websiteUrl || '',
-    enabled: extraConfig.enabled !== false, // 默认启用
+    enabled: extraConfig.enabled !== false,
     weight: extraConfig.weight || 1,
     maxConcurrency: extraConfig.maxConcurrency || null,
     balanceToken: extraConfig.balanceToken || '',
@@ -260,17 +388,12 @@ function createChannel(name, baseUrl, apiKey, model = 'gemini-2.5-pro', extraCon
     updatedAt: Date.now()
   };
   newChannel.websiteUrl = resolveChannelWebsiteUrl('gemini', newChannel);
-
+  validateGeminiOAuthMutation(newChannel, 'create');
+  assertGeminiEnabledChannelsAreValid([...data.channels, newChannel]);
   data.channels.push(newChannel);
   saveChannels(data);
-
-  // 仅在非动态切换模式下写入 Gemini 配置文件
-  const { getGeminiProxyStatus } = require('../gemini-proxy-server');
-  const proxyStatus = getGeminiProxyStatus();
-  if (!proxyStatus.running) {
-    writeGeminiConfigForMultiChannel(data.channels);
-  }
-
+  const { getGeminiProxyStatus } = require('./proxy-implementation');
+  if (!getGeminiProxyStatus().running) writeGeminiConfigForMultiChannel(data.channels);
   return newChannel;
 }
 
@@ -284,6 +407,18 @@ function updateChannel(channelId, updates) {
   }
 
   const oldChannel = data.channels[index];
+  const auth = normalizeAuthConfig(updates, oldChannel);
+  if (auth.authMode === 'oauth' && updates.enabled !== false) {
+    const conflict = data.channels.find(channel => channel.id !== channelId && channel.authMode === 'oauth' && channel.enabled !== false);
+    if (conflict) {
+      const error = new Error(`OAuth channel conflicts with ${conflict.name || conflict.id}`);
+      error.statusCode = 409;
+      error.code = 'oauth_channel_conflict';
+      error.conflictingChannelId = conflict.id;
+      error.conflictingChannelName = conflict.name || conflict.id;
+      throw error;
+    }
+  }
 
   // 检查名称冲突
   if (updates.name && updates.name !== oldChannel.name) {
@@ -293,11 +428,13 @@ function updateChannel(channelId, updates) {
     }
   }
 
-  const merged = { ...oldChannel, ...updates };
+  const merged = { ...oldChannel, ...updates, ...auth };
   const nextChannel = {
     ...merged,
-    id: channelId, // 保持 ID 不变
-    createdAt: oldChannel.createdAt, // 保持创建时间
+    id: channelId,
+    createdAt: oldChannel.createdAt,
+    baseUrl: auth.authMode === 'oauth' ? '' : (merged.baseUrl || ''),
+    apiKey: auth.authMode === 'oauth' || auth.authMode === 'none' ? '' : merged.apiKey,
     modelRedirects: updates.modelRedirects !== undefined ? updates.modelRedirects : (oldChannel.modelRedirects || []),
     speedTestModel: updates.speedTestModel !== undefined ? updates.speedTestModel : (oldChannel.speedTestModel || null),
     apiFormat: updates.apiFormat !== undefined ? normalizeGeminiApiFormat(updates.apiFormat) : normalizeGeminiApiFormat(oldChannel.apiFormat),
@@ -306,11 +443,13 @@ function updateChannel(channelId, updates) {
     gatewaySourceType: normalizeGatewaySourceType(merged.gatewaySourceType, 'gemini'),
     updatedAt: Date.now()
   };
-  nextChannel.websiteUrl = resolveChannelWebsiteUrl('gemini', nextChannel);
+  validateGeminiOAuthMutation(nextChannel, 'update');
+  const nextChannels = data.channels.map((channel, currentIndex) => (
+    currentIndex === index ? nextChannel : channel
+  ));
+  assertGeminiEnabledChannelsAreValid(nextChannels);
   data.channels[index] = nextChannel;
-
-  // Get proxy status
-  const { getGeminiProxyStatus } = require('../gemini-proxy-server');
+  const { getGeminiProxyStatus } = require('./proxy-implementation');
   const proxyStatus = getGeminiProxyStatus();
   const isProxyRunning = proxyStatus.running;
 
@@ -357,6 +496,7 @@ function applyChannelToSettings(channelId, channels = null) {
   if (!channel) {
     throw new Error('Channel not found');
   }
+  validateGeminiOAuthMutation(channel, 'apply');
 
   const wasEnabled = channel.enabled !== false;
   // In single-channel mode, only this channel should be enabled
@@ -371,6 +511,10 @@ function applyChannelToSettings(channelId, channels = null) {
     clearChannelBalanceCache(channel);
   }
 
+  if (channel.authMode === 'oauth') {
+    return applyNativeGeminiOAuth(channel);
+  }
+
   clearNativeOAuth('gemini');
 
   const geminiDir = getGeminiDir();
@@ -422,7 +566,7 @@ async function deleteChannel(channelId) {
   saveChannels(data);
 
   // 仅在非动态切换模式下更新 Gemini 配置文件
-  const { getGeminiProxyStatus } = require('../gemini-proxy-server');
+  const { getGeminiProxyStatus } = require('./proxy-implementation');
   const proxyStatus = getGeminiProxyStatus();
   if (!proxyStatus.running) {
     writeGeminiConfigForMultiChannel(data.channels);
@@ -440,8 +584,14 @@ function writeGeminiConfigForMultiChannel(allChannels) {
   }
 
   // 获取第一个启用的渠道作为默认配置
-  const enabledChannels = allChannels.filter(c => c.enabled !== false);
-  const defaultChannel = enabledChannels[0] || allChannels[0];
+  const channels = Array.isArray(allChannels) ? allChannels : [];
+  const enabledChannels = channels.filter(c => c.enabled !== false);
+  assertGeminiEnabledChannelsAreValid(channels);
+  const oauthChannels = enabledChannels.filter(channel => channel.authMode === 'oauth');
+  if (oauthChannels.length) {
+    return applyNativeGeminiOAuth(oauthChannels[0]);
+  }
+  const defaultChannel = enabledChannels[0];
 
   const env = readExistingGeminiEnv();
 
@@ -485,6 +635,16 @@ function getEnabledChannels() {
   return data.channels.filter(c => c.enabled !== false);
 }
 
+function getGeminiProxyExcludedChannelIds(channels = null) {
+  const candidates = Array.isArray(channels) ? channels : getEnabledChannels();
+  return [...new Set(
+    candidates
+      .filter(channel => channel?.enabled !== false && channel?.authMode === 'oauth')
+      .map(channel => channel.id)
+      .filter(Boolean)
+  )];
+}
+
 function markChannelAsRecentlyUsed(channelId) {
   return updateChannel(channelId, {});
 }
@@ -521,10 +681,13 @@ function disableAllChannels() {
   const data = loadChannels();
   data.channels.forEach(ch => { ch.enabled = false; });
   saveChannels(data);
+  if (!getGeminiProxyState().running) {
+    clearGeminiChannelConfig();
+  }
 }
 
 function readGeminiSettings() {
-  const settingsPath = NATIVE_PATHS.gemini.settings;
+  const settingsPath = configuredNative.settings;
   if (!settingsPath || !fs.existsSync(settingsPath)) {
     return {};
   }
@@ -639,6 +802,7 @@ function syncCurrentGeminiChannel() {
 }
 
 module.exports = {
+  configure,
   getChannels,
   createChannel,
   updateChannel,
@@ -646,6 +810,7 @@ module.exports = {
   deleteChannel,
   getEnabledChannels,
   getEffectiveApiKey,
+  getGeminiProxyExcludedChannelIds,
   saveChannelOrder,
   isProxyConfig,
   getGeminiDir,

package/src/platforms/drivers/gemini/channels.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const { createChannelDriver } = require('../../../shared/channel-driver');
+
+function createDriver(context = {}) {
+  const driver = createChannelDriver({
+    ...context,
+    platform: 'gemini',
+    servicePath: './gemini/channels-implementation',
+    localServicePath: '../platforms/drivers/gemini/channels-implementation',
+    syncMethod: 'syncCurrentGeminiChannel',
+    createArgs: (input, rest) => typeof input === 'object'
+      ? (() => {
+        const { name, baseUrl, apiKey, model, extra, ...channelExtra } = input;
+        return [name, baseUrl, apiKey, model, { ...channelExtra, ...extra }];
+      })()
+      : [input, ...rest],
+    cliMetadata: {
+      supportsCliCreate: true,
+      supportsCliToggle: true,
+      defaultPort: 20090,
+      createDefaults: { model: 'gemini-2.5-pro' },
+      createQuestions: [{
+        type: 'input',
+        name: 'model',
+        message: '模型名称 (默认: gemini-2.5-pro):',
+        default: 'gemini-2.5-pro'
+      }]
+    },
+    formatCliChannelDetails: channel => channel.model ? [`model ${channel.model}`] : []
+  });
+  const auth = require('../../channel-auth-service');
+  driver.getAuth = context => auth.getChannelAuth('gemini', { channelId: context?.params?.channelId || context?.query?.channelId || '' });
+  driver.syncLocalAuth = context => auth.syncLocalChannelAuth('gemini', { channelId: context?.body?.channelId || context?.params?.channelId || context?.query?.channelId || '' });
+  driver.getAuthQuota = context => auth.fetchChannelAuthQuota('gemini', context?.params?.channelId, { refresh: context?.query?.refresh === 'true' });
+  return driver;
+}
+
+module.exports = { createDriver };

package/src/{server/services/gemini-config.js → platforms/drivers/gemini/config.js}

@@ -1,12 +1,21 @@
 const fs = require('fs');
 const path = require('path');
-const { NATIVE_PATHS } = require('../../config/paths');
+const { NATIVE_PATHS } = require('../../../config/paths');
+
+const DEFAULT_GEMINI_DIR = path.dirname(NATIVE_PATHS.gemini.env);
+let geminiDirOverride = null;
+
+function configure({ pathContext } = {}) {
+  geminiDirOverride = pathContext?.customized
+    ? (pathContext.native?.dir || path.dirname(pathContext.native?.env || DEFAULT_GEMINI_DIR))
+    : null;
+}
 
 /**
  * 获取 Gemini 配置目录
  */
 function getGeminiDir() {
-  return path.dirname(NATIVE_PATHS.gemini.env);
+  return geminiDirOverride || DEFAULT_GEMINI_DIR;
 }
 
 /**
@@ -66,6 +75,7 @@ function isGeminiInstalled() {
 }
 
 module.exports = {
+  configure,
   getGeminiDir,
   loadEnv,
   loadSettings,

package/src/platforms/drivers/gemini/mcp.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const { createMcpDriver } = require('../../../shared/driver-factories/mcp');
+
+function createDriver(context = {}) {
+  return createMcpDriver({ ...context, platform: 'gemini' });
+}
+
+module.exports = { createDriver };

package/src/{server/services/gemini-settings-manager.js → platforms/drivers/gemini/native-config-implementation.js}

@@ -1,23 +1,31 @@
 const fs = require('fs');
 const path = require('path');
-const { NATIVE_PATHS } = require('../../config/paths');
+const { NATIVE_PATHS } = require('../../../config/paths');
+const DEFAULT_NATIVE_PATHS = NATIVE_PATHS.gemini;
+let nativePaths = DEFAULT_NATIVE_PATHS;
+
+function configure({ pathContext } = {}) {
+  nativePaths = pathContext?.customized && pathContext.native?.env
+    ? { ...DEFAULT_NATIVE_PATHS, ...pathContext.native }
+    : DEFAULT_NATIVE_PATHS;
+}
 
 // Gemini 配置文件路径
 function getEnvPath() {
-  return NATIVE_PATHS.gemini.env;
+  return nativePaths.env;
 }
 
 function getSettingsPath() {
-  return path.join(path.dirname(NATIVE_PATHS.gemini.env), 'settings.json');
+  return nativePaths.settings || path.join(path.dirname(nativePaths.env), 'settings.json');
 }
 
 // 备份文件路径
 function getEnvBackupPath() {
-  return NATIVE_PATHS.gemini.envBackup;
+  return nativePaths.envBackup;
 }
 
 function getSettingsBackupPath() {
-  return path.join(path.dirname(NATIVE_PATHS.gemini.env), 'settings.json.cc-tool-backup');
+  return nativePaths.settingsBackup || path.join(path.dirname(nativePaths.env), 'settings.json.cc-tool-backup');
 }
 
 // 检查配置文件是否存在
@@ -257,6 +265,7 @@ function getCurrentProxyPort() {
 }
 
 module.exports = {
+  configure,
   getEnvPath,
   getSettingsPath,
   getEnvBackupPath,

package/src/platforms/drivers/gemini/native-config.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const implementation = require('./native-config-implementation');
+const path = require('path');
+const { createNativeSnapshotMethods } = require('../native-config-snapshot');
+
+function createDriver({ requireImpl, ...context } = {}) {
+  const configuredPaths = context.pathContext?.native;
+  const currentNativePaths = context.pathContext?.customized && configuredPaths?.env
+    ? configuredPaths
+    : require('../../../config/paths').NATIVE_PATHS.gemini;
+  const settings = requireImpl
+    ? requireImpl('./gemini/native-config-implementation')
+    : implementation;
+  settings.configure?.({ pathContext: context.pathContext });
+  const snapshotMethods = createNativeSnapshotMethods({
+    env: { path: currentNativePaths.env, format: 'text', mode: 0o600 },
+    settings: {
+      path: currentNativePaths.settings || path.join(path.dirname(currentNativePaths.env), 'settings.json'),
+      format: 'json'
+    }
+  }, { platform: 'gemini', runtime: context.runtime });
+  return {
+    platform: 'gemini',
+    capability: 'nativeConfig',
+    ...context,
+    ...settings,
+    ...snapshotMethods,
+    clearNativeOAuth: () => {
+      const adapters = require('../../native-oauth-adapters');
+      adapters.configure?.(context);
+      return adapters.clearNativeOAuth('gemini');
+    },
+    preserveNativeOAuthOnProxyStart: true,
+    restoreNativeSettingsOnProxyStop: true
+  };
+}
+
+module.exports = { createDriver };