codeblog-app 2.2.6 → 2.3.1

package/src/mcp/__tests__/e2e.ts

@@ -54,6 +54,10 @@ function assert(condition: boolean, msg: string) {
   if (!condition) throw new Error(`Assertion failed: ${msg}`)
 }
 
+function firstLine(text: string): string {
+  return text.split("\n")[0] ?? ""
+}
+
 async function main() {
   console.log("=== CodeBlog E2E Test — Full User Journey ===\n")
 
@@ -62,7 +66,7 @@ async function main() {
     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]}`)
+    console.log(`    → ${firstLine(result)}`)
   })
 
   // 2. Scan IDE sessions
@@ -172,7 +176,7 @@ async function main() {
       const idMatch = raw.match(/Comment ID:\s*([a-z0-9]+)/)
       testCommentId = idMatch?.[1] || ""
     }
-    console.log(`    → ${raw.split("\n")[0].slice(0, 80)}`)
+    console.log(`    → ${firstLine(raw).slice(0, 80)}`)
   })
 
   // 11. Edit the post
@@ -219,14 +223,14 @@ async function main() {
   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]}`)
+    console.log(`    → ${firstLine(raw)}`)
   })
 
   // 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]}`)
+    console.log(`    → ${firstLine(raw)}`)
   })
 
   // 18. My posts
@@ -272,14 +276,14 @@ async function main() {
   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]}`)
+    console.log(`    → ${firstLine(raw)}`)
   })
 
   // 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)}`)
+    console.log(`    → ${firstLine(raw).slice(0, 100)}`)
   })
 
   // 26. Remove vote

package/src/mcp/client.ts

@@ -1,74 +1,48 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js"
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
-import { resolve, dirname } from "path"
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js"
+import { createServer } from "codeblog-mcp"
 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 clientTransport: InstanceType<typeof InMemoryTransport> | 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 })
+    log.info("connecting via InMemoryTransport")
 
-    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 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 withTimeout(c.connect(t), CONNECTION_TIMEOUT_MS, "MCP connection")
+      await server.connect(serverTransport)
+      await c.connect(ct)
     } catch (err) {
-      // Clean up on failure so next call can retry
-      await t.close().catch(() => {})
+      const errMsg = err instanceof Error ? err.message : String(err)
+      log.error("mcp-connect-failed", { error: errMsg })
+      await ct.close().catch(() => {})
       throw err
     }
 
-    log.debug("connected", {
+    log.info("connected", {
       server: c.getServerVersion()?.name,
       version: c.getServerVersion()?.version,
     })
 
-    // Only assign to module-level vars after successful connection
-    transport = t
+    clientTransport = ct
     client = c
     return c
   })()
@@ -76,35 +50,36 @@ async function connect(): Promise<Client> {
   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 })
+    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)
   }
 
-  /**
-   * Call an MCP tool and parse the result as JSON.
-   */
   export async function callToolJSON<T = unknown>(
     name: string,
     args: Record<string, unknown> = {},
@@ -117,22 +92,17 @@ export namespace McpBridge {
     }
   }
 
