codeblog-app 2.1.2 → 2.1.4

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/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,71 @@
+import { Database } from "./db"
+
+export interface ChatMsg {
+  role: "user" | "assistant" | "tool"
+  content: string
+  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/app.tsx

@@ -0,0 +1,179 @@
+import { render, useKeyboard, useRenderer, useTerminalDimensions } from "@opentui/solid"
+import { Switch, Match, onMount, createSignal, Show } from "solid-js"
+import { RouteProvider, useRoute } from "./context/route"
+import { ExitProvider, useExit } from "./context/exit"
+import { ThemeProvider, useTheme } from "./context/theme"
+import { Home } from "./routes/home"
+import { ThemePicker } from "./routes/setup"
+import { ModelPicker } from "./routes/model"
+import { Post } from "./routes/post"
+import { Search } from "./routes/search"
+import { Trending } from "./routes/trending"
+import { Notifications } from "./routes/notifications"
+
+import pkg from "../../package.json"
+const VERSION = pkg.version
+
+export function tui(input: { onExit?: () => Promise<void> }) {
+  return new Promise<void>(async (resolve) => {
+    render(
+      () => (
+        <ExitProvider onExit={async () => { await input.onExit?.(); resolve() }}>
+          <ThemeProvider>
+            <RouteProvider>
+              <App />
+            </RouteProvider>
+          </ThemeProvider>
+        </ExitProvider>
+      ),
+      {
+        targetFps: 30,
+        exitOnCtrlC: false,
+        autoFocus: false,
+        openConsoleOnError: false,
+      },
+    )
+  })
+}
+
+function App() {
+  const route = useRoute()
+  const exit = useExit()
+  const theme = useTheme()
+  const dimensions = useTerminalDimensions()
+  const renderer = useRenderer()
+  const [loggedIn, setLoggedIn] = createSignal(false)
+  const [username, setUsername] = createSignal("")
+  const [hasAI, setHasAI] = createSignal(false)
+  const [aiProvider, setAiProvider] = createSignal("")
+  const [modelName, setModelName] = createSignal("")
+
+  async function refreshAI() {
+    try {
+      const { AIProvider } = await import("../ai/provider")
+      const has = await AIProvider.hasAnyKey()
+      setHasAI(has)
+      if (has) {
+        const { Config } = await import("../config")
+        const cfg = await Config.load()
+        const model = cfg.model || AIProvider.DEFAULT_MODEL
+        setModelName(model)
+        const info = AIProvider.BUILTIN_MODELS[model]
+        setAiProvider(info?.providerID || model.split("/")[0] || "ai")
+      }
+    } catch {}
+  }
+
+  onMount(async () => {
+    renderer.setTerminalTitle("CodeBlog")
+
+    // Check auth status
+    try {
+      const { Auth } = await import("../auth")
+      const authenticated = await Auth.authenticated()
+      setLoggedIn(authenticated)
+      if (authenticated) {
+        const token = await Auth.get()
+        if (token?.username) setUsername(token.username)
+      }
+    } catch {}
+
+    await refreshAI()
+  })
+
+  useKeyboard((evt) => {
+    if (evt.ctrl && evt.name === "c") {
+      exit()
+      evt.preventDefault()
+      return
+    }
+
+    // Back navigation from sub-pages
+    if (evt.name === "escape" && route.data.type !== "home") {
+      route.navigate({ type: "home" })
+      evt.preventDefault()
+      return
+    }
+  })
+
+  return (
+    <box flexDirection="column" width={dimensions().width} height={dimensions().height}>
+      <Switch>
+        <Match when={route.data.type === "home"}>
+          <Home
+            loggedIn={loggedIn()}
+            username={username()}
+            hasAI={hasAI()}
+            aiProvider={aiProvider()}
+            modelName={modelName()}
+            onLogin={async () => {
+              try {
+                const { OAuth } = await import("../auth/oauth")
+                await OAuth.login()
+                const { Auth } = await import("../auth")
+                setLoggedIn(true)
+                const token = await Auth.get()
+                if (token?.username) setUsername(token.username)
+              } catch {}
+            }}
+            onLogout={() => { setLoggedIn(false); setUsername("") }}
+            onAIConfigured={refreshAI}
+          />
+        </Match>
+        <Match when={route.data.type === "theme"}>
+          <ThemePicker onDone={() => route.navigate({ type: "home" })} />
+        </Match>
+        <Match when={route.data.type === "model"}>
+          <ModelPicker onDone={async (model) => {
+            if (model) setModelName(model)
+            await refreshAI()
+            route.navigate({ type: "home" })
+          }} />
+        </Match>
+        <Match when={route.data.type === "post"}>
+          <Post />
+        </Match>
+        <Match when={route.data.type === "search"}>
+          <Search />
+        </Match>
+        <Match when={route.data.type === "trending"}>
+          <Trending />
+        </Match>
+        <Match when={route.data.type === "notifications"}>
+          <Notifications />
+        </Match>
+      </Switch>
+
+      {/* Status bar — like OpenCode */}
+      <box paddingLeft={2} paddingRight={2} flexShrink={0} flexDirection="row" gap={2}>
+        <text fg={theme.colors.textMuted}>{process.cwd()}</text>
+        <box flexGrow={1} />
+        <Show when={hasAI()}>
+          <text fg={theme.colors.text}>
+            <span style={{ fg: theme.colors.success }}>● </span>
+            {modelName()}
+          </text>
+        </Show>
+        <Show when={!hasAI()}>
+          <text fg={theme.colors.text}>
+            <span style={{ fg: theme.colors.error }}>○ </span>
+            no AI <span style={{ fg: theme.colors.textMuted }}>/ai</span>
+          </text>
+        </Show>
+        <Show when={loggedIn()}>
+          <text fg={theme.colors.text}>
+            <span style={{ fg: theme.colors.success }}>● </span>
+            {username() || "logged in"}
+          </text>
+        </Show>
+        <Show when={!loggedIn()}>
+          <text fg={theme.colors.text}>
+            <span style={{ fg: theme.colors.error }}>○ </span>
+            <span style={{ fg: theme.colors.textMuted }}>/login</span>
+          </text>
+        </Show>
+        <text fg={theme.colors.textMuted}>v{VERSION}</text>
+      </box>
+    </box>
+  )
+}