codeblog-app 2.3.2 → 2.3.3

package/src/mcp/__tests__/integration.ts

@@ -0,0 +1,148 @@
+/**
+ * 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

@@ -0,0 +1,118 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js"
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js"
+import { createServer } from "codeblog-mcp"
+import { Log } from "../util/log"
+
+const log = Log.create({ service: "mcp" })
+
+let client: Client | null = null
+let clientTransport: InstanceType<typeof InMemoryTransport> | null = null
+let connecting: Promise<Client> | null = null
+
+async function connect(): Promise<Client> {
+  if (client) return client
+  if (connecting) return connecting
+
+  connecting = (async (): Promise<Client> => {
+    log.info("connecting via InMemoryTransport")
+
+    const server = createServer()
+    const [ct, serverTransport] = InMemoryTransport.createLinkedPair()
+
+    const c = new Client({ name: "codeblog-cli", version: "2.0.0" })
+
+    c.onclose = () => {
+      log.warn("mcp-connection-closed")
+      client = null
+      clientTransport = null
+    }
+
+    try {
+      await server.connect(serverTransport)
+      await c.connect(ct)
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err)
+      log.error("mcp-connect-failed", { error: errMsg })
+      await ct.close().catch(() => {})
+      throw err
+    }
+
+    log.info("connected", {
+      server: c.getServerVersion()?.name,
+      version: c.getServerVersion()?.version,
+    })
+
+    clientTransport = ct
+    client = c
+    return c
+  })()
+
+  try {
+    return await connecting
+  } catch (err) {
+    connecting = null
+    throw err
+  }
+}
+
+export namespace McpBridge {
+  export async function callTool(
+    name: string,
+    args: Record<string, unknown> = {},
+  ): Promise<string> {
+    const c = await connect()
+    let result
+    try {
+      result = await c.callTool({ name, arguments: args })
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err)
+      const errCode = (err as any)?.code
+      log.error("mcp-tool-call-failed", { tool: name, error: errMsg, code: errCode })
+      throw err
+    }
+
+    if (result.isError) {
+      const text = extractText(result)
+      log.error("mcp-tool-returned-error", { tool: name, error: text })
+      throw new Error(text || `MCP tool "${name}" returned an error`)
+    }
+
+    return extractText(result)
+  }
+
+  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
+    }
+  }
+
+  export async function listTools() {
+    const c = await connect()
+    return c.listTools()
+  }
+
+  export async function disconnect(): Promise<void> {
+    log.info("disconnecting", { hadClient: !!client })
+    connecting = null
+    if (clientTransport) {
+      await clientTransport.close().catch(() => {})
+      clientTransport = 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

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

@@ -0,0 +1,73 @@
+import { Database } from "./db"
+
+export interface ChatMsg {
+  role: "user" | "assistant" | "tool" | "system"
+  content: string
+  modelContent?: string
+  tone?: "info" | "success" | "warning" | "error"
+  toolName?: string
+  toolStatus?: "running" | "done" | "error"
+}
+
+function raw() {
+  // Access the underlying bun:sqlite instance from Drizzle
+  // Tables are already created in db.ts via CREATE TABLE IF NOT EXISTS
+  return (Database.Client() as any).$client as import("bun:sqlite").Database
+}
+
+export namespace ChatHistory {
+  export function create(id: string, title?: string) {
+    raw().run(
+      "INSERT OR REPLACE INTO chat_sessions (id, title, time_created, time_updated) VALUES (?, ?, ?, ?)",
+      [id, title || null, Date.now(), Date.now()],
+    )
+  }
+
+  export function save(sessionId: string, messages: ChatMsg[]) {
+    const d = raw()
+    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])
+    }
+  }
+
+  export function load(sessionId: string): ChatMsg[] {
+    const rows = raw()
+      .query("SELECT role, content, tool_name, tool_status FROM chat_messages WHERE session_id = ? ORDER BY id ASC")
+      .all(sessionId) as any[]
+    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 rows = raw()
+      .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[]
+    return rows.map((r) => ({ id: r.id, title: r.title, time: r.time, count: r.count }))
+  }
+
+  export function remove(sessionId: string) {
+    const d = raw()
+    d.run("DELETE FROM chat_messages WHERE session_id = ?", [sessionId])
+    d.run("DELETE FROM chat_sessions WHERE id = ?", [sessionId])
+  }
+}

package/src/storage/db.ts

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

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

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

package/src/tui/__tests__/input-intent.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, test } from "bun:test"
+import { isShiftEnterSequence } from "../input-intent"
+
+describe("input intent", () => {
+  test("detects kitty csi-u shift+enter sequences", () => {
+    expect(isShiftEnterSequence("\x1b[13;2u")).toBe(true)
+    expect(isShiftEnterSequence("\x1b[57345;2u")).toBe(true)
+    expect(isShiftEnterSequence("\x1b[13;2:1u")).toBe(true)
+  })
+
+  test("detects modifyOtherKeys-style shift+enter sequences", () => {
+    expect(isShiftEnterSequence("\x1b[27;2;13~")).toBe(true)
+    expect(isShiftEnterSequence("\x1b[13;2~")).toBe(true)
+  })
+
+  test("detects shift+enter sequences with trailing newline bytes", () => {
+    expect(isShiftEnterSequence("\x1b[13;2u\r")).toBe(true)
+    expect(isShiftEnterSequence("\x1b[27;2;13~\n")).toBe(true)
+  })
+
+  test("does not match plain enter sequences", () => {
+    expect(isShiftEnterSequence("\r")).toBe(false)
+    expect(isShiftEnterSequence("\n")).toBe(false)
+    expect(isShiftEnterSequence("\x1b[13u")).toBe(false)
+    expect(isShiftEnterSequence("")).toBe(false)
+  })
+})

package/src/tui/__tests__/stream-assembler.test.ts

@@ -0,0 +1,33 @@
+import { describe, test, expect } from "bun:test"
+import { TuiStreamAssembler } from "../stream-assembler"
+
+describe("TuiStreamAssembler", () => {
+  test("delta -> final does not lose text", () => {
+    const a = new TuiStreamAssembler()
+    a.pushDelta("Hello ")
+    a.pushDelta("World")
+    const final = a.pushFinal("Hello World!")
+    expect(final).toBe("Hello World!")
+  })
+
+  test("empty final keeps streamed text", () => {
+    const a = new TuiStreamAssembler()
+    a.pushDelta("Streaming content")
+    const final = a.pushFinal("")
+    expect(final).toBe("Streaming content")
+  })
+
+  test("out-of-order delta is ignored", () => {
+    const a = new TuiStreamAssembler()
+    a.pushDelta("abc", 2)
+    a.pushDelta("x", 1)
+    expect(a.getText()).toBe("abc")
+  })
+
+  test("repeated delta text is preserved", () => {
+    const a = new TuiStreamAssembler()
+    a.pushDelta("ha", 1)
+    a.pushDelta("ha", 2)
+    expect(a.getText()).toBe("haha")
+  })
+})

package/src/tui/ai-stream.ts

@@ -0,0 +1,28 @@
+export interface ToolResultItem {
+  name: string
+  result: string
+}
+
+export function formatToolResultSummary(results: ToolResultItem[]): string {
+  return `Tool execution completed:\n${results.map((t) => `- ${t.name}: ${t.result}`).join("\n")}`
+}
+
+export function resolveAssistantContent(args: {
+  finalText: string
+  aborted: boolean
+  abortByUser: boolean
+  hasToolCalls: boolean
+  toolResults: ToolResultItem[]
+}): string | undefined {
+  if (args.finalText) {
+    if (args.aborted && args.abortByUser) return `${args.finalText}\n\n(interrupted)`
+    return args.finalText
+  }
+  if (args.hasToolCalls && args.toolResults.length > 0) {
+    return formatToolResultSummary(args.toolResults)
+  }
+  if (args.aborted && args.abortByUser) {
+    return "(interrupted)"
+  }
+  return undefined
+}