airaknit 1.1.2-rc.9

package/src/server/claude-pty/jsonl-path.adapter.ts

@@ -0,0 +1,57 @@
+import { realpathSync } from "node:fs"
+import path from "node:path"
+
+const MAX_SANITIZED_LENGTH = 200
+
+function djb2Hash(str: string): number {
+  let hash = 0
+  for (let i = 0; i < str.length; i++) {
+    hash = ((hash << 5) - hash + str.charCodeAt(i)) | 0
+  }
+  return hash
+}
+
+function hashSuffix(name: string): string {
+  // Mirror claude-code/src/utils/sessionStoragePortable.ts: prefer Bun.hash
+  // (wyhash) when running under Bun, fall back to djb2 elsewhere. Both encode
+  // base36. Cross-runtime stability matters only for paths >200 chars.
+  const maybeBun = (globalThis as { Bun?: { hash: (s: string) => bigint } }).Bun
+  if (maybeBun && typeof maybeBun.hash === "function") {
+    return maybeBun.hash(name).toString(36)
+  }
+  return Math.abs(djb2Hash(name)).toString(36)
+}
+
+function sanitizePath(name: string): string {
+  const sanitized = name.replace(/[^a-zA-Z0-9]/g, "-")
+  if (sanitized.length <= MAX_SANITIZED_LENGTH) return sanitized
+  return `${sanitized.slice(0, MAX_SANITIZED_LENGTH)}-${hashSuffix(name)}`
+}
+
+export function encodeCwd(cwd: string): string {
+  // Ported verbatim from claude-code v2.1.146:
+  // bootstrap/state.ts realpath + NFC normalize, then sessionStoragePortable.ts
+  // sanitizePath. Throws ENOENT if cwd is missing — callers guarantee an
+  // existing directory.
+  const real = realpathSync(cwd)
+  const normalized = real.normalize("NFC")
+  return sanitizePath(normalized)
+}
+
+export function computeProjectDir(args: {
+  homeDir: string
+  cwd: string
+}): string {
+  return path.join(args.homeDir, ".claude", "projects", encodeCwd(args.cwd))
+}
+
+export function computeJsonlPath(args: {
+  homeDir: string
+  cwd: string
+  sessionId: string
+}): string {
+  return path.join(
+    computeProjectDir({ homeDir: args.homeDir, cwd: args.cwd }),
+    `${args.sessionId}.jsonl`,
+  )
+}

package/src/server/claude-pty/jsonl-path.test.ts

