airaknit 1.1.2-rc.9

package/src/server/terminal-manager.ts

@@ -0,0 +1,354 @@
+import path from "node:path"
+import process from "node:process"
+import defaultShell, { detectDefaultShell } from "default-shell"
+import { Terminal } from "@xterm/headless"
+import { SerializeAddon } from "@xterm/addon-serialize"
+import type { TerminalEvent, TerminalSnapshot } from "../shared/protocol"
+
+const DEFAULT_COLS = 80
+const DEFAULT_ROWS = 24
+const DEFAULT_SCROLLBACK = 1_000
+const MIN_SCROLLBACK = 500
+const MAX_SCROLLBACK = 5_000
+const FOCUS_IN_SEQUENCE = "\x1b[I"
+const FOCUS_OUT_SEQUENCE = "\x1b[O"
+const MODE_SEQUENCE_TAIL_LENGTH = 16
+
+interface CreateTerminalArgs {
+  workspacePath: string
+  terminalId: string
+  cols: number
+  rows: number
+  scrollback: number
+}
+
+interface TerminalSession {
+  terminalId: string
+  title: string
+  cwd: string
+  shell: string
+  cols: number
+  rows: number
+  scrollback: number
+  status: "running" | "exited"
+  exitCode: number | null
+  process: Bun.Subprocess | null
+  terminal: Bun.Terminal
+  headless: Terminal
+  serializeAddon: SerializeAddon
+  focusReportingEnabled: boolean
+  modeSequenceTail: string
+}
+
+function clampScrollback(value: number) {
+  if (!Number.isFinite(value)) return DEFAULT_SCROLLBACK
+  return Math.min(MAX_SCROLLBACK, Math.max(MIN_SCROLLBACK, Math.round(value)))
+}
+
+function normalizeTerminalDimension(value: number, fallback: number) {
+  if (!Number.isFinite(value)) return fallback
+  return Math.max(1, Math.round(value))
+}
+
+function resolveShell() {
+  if (process.env.TINKARIA_SHELL) {
+    return process.env.TINKARIA_SHELL
+  }
+
+  try {
+    return detectDefaultShell()
+  } catch {
+    if (defaultShell) return defaultShell
+    if (process.platform === "win32") {
+      return process.env.ComSpec || "cmd.exe"
+    }
+    return process.env.SHELL || "/bin/sh"
+  }
+}
+
+function resolveShellArgs(shellPath: string) {
+  if (process.platform === "win32") {
+    return []
+  }
+
+  const shellName = path.basename(shellPath)
+  if (["bash", "zsh", "fish", "sh", "ksh"].includes(shellName)) {
+    return ["-l"]
+  }
+
+  return []
+}
+
+function createTerminalEnv() {
+  return {
+    ...process.env,
+    TERM: "xterm-256color",
+    COLORTERM: "truecolor",
+  }
+}
+
+function updateFocusReportingState(session: Pick<TerminalSession, "focusReportingEnabled" | "modeSequenceTail">, chunk: string) {
+  const combined = session.modeSequenceTail + chunk
+  const regex = /\x1b\[\?1004([hl])/g
+
+  for (const match of combined.matchAll(regex)) {
+    session.focusReportingEnabled = match[1] === "h"
+  }
+
+  session.modeSequenceTail = combined.slice(-MODE_SEQUENCE_TAIL_LENGTH)
+}
+
+function filterFocusReportInput(data: string, allowFocusReporting: boolean) {
+  if (allowFocusReporting) {
+    return data
+  }
+
+  return data.replaceAll(FOCUS_IN_SEQUENCE, "").replaceAll(FOCUS_OUT_SEQUENCE, "")
+}
+
+function killTerminalProcessTree(subprocess: Bun.Subprocess | null) {
+  if (!subprocess) return
+
+  const pid = subprocess.pid
+  if (typeof pid !== "number") return
+
+  if (process.platform !== "win32") {
+    try {
+      process.kill(-pid, "SIGKILL")
+      return
+    } catch {
+      // Fall back to killing only the shell process if group termination fails.
+    }
+  }
+
+  try {
+    subprocess.kill("SIGKILL")
+  } catch {
+    // Ignore subprocess shutdown errors during disposal.
+  }
+}
+
+function signalTerminalProcessGroup(subprocess: Bun.Subprocess | null, signal: NodeJS.Signals) {
+  if (!subprocess) return false
+
+  const pid = subprocess.pid
+  if (typeof pid !== "number") return false
+
+  if (process.platform !== "win32") {
+    try {
+      process.kill(-pid, signal)
+      return true
+    } catch {
+      // Fall back to signaling only the shell if group signaling fails.
+    }
+  }
+
+  try {
+    subprocess.kill(signal)
+    return true
+  } catch {
+    return false
+  }
+}
+
+export class TerminalManager {
+  private readonly sessions = new Map<string, TerminalSession>()
+  private readonly listeners = new Set<(event: TerminalEvent) => void>()
+
+  onEvent(listener: (event: TerminalEvent) => void) {
+    this.listeners.add(listener)
+    return () => {
+      this.listeners.delete(listener)
+    }
+  }
+
+  createTerminal(args: CreateTerminalArgs) {
+    if (process.platform === "win32") {
+      throw new Error("Embedded terminal is currently supported on macOS/Linux only.")
+    }
+    if (typeof Bun.Terminal !== "function") {
+      throw new Error("Embedded terminal requires Bun 1.3.5+ with Bun.Terminal support.")
+    }
+
+    const existing = this.sessions.get(args.terminalId)
+    if (existing) {
+      existing.scrollback = clampScrollback(args.scrollback)
+      existing.cols = normalizeTerminalDimension(args.cols, existing.cols)
+      existing.rows = normalizeTerminalDimension(args.rows, existing.rows)
+      existing.headless.options.scrollback = existing.scrollback
+      existing.headless.resize(existing.cols, existing.rows)
+      existing.terminal.resize(existing.cols, existing.rows)
+      signalTerminalProcessGroup(existing.process, "SIGWINCH")
+      return this.snapshotOf(existing)
+    }
+
+    const shell = resolveShell()
+    const cols = normalizeTerminalDimension(args.cols, DEFAULT_COLS)
+    const rows = normalizeTerminalDimension(args.rows, DEFAULT_ROWS)
+    const scrollback = clampScrollback(args.scrollback)
+    const title = path.basename(shell) || "shell"
+    const headless = new Terminal({ cols, rows, scrollback, allowProposedApi: true })
+    const serializeAddon = new SerializeAddon()
+    headless.loadAddon(serializeAddon)
+
+    const session: TerminalSession = {
+      terminalId: args.terminalId,
+      title,
+      cwd: args.workspacePath,
+      shell,
+      cols,
+      rows,
+      scrollback,
+      status: "running",
+      exitCode: null,
+      process: null,
+      terminal: new Bun.Terminal({
+        cols,
+        rows,
+        name: "xterm-256color",
+        data: (_terminal, data) => {
+          const chunk = Buffer.from(data).toString("utf8")
+          updateFocusReportingState(session, chunk)
+          headless.write(chunk)
+          this.emit({
+            type: "terminal.output",
+            terminalId: args.terminalId,
+            data: chunk,
+          })
+        },
+      }),
+      headless,
+      serializeAddon,
+      focusReportingEnabled: false,
+      modeSequenceTail: "",
+    }
+
+    try {
+      session.process = Bun.spawn([shell, ...resolveShellArgs(shell)], {
+        cwd: args.workspacePath,
+        env: createTerminalEnv(),
+        terminal: session.terminal,
+      })
+    } catch (error) {
+      session.terminal.close()
+      session.serializeAddon.dispose()
+      session.headless.dispose()
+      throw error
+    }
+    void session.process.exited.then((exitCode) => {
+      const active = this.sessions.get(args.terminalId)
+      if (!active) return
+      active.status = "exited"
+      active.exitCode = exitCode
+      this.emit({
+        type: "terminal.exit",
+        terminalId: args.terminalId,
+        exitCode,
+      })
+    }).catch((error) => {
+      const active = this.sessions.get(args.terminalId)
+      if (!active) return
+      active.status = "exited"
+      active.exitCode = 1
+      this.emit({
+        type: "terminal.output",
+        terminalId: args.terminalId,
+        data: `\r\n[terminal error] ${error instanceof Error ? error.message : String(error)}\r\n`,
+      })
+      this.emit({
+        type: "terminal.exit",
+        terminalId: args.terminalId,
+        exitCode: 1,
+      })
+    })
+
+    this.sessions.set(args.terminalId, session)
+    return this.snapshotOf(session)
+  }
+
+  getSnapshot(terminalId: string): TerminalSnapshot | null {
+    const session = this.sessions.get(terminalId)
+    return session ? this.snapshotOf(session) : null
+  }
+
+  write(terminalId: string, data: string) {
+    const session = this.sessions.get(terminalId)
+    if (!session || session.status === "exited") return
+
+    const filteredData = filterFocusReportInput(data, session.focusReportingEnabled)
+    if (!filteredData) return
+
+    let cursor = 0
+
+    while (cursor < filteredData.length) {
+      const ctrlCIndex = filteredData.indexOf("\x03", cursor)
+
+      if (ctrlCIndex === -1) {
+        session.terminal.write(filteredData.slice(cursor))
+        return
+      }
+
+      if (ctrlCIndex > cursor) {
+        session.terminal.write(filteredData.slice(cursor, ctrlCIndex))
+      }
+
+      signalTerminalProcessGroup(session.process, "SIGINT")
+      cursor = ctrlCIndex + 1
+    }
+  }
+
+  resize(terminalId: string, cols: number, rows: number) {
+    const session = this.sessions.get(terminalId)
+    if (!session) return
+    session.cols = normalizeTerminalDimension(cols, session.cols)
+    session.rows = normalizeTerminalDimension(rows, session.rows)
+    session.headless.resize(session.cols, session.rows)
+    session.terminal.resize(session.cols, session.rows)
+    signalTerminalProcessGroup(session.process, "SIGWINCH")
+  }
+
+  close(terminalId: string) {
+    const session = this.sessions.get(terminalId)
+    if (!session) return
+
+    this.sessions.delete(terminalId)
+    killTerminalProcessTree(session.process)
+    session.terminal.close()
+    session.serializeAddon.dispose()
+    session.headless.dispose()
+  }
+
+  closeByCwd(cwd: string) {
+    for (const [terminalId, session] of this.sessions.entries()) {
+      if (session.cwd !== cwd) continue
+      this.close(terminalId)
+    }
+  }
+
+  closeAll() {
+    for (const terminalId of this.sessions.keys()) {
+      this.close(terminalId)
+    }
+  }
+
+  private snapshotOf(session: TerminalSession): TerminalSnapshot {
+    return {
+      terminalId: session.terminalId,
+      title: session.title,
+      cwd: session.cwd,
+      shell: session.shell,
+      cols: session.cols,
+      rows: session.rows,
+      scrollback: session.scrollback,
+      serializedState: session.serializeAddon.serialize({ scrollback: session.scrollback }),
+      status: session.status,
+      exitCode: session.exitCode,
+    }
+  }
+
+  private emit(event: TerminalEvent) {
+    for (const listener of this.listeners) {
+      listener(event)
+    }
+  }
+}

package/src/server/transcript-consumer.test.ts

@@ -0,0 +1,339 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { NatsServer } from "@lagz0ne/nats-embedded"
+import { connect, type NatsConnection } from "@nats-io/transport-node"
+import { jetstream } from "@nats-io/jetstream"
+import { ensureRunnerEventsStream } from "./nats-streams"
+import { runnerEventsSubject } from "../shared/runner-protocol"
+import { TranscriptConsumer, type TranscriptConsumerStore } from "./transcript-consumer"
+import type { TranscriptEntry, SessionStatus, AgentProvider } from "../shared/types"
+
+const encoder = new TextEncoder()
+
+let server: NatsServer | null = null
+let nc: NatsConnection | null = null
+let consumer: TranscriptConsumer | null = null
+
+afterEach(async () => {
+  if (consumer) {
+    consumer.stop()
+    consumer = null
+  }
+  if (nc) {
+    await nc.drain()
+    nc = null
+  }
+  if (server) {
+    await server.stop()
+    server = null
+  }
+})
+
+async function setup() {
+  server = await NatsServer.start({ jetstream: true })
+  nc = await connect({ servers: server.url })
+  await ensureRunnerEventsStream(nc)
+  return nc
+}
+
+function makeStore(): TranscriptConsumerStore & {
+  calls: { method: string; args: unknown[] }[]
+} {
+  const calls: { method: string; args: unknown[] }[] = []
+  return {
+    calls,
+    async appendMessage(chatId: string, entry: TranscriptEntry) {
+      calls.push({ method: "appendMessage", args: [chatId, entry] })
+    },
+    async recordTurnFinished(chatId: string) {
+      calls.push({ method: "recordTurnFinished", args: [chatId] })
+    },
+    async recordTurnFailed(chatId: string, error: string) {
+      calls.push({ method: "recordTurnFailed", args: [chatId, error] })
+    },
+    async recordTurnCancelled(chatId: string) {
+      calls.push({ method: "recordTurnCancelled", args: [chatId] })
+    },
+    async setSessionToken(chatId: string, token: string | null) {
+      calls.push({ method: "setSessionToken", args: [chatId, token] })
+    },
+    async renameChat(chatId: string, title: string) {
+      calls.push({ method: "renameChat", args: [chatId, title] })
+    },
+    async setChatProvider(chatId: string, provider: AgentProvider) {
+      calls.push({ method: "setChatProvider", args: [chatId, provider] })
+    },
+    async setPlanMode(chatId: string, planMode: boolean) {
+      calls.push({ method: "setPlanMode", args: [chatId, planMode] })
+    },
+  }
+}
+
+async function publishEvent(conn: NatsConnection, chatId: string, event: Record<string, unknown>) {
+  const js = jetstream(conn)
+  const subject = runnerEventsSubject(chatId)
+  await js.publish(subject, encoder.encode(JSON.stringify({ ...event, chatId })))
+}
+
+/** Wait until the predicate returns true, polling every intervalMs. Throws after timeoutMs. */
+async function waitFor(predicate: () => boolean, timeoutMs = 3000, intervalMs = 20): Promise<void> {
+  const deadline = Date.now() + timeoutMs
+  while (!predicate()) {
+    if (Date.now() > deadline) throw new Error("waitFor timeout")
+    await new Promise((r) => setTimeout(r, intervalMs))
+  }
+}
+
+describe("TranscriptConsumer", () => {
+  test("transcript event calls store.appendMessage and onMessageAppended", async () => {
+    const conn = await setup()
+    const store = makeStore()
+    const appended: { chatId: string; entry: TranscriptEntry }[] = []
+
+    consumer = new TranscriptConsumer({
+      nc: conn,
+      store,
+      onStateChange: () => {},
+      onMessageAppended: (chatId, entry) => appended.push({ chatId, entry }),
+    })
+    await consumer.start()
+
+    const entry: TranscriptEntry = { _id: "msg-1", createdAt: Date.now(), kind: "assistant_text", text: "hello" }
+    await publishEvent(conn, "chat-1", { type: "transcript", entry })
+
+    await waitFor(() => store.calls.length >= 1)
+    expect(store.calls[0]).toEqual({ method: "appendMessage", args: ["chat-1", entry] })
+    expect(appended).toHaveLength(1)
+    expect(appended[0]!.chatId).toBe("chat-1")
+    expect(appended[0]!.entry).toEqual(entry)
+  })
+
+  test("turn_finished calls store.recordTurnFinished and removes from activeStatuses", async () => {
+    const conn = await setup()
+    const store = makeStore()
+    let stateChanges = 0
+
+    consumer = new TranscriptConsumer({
+      nc: conn,
+      store,
+      onStateChange: () => { stateChanges++ },
+    })
+    await consumer.start()
+
+    // First set a status so there's something to remove
+    await publishEvent(conn, "chat-2", { type: "status_change", status: "running" satisfies SessionStatus })
+    await waitFor(() => stateChanges >= 1)
+    expect(consumer.getActiveStatuses().get("chat-2")).toBe("running")
+
+    // Now finish
+    await publishEvent(conn, "chat-2", { type: "turn_finished" })
+    await waitFor(() => store.calls.some((c) => c.method === "recordTurnFinished"))
+    expect(store.calls.find((c) => c.method === "recordTurnFinished")).toEqual({
+      method: "recordTurnFinished",
+      args: ["chat-2"],
+    })
+    expect(consumer.getActiveStatuses().has("chat-2")).toBe(false)
+  })
+
+  test("turn_failed calls store.recordTurnFailed and removes from activeStatuses", async () => {
+    const conn = await setup()
+    const store = makeStore()
+    let stateChanges = 0
+
+    consumer = new TranscriptConsumer({
+      nc: conn,
+      store,
+      onStateChange: () => { stateChanges++ },
+    })
+    await consumer.start()
+
+    await publishEvent(conn, "chat-3", { type: "status_change", status: "running" satisfies SessionStatus })
+    await waitFor(() => stateChanges >= 1)
+
+    await publishEvent(conn, "chat-3", { type: "turn_failed", error: "something broke" })
+    await waitFor(() => store.calls.some((c) => c.method === "recordTurnFailed"))
+    expect(store.calls.find((c) => c.method === "recordTurnFailed")).toEqual({
+      method: "recordTurnFailed",
+      args: ["chat-3", "something broke"],
+    })
+    expect(consumer.getActiveStatuses().has("chat-3")).toBe(false)
+  })
+
+  test("turn_cancelled calls store.recordTurnCancelled and removes from activeStatuses", async () => {
+    const conn = await setup()
+    const store = makeStore()
+    let stateChanges = 0
+
+    consumer = new TranscriptConsumer({
+      nc: conn,
+      store,
+      onStateChange: () => { stateChanges++ },
+    })
+    await consumer.start()
+
+    await publishEvent(conn, "chat-4", { type: "status_change", status: "running" satisfies SessionStatus })
+    await waitFor(() => stateChanges >= 1)
+
+    await publishEvent(conn, "chat-4", { type: "turn_cancelled" })
+    await waitFor(() => store.calls.some((c) => c.method === "recordTurnCancelled"))
+    expect(store.calls.find((c) => c.method === "recordTurnCancelled")).toEqual({
+      method: "recordTurnCancelled",
+      args: ["chat-4"],
+    })
+    expect(consumer.getActiveStatuses().has("chat-4")).toBe(false)
+  })
+
+  test("session_token calls store.setSessionToken", async () => {
+    const conn = await setup()
+    const store = makeStore()
+
+    consumer = new TranscriptConsumer({
+      nc: conn,
+      store,
+      onStateChange: () => {},
+    })
+    await consumer.start()
+
+    await publishEvent(conn, "chat-5", { type: "session_token", sessionToken: "tok-abc" })
+    await waitFor(() => store.calls.some((c) => c.method === "setSessionToken"))
+    expect(store.calls.find((c) => c.method === "setSessionToken")).toEqual({
+      method: "setSessionToken",
+      args: ["chat-5", "tok-abc"],
+    })
+  })
+
+  test("title_generated calls store.renameChat", async () => {
+    const conn = await setup()
+    const store = makeStore()
+
+    consumer = new TranscriptConsumer({
+      nc: conn,
+      store,
+      onStateChange: () => {},
+    })
+    await consumer.start()
+
+    await publishEvent(conn, "chat-6", { type: "title_generated", title: "My Chat Title" })
+    await waitFor(() => store.calls.some((c) => c.method === "renameChat"))
+    expect(store.calls.find((c) => c.method === "renameChat")).toEqual({
+      method: "renameChat",
+      args: ["chat-6", "My Chat Title"],
+    })
+  })
+
+  test("status_change updates activeStatuses", async () => {
+    const conn = await setup()
+    const store = makeStore()
+    let stateChanges = 0
+
+    consumer = new TranscriptConsumer({
+      nc: conn,
+      store,
+      onStateChange: () => { stateChanges++ },
+    })
+    await consumer.start()
+
+    await publishEvent(conn, "chat-7", { type: "status_change", status: "running" satisfies SessionStatus })
+    await waitFor(() => stateChanges >= 1)
+    expect(consumer.getActiveStatuses().get("chat-7")).toBe("running")
+
+    await publishEvent(conn, "chat-7", { type: "status_change", status: "waiting_for_user" satisfies SessionStatus })
+    await waitFor(() => stateChanges >= 2)
+    expect(consumer.getActiveStatuses().get("chat-7")).toBe("waiting_for_user")
+  })
+
+  test("provider_set calls store.setChatProvider", async () => {
+    const conn = await setup()
+    const store = makeStore()
+
+    consumer = new TranscriptConsumer({
+      nc: conn,
+      store,
+      onStateChange: () => {},
+    })
+    await consumer.start()
+
+    await publishEvent(conn, "chat-8", { type: "provider_set", provider: "claude" })
+    await waitFor(() => store.calls.some((c) => c.method === "setChatProvider"))
+    expect(store.calls.find((c) => c.method === "setChatProvider")).toEqual({
+      method: "setChatProvider",
+      args: ["chat-8", "claude"],
+    })
+  })
+
+  test("plan_mode_set calls store.setPlanMode", async () => {
+    const conn = await setup()
+    const store = makeStore()
+
+    consumer = new TranscriptConsumer({
+      nc: conn,
+      store,
+      onStateChange: () => {},
+    })
+    await consumer.start()
+
+    await publishEvent(conn, "chat-9", { type: "plan_mode_set", planMode: true })
+    await waitFor(() => store.calls.some((c) => c.method === "setPlanMode"))
+    expect(store.calls.find((c) => c.method === "setPlanMode")).toEqual({
+      method: "setPlanMode",
+      args: ["chat-9", true],
+    })
+  })
+
+  test("every event triggers onStateChange", async () => {
+    const conn = await setup()
+    const store = makeStore()
+    let stateChanges = 0
+
+    consumer = new TranscriptConsumer({
+      nc: conn,
+      store,
+      onStateChange: () => { stateChanges++ },
+    })
+    await consumer.start()
+
+    const entry: TranscriptEntry = { _id: "msg-x", createdAt: Date.now(), kind: "assistant_text", text: "hi" }
+    await publishEvent(conn, "chat-x", { type: "transcript", entry })
+    await publishEvent(conn, "chat-x", { type: "status_change", status: "running" satisfies SessionStatus })
+    await publishEvent(conn, "chat-x", { type: "turn_finished" })
+
+    await waitFor(() => stateChanges >= 3)
+    expect(stateChanges).toBeGreaterThanOrEqual(3)
+  })
+
+  test("pending_tool event triggers onStateChange without store call", async () => {
+    const conn = await setup()
+    const store = makeStore()
+    let stateChanges = 0
+
+    consumer = new TranscriptConsumer({
+      nc: conn,
+      store,
+      onStateChange: () => { stateChanges++ },
+    })
+    await consumer.start()
+
+    await publishEvent(conn, "chat-pt", { type: "pending_tool", tool: { toolUseId: "t1", toolKind: "ask_user_question" } })
+    await waitFor(() => stateChanges >= 1)
+    // No store method called for pending_tool
+    expect(store.calls).toHaveLength(0)
+  })
+
+  test("context_cleared event does not trigger onStateChange (handled by session_token)", async () => {
+    const conn = await setup()
+    const store = makeStore()
+    let stateChanges = 0
+
+    consumer = new TranscriptConsumer({
+      nc: conn,
+      store,
+      onStateChange: () => { stateChanges++ },
+    })
+    await consumer.start()
+
+    await publishEvent(conn, "chat-cc", { type: "context_cleared" })
+    // Give consumer time to process — but state should NOT change
+    await new Promise(r => setTimeout(r, 200))
+    expect(stateChanges).toBe(0)
+    expect(store.calls).toHaveLength(0)
+  })
+})