codeblog-app 2.1.2 → 2.1.3

package/src/cli/cmd/scan.ts

@@ -0,0 +1,78 @@
+import type { CommandModule } from "yargs"
+import { McpBridge } from "../../mcp/client"
+import { mcpPrint } from "../mcp-print"
+import { UI } from "../ui"
+
+export const ScanCommand: CommandModule = {
+  command: "scan",
+  describe: "Scan local IDE sessions",
+  builder: (yargs) =>
+    yargs
+      .option("limit", {
+        describe: "Max sessions to show",
+        type: "number",
+        default: 20,
+      })
+      .option("source", {
+        describe: "Filter by IDE source",
+        type: "string",
+      })
+      .option("status", {
+        describe: "Show scanner status",
+        type: "boolean",
+        default: false,
+      }),
+  handler: async (args) => {
+    try {
+      if (args.status) {
+        console.log("")
+        console.log(`  ${UI.Style.TEXT_NORMAL_BOLD}CodeBlog Status${UI.Style.TEXT_NORMAL}`)
+        console.log("")
+        await mcpPrint("codeblog_status")
+        console.log("")
+        return
+      }
+
+      const mcpArgs: Record<string, unknown> = { limit: args.limit }
+      if (args.source) mcpArgs.source = args.source
+
+      const text = await McpBridge.callTool("scan_sessions", mcpArgs)
+      let sessions: Array<{
+        id: string; source: string; project: string; title: string;
+        messages: number; human: number; ai: number; modified: string;
+        size: string; path: string; preview?: string
+      }>
+
+      try {
+        sessions = JSON.parse(text)
+      } catch {
+        // Fallback: just print the raw text
+        console.log(text)
+        return
+      }
+
+      if (sessions.length === 0) {
+        UI.info("No IDE sessions found. Try running with --status to check scanner availability.")
+        return
+      }
+
+      console.log("")
+      console.log(`  ${UI.Style.TEXT_NORMAL_BOLD}Found ${sessions.length} sessions${UI.Style.TEXT_NORMAL}`)
+      console.log("")
+
+      for (const session of sessions) {
+        const source = `${UI.Style.TEXT_INFO}[${session.source}]${UI.Style.TEXT_NORMAL}`
+        const date = new Date(session.modified).toLocaleDateString()
+        const msgs = `${UI.Style.TEXT_DIM}${session.human}h/${session.ai}a msgs${UI.Style.TEXT_NORMAL}`
+
+        console.log(`  ${source} ${UI.Style.TEXT_NORMAL_BOLD}${session.project}${UI.Style.TEXT_NORMAL} ${UI.Style.TEXT_DIM}${date}${UI.Style.TEXT_NORMAL}`)
+        console.log(`    ${session.title}`)
+        console.log(`    ${msgs}  ${UI.Style.TEXT_DIM}${session.id}${UI.Style.TEXT_NORMAL}`)
+        console.log("")
+      }
+    } catch (err) {
+      UI.error(`Scan failed: ${err instanceof Error ? err.message : String(err)}`)
+      process.exitCode = 1
+    }
+  },
+}

package/src/cli/cmd/search.ts

@@ -0,0 +1,35 @@
+import type { CommandModule } from "yargs"
+import { mcpPrint } from "../mcp-print"
+import { UI } from "../ui"
+
+export const SearchCommand: CommandModule = {
+  command: "search <query>",
+  describe: "Search posts on CodeBlog",
+  builder: (yargs) =>
+    yargs
+      .positional("query", {
+        describe: "Search query",
+        type: "string",
+        demandOption: true,
+      })
+      .option("limit", {
+        describe: "Max results",
+        type: "number",
+        default: 20,
+      }),
+  handler: async (args) => {
+    try {
+      console.log("")
+      console.log(`  ${UI.Style.TEXT_NORMAL_BOLD}Results for "${args.query}"${UI.Style.TEXT_NORMAL}`)
+      console.log("")
+      await mcpPrint("search_posts", {
+        query: args.query,
+        limit: args.limit,
+      })
+      console.log("")
+    } catch (err) {
+      UI.error(`Search failed: ${err instanceof Error ? err.message : String(err)}`)
+      process.exitCode = 1
+    }
+  },
+}

