free-coding-models 0.2.4 → 0.2.8

package/src/config.js

@@ -102,7 +102,7 @@
  *   → getProxySettings(config) — Return normalized proxy settings from config
  *   → normalizeEndpointInstalls(endpointInstalls) — Keep tracked endpoint installs stable across app versions
  *
- * @exports loadConfig, saveConfig, getApiKey, isProviderEnabled
+ * @exports loadConfig, saveConfig, validateConfigFile, getApiKey, isProviderEnabled
  * @exports addApiKey, removeApiKey, listApiKeys — multi-key management helpers
  * @exports saveAsProfile, loadProfile, listProfiles, deleteProfile
  * @exports getActiveProfileName, setActiveProfile, getProxySettings, normalizeEndpointInstalls
@@ -112,9 +112,9 @@
  * @see sources.js — provider keys come from Object.keys(sources)
  */
 
-import { readFileSync, writeFileSync, existsSync } from 'fs'
-import { homedir } from 'os'
-import { join } from 'path'
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, statSync, unlinkSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
 
 // 📖 New JSON config path — stores all providers' API keys + enabled state
 export const CONFIG_PATH = join(homedir(), '.free-coding-models.json')
@@ -155,14 +155,26 @@ const ENV_VARS = {
  *   2. If missing, check if ~/.free-coding-models (old plain-text) exists → migrate
  *   3. If neither, return an empty default config
  *
- * 📖 The migration reads the old file as a plain nvidia API key and writes
- *    a proper JSON config. The old file is NOT deleted (safety first).
+ * 📖 Now includes automatic validation and repair from backups if config is corrupted.
  *
  * @returns {{ apiKeys: Record<string,string>, providers: Record<string,{enabled:boolean}>, favorites: string[], telemetry: { enabled: boolean | null, consentVersion: number, anonymousId: string | null } }}
  */
 export function loadConfig() {
   // 📖 Try new JSON config first
   if (existsSync(CONFIG_PATH)) {
+    // 📖 Validate the config file first, try auto-repair if corrupted
+    const validation = validateConfigFile({ autoRepair: true })
+    
+    if (!validation.valid && !validation.repaired) {
+      // 📖 Config is corrupted and repair failed - warn user but continue with empty config
+      console.error(`⚠️  Warning: Config file is corrupted and could not be repaired: ${validation.error}`)
+      console.error('⚠️  Starting with fresh config. Your backups are in ~/.free-coding-models.backups/')
+    }
+
+    if (validation.repaired) {
+      console.log('✅ Config file was corrupted but has been restored from backup.')
+    }
+
     try {
       const raw = readFileSync(CONFIG_PATH, 'utf8').trim()
       const parsed = JSON.parse(raw)
@@ -204,7 +216,10 @@ export function loadConfig() {
         const config = _emptyConfig()
         config.apiKeys.nvidia = oldKey
         // 📖 Auto-save migrated config so next launch is fast
-        saveConfig(config)
+        const result = saveConfig(config)
+        if (!result.success) {
+          console.error(`⚠️  Warning: Failed to save migrated config: ${result.error}`)
+        }
         return config
       }
     } catch {
@@ -220,14 +235,229 @@ export function loadConfig() {
  *
  * 📖 Uses mode 0o600 so the file is only readable by the owning user (API keys!).
  * 📖 Pretty-prints JSON for human readability.
+ * 📖 Now includes:
+ *   - Automatic backup before overwriting (keeps last 5 versions)
+ *   - Verification that write succeeded
+ *   - Explicit error handling (no silent failures)
+ *   - Post-write validation to ensure file is valid JSON
  *
  * @param {{ apiKeys: Record<string,string>, providers: Record<string,{enabled:boolean}>, favorites?: string[], telemetry?: { enabled?: boolean | null, consentVersion?: number, anonymousId?: string | null } }} config
+ * @returns {{ success: boolean, error?: string, backupCreated?: boolean }}
  */
 export function saveConfig(config) {
+  // 📖 Create backup of existing config before overwriting
+  const backupCreated = createBackup()
+
+  try {
+    // 📖 Write the new config
+    const json = JSON.stringify(config, null, 2)
+    writeFileSync(CONFIG_PATH, json, { mode: 0o600 })
+
+    // 📖 Verify the write succeeded by reading back and validating
+    try {
+      const written = readFileSync(CONFIG_PATH, 'utf8')
+      const parsed = JSON.parse(written)
+
+      // 📖 Basic sanity check - ensure apiKeys object exists
+      if (!parsed || typeof parsed !== 'object') {
+        throw new Error('Written config is not a valid object')
+      }
+
+      // 📖 Verify critical data wasn't lost - check ALL keys are preserved
+      if (config.apiKeys && Object.keys(config.apiKeys).length > 0) {
+        if (!parsed.apiKeys) {
+          throw new Error('apiKeys object missing after write')
+        }
+        const originalKeys = Object.keys(config.apiKeys).sort()
+        const writtenKeys = Object.keys(parsed.apiKeys).sort()
+        if (originalKeys.length > writtenKeys.length) {
+          const lostKeys = originalKeys.filter(k => !writtenKeys.includes(k))
+          throw new Error(`API keys lost during write: ${lostKeys.join(', ')}`)
+        }
+        // 📖 Also verify each key's value is not empty
+        for (const key of originalKeys) {
+          if (!parsed.apiKeys[key] || parsed.apiKeys[key].length === 0) {
+            throw new Error(`API key for ${key} is empty after write`)
+          }
+        }
+      }
+
+      return { success: true, backupCreated }
+    } catch (verifyError) {
+      // 📖 Verification failed - this is critical!
+      const errorMsg = `Config verification failed: ${verifyError.message}`
+      
+      // 📖 Try to restore from backup if we have one
+      if (backupCreated) {
+        try {
+          restoreFromBackup()
+          errorMsg += ' (Restored from backup)'
+        } catch (restoreError) {
+          errorMsg += ` (Backup restoration failed: ${restoreError.message})`
+        }
+      }
+
+      return { success: false, error: errorMsg, backupCreated }
+    }
+  } catch (writeError) {
+    // 📖 Write failed - explicit error instead of silent failure
+    const errorMsg = `Failed to write config: ${writeError.message}`
+    
+    // 📖 Try to restore from backup if we have one
+    if (backupCreated) {
+      try {
+        restoreFromBackup()
+        errorMsg += ' (Restored from backup)'
+      } catch (restoreError) {
+        errorMsg += ` (Backup restoration failed: ${restoreError.message})`
+      }
+    }
+
+    return { success: false, error: errorMsg, backupCreated }
+  }
+}
+
+/**
+ * 📖 createBackup: Creates a timestamped backup of the current config file.
+ * 📖 Keeps only the 5 most recent backups to avoid disk space issues.
+ * 📖 Backup files are stored in ~/.free-coding-models.backups/
+ * 
+ * @returns {boolean} true if backup was created, false otherwise
+ */
+function createBackup() {
+  try {
+    if (!existsSync(CONFIG_PATH)) {
+      return false // No file to backup
+    }
+
+    // 📖 Create backup directory if it doesn't exist
+    const backupDir = join(homedir(), '.free-coding-models.backups')
+    if (!existsSync(backupDir)) {
+      mkdirSync(backupDir, { mode: 0o700, recursive: true })
+    }
+
+    // 📖 Create timestamped backup
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '').slice(0, -5) + 'Z'
+    const backupPath = join(backupDir, `config.${timestamp}.json`)
+    const backupContent = readFileSync(CONFIG_PATH, 'utf8')
+    writeFileSync(backupPath, backupContent, { mode: 0o600 })
+
+    // 📖 Clean up old backups (keep only 5 most recent)
+    const backups = readdirSync(backupDir)
+      .filter(f => f.startsWith('config.') && f.endsWith('.json'))
+      .map(f => ({
+        name: f,
+        path: join(backupDir, f),
+        time: statSync(join(backupDir, f)).mtime.getTime()
+      }))
+      .sort((a, b) => b.time - a.time)
+
+    // 📖 Delete old backups beyond the 5 most recent
+    if (backups.length > 5) {
+      for (const oldBackup of backups.slice(5)) {
+        try {
+          unlinkSync(oldBackup.path)
+        } catch {
+          // Ignore cleanup errors
+        }
+      }
+    }
+
+    return true
+  } catch (error) {
+    // 📖 Log but don't fail if backup creation fails
+    console.error(`Warning: Backup creation failed: ${error.message}`)
+    return false
+  }
+}
+
+/**
+ * 📖 restoreFromBackup: Restores the most recent backup.
+ * 📖 Used when config write or verification fails.
+ * 
+ * @throws {Error} if no backup exists or restoration fails
+ */
+function restoreFromBackup() {
+  const backupDir = join(homedir(), '.free-coding-models.backups')
+  
+  if (!existsSync(backupDir)) {
+    throw new Error('No backup directory found')
+  }
+
+  // 📖 Find the most recent backup
+  const backups = readdirSync(backupDir)
+    .filter(f => f.startsWith('config.') && f.endsWith('.json'))
+    .map(f => ({
+      name: f,
+      path: join(backupDir, f),
+      time: statSync(join(backupDir, f)).mtime.getTime()
+    }))
+    .sort((a, b) => b.time - a.time)
+
+  if (backups.length === 0) {
+    throw new Error('No backups available')
+  }
+
+  const latestBackup = backups[0]
+  const backupContent = readFileSync(latestBackup.path, 'utf8')
+  
+  // 📖 Verify backup is valid JSON before restoring
+  JSON.parse(backupContent)
+  
+  // 📖 Restore the backup
+  writeFileSync(CONFIG_PATH, backupContent, { mode: 0o600 })
+}
+
+/**
+ * 📖 validateConfigFile: Checks if the config file is valid JSON.
+ * 📖 Returns validation result and can auto-repair from backups if needed.
+ * 
+ * @param {{ autoRepair?: boolean }} options - If true, attempts to repair using backups
+ * @returns {{ valid: boolean, error?: string, repaired?: boolean }}
+ */
+export function validateConfigFile(options = {}) {
+  const { autoRepair = false } = options
+
   try {
-    writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 })
-  } catch {
-    // 📖 Silently fail — the app is still usable, keys just won't persist
+    if (!existsSync(CONFIG_PATH)) {
+      return { valid: true } // No config file is valid (will be created)
+    }
+
+    const content = readFileSync(CONFIG_PATH, 'utf8')
+    
+    // 📖 Check if file is empty
+    if (!content.trim()) {
+      throw new Error('Config file is empty')
+    }
+
+    // 📖 Try to parse JSON
+    const parsed = JSON.parse(content)
+
+    // 📖 Basic structure validation
+    if (!parsed || typeof parsed !== 'object') {
+      throw new Error('Config is not a valid object')
+    }
+
+    // 📖 Check for critical corruption (apiKeys should be an object if it exists)
+    if (parsed.apiKeys !== null && parsed.apiKeys !== undefined && typeof parsed.apiKeys !== 'object') {
+      throw new Error('apiKeys field is corrupted')
+    }
+
+    return { valid: true }
+  } catch (error) {
+    const errorMsg = `Config validation failed: ${error.message}`
+
+    // 📖 Attempt auto-repair from backup if requested
+    if (autoRepair) {
+      try {
+        restoreFromBackup()
+        return { valid: false, error: errorMsg, repaired: true }
+      } catch (repairError) {
+        return { valid: false, error: `${errorMsg} (Repair failed: ${repairError.message})`, repaired: false }
+      }
+    }
+
+    return { valid: false, error: errorMsg, repaired: false }
   }
 }
 
@@ -524,7 +754,13 @@ export function loadProfile(config, name) {
   const nextSettings = profile.settings ? { ..._emptyProfileSettings(), ...profile.settings, proxy: normalizeProxySettings(profile.settings.proxy) } : _emptyProfileSettings()
 
   // 📖 Deep-copy the profile data into the live config (don't share references)
-  config.apiKeys = JSON.parse(JSON.stringify(profile.apiKeys || {}))
+  // 📖 IMPORTANT: MERGE apiKeys instead of replacing to preserve keys not in profile
+  // 📖 Profile keys take priority over existing keys (allows profile-specific overrides)
+  const profileApiKeys = profile.apiKeys || {}
+  const mergedApiKeys = { ...config.apiKeys || {}, ...profileApiKeys }
+  config.apiKeys = JSON.parse(JSON.stringify(mergedApiKeys))
+
+  // 📖 For providers, favorites: replace with profile values (these are profile-specific settings)
   config.providers = JSON.parse(JSON.stringify(profile.providers || {}))
   config.favorites = [...(profile.favorites || [])]
   config.settings = nextSettings

package/src/constants.js

@@ -74,10 +74,10 @@ export const TIER_CYCLE = [null, 'S+', 'S', 'A+', 'A', 'A-', 'B+', 'B', 'C']
 
 // 📖 Overlay background chalk functions — each overlay panel has a distinct tint
 // 📖 so users can tell Settings, Help, Recommend, and Log panels apart at a glance.
-export const SETTINGS_OVERLAY_BG  = chalk.bgRgb(14, 20, 30)
-export const HELP_OVERLAY_BG      = chalk.bgRgb(24, 16, 32)
-export const RECOMMEND_OVERLAY_BG = chalk.bgRgb(10, 25, 15)  // 📖 Green tint for Smart Recommend
-export const LOG_OVERLAY_BG       = chalk.bgRgb(10, 20, 26)  // 📖 Dark blue-green tint for Log page
+export const SETTINGS_OVERLAY_BG  = chalk.bgRgb(0, 0, 0)
+export const HELP_OVERLAY_BG      = chalk.bgRgb(0, 0, 0)
+export const RECOMMEND_OVERLAY_BG = chalk.bgRgb(0, 0, 0)  // 📖 Green tint for Smart Recommend
+export const LOG_OVERLAY_BG       = chalk.bgRgb(0, 0, 0)  // 📖 Dark blue-green tint for Log page
 
 // 📖 OVERLAY_PANEL_WIDTH: fixed character width of all overlay panels so background
 // 📖 tint fills the panel consistently regardless of content length.

package/src/key-handler.js

@@ -750,6 +750,12 @@ export function createKeyHandler(ctx) {
         state.logVisible = false
         return
       }
+      // 📖 A key: toggle between showing all logs and limited to 500
+      if (key.name === 'a') {
+        state.logShowAll = !state.logShowAll
+        state.logScrollOffset = 0
+        return
+      }
       if (key.name === 'up') { state.logScrollOffset = Math.max(0, state.logScrollOffset - 1); return }
       if (key.name === 'down') { state.logScrollOffset += 1; return }
       if (key.name === 'pageup') { state.logScrollOffset = Math.max(0, state.logScrollOffset - pageStep); return }

package/src/openclaw.js

@@ -23,6 +23,8 @@ import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from
 import { homedir } from 'os'
 import { join } from 'path'
 import { patchOpenClawModelsJson } from '../patch-openclaw-models.js'
+import { sources } from '../sources.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')
@@ -84,7 +86,10 @@ export async function startOpenClaw(model, apiKey) {
       api: 'openai-completions',
       models: [],
     }
-    console.log(chalk.dim('  ➕ Added nvidia provider block to OpenClaw config (models.providers.nvidia)'))
+    // 📖 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)) {

package/src/opencode.js

@@ -38,6 +38,7 @@ import { homedir } from 'os'
 import { join } from 'path'
 import { copyFileSync, existsSync } from 'fs'
 import { sources } from '../sources.js'
+import { PROVIDER_COLOR } from './render-table.js'
 import { resolveCloudflareUrl } from './ping.js'
 import { ProxyServer } from './proxy-server.js'
 import { loadOpenCodeConfig, saveOpenCodeConfig, syncToOpenCode } from './opencode-sync.js'
@@ -268,7 +269,10 @@ export async function startOpenCode(model, fcmConfig) {
         },
         models: {}
       }
-      console.log(chalk.green('  + Auto-configured NVIDIA NIM provider in OpenCode'))
+      // 📖 Color provider name the same way as in the main table
+      const providerRgb = PROVIDER_COLOR['nvidia'] ?? [105, 190, 245]
+      const coloredNimName = chalk.bold.rgb(...providerRgb)('NVIDIA NIM')
+      console.log(chalk.green(`  + Auto-configured ${coloredNimName} provider in OpenCode`))
     }
 
     console.log(chalk.green(`  Setting ${chalk.bold(model.label)} as default...`))
@@ -780,7 +784,10 @@ export async function startOpenCodeDesktop(model, fcmConfig) {
         },
         models: {}
       }
-      console.log(chalk.green('  + Auto-configured NVIDIA NIM provider in OpenCode'))
+      // 📖 Color provider name the same way as in the main table
+      const providerRgb = PROVIDER_COLOR['nvidia'] ?? [105, 190, 245]
+      const coloredNimName = chalk.bold.rgb(...providerRgb)('NVIDIA NIM')
+      console.log(chalk.green(`  + Auto-configured ${coloredNimName} provider in OpenCode`))
     }
 
     console.log(chalk.green(`  Setting ${chalk.bold(model.label)} as default for OpenCode Desktop...`))