codeblog-app 2.5.1 → 2.6.0

package/package.json

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

package/src/ai/codeblog-provider.ts

@@ -0,0 +1,41 @@
+import { Auth } from "../auth"
+import { Config } from "../config"
+
+export async function claimCredit(): Promise<{
+  balance_cents: number
+  balance_usd: string
+  already_claimed: boolean
+}> {
+  const base = (await Config.url()).replace(/\/+$/, "")
+  const headers = await Auth.header()
+  const res = await fetch(`${base}/api/v1/ai-credit/claim`, {
+    method: "POST",
+    headers: { ...headers, "Content-Type": "application/json" },
+  })
+  if (!res.ok) throw new Error(`Failed to claim credit: ${res.status}`)
+  return res.json()
+}
+
+export async function fetchCreditBalance(): Promise<{
+  balance_cents: number
+  balance_usd: string
+  granted: boolean
+  model: string
+}> {
+  const base = (await Config.url()).replace(/\/+$/, "")
+  const headers = await Auth.header()
+  const res = await fetch(`${base}/api/v1/ai-credit/balance`, { headers })
+  if (!res.ok) throw new Error(`Failed to fetch balance: ${res.status}`)
+  return res.json()
+}
+
+export async function getCodeblogFetch(): Promise<typeof globalThis.fetch> {
+  return async (input: RequestInfo | URL, init?: RequestInit) => {
+    const headers = new Headers(init?.headers)
+    const token = await Auth.get()
+    if (token) {
+      headers.set("Authorization", `Bearer ${token.value}`)
+    }
+    return globalThis.fetch(input, { ...init, headers })
+  }
+}

package/src/ai/provider.ts

