codeblog-app 2.8.2 → 2.9.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "codeblog-app",
-  "version": "2.8.2",
+  "version": "2.9.0",
   "description": "CLI client for CodeBlog — Agent Only Coding Society",
   "type": "module",
   "license": "MIT",
@@ -58,11 +58,11 @@
     "typescript": "5.8.2"
   },
   "optionalDependencies": {
-    "codeblog-app-darwin-arm64": "2.8.2",
-    "codeblog-app-darwin-x64": "2.8.2",
-    "codeblog-app-linux-arm64": "2.8.2",
-    "codeblog-app-linux-x64": "2.8.2",
-    "codeblog-app-windows-x64": "2.8.2"
+    "codeblog-app-darwin-arm64": "2.9.0",
+    "codeblog-app-darwin-x64": "2.9.0",
+    "codeblog-app-linux-arm64": "2.9.0",
+    "codeblog-app-linux-x64": "2.9.0",
+    "codeblog-app-windows-x64": "2.9.0"
   },
   "dependencies": {
     "@ai-sdk/anthropic": "^3.0.44",
@@ -73,7 +73,7 @@
     "@opentui/core": "^0.1.79",
     "@opentui/solid": "^0.1.79",
     "ai": "^6.0.86",
-    "codeblog-mcp": "2.8.2",
+    "codeblog-mcp": "2.9.0",
     "drizzle-orm": "1.0.0-beta.12-a5629fb",
     "fuzzysort": "^3.1.0",
     "hono": "4.10.7",

package/src/ai/__tests__/compat.test.ts

@@ -16,7 +16,7 @@ describe("AI Compat", () => {
     const compat = resolveCompat({
       providerID: "openai-compatible",
       modelID: "claude-sonnet-4-20250514",
-      providerConfig: { api_key: "x", api: "anthropic", compat_profile: "anthropic" },
+      providerConfig: { apiKey: "x", apiType: "anthropic", compatProfile: "anthropic" },
     })
     expect(compat.api).toBe("anthropic")
     expect(compat.compatProfile).toBe("anthropic")

package/src/ai/__tests__/provider-registry.test.ts

@@ -11,25 +11,29 @@ describe("provider-registry", () => {
 
   test("routes explicit provider/model first", async () => {
     const route = await routeModel("openai/gpt-4o", {
-      api_url: "https://codeblog.ai",
-      providers: {
-        openai: { api_key: "sk-openai" },
+      serverUrl: "https://codeblog.ai",
+      cli: {
+        providers: {
+          openai: { apiKey: "sk-openai" },
+        },
       },
     })
     expect(route.providerID).toBe("openai")
     expect(route.modelID).toBe("gpt-4o")
   })
 
-  test("routes by default_provider for unknown model", async () => {
+  test("routes by defaultProvider for unknown model", async () => {
     const route = await routeModel("deepseek-chat", {
-      api_url: "https://codeblog.ai",
-      default_provider: "openai-compatible",
-      providers: {
-        "openai-compatible": {
-          api_key: "sk-compat",
-          base_url: "https://api.deepseek.com",
-          api: "openai-compatible",
-          compat_profile: "openai-compatible",
+      serverUrl: "https://codeblog.ai",
+      cli: {
+        defaultProvider: "openai-compatible",
+        providers: {
+          "openai-compatible": {
+            apiKey: "sk-compat",
+            baseUrl: "https://api.deepseek.com",
+            apiType: "openai-compatible",
+            compatProfile: "openai-compatible",
+          },
         },
       },
     })
@@ -39,20 +43,24 @@ describe("provider-registry", () => {
 
   test("unknown model throws deterministic actionable error", async () => {
     await expect(routeModel("unknown-model-x", {
-      api_url: "https://codeblog.ai",
-      providers: {
-        openai: { api_key: "sk-openai" },
+      serverUrl: "https://codeblog.ai",
+      cli: {
+        providers: {
+          openai: { apiKey: "sk-openai" },
+        },
       },
     })).rejects.toThrow('Unknown model "unknown-model-x"')
   })
 
   test("multi-provider routing is deterministic by prefix", async () => {
     const route = await routeModel("gpt-4o-mini", {
-      api_url: "https://codeblog.ai",
-      default_provider: "openai-compatible",
-      providers: {
-        openai: { api_key: "sk-openai" },
-        "openai-compatible": { api_key: "sk-compat", base_url: "https://api.deepseek.com" },
+      serverUrl: "https://codeblog.ai",
+      cli: {
+        defaultProvider: "openai-compatible",
+        providers: {
+          openai: { apiKey: "sk-openai" },
+          "openai-compatible": { apiKey: "sk-compat", baseUrl: "https://api.deepseek.com" },
+        },
       },
     })
     expect(route.providerID).toBe("openai")
@@ -61,11 +69,13 @@ describe("provider-registry", () => {
 
   test("legacy model id is normalized to stable default", async () => {
     const route = await routeModel(undefined, {
-      api_url: "https://codeblog.ai",
-      default_provider: "openai",
-      model: "4.0Ultra",
-      providers: {
-        openai: { api_key: "sk-openai" },
+      serverUrl: "https://codeblog.ai",
+      cli: {
+        defaultProvider: "openai",
+        model: "4.0Ultra",
+        providers: {
+          openai: { apiKey: "sk-openai" },
+        },
       },
     })
     expect(route.providerID).toBe("openai")
@@ -74,10 +84,12 @@ describe("provider-registry", () => {
 
   test("missing model uses provider-specific default", async () => {
     const route = await routeModel(undefined, {
-      api_url: "https://codeblog.ai",
-      default_provider: "openai",
-      providers: {
-        openai: { api_key: "sk-openai" },
+      serverUrl: "https://codeblog.ai",
+      cli: {
+        defaultProvider: "openai",
+        providers: {
+          openai: { apiKey: "sk-openai" },
+        },
       },
     })
     expect(route.providerID).toBe("openai")
@@ -86,10 +98,12 @@ describe("provider-registry", () => {
 
   test("missing model on openai-compatible keeps provider prefix", async () => {
     const route = await routeModel(undefined, {
-      api_url: "https://codeblog.ai",
-      default_provider: "openai-compatible",
-      providers: {
-        "openai-compatible": { api_key: "sk-compat", base_url: "https://example.com/v1", api: "openai-compatible" },
+      serverUrl: "https://codeblog.ai",
+      cli: {
+        defaultProvider: "openai-compatible",
+        providers: {
+          "openai-compatible": { apiKey: "sk-compat", baseUrl: "https://example.com/v1", apiType: "openai-compatible" },
+        },
       },
     })
     expect(route.providerID).toBe("openai-compatible")

package/src/ai/__tests__/provider.test.ts

@@ -7,7 +7,7 @@ import { Config } from "../../config"
 describe("AIProvider", () => {
   const originalEnv = { ...process.env }
   const testHome = path.join(os.tmpdir(), `codeblog-provider-test-${process.pid}-${Date.now()}`)
-  const configFile = path.join(testHome, ".config", "codeblog", "config.json")
+  const configFile = path.join(testHome, ".codeblog", "config.json")
   const xdgData = path.join(testHome, ".local", "share")
   const xdgCache = path.join(testHome, ".cache")
   const xdgConfig = path.join(testHome, ".config")
@@ -207,7 +207,7 @@ describe("AIProvider", () => {
 
   test("getModel throws when no API key for builtin model", async () => {
     const load = Config.load
-    Config.load = async () => ({ api_url: "https://codeblog.ai" })
+    Config.load = async () => ({ serverUrl: "https://codeblog.ai" })
     try {
       await expect(AIProvider.getModel("gpt-4o")).rejects.toThrow("No API key for openai")
     } finally {
@@ -215,10 +215,10 @@ describe("AIProvider", () => {
     }
   })
 
-  test("getModel falls back to provider with base_url for unknown model", async () => {
-    // When a provider with base_url is configured, unknown models get sent there
+  test("getModel falls back to provider with baseUrl for unknown model", async () => {
+    // When a provider with baseUrl is configured, unknown models get sent there
     // instead of throwing. This test verifies the fallback behavior.
-    // If no provider has a base_url, it would throw.
+    // If no provider has a baseUrl, it would throw.
     const result = AIProvider.getModel("nonexistent-model-xyz")
     // Either resolves (provider with base_url available) or rejects
     const settled = await Promise.allSettled([result])

package/src/ai/codeblog-provider.ts

@@ -45,7 +45,7 @@ type FetchFn = (
 
 export async function getCodeblogFetch(): Promise<FetchFn> {
   const cfg = await Config.load()
-  const proxyURL = (cfg.providers?.codeblog?.base_url || `${(await Config.url()).replace(/\/+$/, "")}/api/v1/ai-credit/chat`).replace(/\/+$/, "")
+  const proxyURL = (cfg.cli?.providers?.codeblog?.baseUrl || `${(await Config.url()).replace(/\/+$/, "")}/api/v1/ai-credit/chat`).replace(/\/+$/, "")
 
   return async (input, init) => {
     const headers = new Headers(init?.headers)

package/src/ai/configure.ts

@@ -90,29 +90,29 @@ export async function saveProvider(url: string, key: string): Promise<{ provider
     process.env[envBase] = url
 
     const cfg = await Config.load()
-    const providers = cfg.providers || {}
+    const providers = cfg.cli?.providers || {}
     providers[provider] = {
-      api_key: key,
-      base_url: url,
-      api: detected === "anthropic" ? "anthropic" : "openai-compatible",
-      compat_profile: detected === "anthropic" ? "anthropic" : "openai-compatible",
+      apiKey: key,
+      baseUrl: url,
+      apiType: detected === "anthropic" ? "anthropic" : "openai-compatible",
+      compatProfile: detected === "anthropic" ? "anthropic" : "openai-compatible",
     }
 
     // Auto-set model if not already configured
-    const update: Record<string, unknown> = { providers, default_provider: provider }
-    if (!cfg.model) {
+    const cliUpdate: Record<string, unknown> = { providers, defaultProvider: provider }
+    if (!cfg.cli?.model) {
       const { defaultModelForProvider } = await import("./models")
       if (detected === "anthropic") {
-        update.model = defaultModelForProvider("anthropic")
+        cliUpdate.model = defaultModelForProvider("anthropic")
       } else {
         // For openai-compatible with custom URL, try to fetch available models
         const model = await fetchFirstModel(url, key)
-        if (model) update.model = `openai-compatible/${model}`
-        else update.model = `openai-compatible/${defaultModelForProvider("openai-compatible")}`
+        if (model) cliUpdate.model = `openai-compatible/${model}`
+        else cliUpdate.model = `openai-compatible/${defaultModelForProvider("openai-compatible")}`
       }
     }
 
-    await Config.save(update)
+    await Config.save({ cli: cliUpdate })
     return { provider: `${detected} format` }
   }
 
@@ -120,21 +120,21 @@ export async function saveProvider(url: string, key: string): Promise<{ provider
   if (ENV_MAP[provider]) process.env[ENV_MAP[provider]] = key
 
   const cfg = await Config.load()
-  const providers = cfg.providers || {}
+  const providers = cfg.cli?.providers || {}
   providers[provider] = {
-    api_key: key,
-    api: provider === "anthropic" ? "anthropic" : provider === "google" ? "google" : provider === "openai" ? "openai" : "openai-compatible",
-    compat_profile: provider === "anthropic" ? "anthropic" : provider === "google" ? "google" : provider === "openai" ? "openai" : "openai-compatible",
+    apiKey: key,
+    apiType: provider === "anthropic" ? "anthropic" : provider === "google" ? "google" : provider === "openai" ? "openai" : "openai-compatible",
+    compatProfile: provider === "anthropic" ? "anthropic" : provider === "google" ? "google" : provider === "openai" ? "openai" : "openai-compatible",
   }
 
   // Auto-set model for known providers
-  const update: Record<string, unknown> = { providers, default_provider: provider }
-  if (!cfg.model) {
+  const cliUpdate2: Record<string, unknown> = { providers, defaultProvider: provider }
+  if (!cfg.cli?.model) {
     const { defaultModelForProvider } = await import("./models")
-    update.model = defaultModelForProvider(provider)
+    cliUpdate2.model = defaultModelForProvider(provider)
   }
 
-  await Config.save(update)
+  await Config.save({ cli: cliUpdate2 })
   return { provider }
 }
 

package/src/ai/models.ts

@@ -49,11 +49,11 @@ export function defaultModelForProvider(providerID?: string): string {
   return PROVIDER_DEFAULT_MODEL[providerID] || DEFAULT_MODEL
 }
 
-export function resolveModelFromConfig(cfg: { model?: string; default_provider?: string }): string {
-  const model = normalizeModelID(cfg.model)
+export function resolveModelFromConfig(cfg: { cli?: { model?: string; defaultProvider?: string } }): string {
+  const model = normalizeModelID(cfg.cli?.model)
   if (model) return model
-  const fallback = defaultModelForProvider(cfg.default_provider)
-  if (cfg.default_provider === "openai-compatible" && !fallback.includes("/")) {
+  const fallback = defaultModelForProvider(cfg.cli?.defaultProvider)
+  if (cfg.cli?.defaultProvider === "openai-compatible" && !fallback.includes("/")) {
     return `openai-compatible/${fallback}`
   }
   return fallback

package/src/ai/provider-registry.ts

@@ -49,7 +49,7 @@ function readFirstEnv(keys: string[]): string | undefined {
 
 export async function loadProviders(cfgInput?: Config.CodeblogConfig): Promise<ProviderRegistryView> {
   const cfg = cfgInput || await Config.load()
-  const user = cfg.providers || {}
+  const user = cfg.cli?.providers || {}
   const ids = new Set<string>([
     ...Object.keys(PROVIDER_ENV),
     ...Object.keys(user),
@@ -62,12 +62,12 @@ export async function loadProviders(cfgInput?: Config.CodeblogConfig): Promise<P
     providers[id] = {
       id,
       config,
-      apiKey: readFirstEnv(PROVIDER_ENV[id] || []) || config?.api_key,
-      baseURL: readFirstEnv(PROVIDER_BASE_URL_ENV[id] || []) || config?.base_url,
+      apiKey: readFirstEnv(PROVIDER_ENV[id] || []) || config?.apiKey,
+      baseURL: readFirstEnv(PROVIDER_BASE_URL_ENV[id] || []) || config?.baseUrl,
     }
   }
 
-  return { providers, defaultProvider: cfg.default_provider }
+  return { providers, defaultProvider: cfg.cli?.defaultProvider }
 }
 
 function availableProvidersWithKeys(providers: Record<string, ProviderRuntimeConfig>): string[] {

package/src/ai/provider.ts

@@ -40,7 +40,7 @@ export namespace AIProvider {
       if (process.env[key]) return process.env[key]
     }
     const cfg = await Config.load()
-    return cfg.providers?.[providerID]?.api_key
+    return cfg.cli?.providers?.[providerID]?.apiKey
   }
 
   export async function getBaseUrl(providerID: string): Promise<string | undefined> {
@@ -49,7 +49,7 @@ export namespace AIProvider {
       if (process.env[key]) return process.env[key]
     }
     const cfg = await Config.load()
-    return cfg.providers?.[providerID]?.base_url
+    return cfg.cli?.providers?.[providerID]?.baseUrl
   }
 
   export async function listProviders(): Promise<Record<string, { name: string; models: string[]; hasKey: boolean }>> {
@@ -89,7 +89,7 @@ export namespace AIProvider {
   }
 
   export async function getModel(modelID?: string): Promise<LanguageModel> {
-    const useRegistry = await Config.featureEnabled("ai_provider_registry_v2")
+    const useRegistry = await Config.featureEnabled("aiProviderRegistryV2")
     if (useRegistry) {
       const route = await routeModel(modelID)
       const customFetch = route.providerID === "codeblog" ? await loadCodeblogFetch() : undefined
@@ -99,7 +99,7 @@ export namespace AIProvider {
   }
 
   export async function resolveModelCompat(modelID?: string): Promise<ModelCompatConfig> {
-    const useRegistry = await Config.featureEnabled("ai_provider_registry_v2")
+    const useRegistry = await Config.featureEnabled("aiProviderRegistryV2")
     if (useRegistry) return (await routeModel(modelID)).compat
     return (await resolveLegacyRoute(modelID)).compat
   }
@@ -130,7 +130,7 @@ export namespace AIProvider {
         modelID: requested,
         apiKey,
         baseURL,
-        compat: resolveCompat({ providerID: builtin.providerID, modelID: requested, providerConfig: cfg.providers?.[builtin.providerID] }),
+        compat: resolveCompat({ providerID: builtin.providerID, modelID: requested, providerConfig: cfg.cli?.providers?.[builtin.providerID] }),
       }
     }
 
@@ -145,20 +145,20 @@ export namespace AIProvider {
         modelID,
         apiKey,
         baseURL,
-        compat: resolveCompat({ providerID: providerID!, modelID, providerConfig: cfg.providers?.[providerID!] }),
+        compat: resolveCompat({ providerID: providerID!, modelID, providerConfig: cfg.cli?.providers?.[providerID!] }),
       }
     }
 
-    if (cfg.providers) {
-      for (const [providerID, p] of Object.entries(cfg.providers)) {
-        if (!p.api_key) continue
-        const baseURL = p.base_url || (await getBaseUrl(providerID))
+    if (cfg.cli?.providers) {
+      for (const [providerID, p] of Object.entries(cfg.cli.providers)) {
+        if (!p.apiKey) continue
+        const baseURL = p.baseUrl || (await getBaseUrl(providerID))
         if (!baseURL) continue
-        log.info("legacy fallback: unknown model routed to first provider with base_url", { provider: providerID, model: requested })
+        log.info("legacy fallback: unknown model routed to first provider with baseUrl", { provider: providerID, model: requested })
         return {
           providerID,
           modelID: requested,
-          apiKey: p.api_key,
+          apiKey: p.apiKey,
           baseURL,
           compat: resolveCompat({ providerID, modelID: requested, providerConfig: p }),
         }

package/src/ai/types.ts

@@ -50,10 +50,10 @@ function isOfficialOpenAIBase(baseURL?: string): boolean {
 }
 
 function resolveApiFromProvider(providerID: string, cfg?: Config.ProviderConfig): ModelApi {
-  if (providerID === "openai" && cfg?.base_url && !isOfficialOpenAIBase(cfg.base_url)) {
+  if (providerID === "openai" && cfg?.baseUrl && !isOfficialOpenAIBase(cfg.baseUrl)) {
     return "openai-compatible"
   }
-  if (cfg?.api) return cfg.api
+  if (cfg?.apiType) return cfg.apiType
   if (providerID === "anthropic") return "anthropic"
   if (providerID === "openai") return "openai"
   if (providerID === "google") return "google"
@@ -74,7 +74,7 @@ export function resolveCompat(args: {
   providerConfig?: Config.ProviderConfig
 }): ModelCompatConfig {
   const api = resolveApiFromProvider(args.providerID, args.providerConfig)
-  const configured = args.providerConfig?.compat_profile
+  const configured = args.providerConfig?.compatProfile
   const compatProfile = api === "openai-compatible" && configured === "openai"
     ? "openai-compatible"
     : configured || defaultCompatForApi(api)

package/src/auth/index.ts

@@ -1,7 +1,5 @@
-import path from "path"
-import { chmod, writeFile } from "fs/promises"
-import { Global } from "../global"
 import z from "zod"
+import { Config } from "../config"
 
 export namespace Auth {
   export const Token = z
@@ -14,36 +12,27 @@ export namespace Auth {
     .meta({ ref: "AuthToken" })
   export type Token = z.infer<typeof Token>
 
-  const filepath = path.join(Global.Path.data, "auth.json")
-
   export async function get(): Promise<Token | null> {
-    const file = Bun.file(filepath)
-    const data = await file.json().catch(() => null)
-    if (!data) return null
-    const parsed = Token.safeParse(data)
-    if (!parsed.success) return null
-    return parsed.data
+    const cfg = await Config.load()
+    if (!cfg.auth?.apiKey) return null
+    return { type: "apikey", value: cfg.auth.apiKey, username: cfg.auth.username }
   }
 
   export async function set(token: Token) {
-    await writeFile(filepath, JSON.stringify(token, null, 2))
-    await chmod(filepath, 0o600).catch(() => {})
+    await Config.save({ auth: { apiKey: token.value, username: token.username } })
   }
 
   export async function remove() {
-    const fs = await import("fs/promises")
-    await fs.unlink(filepath).catch(() => {})
+    await Config.save({ auth: { apiKey: undefined, userId: undefined, activeAgent: undefined, username: undefined } })
   }
 
   export async function header(): Promise<Record<string, string>> {
     const token = await get()
     if (!token) return {}
-    if (token.type === "apikey") return { Authorization: `Bearer ${token.value}` }
     return { Authorization: `Bearer ${token.value}` }
   }
 
   export async function authenticated(): Promise<boolean> {
-    const token = await get()
-    return token !== null
+    return (await get()) !== null
   }
 }

package/src/auth/oauth.ts

@@ -1,6 +1,5 @@
 import { Auth } from "./index"
 import { Config } from "../config"
-import { McpBridge } from "../mcp/client"
 import { Server } from "../server"
 import { Log } from "../util/log"
 
@@ -58,12 +57,6 @@ export namespace OAuth {
             throw new Error(ownerMismatch)
           }
         } else {
-          // Sync API key to MCP config (~/.codeblog/config.json)
-          try {
-            await McpBridge.callTool("codeblog_setup", { api_key: key })
-          } catch (err) {
-            log.warn("failed to sync API key to MCP config", { error: String(err) })
-          }
           log.info("authenticated with api key")
         }
       } else if (token) {

package/src/cli/cmd/config.ts

@@ -86,12 +86,12 @@ export const ConfigCommand: CommandModule = {
 
       if (args.provider && (args.apiKey || args.baseUrl)) {
         const cfg = await Config.load()
-        const providers = cfg.providers || {}
+        const providers = cfg.cli?.providers || {}
         const existing = providers[args.provider as string] || {} as Config.ProviderConfig
-        if (args.apiKey) existing.api_key = args.apiKey as string
-        if (args.baseUrl) existing.base_url = args.baseUrl as string
+        if (args.apiKey) existing.apiKey = args.apiKey as string
+        if (args.baseUrl) existing.baseUrl = args.baseUrl as string
         providers[args.provider as string] = existing
-        await Config.save({ providers })
+        await Config.save({ cli: { providers } })
         const parts: string[] = []
         if (args.apiKey) parts.push("API key")
         if (args.baseUrl) parts.push(`base URL (${args.baseUrl})`)
@@ -100,19 +100,19 @@ export const ConfigCommand: CommandModule = {
       }
 
       if (args.model) {
-        await Config.save({ model: args.model as string })
+        await Config.save({ cli: { model: args.model as string } })
         UI.success(`Default model set to ${args.model}`)
         return
       }
 
       if (args.url) {
-        await Config.save({ api_url: args.url as string })
+        await Config.save({ serverUrl: args.url as string })
         UI.success(`Server URL set to ${args.url}`)
         return
       }
 
       if (args.language) {
-        await Config.save({ default_language: args.language as string })
+        await Config.save({ cli: { defaultLanguage: args.language as string } })
         UI.success(`Default language set to ${args.language}`)
         return
       }
@@ -121,22 +121,22 @@ export const ConfigCommand: CommandModule = {
       const cfg = await Config.load()
       const { resolveModelFromConfig } = await import("../../ai/models")
       const model = resolveModelFromConfig(cfg) || AIProvider.DEFAULT_MODEL
-      const providers = cfg.providers || {}
+      const providers = cfg.cli?.providers || {}
 
       console.log("")
       console.log(`  ${UI.Style.TEXT_NORMAL_BOLD}Current Config${UI.Style.TEXT_NORMAL}`)
       console.log(`  ${UI.Style.TEXT_DIM}${Config.filepath}${UI.Style.TEXT_NORMAL}`)
       console.log("")
       console.log(`  Model:     ${UI.Style.TEXT_HIGHLIGHT}${model}${UI.Style.TEXT_NORMAL}`)
-      console.log(`  API URL:   ${cfg.api_url || "https://codeblog.ai"}`)
-      console.log(`  Language:  ${cfg.default_language || `${UI.Style.TEXT_DIM}(server default)${UI.Style.TEXT_NORMAL}`}`)
+      console.log(`  API URL:   ${cfg.serverUrl || "https://codeblog.ai"}`)
+      console.log(`  Language:  ${cfg.cli?.defaultLanguage || `${UI.Style.TEXT_DIM}(server default)${UI.Style.TEXT_NORMAL}`}`)
       console.log("")
 
       if (Object.keys(providers).length > 0) {
         console.log(`  ${UI.Style.TEXT_NORMAL_BOLD}AI Providers${UI.Style.TEXT_NORMAL}`)
         for (const [id, p] of Object.entries(providers)) {
-          const masked = p.api_key ? p.api_key.slice(0, 8) + "..." : "not set"
-          const url = p.base_url ? ` → ${p.base_url}` : ""
+          const masked = p.apiKey ? p.apiKey.slice(0, 8) + "..." : "not set"
+          const url = p.baseUrl ? ` → ${p.baseUrl}` : ""
           console.log(`    ${UI.Style.TEXT_SUCCESS}✓${UI.Style.TEXT_NORMAL} ${id}: ${UI.Style.TEXT_DIM}${masked}${url}${UI.Style.TEXT_NORMAL}`)
         }
       } else {

package/src/cli/cmd/login.ts

@@ -1,7 +1,6 @@
 import type { CommandModule } from "yargs"
 import { OAuth } from "../../auth/oauth"
 import { Auth } from "../../auth"
-import { McpBridge } from "../../mcp/client"
 import { UI } from "../ui"
 
 export const LoginCommand: CommandModule = {
@@ -23,12 +22,6 @@ export const LoginCommand: CommandModule = {
     if (args.key) {
       const key = args.key as string
       await Auth.set({ type: "apikey", value: key })
-      // Sync API key to MCP config (~/.codeblog/config.json)
-      try {
-        await McpBridge.callTool("codeblog_setup", { api_key: key })
-      } catch {
-        // Non-fatal: MCP sync failed but CLI auth is saved
-      }
       UI.success("Logged in with API key")
       return
     }

package/src/cli/cmd/logout.ts

@@ -1,14 +1,16 @@
 import type { CommandModule } from "yargs"
 import { Auth } from "../../auth"
-import { Config } from "../../config"
 import { UI } from "../ui"
 
 export const LogoutCommand: CommandModule = {
   command: "logout",
   describe: "Logout from CodeBlog",
   handler: async () => {
+    const { McpBridge } = await import("../../mcp/client")
+    const { clearChatToolsCache } = await import("../../ai/tools")
     await Auth.remove()
-    await Config.clearActiveAgent()
+    await McpBridge.disconnect()
+    clearChatToolsCache()
     UI.success("Logged out successfully")
   },
 }