codeblog-app 2.1.2 → 2.1.4

package/src/ai/configure.ts

@@ -0,0 +1,134 @@
+// AI provider auto-detection and configuration
+
+function looksLikeApi(r: Response) {
+  const ct = r.headers.get("content-type") || ""
+  return ct.includes("json") || ct.includes("text/plain")
+}
+
+export async function probe(base: string, key: string): Promise<"openai" | "anthropic" | null> {
+  const clean = base.replace(/\/+$/, "")
+  try {
+    const r = await fetch(`${clean}/v1/models`, {
+      headers: { Authorization: `Bearer ${key}` },
+      signal: AbortSignal.timeout(8000),
+    })
+    if (r.ok || ((r.status === 401 || r.status === 403) && looksLikeApi(r))) return "openai"
+  } catch {}
+  try {
+    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: "test", max_tokens: 1, messages: [] }),
+      signal: AbortSignal.timeout(8000),
+    })
+    if (r.status !== 404 && looksLikeApi(r)) return "anthropic"
+  } catch {}
+  return null
+}
+
+const KEY_PREFIX_MAP: Record<string, string> = {
+  "sk-ant-": "anthropic",
+  "AIza": "google",
+  "xai-": "xai",
+  "gsk_": "groq",
+  "sk-or-": "openrouter",
+  "pplx-": "perplexity",
+}
+
+const ENV_MAP: Record<string, string> = {
+  anthropic: "ANTHROPIC_API_KEY",
+  openai: "OPENAI_API_KEY",
+  google: "GOOGLE_GENERATIVE_AI_API_KEY",
+  xai: "XAI_API_KEY",
+  groq: "GROQ_API_KEY",
+  openrouter: "OPENROUTER_API_KEY",
+  perplexity: "PERPLEXITY_API_KEY",
+  "openai-compatible": "OPENAI_COMPATIBLE_API_KEY",
+}
+
+async function fetchFirstModel(base: string, key: string): Promise<string | null> {
+  try {
+    const clean = base.replace(/\/+$/, "")
+    const r = await fetch(`${clean}/v1/models`, {
+      headers: { Authorization: `Bearer ${key}` },
+      signal: AbortSignal.timeout(8000),
+    })
+    if (!r.ok) return null
+    const data = await r.json() as { data?: Array<{ id: string }> }
+    if (!data.data || data.data.length === 0) return null
+
+    // Prefer capable models: claude-sonnet > gpt-4o > claude-opus > first available
+    const ids = data.data.map((m) => m.id)
+    const preferred = [/^claude-sonnet-4/, /^gpt-4o$/, /^claude-opus-4/, /^gpt-4o-mini$/, /^gemini-2\.5-flash$/]
+    for (const pattern of preferred) {
+      const match = ids.find((id) => pattern.test(id))
+      if (match) return match
+    }
+    return ids[0] ?? null
+  } catch {}
+  return null
+}
+
+export function detectProvider(key: string) {
+  for (const [prefix, provider] of Object.entries(KEY_PREFIX_MAP)) {
+    if (key.startsWith(prefix)) return provider
+  }
+  return "openai"
+}
+
+export async function saveProvider(url: string, key: string): Promise<{ provider: string; error?: string }> {
+  const { Config } = await import("../config")
+
+  if (url) {
+    const detected = await probe(url, key)
+    if (!detected) return { provider: "", error: "Could not connect. Check URL and key." }
+
+    const provider = detected === "anthropic" ? "anthropic" : "openai-compatible"
+    const envKey = detected === "anthropic" ? "ANTHROPIC_API_KEY" : "OPENAI_COMPATIBLE_API_KEY"
+    const envBase = detected === "anthropic" ? "ANTHROPIC_BASE_URL" : "OPENAI_COMPATIBLE_BASE_URL"
+    process.env[envKey] = key
+    process.env[envBase] = url
+
+    const cfg = await Config.load()
+    const providers = cfg.providers || {}
+    providers[provider] = { api_key: key, base_url: url }
+
+    // Auto-set model if not already configured
+    const update: Record<string, unknown> = { providers }
+    if (!cfg.model) {
+      if (detected === "anthropic") {
+        update.model = "claude-sonnet-4-20250514"
+      } else {
+        // For openai-compatible with custom URL, try to fetch available models
+        const model = await fetchFirstModel(url, key)
+        if (model) update.model = `openai-compatible/${model}`
+      }
+    }
+
+    await Config.save(update)
+    return { provider: `${detected} format` }
+  }
+
+  const provider = detectProvider(key)
+  if (ENV_MAP[provider]) process.env[ENV_MAP[provider]] = key
+
+  const cfg = await Config.load()
+  const providers = cfg.providers || {}
+  providers[provider] = { api_key: key }
+
+  // Auto-set model for known providers
+  const update: Record<string, unknown> = { providers }
+  if (!cfg.model) {
+    const { AIProvider } = await import("./provider")
+    const models = Object.values(AIProvider.BUILTIN_MODELS).filter((m) => m.providerID === provider)
+    if (models.length > 0) update.model = models[0]!.id
+  }
+
+  await Config.save(update)
+  return { provider }
+}
+
+export function mask(s: string) {
+  if (s.length <= 8) return s
+  return s.slice(0, 4) + "\u2022".repeat(Math.min(s.length - 8, 20)) + s.slice(-4)
+}

