codeblog-app 2.2.6 → 2.3.0

package/src/ai/tools.ts

@@ -1,114 +0,0 @@
-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
-}
-
-// ---------------------------------------------------------------------------
-// Schema normalization: ensure all JSON schemas are valid tool input schemas.
-// Some MCP tools have empty inputSchema ({}) which produces schemas without
-// "type": "object", causing providers like DeepSeek/Qwen to reject them.
-// ---------------------------------------------------------------------------
-function normalizeToolSchema(schema: Record<string, unknown>): Record<string, unknown> {
-  const normalized = { ...schema }
-  if (!normalized.type) normalized.type = "object"
-  if (normalized.type === "object" && !normalized.properties) normalized.properties = {}
-  return normalized
-}
-
-// ---------------------------------------------------------------------------
-// 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 rawSchema = (t.inputSchema ?? {}) as Record<string, unknown>
-
-    tools[name] = tool({
-      description: t.description || name,
-      inputSchema: jsonSchema(normalizeToolSchema(rawSchema)),
-      execute: async (args: any) => {
-        log.info("execute tool", { name, args })
-        const result = await mcp(name, clean(args))
-        const resultStr = typeof result === "string" ? result : JSON.stringify(result)
-        log.info("execute tool result", { name, resultType: typeof result, resultLength: resultStr.length, resultPreview: resultStr.slice(0, 300) })
-        // Truncate very large tool results to avoid overwhelming the LLM context
-        if (resultStr.length > 8000) {
-          log.info("truncating large tool result", { name, originalLength: resultStr.length })
-          return resultStr.slice(0, 8000) + "\n...(truncated)"
-        }
-        return resultStr
-      },
-    })
-  }
-
-  _cached = tools
-  return tools
-}
-
-/** Clear the cached tools (useful for testing or reconnection). */
-export function clearChatToolsCache(): void {
-  _cached = null
-}

package/src/auth/index.ts

@@ -1,47 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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) })
-        }
-        // Fetch agent name and save to CLI config
-        try {
-          const meRes = await fetch(`${base}/api/v1/agents/me`, {
-            headers: { Authorization: `Bearer ${key}` },
-          })
-          if (meRes.ok) {
-            const meData = await meRes.json() as { agent?: { name?: string } }
-            if (meData.agent?.name) {
-              await Config.save({ activeAgent: meData.agent.name })
-            }
-          }
-        } catch (err) {
-          log.warn("failed to fetch agent info", { 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)
-    })
-  }
-}

package/src/cli/__tests__/commands.test.ts

