@agentshouse/kit 0.2.1-c903d1429e34a → 0.2.1-c96855aa27328

package/dist/bridge.js

@@ -1,7 +1,6 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { once } from 'node:events';
 import { setTimeout as delay } from 'node:timers/promises';
-import { mkdir } from 'node:fs/promises';
 import { createServer, request as httpRequest } from 'node:http';
 import { request as httpsRequest } from 'node:https';
 import { delimiter, dirname, join } from 'node:path';
@@ -9,12 +8,12 @@ import { parse } from 'yaml';
 import { finalRefusal, HouseRefusal, retryDelay, retrying } from './api.js';
 import { loginPath } from './clis.js';
 import { changedPaths, } from './copies.js';
-import { kitHome, readEnrolment } from './home.js';
+import { kitHome, readEnrolment, socketDirectory } from './home.js';
 import { callHouse, mcpBody, rpc, UNREACHABLE } from './mcp.js';
 import { operationId } from './operation.js';
 import { refusalOf, retryable } from './refusals.js';
 import { relayed } from './relay.js';
-const MCP_REQUEST_BYTES = 4 * 1024 * 1024;
+const MCP_REQUEST_BYTES = 4_000_000;
 export async function received(request) {
     let text = '';
     request.setEncoding('utf8');
@@ -82,7 +81,7 @@ function editAnswer(forwarded) {
 export async function openBridge(house, copies, conversationId, signal) {
     const path = [join(kitHome(), 'shim'), dirname(process.execPath), await loginPath()].join(delimiter);
     const origin = (await readEnrolment()).house;
-    const { credential } = await house.post(`/kit/conversations/${conversationId}/credential`, {}, signal);
+    const { credential } = await retrying(() => house.post(`/kit/conversations/${conversationId}/credential`, {}, signal), signal);
     const closed = new AbortController();
     const sent = (message, operation) => callHouse(origin, credential, message, operation, closed.signal);
     const send = async (message, operation) => {
@@ -167,9 +166,7 @@ export async function openBridge(house, copies, conversationId, signal) {
         }
         return path === '/' ? forward(text) : { status: 404, text: '' };
     };
-    const sockets = join(kitHome(), 'bridges');
-    await mkdir(sockets, { recursive: true, mode: 0o700 });
-    const socketPath = join(sockets, `${randomUUID()}.sock`);
+    const socketPath = join(socketDirectory(), `${randomUUID()}.sock`);
     const bridge = createServer(async (request, response) => {
         try {
             const path = request.url ?? '';

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

@@ -0,0 +1,71 @@
+import { existsSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { kitHome } from './home.js';
+function logged(error) {
+    process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
+}
+export class Calls {
+    house;
+    changed;
+    carried = new Map();
+    path = join(kitHome(), 'call-results.json');
+    results;
+    returned = new Set();
+    released = new Set();
+    open = 0;
+    constructor(house, changed) {
+        this.house = house;
+        this.changed = changed;
+        this.results = new Map(existsSync(this.path) ? Object.entries(JSON.parse(readFileSync(this.path, 'utf8'))) : []);
+    }
+    keepResult(callId, result) {
+        if (this.returned.has(callId))
+            return;
+        this.results.set(callId, result);
+        this.save();
+    }
+    idle() {
+        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 }));
+        if (known === undefined) {
+            this.carried.set(callId, carried);
+            carried.catch(() => this.carried.delete(callId));
+        }
+        this.open++;
+        this.changed();
+        return carried
+            .then(async ({ result, returned, release }) => {
+            try {
+                await this.house.deliver(`/kit/inputs/${callId}/ack`, result);
+            }
+            finally {
+                this.returned.add(callId);
+                if (this.results.delete(callId))
+                    this.save();
+            }
+            if (known !== undefined)
+                return;
+            if (release) {
+                this.carried.delete(callId);
+                this.released.add(callId);
+            }
+            await returned?.();
+        })
+            .catch(logged)
+            .finally(() => {
+            this.open--;
+            this.changed();
+        });
+    }
+    save() {
+        const temporary = `${this.path}.${process.pid}`;
+        writeFileSync(temporary, JSON.stringify(Object.fromEntries(this.results)), { mode: 0o600 });
+        renameSync(temporary, this.path);
+    }
+}

package/dist/chatgpt.js

@@ -0,0 +1,32 @@
+import { parseArgs } from 'node:util';
+import { placeAppGit } from './app-git.js';
+import { kitHome, readOwnAgent, writeOwnAgent } from './home.js';
+import { accepted, DEFAULT_HOUSE } from './login.js';
+const KEY_SOURCE = 'New key for a script on Connections';
+const USAGE = `usage: kit chatgpt --key <key> [--house <origin>]
+  --key <key>       a key from ${KEY_SOURCE}
+  --house <origin>  the House of the key, ${DEFAULT_HOUSE} unless one is stored
+`;
+export async function chatgpt(argv) {
+    const { values } = parseArgs({
+        args: argv,
+        options: { key: { type: 'string' }, house: { type: 'string' }, help: { type: 'boolean', default: false } },
+    });
+    if (values.help) {
+        process.stdout.write(USAGE);
+        return;
+    }
+    if (values.key === undefined)
+        throw new Error(`pass --key with a key from ${KEY_SOURCE}`);
+    const before = await readOwnAgent();
+    const house = values.house ?? before?.house ?? DEFAULT_HOUSE;
+    if (!(await accepted(house, values.key)))
+        throw new Error(`${house} does not accept this key; pass one from ${KEY_SOURCE}`);
+    const relay = process.env.HOUSE_KIT_RELAY || undefined;
+    await writeOwnAgent({ house, ...(relay === undefined ? {} : { relay }), credential: values.key });
+    await placeAppGit(await readOwnAgent()).catch((error) => process.stderr.write(`kit: ${error.message}\n`));
+    if (before !== null && before.credential !== values.key) {
+        process.stdout.write('This replaced the key this Kit home held; give each session its own HOUSE_KIT_HOME to keep its own key.\n');
+    }
+    process.stdout.write(`house now calls ${house} as you, with the key kept in ${kitHome()}.\n`);
+}

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,14 +1,22 @@
 import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
 import { constants, readFileSync } from 'node:fs';
-import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { access, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { homedir, userInfo } from 'node:os';
-import { delimiter, isAbsolute, join } from 'node:path';
+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`;
+}
 const RAW_SUBTYPES = [
     'background_tasks_changed',
     'task_started',
     'task_updated',
     'task_notification',
+    'task_progress',
     'session_state_changed',
     'hook_started',
     'hook_response',
@@ -22,24 +30,49 @@ async function executable(path) {
         return false;
     }
 }
-async function allowHouseInCodex(path) {
+async function listedHouses(file) {
+    let text;
+    try {
+        text = await readFile(file, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+    try {
+        const listed = JSON.parse(HOUSE_EXECUTABLES.exec(text)?.[1] ?? '[]');
+        return Array.isArray(listed) ? listed.filter((house) => typeof house === 'string') : [];
+    }
+    catch {
+        return [];
+    }
+}
+export async function allowHouseInCodex(path) {
     const candidates = [...new Set(path.split(delimiter).filter((directory) => isAbsolute(directory)))].map((directory) => join(directory, 'house'));
-    const houses = [];
-    for (const candidate of candidates)
-        if (await executable(candidate))
-            houses.push(candidate);
     const rules = join(process.env.CODEX_HOME || join(homedir(), '.codex'), 'rules');
+    const file = join(rules, 'house.rules');
+    const houses = [];
+    for (const house of [...(await listedHouses(file)), ...candidates]) {
+        if (!houses.includes(house) && (await executable(house)))
+            houses.push(house);
+    }
     await mkdir(rules, { recursive: true });
-    await writeFile(join(rules, 'house.rules'), `prefix_rule(pattern = ["house"], decision = "allow")\nhost_executable(name = "house", paths = ${JSON.stringify(houses)})\n`);
+    const temporary = `${file}.${randomUUID()}`;
+    await writeFile(temporary, houseRule(houses));
+    await rename(temporary, file);
 }
 async function nothing() { }
+function answered(error) {
+    return typeof error === 'object' && error !== null ? error : {};
+}
 function bridgeInClaudeSandbox(bridge) {
     return process.platform === 'darwin' ? { allowUnixSockets: [bridge] } : { allowAllUnixSockets: true };
 }
 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',
         adapter: {
             package: '@agentclientprotocol/codex-acp',
@@ -50,6 +83,10 @@ export const CLIS = {
         args: [],
         fullAccess: 'agent-full-access',
         sessionMeta: () => ({}),
+        unknownSession: (error) => {
+            const { code, data } = answered(error);
+            return code === -32603 && typeof data?.details === 'string' && data.details.startsWith('no rollout found');
+        },
         renames: true,
         allowHouse: allowHouseInCodex,
         signedIn: { command: ['login', 'status'] },
@@ -58,7 +95,7 @@ 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',
         adapter: {
             package: '@agentclientprotocol/claude-agent-acp',
@@ -76,9 +113,10 @@ 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,
         renames: false,
         allowHouse: nothing,
         signedIn: { command: ['auth', 'status'] },
@@ -93,6 +131,7 @@ export const CLIS = {
         args: ['--sandbox', 'off', 'agent', '--always-approve', '--no-leader', 'stdio'],
         fullAccess: null,
         sessionMeta: () => ({}),
+        unknownSession: (error) => answered(error).data?.code === 'FS_NOT_FOUND',
         renames: false,
         allowHouse: nothing,
         signedIn: { initializeMeta: 'defaultAuthMethodId' },
@@ -101,8 +140,7 @@ export const CLIS = {
     },
 };
 const KIT_PACKAGE = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
-export const KIT_VERSION = KIT_PACKAGE.version;
-const PROXY = /^https?_proxy$/i;
+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.
 const INSTALL_MS = 15 * 60_000;
@@ -124,15 +162,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,
         });
@@ -166,15 +201,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), '--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);
@@ -189,15 +246,24 @@ const USER_BIN = 'case ":$PATH:" in *":$HOME/.local/bin:"*) ;; *) PATH="$PATH:$H
 function inLoginShell(script, argument = '', signal) {
     return run(loginShell(), ['-l', '-i', '-c', `exec /bin/sh -c '${USER_BIN}; ${script}' sh ${argument}`], READ_MS, true, signal);
 }
-export async function locate(kind, signal) {
-    const ran = await inLoginShell(LOOKUP, CLIS[kind].bin, signal);
+export async function onLoginPath(program, signal) {
+    const ran = await inLoginShell(LOOKUP, program, signal);
     return ran.stdout.split('\n').findLast((line) => line.startsWith(FOUND))?.slice(FOUND.length) ?? null;
 }
+export function locate(kind, signal) {
+    return onLoginPath(CLIS[kind].bin, signal);
+}
 export async function loginPath() {
     const marker = 'house-kit-path ';
     const ran = await inLoginShell(`printf "${marker}%s\\n" "$PATH"`);
     return ran.stdout.split('\n').findLast((line) => line.startsWith(marker)).slice(marker.length);
 }
+export async function writeCodexRule() {
+    const shell = await loginPath().catch(() => '');
+    await allowHouseInCodex([dirname(process.execPath), process.env.PATH ?? '', shell].join(delimiter)).catch((error) => {
+        throw new Error(`Codex's rule for house could not be written: ${error.message}`);
+    });
+}
 export async function versionOf(path, signal) {
     return VERSION.exec((await run(path, ['--version'], READ_MS, false, signal)).stdout)?.[0] ?? null;
 }

package/dist/connection.js

@@ -0,0 +1,116 @@
+import { subscribe } from 'node:diagnostics_channel';
+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;
+function connectionUrl(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 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();
+            process.stderr.write(`kit: connection closed ${event.code} ${event.reason}\n`);
+            if (event.reason === 'replaced')
+                end(REPLACED);
+            if (event.reason === 'credential_rejected' || refused?.status === 401) {
+                void signInAgain(credential);
+                return;
+            }
+            if (refused !== null)
+                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++));
+        };
+        opening.onopen = () => {
+            opened = true;
+            failures = 0;
+            connection = opening;
+            silence = new Silence(CONNECTION_SILENCE_MS, () => {
+                if (connection !== opening)
+                    return;
+                connection = null;
+                opening.onclose = null;
+                opening.close();
+                closed(new CloseEvent('close', { code: 1006, reason: 'heartbeat_missed' }));
+            });
+            silence.heard();
+            handlers.opened();
+        };
+        opening.onmessage = (event) => {
+            silence?.heard();
+            const arrived = JSON.parse(String(event.data));
+            if (arrived.type === 'input')
+                handlers.call(arrived);
+            else if (arrived.type !== 'beat')
+                handlers.notification(arrived);
+        };
+        opening.onerror = () => undefined;
+        opening.onclose = closed;
+    };
+    void connect();
+    return {
+        send(notification) {
+            if (connection === null || connection.readyState !== WebSocket.OPEN)
+                return false;
+            connection.send(JSON.stringify(notification));
+            return true;
+        },
+        pause() {
+            paused = true;
+            socket?.close();
+            return () => {
+                paused = false;
+                void connect();
+            };
+        },
+    };
+}