oakode 0.0.0-stage → 0.5.0

package/dist/runners.js

@@ -0,0 +1,264 @@
+/**
+ * Runner commands (`npm test`, `make`, `cargo test`, `./run.sh` …) do what command-defining files say: package.json's
+ * scripts, a Makefile, a build file, the script itself. A saved approval of such a command is tied to those files as
+ * they were when it was approved; when one changes, the command asks again (see Permissions.runnerChanged).
+ *
+ * A deliberate trust/UX tradeoff, not a sandbox: ordinary source and test edits never invalidate an approval, so the
+ * edit-test-fix loop keeps running, even though `npm test` runs whatever the edited tests do.
+ */
+import { createHash } from "node:crypto";
+import { readFileSync, statSync } from "node:fs";
+import { isAbsolute, join, normalize, relative } from "node:path";
+// Executable tool configs that npm scripts run (lint, build, format); not test configs, which change in the test loop
+const JS = ["js", "cjs", "mjs", "ts", "mts", "cts"];
+const NODE_CONFIGS = ["eslint.config", "prettier.config", "vite.config", "webpack.config", "rollup.config", "tsup.config", "babel.config", "postcss.config"].flatMap((b) => JS.map((e) => `${b}.${e}`));
+const NODE = ["package.json", ".npmrc", ".yarnrc", ".yarnrc.yml", "pnpm-workspace.yaml", "bunfig.toml", ".eslintrc.js", ".eslintrc.cjs", ".prettierrc.js", ".prettierrc.cjs", ".babelrc.js", ...NODE_CONFIGS];
+const PYTHON = ["pyproject.toml", "setup.cfg", "setup.py", "tox.ini", "pytest.ini", "noxfile.py", "Pipfile"];
+const GRADLE = ["build.gradle", "build.gradle.kts", "settings.gradle", "settings.gradle.kts", "gradle.properties", "gradle/wrapper/gradle-wrapper.properties"];
+const MAVEN = ["pom.xml", ".mvn/maven.config", ".mvn/extensions.xml", ".mvn/wrapper/maven-wrapper.properties"];
+const MAKE = ["Makefile", "makefile", "GNUmakefile"];
+/** Program name (lower case) → the files, relative to the directory it runs in or a parent, that define what it does. */
+const RUNNERS = {
+    npm: NODE, npx: NODE, pnpm: NODE, pnpx: NODE, yarn: NODE, bun: NODE, bunx: NODE, turbo: ["turbo.json", ...NODE], nx: ["nx.json", ...NODE],
+    deno: ["deno.json", "deno.jsonc"],
+    make: MAKE, gmake: MAKE,
+    cargo: ["Cargo.toml", "build.rs", ".cargo/config.toml", ".cargo/config", "rust-toolchain.toml", "rust-toolchain"],
+    go: ["go.mod", "go.work"],
+    gradle: GRADLE, gradlew: GRADLE, mvn: MAVEN, mvnw: MAVEN,
+    just: ["justfile", "Justfile", ".justfile"],
+    task: ["Taskfile.yml", "Taskfile.yaml", "taskfile.yml", "taskfile.yaml"],
+    rake: ["Rakefile", "Gemfile"], bundle: ["Gemfile"],
+    pytest: PYTHON, tox: PYTHON, nox: PYTHON, poetry: PYTHON, uv: PYTHON, pipenv: PYTHON, hatch: PYTHON, pdm: PYTHON,
+    composer: ["composer.json"],
+};
+const NODE_PMS = new Set(["npm", "pnpm", "yarn", "bun"]);
+const SHELLS = new Set(["sh", "bash", "zsh", "dash", "ksh", "fish"]);
+const PYTHONS = /^python(\d+(\.\d+)?)?$/;
+/** Programs that run the command after them, with the options of theirs that take a value. */
+const WRAPPERS = { env: ["-u", "-C", "--unset", "--chdir"], time: [], nice: ["-n"], nohup: [], command: [], exec: ["-a"], timeout: ["-s", "-k", "--signal", "--kill-after"], sudo: ["-u", "-g"], corepack: [], xargs: [] };
+/** Splits a command line into simple commands' words (quotes respected; good enough to find program names). */
+function segments(line) {
+    const out = [[]];
+    let word = "", quote = "", has = false;
+    const end = () => {
+        if (has)
+            out.at(-1).push(word);
+        word = "";
+        has = false;
+    };
+    for (let i = 0; i < line.length; i++) {
+        const c = line[i];
+        if (quote) {
+            if (c === quote)
+                quote = "";
+            else if (c === "\\" && quote === '"' && i + 1 < line.length)
+                word += line[++i];
+            else
+                word += c;
+            continue;
+        }
+        if (c === "'" || c === '"')
+            (quote = c), (has = true);
+        else if (c === "\\" && i + 1 < line.length)
+            (word += line[++i]), (has = true);
+        else if (/\s/.test(c) && c !== "\n")
+            end();
+        else if ("\n;|&()`".includes(c)) {
+            end();
+            if (out.at(-1).length)
+                out.push([]);
+        }
+        else
+            (word += c), (has = true);
+    }
+    end();
+    return out.filter((s) => s.length);
+}
+/** Drops wrapper programs (`timeout 120`, `nice -n 5`, `env -i A=1`, `bundle exec`, `corepack`) and assignments. */
+function unwrap(words) {
+    for (;;) {
+        if (words.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(words[0]))
+            words = words.slice(1);
+        else if (words.length > 1 && words[0].toLowerCase() === "bundle" && words[1] === "exec")
+            words = words.slice(2);
+        else if (words.length && Object.hasOwn(WRAPPERS, words[0].toLowerCase())) {
+            const w = words[0].toLowerCase();
+            let i = 1;
+            while (i < words.length && words[i].startsWith("-"))
+                i += WRAPPERS[w].includes(words[i]) ? 2 : 1;
+            if (w === "timeout" && i < words.length)
+                i++; // the duration
+            words = words.slice(i);
+        }
+        else
+            return words;
+    }
+}
+/** The value of an option given as `--opt value` or `--opt=value`. */
+function opt(args, names) {
+    for (let i = 0; i < args.length; i++) {
+        for (const n of names) {
+            if (args[i] === n)
+                return args[i + 1];
+            if (n.startsWith("--") && args[i].startsWith(n + "="))
+                return args[i].slice(n.length + 1);
+        }
+    }
+    return undefined;
+}
+/** The package.json script an npm-style command runs (`npm test`, `npm run build`, `yarn lint`, `node --run x`). */
+function scriptName(pm, args) {
+    const rest = args.filter((a) => !a.startsWith("-"));
+    const [sub, name] = rest;
+    if (!sub)
+        return undefined;
+    if (["test", "t", "tst"].includes(sub))
+        return "test";
+    if (["start", "stop", "restart"].includes(sub))
+        return sub;
+    if (sub === "run" || sub === "run-script")
+        return name;
+    if (pm !== "npm" && !["install", "add", "remove", "exec", "dlx", "x", "create", "init", "why", "info"].includes(sub))
+        return sub; // `yarn lint`
+    return undefined;
+}
+function scriptsOf(cwd, dir) {
+    try {
+        const j = JSON.parse(readFileSync(join(cwd, dir, "package.json"), "utf8"));
+        return j && typeof j.scripts === "object" && j.scripts ? j.scripts : {};
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * The command-defining files of a command line, relative to the workspace, or [] when it runs no runner. `cd dir`
+ * moves later parts into that directory (outside the workspace nothing is followed). With `cwd`, the package.json
+ * scripts a command runs are looked into too (`"lint": "./scripts/lint.sh"`).
+ */
+export function runnerFiles(command, cwd, depth = 0, start = ".") {
+    const files = new Set();
+    let dir = start;
+    const inside = (d, to) => {
+        let p = to;
+        if (isAbsolute(to)) {
+            if (!cwd)
+                return undefined;
+            const r = relative(cwd, to);
+            if (r.startsWith("..") || isAbsolute(r))
+                return undefined;
+            p = r || ".";
+        }
+        else if (to.startsWith("~"))
+            return undefined;
+        else
+            p = join(d, to);
+        const n = normalize(p).replace(/\\/g, "/");
+        return n === ".." || n.startsWith("../") ? undefined : n;
+    };
+    const add = (d, f) => {
+        const p = d === undefined ? undefined : inside(d, f);
+        if (p)
+            files.add(p);
+    };
+    // a runner finds its files in the directory it runs in or the nearest parent that has them
+    const addUp = (d, list) => {
+        for (let x = d; x !== undefined; x = x === "." ? undefined : normalize(join(x, "..")).replace(/\\/g, "/"))
+            for (const f of list)
+                add(x, f);
+    };
+    for (const raw of segments(command)) {
+        const words = unwrap(raw);
+        if (!words.length)
+            continue;
+        const [prog, ...args] = words;
+        if (prog === "cd" || prog === "pushd") {
+            dir = args[0] && dir !== undefined ? inside(dir, args[0]) : undefined;
+            continue;
+        }
+        const base = prog.replace(/^.*[\\/]/, "").replace(/\.(cmd|bat|exe|ps1)$/i, "").toLowerCase();
+        const sub = (s) => {
+            if (s !== undefined && depth < 3 && dir !== undefined)
+                for (const f of runnerFiles(s, cwd, depth + 1, dir))
+                    files.add(f);
+        };
+        // a program run by path is its own definition (./run.sh, scripts/test, ./gradlew)
+        if (prog.includes("/") || prog.includes("\\"))
+            add(dir, prog);
+        if (RUNNERS[base]) {
+            // the directory it is pointed at (npm --prefix web, yarn --cwd web, pnpm -C web, make -C sub)
+            const to = RUNNERS[base].includes("package.json") ? opt(args, ["--prefix", "--cwd", "-C", "--dir"]) : base.endsWith("make") ? opt(args, ["-C", "--directory"]) : undefined;
+            const runDir = to !== undefined && dir !== undefined ? inside(dir, to) : dir;
+            addUp(runDir, RUNNERS[base]);
+            if (base.endsWith("make")) {
+                const mf = opt(args, ["-f", "--file", "--makefile"]);
+                if (mf)
+                    add(runDir, mf);
+            }
+            if (cwd && runDir !== undefined && NODE_PMS.has(base)) {
+                const name = scriptName(base, args);
+                const scripts = name ? scriptsOf(cwd, runDir) : {};
+                for (const n of name ? [`pre${name}`, name, `post${name}`] : [])
+                    if (typeof scripts[n] === "string" && depth < 3)
+                        for (const f of runnerFiles(scripts[n], cwd, depth + 1, runDir))
+                            files.add(f);
+            }
+        }
+        if (base === "node" && opt(args, ["--run"]) !== undefined) {
+            addUp(dir, NODE);
+            const scripts = cwd && dir !== undefined ? scriptsOf(cwd, dir) : {};
+            const n = opt(args, ["--run"]);
+            if (typeof scripts[n] === "string")
+                sub(scripts[n]);
+        }
+        // a shell: the string after -c (also -lc, -ec …), else the script file it runs
+        if (SHELLS.has(base)) {
+            const c = args.findIndex((a) => /^-[A-Za-z]*c[A-Za-z]*$/.test(a));
+            if (c >= 0)
+                sub(args[c + 1]);
+            else {
+                const script = args.find((a) => !a.startsWith("-"));
+                if (script)
+                    add(dir, script);
+            }
+        }
+        if (base === "cmd")
+            sub(args.slice(args.findIndex((a) => /^\/[ck]$/i.test(a)) + 1).join(" ") || undefined);
+        if (base === "powershell" || base === "pwsh") {
+            const c = args.findIndex((a) => /^-(c|command)$/i.test(a));
+            if (c >= 0)
+                sub(args.slice(c + 1).join(" "));
+            const f = opt(args, ["-File", "-file", "-f"]);
+            if (f)
+                add(dir, f);
+        }
+        // `python -m pytest` and friends read the Python project files; `python main.py` is ordinary source
+        if (PYTHONS.test(base) && args[0] === "-m" && RUNNERS[args[1]?.split(".")[0]?.toLowerCase()])
+            addUp(dir, PYTHON);
+    }
+    return [...files].sort();
+}
+const MAX_HASHED = 5 * 1024 * 1024;
+/** Each file's content hash ("" when absent), so a later change can be named. */
+export function runnerHashes(cwd, files) {
+    const out = {};
+    for (const f of files) {
+        try {
+            const p = join(cwd, f);
+            const st = statSync(p);
+            if (!st.isFile())
+                continue;
+            const h = createHash("sha256").update(st.size > MAX_HASHED ? `size:${st.size}:${st.mtimeMs}` : readFileSync(p));
+            out[f] = h.digest("hex").slice(0, 32);
+        }
+        catch {
+            out[f] = "";
+        }
+    }
+    return out;
+}
+/** The files whose state differs from the baseline (changed, added or removed). */
+export function changedFiles(base, now) {
+    const keys = new Set([...Object.keys(base), ...Object.keys(now)]);
+    return [...keys].filter((k) => (base[k] ?? "") !== (now[k] ?? "")).sort();
+}

package/dist/serial.js

@@ -0,0 +1,9 @@
+/** Runs async jobs one at a time, in call order. A job that fails does not block the ones after it. */
+export function serial() {
+    let tail = Promise.resolve();
+    return (job) => {
+        const p = tail.then(job, job);
+        tail = p.catch(() => { });
+        return p;
+    };
+}