coding-tool-x 3.3.7 → 3.3.9

package/src/server/services/oauth-utils.js

@@ -0,0 +1,49 @@
+const fs = require('fs');
+const crypto = require('crypto');
+
+function maskToken(value) {
+  const token = String(value || '').trim();
+  if (!token) {
+    return '';
+  }
+  if (token.length <= 8) {
+    return `${token.slice(0, 2)}***`;
+  }
+  return `${token.slice(0, 4)}...${token.slice(-4)}`;
+}
+
+function decodeJwtPayload(token) {
+  if (typeof token !== 'string' || !token.includes('.')) {
+    return null;
+  }
+
+  try {
+    const payload = token.split('.')[1];
+    const normalized = payload.replace(/-/g, '+').replace(/_/g, '/');
+    const padded = normalized.padEnd(Math.ceil(normalized.length / 4) * 4, '=');
+    return JSON.parse(Buffer.from(padded, 'base64').toString('utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function removeFileIfExists(filePath) {
+  try {
+    if (filePath && fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+    }
+  } catch {
+    // ignore cleanup failures
+  }
+}
+
+function sha256(value) {
+  return crypto.createHash('sha256').update(String(value || ''), 'utf8').digest('hex');
+}
+
+module.exports = {
+  maskToken,
+  decodeJwtPayload,
+  removeFileIfExists,
+  sha256
+};

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

@@ -2,6 +2,8 @@ const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
 const { PATHS } = require('../../config/paths');
+const { clearNativeOAuth } = require('./native-oauth-adapters');
+const { setChannelConfig } = require('./opencode-settings-manager');
 
 /**
  * OpenCode 渠道管理服务
@@ -41,17 +43,17 @@ function normalizeChannelName(value) {
 
 // 获取渠道存储文件路径
 function getChannelsFilePath() {
-  const ccToolDir = PATHS.base;
-  if (!fs.existsSync(ccToolDir)) {
-    fs.mkdirSync(ccToolDir, { recursive: true });
+  const channelsDir = path.dirname(PATHS.channels.opencode);
+  if (!fs.existsSync(channelsDir)) {
+    fs.mkdirSync(channelsDir, { recursive: true });
   }
   return PATHS.channels.opencode;
 }
 
 function getCodexChannelsFilePath() {
-  const ccToolDir = PATHS.base;
-  if (!fs.existsSync(ccToolDir)) {
-    fs.mkdirSync(ccToolDir, { recursive: true });
+  const channelsDir = path.dirname(PATHS.channels.codex);
+  if (!fs.existsSync(channelsDir)) {
+    fs.mkdirSync(channelsDir, { recursive: true });
   }
   return PATHS.channels.codex;
 }
@@ -189,14 +191,6 @@ function updateChannel(channelId, updates) {
     console.log(`[OpenCode Single-channel mode] Enabled "${merged.name}", disabled all others`);
   }
 
-  // Prevent disabling last enabled channel when proxy is OFF
-  if (!isProxyRunning && !merged.enabled && oldChannel.enabled) {
-    const enabledCount = data.channels.filter(ch => ch.enabled).length;
-    if (enabledCount === 0) {
-      throw new Error('无法禁用最后一个启用的渠道。请先启用其他渠道或启动动态切换。');
-    }
-  }
-
   saveChannels(data);
   return data.channels[index];
 }
@@ -259,6 +253,9 @@ function applyChannelToSettings(channelId) {
   });
   saveChannels(data);
 
+  clearNativeOAuth('opencode');
+  setChannelConfig(channel);
+
   return channel;
 }
 
@@ -371,6 +368,12 @@ async function getEffectiveApiKey(channel) {
   return candidates[0] || null;
 }
 
+function disableAllChannels() {
+  const data = loadChannels();
+  data.channels.forEach(ch => { ch.enabled = false; });
+  saveChannels(data);
+}
+
 module.exports = {
   getChannels,
   createChannel,
@@ -380,5 +383,6 @@ module.exports = {
   saveChannelOrder,
   applyChannelToSettings,
   getEffectiveApiKey,
-  getEffectiveApiKeyCandidates
+  getEffectiveApiKeyCandidates,
+  disableAllChannels
 };

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

@@ -9,8 +9,8 @@ const { NATIVE_PATHS, PATHS } = require('../../config/paths');
  * 读取 OpenCode SQLite 会话数据
  */
 
-const PROJECT_ORDER_FILE = path.join(PATHS.base, 'opencode-project-order.json');
-const SESSION_ORDER_FILE = path.join(PATHS.base, 'opencode-session-order.json');
+const PROJECT_ORDER_FILE = PATHS.opencodeProjectOrder;
+const SESSION_ORDER_FILE = PATHS.opencodeSessionOrder;
 const OPENCODE_DB_PATH = path.join(NATIVE_PATHS.opencode.data, 'opencode.db');
 const COUNTS_CACHE_TTL_MS = 30 * 1000;
 const EMPTY_COUNTS = Object.freeze({ projectCount: 0, sessionCount: 0 });

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

@@ -169,6 +169,11 @@ function isManagedProxyProvider(provider) {
   return apiKey === PROXY_API_KEY && isLocalProxyBaseUrl(baseUrl);
 }
 
+function isManagedChannelProvider(provider) {
+  if (!provider || typeof provider !== 'object') return false;
+  return provider?.[MANAGED_PROVIDER_MARKER] === true;
+}
+
 function isManagedProxyConfig(config) {
   if (!config || typeof config !== 'object') return false;
   // Check legacy single-provider format
@@ -244,6 +249,92 @@ function resolveProxyBaseUrl(config) {
   return '';
 }
 
+function collectChannelModelCandidates(channel = {}) {
+  const seen = new Set();
+  const models = [];
+  const add = (value) => {
+    if (typeof value !== 'string') return;
+    const trimmed = value.trim();
+    if (!trimmed) return;
+    const key = trimmed.toLowerCase();
+    if (seen.has(key)) return;
+    seen.add(key);
+    models.push(trimmed);
+  };
+
+  add(channel.model);
+  add(channel.speedTestModel);
+
+  if (Array.isArray(channel.allowedModels)) {
+    channel.allowedModels.forEach(add);
+  }
+
+  if (channel.modelConfig && typeof channel.modelConfig === 'object') {
+    add(channel.modelConfig.model);
+    add(channel.modelConfig.opusModel);
+    add(channel.modelConfig.sonnetModel);
+    add(channel.modelConfig.haikuModel);
+  }
+
+  if (Array.isArray(channel.modelRedirects)) {
+    channel.modelRedirects.forEach((rule) => {
+      add(rule?.from);
+      add(rule?.to);
+    });
+  }
+
+  return models;
+}
+
+function clearManagedProviders(config) {
+  const removedProviderKeys = [];
+
+  if (!config?.provider || typeof config.provider !== 'object') {
+    return removedProviderKeys;
+  }
+
+  if (isLegacyProxyProvider(config.provider[LEGACY_PROVIDER_ID])) {
+    delete config.provider[LEGACY_PROVIDER_ID];
+    removedProviderKeys.push(LEGACY_PROVIDER_ID);
+  }
+
+  if (isManagedProxyProvider(config.provider[PROXY_PROVIDER_ID])) {
+    delete config.provider[PROXY_PROVIDER_ID];
+    removedProviderKeys.push(PROXY_PROVIDER_ID);
+  }
+
+  Object.keys(config.provider).forEach((key) => {
+    const provider = config.provider[key];
+    if (isManagedProxyProvider(provider) || isManagedChannelProvider(provider)) {
+      delete config.provider[key];
+      removedProviderKeys.push(key);
+    }
+  });
+
+  if (Object.keys(config.provider).length === 0) {
+    delete config.provider;
+  }
+
+  return removedProviderKeys;
+}
+
+function clearManagedModelRef(config, removedProviderKeys = []) {
+  const modelRef = String(config?.model || '').trim();
+  if (!modelRef) {
+    return;
+  }
+
+  if (isOldManagedModelRef(modelRef)) {
+    delete config.model;
+    return;
+  }
+
+  const providerId = modelRef.includes('/') ? modelRef.split('/')[0] : '';
+  if (providerId && removedProviderKeys.includes(providerId)) {
+    delete config.model;
+  }
+}
+
 function backupConfig(filePath) {
   ensureConfigDir();
   const backupPath = getBackupPath(filePath);
@@ -324,23 +415,13 @@ function setProxyConfig(proxyPort, options = {}) {
   if (!next.provider || typeof next.provider !== 'object') {
     next.provider = {};
   }
-  // 清理历史 openai 代理注入，避免 /models 出现与代理无关的 openai 模型列表。
-  if (isLegacyProxyProvider(next.provider[LEGACY_PROVIDER_ID])) {
-    delete next.provider[LEGACY_PROVIDER_ID];
-  }
-  if (Object.prototype.hasOwnProperty.call(next.provider[LEGACY_PROVIDER_ID] || {}, 'model')) {
-    delete next.provider[LEGACY_PROVIDER_ID].model;
-  }
-
-  // Remove old single ctx-proxy provider (superseded by per-channel providers)
-  delete next.provider[PROXY_PROVIDER_ID];
+  const removedProviderKeys = clearManagedProviders(next);
+  clearManagedModelRef(next, removedProviderKeys);
 
-  // Remove any previously managed per-channel providers that are no longer in the current list
-  Object.keys(next.provider).forEach((key) => {
-    if (isManagedProxyProvider(next.provider[key])) {
-      delete next.provider[key];
-    }
-  });
+  // clearManagedProviders 可能在清空所有 provider 后 delete next.provider，重新确保存在
+  if (!next.provider || typeof next.provider !== 'object') {
+    next.provider = {};
+  }
 
   const channels = Array.isArray(options.channels) ? options.channels : null;
 
@@ -427,6 +508,73 @@ function setProxyConfig(proxyPort, options = {}) {
   return { success: true, port: proxyPort, path: filePath };
 }
 
+function setChannelConfig(channel = {}) {
+  const filePath = selectConfigPath();
+  backupConfig(filePath);
+
+  const current = readConfig(filePath);
+  const next = (current && typeof current === 'object') ? current : {};
+
+  if (!next.provider || typeof next.provider !== 'object') {
+    next.provider = {};
+  }
+
+  const removedProviderKeys = clearManagedProviders(next);
+  clearManagedModelRef(next, removedProviderKeys);
+
+  const baseProviderKey = sanitizeProviderKey(channel.providerKey || channel.name || 'ctx-channel');
+  let providerKey = baseProviderKey;
+  let suffix = 2;
+  while (next.provider[providerKey] && !isManagedChannelProvider(next.provider[providerKey])) {
+    providerKey = `${baseProviderKey}-${suffix}`;
+    suffix += 1;
+  }
+
+  const modelCandidates = collectChannelModelCandidates(channel);
+  const fallbackModel = String(channel.model || channel.speedTestModel || modelCandidates[0] || '').trim();
+  const modelsMap = buildModelsMap(modelCandidates, fallbackModel);
+  const modelIds = Object.keys(modelsMap);
+
+  if (modelIds.length === 0) {
+    throw new Error('OpenCode 渠道缺少可写入的模型，请至少配置默认模型或可用模型。');
+  }
+
+  next.provider[providerKey] = {
+    [MANAGED_PROVIDER_MARKER]: true,
+    npm: '@ai-sdk/openai-compatible',
+    name: channel.name || providerKey,
+    options: {
+      baseURL: String(channel.baseUrl || '').trim(),
+      apiKey: String(channel.apiKey || '').trim()
+    },
+    models: modelsMap
+  };
+
+  const topModel = normalizeOpenCodeModel(fallbackModel || modelIds[0], providerKey);
+  if (topModel) {
+    next.model = topModel;
+  } else {
+    clearManagedModelRef(next, [providerKey]);
+  }
+
+  writeConfig(filePath, next);
+  return { success: true, path: filePath, providerKey, model: next.model || null };
+}
+
+function clearManagedChannelConfig() {
+  const filePath = selectConfigPath();
+  if (!fs.existsSync(filePath)) {
+    return { success: true, path: filePath };
+  }
+
+  const current = readConfig(filePath);
+  const next = (current && typeof current === 'object') ? current : {};
+  const removedProviderKeys = clearManagedProviders(next);
+  clearManagedModelRef(next, removedProviderKeys);
+  writeConfig(filePath, next);
+  return { success: true, path: filePath };
+}
+
 function isOldManagedModelRef(modelRef) {
   const s = String(modelRef || '');
   return s.startsWith(`${PROXY_PROVIDER_ID}/`) || s.startsWith(`${LEGACY_PROVIDER_ID}/`);
@@ -485,7 +633,12 @@ function getCurrentProxyPort() {
 module.exports = {
   configExists,
   hasBackup,
+  readConfig,
+  writeConfig,
+  selectConfigPath,
   setProxyConfig,
+  setChannelConfig,
+  clearManagedChannelConfig,
   restoreSettings,
   deleteBackup,
   isProxyConfig,

package/src/server/services/opencode-statistics-service.js

@@ -4,36 +4,12 @@ const {
   getDailyStatistics: getSharedDailyStatistics,
   getTodayStatistics: getSharedTodayStatistics
 } = require('./statistics-service');
+const { normalizeUsageTokens, toNumber } = require('./proxy-log-helper');
 
 const TOOL_TYPE = 'opencode';
 
-function toNumber(value) {
-  const num = Number(value);
-  return Number.isFinite(num) ? num : 0;
-}
-
-function normalizeToolTokens(tokens = {}) {
-  const input = toNumber(tokens.input);
-  const output = toNumber(tokens.output);
-  const reasoning = toNumber(tokens.reasoning);
-  const cached = toNumber(tokens.cached);
-  const cacheCreation = toNumber(tokens.cacheCreation);
-  const cacheRead = toNumber(tokens.cacheRead || cached);
-  const total = toNumber(tokens.total) || (input + output + reasoning);
-
-  return {
-    input,
-    output,
-    reasoning,
-    cached,
-    cacheCreation,
-    cacheRead,
-    total
-  };
-}
-
 function toLegacyEntryShape(entry = {}, includeName = false) {
-  const normalized = normalizeToolTokens(entry.tokens || {});
+  const normalized = normalizeUsageTokens(TOOL_TYPE, entry.tokens || {});
   const result = {
     requests: toNumber(entry.requests),
     tokens: {
@@ -126,7 +102,7 @@ function buildDailyStatistics(sharedDaily = {}, fallbackDate) {
 }
 
 function recordRequest(requestData = {}) {
-  const normalizedTokens = normalizeToolTokens(requestData.tokens || {});
+  const normalizedTokens = normalizeUsageTokens(TOOL_TYPE, requestData.tokens || {});
   return recordSharedRequest({
     ...requestData,
     toolType: TOOL_TYPE,

package/src/server/services/plugins-service.js

@@ -10,7 +10,7 @@ const { listPlugins, getPlugin, updatePlugin: updatePluginRegistry } = require('
 const { installPlugin: installPluginCore, uninstallPlugin: uninstallPluginCore } = require('../../plugins/plugin-installer');
 const { initializePlugins, shutdownPlugins } = require('../../plugins/plugin-manager');
 const { INSTALLED_DIR, CONFIG_DIR } = require('../../plugins/constants');
-const { NATIVE_PATHS, HOME_DIR } = require('../../config/paths');
+const { NATIVE_PATHS, PATHS } = require('../../config/paths');
 
 const CLAUDE_PLUGINS_DIR = path.join(path.dirname(NATIVE_PATHS.claude.settings), 'plugins');
 const CLAUDE_INSTALLED_FILE = path.join(CLAUDE_PLUGINS_DIR, 'installed_plugins.json');
@@ -106,9 +106,77 @@ function stripJsonComments(input = '') {
 class PluginsService {
   constructor(platform = 'claude') {
     this.platform = ['claude', 'opencode'].includes(platform) ? platform : 'claude';
-    this.ccToolConfigDir = path.join(HOME_DIR, '.cc-tool');
+    this.ccToolConfigDir = path.dirname(PATHS.pluginRepos.claude);
     this.opencodePluginsDir = path.join(OPENCODE_CONFIG_DIR, 'plugins');
     this.opencodeLegacyPluginsDir = path.join(OPENCODE_CONFIG_DIR, 'plugin');
+    this.marketCachePath = this.platform === 'opencode'
+      ? PATHS.pluginMarketCache.opencode
+      : PATHS.pluginMarketCache.claude;
+    this._marketCache = null;
+  }
+
+  clearMarketCache({ removeFile = true } = {}) {
+    this._marketCache = null;
+    if (removeFile) {
+      try {
+        if (fs.existsSync(this.marketCachePath)) {
+          fs.unlinkSync(this.marketCachePath);
+        }
+      } catch (err) {
+        // ignore cache deletion errors
+      }
+    }
+  }
+
+  loadMarketCacheFromFile() {
+    try {
+      if (fs.existsSync(this.marketCachePath)) {
+        const data = JSON.parse(fs.readFileSync(this.marketCachePath, 'utf-8'));
+        if (Array.isArray(data.plugins)) {
+          return data.plugins;
+        }
+      }
+    } catch (err) {
+      // ignore cache read errors
+    }
+    return null;
+  }
+
+  saveMarketCacheToFile(plugins) {
+    try {
+      this._ensureDir(path.dirname(this.marketCachePath));
+      fs.writeFileSync(this.marketCachePath, JSON.stringify({ plugins }), 'utf-8');
+    } catch (err) {
+      // ignore cache write errors
+    }
+  }
+
+  prepareMarketPlugins(plugins = []) {
+    const preparedPlugins = Array.isArray(plugins)
+      ? plugins.map(plugin => ({ ...plugin }))
+      : [];
+    const seen = new Set();
+    const installedPlugins = this.listPlugins().plugins;
+    const installedNames = new Set(installedPlugins.map(p => p.name));
+
+    const deduped = [];
+    for (const plugin of preparedPlugins) {
+      const key = [
+        plugin.name || '',
+        plugin.repoOwner || '',
+        plugin.repoName || '',
+        plugin.directory || plugin.installSource || ''
+      ].join('::');
+      if (seen.has(key)) continue;
+      seen.add(key);
+      deduped.push({
+        ...plugin,
+        isInstalled: installedNames.has(plugin.name)
+      });
+    }
+
+    deduped.sort((a, b) => (a.name || '').toLowerCase().localeCompare((b.name || '').toLowerCase()));
+    return deduped;
   }
 
   _ensureDir(dirPath) {
@@ -777,11 +845,9 @@ class PluginsService {
    * @returns {string} Config file path
    */
   getReposConfigPath() {
-    this._ensureDir(this.ccToolConfigDir);
-    if (this._isOpenCode()) {
-      return path.join(this.ccToolConfigDir, 'opencode-plugin-repos.json');
-    }
-    return path.join(this.ccToolConfigDir, 'plugin-repos.json');
+    const filePath = this._isOpenCode() ? PATHS.pluginRepos.opencode : PATHS.pluginRepos.claude;
+    this._ensureDir(path.dirname(filePath));
+    return filePath;
   }
 
   _getDefaultRepos() {
@@ -933,6 +999,7 @@ class PluginsService {
 
     config.repos.push(newRepo);
     this.saveReposConfig(config);
+    this.clearMarketCache();
 
     return config.repos;
   }
@@ -947,6 +1014,7 @@ class PluginsService {
     const config = this.loadReposConfig();
     config.repos = config.repos.filter(r => !(r.owner === owner && r.name === name));
     this.saveReposConfig(config);
+    this.clearMarketCache();
     return config.repos;
   }
 
@@ -965,6 +1033,7 @@ class PluginsService {
     }
     repo.enabled = enabled;
     this.saveReposConfig(config);
+    this.clearMarketCache();
     return config.repos;
   }
 
@@ -1153,9 +1222,30 @@ class PluginsService {
    * Get market plugins from configured repositories
    * @returns {Promise<Array>} List of available market plugins
    */
-  async getMarketPlugins() {
+  async getMarketPlugins(forceRefresh = false) {
+    if (forceRefresh) {
+      this.clearMarketCache({ removeFile: false });
+    }
+
+    const fileCache = this.loadMarketCacheFromFile();
+
+    if (!forceRefresh && Array.isArray(this._marketCache) && this._marketCache.length > 0) {
+      if (Array.isArray(fileCache) && fileCache.length > this._marketCache.length) {
+        this._marketCache = this.prepareMarketPlugins(fileCache);
+        return this._marketCache;
+      }
+      this._marketCache = this.prepareMarketPlugins(this._marketCache);
+      return this._marketCache;
+    }
+
+    if (!forceRefresh && Array.isArray(fileCache) && fileCache.length > 0) {
+      this._marketCache = this.prepareMarketPlugins(fileCache);
+      return this._marketCache;
+    }
+
     const repos = this.getRepos().filter(r => r.enabled);
     const marketPlugins = [];
+    let repoFailureCount = 0;
 
     for (const repo of repos) {
       try {
@@ -1248,19 +1338,29 @@ class PluginsService {
           }
         }
       } catch (err) {
+        repoFailureCount++;
         console.error(`[PluginsService] Failed to fetch plugins from ${repo.owner}/${repo.name}:`, err.message);
       }
     }
 
-    // Mark installed plugins
-    const installedPlugins = this.listPlugins().plugins;
-    const installedNames = new Set(installedPlugins.map(p => p.name));
+    const preparedPlugins = this.prepareMarketPlugins(marketPlugins);
+    const preparedFileCache = Array.isArray(fileCache) && fileCache.length > 0
+      ? this.prepareMarketPlugins(fileCache)
+      : null;
+    const shouldUseStaleFileCache = preparedFileCache && (
+      (repos.length > 0 && repoFailureCount === repos.length) ||
+      (repoFailureCount > 0 && preparedFileCache.length > preparedPlugins.length)
+    );
 
-    marketPlugins.forEach(plugin => {
-      plugin.isInstalled = installedNames.has(plugin.name);
-    });
+    if (shouldUseStaleFileCache) {
+      this._marketCache = preparedFileCache;
+      return this._marketCache;
+    }
+
+    this._marketCache = preparedPlugins;
+    this.saveMarketCacheToFile(preparedPlugins);
 
-    return marketPlugins;
+    return preparedPlugins;
   }
 }
 

package/src/server/services/prompts-service.js

@@ -7,14 +7,13 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-const { NATIVE_PATHS } = require('../../config/paths');
+const { NATIVE_PATHS, PATHS } = require('../../config/paths');
 const { resolvePreferredHomeDir } = require('../../utils/home-dir');
 
 const HOME_DIR = resolvePreferredHomeDir(process.platform, process.env, os.homedir());
 
 // Prompts 配置文件路径
-const CC_TOOL_DIR = path.join(HOME_DIR, '.cc-tool');
-const PROMPTS_FILE = path.join(CC_TOOL_DIR, 'prompts.json');
+const PROMPTS_FILE = PATHS.prompts;
 
 // 各平台提示词文件路径
 const CLAUDE_PROMPT_PATH = path.join(HOME_DIR, '.claude', 'CLAUDE.md');