@agentshouse/kit 0.2.1-ca0e1517cce79 → 0.2.1-ca1f38641026d

package/README.md

@@ -13,17 +13,17 @@ pass `--workspace <path>`.
 
 Add `--container` to run Kit in one Docker container instead, with your
 workspace mounted at `/agents/house`; your Agents then reach only that
-workspace. On Windows 11 the container is the one choice. Append a `kit` or `house` command to the container's options to run it in that container.
+workspace. On Windows the container is the one choice. Append a `kit` or `house` command to the container's options to run it in that container.
 Running the command for the other choice on a connected computer asks you to
 confirm, then replaces its Environment, whose Agents end, with a new one. Running it with a different `HOUSE_KIT_HOME`
 from the running Kit process asks you to confirm before it replaces that process, and leaves the earlier Kit home as it was.
 
-On your own Linux server, run the Linux command with `--linux` to
-install Kit natively, with its workspace at `/agents/house`; `kit` and
-`house` are then on the server's `PATH`.
+On your own Linux server, run the Linux command with `--linux` to install Kit natively, with its workspace at `/agents/house` and a missing `ca-certificates`, `curl` or `git` installed through apt; `kit` and `house` are then on the server's `PATH`.
+
+Kit is built for macOS 27 on Apple silicon, Ubuntu 26.04 LTS on amd64 and Windows 11 on amd64. On another release, distribution or architecture the command prints one warning line, such as `Warning: macOS 26.7.1 is outdated; update to macOS 27.`, and installs anyway. It refuses only an architecture other than amd64 and arm64, and a native install on a Linux without glibc, where `--container` still runs Kit. On a Linux without systemd it installs and connects Kit but starts nothing: run the `kit resident` command it prints under your own service manager, restarting it whenever it ends with a failure. `--container` installs Docker Engine on Ubuntu and Debian; another Linux needs a working Docker Engine first.
 
 Kit runs the agent CLIs your login shell finds and installs a missing one
-through that CLI's own installer. Running the command again offers to update
+through that CLI's own installer. A CLI older than the oldest release Kit is built for still runs, though its conversations may fail: Kit tells House its version, that oldest release and the CLI's own update command, such as `claude update`. Running the command again offers to update
 each CLI older than Kit needs; add `--update-clis` to update every one to
 its latest release without asking. Kit also gives every Agent on the
 Environment the agent skills of `@agentshouse/skills`, at the version each Kit
