@cuongtran001/kanna 1.63.2 → 1.63.3

package/src/server/claude-pty/parity-matrix.test.ts

@@ -1,437 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { mkdtemp, rm, writeFile, appendFile, mkdir } from "node:fs/promises"
-import { tmpdir } from "node:os"
-import path from "node:path"
-import { createClaudeHarnessStream } from "../agent"
-import type { ClaudeRawSdkMessage } from "../agent"
-import { createJsonlEventParser } from "./jsonl-to-event"
-import { startTranscriptStream } from "./tui-source.adapter"
-import type { HarnessEvent } from "../harness-types"
-import type { CompactBoundaryMetadata } from "../../shared/transcript-types"
-import type { ModelPrice } from "../../shared/token-pricing"
-
-
-function fakeQuery(messages: unknown[]): AsyncGenerator<ClaudeRawSdkMessage> {
-  return (async function* () {
-    for (const m of messages) yield m as ClaudeRawSdkMessage
-  })()
-}
-
-function normalize(events: HarnessEvent[]): unknown[] {
-  return events.map((ev) => {
-    if (ev.type === "transcript") {
-      const { _id: _i, createdAt: _c, ...rest } = ev.entry as unknown as Record<string, unknown> & {
-        _id?: string
-        createdAt?: number
-      }
-      return { type: ev.type, entry: rest }
-    }
-    return ev
-  })
-}
-
-async function collectSdk(messages: unknown[], configuredContextWindow?: number): Promise<HarnessEvent[]> {
-  const events: HarnessEvent[] = []
-  for await (const ev of createClaudeHarnessStream(fakeQuery(messages), configuredContextWindow)) {
-    events.push(ev)
-  }
-  return events
-}
-
-async function ptyEventsViaTranscriptStream(messages: unknown[], configuredContextWindow?: number): Promise<HarnessEvent[]> {
-  const tmpDir = await mkdtemp(path.join(tmpdir(), "kanna-parity-"))
-  const projectDir = path.join(tmpDir, "projects", "fake")
-  await mkdir(projectDir, { recursive: true })
-  const filePath = path.join(projectDir, "fixture.jsonl")
-  await writeFile(filePath, "")
-  const stream = await startTranscriptStream({ projectDir, knownFilePath: filePath, firstFileTimeoutMs: 2000 })
-  const parser = createJsonlEventParser({ configuredContextWindow })
-  const events: HarnessEvent[] = []
-  const writeAll = (async () => {
-    for (const m of messages) {
-      await appendFile(filePath, `${JSON.stringify(m)  }\n`)
-      await new Promise<void>((r) => setTimeout(r, 30))
-    }
-    await appendFile(filePath, '{"type":"__parity_sentinel__"}\n')
-  })()
-  const collectDone = (async () => {
-    for await (const line of stream.lines) {
-      let parsed: { type?: string }
-      try { parsed = JSON.parse(line) as { type?: string } } catch { continue }
-      if (parsed.type === "__parity_sentinel__") break
-      for (const ev of parser.parse(line)) events.push(ev)
-    }
-  })()
-  await writeAll
-  await collectDone
-  stream.close()
-  await rm(tmpDir, { recursive: true, force: true })
-  return events
-}
-
-async function assertSameEvents(messages: unknown[], configuredContextWindow?: number): Promise<void> {
-  const sdk = await collectSdk(messages, configuredContextWindow)
-  const pty = await ptyEventsViaTranscriptStream(messages, configuredContextWindow)
-  expect(normalize(pty)).toEqual(normalize(sdk))
-}
-
-describe("SDK ↔ PTY HarnessEvent equivalence matrix", () => {
-  test("simple turn: system/init → assistant → result", async () => {
-    await assertSameEvents([
-      {
-        type: "system",
-        subtype: "init",
-        session_id: "sess-1",
-        model: "claude-sonnet-4-6",
-        tools: [],
-        mcp_servers: [],
-        slash_commands: [],
-        cwd: "/tmp",
-        permissionMode: "acceptEdits",
-        apiKeySource: "none",
-        claude_code_version: "0.0.0",
-        output_style: "default",
-        skills: [],
-        plugins: [],
-        uuid: "u1",
-      },
-      {
-        type: "assistant",
-        session_id: "sess-1",
-        message: {
-          id: "msg-1",
-          role: "assistant",
-          content: [{ type: "text", text: "hi" }],
-        },
-        usage: { input_tokens: 100, output_tokens: 25 },
-        uuid: "u2",
-      },
-      {
-        type: "result",
-        subtype: "success",
-        session_id: "sess-1",
-        result: "done",
-        is_error: false,
-        duration_ms: 500,
-        usage: { input_tokens: 100, output_tokens: 25 },
-        modelUsage: { "claude-sonnet-4-6": { contextWindow: 200000 } },
-        uuid: "u3",
-      },
-    ])
-  })
-
-  test("rate_limit_event (SDK-native shape)", async () => {
-    await assertSameEvents([
-      {
-        type: "rate_limit_event",
-        session_id: "sess-rl",
-        rate_limit_info: { status: "rejected", resetsAt: 1_748_800_000 },
-      },
-    ])
-  })
-
-  test("prompt-too-long error result", async () => {
-    await assertSameEvents([
-      {
-        type: "result",
-        subtype: "error",
-        session_id: "sess-err",
-        is_error: true,
-        result: "prompt is too long",
-        duration_ms: 0,
-        uuid: "u-err",
-      },
-    ])
-  })
-
-  test("multiple assistant messages dedupe on usage id (same id seen twice)", async () => {
-    await assertSameEvents([
-      {
-        type: "assistant",
-        session_id: "sess-d",
-        message: { id: "dup", role: "assistant", content: [{ type: "text", text: "a" }] },
-        usage: { input_tokens: 10, output_tokens: 3 },
-      },
-      {
-        type: "assistant",
-        session_id: "sess-d",
-        message: { id: "dup", role: "assistant", content: [{ type: "text", text: "a" }] },
-        usage: { input_tokens: 10, output_tokens: 3 },
-      },
-    ])
-  })
-
-  test("1M context window floor preserved against modelUsage.contextWindow=200k", async () => {
-    await assertSameEvents(
-      [
-        {
-          type: "assistant",
-          session_id: "sess-1m",
-          message: { id: "msg-1m", role: "assistant", content: [{ type: "text", text: "x" }] },
-          usage: { input_tokens: 100, output_tokens: 50 },
-        },
-        {
-          type: "result",
-          subtype: "success",
-          session_id: "sess-1m",
-          is_error: false,
-          duration_ms: 500,
-          usage: { input_tokens: 100, output_tokens: 50 },
-          modelUsage: { "claude-sonnet-4-6": { contextWindow: 200000 } },
-        },
-      ],
-      1_000_000,
-    )
-  })
-
-  test("session_token emitted from every message carrying session_id", async () => {
-    await assertSameEvents([
-      { type: "system", subtype: "init", session_id: "a", model: "m", tools: [], mcp_servers: [], slash_commands: [], cwd: "/", permissionMode: "acceptEdits", apiKeySource: "none", claude_code_version: "0", output_style: "d", skills: [], plugins: [], uuid: "1" },
-      { type: "assistant", session_id: "a", message: { id: "m1", role: "assistant", content: [] } },
-      { type: "result", subtype: "success", session_id: "a", is_error: false, duration_ms: 0, uuid: "r" },
-    ])
-  })
-
-  test("rate-limit api_error + error result: result body scrubbed (no duplicate text)", async () => {
-    const limitText = "You've hit your limit · resets 11:10pm (Asia/Saigon)"
-    const sdk = await collectSdk([
-      {
-        type: "assistant",
-        session_id: "sess-rl",
-        uuid: "msg-err",
-        isApiErrorMessage: true,
-        message: {
-          model: "<synthetic>",
-          content: [{ type: "text", text: limitText }],
-        },
-      },
-      {
-        type: "result",
-        subtype: "error",
-        session_id: "sess-rl",
-        is_error: true,
-        result: limitText,
-        duration_ms: 2000,
-        uuid: "r-err",
-      },
-    ])
-    const apiErrorEntries = sdk.flatMap((ev) =>
-      ev.type === "transcript" && ev.entry && ev.entry.kind === "api_error" ? [ev.entry] : [],
-    )
-    const resultEntries = sdk.flatMap((ev) =>
-      ev.type === "transcript" && ev.entry && ev.entry.kind === "result" ? [ev.entry] : [],
-    )
-    expect(apiErrorEntries).toHaveLength(1)
-    expect(apiErrorEntries[0].text).toContain("hit your limit")
-    expect(resultEntries).toHaveLength(1)
-    expect(resultEntries[0].isError).toBe(true)
-    expect(resultEntries[0].result).toBe("")
-    expect(resultEntries[0].durationMs).toBe(2000)
-  })
-
-  test("compact_boundary turn does not produce phantom context_window_updated", async () => {
-    await assertSameEvents([
-      {
-        type: "system",
-        subtype: "compact_boundary",
-        session_id: "sess-c",
-        compact_metadata: { trigger: "auto", pre_tokens: 50000 },
-        uuid: "cb",
-      },
-      {
-        type: "result",
-        subtype: "success",
-        session_id: "sess-c",
-        is_error: false,
-        duration_ms: 100,
-        usage: { input_tokens: 1000, cache_read_input_tokens: 49000, output_tokens: 0 },
-        uuid: "r-c",
-      },
-    ])
-  })
-
-  test("both wire spellings of compact metadata reach the entry identically", async () => {
-    const snakeCaseFromSdkStream = {
-      type: "system",
-      subtype: "compact_boundary",
-      session_id: "sess-d",
-      compact_metadata: { trigger: "auto", pre_tokens: 206978, post_tokens: 7509, duration_ms: 143806 },
-      uuid: "cb-snake",
-    }
-    const camelCaseFromCliTranscript = {
-      type: "system",
-      subtype: "compact_boundary",
-      session_id: "sess-d",
-      compactMetadata: { trigger: "auto", preTokens: 206978, postTokens: 7509, durationMs: 143806 },
-      uuid: "cb-camel",
-    }
-    const expected: CompactBoundaryMetadata = {
-      trigger: "auto",
-      preTokens: 206978,
-      postTokens: 7509,
-      durationMs: 143806,
-    }
-    const boundaryMetadata = (events: HarnessEvent[]): (CompactBoundaryMetadata | undefined)[] =>
-      events.flatMap((event) =>
-        event.type === "transcript" && event.entry.kind === "compact_boundary"
-          ? [event.entry.compactMetadata]
-          : [],
-      )
-
-    for (const message of [snakeCaseFromSdkStream, camelCaseFromCliTranscript]) {
-      await assertSameEvents([message])
-      expect(boundaryMetadata(await collectSdk([message]))).toEqual([expected])
-      expect(boundaryMetadata(await ptyEventsViaTranscriptStream([message]))).toEqual([expected])
-    }
-  })
-})
-
-describe("createClaudeHarnessStream cost attachment", () => {
-  test("claude result cost is attached to the final-turn snapshot", async () => {
-    const messages = [
-      {
-        type: "assistant",
-        session_id: "sess-cost",
-        message: { id: "m1", role: "assistant", content: [] },
-        usage: { input_tokens: 100, output_tokens: 50 },
-      },
-      {
-        type: "result",
-        subtype: "success",
-        session_id: "sess-cost",
-        is_error: false,
-        total_cost_usd: 0.0123,
-        usage: { input_tokens: 100, output_tokens: 50 },
-        duration_ms: 10,
-        num_turns: 1,
-        result: "ok",
-      },
-    ]
-
-    const events: HarnessEvent[] = []
-    for await (const ev of createClaudeHarnessStream(fakeQuery(messages))) {
-      events.push(ev)
-    }
-
-    const cwuEntries = events.flatMap((ev) => {
-      if (ev.type !== "transcript") return []
-      const entry = ev.entry
-      return entry && entry.kind === "context_window_updated" ? [entry] : []
-    })
-    const lastCwu = cwuEntries.at(-1)
-    expect(lastCwu).toBeDefined()
-    expect(lastCwu!.usage.costUsd).toBeCloseTo(0.0123, 6)
-  })
-
-  test("openrouter turn gets computed cost from a price resolver", async () => {
-    const messages = [
-      {
-        type: "assistant",
-        session_id: "sess-or",
-        message: { id: "m1", role: "assistant", content: [] },
-        usage: { input_tokens: 1_000_000, output_tokens: 0 },
-      },
-      {
-        type: "result",
-        subtype: "success",
-        session_id: "sess-or",
-        is_error: false,
-        usage: { input_tokens: 1_000_000, output_tokens: 0 },
-        duration_ms: 10,
-        num_turns: 1,
-        result: "ok",
-      },
-    ]
-
-    const price: ModelPrice = { inputPerMTok: 3, outputPerMTok: 15 }
-    const events: HarnessEvent[] = []
-    for await (const ev of createClaudeHarnessStream(fakeQuery(messages), undefined, () => price)) {
-      events.push(ev)
-    }
-
-    const cwuEntries = events.flatMap((ev) => {
-      if (ev.type !== "transcript") return []
-      const entry = ev.entry
-      return entry && entry.kind === "context_window_updated" ? [entry] : []
-    })
-    const lastCwu = cwuEntries.at(-1)
-    expect(lastCwu).toBeDefined()
-    expect(lastCwu!.usage.costUsd).toBeCloseTo(3, 6)
-  })
-})
-
-describe("result entry usage + cost enrichment", () => {
-  test("claude: result entry carries usage tokens and provider costUsd", async () => {
-    const messages = [
-      {
-        type: "assistant",
-        session_id: "sess-ru",
-        message: { id: "m1", role: "assistant", content: [] },
-        usage: { input_tokens: 200, output_tokens: 80 },
-      },
-      {
-        type: "result",
-        subtype: "success",
-        session_id: "sess-ru",
-        is_error: false,
-        total_cost_usd: 0.02,
-        usage: { input_tokens: 200, output_tokens: 80 },
-        duration_ms: 100,
-        num_turns: 1,
-        result: "done",
-      },
-    ]
-
-    const events: HarnessEvent[] = []
-    for await (const ev of createClaudeHarnessStream(fakeQuery(messages))) {
-      events.push(ev)
-    }
-
-    const resultEntries = events.flatMap((ev) =>
-      ev.type === "transcript" && ev.entry && ev.entry.kind === "result" ? [ev.entry] : [],
-    )
-    expect(resultEntries).toHaveLength(1)
-    const resultEntry = resultEntries[0]
-    expect(resultEntry.costUsd).toBeCloseTo(0.02, 6)
-    expect(resultEntry.usage).toBeDefined()
-    expect(resultEntry.usage?.outputTokens).toBe(80)
-    expect(resultEntry.usage?.inputTokens).toBe(200)
-  })
-
-  test("openrouter: result entry carries computed cost and usage tokens from resolver", async () => {
-    const messages = [
-      {
-        type: "assistant",
-        session_id: "sess-oru",
-        message: { id: "m1", role: "assistant", content: [] },
-        usage: { input_tokens: 1_000_000, output_tokens: 0 },
-      },
-      {
-        type: "result",
-        subtype: "success",
-        session_id: "sess-oru",
-        is_error: false,
-        usage: { input_tokens: 1_000_000, output_tokens: 0 },
-        duration_ms: 10,
-        num_turns: 1,
-        result: "ok",
-      },
-    ]
-
-    const price: ModelPrice = { inputPerMTok: 3, outputPerMTok: 15 }
-    const events: HarnessEvent[] = []
-    for await (const ev of createClaudeHarnessStream(fakeQuery(messages), undefined, () => price)) {
-      events.push(ev)
-    }
-
-    const resultEntries = events.flatMap((ev) =>
-      ev.type === "transcript" && ev.entry && ev.entry.kind === "result" ? [ev.entry] : [],
-    )
-    expect(resultEntries).toHaveLength(1)
-    const resultEntry = resultEntries[0]
-    expect(resultEntry.costUsd).toBeCloseTo(3, 6)
-    expect(resultEntry.usage).toBeDefined()
-    expect(resultEntry.usage?.inputTokens).toBe(1_000_000)
-    expect(resultEntry.usage?.outputTokens).toBeUndefined()
-  })
-})

