@agentshouse/kit 0.2.1-c441d29eb63f4 → 0.2.1-c4613862fad84

package/dist/update.js

@@ -1,138 +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';
-function directory() {
-    return join(kitHome(), 'update');
+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 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; 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;
-    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));
-    }
-}
-function rerun(script, callId, flags) {
+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;
     queue = Promise.resolve();
+    placed = null;
     constructor(calls) {
         this.calls = calls;
     }
-    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)) }));
     }
-    start(call) {
-        void this.enqueue(call.input_id, () => this.carry(call));
+    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));
+        }
     }
-    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;
+    placedRelease() {
+        return this.placed;
+    }
+    queued(work) {
+        const taken = this.queue.then(work);
+        this.queue = taken.catch(() => undefined);
+        return taken;
     }
-    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') !== call.sha256) {
-            return { refused: 'the Kit bootstrap does not match its sha256' };
+    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 place(release, which) {
+        const signal = AbortSignal.timeout(PLACEMENT_MS);
+        let version = release;
+        let failure;
+        try {
+            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);
         }
-        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',
-        };
+        catch (error) {
+            failure = signal.aborted ? `the placement did not end within ${PLACEMENT_MS / 1000} seconds` : causeOf(error);
+        }
+        if (failure !== null) {
+            const refused = `Kit ${version} could not be placed: ${failure}`;
+            process.stderr.write(`kit: ${refused}\n`);
+            return refused;
+        }
+        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-c441d29eb63f4",
+  "version": "0.2.1-c4613862fad84",
   "description": "Kit connects an Environment to agents.house.",
   "license": "MIT",
   "repository": {
@@ -12,28 +12,27 @@
     "kit": "dist/kit-main.js",
     "house": "dist/house-main.js"
   },
-  "exports": {
-    "./bootstrap": "./dist/bootstrap.json"
-  },
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.build.json && node scripts/bootstrap-manifest.mjs",
+    "bootstrap-manifest": "node scripts/bootstrap-manifest.mjs",
+    "build": "tsc -p tsconfig.build.json",
     "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",
+    "release-files": "node scripts/release-files.mjs",
     "test": "tsc -p tsconfig.json && vitest run"
   },
   "dependencies": {
-    "@agentclientprotocol/sdk": "1.7.0",
-    "@agentshouse/mdmodel": "0.1.0-cabd61587647f",
-    "@agentshouse/skills": "0.1.0-c6411c39c6d0f",
+    "@agentclientprotocol/sdk": "2.0.1",
+    "@agentshouse/mdmodel": "0.1.0-c4f4d37bc9d6a",
+    "@agentshouse/skills": "0.1.0-ca0e7383018fc",
     "@lydell/node-pty": "1.2.0-beta.15",
     "yaml": "2.9.1"
   },
   "peerDependencies": {
-    "@agentclientprotocol/claude-agent-acp": "0.85.1",
-    "@agentclientprotocol/codex-acp": "2.1.1"
+    "@agentclientprotocol/claude-agent-acp": "0.94.0",
+    "@agentclientprotocol/codex-acp": "2.2.2"
   },
   "peerDependenciesMeta": {
     "@agentclientprotocol/claude-agent-acp": {
@@ -44,26 +43,26 @@
     }
   },
   "devDependencies": {
-    "@types/node": "24.13.6",
+    "@types/node": "24.19.2",
     "@types/ws": "8.18.2",
     "typescript": "7.0.2",
-    "vitest": "5.0.1",
+    "vitest": "5.0.5",
     "ws": "8.22.0"
   },
-  "packageManager": "npm@11.19.0",
+  "packageManager": "npm@11.19.1",
   "engines": {
-    "node": "24.21.0",
-    "npm": "11.19.0"
+    "node": "24.22.1",
+    "npm": "11.19.1"
   },
   "devEngines": {
     "runtime": {
       "name": "node",
-      "version": "24.21.0",
+      "version": "24.22.1",
       "onFail": "error"
     },
     "packageManager": {
       "name": "npm",
-      "version": "11.19.0",
+      "version": "11.19.1",
       "onFail": "error"
     }
   }

package/dist/bootstrap.json

@@ -1,24 +0,0 @@
-{
-  "schemaVersion": 2,
-  "version": "0.2.1-c441d29eb63f4",
-  "hosts": {
-    "macos": {
-      "asset": {
-        "name": "connect-linux.sh",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-c441d29eb63f4/connect-linux.sh"
-      }
-    },
-    "linux": {
-      "asset": {
-        "name": "connect-linux.sh",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-c441d29eb63f4/connect-linux.sh"
-      }
-    },
-    "windows": {
-      "asset": {
-        "name": "connect-windows.ps1",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-c441d29eb63f4/connect-windows.ps1"
-      }
-    }
-  }
-}

package/dist/clis-main.js

@@ -1,23 +0,0 @@
-import { setGlobalProxyFromEnv } from 'node:http';
-import { post } from './api.js';
-import { CLIS, below, locate, versionOf } from './clis.js';
-import { readEnrolment } from './home.js';
-setGlobalProxyFromEnv();
-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;
-}

package/dist/web-wizard.js

@@ -1,100 +0,0 @@
-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);
-    }
-}