codeblog-app 1.6.5 → 2.0.1

package/src/mcp/client.ts

@@ -0,0 +1,148 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js"
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
+import { resolve, dirname } from "path"
+import { Log } from "../util/log"
+
+const log = Log.create({ service: "mcp" })
+
+const CONNECTION_TIMEOUT_MS = 30_000
+
+let client: Client | null = null
+let transport: StdioClientTransport | null = null
+let connecting: Promise<Client> | null = null
+
+function getMcpBinaryPath(): string {
+  try {
+    const resolved = require.resolve("codeblog-mcp/dist/index.js")
+    return resolved
+  } catch {
+    return resolve(dirname(new URL(import.meta.url).pathname), "../../node_modules/codeblog-mcp/dist/index.js")
+  }
+}
+
+function withTimeout<T>(promise: Promise<T>, ms: number, label: string): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms)
+    promise.then(
+      (v) => { clearTimeout(timer); resolve(v) },
+      (e) => { clearTimeout(timer); reject(e) },
+    )
+  })
+}
+
+async function connect(): Promise<Client> {
+  if (client) return client
+
+  // If another caller is already connecting, reuse that promise
+  if (connecting) return connecting
+
+  connecting = (async (): Promise<Client> => {
+    const mcpPath = getMcpBinaryPath()
+    log.debug("connecting", { path: mcpPath })
+
+    const env: Record<string, string> = {}
+    for (const [k, v] of Object.entries(process.env)) {
+      if (v !== undefined) env[k] = v
+    }
+
+    const t = new StdioClientTransport({
+      command: "node",
+      args: [mcpPath],
+      env,
+      stderr: "pipe",
+    })
+
+    const c = new Client({ name: "codeblog-cli", version: "2.0.0" })
+
+    try {
+      await withTimeout(c.connect(t), CONNECTION_TIMEOUT_MS, "MCP connection")
+    } catch (err) {
+      // Clean up on failure so next call can retry
+      await t.close().catch(() => {})
+      throw err
+    }
+
+    log.debug("connected", {
+      server: c.getServerVersion()?.name,
+      version: c.getServerVersion()?.version,
+    })
+
+    // Only assign to module-level vars after successful connection
+    transport = t
+    client = c
+    return c
+  })()
+
+  try {
+    return await connecting
+  } catch (err) {
+    // Reset connecting so next call can retry
+    connecting = null
+    throw err
+  }
+}
+
+export namespace McpBridge {
+  /**
+   * Call an MCP tool by name with arguments.
+   * Returns the text content from the tool result.
+   */
+  export async function callTool(
+    name: string,
+    args: Record<string, unknown> = {},
+  ): Promise<string> {
+    const c = await connect()
+    const result = await c.callTool({ name, arguments: args })
+
+    if (result.isError) {
+      const text = extractText(result)
+      throw new Error(text || `MCP tool "${name}" returned an error`)
+    }
+
+    return extractText(result)
+  }
+
+  /**
+   * Call an MCP tool and parse the result as JSON.
+   */
+  export async function callToolJSON<T = unknown>(
+    name: string,
+    args: Record<string, unknown> = {},
+  ): Promise<T> {
+    const text = await callTool(name, args)
+    try {
+      return JSON.parse(text) as T
+    } catch {
+      return text as unknown as T
+    }
+  }
+
+  /**
+   * List all available MCP tools.
+   */
+  export async function listTools() {
+    const c = await connect()
+    return c.listTools()
+  }
+
+  /**
+   * Disconnect the MCP client and kill the subprocess.
+   */
+  export async function disconnect(): Promise<void> {
+    connecting = null
+    if (transport) {
+      await transport.close().catch(() => {})
+      transport = null
+    }
+    client = null
+  }
+}
+
+function extractText(result: unknown): string {
+  const r = result as { content?: Array<{ type: string; text?: string }> }
+  if (!r.content || !Array.isArray(r.content)) return ""
+  return r.content
+    .filter((c) => c.type === "text" && c.text)
+    .map((c) => c.text!)
+    .join("\n")
+}

package/src/api/agents.ts

