@midhunxavier/code-flow 0.0.0-stage → 0.1.0-preview.3

package/src/shared-api.js

@@ -0,0 +1,239 @@
+import { randomUUID } from "node:crypto";
+import { HttpError, readJson, send } from "./http.js";
+import { roleAtLeast } from "./shared-accounts.js";
+import { sharedCanReadRun, sharedCoverageProjection, sharedDiffProjection, sharedEventProjection, sharedProjectProjection, sharedProjectRole, sharedRoutePolicy, sharedRunProjection } from "./shared-access.js";
+import { afterRunCursor, compareRuns, decodeRunCursor, encodeRunCursor } from "./run-history.js";
+import { sensitiveContextPath } from "./context-inspection.js";
+import { redactExport } from "./privacy.js";
+const sharedStreams = /* @__PURE__ */ new Map();
+let totalSharedStreams = 0;
+const STREAM_BYTES = 2 * 1024 * 1024;
+function sharedStream(res, userId) {
+  const count = sharedStreams.get(userId) ?? 0;
+  if (count >= 4 || totalSharedStreams >= 128) throw new HttpError(429, "Too many shared event streams; close another tab and retry");
+  sharedStreams.set(userId, count + 1);
+  totalSharedStreams++;
+  let closed = false, blocked = false;
+  const disposers = [];
+  const close = () => {
+    if (closed) return;
+    closed = true;
+    const remaining = (sharedStreams.get(userId) ?? 1) - 1;
+    if (remaining) sharedStreams.set(userId, remaining);
+    else sharedStreams.delete(userId);
+    totalSharedStreams--;
+    for (const dispose of disposers.splice(0)) dispose();
+    res.destroy();
+  };
+  const write = (frame) => {
+    if (closed) return;
+    if (blocked || Buffer.byteLength(frame) > STREAM_BYTES || res.writableLength + Buffer.byteLength(frame) > STREAM_BYTES) return close();
+    blocked = !res.write(frame);
+  };
+  res.on("drain", () => {
+    blocked = false;
+  });
+  res.on("close", close);
+  res.writeHead(200, { "content-type": "text/event-stream; charset=utf-8", "cache-control": "no-store", connection: "keep-alive", "x-accel-buffering": "no" });
+  return { close, add: (dispose) => disposers.push(dispose), emit: (value) => write(`data: ${JSON.stringify(value)}
+
+`), ping: () => write(": connected\n\n") };
+}
+async function handleSharedApi(req, res, url, parts, host) {
+  const policy = sharedRoutePolicy(req.method ?? "GET", parts);
+  if (policy === "owner" || policy === "identity") throw new HttpError(403, "This operation requires the Code Flow owner");
+  const current = () => {
+    const identity = host.accounts.authenticate(host.token, { touch: false });
+    if (!identity || identity.userId !== host.identity.userId || identity.revision !== host.identity.revision) throw new HttpError(401, "Shared session expired or was revoked");
+    return identity;
+  };
+  const projectId = (run2) => run2.project ?? (() => {
+    const matches = host.projects.list().filter((project) => project.repos.includes(run2.repo));
+    return matches.length === 1 ? matches[0].id : void 0;
+  })();
+  const canRead = (run2) => (!host.canReadFilePolicy || host.canReadFilePolicy(run2)) && sharedCanReadRun(current(), run2, host.projects.list());
+  const canReadId = (id) => {
+    const run2 = host.manager.get(id);
+    return !!run2 && canRead(run2);
+  };
+  const projection = (run2) => sharedRunProjection({ ...run2, project: projectId(run2) }, canReadId);
+  const authorized = () => host.manager.list().filter(canRead).sort(compareRuns);
+  const requestedRun = () => {
+    const run2 = host.manager.get(parts[2] ?? "");
+    if (!run2 || !canRead(run2)) throw new HttpError(404, "Run not found");
+    return run2;
+  };
+  const assertBranch = (run2, branch) => {
+    if (typeof branch !== "string" || !run2.worktrees.some((tree) => tree.branch === branch)) throw new HttpError(404, "Result branch not found");
+    return branch;
+  };
+  const coverage = sharedCoverageProjection;
+  current();
+  if (policy === "catalog") return send(res, 200, redactExport(parts[1] === "patterns" ? host.patterns : host.templates));
+  if (policy === "project-list") return send(res, 200, host.projects.list().filter((project) => sharedProjectRole(current(), project.id)).map(sharedProjectProjection));
+  if (policy === "run-list" && parts[1] === "runs") {
+    const limit = url.searchParams.has("limit") ? Number(url.searchParams.get("limit")) : 50;
+    const query = url.searchParams.get("q") ?? "", selectedProject = url.searchParams.get("project");
+    if (!Number.isInteger(limit) || limit < 1 || limit > 100 || query.length > 300) throw new HttpError(400, "Choose a history limit of 1\u2013100 and a bounded search");
+    if (selectedProject && !sharedProjectRole(current(), selectedProject)) throw new HttpError(404, "Project not found");
+    const words = query.trim().toLowerCase().split(/\s+/).filter(Boolean);
+    const filtered = authorized().filter((run2) => {
+      if (selectedProject && projectId(run2) !== selectedProject) return false;
+      if (!words.length) return true;
+      const full = run2.cold ? host.manager.get(run2.id) : run2;
+      if (!full || !canRead(full) || selectedProject && projectId(full) !== selectedProject) return false;
+      const text = [full.id, full.task, full.pattern].join("\n").toLowerCase();
+      return words.every((word) => text.includes(word));
+    });
+    const cursor = url.searchParams.get("cursor");
+    let after;
+    try {
+      after = cursor ? decodeRunCursor(cursor) : void 0;
+    } catch {
+      throw new HttpError(400, "Invalid shared history cursor");
+    }
+    const remaining = after ? filtered.filter((run2) => afterRunCursor(run2, after)) : filtered;
+    const page = remaining.slice(0, limit);
+    return send(res, 200, { runs: page.map(projection), total: filtered.length, ...remaining.length > limit ? { nextCursor: encodeRunCursor(page.at(-1)) } : {} });
+  }
+  if (policy === "run-list") {
+    const { emit, close, add, ping } = sharedStream(res, host.identity.userId);
+    let visible = /* @__PURE__ */ new Set();
+    const notification = (run2) => ({ id: run2.id, project: projectId(run2), status: run2.status, createdAt: run2.createdAt, endedAt: run2.endedAt });
+    const reset = () => {
+      const list = authorized();
+      visible = new Set(list.map((run2) => run2.id));
+      emit({ type: "hello", epoch: randomUUID(), runs: list.slice(0, 100).map(notification), total: list.length });
+    };
+    add(host.manager.subscribeAll((run2) => {
+      if (run2.deleted) {
+        if (visible.delete(run2.id)) reset();
+        return;
+      }
+      try {
+        if (canRead(run2)) {
+          visible.add(run2.id);
+          emit({ type: "run", run: notification(run2) });
+        } else if (visible.delete(run2.id)) reset();
+      } catch {
+        close();
+      }
+    }));
+    if (host.onFilePolicyChange) add(host.onFilePolicyChange(() => close()));
+    add(host.accounts.onChange(() => {
+      try {
+        current();
+      } catch {
+        close();
+      }
+    }));
+    add(host.projects.onChange(() => {
+      try {
+        current();
+        reset();
+      } catch {
+        close();
+      }
+    }));
+    const timer = setInterval(() => {
+      try {
+        current();
+        ping();
+      } catch {
+        close();
+      }
+    }, 15e3);
+    timer.unref();
+    add(() => clearInterval(timer));
+    reset();
+    return;
+  }
+  const run = requestedRun();
+  if (policy === "run-review") {
+    const reviewer = (identity2) => roleAtLeast(sharedProjectRole(identity2, projectId(run)), "reviewer");
+    if (!reviewer(current())) throw new HttpError(403, "A project reviewer role is required");
+    const body = await readJson(req, 16 * 1024, { timeoutMs: 1e4 });
+    const branch = assertBranch(run, body.branch);
+    const identity = current();
+    if (!canRead(run) || !reviewer(identity)) throw new HttpError(404, "Run not found");
+    if (parts[3] === "review-coverage") {
+      if (typeof body.path !== "string" || sensitiveContextPath(body.path)) throw new HttpError(403, "This path requires owner review");
+      const result2 = await host.manager.recordFileReview(run.id, { branch, expectedHead: body.expectedHead, path: body.path, reviewed: body.reviewed }, `shared:${identity.userId}:${identity.username}`, () => {
+        if (!canRead(run) || !reviewer(current())) throw new HttpError(403, "Project reviewer access changed");
+      });
+      current();
+      if (!canRead(run)) throw new HttpError(404, "Run not found");
+      return send(res, 200, coverage(result2));
+    }
+    const result = await host.comments.add(run.id, { branch, expectedHead: body.expectedHead, text: body.text }, { id: `shared:${identity.userId}`, name: identity.displayName }, async () => {
+      current();
+      const latest = requestedRun();
+      assertBranch(latest, branch);
+      return (await host.manager.reviewCoverage(run.id, branch)).head;
+    }, () => {
+      if (!canRead(run) || !reviewer(current())) throw new HttpError(403, "Project reviewer access changed");
+    });
+    current();
+    if (!canRead(run)) throw new HttpError(404, "Run not found");
+    return send(res, 201, result);
+  }
+  if (parts.length === 3) return send(res, 200, projection(run));
+  if (parts[3] === "export") return send(res, 200, { version: 1, exportedAt: Date.now(), run: projection(run) });
+  if (parts[3] === "collaboration") {
+    const result = await host.comments.list(run.id);
+    current();
+    if (!canRead(run)) throw new HttpError(404, "Run not found");
+    return send(res, 200, result);
+  }
+  if (parts[3] === "diff" || parts[3] === "review-coverage") {
+    const branch = assertBranch(run, url.searchParams.get("branch"));
+    const result = parts[3] === "diff" ? sharedDiffProjection(await host.manager.diff(run.id, branch, false)) : coverage(await host.manager.reviewCoverage(run.id, branch));
+    current();
+    if (!canRead(run)) throw new HttpError(404, "Run not found");
+    return send(res, 200, result);
+  }
+  if (parts[3] === "events") {
+    const { emit, close, add, ping } = sharedStream(res, host.identity.userId);
+    add(host.manager.subscribe(run.id, (event) => {
+      try {
+        requestedRun();
+        const value = sharedEventProjection(event, canReadId);
+        if (value) emit(value);
+      } catch {
+        close();
+      }
+    }));
+    if (host.onFilePolicyChange) add(host.onFilePolicyChange(() => close()));
+    add(host.accounts.onChange(() => {
+      try {
+        requestedRun();
+      } catch {
+        close();
+      }
+    }));
+    add(host.projects.onChange(() => {
+      try {
+        requestedRun();
+      } catch {
+        close();
+      }
+    }));
+    const timer = setInterval(() => {
+      try {
+        requestedRun();
+        ping();
+      } catch {
+        close();
+      }
+    }, 15e3);
+    timer.unref();
+    add(() => clearInterval(timer));
+    const snapshot = projection(run);
+    emit({ type: "hello", snapshot: { run: { ...snapshot, steps: void 0 }, steps: snapshot.steps ?? [] } });
+    return;
+  }
+  throw new HttpError(403, "This operation requires the Code Flow owner");
+}
+export {
+  handleSharedApi
+};

