free-coding-models 0.3.11 → 0.3.12

package/src/legacy-proxy-cleanup.js

@@ -0,0 +1,432 @@
+/**
+ * @file src/legacy-proxy-cleanup.js
+ * @description Best-effort cleanup for discontinued proxy-era config leftovers.
+ *
+ * @details
+ *   📖 The old global proxy/daemon stack has been removed from the product, but
+ *   📖 some users may still have persisted `fcm-proxy` entries, env files, or
+ *   📖 runtime artifacts from earlier versions.
+ *
+ *   📖 This module removes only the legacy proxy markers that are now obsolete:
+ *   - `fcm-proxy` providers inside tool configs
+ *   - proxy-only env files for removed tools
+ *   - daemon/log artifacts from the old bridge
+ *   - stale proxy fields in `~/.free-coding-models.json`
+ *
+ *   📖 It intentionally preserves current direct-provider installs such as
+ *   📖 `fcm-nvidia`, `fcm-groq`, or the current OpenHands env file when it is
+ *   📖 clearly configured for direct provider usage instead of the removed proxy.
+ *
+ * @functions
+ *   → `cleanupLegacyProxyArtifacts` — remove discontinued proxy-era config files and entries
+ *
+ * @exports cleanupLegacyProxyArtifacts
+ */
+
+import { existsSync, readFileSync, writeFileSync, unlinkSync, readdirSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+const LEGACY_TOOL_MODES = new Set(['claude-code', 'codex', 'gemini'])
+const LEGACY_RUNTIME_FILES = ['daemon.json', 'daemon-stdout.log', 'daemon-stderr.log', 'request-log.jsonl']
+const LEGACY_ENV_FILES = ['.fcm-claude-code-env', '.fcm-codex-env', '.fcm-gemini-env']
+
+function getDefaultPaths(homeDir) {
+  return {
+    configPath: join(homeDir, '.free-coding-models.json'),
+    dataDir: join(homeDir, '.free-coding-models'),
+    opencodeConfigPath: join(homeDir, '.config', 'opencode', 'opencode.json'),
+    openclawConfigPath: join(homeDir, '.openclaw', 'openclaw.json'),
+    crushConfigPath: join(homeDir, '.config', 'crush', 'crush.json'),
+    gooseProvidersDir: join(homeDir, '.config', 'goose', 'custom_providers'),
+    gooseSecretsPath: join(homeDir, '.config', 'goose', 'secrets.yaml'),
+    gooseConfigPath: join(homeDir, '.config', 'goose', 'config.yaml'),
+    piModelsPath: join(homeDir, '.pi', 'agent', 'models.json'),
+    piSettingsPath: join(homeDir, '.pi', 'agent', 'settings.json'),
+    aiderConfigPath: join(homeDir, '.aider.conf.yml'),
+    ampConfigPath: join(homeDir, '.config', 'amp', 'settings.json'),
+    qwenConfigPath: join(homeDir, '.qwen', 'settings.json'),
+    launchAgentPath: join(homeDir, 'Library', 'LaunchAgents', 'com.fcm.proxy.plist'),
+    systemdServicePath: join(homeDir, '.config', 'systemd', 'user', 'fcm-proxy.service'),
+    shellProfilePaths: [
+      join(homeDir, '.zshrc'),
+      join(homeDir, '.bashrc'),
+      join(homeDir, '.bash_profile'),
+    ],
+  }
+}
+
+function createSummary() {
+  return {
+    changed: false,
+    removedFiles: [],
+    updatedFiles: [],
+    removedEntries: 0,
+    errors: [],
+  }
+}
+
+function noteRemovedFile(summary, filePath) {
+  summary.changed = true
+  summary.removedFiles.push(filePath)
+}
+
+function noteUpdatedFile(summary, filePath, removedEntries = 1) {
+  summary.changed = true
+  summary.updatedFiles.push(filePath)
+  summary.removedEntries += removedEntries
+}
+
+function noteError(summary, filePath, error) {
+  summary.errors.push(`${filePath}: ${error instanceof Error ? error.message : String(error)}`)
+}
+
+function readJsonFile(filePath, fallback = null) {
+  if (!existsSync(filePath)) return fallback
+  return JSON.parse(readFileSync(filePath, 'utf8'))
+}
+
+function writeJsonFile(filePath, value) {
+  writeFileSync(filePath, JSON.stringify(value, null, 2) + '\n')
+}
+
+function deleteFileIfExists(filePath, summary) {
+  if (!existsSync(filePath)) return false
+  try {
+    unlinkSync(filePath)
+    noteRemovedFile(summary, filePath)
+    return true
+  } catch (error) {
+    noteError(summary, filePath, error)
+    return false
+  }
+}
+
+function updateJsonFile(filePath, mutate, summary) {
+  if (!existsSync(filePath)) return
+  try {
+    const data = readJsonFile(filePath, {})
+    const removedEntries = mutate(data)
+    if (removedEntries > 0) {
+      writeJsonFile(filePath, data)
+      noteUpdatedFile(summary, filePath, removedEntries)
+    }
+  } catch (error) {
+    noteError(summary, filePath, error)
+  }
+}
+
+function cleanupMainConfig(filePath, summary) {
+  if (!existsSync(filePath)) return
+  try {
+    const config = readJsonFile(filePath, {})
+    let removedEntries = 0
+
+    if (config.settings && typeof config.settings === 'object' && 'proxy' in config.settings) {
+      delete config.settings.proxy
+      removedEntries += 1
+    }
+
+    if ('proxySettings' in config) {
+      delete config.proxySettings
+      removedEntries += 1
+    }
+
+    if (Array.isArray(config.endpointInstalls)) {
+      const before = config.endpointInstalls.length
+      config.endpointInstalls = config.endpointInstalls.filter(
+        (entry) => !LEGACY_TOOL_MODES.has(entry?.toolMode)
+      )
+      removedEntries += before - config.endpointInstalls.length
+    }
+
+    if (config.settings?.preferredToolMode && LEGACY_TOOL_MODES.has(config.settings.preferredToolMode)) {
+      config.settings.preferredToolMode = 'opencode'
+      removedEntries += 1
+    }
+
+    if (removedEntries > 0) {
+      writeJsonFile(filePath, config)
+      noteUpdatedFile(summary, filePath, removedEntries)
+    }
+  } catch (error) {
+    noteError(summary, filePath, error)
+  }
+}
+
+function cleanupRuntimeFiles(dataDir, summary) {
+  for (const fileName of LEGACY_RUNTIME_FILES) {
+    deleteFileIfExists(join(dataDir, fileName), summary)
+  }
+}
+
+function cleanupLegacyEnvFiles(homeDir, summary) {
+  for (const fileName of LEGACY_ENV_FILES) {
+    deleteFileIfExists(join(homeDir, fileName), summary)
+    deleteFileIfExists(join(homeDir, `${fileName}.bak`), summary)
+  }
+}
+
+function cleanupShellProfiles(profilePaths, summary) {
+  const patterns = [
+    /# 📖 FCM Proxy — Claude Code env vars/,
+    /\.fcm-claude-code-env/,
+  ]
+
+  for (const profilePath of profilePaths) {
+    if (!existsSync(profilePath)) continue
+    try {
+      const raw = readFileSync(profilePath, 'utf8')
+      const lines = raw.split(/\r?\n/)
+      const filtered = lines.filter((line) => !patterns.some((pattern) => pattern.test(line)))
+      if (filtered.join('\n') !== lines.join('\n')) {
+        writeFileSync(profilePath, filtered.join('\n'))
+        noteUpdatedFile(summary, profilePath, 1)
+      }
+    } catch (error) {
+      noteError(summary, profilePath, error)
+    }
+  }
+}
+
+function cleanupOpenCode(filePath, summary) {
+  updateJsonFile(filePath, (config) => {
+    let removedEntries = 0
+    if (config.provider?.['fcm-proxy']) {
+      delete config.provider['fcm-proxy']
+      removedEntries += 1
+      if (Object.keys(config.provider).length === 0) delete config.provider
+    }
+    if (typeof config.model === 'string' && config.model.startsWith('fcm-proxy/')) {
+      delete config.model
+      removedEntries += 1
+    }
+    return removedEntries
+  }, summary)
+}
+
+function cleanupOpenClaw(filePath, summary) {
+  updateJsonFile(filePath, (config) => {
+    let removedEntries = 0
+    if (config.models?.providers?.['fcm-proxy']) {
+      delete config.models.providers['fcm-proxy']
+      removedEntries += 1
+    }
+    if (config.agents?.defaults?.models && typeof config.agents.defaults.models === 'object') {
+      for (const key of Object.keys(config.agents.defaults.models)) {
+        if (key.startsWith('fcm-proxy/')) {
+          delete config.agents.defaults.models[key]
+          removedEntries += 1
+        }
+      }
+    }
+    return removedEntries
+  }, summary)
+}
+
+function cleanupCrush(filePath, summary) {
+  updateJsonFile(filePath, (config) => {
+    let removedEntries = 0
+    if (config.providers?.['fcm-proxy']) {
+      delete config.providers['fcm-proxy']
+      removedEntries += 1
+    }
+    if (config.models?.large?.provider === 'fcm-proxy') {
+      delete config.models.large
+      removedEntries += 1
+    }
+    if (config.models?.small?.provider === 'fcm-proxy') {
+      delete config.models.small
+      removedEntries += 1
+    }
+    return removedEntries
+  }, summary)
+}
+
+function readSimpleYamlMap(filePath) {
+  if (!existsSync(filePath)) return {}
+  const output = {}
+  const lines = readFileSync(filePath, 'utf8').split(/\r?\n/)
+  for (const line of lines) {
+    if (!line.trim() || line.trim().startsWith('#')) continue
+    const match = line.match(/^([A-Za-z0-9_]+):\s*(.*)$/)
+    if (!match) continue
+    output[match[1]] = match[2].trim().replace(/^['"]|['"]$/g, '')
+  }
+  return output
+}
+
+function writeSimpleYamlMap(filePath, entries) {
+  const lines = Object.keys(entries)
+    .sort()
+    .map((key) => `${key}: ${JSON.stringify(String(entries[key] ?? ''))}`)
+  writeFileSync(filePath, lines.join('\n') + '\n')
+}
+
+function cleanupGoose(paths, summary) {
+  deleteFileIfExists(join(paths.gooseProvidersDir, 'fcm-proxy.json'), summary)
+
+  if (existsSync(paths.gooseSecretsPath)) {
+    try {
+      const secrets = readSimpleYamlMap(paths.gooseSecretsPath)
+      if ('FCM_PROXY_API_KEY' in secrets) {
+        delete secrets.FCM_PROXY_API_KEY
+        writeSimpleYamlMap(paths.gooseSecretsPath, secrets)
+        noteUpdatedFile(summary, paths.gooseSecretsPath, 1)
+      }
+    } catch (error) {
+      noteError(summary, paths.gooseSecretsPath, error)
+    }
+  }
+
+  if (existsSync(paths.gooseConfigPath)) {
+    try {
+      const lines = readFileSync(paths.gooseConfigPath, 'utf8').split(/\r?\n/)
+      const hadLegacyProvider = lines.some((line) => /^GOOSE_PROVIDER:\s*fcm-proxy\s*$/.test(line))
+      if (hadLegacyProvider) {
+        const filtered = lines.filter((line) => {
+          if (/^GOOSE_PROVIDER:\s*fcm-proxy\s*$/.test(line)) return false
+          if (/^GOOSE_MODEL:\s*/.test(line)) return false
+          return true
+        })
+        writeFileSync(paths.gooseConfigPath, filtered.join('\n'))
+        noteUpdatedFile(summary, paths.gooseConfigPath, 2)
+      }
+    } catch (error) {
+      noteError(summary, paths.gooseConfigPath, error)
+    }
+  }
+}
+
+function cleanupPi(paths, summary) {
+  updateJsonFile(paths.piModelsPath, (config) => {
+    let removedEntries = 0
+    if (config.providers?.['fcm-proxy']) {
+      delete config.providers['fcm-proxy']
+      removedEntries += 1
+    }
+    return removedEntries
+  }, summary)
+
+  updateJsonFile(paths.piSettingsPath, (config) => {
+    let removedEntries = 0
+    if (config.defaultProvider === 'fcm-proxy') {
+      delete config.defaultProvider
+      removedEntries += 1
+    }
+    if (typeof config.defaultModel === 'string' && config.defaultModel.startsWith('fcm-proxy/')) {
+      delete config.defaultModel
+      removedEntries += 1
+    }
+    return removedEntries
+  }, summary)
+}
+
+function cleanupAider(filePath, summary) {
+  if (!existsSync(filePath)) return
+  try {
+    const content = readFileSync(filePath, 'utf8')
+    const isLegacyProxyConfig = content.includes('FCM Proxy V2') || /openai-api-base:\s*http:\/\/127\.0\.0\.1:/i.test(content)
+    if (isLegacyProxyConfig) {
+      unlinkSync(filePath)
+      noteRemovedFile(summary, filePath)
+    }
+  } catch (error) {
+    noteError(summary, filePath, error)
+  }
+}
+
+function cleanupAmp(filePath, summary) {
+  updateJsonFile(filePath, (config) => {
+    let removedEntries = 0
+    const usesLegacyLocalhost = typeof config['amp.url'] === 'string' && /127\.0\.0\.1|localhost/.test(config['amp.url'])
+    if (usesLegacyLocalhost) {
+      delete config['amp.url']
+      removedEntries += 1
+      if (typeof config['amp.model'] === 'string') {
+        delete config['amp.model']
+        removedEntries += 1
+      }
+    }
+    return removedEntries
+  }, summary)
+}
+
+function cleanupQwen(filePath, summary) {
+  updateJsonFile(filePath, (config) => {
+    let removedEntries = 0
+    const removedIds = new Set()
+    if (Array.isArray(config.modelProviders?.openai)) {
+      const next = []
+      for (const entry of config.modelProviders.openai) {
+        const isLegacyEntry = entry?.envKey === 'FCM_PROXY_API_KEY'
+          || (typeof entry?.baseUrl === 'string' && /127\.0\.0\.1|localhost/.test(entry.baseUrl))
+          || (typeof entry?.id === 'string' && entry.id.startsWith('fcm-proxy/'))
+        if (isLegacyEntry) {
+          if (typeof entry?.id === 'string') removedIds.add(entry.id)
+          removedEntries += 1
+          continue
+        }
+        next.push(entry)
+      }
+      config.modelProviders.openai = next
+    }
+    if (typeof config.model === 'string' && (config.model.startsWith('fcm-proxy/') || removedIds.has(config.model))) {
+      delete config.model
+      removedEntries += 1
+    }
+    return removedEntries
+  }, summary)
+}
+
+function cleanupOpenHandsEnv(homeDir, summary) {
+  const filePath = join(homeDir, '.fcm-openhands-env')
+  if (!existsSync(filePath)) return
+  try {
+    const content = readFileSync(filePath, 'utf8')
+    const isLegacyProxyEnv = content.includes('FCM Proxy V2') || /127\.0\.0\.1|localhost/.test(content)
+    if (isLegacyProxyEnv) {
+      unlinkSync(filePath)
+      noteRemovedFile(summary, filePath)
+    }
+  } catch (error) {
+    noteError(summary, filePath, error)
+  }
+}
+
+/**
+ * 📖 cleanupLegacyProxyArtifacts removes stale proxy-era artifacts from older
+ * 📖 releases. It is safe to run multiple times.
+ *
+ * @param {{
+ *   homeDir?: string,
+ *   paths?: Partial<ReturnType<typeof getDefaultPaths>>
+ * }} [options]
+ * @returns {{ changed: boolean, removedFiles: string[], updatedFiles: string[], removedEntries: number, errors: string[] }}
+ */
+export function cleanupLegacyProxyArtifacts(options = {}) {
+  const homeDir = options.homeDir || homedir()
+  const paths = {
+    ...getDefaultPaths(homeDir),
+    ...(options.paths || {}),
+  }
+  const summary = createSummary()
+
+  cleanupMainConfig(paths.configPath, summary)
+  cleanupRuntimeFiles(paths.dataDir, summary)
+  cleanupLegacyEnvFiles(homeDir, summary)
+  cleanupShellProfiles(paths.shellProfilePaths || [], summary)
+  cleanupOpenCode(paths.opencodeConfigPath, summary)
+  cleanupOpenClaw(paths.openclawConfigPath, summary)
+  cleanupCrush(paths.crushConfigPath, summary)
+  cleanupGoose(paths, summary)
+  cleanupPi(paths, summary)
+  cleanupAider(paths.aiderConfigPath, summary)
+  cleanupAmp(paths.ampConfigPath, summary)
+  cleanupQwen(paths.qwenConfigPath, summary)
+  cleanupOpenHandsEnv(homeDir, summary)
+  deleteFileIfExists(paths.launchAgentPath, summary)
+  deleteFileIfExists(paths.systemdServicePath, summary)
+
+  return summary
+}

package/src/openclaw.js

@@ -1,136 +1,97 @@
 /**
- * @file openclaw.js
- * @description OpenClaw config helpers for setting NVIDIA NIM defaults.
+ * @file src/openclaw.js
+ * @description OpenClaw config helpers for persisting the selected provider/model as the default.
  *
  * @details
- *   This module owns the OpenClaw integration logic:
- *   - Read/write ~/.openclaw/openclaw.json
- *   - Ensure the NVIDIA provider block exists under models.providers
- *   - Patch the OpenClaw allowlist for NVIDIA models when needed
- *   - Set the selected model as the default primary model
+ *   📖 OpenClaw is config-driven: FCM does not launch a separate foreground CLI here.
+ *   📖 Pressing Enter in `OpenClaw` mode must therefore do two things reliably:
+ *   - install the selected provider/model into `~/.openclaw/openclaw.json`
+ *   - set that exact model as the default primary model for the next OpenClaw session
  *
- *   → Functions:
- *   - `loadOpenClawConfig` — read OpenClaw config as JSON
- *   - `saveOpenClawConfig` — persist OpenClaw config safely
- *   - `startOpenClaw` — set NVIDIA model as OpenClaw default
+ *   📖 The old implementation was hard-coded to `nvidia/*`, which meant selecting
+ *   📖 a Groq/Cerebras/etc. row silently wrote the wrong provider/model into the
+ *   📖 OpenClaw config. This module now delegates to the shared direct-install
+ *   📖 writer so every supported provider uses the same contract.
+ *
+ * @functions
+ *   → `loadOpenClawConfig` — read the OpenClaw config from disk
+ *   → `saveOpenClawConfig` — persist the OpenClaw config to disk
+ *   → `startOpenClaw` — install the selected provider/model and set it as default
  *
  * @exports { loadOpenClawConfig, saveOpenClawConfig, startOpenClaw }
- * @see ../patch-openclaw-models.js
+ *
+ * @see src/endpoint-installer.js
  */
 
 import chalk from 'chalk'
-import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs'
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs'
 import { homedir } from 'os'
-import { join } from 'path'
-import { patchOpenClawModelsJson } from '../patch-openclaw-models.js'
-import { sources } from '../sources.js'
+import { dirname, join } from 'path'
+import { installProviderEndpoints } from './endpoint-installer.js'
+import { ENV_VAR_NAMES } from './provider-metadata.js'
 import { PROVIDER_COLOR } from './render-table.js'
 
-// 📖 OpenClaw config: ~/.openclaw/openclaw.json (JSON format, may be JSON5 in newer versions)
 const OPENCLAW_CONFIG = join(homedir(), '.openclaw', 'openclaw.json')
 
-export function loadOpenClawConfig() {
-  if (!existsSync(OPENCLAW_CONFIG)) return {}
+function getOpenClawConfigPath(options = {}) {
+  return options.paths?.openclawConfigPath || OPENCLAW_CONFIG
+}
+
+export function loadOpenClawConfig(options = {}) {
+  const filePath = getOpenClawConfigPath(options)
+  if (!existsSync(filePath)) return {}
   try {
-    // 📖 JSON.parse works for standard JSON; OpenClaw may use JSON5 but base config is valid JSON
-    return JSON.parse(readFileSync(OPENCLAW_CONFIG, 'utf8'))
+    return JSON.parse(readFileSync(filePath, 'utf8'))
   } catch {
     return {}
   }
 }
 
-export function saveOpenClawConfig(config) {
-  const dir = join(homedir(), '.openclaw')
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true })
-  }
-  writeFileSync(OPENCLAW_CONFIG, JSON.stringify(config, null, 2))
+export function saveOpenClawConfig(config, options = {}) {
+  const filePath = getOpenClawConfigPath(options)
+  mkdirSync(dirname(filePath), { recursive: true })
+  writeFileSync(filePath, JSON.stringify(config, null, 2))
 }
 
-// 📖 startOpenClaw: sets the selected NVIDIA NIM model as default in OpenClaw config.
-// 📖 Also ensures the nvidia provider block is present with the NIM base URL.
-// 📖 Does NOT launch OpenClaw — OpenClaw runs as a daemon, so config changes are picked up on restart.
-export async function startOpenClaw(model, apiKey) {
+/**
+ * 📖 startOpenClaw installs the selected provider/model into OpenClaw and sets
+ * 📖 it as the primary default model. OpenClaw itself is not launched here.
+ *
+ * @param {{ providerKey: string, modelId: string, label: string }} model
+ * @param {Record<string, unknown>} config
+ * @param {{ paths?: { openclawConfigPath?: string } }} [options]
+ * @returns {Promise<ReturnType<typeof installProviderEndpoints> | null>}
+ */
+export async function startOpenClaw(model, config, options = {}) {
+  const providerRgb = PROVIDER_COLOR[model.providerKey] ?? [105, 190, 245]
+  const coloredProviderName = chalk.bold.rgb(...providerRgb)(model.providerKey)
   console.log(chalk.rgb(255, 100, 50)(`  🦞 Setting ${chalk.bold(model.label)} as OpenClaw default…`))
-  console.log(chalk.dim(`  Model: nvidia/${model.modelId}`))
+  console.log(chalk.dim(`  Provider: ${coloredProviderName}`))
+  console.log(chalk.dim(`  Model: ${model.providerKey}/${model.modelId}`))
   console.log()
 
-  const config = loadOpenClawConfig()
-
-  // 📖 Backup existing config before touching it
-  if (existsSync(OPENCLAW_CONFIG)) {
-    const backupPath = `${OPENCLAW_CONFIG}.backup-${Date.now()}`
-    copyFileSync(OPENCLAW_CONFIG, backupPath)
-    console.log(chalk.dim(`  💾 Backup: ${backupPath}`))
-  }
-
-  // 📖 Patch models.json to add all NVIDIA models (fixes "not allowed" errors)
-  const patchResult = patchOpenClawModelsJson()
-  if (patchResult.wasPatched) {
-    console.log(chalk.dim(`  ✨ Added ${patchResult.added} NVIDIA models to allowlist (${patchResult.total} total)`))
-    if (patchResult.backup) {
-      console.log(chalk.dim(`  💾 models.json backup: ${patchResult.backup}`))
-    }
-  }
-
-  // 📖 Ensure models.providers section exists with nvidia NIM block.
-  // 📖 Per OpenClaw docs (docs.openclaw.ai/providers/nvidia), providers MUST be nested under
-  // 📖 "models.providers", NOT at the config root. Root-level "providers" is ignored by OpenClaw.
-  // 📖 API key is NOT stored in the provider block — it's read from env var NVIDIA_API_KEY.
-  // 📖 If needed, it can be stored under the root "env" key: { env: { NVIDIA_API_KEY: "nvapi-..." } }
-  if (!config.models) config.models = {}
-  if (!config.models.providers) config.models.providers = {}
-  if (!config.models.providers.nvidia) {
-    config.models.providers.nvidia = {
-      baseUrl: 'https://integrate.api.nvidia.com/v1',
-      api: 'openai-completions',
-      models: [],
-    }
-    // 📖 Color provider name the same way as in the main table
-    const providerRgb = PROVIDER_COLOR['nvidia'] ?? [105, 190, 245]
-    const coloredProviderName = chalk.bold.rgb(...providerRgb)('nvidia')
-    console.log(chalk.dim(`  ➕ Added ${coloredProviderName} provider block to OpenClaw config (models.providers.nvidia)`))
-  }
-  // 📖 Ensure models array exists even if the provider block was created by an older version
-  if (!Array.isArray(config.models.providers.nvidia.models)) {
-    config.models.providers.nvidia.models = []
-  }
+  try {
+    const result = installProviderEndpoints(config, model.providerKey, 'openclaw', {
+      scope: 'selected',
+      modelIds: [model.modelId],
+      track: false,
+      paths: options.paths,
+    })
 
-  // 📖 Store API key in the root "env" section so OpenClaw can read it as NVIDIA_API_KEY env var.
-  // 📖 Only writes if not already set to avoid overwriting an existing key.
-  const resolvedKey = apiKey || process.env.NVIDIA_API_KEY
-  if (resolvedKey) {
-    if (!config.env) config.env = {}
-    if (!config.env.NVIDIA_API_KEY) {
-      config.env.NVIDIA_API_KEY = resolvedKey
-      console.log(chalk.dim('  🔑 Stored NVIDIA_API_KEY in config env section'))
-    }
+    const providerEnvName = ENV_VAR_NAMES[model.providerKey]
+    console.log(chalk.rgb(255, 140, 0)(`  ✓ Default model set to: ${result.primaryModelRef || `${result.providerId}/${model.modelId}`}`))
+    console.log()
+    console.log(chalk.dim(`  📄 Config updated: ${result.path}`))
+    if (result.backupPath) console.log(chalk.dim(`  💾 Backup: ${result.backupPath}`))
+    if (providerEnvName) console.log(chalk.dim(`  🔑 API key synced under config env.${providerEnvName}`))
+    console.log()
+    console.log(chalk.dim('  💡 OpenClaw will reload config automatically when it notices the file change.'))
+    console.log(chalk.dim(`     To apply manually: openclaw models set ${result.primaryModelRef || `${result.providerId}/${model.modelId}`}`))
+    console.log()
+    return result
+  } catch (error) {
+    console.log(chalk.red(`  X Could not configure OpenClaw: ${error instanceof Error ? error.message : String(error)}`))
+    console.log()
+    return null
   }
-
-  // 📖 Set as the default primary model for all agents.
-  // 📖 Format: "provider/model-id" — e.g. "nvidia/deepseek-ai/deepseek-v3.2"
-  if (!config.agents) config.agents = {}
-  if (!config.agents.defaults) config.agents.defaults = {}
-  if (!config.agents.defaults.model) config.agents.defaults.model = {}
-  config.agents.defaults.model.primary = `nvidia/${model.modelId}`
-
-  // 📖 REQUIRED: OpenClaw requires the model to be explicitly listed in agents.defaults.models
-  // 📖 (the allowlist). Without this entry, OpenClaw rejects the model with "not allowed".
-  // 📖 See: https://docs.openclaw.ai/gateway/configuration-reference
-  if (!config.agents.defaults.models) config.agents.defaults.models = {}
-  config.agents.defaults.models[`nvidia/${model.modelId}`] = {}
-
-  saveOpenClawConfig(config)
-
-  console.log(chalk.rgb(255, 140, 0)(`  ✓ Default model set to: nvidia/${model.modelId}`))
-  console.log()
-  console.log(chalk.dim('  📄 Config updated: ' + OPENCLAW_CONFIG))
-  console.log()
-  // 📖 "openclaw restart" does NOT exist. The gateway auto-reloads on config file changes.
-  // 📖 To apply manually: use "openclaw models set" or "openclaw configure"
-  // 📖 See: https://docs.openclaw.ai/gateway/configuration
-  console.log(chalk.dim('  💡 OpenClaw will reload config automatically (gateway.reload.mode).'))
-  console.log(chalk.dim('     To apply manually: openclaw models set nvidia/' + model.modelId))
-  console.log(chalk.dim('     Or run the setup wizard: openclaw configure'))
-  console.log()
 }

package/src/opencode-config.js

@@ -0,0 +1,48 @@
+/**
+ * @file src/opencode-config.js
+ * @description Small filesystem helpers for the shared OpenCode config file.
+ *
+ * @details
+ *   📖 The app still needs a stable way to read and write `opencode.json`
+ *   📖 for direct OpenCode CLI and Desktop launches.
+ *   📖 This module deliberately stays tiny so OpenCode launch code is not
+ *   📖 coupled to old bridge-specific sync behavior anymore.
+ *
+ * @functions
+ *   → `loadOpenCodeConfig` — read `~/.config/opencode/opencode.json` safely
+ *   → `saveOpenCodeConfig` — write `opencode.json` with a simple backup
+ *   → `restoreOpenCodeBackup` — restore the last `.bak` copy if needed
+ *
+ * @exports loadOpenCodeConfig, saveOpenCodeConfig, restoreOpenCodeBackup
+ */
+
+import { readFileSync, writeFileSync, copyFileSync, existsSync, mkdirSync } from 'node:fs'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+
+const OPENCODE_CONFIG_DIR = join(homedir(), '.config', 'opencode')
+const OPENCODE_CONFIG_PATH = join(OPENCODE_CONFIG_DIR, 'opencode.json')
+const OPENCODE_BACKUP_PATH = join(OPENCODE_CONFIG_DIR, 'opencode.json.bak')
+
+export function loadOpenCodeConfig() {
+  try {
+    if (existsSync(OPENCODE_CONFIG_PATH)) {
+      return JSON.parse(readFileSync(OPENCODE_CONFIG_PATH, 'utf8'))
+    }
+  } catch {}
+  return {}
+}
+
+export function saveOpenCodeConfig(config) {
+  mkdirSync(OPENCODE_CONFIG_DIR, { recursive: true })
+  if (existsSync(OPENCODE_CONFIG_PATH)) {
+    copyFileSync(OPENCODE_CONFIG_PATH, OPENCODE_BACKUP_PATH)
+  }
+  writeFileSync(OPENCODE_CONFIG_PATH, JSON.stringify(config, null, 2) + '\n')
+}
+
+export function restoreOpenCodeBackup() {
+  if (!existsSync(OPENCODE_BACKUP_PATH)) return false
+  copyFileSync(OPENCODE_BACKUP_PATH, OPENCODE_CONFIG_PATH)
+  return true
+}