@opencode-cockpit/daemon 0.1.3 → 0.1.5

package/src/modules/shell/output/normalizer.ts

@@ -1,172 +0,0 @@
-/**
- * Streaming terminal-output normalizer (ADR 0003).
- *
- * Turns a PTY byte stream into committed plain-text lines, applying the parts of terminal
- * semantics that matter for a single line: carriage return and backspace overwrite, tabs, erase
- * in line, and horizontal cursor moves. Escape sequences are consumed and dropped. Anything that
- * moves between lines (cursor up, scroll regions) is out of scope; the screen view handles those.
- */
-
-const ESC = 0x1b
-const BEL = 0x07
-const TAB_WIDTH = 8
-
-enum State {
-  Ground,
-  Escape,
-  EscapeIntermediate,
-  Csi,
-  Osc,
-  OscEscape,
-}
-
-export interface NormalizerOptions {
-  /** Force a commit when a line grows past this many characters. */
-  maxLineLength?: number
-}
-
-export class OutputNormalizer {
-  private readonly decoder = new TextDecoder()
-  private readonly maxLineLength: number
-  private state = State.Ground
-  private csiParams = ""
-  private cells: string[] = []
-  private col = 0
-
-  constructor(
-    private readonly commit: (text: string) => void,
-    options: NormalizerOptions = {},
-  ) {
-    this.maxLineLength = options.maxLineLength ?? 10_000
-  }
-
-  /** Text of the line currently being written (not yet terminated by a newline). */
-  get partial(): string {
-    return this.render()
-  }
-
-  push(chunk: Uint8Array | string): void {
-    const text = typeof chunk === "string" ? chunk : this.decoder.decode(chunk, { stream: true })
-    for (const char of text) this.step(char)
-  }
-
-  /** Commit the partial line, if any. Call when the stream ends. */
-  flush(): void {
-    const tail = this.render()
-    if (tail.length > 0) this.commit(tail)
-    this.cells = []
-    this.col = 0
-  }
-
-  private step(char: string): void {
-    const code = char.codePointAt(0) ?? 0
-    switch (this.state) {
-      case State.Ground:
-        this.ground(char, code)
-        return
-      case State.Escape:
-        if (code === 0x5b) {
-          this.state = State.Csi
-          this.csiParams = ""
-        } else if (code === 0x5d) {
-          this.state = State.Osc
-        } else if (code >= 0x20 && code <= 0x2f) {
-          this.state = State.EscapeIntermediate
-        } else {
-          this.state = State.Ground
-        }
-        return
-      case State.EscapeIntermediate:
-        if (code >= 0x30 && code <= 0x7e) this.state = State.Ground
-        return
-      case State.Csi:
-        if (code >= 0x40 && code <= 0x7e) {
-          this.csi(char, this.csiParams)
-          this.state = State.Ground
-        } else {
-          this.csiParams += char
-        }
-        return
-      case State.Osc:
-        if (code === BEL) this.state = State.Ground
-        else if (code === ESC) this.state = State.OscEscape
-        return
-      case State.OscEscape:
-        this.state = code === 0x5c ? State.Ground : State.Osc
-        return
-    }
-  }
-
-  private ground(char: string, code: number): void {
-    if (code === ESC) {
-      this.state = State.Escape
-      return
-    }
-    if (char === "\n") {
-      this.commit(this.render())
-      this.cells = []
-      this.col = 0
-      return
-    }
-    if (char === "\r") {
-      this.col = 0
-      return
-    }
-    if (char === "\b") {
-      this.col = Math.max(0, this.col - 1)
-      return
-    }
-    if (char === "\t") {
-      const next = (Math.floor(this.col / TAB_WIDTH) + 1) * TAB_WIDTH
-      while (this.col < next) this.put(" ")
-      return
-    }
-    if (code < 0x20 || code === 0x7f) return
-    this.put(char)
-  }
-
-  private csi(final: string, raw: string): void {
-    const params = raw.replace(/^[?>=!]/, "")
-    const first = Number.parseInt(params.split(";")[0] ?? "", 10)
-    const n = Number.isNaN(first) ? undefined : first
-    switch (final) {
-      case "K": // erase in line
-        if (n === undefined || n === 0) this.cells.length = Math.min(this.cells.length, this.col)
-        else if (n === 1) for (let i = 0; i <= this.col && i < this.cells.length; i++) this.cells[i] = " "
-        else if (n === 2) this.cells = []
-        return
-      case "G": // cursor horizontal absolute (1-based)
-        this.col = Math.max(0, (n ?? 1) - 1)
-        return
-      case "C": // cursor forward
-        this.col += Math.max(1, n ?? 1)
-        return
-      case "D": // cursor back
-        this.col = Math.max(0, this.col - Math.max(1, n ?? 1))
-        return
-      case "J": // erase display: the current line is all this view can clear
-        if (n === 2 || n === 3) {
-          this.cells = []
-          this.col = 0
-        }
-        return
-      default:
-        return // colours (m) and everything else carry no line text
-    }
-  }
-
-  private put(char: string): void {
-    while (this.cells.length < this.col) this.cells.push(" ")
-    this.cells[this.col] = char
-    this.col++
-    if (this.cells.length >= this.maxLineLength) {
-      this.commit(this.render())
-      this.cells = []
-      this.col = 0
-    }
-  }
-
-  private render(): string {
-    return this.cells.join("").trimEnd()
-  }
-}

