codeblog-app 2.0.0 → 2.0.2

package/src/mcp/__tests__/integration.ts

@@ -1,148 +0,0 @@
-/**
- * Integration test: verify all 26 MCP tools are accessible via McpBridge.
- *
- * This script:
- * 1. Connects to the MCP server (spawns codeblog-mcp subprocess)
- * 2. Lists all available tools
- * 3. Tests calling each tool that can be safely invoked without side effects
- * 4. Reports results
- *
- * Usage: bun run src/mcp/__tests__/integration.ts
- */
-
-import { McpBridge } from "../client"
-
-const EXPECTED_TOOLS = [
-  "scan_sessions",
-  "read_session",
-  "analyze_session",
-  "post_to_codeblog",
-  "auto_post",
-  "weekly_digest",
-  "browse_posts",
-  "search_posts",
-  "read_post",
-  "comment_on_post",
-  "vote_on_post",
-  "edit_post",
-  "delete_post",
-  "bookmark_post",
-  "browse_by_tag",
-  "trending_topics",
-  "explore_and_engage",
-  "join_debate",
-  "my_notifications",
-  "manage_agents",
-  "my_posts",
-  "my_dashboard",
-  "follow_agent",
-  "codeblog_status",
-  "codeblog_setup",
-]
-
-// Tools that are safe to call without side effects (read-only)
-const SAFE_TOOLS: Record<string, Record<string, unknown>> = {
-  codeblog_status: {},
-  scan_sessions: { limit: 3 },
-  browse_posts: { sort: "new", limit: 2 },
-  search_posts: { query: "test", limit: 2 },
-  browse_by_tag: { action: "trending", limit: 3 },
-  trending_topics: {},
-  explore_and_engage: { action: "browse", limit: 2 },
-  join_debate: { action: "list" },
-  my_notifications: { action: "list", limit: 2 },
-  manage_agents: { action: "list" },
-  my_posts: { limit: 2 },
-  my_dashboard: {},
-  follow_agent: { action: "list_following", limit: 2 },
-  bookmark_post: { action: "list" },
-}
-
-async function main() {
-  console.log("=== MCP Integration Test ===\n")
-
-  // Step 1: List tools
-  console.log("1. Listing MCP tools...")
-  let tools: Array<{ name: string; description?: string }>
-  try {
-    const result = await McpBridge.listTools()
-    tools = result.tools
-    console.log(`   ✓ Found ${tools.length} tools\n`)
-  } catch (err) {
-    console.error(`   ✗ Failed to list tools: ${err instanceof Error ? err.message : err}`)
-    await McpBridge.disconnect()
-    process.exit(1)
-    return
-  }
-
-  // Step 2: Check expected tools
-  console.log("2. Checking expected tools...")
-  const toolNames = tools.map((t) => t.name)
-  let missing = 0
-  for (const expected of EXPECTED_TOOLS) {
-    if (toolNames.includes(expected)) {
-      console.log(`   ✓ ${expected}`)
-    } else {
-      console.log(`   ✗ MISSING: ${expected}`)
-      missing++
-    }
-  }
-
-  const extra = toolNames.filter((t) => !EXPECTED_TOOLS.includes(t))
-  if (extra.length > 0) {
-    console.log(`\n   Extra tools not in expected list: ${extra.join(", ")}`)
-  }
-  console.log(`\n   Expected: ${EXPECTED_TOOLS.length}, Found: ${toolNames.length}, Missing: ${missing}\n`)
-
-  // Step 3: Call safe tools
-  console.log("3. Testing safe tool calls...")
-  let passed = 0
-  let failed = 0
-
-  for (const [name, args] of Object.entries(SAFE_TOOLS)) {
-    if (!toolNames.includes(name)) {
-      console.log(`   ⊘ ${name} — skipped (not available)`)
-      continue
-    }
-
-    try {
-      const result = await McpBridge.callTool(name, args)
-      const preview = result.slice(0, 80).replace(/\n/g, " ")
-      console.log(`   ✓ ${name} — ${preview}${result.length > 80 ? "..." : ""}`)
-      passed++
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err)
-      // Auth errors are expected in test environment
-      if (msg.includes("auth") || msg.includes("API key") || msg.includes("token") || msg.includes("401") || msg.includes("unauthorized") || msg.includes("Unauthorized")) {
-        console.log(`   ⊘ ${name} — auth required (expected in test env)`)
-        passed++ // Count as pass — tool is reachable, just needs auth
-      } else {
-        console.log(`   ✗ ${name} — ${msg}`)
-        failed++
-      }
-    }
-  }
-
-  console.log(`\n   Passed: ${passed}, Failed: ${failed}\n`)
-
-  // Cleanup
-  console.log("4. Disconnecting...")
-  await McpBridge.disconnect()
-  console.log("   ✓ Disconnected\n")
-
-  console.log("=== Summary ===")
-  console.log(`Tools found: ${toolNames.length}`)
-  console.log(`Tools tested: ${passed + failed}/${Object.keys(SAFE_TOOLS).length}`)
-  console.log(`Tests passed: ${passed}`)
-  console.log(`Tests failed: ${failed}`)
-  console.log(`Missing expected tools: ${missing}`)
-
-  if (failed > 0 || missing > 0) {
-    process.exit(1)
-  }
-}
-
-main().catch((err) => {
-  console.error("Fatal error:", err)
-  process.exit(1)
-})

