@agentshouse/kit 0.2.1-cf669c6d1ecbb → 0.2.1-cf6a92e13f031

package/dist/skills.js

@@ -1,17 +1,10 @@
-import { readFileSync } from 'node:fs';
-import { cp, lstat, mkdir, readdir, realpath, rm, symlink, writeFile } from 'node:fs/promises';
+import { cp, lstat, mkdir, realpath, rm, symlink } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join, relative } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { KIT_VERSION } from './clis.js';
+import { listSkills } from '@agentshouse/skills';
+import { KIT_RELEASE } from './clis.js';
 import { kitHome, readConfiguration, readHome, writeHome } from './home.js';
-import { refusalOf } from './refusals.js';
-export 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 RECORD = 'skill-set.json';
-const CREATED = 'how-we-work-created';
-const UNWRITABLE = new Set(['room_not_found', 'operation_denied']);
 function skillsDirectory() {
     return join(homedir(), '.agents', 'skills');
 }
@@ -30,28 +23,37 @@ async function present(path) {
     }
 }
 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);
+    const placed = [];
+    for (const skill of listSkills()) {
+        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, directory } of placed) {
+        await cp(directory, join(skillsDirectory(), name), { recursive: true });
         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, names });
 }
 export async function placeSkillSet() {
+    try {
+        await replaceSkillSet();
+    }
+    catch (error) {
+        process.stderr.write(`kit: the skills could not be placed: ${error.message}\n`);
+    }
+}
+async function replaceSkillSet() {
     const accepted = (await readConfiguration()).skills;
     const installed = await readHome(RECORD);
-    if (accepted && installed?.version === KIT_VERSION)
+    if (accepted && installed?.version === KIT_RELEASE)
         return;
     for (const name of installed?.names ?? []) {
         await rm(join(claudeDirectory(), name), { recursive: true, force: true });
@@ -62,17 +64,3 @@ export async function placeSkillSet() {
     else
         await rm(join(kitHome(), RECORD), { force: true });
 }
-export async function createHowWeWork(bridge) {
-    if ((await readHome(RECORD)) === null || (await present(join(kitHome(), CREATED))))
-        return;
-    const created = await bridge.tool('edit', { changes: [{ op: 'create', path: HOW_WE_WORK, content: HOW_WE_WORK_TEXT }] });
-    if (created.isError === true) {
-        const text = created.content.map((content) => content.text).join('\n');
-        const refusal = refusalOf(text);
-        if (UNWRITABLE.has(refusal?.code ?? ''))
-            return;
-        if (refusal?.code !== 'edit_conflict' || !refusal.conflicts.includes('path_exists'))
-            throw new Error(text);
-    }
-    await writeFile(join(kitHome(), CREATED), '');
-}

package/dist/transcription.js

@@ -6,6 +6,7 @@ import { basename, join } from 'node:path';
 import { pipeline } from 'node:stream/promises';
 import { unlessAborted } from './abort.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 = {
@@ -28,6 +29,11 @@ export const ENGINES = {
     },
 };
 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;
@@ -49,10 +55,10 @@ async function executed(command, args, signal) {
 function present(path) {
     return stat(path).then(() => true, () => false);
 }
-async function cpus() {
+async function threads() {
     const [quota, period] = (await readFile('/sys/fs/cgroup/cpu.max', 'utf8').catch(() => 'max')).split(' ');
     const allowed = quota === 'max' ? Infinity : Math.ceil(Number(quota) / Number(period));
-    return Math.min(availableParallelism(), allowed);
+    return Math.max(1, Math.floor(Math.min(availableParallelism(), allowed) / 2));
 }
 async function sha256(path) {
     const hash = createHash('sha256');
@@ -62,6 +68,20 @@ async function sha256(path) {
 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}`];
 }
@@ -133,27 +153,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 cpus()), '-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 +178,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

@@ -4,11 +4,8 @@ import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { run } from './clis.js';
-import { kitHome } from './home.js';
-const RECORD = 'outcome=$1; shift; bash "$0" --linux "$@"; printf %s "$?" > "$outcome"; systemctl start house-kit.service';
-function logged(error) {
-    process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
-}
+import { kitHome, workspaceRoot } from './home.js';
+import { service, throughSudo } from './placement.js';
 function directory() {
     return join(kitHome(), 'update');
 }
@@ -18,10 +15,25 @@ function pending() {
 function outcome() {
     return join(directory(), 'outcome');
 }
-function unit(inputId) {
-    return `house-kit-update-${inputId}`;
+function unit(callId) {
+    return `house-kit-update-${callId}`;
+}
+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() {
+async function pendingCall() {
     try {
         return JSON.parse(await readFile(pending(), 'utf8')).input_id;
     }
@@ -35,85 +47,92 @@ async function recorded() {
         return null;
     return status.trim() === '0' ? {} : { refused: `the Kit bootstrap exited with ${status.trim()}` };
 }
-async function finished(inputId) {
+async function forget(callId) {
+    if ((await pendingCall()) !== callId)
+        return;
+    await rm(pending(), { force: true });
+    await rm(outcome(), { force: true });
+}
+async function finished(callId) {
     for (;;) {
-        const ack = await recorded();
-        if (ack !== null)
-            return ack;
+        const result = await recorded();
+        if (result !== null)
+            return result;
         // systemctl answers at once, so ten seconds only bounds a stuck service manager.
-        if ((await run('systemctl', ['is-active', '--quiet', unit(inputId)], 10_000)).status !== 0) {
+        if ((await run('systemctl', [...manager(), 'is-active', '--quiet', unit(callId)], 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 rerun(script, callId, flags) {
     return new Promise((resolve) => {
-        const child = spawn('systemd-run', [
+        const [command, ...args] = [
+            ...elevated(),
+            'systemd-run',
+            ...manager(),
+            ...account(),
             '--wait',
             '--collect',
             '--quiet',
-            `--unit=${unit(inputId)}`,
+            `--unit=${unit(callId)}`,
             `--setenv=HOME=${homedir()}`,
+            `--setenv=HOUSE_KIT_HOME=${kitHome()}`,
             '/bin/sh',
             '-c',
-            RECORD,
+            record(),
             script,
             outcome(),
+            ...placement(),
             ...flags,
-        ], { stdio: ['ignore', 'ignore', 'inherit'] });
-        child.on('error', () => resolve({ refused: 'no service manager runs this Kit' }));
+        ];
+        const child = spawn(command, args, { stdio: ['ignore', 'ignore', 'inherit'] });
+        child.on('error', () => resolve({ refused: 'no service manager runs this Kit process' }));
         child.on('close', () => resolve(null));
     });
 }
-export class Updates {
-    house;
-    held = new Set();
+export class KitUpdate {
+    calls;
     queue = Promise.resolve();
-    constructor(house) {
-        this.house = house;
+    constructor(calls) {
+        this.calls = calls;
     }
     async resumed() {
-        const inputId = await pendingInput();
-        if (inputId === null)
+        const callId = await pendingCall();
+        if (callId === null)
             return;
-        await this.acknowledge(inputId, await finished(inputId));
+        await this.enqueue(callId, () => finished(callId));
     }
-    start(input) {
-        if (this.held.has(input.input_id))
-            return;
-        this.held.add(input.input_id);
-        this.queue = this.queue
-            .then(() => this.carry(input))
-            .then((ack) => this.acknowledge(input.input_id, ack))
-            .catch(logged)
-            .finally(() => this.held.delete(input.input_id));
+    start(call) {
+        void this.enqueue(call.input_id, () => this.carry(call));
+    }
+    enqueue(callId, work) {
+        const before = this.queue;
+        const carried = this.calls.carry(callId, async () => {
+            await before;
+            return { result: await work(), returned: () => forget(callId) };
+        });
+        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);
+    async carry(call) {
+        if ((await pendingCall()) === call.input_id)
+            return finished(call.input_id);
+        const answer = await fetch(call.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) {
+        if (createHash('sha256').update(script).digest('hex') !== call.sha256) {
             return { refused: 'the Kit bootstrap does not match its sha256' };
         }
         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()) ?? {
+        await writeFile(pending(), `${JSON.stringify({ input_id: call.input_id })}\n`, { mode: 0o600 });
+        return (await rerun(path, call.input_id, call.update_clis ? ['--update-clis'] : [])) ?? (await recorded()) ?? {
             refused: 'the Kit bootstrap did not finish',
         };
     }
-    async acknowledge(inputId, ack) {
-        await this.house.deliver(`/kit/inputs/${inputId}/ack`, ack);
-        if ((await pendingInput()) !== inputId)
-            return;
-        await rm(pending(), { force: true });
-        await rm(outcome(), { force: true });
-    }
 }

package/dist/web-wizard.js

@@ -0,0 +1,100 @@
+import { loginPath, onLoginPath, withoutProxy } from './clis.js';
+import { killTree } from './scope.js';
+const TERMINAL = 'xterm-256color';
+const SIGNALLED = 128;
+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(cause) {
+    process.stderr.write(`kit: a Web Wizard could not start: ${cause}\n`);
+    return { refused: `the script could not start: ${cause}` };
+}
+export class WebWizards {
+    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));
+    }
+    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')
+            this.end(run, {});
+    }
+    disconnected() {
+        for (const run of this.runs.values())
+            this.end(run, LOST);
+    }
+    async run(call) {
+        const run = { terminal: null, size: null, typed: [], ended: null, sized: Promise.withResolvers() };
+        this.runs.set(call.input_id, run);
+        try {
+            return { result: await this.ran(call.input_id, call.script, run) };
+        }
+        finally {
+            this.runs.delete(call.input_id);
+        }
+    }
+    async ran(wizard, script, run) {
+        let terminal;
+        try {
+            const { spawn } = await import('@lydell/node-pty');
+            const shell = await onLoginPath('bash');
+            if (shell === null)
+                return failed(NO_BASH);
+            const path = await loginPath();
+            await run.sized.promise;
+            if (run.ended !== null)
+                return run.ended;
+            terminal = spawn(shell, ['-c', script], {
+                name: TERMINAL,
+                ...run.size,
+                cwd: process.cwd(),
+                env: { ...withoutProxy(), PATH: path },
+            });
+        }
+        catch (error) {
+            return failed(causeOf(error));
+        }
+        run.terminal = terminal;
+        terminal.onData((data) => this.send({ type: 'wizard_output', wizard, data }));
+        for (const data of run.typed.splice(0))
+            terminal.write(data);
+        const exited = await new Promise((resolve) => terminal.onExit(resolve));
+        return run.ended ?? { exit_code: exited.signal ? SIGNALLED + exited.signal : exited.exitCode };
+    }
+    typed(run, 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();
+        if (run.terminal !== null)
+            killTree(run.terminal);
+    }
+}

package/dist/wire.js

@@ -0,0 +1,22 @@
+import { newerThanHouse, updateRequired } from './end.js';
+import { machine } from './placement.js';
+import { refusalOf } from './refusals.js';
+export const KIT_WIRE = 3;
+export const KIT_WIRE_HEADER = 'x-house-kit-wire';
+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()]);
+}

package/dist/work.js

@@ -1,11 +1,11 @@
 import { randomUUID } from 'node:crypto';
 import { once } from 'node:events';
 import { readFileSync } from 'node:fs';
-import { mkdir, rm } from 'node:fs/promises';
+import { rm } from 'node:fs/promises';
 import { createServer } from 'node:net';
 import { join } from 'node:path';
 import { RUNNING_JOB } from './events.js';
-import { kitHome } from './home.js';
+import { kitHome, socketDirectory } from './home.js';
 const ENDED_TASK = new Set(['completed', 'failed', 'killed']);
 const SCHEDULING = new Set(['CronCreate', 'CronDelete', 'ScheduleWakeup']);
 const QUEUE_LIST = 'house-kit-queue-';
@@ -194,9 +194,7 @@ class CodexWork extends Work {
     proving = -1;
     proven = -1;
     async open(cli) {
-        const sockets = join(kitHome(), 'bridges');
-        await mkdir(sockets, { recursive: true, mode: 0o700 });
-        this.path = join(sockets, `${randomUUID()}.sock`);
+        this.path = join(socketDirectory(), `${randomUUID()}.sock`);
         this.server = createServer((socket) => this.connected(socket));
         this.server.listen(this.path);
         await once(this.server, 'listening');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agentshouse/kit",
-  "version": "0.2.1-cf669c6d1ecbb",
-  "description": "House Kit connects an Environment to agents.house.",
+  "version": "0.2.1-cf6a92e13f031",
+  "description": "Kit connects an Environment to agents.house.",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -16,18 +16,19 @@
     "./bootstrap": "./dist/bootstrap.json"
   },
   "files": [
-    "dist",
-    "how-we-work.md",
-    "skills"
+    "dist"
   ],
   "scripts": {
     "build": "tsc -p tsconfig.build.json && node scripts/bootstrap-manifest.mjs",
     "engine": "mkdir -p tmp/engine && docker run --rm -v \"$PWD:/kit\" -w /kit alpine:3.24@sha256:294b683cb724975bec92580e1e685676bd4b50bda910ddb8c51d4cabeaec77e6 sh scripts/engine.sh tmp/engine",
+    "follow-skills": "node scripts/follow-skills.mjs",
     "test": "tsc -p tsconfig.json && vitest run"
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "1.7.0",
-    "@agentshouse/mdmodel": "0.1.0-c68e2039f1ca8",
+    "@agentshouse/mdmodel": "0.1.0-cabd61587647f",
+    "@agentshouse/skills": "0.1.0-c6411c39c6d0f",
+    "@lydell/node-pty": "1.2.0-beta.15",
     "yaml": "2.9.1"
   },
   "peerDependencies": {

package/dist/stream.js

@@ -1,74 +0,0 @@
-import { subscribe } from 'node:diagnostics_channel';
-import { finalRefusal, HouseRefusal, retryDelay } from './api.js';
-import { end, REPLACED, signInAgain } from './end.js';
-import { readEnrolment } from './home.js';
-import { relayed } from './relay.js';
-const PATH = '/kit/stream';
-const SUBPROTOCOL = 'house.kit.stream.1';
-const REFUSAL_HEADER = 'x-house-refusal';
-function streamUrl(house) {
-    const url = new URL(PATH, house);
-    url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
-    return url;
-}
-function header(headers, name) {
-    for (let index = 0; index < headers.length; index += 2) {
-        if (headers[index].toString('latin1').toLowerCase() === name)
-            return headers[index + 1].toString('latin1');
-    }
-    return '';
-}
-let refused = null;
-subscribe('undici:request:headers', (message) => {
-    const { request, response } = message;
-    if (!request.path.endsWith(PATH))
-        return;
-    refused = new HouseRefusal(PATH, response.statusCode, header(response.headers, REFUSAL_HEADER) || response.statusText);
-});
-export function holdStream(handlers) {
-    let socket = null;
-    let failures = 0;
-    const connect = async () => {
-        const { house, credential } = (await readEnrolment());
-        refused = null;
-        const opening = new WebSocket(relayed(streamUrl(house)), {
-            protocols: [SUBPROTOCOL],
-            headers: { authorization: `Bearer ${credential}` },
-        });
-        let opened = false;
-        opening.onopen = () => {
-            opened = true;
-            failures = 0;
-            socket = opening;
-            handlers.opened();
-        };
-        opening.onmessage = (event) => {
-            handlers.frame(JSON.parse(String(event.data)));
-        };
-        opening.onerror = () => undefined;
-        opening.onclose = (event) => {
-            if (socket === opening)
-                socket = null;
-            process.stderr.write(`kit: control stream closed ${event.code} ${event.reason}\n`);
-            if (event.reason === 'replaced')
-                end(REPLACED);
-            if (event.reason === 'credential_rejected' || refused?.status === 401) {
-                void signInAgain(credential);
-                return;
-            }
-            if (finalRefusal(refused))
-                end(refused.message);
-            // A closed socket reopens in one to three seconds, spread so Kits one restart closed return apart; an opening House refused as retryable or left unanswered backs off on the jittered curve.
-            setTimeout(() => void connect(), opened ? 1000 + Math.random() * 2000 : retryDelay(failures++));
-        };
-    };
-    void connect();
-    return {
-        send(frame) {
-            if (socket === null || socket.readyState !== WebSocket.OPEN)
-                return false;
-            socket.send(JSON.stringify(frame));
-            return true;
-        },
-    };
-}