package/src/shell.js

@@ -0,0 +1,346 @@
+import { execFile, spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { existsSync } from "node:fs";
+import { basename } from "node:path";
+import { fileURLToPath } from "node:url";
+import { killGroup, trackGroup, untrackGroup } from "./adapters/process.js";
+import { childEnv } from "./env.js";
+const MARK = "";
+const MARKER = new RegExp(`${MARK}(\\d+)${MARK}([^${MARK}]*)${MARK}\\n?`);
+const HISTORY_BYTES = 256 * 1024;
+const MAX_SHELLS = 12;
+const PTY_SCRIPT = fileURLToPath(new URL("../scripts/pty.py", import.meta.url));
+const PTY_CLOSE_MS = 3e3;
+const clamp = (n, lo, hi, fallback) => Number.isFinite(Number(n)) ? Math.min(hi, Math.max(lo, Math.round(Number(n)))) : fallback;
+class ShellLimitError extends Error {
+}
+function shellProgram(env = process.env) {
+  const own = env.SHELL ?? "";
+  if (["bash", "zsh", "sh", "dash", "ksh"].includes(basename(own)) && existsSync(own)) return own;
+  return existsSync("/bin/bash") ? "/bin/bash" : "/bin/sh";
+}
+function loginShell(env = process.env) {
+  const own = env.SHELL ?? "";
+  return own.startsWith("/") && existsSync(own) ? own : shellProgram(env);
+}
+const probes = /* @__PURE__ */ new Map();
+function ptyPython(python = defaultPython()) {
+  if (process.platform === "win32") return Promise.resolve(void 0);
+  let probe = probes.get(python);
+  if (!probe) {
+    probe = new Promise((resolve) => {
+      const check = "import sys, pty, termios, fcntl, select\nif sys.version_info < (3, 6): sys.exit(1)\nprint(sys.executable)";
+      execFile(python, ["-I", "-c", check], { timeout: 1e4, env: childEnv() }, (err, stdout) => resolve(err ? void 0 : String(stdout).trim() || python));
+    });
+    probes.set(python, probe);
+  }
+  return probe;
+}
+function ptyAvailable(python = defaultPython(), options = {}) {
+  if (options.refresh) probes.delete(python);
+  return ptyPython(python).then(Boolean);
+}
+function defaultPython() {
+  return process.env.CODEFLOW_PYTHON || "python3";
+}
+class Shells {
+  shells = /* @__PURE__ */ new Map();
+  python;
+  constructor(opts = {}) {
+    this.python = opts.python ?? defaultPython();
+  }
+  /** Whether new terminals can be interactive (python3 is there to run the pseudo-terminal). */
+  interactive() {
+    return ptyAvailable(this.python);
+  }
+  list() {
+    return [...this.shells.values()].map(describe);
+  }
+  get(id) {
+    const s = this.shells.get(id);
+    return s && describe(s);
+  }
+  /** What a client needs to catch up: the kept output, in order. */
+  history(id) {
+    const s = this.shells.get(id);
+    if (!s) return [];
+    const events = [...s.history];
+    const first = events[0];
+    if (s.interactive && s.trimmed && first?.type === "output") {
+      const nl = first.text.indexOf("\n");
+      events[0] = { type: "output", text: nl < 0 ? "" : first.text.slice(nl + 1) };
+    }
+    return events;
+  }
+  /**
+   * A new shell in `cwd`. `pty` asks for a real terminal of `cols` × `rows`; without python3 it's
+   * a line-based one (`interactive: false`).
+   */
+  async open(cwd, opts = {}) {
+    const python = opts.pty ? await ptyPython(this.python) : void 0;
+    const pty = !!python;
+    while (this.shells.size >= MAX_SHELLS) {
+      const spare = await this.spare();
+      if (!spare) throw new ShellLimitError(`${MAX_SHELLS} terminals are open and each is running something: stop or close one first`);
+      this.close(spare.id);
+    }
+    const id = `sh${Date.now().toString(36)}${randomBytes(2).toString("hex")}`;
+    const shell = python ? this.startPty(id, python, cwd, clamp(opts.cols, 2, 1e3, 80), clamp(opts.rows, 1, 500, 24)) : this.startLines(id, cwd);
+    shell.child.stdin?.on("error", () => {
+    });
+    const ended = (code) => {
+      if (shell.status === "exited") return;
+      untrackGroup(shell.child.pid);
+      untrackGroup(shell.pid);
+      if (shell.pending) this.emit(shell, { type: "output", text: shell.pending });
+      const rest = shell.decoder?.decode();
+      if (rest) this.emit(shell, { type: "output", text: rest });
+      shell.pending = "";
+      shell.status = "exited";
+      shell.exitCode = code;
+      shell.busy = false;
+      shell.running = void 0;
+      this.emit(shell, { type: "exit", code });
+    };
+    shell.child.on(pty ? "close" : "exit", ended);
+    shell.child.on("error", () => shell.child.pid === void 0 && ended(null));
+    this.shells.set(id, shell);
+    return describe(shell);
+  }
+  /**
+   * The shell to close to make room for another: one that's done, else the oldest one waiting for
+   * a command. Never one that's running something, in the foreground or as a job in the
+   * background (`npm run dev &`, a stopped vim): closing the shell would end it.
+   */
+  async spare() {
+    const byAge = [...this.shells.values()].sort((a, b) => a.startedAt - b.startedAt);
+    const exited = byAge.find((s) => s.status === "exited");
+    if (exited) return exited;
+    if (!byAge.some((s) => !s.busy)) return void 0;
+    const procs = await processes();
+    return byAge.find((s) => s.status === "exited" || !s.busy && !hasJobs(s, procs));
+  }
+  /** Send a command to a line-based shell. Its exit code and the folder it left the shell in come back as `done`. */
+  write(id, text) {
+    const s = this.shells.get(id);
+    if (!s || s.status !== "running" || !s.child.stdin?.writable) return false;
+    if (s.interactive) return this.type(id, `${text.replace(/\r\n?|\n/g, "\r").replace(/\r$/, "")}\r`);
+    const command = text.replace(/\r\n?/g, "\n").replace(/\n$/, "");
+    this.emit(s, { type: "input", text: command });
+    s.busy = true;
+    s.child.stdin.write(`${command}
+printf '\\036%s\\036%s\\036\\n' "$?" "$PWD"
+`);
+    return true;
+  }
+  /**
+   * Keystrokes for an interactive shell, as typed (a paste, an escape sequence, Ctrl-C as \x03).
+   * `latin1`: bytes, one per character, sent as they are (xterm's mouse reports, which aren't UTF-8).
+   */
+  type(id, data, encoding = "utf8") {
+    const s = this.shells.get(id);
+    if (!s || !s.interactive || s.status !== "running" || !s.child.stdin?.writable) return false;
+    s.child.stdin.write(Buffer.from(data, encoding));
+    return true;
+  }
+  /** Buffered keystrokes, for bounded remote terminal input. */
+  pendingInputBytes(id) {
+    return this.shells.get(id)?.child.stdin?.writableLength ?? 0;
+  }
+  /** An interactive shell's window changed size: the programs in it get SIGWINCH. */
+  resize(id, cols, rows) {
+    const s = this.shells.get(id);
+    const control = s?.child.stdio[3];
+    if (!s || !s.interactive || s.status !== "running" || !control?.writable) return false;
+    s.cols = clamp(cols, 2, 1e3, s.cols ?? 80);
+    s.rows = clamp(rows, 1, 500, s.rows ?? 24);
+    control.write(`${JSON.stringify({ resize: [s.cols, s.rows] })}
+`);
+    return true;
+  }
+  subscribe(id, client) {
+    const s = this.shells.get(id);
+    if (!s) return void 0;
+    s.clients.add(client);
+    return () => s.clients.delete(client);
+  }
+  close(id) {
+    const s = this.shells.get(id);
+    if (!s) return false;
+    if (s.status === "running") {
+      if (s.interactive) {
+        if (s.pid) signalGroup(s.pid, "SIGHUP");
+        killGroup(s.child.pid, PTY_CLOSE_MS);
+      } else killGroup(s.child.pid, 2e3);
+    }
+    untrackGroup(s.child.pid);
+    this.shells.delete(id);
+    return true;
+  }
+  /**
+   * Close every shell: code-flow is stopping. An interactive shell's helper is left to hang up its
+   * terminal on its own, after code-flow has exited (about a second), so it's no longer tracked:
+   * killed at exit, it couldn't, and jobs in process groups of their own (`nohup cmd &`, `disown`)
+   * would keep running with nothing left that knows about them.
+   */
+  closeAll() {
+    for (const s of [...this.shells.values()]) {
+      if (!s.interactive || s.status !== "running") {
+        this.close(s.id);
+        continue;
+      }
+      if (s.pid) signalGroup(s.pid, "SIGHUP");
+      if (s.child.pid) signalGroup(s.child.pid, "SIGTERM");
+      untrackGroup(s.child.pid);
+      untrackGroup(s.pid);
+      this.shells.delete(s.id);
+    }
+  }
+  startLines(id, cwd) {
+    const program = shellProgram();
+    const child = spawn(program, [], {
+      cwd,
+      detached: true,
+      // its own group: closing the shell closes whatever it started
+      stdio: ["pipe", "pipe", "pipe"],
+      env: childEnv({ TERM: "dumb", NO_COLOR: "1", FORCE_COLOR: "0", PAGER: "cat", GIT_PAGER: "cat", GIT_TERMINAL_PROMPT: "0", GCM_INTERACTIVE: "never" })
+    });
+    trackGroup(child.pid);
+    const shell = newShell(id, cwd, program, child, false);
+    child.stdout.on("data", (chunk) => this.onStdout(shell, chunk.toString()));
+    child.stderr.on("data", (chunk) => this.emit(shell, { type: "output", text: chunk.toString() }));
+    child.on("error", (err) => this.emit(shell, { type: "output", text: `Couldn't start ${program}: ${err.message}
+` }));
+    return shell;
+  }
+  startPty(id, python, cwd, cols, rows) {
+    const program = loginShell();
+    const env = childEnv({ TERM: "xterm-256color", COLORTERM: "truecolor" });
+    if (!env.LC_ALL && !env.LC_CTYPE && !env.LANG) env.LANG = process.platform === "darwin" ? "en_US.UTF-8" : "C.UTF-8";
+    const child = spawn(python, ["-I", PTY_SCRIPT, String(cols), String(rows), program, `-${basename(program)}`], {
+      cwd,
+      detached: true,
+      // the helper's own group; the shell gets a session of its own in the terminal
+      stdio: ["pipe", "pipe", "pipe", "pipe"],
+      env
+    });
+    trackGroup(child.pid);
+    const shell = newShell(id, cwd, program, child, true);
+    shell.cols = cols;
+    shell.rows = rows;
+    shell.decoder = new TextDecoder("utf-8");
+    child.stdout.on("data", (chunk) => {
+      const text = shell.decoder.decode(chunk, { stream: true });
+      if (text) this.emit(shell, { type: "output", text });
+    });
+    child.stderr.on("data", (chunk) => this.emit(shell, { type: "output", text: chunk.toString().replace(/\r?\n/g, "\r\n") }));
+    child.on("error", (err) => this.emit(shell, { type: "output", text: `Couldn't start the terminal (${python}): ${err.message}\r
+` }));
+    let control = "";
+    child.stdio[3]?.on("data", (chunk) => {
+      control += chunk.toString();
+      const lines = control.split("\n");
+      control = lines.pop();
+      for (const line of lines) {
+        let msg;
+        try {
+          msg = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (typeof msg.pid === "number") {
+          shell.pid = msg.pid;
+          if (shell.status === "running") trackGroup(msg.pid);
+        }
+        if (typeof msg.tty === "string") shell.tty = msg.tty.replace(/^\/dev\//, "");
+        if ("fg" in msg) this.onForeground(shell, msg.fg ?? null);
+      }
+    });
+    child.stdio[3]?.on("error", () => {
+    });
+    return shell;
+  }
+  /** The terminal's foreground changed: busy unless it's the shell itself; name what's running. */
+  onForeground(s, fg) {
+    s.fg = fg;
+    const busy = fg !== null && s.pid !== void 0 && fg !== s.pid;
+    if (busy === s.busy && !busy) return;
+    s.busy = busy;
+    s.running = void 0;
+    this.emit(s, { type: "busy", busy });
+    if (!busy) return;
+    execFile("ps", ["-o", "comm=", "-p", String(fg)], { timeout: 5e3, env: { ...process.env, LC_ALL: "C" } }, (err, stdout) => {
+      const name = basename(String(stdout).trim()).replace(/^-/, "");
+      if (err || !name || s.fg !== fg || s.status !== "running") return;
+      s.running = name;
+      this.emit(s, { type: "busy", busy: true, running: name });
+    });
+  }
+  onStdout(s, chunk) {
+    s.pending += chunk;
+    for (; ; ) {
+      const m = MARKER.exec(s.pending);
+      if (!m) break;
+      const before = s.pending.slice(0, m.index);
+      if (before) this.emit(s, { type: "output", text: before });
+      s.pending = s.pending.slice(m.index + m[0].length);
+      s.busy = false;
+      s.cwd = m[2] || s.cwd;
+      this.emit(s, { type: "done", code: Number(m[1]), cwd: s.cwd });
+    }
+    const partial = s.pending.indexOf(MARK);
+    const ready = partial < 0 ? s.pending : s.pending.slice(0, partial);
+    if (ready) {
+      this.emit(s, { type: "output", text: ready });
+      s.pending = s.pending.slice(ready.length);
+    }
+  }
+  emit(s, event) {
+    if (event.type === "busy") {
+      for (const client of s.clients) client(event);
+      return;
+    }
+    const last = s.history.at(-1);
+    if (event.type === "output" && last?.type === "output" && last.text.length < 8192) last.text += event.text;
+    else s.history.push(event.type === "output" ? { ...event } : event);
+    s.historyBytes += event.type === "output" || event.type === "input" ? event.text.length : 16;
+    while (s.historyBytes > HISTORY_BYTES && s.history.length > 1) {
+      const dropped = s.history.shift();
+      s.historyBytes -= dropped.type === "output" || dropped.type === "input" ? dropped.text.length : 16;
+      s.trimmed = true;
+    }
+    for (const client of s.clients) client(event);
+  }
+}
+function newShell(id, cwd, program, child, interactive) {
+  return { id, cwd, shell: program, status: "running", startedAt: Date.now(), busy: false, interactive, child, history: [], historyBytes: 0, trimmed: false, pending: "", clients: /* @__PURE__ */ new Set() };
+}
+function processes() {
+  return new Promise((resolve) => {
+    execFile("ps", ["-A", "-o", "pid=,pgid=,tty="], { timeout: 5e3, maxBuffer: 16 * 1024 * 1024, env: { ...process.env, LC_ALL: "C" } }, (err, stdout) => {
+      if (err) return resolve([]);
+      const rows = String(stdout).split("\n").map((line) => line.trim().split(/\s+/));
+      resolve(rows.filter((r) => r.length >= 2).map(([pid, pgid, tty]) => ({ pid: Number(pid), pgid: Number(pgid), tty: tty ?? "" })));
+    });
+  });
+}
+function hasJobs(s, procs) {
+  if (s.interactive) return !!s.tty && procs.some((p) => p.tty === s.tty && p.pgid !== s.pid);
+  return procs.some((p) => p.pgid === s.child.pid && p.pid !== s.child.pid);
+}
+function signalGroup(pid, signal) {
+  try {
+    process.kill(-pid, signal);
+  } catch {
+  }
+}
+function describe(s) {
+  return { id: s.id, cwd: s.cwd, shell: s.shell, status: s.status, exitCode: s.exitCode, startedAt: s.startedAt, busy: s.busy, interactive: s.interactive, cols: s.cols, rows: s.rows, running: s.running };
+}
+export {
+  MAX_SHELLS,
+  ShellLimitError,
+  Shells,
+  ptyAvailable,
+  shellProgram
+};