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

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