coding-tool-x 3.8.4 → 3.8.6

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

@@ -1,30 +1,55 @@
 const fs = require('fs');
 const path = require('path');
-const BaseChannelService = require('./base/base-channel-service');
-const { isProxyConfig } = require('./settings-manager');
-const { PATHS, NATIVE_PATHS } = require('../../config/paths');
-const { clearNativeOAuth } = require('./native-oauth-adapters');
-const { isWindowsLikePlatform } = require('../../utils/home-dir');
-const { normalizeGatewaySourceType } = require('./base/proxy-utils');
+const BaseChannelService = require('../../../shared/base-channel-service');
+const { isProxyConfig } = require('./native-config-implementation');
+const { PATHS, NATIVE_PATHS } = require('../../../config/paths');
+const { clearNativeOAuth, readNativeOAuth, clearClaudeChannelConfig } = require('../../native-oauth-adapters');
+const { isWindowsLikePlatform } = require('../../../utils/home-dir');
+const { normalizeGatewaySourceType } = require('../../../shared/proxy-utils');
 const {
   createSkippedResult,
   isLocalProxyBaseUrl,
   resolveExistingActiveChannel,
   upsertSyncedChannels
-} = require('./channel-sync-utils');
+} = require('../../../server/services/channel-sync-utils');
+
+let configuredNative = NATIVE_PATHS.claude;
+let configuredState = {
+  channels: PATHS.channels?.claude,
+  activeChannel: PATHS.activeChannel?.claude
+    || path.join(path.dirname(PATHS.channels?.claude || 'active-channel.json'), 'active-channel.json')
+};
+
+function configure({ pathContext } = {}) {
+  const custom = pathContext?.customized === true;
+  configuredNative = custom && pathContext.native?.settings
+    ? { ...NATIVE_PATHS.claude, ...pathContext.native }
+    : NATIVE_PATHS.claude;
+  configuredState = {
+    channels: custom ? (pathContext.state?.channels || PATHS.channels?.claude) : PATHS.channels?.claude,
+    activeChannel: custom
+      ? (pathContext.state?.activeChannel || PATHS.activeChannel?.claude)
+      : PATHS.activeChannel?.claude
+  };
+  if (!configuredState.activeChannel) {
+    configuredState.activeChannel = path.join(path.dirname(configuredState.channels || 'active-channel.json'), 'active-channel.json');
+  }
+  require('../../native-oauth-adapters').configure?.({ pathContext });
+  if (service) service.channelsFilePath = configuredState.channels;
+}
 
 // ── Claude 特有工具函数 ──
 
 function getActiveChannelIdPath() {
-  const dir = path.dirname(PATHS.activeChannel.claude);
+  const dir = path.dirname(configuredState.activeChannel);
   if (!fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true });
   }