package/src/ai/provider.ts

@@ -0,0 +1,238 @@
+import { createAnthropic } from "@ai-sdk/anthropic"
+import { createOpenAI } from "@ai-sdk/openai"
+import { createGoogleGenerativeAI } from "@ai-sdk/google"
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible"
+import { type LanguageModel, type Provider as SDK } from "ai"
+import { Config } from "../config"
+import { Log } from "../util/log"
+
+const log = Log.create({ service: "ai-provider" })
+
+export namespace AIProvider {
+  // ---------------------------------------------------------------------------
+  // Bundled providers (4 core)
+  // ---------------------------------------------------------------------------
+  const BUNDLED_PROVIDERS: Record<string, (options: any) => SDK> = {
+    "@ai-sdk/anthropic": createAnthropic as any,
+    "@ai-sdk/openai": createOpenAI as any,
+    "@ai-sdk/google": createGoogleGenerativeAI as any,
+    "@ai-sdk/openai-compatible": createOpenAICompatible as any,
+  }
+
+  // ---------------------------------------------------------------------------
+  // Provider env key mapping
+  // ---------------------------------------------------------------------------
+  const PROVIDER_ENV: Record<string, string[]> = {
+    anthropic: ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN"],
+    openai: ["OPENAI_API_KEY"],
+    google: ["GOOGLE_GENERATIVE_AI_API_KEY", "GOOGLE_API_KEY"],
+    "openai-compatible": ["OPENAI_COMPATIBLE_API_KEY"],
+  }
+
+  // ---------------------------------------------------------------------------
+  // Provider base URL env mapping
+  // ---------------------------------------------------------------------------
+  const PROVIDER_BASE_URL_ENV: Record<string, string[]> = {
+    anthropic: ["ANTHROPIC_BASE_URL"],
+    openai: ["OPENAI_BASE_URL", "OPENAI_API_BASE"],
+    google: ["GOOGLE_API_BASE_URL"],
+    "openai-compatible": ["OPENAI_COMPATIBLE_BASE_URL"],
+  }
+
+  // ---------------------------------------------------------------------------
+  // Provider → npm package mapping
+  // ---------------------------------------------------------------------------
+  const PROVIDER_NPM: Record<string, string> = {
+    anthropic: "@ai-sdk/anthropic",
+    openai: "@ai-sdk/openai",
+    google: "@ai-sdk/google",
+    "openai-compatible": "@ai-sdk/openai-compatible",
+  }
+
+  // ---------------------------------------------------------------------------
+  // Model info type
+  // ---------------------------------------------------------------------------
+  export interface ModelInfo {
+    id: string
+    providerID: string
+    name: string
+    contextWindow: number
+    outputTokens: number
+  }
+
+  // ---------------------------------------------------------------------------
+  // Built-in model list
+  // ---------------------------------------------------------------------------
+  export const BUILTIN_MODELS: Record<string, ModelInfo> = {
+    "claude-sonnet-4-20250514": { id: "claude-sonnet-4-20250514", providerID: "anthropic", name: "Claude Sonnet 4", contextWindow: 200000, outputTokens: 16384 },
+    "claude-3-5-haiku-20241022": { id: "claude-3-5-haiku-20241022", providerID: "anthropic", name: "Claude 3.5 Haiku", contextWindow: 200000, outputTokens: 8192 },
+    "gpt-4o": { id: "gpt-4o", providerID: "openai", name: "GPT-4o", contextWindow: 128000, outputTokens: 16384 },
+    "gpt-4o-mini": { id: "gpt-4o-mini", providerID: "openai", name: "GPT-4o Mini", contextWindow: 128000, outputTokens: 16384 },
+    "o3-mini": { id: "o3-mini", providerID: "openai", name: "o3-mini", contextWindow: 200000, outputTokens: 100000 },
+    "gemini-2.5-flash": { id: "gemini-2.5-flash", providerID: "google", name: "Gemini 2.5 Flash", contextWindow: 1048576, outputTokens: 65536 },
+    "gemini-2.5-pro": { id: "gemini-2.5-pro", providerID: "google", name: "Gemini 2.5 Pro", contextWindow: 1048576, outputTokens: 65536 },
+  }
+
+  export const DEFAULT_MODEL = "claude-sonnet-4-20250514"
+
+  // ---------------------------------------------------------------------------
+  // Get API key for a provider
+  // ---------------------------------------------------------------------------
+  export async function getApiKey(providerID: string): Promise<string | undefined> {
+    const envKeys = PROVIDER_ENV[providerID] || []
+    for (const key of envKeys) {
+      if (process.env[key]) return process.env[key]
+    }
+    const cfg = await Config.load()
+    return cfg.providers?.[providerID]?.api_key
+  }
+
+  // ---------------------------------------------------------------------------
+  // Get base URL for a provider
+  // ---------------------------------------------------------------------------
+  export async function getBaseUrl(providerID: string): Promise<string | undefined> {
+    const envKeys = PROVIDER_BASE_URL_ENV[providerID] || []
+    for (const key of envKeys) {
+      if (process.env[key]) return process.env[key]
+    }
+    const cfg = await Config.load()
+    return cfg.providers?.[providerID]?.base_url
+  }
+
+  // ---------------------------------------------------------------------------
+  // List all available providers
+  // ---------------------------------------------------------------------------
+  export async function listProviders(): Promise<Record<string, { name: string; models: string[]; hasKey: boolean }>> {
+    const result: Record<string, { name: string; models: string[]; hasKey: boolean }> = {}
+    for (const model of Object.values(BUILTIN_MODELS)) {
+      if (!result[model.providerID]) {
+        const key = await getApiKey(model.providerID)
+        result[model.providerID] = { name: model.providerID, models: [], hasKey: !!key }
+      }
+      if (!result[model.providerID]!.models.includes(model.id)) {
+        result[model.providerID]!.models.push(model.id)
+      }
+    }
+    const compatKey = await getApiKey("openai-compatible")
+    if (compatKey) {
+      result["openai-compatible"] = { name: "OpenAI Compatible", models: [], hasKey: true }
+    }
+    return result
+  }
+
+  // ---------------------------------------------------------------------------
+  // Get a LanguageModel instance
+  // ---------------------------------------------------------------------------
+  const sdkCache = new Map<string, SDK>()
+
+  export async function getModel(modelID?: string): Promise<LanguageModel> {
+    const id = modelID || (await getConfiguredModel()) || DEFAULT_MODEL
+
+    const builtin = BUILTIN_MODELS[id]
+    if (builtin) {
+      const apiKey = await getApiKey(builtin.providerID)
+      if (!apiKey) throw noKeyError(builtin.providerID)
+      const base = await getBaseUrl(builtin.providerID)
+      return getLanguageModel(builtin.providerID, id, apiKey, undefined, base)
+    }
+
+    if (id.includes("/")) {
+      const [providerID, ...rest] = id.split("/")
+      const mid = rest.join("/")
+      const apiKey = await getApiKey(providerID!)
+      if (!apiKey) throw noKeyError(providerID!)
+      const base = await getBaseUrl(providerID!)
+      return getLanguageModel(providerID!, mid, apiKey, undefined, base)
+    }
+
+    const cfg = await Config.load()
+    if (cfg.providers) {
+      for (const [providerID, p] of Object.entries(cfg.providers)) {
+        if (!p.api_key) continue
+        const base = p.base_url || (await getBaseUrl(providerID))
+        if (base) {
+          log.info("fallback: sending unknown model to provider with base_url", { provider: providerID, model: id })
+          return getLanguageModel(providerID, id, p.api_key, undefined, base)
+        }
+      }
+    }
+
+    throw new Error(`Unknown model: ${id}. Run: codeblog config --list`)
+  }
+
+  function getLanguageModel(providerID: string, modelID: string, apiKey: string, npm?: string, baseURL?: string): LanguageModel {
+    const pkg = npm || PROVIDER_NPM[providerID] || "@ai-sdk/openai-compatible"
+    const cacheKey = `${providerID}:${pkg}:${apiKey.slice(0, 8)}`
+
+    log.info("loading model", { provider: providerID, model: modelID, pkg })
+
+    let sdk = sdkCache.get(cacheKey)
+    if (!sdk) {
+      const createFn = BUNDLED_PROVIDERS[pkg]
+      if (!createFn) throw new Error(`No bundled provider for ${pkg}. Use openai-compatible with a base URL instead.`)
+      const opts: Record<string, unknown> = { apiKey, name: providerID }
+      if (baseURL) {
+        const clean = baseURL.replace(/\/+$/, "")
+        opts.baseURL = clean.endsWith("/v1") ? clean : `${clean}/v1`
+      }
+      sdk = createFn(opts)
+      sdkCache.set(cacheKey, sdk)
+    }
+
+    if (pkg === "@ai-sdk/openai-compatible" && typeof (sdk as any).chatModel === "function") {
+      return (sdk as any).chatModel(modelID)
+    }
+    if (typeof (sdk as any).languageModel === "function") {
+      return (sdk as any).languageModel(modelID)
+    }
+    return (sdk as any)(modelID)
+  }
+
+  function noKeyError(providerID: string): Error {
+    const envKeys = PROVIDER_ENV[providerID] || []
+    const envHint = envKeys[0] || `${providerID.toUpperCase().replace(/-/g, "_")}_API_KEY`
+    return new Error(`No API key for ${providerID}. Set ${envHint} or run: codeblog config --provider ${providerID} --api-key <key>`)
+  }
+
+  async function getConfiguredModel(): Promise<string | undefined> {
+    const cfg = await Config.load()
+    return cfg.model
+  }
+
+  // ---------------------------------------------------------------------------
+  // Check if any AI provider has a key configured
+  // ---------------------------------------------------------------------------
+  export async function hasAnyKey(): Promise<boolean> {
+    for (const providerID of Object.keys(PROVIDER_ENV)) {
+      const key = await getApiKey(providerID)
+      if (key) return true
+    }
+    const cfg = await Config.load()
+    if (cfg.providers) {
+      for (const p of Object.values(cfg.providers)) {
+        if (p.api_key) return true
+      }
+    }
+    return false
+  }
+
+  // ---------------------------------------------------------------------------
+  // List available models with key status
+  // ---------------------------------------------------------------------------
+  export async function available(): Promise<Array<{ model: ModelInfo; hasKey: boolean }>> {
+    const result: Array<{ model: ModelInfo; hasKey: boolean }> = []
+    for (const model of Object.values(BUILTIN_MODELS)) {
+      const apiKey = await getApiKey(model.providerID)
+      result.push({ model, hasKey: !!apiKey })
+    }
+    return result
+  }
+
+  // ---------------------------------------------------------------------------
+  // Parse provider/model format
+  // ---------------------------------------------------------------------------
+  export function parseModel(model: string) {
+    const [providerID, ...rest] = model.split("/")
+    return { providerID, modelID: rest.join("/") }
+  }
+}

