@opencode-cockpit/daemon 0.1.4 → 0.2.0

package/src/core/server.ts

@@ -1,223 +0,0 @@
-import {
-  ErrorCode,
-  EVENT_METHOD,
-  encodeFrame,
-  LineDecoder,
-  RpcError,
-  type RpcMessage,
-  type RpcRequest,
-} from "@opencode-cockpit/protocol"
-import type { Socket, UnixSocketListener } from "bun"
-import type { Logger } from "./logger.ts"
-import type { Peer } from "./module.ts"
-import type { Router } from "./router.ts"
-
-const MAX_QUEUED_BYTES = 32 * 1024 * 1024
-
-interface ConnState {
-  peer: PeerImpl
-}
-
-class PeerImpl implements Peer {
-  name = "unknown"
-  greeted = false
-  readonly topics = new Set<string>()
-  private readonly closers: (() => void)[] = []
-  private queue: Uint8Array[] = []
-  private queued = 0
-  closed = false
-
-  constructor(
-    readonly id: number,
-    private readonly socket: Socket<ConnState>,
-    private readonly log: Logger,
-  ) {}
-
-  greet(name: string): void {
-    this.name = name
-    this.greeted = true
-  }
-
-  onClose(fn: () => void): void {
-    if (this.closed) fn()
-    else this.closers.push(fn)
-  }
-
-  send(topic: string, data: unknown): void {
-    this.write({ jsonrpc: "2.0", method: EVENT_METHOD, params: { topic, data } })
-  }
-
-  subscribed(topic: string): boolean {
-    if (this.topics.has(topic) || this.topics.has("*")) return true
-    const dot = topic.indexOf(".")
-    return dot > 0 && this.topics.has(`${topic.slice(0, dot)}.*`)
-  }
-
-  write(message: unknown): void {
-    if (this.closed) return
-    const frame = encodeFrame(message)
-    if (this.queue.length > 0) {
-      this.enqueue(frame)
-      return
-    }
-    const written = this.socket.write(frame)
-    if (written < frame.byteLength) this.enqueue(frame.subarray(Math.max(0, written)))
-  }
-
-  drain(): void {
-    while (this.queue.length > 0) {
-      const head = this.queue[0] as Uint8Array
-      const written = this.socket.write(head)
-      if (written < head.byteLength) {
-        this.queue[0] = head.subarray(Math.max(0, written))
-        this.queued -= Math.max(0, written)
-        return
-      }
-      this.queue.shift()
-      this.queued -= head.byteLength
-    }
-  }
-
-  close(): void {
-    if (this.closed) return
-    this.closed = true
-    this.queue = []
-    for (const fn of this.closers.splice(0)) {
-      try {
-        fn()
-      } catch (err) {
-        this.log.warn("peer close hook failed", { err: String(err) })
-      }
-    }
-  }
-
-  private enqueue(frame: Uint8Array): void {
-    this.queue.push(frame)
-    this.queued += frame.byteLength
-    if (this.queued > MAX_QUEUED_BYTES) {
-      this.log.warn("peer too slow, disconnecting", { peer: this.id, queued: this.queued })
-      this.socket.end()
-    }
-  }
-}
-
-export interface RpcServerHooks {
-  onConnect(count: number): void
-  onDisconnect(count: number): void
-}
-
-export class RpcServer {
-  private listener: UnixSocketListener<ConnState> | undefined
-  private readonly peers = new Set<PeerImpl>()
-  private nextId = 1
-
-  constructor(
-    private readonly router: Router,
-    private readonly hooks: RpcServerHooks,
-    private readonly log: Logger,
-  ) {}
-
-  get clientCount(): number {
-    return this.peers.size
-  }
-
-  listen(path: string): void {
-    const decoders = new WeakMap<PeerImpl, LineDecoder>()
-    this.listener = Bun.listen<ConnState>({
-      unix: path,
-      socket: {
-        open: (socket) => {
-          const peer = new PeerImpl(this.nextId++, socket, this.log)
-          socket.data = { peer }
-          decoders.set(peer, new LineDecoder())
-          this.peers.add(peer)
-          this.hooks.onConnect(this.peers.size)
-        },
-        data: (socket, chunk) => {
-          const peer = socket.data.peer
-          let lines: string[]
-          try {
-            lines = (decoders.get(peer) as LineDecoder).push(chunk)
-          } catch (err) {
-            peer.write({
-              jsonrpc: "2.0",
-              id: null,
-              error: { code: ErrorCode.ParseError, message: String(err) },
-            })
-            socket.end()
-            return
-          }
-          for (const line of lines) void this.handleLine(peer, line)
-        },
-        drain: (socket) => socket.data.peer.drain(),
-        close: (socket) => this.drop(socket.data.peer),
-        error: (socket, err) => {
-          this.log.warn("socket error", { err: String(err) })
-          this.drop(socket.data.peer)
-        },
-      },
-    })
-  }
-
-  broadcast(topic: string, data: unknown): void {
-    for (const peer of this.peers) if (peer.subscribed(topic)) peer.send(topic, data)
-  }
-
-  stop(): void {
-    this.listener?.stop(true)
-    for (const peer of this.peers) peer.close()
-    this.peers.clear()
-  }
-
-  private drop(peer: PeerImpl): void {
-    if (!this.peers.delete(peer)) return
-    peer.close()
-    this.hooks.onDisconnect(this.peers.size)
-  }
-
-  private async handleLine(peer: PeerImpl, line: string): Promise<void> {
-    let message: RpcMessage
-    try {
-      message = JSON.parse(line)
-    } catch {
-      peer.write({ jsonrpc: "2.0", id: null, error: { code: ErrorCode.ParseError, message: "invalid JSON" } })
-      return
-    }
-    if (
-      typeof message !== "object" ||
-      message === null ||
-      !("method" in message) ||
-      typeof message.method !== "string"
-    ) {
-      peer.write({
-        jsonrpc: "2.0",
-        id: null,
-        error: { code: ErrorCode.InvalidRequest, message: "expected a request" },
-      })
-      return
-    }
-    const hasId = "id" in message && (typeof message.id === "number" || typeof message.id === "string")
-    const request = message as RpcRequest
-    try {
-      const result = await this.invoke(peer, request)
-      if (hasId) peer.write({ jsonrpc: "2.0", id: request.id, result: result ?? {} })
-    } catch (err) {
-      const rpc =
-        err instanceof RpcError
-          ? err
-          : new RpcError(ErrorCode.InternalError, err instanceof Error ? err.message : String(err))
-      if (!(err instanceof RpcError))
-        this.log.error("handler crashed", { method: request.method, err: String(err) })
-      if (hasId) peer.write({ jsonrpc: "2.0", id: request.id, error: rpc.toShape() })
-    }
-  }
-
-  private async invoke(peer: PeerImpl, request: RpcRequest): Promise<unknown> {
-    if (!peer.greeted && request.method !== "daemon.hello") {
-      throw new RpcError(ErrorCode.InvalidRequest, "call daemon.hello first")
-    }
-    return this.router.dispatch(request.method, request.params, { peer })
-  }
-}
-
-export type { PeerImpl }

