@opencode-cockpit/daemon 0.1.4 → 0.2.0

package/dist/modules/shell/methods.js

@@ -0,0 +1,186 @@
+import { invalidParams, invalidState } from "../../core/errors.js";
+import { compilePattern } from "./module.js";
+import { waitFor } from "./wait.js";
+import { PRESETS, presetByName, presetForCommand } from "./watch/presets.js";
+import { compileRule, Watcher } from "./watch/watcher.js";
+
+/**
+ * The `shell.*` methods, kept apart from the module's lifecycle and bookkeeping so each file has
+ * one job: this one maps protocol calls onto the module, `module.ts` owns the shells.
+ */
+export function shellMethods(module) {
+  return {
+    start: params => module.startShell(params),
+    list: params => {
+      const owner = params.owner;
+      return [...module.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
+    }) => module.require(id).info(),
+    read: ({
+      id,
+      after,
+      tail,
+      limit,
+      grep,
+      ignoreCase
+    }) => {
+      const shell = module.require(id);
+      const page = shell.log.read({
+        after,
+        tail,
+        limit,
+        grep: grep === undefined ? undefined : compilePattern(grep, ignoreCase)
+      });
+      return {
+        ...page,
+        status: shell.status
+      };
+    },
+    screen: ({
+      id
+    }) => module.require(id).snapshot(),
+    write: ({
+      id,
+      data
+    }) => {
+      const shell = module.require(id);
+      if (!shell.running) throw invalidState(`shell ${id} is ${shell.status}`);
+      return {
+        bytes: shell.write(data)
+      };
+    },
+    resize: ({
+      id,
+      cols,
+      rows
+    }) => {
+      module.require(id).resize(cols, rows);
+      return {};
+    },
+    wait: async params => {
+      const shell = module.require(params.id);
+      const outcome = await waitFor(shell, params, compilePattern);
+      return {
+        ...outcome,
+        info: shell.info()
+      };
+    },
+    stop: async ({
+      id,
+      signal,
+      graceMs
+    }) => {
+      const shell = module.require(id);
+      await shell.stop(signal, graceMs);
+      await shell.exited;
+      return shell.info();
+    },
+    restart: async ({
+      id
+    }) => {
+      const shell = module.require(id);
+      if (shell.running) {
+        await shell.stop("SIGTERM", 3000);
+        await shell.exited;
+      }
+      module.spawn(shell);
+      return shell.info();
+    },
+    remove: async ({
+      id
+    }) => {
+      const shell = module.require(id);
+      if (shell.running) {
+        await shell.stop("SIGTERM", 3000);
+        await shell.exited;
+      }
+      module.forget(shell);
+      return {};
+    },
+    attach: ({
+      id,
+      fromOffset
+    }, {
+      peer
+    }) => {
+      const shell = module.require(id);
+      module.detach(peer, id);
+      const replay = shell.raw.since(fromOffset ?? 0);
+      module.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 [...module.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;
+        module.forget(shell);
+        removed.push(info.id);
+      }
+      return {
+        removed
+      };
+    },
+    watch: ({
+      id,
+      preset,
+      rule
+    }) => {
+      const shell = module.require(id);
+      const command = [shell.spec.command, ...shell.spec.args].join(" ");
+      const chosen = rule ? undefined : preset && preset !== "auto" ? presetByName(preset) ?? invalidParams(`unknown preset "${preset}"; call shell.presets for the list`) : presetForCommand(command);
+      if (chosen instanceof Error) throw chosen;
+      const watchRule = rule ?? chosen?.rule;
+      if (!watchRule) {
+        throw invalidParams(`no watch preset matches "${command.slice(0, 80)}"; pass a rule (done/fail/ok patterns) or a preset name`);
+      }
+      try {
+        shell.watcher = new Watcher(compileRule(watchRule), chosen?.name);
+      } catch (err) {
+        throw invalidParams(`invalid watch pattern: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      shell.onWatchChange = change => {
+        module.emit("shell.watch", {
+          info: shell.info(),
+          ...change
+        });
+      };
+      module.armIdle(shell);
+      return shell.info();
+    },
+    unwatch: ({
+      id
+    }) => {
+      const shell = module.require(id);
+      shell.watcher = undefined;
+      shell.onWatchChange = undefined;
+      module.clearIdle(id);
+      return shell.info();
+    },
+    presets: () => PRESETS.map(preset => ({
+      name: preset.name,
+      match: preset.match,
+      rule: preset.rule
+    })),
+    detach: ({
+      id
+    }, {
+      peer
+    }) => {
+      module.detach(peer, id);
+      return {};
+    }
+  };
+}

package/dist/modules/shell/module.js

@@ -0,0 +1,259 @@
+import { join } from "node:path";
+import { invalidParams, notFound } from "../../core/errors.js";
+import { silentLogger } from "../../core/logger.js";
+import { newShellId } from "./ids.js";
+import { shellMethods } from "./methods.js";
+import { bunPtyBackend } from "./pty.js";
+import { ProcessRegistry } from "./registry.js";
+import { Shell } from "./shell.js";
+const DEFAULT_LIMITS = {
+  logChars: 4_000_000,
+  rawBytes: 1_000_000,
+  scrollback: 2000
+};
+export class ShellModule {
+  name = "shell";
+  /** @internal */
+  shells = new Map();
+  /** @internal */
+  attachments = new Map(); // `${peer.id}:${shellId}` → detach
+
+  log = silentLogger;
+  idleTimers = new Map();
+  /** @internal */
+  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() {
+    for (const id of [...this.idleTimers.keys()]) this.clearIdle(id);
+    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 = shellMethods(this);
+
+  /** @internal used by methods.ts */
+  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 id = this.uniqueId();
+    const shell = new Shell({
+      id,
+      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,
+      idleTimeoutMs: params.idleTimeoutMs,
+      logFile: params.logFile ? join(this.options.logDir ?? "/tmp", `${id}.log`) : undefined
+    }, 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();
+  }
+
+  /** @internal used by methods.ts */
+  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;
+  }
+
+  /** @internal used by methods.ts */
+  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);
+  }
+
+  /** @internal used by methods.ts */
+  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);
+  }
+
+  /** @internal used by methods.ts */
+  detach(peer, id) {
+    this.attachments.get(`${peer.id}:${id}`)?.();
+  }
+
+  /**
+   * Rules without a `done` pattern end a run on silence, so poll those watchers; the check is a
+   * timestamp comparison, and only shells that need it are polled.
+   */
+  /** @internal used by methods.ts */
+  armIdle(shell) {
+    this.clearIdle(shell.id);
+    const idleMs = shell.watcher?.idleMs;
+    if (!idleMs) return;
+    const timer = setInterval(() => {
+      if (!shell.watcher || Date.now() - shell.lastOutputAt < idleMs) return;
+      const change = shell.watcher.idle();
+      if (change) this.emit("shell.watch", {
+        info: shell.info(),
+        ...change
+      });
+    }, Math.max(500, Math.floor(idleMs / 2)));
+    this.idleTimers.set(shell.id, timer);
+  }
+
+  /** @internal used by methods.ts */
+  clearIdle(id) {
+    const timer = this.idleTimers.get(id);
+    if (timer) clearInterval(timer);
+    this.idleTimers.delete(id);
+  }
+
+  /** @internal used by methods.ts */
+  forget(shell) {
+    this.clearIdle(shell.id);
+    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
+    });
+  }
+
+  /** @internal used by methods.ts */
+  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);
+  }
+
+  /** @internal used by methods.ts */
+  require(id) {
+    const shell = this.shells.get(id);
+    if (!shell) throw notFound(`shell ${id}`);
+    return shell;
+  }
+
+  /** @internal used by methods.ts */
+  uniqueId() {
+    let id = newShellId();
+    while (this.shells.has(id)) id = newShellId();
+    return id;
+  }
+
+  /** @internal used by methods.ts */
+  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/palette.js

@@ -0,0 +1,19 @@
+/** Standard xterm palette, so the daemon can hand UIs resolved colours instead of escape codes. */
+const BASE = ["#000000", "#cd0000", "#00cd00", "#cdcd00", "#0000ee", "#cd00cd", "#00cdcd", "#e5e5e5", "#7f7f7f", "#ff0000", "#00ff00", "#ffff00", "#5c5cff", "#ff00ff", "#00ffff", "#ffffff"];
+const STEPS = [0, 95, 135, 175, 215, 255];
+const hex = n => n.toString(16).padStart(2, "0");
+export function paletteColor(index) {
+  if (index < 16) return BASE[index] ?? "#ffffff";
+  if (index < 232) {
+    const value = index - 16;
+    const r = STEPS[Math.floor(value / 36) % 6] ?? 0;
+    const g = STEPS[Math.floor(value / 6) % 6] ?? 0;
+    const b = STEPS[value % 6] ?? 0;
+    return `#${hex(r)}${hex(g)}${hex(b)}`;
+  }
+  const grey = 8 + (index - 232) * 10;
+  return `#${hex(grey)}${hex(grey)}${hex(grey)}`;
+}
+export function rgbColor(value) {
+  return `#${hex(value >> 16 & 0xff)}${hex(value >> 8 & 0xff)}${hex(value & 0xff)}`;
+}