package/src/ai/tools.ts

@@ -0,0 +1,91 @@
+import { tool, jsonSchema } from "ai"
+import { McpBridge } from "../mcp/client"
+import { Log } from "../util/log"
+
+const log = Log.create({ service: "ai-tools" })
+
+// ---------------------------------------------------------------------------
+// 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...",
+  read_session: "Reading session...",
+  analyze_session: "Analyzing session...",
+  post_to_codeblog: "Publishing post...",
+  auto_post: "Auto-posting...",
+  weekly_digest: "Generating weekly digest...",
+  browse_posts: "Browsing posts...",
+  search_posts: "Searching posts...",
+  read_post: "Reading post...",
+  comment_on_post: "Posting comment...",
+  vote_on_post: "Voting...",
+  edit_post: "Editing post...",
+  delete_post: "Deleting post...",
+  bookmark_post: "Bookmarking...",
+  browse_by_tag: "Browsing tags...",
+  trending_topics: "Loading trending...",
+  explore_and_engage: "Exploring posts...",
+  join_debate: "Loading debates...",
+  my_notifications: "Checking notifications...",
+  manage_agents: "Managing agents...",
+  my_posts: "Loading your posts...",
+  my_dashboard: "Loading dashboard...",
+  follow_user: "Processing follow...",
+  codeblog_setup: "Configuring CodeBlog...",
+  codeblog_status: "Checking status...",
+}
+
+// ---------------------------------------------------------------------------
+// Helper: call MCP tool and return result
+// ---------------------------------------------------------------------------
+async function mcp(name: string, args: Record<string, unknown> = {}): Promise<any> {
+  return McpBridge.callToolJSON(name, args)
+}
+
+// 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)) {
+    if (v !== undefined && v !== null) result[k] = v
+  }
+  return result
+}
+
+// ---------------------------------------------------------------------------
+// Dynamic tool discovery from MCP server
+// ---------------------------------------------------------------------------
+let _cached: Record<string, any> | null = null
+
+/**
+ * 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 { tools: mcpTools } = await McpBridge.listTools()
+  log.info("discovered MCP tools", { count: mcpTools.length, names: mcpTools.map((t) => t.name) })
+
+  const tools: Record<string, any> = {}
+
+  for (const t of mcpTools) {
+    const name = t.name
+    const schema = t.inputSchema as Record<string, unknown>
+
+    tools[name] = (tool as any)({
+      description: t.description || name,
+      parameters: jsonSchema(schema),
+      execute: async (args: any) => mcp(name, clean(args)),
+    })
+  }
+
+  _cached = tools
+  return tools
+}
+
+/** Clear the cached tools (useful for testing or reconnection). */
+export function clearChatToolsCache(): void {
+  _cached = null
+}

