@agentshouse/kit 0.2.1-c3e4a20bb3183 → 0.2.1-c4ea88ba9424e

package/dist/login.js

@@ -4,7 +4,8 @@ import { hostname } from 'node:os';
 import { createInterface } from 'node:readline/promises';
 import { parseArgs } from 'node:util';
 import { post } from './api.js';
-import { forgetOwnAgent, readEnrolment, readOwnAgent, writeEnrolment, writeOwnAgent } from './home.js';
+import { placeAppGit } from './app-git.js';
+import { forgetOwnAgent, readDisconnected, readEnrolment, readOwnAgent, writeEnrolment, writeOwnAgent } from './home.js';
 import { callHouse, rpc } from './mcp.js';
 const DEFAULT_HOUSE = 'https://agents.house';
 function listen() {
@@ -78,7 +79,7 @@ export async function login(argv) {
             manual: { type: 'boolean', default: false },
         },
     });
-    const enrolled = await readEnrolment();
+    const enrolled = (await readEnrolment()) ?? (await readDisconnected());
     const house = values.house ?? enrolled?.house ?? DEFAULT_HOUSE;
     const replaces = process.env.HOUSE_KIT_REPLACES;
     const environment = replaces === undefined ? (values.environment ?? (enrolled?.house === house ? enrolled.environment : undefined)) : undefined;
@@ -104,6 +105,7 @@ export async function login(argv) {
             process.stdout.write("This computer's own agent was another User's; run kit login again to connect it to you.\n");
         }
     };
