@adversity/coding-tool-x 3.1.1 → 3.1.3

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

@@ -1,6 +1,25 @@
 const fs = require('fs');
 const path = require('path');
 const { NATIVE_PATHS } = require('../../config/paths');
+const { resolveModelMetadata } = require('../../config/model-metadata');
+
+/**
+ * 根据模型 ID 查找 limit（context + output）
+ * 委托给集中式 model-metadata.js
+ */
+function resolveModelLimit(modelId) {
+  const meta = resolveModelMetadata(modelId);
+  return meta ? meta.limit : null;
+}
+
+/**
+ * 根据模型 ID 查找定价信息
+ * 委托给集中式 model-metadata.js
+ */
+function resolveModelCost(modelId) {
+  const meta = resolveModelMetadata(modelId);
+  return meta ? meta.pricing : null;
+}
 
 const CONFIG_DIR = NATIVE_PATHS.opencode.config;
 const CONFIG_PATHS = {
@@ -13,6 +32,7 @@ const EMPTY_SENTINEL = '__CC_TOOL_NO_FILE__';
 const PROXY_PROVIDER_ID = 'ctx-proxy';
 const LEGACY_PROVIDER_ID = 'openai';
 const PROXY_API_KEY = 'PROXY_KEY';
+const MANAGED_PROVIDER_MARKER = '__ctx_managed__';
 
 function ensureConfigDir() {
   if (!fs.existsSync(CONFIG_DIR)) {
@@ -106,18 +126,28 @@ function writeConfig(filePath, config) {
   fs.writeFileSync(filePath, content, 'utf8');
 }
 
-function normalizeOpenCodeModel(modelId) {
+function normalizeOpenCodeModel(modelId, providerId) {
   const normalized = String(modelId || '').trim();
   if (!normalized) {
     return '';
   }
 
-  // OpenCode 要求格式为 provider/model。这里统一绑定到 ctx-proxy provider，
-  // 避免落到内置 openai provider 的模型清单。
-  if (normalized.startsWith(`${PROXY_PROVIDER_ID}/`)) {
+  const pid = String(providerId || PROXY_PROVIDER_ID).trim() || PROXY_PROVIDER_ID;
+
+  // Already has a provider/ prefix - keep as-is only if it matches the expected provider
+  if (normalized.includes('/')) {
     return normalized;
   }
-  return `${PROXY_PROVIDER_ID}/${normalized}`;
+  return `${pid}/${normalized}`;
+}
+
+function sanitizeProviderKey(name) {
+  return String(name || '')
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '')
+    || 'channel';
 }
 
 function isLocalProxyBaseUrl(url) {
@@ -141,8 +171,16 @@ function isManagedProxyProvider(provider) {
 
 function isManagedProxyConfig(config) {
   if (!config || typeof config !== 'object') return false;
-  return isManagedProxyProvider(config?.provider?.[PROXY_PROVIDER_ID])
-    || isLegacyProxyProvider(config?.provider?.[LEGACY_PROVIDER_ID]);
+  // Check legacy single-provider format
+  if (isManagedProxyProvider(config?.provider?.[PROXY_PROVIDER_ID])
+    || isLegacyProxyProvider(config?.provider?.[LEGACY_PROVIDER_ID])) {
+    return true;
+  }
+  // Check per-channel provider format (any provider with PROXY_API_KEY + local baseURL)
+  if (config?.provider && typeof config.provider === 'object') {
+    return Object.values(config.provider).some(p => isManagedProxyProvider(p));
+  }
+  return false;
 }
 
 function buildModelsMap(models = [], fallbackModel = '') {
@@ -156,7 +194,28 @@ function buildModelsMap(models = [], fallbackModel = '') {
     const key = trimmed.toLowerCase();
     if (seen.has(key)) return;
     seen.add(key);
-    map[trimmed] = { name: trimmed };
+
+    const entry = { name: trimmed };
+
+    // 注入 limit（context + output），供 OpenCode 显示 "X% used"
+    // OpenCode schema 要求 limit 必须同时包含 context 和 output
+    const limit = resolveModelLimit(trimmed);
+    if (limit) {
+      entry.limit = { context: limit.context, output: limit.output };
+    }
+
+    // 注入定价信息，供 OpenCode 计算 cost
+    const pricing = resolveModelCost(trimmed);
+    if (pricing) {
+      entry.cost = {
+        input: pricing.input,
+        output: pricing.output,
+        cache_read: pricing.cacheRead,
+        cache_write: pricing.cacheCreation
+      };
+    }
+
+    map[trimmed] = entry;
   };
 
   if (Array.isArray(models)) {
@@ -168,9 +227,21 @@ function buildModelsMap(models = [], fallbackModel = '') {
 }
 
 function resolveProxyBaseUrl(config) {
-  return config?.provider?.[PROXY_PROVIDER_ID]?.options?.baseURL
-    || config?.provider?.[LEGACY_PROVIDER_ID]?.options?.baseURL
-    || '';
+  if (config?.provider?.[PROXY_PROVIDER_ID]?.options?.baseURL) {
+    return config.provider[PROXY_PROVIDER_ID].options.baseURL;
+  }
+  if (config?.provider?.[LEGACY_PROVIDER_ID]?.options?.baseURL) {
+    return config.provider[LEGACY_PROVIDER_ID].options.baseURL;
+  }
+  // Check per-channel managed providers
+  if (config?.provider && typeof config.provider === 'object') {
+    for (const p of Object.values(config.provider)) {
+      if (isManagedProxyProvider(p) && p?.options?.baseURL) {
+        return p.options.baseURL;
+      }
+    }
+  }
+  return '';
 }
 
 function backupConfig(filePath) {
@@ -257,38 +328,98 @@ function setProxyConfig(proxyPort, options = {}) {
   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;
   }
 
-  const modelsMap = buildModelsMap(options.models, options.model);
-  const modelIds = Object.keys(modelsMap);
-
-  if (modelIds.length > 0) {
-    next.provider[PROXY_PROVIDER_ID] = {
-      npm: '@ai-sdk/openai-compatible',
-      name: 'CTX Proxy',
-      options: {
-        baseURL: `http://127.0.0.1:${proxyPort}/v1`,
-        apiKey: PROXY_API_KEY
-      },
-      models: modelsMap
-    };
+  // Remove old single ctx-proxy provider (superseded by per-channel providers)
+  delete next.provider[PROXY_PROVIDER_ID];
+
+  // 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];
+    }
+  });
+
+  const channels = Array.isArray(options.channels) ? options.channels : null;
+
+  if (channels && channels.length > 0) {
+    // Per-channel mode: write one provider entry per channel
+    const usedKeys = new Set();
+    let firstProviderId = null;
+    let firstModelId = null;
+
+    channels.forEach((ch) => {
+      const rawKey = sanitizeProviderKey(ch.providerKey || ch.name || '');
+      // Ensure uniqueness
+      let key = rawKey;
+      let suffix = 2;
+      while (usedKeys.has(key)) {
+        key = `${rawKey}-${suffix}`;
+        suffix += 1;
+      }
+      usedKeys.add(key);
+
+      const modelsMap = buildModelsMap(ch.models, ch.model);
+      const modelIds = Object.keys(modelsMap);
+
+      if (modelIds.length > 0) {
+        next.provider[key] = {
+          npm: '@ai-sdk/openai-compatible',
+          name: ch.name || key,
+          options: {
+            baseURL: `http://127.0.0.1:${proxyPort}/v1`,
+            apiKey: PROXY_API_KEY
+          },
+          models: modelsMap
+        };
+
+        if (firstProviderId === null) {
+          firstProviderId = key;
+          firstModelId = ch.model || modelIds[0] || null;
+        }
+      }
+    });
+
+    // Write top-level model pointing to first channel's first model
+    const topModel = options.model || (firstProviderId && firstModelId
+      ? `${firstProviderId}/${firstModelId}`
+      : null);
+    if (topModel) {
+      const resolved = normalizeOpenCodeModel(topModel, firstProviderId || PROXY_PROVIDER_ID);
+      if (resolved) {
+        next.model = resolved;
+      }
+    } else if (isOldManagedModelRef(next.model)) {
+      delete next.model;
+    }
   } else {
-    // 无模型时不暴露 provider，避免出现误导性的 provider.openai/provider 列表。
-    delete next.provider[PROXY_PROVIDER_ID];
-  }
+    // Fallback: legacy flat-model mode (single ctx-proxy provider)
+    const modelsMap = buildModelsMap(options.models, options.model);
+    const modelIds = Object.keys(modelsMap);
+
+    if (modelIds.length > 0) {
+      next.provider[PROXY_PROVIDER_ID] = {
+        npm: '@ai-sdk/openai-compatible',
+        name: 'CTX Proxy',
+        options: {
+          baseURL: `http://127.0.0.1:${proxyPort}/v1`,
+          apiKey: PROXY_API_KEY
+        },
+        models: modelsMap
+      };
+    }
 
-  // 写入顶层 model（OpenCode 要求 provider/model 格式），无显式模型时兜底第一个模型。
-  const fallbackModel = options.model || modelIds[0] || '';
-  if (fallbackModel) {
-    const resolvedModel = normalizeOpenCodeModel(fallbackModel);
-    if (resolvedModel) {
-      next.model = resolvedModel;
+    const fallbackModel = options.model || modelIds[0] || '';
+    if (fallbackModel) {
+      const resolvedModel = normalizeOpenCodeModel(fallbackModel, PROXY_PROVIDER_ID);
+      if (resolvedModel) {
+        next.model = resolvedModel;
+      }
+    } else if (isOldManagedModelRef(next.model)) {
+      delete next.model;
     }
-  } else if (String(next.model || '').startsWith(`${PROXY_PROVIDER_ID}/`) || String(next.model || '').startsWith(`${LEGACY_PROVIDER_ID}/`)) {
-    delete next.model;
   }
 
   writeConfig(filePath, next);
@@ -296,6 +427,11 @@ function setProxyConfig(proxyPort, options = {}) {
   return { success: true, port: proxyPort, path: filePath };
 }
 
+function isOldManagedModelRef(modelRef) {
+  const s = String(modelRef || '');
+  return s.startsWith(`${PROXY_PROVIDER_ID}/`) || s.startsWith(`${LEGACY_PROVIDER_ID}/`);
+}
+
 function restoreSettings() {
   const restored = [
     restoreConfig(CONFIG_PATHS.opencodec),

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

@@ -703,46 +703,55 @@ class PluginsService {
   getRepos() {
     const repos = [];
     const seenRepos = new Set();
+    const pushRepo = (repo) => {
+      if (!repo || !repo.owner || !repo.name) return;
+      const key = `${repo.owner}/${repo.name}`;
+      if (seenRepos.has(key)) return;
+      repos.push(repo);
+      seenRepos.add(key);
+    };
+    const parseRepoUrl = (url) => {
+      if (!url || typeof url !== 'string') return null;
+      const match = url.match(/github\.com\/([^\/]+)\/([^\/\.]+)/);
+      if (!match) return null;
+      return { owner: match[1], name: match[2], url };
+    };
 
     // 1. Load our own config
     const config = this.loadReposConfig();
     for (const repo of config.repos || []) {
-      const key = `${repo.owner}/${repo.name}`;
-      if (!seenRepos.has(key)) {
-        repos.push(repo);
-        seenRepos.add(key);
-      }
+      pushRepo(repo);
     }
 
     // 2. Load Claude Code's native marketplace config (Claude only)
     if (!this._isOpenCode() && fs.existsSync(CLAUDE_MARKETPLACES_FILE)) {
       try {
         const marketplaces = JSON.parse(fs.readFileSync(CLAUDE_MARKETPLACES_FILE, 'utf8'));
-
-        for (const [marketplaceName, marketplaceData] of Object.entries(marketplaces)) {
-          if (marketplaceData.source && marketplaceData.source.url) {
-            const url = marketplaceData.source.url;
-            const match = url.match(/github\.com\/([^\/]+)\/([^\/\.]+)/);
-
-            if (match) {
-              const [, owner, name] = match;
-              const key = `${owner}/${name}`;
-
-              if (!seenRepos.has(key)) {
-                repos.push({
-                  owner,
-                  name,
-                  url,
-                  branch: 'main', // Default branch
-                  enabled: true,
-                  source: 'claude-native',
-                  lastUpdated: marketplaceData.lastUpdated
-                });
-                seenRepos.add(key);
-              }
-            }
+        const entries = [];
+        if (Array.isArray(marketplaces)) {
+          entries.push(...marketplaces.map(item => ({ key: '', data: item })));
+        } else if (marketplaces && typeof marketplaces === 'object') {
+          entries.push(...Object.entries(marketplaces).map(([key, data]) => ({ key, data })));
+          if (Array.isArray(marketplaces.marketplaces)) {
+            entries.push(...marketplaces.marketplaces.map(item => ({ key: item?.name || '', data: item })));
           }
         }
+
+        for (const { key, data } of entries) {
+          const sourceUrl = data?.source?.url || data?.url || data?.repoUrl || data?.repository;
+          const parsed = parseRepoUrl(sourceUrl);
+          if (!parsed) continue;
+          pushRepo({
+            owner: parsed.owner,
+            name: parsed.name,
+            url: parsed.url,
+            branch: data?.source?.branch || data?.branch || 'main',
+            enabled: data?.enabled !== false,
+            source: 'claude-native',
+            marketplace: key || data?.name || '',
+            lastUpdated: data?.lastUpdated
+          });
+        }
       } catch (err) {
         console.error('[PluginsService] Failed to read known_marketplaces.json:', err.message);
       }

package/src/server/services/pty-manager.js

@@ -48,6 +48,14 @@ class PtyManager {
     }
   }
 
+  isDirectoryPath(candidate) {
+    try {
+      return fs.existsSync(candidate) && fs.statSync(candidate).isDirectory();
+    } catch (err) {
+      return false;
+    }
+  }
+
   resolveWorkingDirectory(cwd) {
     const fallback = os.homedir();
     if (typeof cwd !== 'string') {
@@ -69,28 +77,22 @@ class PtyManager {
     }
 
     // 先尝试直接使用（支持相对路径）
-    try {
-      if (fs.existsSync(normalized) && fs.statSync(normalized).isDirectory()) {
-        return path.isAbsolute(normalized) ? normalized : path.resolve(process.cwd(), normalized);
-      }
-    } catch (err) {
-      // 忽略错误，继续尝试其他候选路径
+    if (this.isDirectoryPath(normalized)) {
+      return path.isAbsolute(normalized) ? normalized : path.resolve(process.cwd(), normalized);
     }
 
     // 相对路径：优先按进程 cwd 解析，其次按用户 home 解析（用于 .codex 这类隐藏目录）
     if (!path.isAbsolute(normalized)) {
       const candidates = [
         path.resolve(process.cwd(), normalized),
+        path.resolve(process.cwd(), '..', normalized),
+        path.resolve(process.cwd(), '..', '..', normalized),
         path.resolve(os.homedir(), normalized)
       ];
 
       for (const candidate of candidates) {
-        try {
-          if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
-            return candidate;
-          }
-        } catch (err) {
-          // 忽略错误
+        if (this.isDirectoryPath(candidate)) {
+          return candidate;
         }
       }
     }
@@ -269,16 +271,18 @@ class PtyManager {
       console.log(`[PTY] Resolved cwd: ${originalCwd} -> ${cwd}`);
     }
 
-    try {
-      if (!fs.existsSync(cwd) || !fs.statSync(cwd).isDirectory()) {
+    if (!this.isDirectoryPath(cwd)) {
+      const fallbackCandidates = [process.cwd(), os.homedir()];
+      const fallbackCwd = fallbackCandidates.find((candidate) => this.isDirectoryPath(candidate));
+
+      if (fallbackCwd) {
+        console.warn(`[PTY] Working directory not found: ${cwd}, fallback to ${fallbackCwd}`);
+        cwd = fallbackCwd;
+      } else {
         const error = `Working directory not found: ${cwd}`;
         console.error('[PTY]', error);
         throw new Error(error);
       }
-    } catch (err) {
-      const error = `Working directory not found: ${cwd}`;
-      console.error('[PTY]', error);
-      throw new Error(error);
     }
 
     console.log(`[PTY] Creating terminal: shell=${shell}, cwd=${cwd}`);

package/src/server/services/response-decoder.js

@@ -0,0 +1,21 @@
+const zlib = require('zlib');
+
+function createDecodedStream(res) {
+  const encoding = String(res.headers['content-encoding'] || '').toLowerCase();
+
+  if (encoding.includes('gzip')) {
+    return res.pipe(zlib.createGunzip());
+  }
+  if (encoding.includes('deflate')) {
+    return res.pipe(zlib.createInflate());
+  }
+  if (encoding.includes('br') && typeof zlib.createBrotliDecompress === 'function') {
+    return res.pipe(zlib.createBrotliDecompress());
+  }
+
+  return res;
+}
+
+module.exports = {
+  createDecodedStream
+};

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

@@ -15,9 +15,6 @@ const { pipeline } = require('stream/promises');
 const AdmZip = require('adm-zip');
 const {
   parseSkillContent,
-  detectSkillFormat,
-  convertSkillToCodex,
-  convertSkillToClaude
 } = require('./format-converter');
 const { NATIVE_PATHS } = require('../../config/paths');
 
@@ -705,25 +702,6 @@ class SkillService {
     return this.validateOpenCodeSkillMetadata(metadata, directory);
   }
 
-  /**
-   * 转换技能格式
-   * @param {string} content - 技能内容
-   * @param {string} targetFormat - 目标格式 ('claude' | 'codex')
-   */
-  convertSkillFormat(content, targetFormat) {
-    const sourceFormat = detectSkillFormat(content);
-
-    if (sourceFormat === targetFormat) {
-      return { content, warnings: [], format: targetFormat };
-    }
-
-    if (targetFormat === 'codex') {
-      return convertSkillToCodex(content);
-    } else {
-      return convertSkillToClaude(content);
-    }
-  }
-
   /**
    * 检查技能是否已安装
    */
@@ -880,9 +858,7 @@ class SkillService {
       fs.mkdirSync(dest, { recursive: true });
       this.copyDirRecursive(sourceDir, dest);
 
-      if (this.platform === 'codex') {
-        this.convertInstalledSkillToCodex(dest);
-      } else if (this.platform === 'opencode') {
+      if (this.platform === 'opencode') {
         const skillMdPath = path.join(dest, 'SKILL.md');
         if (fs.existsSync(skillMdPath)) {
           const validationError = this.validateOpenCodeSkillContent(
@@ -976,22 +952,6 @@ class SkillService {
     }
   }
 
-  /**
-   * 将安装后的 SKILL.md 转换为 Codex 兼容格式
-   */
-  convertInstalledSkillToCodex(skillDir) {
-    const skillMdPath = path.join(skillDir, 'SKILL.md');
-    if (!fs.existsSync(skillMdPath)) return;
-
-    try {
-      const content = fs.readFileSync(skillMdPath, 'utf-8');
-      const converted = convertSkillToCodex(content);
-      fs.writeFileSync(skillMdPath, converted.content, 'utf-8');
-    } catch (err) {
-      console.warn('[SkillService] Convert skill to codex format failed:', err.message);
-    }
-  }
-
   /**
    * 创建自定义技能
    */
@@ -1051,10 +1011,6 @@ ${content}
     // 写入文件
     fs.writeFileSync(path.join(dest, 'SKILL.md'), skillMdContent, 'utf-8');
 
-    if (this.platform === 'codex') {
-      this.convertInstalledSkillToCodex(dest);
-    }
-
     // 清除缓存，让列表刷新
     this.skillsCache = null;
     this.cacheTime = 0;
@@ -1122,10 +1078,6 @@ ${content}
       }
     }
 
-    if (this.platform === 'codex') {
-      this.convertInstalledSkillToCodex(dest);
-    }
-
     // 清除缓存
     this.skillsCache = null;
     this.cacheTime = 0;

package/src/server/services/speed-test.js

@@ -12,6 +12,7 @@ const { getEffectiveApiKey: getClaudeEffectiveApiKey } = require('./channels');
 const { getEffectiveApiKey: getCodexEffectiveApiKey } = require('./codex-channels');
 const { getEffectiveApiKey: getGeminiEffectiveApiKey } = require('./gemini-channels');
 const { getEffectiveApiKey: getOpenCodeEffectiveApiKey } = require('./opencode-channels');
+const { getDefaultSpeedTestModelByToolType } = require('../../config/model-metadata');
 
 // 测试结果缓存
 const testResultsCache = new Map();
@@ -87,6 +88,21 @@ function resolveExplicitModel(channel, model) {
   );
 }
 
+function resolveToolTypeForSpeedTest(channelType, channel) {
+  if (channelType === 'claude' || channelType === 'codex' || channelType === 'gemini') {
+    return channelType;
+  }
+  const gatewaySourceType = normalizeNonEmptyString(channel?.gatewaySourceType);
+  if (gatewaySourceType === 'claude' || gatewaySourceType === 'codex' || gatewaySourceType === 'gemini') {
+    return gatewaySourceType;
+  }
+  return 'codex';
+}
+
+function getConfiguredDefaultSpeedTestModel(toolType) {
+  return normalizeNonEmptyString(getDefaultSpeedTestModelByToolType(toolType));
+}
+
 function resolveEffectiveApiKey(channel, channelType) {
   switch (channelType) {
     case 'codex':
@@ -441,6 +457,21 @@ async function testAPIFunctionality(baseUrl, apiKey, timeout, channelType = 'cla
       };
       console.log(`[SpeedTest] Using explicit model: ${explicitModel}`);
     } else {
+      const defaultSpeedTestModel = getConfiguredDefaultSpeedTestModel(
+        resolveToolTypeForSpeedTest(channelType, channel)
+      );
+      if (defaultSpeedTestModel) {
+        modelProbe = {
+          preferredTestModel: defaultSpeedTestModel,
+          availableModels: [defaultSpeedTestModel],
+          cached: false,
+          method: 'default_config'
+        };
+        console.log(`[SpeedTest] Using default speedTestModel from config: ${defaultSpeedTestModel}`);
+      }
+    }
+
+    if (!modelProbe) {
       // Fall back to auto-detection
       try {
         modelProbe = await probeModelAvailability(channel, channelType, { stopOnFirstAvailable: true });
@@ -512,7 +543,9 @@ async function testAPIFunctionality(baseUrl, apiKey, timeout, channelType = 'cla
     }
     apiPath += '?beta=true';
 
-    testModel = modelProbe?.preferredTestModel || normalizeNonEmptyString(model) || 'claude-sonnet-4-20250514';
+    testModel = modelProbe?.preferredTestModel
+      || normalizeNonEmptyString(model)
+      || getConfiguredDefaultSpeedTestModel('claude');
     const sessionId = Math.random().toString(36).substring(2, 15);
     primaryRequestConfig = {
       apiPath,
@@ -550,7 +583,9 @@ async function testAPIFunctionality(baseUrl, apiKey, timeout, channelType = 'cla
     };
   } else if (channelType === 'codex') {
     const apiPath = buildCodexResponsesPath(parsedUrl);
-    testModel = modelProbe?.preferredTestModel || normalizeNonEmptyString(model) || 'gpt-5-codex';
+    testModel = modelProbe?.preferredTestModel
+      || normalizeNonEmptyString(model)
+      || getConfiguredDefaultSpeedTestModel('codex');
     const codexSessionId = `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
 
     const baseBody = {
@@ -588,7 +623,9 @@ async function testAPIFunctionality(baseUrl, apiKey, timeout, channelType = 'cla
       isStreamingResponse: true
     };
   } else if (channelType === 'gemini') {
-    testModel = modelProbe?.preferredTestModel || normalizeNonEmptyString(model) || 'gemini-2.5-pro';
+    testModel = modelProbe?.preferredTestModel
+      || normalizeNonEmptyString(model)
+      || getConfiguredDefaultSpeedTestModel('gemini');
     const useCliFormat = shouldUseGeminiCliFormat(parsedUrl);
 
     const cliRequestConfig = {