@cuongtran001/kanna 1.63.2 → 1.64.0

package/src/server/claude-pty/tui-control.ts

@@ -1,174 +0,0 @@
-import type { PtyProcess } from "./pty-process.adapter"
-import type { OutputRing } from "./output-ring"
-
-export const TRUST_DIALOG_MARKER = "trust this folder"
-export const DEV_CHANNELS_DIALOG_MARKER = "local channel development"
-export const TUI_READY_MARKER = "❯ "
-export const TUI_READY_HARD_CAP_DEFAULT_MS = 3000
-export const TUI_READY_QUIET_DEFAULT_MS = 300
-
-function stripAnsi(s: string): string {
-  return s
-    .replace(/\x1b\[[0-9;]*[A-Za-z]/g, " ")
-    .replace(/\x1b./g, "")
-    .replace(/\u00a0/g, " ")
-}
-
-export interface WaitForTuiReadyOpts {
-  hardCapMs?: number
-  pollMs?: number
-  quietPeriodMs?: number
-}
-
-export async function waitForTuiReady(
-  ring: OutputRing,
-  opts: WaitForTuiReadyOpts = {},
-): Promise<"marker" | "timeout"> {
-  const hardCapMs = opts.hardCapMs ?? TUI_READY_HARD_CAP_DEFAULT_MS
-  const pollMs = opts.pollMs ?? 50
-  const quietPeriodMs = opts.quietPeriodMs ?? TUI_READY_QUIET_DEFAULT_MS
-  const start = Date.now()
-  while (true) {
-    if (stripAnsi(ring.tail()).includes(TUI_READY_MARKER)) {
-      await waitForRingQuiet(ring, { quietMs: quietPeriodMs, pollMs, deadline: start + hardCapMs })
-      return "marker"
-    }
-    if (Date.now() - start >= hardCapMs) return "timeout"
-    await new Promise((r) => setTimeout(r, pollMs))
-  }
-}
-
-async function waitForRingQuiet(
-  ring: OutputRing,
-  opts: { quietMs: number; pollMs: number; deadline: number },
-): Promise<void> {
-  if (opts.quietMs <= 0) return
-  let lastLength = ring.tail().length
-  let quietStart = Date.now()
-  while (Date.now() - quietStart < opts.quietMs) {
-    if (Date.now() >= opts.deadline) return
-    await new Promise((r) => setTimeout(r, opts.pollMs))
-    const currentLength = ring.tail().length
-    if (currentLength !== lastLength) {
-      lastLength = currentLength
-      quietStart = Date.now()
-    }
-  }
-}
-
-export async function dismissTrustDialogIfPresent(
-  pty: PtyProcess,
-  ring: OutputRing,
-): Promise<boolean> {
-  if (!stripAnsi(ring.tail()).includes(TRUST_DIALOG_MARKER)) return false
-  await pty.sendInput("\r")
-  return true
-}
-
-export async function dismissDevChannelsDialogIfPresent(
-  pty: PtyProcess,
-  ring: OutputRing,
-): Promise<boolean> {
-  if (!stripAnsi(ring.tail()).includes(DEV_CHANNELS_DIALOG_MARKER)) return false
-  await pty.sendInput("\r")
-  return true
-}
-
-export interface WaitForTuiReadyWithTrustDismissOpts {
-  hardCapMs?: number
-  pollMs?: number
-  quietPeriodMs?: number
-}
-
-export async function waitForTuiReadyWithTrustDismiss(
-  pty: PtyProcess,
-  ring: OutputRing,
-  opts: WaitForTuiReadyWithTrustDismissOpts = {},
-): Promise<"ready" | "timeout"> {
-  const hardCapMs = opts.hardCapMs ?? 15_000
-  const pollMs = opts.pollMs ?? 50
-  const quietPeriodMs = opts.quietPeriodMs ?? TUI_READY_QUIET_DEFAULT_MS
-  const start = Date.now()
-  let trustDismissed = false
-  let postDismissOffset = 0
-
-  while (Date.now() - start < hardCapMs) {
-    const raw = ring.tail()
-    if (!trustDismissed && stripAnsi(raw).includes(TRUST_DIALOG_MARKER)) {
-      postDismissOffset = raw.length
-      await pty.sendInput("\r")
-      trustDismissed = true
-    } else {
-      const checkWindow = trustDismissed ? raw.slice(postDismissOffset) : raw
-      if (stripAnsi(checkWindow).includes(TUI_READY_MARKER)) {
-        await waitForRingQuiet(ring, { quietMs: quietPeriodMs, pollMs, deadline: start + hardCapMs })
-        return "ready"
-      }
-    }
-    await new Promise((r) => setTimeout(r, pollMs))
-  }
-  return "timeout"
-}
-
-export async function waitForTuiReadyDismissingDialogs(
-  pty: PtyProcess,
-  ring: OutputRing,
-  opts: { hardCapMs?: number; pollMs?: number } = {},
-): Promise<"marker" | "timeout"> {
-  const hardCapMs = opts.hardCapMs ?? TUI_READY_HARD_CAP_DEFAULT_MS + 5_000
-  const pollMs = opts.pollMs ?? 50
-  const start = Date.now()
-  let trustDone = false
-  let devDone = false
-  let postDismissOffset = 0
-  while (Date.now() - start < hardCapMs) {
-    const raw = ring.tail()
-    const view = stripAnsi(raw)
-    if (!trustDone && view.includes(TRUST_DIALOG_MARKER)) {
-      postDismissOffset = raw.length
-      await pty.sendInput("\r")
-      trustDone = true
-      await new Promise((r) => setTimeout(r, pollMs))
-      continue
-    }
-    if (!devDone && view.includes(DEV_CHANNELS_DIALOG_MARKER)) {
-      postDismissOffset = raw.length
-      await pty.sendInput("\r")
-      devDone = true
-      await new Promise((r) => setTimeout(r, pollMs))
-      continue
-    }
-    if (devDone && stripAnsi(raw.slice(postDismissOffset)).includes(TUI_READY_MARKER)) {
-      return "marker"
-    }
-    await new Promise((r) => setTimeout(r, pollMs))
-  }
-  return "timeout"
-}
-
-export interface SendUserPromptOpts {
-  commitTimeoutMs?: number
-  pollMs?: number
-}
-
-export async function sendUserPrompt(
-  pty: PtyProcess,
-  ring: OutputRing,
-  text: string,
-  opts: SendUserPromptOpts = {},
-): Promise<void> {
-  const commitTimeoutMs = opts.commitTimeoutMs ?? 2_000
-  const pollMs = opts.pollMs ?? 10
-  const baseline = ring.tail().length
-  await pty.sendInput(`\x1b[200~${text}\x1b[201~`)
-  const deadline = Date.now() + commitTimeoutMs
-  while (Date.now() < deadline) {
-    if (ring.tail().length > baseline) break
-    await new Promise((r) => setTimeout(r, pollMs))
-  }
-  await pty.sendInput("\r")
-}
-
-export async function sendExitCommand(pty: PtyProcess): Promise<void> {
-  await pty.sendInput("/exit\r")
-}

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

@@ -1,374 +0,0 @@
-import { describe, expect, test, beforeEach, afterEach } from "bun:test"
-import { mkdtemp, rm, writeFile, mkdir, appendFile } from "node:fs/promises"
-import { tmpdir } from "node:os"
-import path from "node:path"
-import {
-  findLatestTranscript,
-  startTranscriptStream,
-  waitForResultEntry,
-} from "./tui-source.adapter"
-import { encodeCwd } from "./jsonl-path.adapter"
-
-let workHome: string
-let projectDir: string
-
-beforeEach(async () => {
-  workHome = await mkdtemp(path.join(tmpdir(), "kanna-tui-source-"))
-  projectDir = path.join(workHome, ".claude", "projects", "fake-cwd")
-  await mkdir(projectDir, { recursive: true })
-})
-
-afterEach(async () => {
-  await rm(workHome, { recursive: true, force: true })
-})
-
-describe("findLatestTranscript", () => {
-  test("returns null when project dir empty", async () => {
-    const result = await findLatestTranscript(projectDir)
-    expect(result).toBeNull()
-  })
-
-  test("returns path of newest .jsonl file", async () => {
-    const fileA = path.join(projectDir, "aaa.jsonl")
-    const fileB = path.join(projectDir, "bbb.jsonl")
-    await writeFile(fileA, "{}\n")
-    await new Promise((r) => setTimeout(r, 20))
-    await writeFile(fileB, "{}\n")
-    const result = await findLatestTranscript(projectDir)
-    expect(result).toBe(fileB)
-  })
-
-  test("ignores non-.jsonl files", async () => {
-    await writeFile(path.join(projectDir, "notes.txt"), "hello")
-    const result = await findLatestTranscript(projectDir)
-    expect(result).toBeNull()
-  })
-
-  test("returns null when project dir does not exist", async () => {
-    const result = await findLatestTranscript(path.join(workHome, "no-such-dir"))
-    expect(result).toBeNull()
-  })
-
-  test("minMtimeMs filter skips JSONLs older than the floor", async () => {
-    const stale = path.join(projectDir, "stale.jsonl")
-    const fresh = path.join(projectDir, "fresh.jsonl")
-    await writeFile(stale, "{}\n")
-    await new Promise((r) => setTimeout(r, 20))
-    const floor = Date.now()
-    await new Promise((r) => setTimeout(r, 20))
-    await writeFile(fresh, "{}\n")
-    const result = await findLatestTranscript(projectDir, { minMtimeMs: floor })
-    expect(result).toBe(fresh)
-  })
-
-  test("minMtimeMs returns null when every JSONL is older than the floor", async () => {
-    const a = path.join(projectDir, "a.jsonl")
-    await writeFile(a, "{}\n")
-    await new Promise((r) => setTimeout(r, 20))
-    const result = await findLatestTranscript(projectDir, { minMtimeMs: Date.now() })
-    expect(result).toBeNull()
-  })
-})
-
-describe("startTranscriptStream (dir-watch)", () => {
-  test("picks up file written after stream start", async () => {
-    const stream = await startTranscriptStream({ projectDir, firstFileTimeoutMs: 2000 })
-    const filePath = path.join(projectDir, "new.jsonl")
-    setTimeout(() => writeFile(filePath, '{"type":"hello"}\n'), 100)
-    const resolved = await stream.filePath
-    expect(resolved).toBe(filePath)
-    stream.close()
-  }, 5000)
-
-  test("opens existing file when present at start", async () => {
-    const filePath = path.join(projectDir, "existing.jsonl")
-    await writeFile(filePath, '{"type":"hello"}\n')
-    const stream = await startTranscriptStream({ projectDir, firstFileTimeoutMs: 2000 })
-    const resolved = await stream.filePath
-    expect(resolved).toBe(filePath)
-    stream.close()
-  }, 5000)
-
-  test("emits complete lines as they are appended", async () => {
-    const filePath = path.join(projectDir, "stream.jsonl")
-    await writeFile(filePath, '{"type":"one"}\n')
-    const stream = await startTranscriptStream({ projectDir, firstFileTimeoutMs: 2000 })
-    const iter = stream.lines[Symbol.asyncIterator]()
-    const first = await iter.next()
-    expect(first.value).toBe('{"type":"one"}')
-    setTimeout(() => writeFile(filePath, '{"type":"one"}\n{"type":"two"}\n'), 100)
-    const second = await iter.next()
-    expect(second.value).toBe('{"type":"two"}')
-    stream.close()
-  }, 5000)
-
-  test("holds partial line across writes", async () => {
-    const filePath = path.join(projectDir, "partial.jsonl")
-    await writeFile(filePath, '{"type":')
-    const stream = await startTranscriptStream({
-      projectDir,
-      firstFileTimeoutMs: 2000,
-      pollIntervalMs: 30,
-    })
-    const iter = stream.lines[Symbol.asyncIterator]()
-    let resolved = false
-    const firstPromise = iter.next().then((r: IteratorResult<string>) => { resolved = true; return r })
-    await new Promise((r) => setTimeout(r, 200))
-    expect(resolved).toBe(false)
-    await writeFile(filePath, '{"type":"one"}\n')
-    const first = await firstPromise
-    expect(first.value).toBe('{"type":"one"}')
-    stream.close()
-  }, 5000)
-
-  test("times out when no file appears within firstFileTimeoutMs", async () => {
-    const stream = await startTranscriptStream({ projectDir, firstFileTimeoutMs: 200 })
-    await expect(stream.filePath).rejects.toThrow(/transcript file did not appear/)
-    stream.close()
-  }, 5000)
-
-  test("knownFilePath skips dir-watch", async () => {
-    const filePath = path.join(projectDir, "known.jsonl")
-    await writeFile(filePath, '{"type":"hello"}\n')
-    const stream = await startTranscriptStream({
-      projectDir,
-      knownFilePath: filePath,
-      firstFileTimeoutMs: 500,
-    })
-    const resolved = await stream.filePath
-    expect(resolved).toBe(filePath)
-    stream.close()
-  }, 5000)
-})
-
-describe("startTranscriptStream (poll follower)", () => {
-  test("emits lines via the tail-poll", async () => {
-    const stream = await startTranscriptStream({
-      projectDir,
-      pollIntervalMs: 30,
-      firstFileTimeoutMs: 2000,
-    })
-    const filePath = path.join(projectDir, "poll.jsonl")
-    setTimeout(() => writeFile(filePath, '{"type":"polled"}\n'), 100)
-    const iter = stream.lines[Symbol.asyncIterator]()
-    const first = await iter.next()
-    expect(first.value).toBe('{"type":"polled"}')
-    stream.close()
-  }, 5000)
-
-  test("close() stops the poll timer (no leak)", async () => {
-    const filePath = path.join(projectDir, "leak.jsonl")
-    await writeFile(filePath, '{"type":"one"}\n')
-    const stream = await startTranscriptStream({
-      projectDir,
-      knownFilePath: filePath,
-      pollIntervalMs: 20,
-      firstFileTimeoutMs: 500,
-    })
-    const iter = stream.lines[Symbol.asyncIterator]()
-    expect((await iter.next()).value).toBe('{"type":"one"}')
-    stream.close()
-    await appendFile(filePath, '{"type":"two"}\n')
-    await new Promise((r) => setTimeout(r, 120))
-    const next = await Promise.race([
-      iter.next(),
-      new Promise<{ value: undefined; done: true }>((r) => setTimeout(() => r({ value: undefined, done: true }), 150)),
-    ])
-    expect(next.done).toBe(true)
-  }, 5000)
-})
-
-describe("startTranscriptStream (registry resolution)", () => {
-  test("registry resolves but JSONL missing — never falls back to other JSONL in same dir", async () => {
-    const pid = 99001
-    const realCwd = await mkdtemp(path.join(workHome, "real-cwd-"))
-    const encoded = encodeCwd(realCwd)
-    const ownProjectDir = path.join(workHome, ".claude", "projects", encoded)
-    await mkdir(ownProjectDir, { recursive: true })
-    const sessionsDir = path.join(workHome, ".claude", "sessions")
-    await mkdir(sessionsDir, { recursive: true })
-    const ownSessionId = "our-session-aaaaaaaaaa"
-    await writeFile(
-      path.join(sessionsDir, `${pid}.json`),
-      JSON.stringify({ pid, sessionId: ownSessionId, cwd: realCwd, kind: "interactive", startedAt: Date.now() }),
-    )
-    const strangerFile = path.join(ownProjectDir, "stranger-session.jsonl")
-    await writeFile(strangerFile, '{"type":"assistant","message":{"content":[{"type":"text","text":"NOT OURS"}]}}\n')
-
-    const stream = await startTranscriptStream({
-      projectDir: ownProjectDir,
-      homeDir: workHome,
-      claudeChildPid: pid,
-      sessionRegistryTimeoutMs: 300,
-      firstFileTimeoutMs: 5_000,
-      pollIntervalMs: 20,
-    })
-
-    const beforeWrite = await Promise.race([
-      stream.filePath
-        .then((fp) => ({ kind: "resolved" as const, fp }))
-        .catch((err: Error) => ({ kind: "rejected" as const, err })),
-      new Promise<{ kind: "pending" }>((r) => setTimeout(() => r({ kind: "pending" }), 600)),
-    ])
-    expect(beforeWrite.kind).toBe("pending")
-
-    const ownFile = path.join(ownProjectDir, `${ownSessionId}.jsonl`)
-    await writeFile(ownFile, '{"type":"assistant","message":{"content":[{"type":"text","text":"ours"}]}}\n')
-    const resolved = await stream.filePath
-    expect(resolved).toBe(ownFile)
-    expect(resolved).not.toBe(strangerFile)
-    stream.close()
-  }, 5000)
-
-  test("registry resolved but JSONL never appears — filePath rejects after firstFileTimeoutMs", async () => {
-    const pid = 99003
-    const realCwd = await mkdtemp(path.join(workHome, "real-cwd-"))
-    const encoded = encodeCwd(realCwd)
-    const ownProjectDir = path.join(workHome, ".claude", "projects", encoded)
-    await mkdir(ownProjectDir, { recursive: true })
-    const sessionsDir = path.join(workHome, ".claude", "sessions")
-    await mkdir(sessionsDir, { recursive: true })
-    const ownSessionId = "our-session-cccccccccc"
-    await writeFile(
-      path.join(sessionsDir, `${pid}.json`),
-      JSON.stringify({ pid, sessionId: ownSessionId, cwd: realCwd, kind: "interactive", startedAt: Date.now() }),
-    )
-
-    const stream = await startTranscriptStream({
-      projectDir: ownProjectDir,
-      homeDir: workHome,
-      claudeChildPid: pid,
-      sessionRegistryTimeoutMs: 300,
-      firstFileTimeoutMs: 150,
-      pollIntervalMs: 20,
-    })
-
-    const start = Date.now()
-    await expect(stream.filePath).rejects.toThrow(/did not appear in 150ms/)
-    const elapsed = Date.now() - start
-    expect(elapsed).toBeLessThan(1_500)
-    stream.close()
-  }, 5000)
-
-  test("registry resolves with existing JSONL — returns registry path immediately", async () => {
-    const pid = 99002
-    const realCwd = await mkdtemp(path.join(workHome, "real-cwd-"))
-    const encoded = encodeCwd(realCwd)
-    const ownProjectDir = path.join(workHome, ".claude", "projects", encoded)
-    await mkdir(ownProjectDir, { recursive: true })
-    const sessionsDir = path.join(workHome, ".claude", "sessions")
-    await mkdir(sessionsDir, { recursive: true })
-    const ownSessionId = "our-session-bbbbbbbbbb"
-    const ownFile = path.join(ownProjectDir, `${ownSessionId}.jsonl`)
-    await writeFile(ownFile, "{}\n")
-    await writeFile(
-      path.join(sessionsDir, `${pid}.json`),
-      JSON.stringify({ pid, sessionId: ownSessionId, cwd: realCwd, kind: "interactive", startedAt: Date.now() }),
-    )
-    await new Promise((r) => setTimeout(r, 20))
-    await writeFile(path.join(ownProjectDir, "stranger.jsonl"), "{}\n")
-
-    const stream = await startTranscriptStream({
-      projectDir: ownProjectDir,
-      homeDir: workHome,
-      claudeChildPid: pid,
-    })
-    const resolved = await stream.filePath
-    expect(resolved).toBe(ownFile)
-    stream.close()
-  }, 5000)
-})
-
-describe("startTranscriptStream (rapid turn-end appends)", () => {
-  test("delivers all rows appended in rapid succession after stream setup", async () => {
-    const filePath = path.join(projectDir, "watched.jsonl")
-    await writeFile(filePath, '{"type":"system","subtype":"init"}\n')
-    const stream = await startTranscriptStream({
-      projectDir,
-      knownFilePath: filePath,
-      firstFileTimeoutMs: 500,
-    })
-    const iter = stream.lines[Symbol.asyncIterator]()
-    const first = await iter.next()
-    expect(first.value).toContain('"system"')
-
-    await appendFile(filePath, '{"type":"assistant","message":{"content":[{"type":"text","text":"a"}]}}\n')
-    await appendFile(filePath, '{"type":"assistant","message":{"content":[{"type":"text","text":"b"}]}}\n')
-    await appendFile(filePath, '{"type":"system","subtype":"turn_duration","durationMs":42}\n')
-
-    const collected: string[] = []
-    const deadline = Date.now() + 2_000
-    while (collected.length < 3 && Date.now() < deadline) {
-      const nxt = await Promise.race([
-        iter.next(),
-        new Promise<{ value: undefined; done: true }>((r) => setTimeout(() => r({ value: undefined, done: true }), 1_500)),
-      ])
-      if (nxt.done) break
-      collected.push(nxt.value)
-    }
-    expect(collected.length).toBe(3)
-    expect(collected[0]).toContain('"a"')
-    expect(collected[1]).toContain('"b"')
-    expect(collected[2]).toContain("turn_duration")
-    stream.close()
-  }, 8000)
-})
-
-describe("waitForResultEntry", () => {
-  test("resolves on first result line", async () => {
-    const filePath = path.join(projectDir, "result.jsonl")
-    await writeFile(filePath, '{"type":"system"}\n{"type":"assistant"}\n')
-    const stream = await startTranscriptStream({ projectDir, firstFileTimeoutMs: 2000 })
-    setTimeout(() => writeFile(filePath, '{"type":"system"}\n{"type":"assistant"}\n{"type":"result","subtype":"success"}\n'), 100)
-    const entry = await waitForResultEntry(stream, { timeoutMs: 2000 })
-    expect(entry.parsed.type).toBe("result")
-    stream.close()
-  }, 5000)
-
-  test("resolves on assistant row with terminal stop_reason (new CLI format)", async () => {
-    const filePath = path.join(projectDir, "stop-reason.jsonl")
-    await writeFile(filePath, '{"type":"user","message":{"role":"user","content":"hi"}}\n')
-    const stream = await startTranscriptStream({ projectDir, firstFileTimeoutMs: 2000 })
-    const endTurnRow = JSON.stringify({
-      type: "assistant",
-      message: { id: "msg_end", role: "assistant", stop_reason: "end_turn", content: [{ type: "text", text: "done" }] },
-    })
-    setTimeout(() => writeFile(
-      filePath,
-      `{"type":"user","message":{"role":"user","content":"hi"}}\n${endTurnRow}\n`,
-    ), 100)
-    const entry = await waitForResultEntry(stream, { timeoutMs: 2000 })
-    expect(entry.parsed.type).toBe("assistant")
-    stream.close()
-  }, 5000)
-
-  test("does NOT resolve on assistant row with tool_use stop_reason", async () => {
-    const filePath = path.join(projectDir, "stop-reason-tooluse.jsonl")
-    const toolUseRow = JSON.stringify({
-      type: "assistant",
-      message: { id: "msg_t", role: "assistant", stop_reason: "tool_use", content: [{ type: "tool_use", id: "t1", name: "Read", input: {} }] },
-    })
-    await writeFile(filePath, `${toolUseRow}\n`)
-    const stream = await startTranscriptStream({ projectDir, firstFileTimeoutMs: 2000 })
-    await expect(waitForResultEntry(stream, { timeoutMs: 300 })).rejects.toThrow(/timed out/i)
-    stream.close()
-  }, 5000)
-
-  test("rejects on abort signal", async () => {
-    const filePath = path.join(projectDir, "abort.jsonl")
-    await writeFile(filePath, '{"type":"system"}\n')
-    const stream = await startTranscriptStream({ projectDir, firstFileTimeoutMs: 2000 })
-    const ctrl = new AbortController()
-    setTimeout(() => ctrl.abort(), 50)
-    await expect(waitForResultEntry(stream, { signal: ctrl.signal })).rejects.toThrow(/aborted/i)
-    stream.close()
-  }, 5000)
-
-  test("rejects on timeout", async () => {
-    const filePath = path.join(projectDir, "timeout.jsonl")
-    await writeFile(filePath, '{"type":"system"}\n')
-    const stream = await startTranscriptStream({ projectDir, firstFileTimeoutMs: 2000 })
-    await expect(waitForResultEntry(stream, { timeoutMs: 100 })).rejects.toThrow(/timed out/i)
-    stream.close()
-  }, 5000)
-})