codeblog-app 2.2.6 → 2.3.1

package/src/cli/cmd/setup.ts

@@ -3,6 +3,7 @@ import { Auth } from "../../auth"
 import { OAuth } from "../../auth/oauth"
 import { McpBridge } from "../../mcp/client"
 import { UI } from "../ui"
+import { Config } from "../../config"
 
 export let setupCompleted = false
 
@@ -190,7 +191,7 @@ async function scanAndPublish(): Promise<void> {
 
 // ─── AI Configuration ────────────────────────────────────────────────────────
 
-async function aiConfigPrompt(): Promise<void> {
+async function aiQuickConfigPrompt(): Promise<void> {
   const { AIProvider } = await import("../../ai/provider")
   const hasKey = await AIProvider.hasAnyKey()
 
@@ -287,6 +288,271 @@ async function aiConfigPrompt(): Promise<void> {
   }
 }
 
+type WizardMode = "quick" | "manual"
+
+interface ProviderChoice {
+  name: string
+  providerID: string
+  api: "anthropic" | "openai" | "google" | "openai-compatible"
+  baseURL?: string
+  hint?: string
+}
+
+const PROVIDER_CHOICES: ProviderChoice[] = [
+  { 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" },
+  { name: "OpenRouter", providerID: "openai-compatible", api: "openai-compatible", baseURL: "https://openrouter.ai/api", hint: "OpenAI-compatible" },
+  { name: "vLLM", providerID: "openai-compatible", api: "openai-compatible", baseURL: "http://127.0.0.1:8000", hint: "Local/self-hosted OpenAI-compatible" },
+  { name: "MiniMax", providerID: "openai-compatible", api: "openai-compatible", baseURL: "https://api.minimax.io", hint: "OpenAI-compatible endpoint" },
+  { name: "Moonshot AI (Kimi K2.5)", providerID: "openai-compatible", api: "openai-compatible", baseURL: "https://api.moonshot.ai", hint: "OpenAI-compatible endpoint" },
+  { name: "xAI (Grok)", providerID: "openai-compatible", api: "openai-compatible", baseURL: "https://api.x.ai", hint: "OpenAI-compatible endpoint" },
+  { name: "Qianfan", providerID: "openai-compatible", api: "openai-compatible", baseURL: "https://qianfan.baidubce.com", hint: "OpenAI-compatible endpoint" },
+  { name: "Vercel AI Gateway", providerID: "openai-compatible", api: "openai-compatible", baseURL: "https://ai-gateway.vercel.sh", hint: "OpenAI-compatible endpoint" },
+  { name: "OpenCode Zen", providerID: "openai-compatible", api: "openai-compatible", baseURL: "https://opencode.ai/zen", hint: "OpenAI-compatible endpoint" },
+  { name: "Xiaomi", providerID: "anthropic", api: "anthropic", baseURL: "https://api.xiaomimimo.com/anthropic", hint: "Anthropic-compatible endpoint" },
+  { name: "Synthetic", providerID: "anthropic", api: "anthropic", baseURL: "https://api.synthetic.new", hint: "Anthropic-compatible endpoint" },
+  { name: "Together AI", providerID: "openai-compatible", api: "openai-compatible", baseURL: "https://api.together.xyz", hint: "OpenAI-compatible endpoint" },
+  { name: "Hugging Face", providerID: "openai-compatible", api: "openai-compatible", baseURL: "https://router.huggingface.co", hint: "OpenAI-compatible endpoint" },
+  { name: "Venice AI", providerID: "openai-compatible", api: "openai-compatible", baseURL: "https://api.venice.ai/api", hint: "OpenAI-compatible endpoint" },
+  { name: "LiteLLM", providerID: "openai-compatible", api: "openai-compatible", baseURL: "http://localhost:4000", hint: "Unified OpenAI-compatible gateway" },
+  { name: "Cloudflare AI Gateway", providerID: "anthropic", api: "anthropic", hint: "Enter full Anthropic gateway URL manually" },
+  { name: "Custom Provider", providerID: "openai-compatible", api: "openai-compatible", hint: "Any OpenAI-compatible URL" },
+]
+
+async function fetchOpenAIModels(baseURL: string, key: string): Promise<string[]> {
+  try {
+    const clean = baseURL.replace(/\/+$/, "")
+    const url = clean.endsWith("/v1") ? `${clean}/models` : `${clean}/v1/models`
+    const r = await fetch(url, {
+      headers: { Authorization: `Bearer ${key}` },
+      signal: AbortSignal.timeout(8000),
+    })
+    if (!r.ok) return []
+    const data = await r.json() as { data?: Array<{ id: string }> }
+    return data.data?.map((m) => m.id) || []
+  } catch {
+    return []
+  }
+}
+
+function isOfficialOpenAIBase(baseURL: string): boolean {
+  try {
+    const u = new URL(baseURL)
+    return u.hostname === "api.openai.com"
+  } catch {
+    return false
+  }
+}
+
+async function verifyEndpoint(choice: ProviderChoice, baseURL: string, key: string): Promise<{ ok: boolean; detail: string; detectedApi?: Config.ModelApi }> {
+  try {
+    if (choice.api === "anthropic") {
+      const clean = baseURL.replace(/\/+$/, "")
+      const r = await fetch(`${clean}/v1/messages`, {
+        method: "POST",
+        headers: { "x-api-key": key, "anthropic-version": "2023-06-01", "content-type": "application/json" },
+        body: JSON.stringify({ model: "claude-3-5-haiku-latest", max_tokens: 1, messages: [{ role: "user", content: "ping" }] }),
+        signal: AbortSignal.timeout(8000),
+      })
+      if (r.status !== 404) return { ok: true, detail: `Anthropic endpoint reachable (${r.status})`, detectedApi: "anthropic" }
+      return { ok: false, detail: "Anthropic endpoint returned 404" }
+    }
+
+    if (choice.api === "google") {
+      const clean = baseURL.replace(/\/+$/, "")
+      const r = await fetch(`${clean}/v1beta/models?key=${encodeURIComponent(key)}`, {
+        signal: AbortSignal.timeout(8000),
+      })
+      if (r.ok || r.status === 401 || r.status === 403) return { ok: true, detail: `Google endpoint reachable (${r.status})` }
+      return { ok: false, detail: `Google endpoint responded ${r.status}` }
+    }
+
+    const { probe } = await import("../../ai/configure")
+    const detected = await probe(baseURL, key)
+    if (detected === "anthropic") return { ok: true, detail: "Detected Anthropic API format", detectedApi: "anthropic" }
+    if (detected === "openai") {
+      const detectedApi: Config.ModelApi =
+        choice.providerID === "openai" && isOfficialOpenAIBase(baseURL)
+          ? "openai"
+          : "openai-compatible"
+      return { ok: true, detail: "Detected OpenAI API format", detectedApi }
+    }
+
+    const models = await fetchOpenAIModels(baseURL, key)
+    if (models.length > 0) {
+      const detectedApi: Config.ModelApi =
+        choice.providerID === "openai" && isOfficialOpenAIBase(baseURL)
+          ? "openai"
+          : "openai-compatible"
+      return { ok: true, detail: `Model endpoint reachable (${models.length} models)`, detectedApi }
+    }
+
+    return { ok: false, detail: "Could not detect endpoint format or list models" }
+  } catch (err) {
+    return { ok: false, detail: err instanceof Error ? err.message : String(err) }
+  }
+}
+
+async function chooseProvider(): Promise<ProviderChoice | undefined> {
+  console.log("")
+  console.log(`  ${UI.Style.TEXT_NORMAL_BOLD}Model/auth provider${UI.Style.TEXT_NORMAL}`)
+  const idx = await UI.select(
+    "  Choose a provider",
+    [...PROVIDER_CHOICES.map((p) => p.hint ? `${p.name} (${p.hint})` : p.name), "Skip for now"],
+  )
+  if (idx < 0 || idx >= PROVIDER_CHOICES.length) return undefined
+  return PROVIDER_CHOICES[idx]
+}
+
+async function chooseModel(choice: ProviderChoice, mode: WizardMode, baseURL: string, key: string): Promise<string | undefined> {
+  const { AIProvider } = await import("../../ai/provider")
+  const builtin = Object.values(AIProvider.BUILTIN_MODELS).filter((m) => m.providerID === choice.providerID).map((m) => m.id)
+  const openaiCustom = choice.providerID === "openai" && !isOfficialOpenAIBase(baseURL)
+  const useRemote = choice.providerID === "openai-compatible" || openaiCustom
+
+  if (mode === "quick") {
+    if (choice.providerID === "anthropic") return "claude-sonnet-4-20250514"
+    if (choice.providerID === "openai" && !openaiCustom) return "gpt-4o-mini"
+    if (choice.providerID === "google") return "gemini-2.5-flash"
+    const remote = await fetchOpenAIModels(baseURL, key)
+    return remote[0] || "gpt-4o-mini"
+  }
+
+  let options = builtin
+  if (useRemote) {
+    const remote = await fetchOpenAIModels(baseURL, key)
+    options = remote
+  }
+  if (options.length === 0) {
+    const typed = await UI.input(`  Model ID: `)
+    return typed.trim() || "gpt-4o-mini"
+  }
+
+  const idx = await UI.select("  Choose a model", [...options, "Custom model id"])
+  if (idx < 0) return undefined
+  if (idx >= options.length) {
+    const typed = await UI.input(`  Model ID: `)
+    return typed.trim() || options[0]!
+  }
+  return options[idx]!
+}
+
+export async function runAISetupWizard(source: "setup" | "command" = "command"): Promise<void> {
+  const { AIProvider } = await import("../../ai/provider")
+  const hasKey = await AIProvider.hasAnyKey()
+
+  UI.divider()
+  if (source === "setup") {
+    await UI.typeText("AI onboarding")
+  } else {
+    await UI.typeText("CodeBlog AI setup wizard")
+  }
+
+  if (hasKey) {
+    const keep = await UI.waitEnter("AI is already configured. Press Enter to reconfigure, or Esc to keep current config")
+    if (keep === "escape") return
+  }
+
+  console.log("")
+  const modeIdx = await UI.select("  Onboarding mode", ["QuickStart (recommended)", "Manual", "Skip for now"])
+  if (modeIdx < 0 || modeIdx === 2) {
+    UI.info("Skipped AI setup.")
+    return
+  }
+  const mode = modeIdx === 0 ? "quick" : "manual"
+
+  const provider = await chooseProvider()
+  if (!provider) {
+    UI.info("Skipped AI setup.")
+    return
+  }
+  if (provider.hint) UI.info(`${provider.name}: ${provider.hint}`)
+
+  const defaultBaseURL = provider.baseURL || ""
+  const needsBasePrompt =
+    mode === "manual" ||
+    provider.providerID === "openai-compatible" ||
+    provider.providerID === "openai" ||
+    !defaultBaseURL
+  let baseURL = defaultBaseURL
+
+  if (needsBasePrompt) {
+    const endpointHint = defaultBaseURL ? ` [${defaultBaseURL}]` : ""
+    const entered = await UI.inputWithEscape(`  Endpoint base URL${endpointHint}: `)
+    if (entered === null) {
+      UI.info("Skipped AI setup.")
+      return
+    }
+    baseURL = entered.trim() || defaultBaseURL
+  }
+
+  const keyRaw = await UI.inputWithEscape(`  API key / Bearer token: `)
+  if (keyRaw === null) {
+    UI.info("Skipped AI setup.")
+    return
+  }
+  const key = keyRaw.trim()
+  if (!key || key.length < 5) {
+    UI.warn("Credential seems invalid, setup skipped.")
+    return
+  }
+
+  if (!baseURL) {
+    UI.warn("Endpoint URL is required for this provider.")
+    return
+  }
+
+  let verified = false
+  let detectedApi: Config.ModelApi | undefined
+
+  while (!verified) {
+    await shimmerLine("Verifying endpoint...", 900)
+    const verify = await verifyEndpoint(provider, baseURL, key)
+    detectedApi = verify.detectedApi
+    if (verify.ok) {
+      UI.success(verify.detail)
+      verified = true
+      break
+    }
+    UI.warn(`Endpoint verification failed: ${verify.detail}`)
+    const retry = await UI.waitEnter("Press Enter to retry verification, or Esc to continue anyway")
+    if (retry === "escape") break
+  }
+
+  const selectedModel = await chooseModel(provider, mode, baseURL, key)
+  if (!selectedModel) {
+    UI.info("Skipped AI setup.")
+    return
+  }
+  const cfg = await Config.load()
+  const providers = cfg.providers || {}
+  const resolvedApi = detectedApi || provider.api
+  const resolvedCompat = provider.providerID === "openai-compatible" && resolvedApi === "openai"
+    ? "openai-compatible"
+    : resolvedApi
+  const providerConfig: Config.ProviderConfig = {
+    api_key: key,
+    api: resolvedApi,
+    compat_profile: resolvedCompat,
+  }
+  if (baseURL) providerConfig.base_url = baseURL
+  providers[provider.providerID] = providerConfig
+
+  const model = provider.providerID === "openai-compatible" && !selectedModel.includes("/")
+    ? `openai-compatible/${selectedModel}`
+    : selectedModel
+
+  await Config.save({
+    providers,
+    default_provider: provider.providerID,
+    model,
+  })
+
+  UI.success(`AI configured: ${provider.name} (${model})`)
+  console.log(`  ${UI.Style.TEXT_DIM}You can rerun this wizard with: codeblog ai setup${UI.Style.TEXT_NORMAL}`)
+}
+
 // ─── Setup Command ───────────────────────────────────────────────────────────
 
 export const SetupCommand: CommandModule = {
@@ -325,7 +591,14 @@ export const SetupCommand: CommandModule = {
     const token = await Auth.get()
     UI.success(`Authenticated as ${token?.username || "user"}!`)
 
-    // Phase 3: Interactive scan & publish
+    // Phase 3: AI configuration (OpenClaw-like provider chooser)
+    UI.divider()
+    await UI.typeText("Let's connect your AI provider first.", { charDelay: 10 })
+    await UI.typeText("Choose a provider, enter key/endpoint, and we'll verify it.", { charDelay: 10 })
+    console.log("")
+    await runAISetupWizard("setup")
+
+    // Phase 4: Interactive scan & publish
     UI.divider()
 
     await UI.typeText("Great! Let's see what you've been working on.")
@@ -340,9 +613,6 @@ export const SetupCommand: CommandModule = {
       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

package/src/cli/ui.ts

@@ -84,31 +84,70 @@ export namespace UI {
       if (stdin.isTTY && stdin.setRawMode) stdin.setRawMode(true)
 
       let buf = ""
-      const onData = (ch: Buffer) => {
+      let paste = false
+      let onData: ((ch: Buffer) => void) = () => {}
+
+      const restore = () => {
+        if (stdin.isTTY && stdin.setRawMode) stdin.setRawMode(wasRaw ?? false)
+        stdin.removeListener("data", onData)
+      }
+
+      const readClipboard = () => {
+        if (process.platform !== "darwin") return ""
+        try {
+          const out = Bun.spawnSync(["pbpaste"])
+          if (out.exitCode !== 0) return ""
+          return out.stdout.toString().replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\n/g, "")
+        } catch {
+          return ""
+        }
+      }
+
+      const append = (text: string) => {
+        if (!text) return
+        buf += text
+        process.stderr.write(text)
+      }
+
+      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)
+          restore()
           process.exit(130)
         }
-        if (c === "\x1b") {
+        if (!paste && c === "\x1b") {
           // Escape
-          if (stdin.isTTY && stdin.setRawMode) stdin.setRawMode(wasRaw ?? false)
-          stdin.removeListener("data", onData)
+          restore()
           process.stderr.write("\n")
           resolve(null)
           return
         }
-        if (c === "\r" || c === "\n") {
+        if (c === "\x16" || c === "\x1bv") {
+          const clip = readClipboard()
+          if (clip) append(clip)
+          return
+        }
+
+        let text = c
+        if (text.includes("\x1b[200~")) {
+          paste = true
+          text = text.replace(/\x1b\[200~/g, "")
+        }
+        if (text.includes("\x1b[201~")) {
+          paste = false
+          text = text.replace(/\x1b\[201~/g, "")
+        }
+        text = text.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "").replace(/\x1b./g, "")
+
+        if (!paste && (text === "\r" || text === "\n")) {
           // Enter
-          if (stdin.isTTY && stdin.setRawMode) stdin.setRawMode(wasRaw ?? false)
-          stdin.removeListener("data", onData)
+          restore()
           process.stderr.write("\n")
           resolve(buf)
           return
         }
-        if (c === "\u007f" || c === "\b") {
+        if (!paste && (text === "\u007f" || text === "\b")) {
           // Backspace
           if (buf.length > 0) {
             buf = buf.slice(0, -1)
@@ -117,11 +156,8 @@ export namespace UI {
           return
         }
         // Regular character
-        const clean = c.replace(/[\x00-\x1f\x7f]/g, "")
-        if (clean) {
-          buf += clean
-          process.stderr.write(clean)
-        }
+        const clean = text.replace(/[\x00-\x08\x0b-\x1f\x7f]/g, "")
+        append(clean)
       }
       stdin.on("data", onData)
     })
@@ -165,16 +201,87 @@ export namespace UI {
   }
 
   export async function select(prompt: string, options: string[]): Promise<number> {
-    console.log(prompt)
-    for (let i = 0; i < options.length; i++) {
-      console.log(`  ${Style.TEXT_HIGHLIGHT}[${i + 1}]${Style.TEXT_NORMAL} ${options[i]}`)
+    if (options.length === 0) return 0
+
+    const stdin = process.stdin
+    const wasRaw = stdin.isRaw
+    if (stdin.isTTY && stdin.setRawMode) stdin.setRawMode(true)
+    process.stderr.write("\x1b[?25l")
+
+    let idx = 0
+    let drawnRows = 0
+    const maxRows = 12
+    let onData: ((ch: Buffer) => void) = () => {}
+
+    const stripAnsi = (text: string) => text.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "").replace(/\x1b./g, "")
+    const rowCount = (line: string) => {
+      const cols = Math.max(20, process.stderr.columns || 80)
+      const len = Array.from(stripAnsi(line)).length
+      return Math.max(1, Math.ceil((len || 1) / cols))
+    }
+
+    const draw = () => {
+      if (drawnRows > 1) process.stderr.write(`\x1b[${drawnRows - 1}F`)
+      process.stderr.write("\x1b[J")
+
+      const start = options.length <= maxRows ? 0 : Math.max(0, Math.min(idx - 4, options.length - maxRows))
+      const items = options.slice(start, start + maxRows)
+      const lines = [
+        prompt,
+        ...items.map((item, i) => {
+          const active = start + i === idx
+          const marker = active ? `${Style.TEXT_HIGHLIGHT}●${Style.TEXT_NORMAL}` : "○"
+          const text = active ? `${Style.TEXT_NORMAL_BOLD}${item}${Style.TEXT_NORMAL}` : item
+          return `  ${marker} ${text}`
+        }),
+        options.length > maxRows
+          ? `  ${Style.TEXT_DIM}${start > 0 ? "↑ more  " : ""}${start + maxRows < options.length ? "↓ more" : ""}${Style.TEXT_NORMAL}`
+          : `  ${Style.TEXT_DIM}${Style.TEXT_NORMAL}`,
+        `  ${Style.TEXT_DIM}Use ↑/↓ then Enter (Esc to cancel)${Style.TEXT_NORMAL}`,
+      ]
+      process.stderr.write(lines.map((line) => `\x1b[2K\r${line}`).join("\n"))
+      drawnRows = lines.reduce((sum, line) => sum + rowCount(line), 0)
     }
-    console.log("")
-    const answer = await input(`  Choice [1]: `)
-    const num = parseInt(answer, 10)
-    if (!answer) return 0
-    if (isNaN(num) || num < 1 || num > options.length) return 0
-    return num - 1
+
+    const restore = () => {
+      process.stderr.write("\x1b[?25h")
+      if (stdin.isTTY && stdin.setRawMode) stdin.setRawMode(wasRaw ?? false)
+      stdin.removeListener("data", onData)
+      process.stderr.write("\n")
+    }
+
+    draw()
+
+    return new Promise((resolve) => {
+      onData = (ch: Buffer) => {
+        const c = ch.toString("utf8")
+        if (c === "\u0003") {
+          restore()
+          process.exit(130)
+        }
+        if (c === "\r" || c === "\n") {
+          restore()
+          resolve(idx)
+          return
+        }
+        if (c === "\x1b") {
+          restore()
+          resolve(-1)
+          return
+        }
+        if (c === "k" || c.includes("\x1b[A") || c.includes("\x1bOA")) {
+          idx = (idx - 1 + options.length) % options.length
+          draw()
+          return
+        }
+        if (c === "j" || c.includes("\x1b[B") || c.includes("\x1bOB")) {
+          idx = (idx + 1) % options.length
+          draw()
+          return
+        }
+      }
+      stdin.on("data", onData)
+    })
   }
 
   export async function waitKey(prompt: string, keys: string[]): Promise<string> {

package/src/config/index.ts

@@ -1,12 +1,23 @@
 import path from "path"
+import { chmod, writeFile } from "fs/promises"
 import { Global } from "../global"
 
 const CONFIG_FILE = path.join(Global.Path.config, "config.json")
 
 export namespace Config {
+  export type ModelApi = "anthropic" | "openai" | "google" | "openai-compatible"
+  export type CompatProfile = "anthropic" | "openai" | "openai-compatible" | "google"
+
+  export interface FeatureFlags {
+    ai_provider_registry_v2?: boolean
+    ai_onboarding_wizard_v2?: boolean
+  }
+
   export interface ProviderConfig {
     api_key: string
     base_url?: string
+    api?: ModelApi
+    compat_profile?: CompatProfile
   }
 
   export interface CodeblogConfig {
@@ -14,9 +25,11 @@ export namespace Config {
     api_key?: string
     token?: string
     model?: string
+    default_provider?: string
     default_language?: string
     activeAgent?: string
     providers?: Record<string, ProviderConfig>
+    feature_flags?: FeatureFlags
   }
 
   const defaults: CodeblogConfig = {
@@ -25,6 +38,11 @@ export namespace Config {
 
   export const filepath = CONFIG_FILE
 
+  const FEATURE_FLAG_ENV: Record<keyof FeatureFlags, string> = {
+    ai_provider_registry_v2: "CODEBLOG_AI_PROVIDER_REGISTRY_V2",
+    ai_onboarding_wizard_v2: "CODEBLOG_AI_ONBOARDING_WIZARD_V2",
+  }
+
   export async function load(): Promise<CodeblogConfig> {
     const file = Bun.file(CONFIG_FILE)
     const data = await file.json().catch(() => ({}))
@@ -34,7 +52,8 @@ export namespace Config {
   export async function save(config: Partial<CodeblogConfig>) {
     const current = await load()
     const merged = { ...current, ...config }
-    await Bun.write(Bun.file(CONFIG_FILE, { mode: 0o600 }), JSON.stringify(merged, null, 2))
+    await writeFile(CONFIG_FILE, JSON.stringify(merged, null, 2))
+    await chmod(CONFIG_FILE, 0o600).catch(() => {})
   }
 
   export async function url() {
@@ -52,4 +71,22 @@ export namespace Config {
   export async function language() {
     return process.env.CODEBLOG_LANGUAGE || (await load()).default_language
   }
+
+  function parseBool(raw: string | undefined): boolean | undefined {
+    if (!raw) return undefined
+    const v = raw.trim().toLowerCase()
+    if (["1", "true", "yes", "on"].includes(v)) return true
+    if (["0", "false", "no", "off"].includes(v)) return false
+    return undefined
+  }
+
+  export function envFlagName(flag: keyof FeatureFlags): string {
+    return FEATURE_FLAG_ENV[flag]
+  }
+
+  export async function featureEnabled(flag: keyof FeatureFlags): Promise<boolean> {
+    const env = parseBool(process.env[FEATURE_FLAG_ENV[flag]])
+    if (env !== undefined) return env
+    return !!(await load()).feature_flags?.[flag]
+  }
 }

package/src/index.ts

@@ -8,6 +8,7 @@ import { Auth } from "./auth"
 
 // Commands
 import { SetupCommand } from "./cli/cmd/setup"
+import { AISetupCommand } from "./cli/cmd/ai"
 import { LoginCommand } from "./cli/cmd/login"
 import { LogoutCommand } from "./cli/cmd/logout"
 import { WhoamiCommand } from "./cli/cmd/whoami"
@@ -71,7 +72,7 @@ const cli = yargs(hideBin(process.argv))
   })
   .middleware(async (argv) => {
     const cmd = argv._[0] as string | undefined
-    const skipAuth = ["setup", "login", "logout", "config", "update", "uninstall"]
+    const skipAuth = ["setup", "ai", "login", "logout", "config", "update", "uninstall"]
     if (cmd && !skipAuth.includes(cmd)) {
       const authed = await Auth.authenticated()
       if (!authed) {
@@ -84,6 +85,7 @@ const cli = yargs(hideBin(process.argv))
     "\n" + UI.logo() +
     "\n  Getting Started:\n" +
     "    setup              First-time setup wizard\n" +
+    "    ai setup           Full AI onboarding wizard\n" +
     "    login / logout     Authentication\n\n" +
     "  Browse & Interact:\n" +
     "    feed               Browse the forum feed\n" +
@@ -111,6 +113,7 @@ const cli = yargs(hideBin(process.argv))
   // Register commands with describe=false to hide from auto-generated Commands section
   // (we already display them in the custom usage above)
   .command({ ...SetupCommand, describe: false })
+  .command({ ...AISetupCommand, describe: false })
   .command({ ...LoginCommand, describe: false })
   .command({ ...LogoutCommand, describe: false })
   .command({ ...FeedCommand, describe: false })

package/src/mcp/__tests__/client.test.ts

@@ -6,7 +6,7 @@ import { describe, test, expect, mock, beforeEach, afterEach } from "bun:test"
 // ---------------------------------------------------------------------------
 
 // Mock the MCP SDK
-const mockCallTool = mock(() =>
+const mockCallTool = mock((): Promise<{ content: Array<{ type: string; text?: string; data?: string }>; isError: boolean }> =>
   Promise.resolve({
     content: [{ type: "text", text: '{"ok":true}' }],
     isError: false,
@@ -120,7 +120,7 @@ describe("McpBridge", () => {
   test("listTools delegates to MCP client", async () => {
     const result = await McpBridge.listTools()
     expect(result.tools).toHaveLength(1)
-    expect(result.tools[0].name).toBe("test_tool")
+    expect(result.tools[0]?.name).toBe("test_tool")
   })
 
   test("disconnect cleans up transport and client", async () => {