package/src/auth/index.ts

@@ -0,0 +1,47 @@
+import path from "path"
+import { Global } from "../global"
+import z from "zod"
+
+export namespace Auth {
+  export const Token = z
+    .object({
+      type: z.enum(["jwt", "apikey"]),
+      value: z.string(),
+      expires: z.number().optional(),
+      username: z.string().optional(),
+    })
+    .meta({ ref: "AuthToken" })
+  export type Token = z.infer<typeof Token>
+
+  const filepath = path.join(Global.Path.data, "auth.json")
+
+  export async function get(): Promise<Token | null> {
+    const file = Bun.file(filepath)
+    const data = await file.json().catch(() => null)
+    if (!data) return null
+    const parsed = Token.safeParse(data)
+    if (!parsed.success) return null
+    return parsed.data
+  }
+
+  export async function set(token: Token) {
+    await Bun.write(Bun.file(filepath, { mode: 0o600 }), JSON.stringify(token, null, 2))
+  }
+
+  export async function remove() {
+    const fs = await import("fs/promises")
+    await fs.unlink(filepath).catch(() => {})
+  }
+
+  export async function header(): Promise<Record<string, string>> {
+    const token = await get()
+    if (!token) return {}
+    if (token.type === "apikey") return { Authorization: `Bearer ${token.value}` }
+    return { Authorization: `Bearer ${token.value}` }
+  }
+
+  export async function authenticated(): Promise<boolean> {
+    const token = await get()
+    return token !== null
+  }
+}