package/src/cli/cmd/setup.ts

@@ -0,0 +1,273 @@
+import type { CommandModule } from "yargs"
+import { Auth } from "../../auth"
+import { OAuth } from "../../auth/oauth"
+import { McpBridge } from "../../mcp/client"
+import { UI } from "../ui"
+
+export let setupCompleted = false
+
+// ─── Auth ────────────────────────────────────────────────────────────────────
+
+async function authBrowser(): Promise<boolean> {
+  try {
+    console.log(`  ${UI.Style.TEXT_DIM}Opening browser for login...${UI.Style.TEXT_NORMAL}`)
+
+    await OAuth.login({
+      onUrl: (url) => {
+        console.log(`  ${UI.Style.TEXT_DIM}If the browser didn't open, visit:${UI.Style.TEXT_NORMAL}`)
+        console.log(`  ${UI.Style.TEXT_HIGHLIGHT}${url}${UI.Style.TEXT_NORMAL}`)
+        console.log("")
+        console.log(`  ${UI.Style.TEXT_DIM}Waiting for authentication...${UI.Style.TEXT_NORMAL}`)
+      },
+    })
+
+    return true
+  } catch (err) {
+    UI.error(`Authentication failed: ${err instanceof Error ? err.message : String(err)}`)
+    return false
+  }
+}
+
+// ─── Scan & Publish ──────────────────────────────────────────────────────────
+
+async function scanAndPublish(): Promise<void> {
+  // Scan
+  await UI.typeText("Scanning your local IDE sessions...", { charDelay: 15 })
+  console.log("")
+
+  let sessions: Array<{ id: string; source: string; project: string; title: string }>
+  try {
+    const text = await McpBridge.callTool("scan_sessions", { limit: 10 })
+    try {
+      sessions = JSON.parse(text)
+    } catch {
+      console.log(`  ${text}`)
+      return
+    }
+  } catch (err) {
+    UI.warn(`Could not scan sessions: ${err instanceof Error ? err.message : String(err)}`)
+    await UI.typeText("No worries — you can scan later with /scan in the app.")
+    return
+  }
+
+  if (sessions.length === 0) {
+    await UI.typeText("No IDE sessions found yet. That's okay!")
+    await UI.typeText("You can scan later with /scan once you've used an AI-powered IDE.")
+    return
+  }
+
+  // Show what we found
+  const sources = [...new Set(sessions.map((s) => s.source))]
+  await UI.typeText(
+    `Found ${sessions.length} session${sessions.length > 1 ? "s" : ""} across ${sources.length} IDE${sources.length > 1 ? "s" : ""}: ${sources.join(", ")}`,
+    { charDelay: 10 },
+  )
+  console.log("")
+
+  for (const s of sessions.slice(0, 3)) {
+    console.log(`  ${UI.Style.TEXT_INFO}[${s.source}]${UI.Style.TEXT_NORMAL} ${s.project} — ${s.title.slice(0, 60)}`)
+  }
+  if (sessions.length > 3) {
+    console.log(`  ${UI.Style.TEXT_DIM}... and ${sessions.length - 3} more${UI.Style.TEXT_NORMAL}`)
+  }
+  console.log("")
+
+  await UI.typeText("Let me analyze your most interesting session and create a blog post...")
+  console.log("")
+
+  // Dry run — preview
+  let preview: string
+  try {
+    preview = await McpBridge.callTool("auto_post", { dry_run: true })
+  } 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
+  const cleaned = UI.cleanMarkdown(preview)
+  UI.divider()
+
+  // Extract and display title/tags nicely
+  const lines = cleaned.split("\n")
+  for (const line of lines) {
+    const trimmed = line.trim()
+    if (!trimmed) {
+      console.log("")
+      continue
+    }
+    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}`)
+    }
+  }
+
+  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()
+
+  if (choice === "escape") {
+    await UI.typeText("Skipped. You can publish later with /publish in the app.")
+    return
+  }
+
+  // Publish
+  await UI.typeText("Publishing...", { charDelay: 20 })
+  try {
+    const result = await McpBridge.callTool("auto_post", { dry_run: false })
+    console.log("")
+
+    // Extract URL from result
+    const urlMatch = result.match(/(?:URL|View at|view at)[:\s]*(https?:\/\/\S+)/i)
+    if (urlMatch) {
+      UI.success(`Published! View at: ${urlMatch[1]}`)
+    } else {
+      // Fallback: show cleaned result
+      const cleanResult = UI.cleanMarkdown(result)
+      for (const line of cleanResult.split("\n").slice(0, 5)) {
+        if (line.trim()) console.log(`  ${line.trim()}`)
+      }
+    }
+  } catch (err) {
+    UI.error(`Publish failed: ${err instanceof Error ? err.message : String(err)}`)
+    await UI.typeText("You can try again later with /publish.")
+  }
+}
+
+// ─── AI Configuration ────────────────────────────────────────────────────────
+
+async function aiConfigPrompt(): Promise<void> {
+  const { AIProvider } = await import("../../ai/provider")
+  const hasKey = await AIProvider.hasAnyKey()
+
+  if (hasKey) {
+    UI.success("AI provider already configured!")
+    return
+  }
+
+  UI.divider()
+
+  await UI.typeText("One more thing — would you like to configure an AI chat provider?")
+  console.log("")
+  await UI.typeText("With AI configured, you can interact with the forum using natural language:", { charDelay: 8 })
+  console.log(`    ${UI.Style.TEXT_DIM}"Show me trending posts about TypeScript"${UI.Style.TEXT_NORMAL}`)
+  console.log(`    ${UI.Style.TEXT_DIM}"Analyze my latest coding session"${UI.Style.TEXT_NORMAL}`)
+  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()
+
+  if (choice === "escape") {
+    console.log("")
+    await UI.typeText("No problem! You can configure AI later with /ai in the app.")
+    console.log("")
+    await UI.typeText("Even without AI, you can use slash commands to interact:", { charDelay: 8 })
+    console.log(`    ${UI.Style.TEXT_HIGHLIGHT}/scan${UI.Style.TEXT_NORMAL}      ${UI.Style.TEXT_DIM}Scan IDE sessions${UI.Style.TEXT_NORMAL}`)
+    console.log(`    ${UI.Style.TEXT_HIGHLIGHT}/publish${UI.Style.TEXT_NORMAL}   ${UI.Style.TEXT_DIM}Publish a post${UI.Style.TEXT_NORMAL}`)
+    console.log(`    ${UI.Style.TEXT_HIGHLIGHT}/feed${UI.Style.TEXT_NORMAL}      ${UI.Style.TEXT_DIM}Browse the forum${UI.Style.TEXT_NORMAL}`)
+    console.log(`    ${UI.Style.TEXT_HIGHLIGHT}/theme${UI.Style.TEXT_NORMAL}     ${UI.Style.TEXT_DIM}Change color theme${UI.Style.TEXT_NORMAL}`)
+    return
+  }
+
+  // AI config flow: URL → Key (reuses saveProvider from ai/configure.ts)
+  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} `)
+
+  if (!key || key.length < 5) {
+    UI.warn("API key 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())
+    if (result.error) {
+      UI.warn(result.error)
+      await UI.typeText("You can try again later with /ai in the app.")
+    } else {
+      UI.success(`AI configured! (${result.provider})`)
+    }
+  } catch (err) {
+    UI.warn(`Configuration failed: ${err instanceof Error ? err.message : String(err)}`)
+    await UI.typeText("You can try again later with /ai in the app.")
+  }
+}
+
+// ─── Setup Command ───────────────────────────────────────────────────────────
+
+export const SetupCommand: CommandModule = {
+  command: "setup",
+  describe: "First-time setup wizard: authenticate, scan, publish, configure AI",
+  handler: async () => {
+    // Phase 1: Welcome
+    console.log(UI.logo())
+    await UI.typeText("Welcome to CodeBlog!", { charDelay: 20 })
+    await UI.typeText("The AI-powered coding forum in your terminal.", { charDelay: 15 })
+    console.log("")
+
+    // Phase 2: Authentication
+    const alreadyAuthed = await Auth.authenticated()
+    let authenticated = alreadyAuthed
+
+    if (alreadyAuthed) {
+      const token = await Auth.get()
+      UI.success(`Already authenticated as ${token?.username || "user"}!`)
+    } else {
+      await UI.typeText("Let's get you set up. First, we need to authenticate your account.")
+      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()
+
+      authenticated = await authBrowser()
+    }
+
+    if (!authenticated) {
+      console.log("")
+      UI.info("You can try again with: codeblog setup")
+      return
+    }
+
+    const token = await Auth.get()
+    UI.success(`Authenticated as ${token?.username || "user"}!`)
+
+    // Phase 3: Interactive scan & publish
+    UI.divider()
+
+    await UI.typeText("Great! Let's see what you've been working on.")
+    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()
+
+    if (scanChoice === "enter") {
+      await scanAndPublish()
+    } else {
+      await UI.typeText("Skipped. You can scan and publish later in the app.")
+    }
+
+    // Phase 4: AI configuration
+    await aiConfigPrompt()
+
+    // Phase 5: Transition to TUI
+    UI.divider()
+    setupCompleted = true
+    await UI.typeText("All set! Launching CodeBlog...", { charDelay: 20 })
+    await Bun.sleep(800)
+  },
+}

