codeblog-app 2.8.2 → 2.9.0

package/src/cli/cmd/setup.ts

@@ -356,7 +356,7 @@ function isOfficialOpenAIBase(baseURL: string): boolean {
   }
 }
 
-async function verifyEndpoint(choice: ProviderChoice, baseURL: string, key: string): Promise<{ ok: boolean; detail: string; detectedApi?: Config.ModelApi }> {
+async function verifyEndpoint(choice: ProviderChoice, baseURL: string, key: string): Promise<{ ok: boolean; detail: string; detectedApi?: Config.ApiType }> {
   try {
     if (choice.api === "anthropic") {
       const clean = baseURL.replace(/\/+$/, "")
@@ -383,7 +383,7 @@ async function verifyEndpoint(choice: ProviderChoice, baseURL: string, key: stri
     const detected = await probe(baseURL, key)
     if (detected === "anthropic") return { ok: true, detail: "Detected Anthropic API format", detectedApi: "anthropic" }
     if (detected === "openai") {
-      const detectedApi: Config.ModelApi =
+      const detectedApi: Config.ApiType =
         choice.providerID === "openai" && isOfficialOpenAIBase(baseURL)
           ? "openai"
           : "openai-compatible"
@@ -392,7 +392,7 @@ async function verifyEndpoint(choice: ProviderChoice, baseURL: string, key: stri
 
     const models = await fetchOpenAIModels(baseURL, key)
     if (models.length > 0) {
-      const detectedApi: Config.ModelApi =
+      const detectedApi: Config.ApiType =
         choice.providerID === "openai" && isOfficialOpenAIBase(baseURL)
           ? "openai"
           : "openai-compatible"
@@ -501,18 +501,20 @@ export async function runAISetupWizard(source: "setup" | "command" = "command"):
 
       const proxyURL = `${(await Config.url()).replace(/\/+$/, "")}/api/v1/ai-credit/chat`
       const cfg = await Config.load()
-      const providers = cfg.providers || {}
+      const providers = cfg.cli?.providers || {}
       providers["codeblog"] = {
-        api_key: "proxy",
-        base_url: proxyURL,
-        api: "openai-compatible",
-        compat_profile: "openai-compatible",
+        apiKey: "proxy",
+        baseUrl: proxyURL,
+        apiType: "openai-compatible",
+        compatProfile: "openai-compatible",
       }
 
       await Config.save({
-        providers,
-        default_provider: "codeblog",
-        model: `codeblog/${balance.model}`,
+        cli: {
+          providers,
+          defaultProvider: "codeblog",
+          model: `codeblog/${balance.model}`,
+        },
       })
 
       UI.success(`AI configured: CodeBlog Credit (${balance.model})`)
@@ -567,7 +569,7 @@ export async function runAISetupWizard(source: "setup" | "command" = "command"):
   }
 
   let verified = false
-  let detectedApi: Config.ModelApi | undefined
+  let detectedApi: Config.ApiType | undefined
 
   while (!verified) {
     await shimmerLine("Verifying endpoint...", 900)
@@ -589,17 +591,17 @@ export async function runAISetupWizard(source: "setup" | "command" = "command"):
     return
   }
   const cfg = await Config.load()
-  const providers = cfg.providers || {}
+  const providers = cfg.cli?.providers || {}
   const resolvedApi = detectedApi || provider.api
   const resolvedCompat = provider.providerID === "openai-compatible" && resolvedApi === "openai"
     ? "openai-compatible"
     : resolvedApi
   const providerConfig: Config.ProviderConfig = {
-    api_key: key,
-    api: resolvedApi,
-    compat_profile: resolvedCompat,
+    apiKey: key,
+    apiType: resolvedApi,
+    compatProfile: resolvedCompat,
   }
-  if (baseURL) providerConfig.base_url = baseURL
+  if (baseURL) providerConfig.baseUrl = baseURL
   providers[provider.providerID] = providerConfig
 
   const model = provider.providerID === "openai-compatible" && !selectedModel.includes("/")
@@ -607,9 +609,11 @@ export async function runAISetupWizard(source: "setup" | "command" = "command"):
     : selectedModel
 
   await Config.save({
-    providers,
-    default_provider: provider.providerID,
-    model,
+    cli: {
+      providers,
+      defaultProvider: provider.providerID,
+      model,
+    },
   })
 
   UI.success(`AI configured: ${provider.name} (${model})`)
@@ -763,11 +767,6 @@ async function agentSelectionPrompt(): Promise<void> {
         await Auth.set({ type: "apikey", value: switchData.agent.api_key, username: auth.username })
         await Config.saveActiveAgent(switchData.agent.name, auth.username)
 
-        // Sync to MCP config
-        try {
-          await McpBridge.callTool("codeblog_setup", { api_key: switchData.agent.api_key })
-        } catch {}
-
         UI.success(`Active agent: ${switchData.agent.name}`)
       } else {
         UI.error("Failed to switch agent. You can switch later with: codeblog agent switch")
@@ -864,11 +863,6 @@ async function agentCreationWizard(): Promise<void> {
     await Auth.set({ type: "apikey", value: result.api_key, username: auth?.username })
     await Config.saveActiveAgent(result.name, auth?.username)
 
-    // Sync to MCP config
-    try {
-      await McpBridge.callTool("codeblog_setup", { api_key: result.api_key })
-    } catch {}
-
     console.log("")
     UI.success(`Your agent "${emoji} ${name}" is ready! It'll represent you on CodeBlog.`)
   } catch (err) {

package/src/config/__tests__/config.test.ts

@@ -0,0 +1,222 @@
+import fs from "fs/promises"
+import os from "os"
+import path from "path"
+import { describe, test, expect, beforeAll, beforeEach, afterAll } from "bun:test"
+
+describe("Config unified read/write", () => {
+  const testHome = path.join(os.tmpdir(), `codeblog-config-test-${process.pid}-${Date.now()}`)
+  const configDir = path.join(testHome, ".codeblog")
+  const configFile = path.join(configDir, "config.json")
+
+  let Config: (typeof import("../../config"))["Config"]
+  let Auth: (typeof import("../../auth"))["Auth"]
+
+  beforeAll(async () => {
+    process.env.CODEBLOG_TEST_HOME = testHome
+    await fs.mkdir(configDir, { recursive: true })
+    await fs.writeFile(configFile, "{}\n")
+    ;({ Config } = await import("../../config"))
+    ;({ Auth } = await import("../../auth"))
+  })
+
+  beforeEach(async () => {
+    await fs.writeFile(configFile, "{}\n")
+  })
+
+  afterAll(async () => {
+    await fs.rm(testHome, { recursive: true, force: true })
+    delete process.env.CODEBLOG_TEST_HOME
+  })
+
+  // --- Config.save / Config.load ---
+
+  test("save and load serverUrl at top level", async () => {
+    await Config.save({ serverUrl: "https://test.codeblog.ai" })
+    const cfg = await Config.load()
+    expect(cfg.serverUrl).toBe("https://test.codeblog.ai")
+  })
+
+  test("save and load dailyReportHour at top level", async () => {
+    await Config.save({ dailyReportHour: 18 })
+    const cfg = await Config.load()
+    expect(cfg.dailyReportHour).toBe(18)
+  })
+
+  test("save auth nested fields", async () => {
+    await Config.save({ auth: { apiKey: "cbk_test123", activeAgent: "my-agent", userId: "user123" } })
+    const cfg = await Config.load()
+    expect(cfg.auth?.apiKey).toBe("cbk_test123")
+    expect(cfg.auth?.activeAgent).toBe("my-agent")
+    expect(cfg.auth?.userId).toBe("user123")
+  })
+
+  test("save cli nested fields", async () => {
+    await Config.save({
+      cli: {
+        model: "anthropic/claude-sonnet-4",
+        defaultProvider: "anthropic",
+        providers: {
+          anthropic: { apiKey: "sk-ant-test", apiType: "anthropic", compatProfile: "anthropic" },
+        },
+      },
+    })
+    const cfg = await Config.load()
+    expect(cfg.cli?.model).toBe("anthropic/claude-sonnet-4")
+    expect(cfg.cli?.defaultProvider).toBe("anthropic")
+    expect(cfg.cli?.providers?.anthropic?.apiKey).toBe("sk-ant-test")
+  })
+
+  // --- Deep merge ---
+
+  test("deep merge preserves other sections when saving one", async () => {
+    await Config.save({ auth: { apiKey: "cbk_first" } })
+    await Config.save({ cli: { model: "gpt-5.2" } })
+    const cfg = await Config.load()
+    expect(cfg.auth?.apiKey).toBe("cbk_first")
+    expect(cfg.cli?.model).toBe("gpt-5.2")
+  })
+
+  test("deep merge preserves nested fields within same section", async () => {
+    await Config.save({ auth: { apiKey: "cbk_key", userId: "u1" } })
+    await Config.save({ auth: { activeAgent: "agent1" } })
+    const cfg = await Config.load()
+    expect(cfg.auth?.apiKey).toBe("cbk_key")
+    expect(cfg.auth?.userId).toBe("u1")
+    expect(cfg.auth?.activeAgent).toBe("agent1")
+  })
+
+  test("undefined deletes fields (for Auth.remove)", async () => {
+    await Config.save({ auth: { apiKey: "cbk_key", userId: "u1", activeAgent: "a1" } })
+    await Config.save({ auth: { apiKey: undefined, userId: undefined, activeAgent: undefined } })
+    const cfg = await Config.load()
+    expect(cfg.auth?.apiKey).toBeUndefined()
+    expect(cfg.auth?.userId).toBeUndefined()
+    expect(cfg.auth?.activeAgent).toBeUndefined()
+  })
+
+  test("undefined in auth does not affect cli", async () => {
+    await Config.save({ auth: { apiKey: "cbk_key" }, cli: { model: "gpt-5.2" } })
+    await Config.save({ auth: { apiKey: undefined } })
+    const cfg = await Config.load()
+    expect(cfg.auth?.apiKey).toBeUndefined()
+    expect(cfg.cli?.model).toBe("gpt-5.2")
+  })
+
+  // --- Auth proxy ---
+
+  test("Auth.set writes to config.auth", async () => {
+    await Auth.set({ type: "apikey", value: "cbk_authtest", username: "testuser" })
+    const cfg = await Config.load()
+    expect(cfg.auth?.apiKey).toBe("cbk_authtest")
+    expect(cfg.auth?.username).toBe("testuser")
+  })
+
+  test("Auth.get reads from config.auth", async () => {
+    await Config.save({ auth: { apiKey: "cbk_gettest", username: "user2" } })
+    const token = await Auth.get()
+    expect(token).not.toBeNull()
+    expect(token!.type).toBe("apikey")
+    expect(token!.value).toBe("cbk_gettest")
+    expect(token!.username).toBe("user2")
+  })
+
+  test("Auth.get returns null when no apiKey", async () => {
+    const token = await Auth.get()
+    expect(token).toBeNull()
+  })
+
+  test("Auth.remove clears auth but preserves cli", async () => {
+    await Config.save({ auth: { apiKey: "cbk_rm", userId: "u1" }, cli: { model: "gpt-5.2" } })
+    await Auth.remove()
+    const cfg = await Config.load()
+    expect(cfg.auth?.apiKey).toBeUndefined()
+    expect(cfg.auth?.userId).toBeUndefined()
+    expect(cfg.cli?.model).toBe("gpt-5.2")
+  })
+
+  test("Auth.authenticated returns true/false correctly", async () => {
+    expect(await Auth.authenticated()).toBe(false)
+    await Auth.set({ type: "apikey", value: "cbk_auth" })
+    expect(await Auth.authenticated()).toBe(true)
+    await Auth.remove()
+    expect(await Auth.authenticated()).toBe(false)
+  })
+
+  test("Auth.header returns correct Authorization header", async () => {
+    await Auth.set({ type: "apikey", value: "cbk_hdr" })
+    const header = await Auth.header()
+    expect(header).toEqual({ Authorization: "Bearer cbk_hdr" })
+  })
+
+  test("Auth.header returns empty object when not authenticated", async () => {
+    const header = await Auth.header()
+    expect(header).toEqual({})
+  })
+
+  // --- Config helper functions ---
+
+  test("Config.url reads serverUrl", async () => {
+    await Config.save({ serverUrl: "https://custom.codeblog.ai" })
+    const url = await Config.url()
+    expect(url).toBe("https://custom.codeblog.ai")
+  })
+
+  test("Config.url returns default when not set", async () => {
+    const url = await Config.url()
+    expect(url).toBe("https://codeblog.ai")
+  })
+
+  test("Config.key reads auth.apiKey", async () => {
+    await Config.save({ auth: { apiKey: "cbk_keytest" } })
+    const key = await Config.key()
+    expect(key).toBe("cbk_keytest")
+  })
+
+  test("Config.getActiveAgent reads auth.activeAgent", async () => {
+    await Config.save({ auth: { activeAgent: "my-bot" } })
+    const agent = await Config.getActiveAgent()
+    expect(agent).toBe("my-bot")
+  })
+
+  test("Config.saveActiveAgent writes auth.activeAgent", async () => {
+    await Config.saveActiveAgent("new-bot")
+    const cfg = await Config.load()
+    expect(cfg.auth?.activeAgent).toBe("new-bot")
+  })
+
+  test("Config.clearActiveAgent removes auth.activeAgent", async () => {
+    await Config.save({ auth: { activeAgent: "old-bot", apiKey: "cbk_keep" } })
+    await Config.clearActiveAgent()
+    const cfg = await Config.load()
+    expect(cfg.auth?.activeAgent).toBeUndefined()
+    expect(cfg.auth?.apiKey).toBe("cbk_keep")
+  })
+
+  test("Config.dailyReportHour returns saved value or default 22", async () => {
+    expect(await Config.dailyReportHour()).toBe(22)
+    await Config.save({ dailyReportHour: 8 })
+    expect(await Config.dailyReportHour()).toBe(8)
+  })
+
+  // --- JSON file format ---
+
+  test("config file is valid JSON with correct structure", async () => {
+    await Config.save({
+      serverUrl: "https://codeblog.ai",
+      dailyReportHour: 22,
+      auth: { apiKey: "cbk_json", activeAgent: "bot", userId: "u1" },
+      cli: { model: "gpt-5.2", providers: { openai: { apiKey: "sk-test" } } },
+    })
+    const raw = await fs.readFile(configFile, "utf-8")
+    const parsed = JSON.parse(raw)
+    expect(parsed.serverUrl).toBe("https://codeblog.ai")
+    expect(parsed.dailyReportHour).toBe(22)
+    expect(parsed.auth.apiKey).toBe("cbk_json")
+    expect(parsed.cli.model).toBe("gpt-5.2")
+    expect(parsed.cli.providers.openai.apiKey).toBe("sk-test")
+    // No old flat fields
+    expect(parsed.api_url).toBeUndefined()
+    expect(parsed.apiKey).toBeUndefined()
+    expect(parsed.providers).toBeUndefined()
+  })
+})

package/src/config/index.ts

@@ -5,105 +5,111 @@ import { Global } from "../global"
 const CONFIG_FILE = path.join(Global.Path.config, "config.json")
 
 export namespace Config {
-  export type ModelApi = "anthropic" | "openai" | "google" | "openai-compatible"
+  export type ApiType = "anthropic" | "openai" | "google" | "openai-compatible"
   export type CompatProfile = "anthropic" | "openai" | "openai-compatible" | "google"
 
-  export interface FeatureFlags {
-    ai_provider_registry_v2?: boolean
-    ai_onboarding_wizard_v2?: boolean
+  export interface AuthConfig {
+    apiKey?: string
+    activeAgent?: string
+    userId?: string
+    username?: string
   }
 
   export interface ProviderConfig {
-    api_key: string
-    base_url?: string
-    api?: ModelApi
-    compat_profile?: CompatProfile
+    apiKey: string
+    baseUrl?: string
+    apiType?: ApiType
+    compatProfile?: CompatProfile
   }
 
-  export interface CodeblogConfig {
-    api_url: string
-    api_key?: string
-    token?: string
+  export interface FeatureFlags {
+    aiProviderRegistryV2?: boolean
+    aiOnboardingWizardV2?: boolean
+  }
+
+  export interface CliConfig {
     model?: string
-    default_provider?: string
-    default_language?: string
-    activeAgent?: string
-    active_agents?: Record<string, string>
+    defaultProvider?: string
+    defaultLanguage?: string
+    dailyReportHour?: number
     providers?: Record<string, ProviderConfig>
-    feature_flags?: FeatureFlags
+    featureFlags?: FeatureFlags
+  }
+
+  export interface CodeblogConfig {
+    serverUrl?: string
     dailyReportHour?: number
+    auth?: AuthConfig
+    cli?: CliConfig
   }
 
   const defaults: CodeblogConfig = {
-    api_url: "https://codeblog.ai",
+    serverUrl: "https://codeblog.ai",
   }
 
   export const filepath = CONFIG_FILE
 
   const FEATURE_FLAG_ENV: Record<keyof FeatureFlags, string> = {
-    ai_provider_registry_v2: "CODEBLOG_AI_PROVIDER_REGISTRY_V2",
-    ai_onboarding_wizard_v2: "CODEBLOG_AI_ONBOARDING_WIZARD_V2",
+    aiProviderRegistryV2: "CODEBLOG_AI_PROVIDER_REGISTRY_V2",
+    aiOnboardingWizardV2: "CODEBLOG_AI_ONBOARDING_WIZARD_V2",
+  }
+
+  function deepMerge(target: Record<string, any>, source: Record<string, any>): Record<string, any> {
+    const result = { ...target }
+    for (const key of Object.keys(source)) {
+      const val = source[key]
+      if (val === undefined) {
+        delete result[key]
+      } else if (typeof val === "object" && !Array.isArray(val) && val !== null) {
+        result[key] = deepMerge((result[key] as Record<string, any>) || {}, val)
+      } else {
+        result[key] = val
+      }
+    }
+    return result
   }
 
   export async function load(): Promise<CodeblogConfig> {
     const file = Bun.file(CONFIG_FILE)
     const data = await file.json().catch(() => ({}))
-    return { ...defaults, ...data }
+    return deepMerge(defaults, data) as CodeblogConfig
   }
 
   export async function save(config: Partial<CodeblogConfig>) {
     const current = await load()
-    const merged = { ...current, ...config }
+    const merged = deepMerge(current, config as Record<string, any>)
     await writeFile(CONFIG_FILE, JSON.stringify(merged, null, 2))
     await chmod(CONFIG_FILE, 0o600).catch(() => {})
   }
 
-  export async function getActiveAgent(username?: string) {
+  // --- Auth helpers ---
+
+  export async function getActiveAgent(_username?: string) {
     const cfg = await load()
-    if (username) return cfg.active_agents?.[username] || ""
-    return cfg.activeAgent || ""
+    return cfg.auth?.activeAgent || ""
   }
 
-  export async function saveActiveAgent(agent: string, username?: string) {
+  export async function saveActiveAgent(agent: string, _username?: string) {
     if (!agent.trim()) return
-    if (!username) {
-      await save({ activeAgent: agent })
-      return
-    }
-    const cfg = await load()
-    await save({
-      active_agents: {
-        ...(cfg.active_agents || {}),
-        [username]: agent,
-      },
-    })
-  }
-
-  export async function clearActiveAgent(username?: string) {
-    if (!username) {
-      await save({ activeAgent: "", active_agents: {} })
-      return
-    }
-    const cfg = await load()
-    const map = { ...(cfg.active_agents || {}) }
-    delete map[username]
-    await save({ active_agents: map })
+    await save({ auth: { activeAgent: agent } })
   }
 
-  export async function url() {
-    return process.env.CODEBLOG_URL || (await load()).api_url || "https://codeblog.ai"
+  export async function clearActiveAgent(_username?: string) {
+    await save({ auth: { activeAgent: undefined } })
   }
 
-  export async function key() {
-    return process.env.CODEBLOG_API_KEY || (await load()).api_key || ""
+  // --- Server helpers ---
+
+  export async function url() {
+    return process.env.CODEBLOG_URL || (await load()).serverUrl || "https://codeblog.ai"
   }
 
-  export async function token() {
-    return process.env.CODEBLOG_TOKEN || (await load()).token || ""
+  export async function key() {
+    return process.env.CODEBLOG_API_KEY || (await load()).auth?.apiKey || ""
   }
 
   export async function language() {
-    return process.env.CODEBLOG_LANGUAGE || (await load()).default_language
+    return process.env.CODEBLOG_LANGUAGE || (await load()).cli?.defaultLanguage
   }
 
   export async function dailyReportHour(): Promise<number> {
@@ -111,6 +117,8 @@ export namespace Config {
     return val !== undefined ? val : 22
   }
 
+  // --- Feature flags ---
+
   function parseBool(raw: string | undefined): boolean | undefined {
     if (!raw) return undefined
     const v = raw.trim().toLowerCase()
@@ -126,6 +134,6 @@ export namespace Config {
   export async function featureEnabled(flag: keyof FeatureFlags): Promise<boolean> {
     const env = parseBool(process.env[FEATURE_FLAG_ENV[flag]])
     if (env !== undefined) return env
-    return !!(await load()).feature_flags?.[flag]
+    return !!(await load()).cli?.featureFlags?.[flag]
   }
 }

package/src/global/index.ts

@@ -12,7 +12,7 @@ const localappdata = process.env.LOCALAPPDATA || path.join(home, "AppData", "Loc
 
 const data = win ? path.join(localappdata, app) : path.join(xdgData || path.join(home, ".local", "share"), app)
 const cache = win ? path.join(localappdata, app, "cache") : path.join(xdgCache || path.join(home, ".cache"), app)
-const config = win ? path.join(appdata, app) : path.join(xdgConfig || path.join(home, ".config"), app)
+const config = path.join(home, `.${app}`)
 const state = win ? path.join(localappdata, app, "state") : path.join(xdgState || path.join(home, ".local", "state"), app)
 
 export namespace Global {

package/src/tui/app.tsx

@@ -195,13 +195,13 @@ function App() {
         const { Config } = await import("../config")
         const cfg = await Config.load()
         const model = resolveModelFromConfig(cfg) || AIProvider.DEFAULT_MODEL
-        if (cfg.model !== model) await Config.save({ model })
+        if (cfg.cli?.model !== model) await Config.save({ cli: { model } })
         setModelName(model)
         const info = AIProvider.BUILTIN_MODELS[model]
         setAiProvider(info?.providerID || model.split("/")[0] || "ai")
 
         // Fetch credit balance if using codeblog provider
-        if (cfg.default_provider === "codeblog") {
+        if (cfg.cli?.defaultProvider === "codeblog") {
           try {
             const { fetchCreditBalance } = await import("../ai/codeblog-provider")
             const balance = await fetchCreditBalance()

package/src/tui/commands.ts

@@ -56,7 +56,7 @@ export function createCommands(deps: CommandDeps): CmdDef[] {
       }
 
       const saveId = picked.providerID === "openai-compatible" ? `openai-compatible/${picked.id}` : picked.id
-      await Config.save({ model: saveId })
+      await Config.save({ cli: { model: saveId } })
       deps.onAIConfigured()
       deps.showMsg(`Model switched to ${saveId}`, deps.colors.success)
     }},
@@ -72,7 +72,11 @@ export function createCommands(deps: CommandDeps): CmdDef[] {
     { name: "/logout", description: "Sign out of CodeBlog", action: async () => {
       try {
         const { Auth } = await import("../auth")
+        const { McpBridge } = await import("../mcp/client")
+        const { clearChatToolsCache } = await import("../ai/tools")
         await Auth.remove()
+        await McpBridge.disconnect()
+        clearChatToolsCache()
         deps.showMsg("Logged out.", deps.colors.text)
         deps.onLogout()
       } catch (err) { deps.showMsg(`Logout failed: ${err instanceof Error ? err.message : String(err)}`, deps.colors.error) }

package/src/tui/routes/home.tsx

@@ -306,13 +306,13 @@ export function Home(props: {
         const current = resolveModelFromConfig(cfg) || AIProvider.DEFAULT_MODEL
         const currentBuiltin = AIProvider.BUILTIN_MODELS[current]
         const currentProvider =
-          cfg.default_provider ||
+          cfg.cli?.defaultProvider ||
           (current.includes("/") ? current.split("/")[0] : currentBuiltin?.providerID) ||
           "openai"
-        const providerCfg = cfg.providers?.[currentProvider]
-        const providerApi = providerCfg?.api || providerCfg?.compat_profile || (currentProvider === "openai" ? "openai" : "openai-compatible")
-        const providerKey = providerCfg?.api_key
-        const providerBase = providerCfg?.base_url || (currentProvider === "openai" ? "https://api.openai.com" : "")
+        const providerCfg = cfg.cli?.providers?.[currentProvider]
+        const providerApi = providerCfg?.apiType || providerCfg?.compatProfile || (currentProvider === "openai" ? "openai" : "openai-compatible")
+        const providerKey = providerCfg?.apiKey
+        const providerBase = providerCfg?.baseUrl || (currentProvider === "openai" ? "https://api.openai.com" : "")
 
         const remote = await (async () => {
           if (!providerKey || !providerBase) return [] as string[]
@@ -382,7 +382,7 @@ export function Home(props: {
   async function pickModel(id: string) {
     try {
       const { Config } = await import("../../config")
-      await Config.save({ model: id })
+      await Config.save({ cli: { model: id } })
       props.onAIConfigured()
       showMsg(`Set model to ${id}`, theme.colors.success)
     } catch (err) {
@@ -958,18 +958,20 @@ export function Home(props: {
 
       const proxyURL = `${(await Config.url()).replace(/\/+$/, "")}/api/v1/ai-credit/chat`
       const cfg = await Config.load()
-      const providers = cfg.providers || {}
+      const providers = cfg.cli?.providers || {}
       providers["codeblog"] = {
-        api_key: "proxy",
-        base_url: proxyURL,
-        api: "openai-compatible",
-        compat_profile: "openai-compatible",
+        apiKey: "proxy",
+        baseUrl: proxyURL,
+        apiType: "openai-compatible",
+        compatProfile: "openai-compatible",
       }
 
       await Config.save({
-        providers,
-        default_provider: "codeblog",
-        model: `codeblog/${balance.model}`,
+        cli: {
+          providers,
+          defaultProvider: "codeblog",
+          model: `codeblog/${balance.model}`,
+        },
       })
 
       const msg = claim.already_claimed
@@ -1006,17 +1008,17 @@ export function Home(props: {
 
     const { Config } = await import("../../config")
     const cfg = await Config.load()
-    const providers = cfg.providers || {}
+    const providers = cfg.cli?.providers || {}
     const resolvedApi = verify.detectedApi || choice.api
     const resolvedCompat = choice.providerID === "openai-compatible" && resolvedApi === "openai"
       ? "openai-compatible" as const
       : resolvedApi
-    const providerConfig: { api_key: string; base_url?: string; api: typeof resolvedApi; compat_profile: typeof resolvedCompat } = {
-      api_key: key,
-      api: resolvedApi,
-      compat_profile: resolvedCompat,
+    const providerConfig: { apiKey: string; baseUrl?: string; apiType: typeof resolvedApi; compatProfile: typeof resolvedCompat } = {
+      apiKey: key,
+      apiType: resolvedApi,
+      compatProfile: resolvedCompat,
     }
-    if (baseURL) providerConfig.base_url = baseURL
+    if (baseURL) providerConfig.baseUrl = baseURL
     providers[choice.providerID] = providerConfig
 
     const saveModel = choice.providerID === "openai-compatible" && !model.includes("/")
@@ -1024,9 +1026,11 @@ export function Home(props: {
       : model
 
     await Config.save({
-      providers,
-      default_provider: choice.providerID,
-      model: saveModel,
+      cli: {
+        providers,
+        defaultProvider: choice.providerID,
+        model: saveModel,
+      },
     })
 
     showMsg(`✓ AI configured: ${choice.name} (${saveModel})`, theme.colors.success)