oakode 0.0.0-stage → 0.5.1

package/dist/input.js

@@ -0,0 +1,244 @@
+/**
+ * Keyboard input decoding (raw mode) and the exit watchdog.
+ *
+ * Pasted text arrives between ESC[200~ and ESC[201~ and is inserted verbatim: it can never submit, approve a prompt, or be
+ * altered by editing rules. There are no timers in paste detection.
+ */
+import { spawn } from "node:child_process";
+const PASTE_START = "\x1b[200~";
+const PASTE_END = "\x1b[201~";
+/** Pasted text: unify line endings and drop control characters (they could drive the terminal). */
+const cleanPaste = (s) => s.replace(/\r\n?/g, "\n").replace(/[\x00-\x08\x0b-\x1f\x7f]/g, "");
+export class KeyParser {
+    pending = "";
+    paste = null;
+    /** After a short idle: a lone ESC is the Escape key; any other incomplete sequence is dropped. Never touches a paste. */
+    flushPending() {
+        if (this.paste !== null)
+            return [];
+        const lone = this.pending === "\x1b" || this.pending.startsWith("\x1b\x1b"); // ESC ESC that did not become Option+Up
+        this.pending = "";
+        return lone ? [{ k: "escape" }] : [];
+    }
+    feed(chunk) {
+        const s = this.pending + chunk;
+        this.pending = "";
+        const keys = [];
+        let text = "";
+        const flushText = () => {
+            if (text)
+                keys.push({ k: "text", s: text });
+            text = "";
+        };
+        let i = 0;
+        while (i < s.length) {
+            if (this.paste !== null) {
+                const end = s.indexOf(PASTE_END, i);
+                if (end < 0) {
+                    // keep a possible partial end marker for the next chunk
+                    let hold = 0;
+                    for (let n = Math.min(PASTE_END.length - 1, s.length - i); n > 0; n--) {
+                        if (PASTE_END.startsWith(s.slice(s.length - n))) {
+                            hold = n;
+                            break;
+                        }
+                    }
+                    this.paste += s.slice(i, s.length - hold);
+                    this.pending = s.slice(s.length - hold);
+                    return keys;
+                }
+                keys.push({ k: "paste", s: cleanPaste(this.paste + s.slice(i, end)) });
+                this.paste = null;
+                i = end + PASTE_END.length;
+                continue;
+            }
+            const ch = s[i];
+            if (ch === "\x1b") {
+                flushText();
+                const next = this.escape(s, i, keys);
+                if (next < 0) {
+                    this.pending = s.slice(i);
+                    return unbracketed(keys);
+                }
+                i = next;
+                continue;
+            }
+            const code = ch.charCodeAt(0);
+            if (code >= 0x20 && code !== 0x7f) {
+                text += ch;
+                i++;
+                continue;
+            }
+            flushText();
+            i++;
+            switch (ch) {
+                case "\r":
+                    keys.push({ k: "enter" });
+                    break;
+                case "\t":
+                    keys.push({ k: "tab" });
+                    break;
+                case "\n":
+                    keys.push({ k: "newline" });
+                    break; // Ctrl+J
+                case "\x7f":
+                case "\b":
+                    keys.push({ k: "backspace" });
+                    break;
+                case "\x01":
+                    keys.push({ k: "ctrl", c: "a" });
+                    break;
+                case "\x03":
+                    keys.push({ k: "ctrl", c: "c" });
+                    break;
+                case "\x04":
+                    keys.push({ k: "ctrl", c: "d" });
+                    break;
+                case "\x05":
+                    keys.push({ k: "ctrl", c: "e" });
+                    break;
+                case "\x0b":
+                    keys.push({ k: "ctrl", c: "k" });
+                    break;
+                case "\x0c":
+                    keys.push({ k: "ctrl", c: "l" });
+                    break;
+                case "\x15":
+                    keys.push({ k: "ctrl", c: "u" });
+                    break;
+                case "\x17":
+                    keys.push({ k: "ctrl", c: "w" });
+                    break;
+                default: break; // other control characters are ignored
+            }
+        }
+        flushText();
+        return unbracketed(keys);
+    }
+    /** Parse an escape sequence at s[i]; returns the next index, or -1 if the sequence is incomplete. */
+    escape(s, i, keys) {
+        if (i + 1 >= s.length)
+            return -1;
+        const n = s[i + 1];
+        if (n === "[") {
+            let j = i + 2;
+            while (j < s.length && !(s.charCodeAt(j) >= 0x40 && s.charCodeAt(j) <= 0x7e))
+                j++;
+            if (j >= s.length)
+                return s.length - i > 32 ? s.length : -1; // incomplete (or junk: drop it)
+            const params = s.slice(i + 2, j);
+            const fin = s[j];
+            const arrows = { A: "up", B: "down", C: "right", D: "left", H: "home", F: "end" };
+            if (fin === "~") {
+                if (params === "200")
+                    this.paste = "";
+                else if (params === "3")
+                    keys.push({ k: "delete" });
+                else if (params === "1" || params === "7")
+                    keys.push({ k: "home" });
+                else if (params === "4" || params === "8")
+                    keys.push({ k: "end" });
+                else if (params === "27;2;13")
+                    keys.push({ k: "newline" }); // Shift+Enter (xterm modifyOtherKeys)
+            }
+            else if (fin === "Z") {
+                keys.push({ k: "shifttab" });
+            }
+            else if ((fin === "I" || fin === "O") && params === "") {
+                keys.push({ k: fin === "I" ? "focusin" : "focusout" }); // focus reporting (ESC[?1004h)
+            }
+            else if (fin === "u" && /^13;[2-8]$/.test(params)) {
+                keys.push({ k: "newline" }); // Shift/Alt/Ctrl+Enter (kitty protocol)
+            }
+            else if (fin === "u" && params === "13") {
+                keys.push({ k: "enter" });
+            }
+            else if (arrows[fin]) {
+                const mod = /^1;[35]$/.test(params);
+                if (/^1;(3|9)$/.test(params) && fin === "A")
+                    keys.push({ k: "altup" }); // Alt/Option+Up
+                else if (mod && fin === "C")
+                    keys.push({ k: "wordright" });
+                else if (mod && fin === "D")
+                    keys.push({ k: "wordleft" });
+                else
+                    keys.push({ k: arrows[fin] });
+            }
+            return j + 1;
+        }
+        if (n === "O") {
+            if (i + 2 >= s.length)
+                return -1;
+            const m = { A: "up", B: "down", C: "right", D: "left", H: "home", F: "end" };
+            if (m[s[i + 2]])
+                keys.push({ k: m[s[i + 2]] });
+            return i + 3;
+        }
+        if (n === "\x1b") {
+            // ESC ESC [A: Option+Up in terminals that send Meta as an ESC prefix. Wait only while it can still be that;
+            // anything else is an Escape key, and the second ESC starts its own sequence.
+            const rest = s.slice(i, i + 4);
+            if (rest === "\x1b\x1b[A") {
+                keys.push({ k: "altup" });
+                return i + 4;
+            }
+            if ("\x1b\x1b[A".startsWith(rest))
+                return -1;
+            keys.push({ k: "escape" });
+            return i + 1;
+        }
+        if (n === "\r")
+            keys.push({ k: "newline" }); // Alt+Enter
+        else if (n === "\x7f")
+            keys.push({ k: "delword" });
+        else if (n === "b")
+            keys.push({ k: "wordleft" });
+        else if (n === "f")
+            keys.push({ k: "wordright" });
+        return i + 2;
+    }
+}
+/**
+ * Terminals without bracketed paste deliver a paste as one chunk with Enter keys followed by more
+ * input. Typed Enter is always the last key of its chunk, so Enters followed by anything are newlines.
+ * This is structural (no timing) and fails safe: it never submits.
+ */
+function unbracketed(keys) {
+    const firstEnter = keys.findIndex((k) => k.k === "enter");
+    if (firstEnter < 0 || firstEnter === keys.length - 1)
+        return keys;
+    return keys.map((k) => (k.k === "enter" ? { k: "newline" } : k));
+}
+/**
+ * Shell script for the exit watchdog. After `delay` seconds, if the SAME process (same start time, so a recycled pid is
+ * never touched) is still alive, kill it and best-effort restore its terminal (raw mode, bracketed paste) for when the
+ * terminal starts reading again.
+ *
+ * Platform assumptions (all fail safe: if one does not hold, the watchdog does nothing rather than killing something):
+ * POSIX `sh`, `ps -o lstart=`/`-o tty=` (macOS, Linux procps; busybox `ps` lacks lstart, so it stays inert there), and
+ * `stty`. It is never armed on Windows.
+ */
+export function watchdogScript(pid, opts = {}) {
+    const start = opts.expectedStart !== undefined ? `S='${opts.expectedStart.replace(/'/g, "")}'` : `S=$(ps -o lstart= -p ${pid} 2>/dev/null)`;
+    return [
+        start,
+        `sleep ${opts.delay ?? 2}`,
+        `[ -n "$S" ] && [ "$(ps -o lstart= -p ${pid} 2>/dev/null)" = "$S" ] || exit 0`,
+        `T=$(ps -o tty= -p ${pid} 2>/dev/null | tr -d ' ')`,
+        `kill -9 ${pid} 2>/dev/null`,
+        `case "$T" in ""|"?"|"??") exit 0;; esac`,
+        `printf '\\033[?2004l\\033[?1004l' > "/dev/$T"`, // bracketed paste and focus reports off
+        `stty sane < "/dev/$T"`,
+    ].join("\n");
+}
+export function armWatchdog(pid) {
+    if (process.platform === "win32")
+        return false;
+    try {
+        spawn("sh", ["-c", watchdogScript(pid)], { detached: true, stdio: "ignore" }).unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/jobs.js

@@ -0,0 +1,262 @@
+import { closeSync, constants, existsSync, mkdtempSync, openSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { isAbsolute, join, sep } from "node:path";
+import { MAX_BYTES, ToolError } from "./fileio.js";
+import { HeadTail, condenseOutput, keepEnds, stripEscapes } from "./output.js";
+import { killTreeOf, spawnShell, untrackChild } from "./proc.js";
+// ---------------------------------------------------------------- output folder
+const PREFIX = "oakode-out-";
+let dir;
+/** This process's output folder (created on first use, owner-only: logs can hold secrets; the pid marks it in use). */
+export function outputDir() {
+    if (!dir || !existsSync(dir))
+        dir = mkdtempSync(join(tmpdir(), `${PREFIX}${process.pid}-`));
+    return dir;
+}
+/** Creates a new file there: never an existing one, never through a symlink. */
+const CREATE = constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | (constants.O_NOFOLLOW ?? 0);
+export function openOutput(name) {
+    const path = join(outputDir(), name);
+    return { path, fd: openSync(path, CREATE, 0o600) };
+}
+export function saveOutput(name, text) {
+    const { path, fd } = openOutput(name);
+    try {
+        writeFileSync(fd, text);
+    }
+    finally {
+        closeSync(fd);
+    }
+    return path;
+}
+/** The real path when `p` is a file in this process's output folder, else undefined (read and grep may open those). */
+export function outputFile(p) {
+    if (!dir || typeof p !== "string" || !isAbsolute(p))
+        return undefined;
+    try {
+        const real = realpathSync(p);
+        return real.startsWith(realpathSync(dir) + sep) ? real : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** At exit. Folders left by a crash are removed by the next start once they are a day old. */
+export function removeOutput() {
+    try {
+        if (dir)
+            rmSync(dir, { recursive: true, force: true });
+    }
+    catch { } // Windows: a log still open by a closing job; the next start's sweep removes it
+    dir = undefined;
+}
+const alive = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === "EPERM";
+    }
+};
+export function sweepOldOutput(maxAgeMs = 24 * 3600_000) {
+    try {
+        for (const n of readdirSync(tmpdir())) {
+            const m = new RegExp(`^${PREFIX}(\\d+)-`).exec(n);
+            if (!m || alive(Number(m[1])))
+                continue; // a running OAKODE's folder is never touched
+            const p = join(tmpdir(), n);
+            try {
+                if (Date.now() - statSync(p).mtimeMs > maxAgeMs)
+                    rmSync(p, { recursive: true, force: true });
+            }
+            catch { }
+        }
+    }
+    catch { }
+}
+// ---------------------------------------------------------------- jobs
+export const MAX_JOBS = 8;
+const LOG_CAP = 50 * 1024 * 1024;
+export class Job {
+    id;
+    command;
+    started = Date.now();
+    /** "exit code 0", "signal SIGINT", "failed to start: …"; undefined while running. */
+    ended;
+    /** Its output pipes closed: nothing it started is still holding them (a shell can end before what it put in the background). */
+    closed = false;
+    log;
+    child;
+    pending = new HeadTail(256 * 1024, 768 * 1024);
+    fd;
+    logged = 0;
+    listeners = new Set();
+    constructor(id, command, cwd) {
+        this.id = id;
+        this.command = command;
+        const out = openOutput(`job-${id}.log`);
+        this.log = out.path;
+        this.fd = out.fd;
+        const child = (this.child = spawnShell(command, cwd));
+        const take = (b) => {
+            this.pending.push(b);
+            if (this.fd !== undefined && this.logged < LOG_CAP) {
+                try {
+                    writeSync(this.fd, this.logged + b.length > LOG_CAP ? b.subarray(0, LOG_CAP - this.logged) : b);
+                    this.logged += b.length;
+                    if (this.logged >= LOG_CAP)
+                        writeSync(this.fd, "\n[log stopped at 50 MB]\n");
+                }
+                catch {
+                    this.closeLog(); // a full disk stops the log, not OAKODE
+                }
+            }
+            this.emit(b.toString());
+        };
+        child.stdout.on("data", take);
+        child.stderr.on("data", take);
+        const end = (why) => {
+            if (this.ended !== undefined)
+                return;
+            this.ended = why;
+            this.emit("");
+        };
+        // the shell's exit ends the job; what it left running in the background is stopped with it at OAKODE's exit
+        child.on("exit", (code, sig) => setTimeout(() => end(code !== null ? `exit code ${code}` : `signal ${sig}`), 250));
+        child.on("error", (e) => end(`failed to start: ${e.message}`));
+        child.on("close", (code, sig) => {
+            end(code !== null ? `exit code ${code}` : `signal ${sig}`);
+            this.closed = true;
+            untrackChild(child);
+            this.closeLog();
+            this.emit("");
+        });
+    }
+    closeLog() {
+        try {
+            if (this.fd !== undefined)
+                closeSync(this.fd);
+        }
+        catch { }
+        this.fd = undefined;
+    }
+    get running() {
+        return this.ended === undefined;
+    }
+    /** Something of it still runs: the command, or processes it left in the background. */
+    get alive() {
+        return !this.closed && !this.ended?.startsWith("failed to start");
+    }
+    emit(chunk) {
+        for (const l of this.listeners)
+            l(chunk);
+    }
+    /**
+     * Waits up to `ms` until the job ends or its new output matches `until`. `onOutput` sees the output as it arrives.
+     * An abort stops the wait, never the job.
+     */
+    wait(ms, until, signal, onOutput) {
+        return new Promise((resolve) => {
+            // `until` sees whole lines, each cut to 2 KB: a model's regex cannot stall OAKODE on a huge line, and each
+            // chunk is checked once, not the whole buffer again
+            let carry = "";
+            const hit = (text) => !!until && text.split("\n").some((l) => until.test(stripEscapes(l.slice(0, 2048))));
+            const fresh = (chunk) => {
+                const lines = (carry + chunk).split("\n");
+                carry = (lines.pop() ?? "").slice(-2048);
+                return hit(lines.join("\n")) || hit(carry);
+            };
+            const check = (matched = false) => (!this.running ? "ended" : matched ? "matched" : undefined);
+            const first = check(hit(this.pending.text()));
+            if (first)
+                return resolve(first);
+            if (signal.aborted)
+                return resolve("stopped");
+            const done = (r) => {
+                clearTimeout(timer);
+                this.listeners.delete(listener);
+                signal.removeEventListener("abort", onAbort);
+                resolve(r);
+            };
+            const listener = (chunk) => {
+                if (chunk)
+                    onOutput?.(stripEscapes(chunk));
+                const r = check(!!chunk && fresh(chunk));
+                if (r)
+                    done(r);
+            };
+            const onAbort = () => done("stopped");
+            const timer = setTimeout(() => done("waited"), ms);
+            this.listeners.add(listener);
+            signal.addEventListener("abort", onAbort, { once: true });
+        });
+    }
+    /** The output since the last call, cleaned and shortened for the model. */
+    take() {
+        const raw = this.pending.text();
+        const omitted = this.pending.omitted;
+        this.pending = new HeadTail(256 * 1024, 768 * 1024);
+        const { text, truncated } = keepEnds(condenseOutput(raw).text, MAX_BYTES);
+        return (truncated || omitted ? `[output shortened; the full log is ${this.log} (read or grep can open it)]\n` : "") + text;
+    }
+    /** interrupt: Ctrl+C (SIGINT) to the job's process group; kill: SIGTERM, then SIGKILL. On Windows both are a kill. */
+    async stop(how) {
+        if (!this.alive)
+            return;
+        const gone = (ms) => new Promise((r) => {
+            if (!this.alive)
+                return r();
+            const t = setTimeout(() => (this.listeners.delete(l), r()), ms);
+            const l = () => !this.alive && (clearTimeout(t), this.listeners.delete(l), r());
+            this.listeners.add(l);
+        });
+        if (how === "interrupt" && process.platform !== "win32") {
+            killTreeOf(this.child, "SIGINT");
+            await gone(5000);
+            return;
+        }
+        killTreeOf(this.child, "SIGTERM");
+        await gone(2000);
+        if (this.alive)
+            killTreeOf(this.child, "SIGKILL"), await gone(2000);
+    }
+}
+const jobs = new Map();
+let seq = 0;
+export const allJobs = () => [...jobs.values()];
+/** Jobs with something still running (also a shell that ended but left processes in the background). */
+export const runningJobs = () => allJobs().filter((j) => j.alive);
+export const jobById = (id) => (typeof id === "number" ? jobs.get(id) : undefined);
+export function startJob(command, cwd) {
+    const live = runningJobs();
+    if (live.length >= MAX_JOBS) {
+        throw new ToolError(`${MAX_JOBS} background jobs are already running (${live.map((j) => `${j.id}: ${j.command.slice(0, 40)}`).join("; ")}). Stop one with job {id, action: "kill"} first.`);
+    }
+    const job = new Job(++seq, command, cwd);
+    jobs.set(job.id, job);
+    // keep the table small: forget the oldest finished jobs (their logs stay until exit)
+    const done = allJobs().filter((j) => !j.alive);
+    for (const j of done.slice(0, Math.max(0, done.length - 16)))
+        jobs.delete(j.id);
+    return job;
+}
+const secs = (ms) => (ms < 60_000 ? `${Math.round(ms / 1000)} s` : `${Math.floor(ms / 60_000)} min ${Math.round((ms % 60_000) / 1000)} s`);
+/** One job's state and new output, as a tool result. */
+export function report(job, outcome) {
+    const out = job.take().replace(/\s+$/, "");
+    const head = `[job ${job.id} · ${job.running ? `running for ${secs(Date.now() - job.started)}` : `ended (${job.ended}) after ${secs(Date.now() - job.started)}`} · ${job.command.split("\n")[0].slice(0, 80)}]`;
+    const why = outcome === "matched" ? " (its output matched `until`)" : outcome === "stopped" ? " (stopped waiting at your request; the job itself keeps running)" : "";
+    const next = job.running
+        ? `[still running${why}: poll with job {id: ${job.id}}, stop with action "interrupt" or "kill"]`
+        : job.alive
+            ? `[processes it started in the background are still running and holding its output; job {id: ${job.id}, action: "kill"} stops them]`
+            : "";
+    return [head, out || "(no new output)", next].filter(Boolean).join("\n");
+}
+export function stopAllJobs() {
+    for (const j of runningJobs())
+        void j.stop("kill");
+}
+/** "running", "ended (exit code 0)", or that plus processes it left in the background. */
+export const stateOf = (j) => (j.running ? "running" : `ended (${j.ended})${j.alive ? ", background processes still running" : ""}`);