coding-tool-x 3.8.9 → 3.9.0

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

@@ -83,17 +83,43 @@ function writeEntry(spec, entry, overwrite) {
   return 'success';
 }
 
-function createNativeSnapshotMethods(specs, { platform, runtime } = {}) {
+function resolveSnapshotPath(spec, { pathContext, paths, manifest } = {}) {
+  const rawPath = typeof spec?.path === 'string' ? spec.path.trim() : '';
+  if (!rawPath) return null;
+
+  const nativePaths = pathContext?.native || paths || {};
+  if (typeof nativePaths[rawPath] === 'string' && nativePaths[rawPath].trim()) {
+    return nativePaths[rawPath];
+  }
+
+  const home = pathContext?.home || nativePaths.home || manifest?.paths?.home || process.cwd();
+  const expanded = rawPath.replace(/\{home\}/g, home);
+  return path.isAbsolute(expanded) ? path.normalize(expanded) : path.resolve(home, expanded);
+}
+
+function resolveNativeSnapshotSpecs(declarations, context = {}) {
+  return Object.fromEntries(Object.entries(declarations || {})
+    .map(([key, spec]) => [key, {
+      ...spec,
+      path: resolveSnapshotPath(spec, context)
+    }])
+    .filter(([, spec]) => spec.path));
+}
+
+function createNativeSnapshotMethods(specs, { platform, runtime, manifest, pathContext, paths } = {}) {
+  const resolvedSpecs = Object.keys(specs || {}).length > 0
+    ? specs
+    : resolveNativeSnapshotSpecs(manifest?.nativeConfigSnapshot, { manifest, pathContext, paths });
   const methods = {
     exportSnapshot() {
-      return Object.fromEntries(Object.entries(specs || {})
+      return Object.fromEntries(Object.entries(resolvedSpecs || {})
         .map(([key, spec]) => [key, readEntry(spec)])
         .filter(([, entry]) => entry));
     },
     importSnapshot(snapshot = {}, { overwrite = true } = {}) {
       const result = { success: 0, imported: 0, skipped: 0, failed: 0 };
       for (const [key, entry] of Object.entries(snapshot || {})) {
-        const status = writeEntry(specs[key], entry, overwrite);
+        const status = writeEntry(resolvedSpecs[key], entry, overwrite);
         if (status === 'success') {
           result.success += 1;
           result.imported += 1;
@@ -122,4 +148,4 @@ function createNativeSnapshotMethods(specs, { platform, runtime } = {}) {
   return methods;
 }
 
-module.exports = { createNativeSnapshotMethods };
+module.exports = { createNativeSnapshotMethods, resolveNativeSnapshotSpecs };

package/src/platforms/drivers/omp/channels-implementation.js

@@ -10,6 +10,7 @@ const {
   writeManagedOmpProviders,
   removeManagedOmpProviders,
   getLastManagedOmpSyncResult,
+  getManagedProviderId,
   readModelsConfig,
   readOmpSettingsConfig,
   normalizeProviderId,
@@ -59,6 +60,15 @@ function selectLatestEnabledChannel(channels = []) {
   }, enabledChannels[0]);
 }
 
+function getChannelManagedProviderId(channel = {}) {
+  if (typeof getManagedProviderId === 'function') {
+    return getManagedProviderId(channel);
+  }
+  const rawId = channel.managedProviderId || channel.providerKey || channel.provider || channel.name || channel.id;
+  const normalizedId = normalizeProviderId(rawId);
+  return normalizedId.startsWith('ctx-') ? normalizedId : `ctx-${normalizedId}`;
+}
+
 function loadManagedOmpModeState() {
   ensureStorageDirMigrated();
   try {
@@ -269,16 +279,24 @@ class OmpChannelService extends BaseChannelService {
   }
 
   _applyToNativeSettings(channel) {
+    const knownProviderIds = this.getChannels().channels.map(getChannelManagedProviderId);
     if (isManagedOmpModeEnabled()) {
       const state = loadManagedOmpModeState();
       enableManagedOmpMode(channel.id, state?.gateway || null);
       writeManagedOmpProviders([channel], state?.gateway ? {
         gateway: state.gateway,
-        activeChannelId: channel.id
-      } : {});
+        activeChannelId: channel.id,
+        knownProviderIds
+      } : { knownProviderIds });
       return;
     }
-    writeManagedOmpProviders([channel], {});
+    writeManagedOmpProviders([channel], { knownProviderIds });
+  }
+
+  disableAllChannels() {
+    const result = super.disableAllChannels();
+    this.syncOmpProvidersForCurrentMode(this.getChannels().channels);
+    return result;
   }
 
   _onAfterCreate(_channel, allChannels) {
@@ -296,13 +314,18 @@ class OmpChannelService extends BaseChannelService {
   syncOmpProvidersForCurrentMode(channels = this.getChannels().channels) {
     if (isManagedOmpModeEnabled()) {
       const state = loadManagedOmpModeState();
-      return this.syncManagedOmpProviders(channels, state?.gateway ? {
-        gateway: state.gateway,
-        activeChannelId: state.activeChannelId
-      } : {});
+      return this.syncManagedOmpProviders(channels, {
+        ...(state?.gateway ? {
+          gateway: state.gateway,
+          activeChannelId: state.activeChannelId
+        } : {}),
+        knownProviderIds: channels.map(getChannelManagedProviderId)
+      });
     }
     const activeChannel = selectLatestEnabledChannel(channels);
-    return this.syncManagedOmpProviders(activeChannel ? [activeChannel] : [], {});
+    return this.syncManagedOmpProviders(activeChannel ? [activeChannel] : [], {
+      knownProviderIds: channels.map(getChannelManagedProviderId)
+    });
   }
 
   syncManagedOmpProviders(channels = this.getChannels().channels, options = {}) {
@@ -335,7 +358,9 @@ class OmpChannelService extends BaseChannelService {
 
     try {
       this.saveChannels(data);
-      const sync = this.syncManagedOmpProviders([channel], {});
+      const sync = this.syncManagedOmpProviders([channel], {
+        knownProviderIds: data.channels.map(getChannelManagedProviderId)
+      });
       if (!wasEnabled) {
         clearOmpChannelBalanceCache(channel);
       }
@@ -739,24 +764,33 @@ function getCatalogMetadata({
       ))
       : [])
   ]
-    .map(value => String(value || '').trim().toLowerCase())
-    .filter(Boolean);
+    .map(value => String(value || '').trim())
+    .filter(Boolean)
+    .filter((value, index, values) => values.findIndex(item => item.toLowerCase() === value.toLowerCase()) === index);
   const normalizedProviderKey = String(providerKey || '').trim().toLowerCase();
 
   const allEntries = Object.entries(MODEL_METADATA)
     .filter(([, metadata]) => Array.isArray(metadata.toolTypes) && metadata.toolTypes.includes('omp'))
     .map(([id, metadata]) => ({ ...structuredClone(metadata), id }));
 
-  const matchesRequestedId = entry => requestedIds.length > 0 && requestedIds.some(requested => (
-    requested === entry.id.toLowerCase()
-      || requested === String(entry.sourceId || '').toLowerCase()
-      || requested === entry.id.split('/').pop().toLowerCase()
-  ));
+  const findRequestedEntry = requestedId => allEntries.find(entry => {
+    const normalizedRequestedId = requestedId.toLowerCase();
+    return normalizedRequestedId === entry.id.toLowerCase()
+      || normalizedRequestedId === String(entry.sourceId || '').toLowerCase()
+      || normalizedRequestedId === entry.id.split('/').pop().toLowerCase();
+  });
   const matchesProvider = entry => (
     String(entry.provider || '').toLowerCase() === normalizedProviderKey
     || String(entry.sourceId || '').toLowerCase().startsWith(`${normalizedProviderKey}/`)
   );
-  const requestedEntries = requestedIds.length > 0 ? allEntries.filter(matchesRequestedId) : [];
+  const requestedEntries = requestedIds.length > 0
+    ? requestedIds
+      .map(requestedId => {
+        const entry = findRequestedEntry(requestedId);
+        return entry ? { ...entry, id: requestedId } : null;
+      })
+      .filter(Boolean)
+    : [];
   const providerEntries = normalizedProviderKey ? allEntries.filter(matchesProvider) : [];
   const entries = requestedIds.length > 0 ? requestedEntries : providerEntries;
 

package/src/platforms/drivers/omp/native-config-implementation.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const { spawnSync } = require('child_process');
 const yaml = require('js-yaml');
+const { writeYamlFile } = require('../../../utils/native-config-patcher');
 const ompConfig = require('./config');
 const { prepareManagedOmpChannels } = require('./gateway-routing');
 const { MODEL_METADATA, MODEL_ALIASES } = require('../../../config/model-metadata');
@@ -409,13 +410,7 @@ function readModelsConfig(filePath = getOmpPaths().modelsYml) {
 }
 
 function writeModelsConfig(config, filePath = getOmpPaths().modelsYml) {
-  ensureOmpDir(path.dirname(filePath));
-  const doc = yaml.dump(config || { providers: {} }, {
-    lineWidth: 120,
-    noRefs: true,
-    sortKeys: false
-  });
-  writeFileAtomic(filePath, doc);
+  writeYamlFile(filePath, config || { providers: {} }, { atomic: true });
 }
 
 function getOmpSettingsPath(paths = getOmpPaths()) {
@@ -447,13 +442,7 @@ function readOmpSettingsConfig(filePath = getOmpSettingsPath()) {
 }
 
 function writeOmpSettingsConfig(config, filePath = getOmpSettingsPath()) {
-  ensureOmpDir(path.dirname(filePath));
-  const doc = yaml.dump(config || {}, {
-    lineWidth: 120,
-    noRefs: true,
-    sortKeys: false
-  });
-  writeFileAtomic(filePath, doc);
+  writeYamlFile(filePath, config || {}, { atomic: true });
 }
 
 function getModelsBackupPrefix(filePath) {
@@ -669,9 +658,10 @@ function removeLegacyManagedExtension(paths = getOmpPaths()) {
   }
 }
 
-function pruneManagedProviders(providers = {}) {
+function pruneManagedProviders(providers = {}, knownProviderIds = null) {
+  const keep = knownProviderIds instanceof Set ? knownProviderIds : null;
   Object.keys(providers).forEach((providerId) => {
-    if (isManagedProviderId(providerId)) {
+    if (isManagedProviderId(providerId) && (!keep || !keep.has(providerId))) {
       delete providers[providerId];
     }
   });
@@ -684,7 +674,10 @@ function buildManagedModelsConfig(channels = [], baseConfig = readModelsConfig()
       ...(baseConfig.providers || {})
     }
   };
-  pruneManagedProviders(next.providers);
+  const knownProviderIds = Array.isArray(options.knownProviderIds)
+    ? new Set(options.knownProviderIds)
+    : new Set((channels || []).map(getManagedProviderId));
+  pruneManagedProviders(next.providers, knownProviderIds);
 
   channels
     .filter(channel => channel && channel.enabled !== false && channel.baseUrl)

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

@@ -282,6 +282,10 @@ function updateChannel(channelId, updates) {
   if (!isProxyRunning) {
     if (oldChannel.enabled === false && merged.enabled !== false) {
       syncManagedChannelConfig(data.channels, merged);
+    } else if (oldChannel.enabled !== false && merged.enabled === false) {
+      const activeChannel = resolveCurrentManagedChannel(data.channels);
+      if (activeChannel) syncManagedChannelConfig(data.channels, activeChannel);
+      else clearManagedChannelConfig();
     } else {
       const activeChannel = resolveCurrentManagedChannel(data.channels);
       if (merged.enabled !== false && activeChannel?.id === merged.id) {
@@ -487,9 +491,11 @@ async function getEffectiveApiKey(channel) {
 }
 
 function disableAllChannels() {
+  const proxyRunning = getOpenCodeProxyRunning();
   const data = loadChannels();
   data.channels.forEach(ch => { ch.enabled = false; });
   saveChannels(data);
+  if (!proxyRunning) clearManagedChannelConfig();
 }
 
 function getCurrentOpenCodeProviderId(config = {}) {

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

@@ -1,5 +1,6 @@
 const fs = require('fs');
 const path = require('path');
+const { readJsoncFile, writeJsoncFile } = require('../../../utils/native-config-patcher');
 const { NATIVE_PATHS } = require('../../../config/paths');
 const { resolveModelMetadata } = require('../../../config/model-metadata');
 const { resolveModelPricing } = require('../../../server/utils/pricing');
@@ -61,79 +62,18 @@ function selectConfigPath() {
   return CONFIG_PATHS.opencode;
 }
 
-function stripJsonComments(input) {
-  let result = '';
-  let inString = false;
-  let stringChar = '';
-  let i = 0;
-
-  while (i < input.length) {
-    const ch = input[i];
-    const next = input[i + 1];
-
-    if (inString) {
-      result += ch;
-      if (ch === '\\') {
-        if (next) {
-          result += next;
-          i += 2;
-          continue;
-        }
-      } else if (ch === stringChar) {
-        inString = false;
-      }
-      i += 1;
-      continue;
-    }
-
-    if (ch === '"' || ch === '\'') {
-      inString = true;
-      stringChar = ch;
-      result += ch;
-      i += 1;
-      continue;
-    }
-
-    if (ch === '/' && next === '/') {
-      i += 2;
-      while (i < input.length && input[i] !== '\n') i += 1;
-      continue;
-    }
-
-    if (ch === '/' && next === '*') {
-      i += 2;
-      while (i < input.length - 1 && !(input[i] === '*' && input[i + 1] === '/')) i += 1;
-      i += 2;
-      continue;
-    }
-
-    result += ch;
-    i += 1;
-  }
-
-  return result;
-}
-
 function readConfig(filePath) {
   if (!fs.existsSync(filePath)) return {};
 
-  const raw = fs.readFileSync(filePath, 'utf8');
-  if (!raw.trim()) return {};
-
   try {
-    if (filePath.endsWith('.jsonc')) {
-      return JSON.parse(stripJsonComments(raw));
-    }
-    return JSON.parse(raw);
+    return readJsoncFile(filePath);
   } catch (err) {
     throw new Error(`Failed to parse ${path.basename(filePath)}: ${err.message}`);
   }
 }
 
 function writeConfig(filePath, config) {
-  ensureConfigDir();
-  const content = JSON.stringify(config, null, 2);
-  fs.writeFileSync(filePath, content, 'utf8');
+  writeJsoncFile(filePath, config);
 }
 
 function normalizeOpenCodeModel(modelId, providerId) {
@@ -520,7 +460,6 @@ function setProxyConfig(proxyPort, options = {}) {
 
 function setChannelConfig(channel = {}) {
   const filePath = selectConfigPath();
-  backupConfig(filePath);
 
   const current = readConfig(filePath);
   const next = (current && typeof current === 'object') ? current : {};
@@ -529,9 +468,6 @@ function setChannelConfig(channel = {}) {
     next.provider = {};
   }
 
-  const removedProviderKeys = clearManagedProviders(next);
-  clearManagedModelRef(next, removedProviderKeys);
-
   const baseProviderKey = sanitizeProviderKey(channel.providerKey || channel.name || 'ctx-channel');
   let providerKey = baseProviderKey;
   let suffix = 2;

package/src/platforms/manifest-schema.js

@@ -11,6 +11,7 @@ const DRIVER_IDS = new Set([
   'generic-openai-compatible',
   'generic-mcp',
   'generic-prompt',
+  'generic-native-config',
   'legacy:claude',
   'legacy:codex',
   'legacy:gemini',
@@ -80,7 +81,7 @@ const CAPABILITY_OPERATIONS = Object.freeze({
     'updateSkill',
     'deleteSkill'
   ]),
-  channels: new Set(['applyToSettings', 'bestForRestore', 'catalogMetadata', 'create', 'current', 'enabled', 'getAuth', 'getAuthQuota', 'list', 'models', 'order', 'poolStatus', 'probeModels', 'remove', 'resetHealth', 'speedTest', 'speedTestAll', 'sync', 'syncLocalAuth', 'update']),
+  channels: new Set(['applyToSettings', 'bestForRestore', 'catalogMetadata', 'create', 'current', 'enabled', 'getAuth', 'getAuthQuota', 'list', 'models', 'order', 'poolStatus', 'probeModels', 'remove', 'resetHealth', 'speedTest', 'sync', 'syncLocalAuth', 'update']),
   health: new Set(['healthCheck']),
   hooks: new Set(['getHooks', 'saveHooks', 'testHooks']),
   projects: new Set(['createProject', 'deleteProject', 'listProjects', 'saveProjectOrder']),
@@ -198,6 +199,19 @@ const schema = {
     sessionMapping: { type: 'object', additionalProperties: { type: 'string' } },
     sessionGlob: { type: 'string', minLength: 1 },
     resourceMappings: { type: 'object', additionalProperties: { type: 'string' } },
+    nativeConfigSnapshot: {
+      type: 'object',
+      additionalProperties: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['path', 'format'],
+        properties: {
+          path: { type: 'string', minLength: 1 },
+          format: { enum: ['text', 'json', 'yaml', 'directory'] },
+          mode: { type: 'integer', minimum: 0, maximum: 511 }
+        }
+      }
+    },
     projectResources: {
       type: 'object',
       additionalProperties: false,
@@ -333,6 +347,17 @@ function validateProjectResources(manifest, errors) {
   }
 }
 
+function validateNativeConfigSnapshot(manifest, errors) {
+  for (const [key, spec] of Object.entries(manifest?.nativeConfigSnapshot || {})) {
+    if (!isSafeRelativePath(spec?.path)) {
+      errors.push({
+        instancePath: `/nativeConfigSnapshot/${key}/path`,
+        message: 'must be a safe relative path or a declared native path name'
+      });
+    }
+  }
+}
+
 function validateApiRoutes(manifest, errors) {
   const api = manifest?.api;
   if (!api?.routes) return;
@@ -395,7 +420,8 @@ function validateManifest(manifest) {
     'generic-filesystem': new Set(['resourceSync']),
     'generic-openai-compatible': new Set(['channels']),
     'generic-mcp': new Set(['mcp']),
-    'generic-prompt': new Set(['prompts'])
+    'generic-prompt': new Set(['prompts']),
+    'generic-native-config': new Set(['nativeConfig'])
   };
 
   for (const [capability, driver] of Object.entries(manifest && manifest.capabilities || {})) {
@@ -424,6 +450,13 @@ function validateManifest(manifest) {
     }
   }
 
+  if (manifest?.capabilities?.nativeConfig === 'generic-native-config' && !manifest.nativeConfigSnapshot) {
+    errors.push({
+      instancePath: '/nativeConfigSnapshot',
+      message: 'generic-native-config requires nativeConfigSnapshot declarations'
+    });
+  }
+  validateNativeConfigSnapshot(manifest, errors);
   validateApiRoutes(manifest, errors);
   return { valid: errors.length === 0, errors };
 }

package/src/platforms/manifests/claude.json

@@ -356,14 +356,6 @@
         "request": "default",
         "response": "default"
       },
-      {
-        "method": "POST",
-        "path": "/channels/speed-test-all",
-        "capability": "channels",
-        "operation": "speedTestAll",
-        "request": "default",
-        "response": "default"
-      },
       {
         "method": "POST",
         "path": "/channels/probe-models",

package/src/platforms/manifests/codex.json

@@ -348,14 +348,6 @@
         "request": "default",
         "response": "default"
       },
-      {
-        "method": "POST",
-        "path": "/channels/speed-test-all",
-        "capability": "channels",
-        "operation": "speedTestAll",
-        "request": "default",
-        "response": "default"
-      },
       {
         "method": "POST",
         "path": "/channels/probe-models",

package/src/platforms/manifests/dsh.json

@@ -253,14 +253,6 @@
         "request": "default",
         "response": "default"
       },
-      {
-        "method": "POST",
-        "path": "/channels/speed-test-all",
-        "capability": "channels",
-        "operation": "speedTestAll",
-        "request": "default",
-        "response": "default"
-      },
       {
         "method": "POST",
         "path": "/channels/probe-models",
@@ -530,7 +522,7 @@
   "capabilities": {
     "projects": "dsh-projects",
     "sessions": "dsh-sessions",
-    "nativeConfig": "dsh-native-config",
+    "nativeConfig": "generic-native-config",
     "api": "dsh-api",
     "channels": "dsh-channels",
     "proxy": "dsh-proxy",
@@ -538,5 +530,10 @@
     "nativeLogs": "dsh-native-logs",
     "mcp": "dsh-api",
     "prompts": "dsh-api"
+  },
+  "nativeConfigSnapshot": {
+    "settings": { "path": "settings", "format": "text", "mode": 384 },
+    "credentials": { "path": "credentials", "format": "text", "mode": 384 },
+    "patch": { "path": "patch", "format": "text", "mode": 384 }
   }
 }

package/src/platforms/manifests/gemini.json

@@ -347,14 +347,6 @@
         "request": "default",
         "response": "default"
       },
-      {
-        "method": "POST",
-        "path": "/channels/speed-test-all",
-        "capability": "channels",
-        "operation": "speedTestAll",
-        "request": "default",
-        "response": "default"
-      },
       {
         "method": "POST",
         "path": "/channels/probe-models",

package/src/platforms/manifests/omp.json

@@ -365,14 +365,6 @@
         "request": "default",
         "response": "default"
       },
-      {
-        "method": "POST",
-        "path": "/channels/speed-test-all",
-        "capability": "channels",
-        "operation": "speedTestAll",
-        "request": "default",
-        "response": "default"
-      },
       {
         "method": "POST",
         "path": "/channels/probe-models",

package/src/platforms/manifests/opencode.json

@@ -349,14 +349,6 @@
         "request": "default",
         "response": "default"
       },
-      {
-        "method": "POST",
-        "path": "/channels/speed-test-all",
-        "capability": "channels",
-        "operation": "speedTestAll",
-        "request": "default",
-        "response": "default"
-      },
       {
         "method": "POST",
         "path": "/channels/probe-models",

package/src/platforms/native-oauth-adapters.js

@@ -4,7 +4,7 @@ const os = require('os');
 const crypto = require('crypto');
 const { execFileSync, spawnSync } = require('child_process');
 const toml = require('toml');
-const tomlStringify = require('@iarna/toml').stringify;
+const { writeTomlFile } = require('../utils/native-config-patcher');
 const pathsModule = require('../config/paths');
 const DEFAULT_NATIVE_PATHS = pathsModule.NATIVE_PATHS;
 const DEFAULT_PATHS = pathsModule.PATHS;
@@ -185,29 +185,29 @@ function clearClaudeOAuth() {
   ensureDir(path.dirname(NATIVE_PATHS.claude.settings));
   claudeSettingsManager.writeSettings(settings);
 }
-function clearClaudeChannelConfig() {
-  let settings = {};
-  try {
-    settings = claudeSettingsManager.settingsExists()
-      ? claudeSettingsManager.readSettings()
-      : {};
-  } catch {
-    settings = {};
+function clearClaudeChannelConfig(managedProxyUrls = []) {
+  if (!claudeSettingsManager.settingsExists()) return;
+  const settings = claudeSettingsManager.readSettings();
+  if (settings.env && typeof settings.env === 'object' && !Array.isArray(settings.env)) {
+    [
+      'ANTHROPIC_BASE_URL',
+      'ANTHROPIC_API_KEY',
+      'ANTHROPIC_AUTH_TOKEN',
+      'CLAUDE_CODE_OAUTH_TOKEN',
+      'ANTHROPIC_MODEL',
+      'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+      'ANTHROPIC_DEFAULT_SONNET_MODEL',
+      'ANTHROPIC_DEFAULT_OPUS_MODEL'
+    ].forEach((key) => {
+      delete settings.env[key];
+    });
+    const managedProxies = new Set((Array.isArray(managedProxyUrls) ? managedProxyUrls : [])
+      .map(value => String(value || '').trim()).filter(Boolean));
+    ['HTTP_PROXY', 'HTTPS_PROXY'].forEach((key) => {
+      if (managedProxies.has(String(settings.env[key] || '').trim())) delete settings.env[key];
+    });
+    if (Object.keys(settings.env).length === 0) delete settings.env;
   }
-
-  settings.env = settings.env || {};
-  [
-    'ANTHROPIC_BASE_URL',
-    'ANTHROPIC_API_KEY',
-    'ANTHROPIC_AUTH_TOKEN',
-    'CLAUDE_CODE_OAUTH_TOKEN',
-    'ANTHROPIC_MODEL',
-    'ANTHROPIC_DEFAULT_HAIKU_MODEL',
-    'ANTHROPIC_DEFAULT_SONNET_MODEL',
-    'ANTHROPIC_DEFAULT_OPUS_MODEL'
-  ].forEach((key) => {
-    delete settings.env[key];
-  });
   delete settings.apiKeyHelper;
   ensureDir(path.dirname(NATIVE_PATHS.claude.settings));
   claudeSettingsManager.writeSettings(settings);
@@ -444,16 +444,16 @@ function removeCodexChannelEnvVars() {
 }
 
 function clearCodexChannelConfig() {
-  removeCodexChannelEnvVars();
-
   const configPath = NATIVE_PATHS.codex.config;
+  if (!fs.existsSync(configPath)) {
+    removeCodexChannelEnvVars();
+    return;
+  }
   let config = {};
-  if (fs.existsSync(configPath)) {
-    try {
-      config = toml.parse(fs.readFileSync(configPath, 'utf8'));
-    } catch {
-      config = {};
-    }
+  try {
+    config = toml.parse(fs.readFileSync(configPath, 'utf8'));
+  } catch (error) {
+    throw new Error(`Failed to parse existing Codex config.toml: ${error.message}`);
   }
 
   const managedProviderKeys = new Set(['cc-proxy']);
@@ -478,8 +478,8 @@ function clearCodexChannelConfig() {
     }
   }
 
-  ensureDir(path.dirname(configPath));
-  fs.writeFileSync(configPath, tomlStringify(config), 'utf8');
+  writeTomlFile(configPath, config, { atomic: true });
+  removeCodexChannelEnvVars();
 }
 
 function applyCodexOAuth(credential) {