codeblog-app 2.3.3 → 2.3.5

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "codeblog-app",
-  "version": "2.3.3",
+  "version": "2.3.5",
   "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.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"
+    "codeblog-app-darwin-arm64": "2.3.5",
+    "codeblog-app-darwin-x64": "2.3.5",
+    "codeblog-app-linux-arm64": "2.3.5",
+    "codeblog-app-linux-x64": "2.3.5",
+    "codeblog-app-windows-x64": "2.3.5"
   },
   "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.1",
+    "codeblog-mcp": "2.3.0",
     "drizzle-orm": "1.0.0-beta.12-a5629fb",
     "fuzzysort": "^3.1.0",
     "hono": "4.10.7",

package/src/auth/oauth.ts

@@ -6,6 +6,9 @@ import { Log } from "../util/log"
 
 const log = Log.create({ service: "oauth" })
 
+/** Set after a successful login — indicates whether the user already has agents. */
+export let lastAuthHasAgents: boolean | undefined = undefined
+
 export namespace OAuth {
   export async function login(options?: { onUrl?: (url: string) => void }) {
     const open = (await import("open")).default
@@ -15,6 +18,8 @@ export namespace OAuth {
       const token = params.get("token")
       const key = params.get("api_key")
       const username = params.get("username") || undefined
+      const hasAgentsParam = params.get("has_agents")
+      lastAuthHasAgents = hasAgentsParam === "true" ? true : hasAgentsParam === "false" ? false : undefined
 
       if (key) {
         let ownerMismatch = ""

package/src/cli/auto-update.ts

@@ -0,0 +1,59 @@
+import { performUpdate } from "./perform-update"
+import { UI } from "./ui"
+
+/**
+ * Checks for a newer CLI version on startup and auto-updates if available.
+ * Equivalent to running `codeblog update` automatically.
+ * On any failure, silently continues — never blocks normal usage.
+ */
+export async function checkAndAutoUpdate(): Promise<void> {
+  try {
+    // Skip if disabled via env
+    if (process.env.CODEBLOG_NO_AUTO_UPDATE === "1") return
+
+    // Skip if running the `update` command (avoid double-update)
+    const cmd = process.argv[2]
+    if (cmd === "update") return
+
+    // Fetch latest version from npm registry
+    const controller = new AbortController()
+    const timeout = setTimeout(() => controller.abort(), 10_000)
+    let res: Response
+    try {
+      res = await fetch("https://registry.npmjs.org/codeblog-app/latest", { signal: controller.signal })
+    } catch (e: any) {
+      clearTimeout(timeout)
+      if (e.name === "AbortError") {
+        UI.error("Version check timed out (10s). Please check your network and try again.")
+      } else {
+        UI.error(`Failed to check for updates: ${e.message}`)
+      }
+      return
+    }
+    clearTimeout(timeout)
+    if (!res.ok) return
+
+    const data = (await res.json()) as { version: string }
+    const latest = data.version
+    const pkg = await import("../../package.json")
+    const current = pkg.version
+
+    if (current === latest) return
+
+    // Run the same flow as `codeblog update`
+    UI.info(`Current version: v${current}`)
+    UI.info(`Updating v${current} → v${latest}...`)
+
+    await performUpdate(latest)
+    UI.success(`Updated to v${latest}!`)
+
+    // Re-exec: run the updated binary with the same arguments
+    const proc = Bun.spawn([process.execPath, ...process.argv.slice(1)], {
+      stdio: ["inherit", "inherit", "inherit"],
+    })
+    const code = await proc.exited
+    process.exit(code)
+  } catch (e) {
+    UI.error(e instanceof Error ? e.message : String(e))
+  }
+}

package/src/cli/cmd/setup.ts

@@ -1,6 +1,6 @@
 import type { CommandModule } from "yargs"
 import { Auth } from "../../auth"
-import { OAuth } from "../../auth/oauth"
+import { OAuth, lastAuthHasAgents } from "../../auth/oauth"
 import { McpBridge } from "../../mcp/client"
 import { UI } from "../ui"
 import { Config } from "../../config"
@@ -465,7 +465,7 @@ export async function runAISetupWizard(source: "setup" | "command" = "command"):
   }
 
   console.log("")
-  const modeIdx = await UI.select("  Onboarding mode", ["QuickStart (recommended)", "Manual", "Skip for now"])
+  const modeIdx = await UI.select("  Onboarding mode", ["QuickStart (recommended)", "Manual", "Skip for now"], { searchable: false })
   if (modeIdx < 0 || modeIdx === 2) {
     UI.info("Skipped AI setup.")
     return
@@ -563,6 +563,212 @@ export async function runAISetupWizard(source: "setup" | "command" = "command"):
   console.log(`  ${UI.Style.TEXT_DIM}You can rerun this wizard with: codeblog ai setup${UI.Style.TEXT_NORMAL}`)
 }
 
+// ─── Agent Creation ─────────────────────────────────────────────────────────
+
+const SOURCE_OPTIONS = ["Claude Code", "Cursor", "Windsurf", "Codex CLI", "Multiple / Other"]
+const SOURCE_VALUES  = ["claude-code", "cursor", "windsurf", "codex", "other"]
+
+async function generateAgentNameAndEmoji(): Promise<{ name: string; emoji: string } | null> {
+  try {
+    const { AIProvider } = await import("../../ai/provider")
+    const { generateText } = await import("ai")
+    const model = await AIProvider.getModel()
+    const result = await generateText({
+      model,
+      prompt:
+        "You are naming an AI coding agent for a developer forum called CodeBlog. " +
+        "Generate a creative, short (1-3 words) agent name and pick a single emoji that fits as its avatar. " +
+        "The emoji should be fun, expressive, and have personality. " +
+        "Do NOT use 🤖 or plain colored circles (🟠🟣🟢🔵⚫) — those are reserved by the system. " +
+        "Respond ONLY with JSON: {\"name\": \"...\", \"emoji\": \"...\"}",
+      maxOutputTokens: 100,
+    })
+    const parsed = JSON.parse(result.text.trim())
+    if (parsed.name && parsed.emoji) {
+      return { name: String(parsed.name).slice(0, 50), emoji: String(parsed.emoji) }
+    }
+  } catch {}
+  return null
+}
+
+async function generateEmojiForName(agentName: string): Promise<string> {
+  try {
+    const { AIProvider } = await import("../../ai/provider")
+    const { generateText } = await import("ai")
+    const model = await AIProvider.getModel()
+    const result = await generateText({
+      model,
+      prompt:
+        `Pick a single emoji that best represents an AI coding agent named "${agentName}". ` +
+        "The emoji should be fun, expressive, and have personality. " +
+        "Do NOT use 🤖 or plain colored circles (🟠🟣🟢🔵⚫) — those are reserved by the system. " +
+        "Respond with ONLY the emoji, nothing else.",
+      maxOutputTokens: 10,
+    })
+    const emoji = result.text.trim()
+    if (emoji && emoji.length <= 16) return emoji
+  } catch {}
+  return "🦊"
+}
+
+async function detectSourceType(): Promise<string | null> {
+  try {
+    const result = await McpBridge.callTool("scan_sessions", { limit: 1 })
+    const sessions = JSON.parse(result)
+    if (sessions.length > 0 && sessions[0].source) {
+      const map: Record<string, string> = {
+        "claude-code": "claude-code",
+        cursor: "cursor",
+        windsurf: "windsurf",
+        codex: "codex",
+      }
+      return map[sessions[0].source] || null
+    }
+  } catch {}
+  return null
+}
+
+async function createAgentViaAPI(opts: {
+  name: string
+  avatar: string
+  sourceType: string
+}): Promise<{ api_key: string; name: string; id: string } | null> {
+  const base = await Config.url()
+  const auth = await Auth.get()
+  if (!auth) return null
+
+  // This endpoint requires a JWT token, not an API key.
+  // During setup the user may only have a JWT (no agent/api_key yet).
+  const token = auth.type === "jwt" ? auth.value : null
+  if (!token) {
+    throw new Error("JWT token required to create an agent. Please re-login with: codeblog login")
+  }
+
+  const res = await fetch(`${base}/api/auth/create-agent`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      name: opts.name,
+      avatar: opts.avatar,
+      source_type: opts.sourceType,
+    }),
+  })
+
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({ error: "Unknown error" })) as { error?: string }
+    throw new Error(err.error || `Server returned ${res.status}`)
+  }
+
+  const data = await res.json() as { agent: { api_key: string; name: string; id: string } }
+  return {
+    api_key: data.agent.api_key,
+    name: data.agent.name,
+    id: data.agent.id,
+  }
+}
+
+async function agentCreationWizard(): Promise<void> {
+  await UI.typeText("Now let's create your AI Agent!", { charDelay: 10 })
+  await UI.typeText("Your agent is your coding persona on CodeBlog — it represents you and your coding style.", { charDelay: 10 })
+  await UI.typeText("Give it a name, an emoji avatar, and it'll be ready to publish insights from your coding sessions.", { charDelay: 10 })
+  console.log("")
+
+  const { AIProvider } = await import("../../ai/provider")
+  const hasAI = await AIProvider.hasAnyKey()
+
+  let name = ""
+  let emoji = ""
+
+  // ── Name ──
+  if (hasAI) {
+    await UI.typeText("Want AI to come up with a creative name for your agent?", { charDelay: 10 })
+    const choice = await UI.waitEnter("Press Enter to generate, or Esc to type your own")
+
+    if (choice === "enter") {
+      await shimmerLine("Generating a creative name...", 1500)
+      const suggestion = await generateAgentNameAndEmoji()
+      if (suggestion) {
+        console.log("")
+        console.log(`  ${UI.Style.TEXT_NORMAL_BOLD}${suggestion.emoji} ${suggestion.name}${UI.Style.TEXT_NORMAL}`)
+        console.log("")
+        const accept = await UI.waitEnter("Like it? Press Enter to keep, or Esc to type your own")
+        if (accept === "enter") {
+          name = suggestion.name
+          emoji = suggestion.emoji
+        }
+      } else {
+        UI.warn("AI generation failed — let's type a name instead.")
+      }
+    }
+  }
+
+  if (!name) {
+    const entered = await UI.inputWithEscape(
+      `  ${UI.Style.TEXT_NORMAL_BOLD}Agent name${UI.Style.TEXT_NORMAL} ${UI.Style.TEXT_DIM}(e.g. "CodeNinja", "ByteWizard"):${UI.Style.TEXT_NORMAL} `,
+    )
+    if (entered === null || !entered.trim()) {
+      UI.info("No worries! You can create an agent later on the website or with: codeblog agent create")
+      return
+    }
+    name = entered.trim()
+  }
+
+  // ── Emoji avatar ──
+  if (!emoji) {
+    if (hasAI) {
+      await shimmerLine("Picking the perfect emoji avatar...", 800)
+      emoji = await generateEmojiForName(name)
+      console.log(`  ${UI.Style.TEXT_DIM}Avatar:${UI.Style.TEXT_NORMAL} ${emoji}`)
+    } else {
+      const EMOJI_POOL = ["🦊", "🐙", "🧠", "⚡", "🔥", "🌟", "🎯", "🛠️", "💡", "🚀", "🎨", "🐱", "🦉", "🐺", "🐲", "🦋", "🧙", "🛡️", "🌊", "🦈"]
+      const idx = await UI.select("  Pick an emoji avatar for your agent", EMOJI_POOL)
+      emoji = idx >= 0 ? EMOJI_POOL[idx]! : "🦊"
+    }
+  }
+
+  // ── Source type ──
+  await shimmerLine("Detecting IDE...", 600)
+  let sourceType = await detectSourceType()
+  if (sourceType) {
+    const label = SOURCE_OPTIONS[SOURCE_VALUES.indexOf(sourceType)] || sourceType
+    console.log(`  ${UI.Style.TEXT_DIM}Detected IDE:${UI.Style.TEXT_NORMAL} ${label}`)
+  } else {
+    const idx = await UI.select("  Which IDE do you primarily use?", SOURCE_OPTIONS)
+    sourceType = idx >= 0 ? SOURCE_VALUES[idx]! : "other"
+  }
+
+  // ── Preview & create ──
+  console.log("")
+  console.log(`  ${UI.Style.TEXT_DIM}Your agent:${UI.Style.TEXT_NORMAL} ${UI.Style.TEXT_NORMAL_BOLD}${emoji} ${name}${UI.Style.TEXT_NORMAL} ${UI.Style.TEXT_DIM}(${SOURCE_OPTIONS[SOURCE_VALUES.indexOf(sourceType)] || sourceType})${UI.Style.TEXT_NORMAL}`)
+  console.log("")
+
+  await shimmerLine("Creating your agent...", 1200)
+
+  try {
+    const result = await createAgentViaAPI({ name, avatar: emoji, sourceType })
+    if (!result) throw new Error("No result returned")
+
+    // Save the new API key as primary auth
+    const auth = await Auth.get()
+    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) {
+    UI.error(`Failed to create agent: ${err instanceof Error ? err.message : String(err)}`)
+    await UI.typeText("No worries — you can create an agent later on the website or with: codeblog agent create")
+  }
+}
+
 // ─── Setup Command ───────────────────────────────────────────────────────────
 
 export const SetupCommand: CommandModule = {
@@ -608,6 +814,13 @@ export const SetupCommand: CommandModule = {
     console.log("")
     await runAISetupWizard("setup")
 
+    // Phase 3.5: Agent creation (if the user has no agents yet)
+    const needsAgent = lastAuthHasAgents === false || (lastAuthHasAgents === undefined && !(await Auth.get())?.type?.startsWith("apikey"))
+    if (needsAgent) {
+      UI.divider()
+      await agentCreationWizard()
+    }
+
     // Phase 4: Interactive scan & publish
     UI.divider()
 

package/src/cli/cmd/update.ts

@@ -1,5 +1,6 @@
 import type { CommandModule } from "yargs"
 import { UI } from "../ui"
+import { performUpdate } from "../perform-update"
 
 export const UpdateCommand: CommandModule = {
   command: "update",
@@ -49,91 +50,12 @@ export const UpdateCommand: CommandModule = {
 
     UI.info(`Updating v${current} → v${latest}...`)
 
-    const os = process.platform === "win32" ? "windows" : process.platform === "darwin" ? "darwin" : "linux"
-    const arch = process.arch === "arm64" ? "arm64" : "x64"
-    const platform = `${os}-${arch}`
-    const pkg_name = `codeblog-app-${platform}`
-    const url = `https://registry.npmjs.org/${pkg_name}/-/${pkg_name}-${latest}.tgz`
-
-    const tmpdir = (await import("os")).tmpdir()
-    const path = await import("path")
-    const fs = await import("fs/promises")
-    const tmp = path.join(tmpdir, `codeblog-update-${Date.now()}`)
-    await fs.mkdir(tmp, { recursive: true })
-
-    UI.info("Downloading...")
-    const tgz = path.join(tmp, "pkg.tgz")
-    const dlController = new AbortController()
-    const dlTimeout = setTimeout(() => dlController.abort(), 60_000)
-    let dlRes: Response
     try {
-      dlRes = await fetch(url, { signal: dlController.signal })
-    } catch (e: any) {
-      clearTimeout(dlTimeout)
-      await fs.rm(tmp, { recursive: true, force: true }).catch(() => {})
-      if (e.name === "AbortError") {
-        UI.error("Download timed out (60s). Please check your network and try again.")
-      } else {
-        UI.error(`Download failed: ${e.message}`)
-      }
+      await performUpdate(latest)
+      UI.success(`Updated to v${latest}!`)
+    } catch (e) {
+      UI.error(e instanceof Error ? e.message : String(e))
       process.exitCode = 1
-      return
-    }
-    clearTimeout(dlTimeout)
-    if (!dlRes.ok) {
-      UI.error(`Failed to download update for ${platform} (HTTP ${dlRes.status})`)
-      await fs.rm(tmp, { recursive: true, force: true }).catch(() => {})
-      process.exitCode = 1
-      return
-    }
-
-    const arrayBuf = await dlRes.arrayBuffer()
-    await fs.writeFile(tgz, Buffer.from(arrayBuf))
-
-    UI.info("Extracting...")
-    const proc = Bun.spawn(["tar", "-xzf", tgz, "-C", tmp], { stdout: "ignore", stderr: "ignore" })
-    await proc.exited
-
-    const bin = process.execPath
-    const ext = os === "windows" ? ".exe" : ""
-    const src = path.join(tmp, "package", "bin", `codeblog${ext}`)
-
-    UI.info("Installing...")
-    // On macOS/Linux, remove the running binary first to avoid ETXTBSY
-    if (os !== "windows") {
-      try {
-        await fs.unlink(bin)
-      } catch {
-        // ignore if removal fails
-      }
-    }
-    await fs.copyFile(src, bin)
-    if (os !== "windows") {
-      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" })
-      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 })
-
-    UI.success(`Updated to v${latest}!`)
   },
 }

package/src/cli/perform-update.ts

@@ -0,0 +1,68 @@
+import path from "path"
+import { tmpdir } from "os"
+import { mkdir, writeFile, rm, unlink, copyFile, chmod } from "fs/promises"
+
+/**
+ * Downloads and installs a specific version of the codeblog CLI binary.
+ * Shared between the `update` command and auto-update logic.
+ *
+ * Throws on failure so callers can handle errors as they see fit.
+ */
+export async function performUpdate(latest: string): Promise<void> {
+  const os = process.platform === "win32" ? "windows" : process.platform === "darwin" ? "darwin" : "linux"
+  const arch = process.arch === "arm64" ? "arm64" : "x64"
+  const platform = `${os}-${arch}`
+  const pkgName = `codeblog-app-${platform}`
+  const url = `https://registry.npmjs.org/${pkgName}/-/${pkgName}-${latest}.tgz`
+
+  const tmp = path.join(tmpdir(), `codeblog-update-${Date.now()}`)
+  await mkdir(tmp, { recursive: true })
+
+  try {
+    // Download
+    const tgz = path.join(tmp, "pkg.tgz")
+    const dlController = new AbortController()
+    const dlTimeout = setTimeout(() => dlController.abort(), 60_000)
+    let dlRes: Response
+    try {
+      dlRes = await fetch(url, { signal: dlController.signal })
+    } catch (e: any) {
+      clearTimeout(dlTimeout)
+      if (e.name === "AbortError") throw new Error("Download timed out (60s)")
+      throw new Error(`Download failed: ${e.message}`)
+    }
+    clearTimeout(dlTimeout)
+    if (!dlRes.ok) throw new Error(`Failed to download update for ${platform} (HTTP ${dlRes.status})`)
+
+    const arrayBuf = await dlRes.arrayBuffer()
+    await writeFile(tgz, Buffer.from(arrayBuf))
+
+    // Extract
+    const proc = Bun.spawn(["tar", "-xzf", tgz, "-C", tmp], { stdout: "ignore", stderr: "ignore" })
+    await proc.exited
+
+    // Install
+    const bin = process.execPath
+    const ext = os === "windows" ? ".exe" : ""
+    const src = path.join(tmp, "package", "bin", `codeblog${ext}`)
+
+    if (os !== "windows") {
+      try { await unlink(bin) } catch {}
+    }
+    await copyFile(src, bin)
+    if (os !== "windows") {
+      await chmod(bin, 0o755)
+    }
+
+    // macOS codesign
+    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" })
+      if ((await cs.exited) !== 0) throw new Error("macOS code signing failed")
+      const verify = Bun.spawn(["codesign", "--verify", "--deep", "--strict", bin], { stdout: "ignore", stderr: "ignore" })
+      if ((await verify.exited) !== 0) throw new Error("macOS signature verification failed")
+    }
+  } finally {
+    await rm(tmp, { recursive: true, force: true }).catch(() => {})
+  }
+}

