coding-tool-x 3.4.10 → 3.4.12

package/src/server/api/opencode-proxy.js

@@ -13,9 +13,16 @@ const {
   restoreSettings,
   deleteBackup,
   isProxyConfig,
-  getCurrentProxyPort
+  getCurrentProxyPort,
+  readConfig,
+  selectConfigPath
 } = require('../services/opencode-settings-manager');
-const { getChannels, getEnabledChannels, applyChannelToSettings } = require('../services/opencode-channels');
+const {
+  getChannels,
+  getEnabledChannels,
+  applyChannelToSettings,
+  getEffectiveApiKeyCandidates
+} = require('../services/opencode-channels');
 const { getSchedulerState } = require('../services/channel-scheduler');
 const { PATHS, ensureStorageDirMigrated } = require('../../config/paths');
 const fs = require('fs');
@@ -60,6 +67,83 @@ function resolveActiveChannel(channels, activeChannelId = null) {
     || null;
 }
 
+function sanitizeManagedProviderId(value) {
+  return String(value || '')
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '')
+    || 'channel';
+}
+
+function getCurrentProviderIdFromConfig(config) {
+  const modelRef = String(config?.model || '').trim();
+  if (modelRef.includes('/')) {
+    return modelRef.split('/')[0].trim();
+  }
+
+  const providerIds = config?.provider && typeof config.provider === 'object'
+    ? Object.keys(config.provider).filter(Boolean)
+    : [];
+
+  return providerIds.length === 1 ? providerIds[0] : '';
+}
+
+function getManagedProviderIdsForChannel(channel) {
+  const providerKey = String(channel?.providerKey || '').trim();
+  const fallbackName = String(channel?.name || '').trim();
+  const base = providerKey || fallbackName || 'ctx-channel';
+  return new Set([
+    providerKey,
+    sanitizeManagedProviderId(base)
+  ].filter(Boolean));
+}
+
+function findActiveChannelFromNativeConfig(channels = []) {
+  if (!Array.isArray(channels) || channels.length === 0) {
+    return null;
+  }
+
+  try {
+    const configPath = selectConfigPath();
+    if (!configPath || !fs.existsSync(configPath)) {
+      return null;
+    }
+
+    const config = readConfig(configPath);
+    const providerId = getCurrentProviderIdFromConfig(config);
+    const provider = providerId && config?.provider && typeof config.provider === 'object'
+      ? config.provider[providerId]
+      : null;
+    const baseUrl = String(provider?.options?.baseURL || '').trim();
+    const apiKey = String(provider?.options?.apiKey || '').trim();
+
+    if (providerId) {
+      const providerMatched = channels.find((channel) => getManagedProviderIdsForChannel(channel).has(providerId));
+      if (providerMatched) {
+        return providerMatched;
+      }
+    }
+
+    if (baseUrl && apiKey) {
+      const exactMatched = channels.find((channel) => (
+        channel.baseUrl === baseUrl && getEffectiveApiKeyCandidates(channel).includes(apiKey)
+      ));
+      if (exactMatched) {
+        return exactMatched;
+      }
+    }
+
+    if (baseUrl) {
+      return channels.find((channel) => channel.baseUrl === baseUrl) || null;
+    }
+  } catch (error) {
+    console.warn('[OpenCode Proxy] Failed to infer native active channel:', error.message);
+  }
+
+  return null;
+}
+
 // 保存激活渠道ID
 function saveActiveChannelId(channelId) {
   ensureStorageDirMigrated();
@@ -127,14 +211,15 @@ router.post('/start', async (req, res) => {
   try {
     // 1. 获取当前启用的渠道
     const enabledChannels = getEnabledChannels();
-    const currentChannel = enabledChannels[0];
-
-    if (!currentChannel) {
+    if (enabledChannels.length === 0) {
       return res.status(400).json({
         error: 'No enabled OpenCode channel found. Please create and enable a channel first.'
       });
     }
 
+    const { channels: allChannels } = getChannels();
+    const currentChannel = findActiveChannelFromNativeConfig(allChannels) || enabledChannels[0];
+
     // 2. 保存当前激活渠道ID
     saveActiveChannelId(currentChannel.id);
     console.log(`[OpenCode Proxy] Saved active channel: ${currentChannel.name} (${currentChannel.id})`);
@@ -193,13 +278,13 @@ router.post('/start', async (req, res) => {
       };
     });
 
-    const activeModel = currentChannel.model || currentChannel.speedTestModel || null;
+    const primaryProxyChannel = enabledChannels[0] || currentChannel;
+    const activeModel = primaryProxyChannel?.model || primaryProxyChannel?.speedTestModel || null;
     setProxyConfig(proxyResult.port, { channels: channelPayloads, model: activeModel });
 
     // 5. 广播状态更新
     const { broadcastProxyState } = require('../websocket-server');
     const updatedStatus = getOpenCodeProxyStatus();
-    const { channels: allChannels } = getChannels();
     broadcastProxyState('opencode', updatedStatus, currentChannel, allChannels);
 
     res.json({

package/src/server/index.js

@@ -199,11 +199,12 @@ async function startServer(port, host = '127.0.0.1', options = {}) {
   app.use('/api/env', require('./api/env'));
   app.use('/api/skills', require('./api/skills'));
   const claudeHooks = require('./api/claude-hooks');
+  const notificationHooks = require('./services/notification-hooks');
   app.use('/api/claude/hooks', claudeHooks);
   app.use('/api/hooks', require('./api/hooks'));
 
   // 初始化 Claude hooks 默认配置（自动开启任务完成通知）
-  claudeHooks.initDefaultHooks();
+  notificationHooks.initDefaultHooks();
 
   // Claude Code 专有功能 API
   app.use('/api/commands', require('./api/commands'));

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

@@ -73,7 +73,7 @@ function writeAnnotatedCodexConfig(configPath, config, comments = []) {
 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)) {
+    if (key === 'cc-proxy' || (key !== currentProviderKey && knownKeys.has(key))) {
       delete existingProviders[key];
     }
   }

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

@@ -34,6 +34,43 @@ function getChannelsFilePath() {
   return PATHS.channels.gemini;
 }
 
+function readExistingGeminiEnv() {
+  const envPath = path.join(getGeminiDir(), '.env');
+  if (!fs.existsSync(envPath)) {
+    return {};
+  }
+
+  const env = {};
+  try {
+    const content = fs.readFileSync(envPath, 'utf8');
+    content.split('\n').forEach((line) => {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('#')) return;
+
+      const match = trimmed.match(/^([^=]+)=(.*)$/);
+      if (match) {
+        env[match[1].trim()] = match[2].trim();
+      }
+    });
+  } catch (err) {
+    return {};
+  }
+
+  return env;
+}
+
+function writeGeminiEnv(env = {}) {
+  const envPath = path.join(getGeminiDir(), '.env');
+  const content = Object.entries(env)
+    .map(([key, value]) => `${key}=${value}`)
+    .join('\n');
+
+  fs.writeFileSync(envPath, content ? `${content}\n` : '', 'utf8');
+  if (process.platform !== 'win32') {
+    fs.chmodSync(envPath, 0o600);
+  }
+}
+
 // 检查是否在代理模式
 function isProxyConfig() {
   const envPath = path.join(getGeminiDir(), '.env');
@@ -295,21 +332,12 @@ function applyChannelToSettings(channelId, channels = null) {
     fs.mkdirSync(geminiDir, { recursive: true });
   }
 
-  const envPath = path.join(geminiDir, '.env');
-
-  // 构建 .env 内容
+  const env = readExistingGeminiEnv();
   const effectiveApiKey = getEffectiveApiKey(channel) || '';
-  const envContent = `GOOGLE_GEMINI_BASE_URL=${channel.baseUrl}
-GEMINI_API_KEY=${effectiveApiKey}
-GEMINI_MODEL=${channel.model}
-`;
-
-  fs.writeFileSync(envPath, envContent, 'utf8');
-
-  // 设置 .env 文件权限为 600 (仅所有者可读写)
-  if (process.platform !== 'win32') {
-    fs.chmodSync(envPath, 0o600);
-  }
+  env.GOOGLE_GEMINI_BASE_URL = channel.baseUrl;
+  env.GEMINI_API_KEY = effectiveApiKey;
+  env.GEMINI_MODEL = channel.model;
+  writeGeminiEnv(env);
 
   // 确保 settings.json 存在并配置正确的认证模式
   const settingsPath = path.join(geminiDir, 'settings.json');
@@ -364,32 +392,25 @@ function writeGeminiConfigForMultiChannel(allChannels) {
     fs.mkdirSync(geminiDir, { recursive: true });
   }
 
-  const envPath = path.join(geminiDir, '.env');
-
   // 获取第一个启用的渠道作为默认配置
   const enabledChannels = allChannels.filter(c => c.enabled !== false);
   const defaultChannel = enabledChannels[0] || allChannels[0];
 
+  const env = readExistingGeminiEnv();
+
   if (!defaultChannel) {
-    // 没有渠道，写入空配置
-    const envContent = `# Gemini Configuration\n# No channels configured\n`;
-    fs.writeFileSync(envPath, envContent, 'utf8');
+    delete env.GOOGLE_GEMINI_BASE_URL;
+    delete env.GEMINI_API_KEY;
+    delete env.GEMINI_MODEL;
+    writeGeminiEnv(env);
     return;
   }
 
-  // 构建 .env 内容
   const effectiveApiKey = getEffectiveApiKey(defaultChannel) || '';
-  const envContent = `GOOGLE_GEMINI_BASE_URL=${defaultChannel.baseUrl}
-GEMINI_API_KEY=${effectiveApiKey}
-GEMINI_MODEL=${defaultChannel.model}
-`;
-
-  fs.writeFileSync(envPath, envContent, 'utf8');
-
-  // 设置 .env 文件权限为 600 (仅所有者可读写)
-  if (process.platform !== 'win32') {
-    fs.chmodSync(envPath, 0o600);
-  }
+  env.GOOGLE_GEMINI_BASE_URL = defaultChannel.baseUrl;
+  env.GEMINI_API_KEY = effectiveApiKey;
+  env.GEMINI_MODEL = defaultChannel.model;
+  writeGeminiEnv(env);
 
   // 确保 settings.json 存在并配置正确的认证模式
   const settingsPath = path.join(geminiDir, 'settings.json');

package/src/server/services/native-oauth-adapters.js

@@ -723,18 +723,21 @@ function clearOpenCodeOAuth() {
     return;
   }
 
+  const removedProviderIds = [];
   Object.keys(payload).forEach((providerId) => {
     if (payload[providerId]?.type === 'oauth') {
+      removedProviderIds.push(providerId);
       delete payload[providerId];
     }
   });
 
   if (Object.keys(payload).length === 0) {
     removeFileIfExists(NATIVE_PATHS.opencode.auth);
-    return;
+  } else {
+    writeJsonFile(NATIVE_PATHS.opencode.auth, payload);
   }
 
-  writeJsonFile(NATIVE_PATHS.opencode.auth, payload);
+  syncOpenCodeConfigAfterOAuthRemoval(removedProviderIds);
 }
 
 function disableOpenCodeOAuthCredential(credential = {}) {
@@ -745,6 +748,7 @@ function disableOpenCodeOAuthCredential(credential = {}) {
     return;
   }
 
+  const removedProviderIds = [];
   Object.keys(payload).forEach((key) => {
     const target = payload[key];
     if (!target || target.type !== 'oauth') {
@@ -754,16 +758,18 @@ function disableOpenCodeOAuthCredential(credential = {}) {
     const providerMatched = providerId && key === providerId;
     const tokenMatched = accessToken && String(target.access || '').trim() === accessToken;
     if (providerMatched || tokenMatched) {
+      removedProviderIds.push(key);
       delete payload[key];
     }
   });
 
   if (Object.keys(payload).length === 0) {
     removeFileIfExists(NATIVE_PATHS.opencode.auth);
-    return;
+  } else {
+    writeJsonFile(NATIVE_PATHS.opencode.auth, payload);
   }
 
-  writeJsonFile(NATIVE_PATHS.opencode.auth, payload);
+  syncOpenCodeConfigAfterOAuthRemoval(removedProviderIds);
 }
 
 function isManagedOpenCodeProvider(provider) {
@@ -780,6 +786,44 @@ function isManagedOpenCodeProvider(provider) {
   return apiKey === 'PROXY_KEY' && (baseUrl.includes('127.0.0.1') || baseUrl.includes('localhost'));
 }
 
+function isProxyBackedOpenCodeProvider(provider) {
+  if (!provider || typeof provider !== 'object') {
+    return false;
+  }
+
+  const apiKey = String(provider?.options?.apiKey || '').trim();
+  const baseUrl = String(provider?.options?.baseURL || '').trim();
+  return apiKey === 'PROXY_KEY' && (baseUrl.includes('127.0.0.1') || baseUrl.includes('localhost'));
+}
+
+function isMeaningfulOpenCodeProvider(provider) {
+  if (!provider || typeof provider !== 'object') {
+    return false;
+  }
+
+  if (provider.__ctx_managed__ === true) {
+    return true;
+  }
+
+  if (typeof provider.npm === 'string' && provider.npm.trim()) {
+    return true;
+  }
+
+  if (typeof provider.name === 'string' && provider.name.trim()) {
+    return true;
+  }
+
+  if (provider.options && typeof provider.options === 'object' && Object.keys(provider.options).length > 0) {
+    return true;
+  }
+
+  if (provider.models && typeof provider.models === 'object' && Object.keys(provider.models).length > 0) {
+    return true;
+  }
+
+  return false;
+}
+
 function clearOpenCodeManagedModelSelection(config) {
   const modelRef = String(config?.model || '').trim();
   if (!modelRef || !modelRef.includes('/')) {
@@ -797,6 +841,107 @@ function clearOpenCodeManagedModelSelection(config) {
   }
 }
 
+function getConfiguredOpenCodeProviderId(config) {
+  const modelRef = String(config?.model || '').trim();
+  if (modelRef.includes('/')) {
+    return modelRef.split('/')[0].trim();
+  }
+
+  const providerIds = config?.provider && typeof config.provider === 'object'
+    ? Object.keys(config.provider).filter(Boolean)
+    : [];
+  return providerIds.length === 1 ? providerIds[0] : '';
+}
+
+function buildOpenCodeModelRef(providerId, provider) {
+  if (!providerId || !provider || typeof provider !== 'object') {
+    return '';
+  }
+
+  const modelIds = provider.models && typeof provider.models === 'object'
+    ? Object.keys(provider.models).filter(Boolean)
+    : [];
+
+  if (modelIds.length === 0) {
+    return '';
+  }
+
+  return `${providerId}/${modelIds[0]}`;
+}
+
+function pickFallbackOpenCodeModel(config, excludedProviderIds = new Set()) {
+  const providers = config?.provider && typeof config.provider === 'object'
+    ? Object.entries(config.provider)
+    : [];
+
+  for (const [providerId, provider] of providers) {
+    if (excludedProviderIds.has(providerId)) {
+      continue;
+    }
+
+    const modelRef = buildOpenCodeModelRef(providerId, provider);
+    if (modelRef) {
+      return modelRef;
+    }
+  }
+
+  return '';
+}
+
+function syncOpenCodeConfigAfterOAuthRemoval(removedProviderIds = []) {
+  const removedIds = new Set((removedProviderIds || []).filter(Boolean));
+  if (removedIds.size === 0) {
+    return;
+  }
+
+  const configPath = opencodeSettingsManager.selectConfigPath();
+  if (!configPath || !fs.existsSync(configPath)) {
+    return;
+  }
+
+  let config = {};
+  try {
+    config = opencodeSettingsManager.readConfig(configPath);
+  } catch {
+    return;
+  }
+
+  config = config && typeof config === 'object' ? config : {};
+  config.provider = config.provider && typeof config.provider === 'object' ? config.provider : {};
+
+  let changed = false;
+  for (const providerId of removedIds) {
+    const provider = config.provider[providerId];
+    if (provider && !isMeaningfulOpenCodeProvider(provider)) {
+      delete config.provider[providerId];
+      changed = true;
+    }
+  }
+
+  const activeProviderId = getConfiguredOpenCodeProviderId(config);
+  if (activeProviderId && removedIds.has(activeProviderId)) {
+    const activeProvider = config.provider[activeProviderId];
+    if (!isMeaningfulOpenCodeProvider(activeProvider)) {
+      const fallbackModel = pickFallbackOpenCodeModel(config, removedIds);
+      if (fallbackModel) {
+        config.model = fallbackModel;
+      } else {
+        delete config.model;
+      }
+      changed = true;
+    }
+  }
+
+  if (Object.keys(config.provider).length === 0) {
+    delete config.provider;
+    changed = true;
+  }
+
+  if (changed) {
+    opencodeSettingsManager.writeConfig(configPath, config);
+  }
+}
+
 function applyOpenCodeOAuth(credential) {
   const providerId = String(credential.providerId || 'openai').trim() || 'openai';
   const payload = readJsonFile(NATIVE_PATHS.opencode.auth, {});
@@ -840,7 +985,9 @@ function inspectOpenCodeState() {
     const providers = config?.provider && typeof config.provider === 'object'
       ? Object.values(config.provider)
       : [];
-    channelConfigured = providers.some(provider => provider?.__ctx_managed__ === true);
+    channelConfigured = providers.some(provider => (
+      isMeaningfulOpenCodeProvider(provider) && !isProxyBackedOpenCodeProvider(provider)
+    ));
   } catch {
     channelConfigured = false;
   }