@@ -0,0 +1,114 @@
+import { realpathSync } from "node:fs"
+import { mkdtemp, rm } from "node:fs/promises"
+import { homedir, tmpdir } from "node:os"
+import path from "node:path"
+import { describe, expect, test } from "bun:test"
+import { computeJsonlPath, computeProjectDir, encodeCwd } from "./jsonl-path.adapter"
+
+describe("encodeCwd", () => {
+  test("absolute path: replaces / with -", () => {
+    const expected = homedir().replace(/\//g, "-").replace(/\./g, "-")
+    expect(encodeCwd(homedir())).toBe(expected)
+  })
+  test("absolute path with trailing slash: trims it", () => {
+    const expected = homedir().replace(/\//g, "-").replace(/\./g, "-")
+    expect(encodeCwd(homedir() + "/")).toBe(expected)
+  })
+  test("nested path", () => {
+    const expected = process.cwd().replace(/\//g, "-").replace(/\./g, "-")
+    expect(encodeCwd(process.cwd())).toBe(expected)
+  })
+  test("root path", () => {
+    expect(encodeCwd("/")).toBe("-")
+  })
+})
+
+describe("computeJsonlPath", () => {
+  test("combines homeDir + encoded cwd + session uuid", async () => {
+    const tmp = await mkdtemp(path.join(tmpdir(), "kanna-jsonlpath-"))
+    try {
+      const realPath = realpathSync(tmp)
+      const encodedCwd = realPath.replace(/\//g, "-").replace(/\./g, "-")
+      const result = computeJsonlPath({
+        homeDir: "/home/u",
+        cwd: tmp,
+        sessionId: "abc-123",
+      })
+      expect(result).toBe(`/home/u/.claude/projects/${encodedCwd}/abc-123.jsonl`)
+    } finally {
+      await rm(tmp, { recursive: true, force: true })
+    }
+  })
+})
+
+describe("encodeCwd realpath + dot replacement", () => {
+  test("resolves macOS /var -> /private/var symlink", async () => {
+    const tmp = await mkdtemp(path.join(tmpdir(), "kanna-encodecwd-"))
+    try {
+      const encoded = encodeCwd(tmp)
+      const realPath = realpathSync(tmp)
+      const expectedEncoded = realPath.replace(/\//g, "-").replace(/\./g, "-")
+      expect(encoded).toBe(expectedEncoded)
+    } finally {
+      await rm(tmp, { recursive: true, force: true })
+    }
+  })
+
+  test("replaces dots with dashes in segment names", async () => {
+    // mkdtemp ensures the directory exists so realpathSync succeeds
+    const tmp = await mkdtemp(path.join(tmpdir(), "kanna.dot-test-"))
+    try {
+      const encoded = encodeCwd(tmp)
+      expect(encoded).not.toContain(".")
+      // The "kanna.dot-test-XXXX" segment dot must be replaced
+      expect(encoded).toContain("kanna-dot-test-")
+    } finally {
+      await rm(tmp, { recursive: true, force: true })
+    }
+  })
+
+  test("trailing slash trimmed before encoding", () => {
+    const a = encodeCwd("/etc/")
+    const b = encodeCwd("/etc")
+    expect(a).toBe(b)
+  })
+
+  test("root / encodes to single dash", () => {
+    const result = encodeCwd("/")
+    expect(result).toBe("-")
+  })
+
+  test("replaces underscore with dash (claude sanitizePath parity)", async () => {
+    const tmp = await mkdtemp(path.join(tmpdir(), "kanna_under_"))
+    try {
+      const encoded = encodeCwd(tmp)
+      expect(encoded).not.toContain("_")
+    } finally {
+      await rm(tmp, { recursive: true, force: true })
+    }
+  })
+
+  test("encoded segment matches /[^a-zA-Z0-9-]/ never present", async () => {
+    const tmp = await mkdtemp(path.join(tmpdir(), "kanna-charset-"))
+    try {
+      const encoded = encodeCwd(tmp)
+      expect(encoded).toMatch(/^[a-zA-Z0-9-]+$/)
+    } finally {
+      await rm(tmp, { recursive: true, force: true })
+    }
+  })
+})
+
+describe("computeProjectDir", () => {
+  test("returns .claude/projects/<encodedCwd> path", async () => {
+    const tmp = await mkdtemp(path.join(tmpdir(), "kanna-projdir-"))
+    try {
+      const realPath = realpathSync(tmp)
+      const encodedCwd = realPath.replace(/\//g, "-").replace(/\./g, "-")
+      const result = computeProjectDir({ homeDir: "/home/user", cwd: tmp })
+      expect(result).toBe(`/home/user/.claude/projects/${encodedCwd}`)
+    } finally {
+      await rm(tmp, { recursive: true, force: true })
+    }
+  })
+})

package/src/server/claude-pty/jsonl-to-event.test.ts

@@ -0,0 +1,241 @@
+import { describe, expect, test } from "bun:test"
+import { parseJsonlLine, createJsonlEventParser } from "./jsonl-to-event"
+import type { HarnessEvent } from "../harness-types"
+
+describe("parseJsonlLine", () => {
+  test("ignores empty lines", () => {
+    expect(parseJsonlLine("")).toEqual([])
+    expect(parseJsonlLine("   ")).toEqual([])
+  })
+
+  test("ignores malformed JSON (logs but does not throw)", () => {
+    expect(parseJsonlLine("{not json")).toEqual([])
+  })
+
+  test("system.init → session_token event", () => {
+    const line = JSON.stringify({
+      type: "system",
+      subtype: "init",
+      session_id: "sess-1",
+      model: "claude-sonnet-4-6",
+    })
+    const events = parseJsonlLine(line)
+    const sessionTokenEvent = events.find((e) => e.type === "session_token")
+    expect(sessionTokenEvent).toBeDefined()
+    expect(sessionTokenEvent?.sessionToken).toBe("sess-1")
+  })
+
+  test("assistant message → transcript event with assistant role", () => {
+    const line = JSON.stringify({
+      type: "assistant",
+      message: {
+        role: "assistant",
+        content: [{ type: "text", text: "hello" }],
+      },
+    })
+    const events = parseJsonlLine(line)
+    const transcriptEvents = events.filter((e) => e.type === "transcript")
+    expect(transcriptEvents.length).toBeGreaterThan(0)
+  })
+
+  test("system.rate_limit subtype → rate_limit event", () => {
+    const line = JSON.stringify({
+      type: "system",
+      subtype: "rate_limit",
+      resetAt: 1748800000000,
+      tz: "PT",
+    })
+    const events = parseJsonlLine(line)
+    const rl = events.find((e) => e.type === "rate_limit")
+    expect(rl).toBeDefined()
+    expect(rl?.rateLimit?.tz).toBe("PT")
+  })
+
+  test("system.informational without rate-limit content → no rate_limit event", () => {
+    const line = JSON.stringify({
+      type: "system",
+      subtype: "informational",
+      content: "Remote Control failed to connect",
+    })
+    const events = parseJsonlLine(line)
+    const rl = events.find((e) => e.type === "rate_limit")
+    expect(rl).toBeUndefined()
+  })
+})
+
+describe("createJsonlEventParser", () => {
+  function emitTypes(events: HarnessEvent[]): string[] {
+    return events.map((e) => e.type)
+  }
+
+  test("D3: emits session_token for every line carrying a session_id (not only system/init)", () => {
+    const parser = createJsonlEventParser()
+    const initLine = JSON.stringify({
+      type: "system",
+      subtype: "init",
+      session_id: "sess-A",
+    })
+    const assistantLine = JSON.stringify({
+      type: "assistant",
+      session_id: "sess-A",
+      message: { id: "msg-1", role: "assistant", content: [{ type: "text", text: "hi" }] },
+    })
+    const initEvents = parser.parse(initLine)
+    const assistantEvents = parser.parse(assistantLine)
+    expect(initEvents.find((e) => e.type === "session_token")?.sessionToken).toBe("sess-A")
+    expect(assistantEvents.find((e) => e.type === "session_token")?.sessionToken).toBe("sess-A")
+  })
+
+  test("D3: lines without session_id do not emit session_token", () => {
+    const parser = createJsonlEventParser()
+    const noSession = JSON.stringify({ type: "assistant", message: { role: "assistant", content: [] } })
+    const events = parser.parse(noSession)
+    expect(events.find((e) => e.type === "session_token")).toBeUndefined()
+  })
+
+  test("D2: SDK-native rate_limit_event message → rate_limit event via detector", () => {
+    const parser = createJsonlEventParser()
+    const line = JSON.stringify({
+      type: "rate_limit_event",
+      rate_limit_info: {
+        status: "rejected",
+        // Epoch seconds (detector coerces to ms).
+        resetsAt: 1_748_800_000,
+      },
+    })
+    const events = parser.parse(line)
+    const rl = events.find((e) => e.type === "rate_limit")
+    expect(rl).toBeDefined()
+    expect(rl?.rateLimit?.resetAt).toBe(1_748_800_000_000)
+  })
+
+  test("D2: rate_limit_event with status != rejected → no event", () => {
+    const parser = createJsonlEventParser()
+    const line = JSON.stringify({
+      type: "rate_limit_event",
+      rate_limit_info: { status: "allowed", resetsAt: 1_748_800_000 },
+    })
+    const events = parser.parse(line)
+    expect(events.find((e) => e.type === "rate_limit")).toBeUndefined()
+  })
+
+  test("D2: legacy system/rate_limit shape still recognised", () => {
+    const parser = createJsonlEventParser()
+    const line = JSON.stringify({
+      type: "system",
+      subtype: "rate_limit",
+      resetAt: 1748800000000,
+      tz: "PT",
+    })
+    const events = parser.parse(line)
+    const rl = events.find((e) => e.type === "rate_limit")
+    expect(rl).toBeDefined()
+    expect(rl?.rateLimit?.tz).toBe("PT")
+  })
+
+  test("D1: assistant message with usage → context_window_updated transcript", () => {
+    const parser = createJsonlEventParser()
+    const line = JSON.stringify({
+      type: "assistant",
+      message: {
+        id: "msg-usage-1",
+        role: "assistant",
+        content: [{ type: "text", text: "hi" }],
+      },
+      usage: {
+        input_tokens: 100,
+        cache_creation_input_tokens: 0,
+        cache_read_input_tokens: 0,
+        output_tokens: 25,
+      },
+    })
+    const events = parser.parse(line)
+    const ctxEvents = events.filter(
+      (e) => e.type === "transcript" && (e.entry as { kind?: string }).kind === "context_window_updated",
+    )
+    expect(ctxEvents).toHaveLength(1)
+  })
+
+  test("D1: duplicate assistant usage id is deduped", () => {
+    const parser = createJsonlEventParser()
+    const line = JSON.stringify({
+      type: "assistant",
+      message: {
+        id: "msg-dedup",
+        role: "assistant",
+        content: [{ type: "text", text: "hi" }],
+      },
+      usage: { input_tokens: 50, output_tokens: 10 },
+    })
+    const first = parser.parse(line)
+    const second = parser.parse(line)
+    const firstCtx = first.filter(
+      (e) => e.type === "transcript" && (e.entry as { kind?: string }).kind === "context_window_updated",
+    )
+    const secondCtx = second.filter(
+      (e) => e.type === "transcript" && (e.entry as { kind?: string }).kind === "context_window_updated",
+    )
+    expect(firstCtx).toHaveLength(1)
+    expect(secondCtx).toHaveLength(0)
+  })
+
+  test("D1: result message after assistant emits final context_window_updated", () => {
+    const parser = createJsonlEventParser()
+    parser.parse(JSON.stringify({
+      type: "assistant",
+      message: { id: "msg-1", role: "assistant", content: [{ type: "text", text: "hi" }] },
+      usage: { input_tokens: 80, output_tokens: 20 },
+    }))
+    const resultLine = JSON.stringify({
+      type: "result",
+      subtype: "success",
+      result: "done",
+      isError: false,
+      durationMs: 1000,
+      usage: { input_tokens: 80, output_tokens: 20 },
+      modelUsage: {
+        "claude-sonnet-4-6": { contextWindow: 200000, inputTokens: 80, outputTokens: 20 },
+      },
+    })
+    const events = parser.parse(resultLine)
+    const ctxEvents = events.filter(
+      (e) => e.type === "transcript" && (e.entry as { kind?: string }).kind === "context_window_updated",
+    )
+    expect(ctxEvents).toHaveLength(1)
+  })
+
+  test("D1: 1M context window floor preserved when modelUsage reports 200k", () => {
+    const parser = createJsonlEventParser({ configuredContextWindow: 1_000_000 })
+    parser.parse(JSON.stringify({
+      type: "assistant",
+      message: { id: "msg-1m", role: "assistant", content: [{ type: "text", text: "hi" }] },
+      usage: { input_tokens: 100, output_tokens: 50 },
+    }))
+    const resultLine = JSON.stringify({
+      type: "result",
+      subtype: "success",
+      result: "done",
+      isError: false,
+      durationMs: 500,
+      usage: { input_tokens: 100, output_tokens: 50 },
+      modelUsage: { "claude-sonnet-4-6": { contextWindow: 200000 } },
+    })
+    const events = parser.parse(resultLine)
+    const ctx = events.find(
+      (e) => e.type === "transcript" && (e.entry as { kind?: string }).kind === "context_window_updated",
+    )
+    const usage = (ctx?.entry as { usage?: { maxTokens?: number } } | undefined)?.usage
+    expect(usage?.maxTokens).toBe(1_000_000)
+  })
+
+  test("emitTypes helper produces deterministic order across calls", () => {
+    const parser = createJsonlEventParser()
+    const types = emitTypes(parser.parse(JSON.stringify({
+      type: "system",
+      subtype: "init",
+      session_id: "sess-X",
+    })))
+    expect(types[0]).toBe("session_token")
+  })
+
+})

package/src/server/claude-pty/jsonl-to-event.ts

@@ -0,0 +1,174 @@
+import type { HarnessEvent } from "../harness-types"
+import type { ContextWindowUsageSnapshot } from "../../shared/types"
+import {
+  normalizeClaudeStreamMessage,
+  normalizeClaudeUsageSnapshot,
+  resolveFinalTurnUsage,
+  maxClaudeContextWindowFromModelUsage,
+  getClaudeAssistantMessageUsageId,
+  timestamped,
+} from "./agent-normalizers"
+import { ClaudeLimitDetector } from "./../auto-continue/limit-detector"
+
+export interface JsonlEventParser {
+  /** Parse one JSONL line; returns zero or more harness events. Stateful — updates internal usage / context-window tracking across calls. */
+  parse(rawLine: string): HarnessEvent[]
+}
+
+export interface CreateJsonlEventParserOptions {
+  /** Per-model context-window floor (e.g. 1_000_000 for `[1m]` models). */
+  configuredContextWindow?: number
+}
+
+/**
+ * Stateful JSONL → HarnessEvent parser. One instance per PTY session so
+ * usage snapshots can be diffed across `assistant` → `result` messages,
+ * matching the SDK driver's `createClaudeHarnessStream` shape.
+ */
+export function createJsonlEventParser(opts: CreateJsonlEventParserOptions = {}): JsonlEventParser {
+  let seenAssistantUsageIds = new Set<string>()
+  let latestUsageSnapshot: ContextWindowUsageSnapshot | null = null
+  let lastKnownContextWindow: number | undefined = opts.configuredContextWindow
+  const detector = new ClaudeLimitDetector()
+
+  return {
+    parse(rawLine: string): HarnessEvent[] {
+      const trimmed = rawLine.trim()
+      if (!trimmed) return []
+      let parsed: unknown
+      try {
+        parsed = JSON.parse(trimmed)
+      } catch {
+        console.warn("[claude-pty/jsonl] failed to parse line", trimmed.slice(0, 120))
+        return []
+      }
+      if (!parsed || typeof parsed !== "object") return []
+      const message = parsed as Record<string, unknown>
+      const events: HarnessEvent[] = []
+
+      // D3 — emit session_token for any message carrying a session_id, not
+      // just `system/init`. Matches the SDK driver loop in
+      // createClaudeHarnessStream (agent.ts).
+      if (typeof message.session_id === "string" && message.session_id.length > 0) {
+        events.push({ type: "session_token", sessionToken: message.session_id })
+      }
+
+      // D2 — recognise both shapes:
+      //   (a) the SDK-native `rate_limit_event` message Claude Code mirrors
+      //       into JSONL when running under the agent SDK
+      //   (b) legacy `system/rate_limit` shape kept for any older CLI build
+      //       that emits it (existing kanna call sites).
+      if (message.type === "rate_limit_event") {
+        const detection = detector.detectFromSdkRateLimitInfo(
+          "",
+          (message as { rate_limit_info?: unknown }).rate_limit_info,
+        )
+        if (detection) {
+          events.push({ type: "rate_limit", rateLimit: { resetAt: detection.resetAt, tz: detection.tz } })
+        }
+      } else if (message.type === "system" && message.subtype === "rate_limit") {
+        const resetAt = typeof message.resetAt === "number" ? message.resetAt : Date.now()
+        const tz = typeof message.tz === "string" ? message.tz : "UTC"
+        events.push({ type: "rate_limit", rateLimit: { resetAt, tz } })
+      }
+
+      // D1 — assistant message usage delta → context_window_updated.
+      if (message.type === "assistant") {
+        const usageId = getClaudeAssistantMessageUsageId(message)
+        const usageSnapshot = normalizeClaudeUsageSnapshot(
+          (message as { usage?: unknown }).usage,
+          lastKnownContextWindow,
+        )
+        if (usageId && usageSnapshot && !seenAssistantUsageIds.has(usageId)) {
+          seenAssistantUsageIds.add(usageId)
+          latestUsageSnapshot = usageSnapshot
+          events.push({
+            type: "transcript",
+            entry: timestamped({ kind: "context_window_updated", usage: usageSnapshot }),
+          })
+        }
+      }
+
+      // D1 — turn-end context window emit. Preserves the configured-window
+      // floor so the SDK-internal `modelUsage.contextWindow` of 200_000
+      // can't silently override a 1M-beta opt-in.
+      if (message.type === "result") {
+        const resultContextWindow = maxClaudeContextWindowFromModelUsage(
+          (message as { modelUsage?: unknown }).modelUsage,
+        )
+        if (resultContextWindow !== undefined) {
+          lastKnownContextWindow = Math.max(lastKnownContextWindow ?? 0, resultContextWindow)
+        }
+        const accumulatedUsage = normalizeClaudeUsageSnapshot(
+          (message as { usage?: unknown }).usage,
+          lastKnownContextWindow,
+        )
+        const finalUsage = resolveFinalTurnUsage(
+          latestUsageSnapshot,
+          accumulatedUsage,
+          lastKnownContextWindow,
+        )
+        if (finalUsage) {
+          events.push({
+            type: "transcript",
+            entry: timestamped({ kind: "context_window_updated", usage: finalUsage }),
+          })
+        }
+        seenAssistantUsageIds = new Set<string>()
+        latestUsageSnapshot = null
+      }
+
+      try {
+        const entries = normalizeClaudeStreamMessage(parsed)
+        for (const entry of entries) {
+          events.push({ type: "transcript", entry })
+        }
+      } catch (err) {
+        console.warn("[claude-pty/jsonl] normalizeClaudeStreamMessage threw", err)
+      }
+
+      return events
+    },
+  }
+}
+
+/**
+ * Stateless wrapper kept for callers that don't need usage tracking.
+ * Behaves the same as before D1/D2/D3 landed: no usage diff, no per-message
+ * session_token. New callers should use `createJsonlEventParser` instead.
+ */
+export function parseJsonlLine(rawLine: string): HarnessEvent[] {
+  const trimmed = rawLine.trim()
+  if (!trimmed) return []
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(trimmed)
+  } catch {
+    console.warn("[claude-pty/jsonl] failed to parse line", trimmed.slice(0, 120))
+    return []
+  }
+  if (!parsed || typeof parsed !== "object") return []
+  const message = parsed as Record<string, unknown>
+  const events: HarnessEvent[] = []
+
+  if (message.type === "system" && message.subtype === "init" && typeof message.session_id === "string") {
+    events.push({ type: "session_token", sessionToken: message.session_id })
+  }
+
+  if (message.type === "system" && message.subtype === "rate_limit") {
+    const resetAt = typeof message.resetAt === "number" ? message.resetAt : Date.now()
+    const tz = typeof message.tz === "string" ? message.tz : "UTC"
+    events.push({ type: "rate_limit", rateLimit: { resetAt, tz } })
+  }
+
+  try {
+    const entries = normalizeClaudeStreamMessage(parsed)
+    for (const entry of entries) {
+      events.push({ type: "transcript", entry })
+    }
+  } catch (err) {
+    console.warn("[claude-pty/jsonl] normalizeClaudeStreamMessage threw", err)
+  }
+
+  return events
+}

package/src/server/claude-pty/output-ring.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, test } from "bun:test"
+import { OutputRing, OUTPUT_RING_DEFAULT_BYTES } from "./output-ring"
+
+describe("OutputRing", () => {
+  test("appends and returns full content under capacity", () => {
+    const r = new OutputRing(100)
+    r.append("hello ")
+    r.append("world")
+    expect(r.tail()).toBe("hello world")
+  })
+
+  test("drops oldest bytes once capacity exceeded", () => {
+    const r = new OutputRing(5)
+    r.append("abcdefgh")
+    expect(r.tail()).toBe("defgh")
+  })
+
+  test("default capacity is 256 KB", () => {
+    expect(OUTPUT_RING_DEFAULT_BYTES).toBe(256 * 1024)
+  })
+
+  test("contains(needle) returns true when present in tail", () => {
+    const r = new OutputRing(100)
+    r.append("Please run /login")
+    expect(r.contains("/login")).toBe(true)
+    expect(r.contains("foobar")).toBe(false)
+  })
+
+  test("contains works after rotation", () => {
+    const r = new OutputRing(20)
+    r.append("xxxxxxxxxxxxx")
+    r.append("Please run /login")
+    expect(r.contains("/login")).toBe(true)
+  })
+})

package/src/server/claude-pty/output-ring.ts

@@ -0,0 +1,25 @@
+export const OUTPUT_RING_DEFAULT_BYTES = 256 * 1024
+
+export class OutputRing {
+  private buf = ""
+  private readonly capacity: number
+
+  constructor(capacityBytes: number = OUTPUT_RING_DEFAULT_BYTES) {
+    this.capacity = capacityBytes
+  }
+
+  append(chunk: string): void {
+    this.buf += chunk
+    if (this.buf.length > this.capacity) {
+      this.buf = this.buf.slice(this.buf.length - this.capacity)
+    }
+  }
+
+  tail(): string {
+    return this.buf
+  }
+
+  contains(needle: string): boolean {
+    return this.buf.includes(needle)
+  }
+}