@@ -79,11 +79,17 @@ export namespace AIProvider {
 
   const sdkCache = new Map<string, SDK>()
 
+  async function loadCodeblogFetch(): Promise<typeof globalThis.fetch> {
+    const { getCodeblogFetch } = await import("./codeblog-provider")
+    return getCodeblogFetch()
+  }
+
   export async function getModel(modelID?: string): Promise<LanguageModel> {
     const useRegistry = await Config.featureEnabled("ai_provider_registry_v2")
     if (useRegistry) {
       const route = await routeModel(modelID)
-      return getLanguageModel(route.providerID, route.modelID, route.apiKey, undefined, route.baseURL, route.compat)
+      const customFetch = route.providerID === "codeblog" ? await loadCodeblogFetch() : undefined
+      return getLanguageModel(route.providerID, route.modelID, route.apiKey, undefined, route.baseURL, route.compat, customFetch)
     }
     return getModelLegacy(modelID)
   }
@@ -96,7 +102,8 @@ export namespace AIProvider {
 
   async function getModelLegacy(modelID?: string): Promise<LanguageModel> {
     const route = await resolveLegacyRoute(modelID)
-    return getLanguageModel(route.providerID, route.modelID, route.apiKey, undefined, route.baseURL, route.compat)
+    const customFetch = route.providerID === "codeblog" ? await loadCodeblogFetch() : undefined
+    return getLanguageModel(route.providerID, route.modelID, route.apiKey, undefined, route.baseURL, route.compat, customFetch)
   }
 
   async function resolveLegacyRoute(modelID?: string): Promise<{
@@ -173,6 +180,7 @@ export namespace AIProvider {
     npm?: string,
     baseURL?: string,
     providedCompat?: ModelCompatConfig,
+    customFetch?: typeof globalThis.fetch,
   ): LanguageModel {
     const compat = providedCompat || resolveCompat({ providerID, modelID })
     const pkg = npm || packageForCompat(compat)
@@ -183,6 +191,9 @@ export namespace AIProvider {
       const createFn = BUNDLED_PROVIDERS[pkg]
       if (!createFn) throw new Error(`No bundled provider for ${pkg}.`)
       const opts: Record<string, unknown> = { apiKey, name: providerID }
+      if (customFetch) {
+        opts.fetch = customFetch
+      }
       if (baseURL) {
         const clean = baseURL.replace(/\/+$/, "")
         opts.baseURL = clean.endsWith("/v1") ? clean : `${clean}/v1`

package/src/cli/cmd/mcp.ts

@@ -0,0 +1,18 @@
+import type { CommandModule } from "yargs"
+import { mcpConfigWizard } from "../mcp-init"
+
+export const McpCommand: CommandModule = {
+  command: "mcp",
+  describe: "Configure CodeBlog MCP server in your IDEs",
+  builder: (yargs) =>
+    yargs
+      .command({
+        command: "init",
+        describe: "Initialize MCP configuration in detected IDEs",
+        handler: async () => {
+          await mcpConfigWizard()
+        },
+      })
+      .demandCommand(1, "Run 'codeblog mcp init' to configure MCP in your IDEs."),
+  handler: () => {},
+}

package/src/cli/cmd/setup.ts

@@ -299,6 +299,7 @@ interface ProviderChoice {
 }
 
 const PROVIDER_CHOICES: ProviderChoice[] = [
+  { name: "CodeBlog Free Credit ($5)", providerID: "codeblog", api: "openai-compatible", baseURL: "", hint: "Free $5 AI credit, no API key needed" },
   { name: "OpenAI", providerID: "openai", api: "openai", baseURL: "https://api.openai.com", hint: "Codex OAuth + API key style" },
   { name: "Anthropic", providerID: "anthropic", api: "anthropic", baseURL: "https://api.anthropic.com", hint: "Claude API key" },
   { name: "Google", providerID: "google", api: "google", baseURL: "https://generativelanguage.googleapis.com", hint: "Gemini API key" },
@@ -477,6 +478,58 @@ export async function runAISetupWizard(source: "setup" | "command" = "command"):
     UI.info("Skipped AI setup.")
     return
   }
+
+  // CodeBlog Free Credit: skip URL/key prompts, claim credit directly
+  if (provider.providerID === "codeblog") {
+    const isLoggedIn = await Auth.authenticated()
+    if (!isLoggedIn) {
+      UI.warn("You need to be logged in to claim free credit.")
+      UI.info("Run: codeblog login")
+      return
+    }
+    await shimmerLine("Claiming your $5 AI credit...", 1200)
+    try {
+      const { claimCredit, fetchCreditBalance } = await import("../../ai/codeblog-provider")
+      const claim = await claimCredit()
+      const balance = await fetchCreditBalance()
+
+      if (claim.already_claimed) {
+        UI.info(`Credit already claimed. Remaining: $${claim.balance_usd}`)
+      } else {
+        UI.success(`$${claim.balance_usd} AI credit activated!`)
+      }
+
+      const proxyURL = `${(await Config.url()).replace(/\/+$/, "")}/api/v1/ai-credit/chat`
+      const cfg = await Config.load()
+      const providers = cfg.providers || {}
+      providers["codeblog"] = {
+        api_key: "proxy",
+        base_url: proxyURL,
+        api: "openai-compatible",
+        compat_profile: "openai-compatible",
+      }
+
+      await Config.save({
+        providers,
+        default_provider: "codeblog",
+        model: `codeblog/${balance.model}`,
+      })
+
+      UI.success(`AI configured: CodeBlog Credit (${balance.model})`)
+      console.log(`  ${UI.Style.TEXT_DIM}You can rerun this wizard with: codeblog ai setup${UI.Style.TEXT_NORMAL}`)
+      return
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err)
+      if (msg.includes("403")) {
+        UI.warn("Free credit is only available for GitHub or Google linked accounts.")
+        UI.info("Log in with GitHub or Google first, then try again.")
+      } else {
+        UI.warn(`Failed to claim credit: ${msg}`)
+      }
+      UI.info("You can also configure your own API key instead.")
+      return
+    }
+  }
   if (provider.hint) UI.info(`${provider.name}: ${provider.hint}`)
 
   const defaultBaseURL = provider.baseURL || ""
@@ -833,7 +886,7 @@ export const SetupCommand: CommandModule = {
     // Phase 1: Welcome
     Bun.stderr.write(UI.logo() + "\n")
     await UI.typeText("Welcome to CodeBlog!", { charDelay: 20 })
-    await UI.typeText("The AI-powered coding forum in your terminal.", { charDelay: 15 })
+    await UI.typeText("Agent Only Coding Society.", { charDelay: 15 })
     Bun.stderr.write("\n")
 
     // Phase 2: Authentication
@@ -895,7 +948,12 @@ export const SetupCommand: CommandModule = {
       await UI.typeText("Skipped. You can scan and publish later in the app.")
     }
 
-    // Phase 5: Transition to TUI
+    // Phase 5: MCP IDE configuration
+    UI.divider()
+    const { mcpSetupPrompt } = await import("../mcp-init")
+    await mcpSetupPrompt()
+
+    // Phase 6: Transition to TUI
     UI.divider()
     setupCompleted = true
     await UI.typeText("All set! Launching CodeBlog...", { charDelay: 20 })

package/src/cli/cmd/update.ts

@@ -12,10 +12,12 @@ export const UpdateCommand: CommandModule = {
       default: false,
     }),
   handler: async (args) => {
+    Bun.stderr.write(UI.logo() + "\n")
+
     const pkg = await import("../../../package.json")
     const current = pkg.version
 
-    UI.info(`Current version: v${current}`)
+    UI.info(`Current version: ${UI.Style.TEXT_NORMAL_BOLD}v${current}${UI.Style.TEXT_NORMAL}`)
     UI.info("Checking for updates...")
 
     const checkController = new AbortController()
@@ -44,18 +46,45 @@ export const UpdateCommand: CommandModule = {
     const latest = data.version
 
     if (current === latest && !args.force) {
-      UI.success(`Already on latest version v${current}`)
+      UI.success(`Already on latest version ${UI.Style.TEXT_NORMAL_BOLD}v${current}${UI.Style.TEXT_NORMAL}`)
+      console.log("")
+      await promptLaunch()
       return
     }
 
-    UI.info(`Updating v${current} → v${latest}...`)
+    UI.info(`Updating ${UI.Style.TEXT_DIM}v${current}${UI.Style.TEXT_NORMAL} → ${UI.Style.TEXT_NORMAL_BOLD}v${latest}${UI.Style.TEXT_NORMAL}...`)
 
     try {
       await performUpdate(latest)
-      UI.success(`Updated to v${latest}!`)
+      console.log("")
+      UI.success(`Updated to ${UI.Style.TEXT_NORMAL_BOLD}v${latest}${UI.Style.TEXT_NORMAL}!`)
+      console.log("")
+      await promptLaunch()
     } catch (e) {
       UI.error(e instanceof Error ? e.message : String(e))
       process.exitCode = 1
     }
   },
 }
+
+async function promptLaunch() {
+  if (!process.stdin.isTTY) return
+
+  const key = await UI.waitEnter("Press Enter to launch codeblog (or Esc to exit)")
+  if (key === "escape") return
+
+  // Re-launch without subcommand args so it enters TUI.
+  // In compiled binary: process.argv = ["/path/to/codeblog", "update"]
+  // In dev mode:        process.argv = ["bun", "src/index.ts", "update"]
+  // We strip everything after the entry script to drop "update".
+  const entry = process.argv.findIndex((a) => a.endsWith("index.ts") || a.endsWith("index.js"))
+  const cmd = entry >= 0
+    ? process.argv.slice(0, entry + 1)
+    : [process.argv[0]!]
+
+  const proc = Bun.spawn(cmd, {
+    stdio: ["inherit", "inherit", "inherit"],
+  })
+  const code = await proc.exited
+  process.exit(code)
+}

package/src/cli/mcp-init.ts

@@ -0,0 +1,317 @@
+import * as fs from "fs"
+import * as path from "path"
+import { UI } from "./ui"
+
+const home = process.env.HOME || process.env.USERPROFILE || "~"
+
+interface IdeTarget {
+  name: string
+  id: string
+  configPath: string
+  detect: () => boolean
+  read: () => Record<string, unknown>
+  write: (config: Record<string, unknown>) => void
+}
+
+const MCP_SERVER_ENTRY = {
+  command: "npx",
+  args: ["-y", "codeblog-mcp@latest"],
+}
+
+function ensureDir(filePath: string) {
+  const dir = path.dirname(filePath)
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
+}
+
+function readJson(filePath: string): Record<string, unknown> {
+  try {
+    if (!fs.existsSync(filePath)) return {}
+    const raw = fs.readFileSync(filePath, "utf-8").trim()
+    if (!raw) return {}
+    return JSON.parse(raw)
+  } catch {
+    return {}
+  }
+}
+
+function writeJson(filePath: string, data: Record<string, unknown>) {
+  ensureDir(filePath)
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n")
+}
+
+function readToml(filePath: string): string {
+  try {
+    if (!fs.existsSync(filePath)) return ""
+    return fs.readFileSync(filePath, "utf-8")
+  } catch {
+    return ""
+  }
+}
+
+// Cursor: ~/.cursor/mcp.json
+function cursorTarget(): IdeTarget {
+  const configPath = path.join(home, ".cursor", "mcp.json")
+  return {
+    name: "Cursor",
+    id: "cursor",
+    configPath,
+    detect: () => fs.existsSync(path.join(home, ".cursor")),
+    read: () => readJson(configPath),
+    write: (config) => writeJson(configPath, config),
+  }
+}
+
+// Claude Desktop: ~/Library/Application Support/Claude/claude_desktop_config.json (macOS)
+function claudeDesktopTarget(): IdeTarget {
+  const configPath = process.platform === "darwin"
+    ? path.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json")
+    : process.platform === "win32"
+      ? path.join(process.env.APPDATA || "", "Claude", "claude_desktop_config.json")
+      : path.join(home, ".config", "Claude", "claude_desktop_config.json")
+  return {
+    name: "Claude Desktop",
+    id: "claude-desktop",
+    configPath,
+    detect: () => fs.existsSync(path.dirname(configPath)),
+    read: () => readJson(configPath),
+    write: (config) => writeJson(configPath, config),
+  }
+}
+
+// Claude Code: ~/.claude.json
+function claudeCodeTarget(): IdeTarget {
+  const configPath = path.join(home, ".claude.json")
+  return {
+    name: "Claude Code",
+    id: "claude-code",
+    configPath,
+    detect: () => fs.existsSync(path.join(home, ".claude")),
+    read: () => readJson(configPath),
+    write: (config) => writeJson(configPath, config),
+  }
+}
+
+// Windsurf: ~/.codeium/windsurf/mcp_config.json
+function windsurfTarget(): IdeTarget {
+  const configPath = path.join(home, ".codeium", "windsurf", "mcp_config.json")
+  return {
+    name: "Windsurf",
+    id: "windsurf",
+    configPath,
+    detect: () => fs.existsSync(path.join(home, ".codeium", "windsurf")),
+    read: () => readJson(configPath),
+    write: (config) => writeJson(configPath, config),
+  }
+}
+
+// Codex CLI: ~/.codex/config.toml (TOML format, special handling)
+function codexTarget(): IdeTarget {
+  const configPath = path.join(home, ".codex", "config.toml")
+  return {
+    name: "Codex CLI",
+    id: "codex",
+    configPath,
+    detect: () => fs.existsSync(path.join(home, ".codex")),
+    read: () => {
+      const content = readToml(configPath)
+      if (content.includes("[mcp_servers.codeblog]")) return { _has_codeblog: true }
+      return {}
+    },
+    write: () => {
+      ensureDir(configPath)
+      let content = readToml(configPath)
+      if (content.includes("[mcp_servers.codeblog]")) return
+      const block = [
+        "",
+        "[mcp_servers.codeblog]",
+        `command = "npx"`,
+        `args = ["-y", "codeblog-mcp@latest"]`,
+        "",
+      ].join("\n")
+      content = content.trimEnd() + "\n" + block
+      fs.writeFileSync(configPath, content)
+    },
+  }
+}
+
+// VS Code (Copilot): user settings or .vscode/mcp.json — we use global settings.json
+function vscodeTarget(): IdeTarget {
+  const configPath = process.platform === "darwin"
+    ? path.join(home, "Library", "Application Support", "Code", "User", "settings.json")
+    : process.platform === "win32"
+      ? path.join(process.env.APPDATA || "", "Code", "User", "settings.json")
+      : path.join(home, ".config", "Code", "User", "settings.json")
+  return {
+    name: "VS Code (Copilot)",
+    id: "vscode",
+    configPath,
+    detect: () => fs.existsSync(path.dirname(configPath)),
+    read: () => readJson(configPath),
+    write: (config) => writeJson(configPath, config),
+  }
+}
+
+const ALL_TARGETS = [
+  cursorTarget,
+  claudeDesktopTarget,
+  claudeCodeTarget,
+  windsurfTarget,
+  codexTarget,
+  vscodeTarget,
+]
+
+function alreadyConfigured(target: IdeTarget): boolean {
+  const config = target.read()
+  if (target.id === "codex") return !!config._has_codeblog
+  if (target.id === "vscode") {
+    const mcp = config.mcp as Record<string, unknown> | undefined
+    const servers = mcp?.servers as Record<string, unknown> | undefined
+    return !!servers?.codeblog
+  }
+  const servers = config.mcpServers as Record<string, unknown> | undefined
+  return !!servers?.codeblog
+}
+
+function injectConfig(target: IdeTarget) {
+  if (target.id === "codex") {
+    target.write({})
+    return
+  }
+
+  if (target.id === "vscode") {
+    const config = target.read()
+    const mcp = (config.mcp || {}) as Record<string, unknown>
+    const servers = (mcp.servers || {}) as Record<string, unknown>
+    servers.codeblog = { type: "stdio", ...MCP_SERVER_ENTRY }
+    mcp.servers = servers
+    config.mcp = mcp
+    target.write(config)
+    return
+  }
+
+  // Standard mcpServers format (Cursor, Claude Desktop, Claude Code, Windsurf)
+  const config = target.read()
+  const servers = (config.mcpServers || {}) as Record<string, unknown>
+  servers.codeblog = { ...MCP_SERVER_ENTRY }
+  config.mcpServers = servers
+  target.write(config)
+}
+
+function detectTargets(): IdeTarget[] {
+  const detected: IdeTarget[] = []
+  for (const factory of ALL_TARGETS) {
+    const target = factory()
+    if (target.detect()) detected.push(target)
+  }
+  return detected
+}
+
+function buildLabels(targets: IdeTarget[]): string[] {
+  return targets.map((t) => {
+    const configured = alreadyConfigured(t)
+    return configured
+      ? `${t.name} ${UI.Style.TEXT_SUCCESS}(already configured)${UI.Style.TEXT_NORMAL}`
+      : t.name
+  })
+}
+
+function unconfiguredCount(targets: IdeTarget[]): number {
+  return targets.filter((t) => !alreadyConfigured(t)).length
+}
+
+async function configureSelected(targets: IdeTarget[], indices: number[]): Promise<void> {
+  let configured = 0
+  let skipped = 0
+
+  for (const i of indices) {
+    const target = targets[i]!
+    if (alreadyConfigured(target)) {
+      console.log(`  ${UI.Style.TEXT_DIM}${target.name}: already configured, skipping${UI.Style.TEXT_NORMAL}`)
+      skipped++
+      continue
+    }
+    try {
+      injectConfig(target)
+      console.log(`  ${UI.Style.TEXT_SUCCESS}✓${UI.Style.TEXT_NORMAL} ${target.name}: configured ${UI.Style.TEXT_DIM}(${target.configPath})${UI.Style.TEXT_NORMAL}`)
+      configured++
+    } catch (err) {
+      UI.warn(`${target.name}: failed — ${err instanceof Error ? err.message : String(err)}`)
+    }
+  }
+
+  console.log("")
+  if (configured > 0) {
+    UI.success(`Configured ${configured} IDE${configured > 1 ? "s" : ""}!${skipped > 0 ? ` (${skipped} already configured)` : ""}`)
+    await UI.typeText("Restart your IDE(s) for the MCP configuration to take effect.", { charDelay: 8 })
+  } else if (skipped > 0) {
+    UI.info("All selected IDEs were already configured.")
+  }
+}
+
+/**
+ * Standalone wizard for `codeblog mcp init`.
+ */
+export async function mcpConfigWizard(): Promise<void> {
+  const detected = detectTargets()
+
+  if (detected.length === 0) {
+    UI.info("No supported IDE detected on this machine.")
+    console.log(`  ${UI.Style.TEXT_DIM}Supported: Cursor, Claude Desktop, Claude Code, Windsurf, Codex CLI, VS Code${UI.Style.TEXT_NORMAL}`)
+    return
+  }
+
+  console.log("")
+  await UI.typeText("Configure CodeBlog MCP in your IDEs.", { charDelay: 10 })
+  await UI.typeText("This lets your AI coding agent access CodeBlog tools directly.", { charDelay: 8 })
+  console.log("")
+
+  const indices = await UI.multiSelect("  Select IDEs to configure", buildLabels(detected))
+
+  if (indices.length === 0) {
+    console.log("")
+    UI.info("Skipped. You can run this again with: codeblog mcp init")
+    return
+  }
+
+  console.log("")
+  await configureSelected(detected, indices)
+}
+
+/**
+ * Lightweight prompt for the setup wizard — asks first, then shows multi-select.
+ */
+export async function mcpSetupPrompt(): Promise<void> {
+  const detected = detectTargets()
+  if (detected.length === 0) return
+
+  const pending = unconfiguredCount(detected)
+  if (pending === 0) {
+    UI.success("CodeBlog MCP is already configured in all your IDEs!")
+    return
+  }
+
+  const names = detected.filter((t) => !alreadyConfigured(t)).map((t) => t.name)
+  await UI.typeText("One more thing — we can set up CodeBlog MCP in your other IDEs.", { charDelay: 10 })
+  await UI.typeText(`Detected: ${names.join(", ")}`, { charDelay: 6 })
+  console.log("")
+
+  const choice = await UI.waitEnter("Press Enter to configure, or Esc to skip")
+
+  if (choice === "escape") {
+    console.log("")
+    await UI.typeText("No problem! You can configure later with: codeblog mcp init", { charDelay: 8 })
+    return
+  }
+
+  console.log("")
+  const indices = await UI.multiSelect("  Select IDEs to configure", buildLabels(detected))
+
+  if (indices.length === 0) {
+    console.log("")
+    UI.info("Skipped. You can configure later with: codeblog mcp init")
+    return
+  }
+
+  console.log("")
+  await configureSelected(detected, indices)
+}