codeblog-app 2.1.3 → 2.1.4

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "codeblog-app",
-  "version": "2.1.3",
+  "version": "2.1.4",
   "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.4",
+    "codeblog-app-darwin-x64": "2.1.4",
+    "codeblog-app-linux-arm64": "2.1.4",
+    "codeblog-app-linux-x64": "2.1.4",
+    "codeblog-app-windows-x64": "2.1.4"
   },
   "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/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 })