package/src/main.ts

@@ -1,36 +0,0 @@
-#!/usr/bin/env bun
-/** cockpitd entry point. Started detached by clients (ADR 0001); safe to run by hand for debugging. */
-import { join } from "node:path"
-import { resolvePaths } from "@opencode-cockpit/protocol"
-import { Daemon } from "./core/daemon.ts"
-import type { Level } from "./core/logger.ts"
-import { createModules } from "./modules/index.ts"
-
-const env = process.env
-const foreground = process.argv.includes("--foreground")
-
-const paths = resolvePaths(env)
-const daemon = new Daemon({
-  paths,
-  modules: createModules({ shell: { registryFile: join(paths.home, "shells.json") } }),
-  idleTimeoutMs: Number(env.COCKPIT_IDLE_TIMEOUT_MS ?? 10 * 60_000),
-  logLevel: (env.COCKPIT_LOG_LEVEL as Level | undefined) ?? "info",
-  logToFile: !foreground,
-})
-
-for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"] as const) {
-  process.on(signal, () => void daemon.stop(signal))
-}
-process.on("uncaughtException", (err) =>
-  daemon.log.error("uncaught exception", { err: String(err), stack: err.stack }),
-)
-process.on("unhandledRejection", (err) => daemon.log.error("unhandled rejection", { err: String(err) }))
-
-try {
-  await daemon.start()
-} catch (err) {
-  daemon.log.error("failed to start", { err: String(err) })
-  process.exit(1)
-}
-await daemon.stopped
-process.exit(0)

