@cuongtran001/kanna 1.63.2 → 1.63.3

package/src/server/claude-pty/tui-source.adapter.ts

@@ -1,294 +0,0 @@
-import { readdir, stat, open } from "node:fs/promises"
-import { existsSync } from "node:fs"
-import path from "node:path"
-import { awaitClaudeSessionForPid } from "./claude-session-registry.adapter"
-import { computeJsonlPath } from "./jsonl-path.adapter"
-
-export async function findLatestTranscript(
-  projectDir: string,
-  opts: { minMtimeMs?: number } = {},
-): Promise<string | null> {
-  if (!existsSync(projectDir)) return null
-  let entries: string[]
-  try {
-    entries = await readdir(projectDir)
-  } catch {
-    return null
-  }
-  const jsonlNames = entries.filter((n) => n.endsWith(".jsonl"))
-  if (jsonlNames.length === 0) return null
-  const floor = opts.minMtimeMs ?? 0
-  let bestPath: string | null = null
-  let bestMtime = 0
-  for (const name of jsonlNames) {
-    const full = path.join(projectDir, name)
-    try {
-      const s = await stat(full)
-      if (s.mtimeMs < floor) continue
-      if (s.mtimeMs > bestMtime) {
-        bestMtime = s.mtimeMs
-        bestPath = full
-      }
-    } catch {
-    }
-  }
-  return bestPath
-}
-
-export interface TranscriptStream {
-  lines: AsyncIterable<string>
-  filePath: Promise<string>
-  close(): void
-}
-
-export interface StartTranscriptStreamArgs {
-  projectDir: string
-  knownFilePath?: string
-  minMtimeMs?: number
-  pollIntervalMs?: number
-  firstFileTimeoutMs?: number
-  claudeChildPid?: number
-  homeDir?: string
-  sessionRegistryTimeoutMs?: number
-  sessionRegistryPollMs?: number
-}
-
-const DEFAULT_FIRST_FILE_TIMEOUT_MS = 20_000
-const DEFAULT_POLL_INTERVAL_MS = 50
-const DEFAULT_SESSION_REGISTRY_TIMEOUT_MS = 2_000
-const DEFAULT_SESSION_REGISTRY_POLL_MS = 20
-
-export async function startTranscriptStream(args: StartTranscriptStreamArgs): Promise<TranscriptStream> {
-  const lineQueue: string[] = []
-  const lineWaiters: Array<(r: IteratorResult<string, undefined>) => void> = []
-  let buffer = ""
-  let position = 0
-  let closed = false
-  let pollTimer: ReturnType<typeof setInterval> | null = null
-
-  function pushLine(line: string) {
-    const w = lineWaiters.shift()
-    if (w) w({ value: line, done: false })
-    else lineQueue.push(line)
-  }
-
-  function endLines() {
-    const done: IteratorReturnResult<undefined> = { value: undefined, done: true }
-    while (lineWaiters.length > 0) {
-      const w = lineWaiters.shift()
-      if (w) w(done)
-    }
-  }
-
-  async function readNewBytes(filePath: string) {
-    try {
-      const s = await stat(filePath)
-      if (s.size <= position) return
-      const fd = await open(filePath, "r")
-      try {
-        const length = s.size - position
-        const buf = Buffer.alloc(length)
-        await fd.read(buf, 0, length, position)
-        position = s.size
-        buffer += buf.toString("utf8")
-        const parts = buffer.split("\n")
-        buffer = parts.pop() ?? ""
-        for (const line of parts) {
-          if (line.length === 0) continue
-          pushLine(line)
-        }
-      } finally {
-        await fd.close()
-      }
-    } catch {
-    }
-  }
-
-  function startFollowing(filePath: string) {
-    const interval = args.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS
-    pollTimer = setInterval(() => { void readNewBytes(filePath) }, interval)
-    void readNewBytes(filePath)
-  }
-
-  async function locateFirstFile(): Promise<string> {
-    if (args.knownFilePath) return args.knownFilePath
-    if (args.claudeChildPid && args.homeDir) {
-      const entry = await awaitClaudeSessionForPid({
-        homeDir: args.homeDir,
-        pid: args.claudeChildPid,
-        timeoutMs: args.sessionRegistryTimeoutMs ?? DEFAULT_SESSION_REGISTRY_TIMEOUT_MS,
-        pollIntervalMs: args.sessionRegistryPollMs ?? DEFAULT_SESSION_REGISTRY_POLL_MS,
-      })
-      if (entry) {
-        const computed = computeJsonlPath({
-          homeDir: args.homeDir,
-          cwd: entry.cwd,
-          sessionId: entry.sessionId,
-        })
-        const jsonlPollMs = args.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS
-        const jsonlTimeoutMs = args.firstFileTimeoutMs ?? DEFAULT_FIRST_FILE_TIMEOUT_MS
-        const jsonlPollStart = Date.now()
-        while (!closed) {
-          if (existsSync(computed)) return computed
-          if (Date.now() - jsonlPollStart > jsonlTimeoutMs) {
-            throw new Error(
-              `registry-resolved JSONL ${computed} did not appear in ${jsonlTimeoutMs}ms (claude TUI likely missed first prompt)`,
-            )
-          }
-          await new Promise((r) => setTimeout(r, jsonlPollMs))
-        }
-        throw new Error("transcript stream closed before registry-resolved JSONL appeared")
-      }
-    }
-    const timeoutMs = args.firstFileTimeoutMs ?? DEFAULT_FIRST_FILE_TIMEOUT_MS
-    const findOpts = { minMtimeMs: args.minMtimeMs }
-    const existing = await findLatestTranscript(args.projectDir, findOpts)
-    if (existing) return existing
-    return new Promise<string>((resolve, reject) => {
-      const start = Date.now()
-      const pollMs = args.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS
-      const timer = setInterval(async () => {
-        if (closed) {
-          clearInterval(timer)
-          reject(new Error("transcript stream closed before first file appeared"))
-          return
-        }
-        if (Date.now() - start > timeoutMs) {
-          clearInterval(timer)
-          reject(new Error(`transcript file did not appear in ${timeoutMs}ms under ${args.projectDir}`))
-          return
-        }
-        const found = await findLatestTranscript(args.projectDir, findOpts)
-        if (found) {
-          clearInterval(timer)
-          resolve(found)
-        }
-      }, pollMs)
-    })
-  }
-
-  const filePathPromise = locateFirstFile()
-  void filePathPromise
-    .then((fp) => { if (!closed) startFollowing(fp) })
-    .catch(() => {
-    })
-
-  const lines: AsyncIterable<string> = {
-    [Symbol.asyncIterator]() {
-      return {
-        next(): Promise<IteratorResult<string, undefined>> {
-          if (lineQueue.length > 0) {
-            const v = lineQueue.shift()
-            if (v !== undefined) return Promise.resolve({ value: v, done: false })
-          }
-          if (closed) return Promise.resolve({ value: undefined, done: true as const })
-          return new Promise((resolve) => lineWaiters.push(resolve))
-        },
-      }
-    },
-  }
-
-  return {
-    lines,
-    filePath: filePathPromise,
-    close() {
-      if (closed) return
-      closed = true
-      if (pollTimer) clearInterval(pollTimer)
-      endLines()
-    },
-  }
-}
-
-export async function waitForResultEntry(
-  stream: TranscriptStream,
-  opts: { timeoutMs?: number; signal?: AbortSignal } = {},
-): Promise<{ rawLine: string; parsed: { type: string } }> {
-  const timeoutMs = opts.timeoutMs
-  return new Promise((resolve, reject) => {
-    let settled = false
-
-    const timer = timeoutMs !== undefined
-      ? setTimeout(() => {
-          if (settled) return
-          settled = true
-          stream.close()
-          reject(new Error(`waitForResultEntry timed out after ${timeoutMs}ms`))
-        }, timeoutMs)
-      : null
-
-    const onAbort = () => {
-      if (settled) return
-      settled = true
-      if (timer) clearTimeout(timer)
-      stream.close()
-      reject(new Error("aborted"))
-    }
-
-    if (opts.signal) {
-      if (opts.signal.aborted) {
-        onAbort()
-        return
-      }
-      opts.signal.addEventListener("abort", onAbort, { once: true })
-    }
-
-    async function consume() {
-      try {
-        for await (const line of stream.lines) {
-          if (settled) return
-          let parsed: {
-            type?: string
-            subtype?: string
-            error?: string
-            isApiErrorMessage?: boolean
-            apiErrorStatus?: number
-            isSidechain?: boolean
-            message?: { stop_reason?: string | null }
-          }
-          try { parsed = JSON.parse(line) } catch { continue }
-          const stopReason = parsed.message?.stop_reason
-          const isTerminalAssistant =
-            parsed.type === "assistant" &&
-            parsed.isSidechain !== true &&
-            typeof stopReason === "string" &&
-            ["end_turn", "stop_sequence", "max_tokens", "refusal"].includes(stopReason)
-          const isTurnEnd =
-            parsed.type === "result" ||
-            (parsed.type === "system" && parsed.subtype === "turn_duration") ||
-            isTerminalAssistant
-          if (isTurnEnd) {
-            settled = true
-            if (timer) clearTimeout(timer)
-            if (opts.signal) opts.signal.removeEventListener("abort", onAbort)
-            resolve({ rawLine: line, parsed: { type: parsed.type ?? "result" } })
-            return
-          }
-          if (parsed.type === "assistant" && parsed.isApiErrorMessage && parsed.apiErrorStatus === 429) {
-            settled = true
-            if (timer) clearTimeout(timer)
-            if (opts.signal) opts.signal.removeEventListener("abort", onAbort)
-            const rlErr: Error & { code: string } = Object.assign(new Error("rate_limited"), { code: "rate_limited" })
-            reject(rlErr)
-            return
-          }
-        }
-        if (!settled) {
-          settled = true
-          if (timer) clearTimeout(timer)
-          if (opts.signal) opts.signal.removeEventListener("abort", onAbort)
-          reject(new Error("transcript stream ended before result entry"))
-        }
-      } catch (err) {
-        if (!settled) {
-          settled = true
-          if (timer) clearTimeout(timer)
-          if (opts.signal) opts.signal.removeEventListener("abort", onAbort)
-          reject(err)
-        }
-      }
-    }
-
-    void consume()
-  })
-}