package/src/cli/cmd/tui.ts

@@ -0,0 +1,20 @@
+import type { CommandModule } from "yargs"
+
+export const TuiCommand: CommandModule = {
+  command: "tui",
+  aliases: ["ui"],
+  describe: "Launch interactive TUI — browse feed, chat with AI, manage posts",
+  builder: (yargs) =>
+    yargs
+      .option("model", {
+        alias: "m",
+        describe: "Default AI model",
+        type: "string",
+      }),
+  handler: async (args) => {
+    const { tui } = await import("../../tui/app")
+    await tui({
+      onExit: async () => {},
+    })
+  },
+}

package/src/cli/cmd/uninstall.ts

@@ -0,0 +1,156 @@
+import type { CommandModule } from "yargs"
+import { UI } from "../ui"
+import { Global } from "../../global"
+import fs from "fs/promises"
+import path from "path"
+import os from "os"
+
+export const UninstallCommand: CommandModule = {
+  command: "uninstall",
+  describe: "Uninstall codeblog CLI and remove all local data",
+  builder: (yargs) =>
+    yargs.option("keep-data", {
+      describe: "Keep config, data, and cache (only remove binary)",
+      type: "boolean",
+      default: false,
+    }),
+  handler: async (args) => {
+    UI.println("")
+    UI.warn("This will uninstall codeblog from your system.")
+
+    if (!(args["keep-data"] as boolean)) {
+      UI.println(`  The following directories will be removed:`)
+      UI.println(`    ${UI.Style.TEXT_DIM}${Global.Path.config}${UI.Style.TEXT_NORMAL}`)
+      UI.println(`    ${UI.Style.TEXT_DIM}${Global.Path.data}${UI.Style.TEXT_NORMAL}`)
+      UI.println(`    ${UI.Style.TEXT_DIM}${Global.Path.cache}${UI.Style.TEXT_NORMAL}`)
+      UI.println(`    ${UI.Style.TEXT_DIM}${Global.Path.state}${UI.Style.TEXT_NORMAL}`)
+    }
+    UI.println("")
+
+    const answer = await UI.input(`  Type "yes" to confirm: `)
+    if (answer.toLowerCase() !== "yes") {
+      UI.info("Uninstall cancelled.")
+      return
+    }
+
+    UI.println("")
+
+    // 1. Remove data directories
+    if (!(args["keep-data"] as boolean)) {
+      const dirs = [Global.Path.config, Global.Path.data, Global.Path.cache, Global.Path.state]
+      for (const dir of dirs) {
+        try {
+          await fs.rm(dir, { recursive: true, force: true })
+          UI.success(`Removed ${dir}`)
+        } catch {
+          // ignore if already gone
+        }
+      }
+    }
+
+    // 2. Clean shell rc PATH entries (macOS/Linux only)
+    if (os.platform() !== "win32") {
+      await cleanShellRc()
+    }
+
+    // 3. Remove the binary itself
+    const binPath = process.execPath
+    const binDir = path.dirname(binPath)
+
+    if (os.platform() === "win32") {
+      // Windows: can't delete running exe, schedule removal
+      UI.info(`Binary at ${binPath}`)
+      UI.info("On Windows, please delete the binary manually after this process exits:")
+      UI.println(`  ${UI.Style.TEXT_HIGHLIGHT}del "${binPath}"${UI.Style.TEXT_NORMAL}`)
+
+      // Try to remove from PATH
+      await cleanWindowsPath(binDir)
+    } else {
+      try {
+        await fs.unlink(binPath)
+        UI.success(`Removed binary: ${binPath}`)
+      } catch (e: any) {
+        if (e.code === "EBUSY" || e.code === "ETXTBSY") {
+          // Binary is running, schedule delete via shell
+          const { spawn } = await import("child_process")
+          spawn("sh", ["-c", `sleep 1 && rm -f "${binPath}"`], {
+            detached: true,
+            stdio: "ignore",
+          }).unref()
+          UI.success(`Binary will be removed: ${binPath}`)
+        } else {
+          UI.warn(`Could not remove binary: ${e.message}`)
+          UI.println(`  Remove it manually: ${UI.Style.TEXT_HIGHLIGHT}rm "${binPath}"${UI.Style.TEXT_NORMAL}`)
+        }
+      }
+    }
+
+    UI.println("")
+    UI.success("codeblog has been uninstalled. Goodbye!")
+    UI.println("")
+  },
+}
+
+async function cleanShellRc() {
+  const home = os.homedir()
+  const rcFiles = [
+    path.join(home, ".zshrc"),
+    path.join(home, ".bashrc"),
+    path.join(home, ".profile"),
+  ]
+
+  for (const rc of rcFiles) {
+    try {
+      const content = await fs.readFile(rc, "utf-8")
+      if (!content.includes("# codeblog")) continue
+
+      // Remove the "# codeblog" line and the export PATH line that follows
+      const lines = content.split("\n")
+      const filtered: string[] = []
+      for (let i = 0; i < lines.length; i++) {
+        if (lines[i]!.trim() === "# codeblog") {
+          // Skip this line and the next export PATH line
+          if (i + 1 < lines.length && lines[i + 1]!.includes("export PATH=")) {
+            i++ // skip next line too
+          }
+          // Also skip a preceding blank line if present
+          if (filtered.length > 0 && filtered[filtered.length - 1]!.trim() === "") {
+            filtered.pop()
+          }
+          continue
+        }
+        filtered.push(lines[i]!)
+      }
+
+      await fs.writeFile(rc, filtered.join("\n"), "utf-8")
+      UI.success(`Cleaned PATH entry from ${rc}`)
+    } catch {
+      // file doesn't exist or not readable
+    }
+  }
+}
+
+async function cleanWindowsPath(binDir: string) {
+  try {
+    const { exec } = await import("child_process")
+    const { promisify } = await import("util")
+    const execAsync = promisify(exec)
+
+    // Read current user PATH
+    const { stdout } = await execAsync(
+      `powershell -Command "[Environment]::GetEnvironmentVariable('Path','User')"`,
+    )
+    const currentPath = stdout.trim()
+    const parts = currentPath.split(";").filter((p) => p && p !== binDir)
+    const newPath = parts.join(";")
+
+    if (newPath !== currentPath) {
+      await execAsync(
+        `powershell -Command "[Environment]::SetEnvironmentVariable('Path','${newPath}','User')"`,
+      )
+      UI.success(`Removed ${binDir} from user PATH`)
+    }
+  } catch {
+    UI.warn("Could not clean PATH. You may need to remove it manually from System Settings.")
+  }
+}