package/src/modules/index.ts

@@ -1,11 +0,0 @@
-import type { Module } from "../core/module.ts"
-import { ShellModule, type ShellModuleOptions } from "./shell/module.ts"
-
-export interface ModuleOptions {
-  shell?: ShellModuleOptions
-}
-
-/** Every capability the daemon hosts. Add new modules here. */
-export function createModules(options: ModuleOptions = {}): Module[] {
-  return [new ShellModule(options.shell)]
-}

package/src/modules/shell/ids.ts

@@ -1,8 +0,0 @@
-const ALPHABET = "abcdefghijklmnopqrstuvwxyz234567"
-
-export function newShellId(): string {
-  const bytes = crypto.getRandomValues(new Uint8Array(8))
-  let id = "sh_"
-  for (const byte of bytes) id += ALPHABET[byte % 32]
-  return id
-}

package/src/modules/shell/module.ts

@@ -1,323 +0,0 @@
-import type { ShellInfo, StartParams } from "@opencode-cockpit/protocol/shell"
-import { invalidParams, invalidState, notFound } from "../../core/errors.ts"
-import type { Logger } from "../../core/logger.ts"
-import { silentLogger } from "../../core/logger.ts"
-import type { MethodTable, Module, ModuleContext, Peer } from "../../core/module.ts"
-import { newShellId } from "./ids.ts"
-import { bunPtyBackend, type PtyBackend } from "./pty.ts"
-import { ProcessRegistry } from "./registry.ts"
-import { Shell, type ShellLimits } from "./shell.ts"
-import { waitFor } from "./wait.ts"
-
-export interface ShellModuleOptions {
-  backend?: PtyBackend
-  limits?: Partial<ShellLimits>
-  /** Oldest finished shells are forgotten beyond this many. */
-  maxFinished?: number
-  /** Base environment for spawned processes (defaults to the daemon's). */
-  baseEnv?: Record<string, string | undefined>
-  /** Coalesce output events per attached peer for this long. */
-  outputFlushMs?: number
-  /** Where to record owned process groups so a restarted daemon can reap orphans. */
-  registryFile?: string
-}
-
-const DEFAULT_LIMITS: ShellLimits = { logChars: 4_000_000, rawBytes: 1_000_000, scrollback: 2000 }
-
-export class ShellModule implements Module<"shell"> {
-  readonly name = "shell" as const
-  private readonly shells = new Map<string, Shell>()
-  private readonly attachments = new Map<string, () => void>() // `${peer.id}:${shellId}` → detach
-  private readonly backend: PtyBackend
-  private readonly limits: ShellLimits
-  private log: Logger = silentLogger
-  private registry: ProcessRegistry | undefined
-  private emit: ModuleContext["emit"] = () => {}
-
-  constructor(private readonly options: ShellModuleOptions = {}) {
-    this.backend = options.backend ?? bunPtyBackend
-    this.limits = { ...DEFAULT_LIMITS, ...options.limits }
-  }
-
-  async start(ctx: ModuleContext): Promise<void> {
-    this.log = ctx.log
-    this.emit = ctx.emit
-    if (this.options.registryFile) {
-      this.registry = new ProcessRegistry(this.options.registryFile, ctx.log)
-      const reaped = this.registry.reap()
-      if (reaped > 0) ctx.log.warn("cleaned up shells left by a previous daemon", { reaped })
-    }
-  }
-
-  async stop(): Promise<void> {
-    await Promise.all([...this.shells.values()].map((s) => s.stop("SIGTERM", 2000).catch(() => {})))
-    for (const detach of this.attachments.values()) detach()
-    for (const shell of this.shells.values()) shell.dispose()
-    this.attachments.clear()
-    this.shells.clear()
-  }
-
-  busy(): boolean {
-    for (const shell of this.shells.values()) if (shell.running) return true
-    return false
-  }
-
-  readonly methods: MethodTable<"shell"> = {
-    start: (params) => this.startShell(params),
-
-    list: (params) => {
-      const owner = params.owner
-      return [...this.shells.values()]
-        .filter((s) => params.includeExited || s.running)
-        .filter((s) => !owner?.project || s.spec.owner.project === owner.project)
-        .filter((s) => !owner?.session || s.spec.owner.session === owner.session)
-        .map((s) => s.info())
-    },
-
-    get: ({ id }) => this.require(id).info(),
-
-    read: ({ id, after, tail, limit, grep, ignoreCase }) => {
-      const shell = this.require(id)
-      const page = shell.log.read({
-        after,
-        tail,
-        limit,
-        grep: grep === undefined ? undefined : compilePattern(grep, ignoreCase),
-      })
-      return { ...page, status: shell.status }
-    },
-
-    screen: ({ id }) => this.require(id).snapshot(),
-
-    write: ({ id, data }) => {
-      const shell = this.require(id)
-      if (!shell.running) throw invalidState(`shell ${id} is ${shell.status}`)
-      return { bytes: shell.write(data) }
-    },
-
-    resize: ({ id, cols, rows }) => {
-      this.require(id).resize(cols, rows)
-      return {}
-    },
-
-    wait: async (params) => {
-      const shell = this.require(params.id)
-      const outcome = await waitFor(shell, params, compilePattern)
-      return { ...outcome, info: shell.info() }
-    },
-
-    stop: async ({ id, signal, graceMs }) => {
-      const shell = this.require(id)
-      await shell.stop(signal, graceMs)
-      await shell.exited
-      return shell.info()
-    },
-
-    restart: async ({ id }) => {
-      const shell = this.require(id)
-      if (shell.running) {
-        await shell.stop("SIGTERM", 3000)
-        await shell.exited
-      }
-      this.spawn(shell)
-      return shell.info()
-    },
-
-    remove: async ({ id }) => {
-      const shell = this.require(id)
-      if (shell.running) {
-        await shell.stop("SIGTERM", 3000)
-        await shell.exited
-      }
-      this.forget(shell)
-      return {}
-    },
-
-    attach: ({ id, fromOffset }, { peer }) => {
-      const shell = this.require(id)
-      this.detach(peer, id)
-      const replay = shell.raw.since(fromOffset ?? 0)
-      this.attachStream(peer, shell)
-      return { offset: replay.offset, replay: Buffer.from(replay.bytes).toString("base64") }
-    },
-
-    clear: ({ owner, finishedBeforeMs }) => {
-      const cutoff = Date.now() - (finishedBeforeMs ?? 0)
-      const removed: string[] = []
-      for (const shell of [...this.shells.values()]) {
-        if (shell.running) continue
-        const info = shell.info()
-        if (owner?.project && info.owner.project !== owner.project) continue
-        if (owner?.session && info.owner.session !== owner.session) continue
-        if ((info.endedAt ?? 0) > cutoff) continue
-        this.forget(shell)
-        removed.push(info.id)
-      }
-      return { removed }
-    },
-
-    detach: ({ id }, { peer }) => {
-      this.detach(peer, id)
-      return {}
-    },
-  }
-
-  private startShell(params: StartParams): ShellInfo {
-    if (params.reuse) {
-      const previous = this.findReusable(params)
-      if (previous) {
-        Object.assign(previous.spec, {
-          env: this.environment(params.env),
-          title: params.title ?? previous.spec.title,
-          timeoutMs: params.timeoutMs,
-          owner: params.owner,
-        })
-        this.spawn(previous)
-        return previous.info()
-      }
-    }
-    const shell = new Shell(
-      {
-        id: this.uniqueId(),
-        command: params.command,
-        args: params.args,
-        cwd: params.cwd,
-        env: this.environment(params.env),
-        title: params.title ?? [params.command, ...params.args].join(" ").slice(0, 200),
-        cols: params.cols,
-        rows: params.rows,
-        owner: params.owner,
-        timeoutMs: params.timeoutMs,
-      },
-      this.backend,
-      this.limits,
-    )
-    this.shells.set(shell.id, shell)
-    shell.subscribe({ exit: (info) => this.onExit(info) })
-    this.spawn(shell)
-    this.pruneFinished()
-    return shell.info()
-  }
-
-  private findReusable(params: StartParams): Shell | undefined {
-    const args = JSON.stringify(params.args)
-    let match: Shell | undefined
-    for (const shell of this.shells.values()) {
-      const spec = shell.spec
-      if (
-        !shell.running &&
-        spec.command === params.command &&
-        JSON.stringify(spec.args) === args &&
-        spec.cwd === params.cwd &&
-        spec.owner.project === params.owner.project &&
-        spec.owner.session === params.owner.session &&
-        (!match || shell.info().startedAt > match.info().startedAt)
-      ) {
-        match = shell
-      }
-    }
-    return match
-  }
-
-  private spawn(shell: Shell): void {
-    try {
-      shell.start()
-    } catch (err) {
-      const info = shell.info()
-      this.log.warn("spawn failed", { id: shell.id, command: shell.spec.command, err: String(err) })
-      this.emit("shell.exited", info)
-      return
-    }
-    const pid = shell.info().pid
-    if (pid) this.registry?.add(shell.id, pid, shell.spec.command)
-    this.log.info("shell started", { id: shell.id, command: shell.spec.command, pid })
-    this.emit("shell.started", shell.info())
-  }
-
-  private onExit(info: ShellInfo): void {
-    this.registry?.remove(info.id)
-    this.log.info("shell ended", {
-      id: info.id,
-      status: info.status,
-      exitCode: info.exitCode,
-      signal: info.signal,
-    })
-    this.emit("shell.exited", info)
-  }
-
-  private attachStream(peer: Peer, shell: Shell): void {
-    const key = `${peer.id}:${shell.id}`
-    const flushMs = this.options.outputFlushMs ?? 16
-    let pending: Uint8Array[] = []
-    let pendingOffset = 0
-    let timer: ReturnType<typeof setTimeout> | undefined
-    const flush = () => {
-      timer = undefined
-      if (pending.length === 0) return
-      const data = Buffer.concat(pending).toString("base64")
-      peer.send("shell.output", { id: shell.id, offset: pendingOffset, data })
-      pending = []
-    }
-    const unsubscribe = shell.subscribe({
-      data(offset, chunk) {
-        if (pending.length === 0) pendingOffset = offset
-        pending.push(chunk)
-        timer ??= setTimeout(flush, flushMs)
-      },
-    })
-    const detach = () => {
-      clearTimeout(timer)
-      flush()
-      unsubscribe()
-      this.attachments.delete(key)
-    }
-    this.attachments.set(key, detach)
-    peer.onClose(detach)
-  }
-
-  private detach(peer: Peer, id: string): void {
-    this.attachments.get(`${peer.id}:${id}`)?.()
-  }
-
-  private forget(shell: Shell): void {
-    for (const [key, detach] of this.attachments) if (key.endsWith(`:${shell.id}`)) detach()
-    shell.dispose()
-    this.shells.delete(shell.id)
-    this.emit("shell.removed", { id: shell.id })
-  }
-
-  private pruneFinished(): void {
-    const max = this.options.maxFinished ?? 50
-    const finished = [...this.shells.values()].filter((s) => !s.running)
-    for (const shell of finished.slice(0, Math.max(0, finished.length - max))) this.forget(shell)
-  }
-
-  private require(id: string): Shell {
-    const shell = this.shells.get(id)
-    if (!shell) throw notFound(`shell ${id}`)
-    return shell
-  }
-
-  private uniqueId(): string {
-    let id = newShellId()
-    while (this.shells.has(id)) id = newShellId()
-    return id
-  }
-
-  private environment(extra: Record<string, string> | undefined): Record<string, string> {
-    const env: Record<string, string> = {}
-    for (const [k, v] of Object.entries(this.options.baseEnv ?? process.env)) if (v !== undefined) env[k] = v
-    env.TERM ??= "xterm-256color"
-    env.COLORTERM ??= "truecolor"
-    Object.assign(env, extra)
-    return env
-  }
-}
-
-export function compilePattern(pattern: string, ignoreCase: boolean): RegExp {
-  try {
-    return new RegExp(pattern, ignoreCase ? "i" : "")
-  } catch (err) {
-    throw invalidParams(`invalid pattern: ${err instanceof Error ? err.message : String(err)}`)
-  }
-}

