@opencode-cockpit/daemon 0.1.0

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

@@ -0,0 +1,30 @@
+/** 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

@@ -0,0 +1,98 @@
+/**
+ * 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

@@ -0,0 +1,86 @@
+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
+    }
+  }
+}

package/src/modules/shell/shell.ts

@@ -0,0 +1,247 @@
+import type { LogLine, Owner, ScreenResult, ShellInfo, ShellStatus } from "@opencode-cockpit/protocol/shell"
+import { LineLog } from "./output/line-log.ts"
+import { OutputNormalizer } from "./output/normalizer.ts"
+import { RawRing } from "./output/raw-ring.ts"
+import { Screen } from "./output/screen.ts"
+import type { PtyBackend, PtyExit, PtyProcess } from "./pty.ts"
+
+const ERROR_LINE = /\b(error|err!|failed|failure|fatal|panic|exception|traceback)\b|✗|✖/i
+
+export interface ShellSpec {
+  id: string
+  command: string
+  args: string[]
+  cwd: string
+  env: Record<string, string>
+  title: string
+  cols: number
+  rows: number
+  owner: Owner
+  timeoutMs?: number
+}
+
+export interface ShellLimits {
+  logChars: number
+  rawBytes: number
+  scrollback: number
+}
+
+export interface ShellListener {
+  data?(offset: number, chunk: Uint8Array): void
+  line?(line: LogLine): void
+  /** The in-progress line changed (prompts that never end in a newline). */
+  partial?(text: string): void
+  exit?(info: ShellInfo): void
+}
+
+/**
+ * One shell: a command, its PTY, and the three output views (ADR 0003).
+ * Survives restarts: `run` increments and output views continue, separated by a marker line.
+ */
+export class Shell {
+  readonly log: LineLog
+  readonly raw: RawRing
+  readonly screen: Screen
+  status: ShellStatus = "running"
+  run = 0
+  /** First log line number belonging to the current run. */
+  runStartLine = 1
+  lastOutputAt = Date.now()
+
+  private pty: PtyProcess | undefined
+  private normalizer: OutputNormalizer
+  private listeners = new Set<ShellListener>()
+  private startedAt = 0
+  private endedAt: number | undefined
+  private exit: PtyExit | undefined
+  private error: string | undefined
+  private summary: string | undefined
+  private stopRequested = false
+  private timeout: ReturnType<typeof setTimeout> | undefined
+  private exitPromise: Promise<void> = Promise.resolve()
+
+  constructor(
+    readonly spec: ShellSpec,
+    private readonly backend: PtyBackend,
+    limits: ShellLimits,
+  ) {
+    this.log = new LineLog(limits.logChars)
+    this.raw = new RawRing(limits.rawBytes)
+    this.screen = new Screen(spec.cols, spec.rows, limits.scrollback)
+    this.normalizer = this.createNormalizer()
+  }
+
+  get id(): string {
+    return this.spec.id
+  }
+
+  get running(): boolean {
+    return this.status === "running"
+  }
+
+  /** Resolves when the current run has fully exited and been accounted for. */
+  get exited(): Promise<void> {
+    return this.exitPromise
+  }
+
+  subscribe(listener: ShellListener): () => void {
+    this.listeners.add(listener)
+    return () => this.listeners.delete(listener)
+  }
+
+  start(): void {
+    if (this.running && this.pty) throw new Error("shell is already running")
+    this.run++
+    if (this.run > 1) {
+      this.normalizer.flush()
+      this.log.append(`──── restart (run ${this.run}) ────`)
+      this.screen.reset()
+    }
+    this.runStartLine = this.log.lastLine + 1
+    this.status = "running"
+    this.startedAt = Date.now()
+    this.lastOutputAt = this.startedAt
+    this.endedAt = undefined
+    this.exit = undefined
+    this.error = undefined
+    this.summary = undefined
+    this.stopRequested = false
+
+    try {
+      this.pty = this.backend.spawn({
+        command: this.spec.command,
+        args: this.spec.args,
+        cwd: this.spec.cwd,
+        env: this.spec.env,
+        cols: this.spec.cols,
+        rows: this.spec.rows,
+        onData: (chunk) => this.onData(chunk),
+      })
+    } catch (err) {
+      this.pty = undefined
+      this.status = "failed"
+      this.error = err instanceof Error ? err.message : String(err)
+      this.endedAt = Date.now()
+      this.log.append(`[cockpit] failed to start: ${this.error}`)
+      throw err
+    }
+
+    const pty = this.pty
+    this.exitPromise = pty.exited.then((exit) => this.onExit(pty, exit))
+    if (this.spec.timeoutMs) {
+      this.timeout = setTimeout(() => void this.stop("SIGTERM", 3000), this.spec.timeoutMs)
+    }
+  }
+
+  write(data: string): number {
+    if (!this.running || !this.pty) throw new Error(`shell is ${this.status}`)
+    return this.pty.write(data)
+  }
+
+  resize(cols: number, rows: number): void {
+    this.spec.cols = cols
+    this.spec.rows = rows
+    this.screen.resize(cols, rows)
+    if (this.running) this.pty?.resize(cols, rows)
+  }
+
+  /** Signal the group, escalate to SIGKILL after `graceMs`, and reap stragglers. */
+  async stop(signal: NodeJS.Signals = "SIGTERM", graceMs = 3000): Promise<void> {
+    const pty = this.pty
+    if (!pty || !this.running) return
+    this.stopRequested = true
+    pty.signal(signal)
+    const exited = await Promise.race([
+      this.exitPromise.then(() => true),
+      Bun.sleep(graceMs).then(() => false),
+    ])
+    if (!exited) {
+      pty.signal("SIGKILL")
+      await this.exitPromise
+    }
+    if (pty.groupAlive()) pty.signal("SIGKILL")
+  }
+
+  async snapshot(): Promise<ScreenResult> {
+    return this.screen.snapshot()
+  }
+
+  info(): ShellInfo {
+    const info: ShellInfo = {
+      id: this.spec.id,
+      title: this.spec.title,
+      command: this.spec.command,
+      args: this.spec.args,
+      cwd: this.spec.cwd,
+      owner: this.spec.owner,
+      status: this.status,
+      run: this.run,
+      startedAt: this.startedAt,
+      cols: this.spec.cols,
+      rows: this.spec.rows,
+      lines: { first: this.log.firstLine, last: this.log.lastLine },
+      bytes: this.raw.end,
+    }
+    if (this.pty) info.pid = this.pty.pid
+    if (this.exit?.exitCode != null) info.exitCode = this.exit.exitCode
+    if (this.exit?.signal) info.signal = this.exit.signal
+    if (this.error) info.error = this.error
+    if (this.summary) info.summary = this.summary
+    if (this.endedAt) info.endedAt = this.endedAt
+    return info
+  }
+
+  dispose(): void {
+    clearTimeout(this.timeout)
+    this.listeners.clear()
+    this.pty?.close()
+    this.screen.dispose()
+  }
+
+  /** Last error-looking line of the current run, else its last non-empty line. */
+  private summarize(): string | undefined {
+    const from = Math.max(this.runStartLine, this.log.lastLine - 200 + 1)
+    let last: string | undefined
+    for (let n = this.log.lastLine; n >= from; n--) {
+      const text = this.log.get(n)?.trim()
+      if (!text) continue
+      last ??= text
+      if (ERROR_LINE.test(text)) return text.slice(0, 300)
+    }
+    return last?.slice(0, 300)
+  }
+
+  private createNormalizer(): OutputNormalizer {
+    return new OutputNormalizer((text) => {
+      const line = this.log.append(text)
+      for (const l of this.listeners) l.line?.(line)
+    })
+  }
+
+  private onData(chunk: Uint8Array): void {
+    this.lastOutputAt = Date.now()
+    const offset = this.raw.append(chunk)
+    this.screen.write(chunk)
+    this.normalizer.push(chunk)
+    const partial = this.normalizer.partial
+    for (const l of this.listeners) {
+      l.data?.(offset, chunk)
+      if (partial) l.partial?.(partial)
+    }
+  }
+
+  private onExit(pty: PtyProcess, exit: PtyExit): void {
+    if (this.pty !== pty) return // a newer run replaced this one
+    clearTimeout(this.timeout)
+    this.normalizer.flush()
+    this.exit = exit
+    this.endedAt = Date.now()
+    this.status = this.stopRequested || exit.signal ? "killed" : "exited"
+    this.summary = this.summarize()
+    // Session leader is gone; make sure nothing it left behind keeps running.
+    if (pty.groupAlive()) pty.signal("SIGHUP")
+    pty.close()
+    const info = this.info()
+    for (const l of this.listeners) l.exit?.(info)
+  }
+}

