coding-tool-x 3.8.4 → 3.8.6

package/src/{server/services/omp-skill-settings-service.js → platforms/drivers/omp/skill-settings.js}

@@ -1,7 +1,7 @@
 const {
   readOmpSettingsStrict,
   writeOmpSettingsAtomic
-} = require('./omp-config');
+} = require('./config');
 
 const OMP_SKILL_SETTING_DEFAULTS = Object.freeze({
   enableCodexUser: true,

package/src/{server/services/omp-statistics-service.js → platforms/drivers/omp/statistics-implementation.js}

@@ -3,8 +3,8 @@ const {
   getStatistics: getSharedStatistics,
   getDailyStatistics: getSharedDailyStatistics,
   getTodayStatistics: getSharedTodayStatistics
-} = require('./statistics-service');
-const { normalizeUsageTokens, toNumber } = require('./proxy-log-helper');
+} = require('../../../server/services/statistics-service');
+const { normalizeUsageTokens, toNumber } = require('../../../server/services/usage-log-utils');
 
 const TOOL_TYPE = 'omp';
 
@@ -174,7 +174,7 @@ function addSessionUsage(entry, session) {
 
 function readSessionUsage() {
   try {
-    const { getAllSessions } = require('./omp-sessions');
+    const { getAllSessions } = require('./sessions-implementation');
     const sessions = getAllSessions();
     return Array.isArray(sessions) ? sessions : [];
   } catch {

package/src/platforms/drivers/omp/statistics.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const { createCapabilityDriver } = require('../../../shared/capability-driver');
+
+function createDriver(context = {}) {
+  return createCapabilityDriver({
+    ...context,
+    platform: 'omp',
+    capability: 'statistics',
+    servicePath: './omp/statistics-implementation',
+    localServicePath: '../platforms/drivers/omp/statistics-implementation',
+    methods: {"getStatistics":"getStatistics","getDailyStatistics":"getDailyStatistics","getTodayStatistics":"getTodayStatistics","recordRequest":"recordRequest","resetStatistics":"resetStatistics"}
+  });
+}
+
+module.exports = { createDriver };

package/src/platforms/drivers/opencode/api-operations.js

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

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

@@ -1,26 +1,36 @@
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
-const { PATHS } = require('../../config/paths');
-const { resolveChannelWebsiteUrl } = require('../../config/channel-preset-websites');
+const { PATHS } = require('../../../config/paths');
+const { resolveChannelWebsiteUrl } = require('../../../config/channel-preset-websites');
 const {
   setChannelConfig,
   clearManagedChannelConfig,
   readConfig,
   selectConfigPath
-} = require('./opencode-settings-manager');
-const { normalizeGatewaySourceType } = require('./base/proxy-utils');
+} = require('./native-config-implementation');
+const { normalizeGatewaySourceType } = require('../../../shared/proxy-utils');
 const {
   createSkippedResult,
   isLocalProxyBaseUrl,
   resolveApiKeyValue,
   resolveExistingActiveChannel,
   upsertSyncedChannels
-} = require('./channel-sync-utils');
+} = require('../../../server/services/channel-sync-utils');
+
+let configuredState = { channels: PATHS.channels.opencode };
+
+function configure({ pathContext } = {}) {
+  configuredState = {
+    channels: pathContext?.customized
+      ? (pathContext.state?.channels || PATHS.channels?.opencode)
+      : PATHS.channels?.opencode
+  };
+}
 
 function clearChannelBalanceCache(channel) {
   try {
-    require('./channel-balance').clearChannelBalanceCache('opencode', channel);
+    require('../../../server/services/channel-balance').clearChannelBalanceCache('opencode', channel);
   } catch (_) {
     // Balance cache invalidation is best-effort and should not block channel updates.
   }
@@ -60,11 +70,11 @@ function normalizeChannelName(value) {
 
 // 获取渠道存储文件路径
 function getChannelsFilePath() {
-  const channelsDir = path.dirname(PATHS.channels.opencode);
+  const channelsDir = path.dirname(configuredState.channels);
   if (!fs.existsSync(channelsDir)) {
     fs.mkdirSync(channelsDir, { recursive: true });
   }
-  return PATHS.channels.opencode;
+  return configuredState.channels;
 }
 
 function getCodexChannelsFilePath() {
@@ -132,7 +142,7 @@ function sanitizeOpenCodeProviderId(value) {
 }
 
 function getOpenCodeProxyRunning() {
-  const { getOpenCodeProxyStatus } = require('../opencode-proxy-server');
+  const { getOpenCodeProxyStatus } = require('./proxy-implementation');
   return Boolean(getOpenCodeProxyStatus()?.running);
 }
 
@@ -155,10 +165,18 @@ function syncManagedChannelConfig(channels = [], preferredChannel = null) {
   return null;
 }
 
+// 保存渠道数据
+function invalidateDashboardSource() {
+  try {
+    require('../../../server/services/snapshot-cache').invalidateDashboardSourceSnapshot('opencode');
+  } catch (_) {}
+}
+
 // 保存渠道数据
 function saveChannels(data) {
   const filePath = getChannelsFilePath();
   fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf8');
+  invalidateDashboardSource();
 }
 
 // 获取所有渠道
@@ -631,6 +649,7 @@ function syncCurrentOpenCodeChannel() {
 }
 
 module.exports = {
+  configure,
   getChannels,
   createChannel,
   updateChannel,

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

@@ -0,0 +1,40 @@
+'use strict';
+
+const { createChannelDriver } = require('../../../shared/channel-driver');
+
+function createDriver(context = {}) {
+  return createChannelDriver({
+    ...context,
+    platform: 'opencode',
+    servicePath: './opencode/channels-implementation',
+    localServicePath: '../opencode/channels-implementation',
+    syncMethod: 'syncCurrentOpenCodeChannel',
+    createArgs: (input, rest) => typeof input === 'object'
+      ? (() => {
+        const { name, baseUrl, apiKey, extra, ...channelExtra } = input;
+        return [name, baseUrl, apiKey, { ...channelExtra, ...extra }];
+      })()
+      : [input, ...rest],
+    cliMetadata: {
+      supportsCliCreate: true,
+      supportsCliToggle: true,
+      defaultPort: 20091,
+      createQuestions: [
+        {
+          type: 'input',
+          name: 'wireApi',
+          message: 'Wire API (默认: openai):',
+          default: 'openai'
+        },
+        {
+          type: 'input',
+          name: 'model',
+          message: '默认模型（可选，直接回车跳过）:'
+        }
+      ]
+    },
+    dashboardChannelShape: 'array'
+  });
+}
+
+module.exports = { createDriver };

package/src/platforms/drivers/opencode/conversion.js

@@ -0,0 +1,41 @@
+'use strict';
+
+function createDriver(context = {}) {
+  const converter = require('./gateway-converter');
+  return {
+    platform: context.platform,
+    capability: 'conversion',
+    formats() {
+      return {
+        sourceTypes: converter.SUPPORTED_SOURCE_TYPES,
+        formats: converter.SUPPORTED_SOURCE_TYPES.map(type => ({
+          id: type,
+          name: type === 'claude' ? 'Claude Code' : type === 'codex' ? 'Codex' : 'Gemini'
+        })),
+        targetApis: converter.SUPPORTED_TARGET_APIS,
+        defaultTargetApi: 'responses',
+        endpoints: {
+          responses: '/v1/responses',
+          'chat.completions': '/v1/chat/completions'
+        }
+      };
+    },
+    getFormats() {
+      return this.formats();
+    },
+    normalizeSourceType: converter.normalizeSourceType,
+    convertSource(sourceType, payload, options = {}) {
+      const handlers = {
+        claude: converter.convertClaudeToOpenCodePayload,
+        codex: converter.convertCodexToOpenCodePayload,
+        gemini: converter.convertGeminiToOpenCodePayload
+      };
+      return (handlers[sourceType] || converter.convertToOpenCodePayload)({ sourceType, payload, options });
+    },
+    convert({ sourceType, payload, options = {} } = {}) {
+      return converter.convertToOpenCodePayload({ sourceType, payload, options });
+    }
+  };
+}
+
+module.exports = { createDriver };

package/src/{server/services/opencode-gateway-converter.js → platforms/drivers/opencode/gateway-converter.js}

@@ -11,7 +11,7 @@
  * - OpenAI Chat Completions API (/v1/chat/completions)
  */
 
-const { ensureOpenAiStreamUsage } = require('./base/proxy-utils');
+const { ensureOpenAiStreamUsage } = require('../../../shared/proxy-utils');
 
 const SUPPORTED_SOURCE_TYPES = ['claude', 'codex', 'gemini'];
 const SUPPORTED_TARGET_APIS = ['responses', 'chat.completions'];

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

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

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

@@ -1,7 +1,8 @@
 const fs = require('fs');
 const path = require('path');
-const { NATIVE_PATHS } = require('../../config/paths');
-const { resolveModelMetadata } = require('../../config/model-metadata');
+const { NATIVE_PATHS } = require('../../../config/paths');
+const { resolveModelMetadata } = require('../../../config/model-metadata');
+const { resolveModelPricing } = require('../../../server/utils/pricing');
 
 /**
  * 根据模型 ID 查找 limit（context + output）
@@ -14,19 +15,28 @@ function resolveModelLimit(modelId) {
 
 /**
  * 根据模型 ID 查找定价信息
- * 委托给集中式 model-metadata.js
+ * 委托给集中式定价解析器（modelMetadataOverrides -> model-metadata.json）
  */
 function resolveModelCost(modelId) {
-  const meta = resolveModelMetadata(modelId);
-  return meta ? meta.pricing : null;
+  const pricing = resolveModelPricing('opencode', modelId);
+  return Object.keys(pricing).length > 0 ? pricing : null;
 }
 
-const CONFIG_DIR = NATIVE_PATHS.opencode.config;
+let CONFIG_DIR = NATIVE_PATHS.opencode.config;
 const CONFIG_PATHS = {
   config: path.join(CONFIG_DIR, 'config.json'),
   opencode: path.join(CONFIG_DIR, 'opencode.json'),
   opencodec: path.join(CONFIG_DIR, 'opencode.jsonc')
 };
+
+function configure({ pathContext } = {}) {
+  const configuredDir = pathContext?.customized ? pathContext.native?.config : null;
+  if (!configuredDir) return;
+  CONFIG_DIR = configuredDir;
+  CONFIG_PATHS.config = path.join(CONFIG_DIR, 'config.json');
+  CONFIG_PATHS.opencode = path.join(CONFIG_DIR, 'opencode.json');
+  CONFIG_PATHS.opencodec = path.join(CONFIG_DIR, 'opencode.jsonc');
+}
 const BACKUP_SUFFIX = '.cc-tool-backup';
 const EMPTY_SENTINEL = '__CC_TOOL_NO_FILE__';
 const PROXY_PROVIDER_ID = 'ctx-proxy';
@@ -631,6 +641,7 @@ function getCurrentProxyPort() {
 }
 
 module.exports = {
+  configure,
   configExists,
   hasBackup,
   readConfig,

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

@@ -0,0 +1,26 @@
+'use strict';
+
+const implementation = require('./native-config-implementation');
+const { createNativeSnapshotMethods } = require('../native-config-snapshot');
+
+function createDriver({ requireImpl, ...context } = {}) {
+  const settings = requireImpl
+    ? requireImpl('./opencode/native-config-implementation')
+    : implementation;
+  settings.configure?.({ pathContext: context.pathContext });
+  const configPaths = settings.CONFIG_PATHS || {};
+  const snapshotMethods = createNativeSnapshotMethods({
+    opencodeJsonc: { path: configPaths.opencodec, format: 'text' },
+    opencodeJson: { path: configPaths.opencode, format: 'text' },
+    configJson: { path: configPaths.config, format: 'text' }
+  }, { platform: 'opencode', runtime: context.runtime });
+  return {
+    platform: 'opencode',
+    capability: 'nativeConfig',
+    ...context,
+    ...settings,
+    ...snapshotMethods,
+  };
+}
+
+module.exports = { createDriver };

package/src/platforms/drivers/opencode/native-logs.js

@@ -0,0 +1,133 @@
+'use strict';
+
+const fs = require('fs');
+const crypto = require('crypto');
+const { DatabaseSync } = require('node:sqlite');
+const { NATIVE_PATHS } = require('../../../config/paths');
+const { normalizeCost, normalizeUsage, hasUsage, subtractUsage } = require('../native-log-utils');
+const { calculateUsageCost } = require('../../../server/services/usage-log-utils');
+
+function getDatabasePath(fsImpl = fs, dataDir) {
+  const configured = typeof process.env.OPENCODE_DB_PATH === 'string' ? process.env.OPENCODE_DB_PATH.trim() : '';
+  if (configured && fsImpl.existsSync(configured)) return configured;
+  return require('./sessions-implementation').getOpenCodeDbPath
+    ? require('./sessions-implementation').getOpenCodeDbPath(dataDir)
+    : require('path').join(NATIVE_PATHS.opencode.data, 'opencode.db');
+}
+
+function parseJson(value) {
+  try { return JSON.parse(value); } catch (_) { return null; }
+}
+
+function usageSignature(event) {
+  return JSON.stringify({
+    provider: event.provider || '',
+    model: event.model || '',
+    tokens: event.tokens,
+    cost: event.cost || 0
+  });
+}
+
+function versionedId(id, signature) {
+  return `${id}:${crypto.createHash('sha1').update(signature).digest('hex').slice(0, 12)}`;
+}
+
+function* readUsageRows(db) {
+  const rows = db.prepare(`
+    SELECT p.id, p.session_id, p.message_id, p.time_created, p.time_updated, p.data,
+           m.data AS message_data
+    FROM part p
+    LEFT JOIN message m ON m.id = p.message_id
+    ORDER BY p.time_created ASC
+  `).iterate();
+
+  for (const row of rows) {
+    const part = parseJson(row.data);
+    const message = parseJson(row.message_data) || {};
+    const usage = part?.tokens || part?.usage || (part?.type === 'step-finish' ? part : null);
+    if (!usage || !hasUsage(usage)) continue;
+    yield {
+      id: `opencode:${row.session_id}:${row.id}`,
+      source: 'opencode',
+      sessionId: row.session_id,
+      timestamp: row.time_updated || row.time_created,
+      provider: part.provider || part.providerID || message.provider || message.providerID || message.model?.providerID || '',
+      model: part.model || part.modelID || message.model || message.modelID || message.model?.modelID || '',
+      tokens: normalizeUsage(usage),
+      cost: normalizeCost(part.cost ?? usage.cost)
+        || calculateUsageCost('opencode', part.model || part.modelID || message.model || message.modelID || '', normalizeUsage(usage))
+    };
+  }
+}
+
+function createDriver({ fsImpl = fs, pathContext } = {}) {
+  const dataDir = pathContext?.customized ? pathContext.native?.data : undefined;
+  if (pathContext?.customized) {
+    require('./sessions-implementation').configure?.({ pathContext });
+  }
+  return {
+    platform: 'opencode',
+    capability: 'nativeLogs',
+    createNativeLogCursor({ fs: cursorFs = fsImpl, onDiagnostic } = {}) {
+      let rowState = new Map();
+      let initialized = false;
+
+      const read = () => {
+        const dbPath = getDatabasePath(cursorFs, dataDir);
+        const stats = { files: 0, bytesRead: 0, parsedRecords: 0, maxLineLength: 0 };
+        if (!dbPath || !cursorFs.existsSync(dbPath)) {
+          try { onDiagnostic?.(stats); } catch (_) {}
+          return [];
+        }
+        stats.files = 1;
+        try { stats.bytesRead = cursorFs.statSync(dbPath).size; } catch (_) {}
+        let db;
+        try {
+          db = new DatabaseSync(dbPath, { readOnly: true, timeout: 1000 });
+          const events = [];
+          for (const event of readUsageRows(db)) {
+            stats.parsedRecords += 1;
+            const signature = usageSignature(event);
+            const previous = rowState.get(event.id);
+            if (!previous) {
+              rowState.set(event.id, { signature, tokens: event.tokens });
+              if (initialized) events.push(event);
+              continue;
+            }
+            if (previous.signature === signature) continue;
+
+            const delta = subtractUsage(event.tokens, previous.tokens);
+            rowState.set(event.id, { signature, tokens: event.tokens });
+            if (initialized && hasUsage(delta)) {
+              events.push({
+                ...event,
+                id: versionedId(event.id, signature),
+                tokens: delta,
+                cost: calculateUsageCost('opencode', event.model, delta)
+              });
+            }
+          }
+          initialized = true;
+          try { onDiagnostic?.({ ...stats, initialized }); } catch (_) {}
+          return events;
+        } catch (_) {
+          try { onDiagnostic?.({ ...stats, parseErrors: 1, initialized }); } catch (_) {}
+          return [];
+        } finally {
+          try { db?.close(); } catch (_) {}
+        }
+      };
+
+      return {
+        initialize() { read(); },
+        readNewEvents: read,
+        read,
+        reset() { rowState = new Map(); initialized = false; },
+        close() { rowState.clear(); initialized = false; }
+      };
+    },
+    createCursor(options) { return this.createNativeLogCursor(options); }
+  };
+}
+
+module.exports = { createDriver };

package/src/platforms/drivers/opencode/project-config.js

@@ -0,0 +1,98 @@
+'use strict';
+
+const mcpFormat = require('../../../shared/mcp-format');
+const {
+  createProjectAdapter,
+  readJsonFile,
+  writeJsonFileAtomic,
+  redactSecrets,
+  validateMcpId,
+  mergeMcpPatch
+} = require('../../../shared/project-config');
+
+function getOpenCodeServers(projectRoot, relativePath, fsImpl) {
+  const config = readJsonFile(projectRoot, relativePath, {}, fsImpl);
+  if (!config || typeof config !== 'object' || Array.isArray(config)) return {};
+
+  if (config.mcp && typeof config.mcp === 'object' && !Array.isArray(config.mcp)) {
+    if (config.mcp.servers && typeof config.mcp.servers === 'object' && !Array.isArray(config.mcp.servers)) {
+      return { config, servers: config.mcp.servers, nested: true };
+    }
+    return { config, servers: config.mcp, nested: false };
+  }
+
+  config.mcp = {};
+  return { config, servers: config.mcp, nested: false };
+}
+
+function createAdapter({ manifest, fsImpl } = {}) {
+  const relativePath = manifest?.projectResources?.mcp?.path;
+  const format = manifest?.projectResources?.mcp?.format || 'opencode-json';
+
+  function readProjectMcp(projectRoot) {
+    const { servers } = getOpenCodeServers(projectRoot, relativePath, fsImpl);
+    return {
+      supported: true,
+      path: relativePath,
+      format,
+      servers: Object.entries(servers).map(([id, nativeSpec]) => ({
+        id,
+        scope: 'project',
+        server: redactSecrets(mcpFormat.convertFromOpenCodeFormat(nativeSpec)),
+        enabled: nativeSpec?.enabled !== false
+      }))
+    };
+  }
+
+  function readProjectMcpSpec(projectRoot, id) {
+    const { servers } = getOpenCodeServers(projectRoot, relativePath, fsImpl);
+    if (!Object.prototype.hasOwnProperty.call(servers, id)) return null;
+    return mcpFormat.convertFromOpenCodeFormat(servers[id]);
+  }
+
+  function upsertProjectMcp(projectRoot, id, spec) {
+    const normalizedId = validateMcpId(id);
+    const { config, servers, nested } = getOpenCodeServers(projectRoot, relativePath, fsImpl);
+    const existing = servers[normalizedId] && typeof servers[normalizedId] === 'object' ? servers[normalizedId] : {};
+    const existingCanonical = mcpFormat.convertFromOpenCodeFormat(existing);
+    const mergedNative = mergeMcpPatch(
+      existingCanonical,
+      spec,
+      value => value,
+      mcpFormat.convertToOpenCodeFormat
+    );
+    servers[normalizedId] = mergedNative;
+    if (nested) config.mcp.servers = servers;
+    writeJsonFileAtomic(projectRoot, relativePath, config, fsImpl);
+    return {
+      success: true,
+      supported: true,
+      path: relativePath,
+      format,
+      id: normalizedId,
+      scope: 'project',
+      server: redactSecrets(mcpFormat.convertFromOpenCodeFormat(servers[normalizedId])),
+      enabled: servers[normalizedId].enabled !== false
+    };
+  }
+
+  function removeProjectMcp(projectRoot, id) {
+    const normalizedId = validateMcpId(id);
+    const { config, servers, nested } = getOpenCodeServers(projectRoot, relativePath, fsImpl);
+    const removed = Object.prototype.hasOwnProperty.call(servers, normalizedId);
+    if (removed) {
+      delete servers[normalizedId];
+      if (nested) config.mcp.servers = servers;
+      writeJsonFileAtomic(projectRoot, relativePath, config, fsImpl);
+    }
+    return { success: true, supported: true, path: relativePath, format, id: normalizedId, scope: 'project', removed };
+  }
+
+  return createProjectAdapter({
+    manifest,
+    fsImpl,
+    mcpHandlers: { readProjectMcp, readProjectMcpSpec, upsertProjectMcp, removeProjectMcp }
+  });
+}
+
+module.exports = { createAdapter };

package/src/platforms/drivers/opencode/projects.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const { createProjectsDriver } = require('../../../shared/driver-factories/projects');
+
+function createDriver(context = {}) {
+  return createProjectsDriver({
+    ...context,
+    platform: 'opencode',
+    servicePath: './opencode/sessions-implementation',
+    localServicePath: '../../platforms/drivers/opencode/sessions-implementation',
+    availabilityMethod: 'isOpenCodeInstalled',
+    onSuccess: operation => {
+      if (['saveProjectOrder', 'createProject', 'deleteProject'].includes(operation)) {
+        context.sessionHistoryIndex?.invalidateSource('opencode');
+      }
+    }
+  });
+}
+
+module.exports = { createDriver };

package/src/platforms/drivers/opencode/prompts.js

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