package/src/server/claude-pty/pid-registry.adapter.ts

@@ -1,164 +0,0 @@
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises"
-import path from "node:path"
-import process from "node:process"
-import { isJsonArray, isJsonObject, safeJsonParse, type JsonValue } from "../../shared/json"
-
-export interface ClaudePtyEntry {
-  chatId: string
-  sessionId: string
-  pid: number
-  cwd: string
-  runtimeDir: string
-  createdAt: number
-}
-
-interface RegistryFile {
-  entries: ClaudePtyEntry[]
-}
-
-export class ClaudePtyRegistry {
-  private readonly filePath: string
-  private entries: ClaudePtyEntry[] = []
-  private loaded = false
-  private writeQueue: Promise<void> = Promise.resolve()
-
-  constructor(filePath: string) {
-    this.filePath = filePath
-  }
-
-  async register(entry: Omit<ClaudePtyEntry, "createdAt">): Promise<void> {
-    await this.loadIfNeeded()
-    const next = this.entries.filter((existing) => existing.pid !== entry.pid)
-    next.push({ ...entry, createdAt: Date.now() })
-    this.entries = next
-    await this.persist()
-  }
-
-  async unregister(pid: number): Promise<void> {
-    await this.loadIfNeeded()
-    this.entries = this.entries.filter((entry) => entry.pid !== pid)
-    await this.persist()
-  }
-
-  async reapStale(): Promise<ClaudePtyEntry[]> {
-    const stored = await this.readFromDisk()
-    if (stored.length === 0) {
-      this.entries = []
-      this.loaded = true
-      return []
-    }
-    for (const entry of stored) {
-      await killProcessTree(entry.pid)
-      if (entry.runtimeDir && entry.runtimeDir.length > 0) {
-        try { await rm(entry.runtimeDir, { recursive: true, force: true }) } catch {
-        }
-      }
-    }
-    this.entries = []
-    this.loaded = true
-    await this.persist()
-    return stored
-  }
-
-  private async loadIfNeeded() {
-    if (this.loaded) return
-    this.entries = await this.readFromDisk()
-    this.loaded = true
-  }
-
-  private async readFromDisk(): Promise<ClaudePtyEntry[]> {
-    let raw: string
-    try {
-      raw = await readFile(this.filePath, "utf8")
-    } catch {
-      return []
-    }
-    const parsed = safeJsonParse(raw)
-    if (parsed === null || !isJsonObject(parsed) || !isJsonArray(parsed.entries)) return []
-    return parsed.entries.filter(isValidEntry)
-  }
-
-  private async persist() {
-    const snapshot: RegistryFile = { entries: [...this.entries] }
-    const serialized = JSON.stringify(snapshot)
-    this.writeQueue = this.writeQueue
-      .catch(() => undefined)
-      .then(async () => {
-        await mkdir(path.dirname(this.filePath), { recursive: true })
-        await writeFile(this.filePath, serialized, "utf8")
-      })
-    await this.writeQueue
-  }
-}
-
-function isValidEntry(value: JsonValue): value is JsonValue & ClaudePtyEntry {
-  if (!isJsonObject(value)) return false
-  return (
-    typeof value.chatId === "string"
-    && typeof value.sessionId === "string"
-    && typeof value.pid === "number"
-    && Number.isFinite(value.pid)
-    && typeof value.cwd === "string"
-    && typeof value.runtimeDir === "string"
-    && typeof value.createdAt === "number"
-  )
-}
-
-export async function killProcessTree(pid: number): Promise<void> {
-  if (process.platform === "win32") return
-  if (!Number.isFinite(pid) || pid <= 0) return
-
-  const targets = [pid, ...(await collectDescendants(pid))]
-  for (const target of targets.reverse()) {
-    try {
-      process.kill(target, "SIGKILL")
-    } catch {
-    }
-  }
-}
-
-async function collectDescendants(root: number): Promise<number[]> {
-  let childrenByParent: Map<number, number[]>
-  try {
-    const proc = Bun.spawn(["ps", "-A", "-o", "pid=,ppid="], {
-      stdout: "pipe",
-      stderr: "ignore",
-      stdin: "ignore",
-    })
-    const text = await new Response(proc.stdout).text()
-    await proc.exited
-    childrenByParent = parsePidPpid(text)
-  } catch {
-    return []
-  }
-
-  const descendants: number[] = []
-  const queue = [root]
-  const seen = new Set<number>([root])
-  while (queue.length > 0) {
-    const parent = queue.shift()
-    if (parent === undefined) break
-    for (const child of childrenByParent.get(parent) ?? []) {
-      if (seen.has(child)) continue
-      seen.add(child)
-      descendants.push(child)
-      queue.push(child)
-    }
-  }
-  return descendants
-}
-
-function parsePidPpid(psOutput: string): Map<number, number[]> {
-  const childrenByParent = new Map<number, number[]>()
-  for (const line of psOutput.split("\n")) {
-    const match = line.trim().match(/^(\d+)\s+(\d+)$/)
-    if (!match) continue
-    const pid = Number.parseInt(match[1] ?? "", 10)
-    const ppid = Number.parseInt(match[2] ?? "", 10)
-    if (!Number.isFinite(pid) || !Number.isFinite(ppid)) continue
-    const siblings = childrenByParent.get(ppid)
-    if (siblings) siblings.push(pid)
-    else childrenByParent.set(ppid, [pid])
-  }
-  return childrenByParent
-}