package/src/modules/shell/wait.ts

@@ -0,0 +1,86 @@
+import type { LogLine, WaitParams, WaitReason } from "@opencode-cockpit/protocol/shell"
+import { probePort } from "./port-probe.ts"
+import type { Shell } from "./shell.ts"
+
+export interface WaitOutcome {
+  reason: WaitReason
+  match?: LogLine
+}
+
+export const PORT_POLL_MS = 250
+
+/**
+ * Races every condition in `until` plus the timeout. Exit always ends a wait: once the process is
+ * gone no pattern, port or idle condition can still become true.
+ */
+export function waitFor(
+  shell: Shell,
+  params: WaitParams,
+  compile: (p: string, i: boolean) => RegExp,
+): Promise<WaitOutcome> {
+  const { until, timeoutMs } = params
+
+  return new Promise<WaitOutcome>((resolve) => {
+    const cleanups: (() => void)[] = []
+    let done = false
+    const finish = (outcome: WaitOutcome) => {
+      if (done) return
+      done = true
+      for (const cleanup of cleanups) cleanup()
+      resolve(outcome)
+    }
+
+    const regex = until.pattern !== undefined ? compile(until.pattern, until.ignoreCase ?? false) : undefined
+
+    // Lines already written count: "wait until ready" must succeed if it is ready already.
+    if (regex) {
+      const after = params.after ?? shell.runStartLine - 1
+      const existing = shell.log.read({ after, tail: 0, limit: Number.MAX_SAFE_INTEGER, grep: regex })
+      const first = existing.lines[0]
+      if (first) return finish({ reason: "pattern", match: first })
+    }
+    if (!shell.running) return finish({ reason: "exit" })
+
+    let idleTimer: ReturnType<typeof setTimeout> | undefined
+    const armIdle = () => {
+      if (until.idleMs === undefined) return
+      clearTimeout(idleTimer)
+      const remaining = Math.max(0, until.idleMs - (Date.now() - shell.lastOutputAt))
+      idleTimer = setTimeout(() => finish({ reason: "idle" }), remaining)
+    }
+    armIdle()
+    cleanups.push(() => clearTimeout(idleTimer))
+
+    cleanups.push(
+      shell.subscribe({
+        line(line) {
+          if (regex?.test(line.text)) finish({ reason: "pattern", match: line })
+        },
+        partial(text) {
+          if (regex?.test(text)) finish({ reason: "pattern", match: { n: shell.log.lastLine + 1, text } })
+        },
+        data: () => armIdle(),
+        exit: () => finish({ reason: "exit" }),
+      }),
+    )
+
+    if (until.port !== undefined) {
+      const port = until.port
+      const host = until.host ?? "127.0.0.1"
+      let polling = true
+      const poll = async () => {
+        while (polling && !done) {
+          if (await probePort(port, host)) return finish({ reason: "port" })
+          await Bun.sleep(PORT_POLL_MS)
+        }
+      }
+      void poll()
+      cleanups.push(() => {
+        polling = false
+      })
+    }
+
+    const timer = setTimeout(() => finish({ reason: "timeout" }), timeoutMs)
+    cleanups.push(() => clearTimeout(timer))
+  })
+}