@agentshouse/kit 0.2.1-ceeaf32286734 → 0.2.1-cf268dff1869b

package/README.md

@@ -9,25 +9,25 @@ Run `sh -c 'kit=$(curl -fsSL "$0") || { echo "Kit could not be downloaded; run t
 or `& { try { $kit = irm agents.house/kit.ps1 } catch { throw 'Kit could not be downloaded; run this command again.' }; & ([scriptblock]::Create($kit)) @args }` on Windows, which run nothing of a failed download, and again to update; options follow `agents.house/kit`.
 On macOS and Linux it installs Kit natively under your own account, without an admin password, as a service that runs
 while you are logged in. `kit` and `house` are then on your login shell's `PATH`, and your workspace is `~/AgentsHouse` unless you
-pass `--workspace <path>`.
+pass `--workspace <path>`. Every run places the Kit release your Building serves, with the Node.js and agent adapters it runs on, in a directory of its own beside the one that runs, then starts it; the earlier one stays until the next release. Kit also updates itself: when your Building takes another release, Kit places it the same way and, once no turn is open, ends so its service, or the container's restart policy, starts it. When House refuses the Kit that runs as too old or too new, Kit places your Building's release at once, ending any running turn, and ends the same way; while it cannot, it stays offline, prints why with the command that installs it again, and tries again regularly.
 
-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.
+Add `--container` to run Kit in one Docker container instead, with your workspace mounted at `/agents/house`; your Agents then reach only that
+workspace. The container's image holds no Kit release and no Node.js: every run places them in Kit home's `kit` folder, which a container created again keeps. On Windows,
+Kit home is the Docker volume `house-kit-home` and 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 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
-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
-release installs. Add `--no-skills` to the command to leave them out; running it again without the flag brings them back.
+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 each agent CLI through the link your login shell finds and installs a missing one through that CLI's own
+installer. When it starts and regularly after, Kit runs each CLI's own update command, such as `claude update`, beside
+your conversations: a running conversation keeps its version and the next one runs the new release. 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 its update command. Kit also gives every Agent on the Environment the agent skills of
+`@agentshouse/skills`, at the version each Kit release installs. Add `--no-skills` to the command to leave them out; running it again without the flag brings them back.
 
 ## Commands
 

package/dist/agents.js

@@ -1,14 +1,15 @@
 import { client } from '@agentclientprotocol/sdk';
-import { readFile, realpath } from 'node:fs/promises';
+import { readFile } from 'node:fs/promises';
 import { setTimeout as delay } from 'node:timers/promises';
 import { signedOut, startAdapter } from './acp.js';
-import { CLIS, KIT_RELEASE, below, installAdapter, installCli, locate, run, versionOf } from './clis.js';
+import { CLIS, KIT_RELEASE, below, installCli, locate, run, updateCli, versionOf } from './clis.js';
 import { agentBase, kitHome } from './home.js';
-import { updatesItself } from './placement.js';
 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 CLI's maker can publish several releases a day, so running each chosen CLI's update command hourly brings a new one to the next conversation within the hour for one small check.
+export const CLI_UPDATE_MS = 60 * 60_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: [] };
@@ -110,10 +111,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,
@@ -123,10 +125,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);
@@ -168,13 +166,15 @@ export class Agents {
     sending = Promise.resolve();
     sent = null;
     refreshing = 0;
+    loaded = Promise.resolve();
+    updating = null;
     changed;
     constructor(house, changed = () => undefined) {
         this.house = house;
         this.changed = changed;
     }
     idle() {
-        return this.refreshing === 0;
+        return this.refreshing === 0 && this.updating === null;
     }
     read() {
         return this.reading.then(() => undefined, () => undefined);
@@ -190,7 +190,7 @@ export class Agents {
             return this.desired;
         });
         this.reading = reading;
-        reading
+        this.loaded = reading
             .then(({ agents, transcribe }) => Promise.all([
             holdTranscription(transcribe)
                 .then((changed) => (changed ? this.report() : undefined))
@@ -206,18 +206,22 @@ export class Agents {
         });
         return reading.then(() => undefined);
     }
+    keepCurrent() {
+        this.updateAll(this.loaded);
+        setInterval(() => this.updateAll(Promise.resolve()), CLI_UPDATE_MS);
+    }
     cli(kind) {
         this.starts += 1;
         return this.queue(kind, async () => {
             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);
@@ -284,9 +288,6 @@ export class Agents {
         return signal === undefined ? queued : Promise.race([queued, ended(signal)]);
     }
     async ensure(kind, signal, owner = {}) {
-        const failed = await installAdapter(kind, signal);
-        if (failed !== null)
-            throw new Error(failed);
         const found = await locate(kind, signal);
         if (found !== null)
             return found;
@@ -305,7 +306,7 @@ export class Agents {
     async resolve(kind, signal, owner) {
         let cli;
         try {
-            cli = await realpath(await this.ensure(kind, signal, owner));
+            cli = await this.ensure(kind, signal, owner);
         }
         catch (error) {
             const failure = causeOf(error);
@@ -315,9 +316,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) {
@@ -327,6 +325,35 @@ export class Agents {
         if (this.reads.get(kind) === current && !signal?.aborted)
             this.hold(kind, reading);
     }
+    updateAll(after) {
+        if (this.updating !== null)
+            return;
+        this.updating = after
+            .then(async () => {
+            for (const kind of this.desired.agents) {
+                if (this.installs.has(kind) || !this.readings.get(kind)?.release)
+                    continue;
+                const failure = await updateCli(kind);
+                if (failure !== null)
+                    process.stderr.write(`kit: ${kind} did not update: ${failure}\n`);
+                await this.readVersion(kind);
+            }
+        })
+            .catch(logged)
+            .finally(() => {
+            this.updating = null;
+            this.changed();
+        });
+        this.changed();
+    }
+    async readVersion(kind) {
+        const cli = await locate(kind);
+        const release = cli === null ? null : await versionOf(cli);
+        const current = this.readings.get(kind);
+        if (release === null || !current?.release || current.release === release)
+            return;
+        this.update(kind, { ...current, release });
+    }
     async quietOffer(kind, cli, known) {
         for (let seen = -1; seen !== this.starts;) {
             seen = this.starts;
@@ -336,7 +363,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();
@@ -353,7 +380,6 @@ export class Agents {
             ...(form === undefined ? {} : { form }),
             kit_release: KIT_RELEASE,
             wire: KIT_WIRE,
-            updates_itself: await updatesItself(),
             agent_base: agentBase(),
             agents,
             transcription: transcriptionReport(),

package/dist/building.js

@@ -16,10 +16,14 @@ async function served(name, signal) {
     await answer.body?.cancel();
     throw new Error(`House answered ${answer.status} for ${name}`);
 }
-export async function servedDigest(name, signal) {
+export async function servedRelease(signal) {
     const manifest = (await (await served(MANIFEST, signal)).json());
-    const sha256 = manifest.files?.[name]?.sha256;
-    return typeof sha256 === 'string' ? sha256 : null;
+    const installer = manifest.hosts?.linux;
+    const sha256 = typeof installer === 'string' ? manifest.files?.[installer]?.sha256 : undefined;
+    if (typeof manifest.version !== 'string' || typeof installer !== 'string' || typeof sha256 !== 'string') {
+        throw new Error(`House serves no Kit release in ${MANIFEST}`);
+    }
+    return { version: manifest.version, installer, sha256 };
 }
 export async function downloadServed(name, sha256, destination, signal, most = Infinity) {
     const answer = await served(name, signal);

package/dist/clis.js

@@ -1,11 +1,10 @@
 import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { constants, readFileSync } from 'node:fs';
-import { access, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { access, mkdir, readFile, rename, 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 { releaseDirectory } from './placement.js';
 import { childEnvironment } from './relay.js';
 const HOUSE_EXECUTABLES = /^host_executable\(name = "house", paths = (\[.*\])\)$/m;
 function houseRule(houses) {
@@ -74,6 +73,7 @@ export const CLIS = {
         bin: 'codex',
         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',
@@ -97,6 +97,7 @@ export const CLIS = {
         bin: 'claude',
         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',
@@ -127,6 +128,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,
@@ -142,25 +144,13 @@ 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 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.
+// An install or update still running after fifteen minutes is ended as failed, so a hung download can neither hold its CLI's report nor keep the Kit busy.
 const INSTALL_MS = 15 * 60_000;
 // A login shell or a version read is ended after half a minute, so a profile that waits for input cannot stall the report.
 const READ_MS = 30_000;
 const CAUSE_CHARACTERS = 4000;
-function prefix(kind) {
-    return join(kitHome(), 'agents', kind);
-}
 export function adapterCommand(kind) {
-    return join(prefix(kind), 'node_modules', '.bin', CLIS[kind].adapter.bin);
-}
-async function installedAdapter(kind) {
-    try {
-        const manifest = join(prefix(kind), 'node_modules', CLIS[kind].adapter.package, 'package.json');
-        return JSON.parse(await readFile(manifest, 'utf8')).version;
-    }
-    catch {
-        return null;
-    }
+    return join(releaseDirectory(KIT_RELEASE), 'adapters', kind, 'node_modules', '.bin', CLIS[kind].adapter.bin);
 }
 export function run(command, args, timeoutMs, detached = false, signal) {
     return new Promise((resolve) => {
@@ -204,38 +194,15 @@ export function failureOf(ran, program) {
 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;
-    if ((await installedAdapter(kind)) === KIT_PACKAGE.peerDependencies[adapter.package])
-        return null;
-    const name = adapterArchive(kind);
-    const archive = `${prefix(kind)}.tar.gz`;
+async function bounded(program, work, signal) {
     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 });
-    }
+    const ran = await work(signal === undefined ? deadline : AbortSignal.any([signal, deadline]));
+    if (deadline.aborted && signal?.aborted !== true)
+        return `${program} did not end within ${INSTALL_MS / 1000} seconds`;
+    return ran.status === 0 ? null : failureOf(ran, program);
 }
-export async function installCli(kind, signal) {
-    const ran = await run('bash', ['-o', 'pipefail', '-c', CLIS[kind].install], INSTALL_MS, true, signal);
-    return ran.status === 0 ? null : failureOf(ran, 'the install');
+export function installCli(kind, signal) {
+    return bounded('the install', (within) => run('bash', ['-o', 'pipefail', '-c', CLIS[kind].install], INSTALL_MS, true, within), signal);
 }
 function loginShell() {
     return process.env.SHELL || userInfo().shell;
@@ -243,8 +210,8 @@ function loginShell() {
 const FOUND = 'house-kit-cli ';
 const LOOKUP = `found=$(command -v "$1") || exit 0; case $found in /*) ;; *) found=$(pwd -P)/$found ;; esac; printf "${FOUND}%s\\n" "$found"`;
 const USER_BIN = 'case ":$PATH:" in *":$HOME/.local/bin:"*) ;; *) PATH="$PATH:$HOME/.local/bin" ;; esac; export PATH';
-function inLoginShell(script, argument = '', signal) {
-    return run(loginShell(), ['-l', '-i', '-c', `exec /bin/sh -c '${USER_BIN}; ${script}' sh ${argument}`], READ_MS, true, signal);
+function inLoginShell(script, argument = '', signal, timeoutMs = READ_MS) {
+    return run(loginShell(), ['-l', '-i', '-c', `exec /bin/sh -c '${USER_BIN}; ${script}' sh ${argument}`], timeoutMs, true, signal);
 }
 export async function onLoginPath(program, signal) {
     const ran = await inLoginShell(LOOKUP, program, signal);
@@ -253,6 +220,9 @@ export async function onLoginPath(program, signal) {
 export function locate(kind, signal) {
     return onLoginPath(CLIS[kind].bin, signal);
 }
+export function updateCli(kind) {
+    return bounded('the update', (within) => inLoginShell(CLIS[kind].update, '', within, INSTALL_MS));
+}
 export async function loginPath() {
     const marker = 'house-kit-path ';
     const ran = await inLoginShell(`printf "${marker}%s\\n" "$PATH"`);

package/dist/connection.js

@@ -4,7 +4,7 @@ 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';
+import { endUnserved, KIT_WIRE, unserved } from './wire.js';
 const PATH = '/kit/stream';
 const SUBPROTOCOL = `house.kit.stream.${KIT_WIRE}`;
 const REFUSAL_HEADER = 'x-house-refusal';
@@ -32,11 +32,10 @@ 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)
+        if (socket !== null || unserved())
             return;
         refused = null;
         const opening = new WebSocket(relayed(connectionUrl(house)), {
@@ -65,8 +64,6 @@ 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++));
         };
@@ -104,13 +101,5 @@ export function holdConnection(handlers) {
             connection.send(JSON.stringify(notification));
             return true;
         },
-        pause() {
-            paused = true;
-            socket?.close();
-            return () => {
-                paused = false;
-                void connect();
-            };
-        },
     };
 }

package/dist/end.js

@@ -14,7 +14,7 @@ export function end(reason) {
 export function restart(reason) {
     exit(reason, 1);
 }
-function updateLine(lead) {
+export function updateLine(lead) {
     const command = installCommand();
     return command === null ? `${lead}; install it again.` : `${lead}. Update it: ${command}`;
 }

package/dist/home.js

@@ -8,7 +8,6 @@ const ENROLMENT = 'credential.json';
 const DISCONNECTED = 'disconnected.json';
 const CONFIGURATION = 'kit.json';
 const OWN_AGENT = 'own-agent.json';
-const RESTART = 'restart';
 let defaulted;
 function writable(directory) {
     try {
@@ -132,12 +131,6 @@ export async function forgetRejected(rejected) {
 export function enrolled() {
     return existsSync(join(kitHome(), ENROLMENT));
 }
-export function restartAsked() {
-    return existsSync(join(kitHome(), RESTART));
-}
-export function forgetRestart() {
-    return rm(join(kitHome(), RESTART), { force: true });
-}
 export function readOwnAgent() {
     return readHome(OWN_AGENT);
 }

package/dist/placement.js

@@ -1,23 +1,6 @@
 import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { run } from './clis.js';
+import { join, resolve } from 'node:path';
 import { kitHome } from './home.js';
-export function service() {
-    if (process.platform !== 'linux' || !process.env.INVOCATION_ID)
-        return null;
-    return process.env.MANAGERPID ? 'user' : 'system';
-}
-export function throughSudo() {
-    return service() === 'system' && process.getuid() !== 0;
-}
-export async function updatesItself() {
-    if (service() === null)
-        return false;
-    if (!throughSudo())
-        return true;
-    // sudo answers at once, so ten seconds only bounds a stuck sudo.
-    return (await run('sudo', ['-n', 'true'], 10_000)).status === 0;
-}
 function recorded(name) {
     try {
         return readFileSync(join(kitHome(), name), 'utf8').trim();
@@ -37,3 +20,12 @@ export function machine() {
         return placed;
     return process.platform === 'darwin' ? 'macos' : 'linux';
 }
+export function placedPrefix() {
+    const prefix = process.env.HOUSE_KIT_PREFIX;
+    if (prefix === undefined || prefix === '')
+        throw new Error('this Kit process was not started by a launcher its installer placed');
+    return resolve(prefix);
+}
+export function releaseDirectory(release) {
+    return join(placedPrefix(), 'releases', release);
+}

package/dist/resident.js

@@ -11,7 +11,7 @@ import { received } from './bridge.js';
 import { CONVERSATION_METHODS, Conversations } from './conversations.js';
 import { LocalCopies } from './copies.js';
 import { restart, unknownMethod } from './end.js';
-import { agentBase, enrolled, forgetRestart, kitHome, ownerLock, ownerSocket, readEnrolment, restartAsked } from './home.js';
+import { agentBase, enrolled, kitHome, ownerLock, ownerSocket, readEnrolment } from './home.js';
 import { Calls } from './calls.js';
 import { killDescendants } from './scope.js';
 import { removeInputs, Scripts } from './scripts.js';
@@ -20,6 +20,7 @@ import { SignIns } from './sign-in.js';
 import { placeSkillSet } from './skills.js';
 import { holdConnection } from './connection.js';
 import { KitUpdate } from './update.js';
+import { takeUnservedRelease } from './wire.js';
 import { codexLauncher } from './work.js';
 function report(error) {
     process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
@@ -110,7 +111,6 @@ function connected() {
 }
 async function started() {
     await connected();
-    await forgetRestart();
     watch(kitHome(), () => {
         if (enrolled())
             return;
@@ -140,11 +140,8 @@ export async function resident() {
         if (!idle()) {
             reported = false;
         }
-        else if (restartAsked() && conversations.quiet()) {
-            restart('restarting for an updated CLI');
-        }
-        else if (update.held() && conversations.quiet()) {
-            update.apply(connection.pause());
+        else if (update.placedRelease() !== null && conversations.quiet()) {
+            restart(`Kit ${update.placedRelease()} is placed; its supervisor starts it`);
         }
         else if (!reported) {
             reported = true;
@@ -161,7 +158,9 @@ export async function resident() {
         changed,
     });
     const signIns = new SignIns(house, agents, calls);
-    const update = new KitUpdate(calls, changed);
+    const update = new KitUpdate(calls);
+    if (process.env.HOUSE_KIT_SANDBOX !== '1')
+        takeUnservedRelease((release) => logged(update.takeRefused(release)));
     removeInputs();
     const scripts = new Scripts(calls, (notification) => connection?.send(notification) ?? false);
     for (const signal of ['SIGTERM', 'SIGINT']) {
@@ -172,8 +171,8 @@ export async function resident() {
         });
     }
     await house.deliver('/kit/restarted', {}).catch(report);
-    await update.resumed().catch(report);
     logged(agents.refresh());
+    agents.keepCurrent();
     connection = holdConnection({
         opened: () => {
             conversations.opened();
@@ -185,7 +184,7 @@ export async function resident() {
             if (call.kind === 'sign_in')
                 signIns.start(call);
             else if (call.kind === 'update')
-                update.hold(call);
+                update.take(call);
             else if (call.kind === 'run_wizard' || call.kind === 'run_function')
                 scripts.start(call);
             else if (CONVERSATION_METHODS.has(call.kind))

package/dist/scope.js

@@ -1,5 +1,5 @@
 import { execFileSync } from 'node:child_process';
-import { mkdirSync, readdirSync, readFileSync, rmdirSync, statSync, writeFileSync } from 'node:fs';
+import { mkdirSync, readdirSync, readFileSync, realpathSync, rmdirSync, statSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 const LISTING_BYTES = 1 << 28;
 const CGROUPS = '/sys/fs/cgroup';
@@ -122,15 +122,23 @@ function members(group) {
     }
     return pids;
 }
+function besideCli(cli) {
+    try {
+        return `${realpathSync(cli)}-`;
+    }
+    catch {
+        return null;
+    }
+}
 export class Scope {
     marker;
-    cli;
+    helpers;
     group;
     session = null;
     recorded = null;
     constructor(marker, name, cli) {
         this.marker = marker;
-        this.cli = cli;
+        this.helpers = besideCli(cli);
         const own = ownGroup();
         this.group = own === null ? null : join(own, name);
         try {
@@ -168,7 +176,7 @@ export class Scope {
             return true;
         if (this.recorded === null)
             return found.size > 0;
-        return [...found].some(([pid, { session, command }]) => session !== this.session || !(this.recorded.has(pid) || command.startsWith(`${this.cli}-`)));
+        return [...found].some(([pid, { session, command }]) => session !== this.session || !(this.recorded.has(pid) || (this.helpers !== null && command.startsWith(this.helpers))));
     }
     empty() {
         return this.found()?.size === 0;

package/dist/update.js

@@ -1,181 +1,127 @@
 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';
-import { relayed } from './relay.js';
-const BOOTSTRAP_BYTES = 1_000_000;
-// A bootstrap is at most a million bytes, so two minutes carry it over ten kilobytes a second and no stalled host holds the update queue.
-const BOOTSTRAP_MS = 120_000;
-// A bootstrap's downloads and CLI updates take minutes, so one still running after an hour has hung and is ended before it keeps the Kit offline.
-const RERUN_MS = 60 * 60_000;
-const TIMED_OUT = '124';
-function directory() {
-    return join(kitHome(), 'update');
-}
-function pending() {
-    return join(directory(), 'pending.json');
-}
-function outcome() {
-    return join(directory(), 'outcome');
-}
-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; timeout ${RERUN_MS / 1000} bash "$0" "$@"; printf %s "$?" > "$outcome"; ${[...elevated(), 'systemctl', ...manager(), 'start', 'house-kit.service'].join(' ')}`;
-}
-async function pendingCall() {
-    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;
-    if (status.trim() === TIMED_OUT)
-        return { refused: `the Kit bootstrap did not finish within ${RERUN_MS / 1000} seconds` };
-    return status.trim() === '0' ? {} : { refused: `the Kit bootstrap exited with ${status.trim()}` };
-}
-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 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', [...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));
-    }
-}
-async function bounded(body, most) {
-    const chunks = [];
-    let bytes = 0;
-    for await (const chunk of body ?? []) {
-        bytes += chunk.length;
-        if (bytes > most)
-            return null;
-        chunks.push(chunk);
-    }
-    return Buffer.concat(chunks, bytes);
-}
-function rerun(script, callId, flags) {
+import { downloadServed, servedRelease } from './building.js';
+import { KIT_RELEASE } from './clis.js';
+import { restart, updateLine } from './end.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;
+// A refused Kit is offline until its placement succeeds, so it tries again within five minutes of its Building or this computer recovering, while a placement that fails only after its hundred-megabyte download runs at most twelve times an hour.
+export const PLACEMENT_RETRY_MS = 5 * 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 placing(installer, house, prefix, signal) {
     return new Promise((resolve) => {
-        const [command, ...args] = [
-            ...elevated(),
-            'systemd-run',
-            ...manager(),
-            ...account(),
-            '--wait',
-            '--collect',
-            '--quiet',
-            `--unit=${unit(callId)}`,
-            `--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 process' }));
-        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 KitUpdate {
     calls;
-    changed;
-    waiting = new Map();
     queue = Promise.resolve();
-    constructor(calls, changed) {
+    placed = null;
+    constructor(calls) {
         this.calls = calls;
-        this.changed = changed;
     }
-    async resumed() {
-        const callId = await pendingCall();
-        if (callId === null)
-            return;
-        await this.enqueue(callId, () => finished(callId));
+    take(call) {
+        void this.calls.carry(call.input_id, async () => ({ result: await this.queued(() => this.update(call.release)) }));
     }
-    hold(call) {
-        this.waiting.set(call.input_id, call);
-        this.changed();
+    async takeRefused(release) {
+        for (;;) {
+            const failure = await this.queued(async () => (this.placed === null ? this.place(release, 'served') : null));
+            if (failure === null)
+                restart(`Kit ${this.placed} is placed; its supervisor starts it`);
+            process.stderr.write(`kit: ${updateLine(`Kit ${KIT_RELEASE} stays offline and tries again in ${PLACEMENT_RETRY_MS / 60_000} minutes`)}\n`);
+            await new Promise((resolve) => setTimeout(resolve, PLACEMENT_RETRY_MS));
+        }
     }
-    held() {
-        return this.waiting.size > 0;
+    placedRelease() {
+        return this.placed;
     }
-    apply(resume) {
-        const held = [...this.waiting.values()];
-        this.waiting.clear();
-        void Promise.all(held.map((call) => this.enqueue(call.input_id, () => this.carry(call)))).then(resume);
+    queued(work) {
+        const taken = this.queue.then(work);
+        this.queue = taken.catch(() => undefined);
+        return taken;
     }
-    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 update(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 failure = await this.place(release, 'named');
+        if (failure !== null)
+            return { refused: failure };
+        process.stderr.write(`kit: Kit ${release} is placed; it starts once no turn is open\n`);
+        return {};
     }
-    async carry(call) {
-        if ((await pendingCall()) === call.input_id)
-            return finished(call.input_id);
-        const deadline = AbortSignal.timeout(BOOTSTRAP_MS);
-        let script;
+    async place(release, which) {
+        const signal = AbortSignal.timeout(PLACEMENT_MS);
+        let version = release;
+        let failure;
         try {
-            const answer = await fetch(relayed(call.bootstrap), { signal: deadline });
-            if (!answer.ok)
-                return { refused: `the Kit bootstrap could not be downloaded: ${answer.status}` };
-            script = await bounded(answer.body, BOOTSTRAP_BYTES);
+            const prefix = placedPrefix();
+            const served = await servedRelease(signal);
+            if (which === 'named' && served.version !== release)
+                throw new Error(`the Building serves Kit ${served.version}, not Kit ${release}`);
+            version = served.version;
+            if (version === KIT_RELEASE)
+                throw new Error(`the Building serves Kit ${KIT_RELEASE}, which this Kit runs`);
+            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);
         }
         catch (error) {
-            if (!deadline.aborted)
-                throw error;
-            return { refused: `the Kit bootstrap did not arrive within ${BOOTSTRAP_MS / 1000} seconds` };
+            failure = signal.aborted ? `the placement did not end within ${PLACEMENT_MS / 1000} seconds` : causeOf(error);
         }
-        if (script === null)
-            return { refused: `the Kit bootstrap is larger than ${BOOTSTRAP_BYTES} bytes` };
-        if (createHash('sha256').update(script).digest('hex') !== call.sha256) {
-            return { refused: 'the Kit bootstrap does not match its sha256' };
+        if (failure !== null) {
+            const refused = `Kit ${version} could not be placed: ${failure}`;
+            process.stderr.write(`kit: ${refused}\n`);
+            return refused;
         }
-        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: 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',
-        };
+        this.placed = version;
+        return null;
     }
 }

package/dist/wire.js

@@ -1,9 +1,11 @@
 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 = 4;
 export const KIT_WIRE_HEADER = 'x-house-kit-wire';
-function newer(text) {
+let take = null;
+let taken = false;
+function unservedBy(text) {
     let body;
     try {
         body = JSON.parse(text);
@@ -11,12 +13,28 @@ function newer(text) {
     catch {
         return null;
     }
-    return body?.error?.code === 'kit_newer_than_house' ? body.error : null;
+    const error = body?.error;
+    if (error?.code !== 'kit_update_required' && error?.code !== 'kit_newer_than_house')
+        return null;
+    return typeof error.release === 'string' ? error : null;
+}
+export function takeUnservedRelease(taking) {
+    take = taking;
+}
+export function unserved() {
+    return taken;
 }
 export function endUnserved(text) {
+    const refused = unservedBy(text);
+    if (refused !== null && take !== null) {
+        if (!taken) {
+            taken = true;
+            take(refused.release);
+        }
+        return;
+    }
     if (refusalOf(text)?.code === 'kit_update_required')
         updateRequired();
-    const refused = newer(text);
-    if (refused !== null)
+    if (refused?.code === 'kit_newer_than_house')
         newerThanHouse(refused.release, refused.commands[machine()]);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/kit",
-  "version": "0.2.1-ceeaf32286734",
+  "version": "0.2.1-cf268dff1869b",
   "description": "Kit connects an Environment to agents.house.",
   "license": "MIT",
   "repository": {
@@ -26,7 +26,7 @@
   "dependencies": {
     "@agentclientprotocol/sdk": "2.0.1",
     "@agentshouse/mdmodel": "0.1.0-c4f4d37bc9d6a",
-    "@agentshouse/skills": "0.1.0-c27d55a17e1d8",
+    "@agentshouse/skills": "0.1.0-cdd0f15bef719",
     "@lydell/node-pty": "1.2.0-beta.15",
     "yaml": "2.9.1"
   },

package/dist/clis-main.js

@@ -1,23 +0,0 @@
-import { post } from './api.js';
-import { CLIS, below, locate, versionOf } from './clis.js';
-import { readEnrolment } from './home.js';
-import { proxyUnlessRelayed } from './relay.js';
-proxyUnlessRelayed();
-try {
-    const { house, credential } = (await readEnrolment());
-    const { agents } = await post(house, '/kit/agents/desired', {}, credential);
-    for (const kind of agents) {
-        const cli = await locate(kind);
-        if (cli === null)
-            continue;
-        const release = await versionOf(cli);
-        if (release === null)
-            continue;
-        const { bin, minimum } = CLIS[kind];
-        process.stdout.write(`${[bin, cli, release, minimum, below(release, minimum) ? 'old' : 'current'].join('\t')}\n`);
-    }
-}
-catch (error) {
-    process.stderr.write(`kit: ${error.message}\n`);
-    process.exitCode = 1;
-}