package/src/server/http-server.adapter.test.ts

@@ -1,18 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { closeHttpServer, createHttpServer } from "./http-server.adapter"
-
-describe("createHttpServer", () => {
-  test("disables socket reaping so long-lived SSE streams survive idle", async () => {
-    const server = createHttpServer((_req, res) => {
-      res.statusCode = 204
-      res.end()
-    })
-    try {
-      expect(server.requestTimeout).toBe(0)
-      expect(server.timeout).toBe(0)
-      expect(server.keepAliveTimeout).toBe(0)
-    } finally {
-      await closeHttpServer(server)
-    }
-  })
-})

package/src/server/http-server.adapter.ts

@@ -1,39 +0,0 @@
-import http from "node:http"
-import type { AddressInfo } from "node:net"
-
-export type HttpRequestHandler = (req: http.IncomingMessage, res: http.ServerResponse) => void
-
-export interface HttpServerHandle {
-  port: number
-  close: () => Promise<void>
-}
-
-export function createHttpServer(handler: HttpRequestHandler) {
-  const server = http.createServer(handler)
-  server.requestTimeout = 0
-  server.timeout = 0
-  server.keepAliveTimeout = 0
-  return server
-}
-
-export function listen(server: http.Server, port: number, host: string): Promise<AddressInfo> {
-  return new Promise<AddressInfo>((resolve, reject) => {
-    server.once("error", reject)
-    server.listen(port, host, () => {
-      server.off("error", reject)
-      const addr = server.address()
-      if (!addr || typeof addr !== "object") { reject(new Error("server.address() is not an AddressInfo")); return }
-      resolve(addr)
-    })
-  })
-}
-
-export function closeHttpServer(server: http.Server): Promise<void> {
-  return new Promise<void>((resolve) => {
-    server.close(() => resolve())
-  })
-}
-
-export type HttpServer = http.Server
-export type HttpIncomingMessage = http.IncomingMessage
-export type HttpServerResponse = http.ServerResponse

