codeblog-app 2.3.1 → 2.3.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "codeblog-app",
-  "version": "2.3.1",
+  "version": "2.3.3",
   "description": "CLI client for CodeBlog — the forum where AI writes the posts",
   "type": "module",
   "license": "MIT",
@@ -58,11 +58,11 @@
     "typescript": "5.8.2"
   },
   "optionalDependencies": {
-    "codeblog-app-darwin-arm64": "2.3.1",
-    "codeblog-app-darwin-x64": "2.3.1",
-    "codeblog-app-linux-arm64": "2.3.1",
-    "codeblog-app-linux-x64": "2.3.1",
-    "codeblog-app-windows-x64": "2.3.1"
+    "codeblog-app-darwin-arm64": "2.3.3",
+    "codeblog-app-darwin-x64": "2.3.3",
+    "codeblog-app-linux-arm64": "2.3.3",
+    "codeblog-app-linux-x64": "2.3.3",
+    "codeblog-app-windows-x64": "2.3.3"
   },
   "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.2.0",
+    "codeblog-mcp": "2.2.1",
     "drizzle-orm": "1.0.0-beta.12-a5629fb",
     "fuzzysort": "^3.1.0",
     "hono": "4.10.7",

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

@@ -58,4 +58,41 @@ describe("provider-registry", () => {
     expect(route.providerID).toBe("openai")
     expect(route.modelID).toBe("gpt-4o-mini")
   })
+
+  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" },
+      },
+    })
+    expect(route.providerID).toBe("openai")
+    expect(route.modelID).toBe("gpt-5.2")
+  })
+
+  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" },
+      },
+    })
+    expect(route.providerID).toBe("openai")
+    expect(route.modelID).toBe("gpt-5.2")
+  })
+
+  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" },
+      },
+    })
+    expect(route.providerID).toBe("openai-compatible")
+    expect(route.modelID).toBe("gpt-5.2")
+  })
 })

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

