@opencode-cockpit/daemon 0.1.4 → 0.1.5

package/dist/modules/shell/module.js

@@ -0,0 +1,334 @@
+import { invalidParams, invalidState, notFound } from "../../core/errors.js";
+import { silentLogger } from "../../core/logger.js";
+import { newShellId } from "./ids.js";
+import { bunPtyBackend } from "./pty.js";
+import { ProcessRegistry } from "./registry.js";
+import { Shell } from "./shell.js";
+import { waitFor } from "./wait.js";
+const DEFAULT_LIMITS = {
+  logChars: 4_000_000,
+  rawBytes: 1_000_000,
+  scrollback: 2000
+};
+export class ShellModule {
+  name = "shell";
+  shells = new Map();
+  attachments = new Map(); // `${peer.id}:${shellId}` → detach
+
+  log = silentLogger;
+  emit = () => {};
+  constructor(options = {}) {
+    this.options = options;
+    this.backend = options.backend ?? bunPtyBackend;
+    this.limits = {
+      ...DEFAULT_LIMITS,
+      ...options.limits
+    };
+  }
+  async start(ctx) {
+    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() {
+    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() {
+    for (const shell of this.shells.values()) if (shell.running) return true;
+    return false;
+  }
+  methods = {
+    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 = [];
+      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 {};
+    }
+  };
+  startShell(params) {
+    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();
+  }
+  findReusable(params) {
+    const args = JSON.stringify(params.args);
+    let match;
+    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;
+  }
+  spawn(shell) {
+    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());
+  }
+  onExit(info) {
+    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);
+  }
+  attachStream(peer, shell) {
+    const key = `${peer.id}:${shell.id}`;
+    const flushMs = this.options.outputFlushMs ?? 16;
+    let pending = [];
+    let pendingOffset = 0;
+    let timer;
+    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);
+  }
+  detach(peer, id) {
+    this.attachments.get(`${peer.id}:${id}`)?.();
+  }
+  forget(shell) {
+    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
+    });
+  }
+  pruneFinished() {
+    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);
+  }
+  require(id) {
+    const shell = this.shells.get(id);
+    if (!shell) throw notFound(`shell ${id}`);
+    return shell;
+  }
+  uniqueId() {
+    let id = newShellId();
+    while (this.shells.has(id)) id = newShellId();
+    return id;
+  }
+  environment(extra) {
+    const env = {};
+    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, ignoreCase) {
+  try {
+    return new RegExp(pattern, ignoreCase ? "i" : "");
+  } catch (err) {
+    throw invalidParams(`invalid pattern: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}

package/dist/modules/shell/output/line-log.js

@@ -0,0 +1,76 @@
+/**
+ * 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 {
+  lines = [];
+  head = 0;
+  chars = 0;
+  first = 1;
+  constructor(maxChars = 4_000_000) {
+    this.maxChars = maxChars;
+  }
+
+  /** Number of the oldest retained line (equals `lastLine + 1` when empty). */
+  get firstLine() {
+    return this.first;
+  }
+
+  /** Number of the newest line, or `firstLine - 1` when empty. */
+  get lastLine() {
+    return this.first + (this.lines.length - this.head) - 1;
+  }
+  append(text) {
+    this.lines.push(text);
+    this.chars += text.length + 1;
+    const line = {
+      n: this.lastLine,
+      text
+    };
+    this.evict();
+    return line;
+  }
+  get(n) {
+    if (n < this.first || n > this.lastLine) return undefined;
+    return this.lines[this.head + (n - this.first)];
+  }
+  read(query) {
+    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 = [];
+    let n = start;
+    for (; n <= last && out.length < query.limit; n++) {
+      const text = this.lines[this.head + (n - this.first)];
+      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
+    };
+  }
+  evict() {
+    while (this.chars > this.maxChars && this.head < this.lines.length - 1) {
+      const dropped = this.lines[this.head];
+      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;
+    }
+  }
+}

package/dist/modules/shell/output/normalizer.js

@@ -0,0 +1,161 @@
+/**
+ * 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;
+var State = /*#__PURE__*/function (State) {
+  State[State["Ground"] = 0] = "Ground";
+  State[State["Escape"] = 1] = "Escape";
+  State[State["EscapeIntermediate"] = 2] = "EscapeIntermediate";
+  State[State["Csi"] = 3] = "Csi";
+  State[State["Osc"] = 4] = "Osc";
+  State[State["OscEscape"] = 5] = "OscEscape";
+  return State;
+}(State || {});
+export class OutputNormalizer {
+  decoder = new TextDecoder();
+  state = State.Ground;
+  csiParams = "";
+  cells = [];
+  col = 0;
+  constructor(commit, options = {}) {
+    this.commit = commit;
+    this.maxLineLength = options.maxLineLength ?? 10_000;
+  }
+
+  /** Text of the line currently being written (not yet terminated by a newline). */
+  get partial() {
+    return this.render();
+  }
+  push(chunk) {
+    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() {
+    const tail = this.render();
+    if (tail.length > 0) this.commit(tail);
+    this.cells = [];
+    this.col = 0;
+  }
+  step(char) {
+    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;
+    }
+  }
+  ground(char, code) {
+    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);
+  }
+  csi(final, raw) {
+    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
+    }
+  }
+  put(char) {
+    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;
+    }
+  }
+  render() {
+    return this.cells.join("").trimEnd();
+  }
+}

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,45 @@
+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 {
+  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 = [];
+    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() {
+    this.term.dispose();
+  }
+}

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));
+  });
+}