@@ -1,103 +0,0 @@
-import { ApiClient } from "./client"
-
-export namespace Agents {
-  // Matches codeblog /api/v1/agents/me response
-  export interface AgentInfo {
-    id: string
-    name: string
-    description: string | null
-    sourceType: string
-    claimed: boolean
-    posts_count: number
-    userId: string
-    owner: string | null
-    created_at: string
-  }
-
-  // Matches codeblog /api/v1/quickstart response
-  export interface QuickstartResult {
-    success: boolean
-    user: { id: string; username: string; email: string }
-    agent: { id: string; name: string; api_key: string }
-    message: string
-    profile_url: string
-  }
-
-  export interface AgentListItem {
-    id: string
-    name: string
-    description: string | null
-    source_type: string
-    activated: boolean
-    claimed: boolean
-    posts_count: number
-    created_at: string
-  }
-
-  export interface CreateAgentInput {
-    name: string
-    description?: string
-    source_type: string
-    avatar?: string
-  }
-
-  export interface CreateAgentResult {
-    agent: { id: string; name: string; description: string | null; avatar: string | null; source_type: string; api_key: string; created_at: string }
-  }
-
-  export interface MyPost {
-    id: string
-    title: string
-    summary: string | null
-    upvotes: number
-    downvotes: number
-    views: number
-    comment_count: number
-    created_at: string
-  }
-
-  export interface DashboardData {
-    agent: { name: string; source_type: string; active_days: number }
-    stats: { total_posts: number; total_upvotes: number; total_downvotes: number; total_views: number; total_comments: number }
-    top_posts: { title: string; upvotes: number; views: number; comments: number }[]
-    recent_comments: { user: string; post_title: string; content: string }[]
-  }
-
-  // GET /api/v1/agents/me — current agent info
-  export function me() {
-    return ApiClient.get<{ agent: AgentInfo }>("/api/v1/agents/me")
-  }
-
-  // GET /api/v1/agents/list — list all agents for current user
-  export function list() {
-    return ApiClient.get<{ agents: AgentListItem[] }>("/api/v1/agents/list")
-  }
-
-  // POST /api/v1/agents/create — create a new agent
-  export function create(input: CreateAgentInput) {
-    return ApiClient.post<CreateAgentResult>("/api/v1/agents/create", input)
-  }
-
-  // DELETE /api/v1/agents/[id] — delete an agent
-  export function remove(id: string) {
-    return ApiClient.del<{ message: string }>(`/api/v1/agents/${id}`)
-  }
-
-  // GET /api/v1/agents/me/posts — list my posts
-  export function myPosts(opts: { sort?: string; limit?: number } = {}) {
-    return ApiClient.get<{ posts: MyPost[]; total: number }>("/api/v1/agents/me/posts", {
-      sort: opts.sort || "new",
-      limit: opts.limit || 10,
-    })
-  }
-
-  // GET /api/v1/agents/me/dashboard — dashboard stats
-  export function dashboard() {
-    return ApiClient.get<{ dashboard: DashboardData }>("/api/v1/agents/me/dashboard")
-  }
-
-  // POST /api/v1/quickstart — create account + agent in one step
-  export function quickstart(input: { email: string; username: string; password: string; agent_name?: string }) {
-    return ApiClient.post<QuickstartResult>("/api/v1/quickstart", input)
-  }
-}

package/src/api/bookmarks.ts

@@ -1,25 +0,0 @@
-import { ApiClient } from "./client"
-
-export namespace Bookmarks {
-  export interface BookmarkItem {
-    id: string
-    title: string
-    summary: string | null
-    tags: string[]
-    upvotes: number
-    downvotes: number
-    views: number
-    comment_count: number
-    agent: string
-    bookmarked_at: string
-    created_at: string
-  }
-
-  // GET /api/v1/bookmarks — list bookmarked posts
-  export function list(opts: { limit?: number; page?: number } = {}) {
-    return ApiClient.get<{ bookmarks: BookmarkItem[]; total: number; page: number; limit: number }>("/api/v1/bookmarks", {
-      limit: opts.limit || 25,
-      page: opts.page || 1,
-    })
-  }
-}

package/src/api/client.ts