@@ -67,8 +67,9 @@ describe("AIProvider", () => {
   // BUILTIN_MODELS
   // ---------------------------------------------------------------------------
 
-  test("BUILTIN_MODELS has 7 models", () => {
-    expect(Object.keys(AIProvider.BUILTIN_MODELS)).toHaveLength(7)
+  test("BUILTIN_MODELS has 8 models", () => {
+    // Includes GPT-5.2 as the OpenAI default.
+    expect(Object.keys(AIProvider.BUILTIN_MODELS)).toHaveLength(8)
   })
 
   test("each model has required fields", () => {
@@ -184,9 +185,9 @@ describe("AIProvider", () => {
       expect(entry.model).toBeDefined()
       expect(typeof entry.hasKey).toBe("boolean")
     }
-    // The first 7 should always be builtins
+    // Built-ins should always be present.
     const builtinCount = models.filter((m) => AIProvider.BUILTIN_MODELS[m.model.id]).length
-    expect(builtinCount).toBe(7)
+    expect(builtinCount).toBe(8)
   })
 
   test("available includes openai-compatible remote models when configured", async () => {

package/src/ai/configure.ts

@@ -57,9 +57,9 @@ async function fetchFirstModel(base: string, key: string): Promise<string | null
     const data = await r.json() as { data?: Array<{ id: string }> }
     if (!data.data || data.data.length === 0) return null
 
-    // Prefer capable models: claude-sonnet > gpt-4o > claude-opus > first available
+    // Prefer stable defaults first; avoid niche/legacy IDs unless explicitly chosen.
     const ids = data.data.map((m) => m.id)
-    const preferred = [/^claude-sonnet-4/, /^gpt-4o$/, /^claude-opus-4/, /^gpt-4o-mini$/, /^gemini-2\.5-flash$/]
+    const preferred = [/^gpt-5\.2$/, /^claude-sonnet-4(?:-5)?/, /^gpt-5(?:\.|$|-)/, /^gpt-4o$/, /^claude-opus-4/, /^gpt-4o-mini$/, /^gemini-2\.5-flash$/]
     for (const pattern of preferred) {
       const match = ids.find((id) => pattern.test(id))
       if (match) return match
@@ -101,12 +101,14 @@ export async function saveProvider(url: string, key: string): Promise<{ provider
     // Auto-set model if not already configured
     const update: Record<string, unknown> = { providers, default_provider: provider }
     if (!cfg.model) {
+      const { defaultModelForProvider } = await import("./models")
       if (detected === "anthropic") {
-        update.model = "claude-sonnet-4-20250514"
+        update.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")}`
       }
     }
 
@@ -128,9 +130,8 @@ export async function saveProvider(url: string, key: string): Promise<{ provider
   // Auto-set model for known providers
   const update: Record<string, unknown> = { providers, default_provider: provider }
   if (!cfg.model) {
-    const { AIProvider } = await import("./provider")
-    const models = Object.values(AIProvider.BUILTIN_MODELS).filter((m) => m.providerID === provider)
-    if (models.length > 0) update.model = models[0]!.id
+    const { defaultModelForProvider } = await import("./models")
+    update.model = defaultModelForProvider(provider)
   }
 
   await Config.save(update)

package/src/ai/models.ts

@@ -9,6 +9,7 @@ export interface ModelInfo {
 export const BUILTIN_MODELS: Record<string, ModelInfo> = {
   "claude-sonnet-4-20250514": { id: "claude-sonnet-4-20250514", providerID: "anthropic", name: "Claude Sonnet 4", contextWindow: 200000, outputTokens: 16384 },
   "claude-3-5-haiku-20241022": { id: "claude-3-5-haiku-20241022", providerID: "anthropic", name: "Claude 3.5 Haiku", contextWindow: 200000, outputTokens: 8192 },
+  "gpt-5.2": { id: "gpt-5.2", providerID: "openai", name: "GPT-5.2", contextWindow: 400000, outputTokens: 128000 },
   "gpt-4o": { id: "gpt-4o", providerID: "openai", name: "GPT-4o", contextWindow: 128000, outputTokens: 16384 },
   "gpt-4o-mini": { id: "gpt-4o-mini", providerID: "openai", name: "GPT-4o Mini", contextWindow: 128000, outputTokens: 16384 },
   "o3-mini": { id: "o3-mini", providerID: "openai", name: "o3-mini", contextWindow: 200000, outputTokens: 100000 },
@@ -17,6 +18,46 @@ export const BUILTIN_MODELS: Record<string, ModelInfo> = {
 }
 
 export const DEFAULT_MODEL = "claude-sonnet-4-20250514"
+const LEGACY_MODEL_MAP: Record<string, string> = {
+  "4.0Ultra": "gpt-5.2",
+  "4.0ultra": "gpt-5.2",
+}
+
+const PROVIDER_DEFAULT_MODEL: Record<string, string> = {
+  anthropic: "claude-sonnet-4-20250514",
+  openai: "gpt-5.2",
+  google: "gemini-2.5-flash",
+  "openai-compatible": "gpt-5.2",
+}
+
+export function normalizeModelID(modelID?: string): string | undefined {
+  if (!modelID) return undefined
+  const trimmed = modelID.trim()
+  if (!trimmed) return undefined
+  if (LEGACY_MODEL_MAP[trimmed]) return LEGACY_MODEL_MAP[trimmed]
+  if (!trimmed.includes("/")) return trimmed
+  const [providerID, ...rest] = trimmed.split("/")
+  const raw = rest.join("/")
+  if (!raw) return trimmed
+  const mapped = LEGACY_MODEL_MAP[raw]
+  if (!mapped) return trimmed
+  return `${providerID}/${mapped}`
+}
+
+export function defaultModelForProvider(providerID?: string): string {
+  if (!providerID) return DEFAULT_MODEL
+  return PROVIDER_DEFAULT_MODEL[providerID] || DEFAULT_MODEL
+}
+
+export function resolveModelFromConfig(cfg: { model?: string; default_provider?: string }): string {
+  const model = normalizeModelID(cfg.model)
+  if (model) return model
+  const fallback = defaultModelForProvider(cfg.default_provider)
+  if (cfg.default_provider === "openai-compatible" && !fallback.includes("/")) {
+    return `openai-compatible/${fallback}`
+  }
+  return fallback
+}
 
 export function inferProviderByModelPrefix(modelID: string): string | undefined {
   if (modelID.startsWith("claude-")) return "anthropic"

package/src/ai/provider-registry.ts

@@ -1,6 +1,6 @@
 import { Config } from "../config"
 import { Log } from "../util/log"
-import { BUILTIN_MODELS, DEFAULT_MODEL, inferProviderByModelPrefix } from "./models"
+import { BUILTIN_MODELS, inferProviderByModelPrefix, resolveModelFromConfig, normalizeModelID } from "./models"
 import { type ModelCompatConfig, resolveCompat } from "./types"
 
 const log = Log.create({ service: "ai-provider-registry" })
@@ -115,7 +115,7 @@ function routeViaProvider(
 
 export async function routeModel(inputModel?: string, cfgInput?: Config.CodeblogConfig): Promise<ModelRoute> {
   const cfg = cfgInput || await Config.load()
-  const requestedModel = inputModel || cfg.model || DEFAULT_MODEL
+  const requestedModel = normalizeModelID(inputModel) || resolveModelFromConfig(cfg)
   const loaded = await loadProviders(cfg)
   const providers = loaded.providers
 

package/src/ai/provider.ts

@@ -5,7 +5,7 @@ import { createOpenAICompatible } from "@ai-sdk/openai-compatible"
 import { type LanguageModel, type Provider as SDK } from "ai"
 import { Config } from "../config"
 import { Log } from "../util/log"
-import { BUILTIN_MODELS as CORE_MODELS, DEFAULT_MODEL as CORE_DEFAULT_MODEL, type ModelInfo as CoreModelInfo } from "./models"
+import { BUILTIN_MODELS as CORE_MODELS, DEFAULT_MODEL as CORE_DEFAULT_MODEL, type ModelInfo as CoreModelInfo, resolveModelFromConfig, normalizeModelID } from "./models"
 import { loadProviders, PROVIDER_BASE_URL_ENV, PROVIDER_ENV, routeModel } from "./provider-registry"
 import { patchRequestByCompat, resolveCompat, type ModelApi, type ModelCompatConfig } from "./types"
 
@@ -106,7 +106,7 @@ export namespace AIProvider {
     baseURL?: string
     compat: ModelCompatConfig
   }> {
-    const requested = modelID || (await getConfiguredModel()) || DEFAULT_MODEL
+    const requested = normalizeModelID(modelID) || (await getConfiguredModel()) || DEFAULT_MODEL
     const cfg = await Config.load()
 
     const builtin = BUILTIN_MODELS[requested]
@@ -227,7 +227,7 @@ export namespace AIProvider {
 
   async function getConfiguredModel(): Promise<string | undefined> {
     const cfg = await Config.load()
-    return cfg.model
+    return resolveModelFromConfig(cfg)
   }
 
   export async function hasAnyKey(): Promise<boolean> {

package/src/auth/oauth.ts

@@ -17,28 +17,46 @@ export namespace OAuth {
       const username = params.get("username") || undefined
 
       if (key) {
+        let ownerMismatch = ""
         await Auth.set({ type: "apikey", value: key, username })
-        // 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) })
-        }
         // Fetch agent name and save to CLI config
         try {
           const meRes = await fetch(`${base}/api/v1/agents/me`, {
             headers: { Authorization: `Bearer ${key}` },
           })
           if (meRes.ok) {
-            const meData = await meRes.json() as { agent?: { name?: string } }
-            if (meData.agent?.name) {
-              await Config.save({ activeAgent: meData.agent.name })
+            const meData = await meRes.json() as { agent?: { name?: string; owner?: string | null } }
+            const name = meData.agent?.name?.trim()
+            const owner = meData.agent?.owner || ""
+            if (username && owner && owner !== username) {
+              ownerMismatch = `API key belongs to @${owner}, not @${username}`
+              log.warn("api key owner mismatch", { username, owner, agent: name || "" })
+            } else if (name) {
+              await Config.saveActiveAgent(name, username)
             }
           }
         } catch (err) {
           log.warn("failed to fetch agent info", { error: String(err) })
         }
-        log.info("authenticated with api key")
+        if (ownerMismatch) {
+          if (token) {
+            await Auth.set({ type: "jwt", value: token, username })
+            log.warn("fallback to jwt auth due api key owner mismatch", { username })
+            log.info("authenticated with jwt")
+          }
+          else {
+            await Auth.remove()
+            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) {
         await Auth.set({ type: "jwt", value: token, username })
         log.info("authenticated with jwt")

package/src/cli/cmd/chat.ts

@@ -12,7 +12,7 @@ export const ChatCommand: CommandModule = {
     yargs
       .option("model", {
         alias: "m",
-        describe: "Model to use (e.g. claude-sonnet-4-20250514, gpt-4o)",
+        describe: "Model to use (e.g. claude-sonnet-4-20250514, gpt-5.2)",
         type: "string",
       })
       .option("prompt", {

package/src/cli/cmd/config.ts

@@ -18,7 +18,7 @@ export const ConfigCommand: CommandModule = {
       })
       .option("model", {
         alias: "m",
-        describe: "Set default AI model (e.g. claude-sonnet-4-20250514, gpt-4o)",
+        describe: "Set default AI model (e.g. claude-sonnet-4-20250514, gpt-5.2)",
         type: "string",
       })
       .option("url", {
@@ -119,7 +119,8 @@ export const ConfigCommand: CommandModule = {
 
       // Show current config
       const cfg = await Config.load()
-      const model = cfg.model || AIProvider.DEFAULT_MODEL
+      const { resolveModelFromConfig } = await import("../../ai/models")
+      const model = resolveModelFromConfig(cfg) || AIProvider.DEFAULT_MODEL
       const providers = cfg.providers || {}
 
       console.log("")

package/src/cli/cmd/logout.ts

@@ -1,5 +1,6 @@
 import type { CommandModule } from "yargs"
 import { Auth } from "../../auth"
+import { Config } from "../../config"
 import { UI } from "../ui"
 
 export const LogoutCommand: CommandModule = {
@@ -7,6 +8,7 @@ export const LogoutCommand: CommandModule = {
   describe: "Logout from CodeBlog",
   handler: async () => {
     await Auth.remove()
+    await Config.clearActiveAgent()
     UI.success("Logged out successfully")
   },
 }

package/src/cli/cmd/setup.ts

@@ -336,6 +336,16 @@ async function fetchOpenAIModels(baseURL: string, key: string): Promise<string[]
   }
 }
 
+function pickPreferredRemoteModel(models: string[]): string | undefined {
+  if (models.length === 0) return undefined
+  const preferred = [/^gpt-5\.2$/, /^claude-sonnet-4(?:-5)?/, /^gpt-5(?:\.|$|-)/, /^gpt-4o$/, /^gpt-4o-mini$/, /^gemini-2\.5-flash$/]
+  for (const pattern of preferred) {
+    const found = models.find((id) => pattern.test(id))
+    if (found) return found
+  }
+  return models[0]
+}
+
 function isOfficialOpenAIBase(baseURL: string): boolean {
   try {
     const u = new URL(baseURL)
@@ -413,10 +423,10 @@ async function chooseModel(choice: ProviderChoice, mode: WizardMode, baseURL: st
 
   if (mode === "quick") {
     if (choice.providerID === "anthropic") return "claude-sonnet-4-20250514"
-    if (choice.providerID === "openai" && !openaiCustom) return "gpt-4o-mini"
+    if (choice.providerID === "openai" && !openaiCustom) return "gpt-5.2"
     if (choice.providerID === "google") return "gemini-2.5-flash"
     const remote = await fetchOpenAIModels(baseURL, key)
-    return remote[0] || "gpt-4o-mini"
+    return pickPreferredRemoteModel(remote) || "gpt-5.2"
   }
 
   let options = builtin
@@ -426,7 +436,7 @@ async function chooseModel(choice: ProviderChoice, mode: WizardMode, baseURL: st
   }
   if (options.length === 0) {
     const typed = await UI.input(`  Model ID: `)
-    return typed.trim() || "gpt-4o-mini"
+    return typed.trim() || "gpt-5.2"
   }
 
   const idx = await UI.select("  Choose a model", [...options, "Custom model id"])

package/src/cli/cmd/update.ts

@@ -112,8 +112,24 @@ export const UpdateCommand: CommandModule = {
       await fs.chmod(bin, 0o755)
     }
     if (os === "darwin") {
+      await Bun.spawn(["codesign", "--remove-signature", bin], { stdout: "ignore", stderr: "ignore" }).exited
       const cs = Bun.spawn(["codesign", "--sign", "-", "--force", bin], { stdout: "ignore", stderr: "ignore" })
-      await cs.exited
+      if ((await cs.exited) !== 0) {
+        await fs.rm(tmp, { recursive: true, force: true })
+        UI.error("Update installed but macOS code signing failed. Please reinstall with install.sh.")
+        process.exitCode = 1
+        return
+      }
+      const verify = Bun.spawn(["codesign", "--verify", "--deep", "--strict", bin], {
+        stdout: "ignore",
+        stderr: "ignore",
+      })
+      if ((await verify.exited) !== 0) {
+        await fs.rm(tmp, { recursive: true, force: true })
+        UI.error("Update installed but signature verification failed. Please reinstall with install.sh.")
+        process.exitCode = 1
+        return
+      }
     }
 
     await fs.rm(tmp, { recursive: true, force: true })

package/src/config/index.ts

@@ -28,6 +28,7 @@ export namespace Config {
     default_provider?: string
     default_language?: string
     activeAgent?: string
+    active_agents?: Record<string, string>
     providers?: Record<string, ProviderConfig>
     feature_flags?: FeatureFlags
   }
@@ -56,6 +57,38 @@ export namespace Config {
     await chmod(CONFIG_FILE, 0o600).catch(() => {})
   }
 
+  export async function getActiveAgent(username?: string) {
+    const cfg = await load()
+    if (username) return cfg.active_agents?.[username] || ""
+    return cfg.activeAgent || ""
+  }
+
+  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 })
+  }
+
   export async function url() {
     return process.env.CODEBLOG_URL || (await load()).api_url || "https://codeblog.ai"
   }

package/src/index.ts

@@ -30,6 +30,14 @@ import { UninstallCommand } from "./cli/cmd/uninstall"
 
 const VERSION = (await import("../package.json")).version
 
+function resetTerminalModes() {
+  if (!process.stdout.isTTY) return
+  // Disable mouse reporting, bracketed paste, focus tracking, and modifyOtherKeys.
+  process.stdout.write("\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1005l\x1b[?1006l\x1b[?2004l\x1b[?1004l\x1b[>4m\x1b[0m")
+}
+
+resetTerminalModes()
+
 process.on("unhandledRejection", (e) => {
   Log.Default.error("rejection", {
     e: e instanceof Error ? e.stack || e.message : e,
@@ -198,6 +206,7 @@ try {
   }
   process.exitCode = 1
 } finally {
+  resetTerminalModes()
   await McpBridge.disconnect().catch(() => {})
   process.exit()
 }

package/src/tui/app.tsx

@@ -75,15 +75,66 @@ function App() {
   const [aiProvider, setAiProvider] = createSignal("")
   const [modelName, setModelName] = createSignal("")
 
+  async function refreshAuth() {
+    try {
+      const { Auth } = await import("../auth")
+      const token = await Auth.get()
+      const authenticated = token !== null
+      const username = token?.username || ""
+      setLoggedIn(authenticated)
+      setUsername(username)
+      if (!authenticated) {
+        setActiveAgent("")
+        return
+      }
+      const { Config } = await import("../config")
+      const cached = await Config.getActiveAgent(username || undefined)
+      if (cached) setActiveAgent(cached)
+      if (!token?.value) {
+        if (!cached) setActiveAgent("")
+        return
+      }
+      try {
+        const base = await Config.url()
+        const res = await fetch(`${base}/api/v1/agents/me`, {
+          headers: { Authorization: `Bearer ${token.value}` },
+        })
+        if (!res.ok) {
+          if (!cached) setActiveAgent("")
+          return
+        }
+        const data = await res.json() as { agent?: { name?: string; owner?: string | null } }
+        const name = data.agent?.name?.trim()
+        const owner = data.agent?.owner || ""
+        if (username && owner && owner !== username) {
+          setActiveAgent("")
+          await Config.clearActiveAgent(username)
+          return
+        }
+        if (!name) {
+          setActiveAgent("")
+          await Config.clearActiveAgent(username || undefined)
+          return
+        }
+        setActiveAgent(name)
+        await Config.saveActiveAgent(name, username || undefined)
+      } catch {
+        if (!cached) setActiveAgent("")
+      }
+    } catch {}
+  }
+
   async function refreshAI() {
     try {
       const { AIProvider } = await import("../ai/provider")
+      const { resolveModelFromConfig } = await import("../ai/models")
       const has = await AIProvider.hasAnyKey()
       setHasAI(has)
       if (has) {
         const { Config } = await import("../config")
         const cfg = await Config.load()
-        const model = cfg.model || AIProvider.DEFAULT_MODEL
+        const model = resolveModelFromConfig(cfg) || AIProvider.DEFAULT_MODEL
+        if (cfg.model !== model) await Config.save({ model })
         setModelName(model)
         const info = AIProvider.BUILTIN_MODELS[model]
         setAiProvider(info?.providerID || model.split("/")[0] || "ai")
@@ -93,46 +144,7 @@ function App() {
 
   onMount(async () => {
     renderer.setTerminalTitle("CodeBlog")
-
-    // Check auth status
-    try {
-      const { Auth } = await import("../auth")
-      const authenticated = await Auth.authenticated()
-      setLoggedIn(authenticated)
-      if (authenticated) {
-        const token = await Auth.get()
-        if (token?.username) setUsername(token.username)
-      }
-    } catch {}
-
-    // Get active agent
-    try {
-      const { Config } = await import("../config")
-      const cfg = await Config.load()
-      if (cfg.activeAgent) {
-        setActiveAgent(cfg.activeAgent)
-      } else if (loggedIn()) {
-        // If logged in but no activeAgent cached, fetch from API
-        const { Auth } = await import("../auth")
-        const tok = await Auth.get()
-        if (tok?.type === "apikey" && tok.value) {
-          try {
-            const base = await Config.url()
-            const res = await fetch(`${base}/api/v1/agents/me`, {
-              headers: { Authorization: `Bearer ${tok.value}` },
-            })
-            if (res.ok) {
-              const data = await res.json() as { agent?: { name?: string } }
-              if (data.agent?.name) {
-                setActiveAgent(data.agent.name)
-                await Config.save({ activeAgent: data.agent.name })
-              }
-            }
-          } catch {}
-        }
-      }
-    } catch {}
-
+    await refreshAuth()
     await refreshAI()
   })
 
@@ -166,13 +178,15 @@ function App() {
               try {
                 const { OAuth } = await import("../auth/oauth")
                 await OAuth.login()
-                const { Auth } = await import("../auth")
-                setLoggedIn(true)
-                const token = await Auth.get()
-                if (token?.username) setUsername(token.username)
-              } catch {}
+                await refreshAuth()
+                return { ok: true }
+              } catch (err) {
+                const msg = err instanceof Error ? err.message : String(err)
+                await refreshAuth()
+                return { ok: false, error: `Login failed: ${msg}` }
+              }
             }}
-            onLogout={() => { setLoggedIn(false); setUsername("") }}
+            onLogout={() => { setLoggedIn(false); setUsername(""); setActiveAgent("") }}
             onAIConfigured={refreshAI}
           />
         </Match>

package/src/tui/commands.ts

@@ -11,7 +11,7 @@ export interface CommandDeps {
   showMsg: (text: string, color?: string) => void
   openModelPicker: () => Promise<void>
   exit: () => void
-  onLogin: () => Promise<void>
+  onLogin: () => Promise<{ ok: boolean; error?: string }>
   onLogout: () => void
   onAIConfigured: () => void
   clearChat: () => void
@@ -62,7 +62,11 @@ export function createCommands(deps: CommandDeps): CmdDef[] {
     }},
     { name: "/login", description: "Sign in to CodeBlog", action: async () => {
       deps.showMsg("Opening browser for login...", deps.colors.primary)
-      await deps.onLogin()
+      const result = await deps.onLogin()
+      if (!result.ok) {
+        deps.showMsg(result.error || "Login failed", deps.colors.error)
+        return
+      }
       deps.showMsg("Logged in!", deps.colors.success)
     }},
     { name: "/logout", description: "Sign out of CodeBlog", action: async () => {

package/src/tui/routes/home.tsx

@@ -60,7 +60,7 @@ export function Home(props: {
   hasAI: boolean
   aiProvider: string
   modelName: string
-  onLogin: () => Promise<void>
+  onLogin: () => Promise<{ ok: boolean; error?: string }>
   onLogout: () => void
   onAIConfigured: () => void
 }) {
@@ -141,6 +141,13 @@ export function Home(props: {
   let modelPreload: Promise<ModelOption[]> | undefined
   const keyLog = process.env.CODEBLOG_DEBUG_KEYS === "1" ? Log.create({ service: "tui-key" }) : undefined
   const toHex = (value: string) => Array.from(value).map((ch) => ch.charCodeAt(0).toString(16).padStart(2, "0")).join(" ")
+  const chars = (evt: { sequence: string; name: string; ctrl: boolean; meta: boolean }) => {
+    if (evt.ctrl || evt.meta) return ""
+    const seq = (evt.sequence || "").replace(/[\x00-\x1f\x7f]/g, "")
+    if (seq) return seq
+    if (evt.name.length === 1) return evt.name
+    return ""
+  }
 
   function tone(color: string): ChatMsg["tone"] {
     if (color === theme.colors.success) return "success"
@@ -181,8 +188,9 @@ export function Home(props: {
         setModelLoading(true)
         const { AIProvider } = await import("../../ai/provider")
         const { Config } = await import("../../config")
+        const { resolveModelFromConfig } = await import("../../ai/models")
         const cfg = await Config.load()
-        const current = cfg.model || AIProvider.DEFAULT_MODEL
+        const current = resolveModelFromConfig(cfg) || AIProvider.DEFAULT_MODEL
         const currentBuiltin = AIProvider.BUILTIN_MODELS[current]
         const currentProvider =
           cfg.default_provider ||
@@ -434,8 +442,9 @@ export function Home(props: {
       const { AIChat } = await import("../../ai/chat")
       const { AIProvider } = await import("../../ai/provider")
       const { Config } = await import("../../config")
+      const { resolveModelFromConfig } = await import("../../ai/models")
       const cfg = await Config.load()
-      const mid = cfg.model || AIProvider.DEFAULT_MODEL
+      const mid = resolveModelFromConfig(cfg) || AIProvider.DEFAULT_MODEL
       const allMsgs = [...prev, userMsg]
         .filter((m): m is ChatMsg & { role: "user" | "assistant" } => m.role === "user" || m.role === "assistant")
         .map((m) => ({ role: m.role, content: m.modelContent || m.content }))
@@ -661,6 +670,7 @@ export function Home(props: {
       (submitKey && seq.startsWith("\x1b[") && seq.endsWith("~")) ||
       (submitKey && raw.includes(";13")) ||
       (submitKey && seq.includes(";13"))
+    const print = chars(evt)
     const newlineKey =
       evt.name === "linefeed" ||
       newlineFromRaw ||
@@ -676,21 +686,15 @@ export function Home(props: {
       if (submitKey || newlineKey) { handleSubmit(); evt.preventDefault(); return }
       if (evt.name === "escape") { setAiMode(""); evt.preventDefault(); return }
       if (evt.name === "backspace") { setAiUrl((s) => s.slice(0, -1)); evt.preventDefault(); return }
-      if (evt.sequence && evt.sequence.length >= 1 && !evt.ctrl && !evt.meta) {
-        const clean = evt.sequence.replace(/[\x00-\x1f\x7f]/g, "")
-        if (clean) { setAiUrl((s) => s + clean); evt.preventDefault(); return }
-      }
-      if (evt.name === "space") { evt.preventDefault(); return }
+      if (print === " " || evt.name === "space") { evt.preventDefault(); return }
+      if (print) { setAiUrl((s) => s + print); evt.preventDefault(); return }
       return
     }
     if (aiMode() === "key") {
       if (submitKey || newlineKey) { handleSubmit(); evt.preventDefault(); return }
       if (evt.name === "escape") { setAiMode("url"); setAiKey(""); showMsg("Paste your API URL (or press Enter to skip):", theme.colors.primary); evt.preventDefault(); return }
       if (evt.name === "backspace") { setAiKey((s) => s.slice(0, -1)); evt.preventDefault(); return }
-      if (evt.sequence && evt.sequence.length >= 1 && !evt.ctrl && !evt.meta) {
-        const clean = evt.sequence.replace(/[\x00-\x1f\x7f]/g, "")
-        if (clean) { setAiKey((s) => s + clean); evt.preventDefault(); return }
-      }
+      if (print) { setAiKey((s) => s + print); evt.preventDefault(); return }
       if (evt.name === "space") { setAiKey((s) => s + " "); evt.preventDefault(); return }
       return
     }
@@ -734,15 +738,7 @@ export function Home(props: {
         evt.preventDefault()
         return
       }
-      if (evt.sequence && evt.sequence.length >= 1 && !evt.ctrl && !evt.meta) {
-        const clean = evt.sequence.replace(/[\x00-\x1f\x7f]/g, "")
-        if (clean) {
-          setModelQuery((q) => q + clean)
-          setModelIdx(0)
-          evt.preventDefault()
-          return
-        }
-      }
+      if (print) { setModelQuery((q) => q + print); setModelIdx(0); evt.preventDefault(); return }
       if (evt.name === "space") {
         setModelQuery((q) => q + " ")
         setModelIdx(0)
@@ -781,10 +777,7 @@ export function Home(props: {
     if (submitKey && !shift && !evt.ctrl && !evt.meta && !modifiedSubmitFromRaw) { handleSubmit(); evt.preventDefault(); return }
     if (newlineKey) { setInput((s) => s + "\n"); evt.preventDefault(); return }
     if (evt.name === "backspace") { setInput((s) => s.slice(0, -1)); setSelectedIdx(0); evt.preventDefault(); return }
-    if (evt.sequence && evt.sequence.length >= 1 && !evt.ctrl && !evt.meta) {
-      const clean = evt.sequence.replace(/[\x00-\x1f\x7f]/g, "")
-      if (clean) { setInput((s) => s + clean); setSelectedIdx(0); evt.preventDefault(); return }
-    }
+    if (print) { setInput((s) => s + print); setSelectedIdx(0); evt.preventDefault(); return }
     if (evt.name === "space") { setInput((s) => s + " "); evt.preventDefault(); return }
   }, { release: true })
 

package/src/tui/routes/model.tsx

@@ -42,8 +42,11 @@ export function ModelPicker(props: { onDone: (model?: string) => void }) {
     try {
       const { AIProvider } = await import("../../ai/provider")
       const { Config } = await import("../../config")
+      const { resolveModelFromConfig } = await import("../../ai/models")
       const cfg = await Config.load()
-      setCurrent(cfg.model || AIProvider.DEFAULT_MODEL)
+      const resolved = resolveModelFromConfig(cfg) || AIProvider.DEFAULT_MODEL
+      setCurrent(resolved)
+      if (cfg.model !== resolved) await Config.save({ model: resolved })
 
       setStatus("Fetching models from API...")
       const all = await AIProvider.available()
@@ -54,7 +57,7 @@ export function ModelPicker(props: { onDone: (model?: string) => void }) {
       }))
       if (items.length > 0) {
         setModels(items)
-        const modelId = cfg.model || AIProvider.DEFAULT_MODEL
+        const modelId = resolveModelFromConfig(cfg) || AIProvider.DEFAULT_MODEL
         const curIdx = items.findIndex((m) => m.id === modelId || `${m.provider}/${m.id}` === modelId)
         if (curIdx >= 0) setIdx(curIdx)
         setStatus(`${items.length} models loaded`)