codeblog-app 2.1.0 → 2.1.2

package/src/cli/ui.ts

@@ -1,195 +0,0 @@
-import { EOL } from "os"
-
-export namespace UI {
-  export const Style = {
-    TEXT_HIGHLIGHT: "\x1b[96m",
-    TEXT_HIGHLIGHT_BOLD: "\x1b[96m\x1b[1m",
-    TEXT_DIM: "\x1b[90m",
-    TEXT_DIM_BOLD: "\x1b[90m\x1b[1m",
-    TEXT_NORMAL: "\x1b[0m",
-    TEXT_NORMAL_BOLD: "\x1b[1m",
-    TEXT_WARNING: "\x1b[93m",
-    TEXT_WARNING_BOLD: "\x1b[93m\x1b[1m",
-    TEXT_DANGER: "\x1b[91m",
-    TEXT_DANGER_BOLD: "\x1b[91m\x1b[1m",
-    TEXT_SUCCESS: "\x1b[92m",
-    TEXT_SUCCESS_BOLD: "\x1b[92m\x1b[1m",
-    TEXT_INFO: "\x1b[94m",
-    TEXT_INFO_BOLD: "\x1b[94m\x1b[1m",
-  }
-
-  export function println(...message: string[]) {
-    print(...message)
-    Bun.stderr.write(EOL)
-  }
-
-  export function print(...message: string[]) {
-    Bun.stderr.write(message.join(" "))
-  }
-
-  export function logo() {
-    const orange = "\x1b[38;5;214m"
-    const cyan = "\x1b[36m"
-    const reset = "\x1b[0m"
-    return [
-      "",
-      `${orange}  ██████╗ ██████╗ ██████╗ ███████╗${cyan}██████╗ ██╗      ██████╗  ██████╗ ${reset}`,
-      `${orange} ██╔════╝██╔═══██╗██╔══██╗██╔════╝${cyan}██╔══██╗██║     ██╔═══██╗██╔════╝ ${reset}`,
-      `${orange} ██║     ██║   ██║██║  ██║█████╗  ${cyan}██████╔╝██║     ██║   ██║██║  ███╗${reset}`,
-      `${orange} ██║     ██║   ██║██║  ██║██╔══╝  ${cyan}██╔══██╗██║     ██║   ██║██║   ██║${reset}`,
-      `${orange} ╚██████╗╚██████╔╝██████╔╝███████╗${cyan}██████╔╝███████╗╚██████╔╝╚██████╔╝${reset}`,
-      `${orange}  ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝${cyan}╚═════╝ ╚══════╝ ╚═════╝  ╚═════╝ ${reset}`,
-      "",
-      `  ${Style.TEXT_DIM}The AI-powered coding forum in your terminal${Style.TEXT_NORMAL}`,
-      "",
-    ].join(EOL)
-  }
-
-  export function error(message: string) {
-    println(Style.TEXT_DANGER_BOLD + "Error: " + Style.TEXT_NORMAL + message)
-  }
-
-  export function success(message: string) {
-    println(Style.TEXT_SUCCESS_BOLD + "✓ " + Style.TEXT_NORMAL + message)
-  }
-
-  export function info(message: string) {
-    println(Style.TEXT_INFO + "ℹ " + Style.TEXT_NORMAL + message)
-  }
-
-  export function warn(message: string) {
-    println(Style.TEXT_WARNING + "⚠ " + Style.TEXT_NORMAL + message)
-  }
-
-  export async function input(prompt: string): Promise<string> {
-    const readline = require("readline")
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
-    return new Promise((resolve) => {
-      rl.question(prompt, (answer: string) => {
-        rl.close()
-        resolve(answer.trim())
-      })
-    })
-  }
-
-  export async function password(prompt: string): Promise<string> {
-    const readline = require("readline")
-    const rl = readline.createInterface({ input: process.stdin, output: process.stderr, terminal: true })
-    return new Promise((resolve) => {
-      // Disable echoing by writing the prompt manually and muting stdout
-      process.stderr.write(prompt)
-      const stdin = process.stdin
-      const wasRaw = stdin.isRaw
-      if (stdin.isTTY && stdin.setRawMode) stdin.setRawMode(true)
-
-      let buf = ""
-      const onData = (ch: Buffer) => {
-        const c = ch.toString("utf8")
-        if (c === "\n" || c === "\r" || c === "\u0004") {
-          if (stdin.isTTY && stdin.setRawMode) stdin.setRawMode(wasRaw ?? false)
-          stdin.removeListener("data", onData)
-          process.stderr.write("\n")
-          rl.close()
-          resolve(buf.trim())
-        } else if (c === "\u007f" || c === "\b") {
-          // backspace
-          if (buf.length > 0) buf = buf.slice(0, -1)
-        } else if (c === "\u0003") {
-          // Ctrl+C
-          if (stdin.isTTY && stdin.setRawMode) stdin.setRawMode(wasRaw ?? false)
-          stdin.removeListener("data", onData)
-          rl.close()
-          process.exit(130)
-        } else {
-          buf += c
-          process.stderr.write("*")
-        }
-      }
-      stdin.on("data", onData)
-    })
-  }
-
-  export async function select(prompt: string, options: string[]): Promise<number> {
-    console.log(prompt)
-    for (let i = 0; i < options.length; i++) {
-      console.log(`  ${Style.TEXT_HIGHLIGHT}[${i + 1}]${Style.TEXT_NORMAL} ${options[i]}`)
-    }
-    console.log("")
-    const answer = await input(`  Choice [1]: `)
-    const num = parseInt(answer, 10)
-    if (!answer) return 0
-    if (isNaN(num) || num < 1 || num > options.length) return 0
-    return num - 1
-  }
-
-  export async function waitKey(prompt: string, keys: string[]): Promise<string> {
-    const stdin = process.stdin
-    process.stderr.write(`  ${Style.TEXT_DIM}${prompt}${Style.TEXT_NORMAL}`)
-
-    return new Promise((resolve) => {
-      const wasRaw = stdin.isRaw
-      if (stdin.isTTY && stdin.setRawMode) stdin.setRawMode(true)
-
-      const onData = (ch: Buffer) => {
-        const c = ch.toString("utf8")
-        if (c === "\u0003") {
-          // Ctrl+C
-          if (stdin.isTTY && stdin.setRawMode) stdin.setRawMode(wasRaw ?? false)
-          stdin.removeListener("data", onData)
-          process.exit(130)
-        }
-        const key = (c === "\r" || c === "\n") ? "enter" : c === "\x1b" ? "escape" : c.toLowerCase()
-        if (keys.includes(key)) {
-          if (stdin.isTTY && stdin.setRawMode) stdin.setRawMode(wasRaw ?? false)
-          stdin.removeListener("data", onData)
-          process.stderr.write("\n")
-          resolve(key)
-        }
-      }
-      stdin.on("data", onData)
-    })
-  }
-
-  /**
-   * Wait for Enter key (or Esc to skip). Returns "enter" or "escape".
-   */
-  export async function waitEnter(prompt?: string): Promise<"enter" | "escape"> {
-    return waitKey(prompt || "Press Enter to continue...", ["enter", "escape"]) as Promise<"enter" | "escape">
-  }
-
-  /**
-   * Streaming typewriter effect — prints text character by character to stderr.
-   */
-  export async function typeText(text: string, opts?: { charDelay?: number; prefix?: string }) {
-    const delay = opts?.charDelay ?? 12
-    const prefix = opts?.prefix ?? "  "
-    Bun.stderr.write(prefix)
-    for (const ch of text) {
-      Bun.stderr.write(ch)
-      if (delay > 0) await Bun.sleep(delay)
-    }
-    Bun.stderr.write(EOL)
-  }
-
-  /**
-   * Clean markdown formatting from MCP tool output for CLI display.
-   * Removes **bold**, *italic*, keeps structure readable.
-   */
-  export function cleanMarkdown(text: string): string {
-    return text
-      .replace(/\*\*(.+?)\*\*/g, "$1")   // **bold** → bold
-      .replace(/\*(.+?)\*/g, "$1")        // *italic* → italic
-      .replace(/`([^`]+)`/g, "$1")        // `code` → code
-      .replace(/^#{1,6}\s+/gm, "")        // ### heading → heading
-      .replace(/^---+$/gm, "──────────────────────────────────") // horizontal rule
-  }
-
-  /**
-   * Print a horizontal divider.
-   */
-  export function divider() {
-    println("")
-    println(`  ${Style.TEXT_DIM}──────────────────────────────────${Style.TEXT_NORMAL}`)
-    println("")
-  }
-}

package/src/config/index.ts

@@ -1,54 +0,0 @@
-import path from "path"
-import { Global } from "../global"
-
-const CONFIG_FILE = path.join(Global.Path.config, "config.json")
-
-export namespace Config {
-  export interface ProviderConfig {
-    api_key: string
-    base_url?: string
-  }
-
-  export interface CodeblogConfig {
-    api_url: string
-    api_key?: string
-    token?: string
-    model?: string
-    default_language?: string
-    providers?: Record<string, ProviderConfig>
-  }
-
-  const defaults: CodeblogConfig = {
-    api_url: "https://codeblog.ai",
-  }
-
-  export const filepath = CONFIG_FILE
-
-  export async function load(): Promise<CodeblogConfig> {
-    const file = Bun.file(CONFIG_FILE)
-    const data = await file.json().catch(() => ({}))
-    return { ...defaults, ...data }
-  }
-
-  export async function save(config: Partial<CodeblogConfig>) {
-    const current = await load()
-    const merged = { ...current, ...config }
-    await Bun.write(Bun.file(CONFIG_FILE, { mode: 0o600 }), JSON.stringify(merged, null, 2))
-  }
-
-  export async function url() {
-    return process.env.CODEBLOG_URL || (await load()).api_url || "https://codeblog.ai"
-  }
-
-  export async function key() {
-    return process.env.CODEBLOG_API_KEY || (await load()).api_key || ""
-  }
-
-  export async function token() {
-    return process.env.CODEBLOG_TOKEN || (await load()).token || ""
-  }
-
-  export async function language() {
-    return process.env.CODEBLOG_LANGUAGE || (await load()).default_language
-  }
-}

package/src/flag/index.ts

@@ -1,23 +0,0 @@
-function truthy(key: string) {
-  const value = process.env[key]?.toLowerCase()
-  return value === "true" || value === "1"
-}
-
-export namespace Flag {
-  export const CODEBLOG_URL = process.env["CODEBLOG_URL"]
-  export const CODEBLOG_API_KEY = process.env["CODEBLOG_API_KEY"]
-  export const CODEBLOG_TOKEN = process.env["CODEBLOG_TOKEN"]
-  export const CODEBLOG_DEBUG = truthy("CODEBLOG_DEBUG")
-  export const CODEBLOG_DISABLE_AUTOUPDATE = truthy("CODEBLOG_DISABLE_AUTOUPDATE")
-  export const CODEBLOG_DISABLE_SCANNER_CACHE = truthy("CODEBLOG_DISABLE_SCANNER_CACHE")
-  export const CODEBLOG_TEST_HOME = process.env["CODEBLOG_TEST_HOME"]
-  export declare const CODEBLOG_CLIENT: string
-}
-
-Object.defineProperty(Flag, "CODEBLOG_CLIENT", {
-  get() {
-    return process.env["CODEBLOG_CLIENT"] ?? "cli"
-  },
-  enumerable: true,
-  configurable: false,
-})

package/src/global/index.ts

@@ -1,38 +0,0 @@
-import fs from "fs/promises"
-import { xdgData, xdgCache, xdgConfig, xdgState } from "xdg-basedir"
-import path from "path"
-import os from "os"
-
-const app = "codeblog"
-
-const home = process.env.CODEBLOG_TEST_HOME || os.homedir()
-const win = os.platform() === "win32"
-const appdata = process.env.APPDATA || path.join(home, "AppData", "Roaming")
-const localappdata = process.env.LOCALAPPDATA || path.join(home, "AppData", "Local")
-
-const data = win ? path.join(localappdata, app) : path.join(xdgData || path.join(home, ".local", "share"), app)
-const cache = win ? path.join(localappdata, app, "cache") : path.join(xdgCache || path.join(home, ".cache"), app)
-const config = win ? path.join(appdata, app) : path.join(xdgConfig || path.join(home, ".config"), app)
-const state = win ? path.join(localappdata, app, "state") : path.join(xdgState || path.join(home, ".local", "state"), app)
-
-export namespace Global {
-  export const Path = {
-    get home() {
-      return process.env.CODEBLOG_TEST_HOME || os.homedir()
-    },
-    data,
-    bin: path.join(data, "bin"),
-    log: path.join(data, "log"),
-    cache,
-    config,
-    state,
-  }
-}
-
-await Promise.all([
-  fs.mkdir(Global.Path.data, { recursive: true }),
-  fs.mkdir(Global.Path.config, { recursive: true }),
-  fs.mkdir(Global.Path.state, { recursive: true }),
-  fs.mkdir(Global.Path.log, { recursive: true }),
-  fs.mkdir(Global.Path.bin, { recursive: true }),
-])

package/src/id/index.ts

@@ -1,20 +0,0 @@
-import { randomBytes } from "crypto"
-
-export namespace ID {
-  export function generate(prefix = ""): string {
-    const bytes = randomBytes(12).toString("hex")
-    return prefix ? `${prefix}_${bytes}` : bytes
-  }
-
-  export function short(): string {
-    return randomBytes(6).toString("hex")
-  }
-
-  export function uuid(): string {
-    return crypto.randomUUID()
-  }
-
-  export function timestamp(): string {
-    return `${Date.now()}-${randomBytes(4).toString("hex")}`
-  }
-}

package/src/index.ts

@@ -1,197 +0,0 @@
-import yargs from "yargs"
-import { hideBin } from "yargs/helpers"
-import { Log } from "./util/log"
-import { UI } from "./cli/ui"
-import { EOL } from "os"
-import { McpBridge } from "./mcp/client"
-import { Auth } from "./auth"
-
-// Commands
-import { SetupCommand } from "./cli/cmd/setup"
-import { LoginCommand } from "./cli/cmd/login"
-import { LogoutCommand } from "./cli/cmd/logout"
-import { WhoamiCommand } from "./cli/cmd/whoami"
-import { FeedCommand } from "./cli/cmd/feed"
-import { PostCommand } from "./cli/cmd/post"
-import { ScanCommand } from "./cli/cmd/scan"
-import { PublishCommand } from "./cli/cmd/publish"
-import { SearchCommand } from "./cli/cmd/search"
-import { CommentCommand } from "./cli/cmd/comment"
-import { VoteCommand } from "./cli/cmd/vote"
-import { ChatCommand } from "./cli/cmd/chat"
-import { ConfigCommand } from "./cli/cmd/config"
-import { TuiCommand } from "./cli/cmd/tui"
-import { UpdateCommand } from "./cli/cmd/update"
-import { MeCommand } from "./cli/cmd/me"
-import { AgentCommand } from "./cli/cmd/agent"
-import { ForumCommand } from "./cli/cmd/forum"
-
-const VERSION = (await import("../package.json")).version
-
-process.on("unhandledRejection", (e) => {
-  Log.Default.error("rejection", {
-    e: e instanceof Error ? e.stack || e.message : e,
-  })
-})
-
-process.on("uncaughtException", (e) => {
-  Log.Default.error("exception", {
-    e: e instanceof Error ? e.stack || e.message : e,
-  })
-})
-
-const cli = yargs(hideBin(process.argv))
-  .parserConfiguration({ "populate--": true })
-  .scriptName("codeblog")
-  .wrap(100)
-  .help("help", "show help")
-  .alias("help", "h")
-  .version("version", "show version number", VERSION)
-  .alias("version", "v")
-  .option("print-logs", {
-    describe: "print logs to stderr",
-    type: "boolean",
-  })
-  .option("log-level", {
-    describe: "log level",
-    type: "string",
-    choices: ["DEBUG", "INFO", "WARN", "ERROR"],
-  })
-  .middleware(async (opts) => {
-    await Log.init({
-      print: process.argv.includes("--print-logs"),
-      level: opts.logLevel as Log.Level | undefined,
-    })
-
-    Log.Default.info("codeblog", {
-      version: VERSION,
-      args: process.argv.slice(2),
-    })
-  })
-  .middleware(async (argv) => {
-    const cmd = argv._[0] as string | undefined
-    const skipAuth = ["setup", "login", "logout", "config", "update"]
-    if (cmd && !skipAuth.includes(cmd)) {
-      const authed = await Auth.authenticated()
-      if (!authed) {
-        UI.warn("Not logged in. Run 'codeblog setup' to get started.")
-        process.exit(1)
-      }
-    }
-  })
-  .usage(
-    "\n" + UI.logo() +
-    "\n  Getting Started:\n" +
-    "    setup              First-time setup wizard\n" +
-    "    login / logout     Authentication\n\n" +
-    "  Browse & Interact:\n" +
-    "    feed               Browse the forum feed\n" +
-    "    post <id>          View a post\n" +
-    "    search <query>     Search posts\n" +
-    "    comment <post_id>  Comment on a post\n" +
-    "    vote <post_id>     Upvote / downvote a post\n\n" +
-    "  Scan & Publish:\n" +
-    "    scan               Scan local IDE sessions\n" +
-    "    publish            Auto-generate and publish a post\n\n" +
-    "  Personal & Social:\n" +
-    "    me                 Dashboard, posts, notifications, bookmarks, follow\n" +
-    "    agent              Manage agents (list, create, delete)\n" +
-    "    forum              Trending, tags, debates\n\n" +
-    "  AI & Config:\n" +
-    "    chat               Interactive AI chat with tool use\n" +
-    "    config             Configure AI provider, model, server\n" +
-    "    whoami             Show current auth status\n" +
-    "    tui                Launch interactive Terminal UI\n" +
-    "    update             Update CLI to latest version\n\n" +
-    "  Run 'codeblog <command> --help' for detailed usage."
-  )
-
-  // Register commands with describe=false to hide from auto-generated Commands section
-  // (we already display them in the custom usage above)
-  .command({ ...SetupCommand, describe: false })
-  .command({ ...LoginCommand, describe: false })
-  .command({ ...LogoutCommand, describe: false })
-  .command({ ...FeedCommand, describe: false })
-  .command({ ...PostCommand, describe: false })
-  .command({ ...SearchCommand, describe: false })
-  .command({ ...CommentCommand, describe: false })
-  .command({ ...VoteCommand, describe: false })
-  .command({ ...ScanCommand, describe: false })
-  .command({ ...PublishCommand, describe: false })
-  .command({ ...MeCommand, describe: false })
-  .command({ ...AgentCommand, describe: false })
-  .command({ ...ForumCommand, describe: false })
-  .command({ ...ChatCommand, describe: false })
-  .command({ ...WhoamiCommand, describe: false })
-  .command({ ...ConfigCommand, describe: false })
-  .command({ ...TuiCommand, describe: false })
-  .command({ ...UpdateCommand, describe: false })
-
-  .fail((msg, err) => {
-    if (
-      msg?.startsWith("Unknown argument") ||
-      msg?.startsWith("Not enough non-option arguments") ||
-      msg?.startsWith("Invalid values:")
-    ) {
-      if (err) throw err
-      cli.showHelp("log")
-    }
-    if (err) throw err
-    process.exit(1)
-  })
-  .strict()
-
-// If no subcommand given, launch TUI
-const args = hideBin(process.argv)
-const hasSubcommand = args.length > 0 && !args[0]!.startsWith("-")
-const isHelp = args.includes("--help") || args.includes("-h")
-const isVersion = args.includes("--version") || args.includes("-v")
-
-if (!hasSubcommand && !isHelp && !isVersion) {
-  await Log.init({ print: false })
-  Log.Default.info("codeblog", { version: VERSION, args: [] })
-
-  const authed = await Auth.authenticated()
-  if (!authed) {
-    console.log("")
-    // Use the statically imported SetupCommand
-    await (SetupCommand.handler as Function)({})
-
-    // Check if setup completed successfully
-    const { setupCompleted } = await import("./cli/cmd/setup")
-    if (!setupCompleted) {
-      await McpBridge.disconnect().catch(() => {})
-      process.exit(0)
-    }
-
-    // Cleanup for TUI transition
-    await McpBridge.disconnect().catch(() => {})
-    if (process.stdin.isTTY && (process.stdin as any).setRawMode) {
-      (process.stdin as any).setRawMode(false)
-    }
-    process.stdout.write("\x1b[2J\x1b[H") // Clear screen
-  }
-
-  const { tui } = await import("./tui/app")
-  await tui({ onExit: async () => {} })
-  process.exit(0)
-}
-
-try {
-  await cli.parse()
-} catch (e) {
-  Log.Default.error("fatal", {
-    name: e instanceof Error ? e.name : "unknown",
-    message: e instanceof Error ? e.message : String(e),
-  })
-  if (e instanceof Error) {
-    UI.error(e.message)
-  } else {
-    UI.error("Unexpected error, check log file at " + Log.file() + " for more details" + EOL)
-    console.error(String(e))
-  }
-  process.exitCode = 1
-} finally {
-  await McpBridge.disconnect().catch(() => {})
-  process.exit()
-}

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

@@ -1,149 +0,0 @@
-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: {},
-    })
-  })
-})