@agentshouse/kit 0.2.1-cb345f4157685 → 0.2.1-cb66cb2fd0696

package/dist/skills.js

@@ -1,31 +1,14 @@
-import { createHash } from 'node:crypto';
-import { readFileSync } from 'node:fs';
-import { cp, lstat, mkdir, readdir, 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 { fileURLToPath } from 'node:url';
+import { GUIDE, listSkills } from '@agentshouse/skills';
 import { parse } from 'yaml';
-import { KIT_VERSION } from './clis.js';
+import { KIT_RELEASE } from './clis.js';
 import { kitHome, readConfiguration, readHome, writeHome } from './home.js';
-import { refusalOf } from './refusals.js';
-const HOW_WE_WORK = '/rooms/private/how-we-work.md';
-const SKILL_SET = fileURLToPath(new URL('../skills/', import.meta.url));
-const HOW_WE_WORK_TEXT = readFileSync(new URL('../how-we-work.md', import.meta.url), 'utf8');
-const SHIPPED_HOW_WE_WORK = [
-    'ae4dda60da7b174f22dc5fa9bf07fc27c25864932a74230de4f9f509ddd91f41',
-    '0bdcd43e1603ba6673a3cae56d70bbf90657cbeefd124e91a47be2ca1cbd6c93',
-    '4106a87ec66da6f7b2a10e74d18e6559d68d5f4fe7415dae68f5c7bdb9081968',
-    'ac814a2197038f037b657bb719340395f89f319ac9fcdd386629c3fe2cec68f1',
-    '29951ee394aad9979eecfed3e5dc32c2c86e2226b6a380db5dbd4f305f4d1156',
-];
 const RECORD = 'skill-set.json';
-const WRITTEN = 'how-we-work.json';
-const UNWRITABLE = new Set(['room_not_found', 'operation_denied']);
-const PRESENT = new Set(['path_exists']);
-const CHANGED = new Set(['base_revision_stale', 'path_absent']);
-const UNREADABLE = /^(?:\S+: )?(?:path_not_found|room_not_found|operation_denied)\b/;
-const FAILED = /^exit: [1-9]\d*$/;
-const CUT = /^stderr: shell: output_cut (\d+) of \d+ bytes; continue with: (.+)$/;
+const ENTRY = 'SKILL.md';
+const FRONTMATTER = /^---\n([\s\S]*?)\n---\n/u;
+const ORIGIN = '<origin>';
 function skillsDirectory() {
     return join(homedir(), '.agents', 'skills');
 }
@@ -43,105 +26,67 @@ async function present(path) {
         throw error;
     }
 }
-async function install() {
-    const names = [];
-    for (const name of (await readdir(SKILL_SET)).sort()) {
-        if (!(await present(join(skillsDirectory(), name))) && !(await present(join(claudeDirectory(), name)))) {
-            names.push(name);
+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 skillSet(origin)) {
+        if (!(await present(join(skillsDirectory(), skill.name))) && !(await present(join(claudeDirectory(), skill.name)))) {
+            placed.push(skill);
         }
     }
+    const names = placed.map((skill) => skill.name);
     await writeHome(RECORD, { names });
     await mkdir(skillsDirectory(), { recursive: true });
     await mkdir(claudeDirectory(), { recursive: true });
     const skills = await realpath(skillsDirectory());
     const claude = await realpath(claudeDirectory());
-    for (const name of names) {
-        await cp(join(SKILL_SET, name), 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_VERSION, 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_VERSION)
+    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 });
 }