package/src/modules/shell/output/line-log.ts

@@ -1,92 +0,0 @@
-import type { LogLine } from "@opencode-cockpit/protocol/shell"
-
-export interface ReadQuery {
-  after?: number
-  tail: number
-  limit: number
-  grep?: RegExp
-}
-
-export interface ReadPage {
-  lines: LogLine[]
-  firstLine: number
-  lastLine: number
-  nextCursor: number
-  truncated: boolean
-  hasMore: boolean
-}
-
-/**
- * Committed lines with monotonic numbering (1-based) and a character budget.
- * Eviction drops the oldest lines and advances `firstLine`; numbers are never reused, so cursors
- * held by clients stay meaningful after eviction.
- */
-export class LineLog {
-  private lines: string[] = []
-  private head = 0
-  private chars = 0
-  private first = 1
-
-  constructor(private readonly maxChars = 4_000_000) {}
-
-  /** Number of the oldest retained line (equals `lastLine + 1` when empty). */
-  get firstLine(): number {
-    return this.first
-  }
-
-  /** Number of the newest line, or `firstLine - 1` when empty. */
-  get lastLine(): number {
-    return this.first + (this.lines.length - this.head) - 1
-  }
-
-  append(text: string): LogLine {
-    this.lines.push(text)
-    this.chars += text.length + 1
-    const line = { n: this.lastLine, text }
-    this.evict()
-    return line
-  }
-
-  get(n: number): string | undefined {
-    if (n < this.first || n > this.lastLine) return undefined
-    return this.lines[this.head + (n - this.first)]
-  }
-
-  read(query: ReadQuery): ReadPage {
-    const last = this.lastLine
-    const requestedStart = query.after !== undefined ? query.after + 1 : Math.max(1, last - query.tail + 1)
-    const start = Math.max(requestedStart, this.first)
-    const truncated = requestedStart < this.first && last >= requestedStart
-
-    const out: LogLine[] = []
-    let n = start
-    for (; n <= last && out.length < query.limit; n++) {
-      const text = this.lines[this.head + (n - this.first)] as string
-      if (query.grep && !query.grep.test(text)) continue
-      out.push({ n, text })
-    }
-    const scannedTo = n - 1
-    return {
-      lines: out,
-      firstLine: this.first,
-      lastLine: last,
-      nextCursor: Math.max(scannedTo, start - 1),
-      truncated,
-      hasMore: scannedTo < last,
-    }
-  }
-
-  private evict(): void {
-    while (this.chars > this.maxChars && this.head < this.lines.length - 1) {
-      const dropped = this.lines[this.head] as string
-      this.chars -= dropped.length + 1
-      this.head++
-      this.first++
-    }
-    // Compact occasionally so the backing array does not grow without bound.
-    if (this.head > 4096 && this.head * 2 > this.lines.length) {
-      this.lines = this.lines.slice(this.head)
-      this.head = 0
-    }
-  }
-}