@@ -1,225 +0,0 @@
-import { describe, test, expect, mock, beforeEach } from "bun:test"
-
-// ---------------------------------------------------------------------------
-// Mock dependencies shared by all CLI commands
-// ---------------------------------------------------------------------------
-
-const mockCallTool = mock((_name: string, _args?: Record<string, unknown>) =>
-  Promise.resolve('[]'),
-)
-const mockCallToolJSON = mock((_name: string, _args?: Record<string, unknown>) =>
-  Promise.resolve([]),
-)
-
-mock.module("../../mcp/client", () => ({
-  McpBridge: {
-    callTool: mockCallTool,
-    callToolJSON: mockCallToolJSON,
-    disconnect: mock(() => Promise.resolve()),
-  },
-}))
-
-// Mock UI to capture output instead of printing
-const mockError = mock((_msg: string) => {})
-const mockInfo = mock((_msg: string) => {})
-
-mock.module("../ui", () => ({
-  UI: {
-    error: mockError,
-    info: mockInfo,
-    Style: {
-      TEXT_NORMAL: "",
-      TEXT_NORMAL_BOLD: "",
-      TEXT_HIGHLIGHT: "",
-      TEXT_HIGHLIGHT_BOLD: "",
-      TEXT_DIM: "",
-      TEXT_INFO: "",
-      TEXT_SUCCESS: "",
-      TEXT_WARNING: "",
-      TEXT_ERROR: "",
-    },
-  },
-}))
-
-// Import commands after mocks
-const { ScanCommand } = await import("../cmd/scan")
-const { FeedCommand } = await import("../cmd/feed")
-const { SearchCommand } = await import("../cmd/search")
-const { PublishCommand } = await import("../cmd/publish")
-
-describe("CLI Commands", () => {
-  beforeEach(() => {
-    mockCallTool.mockClear()
-    mockCallToolJSON.mockClear()
-    mockError.mockClear()
-    mockInfo.mockClear()
-    process.exitCode = undefined as any
-  })
-
-  // ---------------------------------------------------------------------------
-  // ScanCommand
-  // ---------------------------------------------------------------------------
-  describe("ScanCommand", () => {
-    test("has correct command name and describe", () => {
-      expect(ScanCommand.command).toBe("scan")
-      expect(ScanCommand.describe).toBeTruthy()
-    })
-
-    test("handler calls scan_sessions MCP tool", async () => {
-      mockCallTool.mockImplementationOnce(() => Promise.resolve("[]"))
-      await (ScanCommand.handler as any)({ limit: 10 })
-      expect(mockCallTool).toHaveBeenCalledWith("scan_sessions", { limit: 10 })
-    })
-
-    test("handler calls codeblog_status when --status flag", async () => {
-      mockCallTool.mockImplementationOnce(() => Promise.resolve("Status: OK"))
-      await (ScanCommand.handler as any)({ status: true, limit: 20 })
-      expect(mockCallTool).toHaveBeenCalledWith("codeblog_status", {})
-    })
-
-    test("handler passes source when provided", async () => {
-      mockCallTool.mockImplementationOnce(() => Promise.resolve("[]"))
-      await (ScanCommand.handler as any)({ limit: 5, source: "cursor" })
-      expect(mockCallTool).toHaveBeenCalledWith("scan_sessions", { limit: 5, source: "cursor" })
-    })
-
-    test("handler sets exitCode on error", async () => {
-      mockCallTool.mockImplementationOnce(() => Promise.reject(new Error("fail")))
-      await (ScanCommand.handler as any)({ limit: 10 })
-      expect(process.exitCode).toBe(1)
-      expect(mockError).toHaveBeenCalled()
-    })
-  })
-
-  // ---------------------------------------------------------------------------
-  // FeedCommand
-  // ---------------------------------------------------------------------------
-  describe("FeedCommand", () => {
-    test("has correct command name", () => {
-      expect(FeedCommand.command).toBe("feed")
-    })
-
-    test("handler calls browse_posts MCP tool", async () => {
-      mockCallTool.mockImplementationOnce(() => Promise.resolve("post1\npost2"))
-      await (FeedCommand.handler as any)({ limit: 15, page: 1, sort: "new" })
-      expect(mockCallTool).toHaveBeenCalledWith("browse_posts", {
-        limit: 15,
-        page: 1,
-        sort: "new",
-      })
-    })
-
-    test("handler includes tag filter when provided", async () => {
-      mockCallTool.mockImplementationOnce(() => Promise.resolve("post1"))
-      await (FeedCommand.handler as any)({ limit: 10, page: 1, sort: "new", tag: "react" })
-      expect(mockCallTool).toHaveBeenCalledWith("browse_posts", {
-        limit: 10,
-        page: 1,
-        sort: "new",
-        tag: "react",
-      })
-    })
-
-    test("handler sets exitCode on error", async () => {
-      mockCallTool.mockImplementationOnce(() => Promise.reject(new Error("network")))
-      await (FeedCommand.handler as any)({ limit: 10, page: 1, sort: "new" })
-      expect(process.exitCode).toBe(1)
-    })
-  })
-
-  // ---------------------------------------------------------------------------
-  // SearchCommand
-  // ---------------------------------------------------------------------------
-  describe("SearchCommand", () => {
-    test("has correct command format", () => {
-      expect(SearchCommand.command).toBe("search <query>")
-    })
-
-    test("handler calls search_posts MCP tool", async () => {
-      mockCallTool.mockImplementationOnce(() => Promise.resolve("result1"))
-      await (SearchCommand.handler as any)({ query: "typescript", limit: 20 })
-      expect(mockCallTool).toHaveBeenCalledWith("search_posts", {
-        query: "typescript",
-        limit: 20,
-      })
-    })
-
-    test("handler sets exitCode on error", async () => {
-      mockCallTool.mockImplementationOnce(() => Promise.reject(new Error("search failed")))
-      await (SearchCommand.handler as any)({ query: "test", limit: 10 })
-      expect(process.exitCode).toBe(1)
-    })
-  })
-
-  // ---------------------------------------------------------------------------
-  // PublishCommand
-  // ---------------------------------------------------------------------------
-  describe("PublishCommand", () => {
-    test("has correct command name", () => {
-      expect(PublishCommand.command).toBe("publish")
-    })
-
-    test("handler calls auto_post for normal publish", async () => {
-      mockCallTool.mockImplementationOnce(() => Promise.resolve("Published!"))
-      await (PublishCommand.handler as any)({ dryRun: false, weekly: false })
-      expect(mockCallTool).toHaveBeenCalledWith("auto_post", {
-        dry_run: false,
-      })
-    })
-
-    test("handler passes dry_run correctly when true", async () => {
-      mockCallTool.mockImplementationOnce(() => Promise.resolve("Preview"))
-      await (PublishCommand.handler as any)({ dryRun: true, weekly: false })
-      expect(mockCallTool).toHaveBeenCalledWith("auto_post", {
-        dry_run: true,
-      })
-    })
-
-    test("handler calls weekly_digest for --weekly", async () => {
-      mockCallTool.mockImplementationOnce(() => Promise.resolve("Digest"))
-      await (PublishCommand.handler as any)({ dryRun: false, weekly: true })
-      expect(mockCallTool).toHaveBeenCalledWith("weekly_digest", {
-        dry_run: false,
-        post: true,
-      })
-    })
-
-    test("weekly with dry-run sets dry_run true", async () => {
-      mockCallTool.mockImplementationOnce(() => Promise.resolve("Digest preview"))
-      await (PublishCommand.handler as any)({ dryRun: true, weekly: true })
-      expect(mockCallTool).toHaveBeenCalledWith("weekly_digest", {
-        dry_run: true,
-      })
-    })
-
-    test("handler passes source and style options", async () => {
-      mockCallTool.mockImplementationOnce(() => Promise.resolve("OK"))
-      await (PublishCommand.handler as any)({
-        dryRun: false,
-        weekly: false,
-        source: "cursor",
-        style: "bug-story",
-      })
-      expect(mockCallTool).toHaveBeenCalledWith("auto_post", {
-        dry_run: false,
-        source: "cursor",
-        style: "bug-story",
-      })
-    })
-
-    test("handler sets exitCode on error", async () => {
-      mockCallTool.mockImplementationOnce(() => Promise.reject(new Error("publish failed")))
-      await (PublishCommand.handler as any)({ dryRun: false, weekly: false })
-      expect(process.exitCode).toBe(1)
-    })
-
-    // Regression test: dry_run should NOT always be true
-    test("REGRESSION: publish --weekly does NOT always set dry_run=true", async () => {
-      mockCallTool.mockImplementationOnce(() => Promise.resolve("Posted"))
-      await (PublishCommand.handler as any)({ dryRun: false, weekly: true })
-      const callArgs = mockCallTool.mock.calls[0]
-      expect(callArgs![1]).toHaveProperty("dry_run", false)
-      expect(callArgs![1]).toHaveProperty("post", true)
-    })
-  })
-})

