@opencode-cockpit/daemon 0.1.4 → 0.2.0

package/dist/modules/shell/output/raw-ring.js

@@ -0,0 +1,49 @@
+/**
+ * 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 {
+  chunks = [];
+  size = 0;
+  start = 0;
+  constructor(maxBytes = 1_000_000) {
+    this.maxBytes = maxBytes;
+  }
+
+  /** Absolute offset one past the last byte ever written. */
+  get end() {
+    return this.start + this.size;
+  }
+  append(chunk) {
+    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();
+      this.size -= dropped.byteLength;
+      this.start += dropped.byteLength;
+    }
+    return offset;
+  }
+
+  /** Bytes from `offset` (clamped to what is retained) to the end. */
+  since(offset = 0) {
+    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/dist/modules/shell/output/screen.js

@@ -0,0 +1,102 @@
+import { Terminal } from "@xterm/headless";
+import { paletteColor, rgbColor } from "./palette.js";
+
+/** Full VT emulation of a shell's output: what a human would see right now (ADR 0003). */
+export class Screen {
+  constructor(cols, rows, scrollback = 2000) {
+    this.term = new Terminal({
+      cols,
+      rows,
+      scrollback,
+      allowProposedApi: true
+    });
+  }
+  write(chunk) {
+    this.term.write(chunk);
+  }
+  resize(cols, rows) {
+    this.term.resize(cols, rows);
+  }
+  reset() {
+    this.term.reset();
+  }
+
+  /** Waits until every pending write has been parsed, then renders the viewport. */
+  async snapshot() {
+    await new Promise(resolve => this.term.write("", resolve));
+    const buffer = this.term.buffer.active;
+    const rows = [];
+    const styled = [];
+    for (let y = 0; y < this.term.rows; y++) {
+      const line = buffer.getLine(buffer.baseY + y);
+      rows.push(line?.translateToString(true) ?? "");
+      styled.push(line ? styleRuns(line, this.term.cols) : []);
+    }
+    while (rows.length > 0 && rows[rows.length - 1] === "") {
+      rows.pop();
+      styled.pop();
+    }
+    return {
+      text: rows.join("\n"),
+      cols: this.term.cols,
+      rows: this.term.rows,
+      cursor: {
+        x: buffer.cursorX,
+        y: buffer.cursorY
+      },
+      styled
+    };
+  }
+  dispose() {
+    this.term.dispose();
+  }
+}
+/** Groups a row's cells into runs of identical style, trimming the trailing blank. */
+function styleRuns(line, cols) {
+  const runs = [];
+  let current;
+  for (let x = 0; x < cols; x++) {
+    const cell = line.getCell(x);
+    if (!cell || cell.getWidth() === 0) continue;
+    const chars = cell.getChars() || " ";
+    const style = cellStyle(cell);
+    if (current && sameStyle(current, style)) current.text += chars;else {
+      current = {
+        ...style,
+        text: chars
+      };
+      runs.push(current);
+    }
+  }
+  // Drop trailing spaces so a mostly empty row costs nothing to send or paint.
+  while (runs.length > 0) {
+    const last = runs[runs.length - 1];
+    last.text = last.text.replace(/\s+$/, "");
+    if (last.text.length > 0) break;
+    runs.pop();
+  }
+  return runs;
+}
+function cellStyle(cell) {
+  const inverse = cell.isInverse() !== 0;
+  const fg = colorOf(cell, inverse ? "bg" : "fg");
+  const bg = colorOf(cell, inverse ? "fg" : "bg");
+  const style = {};
+  if (fg) style.fg = fg;
+  if (bg) style.bg = bg;
+  if (cell.isBold()) style.bold = true;
+  if (cell.isDim()) style.dim = true;
+  if (cell.isItalic()) style.italic = true;
+  if (cell.isUnderline()) style.underline = true;
+  return style;
+}
+function colorOf(cell, which) {
+  const isDefault = which === "fg" ? cell.isFgDefault() : cell.isBgDefault();
+  if (isDefault) return undefined;
+  const rgb = which === "fg" ? cell.isFgRGB() : cell.isBgRGB();
+  const value = which === "fg" ? cell.getFgColor() : cell.getBgColor();
+  return rgb ? rgbColor(value) : paletteColor(value);
+}
+function sameStyle(a, b) {
+  return a.fg === b.fg && a.bg === b.bg && a.bold === b.bold && a.dim === b.dim && a.italic === b.italic && a.underline === b.underline;
+}

package/dist/modules/shell/port-probe.js

@@ -0,0 +1,30 @@
+/** Resolves true once something accepts TCP connections on host:port. */
+export async function probePort(port, host = "127.0.0.1", timeoutMs = 500) {
+  return new Promise(resolve => {
+    let settled = false;
+    const finish = ok => {
+      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/dist/modules/shell/pty.js

@@ -0,0 +1,59 @@
+/**
+ * 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.
+ */
+
+/** Native PTY via `Bun.spawn({ terminal })` (Bun ≥ 1.3.5). The child leads its own session and group. */
+export const bunPtyBackend = {
+  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, chunk) {
+          // Bun reuses the buffer between callbacks.
+          options.onData(chunk.slice());
+        }
+      }
+    });
+    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/dist/modules/shell/registry.js

@@ -0,0 +1,83 @@
+import { readFileSync, renameSync, writeFileSync } from "node:fs";
+/**
+ * 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 {
+  entries = new Map();
+  constructor(file, log) {
+    this.file = file;
+    this.log = log;
+  }
+
+  /** Kill leftovers from a previous daemon. Returns how many process groups were reaped. */
+  reap() {
+    let previous = [];
+    try {
+      previous = JSON.parse(readFileSync(this.file, "utf8"));
+    } 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, pid, command) {
+    const started = processStartTime(pid);
+    if (!started) return;
+    this.entries.set(id, {
+      id,
+      pid,
+      started,
+      command
+    });
+    this.flush();
+  }
+  remove(id) {
+    if (this.entries.delete(id)) this.flush();
+  }
+  flush() {
+    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) {
+  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, signal) {
+  try {
+    process.kill(-pid, signal);
+  } catch {
+    try {
+      process.kill(pid, signal);
+    } catch {
+      // already gone
+    }
+  }
+}

package/dist/modules/shell/shell.js

@@ -0,0 +1,242 @@
+import { createWriteStream, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { LineLog } from "./output/line-log.js";
+import { OutputNormalizer } from "./output/normalizer.js";
+import { RawRing } from "./output/raw-ring.js";
+import { Screen } from "./output/screen.js";
+const ERROR_LINE = /\b(error|err!|failed|failure|fatal|panic|exception|traceback)\b|✗|✖/i;
+/**
+ * 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 {
+  status = "running";
+  run = 0;
+  /** First log line number belonging to the current run. */
+  runStartLine = 1;
+  lastOutputAt = Date.now();
+  /** Health rule attached to this shell, if any (see watch/watcher.ts). */
+
+  /** Called when the watcher's reported status changes; never per line. */
+
+  listeners = new Set();
+  startedAt = 0;
+
+  /** Why the daemon stopped it, when it was not a user or agent request. */
+
+  stopRequested = false;
+  exitPromise = Promise.resolve();
+  constructor(spec, backend, limits) {
+    this.spec = spec;
+    this.backend = backend;
+    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() {
+    return this.spec.id;
+  }
+
+  /** The line currently being written (e.g. a prompt awaiting input); empty when none. */
+  get partialLine() {
+    return this.normalizer.partial;
+  }
+  get running() {
+    return this.status === "running";
+  }
+
+  /** Resolves when the current run has fully exited and been accounted for. */
+  get exited() {
+    return this.exitPromise;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  start() {
+    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.stoppedBecause = undefined;
+    if (this.spec.logFile && !this.logWriter) {
+      mkdirSync(dirname(this.spec.logFile), {
+        recursive: true
+      });
+      const file = createWriteStream(this.spec.logFile, {
+        flags: "a",
+        mode: 0o600
+      });
+      file.on("error", () => {
+        this.logWriter = undefined;
+      });
+      this.logWriter = {
+        write: text => file.write(text),
+        end: () => file.end()
+      };
+    }
+    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(() => {
+        this.stoppedBecause = `reached its ${Math.round((this.spec.timeoutMs ?? 0) / 1000)}s time limit`;
+        void this.stop("SIGTERM", 3000);
+      }, this.spec.timeoutMs);
+    }
+    if (this.spec.idleTimeoutMs) {
+      const idleMs = this.spec.idleTimeoutMs;
+      this.idleTimer = setInterval(() => {
+        if (!this.running || Date.now() - this.lastOutputAt < idleMs) return;
+        this.stoppedBecause = `produced no output for ${Math.round(idleMs / 1000)}s`;
+        void this.stop("SIGTERM", 3000);
+      }, Math.max(500, Math.floor(idleMs / 4)));
+    }
+  }
+  write(data) {
+    if (!this.running || !this.pty) throw new Error(`shell is ${this.status}`);
+    return this.pty.write(data);
+  }
+  resize(cols, rows) {
+    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 = "SIGTERM", graceMs = 3000) {
+    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() {
+    return this.screen.snapshot();
+  }
+  info() {
+    const info = {
+      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.spec.logFile) info.logFile = this.spec.logFile;
+    if (this.watcher) info.watch = this.watcher.state();
+    if (this.endedAt) info.endedAt = this.endedAt;
+    return info;
+  }
+  dispose() {
+    clearTimeout(this.timeout);
+    clearInterval(this.idleTimer);
+    this.logWriter?.end();
+    this.listeners.clear();
+    this.pty?.close();
+    this.screen.dispose();
+  }
+
+  /** Last error-looking line of the current run, else its last non-empty line. */
+  summarize() {
+    const from = Math.max(this.runStartLine, this.log.lastLine - 200 + 1);
+    let last;
+    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);
+  }
+  createNormalizer() {
+    return new OutputNormalizer(text => {
+      const line = this.log.append(text);
+      this.logWriter?.write(`${text}\n`);
+      const change = this.watcher?.line(text);
+      if (change) this.onWatchChange?.(change);
+      for (const l of this.listeners) l.line?.(line);
+    });
+  }
+  onData(chunk) {
+    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);
+    }
+  }
+  onExit(pty, exit) {
+    if (this.pty !== pty) return; // a newer run replaced this one
+    clearTimeout(this.timeout);
+    clearInterval(this.idleTimer);
+    this.logWriter?.end();
+    this.logWriter = undefined;
+    this.normalizer.flush();
+    this.exit = exit;
+    this.endedAt = Date.now();
+    this.status = this.stopRequested || exit.signal ? "killed" : "exited";
+    this.summary = this.stoppedBecause ? `stopped: ${this.stoppedBecause}` : this.summarize();
+    const ended = this.watcher?.exited(exit.exitCode ?? undefined, exit.signal ?? undefined);
+    if (ended) this.onWatchChange?.(ended);
+    // 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/dist/modules/shell/wait.js

@@ -0,0 +1,107 @@
+import { probePort } from "./port-probe.js";
+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, params, compile) {
+  const {
+    until,
+    timeoutMs
+  } = params;
+  return new Promise(resolve => {
+    const cleanups = [];
+    let done = false;
+    const finish = outcome => {
+      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
+      });
+      // A prompt already on screen has no newline yet, so it is not in the log.
+      const partial = shell.partialLine;
+      if (partial && regex.test(partial)) {
+        return finish({
+          reason: "pattern",
+          match: {
+            n: shell.log.lastLine + 1,
+            text: partial
+          }
+        });
+      }
+    }
+    if (!shell.running) return finish({
+      reason: "exit"
+    });
+    let idleTimer;
+    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));
+  });
+}