package/src/modules/shell/output/raw-ring.ts

@@ -1,46 +0,0 @@
-/**
- * Bounded store of raw PTY bytes addressed by absolute offset, for replaying output to UIs that
- * attach after the fact. Evicts whole chunks from the front.
- */
-export class RawRing {
-  private chunks: Uint8Array[] = []
-  private size = 0
-  private start = 0
-
-  constructor(private readonly maxBytes = 1_000_000) {}
-
-  /** Absolute offset one past the last byte ever written. */
-  get end(): number {
-    return this.start + this.size
-  }
-
-  append(chunk: Uint8Array): number {
-    const offset = this.end
-    this.chunks.push(chunk)
-    this.size += chunk.byteLength
-    while (this.size > this.maxBytes && this.chunks.length > 1) {
-      const dropped = this.chunks.shift() as Uint8Array
-      this.size -= dropped.byteLength
-      this.start += dropped.byteLength
-    }
-    return offset
-  }
-
-  /** Bytes from `offset` (clamped to what is retained) to the end. */
-  since(offset = 0): { offset: number; bytes: Uint8Array } {
-    const from = Math.max(offset, this.start)
-    const out = new Uint8Array(this.end - from)
-    let cursor = this.start
-    let written = 0
-    for (const chunk of this.chunks) {
-      const chunkEnd = cursor + chunk.byteLength
-      if (chunkEnd > from) {
-        const slice = chunk.subarray(Math.max(0, from - cursor))
-        out.set(slice, written)
-        written += slice.byteLength
-      }
-      cursor = chunkEnd
-    }
-    return { offset: from, bytes: out }
-  }
-}

package/src/modules/shell/output/screen.ts

@@ -1,44 +0,0 @@
-import type { ScreenResult } from "@opencode-cockpit/protocol/shell"
-import { Terminal } from "@xterm/headless"
-
-/** Full VT emulation of a shell's output: what a human would see right now (ADR 0003). */
-export class Screen {
-  private readonly term: Terminal
-
-  constructor(cols: number, rows: number, scrollback = 2000) {
-    this.term = new Terminal({ cols, rows, scrollback, allowProposedApi: true })
-  }
-
-  write(chunk: Uint8Array): void {
-    this.term.write(chunk)
-  }
-
-  resize(cols: number, rows: number): void {
-    this.term.resize(cols, rows)
-  }
-
-  reset(): void {
-    this.term.reset()
-  }
-
-  /** Waits until every pending write has been parsed, then renders the viewport. */
-  async snapshot(): Promise<ScreenResult> {
-    await new Promise<void>((resolve) => this.term.write("", resolve))
-    const buffer = this.term.buffer.active
-    const rows: string[] = []
-    for (let y = 0; y < this.term.rows; y++) {
-      rows.push(buffer.getLine(buffer.baseY + y)?.translateToString(true) ?? "")
-    }
-    while (rows.length > 0 && rows[rows.length - 1] === "") rows.pop()
-    return {
-      text: rows.join("\n"),
-      cols: this.term.cols,
-      rows: this.term.rows,
-      cursor: { x: buffer.cursorX, y: buffer.cursorY },
-    }
-  }
-
-  dispose(): void {
-    this.term.dispose()
-  }
-}

package/src/modules/shell/port-probe.ts

@@ -1,30 +0,0 @@
-/** Resolves true once something accepts TCP connections on host:port. */
-export async function probePort(port: number, host = "127.0.0.1", timeoutMs = 500): Promise<boolean> {
-  return new Promise((resolve) => {
-    let settled = false
-    const finish = (ok: boolean) => {
-      if (settled) return
-      settled = true
-      clearTimeout(timer)
-      resolve(ok)
-    }
-    const timer = setTimeout(() => finish(false), timeoutMs)
-    Bun.connect({
-      hostname: host,
-      port,
-      socket: {
-        open(socket) {
-          socket.end()
-          finish(true)
-        },
-        data() {},
-        error() {
-          finish(false)
-        },
-        connectError() {
-          finish(false)
-        },
-      },
-    }).catch(() => finish(false))
-  })
-}

package/src/modules/shell/pty.ts