package/src/server/kanna-mcp-http.test.ts

@@ -1,274 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { startKannaMcpHttpServer, buildMcpConfigJson, buildChannelNotification } from "./kanna-mcp-http"
-import type { McpServerConfig } from "../shared/types"
-
-const baseArgs = {
-  projectId: "proj-test",
-  localPath: "/tmp",
-  chatId: "chat-test",
-  sessionId: "sess-test",
-  tunnelGateway: null,
-}
-
-describe("startKannaMcpHttpServer", () => {
-  test("binds loopback on ephemeral port and exposes a /mcp URL", async () => {
-    const handle = await startKannaMcpHttpServer({ args: baseArgs })
-    try {
-      expect(handle.url).toMatch(/^http:\/\/127\.0\.0\.1:\d+\/mcp$/)
-      expect(handle.bearerToken).toHaveLength(64)
-    } finally {
-      await handle.close()
-    }
-  })
-
-  test("rejects requests without Authorization header (401)", async () => {
-    const handle = await startKannaMcpHttpServer({ args: baseArgs })
-    try {
-      const res = await fetch(handle.url, { method: "POST", body: "{}" })
-      expect(res.status).toBe(401)
-    } finally {
-      await handle.close()
-    }
-  })
-
-  test("rejects requests with mismatched Bearer token (401)", async () => {
-    const handle = await startKannaMcpHttpServer({ args: baseArgs })
-    try {
-      const res = await fetch(handle.url, {
-        method: "POST",
-        headers: { Authorization: "Bearer wrong-token" },
-        body: "{}",
-      })
-      expect(res.status).toBe(401)
-    } finally {
-      await handle.close()
-    }
-  })
-
-  test("rejects requests with non-Bearer scheme (401)", async () => {
-    const handle = await startKannaMcpHttpServer({ args: baseArgs })
-    try {
-      const res = await fetch(handle.url, {
-        method: "POST",
-        headers: { Authorization: `Basic ${handle.bearerToken}` },
-        body: "{}",
-      })
-      expect(res.status).toBe(401)
-    } finally {
-      await handle.close()
-    }
-  })
-
-  test("forwards requests past auth when Bearer matches", async () => {
-    const handle = await startKannaMcpHttpServer({ args: baseArgs })
-    try {
-      const res = await fetch(handle.url, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${handle.bearerToken}`,
-          "Content-Type": "application/json",
-          Accept: "application/json, text/event-stream",
-        },
-        body: JSON.stringify({
-          jsonrpc: "2.0",
-          id: 1,
-          method: "initialize",
-          params: {
-            protocolVersion: "2024-11-05",
-            capabilities: {},
-            clientInfo: { name: "kanna-pty-test", version: "0.0.0" },
-          },
-        }),
-      })
-      expect(res.status).not.toBe(401)
-    } finally {
-      await handle.close()
-    }
-  })
-
-  test("close() shuts down the listener so subsequent requests fail", async () => {
-    const handle = await startKannaMcpHttpServer({ args: baseArgs })
-    const url = handle.url
-    await handle.close()
-    await expect(
-      fetch(url, {
-        method: "POST",
-        headers: { Authorization: `Bearer ${handle.bearerToken}` },
-        body: "{}",
-      }),
-    ).rejects.toBeDefined()
-  })
-
-  test("close() is idempotent", async () => {
-    const handle = await startKannaMcpHttpServer({ args: baseArgs })
-    await handle.close()
-    await handle.close()
-  })
-})
-
-describe("buildChannelNotification", () => {
-  test("builds a notifications/claude/channel payload with kanna source", () => {
-    const n = buildChannelNotification("do the thing")
-    expect(n.method).toBe("notifications/claude/channel")
-    expect(n.params.content).toBe("do the thing")
-    expect(n.params.meta).toEqual({ source: "kanna" })
-  })
-
-  test("merges extra meta but keeps source=kanna", () => {
-    const n = buildChannelNotification("x", { eventType: "delegate" })
-    expect(n.params.meta).toEqual({ source: "kanna", eventType: "delegate" })
-  })
-})
-
-describe("buildMcpConfigJson", () => {
-  test("encodes http MCP server config with Bearer header", () => {
-    const json = buildMcpConfigJson({
-      url: "http://127.0.0.1:55555/mcp",
-      bearerToken: "abcdef0123456789",
-    })
-    const parsed = JSON.parse(json)
-    expect(parsed.mcpServers.kanna.type).toBe("http")
-    expect(parsed.mcpServers.kanna.url).toBe("http://127.0.0.1:55555/mcp")
-    expect(parsed.mcpServers.kanna.headers.Authorization).toBe("Bearer abcdef0123456789")
-  })
-})
-
-describe("startKannaMcpHttpServer channel surface", () => {
-  const channelArgs = {
-    projectId: "p1",
-    localPath: "/tmp",
-    chatId: "c1",
-    sessionId: "s1",
-    tunnelGateway: null,
-    forceInteractiveToolCallbacks: true,
-  } as unknown as Parameters<typeof startKannaMcpHttpServer>[0]["args"]
-
-  test("handle exposes pushChannelPrompt + channelClientReady", async () => {
-    const handle = await startKannaMcpHttpServer({ args: channelArgs, port: 0 })
-    try {
-      expect(typeof handle.pushChannelPrompt).toBe("function")
-      expect(handle.channelClientReady).toBeInstanceOf(Promise)
-    } finally {
-      await handle.close()
-    }
-  })
-
-  test("pushChannelPrompt does not throw before a client connects (no-op safe)", async () => {
-    const handle = await startKannaMcpHttpServer({ args: channelArgs, port: 0 })
-    try {
-      await handle.pushChannelPrompt("hello")
-    } finally {
-      await handle.close()
-    }
-  })
-})
-
-const HANDLE = { url: "http://127.0.0.1:1234/mcp", bearerToken: "tok" }
-
-function stdio(name: string, command = "/bin/ls", enabled = true): McpServerConfig {
-  return {
-    id: name,
-    name,
-    enabled,
-    createdAt: "", updatedAt: "",
-    lastTest: { status: "untested" },
-    transport: "stdio",
-    command,
-    args: ["-la"],
-    env: { FOO: "bar" },
-  }
-}
-
-describe("buildMcpConfigJson — user servers", () => {
-  test("no user servers keeps just kanna", () => {
-    const json = JSON.parse(buildMcpConfigJson(HANDLE))
-    expect(Object.keys(json.mcpServers)).toEqual(["kanna"])
-  })
-
-  test("stdio user entry included with correct shape", () => {
-    const json = JSON.parse(buildMcpConfigJson(HANDLE, [stdio("fs")]))
-    expect(json.mcpServers.fs).toEqual({
-      type: "stdio",
-      command: "/bin/ls",
-      args: ["-la"],
-      env: { FOO: "bar" },
-    })
-  })
-
-  test("stdio with cwd includes cwd", () => {
-    const cfg: McpServerConfig = { ...stdio("fs"), cwd: "/tmp/work" } as McpServerConfig
-    const json = JSON.parse(buildMcpConfigJson(HANDLE, [cfg]))
-    expect(json.mcpServers.fs.cwd).toBe("/tmp/work")
-  })
-
-  test("disabled entries dropped", () => {
-    const json = JSON.parse(buildMcpConfigJson(HANDLE, [stdio("fs", "/bin/ls", false)]))
-    expect(json.mcpServers.fs).toBeUndefined()
-  })
-
-  test("collision with KANNA_MCP_SERVER_NAME filtered", () => {
-    const json = JSON.parse(buildMcpConfigJson(HANDLE, [stdio("kanna")]))
-    expect(Object.keys(json.mcpServers)).toEqual(["kanna"])
-    expect(json.mcpServers.kanna.url).toBe("http://127.0.0.1:1234/mcp")
-  })
-
-  test("http user entry passes headers", () => {
-    const cfg: McpServerConfig = {
-      id: "x", name: "remote", enabled: true,
-      createdAt: "", updatedAt: "", lastTest: { status: "untested" },
-      transport: "http", url: "https://api.example.com/mcp", headers: { "x-key": "secret" },
-    }
-    const json = JSON.parse(buildMcpConfigJson(HANDLE, [cfg]))
-    expect(json.mcpServers.remote).toEqual({
-      type: "http",
-      url: "https://api.example.com/mcp",
-      headers: { "x-key": "secret" },
-    })
-  })
-
-  test("sse user entry uses type: sse", () => {
-    const cfg: McpServerConfig = {
-      id: "s", name: "events", enabled: true,
-      createdAt: "", updatedAt: "", lastTest: { status: "untested" },
-      transport: "sse", url: "https://example.com/sse", headers: {},
-    }
-    const json = JSON.parse(buildMcpConfigJson(HANDLE, [cfg]))
-    expect(json.mcpServers.events.type).toBe("sse")
-  })
-
-  test("ws user entry uses type: ws", () => {
-    const cfg: McpServerConfig = {
-      id: "w", name: "wsx", enabled: true,
-      createdAt: "", updatedAt: "", lastTest: { status: "untested" },
-      transport: "ws", url: "wss://example.com/ws", headers: {},
-    }
-    const json = JSON.parse(buildMcpConfigJson(HANDLE, [cfg]))
-    expect(json.mcpServers.wsx.type).toBe("ws")
-  })
-
-  test("multiple servers preserved in order", () => {
-    const json = JSON.parse(buildMcpConfigJson(HANDLE, [stdio("a"), stdio("b"), stdio("c")]))
-    expect(Object.keys(json.mcpServers)).toEqual(["kanna", "a", "b", "c"])
-  })
-
-  test("injects oauth bearer header for authenticated server", () => {
-    const cfg: McpServerConfig = {
-      id: "s1", name: "design", enabled: true,
-      createdAt: "", updatedAt: "", lastTest: { status: "untested" },
-      transport: "http", url: "https://api.example/mcp", headers: {},
-      oauth: { enabled: true, status: "authenticated", tokens: { access_token: "AT", token_type: "Bearer" } as never },
-    }
-    const json = JSON.parse(buildMcpConfigJson(HANDLE, [cfg], new Map([["s1", "AT"]])))
-    expect(json.mcpServers.design.headers.Authorization).toBe("Bearer AT")
-  })
-
-  test("omits Authorization when no bearer resolved", () => {
-    const cfg: McpServerConfig = {
-      id: "s2", name: "plain", enabled: true,
-      createdAt: "", updatedAt: "", lastTest: { status: "untested" },
-      transport: "http", url: "https://api.example/mcp", headers: {},
-    }
-    const json = JSON.parse(buildMcpConfigJson(HANDLE, [cfg], new Map()))
-    expect(json.mcpServers.plain.headers?.Authorization).toBeUndefined()
-  })
-})