@agentshouse/kit 0.2.1-ca0e1517cce79 → 0.2.1-ca1f38641026d

package/dist/relay.js

@@ -1,6 +1,11 @@
+import { setGlobalProxyFromEnv } from 'node:http';
+const PROXY = /^https?_proxy$/i;
+const LOOPBACK = ['127.0.0.1', 'localhost', '::1'];
 let selected;
+let restoreProxy;
 export function selectRelay(relay) {
     selected = relay === undefined || relay === '' ? null : relay;
+    proxyUnlessRelayed();
 }
 export function relayOrigin() {
     if (selected !== undefined)
@@ -8,6 +13,22 @@ export function relayOrigin() {
     const ambient = process.env.HOUSE_KIT_RELAY;
     return ambient === undefined || ambient === '' ? undefined : ambient;
 }
+function unlessRelayed() {
+    if (relayOrigin() === undefined)
+        return { ...process.env };
+    return Object.fromEntries(Object.entries(process.env).filter(([name]) => !PROXY.test(name)));
+}
+export function proxyUnlessRelayed() {
+    restoreProxy?.();
+    restoreProxy = setGlobalProxyFromEnv(unlessRelayed());
+}
+export function childEnvironment() {
+    const environment = unlessRelayed();
+    if (!Object.keys(environment).some((name) => PROXY.test(name)))
+        return environment;
+    const bypassed = [environment.NO_PROXY ?? environment.no_proxy, ...LOOPBACK].filter((entry) => entry !== undefined && entry !== '').join(',');
+    return { ...environment, NO_PROXY: bypassed, no_proxy: bypassed };
+}
 export function relayed(target) {
     const url = new URL(target);
     const relay = relayOrigin();

package/dist/resident.js

@@ -10,16 +10,16 @@ import { house } from './api.js';
 import { received } from './bridge.js';
 import { CONVERSATION_METHODS, Conversations } from './conversations.js';
 import { LocalCopies } from './copies.js';
-import { restart } from './end.js';
-import { agentBase, enrolled, forgetRestart, kitHome, ownerLock, ownerSocket, restartAsked } from './home.js';
+import { restart, unknownMethod } from './end.js';
+import { agentBase, enrolled, forgetRestart, kitHome, ownerLock, ownerSocket, readEnrolment, restartAsked } from './home.js';
 import { Calls } from './calls.js';
 import { killDescendants } from './scope.js';
+import { removeInputs, Scripts } from './scripts.js';
 import { quoted } from './shell.js';
 import { SignIns } from './sign-in.js';
 import { placeSkillSet } from './skills.js';
 import { holdConnection } from './connection.js';
 import { KitUpdate } from './update.js';
-import { WebWizards } from './web-wizard.js';
 import { codexLauncher } from './work.js';
 function report(error) {
     process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
@@ -117,7 +117,7 @@ async function started() {
         killDescendants();
         process.exit(1);
     });
-    await placeSkillSet();
+    await placeSkillSet((await readEnrolment()).house);
     await mkdir(agentBase(), { recursive: true });
     await installShim(join(kitHome(), 'shim', 'git'), 'git-main');
     await installShim(codexLauncher(), 'codex-main');
@@ -143,6 +143,9 @@ export async function resident() {
         else if (restartAsked() && conversations.quiet()) {
             restart('restarting for an updated CLI');
         }
+        else if (update.held() && conversations.quiet()) {
+            update.apply(connection.pause());
+        }
         else if (!reported) {
             reported = true;
             logged(house.deliver('/kit/idle', {}, idle));
@@ -158,11 +161,13 @@ export async function resident() {
         changed,
     });
     const signIns = new SignIns(house, agents, calls);
-    const update = new KitUpdate(calls);
-    const wizards = new WebWizards(calls, (notification) => connection?.send(notification) ?? false);
+    const update = new KitUpdate(calls, changed);
+    removeInputs();
+    const scripts = new Scripts(calls, (notification) => connection?.send(notification) ?? false);
     for (const signal of ['SIGTERM', 'SIGINT']) {
         process.once(signal, () => {
             killDescendants();
+            removeInputs();
             process.kill(process.pid, signal);
         });
     }
@@ -175,18 +180,18 @@ export async function resident() {
             changed();
             logged(copies.connected());
         },
-        closed: () => wizards.disconnected(),
+        closed: () => scripts.disconnected(),
         call: (call) => {
             if (call.kind === 'sign_in')
                 signIns.start(call);
             else if (call.kind === 'update')
-                update.start(call);
-            else if (call.kind === 'run_wizard')
-                wizards.start(call);
+                update.hold(call);
+            else if (call.kind === 'run_wizard' || call.kind === 'run_function')
+                scripts.start(call);
             else if (CONVERSATION_METHODS.has(call.kind))
                 conversations.call(call);
             else {
-                const refused = { refused: `This Kit does not know ${call.kind}; update the Kit` };
+                const refused = { refused: unknownMethod(call.kind) };
                 void calls.carry(call.input_id, async () => ({ result: refused }));
             }
         },
@@ -197,7 +202,7 @@ export async function resident() {
                 logged(copies.changed(notification.rooms));
             if (notification.type === 'work_available' && notification.subject === 'agents')
                 logged(agents.refresh());
-            wizards.notified(notification);
+            scripts.notified(notification);
         },
     });
 }

