@cuongtran001/kanna 1.63.2 → 1.63.3

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

@@ -1,194 +0,0 @@
-import { registerSdkToolOnMcpServer } from "./mcp-zod-compat.adapter"
-import { randomBytes, randomUUID } from "node:crypto"
-import { closeHttpServer, createHttpServer, listen, type HttpIncomingMessage } from "./http-server.adapter"
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js"
-import type { ServerNotification } from "@modelcontextprotocol/sdk/types.js"
-import { KANNA_MCP_SERVER_NAME } from "../shared/tools"
-import { buildKannaMcpTools, type KannaMcpArgs } from "./kanna-mcp"
-import type { McpServerConfig } from "../shared/types"
-import type { JsonObject } from "../shared/json"
-
-function isServerNotification(
-  value: ChannelNotification,
-): value is ChannelNotification & ServerNotification {
-  return typeof value.method === "string"
-}
-
-export interface ChannelNotification {
-  method: "notifications/claude/channel"
-  params: { content: string; meta: JsonObject; _meta?: JsonObject }
-}
-
-export function buildChannelNotification(
-  content: string,
-  meta: JsonObject = {},
-): ChannelNotification {
-  return {
-    method: "notifications/claude/channel",
-    params: { content, meta: { source: KANNA_MCP_SERVER_NAME, ...meta } },
-  }
-}
-
-export interface KannaMcpHttpHandle {
-  url: string
-  bearerToken: string
-  close: () => Promise<void>
-  channelClientReady: Promise<void>
-  pushChannelPrompt: (content: string, meta?: JsonObject) => Promise<void>
-}
-
-export interface StartKannaMcpHttpServerOptions {
-  args: KannaMcpArgs
-  host?: string
-  port?: number
-}
-
-export async function startKannaMcpHttpServer(
-  opts: StartKannaMcpHttpServerOptions,
-): Promise<KannaMcpHttpHandle> {
-  const bearerToken = randomBytes(32).toString("hex")
-  const host = opts.host ?? "127.0.0.1"
-  const port = opts.port ?? 0
-
-  const mcp = new McpServer(
-    { name: KANNA_MCP_SERVER_NAME, version: "1.0.0" },
-    {
-      capabilities: {
-        experimental: {
-          "claude/channel": {},
-          "claude/channel/permission": {},
-        },
-      },
-    },
-  )
-
-  const tools = buildKannaMcpTools(opts.args)
-  for (const def of tools) {
-    registerSdkToolOnMcpServer(mcp, def)
-  }
-
-  const transport = new StreamableHTTPServerTransport({
-    sessionIdGenerator: () => randomUUID(),
-  })
-  await mcp.connect(transport)
-
-  let resolveReady: () => void = () => {}
-  const channelClientReady = new Promise<void>((resolve) => {
-    resolveReady = resolve
-  })
-  mcp.server.oninitialized = () => {
-    resolveReady()
-  }
-
-  const pushChannelPrompt = async (
-    content: string,
-    meta: JsonObject = {},
-  ): Promise<void> => {
-    const notification = buildChannelNotification(content, meta)
-    try {
-      if (isServerNotification(notification)) {
-        await mcp.server.notification(notification)
-      }
-    } catch (err) {
-      if (mcp.isConnected()) throw err
-    }
-  }
-
-  const httpServer = createHttpServer((req, res) => {
-    if (!authorize(req, bearerToken)) {
-      res.statusCode = 401
-      res.setHeader("WWW-Authenticate", "Bearer")
-      res.end("unauthorized")
-      return
-    }
-    void transport.handleRequest(req, res).catch((err) => {
-      if (!res.headersSent) {
-        res.statusCode = 500
-        res.end(String(err))
-      }
-    })
-  })
-
-  let address
-  try {
-    address = await listen(httpServer, port, host)
-  } catch (err) {
-    try { await transport.close() } catch { }
-    throw err
-  }
-
-  const url = `http://${host}:${address.port}/mcp`
-
-  let closed = false
-  const close = async (): Promise<void> => {
-    if (closed) return
-    closed = true
-    try {
-      await transport.close()
-    } catch {
-    }
-    await closeHttpServer(httpServer)
-  }
-
-  return { url, bearerToken, close, channelClientReady, pushChannelPrompt }
-}
-
-function authorize(req: HttpIncomingMessage, bearerToken: string): boolean {
-  const header = req.headers.authorization
-  if (!header || typeof header !== "string") return false
-  const prefix = "Bearer "
-  if (!header.startsWith(prefix)) return false
-  const supplied = header.slice(prefix.length).trim()
-  return constantTimeEqual(supplied, bearerToken)
-}
-
-function constantTimeEqual(a: string, b: string): boolean {
-  if (a.length !== b.length) return false
-  let mismatch = 0
-  for (let i = 0; i < a.length; i++) {
-    mismatch |= a.charCodeAt(i) ^ b.charCodeAt(i)
-  }
-  return mismatch === 0
-}
-
-
-export function buildMcpConfigJson(
-  handle: { url: string; bearerToken: string },
-  userServers: readonly McpServerConfig[] = [],
-  oauthBearers: ReadonlyMap<string, string> = new Map(),
-): string {
-  const mcpServers: Record<string, JsonObject> = {
-    [KANNA_MCP_SERVER_NAME]: {
-      type: "http",
-      url: handle.url,
-      headers: {
-        Authorization: `Bearer ${handle.bearerToken}`,
-      },
-    },
-  }
-  for (const s of userServers) {
-    if (!s.enabled) continue
-    if (s.name === KANNA_MCP_SERVER_NAME) continue
-    mcpServers[s.name] = toClaudeCliMcpEntry(s, oauthBearers.get(s.id))
-  }
-  return JSON.stringify({ mcpServers })
-}
-
-function toClaudeCliMcpEntry(s: McpServerConfig, oauthBearer?: string): JsonObject {
-  if (s.transport === "stdio") {
-    return {
-      type: "stdio",
-      command: s.command,
-      args: s.args,
-      env: s.env,
-      ...(s.cwd ? { cwd: s.cwd } : {}),
-    }
-  }
-  const headers = oauthBearer ? { ...s.headers, Authorization: `Bearer ${oauthBearer}` } : s.headers
-  return {
-    type: s.transport,
-    url: s.url,
-    headers,
-  }
-}