-  /**
-   * 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> {
+    log.info("disconnecting", { hadClient: !!client })
     connecting = null
-    if (transport) {
-      await transport.close().catch(() => {})
-      transport = null
+    if (clientTransport) {
+      await clientTransport.close().catch(() => {})
+      clientTransport = null
     }
     client = null
   }

package/src/storage/chat.ts

@@ -1,8 +1,10 @@
 import { Database } from "./db"
 
 export interface ChatMsg {
-  role: "user" | "assistant" | "tool"
+  role: "user" | "assistant" | "tool" | "system"
   content: string
+  modelContent?: string
+  tone?: "info" | "success" | "warning" | "error"
   toolName?: string
   toolStatus?: "running" | "done" | "error"
 }

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

package/src/tui/app.tsx

@@ -10,15 +10,27 @@ import { Post } from "./routes/post"
 import { Search } from "./routes/search"
 import { Trending } from "./routes/trending"
 import { Notifications } from "./routes/notifications"
+import { emitInputIntent, isShiftEnterSequence } from "./input-intent"
 
 import pkg from "../../package.json"
 const VERSION = pkg.version
 
+function enableModifyOtherKeys() {
+  if (!process.stdout.isTTY) return () => {}
+  // Ask xterm-compatible terminals to include modifier info for keys like Enter.
+  process.stdout.write("\x1b[>4;2m")
+  return () => {
+    // Disable modifyOtherKeys on exit.
+    process.stdout.write("\x1b[>4m")
+  }
+}
+
 export function tui(input: { onExit?: () => Promise<void> }) {
   return new Promise<void>(async (resolve) => {
+    const restoreModifiers = enableModifyOtherKeys()
     render(
       () => (
-        <ExitProvider onExit={async () => { await input.onExit?.(); resolve() }}>
+        <ExitProvider onExit={async () => { await input.onExit?.(); restoreModifiers(); resolve() }}>
           <ThemeProvider>
             <RouteProvider>
               <App />
@@ -31,6 +43,20 @@ export function tui(input: { onExit?: () => Promise<void> }) {
         exitOnCtrlC: false,
         autoFocus: false,
         openConsoleOnError: false,
+        useKittyKeyboard: {
+          disambiguate: true,
+          alternateKeys: true,
+          events: true,
+          allKeysAsEscapes: true,
+          reportText: true,
+        },
+        prependInputHandlers: [
+          (sequence) => {
+            if (!isShiftEnterSequence(sequence)) return false
+            emitInputIntent("newline")
+            return true
+          },
+        ],
       },
     )
   })

package/src/tui/commands.ts

@@ -9,14 +9,15 @@ export interface CmdDef {
 
 export interface CommandDeps {
   showMsg: (text: string, color?: string) => void
-  navigate: (route: any) => void
+  openModelPicker: () => Promise<void>
   exit: () => void
   onLogin: () => Promise<void>
   onLogout: () => void
+  onAIConfigured: () => void
   clearChat: () => void
   startAIConfig: () => void
   setMode: (mode: "dark" | "light") => void
-  send: (prompt: string) => void
+  send: (prompt: string, options?: { display?: string }) => void
   resume: (id?: string) => void
   listSessions: () => Array<{ id: string; title: string | null; time: number; count: number }>
   hasAI: boolean
@@ -32,8 +33,33 @@ export interface CommandDeps {
 export function createCommands(deps: CommandDeps): CmdDef[] {
   return [
     // === Configuration & Setup ===
-    { name: "/ai", description: "Configure AI provider (paste URL + key)", action: () => deps.startAIConfig() },
-    { name: "/model", description: "Choose AI model", action: () => deps.navigate({ type: "model" }) },
+    { name: "/ai", description: "Quick AI setup (URL + key)", action: () => deps.startAIConfig() },
+    { name: "/model", description: "Switch model (picker or /model <id>)", action: async (parts) => {
+      const query = parts.slice(1).join(" ").trim()
+      if (!query) {
+        await deps.openModelPicker()
+        return
+      }
+      const { AIProvider } = await import("../ai/provider")
+      const { Config } = await import("../config")
+      const list = await AIProvider.available()
+      const all = list.filter((m) => m.hasKey).map((m) => m.model)
+
+      const picked = all.find((m) =>
+        m.id === query ||
+        `${m.providerID}/${m.id}` === query ||
+        (m.providerID === "openai-compatible" && `openai-compatible/${m.id}` === query)
+      )
+      if (!picked) {
+        deps.showMsg(`Model not found: ${query}. Run /model to list available models.`, deps.colors.warning)
+        return
+      }
+
+      const saveId = picked.providerID === "openai-compatible" ? `openai-compatible/${picked.id}` : picked.id
+      await Config.save({ model: saveId })
+      deps.onAIConfigured()
+      deps.showMsg(`Model switched to ${saveId}`, deps.colors.success)
+    }},
     { name: "/login", description: "Sign in to CodeBlog", action: async () => {
       deps.showMsg("Opening browser for login...", deps.colors.primary)
       await deps.onLogin()
@@ -134,7 +160,15 @@ export function createCommands(deps: CommandDeps): CmdDef[] {
     // === UI & Navigation ===
     { name: "/clear", description: "Clear conversation", action: () => deps.clearChat() },
     { name: "/new", description: "New conversation", action: () => deps.clearChat() },
-    { name: "/theme", description: "Change color theme", action: () => deps.navigate({ type: "theme" }) },
+    { name: "/theme", description: "Theme mode: /theme [light|dark]", action: (parts) => {
+      const mode = (parts[1] || "").toLowerCase()
+      if (mode === "dark" || mode === "light") {
+        deps.setMode(mode)
+        deps.showMsg(`Theme switched to ${mode}`, deps.colors.success)
+        return
+      }
+      deps.showMsg("Use /theme dark or /theme light (or /dark /light)", deps.colors.text)
+    }},
     { name: "/dark", description: "Switch to dark mode", action: () => { deps.setMode("dark"); deps.showMsg("Dark mode", deps.colors.text) } },
     { name: "/light", description: "Switch to light mode", action: () => { deps.setMode("light"); deps.showMsg("Light mode", deps.colors.text) } },
     { name: "/resume", description: "Resume last chat session", action: (parts) => deps.resume(parts[1]) },
@@ -155,7 +189,7 @@ export function createCommands(deps: CommandDeps): CmdDef[] {
 }
 
 export const TIPS = [
-  "Type /ai to configure your AI provider with a URL and API key",
+  "Type /ai for quick setup, or run `codeblog ai setup` for full onboarding",
   "Type /model to switch between available AI models",
   "Use /scan to discover IDE coding sessions from Cursor, Windsurf, etc.",
   "Use /publish to share your coding sessions as blog posts",
@@ -169,7 +203,7 @@ export const TIPS = [
 ]
 
 export const TIPS_NO_AI = [
-  "Type /ai to configure your AI provider — unlock AI chat and smart commands",
+  "Type /ai for quick setup, or run `codeblog ai setup` for full onboarding",
   "Commands in grey require AI. Type /ai to set up your provider first",
   "Type / to see all available commands with autocomplete",
   "Configure AI with /ai — then chat naturally to browse, post, and interact",

package/src/tui/context/theme.tsx

@@ -417,6 +417,7 @@ export const THEMES: Record<string, ThemeDef> = {
 }
 
 export const THEME_NAMES = Object.keys(THEMES)
+const DEFAULT_THEME: ThemeDef = codeblog
 
 const configPath = path.join(Global.Path.config, "theme.json")
 
@@ -446,7 +447,7 @@ export const { use: useTheme, provider: ThemeProvider } = createSimpleContext({
 
     return {
       get colors(): ThemeColors {
-        const def = THEMES[store.name] || THEMES.codeblog
+        const def = THEMES[store.name] ?? DEFAULT_THEME
         return def[store.mode]
       },
       get name() { return store.name },

package/src/tui/input-intent.ts

@@ -0,0 +1,26 @@
+export type InputIntent = "newline"
+
+const listeners = new Set<(intent: InputIntent) => void>()
+
+// Common Shift+Enter escape sequences observed across kitty/xterm-style terminals.
+const SHIFT_ENTER_PATTERNS = [
+  /^\x1b\[(?:13|57345);2(?::\d+)?u$/,
+  /^\x1b\[27;2;13~$/,
+  /^\x1b\[13;2~$/,
+]
+
+export function isShiftEnterSequence(sequence: string): boolean {
+  if (!sequence) return false
+  const normalized = sequence.replace(/[\r\n]+$/g, "")
+  if (!normalized) return false
+  return SHIFT_ENTER_PATTERNS.some((pattern) => pattern.test(normalized))
+}
+
+export function emitInputIntent(intent: InputIntent) {
+  for (const listener of listeners) listener(intent)
+}
+
+export function onInputIntent(listener: (intent: InputIntent) => void) {
+  listeners.add(listener)
+  return () => listeners.delete(listener)
+}