codeblog-app 2.1.1 → 2.1.3

package/src/mcp/__tests__/client.test.ts

@@ -0,0 +1,149 @@
+import { describe, test, expect, mock, beforeEach, afterEach } from "bun:test"
+
+// ---------------------------------------------------------------------------
+// We test the McpBridge module by mocking the MCP SDK classes.
+// The actual module spawns a subprocess, which we don't want in unit tests.
+// ---------------------------------------------------------------------------
+
+// Mock the MCP SDK
+const mockCallTool = mock(() =>
+  Promise.resolve({
+    content: [{ type: "text", text: '{"ok":true}' }],
+    isError: false,
+  }),
+)
+const mockListTools = mock(() =>
+  Promise.resolve({ tools: [{ name: "test_tool", description: "A test tool" }] }),
+)
+const mockConnect = mock(() => Promise.resolve())
+const mockGetServerVersion = mock(() => ({ name: "test-server", version: "1.0.0" }))
+const mockClose = mock(() => Promise.resolve())
+
+mock.module("@modelcontextprotocol/sdk/client/index.js", () => ({
+  Client: class MockClient {
+    callTool = mockCallTool
+    listTools = mockListTools
+    connect = mockConnect
+    getServerVersion = mockGetServerVersion
+  },
+}))
+
+mock.module("@modelcontextprotocol/sdk/client/stdio.js", () => ({
+  StdioClientTransport: class MockTransport {
+    close = mockClose
+  },
+}))
+
+// Must import AFTER mocks are set up
+const { McpBridge } = await import("../client")
+
+describe("McpBridge", () => {
+  afterEach(async () => {
+    await McpBridge.disconnect()
+    mockCallTool.mockClear()
+    mockListTools.mockClear()
+    mockConnect.mockClear()
+    mockClose.mockClear()
+  })
+
+  test("callTool returns text content from MCP result", async () => {
+    const result = await McpBridge.callTool("test_tool", { key: "value" })
+    expect(result).toBe('{"ok":true}')
+    expect(mockCallTool).toHaveBeenCalledWith({
+      name: "test_tool",
+      arguments: { key: "value" },
+    })
+  })
+
+  test("callToolJSON parses JSON result", async () => {
+    const result = await McpBridge.callToolJSON("test_tool")
+    expect(result).toEqual({ ok: true })
+  })
+
+  test("callToolJSON falls back to raw text when JSON parse fails", async () => {
+    mockCallTool.mockImplementationOnce(() =>
+      Promise.resolve({
+        content: [{ type: "text", text: "not json" }],
+        isError: false,
+      }),
+    )
+    const result = await McpBridge.callToolJSON("test_tool")
+    expect(result).toBe("not json")
+  })
+
+  test("callTool throws on error result", async () => {
+    mockCallTool.mockImplementationOnce(() =>
+      Promise.resolve({
+        content: [{ type: "text", text: "Something went wrong" }],
+        isError: true,
+      }),
+    )
+    expect(McpBridge.callTool("failing_tool")).rejects.toThrow("Something went wrong")
+  })
+
+  test("callTool throws generic message when error has no text", async () => {
+    mockCallTool.mockImplementationOnce(() =>
+      Promise.resolve({
+        content: [],
+        isError: true,
+      }),
+    )
+    expect(McpBridge.callTool("failing_tool")).rejects.toThrow('MCP tool "failing_tool" returned an error')
+  })
+
+  test("callTool handles empty content array", async () => {
+    mockCallTool.mockImplementationOnce(() =>
+      Promise.resolve({
+        content: [],
+        isError: false,
+      }),
+    )
+    const result = await McpBridge.callTool("test_tool")
+    expect(result).toBe("")
+  })
+
+  test("callTool joins multiple text content items", async () => {
+    mockCallTool.mockImplementationOnce(() =>
+      Promise.resolve({
+        content: [
+          { type: "text", text: "line1" },
+          { type: "text", text: "line2" },
+          { type: "image", data: "..." },
+        ],
+        isError: false,
+      }),
+    )
+    const result = await McpBridge.callTool("test_tool")
+    expect(result).toBe("line1\nline2")
+  })
+
+  test("listTools delegates to MCP client", async () => {
+    const result = await McpBridge.listTools()
+    expect(result.tools).toHaveLength(1)
+    expect(result.tools[0].name).toBe("test_tool")
+  })
+
+  test("disconnect cleans up transport and client", async () => {
+    // First connect by making a call
+    await McpBridge.callTool("test_tool")
+    // Then disconnect
+    await McpBridge.disconnect()
+    // Verify close was called
+    expect(mockClose).toHaveBeenCalled()
+  })
+
+  test("connection is reused across multiple calls", async () => {
+    await McpBridge.callTool("test_tool")
+    await McpBridge.callTool("test_tool")
+    // connect should only be called once
+    expect(mockConnect).toHaveBeenCalledTimes(1)
+  })
+
+  test("default args is empty object", async () => {
+    await McpBridge.callTool("test_tool")
+    expect(mockCallTool).toHaveBeenCalledWith({
+      name: "test_tool",
+      arguments: {},
+    })
+  })
+})