package/src/server/kanna-mcp-tools/ask-user-question.test.ts

@@ -1,108 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { mkdtemp, rm } from "node:fs/promises"
-import { tmpdir } from "node:os"
-import path from "node:path"
-import { POLICY_DEFAULT } from "../../shared/permission-policy"
-import { createToolCallbackService } from "../tool-callback"
-import { createTestEventStore } from "../storage/test-helpers"
-import { createAskUserQuestionTool } from "./ask-user-question"
-
-async function newStore() {
-  const dir = await mkdtemp(path.join(tmpdir(), "kanna-mcp-aq-"))
-  const store = createTestEventStore(dir)
-  await store.initialize()
-  const cleanup = async () => {
-    await new Promise<void>((r) => setTimeout(r, 50))
-    await rm(dir, { recursive: true, force: true })
-  }
-  return { store, dir, cleanup }
-}
-
-const handlerCtx = () => ({
-  chatId: "c1",
-  sessionId: "s1",
-  toolUseId: "tu1",
-  cwd: "/tmp",
-  chatPolicy: POLICY_DEFAULT,
-})
-
-describe("mcp__kanna__ask_user_question", () => {
-  test("calls policy.evaluate then routes to tool-callback", async () => {
-    const { store, cleanup } = await newStore()
-    try {
-      const svc = createToolCallbackService({
-        store, serverSecret: "k", now: () => 1,
-      })
-      const tool = createAskUserQuestionTool({ toolCallback: svc })
-      const inputArgs = {
-        questions: [{
-          text: "ok?",
-          header: "OK",
-          options: [{ label: "yes", description: "" }, { label: "no", description: "" }],
-          multiSelect: false,
-        }],
-      }
-      const promise = tool.handler(inputArgs, handlerCtx())
-      const pending = await store.listPendingToolRequests("c1")
-      expect(pending).toHaveLength(1)
-      await svc.answer(pending[0].id, { kind: "answer", payload: { answers: { "ok?": "yes" } } })
-      const result = await promise
-      expect(result.content[0].type).toBe("text")
-      expect(JSON.parse(result.content[0].text).answers).toEqual({ "ok?": "yes" })
-      expect(result.isError).toBeFalsy()
-    } finally { await cleanup() }
-  })
-
-  test("auto-deny chatPolicy still routes through ask (UI), denial only via cancel/cancelAllForChat", async () => {
-    const { store, cleanup } = await newStore()
-    try {
-      const svc = createToolCallbackService({
-        store, serverSecret: "k", now: () => 1,
-      })
-      const tool = createAskUserQuestionTool({ toolCallback: svc })
-      const promise = tool.handler(
-        {
-          questions: [{
-            text: "x",
-            header: "X",
-            options: [{ label: "a", description: "" }, { label: "b", description: "" }],
-            multiSelect: false,
-          }],
-        },
-        { ...handlerCtx(), chatPolicy: { ...POLICY_DEFAULT, defaultAction: "auto-deny" } },
-      )
-      const pending = await store.listPendingToolRequests("c1")
-      expect(pending).toHaveLength(1)
-      await svc.cancelAllForChat("c1", "user-cancel")
-      const result = await promise
-      expect(result.isError).toBe(true)
-      expect(result.content[0].type).toBe("text")
-      expect(typeof result.content[0].text).toBe("string")
-    } finally { await cleanup() }
-  })
-
-  test("answer decision with no payload → throws loudly (no silent {} coercion)", async () => {
-    const { store, cleanup } = await newStore()
-    try {
-      const svc = createToolCallbackService({
-        store, serverSecret: "k", now: () => 1,
-      })
-      const tool = createAskUserQuestionTool({ toolCallback: svc })
-      const promise = tool.handler(
-        {
-          questions: [{
-            text: "ok?",
-            header: "OK",
-            options: [{ label: "yes", description: "" }, { label: "no", description: "" }],
-            multiSelect: false,
-          }],
-        },
-        handlerCtx(),
-      )
-      const pending = await store.listPendingToolRequests("c1")
-      expect(pending).toHaveLength(1)
-      await svc.answer(pending[0].id, { kind: "allow" as const })
-      await expect(promise).rejects.toThrow(/empty answer payload/i)
-    } finally { await cleanup() }
-  })
-})