package/src/cli/ui.ts

@@ -200,7 +200,7 @@ export namespace UI {
     })
   }
 
-  export async function select(prompt: string, options: string[]): Promise<number> {
+  export async function select(prompt: string, options: string[], opts?: { searchable?: boolean }): Promise<number> {
     if (options.length === 0) return 0
 
     const stdin = process.stdin
@@ -209,8 +209,11 @@ export namespace UI {
     process.stderr.write("\x1b[?25l")
 
     let idx = 0
+    let filter = ""
+    let filtered = options.map((label, originalIndex) => ({ label, originalIndex }))
     let drawnRows = 0
     const maxRows = 12
+    const searchable = opts?.searchable !== false
     let onData: ((ch: Buffer) => void) = () => {}
 
     const stripAnsi = (text: string) => text.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "").replace(/\x1b./g, "")
@@ -220,24 +223,42 @@ export namespace UI {
       return Math.max(1, Math.ceil((len || 1) / cols))
     }
 
+    const applyFilter = () => {
+      const q = filter.toLowerCase()
+      if (!q) {
+        filtered = options.map((label, originalIndex) => ({ label, originalIndex }))
+      } else {
+        filtered = options
+          .map((label, originalIndex) => ({ label, originalIndex }))
+          .filter(({ label }) => stripAnsi(label).toLowerCase().includes(q))
+      }
+      idx = 0
+    }
+
     const draw = () => {
       if (drawnRows > 1) process.stderr.write(`\x1b[${drawnRows - 1}F`)
       process.stderr.write("\x1b[J")
 
-      const start = options.length <= maxRows ? 0 : Math.max(0, Math.min(idx - 4, options.length - maxRows))
-      const items = options.slice(start, start + maxRows)
+      const count = filtered.length
+      const start = count <= maxRows ? 0 : Math.max(0, Math.min(idx - 4, count - maxRows))
+      const items = filtered.slice(start, start + maxRows)
+      const searchLine = filter
+        ? `  ${Style.TEXT_HIGHLIGHT}❯${Style.TEXT_NORMAL} ${filter}${Style.TEXT_DIM}█${Style.TEXT_NORMAL}`
+        : `  ${Style.TEXT_HIGHLIGHT}❯${Style.TEXT_NORMAL} ${Style.TEXT_DIM}type to search...${Style.TEXT_NORMAL}`
       const lines = [
         prompt,
+        ...(searchable ? [searchLine] : []),
         ...items.map((item, i) => {
           const active = start + i === idx
           const marker = active ? `${Style.TEXT_HIGHLIGHT}●${Style.TEXT_NORMAL}` : "○"
-          const text = active ? `${Style.TEXT_NORMAL_BOLD}${item}${Style.TEXT_NORMAL}` : item
+          const text = active ? `${Style.TEXT_NORMAL_BOLD}${item.label}${Style.TEXT_NORMAL}` : item.label
           return `  ${marker} ${text}`
         }),
-        options.length > maxRows
-          ? `  ${Style.TEXT_DIM}${start > 0 ? "↑ more  " : ""}${start + maxRows < options.length ? "↓ more" : ""}${Style.TEXT_NORMAL}`
+        ...(count === 0 ? [`  ${Style.TEXT_DIM}No matches${Style.TEXT_NORMAL}`] : []),
+        count > maxRows
+          ? `  ${Style.TEXT_DIM}${start > 0 ? "↑ more  " : ""}${start + maxRows < count ? "↓ more" : ""}${Style.TEXT_NORMAL}`
           : `  ${Style.TEXT_DIM}${Style.TEXT_NORMAL}`,
-        `  ${Style.TEXT_DIM}Use ↑/↓ then Enter (Esc to cancel)${Style.TEXT_NORMAL}`,
+        `  ${Style.TEXT_DIM}↑/↓ select · Enter confirm · Esc ${filter ? "clear" : "cancel"}${Style.TEXT_NORMAL}`,
       ]
       process.stderr.write(lines.map((line) => `\x1b[2K\r${line}`).join("\n"))
       drawnRows = lines.reduce((sum, line) => sum + rowCount(line), 0)
@@ -260,25 +281,57 @@ export namespace UI {
           process.exit(130)
         }
         if (c === "\r" || c === "\n") {
-          restore()
-          resolve(idx)
+          if (filtered.length > 0) {
+            restore()
+            resolve(filtered[idx]!.originalIndex)
+          }
           return
         }
         if (c === "\x1b") {
-          restore()
-          resolve(-1)
+          if (searchable && filter) {
+            filter = ""
+            applyFilter()
+            draw()
+          } else {
+            restore()
+            resolve(-1)
+          }
           return
         }
-        if (c === "k" || c.includes("\x1b[A") || c.includes("\x1bOA")) {
-          idx = (idx - 1 + options.length) % options.length
+        if (c === "\x7f" || c === "\b") {
+          if (searchable && filter) {
+            filter = filter.slice(0, -1)
+            applyFilter()
+            draw()
+          }
+          return
+        }
+        if (c.includes("\x1b[A") || c.includes("\x1bOA")) {
+          if (filtered.length > 0) idx = (idx - 1 + filtered.length) % filtered.length
           draw()
           return
         }
-        if (c === "j" || c.includes("\x1b[B") || c.includes("\x1bOB")) {
-          idx = (idx + 1) % options.length
+        if (c.includes("\x1b[B") || c.includes("\x1bOB")) {
+          if (filtered.length > 0) idx = (idx + 1) % filtered.length
           draw()
           return
         }
+        // j/k navigation only when filter is empty (otherwise they are search characters)
+        if (!filter && (c === "k" || c === "j")) {
+          if (c === "k") idx = (idx - 1 + filtered.length) % filtered.length
+          else idx = (idx + 1) % filtered.length
+          draw()
+          return
+        }
+        // Printable characters → append to search filter (only when searchable)
+        if (searchable) {
+          const printable = c.replace(/[\x00-\x1f\x7f]/g, "")
+          if (printable) {
+            filter += printable
+            applyFilter()
+            draw()
+          }
+        }
       }
       stdin.on("data", onData)
     })

package/src/index.ts

@@ -5,6 +5,7 @@ import { UI } from "./cli/ui"
 import { EOL } from "os"
 import { McpBridge } from "./mcp/client"
 import { Auth } from "./auth"
+import { checkAndAutoUpdate } from "./cli/auto-update"
 
 // Commands
 import { SetupCommand } from "./cli/cmd/setup"
@@ -161,6 +162,11 @@ const hasSubcommand = args.length > 0 && !args[0]!.startsWith("-")
 const isHelp = args.includes("--help") || args.includes("-h")
 const isVersion = args.includes("--version") || args.includes("-v")
 
+// Auto-update check on startup
+if (!isHelp && !isVersion) {
+  await checkAndAutoUpdate()
+}
+
 if (!hasSubcommand && !isHelp && !isVersion) {
   await Log.init({ print: false })
   Log.Default.info("codeblog", { version: VERSION, args: [] })