coding-tool-x 3.8.4 → 3.8.5

package/src/platforms/driver-registry.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const { createUnsupportedDriver } = require('./drivers/unsupported');
+const { createGenericJsonlDriver } = require('./drivers/generic-jsonl');
+const { createGenericFilesystemDriver } = require('./drivers/generic-filesystem');
+const { createGenericOpenAICompatibleDriver } = require('./drivers/generic-openai-compatible');
+const { createGenericMcpDriver } = require('./drivers/generic-mcp');
+const { createGenericPromptDriver } = require('./drivers/generic-prompt');
+const { registerLegacyDrivers } = require('./drivers/legacy');
+
+const DRIVER_ID_PATTERN = /^[a-z0-9:_-]+$/;
+
+function createDriverRegistry({ drivers = {} } = {}) {
+  const factories = new Map(Object.entries(drivers));
+
+  return {
+    register(id, factory) {
+      const driverId = String(id || '');
+      if (!DRIVER_ID_PATTERN.test(driverId) || typeof factory !== 'function') {
+        throw new Error(`Invalid capability driver: ${id}`);
+      }
+      factories.set(driverId, factory);
+    },
+    has(id) {
+      return factories.has(id);
+    },
+    create(id, context = {}) {
+      const factory = factories.get(id);
+      if (!factory) throw new Error(`Unknown capability driver: ${id}`);
+      return factory(context);
+    },
+    ids() {
+      return [...factories.keys()];
+    }
+  };
+}
+
+let defaultRegistry;
+
+function getDriverRegistry() {
+  if (!defaultRegistry) {
+    defaultRegistry = createDriverRegistry({
+      drivers: {
+        unsupported: createUnsupportedDriver,
+        'generic-jsonl': createGenericJsonlDriver,
+        'generic-filesystem': createGenericFilesystemDriver,
+        'generic-openai-compatible': createGenericOpenAICompatibleDriver,
+        'generic-mcp': createGenericMcpDriver,
+        'generic-prompt': createGenericPromptDriver,
+        'opencode-conversion': require('./drivers/opencode/conversion').createDriver,
+        'claude-health': require('./drivers/claude/health').createDriver
+      }
+    });
+    registerLegacyDrivers(defaultRegistry);
+  }
+  return defaultRegistry;
+}
+
+module.exports = { createDriverRegistry, getDriverRegistry };

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

@@ -0,0 +1,62 @@
+'use strict';
+
+const os = require('os');
+const { createApiOperationsDriver } = require('../../../shared/driver-factories/api');
+
+function getHooksDriver(runtime) {
+  const driver = runtime?.getDriver?.('claude', 'hooks');
+  if (!driver || typeof driver.getHooks !== 'function') {
+    throw new Error('Claude hooks capability is unavailable');
+  }
+  return driver;
+}
+
+function toLegacyHooksResponse(status) {
+  return {
+    success: true,
+    stopHook: {
+      enabled: status?.enabled === true,
+      type: status?.type === 'dialog' || status?.type === 'browser' ? status.type : 'notification'
+    },
+    platform: os.platform()
+  };
+}
+
+function createDriver(context = {}) {
+  const { healthCheckAllProjects } = require('./health-check');
+  return createApiOperationsDriver({
+    ...context,
+    platform: 'claude',
+    operationHandlers: {
+      getHooks: (_requestContext, { runtime }) => {
+        const hooks = getHooksDriver(runtime || context.runtime);
+        return toLegacyHooksResponse(hooks.getHooks());
+      },
+      saveHooks: async (requestContext, { runtime }) => {
+        const hooks = getHooksDriver(runtime || context.runtime);
+        await hooks.saveHooks(requestContext.body?.stopHook || {});
+        return {
+          ...toLegacyHooksResponse(hooks.getHooks()),
+          message: '配置已保存'
+        };
+      },
+      testHooks: async (requestContext, { runtime }) => {
+        const hooks = getHooksDriver(runtime || context.runtime);
+        await hooks.testHooks(requestContext.body || {});
+        return { success: true, message: '系统测试通知已发送' };
+      },
+      healthCheck: async (_requestContext, { sessionHistoryIndex }) => {
+        const projects = sessionHistoryIndex
+          ? await sessionHistoryIndex.listProjects('claude', { consistency: 'stale-ok' })
+          : [];
+        return {
+          success: true,
+          timestamp: new Date().toISOString(),
+          ...healthCheckAllProjects(projects, { includeResults: true })
+        };
+      }
+    }
+  });
+}
+
+module.exports = { createDriver };

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 };