package/dist/scripts.js

@@ -0,0 +1,255 @@
+import { spawn as spawnPiped } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { once } from 'node:events';
+import { rmSync } from 'node:fs';
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { constants } from 'node:os';
+import { join } from 'node:path';
+import { loginPath, onLoginPath } from './clis.js';
+import { kitHome } from './home.js';
+import { childEnvironment } from './relay.js';
+import { killTree } from './scope.js';
+const TERMINAL = 'xterm-256color';
+const FIRST_SIZE = { cols: 80, rows: 24 };
+const SIGNALLED = 128;
+const NEWLINE = 0x0a;
+const NO_BASH = "bash is not on the login shell's PATH";
+const LOST = { refused: 'the Kit lost its connection to House' };
+function causeOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function failed(plan, cause) {
+    process.stderr.write(`kit: ${plan.named} could not start: ${cause}\n`);
+    return { refused: `the script could not start: ${cause}` };
+}
+function planned(call) {
+    if (call.kind === 'run_wizard')
+        return { named: 'a Web Wizard', script: call.script, terminal: 'page', function: null };
+    return {
+        named: 'an Environment function',
+        script: call.script,
+        terminal: call.terminal ? 'at once' : null,
+        function: { input: call.input, timeCap: call.time_cap, outputCap: call.output_cap },
+    };
+}
+function inputs() {
+    return join(kitHome(), 'inputs');
+}
+async function inputFile(value) {
+    await mkdir(inputs(), { recursive: true, mode: 0o700 });
+    const path = join(inputs(), `${randomUUID()}.json`);
+    await writeFile(path, JSON.stringify(value), { mode: 0o600, flag: 'wx' });
+    return path;
+}
+export function removeInputs() {
+    rmSync(inputs(), { recursive: true, force: true });
+}
+function struck(line, typed) {
+    return typed.some((typedLine) => line.includes(typedLine));
+}
+class KeptOutput {
+    cap;
+    typedText = '';
+    text = '';
+    bytes = 0;
+    line = '';
+    lineBytes = 0;
+    dropping = false;
+    cut = false;
+    constructor(cap) {
+        this.cap = cap;
+    }
+    typed(data) {
+        this.typedText += data;
+    }
+    add(data) {
+        const pieces = data.split('\n');
+        const rest = pieces.pop();
+        for (const piece of pieces)
+            this.ended(piece);
+        this.extend(rest);
+    }
+    kept() {
+        const typed = this.typedLines(true);
+        this.text = [...this.text.split(/(?<=\n)/), this.line].filter((line) => line !== '' && !struck(line, typed)).join('');
+        this.bytes = Buffer.byteLength(this.text);
+        this.trim();
+        return { output: this.text, cut: this.cut };
+    }
+    typedLines(all) {
+        const lines = this.typedText.split(/\r\n|\r|\n/);
+        if (!all)
+            lines.pop();
+        return lines.filter((line) => line !== '');
+    }
+    ended(piece) {
+        const line = `${this.line}${piece}\n`;
+        const dropped = this.dropping;
+        this.line = '';
+        this.lineBytes = 0;
+        this.dropping = false;
+        if (dropped || struck(line, this.typedLines(false)))
+            return;
+        this.text += line;
+        this.bytes += Buffer.byteLength(line);
+        if (this.bytes > 2 * this.cap)
+            this.trim();
+    }
+    extend(piece) {
+        if (this.dropping)
+            return;
+        this.line += piece;
+        this.lineBytes += Buffer.byteLength(piece);
+        if (this.lineBytes <= this.cap)
+            return;
+        this.text = '';
+        this.bytes = 0;
+        this.line = '';
+        this.lineBytes = 0;
+        this.dropping = true;
+        this.cut = true;
+    }
+    trim() {
+        if (this.bytes <= this.cap)
+            return;
+        const bytes = Buffer.from(this.text);
+        const start = bytes.indexOf(NEWLINE, bytes.length - this.cap - 1) + 1;
+        this.text = bytes.subarray(start).toString('utf8');
+        this.bytes = bytes.length - start;
+        this.cut = true;
+    }
+}
+export class Scripts {
+    calls;
+    send;
+    runs = new Map();
+    constructor(calls, send) {
+        this.calls = calls;
+        this.send = send;
+    }
+    start(call) {
+        void this.calls.carry(call.input_id, () => this.run(call.input_id, planned(call)));
+    }
+    notified(notification) {
+        const run = this.runs.get(String(notification.wizard));
+        if (run === undefined)
+            return;
+        if (notification.type === 'wizard_input')
+            this.typed(run, String(notification.data));
+        if (notification.type === 'wizard_size')
+            this.resized(run, { cols: Number(notification.cols), rows: Number(notification.rows) });
+        if (notification.type === 'wizard_end' && run.plan.terminal === 'page')
+            this.end(run, {});
+    }
+    disconnected() {
+        for (const run of this.runs.values())
+            this.end(run, LOST);
+    }
+    async run(id, plan) {
+        const size = plan.terminal === 'page' ? null : FIRST_SIZE;
+        const output = plan.function === null ? null : new KeptOutput(plan.function.outputCap);
+        const run = { plan, input: null, output, process: null, pipes: [], terminal: null, size, typed: [], ended: null, sized: Promise.withResolvers() };
+        if (size !== null)
+            run.sized.resolve();
+        this.runs.set(id, run);
+        try {
+            return { result: await this.ran(id, run), release: plan.function !== null };
+        }
+        finally {
+            this.runs.delete(id);
+            if (run.input !== null)
+                await rm(run.input, { force: true });
+        }
+    }
+    async ran(id, run) {
+        const { plan, output } = run;
+        let exited;
+        try {
+            const { spawn } = await import('@lydell/node-pty');
+            const shell = await onLoginPath('bash');
+            if (shell === null)
+                return failed(plan, NO_BASH);
+            const path = await loginPath();
+            await run.sized.promise;
+            if (plan.function !== null)
+                run.input = await inputFile(plan.function.input);
+            if (run.ended !== null)
+                return run.ended;
+            const environment = { ...childEnvironment(), PATH: path, ...(run.input === null ? {} : { HOUSE_INPUT: run.input }) };
+            if (plan.terminal === null) {
+                ({ exited } = await this.piped(plan.script, shell, environment, run));
+            }
+            else {
+                const terminal = spawn(shell, ['-c', plan.script], { name: TERMINAL, ...run.size, cwd: process.cwd(), env: environment });
+                run.process = terminal;
+                run.terminal = terminal;
+                terminal.onData((data) => {
+                    this.send({ type: 'wizard_output', wizard: id, data });
+                    output?.add(data);
+                });
+                for (const data of run.typed.splice(0))
+                    terminal.write(data);
+                exited = new Promise((resolve) => terminal.onExit(({ exitCode, signal }) => resolve(signal ? SIGNALLED + signal : exitCode)));
+            }
+        }
+        catch (error) {
+            return failed(plan, causeOf(error));
+        }
+        let timedOut = false;
+        // House sends a function run's time cap in seconds, and a run still going at its cap ends with its process group and the output pipes it holds.
+        const capped = plan.function === null ? undefined : setTimeout(() => {
+            timedOut = true;
+            this.stop(run);
+        }, plan.function.timeCap * 1000);
+        const code = await exited;
+        clearTimeout(capped);
+        if (run.ended !== null)
+            return run.ended;
+        if (output === null)
+            return { exit_code: code };
+        const kept = output.kept();
+        return timedOut ? { timed_out: true, ...kept } : { exit_code: code, ...kept };
+    }
+    async piped(script, shell, environment, run) {
+        const child = spawnPiped(shell, ['-c', script], { cwd: process.cwd(), env: environment, detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
+        const exited = new Promise((resolve) => child.once('close', (code, signal) => resolve(signal === null ? code : SIGNALLED + constants.signals[signal])));
+        await once(child, 'spawn');
+        run.process = { pid: child.pid };
+        run.pipes = [child.stdout, child.stderr];
+        for (const pipe of run.pipes) {
+            pipe.setEncoding('utf8');
+            pipe.on('data', (data) => run.output.add(data));
+        }
+        if (run.ended !== null)
+            this.stop(run);
+        return { exited };
+    }
+    typed(run, data) {
+        run.output?.typed(data);
+        if (run.terminal === null)
+            run.typed.push(data);
+        else
+            run.terminal.write(data);
+    }
+    resized(run, size) {
+        run.size = size;
+        run.sized.resolve();
+        try {
+            run.terminal?.resize(size.cols, size.rows);
+        }
+        catch { }
+    }
+    end(run, result) {
+        if (run.ended !== null)
+            return;
+        run.ended = result;
+        run.sized.resolve();
+        this.stop(run);
+    }
+    stop(run) {
+        if (run.process !== null)
+            killTree(run.process);
+        for (const pipe of run.pipes)
+            pipe.destroy();
+    }
+}

package/dist/sign-in.js

@@ -1,6 +1,7 @@
 import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
-import { CLIS, withoutProxy } from './clis.js';
+import { CLIS } from './clis.js';
+import { childEnvironment } from './relay.js';
 import { killTree } from './scope.js';
 import { holdSecretInput } from './secret-input.js';
 const ESCAPE = /\u001b\[[\d;]*m/g;
@@ -56,7 +57,7 @@ export class SignIns {
         const child = spawn(cli, login.args, {
             stdio: ['pipe', 'pipe', 'pipe'],
             detached: true,
-            env: withoutProxy(),
+            env: childEnvironment(),
         });
         const running = () => child.exitCode === null && child.signalCode === null;
         const stop = () => killTree(child);

package/dist/silence.js

@@ -0,0 +1,28 @@
+const SYSTEM_CLOCK = {
+    later: (delay, callback) => setTimeout(callback, delay),
+    clear: (timer) => clearTimeout(timer),
+};
+export class Silence {
+    timer = null;
+    interval;
+    silent;
+    clock;
+    constructor(interval, silent, clock = SYSTEM_CLOCK) {
+        this.interval = interval;
+        this.silent = silent;
+        this.clock = clock;
+    }
+    heard() {
+        this.stop();
+        this.timer = this.clock.later(this.interval, () => {
+            this.timer = null;
+            this.silent();
+        });
+    }
+    stop() {
+        if (this.timer === null)
+            return;
+        this.clock.clear(this.timer);
+        this.timer = null;
+    }
+}

package/dist/skills.js

@@ -1,10 +1,14 @@
-import { cp, lstat, mkdir, realpath, rm, symlink } from 'node:fs/promises';
+import { cp, lstat, mkdir, realpath, rm, symlink, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join, relative } from 'node:path';
-import { listSkills } from '@agentshouse/skills';
+import { GUIDE, listSkills } from '@agentshouse/skills';
+import { parse } from 'yaml';
 import { KIT_RELEASE } from './clis.js';
 import { kitHome, readConfiguration, readHome, writeHome } from './home.js';
 const RECORD = 'skill-set.json';
+const ENTRY = 'SKILL.md';
+const FRONTMATTER = /^---\n([\s\S]*?)\n---\n/u;
+const ORIGIN = '<origin>';
 function skillsDirectory() {
     return join(homedir(), '.agents', 'skills');
 }
@@ -22,9 +26,31 @@ async function present(path) {
         throw error;
     }
 }
-async function install() {
+function skillName(text) {
+    const front = FRONTMATTER.exec(text);
+    const fields = (front === null ? null : parse(front[1]));
+    return typeof fields?.name === 'string' && typeof fields.description === 'string' ? fields.name : undefined;
+}
+function skillSet(origin) {
+    const upstream = listSkills().map(({ name, directory }) => ({
+        name,
+        place: (destination) => cp(directory, destination, { recursive: true }),
+    }));
+    const pages = GUIDE.flatMap(({ text }) => {
+        const name = skillName(text);
+        if (name === undefined)
+            return [];
+        const place = async (destination) => {
+            await mkdir(destination);
+            await writeFile(join(destination, ENTRY), text.replaceAll(ORIGIN, origin));
+        };
+        return [{ name, place }];
+    });
+    return [...upstream, ...pages].sort((left, right) => (left.name < right.name ? -1 : 1));
+}
+async function install(origin) {
     const placed = [];
-    for (const skill of listSkills()) {
+    for (const skill of skillSet(origin)) {
         if (!(await present(join(skillsDirectory(), skill.name))) && !(await present(join(claudeDirectory(), skill.name)))) {
             placed.push(skill);
         }
@@ -35,32 +61,32 @@ async function install() {
     await mkdir(claudeDirectory(), { recursive: true });
     const skills = await realpath(skillsDirectory());
     const claude = await realpath(claudeDirectory());
-    for (const { name, directory } of placed) {
-        await cp(directory, join(skillsDirectory(), name), { recursive: true });
+    for (const { name, place } of placed) {
+        await place(join(skillsDirectory(), name));
         if (claude !== skills)
             await symlink(relative(claude, join(skills, name)), join(claudeDirectory(), name));
     }
-    await writeHome(RECORD, { version: KIT_RELEASE, names });
+    await writeHome(RECORD, { version: KIT_RELEASE, origin, names });
 }
-export async function placeSkillSet() {
+export async function placeSkillSet(origin) {
     try {
-        await replaceSkillSet();
+        await replaceSkillSet(origin);
     }
     catch (error) {
         process.stderr.write(`kit: the skills could not be placed: ${error.message}\n`);
     }
 }
-async function replaceSkillSet() {
+async function replaceSkillSet(origin) {
     const accepted = (await readConfiguration()).skills;
     const installed = await readHome(RECORD);
-    if (accepted && installed?.version === KIT_RELEASE)
+    if (accepted && installed?.version === KIT_RELEASE && installed.origin === origin)
         return;
     for (const name of installed?.names ?? []) {
         await rm(join(claudeDirectory(), name), { recursive: true, force: true });
         await rm(join(skillsDirectory(), name), { recursive: true, force: true });
     }
     if (accepted)
-        await install();
+        await install(origin);
     else
         await rm(join(kitHome(), RECORD), { force: true });
 }

package/dist/transcription.js

@@ -1,31 +1,31 @@
-import { createHash } from 'node:crypto';
-import { createReadStream } from 'node:fs';
 import { chmod, mkdir, mkdtemp, readdir, readFile, rename, rm, stat } from 'node:fs/promises';
 import { availableParallelism, tmpdir } from 'node:os';
 import { basename, join } from 'node:path';
-import { pipeline } from 'node:stream/promises';
 import { unlessAborted } from './abort.js';
+import { downloadServed } from './building.js';
 import { failureOf, run } from './clis.js';
 import { downloaded, fetched } from './files.js';
 import { kitHome } from './home.js';
 const RELEASE = 'https://github.com/agentshouse/kit/releases/download/engine-2';
 export const MODEL = {
-    url: 'https://huggingface.co/ggml-org/parakeet-GGUF/resolve/35156454d1a39de06863303dd209fd2bed6ee079/ggml-parakeet-tdt-0.6b-v3-q4_k.bin',
+    name: 'ggml-parakeet-tdt-0.6b-v3-q4_k.bin',
+    from: 'https://huggingface.co/ggml-org/parakeet-GGUF/resolve/35156454d1a39de06863303dd209fd2bed6ee079/ggml-parakeet-tdt-0.6b-v3-q4_k.bin',
     sha256: '8b205b8b39c6535e153de6fb11c51db46125d45c4f16ba496fe41a0fe71b885e',
+    bytes: 415_611_879,
     executable: false,
 };
 export const ENGINES = {
     'linux-x64': {
-        decoder: { url: `${RELEASE}/ffmpeg-linux-x86_64`, sha256: '1f8235d206428305afb89c6e8ab99d100425a0ba61e22bb4c7aff017db8c8de5', executable: true },
-        engine: { url: `${RELEASE}/parakeet-cli-linux-x86_64`, sha256: 'bb2585695992fe1927a33960002cdf51b8a90a96ad65593c3d0a9f1fbc0865c2', executable: true },
+        decoder: { name: 'ffmpeg-linux-x86_64', from: `${RELEASE}/ffmpeg-linux-x86_64`, sha256: '1f8235d206428305afb89c6e8ab99d100425a0ba61e22bb4c7aff017db8c8de5', bytes: 5_175_832, executable: true },
+        engine: { name: 'parakeet-cli-linux-x86_64', from: `${RELEASE}/parakeet-cli-linux-x86_64`, sha256: 'bb2585695992fe1927a33960002cdf51b8a90a96ad65593c3d0a9f1fbc0865c2', bytes: 3_801_616, executable: true },
     },
     'linux-arm64': {
-        decoder: { url: `${RELEASE}/ffmpeg-linux-aarch64`, sha256: 'a7e08a0fae0179d1078312f6bb13d2a9aa4d4c71a1d82a022953f25dee452f5e', executable: true },
-        engine: { url: `${RELEASE}/parakeet-cli-linux-aarch64`, sha256: 'cbc0bedc8daae97f1ef9dcee4200c06226218e300e0fd62ead1306d22742b7ed', executable: true },
+        decoder: { name: 'ffmpeg-linux-aarch64', from: `${RELEASE}/ffmpeg-linux-aarch64`, sha256: 'a7e08a0fae0179d1078312f6bb13d2a9aa4d4c71a1d82a022953f25dee452f5e', bytes: 4_590_208, executable: true },
+        engine: { name: 'parakeet-cli-linux-aarch64', from: `${RELEASE}/parakeet-cli-linux-aarch64`, sha256: 'cbc0bedc8daae97f1ef9dcee4200c06226218e300e0fd62ead1306d22742b7ed', bytes: 3_477_624, executable: true },
     },
     'darwin-arm64': {
-        decoder: { url: `${RELEASE}/ffmpeg-darwin-arm64`, sha256: '7abe154aaed3d6b49f5167ca7221bb66bed51388925d99a7e4261a41fe52fba6', executable: true },
-        engine: { url: `${RELEASE}/parakeet-cli-darwin-arm64`, sha256: '9a2aafc0922ad7c0b6db6eff1641e96572ba32ac40bf995a1df242ed2febf297', executable: true },
+        decoder: { name: 'ffmpeg-darwin-arm64', from: `${RELEASE}/ffmpeg-darwin-arm64`, sha256: '7abe154aaed3d6b49f5167ca7221bb66bed51388925d99a7e4261a41fe52fba6', bytes: 3_696_768, executable: true },
+        engine: { name: 'parakeet-cli-darwin-arm64', from: `${RELEASE}/parakeet-cli-darwin-arm64`, sha256: '9a2aafc0922ad7c0b6db6eff1641e96572ba32ac40bf995a1df242ed2febf297', bytes: 1_939_728, executable: true },
     },
 };
 const CHUNK_SECONDS = 20;
@@ -46,7 +46,7 @@ function installed(artifact) {
     return join(directory(), artifact.sha256);
 }
 async function executed(command, args, signal) {
-    // A download or a transcription runs as long as its size needs; the setting turning off or the turn's interrupt or end aborts it instead.
+    // A decode or a transcription runs as long as its audio needs; the setting turning off or the turn's interrupt or end aborts it instead.
     const ran = await run(command, args, 0, false, signal);
     if (ran.status !== 0)
         throw new Error(failureOf(ran, basename(command)));
@@ -60,11 +60,6 @@ async function threads() {
     const allowed = quota === 'max' ? Infinity : Math.ceil(Number(quota) / Number(period));
     return Math.max(1, Math.floor(Math.min(availableParallelism(), allowed) / 2));
 }
-async function sha256(path) {
-    const hash = createHash('sha256');
-    await pipeline(createReadStream(path), hash);
-    return hash.digest('hex');
-}
 function causeOf(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -85,6 +80,25 @@ function ready() {
 function pinnedHere() {
     return ENGINES[`${process.platform}-${process.arch}`];
 }
+const DOWNLOADS = 3;
+async function downloadedAgain(artifact, signal) {
+    // An artifact arrives at a hundred kilobytes a second or its download ends, so a stalled Building cannot hold the install open.
+    const deadlineMs = Math.ceil(artifact.bytes / 100);
+    const deadline = AbortSignal.timeout(deadlineMs);
+    for (let attempt = 1;; attempt++) {
+        try {
+            return await downloadServed(artifact.name, artifact.sha256, `${installed(artifact)}.part`, AbortSignal.any([signal, deadline]), artifact.bytes);
+        }
+        catch (error) {
+            if (signal.aborted)
+                throw error;
+            if (deadline.aborted)
+                throw new Error(`${artifact.name} did not arrive within ${Math.ceil(deadlineMs / 1000)} seconds`);
+            if (attempt === DOWNLOADS)
+                throw error;
+        }
+    }
+}
 async function install(artifacts, signal) {
     await mkdir(directory(), { recursive: true });
     const pinned = new Set(artifacts.map((artifact) => artifact.sha256));
@@ -97,13 +111,8 @@ async function install(artifacts, signal) {
         if (!(await present(installed(artifact))))
             missing.push(artifact);
     try {
-        for (const artifact of missing) {
-            const part = `${installed(artifact)}.part`;
-            // Three retries carry a large download past a dropped connection before the download fails.
-            await executed('curl', ['-fsSL', '--retry', '3', '-o', part, artifact.url], signal);
-            if ((await sha256(part)) !== artifact.sha256)
-                throw new Error(`${artifact.url} does not match its sha256`);
-        }
+        for (const artifact of missing)
+            await downloadedAgain(artifact, signal);
         for (const artifact of missing) {
             if (artifact.executable)
                 await chmod(`${installed(artifact)}.part`, 0o755);