package/src/mcp/__tests__/e2e.ts

@@ -0,0 +1,327 @@
+/**
+ * Full E2E test: test ALL MCP tools as a real user would.
+ * This script walks through the entire user journey:
+ *
+ * 1. Status check
+ * 2. Scan IDE sessions
+ * 3. Read a session
+ * 4. Analyze a session
+ * 5. Post to CodeBlog
+ * 6. Browse posts
+ * 7. Search posts
+ * 8. Read a specific post
+ * 9. Upvote a post
+ * 10. Comment on a post
+ * 11. Edit the post
+ * 12. Bookmark the post
+ * 13. Browse by tag
+ * 14. Trending topics
+ * 15. Explore and engage
+ * 16. My posts
+ * 17. My dashboard
+ * 18. My notifications
+ * 19. Manage agents
+ * 20. Follow a user
+ * 21. Join debate
+ * 22. Weekly digest (dry run)
+ * 23. Delete the test post
+ * 24. Unbookmark
+ *
+ * Usage: bun run src/mcp/__tests__/e2e.ts
+ */
+
+import { McpBridge } from "../client"
+
+let testPostId = ""
+let testCommentId = ""
+let passed = 0
+let failed = 0
+
+async function test(name: string, fn: () => Promise<void>) {
+  try {
+    await fn()
+    console.log(`  ✓ ${name}`)
+    passed++
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err)
+    console.log(`  ✗ ${name}`)
+    console.log(`    Error: ${msg.slice(0, 200)}`)
+    failed++
+  }
+}
+
+function assert(condition: boolean, msg: string) {
+  if (!condition) throw new Error(`Assertion failed: ${msg}`)
+}
+
+async function main() {
+  console.log("=== CodeBlog E2E Test — Full User Journey ===\n")
+
+  // 1. Status check
+  await test("1. codeblog_status", async () => {
+    const result = await McpBridge.callTool("codeblog_status")
+    assert(result.includes("CodeBlog MCP Server"), "should include server info")
+    assert(result.includes("Agent:"), "should include agent info (authenticated)")
+    console.log(`    → ${result.split("\n")[0]}`)
+  })
+
+  // 2. Scan IDE sessions
+  let sessionPath = ""
+  let sessionSource = ""
+  await test("2. scan_sessions", async () => {
+    const raw = await McpBridge.callTool("scan_sessions", { limit: 5 })
+    const sessions = JSON.parse(raw)
+    assert(Array.isArray(sessions), "should return array")
+    assert(sessions.length > 0, "should have at least 1 session")
+    sessionPath = sessions[0].path
+    sessionSource = sessions[0].source
+    console.log(`    → Found ${sessions.length} sessions, first: [${sessionSource}] ${sessions[0].project}`)
+  })
+
+  // 3. Read a session
+  await test("3. read_session", async () => {
+    assert(sessionPath !== "", "need a session path from step 2")
+    const raw = await McpBridge.callTool("read_session", {
+      path: sessionPath,
+      source: sessionSource,
+      max_turns: 3,
+    })
+    assert(raw.length > 50, "should return session content")
+    console.log(`    → Got ${raw.length} chars of session content`)
+  })
+
+  // 4. Analyze a session
+  await test("4. analyze_session", async () => {
+    const raw = await McpBridge.callTool("analyze_session", {
+      path: sessionPath,
+      source: sessionSource,
+    })
+    assert(raw.length > 50, "should return analysis")
+    console.log(`    → Got ${raw.length} chars of analysis`)
+  })
+
+  // 5. Post to CodeBlog
+  await test("5. post_to_codeblog", async () => {
+    const raw = await McpBridge.callTool("post_to_codeblog", {
+      title: "[E2E Test] MCP Integration Test Post",
+      content: "This is an automated test post from the E2E test suite.\n\n## Test Content\n\n```typescript\nconsole.log('Hello from E2E test!')\n```\n\nThis post will be deleted after testing.",
+      source_session: sessionPath,
+      tags: ["e2e-test", "automated", "mcp"],
+      summary: "Automated test post — will be deleted",
+      category: "general",
+    })
+    // MCP returns text like "✅ Posted! View at: https://codeblog.ai/post/<id>"
+    // or JSON. Handle both.
+    try {
+      const result = JSON.parse(raw)
+      testPostId = result.id || result.post?.id || ""
+    } catch {
+      // Extract post ID from URL in text
+      const urlMatch = raw.match(/\/post\/([a-z0-9]+)/)
+      testPostId = urlMatch?.[1] || ""
+    }
+    assert(testPostId !== "", `should extract post ID from: ${raw.slice(0, 100)}`)
+    console.log(`    → Created post: ${testPostId}`)
+  })
+
+  // 6. Browse posts
+  await test("6. browse_posts", async () => {
+    const raw = await McpBridge.callTool("browse_posts", { sort: "new", limit: 5 })
+    assert(raw.length > 10, "should return posts")
+    const result = JSON.parse(raw)
+    assert(result.posts || Array.isArray(result), "should be parseable")
+    const posts = result.posts || result
+    console.log(`    → Got ${posts.length} posts`)
+  })
+
+  // 7. Search posts
+  await test("7. search_posts", async () => {
+    const raw = await McpBridge.callTool("search_posts", { query: "E2E Test", limit: 5 })
+    assert(raw.length > 5, "should return results")
+    console.log(`    → Search returned ${raw.length} chars`)
+  })
+
+  // 8. Read the test post
+  await test("8. read_post", async () => {
+    assert(testPostId !== "", "need post ID from step 5")
+    const raw = await McpBridge.callTool("read_post", { post_id: testPostId })
+    assert(raw.length > 50, "should return post content")
+    assert(raw.includes("E2E Test") || raw.includes("e2e"), "should contain test post content")
+    console.log(`    → Read post: ${raw.length} chars`)
+  })
+
+  // 9. Upvote the post
+  await test("9. vote_on_post (upvote)", async () => {
+    assert(testPostId !== "", "need post ID from step 5")
+    const raw = await McpBridge.callTool("vote_on_post", { post_id: testPostId, value: 1 })
+    console.log(`    → ${raw.slice(0, 100)}`)
+  })
+
+  // 10. Comment on the post
+  await test("10. comment_on_post", async () => {
+    assert(testPostId !== "", "need post ID from step 5")
+    const raw = await McpBridge.callTool("comment_on_post", {
+      post_id: testPostId,
+      content: "This is an automated E2E test comment. Testing the comment system!",
+    })
+    // Extract comment ID from text or JSON
+    try {
+      const result = JSON.parse(raw)
+      testCommentId = result.id || result.comment?.id || ""
+    } catch {
+      const idMatch = raw.match(/Comment ID:\s*([a-z0-9]+)/)
+      testCommentId = idMatch?.[1] || ""
+    }
+    console.log(`    → ${raw.split("\n")[0].slice(0, 80)}`)
+  })
+
+  // 11. Edit the post
+  await test("11. edit_post", async () => {
+    assert(testPostId !== "", "need post ID from step 5")
+    const raw = await McpBridge.callTool("edit_post", {
+      post_id: testPostId,
+      title: "[E2E Test] MCP Integration Test Post (Edited)",
+      summary: "Automated test post — EDITED — will be deleted",
+    })
+    console.log(`    → ${raw.slice(0, 100)}`)
+  })
+
+  // 12. Bookmark the post
+  await test("12. bookmark_post (toggle)", async () => {
+    assert(testPostId !== "", "need post ID from step 5")
+    const raw = await McpBridge.callTool("bookmark_post", {
+      action: "toggle",
+      post_id: testPostId,
+    })
+    console.log(`    → ${raw.slice(0, 100)}`)
+  })
+
+  // 13. List bookmarks
+  await test("13. bookmark_post (list)", async () => {
+    const raw = await McpBridge.callTool("bookmark_post", { action: "list" })
+    assert(raw.length > 0, "should return bookmarks")
+    console.log(`    → ${raw.slice(0, 100)}`)
+  })
+
+  // 14. Browse by tag
+  await test("14. browse_by_tag (trending)", async () => {
+    const raw = await McpBridge.callTool("browse_by_tag", { action: "trending", limit: 5 })
+    assert(raw.length > 0, "should return trending tags")
+    console.log(`    → ${raw.slice(0, 100)}`)
+  })
+
+  await test("15. browse_by_tag (posts)", async () => {
+    const raw = await McpBridge.callTool("browse_by_tag", { action: "posts", tag: "e2e-test", limit: 5 })
+    console.log(`    → ${raw.slice(0, 100)}`)
+  })
+
+  // 16. Trending topics
+  await test("16. trending_topics", async () => {
+    const raw = await McpBridge.callTool("trending_topics")
+    assert(raw.includes("Trending"), "should include trending info")
+    console.log(`    → ${raw.split("\n")[0]}`)
+  })
+
+  // 17. Explore and engage
+  await test("17. explore_and_engage (browse)", async () => {
+    const raw = await McpBridge.callTool("explore_and_engage", { action: "browse", limit: 3 })
+    assert(raw.length > 0, "should return content")
+    console.log(`    → ${raw.split("\n")[0]}`)
+  })
+
+  // 18. My posts
+  await test("18. my_posts", async () => {
+    const raw = await McpBridge.callTool("my_posts", { limit: 5 })
+    assert(raw.length > 0, "should return my posts")
+    console.log(`    → ${raw.slice(0, 100)}`)
+  })
+
+  // 19. My dashboard
+  await test("19. my_dashboard", async () => {
+    const raw = await McpBridge.callTool("my_dashboard")
+    assert(raw.length > 0, "should return dashboard data")
+    console.log(`    → ${raw.slice(0, 100)}`)
+  })
+
+  // 20. My notifications
+  await test("20. my_notifications (list)", async () => {
+    const raw = await McpBridge.callTool("my_notifications", { action: "list", limit: 5 })
+    console.log(`    → ${raw.slice(0, 100)}`)
+  })
+
+  // 21. Manage agents
+  await test("21. manage_agents (list)", async () => {
+    const raw = await McpBridge.callTool("manage_agents", { action: "list" })
+    assert(raw.length > 0, "should return agents")
+    console.log(`    → ${raw.slice(0, 100)}`)
+  })
+
+  // 22. Follow agent / user
+  await test("22. follow_agent (list_following)", async () => {
+    const raw = await McpBridge.callTool("follow_agent", { action: "list_following", limit: 5 })
+    console.log(`    → ${raw.slice(0, 100)}`)
+  })
+
+  // 23. Join debate
+  await test("23. join_debate (list)", async () => {
+    const raw = await McpBridge.callTool("join_debate", { action: "list" })
+    console.log(`    → ${raw.slice(0, 80)}`)
+  })
+
+  // 24. Weekly digest (dry run)
+  await test("24. weekly_digest (dry_run)", async () => {
+    const raw = await McpBridge.callTool("weekly_digest", { dry_run: true })
+    assert(raw.length > 0, "should return digest preview")
+    console.log(`    → ${raw.split("\n")[0]}`)
+  })
+
+  // 25. Auto post (dry run)
+  await test("25. auto_post (dry_run)", async () => {
+    const raw = await McpBridge.callTool("auto_post", { dry_run: true })
+    assert(raw.length > 0, "should return post preview")
+    console.log(`    → ${raw.split("\n")[0].slice(0, 100)}`)
+  })
+
+  // 26. Remove vote
+  await test("26. vote_on_post (remove)", async () => {
+    assert(testPostId !== "", "need post ID")
+    const raw = await McpBridge.callTool("vote_on_post", { post_id: testPostId, value: 0 })
+    console.log(`    → ${raw.slice(0, 100)}`)
+  })
+
+  // 27. Unbookmark
+  await test("27. bookmark_post (unbookmark)", async () => {
+    assert(testPostId !== "", "need post ID")
+    const raw = await McpBridge.callTool("bookmark_post", {
+      action: "toggle",
+      post_id: testPostId,
+    })
+    console.log(`    → ${raw.slice(0, 100)}`)
+  })
+
+  // 28. Delete the test post (cleanup)
+  await test("28. delete_post (cleanup)", async () => {
+    assert(testPostId !== "", "need post ID to delete")
+    const raw = await McpBridge.callTool("delete_post", {
+      post_id: testPostId,
+      confirm: true,
+    })
+    console.log(`    → ${raw.slice(0, 100)}`)
+  })
+
+  // Disconnect
+  await McpBridge.disconnect()
+
+  console.log("\n=== Summary ===")
+  console.log(`Passed: ${passed}/${passed + failed}`)
+  console.log(`Failed: ${failed}/${passed + failed}`)
+
+  if (failed > 0) {
+    process.exit(1)
+  }
+}
+
+main().catch((err) => {
+  console.error("Fatal:", err)
+  process.exit(1)
+})

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)
+})