kanna-code 0.4.2 → 0.5.1

package/src/server/terminal-manager.ts

@@ -0,0 +1,319 @@
+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
+
+interface CreateTerminalArgs {
+  projectPath: 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
+}
+
+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() {
+  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 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)
+      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.projectPath,
+      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")
+          headless.write(chunk)
+          this.emit({
+            type: "terminal.output",
+            terminalId: args.terminalId,
+            data: chunk,
+          })
+        },
+      }),
+      headless,
+      serializeAddon,
+    }
+
+    try {
+      session.process = Bun.spawn([shell, ...resolveShellArgs(shell)], {
+        cwd: args.projectPath,
+        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
+
+    let cursor = 0
+
+    while (cursor < data.length) {
+      const ctrlCIndex = data.indexOf("\x03", cursor)
+
+      if (ctrlCIndex === -1) {
+        session.terminal.write(data.slice(cursor))
+        return
+      }
+
+      if (ctrlCIndex > cursor) {
+        session.terminal.write(data.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)
+  }
+
+  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/ws-router.test.ts

@@ -19,6 +19,10 @@ describe("ws-router", () => {
     const router = createWsRouter({
       store: { state: createEmptyState() } as never,
       agent: { getActiveStatuses: () => new Map() } as never,
+      terminals: {
+        getSnapshot: () => null,
+        onEvent: () => () => {},
+      } as never,
       refreshDiscovery: async () => [],
       getDiscoveredProjects: () => [],
       machineDisplayName: "Local Machine",
@@ -44,4 +48,43 @@ describe("ws-router", () => {
       },
     ])
   })
+
+  test("acks terminal.input without rebroadcasting terminal snapshots", () => {
+    const router = createWsRouter({
+      store: { state: createEmptyState() } as never,
+      agent: { getActiveStatuses: () => new Map() } as never,
+      terminals: {
+        getSnapshot: () => null,
+        onEvent: () => () => {},
+        write: () => {},
+      } as never,
+      refreshDiscovery: async () => [],
+      getDiscoveredProjects: () => [],
+      machineDisplayName: "Local Machine",
+    })
+    const ws = new FakeWebSocket()
+
+    ws.data.subscriptions.set("sub-terminal", { type: "terminal", terminalId: "terminal-1" })
+    router.handleMessage(
+      ws as never,
+      JSON.stringify({
+        v: 1,
+        type: "command",
+        id: "terminal-input-1",
+        command: {
+          type: "terminal.input",
+          terminalId: "terminal-1",
+          data: "ls\r",
+        },
+      })
+    )
+
+    expect(ws.sent).toEqual([
+      {
+        v: PROTOCOL_VERSION,
+        type: "ack",
+        id: "terminal-input-1",
+      },
+    ])
+  })
 })

package/src/server/ws-router.ts

@@ -7,6 +7,7 @@ import type { DiscoveredProject } from "./discovery"
 import { EventStore } from "./event-store"
 import { openExternal } from "./external-open"
 import { ensureProjectDirectory } from "./paths"
+import { TerminalManager } from "./terminal-manager"
 import { deriveChatSnapshot, deriveLocalProjectsSnapshot, deriveSidebarData } from "./read-models"
 
 export interface ClientState {
@@ -16,6 +17,7 @@ export interface ClientState {
 interface CreateWsRouterArgs {
   store: EventStore
   agent: AgentCoordinator
+  terminals: TerminalManager
   refreshDiscovery: () => Promise<DiscoveredProject[]>
   getDiscoveredProjects: () => DiscoveredProject[]
   machineDisplayName: string
@@ -28,6 +30,7 @@ function send(ws: ServerWebSocket<ClientState>, message: ServerEnvelope) {
 export function createWsRouter({
   store,
   agent,
+  terminals,
   refreshDiscovery,
   getDiscoveredProjects,
   machineDisplayName,
@@ -62,6 +65,18 @@ export function createWsRouter({
       }
     }
 
+    if (topic.type === "terminal") {
+      return {
+        v: PROTOCOL_VERSION,
+        type: "snapshot",
+        id,
+        snapshot: {
+          type: "terminal",
+          data: terminals.getSnapshot(topic.terminalId),
+        },
+      }
+    }
+
     return {
       v: PROTOCOL_VERSION,
       type: "snapshot",
@@ -85,6 +100,33 @@ export function createWsRouter({
     }
   }
 
+  function pushTerminalSnapshot(terminalId: string) {
+    for (const ws of sockets) {
+      for (const [id, topic] of ws.data.subscriptions.entries()) {
+        if (topic.type !== "terminal" || topic.terminalId !== terminalId) continue
+        send(ws, createEnvelope(id, topic))
+      }
+    }
+  }
+
+  function pushTerminalEvent(terminalId: string, event: Extract<ServerEnvelope, { type: "event" }>["event"]) {
+    for (const ws of sockets) {
+      for (const [id, topic] of ws.data.subscriptions.entries()) {
+        if (topic.type !== "terminal" || topic.terminalId !== terminalId) continue
+        send(ws, {
+          v: PROTOCOL_VERSION,
+          type: "event",
+          id,
+          event,
+        })
+      }
+    }
+  }
+
+  const disposeTerminalEvents = terminals.onEvent((event) => {
+    pushTerminalEvent(event.terminalId, event)
+  })
+
   async function handleCommand(ws: ServerWebSocket<ClientState>, message: Extract<ClientEnvelope, { type: "command" }>) {
     const { command, id } = message
     try {
@@ -108,9 +150,13 @@ export function createWsRouter({
           break
         }
         case "project.remove": {
+          const project = store.getProject(command.projectId)
           for (const chat of store.listChatsByProject(command.projectId)) {
             await agent.cancel(chat.id)
           }
+          if (project) {
+            terminals.closeByCwd(project.localPath)
+          }
           await store.removeProject(command.projectId)
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
           break
@@ -151,6 +197,37 @@ export function createWsRouter({
           send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
           break
         }
+        case "terminal.create": {
+          const project = store.getProject(command.projectId)
+          if (!project) {
+            throw new Error("Project not found")
+          }
+          const snapshot = terminals.createTerminal({
+            projectPath: project.localPath,
+            terminalId: command.terminalId,
+            cols: command.cols,
+            rows: command.rows,
+            scrollback: command.scrollback,
+          })
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id, result: snapshot })
+          return
+        }
+        case "terminal.input": {
+          terminals.write(command.terminalId, command.data)
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
+          return
+        }
+        case "terminal.resize": {
+          terminals.resize(command.terminalId, command.cols, command.rows)
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
+          return
+        }
+        case "terminal.close": {
+          terminals.close(command.terminalId)
+          send(ws, { v: PROTOCOL_VERSION, type: "ack", id })
+          pushTerminalSnapshot(command.terminalId)
+          return
+        }
       }
 
       broadcastSnapshots()
@@ -203,5 +280,8 @@ export function createWsRouter({
 
       void handleCommand(ws, parsed)
     },
+    dispose() {
+      disposeTerminalEvents()
+    },
   }
 }

package/src/shared/protocol.ts

@@ -4,6 +4,25 @@ export type SubscriptionTopic =
   | { type: "sidebar" }
   | { type: "local-projects" }
   | { type: "chat"; chatId: string }
+  | { type: "terminal"; terminalId: string }
+
+export interface TerminalSnapshot {
+  terminalId: string
+  title: string
+  cwd: string
+  shell: string
+  cols: number
+  rows: number
+  scrollback: number
+  serializedState: string
+  status: "running" | "exited"
+  exitCode: number | null
+  signal?: number
+}
+
+export type TerminalEvent =
+  | { type: "terminal.output"; terminalId: string; data: string }
+  | { type: "terminal.exit"; terminalId: string; exitCode: number; signal?: number }
 
 export type ClientCommand =
   | { type: "project.open"; localPath: string }
@@ -27,6 +46,10 @@ export type ClientCommand =
     }
   | { type: "chat.cancel"; chatId: string }
   | { type: "chat.respondTool"; chatId: string; toolUseId: string; result: unknown }
+  | { type: "terminal.create"; projectId: string; terminalId: string; cols: number; rows: number; scrollback: number }
+  | { type: "terminal.input"; terminalId: string; data: string }
+  | { type: "terminal.resize"; terminalId: string; cols: number; rows: number }
+  | { type: "terminal.close"; terminalId: string }
 
 export type ClientEnvelope =
   | { v: 1; type: "subscribe"; id: string; topic: SubscriptionTopic }
@@ -37,9 +60,11 @@ export type ServerSnapshot =
   | { type: "sidebar"; data: SidebarData }
   | { type: "local-projects"; data: LocalProjectsSnapshot }
   | { type: "chat"; data: ChatSnapshot | null }
+  | { type: "terminal"; data: TerminalSnapshot | null }
 
 export type ServerEnvelope =
   | { v: 1; type: "snapshot"; id: string; snapshot: ServerSnapshot }
+  | { v: 1; type: "event"; id: string; event: TerminalEvent }
   | { v: 1; type: "ack"; id: string; result?: unknown }
   | { v: 1; type: "error"; id?: string; message: string }