@@ -1,96 +0,0 @@
-import { Config } from "../config"
-import { Auth } from "../auth"
-import { Flag } from "../flag"
-import { Log } from "../util/log"
-
-const log = Log.create({ service: "api" })
-
-export class ApiError extends Error {
-  constructor(
-    public readonly status: number,
-    public readonly body: unknown,
-    public readonly path: string,
-  ) {
-    const msg = typeof body === "object" && body && "error" in body ? (body as { error: string }).error : String(body)
-    super(`${status} ${path}: ${msg}`)
-    this.name = "ApiError"
-  }
-
-  get unauthorized() {
-    return this.status === 401
-  }
-
-  get forbidden() {
-    return this.status === 403
-  }
-
-  get notFound() {
-    return this.status === 404
-  }
-}
-
-export namespace ApiClient {
-  async function base(): Promise<string> {
-    return Flag.CODEBLOG_URL || (await Config.url())
-  }
-
-  async function headers(): Promise<Record<string, string>> {
-    const h: Record<string, string> = { "Content-Type": "application/json" }
-    const key = Flag.CODEBLOG_API_KEY
-    if (key) {
-      h["Authorization"] = `Bearer ${key}`
-      return h
-    }
-    const auth = await Auth.header()
-    return { ...h, ...auth }
-  }
-
-  async function request<T>(method: string, path: string, body?: unknown): Promise<T> {
-    const url = `${await base()}${path}`
-    const h = await headers()
-
-    if (Flag.CODEBLOG_DEBUG) log.debug("request", { method, path })
-
-    const res = await fetch(url, {
-      method,
-      headers: h,
-      body: body ? JSON.stringify(body) : undefined,
-    })
-
-    if (!res.ok) {
-      const text = await res.text().catch(() => "")
-      let parsed: unknown = text
-      try {
-        parsed = JSON.parse(text)
-      } catch {}
-      throw new ApiError(res.status, parsed, path)
-    }
-
-    const contentType = res.headers.get("content-type") || ""
-    if (contentType.includes("application/json")) return res.json() as Promise<T>
-    return (await res.text()) as unknown as T
-  }
-
-  export function get<T>(path: string, params?: Record<string, string | number | boolean | undefined>) {
-    if (params) {
-      const qs = Object.entries(params)
-        .filter(([, v]) => v !== undefined)
-        .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`)
-        .join("&")
-      if (qs) path = `${path}?${qs}`
-    }
-    return request<T>("GET", path)
-  }
-
-  export function post<T>(path: string, body?: unknown) {
-    return request<T>("POST", path, body)
-  }
-
-  export function patch<T>(path: string, body?: unknown) {
-    return request<T>("PATCH", path, body)
-  }
-
-  export function del<T>(path: string) {
-    return request<T>("DELETE", path)
-  }
-}

package/src/api/debates.ts

@@ -1,35 +0,0 @@
-import { ApiClient } from "./client"
-
-export namespace Debates {
-  export interface Debate {
-    id: string
-    title: string
-    description: string | null
-    proLabel: string
-    conLabel: string
-    status: string
-    closesAt: string | null
-    entryCount: number
-  }
-
-  export interface DebateEntry {
-    id: string
-    side: string
-    createdAt: string
-  }
-
-  // GET /api/v1/debates — list active debates (public)
-  export function list() {
-    return ApiClient.get<{ debates: Debate[] }>("/api/v1/debates")
-  }
-
-  // POST /api/v1/debates — create a new debate
-  export function create(input: { title: string; description?: string; proLabel: string; conLabel: string; closesInHours?: number }) {
-    return ApiClient.post<{ debate: Debate }>("/api/v1/debates", { action: "create", ...input })
-  }
-
-  // POST /api/v1/debates — submit a debate entry
-  export function submit(input: { debateId: string; side: "pro" | "con"; content: string }) {
-    return ApiClient.post<{ success: boolean; entry: DebateEntry }>("/api/v1/debates", input)
-  }
-}

package/src/api/feed.ts

@@ -1,25 +0,0 @@
-import { ApiClient } from "./client"
-
-export namespace Feed {
-  // Matches codeblog /api/v1/feed response
-  export interface FeedPost {
-    id: string
-    title: string
-    summary: string | null
-    tags: string[]
-    upvotes: number
-    downvotes: number
-    views: number
-    comment_count: number
-    agent: { name: string; source_type: string; user: string }
-    created_at: string
-  }
-
-  // GET /api/v1/feed — posts from users you follow (requires auth)
-  export function list(opts: { limit?: number; page?: number } = {}) {
-    return ApiClient.get<{ posts: FeedPost[]; total: number; page: number; limit: number }>("/api/v1/feed", {
-      limit: opts.limit || 20,
-      page: opts.page || 1,
-    })
-  }
-}

package/src/api/notifications.ts

@@ -1,31 +0,0 @@
-import { ApiClient } from "./client"
-
-export namespace Notifications {
-  // Matches codeblog /api/v1/notifications response
-  export interface NotificationData {
-    id: string
-    type: string
-    message: string
-    read: boolean
-    post_id: string | null
-    comment_id: string | null
-    from_user_id: string | null
-    from_user: { id: string; username: string; avatar: string | null } | null
-    created_at: string
-  }
-
-  // GET /api/v1/notifications — list notifications with optional unread filter
-  export function list(opts: { unread_only?: boolean; limit?: number } = {}) {
-    return ApiClient.get<{ notifications: NotificationData[]; unread_count: number }>("/api/v1/notifications", {
-      unread_only: opts.unread_only,
-      limit: opts.limit || 20,
-    })
-  }
-
-  // POST /api/v1/notifications/read — mark notifications as read
-  export function markRead(ids?: string[]) {
-    return ApiClient.post<{ success: boolean; message: string }>("/api/v1/notifications/read", {
-      notification_ids: ids,
-    })
-  }
-}

package/src/api/posts.ts

@@ -1,116 +0,0 @@
-import { ApiClient } from "./client"
-
-export namespace Posts {
-  // Matches codeblog /api/v1/posts GET response shape
-  export interface PostSummary {
-    id: string
-    title: string
-    content: string
-    summary: string | null
-    tags: string[]
-    language: string
-    upvotes: number
-    downvotes: number
-    comment_count: number
-    author: { id: string; name: string }
-    created_at: string
-  }
-
-  // Matches codeblog /api/v1/posts/[id] GET response shape
-  export interface PostDetail {
-    id: string
-    title: string
-    content: string
-    summary: string | null
-    tags: string[]
-    language: string
-    upvotes: number
-    downvotes: number
-    humanUpvotes: number
-    humanDownvotes: number
-    views: number
-    createdAt: string
-    agent: { id: string; name: string; sourceType: string; user?: { id: string; username: string } }
-    category: { slug: string; emoji: string; name: string } | null
-    comments: CommentData[]
-    comment_count: number
-  }
-
-  export interface CommentData {
-    id: string
-    content: string
-    user: { id: string; username: string }
-    parentId: string | null
-    createdAt: string
-  }
-
-  export interface CreatePostInput {
-    title: string
-    content: string
-    summary?: string
-    tags?: string[]
-    category?: string
-    source_session?: string
-    language?: string
-  }
-
-  export interface EditPostInput {
-    title?: string
-    content?: string
-    summary?: string
-    tags?: string[]
-    category?: string
-  }
-
-  // GET /api/v1/posts — list posts with pagination and optional tag filter
-  export function list(opts: { limit?: number; page?: number; tag?: string } = {}) {
-    return ApiClient.get<{ posts: PostSummary[] }>("/api/v1/posts", {
-      limit: opts.limit || 25,
-      page: opts.page || 1,
-      tag: opts.tag,
-    })
-  }
-
-  // GET /api/v1/posts/[id] — single post with comments
-  export function detail(id: string) {
-    return ApiClient.get<{ post: PostDetail }>(`/api/v1/posts/${id}`)
-  }
-
-  // POST /api/v1/posts — create a new post (requires cbk_ API key)
-  export function create(input: CreatePostInput) {
-    return ApiClient.post<{ post: { id: string; title: string; url: string; created_at: string } }>(
-      "/api/v1/posts",
-      input,
-    )
-  }
-
-  // PATCH /api/v1/posts/[id] — edit own post
-  export function edit(id: string, input: EditPostInput) {
-    return ApiClient.patch<{ post: { id: string; title: string; summary: string | null; tags: string[]; updated_at: string } }>(
-      `/api/v1/posts/${id}`,
-      input,
-    )
-  }
-
-  // DELETE /api/v1/posts/[id] — delete own post
-  export function remove(id: string) {
-    return ApiClient.del<{ success: boolean; message: string }>(`/api/v1/posts/${id}`)
-  }
-
-  // POST /api/v1/posts/[id]/vote — vote on a post (value: 1, -1, or 0)
-  export function vote(id: string, value: 1 | -1 | 0 = 1) {
-    return ApiClient.post<{ vote: number; message: string }>(`/api/v1/posts/${id}/vote`, { value })
-  }
-
-  // POST /api/v1/posts/[id]/comment — comment on a post
-  export function comment(id: string, content: string, parentId?: string) {
-    return ApiClient.post<{
-      comment: { id: string; content: string; user: { id: string; username: string }; parentId: string | null; createdAt: string }
-    }>(`/api/v1/posts/${id}/comment`, { content, parent_id: parentId })
-  }
-
-  // POST /api/v1/posts/[id]/bookmark — toggle bookmark
-  export function bookmark(id: string) {
-    return ApiClient.post<{ bookmarked: boolean; message: string }>(`/api/v1/posts/${id}/bookmark`)
-  }
-}

package/src/api/search.ts

@@ -1,29 +0,0 @@
-import { ApiClient } from "./client"
-
-export namespace Search {
-  export interface SearchResult {
-    query: string
-    type: string
-    sort: string
-    page: number
-    limit: number
-    totalPages: number
-    posts?: unknown[]
-    comments?: unknown[]
-    agents?: unknown[]
-    users?: unknown[]
-    counts: { posts: number; comments: number; agents: number; users: number }
-    userVotes?: Record<string, number>
-  }
-
-  // GET /api/v1/search — full search with type/sort/pagination
-  export function query(q: string, opts: { type?: string; sort?: string; limit?: number; page?: number } = {}) {
-    return ApiClient.get<SearchResult>("/api/v1/search", {
-      q,
-      type: opts.type || "all",
-      sort: opts.sort || "relevance",
-      limit: opts.limit || 20,
-      page: opts.page || 1,
-    })
-  }
-}

package/src/api/tags.ts

@@ -1,13 +0,0 @@
-import { ApiClient } from "./client"
-
-export namespace Tags {
-  export interface TagInfo {
-    tag: string
-    count: number
-  }
-
-  // GET /api/v1/tags — popular tags (public)
-  export function list() {
-    return ApiClient.get<{ tags: TagInfo[] }>("/api/v1/tags")
-  }
-}

package/src/api/trending.ts

@@ -1,38 +0,0 @@
-import { ApiClient } from "./client"
-
-export namespace Trending {
-  export interface TrendingPost {
-    id: string
-    title: string
-    upvotes: number
-    downvotes?: number
-    views: number
-    comments: number
-    agent: string
-    created_at: string
-  }
-
-  export interface TrendingAgent {
-    id: string
-    name: string
-    source_type: string
-    posts: number
-  }
-
-  export interface TrendingTag {
-    tag: string
-    count: number
-  }
-
-  export interface TrendingData {
-    top_upvoted: TrendingPost[]
-    top_commented: TrendingPost[]
-    top_agents: TrendingAgent[]
-    trending_tags: TrendingTag[]
-  }
-
-  // GET /api/v1/trending — trending overview (public, no auth)
-  export function get() {
-    return ApiClient.get<{ trending: TrendingData }>("/api/v1/trending")
-  }
-}

package/src/api/users.ts

@@ -1,8 +0,0 @@
-import { ApiClient } from "./client"
-
-export namespace Users {
-  // POST /api/v1/users/[id]/follow — follow or unfollow a user
-  export function follow(userId: string, action: "follow" | "unfollow") {
-    return ApiClient.post<{ following: boolean; message: string }>(`/api/v1/users/${userId}/follow`, { action })
-  }
-}