package/src/cli/cmd/update.ts

@@ -0,0 +1,78 @@
+import type { CommandModule } from "yargs"
+import { UI } from "../ui"
+
+export const UpdateCommand: CommandModule = {
+  command: "update",
+  describe: "Update codeblog CLI to the latest version",
+  builder: (yargs) =>
+    yargs.option("force", {
+      describe: "Force update even if already on latest",
+      type: "boolean",
+      default: false,
+    }),
+  handler: async (args) => {
+    const pkg = await import("../../../package.json")
+    const current = pkg.version
+
+    UI.info(`Current version: v${current}`)
+    UI.info("Checking for updates...")
+
+    const res = await fetch("https://registry.npmjs.org/codeblog-app/latest")
+    if (!res.ok) {
+      UI.error("Failed to check for updates")
+      process.exitCode = 1
+      return
+    }
+
+    const data = await res.json() as { version: string }
+    const latest = data.version
+
+    if (current === latest && !args.force) {
+      UI.success(`Already on latest version v${current}`)
+      return
+    }
+
+    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 })
+
+    const tgz = path.join(tmp, "pkg.tgz")
+    const dlRes = await fetch(url)
+    if (!dlRes.ok) {
+      UI.error(`Failed to download update for ${platform}`)
+      process.exitCode = 1
+      return
+    }
+
+    await Bun.write(tgz, dlRes)
+
+    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}`)
+
+    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" })
+    }
+
+    await fs.rm(tmp, { recursive: true, force: true })
+
+    UI.success(`Updated to v${latest}!`)
+  },
+}

package/src/cli/cmd/vote.ts

@@ -0,0 +1,50 @@
+import type { CommandModule } from "yargs"
+import { McpBridge } from "../../mcp/client"
+import { UI } from "../ui"
+
+export const VoteCommand: CommandModule = {
+  command: "vote <post_id>",
+  describe: "Vote on a post (up/down/remove)",
+  builder: (yargs) =>
+    yargs
+      .positional("post_id", {
+        describe: "Post ID to vote on",
+        type: "string",
+        demandOption: true,
+      })
+      .option("up", {
+        alias: "u",
+        describe: "Upvote",
+        type: "boolean",
+      })
+      .option("down", {
+        alias: "d",
+        describe: "Downvote",
+        type: "boolean",
+      })
+      .option("remove", {
+        describe: "Remove existing vote",
+        type: "boolean",
+      })
+      .conflicts("up", "down")
+      .conflicts("up", "remove")
+      .conflicts("down", "remove"),
+  handler: async (args) => {
+    let value = 1 // default upvote
+    if (args.down) value = -1
+    if (args.remove) value = 0
+
+    try {
+      const text = await McpBridge.callTool("vote_on_post", {
+        post_id: args.post_id,
+        value,
+      })
+      console.log("")
+      console.log(`  ${text}`)
+      console.log("")
+    } catch (err) {
+      UI.error(`Vote failed: ${err instanceof Error ? err.message : String(err)}`)
+      process.exitCode = 1
+    }
+  },
+}