kaizenai 0.1.0

package/src/server/server.ts

@@ -0,0 +1,244 @@
+import path from "node:path"
+import { APP_NAME, getRuntimeProfile } from "../shared/branding"
+import { EventStore } from "./event-store"
+import { AgentCoordinator } from "./agent"
+import { ATTACHMENTS_ROUTE_PREFIX, resolveAttachmentPath } from "./attachments"
+import { discoverProjects, type DiscoveredProject } from "./discovery"
+import { GitManager } from "./git-manager"
+import { KeybindingsManager } from "./keybindings"
+import { ProviderSettingsManager } from "./provider-settings"
+import { ThemeSettingsManager } from "./theme-settings"
+import { getMachineDisplayName } from "./machine-name"
+import { listProjectDirectories } from "./paths"
+import { TerminalManager } from "./terminal-manager"
+import { UpdateManager } from "./update-manager"
+import type { UpdateInstallAttemptResult } from "./cli-runtime"
+import { importProjectHistory } from "./recovery"
+import { createWsRouter, type ClientState } from "./ws-router"
+import { getSystemBackgrounds, resolveBackgroundPath } from "./backgrounds"
+
+export interface StartKaizenServerOptions {
+  port?: number
+  host?: string
+  strictPort?: boolean
+  onMigrationProgress?: (message: string) => void
+  update?: {
+    version: string
+    fetchLatestVersion: (packageName: string) => Promise<string>
+    installVersion: (packageName: string, version: string) => UpdateInstallAttemptResult
+  }
+}
+
+export async function startKaizenServer(options: StartKaizenServerOptions = {}) {
+  const port = options.port ?? 3210
+  const hostname = options.host ?? "127.0.0.1"
+  const strictPort = options.strictPort ?? false
+  const store = new EventStore()
+  const machineDisplayName = getMachineDisplayName()
+  await store.initialize()
+  await store.migrateLegacyTranscripts(options.onMigrationProgress)
+  for (const project of store.listProjects()) {
+    await importProjectHistory({
+      store,
+      projectId: project.id,
+      repoKey: project.repoKey,
+      localPath: project.localPath,
+      worktreePaths: project.worktreePaths,
+    })
+  }
+  let discoveredProjects: DiscoveredProject[] = []
+
+  async function refreshDiscovery() {
+    discoveredProjects = discoverProjects().filter((project) => !store.isProjectHidden(project.repoKey))
+    return discoveredProjects
+  }
+
+  await refreshDiscovery()
+
+  let server: ReturnType<typeof Bun.serve<ClientState>>
+  let router: ReturnType<typeof createWsRouter>
+  let agentSnapshotBroadcastTimer: ReturnType<typeof setTimeout> | null = null
+  const terminals = new TerminalManager()
+  const git = new GitManager()
+  const keybindings = new KeybindingsManager()
+  await keybindings.initialize()
+  const providerSettings = new ProviderSettingsManager()
+  await providerSettings.initialize()
+  const themeSettings = new ThemeSettingsManager()
+  await themeSettings.initialize()
+  const updateManager = options.update
+    ? new UpdateManager({
+      currentVersion: options.update.version,
+      fetchLatestVersion: options.update.fetchLatestVersion,
+      installVersion: options.update.installVersion,
+      devMode: getRuntimeProfile() === "dev",
+    })
+    : null
+  const agent = new AgentCoordinator({
+    store,
+    onStateChange: () => {
+      if (agentSnapshotBroadcastTimer) return
+      agentSnapshotBroadcastTimer = setTimeout(() => {
+        agentSnapshotBroadcastTimer = null
+        router.broadcastSnapshots()
+      }, 33)
+    },
+    attachmentsDir: path.join(store.dataDir, "attachments"),
+  })
+  router = createWsRouter({
+    store,
+    agent,
+    terminals,
+    git,
+    keybindings,
+    providerSettings,
+    themeSettings,
+    refreshDiscovery,
+    getDiscoveredProjects: () => discoveredProjects,
+    machineDisplayName,
+    updateManager,
+  })
+
+  const distDir = path.join(import.meta.dir, "..", "..", "dist", "client")
+
+  const MAX_PORT_ATTEMPTS = 20
+  let actualPort = port
+
+  for (let attempt = 0; attempt < MAX_PORT_ATTEMPTS; attempt++) {
+    try {
+      server = Bun.serve<ClientState>({
+        port: actualPort,
+        hostname,
+        fetch(req, serverInstance) {
+          const url = new URL(req.url)
+
+          if (url.pathname === "/ws") {
+            const upgraded = serverInstance.upgrade(req, {
+              data: {
+                subscriptions: new Map(),
+              },
+            })
+            return upgraded ? undefined : new Response("WebSocket upgrade failed", { status: 400 })
+          }
+
+          if (url.pathname === "/health") {
+            return Response.json({ ok: true, port: actualPort })
+          }
+
+          if (url.pathname === "/api/directories") {
+            return serveDirectories(url)
+          }
+
+          if (url.pathname === "/api/backgrounds") {
+            return getSystemBackgrounds().then(Response.json)
+          }
+
+          if (url.pathname.startsWith("/api/backgrounds/")) {
+            const id = url.pathname.slice("/api/backgrounds/".length)
+            return resolveBackgroundPath(id).then(filePath => {
+              if (filePath) return new Response(Bun.file(filePath))
+              return new Response("Not found", { status: 404 })
+            })
+          }
+
+          if (url.pathname.startsWith(`${ATTACHMENTS_ROUTE_PREFIX}/`)) {
+            return serveAttachment(path.join(store.dataDir, "attachments"), url.pathname)
+          }
+
+          return serveStatic(distDir, url.pathname)
+        },
+        websocket: {
+          open(ws) {
+            router.handleOpen(ws)
+          },
+          message(ws, raw) {
+            router.handleMessage(ws, raw)
+          },
+          close(ws) {
+            router.handleClose(ws)
+          },
+        },
+      })
+      break
+    } catch (err: unknown) {
+      const isAddrInUse =
+        err instanceof Error && "code" in err && (err as NodeJS.ErrnoException).code === "EADDRINUSE"
+      if (!isAddrInUse || strictPort || attempt === MAX_PORT_ATTEMPTS - 1) {
+        throw err
+      }
+      console.log(`Port ${actualPort} is in use, trying ${actualPort + 1}...`)
+      actualPort++
+    }
+  }
+
+  const shutdown = async () => {
+    for (const chatId of [...agent.activeTurns.keys()]) {
+      await agent.shutdown(chatId)
+    }
+    router.dispose()
+    keybindings.dispose()
+    providerSettings.dispose()
+    themeSettings.dispose()
+    terminals.closeAll()
+    await store.compact()
+    server.stop(true)
+  }
+
+  return {
+    port: actualPort,
+    store,
+    updateManager,
+    stop: shutdown,
+  }
+}
+
+async function serveAttachment(attachmentsDir: string, pathname: string) {
+  const relativePath = pathname.slice(`${ATTACHMENTS_ROUTE_PREFIX}/`.length)
+  const filePath = resolveAttachmentPath(attachmentsDir, decodeURIComponent(relativePath))
+  if (!filePath) {
+    return new Response("Invalid attachment path", { status: 400 })
+  }
+
+  const file = Bun.file(filePath)
+  if (!(await file.exists())) {
+    return new Response("Not Found", { status: 404 })
+  }
+
+  return new Response(file)
+}
+
+async function serveDirectories(url: URL) {
+  try {
+    const localPath = url.searchParams.get("path") ?? undefined
+    const snapshot = await listProjectDirectories(localPath)
+    return Response.json(snapshot)
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    return Response.json({ error: message }, { status: 400 })
+  }
+}
+
+async function serveStatic(distDir: string, pathname: string) {
+  const requestedPath = pathname === "/" ? "/index.html" : pathname
+  const filePath = path.join(distDir, requestedPath)
+  const indexPath = path.join(distDir, "index.html")
+
+  const file = Bun.file(filePath)
+  if (await file.exists()) {
+    return new Response(file)
+  }
+
+  const indexFile = Bun.file(indexPath)
+  if (await indexFile.exists()) {
+    return new Response(indexFile, {
+      headers: {
+        "Content-Type": "text/html; charset=utf-8",
+      },
+    })
+  }
+
+  return new Response(
+    `${APP_NAME} client bundle not found. Run \`bun run build\` inside workbench/ first.`,
+    { status: 503 }
+  )
+}

package/src/server/terminal-manager.ts

@@ -0,0 +1,350 @@
+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 {
+  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
+  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() {
+  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.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")
+          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.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
+
+    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)
+    }
+  }
+}