coding-tool-x 3.8.4 → 3.8.5

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

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

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

@@ -5,7 +5,7 @@ const crypto = require('crypto');
 const {
   normalizeOpenCodeMessages,
   normalizeStopSequences
-} = require('./opencode-normalization');
+} = require('../opencode/normalization');
 
 // ---------------------------------------------------------------------------
 // Constants

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

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

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

@@ -3,18 +3,34 @@ const path = require('path');
 const crypto = require('crypto');
 const toml = require('toml');
 const tomlStringify = require('@iarna/toml').stringify;
-const { PATHS } = require('../../config/paths');
-const { getCodexDir } = require('./codex-config');
-const { isProxyConfig, readConfig } = require('./codex-settings-manager');
-const { syncCodexUserEnvironment } = require('./codex-env-manager');
-const BaseChannelService = require('./base/base-channel-service');
+const { PATHS } = require('../../../config/paths');
+const { getCodexDir } = require('./config');
+const { isProxyConfig, readConfig } = require('./native-config-implementation');
+const { syncCodexUserEnvironment } = require('./env-manager');
+const {
+  readNativeOAuth,
+  clearCodexChannelConfig
+} = require('../../native-oauth-adapters');
+const BaseChannelService = require('../../../shared/base-channel-service');
 const {
   createSkippedResult,
   isLocalProxyBaseUrl,
   resolveApiKeyValue,
   resolveExistingActiveChannel,
   upsertSyncedChannels
-} = require('./channel-sync-utils');
+} = require('../../../server/services/channel-sync-utils');
+
+let configuredState = { channels: PATHS.channels.codex };
+
+function configure({ pathContext } = {}) {
+  configuredState = {
+    channels: pathContext?.customized
+      ? (pathContext.state?.channels || PATHS.channels?.codex)
+      : PATHS.channels?.codex
+  };
+  require('../../native-oauth-adapters').configure?.({ pathContext });
+  if (service) service.channelsFilePath = configuredState.channels;
+}
 
 const CODEX_MANAGED_ENV_KEY = 'CC_PROXY_KEY';
 const CODEX_PROXY_ENV_VALUE = 'PROXY_KEY';