package/src/server/kanna-mcp-tools/ask-user-question.ts

@@ -1,55 +0,0 @@
-import { z } from "zod"
-import type { ToolCallbackService } from "../tool-callback"
-import type { ToolHandlerContext, ToolHandlerResult } from "./tool-callback-shim"
-import { gatedToolCall } from "./tool-callback-shim"
-
-const QuestionSchema = z.object({
-  text: z.string(),
-  header: z.string(),
-  options: z.array(z.object({ label: z.string(), description: z.string() })).min(2).max(4),
-  multiSelect: z.boolean(),
-})
-
-const InputSchema = z.object({
-  questions: z.array(QuestionSchema).min(1).max(4),
-})
-
-export type AskUserQuestionInput = z.infer<typeof InputSchema>
-
-export interface AskUserQuestionTool {
-  name: "ask_user_question"
-  schema: typeof InputSchema
-  handler: (input: AskUserQuestionInput, ctx: ToolHandlerContext) => Promise<ToolHandlerResult>
-}
-
-export function createAskUserQuestionTool(deps: { toolCallback: ToolCallbackService }): AskUserQuestionTool {
-  return {
-    name: "ask_user_question",
-    schema: InputSchema,
-    async handler(input, ctx) {
-      return gatedToolCall({
-        toolCallback: deps.toolCallback,
-        toolName: "mcp__kanna__ask_user_question",
-        ctx,
-        args: input,
-        formatAnswer: (payload) => {
-          if (payload === undefined || payload === null || typeof payload !== "object") {
-            throw new Error(
-              "mcp__kanna__ask_user_question: empty answer payload "
-              + `(received ${payload === undefined ? "undefined" : typeof payload}). `
-              + "This means the policy gate or tool-callback resolved the request without a user response — "
-              + "interactive tools must always go through the ask/UI path. See issue #215.",
-            )
-          }
-          return {
-            content: [{ type: "text" as const, text: JSON.stringify(payload) }],
-          }
-        },
-        formatDeny: (reason) => ({
-          content: [{ type: "text" as const, text: `Denied: ${reason}` }],
-          isError: true,
-        }),
-      })
-    },
-  }
-}