@@ -53,7 +53,7 @@ the container. An Agent runs both, without `--owner`. `house upload` and `house
 
 Kit turns each audio file your message to an Agent links into text on this computer before the Agent reads it, and keeps a message whose audio it cannot turn into text from starting. While transcription is on, the speech engine and model use about 425 MB beside the Environment's credential; turning it off deletes them.
 
-When you press Run on a Web Wizard's page, Kit runs its script with `bash` in a terminal on this computer, as you, in the home and directory it runs agent CLIs from, with your login shell's `PATH`; the page shows that terminal and takes your typing, and closing the page, or Kit losing its connection to House, ends the script and its child processes. Kit keeps nothing the script prints or you type.
+When you press Run on a Web Wizard's page, Kit runs its script with `bash` in a terminal on this computer, as you, in the home and directory it runs agent CLIs from, with your login shell's `PATH`; the page shows that terminal and takes your typing, and closing the page, or Kit losing its connection to House, ends the script and its child processes. Kit keeps nothing the script prints or you type. A script you keep as a function from a Web Wizard runs as you, from the same home, directory and `PATH`, when a Trigger of your Private Room or your agent runs it, with no terminal and nothing on its standard input, and when you press Run now on its page, in a terminal you can type into. Kit writes the run's input as JSON to a file only you can read, whose path is in `HOUSE_INPUT`, and deletes it when the run ends; it ends the script and its child processes at the run's time limit or when it loses its connection to House, and sends House the end of what the script printed, up to the run's output limit, without any line that holds a line you typed.
 
 ## License
 

package/dist/acp.js

@@ -1,31 +1,74 @@
-import { ndJsonStream, PROTOCOL_VERSION, } from '@agentclientprotocol/sdk';
+import { ndJsonStream, PROTOCOL_VERSION, RequestError, } from '@agentclientprotocol/sdk';
 import { spawn } from 'node:child_process';
 import { Readable, Writable } from 'node:stream';
-import { CLIS, KIT_RELEASE, adapterCommand, withoutProxy } from './clis.js';
+import { CLIS, KIT_RELEASE, adapterCommand } from './clis.js';
+import { childEnvironment } from './relay.js';
 import { killTree } from './scope.js';
+import { Silence } from './silence.js';
 const RETIRED = 'the CLI was retired';
+const SIGNED_OUT = RequestError.authRequired().code;
+export function signedOut(error) {
+    return typeof error === 'object' && error !== null && error.code === SIGNED_OUT;
+}
+// Claude Code ends a shell command or a model request after ten minutes, so a CLI that owes the Kit an answer and sends nothing for half an hour has hung.
+export const CLI_SILENCE_MS = 30 * 60_000;
+const SILENT = `the CLI sent nothing for ${CLI_SILENCE_MS / 60_000} minutes`;
 export async function startAdapter(kind, cli, cwd, app, events = () => undefined, added = {}, signal, scope = null) {
     const adapter = CLIS[kind].adapter;
     const started = [adapter === null ? cli : adapterCommand(kind), CLIS[kind].args];
     const [command, args] = scope?.command(...started) ?? started;
     const child = spawn(command, args, {
         cwd,
-        env: { ...withoutProxy(), ...(adapter === null ? {} : { ...adapter.env, [adapter.executable]: cli }), ...added },
+        env: { ...childEnvironment(), ...(adapter === null ? {} : { ...adapter.env, [adapter.executable]: cli }), ...added },
         stdio: ['pipe', 'pipe', 'pipe'],
         detached: true,
     });
     let owned = true;
     let retired = false;
+    let silent = false;
+    let over = false;
+    let open = false;
     let stderr = '';
+    const owed = new Set();
+    const asked = new Set();
+    const silence = new Silence(CLI_SILENCE_MS, () => {
+        silent = true;
+        connection.close(new Error(SILENT));
+        if (child.pid !== undefined)
+            killTree(child);
+    });
+    const watch = () => (!over && (owed.size > 0 || open) && asked.size === 0 ? silence.heard() : silence.stop());
     child.stderr.on('data', (chunk) => {
         stderr = (stderr + chunk.toString('utf8')).slice(-4000);
     });
     const stream = ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
+    const output = stream.writable.getWriter();
     const connection = app.connect({
-        writable: stream.writable,
+        writable: new WritableStream({
+            write(message) {
+                const sent = message;
+                if (sent.id !== undefined) {
+                    if (sent.method === undefined)
+                        asked.delete(sent.id);
+                    else
+                        owed.add(sent.id);
+                    watch();
+                }
+                return output.write(message);
+            },
+            close: () => output.close(),
+            abort: (reason) => output.abort(reason),
+        }),
         readable: stream.readable.pipeThrough(new TransformStream({
             transform(message, controller) {
                 const read = message;
+                if (read.id !== undefined) {
+                    if (read.method === undefined)
+                        owed.delete(read.id);
+                    else
+                        asked.add(read.id);
+                }
+                watch();
                 if (owned)
                     events(read);
                 if (read.id !== undefined || (read.method !== 'session/update' && !read.method.startsWith('_'))) {
@@ -37,6 +80,8 @@ export async function startAdapter(kind, cli, cwd, app, events = () => undefined
     const { promise: lost, resolve: lose } = Promise.withResolvers();
     const exited = new Promise((resolve) => {
         const end = (cause) => {
+            over = true;
+            silence.stop();
             if (owned)
                 lose(cause);
             owned = false;
@@ -46,11 +91,13 @@ export async function startAdapter(kind, cli, cwd, app, events = () => undefined
         child.on('error', (error) => end(`the CLI did not start: ${error.message}`));
         child.on('exit', (code, signal) => {
             const last = stderr.trim().split('\n').at(-1);
-            end(`the CLI exited with ${code ?? signal}${last ? `: ${last}` : ''}`);
+            end(silent ? SILENT : `the CLI exited with ${code ?? signal}${last ? `: ${last}` : ''}`);
         });
     });
     const retire = () => {
         owned = false;
+        over = true;
+        silence.stop();
         if (retired)
             return;
         retired = true;
@@ -74,7 +121,11 @@ export async function startAdapter(kind, cli, cwd, app, events = () => undefined
             clientInfo: { name: '@agentshouse/kit', version: KIT_RELEASE },
         });
         scope?.entered(child.pid);
-        return { connection, initialized, exited, lost, retire };
+        const turn = (opened) => {
+            open = opened;
+            watch();
+        };
+        return { connection, initialized, exited, lost, silent: () => silent, turn, retire };
     }
     catch (error) {
         retire();

package/dist/agents.js

@@ -1,7 +1,7 @@
 import { client } from '@agentclientprotocol/sdk';
 import { readFile, realpath } from 'node:fs/promises';
 import { setTimeout as delay } from 'node:timers/promises';
-import { startAdapter } from './acp.js';
+import { signedOut, startAdapter } from './acp.js';
 import { CLIS, KIT_RELEASE, below, installAdapter, installCli, locate, run, versionOf } from './clis.js';
 import { agentBase, kitHome } from './home.js';
 import { updatesItself } from './placement.js';
@@ -9,6 +9,8 @@ import { holdTranscription, transcriptionReport } from './transcription.js';
 import { KIT_WIRE } from './wire.js';
 // Two quiet seconds let a fresh conversation start before background model discovery competes for its CPU.
 const MODEL_PROBE_QUIET_MS = 2_000;
+// A sign-in's model read that has not answered in ten seconds leaves its sign-in to the status check, so a hung CLI never holds the sign-in's result.
+const SIGNED_IN_READ_MS = 10_000;
 const SIGNED_OUT = { signed_in: false, models: [], modes: [] };
 const INSTALLING = { release: null, failure: null, installing: true, ...SIGNED_OUT };
 function select(options, category) {
@@ -69,13 +71,6 @@ async function models(kind, adapter, known) {
     }
     return { models: offered, modes };
 }
-async function signedIn(kind, cli, known, signal) {
-    const probe = CLIS[kind].signedIn;
-    // A sign-in check that has not answered in half a minute counts as signed out rather than stalling the report.
-    if ('command' in probe)
-        return (await run(cli, probe.command, 30_000, false, signal)).status === 0;
-    return (await offer(kind, cli, known, signal)).signed_in;
-}
 function ended(signal) {
     return new Promise((_, reject) => {
         if (signal.aborted)
@@ -102,6 +97,8 @@ async function offer(kind, cli, known, signal) {
     catch (error) {
         if (!signal?.aborted)
             process.stderr.write(`kit: ${kind} did not offer its models: ${causeOf(error)}\n`);
+        if (signedOut(error))
+            return SIGNED_OUT;
         return {
             signed_in: adapter === undefined && 'initializeMeta' in probe ? known.signed_in : true,
             models: known.models,
@@ -113,10 +110,11 @@ async function offer(kind, cli, known, signal) {
     }
 }
 function reported(kind, reading) {
+    const { minimum, update } = CLIS[kind];
     return {
         kind,
         release: reading.release,
-        ...(reading.minimum === undefined ? {} : { minimum: reading.minimum }),
+        ...(reading.release !== null && below(reading.release, minimum) ? { minimum, update } : {}),
         failure: reading.failure,
         ...(reading.installing === undefined ? {} : { installing: reading.installing }),
         signed_in: reading.signed_in,
@@ -126,10 +124,6 @@ function reported(kind, reading) {
     };
 }
 const NOT_READY = "the Agent's CLI is not ready on this computer";
-function tooOld(kind, release) {
-    const cli = CLIS[kind];
-    return `${cli.bin} ${release} is older than ${cli.minimum}, the oldest this Kit runs`;
-}
 async function sshHostKey() {
     // Listing a local host key takes a moment, so ten seconds only bounds a stuck ssh-keygen.
     const listed = await run('ssh-keygen', ['-l', '-E', 'sha256', '-f', '/etc/ssh/ssh_host_ed25519_key.pub'], 10_000);
@@ -215,12 +209,12 @@ export class Agents {
             const resolved = await this.resolve(kind);
             if (!('cli' in resolved)) {
                 this.update(kind, resolved);
-                throw new Error(resolved.failure === null ? tooOld(kind, resolved.release) : NOT_READY);
+                throw new Error(NOT_READY);
             }
             const { cli, release } = resolved;
             const known = this.readings.get(kind);
-            const kept = known?.release === null || known?.minimum !== undefined ? SIGNED_OUT : (known ?? SIGNED_OUT);
-            if (known?.release !== release || known.minimum !== undefined || this.installs.has(kind)) {
+            const kept = known?.release === null ? SIGNED_OUT : (known ?? SIGNED_OUT);
+            if (known?.release !== release || this.installs.has(kind)) {
                 this.update(kind, { release, failure: null, signed_in: kept.signed_in, models: kept.models, modes: kept.modes });
             }
             const read = this.nextRead(kind);
@@ -246,7 +240,7 @@ export class Agents {
         const known = this.readings.get(kind) ?? SIGNED_OUT;
         const owner = {};
         try {
-            await this.examine(kind, known, async (kind, cli) => ((await signedIn(kind, cli, known, signal)) ? { ...known, signed_in: true } : SIGNED_OUT), signal, owner);
+            await this.examine(kind, known, (kind, cli) => offer(kind, cli, known, AbortSignal.any([signal, AbortSignal.timeout(SIGNED_IN_READ_MS)])), signal, owner);
         }
         finally {
             this.settle(kind, owner);
@@ -318,9 +312,6 @@ export class Agents {
         const release = await versionOf(cli, signal);
         if (release === null)
             return { release: null, failure: `${cli} --version names no version`, ...SIGNED_OUT };
-        const minimum = CLIS[kind].minimum;
-        if (below(release, minimum))
-            return { release, minimum, failure: null, ...SIGNED_OUT };
         return { cli, release };
     }
     async examine(kind, known, read, signal, owner) {
@@ -339,7 +330,7 @@ export class Agents {
     }
     async load(kind) {
         const known = this.readings.get(kind);
-        if (known !== undefined && known.failure === null && known.minimum === undefined)
+        if (known !== undefined && known.failure === null)
             return;
         await this.examine(kind, SIGNED_OUT, (kind, cli, known) => this.quietOffer(kind, cli, known));
         await this.report();

package/dist/authority-main.js

@@ -1,10 +1,10 @@
-import { setGlobalProxyFromEnv } from 'node:http';
 import { HouseRefusal, post } from './api.js';
 import { readEnrolment } from './home.js';
+import { proxyUnlessRelayed } from './relay.js';
 function unanswered(error) {
     return error instanceof HouseRefusal ? error.status >= 500 : error instanceof TypeError && error.message === 'fetch failed';
 }
-setGlobalProxyFromEnv();
+proxyUnlessRelayed();
 try {
     const { house, credential } = (await readEnrolment());
     try {

package/dist/building.js

@@ -0,0 +1,46 @@
+import { createHash } from 'node:crypto';
+import { createWriteStream } from 'node:fs';
+import { rm } from 'node:fs/promises';
+import { Transform } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { readEnrolment } from './home.js';
+import { relayed } from './relay.js';
+const MANIFEST = 'bootstrap.json';
+async function served(name, signal) {
+    const enrolment = await readEnrolment();
+    if (enrolment === null)
+        throw new Error('this Kit is connected to no House');
+    const answer = await fetch(relayed(new URL(`/kit-installer/${encodeURIComponent(name)}`, enrolment.house)), { signal });
+    if (answer.status === 200 && answer.body !== null)
+        return answer;
+    await answer.body?.cancel();
+    throw new Error(`House answered ${answer.status} for ${name}`);
+}
+export async function servedDigest(name, signal) {
+    const manifest = (await (await served(MANIFEST, signal)).json());
+    const sha256 = manifest.files?.[name]?.sha256;
+    return typeof sha256 === 'string' ? sha256 : null;
+}
+export async function downloadServed(name, sha256, destination, signal, most = Infinity) {
+    const answer = await served(name, signal);
+    const digest = createHash('sha256');
+    let bytes = 0;
+    const hashed = new Transform({
+        transform(chunk, _encoding, done) {
+            bytes += chunk.length;
+            if (bytes > most)
+                return done(new Error(`${name} is larger than its pinned ${most} bytes`));
+            digest.update(chunk);
+            done(null, chunk);
+        },
+    });
+    try {
+        await pipeline(answer.body, hashed, createWriteStream(destination), { signal });
+        if (digest.digest('hex') !== sha256)
+            throw new Error(`${name} does not match its sha256`);
+    }
+    catch (error) {
+        await rm(destination, { force: true });
+        throw error;
+    }
+}

package/dist/calls.js

@@ -11,6 +11,7 @@ export class Calls {
     path = join(kitHome(), 'call-results.json');
     results;
     returned = new Set();
+    released = new Set();
     open = 0;
     constructor(house, changed) {
         this.house = house;
@@ -27,6 +28,8 @@ export class Calls {
         return this.open === 0;
     }
     carry(callId, work) {
+        if (this.released.has(callId))
+            return Promise.resolve();
         const known = this.carried.get(callId);
         const result = this.results.get(callId);
         const carried = known ?? (result === undefined ? work() : Promise.resolve({ result }));
@@ -37,7 +40,7 @@ export class Calls {
         this.open++;
         this.changed();
         return carried
-            .then(async ({ result, returned }) => {
+            .then(async ({ result, returned, release }) => {
             try {
                 await this.house.deliver(`/kit/inputs/${callId}/ack`, result);
             }
@@ -46,8 +49,13 @@ export class Calls {
                 if (this.results.delete(callId))
                     this.save();
             }
-            if (known === undefined)
-                await returned?.();
+            if (known !== undefined)
+                return;
+            if (release) {
+                this.carried.delete(callId);
+                this.released.add(callId);
+            }
+            await returned?.();
         })
             .catch(logged)
             .finally(() => {

package/dist/clis-main.js

@@ -1,8 +1,8 @@
-import { setGlobalProxyFromEnv } from 'node:http';
 import { post } from './api.js';
 import { CLIS, below, locate, versionOf } from './clis.js';
 import { readEnrolment } from './home.js';
-setGlobalProxyFromEnv();
+import { proxyUnlessRelayed } from './relay.js';
+proxyUnlessRelayed();
 try {
     const { house, credential } = (await readEnrolment());
     const { agents } = await post(house, '/kit/agents/desired', {}, credential);

package/dist/clis.js

@@ -1,10 +1,12 @@
 import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { constants, readFileSync } from 'node:fs';
-import { access, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { access, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { homedir, userInfo } from 'node:os';
 import { delimiter, dirname, isAbsolute, join } from 'node:path';
+import { downloadServed, servedDigest } from './building.js';
 import { kitHome } from './home.js';
+import { childEnvironment } from './relay.js';
 const HOUSE_EXECUTABLES = /^host_executable\(name = "house", paths = (\[.*\])\)$/m;
 function houseRule(houses) {
     return `prefix_rule(pattern = ["house"], decision = "allow")\nhost_executable(name = "house", paths = ${JSON.stringify(houses)})\n`;
@@ -14,6 +16,7 @@ const RAW_SUBTYPES = [
     'task_started',
     'task_updated',
     'task_notification',
+    'task_progress',
     'session_state_changed',
     'hook_started',
     'hook_response',
@@ -69,8 +72,9 @@ function bridgeInClaudeSandbox(bridge) {
 export const CLIS = {
     'codex-acp': {
         bin: 'codex',
-        minimum: '0.159.1',
+        minimum: '0.160.1',
         install: 'curl -fsSL https://chatgpt.com/codex/install.sh | sh',
+        update: 'codex update',
         adapter: {
             package: '@agentclientprotocol/codex-acp',
             bin: 'codex-acp',
@@ -92,8 +96,9 @@ export const CLIS = {
     },
     'claude-agent-acp': {
         bin: 'claude',
-        minimum: '2.1.286',
+        minimum: '2.1.303',
         install: 'curl -fsSL https://claude.ai/install.sh | bash',
+        update: 'claude update',
         adapter: {
             package: '@agentclientprotocol/claude-agent-acp',
             bin: 'claude-agent-acp',
@@ -110,7 +115,7 @@ export const CLIS = {
                     title,
                     settings: { sandbox: { network: bridgeInClaudeSandbox(bridge) } },
                 },
-                emitRawSDKMessages: RAW_SUBTYPES.map((subtype) => ({ type: 'system', subtype })),
+                emitRawSDKMessages: [...RAW_SUBTYPES.map((subtype) => ({ type: 'system', subtype })), { type: 'result' }],
             },
         }),
         unknownSession: (error) => answered(error).code === -32002,
@@ -124,6 +129,7 @@ export const CLIS = {
         bin: 'grok',
         minimum: '1.0.46',
         install: 'curl -fsSL https://x.ai/cli/install.sh | bash',
+        update: 'grok update',
         adapter: null,
         args: ['--sandbox', 'off', 'agent', '--always-approve', '--no-leader', 'stdio'],
         fullAccess: null,
@@ -138,7 +144,6 @@ export const CLIS = {
 };
 const KIT_PACKAGE = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
 export const KIT_RELEASE = KIT_PACKAGE.version;
-const PROXY = /^https?_proxy$/i;
 const VERSION = /\d+\.\d+\.\d+(?:-[0-9A-Za-z.]+)?/;
 // An install still running after fifteen minutes is ended and reported as failed, so a hung download cannot hold its CLI's report.
 const INSTALL_MS = 15 * 60_000;
@@ -160,15 +165,12 @@ async function installedAdapter(kind) {
         return null;
     }
 }
-export function withoutProxy() {
-    return Object.fromEntries(Object.entries(process.env).filter(([name]) => !PROXY.test(name)));
-}
 export function run(command, args, timeoutMs, detached = false, signal) {
     return new Promise((resolve) => {
         const child = spawn(command, args, {
             stdio: ['ignore', 'pipe', 'pipe'],
             timeout: timeoutMs,
-            env: withoutProxy(),
+            env: childEnvironment(),
             detached,
             signal: detached ? undefined : signal,
         });
@@ -202,15 +204,37 @@ export function run(command, args, timeoutMs, detached = false, signal) {
 export function failureOf(ran, program) {
     return ran.output.trim().slice(-CAUSE_CHARACTERS) || `${program} exited with ${ran.status ?? 'a signal'}`;
 }
+export function adapterArchive(kind) {
+    return `${kind}-${KIT_PACKAGE.peerDependencies[CLIS[kind].adapter.package]}.tar.gz`;
+}
 export async function installAdapter(kind, signal) {
     const adapter = CLIS[kind].adapter;
     if (adapter === null)
         return null;
-    const release = KIT_PACKAGE.peerDependencies[adapter.package];
-    if ((await installedAdapter(kind)) === release)
+    if ((await installedAdapter(kind)) === KIT_PACKAGE.peerDependencies[adapter.package])
         return null;
-    const ran = await run('npm', ['install', '--prefix', prefix(kind), '--cache', join(kitHome(), 'npm-cache'), '--no-save', '--no-audit', '--no-fund', '--omit=optional', `${adapter.package}@${release}`], INSTALL_MS, true, signal);
-    return ran.status === 0 ? null : failureOf(ran, 'npm');
+    const name = adapterArchive(kind);
+    const archive = `${prefix(kind)}.tar.gz`;
+    const deadline = AbortSignal.timeout(INSTALL_MS);
+    const bounded = signal === undefined ? deadline : AbortSignal.any([signal, deadline]);
+    try {
+        const sha256 = await servedDigest(name, bounded);
+        if (sha256 === null)
+            return `House serves no ${name}`;
+        await rm(prefix(kind), { recursive: true, force: true });
+        await mkdir(prefix(kind), { recursive: true });
+        await downloadServed(name, sha256, archive, bounded);
+        const ran = await run('tar', ['-xzf', archive, '-C', prefix(kind)], INSTALL_MS, true, signal);
+        return ran.status === 0 ? null : failureOf(ran, 'tar');
+    }
+    catch (error) {
+        if (deadline.aborted && signal?.aborted !== true)
+            return `${name} did not arrive within ${INSTALL_MS / 1000} seconds`;
+        return error instanceof Error ? error.message : String(error);
+    }
+    finally {
+        await rm(archive, { force: true });
+    }
 }
 export async function installCli(kind, signal) {
     const ran = await run('bash', ['-o', 'pipefail', '-c', CLIS[kind].install], INSTALL_MS, true, signal);

package/dist/connection.js

@@ -3,40 +3,13 @@ import { HouseRefusal, retryDelay } from './api.js';
 import { end, REPLACED, signInAgain } from './end.js';
 import { readEnrolment } from './home.js';
 import { relayed } from './relay.js';
+import { Silence } from './silence.js';
 import { endUnserved, KIT_WIRE } from './wire.js';
 const PATH = '/kit/stream';
 const SUBPROTOCOL = `house.kit.stream.${KIT_WIRE}`;
 const REFUSAL_HEADER = 'x-house-refusal';
 // House beats each Kit connection every thirty seconds, so two silent beats mean this Kit process cannot hear House.
 export const CONNECTION_SILENCE_MS = 60_000;
-const SYSTEM_CONNECTION_CLOCK = {
-    later: (delay, callback) => setTimeout(callback, delay),
-    clear: (timer) => clearTimeout(timer),
-};
-export class ConnectionSilence {
-    timer = null;
-    silent;
-    clock;
-    interval;
-    constructor(silent, clock = SYSTEM_CONNECTION_CLOCK, interval = CONNECTION_SILENCE_MS) {
-        this.silent = silent;
-        this.clock = clock;
-        this.interval = interval;
-    }
-    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;
-    }
-}
 function connectionUrl(house) {
     const url = new URL(PATH, house);
     url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
@@ -58,19 +31,26 @@ subscribe('undici:request:headers', (message) => {
 });
 export function holdConnection(handlers) {
     let connection = null;
+    let socket = null;
+    let paused = false;
     let failures = 0;
     const connect = async () => {
         const { house, credential } = (await readEnrolment());
+        if (paused || socket !== null)
+            return;
         refused = null;
         const opening = new WebSocket(relayed(connectionUrl(house)), {
             protocols: [SUBPROTOCOL],
             headers: { authorization: `Bearer ${credential}` },
         });
+        socket = opening;
         let opened = false;
         let silence = null;
         const closed = (event) => {
             silence?.stop();
             silence = null;
+            if (socket === opening)
+                socket = null;
             if (connection === opening)
                 connection = null;
             handlers.closed();
@@ -85,6 +65,8 @@ export function holdConnection(handlers) {
                 endUnserved(refused.text);
             if (!opened && refused !== null)
                 process.stderr.write(`kit: ${refused.message}\n`);
+            if (paused)
+                return;
             // A closed connection reopens in one to three seconds, spread so Kit processes one restart closed return apart; an opening House refused or left unanswered backs off on the jittered curve, retryable or not, since a resident outlives a House deploy.
             setTimeout(() => void connect(), opened ? 1000 + Math.random() * 2000 : retryDelay(failures++));
         };
@@ -92,7 +74,7 @@ export function holdConnection(handlers) {
             opened = true;
             failures = 0;
             connection = opening;
-            silence = new ConnectionSilence(() => {
+            silence = new Silence(CONNECTION_SILENCE_MS, () => {
                 if (connection !== opening)
                     return;
                 connection = null;
@@ -122,5 +104,13 @@ export function holdConnection(handlers) {
             connection.send(JSON.stringify(notification));
             return true;
         },
+        pause() {
+            paused = true;
+            socket?.close();
+            return () => {
+                paused = false;
+                void connect();
+            };
+        },
     };
 }