-  return PATHS.activeChannel.claude;
+  return configuredState.activeChannel;
 }
 
 function getClaudeSettingsPath() {
-  return NATIVE_PATHS.claude.settings;
+  return configuredNative.settings;
 }
 
 function saveActiveChannelId(channelId) {
@@ -129,6 +154,63 @@ function updateClaudeSettingsWithModelConfig(channel) {
   fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
 }
 
+function createClaudeOAuthError(message, code, statusCode) {
+  const error = new Error(message);
+  error.code = code;
+  error.statusCode = statusCode;
+  return error;
+}
+
+function isClaudeProxyRunning() {
+  if (isProxyConfig()) {
+    return true;
+  }
+  try {
+    return require('./proxy-implementation').getProxyStatus().running === true;
+  } catch {
+    return false;
+  }
+}
+
+
+function assertClaudeOAuthIsNativeOnly() {
+  if (isClaudeProxyRunning()) {
+    throw createClaudeOAuthError(
+      'Claude OAuth channels are native-only',
+      'claude_oauth_proxy_unsupported',
+      409
+    );
+  }
+}
+
+function assertNativeClaudeOAuthAvailable() {
+  if (!readNativeOAuth('claude')) {
+    throw createClaudeOAuthError(
+      'Claude native OAuth credential is unavailable',
+      'claude_oauth_credential_unavailable',
+      422
+    );
+  }
+}
+
+function applyNativeClaudeOAuth() {
+  assertClaudeOAuthIsNativeOnly();
+  assertNativeClaudeOAuthAvailable();
+  clearClaudeChannelConfig();
+}
+
+function validateClaudeOAuthMutation(channel, operation) {
+  if (channel?.authMode !== 'oauth') {
+    return;
+  }
+  if (operation !== 'apply' && channel.enabled === false) {
+    return;
+  }
+  assertClaudeOAuthIsNativeOnly();
+  assertNativeClaudeOAuthAvailable();
+}
+
+
 function updateClaudeSettings(baseUrl, apiKey) {
   const settingsPath = getClaudeSettingsPath();
   fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
@@ -194,15 +276,21 @@ class ClaudeChannelService extends BaseChannelService {
   constructor() {
     super({
       platform: 'claude',
-      channelsFilePath: PATHS.channels.claude,
+      channelsFilePath: configuredState.channels,
       defaultGatewaySource: 'claude',
-      isProxyRunning: () => isProxyConfig(),
+      isProxyRunning: () => isClaudeProxyRunning(),
+      oauthChannelPolicy: 'single-enabled',
     });
     // Claude 特有：文件监听缓存
     this._cache = null;
     this._cacheInitialized = false;
+    this._watchRegistered = false;
+  }
+  _validateBeforeChannelMutation(channel, _allChannels, context = {}) {
+    validateClaudeOAuthMutation(channel, context.operation);
   }
 
+
   _generateId() {
     return `channel-${Date.now()}`;
   }
@@ -221,25 +309,21 @@ class ClaudeChannelService extends BaseChannelService {
     return normalized;
   }
 
-  // Claude 使用缓存 + fs.watchFile
   loadChannels() {
-    if (this._cacheInitialized && this._cache) {
-      return { channels: this._cache.channels.map(ch => this._applyDefaults(ch)) };
-    }
-
     const data = super.loadChannels();
     this._cache = data;
     this._cacheInitialized = true;
 
-    // 设置文件监听
-    try {
-      fs.watchFile(this.channelsFilePath, { interval: 2000 }, () => {
-        try {
+    if (!this._watchRegistered) {
+      try {
+        fs.watchFile(this.channelsFilePath, { interval: 2000 }, () => {
+          this.invalidate();
           this._cache = null;
           this._cacheInitialized = false;
-        } catch (_) {}
-      });
-    } catch (_) {}
+        });
+        this._watchRegistered = true;
+      } catch (_) {}
+    }
 
     return data;
   }
@@ -251,13 +335,13 @@ class ClaudeChannelService extends BaseChannelService {
   }
 
   _onAfterCreate(channel, _allChannels) {
-    if (!isProxyConfig() && channel.enabled !== false && !isOpenAiCompatibleGateway(channel)) {
+    if (!isClaudeProxyRunning() && channel.enabled !== false && !isOpenAiCompatibleGateway(channel)) {
       this._applyToNativeSettings(channel);
     }
   }
 
   _onAfterUpdate(oldChannel, nextChannel, allChannels) {
-    if (isProxyConfig()) {
+    if (isClaudeProxyRunning()) {
       return;
     }
 
@@ -279,7 +363,7 @@ class ClaudeChannelService extends BaseChannelService {
   }
 
   _onAfterDelete(_channel, allChannels) {
-    if (isProxyConfig()) {
+    if (isClaudeProxyRunning()) {
       return;
     }
 
@@ -301,11 +385,14 @@ class ClaudeChannelService extends BaseChannelService {
       error.statusCode = 400;
       throw error;
     }
-
     return super.applyChannelToSettings(channelId);
   }
 
   _applyToNativeSettings(channel) {
+    if (channel.authMode === 'oauth') {
+      applyNativeClaudeOAuth(channel);
+      return;
+    }
     updateClaudeSettingsWithModelConfig(channel);
   }
 
@@ -318,13 +405,22 @@ class ClaudeChannelService extends BaseChannelService {
 
 const service = new ClaudeChannelService();
 
+
+function getClaudeProxyExcludedChannelIds(channels = null) {
+  const candidates = Array.isArray(channels) ? channels : service.getEnabledChannels();
+  return [...new Set(
+    candidates
+      .filter(channel => channel?.enabled !== false && channel?.authMode === 'oauth')
+      .map(channel => channel.id)
+      .filter(Boolean)
+  )];
+}
 function getAllChannels() {
   const data = service.loadChannels();
   return data.channels;
 }
 
-function getCurrentChannel() {
-  const channels = getAllChannels();
+function getCurrentChannel(channels = getAllChannels()) {
   const activeId = loadActiveChannelId();
   if (activeId) {
     const active = channels.find(ch => ch.id === activeId);
@@ -333,8 +429,8 @@ function getCurrentChannel() {
   return channels.find(ch => ch.enabled !== false) || channels[0] || null;
 }
 
-function getCurrentSettings() {
-  const channel = getCurrentChannel();
+function getCurrentSettings(channels) {
+  const channel = getCurrentChannel(channels);
   if (!channel) return null;
   return {
     baseUrl: channel.baseUrl,
@@ -358,7 +454,7 @@ function readClaudeNativeSettings() {
 
 function readClaudeNativeOAuth() {
   try {
-    const adapters = require('./native-oauth-adapters');
+    const adapters = require('../../native-oauth-adapters');
     return typeof adapters.readNativeOAuth === 'function'
       ? adapters.readNativeOAuth('claude')
       : null;
@@ -498,11 +594,13 @@ function disableAllChannels() {
 }
 
 module.exports = {
+  configure,
   getAllChannels,
   getCurrentChannel,
   getCurrentSettings,
   createChannel,
   updateChannel,
+  getClaudeProxyExcludedChannelIds,
   markChannelAsRecentlyUsed,
   deleteChannel,
   applyChannelToSettings,

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

@@ -0,0 +1,39 @@
+'use strict';
+
+const { createChannelDriver } = require('../../../shared/channel-driver');
+
+function createDriver(context = {}) {
+  const driver = createChannelDriver({
+    ...context,
+    platform: 'claude',
+    servicePath: './claude/channels-implementation',
+    localServicePath: '../platforms/drivers/claude/channels-implementation',
+    listMethod: 'getAllChannels',
+    syncMethod: 'syncCurrentClaudeChannel',
+    createArgs: (input, rest) => typeof input === 'object'
+      ? (() => {
+        const { name, baseUrl, apiKey, websiteUrl, extra, ...channelExtra } = input;
+        return [name, baseUrl, apiKey, websiteUrl, { ...channelExtra, ...extra }];
+      })()
+      : [input, ...rest],
+    cliMetadata: { supportsCliCreate: true, supportsCliToggle: true, defaultPort: 20088 },
+    dashboardChannelShape: 'array'
+  });
+  const callLegacy = (name, args) => driver._service()[name](...args);
+  const auth = require('../../channel-auth-service');
+  driver.getAuth = context => auth.getChannelAuth('claude', { channelId: context?.params?.channelId || context?.query?.channelId || '' });
+  driver.syncLocalAuth = context => auth.syncLocalChannelAuth('claude', { channelId: context?.body?.channelId || context?.params?.channelId || context?.query?.channelId || '' });
+  driver.getAuthQuota = context => auth.fetchChannelAuthQuota('claude', context?.params?.channelId, { refresh: context?.query?.refresh === 'true' });
+  for (const name of [
+    'getAllChannels', 'getCurrentChannel', 'getCurrentSettings', 'createChannel',
+    'updateChannel', 'markChannelAsRecentlyUsed', 'deleteChannel',
+    'applyChannelToSettings', 'getBestChannelForRestore', 'updateClaudeSettings',
+    'updateClaudeSettingsWithModelConfig', 'extractApiKeyFromHelper',
+    'syncCurrentClaudeChannel'
+  ]) {
+    driver[name] = (...args) => callLegacy(name, args);
+  }
+  return driver;
+}
+
+module.exports = { createDriver };

package/src/{server/services/config-sync-service.js → platforms/drivers/claude/config-sync.js}

@@ -15,7 +15,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { HOME_DIR, NATIVE_PATHS } = require('../../config/paths');
+const { HOME_DIR, NATIVE_PATHS } = require('../../../config/paths');
 
 // 全局配置目录
 const GLOBAL_CONFIG_DIR = NATIVE_PATHS.claude.dir
@@ -76,11 +76,35 @@ function copyDirRecursive(src, dest) {
  * 配置同步服务类
  */
 class ConfigSyncService {
-    constructor() {
+    constructor({ registry = null } = {}) {
+        this.registry = registry;
         this.globalConfigDir = GLOBAL_CONFIG_DIR;
+        this.globalConfigDirs = {
+            skills: path.join(this.globalConfigDir, CONFIG_TYPES.skills.globalDir),
+            agents: path.join(this.globalConfigDir, CONFIG_TYPES.agents.globalDir),
+            commands: path.join(this.globalConfigDir, CONFIG_TYPES.commands.globalDir)
+        };
+
+        try {
+            const pathContext = this.registry?.resolvePathContext?.('claude');
+            if (pathContext?.customized) {
+                this.globalConfigDir = pathContext.native?.dir || this.globalConfigDir;
+                this.globalConfigDirs = {
+                    skills: pathContext.native?.skills || path.join(this.globalConfigDir, CONFIG_TYPES.skills.globalDir),
+                    agents: pathContext.native?.agents || path.join(this.globalConfigDir, CONFIG_TYPES.agents.globalDir),
+                    commands: pathContext.native?.commands || path.join(this.globalConfigDir, CONFIG_TYPES.commands.globalDir)
+                };
+            }
+        } catch (_) {
+            // Keep legacy defaults when an injected registry cannot resolve paths.
+        }
         ensureDir(this.globalConfigDir);
     }
 
+    _getGlobalConfigDir(type) {
+        return this.globalConfigDirs[type] || path.join(this.globalConfigDir, CONFIG_TYPES[type]?.globalDir || type);
+    }
+
     /**
      * 获取可用的配置项列表
      * @param {string} source - 'global' 或 'workspace'
@@ -98,7 +122,7 @@ class ConfigSyncService {
             let dir;
 
             if (source === 'global') {
-                dir = path.join(this.globalConfigDir, config.globalDir);
+                dir = this._getGlobalConfigDir(type);
             } else if (source === 'workspace' && projectPath) {
                 if (!config.projectDir) {
                     // skills 不支持项目级
@@ -363,7 +387,7 @@ class ConfigSyncService {
         let baseDir;
 
         if (target === 'global') {
-            baseDir = path.join(this.globalConfigDir, config.globalDir);
+            baseDir = this._getGlobalConfigDir(type);
         } else {
             baseDir = path.join(projectPath, '.claude', config.projectDir);
         }
@@ -463,7 +487,7 @@ class ConfigSyncService {
         let baseDir;
 
         if (source === 'global') {
-            baseDir = path.join(this.globalConfigDir, config.globalDir);
+            baseDir = this._getGlobalConfigDir(type);
         } else {
             baseDir = path.join(projectPath, '.claude', config.projectDir);
         }

package/src/{server/services → platforms/drivers/claude}/health-check.js

@@ -47,8 +47,8 @@ function ensureProjectClaudeDir(projectPath) {
  * @param {Array} projects - 项目列表
  * @returns {Object} 汇总结果
  */
-function healthCheckAllProjects(projects) {
-  const results = [];
+function healthCheckAllProjects(projects, { includeResults = true } = {}) {
+  const results = includeResults ? [] : null;
   let checkedCount = 0;
   let createdCount = 0;
   let errorCount = 0;
@@ -57,7 +57,7 @@ function healthCheckAllProjects(projects) {
     if (!project.fullPath) continue;
 
     const result = ensureProjectClaudeDir(project.fullPath);
-    results.push(result);
+    if (results) results.push(result);
     checkedCount++;
 
     if (result.created) {
@@ -75,7 +75,7 @@ function healthCheckAllProjects(projects) {
       errors: errorCount,
       healthy: checkedCount - errorCount
     },
-    results
+    ...(results ? { results } : {})
   };
 }
 

package/src/platforms/drivers/claude/health.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const { healthCheckAllProjects } = require('./health-check');
+
+function createDriver(context = {}) {
+  return {
+    platform: context.platform,
+    capability: 'health',
+    async healthCheck({ detail = true } = {}) {
+      const projects = context.sessionHistoryIndex
+        ? await context.sessionHistoryIndex.listProjects(context.platform, { consistency: 'stale-ok' })
+        : [];
+      return {
+        success: true,
+        timestamp: new Date().toISOString(),
+        ...healthCheckAllProjects(projects, { includeResults: detail })
+      };
+    }
+  };
+}
+
+module.exports = { createDriver };

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

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

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

@@ -1,6 +1,14 @@
 const fs = require('fs');
-const { NATIVE_PATHS } = require('../../config/paths');
-const { isWindowsLikePlatform } = require('../../utils/home-dir');
+const { NATIVE_PATHS } = require('../../../config/paths');
+const { isWindowsLikePlatform } = require('../../../utils/home-dir');
+const DEFAULT_NATIVE_PATHS = NATIVE_PATHS.claude;
+let nativePaths = DEFAULT_NATIVE_PATHS;
+
+function configure({ pathContext } = {}) {
+  nativePaths = pathContext?.customized && pathContext.native?.settings
+    ? { ...DEFAULT_NATIVE_PATHS, ...pathContext.native }
+    : DEFAULT_NATIVE_PATHS;
+}
 
 function buildEchoCommand(value) {
   if (isWindowsLikePlatform(process.platform, process.env)) {
@@ -11,12 +19,12 @@ function buildEchoCommand(value) {
 
 // Claude Code 配置文件路径
 function getSettingsPath() {
-  return NATIVE_PATHS.claude.settings;
+  return nativePaths.settings;
 }
 
 // 备份文件路径
 function getBackupPath() {
-  return NATIVE_PATHS.claude.settingsBackup;
+  return nativePaths.settingsBackup;
 }
 
 // 检查配置文件是否存在
@@ -168,6 +176,7 @@ function getCurrentProxyPort() {
 }
 
 module.exports = {
+  configure,
   getSettingsPath,
   getBackupPath,
   settingsExists,

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

@@ -0,0 +1,46 @@
+'use strict';
+
+const fs = require('fs');
+const implementation = require('./native-config-implementation');
+const { PATHS } = require('../../../config/paths');
+const { createNativeSnapshotMethods } = require('../native-config-snapshot');
+
+function createDriver({ requireImpl, ...context } = {}) {
+  const configuredPaths = context.pathContext?.native;
+  const currentNativePaths = context.pathContext?.customized && configuredPaths?.settings
+    ? configuredPaths
+    : require('../../../config/paths').NATIVE_PATHS.claude;
+  const settings = requireImpl
+    ? requireImpl('./claude/native-config-implementation')
+    : implementation;
+  settings.configure?.({ pathContext: context.pathContext });
+  const snapshotMethods = createNativeSnapshotMethods({
+    settings: { path: currentNativePaths.settings, format: 'json' }
+  }, { platform: 'claude', runtime: context.runtime });
+  return {
+    platform: 'claude',
+    capability: 'nativeConfig',
+    ...context,
+    ...settings,
+    ...snapshotMethods,
+    clearNativeOAuth: () => {
+      const adapters = require('../../native-oauth-adapters');
+      adapters.configure?.(context);
+      return adapters.clearNativeOAuth('claude');
+    },
+    preserveNativeOAuthOnProxyStart: true,
+    restoreNativeSettingsOnProxyStop: true,
+    clearActiveChannelMarker() {
+      try {
+        const markerPath = context.pathContext?.customized
+          ? (context.pathContext.state?.activeChannel || PATHS.activeChannel.claude)
+          : PATHS.activeChannel.claude;
+        fs.unlinkSync(markerPath);
+      } catch (error) {
+        if (error.code !== 'ENOENT') throw error;
+      }
+    }
+  };
+}
+
+module.exports = { createDriver };

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

@@ -0,0 +1,72 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { NATIVE_PATHS } = require('../../../config/paths');
+const {
+  normalizeUsage,
+  normalizeCost,
+  usageFieldPaths,
+  createSelectiveJsonLineParser,
+  walkFiles,
+  createIncrementalJsonlCursor
+} = require('../native-log-utils');
+const { calculateUsageCost } = require('../../../server/services/usage-log-utils');
+
+const CLAUDE_SELECTED_FIELDS = [
+  'type', 'role', 'uuid', 'id', 'model', 'timestamp', 'provider', 'cost', 'channelId', 'channel',
+  'message.role', 'message.id', 'message.uuid', 'message.model', 'message.timestamp',
+  'message.provider', 'message.cost', 'message.channelId', 'message.channel',
+  ...usageFieldPaths('usage'),
+  ...usageFieldPaths('message.usage')
+];
+
+function createDriver({ nativeRoot, pathContext, fsImpl = fs } = {}) {
+  const resolvedNativeRoot = pathContext?.customized
+    ? (pathContext.native?.projects || nativeRoot || NATIVE_PATHS.claude.projects)
+    : (nativeRoot || NATIVE_PATHS.claude.projects);
+  return {
+    platform: 'claude',
+    capability: 'nativeLogs',
+    createNativeLogCursor({ fs: cursorFs = fsImpl, skipInitialParse = false, onDiagnostic } = {}) {
+      const scanFiles = () => walkFiles(resolvedNativeRoot, name => name.endsWith('.jsonl') && !name.startsWith('agent-'), cursorFs);
+      const parseLine = (filePath, record) => {
+        const message = record.message && typeof record.message === 'object' ? record.message : {};
+        const role = record.role || message.role || (record.type === 'assistant' ? 'assistant' : null);
+        if (role !== 'assistant') return null;
+        const usage = record.usage || message.usage;
+        const messageId = record.uuid || record.id || message.id;
+        if (!usage || typeof usage !== 'object' || !messageId) return null;
+        const tokens = normalizeUsage(usage);
+        const model = record.model || message.model || '';
+        return {
+          id: `${path.basename(filePath)}:${messageId}`,
+          source: 'claude',
+          sessionId: path.basename(filePath, '.jsonl'),
+          timestamp: record.timestamp || message.timestamp,
+          provider: record.provider || message.provider || '',
+          model,
+          tokens,
+          cost: normalizeCost(record.cost ?? message.cost ?? usage.cost)
+            || calculateUsageCost('claude', model, tokens),
+          channelId: record.channelId || message.channelId,
+          channel: record.channel || message.channel
+        };
+      };
+      return createIncrementalJsonlCursor({
+        scanFiles,
+        parseLine,
+        fsImpl: cursorFs,
+        skipInitialParse,
+        createLongLineParser: () => createSelectiveJsonLineParser(CLAUDE_SELECTED_FIELDS),
+        onDiagnostic,
+        onError: (error, filePath) => {
+          console.warn('[Claude Native Logs] Failed to read changed usage events:', filePath, error.message);
+        }
+      });
+    },
+    createCursor(options) { return this.createNativeLogCursor(options); }
+  };
+}
+
+module.exports = { createDriver };