package/src/mcp/client.ts

@@ -1,148 +0,0 @@
-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/server/index.ts

@@ -1,48 +0,0 @@
-import { Hono } from "hono"
-import { Log } from "../util/log"
-
-const log = Log.create({ service: "server" })
-
-export namespace Server {
-  let instance: ReturnType<typeof Bun.serve> | null = null
-
-  export function start(app: Hono, port: number): ReturnType<typeof Bun.serve> {
-    if (instance) {
-      log.warn("server already running, stopping previous instance")
-      instance.stop()
-    }
-    instance = Bun.serve({ port, fetch: app.fetch })
-    log.info("server started", { port })
-    return instance
-  }
-
-  export function stop() {
-    if (instance) {
-      instance.stop()
-      instance = null
-      log.info("server stopped")
-    }
-  }
-
-  export function running(): boolean {
-    return instance !== null
-  }
-
-  export function createCallbackServer(onCallback: (params: URLSearchParams) => Promise<string>): {
-    app: Hono
-    port: number
-  } {
-    const port = 19823
-    const app = new Hono()
-
-    app.get("/callback", async (c) => {
-      const params = new URL(c.req.url).searchParams
-      const html = await onCallback(params)
-      return c.html(html)
-    })
-
-    app.get("/health", (c) => c.json({ ok: true }))
-
-    return { app, port }
-  }
-}

package/src/storage/chat.ts

@@ -1,92 +0,0 @@
-import { Database as BunDatabase } from "bun:sqlite"
-import { Global } from "../global"
-import path from "path"
-
-function db() {
-  const dbpath = path.join(Global.Path.data, "codeblog.db")
-  const sqlite = new BunDatabase(dbpath, { create: true })
-  sqlite.run("PRAGMA journal_mode = WAL")
-  sqlite.run("PRAGMA foreign_keys = ON")
-
-  sqlite.run(`CREATE TABLE IF NOT EXISTS chat_sessions (
-    id TEXT PRIMARY KEY,
-    title TEXT,
-    time_created INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
-    time_updated INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
-  )`)
-
-  sqlite.run(`CREATE TABLE IF NOT EXISTS chat_messages (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    session_id TEXT NOT NULL,
-    role TEXT NOT NULL,
-    content TEXT NOT NULL,
-    tool_name TEXT,
-    tool_status TEXT,
-    time_created INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
-  )`)
-
-  return sqlite
-}
-
-export interface ChatMsg {
-  role: "user" | "assistant" | "tool"
-  content: string
-  toolName?: string
-  toolStatus?: "running" | "done" | "error"
-}
-
-export namespace ChatHistory {
-  export function create(id: string, title?: string) {
-    const d = db()
-    d.run("INSERT OR REPLACE INTO chat_sessions (id, title, time_created, time_updated) VALUES (?, ?, ?, ?)", [id, title || null, Date.now(), Date.now()])
-    d.close()
-  }
-
-  export function save(sessionId: string, messages: ChatMsg[]) {
-    const d = db()
-    d.run("DELETE FROM chat_messages WHERE session_id = ?", [sessionId])
-    const stmt = d.prepare("INSERT INTO chat_messages (session_id, role, content, tool_name, tool_status, time_created) VALUES (?, ?, ?, ?, ?, ?)")
-    for (const m of messages) {
-      stmt.run(sessionId, m.role, m.content, m.toolName || null, m.toolStatus || null, Date.now())
-    }
-    // Update session title from first user message
-    const first = messages.find((m) => m.role === "user")
-    if (first) {
-      const title = first.content.slice(0, 80)
-      d.run("UPDATE chat_sessions SET title = ?, time_updated = ? WHERE id = ?", [title, Date.now(), sessionId])
-    }
-    d.close()
-  }
-
-  export function load(sessionId: string): ChatMsg[] {
-    const d = db()
-    const rows = d.query("SELECT role, content, tool_name, tool_status FROM chat_messages WHERE session_id = ? ORDER BY id ASC").all(sessionId) as any[]
-    d.close()
-    return rows.map((r) => ({
-      role: r.role,
-      content: r.content,
-      ...(r.tool_name ? { toolName: r.tool_name } : {}),
-      ...(r.tool_status ? { toolStatus: r.tool_status } : {}),
-    }))
-  }
-
-  export function list(limit = 20): Array<{ id: string; title: string | null; time: number; count: number }> {
-    const d = db()
-    const rows = d.query(`
-      SELECT s.id, s.title, s.time_updated as time,
-        (SELECT COUNT(*) FROM chat_messages WHERE session_id = s.id) as count
-      FROM chat_sessions s
-      ORDER BY s.time_updated DESC
-      LIMIT ?
-    `).all(limit) as any[]
-    d.close()
-    return rows.map((r) => ({ id: r.id, title: r.title, time: r.time, count: r.count }))
-  }
-
-  export function remove(sessionId: string) {
-    const d = db()
-    d.run("DELETE FROM chat_messages WHERE session_id = ?", [sessionId])
-    d.run("DELETE FROM chat_sessions WHERE id = ?", [sessionId])
-    d.close()
-  }
-}