package/src/auth/oauth.ts

@@ -0,0 +1,94 @@
+import { Auth } from "./index"
+import { Config } from "../config"
+import { McpBridge } from "../mcp/client"
+import { Server } from "../server"
+import { Log } from "../util/log"
+
+const log = Log.create({ service: "oauth" })
+
+export namespace OAuth {
+  export async function login(options?: { onUrl?: (url: string) => void }) {
+    const open = (await import("open")).default
+    const base = await Config.url()
+
+    const { app, port } = Server.createCallbackServer(async (params) => {
+      const token = params.get("token")
+      const key = params.get("api_key")
+      const username = params.get("username") || undefined
+
+      if (key) {
+        await Auth.set({ type: "apikey", value: key, username })
+        // Sync API key to MCP config (~/.codeblog/config.json)
+        try {
+          await McpBridge.callTool("codeblog_setup", { api_key: key })
+        } catch (err) {
+          log.warn("failed to sync API key to MCP config", { error: String(err) })
+        }
+        log.info("authenticated with api key")
+      } else if (token) {
+        await Auth.set({ type: "jwt", value: token, username })
+        log.info("authenticated with jwt")
+      } else {
+        Server.stop()
+        throw new Error("No token received")
+      }
+
+      setTimeout(() => Server.stop(), 500)
+      return `<!DOCTYPE html>
+<html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>CodeBlog - Authenticated</title>
+<style>
+*{margin:0;padding:0;box-sizing:border-box}
+body{font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,sans-serif;min-height:100vh;display:flex;align-items:center;justify-content:center;background:#f8f9fa}
+.card{text-align:center;background:#fff;border-radius:16px;padding:48px 40px;box-shadow:0 4px 24px rgba(0,0,0,.08);max-width:420px;width:90%}
+.icon{font-size:64px;margin-bottom:16px}
+h1{font-size:24px;color:#232629;margin-bottom:8px}
+p{font-size:15px;color:#6a737c;line-height:1.5}
+.brand{color:#f48225;font-weight:700}
+.hint{margin-top:24px;font-size:13px;color:#9a9a9a}
+</style></head><body>
+<div class="card">
+<div class="icon">✅</div>
+<h1>Welcome to <span class="brand">CodeBlog</span></h1>
+<p>Authentication successful! You can close this window and return to the terminal.</p>
+<p class="hint">This window will close automatically...</p>
+</div>
+<script>setTimeout(()=>window.close(),3000)</script>
+</body></html>`
+    })
+
+    return new Promise<void>((resolve, reject) => {
+      const original = app.fetch
+      const wrapped = new Proxy(app, {
+        get(target, prop) {
+          if (prop === "fetch") {
+            return async (...args: Parameters<typeof original>) => {
+              try {
+                const res = await original.apply(target, args)
+                resolve()
+                return res
+              } catch (err) {
+                reject(err instanceof Error ? err : new Error(String(err)))
+                return new Response("Error", { status: 500 })
+              }
+            }
+          }
+          return Reflect.get(target, prop)
+        },
+      })
+
+      Server.start(wrapped, port)
+
+      const authUrl = `${base}/auth/cli?port=${port}`
+      log.info("opening browser", { url: authUrl })
+      if (options?.onUrl) options.onUrl(authUrl)
+      open(authUrl)
+
+      // Timeout after 5 minutes
+      setTimeout(() => {
+        Server.stop()
+        reject(new Error("OAuth login timed out"))
+      }, 5 * 60 * 1000)
+    })
+  }
+}