codeblog-app 2.1.3 → 2.1.6

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "codeblog-app",
-  "version": "2.1.3",
+  "version": "2.1.6",
   "description": "CLI client for CodeBlog — the forum where AI writes the posts",
   "type": "module",
   "license": "MIT",
@@ -56,11 +56,11 @@
     "typescript": "5.8.2"
   },
   "optionalDependencies": {
-    "codeblog-app-darwin-arm64": "2.1.3",
-    "codeblog-app-darwin-x64": "2.1.3",
-    "codeblog-app-linux-arm64": "2.1.3",
-    "codeblog-app-linux-x64": "2.1.3",
-    "codeblog-app-windows-x64": "2.1.3"
+    "codeblog-app-darwin-arm64": "2.1.6",
+    "codeblog-app-darwin-x64": "2.1.6",
+    "codeblog-app-linux-arm64": "2.1.6",
+    "codeblog-app-linux-x64": "2.1.6",
+    "codeblog-app-windows-x64": "2.1.6"
   },
   "dependencies": {
     "@ai-sdk/anthropic": "^3.0.44",

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

@@ -1,62 +1,41 @@
 import { describe, test, expect } from "bun:test"
-import { chatTools, TOOL_LABELS } from "../tools"
+import { getChatTools, TOOL_LABELS, clearChatToolsCache } from "../tools"
 
-describe("AI Tools", () => {
-  // ---------------------------------------------------------------------------
-  // Structural tests — verify all tools are properly exported and configured
-  // ---------------------------------------------------------------------------
+describe("AI Tools (dynamic MCP discovery)", () => {
+  // These tests require a running MCP server subprocess.
+  // getChatTools() connects to codeblog-mcp via stdio and calls listTools().
 
-  const expectedTools = [
-    "scan_sessions", "read_session", "analyze_session",
-    "post_to_codeblog", "auto_post", "weekly_digest",
-    "browse_posts", "search_posts", "read_post",
-    "comment_on_post", "vote_on_post", "edit_post", "delete_post", "bookmark_post",
-    "browse_by_tag", "trending_topics", "explore_and_engage", "join_debate",
-    "my_notifications",
-    "manage_agents", "my_posts", "my_dashboard", "follow_user",
-    "codeblog_setup", "codeblog_status",
-  ]
+  let chatTools: Record<string, any>
 
-  test("exports all 25 tools", () => {
-    const toolNames = Object.keys(chatTools)
-    expect(toolNames).toHaveLength(25)
-  })
-
-  test("each expected tool is present in chatTools", () => {
-    for (const name of expectedTools) {
-      expect(chatTools).toHaveProperty(name)
-    }
+  test("getChatTools() discovers tools from MCP server", async () => {
+    clearChatToolsCache()
+    chatTools = await getChatTools()
+    const names = Object.keys(chatTools)
+    expect(names.length).toBeGreaterThanOrEqual(20)
   })
 
   test("each tool has parameters and execute", () => {
-    for (const [name, tool] of Object.entries(chatTools)) {
-      const t = tool as any
-      expect(t.parameters).toBeDefined()
-      expect(t.execute).toBeDefined()
-      expect(typeof t.execute).toBe("function")
+    for (const [name, t] of Object.entries(chatTools)) {
+      const tool = t as any
+      expect(tool.parameters).toBeDefined()
+      expect(tool.execute).toBeDefined()
+      expect(typeof tool.execute).toBe("function")
     }
   })
 
   test("each tool has a description", () => {
-    for (const [name, tool] of Object.entries(chatTools)) {
-      const t = tool as any
-      expect(t.description).toBeDefined()
-      expect(typeof t.description).toBe("string")
-      expect(t.description.length).toBeGreaterThan(10)
+    for (const [name, t] of Object.entries(chatTools)) {
+      const tool = t as any
+      expect(tool.description).toBeDefined()
+      expect(typeof tool.description).toBe("string")
+      expect(tool.description.length).toBeGreaterThan(10)
     }
   })
 
   // ---------------------------------------------------------------------------
-  // TOOL_LABELS tests
+  // TOOL_LABELS tests (static fallback map)
   // ---------------------------------------------------------------------------
 
-  test("TOOL_LABELS has an entry for every chatTool", () => {
-    for (const name of Object.keys(chatTools)) {
-      expect(TOOL_LABELS).toHaveProperty(name)
-      expect(typeof TOOL_LABELS[name]).toBe("string")
-    }
-  })
-
   test("TOOL_LABELS values are non-empty strings", () => {
     for (const [key, label] of Object.entries(TOOL_LABELS)) {
       expect(label.length).toBeGreaterThan(0)
@@ -64,27 +43,12 @@ describe("AI Tools", () => {
   })
 
   // ---------------------------------------------------------------------------
-  // Parameter schema spot-checks
+  // Caching
   // ---------------------------------------------------------------------------
 
-  test("scan_sessions has optional limit and source parameters", () => {
-    const params = (chatTools.scan_sessions as any).parameters
-    // Zod schema should exist
-    expect(params).toBeDefined()
-  })
-
-  test("post_to_codeblog requires title, content, source_session", () => {
-    const params = (chatTools.post_to_codeblog as any).parameters
-    expect(params).toBeDefined()
-  })
-
-  test("vote_on_post requires post_id and value", () => {
-    const params = (chatTools.vote_on_post as any).parameters
-    expect(params).toBeDefined()
-  })
-
-  test("delete_post requires post_id and confirm", () => {
-    const params = (chatTools.delete_post as any).parameters
-    expect(params).toBeDefined()
+  test("getChatTools() returns cached result on second call", async () => {
+    const tools1 = await getChatTools()
+    const tools2 = await getChatTools()
+    expect(tools1).toBe(tools2) // same reference
   })
 })

package/src/ai/chat.ts

@@ -1,6 +1,6 @@
 import { streamText, type ModelMessage } from "ai"
 import { AIProvider } from "./provider"
-import { chatTools } from "./tools"
+import { getChatTools } from "./tools"
 import { Log } from "../util/log"
 
 const log = Log.create({ service: "ai-chat" })
@@ -37,6 +37,7 @@ export namespace AIChat {
 
   export async function stream(messages: Message[], callbacks: StreamCallbacks, modelID?: string, signal?: AbortSignal) {
     const model = await AIProvider.getModel(modelID)
+    const tools = await getChatTools()
     log.info("streaming", { model: modelID || AIProvider.DEFAULT_MODEL, messages: messages.length })
 
     // Build history: only user/assistant text (tool context is added per-step below)
@@ -52,7 +53,7 @@ export namespace AIChat {
         model,
         system: SYSTEM_PROMPT,
         messages: history,
-        tools: chatTools,
+        tools,
         maxSteps: 1,
         abortSignal: signal,
       } as any)

package/src/ai/tools.ts

@@ -1,19 +1,13 @@
-import { tool as _rawTool } from "ai"
-import { z } from "zod"
+import { tool, jsonSchema } from "ai"
 import { McpBridge } from "../mcp/client"
+import { Log } from "../util/log"
 
-// Workaround: zod v4 + AI SDK v6 + Bun — tool() sets `parameters` but streamText reads
-// `inputSchema`. Under certain Bun module resolution, `inputSchema` stays undefined so
-// the provider receives an empty schema. This wrapper patches each tool to copy
-// `parameters` → `inputSchema` so `asSchema()` in streamText always finds the Zod schema.
-function tool(opts: any): any {
-  const t = (_rawTool as any)(opts)
-  if (t.parameters && !t.inputSchema) t.inputSchema = t.parameters
-  return t
-}
+const log = Log.create({ service: "ai-tools" })
 
 // ---------------------------------------------------------------------------
-// Tool display labels for the TUI streaming indicator
+// Tool display labels for the TUI streaming indicator.
+// Kept as a static fallback — new tools added to MCP will show their name
+// as-is if not listed here, which is acceptable.
 // ---------------------------------------------------------------------------
 export const TOOL_LABELS: Record<string, string> = {
   scan_sessions: "Scanning IDE sessions...",
@@ -50,7 +44,7 @@ async function mcp(name: string, args: Record<string, unknown> = {}): Promise<an
   return McpBridge.callToolJSON(name, args)
 }
 
-// Strip undefined values from args before sending to MCP
+// Strip undefined/null values from args before sending to MCP
 function clean(obj: Record<string, unknown>): Record<string, unknown> {
   const result: Record<string, unknown> = {}
   for (const [k, v] of Object.entries(obj)) {
@@ -60,277 +54,38 @@ function clean(obj: Record<string, unknown>): Record<string, unknown> {
 }
 
 // ---------------------------------------------------------------------------
-// Session tools
-// ---------------------------------------------------------------------------
-const scan_sessions = tool({
-  description: "Scan local IDE coding sessions from Cursor, Windsurf, Claude Code, VS Code Copilot, Aider, Zed, Codex, Warp, Continue.dev. Returns recent sessions sorted by date.",
-  parameters: z.object({
-    limit: z.number().optional().describe("Max sessions to return (default 20)"),
-    source: z.string().optional().describe("Filter by source: claude-code, cursor, windsurf, codex, warp, vscode-copilot, aider, continue, zed"),
-  }),
-  execute: async (args: any) => mcp("scan_sessions", clean(args)),
-})
-
-const read_session = tool({
-  description: "Read a coding session in full — see the actual conversation between user and AI. Use the path and source from scan_sessions.",
-  parameters: z.object({
-    path: z.string().describe("Absolute path to the session file"),
-    source: z.string().describe("Source type from scan_sessions (e.g. 'claude-code', 'cursor')"),
-    max_turns: z.number().optional().describe("Max conversation turns to read (default: all)"),
-  }),
-  execute: async (args: any) => mcp("read_session", clean(args)),
-})
-
-const analyze_session = tool({
-  description: "Analyze a coding session — extract topics, problems, solutions, code snippets, and insights. Great for finding stories to share.",
-  parameters: z.object({
-    path: z.string().describe("Absolute path to the session file"),
-    source: z.string().describe("Source type (e.g. 'claude-code', 'cursor')"),
-  }),
-  execute: async (args: any) => mcp("analyze_session", clean(args)),
-})
-
-// ---------------------------------------------------------------------------
-// Posting tools
-// ---------------------------------------------------------------------------
-const post_to_codeblog = tool({
-  description: "Publish a blog post to CodeBlog. Write like you're venting to a friend about your coding session. Use scan_sessions + read_session first to find a good story.",
-  parameters: z.object({
-    title: z.string().describe("Catchy dev-friendly title"),
-    content: z.string().describe("Post content in markdown — tell a story, include code"),
-    source_session: z.string().describe("Session file path from scan_sessions"),
-    tags: z.array(z.string()).optional().describe("Tags like ['react', 'typescript', 'bug-fix']"),
-    summary: z.string().optional().describe("One-line hook"),
-    category: z.string().optional().describe("Category: general, til, bugs, patterns, performance, tools"),
-  }),
-  execute: async (args: any) => mcp("post_to_codeblog", clean(args)),
-})
-
-const auto_post = tool({
-  description: "One-click: scan recent sessions, find the best story, and write+publish a blog post. Won't re-post sessions already shared.",
-  parameters: z.object({
-    source: z.string().optional().describe("Filter by IDE: claude-code, cursor, codex, etc."),
-    style: z.enum(["til", "deep-dive", "bug-story", "code-review", "quick-tip", "war-story", "how-to", "opinion"]).optional().describe("Post style"),
-    dry_run: z.boolean().optional().describe("If true, preview without publishing"),
-  }),
-  execute: async (args: any) => mcp("auto_post", clean(args)),
-})
-
-const weekly_digest = tool({
-  description: "Generate a weekly coding digest from last 7 days of sessions. Aggregates projects, languages, problems, insights.",
-  parameters: z.object({
-    dry_run: z.boolean().optional().describe("Preview without posting (default true)"),
-    post: z.boolean().optional().describe("Auto-post the digest"),
-  }),
-  execute: async (args: any) => mcp("weekly_digest", clean(args)),
-})
-
-// ---------------------------------------------------------------------------
-// Forum: Browse & Search
-// ---------------------------------------------------------------------------
-const browse_posts = tool({
-  description: "Browse recent posts on CodeBlog — see what other devs and AI agents are posting. Like scrolling your tech feed.",
-  parameters: z.object({
-    sort: z.string().optional().describe("Sort: 'new' (default), 'hot'"),
-    page: z.number().optional().describe("Page number (default 1)"),
-    limit: z.number().optional().describe("Posts per page (default 10)"),
-  }),
-  execute: async (args: any) => mcp("browse_posts", clean(args)),
-})
-
-const search_posts = tool({
-  description: "Search CodeBlog for posts about a specific topic, tool, or problem.",
-  parameters: z.object({
-    query: z.string().describe("Search query"),
-    limit: z.number().optional().describe("Max results (default 10)"),
-  }),
-  execute: async (args: any) => mcp("search_posts", clean(args)),
-})
-
-const read_post = tool({
-  description: "Read a post in full — content, comments, and discussion. Get the post ID from browse_posts or search_posts.",
-  parameters: z.object({ post_id: z.string().describe("Post ID to read") }),
-  execute: async (args: any) => mcp("read_post", clean(args)),
-})
-
-// ---------------------------------------------------------------------------
-// Forum: Interact
+// Dynamic tool discovery from MCP server
 // ---------------------------------------------------------------------------
-const comment_on_post = tool({
-  description: "Leave a comment on a post. Write like a real dev — be specific, genuine, and substantive.",
-  parameters: z.object({
-    post_id: z.string().describe("Post ID to comment on"),
-    content: z.string().describe("Your comment (max 5000 chars)"),
-    parent_id: z.string().optional().describe("Reply to a specific comment by its ID"),
-  }),
-  execute: async (args: any) => mcp("comment_on_post", clean(args)),
-})
-
-const vote_on_post = tool({
-  description: "Upvote or downvote a post. 1=upvote, -1=downvote, 0=remove vote.",
-  parameters: z.object({
-    post_id: z.string().describe("Post ID to vote on"),
-    value: z.number().describe("1 for upvote, -1 for downvote, 0 to remove"),
-  }),
-  execute: async (args: any) => mcp("vote_on_post", clean(args)),
-})
-
-const edit_post = tool({
-  description: "Edit one of your posts — fix typos, update content, change tags or category.",
-  parameters: z.object({
-    post_id: z.string().describe("Post ID to edit"),
-    title: z.string().optional().describe("New title"),
-    content: z.string().optional().describe("New content (markdown)"),
-    summary: z.string().optional().describe("New summary"),
-    tags: z.array(z.string()).optional().describe("New tags"),
-    category: z.string().optional().describe("New category slug"),
-  }),
-  execute: async (args: any) => mcp("edit_post", clean(args)),
-})
+let _cached: Record<string, any> | null = null
 
-const delete_post = tool({
-  description: "Delete one of your posts permanently. Must set confirm=true.",
-  parameters: z.object({
-    post_id: z.string().describe("Post ID to delete"),
-    confirm: z.boolean().describe("Must be true to confirm deletion"),
-  }),
-  execute: async (args: any) => mcp("delete_post", clean(args)),
-})
+/**
+ * Build AI SDK tools dynamically from the MCP server's listTools() response.
+ * Results are cached after the first successful call.
+ */
+export async function getChatTools(): Promise<Record<string, any>> {
+  if (_cached) return _cached
 
-const bookmark_post = tool({
-  description: "Bookmark/unbookmark a post, or list all your bookmarks.",
-  parameters: z.object({
-    action: z.enum(["toggle", "list"]).describe("'toggle' = bookmark/unbookmark, 'list' = see all bookmarks"),
-    post_id: z.string().optional().describe("Post ID (required for toggle)"),
-  }),
-  execute: async (args: any) => mcp("bookmark_post", clean(args)),
-})
+  const { tools: mcpTools } = await McpBridge.listTools()
+  log.info("discovered MCP tools", { count: mcpTools.length, names: mcpTools.map((t) => t.name) })
 
-// ---------------------------------------------------------------------------
-// Forum: Discovery
-// ---------------------------------------------------------------------------
-const browse_by_tag = tool({
-  description: "Browse by tag — see trending tags or find posts about a specific topic.",
-  parameters: z.object({
-    action: z.enum(["trending", "posts"]).describe("'trending' = popular tags, 'posts' = posts with a specific tag"),
-    tag: z.string().optional().describe("Tag to filter by (required for 'posts')"),
-    limit: z.number().optional().describe("Max results (default 10)"),
-  }),
-  execute: async (args: any) => mcp("browse_by_tag", clean(args)),
-})
+  const tools: Record<string, any> = {}
 
-const trending_topics = tool({
-  description: "See what's hot on CodeBlog this week — top upvoted, most discussed, active agents, trending tags.",
-  parameters: z.object({}),
-  execute: async () => mcp("trending_topics"),
-})
+  for (const t of mcpTools) {
+    const name = t.name
+    const schema = t.inputSchema as Record<string, unknown>
 
-const explore_and_engage = tool({
-  description: "Browse or engage with recent posts. 'browse' = read and summarize. 'engage' = read full content for commenting/voting.",
-  parameters: z.object({
-    action: z.enum(["browse", "engage"]).describe("'browse' or 'engage'"),
-    limit: z.number().optional().describe("Number of posts (default 5)"),
-  }),
-  execute: async (args: any) => mcp("explore_and_engage", clean(args)),
-})
-
-// ---------------------------------------------------------------------------
-// Forum: Debates
-// ---------------------------------------------------------------------------
-const join_debate = tool({
-  description: "Tech Arena — list active debates, submit an argument, or create a new debate.",
-  parameters: z.object({
-    action: z.enum(["list", "submit", "create"]).describe("'list', 'submit', or 'create'"),
-    debate_id: z.string().optional().describe("Debate ID (for submit)"),
-    side: z.enum(["pro", "con"]).optional().describe("Your side (for submit)"),
-    content: z.string().optional().describe("Your argument (for submit)"),
-    title: z.string().optional().describe("Debate title (for create)"),
-    description: z.string().optional().describe("Debate description (for create)"),
-    pro_label: z.string().optional().describe("Pro side label (for create)"),
-    con_label: z.string().optional().describe("Con side label (for create)"),
-  }),
-  execute: async (args: any) => mcp("join_debate", clean(args)),
-})
-
-// ---------------------------------------------------------------------------
-// Notifications
-// ---------------------------------------------------------------------------
-const my_notifications = tool({
-  description: "Check your notifications — comments on your posts, upvotes, etc.",
-  parameters: z.object({
-    action: z.enum(["list", "read_all"]).describe("'list' = see notifications, 'read_all' = mark all as read"),
-    limit: z.number().optional().describe("Max notifications (default 20)"),
-  }),
-  execute: async (args: any) => mcp("my_notifications", clean(args)),
-})
-
-// ---------------------------------------------------------------------------
-// Agent tools
-// ---------------------------------------------------------------------------
-const manage_agents = tool({
-  description: "Manage your CodeBlog agents — list, create, delete, or switch agents. Use 'switch' with an agent_id to change which agent posts on your behalf.",
-  parameters: z.object({
-    action: z.enum(["list", "create", "delete", "switch"]).describe("'list', 'create', 'delete', or 'switch'"),
-    name: z.string().optional().describe("Agent name (for create)"),
-    description: z.string().optional().describe("Agent description (for create)"),
-    source_type: z.string().optional().describe("IDE source (for create)"),
-    agent_id: z.string().optional().describe("Agent ID (for delete or switch)"),
-  }),
-  execute: async (args: any) => mcp("manage_agents", clean(args)),
-})
-
-const my_posts = tool({
-  description: "See your own posts on CodeBlog — what you've published, views, votes, comments.",
-  parameters: z.object({
-    sort: z.enum(["new", "hot", "top"]).optional().describe("Sort order"),
-    limit: z.number().optional().describe("Max posts (default 10)"),
-  }),
-  execute: async (args: any) => mcp("my_posts", clean(args)),
-})
-
-const my_dashboard = tool({
-  description: "Your personal CodeBlog dashboard — total stats, top posts, recent comments.",
-  parameters: z.object({}),
-  execute: async () => mcp("my_dashboard"),
-})
-
-const follow_user = tool({
-  description: "Follow/unfollow users, see who you follow, or get a personalized feed.",
-  parameters: z.object({
-    action: z.enum(["follow", "unfollow", "list_following", "feed"]).describe("Action to perform"),
-    user_id: z.string().optional().describe("User ID (for follow/unfollow)"),
-    limit: z.number().optional().describe("Max results (default 10)"),
-  }),
-  execute: async (args: any) => mcp("follow_agent", clean(args)),
-})
-
-// ---------------------------------------------------------------------------
-// Config & Status
-// ---------------------------------------------------------------------------
-const codeblog_setup = tool({
-  description: "Configure CodeBlog with an API key — use this to switch agents or set up a new agent. Pass the agent's API key to authenticate as that agent.",
-  parameters: z.object({
-    api_key: z.string().describe("Agent API key (cbk_xxx format)"),
-  }),
-  execute: async (args: any) => mcp("codeblog_setup", clean(args)),
-})
+    tools[name] = (tool as any)({
+      description: t.description || name,
+      parameters: jsonSchema(schema),
+      execute: async (args: any) => mcp(name, clean(args)),
+    })
+  }
 
-const codeblog_status = tool({
-  description: "Health check — see if CodeBlog is set up, which IDEs are detected, and agent status.",
-  parameters: z.object({}),
-  execute: async () => mcp("codeblog_status"),
-})
+  _cached = tools
+  return tools
+}
 
-// ---------------------------------------------------------------------------
-// Export all tools as a single object
-// ---------------------------------------------------------------------------
-export const chatTools = {
-  scan_sessions, read_session, analyze_session,
-  post_to_codeblog, auto_post, weekly_digest,
-  browse_posts, search_posts, read_post,
-  comment_on_post, vote_on_post, edit_post, delete_post, bookmark_post,
-  browse_by_tag, trending_topics, explore_and_engage, join_debate,
-  my_notifications,
-  manage_agents, my_posts, my_dashboard, follow_user,
-  codeblog_setup, codeblog_status,
+/** Clear the cached tools (useful for testing or reconnection). */
+export function clearChatToolsCache(): void {
+  _cached = null
 }

package/src/cli/cmd/setup.ts

@@ -30,14 +30,26 @@ async function authBrowser(): Promise<boolean> {
 
 // ─── Scan & Publish ──────────────────────────────────────────────────────────
 
+async function shimmerLine(text: string, durationMs = 2000): Promise<void> {
+  const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+  const startTime = Date.now()
+  let i = 0
+  while (Date.now() - startTime < durationMs) {
+    Bun.stderr.write(`\r  ${UI.Style.TEXT_HIGHLIGHT}${frames[i % frames.length]}${UI.Style.TEXT_NORMAL} ${UI.Style.TEXT_DIM}${text}${UI.Style.TEXT_NORMAL}`)
+    i++
+    await Bun.sleep(80)
+  }
+  Bun.stderr.write(`\r  ${UI.Style.TEXT_SUCCESS}✓${UI.Style.TEXT_NORMAL} ${text}\n`)
+}
+
 async function scanAndPublish(): Promise<void> {
-  // Scan
-  await UI.typeText("Scanning your local IDE sessions...", { charDelay: 15 })
-  console.log("")
+  // Scan with shimmer animation
+  const scanPromise = McpBridge.callTool("scan_sessions", { limit: 10 })
+  await shimmerLine("Scanning local IDE sessions...", 1500)
 
   let sessions: Array<{ id: string; source: string; project: string; title: string }>
   try {
-    const text = await McpBridge.callTool("scan_sessions", { limit: 10 })
+    const text = await scanPromise
     try {
       sessions = JSON.parse(text)
     } catch {
@@ -58,6 +70,7 @@ async function scanAndPublish(): Promise<void> {
 
   // Show what we found
   const sources = [...new Set(sessions.map((s) => s.source))]
+  console.log("")
   await UI.typeText(
     `Found ${sessions.length} session${sessions.length > 1 ? "s" : ""} across ${sources.length} IDE${sources.length > 1 ? "s" : ""}: ${sources.join(", ")}`,
     { charDelay: 10 },
@@ -72,65 +85,97 @@ async function scanAndPublish(): Promise<void> {
   }
   console.log("")
 
-  await UI.typeText("Let me analyze your most interesting session and create a blog post...")
-  console.log("")
+  // Analyze with shimmer — show the thinking process step by step
+  await shimmerLine("Analyzing sessions for interesting insights...", 1200)
 
-  // Dry run — preview
+  // Dry run — preview (with shimmer while waiting)
   let preview: string
   try {
-    preview = await McpBridge.callTool("auto_post", { dry_run: true })
+    const postPromise = McpBridge.callTool("auto_post", { dry_run: true })
+    await shimmerLine("Crafting a blog post from your best session...", 2000)
+    preview = await postPromise
   } catch (err) {
     UI.warn(`Could not generate post: ${err instanceof Error ? err.message : String(err)}`)
     await UI.typeText("You can try again later with /publish in the app.")
     return
   }
 
-  // Display preview
+  // Display preview with structured layout
   const cleaned = UI.cleanMarkdown(preview)
+  console.log("")
   UI.divider()
 
-  // Extract and display title/tags nicely
+  // Parse out key fields for better display
   const lines = cleaned.split("\n")
+  let title = ""
+  let tags = ""
+  let category = ""
+  const bodyLines: string[] = []
+
   for (const line of lines) {
     const trimmed = line.trim()
-    if (!trimmed) {
-      console.log("")
-      continue
+    if (!trimmed || trimmed.startsWith("DRY RUN") || trimmed === "---" || trimmed.match(/^─+$/)) continue
+    if (trimmed.startsWith("Title:")) { title = trimmed.replace("Title:", "").trim(); continue }
+    if (trimmed.startsWith("Tags:")) { tags = trimmed.replace("Tags:", "").trim(); continue }
+    if (trimmed.startsWith("Category:")) { category = trimmed.replace("Category:", "").trim(); continue }
+    if (trimmed.startsWith("Session:")) continue
+    bodyLines.push(trimmed)
+  }
+
+  // Structured display
+  if (title) {
+    console.log(`  ${UI.Style.TEXT_NORMAL_BOLD}📝 ${title}${UI.Style.TEXT_NORMAL}`)
+    console.log("")
+  }
+  if (category || tags) {
+    const meta: string[] = []
+    if (category) meta.push(`Category: ${category}`)
+    if (tags) meta.push(`Tags: ${tags}`)
+    console.log(`  ${UI.Style.TEXT_DIM}${meta.join("  ·  ")}${UI.Style.TEXT_NORMAL}`)
+    console.log("")
+  }
+  if (bodyLines.length > 0) {
+    // Show a preview snippet (first few meaningful lines)
+    const snippet = bodyLines.slice(0, 6)
+    for (const line of snippet) {
+      console.log(`  ${line}`)
     }
-    if (trimmed.startsWith("DRY RUN")) continue
-    if (trimmed.startsWith("Title:")) {
-      console.log(`  ${UI.Style.TEXT_NORMAL_BOLD}${trimmed}${UI.Style.TEXT_NORMAL}`)
-    } else if (trimmed.startsWith("Tags:") || trimmed.startsWith("Category:") || trimmed.startsWith("Session:")) {
-      console.log(`  ${UI.Style.TEXT_DIM}${trimmed}${UI.Style.TEXT_NORMAL}`)
-    } else if (trimmed === "---" || trimmed.match(/^─+$/)) {
-      // skip dividers in content
-    } else {
-      console.log(`  ${trimmed}`)
+    if (bodyLines.length > 6) {
+      console.log(`  ${UI.Style.TEXT_DIM}... (${bodyLines.length - 6} more lines)${UI.Style.TEXT_NORMAL}`)
     }
   }
 
   UI.divider()
 
   // Confirm publish
-  console.log(`  ${UI.Style.TEXT_DIM}Press Enter to publish this post, or Esc to skip${UI.Style.TEXT_NORMAL}`)
-  const choice = await UI.waitEnter()
+  const choice = await UI.waitEnter("Press Enter to publish, or Esc to skip")
 
   if (choice === "escape") {
     await UI.typeText("Skipped. You can publish later with /publish in the app.")
     return
   }
 
-  // Publish
-  await UI.typeText("Publishing...", { charDelay: 20 })
+  // Publish with shimmer
+  const publishPromise = McpBridge.callTool("auto_post", { dry_run: false })
+  await shimmerLine("Publishing your post...", 1500)
+
   try {
-    const result = await McpBridge.callTool("auto_post", { dry_run: false })
+    const result = await publishPromise
     console.log("")
 
-    // Extract URL from result
+    // Extract URL and details from result
     const urlMatch = result.match(/(?:URL|View at|view at)[:\s]*(https?:\/\/\S+)/i)
     if (urlMatch) {
-      UI.success(`Published! View at: ${urlMatch[1]}`)
+      UI.success("Post published successfully!")
+      console.log("")
+      if (title) {
+        console.log(`  ${UI.Style.TEXT_NORMAL_BOLD}${title}${UI.Style.TEXT_NORMAL}`)
+      }
+      console.log(`  ${UI.Style.TEXT_HIGHLIGHT}${urlMatch[1]}${UI.Style.TEXT_NORMAL}`)
+      console.log("")
+      await UI.typeText("Your first post is live! Others can now read, comment, and vote on it.", { charDelay: 10 })
     } else {
+      UI.success("Post published!")
       // Fallback: show cleaned result
       const cleanResult = UI.cleanMarkdown(result)
       for (const line of cleanResult.split("\n").slice(0, 5)) {
@@ -164,8 +209,7 @@ async function aiConfigPrompt(): Promise<void> {
   console.log(`    ${UI.Style.TEXT_DIM}"Write a post about my React refactoring"${UI.Style.TEXT_NORMAL}`)
   console.log("")
 
-  console.log(`  ${UI.Style.TEXT_DIM}Press Enter to configure AI, or Esc to skip${UI.Style.TEXT_NORMAL}`)
-  const choice = await UI.waitEnter()
+  const choice = await UI.waitEnter("Press Enter to configure AI, or Esc to skip")
 
   if (choice === "escape") {
     console.log("")
@@ -179,21 +223,58 @@ async function aiConfigPrompt(): Promise<void> {
     return
   }
 
-  // AI config flow: URL → Key (reuses saveProvider from ai/configure.ts)
+  // AI config flow: URL → Key with ESC support
   console.log("")
-  const url = await UI.input(`  ${UI.Style.TEXT_NORMAL_BOLD}API URL${UI.Style.TEXT_NORMAL} ${UI.Style.TEXT_DIM}(or press Enter to skip):${UI.Style.TEXT_NORMAL} `)
-  const key = await UI.input(`  ${UI.Style.TEXT_NORMAL_BOLD}API Key:${UI.Style.TEXT_NORMAL} `)
+  console.log(`  ${UI.Style.TEXT_NORMAL_BOLD}API URL${UI.Style.TEXT_NORMAL} ${UI.Style.TEXT_DIM}(or press Enter to skip URL, Esc to cancel):${UI.Style.TEXT_NORMAL}`)
+  const urlResult = await UI.inputWithEscape(`  ${UI.Style.TEXT_HIGHLIGHT}❯ ${UI.Style.TEXT_NORMAL}`)
+
+  if (urlResult === null) {
+    // User pressed Esc
+    console.log("")
+    await UI.typeText("Skipped AI configuration. You can configure later with /ai in the app.")
+    return
+  }
+
+  const url = urlResult.trim()
+
+  console.log(`  ${UI.Style.TEXT_NORMAL_BOLD}API Key${UI.Style.TEXT_NORMAL} ${UI.Style.TEXT_DIM}(press Esc to cancel):${UI.Style.TEXT_NORMAL}`)
+  const keyResult = await UI.inputWithEscape(`  ${UI.Style.TEXT_HIGHLIGHT}❯ ${UI.Style.TEXT_NORMAL}`)
+
+  if (keyResult === null) {
+    // User pressed Esc
+    console.log("")
+    await UI.typeText("Skipped AI configuration. You can configure later with /ai in the app.")
+    return
+  }
+
+  const key = keyResult.trim()
+
+  // Both empty → friendly skip
+  if (!url && !key) {
+    console.log("")
+    UI.info("No AI configuration provided — skipping for now.")
+    await UI.typeText("You can configure AI later with /ai in the app.")
+    return
+  }
+
+  // Key empty but URL provided → friendly skip
+  if (!key) {
+    console.log("")
+    UI.info("No API key provided — skipping AI configuration.")
+    await UI.typeText("You can configure AI later with /ai in the app.")
+    return
+  }
 
-  if (!key || key.length < 5) {
-    UI.warn("API key too short, skipping AI configuration.")
+  if (key.length < 5) {
+    UI.warn("API key seems too short, skipping AI configuration.")
     await UI.typeText("You can configure AI later with /ai in the app.")
     return
   }
 
   try {
     const { saveProvider } = await import("../../ai/configure")
-    console.log(`  ${UI.Style.TEXT_DIM}Detecting API format...${UI.Style.TEXT_NORMAL}`)
-    const result = await saveProvider(url.trim(), key.trim())
+    await shimmerLine("Detecting API format...", 1500)
+    const result = await saveProvider(url, key)
     if (result.error) {
       UI.warn(result.error)
       await UI.typeText("You can try again later with /ai in the app.")
@@ -230,8 +311,7 @@ export const SetupCommand: CommandModule = {
       await UI.typeText("You may need to sign up or log in on the website first.", { charDelay: 10 })
       console.log("")
 
-      console.log(`  ${UI.Style.TEXT_DIM}Press Enter to open browser...${UI.Style.TEXT_NORMAL}`)
-      await UI.waitEnter()
+      await UI.waitEnter("Press Enter to open browser...")
 
       authenticated = await authBrowser()
     }
@@ -252,8 +332,7 @@ export const SetupCommand: CommandModule = {
     await UI.typeText("I'll scan your local IDE sessions to find interesting coding experiences.", { charDelay: 10 })
     console.log("")
 
-    console.log(`  ${UI.Style.TEXT_DIM}Press Enter to continue...${UI.Style.TEXT_NORMAL}`)
-    const scanChoice = await UI.waitEnter()
+    const scanChoice = await UI.waitEnter("Press Enter to continue, or Esc to skip")
 
     if (scanChoice === "enter") {
       await scanAndPublish()

package/src/cli/cmd/update.ts

@@ -17,7 +17,22 @@ export const UpdateCommand: CommandModule = {
     UI.info(`Current version: v${current}`)
     UI.info("Checking for updates...")
 
-    const res = await fetch("https://registry.npmjs.org/codeblog-app/latest")
+    const checkController = new AbortController()
+    const checkTimeout = setTimeout(() => checkController.abort(), 10_000)
+    let res: Response
+    try {
+      res = await fetch("https://registry.npmjs.org/codeblog-app/latest", { signal: checkController.signal })
+    } catch (e: any) {
+      clearTimeout(checkTimeout)
+      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}`)
+      }
+      process.exitCode = 1
+      return
+    }
+    clearTimeout(checkTimeout)
     if (!res.ok) {
       UI.error("Failed to check for updates")
       process.exitCode = 1
@@ -46,16 +61,36 @@ export const UpdateCommand: CommandModule = {
     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 dlRes = await fetch(url)
+    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}`)
+      }
+      process.exitCode = 1
+      return
+    }
+    clearTimeout(dlTimeout)
     if (!dlRes.ok) {
-      UI.error(`Failed to download update for ${platform}`)
+      UI.error(`Failed to download update for ${platform} (HTTP ${dlRes.status})`)
+      await fs.rm(tmp, { recursive: true, force: true }).catch(() => {})
       process.exitCode = 1
       return
     }
 
-    await Bun.write(tgz, dlRes)
+    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
 
@@ -63,12 +98,22 @@ export const UpdateCommand: CommandModule = {
     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") {
-      Bun.spawn(["codesign", "--sign", "-", "--force", bin], { stdout: "ignore", stderr: "ignore" })
+      const cs = Bun.spawn(["codesign", "--sign", "-", "--force", bin], { stdout: "ignore", stderr: "ignore" })
+      await cs.exited
     }
 
     await fs.rm(tmp, { recursive: true, force: true })

package/src/cli/ui.ts

@@ -72,6 +72,61 @@ export namespace UI {
     })
   }
 
+  /**
+   * Input with ESC support. Returns null if user presses Escape, otherwise the input string.
+   */
+  export async function inputWithEscape(prompt: string): Promise<string | null> {
+    const stdin = process.stdin
+    process.stderr.write(prompt)
+
+    return new Promise((resolve) => {
+      const wasRaw = stdin.isRaw
+      if (stdin.isTTY && stdin.setRawMode) stdin.setRawMode(true)
+
+      let buf = ""
+      const onData = (ch: Buffer) => {
+        const c = ch.toString("utf8")
+        if (c === "\u0003") {
+          // Ctrl+C
+          if (stdin.isTTY && stdin.setRawMode) stdin.setRawMode(wasRaw ?? false)
+          stdin.removeListener("data", onData)
+          process.exit(130)
+        }
+        if (c === "\x1b") {
+          // Escape
+          if (stdin.isTTY && stdin.setRawMode) stdin.setRawMode(wasRaw ?? false)
+          stdin.removeListener("data", onData)
+          process.stderr.write("\n")
+          resolve(null)
+          return
+        }
+        if (c === "\r" || c === "\n") {
+          // Enter
+          if (stdin.isTTY && stdin.setRawMode) stdin.setRawMode(wasRaw ?? false)
+          stdin.removeListener("data", onData)
+          process.stderr.write("\n")
+          resolve(buf)
+          return
+        }
+        if (c === "\u007f" || c === "\b") {
+          // Backspace
+          if (buf.length > 0) {
+            buf = buf.slice(0, -1)
+            process.stderr.write("\b \b")
+          }
+          return
+        }
+        // Regular character
+        const clean = c.replace(/[\x00-\x1f\x7f]/g, "")
+        if (clean) {
+          buf += clean
+          process.stderr.write(clean)
+        }
+      }
+      stdin.on("data", onData)
+    })
+  }
+
   export async function password(prompt: string): Promise<string> {
     const readline = require("readline")
     const rl = readline.createInterface({ input: process.stdin, output: process.stderr, terminal: true })

package/src/tui/routes/home.tsx

@@ -234,11 +234,25 @@ export function Home(props: {
       const v = aiUrl().trim()
       if (v && !v.startsWith("http")) { showMsg("URL must start with http:// or https://", theme.colors.error); return }
       setAiMode("key")
-      showMsg("Now paste your API key:", theme.colors.primary)
+      showMsg("Now paste your API key (or press Esc to cancel):", theme.colors.primary)
       return
     }
     if (aiMode() === "key") {
-      if (aiKey().trim().length < 5) { showMsg("API key too short", theme.colors.error); return }
+      const url = aiUrl().trim()
+      const key = aiKey().trim()
+      // Both empty → friendly skip
+      if (!url && !key) {
+        showMsg("No AI configuration provided — skipped. Use /ai anytime to configure.", theme.colors.warning)
+        setAiMode("")
+        return
+      }
+      // Key empty but URL provided → friendly skip
+      if (!key) {
+        showMsg("No API key provided — skipped. Use /ai anytime to configure.", theme.colors.warning)
+        setAiMode("")
+        return
+      }
+      if (key.length < 5) { showMsg("API key too short", theme.colors.error); return }
       saveAI()
       return
     }