+    const placeGit = async () => placeAppGit(ownAgent, await readOwnAgent());
     if (values.manual) {
         const { start_url } = await post(house, '/kit', {
             ...started,
@@ -111,6 +113,7 @@ export async function login(argv) {
         });
         process.stdout.write(`Open this link and confirm: ${start_url}\n`);
         await exchange(await typed('Code: '));
+        await placeGit();
         return;
     }
     const callback = await listen();
@@ -133,4 +136,5 @@ export async function login(argv) {
     finally {
         callback.close();
     }
+    await placeGit();
 }

package/dist/logout.js

@@ -0,0 +1,21 @@
+import { HouseRefusal, post } from './api.js';
+import { forgetAppGit } from './app-git.js';
+import { forgetEnrolment, readEnrolment } from './home.js';
+export async function logout() {
+    const enrolled = await readEnrolment();
+    if (enrolled === null) {
+        await forgetAppGit();
+        process.stdout.write('This computer is not connected to House.\n');
+        return;
+    }
+    try {
+        await post(enrolled.house, '/kit/logout', {}, enrolled.credential);
+    }
+    catch (error) {
+        if (!(error instanceof HouseRefusal && error.status === 401))
+            throw error;
+    }
+    await forgetEnrolment(enrolled);
+    await forgetAppGit();
+    process.stdout.write(`Environment ${enrolled.environment} is disconnected; kit login reconnects it.\n`);
+}

package/dist/mcp.js

@@ -1,5 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { KIT_VERSION } from './clis.js';
+import { relayed } from './relay.js';
 const MCP_PROTOCOL_VERSION = '2026-07-28';
 export const UNREACHABLE = 'House is unreachable; call again in a minute';
 export function rpc(method, params) {
@@ -21,7 +22,7 @@ export function mcpBody(message, operation) {
 }
 export async function callHouse(origin, credential, message, operation = null, signal) {
     const tool = message.method === 'tools/call' ? String(message.params.name) : null;
-    const answer = await fetch(new URL('/', origin), {
+    const answer = await fetch(relayed(new URL('/', origin)), {
         method: 'POST',
         headers: {
             'content-type': 'application/json',

package/dist/refusals.js

@@ -21,6 +21,18 @@ function spoken(text) {
     const detail = said.indexOf('\n');
     return { code: head[1], text: said, conflicts: detail === -1 ? [] : conflictCodes(said.slice(detail + 1)) };
 }
+export function retryable(text) {
+    let body;
+    try {
+        body = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    const error = body?.error;
+    const verdict = error?.retryable ?? error?.data?.retryable;
+    return typeof verdict === 'boolean' ? verdict : null;
+}
 export function refusalOf(text) {
     let body;
     try {

package/dist/relay.js

@@ -0,0 +1,10 @@
+export function relayed(target) {
+    const url = new URL(target);
+    const relay = process.env.HOUSE_KIT_RELAY;
+    if (relay === undefined || relay === '')
+        return url;
+    const through = new URL(`${url.host}${url.pathname}${url.search}`, `${relay}/`);
+    if (url.protocol === 'wss:' || url.protocol === 'ws:')
+        through.protocol = 'wss:';
+    return through;
+}

package/dist/resident.js

@@ -1,4 +1,5 @@
 import { once } from 'node:events';
+import { watch } from 'node:fs';
 import { mkdir, rm, writeFile } from 'node:fs/promises';
 import { createServer } from 'node:http';
 import { extname, join } from 'node:path';
@@ -9,7 +10,8 @@ import { house } from './api.js';
 import { received } from './bridge.js';
 import { Conversations } from './conversations.js';
 import { LocalCopies } from './copies.js';
-import { agentBase, kitHome, readEnrolment } from './home.js';
+import { agentBase, enrolled, kitHome } from './home.js';
+import { quoted } from './shell.js';
 import { SignIns } from './sign-in.js';
 import { placeSkillSet } from './skills.js';
 import { holdStream } from './stream.js';
@@ -20,9 +22,6 @@ function report(error) {
 function logged(work) {
     work.catch(report);
 }
-function quoted(value) {
-    return `'${value.replaceAll("'", `'\\''`)}'`;
-}
 async function installShim() {
     const main = fileURLToPath(new URL(`./git-main${extname(fileURLToPath(import.meta.url))}`, import.meta.url));
     await mkdir(join(kitHome(), 'shim'), { recursive: true });
@@ -50,12 +49,30 @@ async function serveOwner(copies) {
     server.listen(socketPath);
     await once(server, 'listening');
 }
+function connected() {
+    return new Promise((resolve) => {
+        const watcher = watch(kitHome(), () => {
+            if (!enrolled())
+                return;
+            watcher.close();
+            resolve();
+        });
+        if (!enrolled()) {
+            process.stderr.write('kit: this Environment is not connected; run kit login\n');
+            return;
+        }
+        watcher.close();
+        resolve();
+    });
+}
 export async function resident() {
-    if ((await readEnrolment()) === null) {
-        process.stderr.write('kit: this Environment is not enrolled; run kit login\n');
-        process.exitCode = 1;
-        return;
-    }
+    await connected();
+    watch(kitHome(), () => {
+        if (enrolled())
+            return;
+        killDescendants();
+        process.exit(1);
+    });
     await placeSkillSet();
     await mkdir(agentBase(), { recursive: true });
     process.env.HOUSE_KIT_RESIDENT = String(process.pid);

package/dist/secret-input.js

@@ -1,4 +1,4 @@
-import { retryDelay } from './api.js';
+import { finalRefusal, retryDelay } from './api.js';
 export async function holdSecretInput(house, subject, steps, waiting) {
     for (let failures = 0; waiting();) {
         try {
@@ -10,7 +10,10 @@ export async function holdSecretInput(house, subject, steps, waiting) {
             failures = 0;
         }
         catch (error) {
+            if (finalRefusal(error))
+                return null;
             process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
+            // A wait that did not reach House is held again on the jittered curve for as long as its asker still waits.
             await new Promise((resolve) => setTimeout(resolve, retryDelay(failures++)));
         }
     }

package/dist/shell.js

@@ -0,0 +1,3 @@
+export function quoted(value) {
+    return `'${value.replaceAll("'", `'\\''`)}'`;
+}

package/dist/sign-in.js

@@ -12,6 +12,9 @@ function causeOf(error) {
 function logged(error) {
     process.stderr.write(`kit: ${causeOf(error)}\n`);
 }
+function endOf(signal) {
+    return new Promise((resolve) => signal.addEventListener('abort', () => resolve(true), { once: true }));
+}
 export class SignIns {
     house;
     agents;
@@ -30,24 +33,43 @@ export class SignIns {
             return;
         this.running.add(input.input_id);
         this.changed();
-        this.login(input)
-            .then(() => this.agents.reread(input.cli))
-            .then(() => this.house.deliver(`/kit/inputs/${input.input_id}/ack`, {}))
+        this.signIn(input)
             .catch(logged)
             .finally(() => {
             this.running.delete(input.input_id);
             this.changed();
         });
     }
-    async login(input) {
+    async signIn(input) {
+        const ending = new AbortController();
+        // House stops waiting for a sign-in ten minutes after it wrote it and sends the seconds left, so its install and login end with the page.
+        const timer = setTimeout(() => ending.abort(), input.ends_in * 1000);
+        const ended = await Promise.race([this.signedIn(input, ending.signal), endOf(ending.signal)]);
+        clearTimeout(timer);
+        if (ended)
+            process.stderr.write(`kit: the ${input.cli} sign-in reached the end House set for it\n`);
+        await this.house.deliver(`/kit/inputs/${input.input_id}/ack`, {});
+        if (!ended)
+            await this.agents.reread(input.cli);
+    }
+    async signedIn(input, signal) {
+        await this.login(input, signal);
+        if (!signal.aborted)
+            await this.agents.recheck(input.cli, signal);
+        return false;
+    }
+    async login(input, signal) {
         let cli;
         try {
-            cli = await this.agents.located(input.cli);
+            cli = await this.agents.located(input.cli, signal);
         }
         catch (error) {
-            process.stderr.write(`kit: the ${input.cli} sign-in failed: ${causeOf(error)}\n`);
+            if (!signal.aborted)
+                process.stderr.write(`kit: the ${input.cli} sign-in failed: ${causeOf(error)}\n`);
             return;
         }
+        if (signal.aborted)
+            return;
         const login = CLIS[input.cli].login;
         const child = spawn(cli, login.args, {
             stdio: ['pipe', 'pipe', 'pipe'],
@@ -55,6 +77,8 @@ export class SignIns {
             env: withoutProxy(),
         });
         const running = () => child.exitCode === null && child.signalCode === null;
+        const stop = () => killTree(child);
+        signal.addEventListener('abort', stop, { once: true });
         let link;
         let code;
         let last = '';
@@ -91,9 +115,10 @@ export class SignIns {
             createInterface({ input: output }).on('line', read);
         const failed = await new Promise((resolve) => {
             child.on('error', (error) => resolve(error.message));
-            child.on('close', (status, signal) => resolve(status === 0 ? null : `exited with ${status ?? signal}${last ? `: ${last}` : ''}`));
+            child.on('close', (status, killed) => resolve(status === 0 ? null : `exited with ${status ?? killed}${last ? `: ${last}` : ''}`));
         });
-        if (failed !== null)
+        signal.removeEventListener('abort', stop);
+        if (failed !== null && !signal.aborted)
             process.stderr.write(`kit: the ${input.cli} sign-in failed: ${failed}\n`);
     }
 }

package/dist/skills.js

@@ -6,7 +6,7 @@ import { fileURLToPath } from 'node:url';
 import { KIT_VERSION } from './clis.js';
 import { kitHome, readConfiguration, readHome, writeHome } from './home.js';
 import { refusalOf } from './refusals.js';
-export const HOW_WE_WORK = '/private/how-we-work.md';
+export const HOW_WE_WORK = '/rooms/private/how-we-work.md';
 const SKILL_SET = fileURLToPath(new URL('../skills/', import.meta.url));
 const HOW_WE_WORK_TEXT = readFileSync(new URL('../how-we-work.md', import.meta.url), 'utf8');
 const RECORD = 'skill-set.json';

package/dist/stream.js

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

package/dist/transcription.js

@@ -29,6 +29,10 @@ export const ENGINES = {
 };
 const CHUNK_SECONDS = 20;
 let held = Promise.resolve();
+let holding = Promise.resolve();
+let setting = null;
+let downloading = null;
+let readiness = { installed: false, failure: null };
 function directory() {
     return join(kitHome(), 'transcription');
 }
@@ -36,6 +40,7 @@ function installed(artifact) {
     return join(directory(), artifact.sha256);
 }
 async function executed(command, args, signal) {
+    // A download or a transcription runs as long as its size needs; the setting turning off or the turn's interrupt or end aborts it instead.
     const ran = await run(command, args, 0, false, signal);
     if (ran.status !== 0)
         throw new Error(failureOf(ran, basename(command)));
@@ -54,6 +59,12 @@ async function sha256(path) {
     await pipeline(createReadStream(path), hash);
     return hash.digest('hex');
 }
+function causeOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function pinnedHere() {
+    return ENGINES[`${process.platform}-${process.arch}`];
+}
 async function install(artifacts, signal) {
     await mkdir(directory(), { recursive: true });
     const pinned = new Set(artifacts.map((artifact) => artifact.sha256));
@@ -68,6 +79,7 @@ async function install(artifacts, signal) {
     try {
         for (const artifact of missing) {
             const part = `${installed(artifact)}.part`;
+            // Three retries carry a large download past a dropped connection before the download fails.
             await executed('curl', ['-fsSL', '--retry', '3', '-o', part, artifact.url], signal);
             if ((await sha256(part)) !== artifact.sha256)
                 throw new Error(`${artifact.url} does not match its sha256`);
@@ -83,12 +95,46 @@ async function install(artifacts, signal) {
             await rm(`${installed(artifact)}.part`, { force: true });
     }
 }
+function reported(next) {
+    const changed = next.installed !== readiness.installed || next.failure !== readiness.failure;
+    readiness = next;
+    return changed;
+}
+async function settle(transcribe) {
+    if (transcribe === setting)
+        return false;
+    setting = transcribe;
+    if (!transcribe) {
+        await rm(directory(), { recursive: true, force: true });
+        return reported({ installed: false, failure: null });
+    }
+    const download = new AbortController();
+    downloading = download;
+    try {
+        const pinned = pinnedHere();
+        await install([pinned.decoder, pinned.engine, MODEL], download.signal);
+        return reported({ installed: true, failure: null });
+    }
+    catch (error) {
+        await rm(directory(), { recursive: true, force: true });
+        return reported({ installed: false, failure: download.signal.aborted ? null : causeOf(error) });
+    }
+    finally {
+        downloading = null;
+    }
+}
+export function holdTranscription(transcribe) {
+    if (!transcribe)
+        downloading?.abort();
+    const settled = holding.then(() => settle(transcribe));
+    holding = settled.catch(() => undefined);
+    return settled;
+}
+export function transcriptionReport() {
+    return readiness;
+}
 async function transcribed(path, signal) {
-    const platform = `${process.platform}-${process.arch}`;
-    const pinned = ENGINES[platform];
-    if (pinned === undefined)
-        throw new Error(`no transcription engine is pinned for ${platform}`);
-    await install([pinned.decoder, pinned.engine, MODEL], signal);
+    const pinned = pinnedHere();
     const work = await mkdtemp(join(tmpdir(), 'kit-transcription-'));
     try {
         await executed(installed(pinned.decoder), ['-nostdin', '-hide_banner', '-loglevel', 'error', '-i', path, '-ar', '16000', '-ac', '1', '-c:a', 'pcm_s16le',
@@ -106,6 +152,8 @@ async function transcribed(path, signal) {
     }
 }
 export async function transcribe(path, signal) {
+    if (!readiness.installed)
+        return null;
     const before = held;
     let release;
     const mine = new Promise((resolve) => {
@@ -114,7 +162,7 @@ export async function transcribe(path, signal) {
     held = Promise.all([before, mine]);
     try {
         await unlessAborted(before, signal);
-        return await transcribed(path, signal);
+        return readiness.installed ? await transcribed(path, signal) : null;
     }
     finally {
         release();

package/dist/update.js

@@ -40,9 +40,11 @@ async function finished(inputId) {
         const ack = await recorded();
         if (ack !== null)
             return ack;
+        // systemctl answers at once, so ten seconds only bounds a stuck service manager.
         if ((await run('systemctl', ['is-active', '--quiet', unit(inputId)], 10_000)).status !== 0) {
             return (await recorded()) ?? { refused: 'the Kit bootstrap did not finish' };
         }
+        // The bootstrap runs for minutes, so checking each second sees its outcome within a second at little cost.
         await new Promise((resolve) => setTimeout(resolve, 1000));
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/kit",
-  "version": "0.2.1-c3e4a20bb3183",
+  "version": "0.2.1-c4ea88ba9424e",
   "description": "House Kit connects an Environment to agents.house.",
   "license": "MIT",
   "repository": {