@@ -1,98 +0,0 @@
-/**
- * PTY backend seam. The shell module depends only on these interfaces so the process layer can be
- * swapped (Windows ConPTY, remote hosts, test fakes) without touching session logic.
- */
-
-export interface PtySpawnOptions {
-  command: string
-  args: string[]
-  cwd: string
-  env: Record<string, string>
-  cols: number
-  rows: number
-  onData: (chunk: Uint8Array) => void
-}
-
-export interface PtyExit {
-  exitCode: number | null
-  signal: string | null
-}
-
-export interface PtyProcess {
-  readonly pid: number
-  readonly exited: Promise<PtyExit>
-  write(data: string | Uint8Array): number
-  resize(cols: number, rows: number): void
-  /** Signal the whole process group; falls back to the leader. */
-  signal(signal: NodeJS.Signals): void
-  /** True while any member of the process group is alive. */
-  groupAlive(): boolean
-  close(): void
-}
-
-export interface PtyBackend {
-  spawn(options: PtySpawnOptions): PtyProcess
-}
-
-interface BunTerminal {
-  write(data: string | Uint8Array): number
-  resize(cols: number, rows: number): void
-  close(): void
-}
-
-/** Native PTY via `Bun.spawn({ terminal })` (Bun ≥ 1.3.5). The child leads its own session and group. */
-export const bunPtyBackend: PtyBackend = {
-  spawn(options) {
-    const proc = Bun.spawn([options.command, ...options.args], {
-      cwd: options.cwd,
-      env: options.env,
-      terminal: {
-        cols: options.cols,
-        rows: options.rows,
-        data(_terminal: unknown, chunk: Uint8Array) {
-          // Bun reuses the buffer between callbacks.
-          options.onData(chunk.slice())
-        },
-      },
-    } as Parameters<typeof Bun.spawn>[1]) as ReturnType<typeof Bun.spawn> & { terminal: BunTerminal }
-
-    const pid = proc.pid
-    const exited = proc.exited.then(() => ({
-      exitCode: proc.signalCode ? null : proc.exitCode,
-      signal: proc.signalCode ?? null,
-    }))
-
-    return {
-      pid,
-      exited,
-      write: (data) => proc.terminal.write(data),
-      resize: (cols, rows) => proc.terminal.resize(cols, rows),
-      signal(signal) {
-        try {
-          process.kill(-pid, signal)
-        } catch {
-          try {
-            process.kill(pid, signal)
-          } catch {
-            // already gone
-          }
-        }
-      },
-      groupAlive() {
-        try {
-          process.kill(-pid, 0)
-          return true
-        } catch {
-          return false
-        }
-      },
-      close() {
-        try {
-          proc.terminal.close()
-        } catch {
-          // already closed
-        }
-      },
-    }
-  },
-}

package/src/modules/shell/registry.ts

@@ -1,86 +0,0 @@
-import { readFileSync, renameSync, writeFileSync } from "node:fs"
-import type { Logger } from "../../core/logger.ts"
-
-interface Entry {
-  id: string
-  pid: number
-  /** `ps -o lstart` of the pid when registered; guards against pid reuse. */
-  started: string
-  command: string
-}
-
-/**
- * On-disk record of process groups the daemon owns. If the daemon dies without stopping its
- * shells, the next daemon kills whatever is still alive from that list.
- */
-export class ProcessRegistry {
-  private entries = new Map<string, Entry>()
-
-  constructor(
-    private readonly file: string,
-    private readonly log: Logger,
-  ) {}
-
-  /** Kill leftovers from a previous daemon. Returns how many process groups were reaped. */
-  reap(): number {
-    let previous: Entry[] = []
-    try {
-      previous = JSON.parse(readFileSync(this.file, "utf8")) as Entry[]
-    } catch {
-      // no registry yet, or unreadable: nothing to reap
-    }
-    let reaped = 0
-    for (const entry of previous) {
-      const started = processStartTime(entry.pid)
-      if (!started || started !== entry.started) continue // gone, or the pid now belongs to someone else
-      signalGroup(entry.pid, "SIGKILL")
-      reaped++
-      this.log.warn("reaped orphaned shell", { id: entry.id, pid: entry.pid, command: entry.command })
-    }
-    this.entries.clear()
-    this.flush()
-    return reaped
-  }
-
-  add(id: string, pid: number, command: string): void {
-    const started = processStartTime(pid)
-    if (!started) return
-    this.entries.set(id, { id, pid, started, command })
-    this.flush()
-  }
-
-  remove(id: string): void {
-    if (this.entries.delete(id)) this.flush()
-  }
-
-  private flush(): void {
-    const tmp = `${this.file}.tmp`
-    try {
-      writeFileSync(tmp, JSON.stringify([...this.entries.values()]), { mode: 0o600 })
-      renameSync(tmp, this.file)
-    } catch (err) {
-      this.log.warn("could not write process registry", { err: String(err) })
-    }
-  }
-}
-
-export function processStartTime(pid: number): string | undefined {
-  const result = Bun.spawnSync(["ps", "-o", "lstart=", "-p", String(pid)], {
-    stdout: "pipe",
-    stderr: "ignore",
-  })
-  const text = result.stdout.toString().trim()
-  return result.exitCode === 0 && text ? text : undefined
-}
-
-function signalGroup(pid: number, signal: NodeJS.Signals): void {
-  try {
-    process.kill(-pid, signal)
-  } catch {
-    try {
-      process.kill(pid, signal)
-    } catch {
-      // already gone
-    }
-  }
-}