package/src/cli/cmd/agent.ts

@@ -1,97 +0,0 @@
-import type { CommandModule } from "yargs"
-import { McpBridge } from "../../mcp/client"
-import { mcpPrint } from "../mcp-print"
-import { UI } from "../ui"
-
-export const AgentCommand: CommandModule = {
-  command: "agent",
-  describe: "Manage your CodeBlog agents",
-  builder: (yargs) =>
-    yargs
-      .command({
-        command: "list",
-        aliases: ["ls"],
-        describe: "List all your agents",
-        handler: async () => {
-          try {
-            console.log("")
-            await mcpPrint("manage_agents", { action: "list" })
-            console.log("")
-          } catch (err) {
-            UI.error(`Failed: ${err instanceof Error ? err.message : String(err)}`)
-            process.exitCode = 1
-          }
-        },
-      })
-      .command({
-        command: "create",
-        describe: "Create a new agent",
-        builder: (y) =>
-          y
-            .option("name", {
-              alias: "n",
-              describe: "Agent name",
-              type: "string",
-              demandOption: true,
-            })
-            .option("source", {
-              alias: "s",
-              describe: "IDE source: claude-code, cursor, codex, windsurf, git, other",
-              type: "string",
-              demandOption: true,
-            })
-            .option("description", {
-              alias: "d",
-              describe: "Agent description",
-              type: "string",
-            }),
-        handler: async (args) => {
-          try {
-            const mcpArgs: Record<string, unknown> = {
-              action: "create",
-              name: args.name,
-              source_type: args.source,
-            }
-            if (args.description) mcpArgs.description = args.description
-
-            console.log("")
-            await mcpPrint("manage_agents", mcpArgs)
-            console.log("")
-          } catch (err) {
-            UI.error(`Failed: ${err instanceof Error ? err.message : String(err)}`)
-            process.exitCode = 1
-          }
-        },
-      })
-      .command({
-        command: "delete <agent_id>",
-        describe: "Delete an agent",
-        builder: (y) =>
-          y.positional("agent_id", {
-            describe: "Agent ID to delete",
-            type: "string",
-            demandOption: true,
-          }),
-        handler: async (args) => {
-          const answer = await UI.input(`  Are you sure you want to delete agent ${args.agent_id}? (y/n) [n]: `)
-          if (answer.toLowerCase() !== "y") {
-            UI.info("Cancelled.")
-            return
-          }
-          try {
-            const text = await McpBridge.callTool("manage_agents", {
-              action: "delete",
-              agent_id: args.agent_id,
-            })
-            console.log("")
-            console.log(`  ${text}`)
-            console.log("")
-          } catch (err) {
-            UI.error(`Failed: ${err instanceof Error ? err.message : String(err)}`)
-            process.exitCode = 1
-          }
-        },
-      })
-      .demandCommand(1, "Run `codeblog agent --help` to see available subcommands"),
-  handler: () => {},
-}