package/src/server/kanna-mcp-tools/exit-plan-mode.test.ts

@@ -1,61 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { mkdtemp, rm } from "node:fs/promises"
-import { tmpdir } from "node:os"
-import path from "node:path"
-import { POLICY_DEFAULT } from "../../shared/permission-policy"
-import { createToolCallbackService } from "../tool-callback"
-import { createTestEventStore } from "../storage/test-helpers"
-import { createExitPlanModeTool } from "./exit-plan-mode"
-
-async function newStore() {
-  const dir = await mkdtemp(path.join(tmpdir(), "kanna-mcp-epm-"))
-  const store = createTestEventStore(dir)
-  await store.initialize()
-  const cleanup = async () => {
-    await new Promise<void>((r) => setTimeout(r, 50))
-    await rm(dir, { recursive: true, force: true })
-  }
-  return { store, dir, cleanup }
-}
-
-const handlerCtx = () => ({
-  chatId: "c",
-  sessionId: "s",
-  toolUseId: "tu",
-  cwd: "/tmp",
-  chatPolicy: POLICY_DEFAULT,
-})
-
-describe("mcp__kanna__exit_plan_mode", () => {
-  test("confirmed answer → returns success content", async () => {
-    const { store, cleanup } = await newStore()
-    try {
-      const svc = createToolCallbackService({
-        store, serverSecret: "k", now: () => 1,
-      })
-      const tool = createExitPlanModeTool({ toolCallback: svc })
-      const promise = tool.handler({ plan: "do x" }, handlerCtx())
-      const pending = await store.listPendingToolRequests("c")
-      await svc.answer(pending[0].id, { kind: "answer", payload: { confirmed: true } })
-      const result = await promise
-      expect(result.isError).toBeFalsy()
-      expect(result.content[0].text).toContain("confirmed")
-    } finally { await cleanup() }
-  })
-
-  test("rejected with message → isError true with message", async () => {
-    const { store, cleanup } = await newStore()
-    try {
-      const svc = createToolCallbackService({
-        store, serverSecret: "k", now: () => 1,
-      })
-      const tool = createExitPlanModeTool({ toolCallback: svc })
-      const promise = tool.handler({ plan: "do x" }, handlerCtx())
-      const pending = await store.listPendingToolRequests("c")
-      await svc.answer(pending[0].id, { kind: "answer", payload: { confirmed: false, message: "tweak step 3" } })
-      const result = await promise
-      expect(result.isError).toBe(true)
-      expect(result.content[0].text).toContain("tweak step 3")
-    } finally { await cleanup() }
-  })
-})

package/src/server/kanna-mcp-tools/exit-plan-mode.ts

