codeblog-app 2.8.2 → 2.9.5

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,118 @@ 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 CompanionConfig {
+    enabled?: boolean
+    intervalMinutes?: number  // default 120
+    minSessionMessages?: number  // default 10, skip sessions shorter than this
+  }
+
+  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
+    companion?: CompanionConfig
   }
 
   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 +124,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 +141,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/index.ts

@@ -32,6 +32,7 @@ import { ForumCommand } from "./cli/cmd/forum"
 import { UninstallCommand } from "./cli/cmd/uninstall"
 import { McpCommand } from "./cli/cmd/mcp"
 import { DailyCommand } from "./cli/cmd/daily"
+import { CompanionCommand } from "./cli/cmd/companion"
 
 const VERSION = (await import("../package.json")).version
 
@@ -109,7 +110,8 @@ const cli = yargs(hideBin(process.argv))
     "  Scan & Publish:\n" +
     "    scan               Scan local IDE sessions\n" +
     "    publish            Auto-generate and publish a post\n" +
-    "    daily              Generate daily coding report (Day in Code)\n\n" +
+    "    daily              Generate daily coding report (Day in Code)\n" +
+    "    companion          Background AI companion (start/stop/status/run)\n\n" +
     "  Personal & Social:\n" +
     "    me                 Dashboard, posts, notifications, bookmarks, follow\n" +
     "    agent              Manage agents (list, create, delete)\n" +
@@ -149,6 +151,7 @@ const cli = yargs(hideBin(process.argv))
   .command({ ...UninstallCommand, describe: false })
   .command({ ...McpCommand, describe: false })
   .command({ ...DailyCommand, describe: false })
+  .command({ ...CompanionCommand, describe: false })
 
   .fail((msg, err) => {
     if (

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)

package/src/tui/routes/model.tsx

@@ -46,7 +46,7 @@ export function ModelPicker(props: { onDone: (model?: string) => void }) {
       const cfg = await Config.load()
       const resolved = resolveModelFromConfig(cfg) || AIProvider.DEFAULT_MODEL
       setCurrent(resolved)
-      if (cfg.model !== resolved) await Config.save({ model: resolved })
+      if (cfg.cli?.model !== resolved) await Config.save({ cli: { model: resolved } })
 
       setStatus("Fetching models from API...")
       const all = await AIProvider.available()
@@ -130,7 +130,7 @@ export function ModelPicker(props: { onDone: (model?: string) => void }) {
       const item = filtered().find((m) => m.id === id)
       const saveId = item && item.provider === "openai-compatible" ? `openai-compatible/${id}` : id
       const { Config } = await import("../../config")
-      await Config.save({ model: saveId })
+      await Config.save({ cli: { model: saveId } })
       props.onDone(saveId)
     } catch {
       props.onDone()