@@ -32,7 +48,9 @@ function resolveCurrentManagedChannel(channels = []) {
   }
 
   if (currentProvider && currentProvider !== 'cc-proxy') {
-    const matched = allChannels.find(ch => ch.providerKey === currentProvider);
+    const matched = allChannels.find(ch => (
+      ch.providerKey === currentProvider && ch.enabled !== false
+    ));
     if (matched) {
       return matched;
     }
@@ -41,8 +59,71 @@ function resolveCurrentManagedChannel(channels = []) {
   return allChannels.find(ch => ch.enabled !== false) || null;
 }
 
-function channelRequiresOpenaiAuth() {
-  return false;
+function channelRequiresOpenaiAuth(channel) {
+  return channel?.authMode === 'oauth';
+}
+
+function createCodexOAuthError(message, code, statusCode) {
+  const error = new Error(message);
+  error.code = code;
+  error.statusCode = statusCode;
+  return error;
+}
+
+function readNativeCodexOAuthOrThrow() {
+  const credential = readNativeOAuth('codex');
+  if (!credential) {
+    throw createCodexOAuthError(
+      'Codex native OAuth credential is unavailable; sync local OAuth first',
+      'codex_native_oauth_unavailable',
+      422
+    );
+  }
+  return credential;
+}
+
+function assertCodexOAuthIsNativeOnly() {
+  if (isProxyConfig()) {
+    throw createCodexOAuthError(
+      'Codex OAuth channels are native-only; stop the Codex proxy first',
+      'codex_oauth_proxy_unsupported',
+      409
+    );
+  }
+}
+
+function clearManagedCodexConfig() {
+  clearCodexChannelConfig();
+  delete process.env.CC_PROXY_KEY;
+}
+
+function applyNativeOAuthChannel(channel) {
+  assertCodexOAuthIsNativeOnly();
+  readNativeCodexOAuthOrThrow();
+  clearManagedCodexConfig();
+  console.log(`[Codex Channels] Applied native OAuth channel ${channel.name}`);
+  return channel;
+}
+
+function validateCodexChannelForMutation(channel, operation) {
+  if (channel?.authMode !== 'oauth') {
+    return;
+  }
+  if (operation !== 'apply' && channel.enabled === false) {
+    return;
+  }
+  assertCodexOAuthIsNativeOnly();
+  readNativeCodexOAuthOrThrow();
+}
+
+function getCodexProxyExcludedChannelIds(channels = null) {
+  const enabledChannels = Array.isArray(channels)
+    ? channels.filter(channel => channel?.enabled !== false)
+    : getServiceInstance().getEnabledChannels();
+  return enabledChannels
+    .filter(channel => channel?.authMode === 'oauth')
+    .map(channel => channel.id)
+    .filter(Boolean);
 }
 
 function buildManagedCodexEnvMap(channels = [], { includeProxyKey = false, activeChannel = null } = {}) {
@@ -62,9 +143,31 @@ function syncAllChannelEnvVars() {
     const svc = getServiceInstance();
     const data = svc.loadChannels();
     const proxyRunning = isProxyConfig();
+    const activeChannel = proxyRunning
+      ? null
+      : resolveCurrentManagedChannel(data.channels);
+
+    if (!proxyRunning && !activeChannel) {
+      clearManagedCodexConfig();
+      return;
+    }
+
+    if (!proxyRunning && activeChannel.authMode === 'oauth') {
+      try {
+        applyNativeOAuthChannel(activeChannel);
+      } catch (err) {
+        if (err.code !== 'codex_native_oauth_unavailable') {
+          throw err;
+        }
+        console.warn(`[Codex Channels] ${err.message}; cleared managed config`);
+        clearManagedCodexConfig();
+      }
+      return;
+    }
+
     const envMap = buildManagedCodexEnvMap(data.channels, {
       includeProxyKey: proxyRunning,
-      activeChannel: proxyRunning ? null : resolveCurrentManagedChannel(data.channels)
+      activeChannel
     });
     syncCodexUserEnvironment(envMap, { replace: true });
   } catch (err) {
@@ -108,6 +211,19 @@ function writeCodexConfigForMultiChannel(channels) {
   }
 
   const enabledChannels = channels.filter(ch => ch.enabled !== false);
+  const oauthChannels = enabledChannels.filter(ch => ch.authMode === 'oauth');
+  if (oauthChannels.length > 0) {
+    if (oauthChannels.length !== enabledChannels.length) {
+      throw createCodexOAuthError(
+        'Codex native OAuth cannot be mixed with managed API-key channels',
+        'codex_oauth_mixed_channels',
+        409
+      );
+    }
+    applyNativeOAuthChannel(oauthChannels[0]);
+    return;
+  }
+
   if (enabledChannels.length > 0) {
     const primary = enabledChannels[0];
     config.model_provider = primary.providerKey;
@@ -124,6 +240,9 @@ function writeCodexConfigForMultiChannel(channels) {
         config.model_providers[ch.providerKey].query_params = ch.queryParams;
       }
     }
+  } else {
+    clearManagedCodexConfig();
+    return;
   }
 
   writeAnnotatedCodexConfig(configPath, config, [
@@ -138,8 +257,9 @@ class CodexChannelService extends BaseChannelService {
   constructor() {
     super({
       platform: 'codex',
-      channelsFilePath: PATHS.channels.codex,
+      channelsFilePath: configuredState.channels,
       defaultGatewaySource: 'codex',
+      oauthChannelPolicy: 'single-enabled',
       isProxyRunning: () => isProxyConfig(),
     });
   }
@@ -151,16 +271,25 @@ class CodexChannelService extends BaseChannelService {
   _applyDefaults(channel) {
     const ch = super._applyDefaults(channel);
     ch.providerKey = ch.providerKey || '';
-    ch.envKey = CODEX_MANAGED_ENV_KEY;
+    ch.envKey = ch.authMode === 'oauth' ? '' : CODEX_MANAGED_ENV_KEY;
     ch.wireApi = ch.wireApi || 'responses';
     ch.model = ch.model || '';
     ch.speedTestModel = ch.speedTestModel || null;
     ch.modelRedirects = Array.isArray(ch.modelRedirects) ? ch.modelRedirects : [];
     ch.gatewaySourceType = ch.gatewaySourceType || 'codex';
-    ch.requiresOpenaiAuth = false;
+    ch.requiresOpenaiAuth = channelRequiresOpenaiAuth(ch);
     ch.queryParams = ch.queryParams || {};
     return ch;
   }
+  _validateBeforeChannelMutation(channel, _allChannels, context = {}) {
+    validateCodexChannelForMutation(channel, context.operation);
+  }
+
+  disableAllChannels() {
+    const result = super.disableAllChannels();
+    syncAllChannelEnvVars();
+    return result;
+  }
 
   _validateUniqueness(channels, fields, excludeId) {
     if (!fields.providerKey) return;
@@ -207,6 +336,9 @@ class CodexChannelService extends BaseChannelService {
   }
 
   _applyToNativeSettings(channel) {
+    if (channel.authMode === 'oauth') {
+      return applyNativeOAuthChannel(channel);
+    }
     const codexDir = getCodexDir();
     const configPath = path.join(codexDir, 'config.toml');
 
@@ -404,6 +536,7 @@ try {
 }
 
 module.exports = {
+  configure,
   getChannels,
   createChannel,
   updateChannel,
@@ -416,10 +549,12 @@ module.exports = {
   applyChannelToSettings,
   getEffectiveApiKey,
   disableAllChannels,
+  getCodexProxyExcludedChannelIds,
   syncCurrentCodexChannel,
   _test: {
     buildManagedCodexEnvMap,
     CODEX_MANAGED_ENV_KEY,
-    resolveCurrentManagedChannel
+    resolveCurrentManagedChannel,
+    getCodexProxyExcludedChannelIds
   }
 };

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

@@ -0,0 +1,45 @@
+'use strict';
+
+const { createChannelDriver } = require('../../../shared/channel-driver');
+
+function createDriver(context = {}) {
+  const driver = createChannelDriver({
+    ...context,
+    platform: 'codex',
+    servicePath: './codex/channels-implementation',
+    localServicePath: '../platforms/drivers/codex/channels-implementation',
+    syncMethod: 'syncCurrentCodexChannel',
+    createArgs: (input, rest) => typeof input === 'object'
+      ? (() => {
+        const { name, providerKey, baseUrl, apiKey, wireApi, extra, ...channelExtra } = input;
+        return [name, providerKey, baseUrl, apiKey, wireApi, { ...channelExtra, ...extra }];
+      })()
+      : [input, ...rest],
+    cliMetadata: { supportsCliCreate: true, supportsCliToggle: true, defaultPort: 20089, createDefaults: { wireApi: 'responses' } },
+    modelListType: 'openai_compatible',
+    formatCliChannelDetails: channel => channel.providerKey
+      ? [`provider ${channel.providerKey}`]
+      : []
+  });
+  const auth = require('../../channel-auth-service');
+  driver.getAuth = context => auth.getChannelAuth('codex', { channelId: context?.params?.channelId || context?.query?.channelId || '' });
+  driver.syncLocalAuth = context => auth.syncLocalChannelAuth('codex', { channelId: context?.body?.channelId || context?.params?.channelId || context?.query?.channelId || '' });
+  driver.getAuthQuota = context => auth.fetchChannelAuthQuota('codex', context?.params?.channelId, { refresh: context?.query?.refresh === 'true' });
+  const callLegacy = (name, args) => driver._service()[name](...args);
+  for (const name of [
+    'getChannels', 'getEnabledChannels', 'createChannel', 'updateChannel',
+    'markChannelAsRecentlyUsed', 'deleteChannel', 'saveChannelOrder',
+    'syncAllChannelEnvVars', 'writeCodexConfigForMultiChannel',
+    'applyChannelToSettings', 'syncCurrentCodexChannel'
+  ]) {
+    driver[name] = (...args) => callLegacy(name, args);
+  }
+  driver.writeMultiChannelConfig = channels => {
+    const service = driver._service();
+    return service.writeCodexConfigForMultiChannel(channels);
+  };
+  return driver;
+}
+
+module.exports = { createDriver };
+

package/src/{server/services/codex-config.js → platforms/drivers/codex/config.js}

@@ -1,13 +1,22 @@
 const fs = require('fs');
 const path = require('path');
 const toml = require('toml');
-const { NATIVE_PATHS } = require('../../config/paths');
+const { NATIVE_PATHS } = require('../../../config/paths');
+
+const DEFAULT_CODEX_DIR = NATIVE_PATHS.codex.dir;
+let codexDirOverride = null;
+
+function configure({ pathContext } = {}) {
+  codexDirOverride = pathContext?.customized
+    ? (pathContext.native?.dir || path.dirname(pathContext.native?.config || DEFAULT_CODEX_DIR))
+    : null;
+}
 
 /**
  * 获取 Codex 配置目录
  */
 function getCodexDir() {
-  return NATIVE_PATHS.codex.dir;
+  return codexDirOverride || DEFAULT_CODEX_DIR;
 }
 
 /**
@@ -82,6 +91,7 @@ function isCodexInstalled() {
 }
 
 module.exports = {
+  configure,
   getCodexDir,
   loadConfig,
   loadAuth,

package/src/{server/services/codex-env-manager.js → platforms/drivers/codex/env-manager.js}

@@ -1,7 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const { execFileSync } = require('child_process');
-const { PATHS, HOME_DIR } = require('../../config/paths');
+const { PATHS, HOME_DIR } = require('../../../config/paths');
 
 const PROFILE_MARKER_START = '# >>> coding-tool codex env >>>';
 const PROFILE_MARKER_END = '# <<< coding-tool codex env <<<';

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

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

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

@@ -2,25 +2,33 @@ const fs = require('fs');
 const path = require('path');
 const toml = require('toml');
 const tomlStringify = require('@iarna/toml').stringify;
-const { NATIVE_PATHS } = require('../../config/paths');
-const { syncCodexUserEnvironment } = require('./codex-env-manager');
+const { NATIVE_PATHS } = require('../../../config/paths');
+const { syncCodexUserEnvironment } = require('./env-manager');
+const DEFAULT_NATIVE_PATHS = NATIVE_PATHS.codex;
+let nativePaths = DEFAULT_NATIVE_PATHS;
+
+function configure({ pathContext } = {}) {
+  nativePaths = pathContext?.customized && pathContext.native?.config
+    ? { ...DEFAULT_NATIVE_PATHS, ...pathContext.native }
+    : DEFAULT_NATIVE_PATHS;
+}
 
 // Codex 配置文件路径
 function getConfigPath() {
-  return NATIVE_PATHS.codex.config;
+  return nativePaths.config;
 }
 
 function getAuthPath() {
-  return NATIVE_PATHS.codex.auth;
+  return nativePaths.auth;
 }
 
 // 备份文件路径
 function getConfigBackupPath() {
-  return NATIVE_PATHS.codex.configBackup;
+  return nativePaths.configBackup;
 }
 
 function getAuthBackupPath() {
-  return NATIVE_PATHS.codex.authBackup;
+  return nativePaths.authBackup;
 }
 
 // 检查配置文件是否存在
@@ -354,6 +362,7 @@ function getCurrentProxyPort() {
 }
 
 module.exports = {
+  configure,
   getConfigPath,
   getAuthPath,
   getConfigBackupPath,

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

@@ -0,0 +1,47 @@
+'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?.config
+    ? configuredPaths
+    : require('../../../config/paths').NATIVE_PATHS.codex;
+  const settings = requireImpl
+    ? requireImpl('./codex/native-config-implementation')
+    : implementation;
+  settings.configure?.({ pathContext: context.pathContext });
+  const snapshotMethods = createNativeSnapshotMethods({
+    config: { path: currentNativePaths.config, format: 'text' },
+    auth: { path: currentNativePaths.auth, format: 'json', mode: 0o600 }
+  }, { platform: 'codex', runtime: context.runtime });
+  return {
+    platform: 'codex',
+    capability: 'nativeConfig',
+    ...context,
+    ...settings,
+    ...snapshotMethods,
+    preserveNativeOAuthOnProxyStart: true,
+    restoreNativeSettingsOnProxyStop: true,
+    clearNativeOAuth: () => {
+      const adapters = require('../../native-oauth-adapters');
+      adapters.configure?.(context);
+      return adapters.clearNativeOAuth('codex');
+    },
+    clearActiveChannelMarker() {
+      try {
+        const markerPath = context.pathContext?.customized
+          ? (context.pathContext.state?.activeChannel || PATHS.activeChannel.codex)
+          : PATHS.activeChannel.codex;
+        fs.unlinkSync(markerPath);
+      } catch (error) {
+        if (error.code !== 'ENOENT') throw error;
+      }
+    }
+  };
+}
+
+module.exports = { createDriver };

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

@@ -0,0 +1,166 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { NATIVE_PATHS } = require('../../../config/paths');
+const {
+  normalizeCost,
+  normalizeUsage,
+  subtractUsage,
+  usageFieldPaths,
+  createSelectiveJsonLineParser,
+  visitJsonLinesForward,
+  visitJsonLinesReverse,
+  walkFiles,
+  createIncrementalJsonlCursor
+} = require('../native-log-utils');
+const { calculateUsageCost } = require('../../../server/services/usage-log-utils');
+
+const CODEX_SELECTED_FIELDS = [
+  'type',
+  'timestamp',
+  'payload.type',
+  'payload.id',
+  'payload.model_provider',
+  'payload.model',
+  'payload.info.cost.total',
+  'payload.info.cost.usd',
+  'payload.info.cost.amount',
+  ...usageFieldPaths('payload.info.total_token_usage')
+];
+
+function applyCodexRecord(state, record) {
+  if (record?.type === 'session_meta') {
+    state.sessionId = record.payload?.id || state.sessionId;
+    state.provider = record.payload?.model_provider || state.provider;
+    return;
+  }
+  if (record?.type === 'turn_context') {
+    state.model = record.payload?.model || state.model;
+    return;
+  }
+  if (record?.type !== 'event_msg' || record.payload?.type !== 'token_count') return;
+  const usage = record.payload?.info?.total_token_usage;
+  if (!usage || typeof usage !== 'object') return;
+  state.pendingUsage = normalizeUsage(usage);
+  state.pendingTimestamp = record.timestamp || state.pendingTimestamp;
+  state.pendingCost = normalizeCost(record.payload?.info?.cost ?? usage.cost);
+}
+
+function bootstrapCodexFile(filePath, state, stat, fsImpl, stats) {
+  const endOffset = stat.size;
+  state.sessionId = path.basename(filePath, '.jsonl');
+  state.provider = '';
+  state.model = '';
+  state.lastUsage = null;
+  state.pendingUsage = null;
+  state.pendingTimestamp = null;
+  state.pendingCost = 0;
+  visitJsonLinesForward(filePath, (record) => {
+    if (record?.type === 'session_meta') {
+      state.sessionId = record.payload?.id || state.sessionId;
+      state.provider = record.payload?.model_provider || state.provider;
+      return false;
+    }
+    return true;
+  }, {
+    fsImpl,
+    endOffset,
+    createLongLineParser: () => createSelectiveJsonLineParser(CODEX_SELECTED_FIELDS),
+    stats
+  });
+
+  let latestUsage = null;
+  let foundLatestModel = false;
+  visitJsonLinesReverse(filePath, (record) => {
+    if (record?.type === 'event_msg' && record.payload?.type === 'token_count' && !latestUsage) {
+      const usage = record.payload?.info?.total_token_usage;
+      if (usage && typeof usage === 'object') {
+        latestUsage = normalizeUsage(usage);
+        state.pendingTimestamp = record.timestamp || state.pendingTimestamp;
+        state.pendingCost = normalizeCost(record.payload?.info?.cost ?? usage.cost);
+      }
+    }
+    if (record?.type === 'turn_context' && !foundLatestModel) {
+      const model = record.payload?.model;
+      if (model) {
+        state.model = model;
+        foundLatestModel = true;
+      }
+    }
+    return !(latestUsage && foundLatestModel);
+  }, {
+    fsImpl,
+    endOffset,
+    includeTrailingLine: false,
+    createLongLineParser: () => createSelectiveJsonLineParser(CODEX_SELECTED_FIELDS),
+    stats
+  });
+  if (latestUsage) state.lastUsage = latestUsage;
+  state.pendingUsage = null;
+  return { ok: true };
+}
+
+function createDriver({ nativeRoot, pathContext, fsImpl = fs } = {}) {
+  const resolvedNativeRoot = pathContext?.customized
+    ? (pathContext.native?.sessions || nativeRoot || NATIVE_PATHS.codex.sessions)
+    : (nativeRoot || NATIVE_PATHS.codex.sessions);
+  return {
+    platform: 'codex',
+    capability: 'nativeLogs',
+    createNativeLogCursor({ fs: cursorFs = fsImpl, skipInitialParse = false, onDiagnostic } = {}) {
+      const scanFiles = () => walkFiles(resolvedNativeRoot, name => /^rollout-.*\.jsonl$/.test(name), cursorFs);
+      return createIncrementalJsonlCursor({
+        scanFiles,
+        fsImpl: cursorFs,
+        skipInitialParse,
+        createFileState: (filePath, _stat, previousState) => ({
+          sessionId: previousState?.sessionId || path.basename(filePath, '.jsonl'),
+          provider: previousState?.provider || '',
+          model: previousState?.model || '',
+          lastUsage: previousState?.lastUsage || null,
+          pendingUsage: null,
+          pendingTimestamp: null,
+          pendingCost: 0
+        }),
+        bootstrapFile: (filePath, state, stat, stats) => bootstrapCodexFile(filePath, state, stat, cursorFs, stats),
+        parseLine: (_filePath, record, state) => {
+          applyCodexRecord(state, record);
+          return null;
+        },
+        afterRead: (_filePath, state) => {
+          if (!state.pendingUsage) return null;
+          const current = state.pendingUsage;
+          const previous = state.lastUsage;
+          const restarted = previous && current.total < previous.total;
+          const tokens = previous && !restarted ? subtractUsage(current, previous) : current;
+          state.lastUsage = current;
+          state.pendingUsage = null;
+          if (tokens.total <= 0) return null;
+          const sessionId = state.sessionId || '';
+          const event = {
+            id: `${sessionId}:token-count:${current.total}`,
+            source: 'codex',
+            sessionId,
+            timestamp: state.pendingTimestamp,
+            provider: state.provider,
+            model: state.model,
+            tokens,
+            cost: state.pendingCost || calculateUsageCost('codex', state.model, tokens)
+          };
+          state.pendingTimestamp = null;
+          state.pendingCost = 0;
+          return event;
+        },
+        createLongLineParser: () => createSelectiveJsonLineParser(CODEX_SELECTED_FIELDS),
+        onDiagnostic,
+        onError: (error, filePath) => {
+          console.warn('[Codex Native Logs] Failed to read changed usage events:', filePath, error.message);
+        }
+      });
+    },
+    createCursor(options) { return this.createNativeLogCursor(options); }
+  };
+}
+
+module.exports = { createDriver };

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

@@ -0,0 +1,21 @@
+'use strict';
+
+const mcpFormat = require('../../../shared/mcp-format');
+const {
+  createProjectAdapter,
+  createTomlMcpHandlers
+} = require('../../../shared/project-config');
+
+function createAdapter({ manifest, fsImpl } = {}) {
+  const relativePath = manifest?.projectResources?.mcp?.path;
+  const mcpHandlers = createTomlMcpHandlers({
+    relativePath,
+    format: manifest?.projectResources?.mcp?.format || 'codex-toml',
+    toNative: mcpFormat.convertToCodexFormat,
+    fromNative: mcpFormat.convertFromCodexFormat,
+    fsImpl
+  });
+  return createProjectAdapter({ manifest, fsImpl, mcpHandlers });
+}
+
+module.exports = { createAdapter };