@@ -1,49 +0,0 @@
-import { z } from "zod"
-import type { ToolCallbackService } from "../tool-callback"
-import type { ToolHandlerContext, ToolHandlerResult } from "./tool-callback-shim"
-import { gatedToolCall } from "./tool-callback-shim"
-import { isRecord } from "../../shared/errors"
-
-const InputSchema = z.object({
-  plan: z.string(),
-})
-
-export type ExitPlanModeInput = z.infer<typeof InputSchema>
-
-export interface ExitPlanModeTool {
-  name: "exit_plan_mode"
-  schema: typeof InputSchema
-  handler: (input: ExitPlanModeInput, ctx: ToolHandlerContext) => Promise<ToolHandlerResult>
-}
-
-export function createExitPlanModeTool(deps: { toolCallback: ToolCallbackService }): ExitPlanModeTool {
-  return {
-    name: "exit_plan_mode",
-    schema: InputSchema,
-    async handler(input, ctx) {
-      return gatedToolCall({
-        toolCallback: deps.toolCallback,
-        toolName: "mcp__kanna__exit_plan_mode",
-        ctx,
-        args: input,
-        formatAnswer: (payload) => {
-          const record = isRecord(payload) ? payload : {}
-          if (record.confirmed) {
-            return {
-              content: [{ type: "text" as const, text: JSON.stringify({ confirmed: true }) }],
-            }
-          }
-          const msg = typeof record.message === "string" ? record.message : "User wants to suggest edits."
-          return {
-            content: [{ type: "text" as const, text: msg }],
-            isError: true,
-          }
-        },
-        formatDeny: (reason) => ({
-          content: [{ type: "text" as const, text: `Denied: ${reason}` }],
-          isError: true,
-        }),
-      })
-    },
-  }
-}

package/src/server/mcp-zod-compat.adapter.ts

@@ -1,20 +0,0 @@
-import type { SdkMcpToolDefinition } from "@anthropic-ai/claude-agent-sdk"
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"
-import type { ShapeOutput, ZodRawShapeCompat } from "@modelcontextprotocol/sdk/server/zod-compat.js"
-import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js"
-import type { ServerNotification, ServerRequest } from "@modelcontextprotocol/sdk/types.js"
-
-export function registerSdkToolOnMcpServer(mcp: McpServer, def: SdkMcpToolDefinition): void {
-  const handler = async (
-    input: ShapeOutput<ZodRawShapeCompat>,
-    extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
-  ) => await def.handler(<never>input, <never>extra)
-  mcp.registerTool(
-    def.name,
-    {
-      description: def.description,
-      inputSchema: <ZodRawShapeCompat><unknown>def.inputSchema,
-    },
-    handler,
-  )
-}

package/src/shared/pty-instance.ts

@@ -1,43 +0,0 @@
-export type PtyInstancePhase =
-  | "spawning"
-  | "trust-dialog"
-  | "ready"
-  | "streaming"
-  | "cancelling"
-  | "exited"
-
-export type PtyInstanceSmokeTest = "pending" | "pass" | "fail"
-
-export interface PtyInstanceState {
-  chatId: string
-  sessionId: string | null
-  pid: number | null
-  cwd: string
-  model: string
-  accountLabel: string | null
-  oauthMasked: string | null
-  phase: PtyInstancePhase
-  startedAt: number
-  lastEventAt: number
-  turnCount: number
-  tokensIn: number
-  tokensOut: number
-  planMode: boolean | null
-  smokeTest: PtyInstanceSmokeTest | null
-  outputRingTail: string | null
-  exitedAt: number | null
-  exitCode: number | null
-  rssBytes: number | null
-  rssPeakBytes: number | null
-  cpuPercent: number | null
-  cpuPeakPercent: number | null
-}
-
-export type PtyInstanceDelta =
-  | { type: "added"; instance: PtyInstanceState }
-  | { type: "updated"; instance: PtyInstanceState }
-  | { type: "removed"; chatId: string }
-
-export interface PtyInstancesSnapshot {
-  instances: PtyInstanceState[]
-}