-function sha256(text) {
-    return createHash('sha256').update(text).digest('hex');
-}
-function cutOf(lines) {
-    const cut = CUT.exec(lines[0] ?? '');
-    return cut !== null && Buffer.byteLength(lines.slice(1).join('\n')) === Number(cut[1]) ? cut : null;
-}
-export async function readHowWeWork(bridge) {
-    let document = '';
-    for (let command = `cat ${HOW_WE_WORK}`; command !== undefined;) {
-        const read = await bridge.tool('shell', { command });
-        const text = read.content.map((content) => content.text).join('\n');
-        const lines = text.split('\n');
-        if (read.isError === true || (FAILED.test(lines[0] ?? '') && lines[1]?.startsWith('stderr: '))) {
-            const refusal = read.isError === true ? text : lines.slice(1).join('\n').replace(/^stderr: /gm, '');
-            if (UNREADABLE.test(refusal))
-                return '';
-            throw new Error(refusal);
-        }
-        const cut = cutOf(lines);
-        document += lines.slice(cut === null ? 0 : 1).join('\n');
-        command = cut?.[2];
-    }
-    return document;
-}
-async function currentRevision(bridge) {
-    const inspected = await bridge.tool('inspect', { path: HOW_WE_WORK });
-    const text = inspected.content.map((content) => content.text).join('\n');
-    if (inspected.isError === true)
-        throw new Error(text);
-    return parse(text).revisions[0].revision;
-}
-async function edit(bridge, change, kept) {
-    const edited = await bridge.tool('edit', { changes: [{ ...change, path: HOW_WE_WORK, content: HOW_WE_WORK_TEXT }] });
-    if (edited.isError !== true)
-        return 'written';
-    const text = edited.content.map((content) => content.text).join('\n');
-    const refusal = refusalOf(text);
-    if (UNWRITABLE.has(refusal?.code ?? ''))
-        return 'unwritable';
-    if (refusal?.code === 'edit_conflict' && refusal.conflicts.some((conflict) => kept.has(conflict)))
-        return 'kept';
-    throw new Error(text);
-}
-export async function createHowWeWork(bridge) {
-    if (!(await readConfiguration()).skills || (await readHome(RECORD))?.version === undefined)
-        return;
-    const current = sha256(HOW_WE_WORK_TEXT);
-    if ((await readHome(WRITTEN)) === current)
-        return;
-    const created = await edit(bridge, { op: 'create' }, PRESENT);
-    if (created === 'unwritable')
-        return;
-    if (created === 'kept') {
-        const base = await currentRevision(bridge);
-        const held = sha256(await readHowWeWork(bridge));
-        if (held !== current && SHIPPED_HOW_WE_WORK.includes(held) && (await edit(bridge, { op: 'replace', base }, CHANGED)) === 'unwritable')
-            return;
-    }
-    await writeHome(WRITTEN, current);
-}

package/dist/transcription.js

@@ -1,33 +1,39 @@
-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;
+const OFF = "transcription is off on the Agent's Environment, so this message's audio has no text; turn it on or write instead";
+const NOT_INSTALLED = "the speech engine is not installed on the Agent's Environment, so this message's audio has no text";
+const NOT_DOWNLOADED = 'an audio file this message links could not be downloaded; send the message again';
+const UNDECODABLE = 'an audio file this message links could not be decoded';
+const UNTRANSCRIBED = 'an audio file this message links could not be transcribed';
 let held = Promise.resolve();
 let holding = Promise.resolve();
 let setting = null;
@@ -40,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)));
@@ -54,17 +60,45 @@ 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);
 }
+async function failing(reason, work) {
+    try {
+        return await work;
+    }
+    catch (error) {
+        throw new Error(reason, { cause: error });
+    }
+}
+function ready() {
+    if (setting !== true)
+        throw new Error(OFF);
+    if (!readiness.installed)
+        throw new Error(NOT_INSTALLED);
+}
 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));