package/src/storage/db.ts

@@ -1,85 +0,0 @@
-import { Database as BunDatabase } from "bun:sqlite"
-import { drizzle } from "drizzle-orm/bun-sqlite"
-import { Context } from "../util/context"
-import { lazy } from "../util/lazy"
-import { Global } from "../global"
-import { Log } from "../util/log"
-import path from "path"
-import * as schema from "./schema"
-
-const log = Log.create({ service: "db" })
-
-export namespace Database {
-  type Schema = typeof schema
-
-  export const Client = lazy(() => {
-    const dbpath = path.join(Global.Path.data, "codeblog.db")
-    log.info("opening database", { path: dbpath })
-
-    const sqlite = new BunDatabase(dbpath, { create: true })
-
-    sqlite.run("PRAGMA journal_mode = WAL")
-    sqlite.run("PRAGMA synchronous = NORMAL")
-    sqlite.run("PRAGMA busy_timeout = 5000")
-    sqlite.run("PRAGMA cache_size = -64000")
-    sqlite.run("PRAGMA foreign_keys = ON")
-
-    // Auto-create tables
-    sqlite.run(`CREATE TABLE IF NOT EXISTS published_sessions (
-      id TEXT PRIMARY KEY,
-      session_id TEXT NOT NULL,
-      source TEXT NOT NULL,
-      post_id TEXT,
-      file_path TEXT NOT NULL,
-      time_created INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
-      time_updated INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
-    )`)
-
-    sqlite.run(`CREATE TABLE IF NOT EXISTS cached_posts (
-      id TEXT PRIMARY KEY,
-      title TEXT NOT NULL,
-      content TEXT NOT NULL,
-      author_name TEXT,
-      votes INTEGER DEFAULT 0,
-      comments_count INTEGER DEFAULT 0,
-      tags TEXT,
-      time_created INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
-      time_updated INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
-    )`)
-
-    sqlite.run(`CREATE TABLE IF NOT EXISTS chat_sessions (
-      id TEXT PRIMARY KEY,
-      title TEXT,
-      time_created INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
-      time_updated INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
-    )`)
-
-    sqlite.run(`CREATE TABLE IF NOT EXISTS chat_messages (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      session_id TEXT NOT NULL REFERENCES chat_sessions(id) ON DELETE CASCADE,
-      role TEXT NOT NULL,
-      content TEXT NOT NULL,
-      tool_name TEXT,
-      tool_status TEXT,
-      time_created INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
-    )`)
-
-    sqlite.run(`CREATE TABLE IF NOT EXISTS notifications_cache (
-      id TEXT PRIMARY KEY,
-      type TEXT NOT NULL,
-      message TEXT NOT NULL,
-      read INTEGER DEFAULT 0,
-      post_id TEXT,
-      time_created INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
-      time_updated INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
-    )`)
-
-    return drizzle({ client: sqlite, schema })
-  })
-
-  const ctx = Context.create<{ tx: any; effects: (() => void | Promise<void>)[] }>("database")
-
-  export function use<T>(callback: (db: ReturnType<typeof Client>) => T): T {
-    return callback(Client())
-  }
-}

package/src/storage/schema.sql.ts

@@ -1,39 +0,0 @@
-import { integer, text, sqliteTable } from "drizzle-orm/sqlite-core"
-
-export const Timestamps = {
-  time_created: integer()
-    .notNull()
-    .$default(() => Date.now()),
-  time_updated: integer()
-    .notNull()
-    .$onUpdate(() => Date.now()),
-}
-
-export const published_sessions = sqliteTable("published_sessions", {
-  id: text().primaryKey(),
-  session_id: text().notNull(),
-  source: text().notNull(),
-  post_id: text(),
-  file_path: text().notNull(),
-  ...Timestamps,
-})
-
-export const cached_posts = sqliteTable("cached_posts", {
-  id: text().primaryKey(),
-  title: text().notNull(),
-  content: text().notNull(),
-  author_name: text(),
-  votes: integer().default(0),
-  comments_count: integer().default(0),
-  tags: text(),
-  ...Timestamps,
-})
-
-export const notifications_cache = sqliteTable("notifications_cache", {
-  id: text().primaryKey(),
-  type: text().notNull(),
-  message: text().notNull(),
-  read: integer().default(0),
-  post_id: text(),
-  ...Timestamps,
-})

package/src/storage/schema.ts

@@ -1 +0,0 @@
-export { published_sessions, cached_posts, notifications_cache } from "./schema.sql"