@prestack/thread 0.1.3 → 0.1.5

package/dist/integrations/cli.js

@@ -0,0 +1,440 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import { tmpdir, uptime } from 'node:os';
+import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { allowedNodeEnvironmentFlags, env, execPath, kill, pid, stderr, stdout } from 'node:process';
+import { fileURLToPath } from 'node:url';
+import { CHANNEL, FOLDER, across, attached, createFileSync, existsSync, here, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from '../integrations/disk.js';
+import { VAULT_DIR } from '../integrations/vault.js';
+import { CALL_PREFIX, LOCKFILES, PACKAGER, REACH, managerOf, programOf, unlisted } from '../integrations/target.js';
+import { CLI } from '../core/invoked.js';
+import { valuesIn } from '../core/rows.js';
+import { THING } from '../core/scope.js';
+import { findTree, inTree } from '../core/tree.js';
+const answered = (went) => ({
+    there: went.error === undefined,
+    ok: went.status === 0,
+    code: went.status ?? 1,
+    out: String(went.stdout ?? ''),
+    err: String(went.stderr ?? ''),
+    killed: went.signal ?? null,
+    why: went.error === undefined ? '' : went.error.message,
+});
+const standing = (at) => (at === undefined || across(at) ? undefined : at);
+export function starts(program, words, how = {}) {
+    let went;
+    try {
+        went = spawnSync(program, [...words], {
+            cwd: standing(how.at),
+            encoding: 'utf8',
+            shell: false,
+            stdio: how.shows === true
+                ? [how.hears === undefined ? 'inherit' : 'pipe', 'inherit', 'inherit']
+                : how.shows === 'errors'
+                    ? [how.hears === undefined ? 'ignore' : 'pipe', 'pipe', 'inherit']
+                    : 'pipe',
+            input: how.hears,
+            env: how.holds,
+            ...(how.within === undefined ? {} : { timeout: how.within, killSignal: 'SIGKILL' }),
+        });
+    }
+    catch (thrown) {
+        return nowhere(thrown instanceof Error ? thrown.message : String(thrown));
+    }
+    const ran = answered(went);
+    if (how.shows === 'tee') {
+        stdout.write(ran.out);
+        stderr.write(ran.err);
+    }
+    return ran;
+}
+export function started(program, words, how = {}) {
+    return new Promise((keep) => {
+        let child;
+        try {
+            child = spawn(program, [...words], { cwd: standing(how.at), shell: false, env: how.holds });
+        }
+        catch (thrown) {
+            keep(nowhere(thrown instanceof Error ? thrown.message : String(thrown)));
+            return;
+        }
+        let out = '';
+        let err = '';
+        let why = '';
+        const clock = how.within === undefined ? undefined : setTimeout(() => child.kill('SIGKILL'), how.within);
+        child.stdout.on('data', (chunk) => (out += chunk.toString()));
+        child.stderr.on('data', (chunk) => (err += chunk.toString()));
+        child.on('error', (error) => (why = error.message));
+        child.on('close', (code, killed) => {
+            if (clock !== undefined)
+                clearTimeout(clock);
+            keep({ there: why === '', ok: why === '' && code === 0, code: code ?? 1, out, err, killed, why });
+        });
+        child.stdin.end(how.hears);
+    });
+}
+export function handed(at, program, passed, shows = true, within, hears) {
+    return starts(program, passed, { at, shows, ...(within === undefined ? {} : { within }), ...(hears === undefined ? {} : { hears }) });
+}
+const HOLDING = 'THREAD_RUNNING';
+const CLAIMED = 'running.';
+const CLAIM = '.json';
+const STARTING = 10_000;
+let claimed = '';
+const claimAt = (dir, one) => join(dir, CLAIMED + String(one) + CLAIM);
+const generations = (dir) => existsSync(dir)
+    ? readdirSync(dir)
+        .filter((one) => one.startsWith(CLAIMED) && one.endsWith(CLAIM))
+        .map((one) => Number(one.slice(CLAIMED.length, one.length - CLAIM.length)))
+        .filter((one) => Number.isInteger(one) && one >= 0)
+    : [];
+const living = (one) => {
+    try {
+        kill(one, 0);
+        return true;
+    }
+    catch (thrown) {
+        return thrown.code === 'EPERM';
+    }
+};
+function holding(at) {
+    try {
+        const by = JSON.parse(readFileSync(at, 'utf8'));
+        return by.since > Date.now() - uptime() * 1000 && living(by.pid) ? { by } : {};
+    }
+    catch {
+        try {
+            return Date.now() - statSync(at).mtimeMs < STARTING ? { by: { pid: 0, runs: '', since: Date.now() } } : {};
+        }
+        catch {
+            return {};
+        }
+    }
+}
+export function releases() {
+    const at = claimed === '' ? env[HOLDING] : claimed;
+    if (at !== undefined)
+        rmSync(at, { force: true });
+    claimed = '';
+    Reflect.deleteProperty(env, HOLDING);
+}
+export function claims(root, runs) {
+    if (attached())
+        return {};
+    const dir = join(root, VAULT_DIR);
+    for (let tries = 0; tries < 5; tries += 1) {
+        const taken = generations(dir);
+        const top = Math.max(-1, ...taken);
+        const held = top < 0 ? {} : holding(claimAt(dir, top));
+        if (held.by !== undefined)
+            return env[HOLDING] === claimAt(dir, top) ? {} : held;
+        const mine = claimAt(dir, top + 1);
+        if (!createFileSync(mine, JSON.stringify({ pid, runs, since: Date.now() })))
+            continue;
+        claimed = mine;
+        env[HOLDING] = mine;
+        for (const one of taken)
+            rmSync(claimAt(dir, one), { force: true });
+        process.on('exit', releases);
+        return {};
+    }
+    return { by: { pid: 0, runs: '', since: Date.now() } };
+}
+export function programFor(name, at) {
+    const found = programOf(name, at, existsSync);
+    if (found === undefined)
+        throw new Error(unlisted(name));
+    return found;
+}
+export const SIGNING = 'THREAD_RECEIPTS_KEY';
+const SIGNED_AT = 'thread-receipts.key';
+let signed = '';
+export function signing() {
+    if (signed !== '')
+        return signed;
+    const given = env[SIGNING];
+    if (given !== undefined && given !== '') {
+        signed = given;
+        return signed;
+    }
+    if (attached()) {
+        throw new Error('this answers for a folder on another machine and was handed no key to seal receipts with, so it issues none. ' +
+            'The server that started it hands one over in ' + SIGNING + '.');
+    }
+    const at = join(tmpdir(), SIGNED_AT);
+    if (!existsSync(at))
+        createFileSync(at, randomBytes(32).toString('hex'));
+    signed = readFileSync(at, 'utf8').trim();
+    return signed;
+}
+const OWN = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
+const GUARDS = ['--permission', '--experimental-permission'];
+const HUSHES = '--disable-warning';
+const swapped = (path) => [...path].map((one) => (one === one.toUpperCase() ? one.toLowerCase() : one.toUpperCase())).join('');
+let unguarded = false;
+function guarded() {
+    const before = env.NODE_OPTIONS ?? '';
+    const on = GUARDS.find((one) => allowedNodeEnvironmentFlags.has(one));
+    if (on === undefined) {
+        if (!unguarded) {
+            stderr.write('thread: this node has no permission model, so a thread command started for a folder runs unguarded: nothing ' +
+                'here stops it reading that folder straight off this disk, and on one machine that would go unnoticed.\n');
+            unguarded = true;
+        }
+        return before;
+    }
+    const kept = [...new Set([tmpdir(), realpathSync(tmpdir())])];
+    const allowed = (flag, paths) => paths.map((one) => flag + '="' + one + '"');
+    const quiet = allowedNodeEnvironmentFlags.has(HUSHES) ? [HUSHES + '=SecurityWarning'] : [];
+    return [before, on, ...allowed('--allow-fs-read', [OWN, swapped(OWN), ...kept]), ...allowed('--allow-fs-write', kept), '--allow-child-process', '--allow-worker', ...quiet]
+        .filter((one) => one !== '')
+        .join(' ');
+}
+const SERVED = 'thread-serve';
+const TICK = 2;
+const MARGIN = 5_000;
+const SAYING = '-saying';
+const ORDER = '-order';
+const ANSWER = '-answer';
+const serving = new Map();
+const still = (one, asks) => ({ there: true, ok: false, code: -1, out: '', err: '', killed: null, why: '', of: one.of, asks });
+const nowhere = (why) => ({ there: false, ok: false, code: 1, out: '', err: '', killed: null, why });
+const lost = (of) => ({ there: true, ok: false, code: -1, out: '', err: '', killed: null, why: '', of, lost: of });
+const told = (one) => JSON.stringify([one.order, one.at, one.said ?? null, one.mode ?? null, one.words ?? null]);
+const plainly = (one) => one.order + ' ' + (one.at === '' ? '.' : one.at);
+const outside = (root, at) => {
+    const step = relative(root, at);
+    return step.startsWith('..') ? true : isAbsolute(step);
+};
+function hand(one, held) {
+    const settle = one.waiting.shift();
+    if (settle === undefined)
+        one.parked.push(held);
+    else
+        settle(held);
+}
+function reply(dir, name, held) {
+    writeFileSync(join(dir, name + SAYING), JSON.stringify(held), 'utf8');
+    renameSync(join(dir, name + SAYING), join(dir, name + ANSWER));
+}
+function watching(one) {
+    one.watch = setInterval(() => {
+        let names = [];
+        try {
+            names = readdirSync(one.dir);
+        }
+        catch {
+            return;
+        }
+        for (const name of names) {
+            if (!name.endsWith(ORDER))
+                continue;
+            const file = join(one.dir, name);
+            let said = '';
+            try {
+                said = readFileSync(file, 'utf8');
+            }
+            catch {
+                continue;
+            }
+            rmSync(file, { force: true });
+            const order = JSON.parse(said);
+            const short = name.slice(0, name.length - ORDER.length);
+            if (outside(one.root, order.at)) {
+                reply(one.dir, short, {
+                    answered: 'refused',
+                    because: order.at + ' is outside the folder this command was pointed at, and nothing outside it is ever asked of the machine answering.',
+                });
+                continue;
+            }
+            const asked = { ...order, at: relative(one.root, order.at) };
+            const due = one.replaying.shift();
+            if (due !== undefined) {
+                if (told(due.order) === told(asked)) {
+                    reply(one.dir, short, due.answered);
+                    continue;
+                }
+                one.replaying = [];
+                one.err +=
+                    'thread: this command was carried on here by running it again and handing it the answers it was given before, ' +
+                        'and this time it asked for ' + plainly(asked) + ' where before it asked for ' + plainly(due.order) + '. A command ' +
+                        'that does not ask the same things twice cannot be carried on from its answers, so it was stopped. Run it again.\n';
+                one.stop?.();
+                continue;
+            }
+            one.pending = short;
+            hand(one, still(one, [asked]));
+        }
+    }, TICK);
+}
+function next(one, within) {
+    const held = one.parked.shift();
+    if (held !== undefined)
+        return Promise.resolve(held);
+    return new Promise((settle) => {
+        const done = { is: false };
+        const mine = (ran) => {
+            if (done.is)
+                return;
+            done.is = true;
+            settle(ran);
+        };
+        one.waiting.push(mine);
+        if (within === undefined)
+            return;
+        setTimeout(() => {
+            if (done.is)
+                return;
+            done.is = true;
+            one.waiting = one.waiting.filter((each) => each !== mine);
+            settle(still(one, []));
+        }, Math.max(1_000, within - MARGIN));
+    });
+}
+function begun(word, args, root, hears, called, recording = []) {
+    const of = called ?? randomBytes(6).toString('hex');
+    const dir = join(tmpdir(), SERVED, randomBytes(6).toString('hex'));
+    writeFileSync(join(dir, 'channel'), '', 'utf8');
+    const one = { of, dir, root, out: '', err: '', why: '', pending: '', waiting: [], parked: [], replaying: [...recording], handed: recording.length };
+    const child = spawn(execPath, [...CLI, word, ...args], {
+        cwd: OWN,
+        shell: false,
+        env: { ...env, [CHANNEL]: dir, [FOLDER]: root, [SIGNING]: signing(), NODE_OPTIONS: guarded() },
+    });
+    one.stop = () => child.kill();
+    child.stdout.on('data', (chunk) => (one.out += chunk.toString()));
+    child.stderr.on('data', (chunk) => (one.err += chunk.toString()));
+    child.on('error', (thrown) => (one.why = thrown.message));
+    child.on('close', (code, killed) => {
+        if (one.watch !== undefined)
+            clearInterval(one.watch);
+        serving.delete(of);
+        rmSync(dir, { recursive: true, force: true });
+        hand(one, { there: one.why === '', ok: one.why === '' && code === 0, code: code ?? 1, out: one.out, err: one.err, killed, why: one.why });
+    });
+    child.stdin.end(hears ?? '');
+    watching(one);
+    serving.set(of, one);
+    return one;
+}
+const UNPLACED = ' against, so it did not start. A command on this server runs against the folder the person gave and nowhere else.';
+function counted(one, held) {
+    const asks = held.asks ?? [];
+    if (asks.length === 0)
+        return held;
+    one.handed += asks.length;
+    one.last = held;
+    return held;
+}
+async function served(word, args, within, how) {
+    const of = how?.of;
+    if (of !== undefined) {
+        const one = serving.get(of);
+        if (one === undefined) {
+            const recording = how?.recording;
+            if (recording === undefined)
+                return lost(of);
+            const root = how?.at ?? '';
+            if (root === '')
+                return nowhere('nothing said which folder to run thread ' + word + UNPLACED);
+            const again = begun(word, args, root, how?.hears, of, recording);
+            return counted(again, await next(again, within));
+        }
+        const answering = how?.answering;
+        if (answering !== undefined && answering < one.handed && one.last !== undefined)
+            return one.last;
+        const given = (how?.answered ?? [])[0];
+        if (one.pending !== '' && given !== undefined) {
+            reply(one.dir, one.pending, given);
+            one.pending = '';
+        }
+        return counted(one, await next(one, within));
+    }
+    const root = how?.at ?? '';
+    if (root === '')
+        return nowhere('nothing said which folder to run thread ' + word + UNPLACED);
+    const fresh = begun(word, args, root, how?.hears);
+    return counted(fresh, await next(fresh, within));
+}
+export function running(name, subcommands, at) {
+    const out = {};
+    for (const [key, word] of Object.entries(subcommands)) {
+        out[key] =
+            name === THING
+                ? async (args, shows, within, how) => served(word, args, within, how)
+                : async (args, shows, within, how) => {
+                    const where = how?.at ?? at;
+                    const program = programFor(name, where);
+                    if ((shows ?? false) !== false)
+                        return handed(where, program, [word, ...args], shows ?? false, within, how?.hears);
+                    return await started(program, [word, ...args], { at: where, ...(within === undefined ? {} : { within }), ...(how?.hears === undefined ? {} : { hears: how.hears }) });
+                };
+    }
+    return out;
+}
+function sheet(at) {
+    const path = inTree(findTree(at), 'targets.ts');
+    return existsSync(path) ? valuesIn(readFileSync(path, 'utf8')) : {};
+}
+export function expansions(at) {
+    const held = sheet(at);
+    return (held.TARGETS ?? [])
+        .filter((one) => one.id.startsWith(REACH.cli))
+        .map((one) => ({ program: one.id.slice(REACH.cli.length), target: one, calls: (held.CALLS ?? []).filter((each) => each.of === one.id) }));
+}
+export function calls(target, at) {
+    const named = {};
+    for (const one of sheet(at).CALLS ?? [])
+        if (one.of === target)
+            named[one.id.replace(CALL_PREFIX, '')] = one.path;
+    return running(target.replace(REACH.cli, ''), named, at);
+}
+export { LOCKFILES };
+export const manager = (into) => managerOf(into, existsSync);
+const ADDS = { pnpm: 'add', yarn: 'add', bun: 'add', npm: 'install' };
+export function adding(into) {
+    const tool = manager(into);
+    const verb = ADDS[tool];
+    if (verb === undefined) {
+        throw new Error(tool + ' is what the lockfile in ' + into + ' picks, and nothing here knows the word it adds a package with.');
+    }
+    return [tool, verb];
+}
+export function needing(into, needs) {
+    const manifest = join(into, 'package.json');
+    const was = readFileSync(manifest, 'utf8');
+    const parsed = JSON.parse(was);
+    const named = { ...parsed.devDependencies, ...parsed.dependencies };
+    const added = Object.keys(needs).filter((one) => named[one] === undefined).sort();
+    if (added.length === 0)
+        return [];
+    const dependencies = { ...parsed.dependencies };
+    for (const one of added)
+        dependencies[one] = needs[one] ?? 'latest';
+    writeFileSync(manifest, `${JSON.stringify({ ...parsed, dependencies }, null, 2)}\n`, 'utf8');
+    try {
+        installing(into);
+    }
+    catch (thrown) {
+        writeFileSync(manifest, was, 'utf8');
+        throw new Error(`${added.join(', ')} could not be fetched — ${thrown instanceof Error ? thrown.message : String(thrown)} ` +
+            'package.json is as it was, so nothing here names a package that is not on disk.');
+    }
+    return added;
+}
+export function installing(at) {
+    if (attached())
+        return here().fetch(at);
+    const tool = manager(at);
+    const ran = starts(programFor(PACKAGER, at), ['install'], { at });
+    const said = (ran.out + ran.err).trim();
+    if (!ran.there) {
+        throw new Error(tool + ' is what the lockfile in ' + at + ' picks, and it is not on this machine, so nothing here can fetch ' +
+            'what that tree depends on until that changes.');
+    }
+    if (!ran.ok) {
+        throw new Error(tool + ' could not install what ' + at + ' depends on. It said: ' +
+            (said === '' ? 'nothing, and exited ' + String(ran.code) : said));
+    }
+    return said;
+}