@@ -77,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);
@@ -133,27 +162,23 @@ export function holdTranscription(transcribe) {
 export function transcriptionReport() {
     return readiness;
 }
-async function transcribed(path, signal) {
+async function transcribed(audio, parts, signal) {
     const pinned = pinnedHere();
-    const work = await mkdtemp(join(tmpdir(), 'kit-transcription-'));
-    try {
-        await executed(installed(pinned.decoder), ['-nostdin', '-hide_banner', '-loglevel', 'error', '-i', path, '-ar', '16000', '-ac', '1', '-c:a', 'pcm_s16le',
-            '-f', 'segment', '-segment_time', String(CHUNK_SECONDS), join(work, '%05d.wav')], signal);
-        const parts = (await readdir(work)).sort().flatMap((part) => ['-f', join(work, part)]);
-        const text = await executed(installed(pinned.engine), ['-t', String(await threads()), '-np', '-m', installed(MODEL), ...parts], signal);
-        return text
-            .split('\n')
-            .map((line) => line.trim())
-            .filter((line) => line !== '')
-            .join(' ');
-    }
-    finally {
-        await rm(work, { recursive: true, force: true });
-    }
+    await mkdir(parts);
+    await failing(UNDECODABLE, executed(installed(pinned.decoder), ['-nostdin', '-hide_banner', '-loglevel', 'error', '-i', audio, '-ar', '16000', '-ac', '1', '-c:a', 'pcm_s16le',
+        '-f', 'segment', '-segment_time', String(CHUNK_SECONDS), join(parts, '%05d.wav')], signal));
+    const segments = (await readdir(parts)).sort().flatMap((part) => ['-f', join(parts, part)]);
+    const said = await failing(UNTRANSCRIBED, executed(installed(pinned.engine), ['-t', String(await threads()), '-np', '-m', installed(MODEL), ...segments], signal));
+    const text = said
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line !== '')
+        .join(' ');
+    if (text === '')
+        throw new Error(UNTRANSCRIBED);
+    return text;
 }
-export async function transcribe(path, signal) {
-    if (!readiness.installed)
-        return null;
+async function alone(work, signal) {
     const before = held;
     let release;
     const mine = new Promise((resolve) => {
@@ -162,9 +187,24 @@ export async function transcribe(path, signal) {
     held = Promise.all([before, mine]);
     try {
         await unlessAborted(before, signal);
-        return readiness.installed ? await transcribed(path, signal) : null;
+        return await work();
     }
     finally {
         release();
     }
 }
+export async function transcribe(address, signal) {
+    ready();
+    const work = await mkdtemp(join(tmpdir(), 'kit-transcription-'));
+    try {
+        const audio = join(work, 'audio');
+        await failing(NOT_DOWNLOADED, downloaded(address, (url) => fetched(url, signal), audio, 'audio'));
+        return await alone(() => {
+            ready();
+            return transcribed(audio, join(work, 'parts'), signal);
+        }, signal);
+    }
+    finally {
+        await rm(work, { recursive: true, force: true });
+    }
+}

package/dist/translate.js

@@ -3,14 +3,8 @@ function same(left, right) {
     return JSON.stringify(left) === JSON.stringify(right);
 }
 function applied(document, changes) {
-    let current = document;
-    for (const change of changes) {
-        const result = apply(current, change);
-        if (result.outcome !== 'applied')
-            return null;
-        current = result.document;
-    }
-    return serialize(current);
+    const result = apply(document, changes);
+    return result.outcome === 'applied' ? serialize(result.document) : null;
 }
 function components(path, before, after, text) {
     const edits = [];

package/dist/update.js

@@ -1,138 +1,104 @@
 import { spawn } from 'node:child_process';
-import { createHash } from 'node:crypto';
-import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
+import { mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
-import { run } from './clis.js';
-import { kitHome, workspaceRoot } from './home.js';
-import { service, throughSudo } from './placement.js';
-function directory() {
-    return join(kitHome(), 'update');
+import { downloadServed, servedRelease } from './building.js';
+import { KIT_RELEASE } from './clis.js';
+import { kitHome, readEnrolment } from './home.js';
+import { placedPrefix } from './placement.js';
+import { childEnvironment, relayOrigin } from './relay.js';
+const INSTALLER_BYTES = 1_000_000;
+// A release's Node.js, Kit package and adapters are about a hundred megabytes, so an hour carries them at thirty kilobytes a second, and a placement still running then has hung.
+const PLACEMENT_MS = 60 * 60_000;
+const REFUSED = 'kit_bootstrap_refused: ';
+const OUTPUT_CHARACTERS = 4000;
+function causeOf(error) {
+    if (error instanceof TypeError && error.cause instanceof Error)
+        return `the Building did not answer: ${error.cause.message}`;
+    return error instanceof Error ? error.message : String(error);
 }
-function pending() {
-    return join(directory(), 'pending.json');
-}
-function outcome() {
-    return join(directory(), 'outcome');
-}
-function unit(inputId) {
-    return `house-kit-update-${inputId}`;
-}
-function manager() {
-    return service() === 'user' ? ['--user'] : [];
-}
-function elevated() {
-    return throughSudo() ? ['sudo', '-n'] : [];
-}
-function account() {
-    return throughSudo() ? [`--uid=${process.getuid()}`, `--gid=${process.getgid()}`] : [];
-}
-function placement() {
-    return service() === 'user' ? ['--workspace', workspaceRoot()] : ['--linux'];
-}
-function record() {
-    return `outcome=$1; shift; bash "$0" "$@"; printf %s "$?" > "$outcome"; ${[...elevated(), 'systemctl', ...manager(), 'start', 'house-kit.service'].join(' ')}`;
-}
-async function pendingInput() {
-    try {
-        return JSON.parse(await readFile(pending(), 'utf8')).input_id;
-    }
-    catch {
-        return null;
-    }
-}
-async function recorded() {
-    const status = await readFile(outcome(), 'utf8').catch(() => null);
-    if (status === null)
-        return null;
-    return status.trim() === '0' ? {} : { refused: `the Kit bootstrap exited with ${status.trim()}` };
-}
-async function forget(inputId) {
-    if ((await pendingInput()) !== inputId)
-        return;
-    await rm(pending(), { force: true });
-    await rm(outcome(), { force: true });
-}
-async function finished(inputId) {
-    for (;;) {
-        const ack = await recorded();
-        if (ack !== null)
-            return ack;
-        // systemctl answers at once, so ten seconds only bounds a stuck service manager.
-        if ((await run('systemctl', [...manager(), 'is-active', '--quiet', unit(inputId)], 10_000)).status !== 0) {
-            return (await recorded()) ?? { refused: 'the Kit bootstrap did not finish' };
-        }
-        // The bootstrap runs for minutes, so checking each second sees its outcome within a second at little cost.
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-    }
-}
-function rerun(script, inputId, flags) {
+function placing(installer, house, prefix, signal) {
     return new Promise((resolve) => {
-        const [command, ...args] = [
-            ...elevated(),
-            'systemd-run',
-            ...manager(),
-            ...account(),
-            '--wait',
-            '--collect',
-            '--quiet',
-            `--unit=${unit(inputId)}`,
-            `--setenv=HOME=${homedir()}`,
-            `--setenv=HOUSE_KIT_HOME=${kitHome()}`,
-            '/bin/sh',
-            '-c',
-            record(),
-            script,
-            outcome(),
-            ...placement(),
-            ...flags,
-        ];
-        const child = spawn(command, args, { stdio: ['ignore', 'ignore', 'inherit'] });
-        child.on('error', () => resolve({ refused: 'no service manager runs this Kit' }));
-        child.on('close', () => resolve(null));
+        const relay = relayOrigin();
+        const child = spawn('bash', [installer, '--house', house, '--place', prefix], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: { ...childEnvironment(), ...(relay === undefined ? {} : { HOUSE_KIT_RELAY: relay }) },
+            detached: true,
+        });
+        const stop = () => {
+            try {
+                process.kill(-child.pid, 'SIGKILL');
+            }
+            catch { }
+        };
+        signal.addEventListener('abort', stop, { once: true });
+        if (signal.aborted)
+            stop();
+        let output = '';
+        for (const stream of [child.stdout, child.stderr]) {
+            stream.setEncoding('utf8').on('data', (chunk) => {
+                output = (output + chunk).slice(-OUTPUT_CHARACTERS);
+            });
+        }
+        const ended = (failure) => {
+            signal.removeEventListener('abort', stop);
+            resolve(failure);
+        };
+        child.on('error', (error) => ended(error.message));
+        child.on('close', (status) => {
+            if (status === 0)
+                return ended(null);
+            if (signal.aborted)
+                return ended(`the placement did not end within ${PLACEMENT_MS / 1000} seconds`);
+            const lines = output.split('\n').filter((line) => line.trim() !== '');
+            const refused = lines.findLast((line) => line.startsWith(REFUSED));
+            ended(refused?.slice(REFUSED.length) ?? lines.at(-1) ?? `the placement ended with status ${status ?? 'a signal'}`);
+        });
     });
 }
-export class Updates {
-    inputs;
+export class KitUpdate {
+    calls;
     queue = Promise.resolve();
-    constructor(inputs) {
-        this.inputs = inputs;
+    placed = null;
+    constructor(calls) {
+        this.calls = calls;
     }
-    async resumed() {
-        const inputId = await pendingInput();
-        if (inputId === null)
-            return;
-        await this.enqueue(inputId, () => finished(inputId));
-    }
-    start(input) {
-        void this.enqueue(input.input_id, () => this.carry(input));
-    }
-    enqueue(inputId, work) {
-        const before = this.queue;
-        const carried = this.inputs.carry(inputId, async () => {
-            await before;
-            return { ack: await work(), acknowledged: () => forget(inputId) };
+    take(call) {
+        void this.calls.carry(call.input_id, () => {
+            const taken = this.queue.then(() => this.place(call.release));
+            this.queue = taken.catch(() => undefined);
+            return taken.then((result) => ({ result }));
         });
-        this.queue = before.then(() => carried);
-        return carried;
     }
-    async carry(input) {
-        if ((await pendingInput()) === input.input_id)
-            return finished(input.input_id);
-        const answer = await fetch(input.bootstrap);
-        if (!answer.ok)
-            return { refused: `the Kit bootstrap could not be downloaded: ${answer.status}` };
-        const script = Buffer.from(await answer.arrayBuffer());
-        if (createHash('sha256').update(script).digest('hex') !== input.sha256) {
-            return { refused: 'the Kit bootstrap does not match its sha256' };
+    placedRelease() {
+        return this.placed;
+    }
+    async place(release) {
+        if (release === (this.placed ?? KIT_RELEASE))
+            return {};
+        if (this.placed !== null)
+            return { refused: `Kit ${this.placed} is placed and starts first, once no turn is open` };
+        const signal = AbortSignal.timeout(PLACEMENT_MS);
+        let failure;
+        try {
+            const prefix = placedPrefix();
+            const served = await servedRelease(signal);
+            if (served.version !== release)
+                throw new Error(`the Building serves Kit ${served.version}, not Kit ${release}`);
+            await mkdir(join(kitHome(), 'update'), { recursive: true, mode: 0o700 });
+            const installer = join(kitHome(), 'update', served.installer);
+            await downloadServed(served.installer, served.sha256, installer, signal, INSTALLER_BYTES);
+            failure = await placing(installer, (await readEnrolment()).house, prefix, signal);
         }
-        await mkdir(directory(), { recursive: true, mode: 0o700 });
-        const path = join(directory(), 'connect-linux.sh');
-        await writeFile(path, script, { mode: 0o700 });
-        await rm(outcome(), { force: true });
-        await writeFile(pending(), `${JSON.stringify({ input_id: input.input_id })}\n`, { mode: 0o600 });
-        return (await rerun(path, input.input_id, input.update_clis ? ['--update-clis'] : [])) ?? (await recorded()) ?? {
-            refused: 'the Kit bootstrap did not finish',
-        };
+        catch (error) {
+            failure = signal.aborted ? `the placement did not end within ${PLACEMENT_MS / 1000} seconds` : causeOf(error);
+        }
+        if (failure !== null) {
+            const refused = `Kit ${release} could not be placed: ${failure}`;
+            process.stderr.write(`kit: ${refused}\n`);
+            return { refused };
+        }
+        this.placed = release;
+        process.stderr.write(`kit: Kit ${release} is placed; it starts once no turn is open\n`);
+        return {};
     }
 }

package/dist/wire.js

@@ -1,6 +1,22 @@
+import { newerThanHouse, updateRequired } from './end.js';
+import { machine } from './placement.js';
 import { refusalOf } from './refusals.js';
-export const KIT_WIRE = 2;
+export const KIT_WIRE = 4;
 export const KIT_WIRE_HEADER = 'x-house-kit-wire';
-export function tooOld(text) {
-    return refusalOf(text)?.code === 'kit_update_required';
+function newer(text) {
+    let body;
+    try {
+        body = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    return body?.error?.code === 'kit_newer_than_house' ? body.error : null;
+}
+export function endUnserved(text) {
+    if (refusalOf(text)?.code === 'kit_update_required')
+        updateRequired();
+    const refused = newer(text);
+    if (refused !== null)
+        newerThanHouse(refused.release, refused.commands[machine()]);
 }