@agentshouse/kit 0.2.1-alpha.8 → 0.2.1-c031c7457a661

package/dist/clis.js

@@ -1,83 +1,159 @@
 import { spawn } from 'node:child_process';
-import { readFileSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { constants, readFileSync } from 'node:fs';
+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 { kitHome } from './home.js';
-const RUNNING_JOB = new Set(['running', 'paused']);
-function threadStatus({ method, params }) {
-    if (method !== 'session/update' || params?.update?.sessionUpdate !== 'session_info_update')
-        return undefined;
-    return params.update._meta?.codex?.threadStatus?.type;
-}
-function asyncTask({ method, params }) {
-    const update = params?.update;
-    if (method !== 'session/update' || update?.asyncTaskId === undefined)
-        return null;
-    if (update.sessionUpdate === 'async_task_spawned')
-        return { id: update.asyncTaskId, running: true };
-    if (update.sessionUpdate === 'async_task_state_update' && !RUNNING_JOB.has(update.state ?? '')) {
-        return { id: update.asyncTaskId, running: false };
+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',
+    'session_state_changed',
+    'hook_started',
+    'hook_response',
+];
+async function executable(path) {
+    try {
+        await access(path, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
     }
-    return null;
+}
+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 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 });
+    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': {
-        package: '@agentclientprotocol/codex-acp',
-        bin: 'codex-acp',
+        bin: 'codex',
+        minimum: '0.159.1',
+        install: 'curl -fsSL https://chatgpt.com/codex/install.sh | sh',
+        adapter: {
+            package: '@agentclientprotocol/codex-acp',
+            bin: 'codex-acp',
+            executable: 'CODEX_PATH',
+            env: { CODEX_CONFIG: JSON.stringify({ features: { shell_zsh_fork: true } }) },
+        },
         args: [],
-        signedIn: { command: ['cli', 'login', 'status'] },
-        login: { args: ['cli', 'login', '--device-auth'], code: 'show' },
-        queues: false,
-        turnStarted: (notice) => threadStatus(notice) === 'active',
-        turnEnded: (notice) => threadStatus(notice) === 'idle',
-        job: asyncTask,
+        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'] },
+        login: { args: ['login', '--device-auth'], code: 'show' },
+        air: ['asyncTasks', 'nativeSubagentSessions'],
     },
     'claude-agent-acp': {
-        package: '@agentclientprotocol/claude-agent-acp',
-        bin: 'claude-agent-acp',
+        bin: 'claude',
+        minimum: '2.1.286',
+        install: 'curl -fsSL https://claude.ai/install.sh | bash',
+        adapter: {
+            package: '@agentclientprotocol/claude-agent-acp',
+            bin: 'claude-agent-acp',
+            executable: 'CLAUDE_CODE_EXECUTABLE',
+            env: { CLAUDE_CODE_ENTRYPOINT: 'claude-agent-acp', IS_SANDBOX: '1' },
+        },
         args: [],
-        signedIn: { command: ['--cli', 'auth', 'status'] },
-        login: { args: ['--cli', 'auth', 'login', '--claudeai'], code: 'collect' },
-        queues: false,
-        turnStarted: () => false,
-        turnEnded: ({ method, params }) => method === 'session/update' &&
-            params?.update?.sessionUpdate === 'usage_update' &&
-            params.update._meta?.['_claude/origin'] !== undefined,
-        job: asyncTask,
+        fullAccess: 'bypassPermissions',
+        sessionMeta: (bridge, title) => ({
+            claudeCode: {
+                options: {
+                    allowedTools: ['Bash(house:*)'],
+                    includeHookEvents: true,
+                    title,
+                    settings: { sandbox: { network: bridgeInClaudeSandbox(bridge) } },
+                },
+                emitRawSDKMessages: RAW_SUBTYPES.map((subtype) => ({ type: 'system', subtype })),
+            },
+        }),
+        unknownSession: (error) => answered(error).code === -32002,
+        renames: false,
+        allowHouse: nothing,
+        signedIn: { command: ['auth', 'status'] },
+        login: { args: ['auth', 'login', '--claudeai'], code: 'collect', rejected: 'Invalid code' },
+        air: ['asyncTasks', 'sessionFailure'],
     },
     'grok-build': {
-        package: '@xai-official/grok',
         bin: 'grok',
-        args: ['agent', '--no-leader', 'stdio'],
+        minimum: '1.0.46',
+        install: 'curl -fsSL https://x.ai/cli/install.sh | bash',
+        adapter: null,
+        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' },
         login: { args: ['login', '--device-auth'], code: 'show' },
-        queues: true,
-        turnStarted: ({ method, params }) => method === '_x.ai/queue/changed' && params?.runningPromptId !== undefined,
-        turnEnded: ({ method, params }) => method === '_x.ai/session_notification' && params?.update?.sessionUpdate === 'turn_completed',
-        job: ({ method, params }) => {
-            if (method === '_x.ai/task_backgrounded')
-                return { id: params.update.task_id, running: true };
-            if (method === '_x.ai/task_completed')
-                return { id: params.update.task_snapshot.task_id, running: false };
-            return null;
-        },
+        air: ['asyncTasks'],
     },
 };
 const KIT_PACKAGE = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
-export const KIT_VERSION = KIT_PACKAGE.version;
+export const KIT_RELEASE = KIT_PACKAGE.version;
 const PROXY = /^https?_proxy$/i;
-export function pinned(kind) {
-    return KIT_PACKAGE.peerDependencies[CLIS[kind].package];
-}
+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;
+// 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 cliCommand(kind) {
-    return join(prefix(kind), 'node_modules', '.bin', CLIS[kind].bin);
+export function adapterCommand(kind) {
+    return join(prefix(kind), 'node_modules', '.bin', CLIS[kind].adapter.bin);
 }
-export async function installedRelease(kind) {
+async function installedAdapter(kind) {
     try {
-        const manifest = join(prefix(kind), 'node_modules', CLIS[kind].package, 'package.json');
+        const manifest = join(prefix(kind), 'node_modules', CLIS[kind].adapter.package, 'package.json');
         return JSON.parse(await readFile(manifest, 'utf8')).version;
     }
     catch {
@@ -87,28 +163,97 @@ export async function installedRelease(kind) {
 export function withoutProxy() {
     return Object.fromEntries(Object.entries(process.env).filter(([name]) => !PROXY.test(name)));
 }
-export function run(command, args, timeoutMs) {
+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() });
+        const child = spawn(command, args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            timeout: timeoutMs,
+            env: withoutProxy(),
+            detached,
+            signal: detached ? undefined : signal,
+        });
+        const stop = () => {
+            try {
+                process.kill(-child.pid, 'SIGKILL');
+            }
+            catch { }
+        };
+        if (detached && signal?.aborted)
+            stop();
+        if (detached)
+            signal?.addEventListener('abort', stop, { once: true });
+        const ended = (ran) => {
+            signal?.removeEventListener('abort', stop);
+            resolve(ran);
+        };
+        let stdout = '';
         let output = '';
-        child.stdout.on('data', (chunk) => {
-            output += chunk.toString('utf8');
+        child.stdout.setEncoding('utf8').on('data', (chunk) => {
+            stdout += chunk;
+            output += chunk;
         });
-        child.stderr.on('data', (chunk) => {
-            output += chunk.toString('utf8');
+        child.stderr.setEncoding('utf8').on('data', (chunk) => {
+            output += chunk;
         });
-        child.on('error', (error) => resolve({ status: null, output: error.message }));
-        child.on('close', (status) => resolve({ status, output }));
+        child.on('error', (error) => ended({ status: null, stdout, output: error.message }));
+        child.on('close', (status) => ended({ status, stdout, output }));
     });
 }
-export async function install(kind) {
-    const release = pinned(kind);
-    if ((await installedRelease(kind)) === release)
-        return release;
-    const ran = await run('npm', ['install', '--prefix', prefix(kind), '--no-save', '--no-audit', '--no-fund', `${CLIS[kind].package}@${release}`], 15 * 60_000);
-    if (ran.status !== 0) {
-        process.stderr.write(`kit: ${kind} did not install: ${ran.output.trim()}\n`);
+export function failureOf(ran, program) {
+    return ran.output.trim().slice(-CAUSE_CHARACTERS) || `${program} exited with ${ran.status ?? 'a signal'}`;
+}
+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)
         return null;
+    const ran = await run('npm', ['install', '--prefix', prefix(kind), '--cache', join(kitHome(), 'npm-cache'), '--no-save', '--no-audit', '--no-fund', '--omit=optional', `${adapter.package}@${release}`], INSTALL_MS, true, signal);
+    return ran.status === 0 ? null : failureOf(ran, 'npm');
+}
+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');
+}
+function loginShell() {
+    return process.env.SHELL || userInfo().shell;
+}
+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);
+}
+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;
+}
+function numbers(version) {
+    return version.split(/[.-]/, 3).map(Number);
+}
+export function below(found, minimum) {
+    const [have, need] = [numbers(found), numbers(minimum)];
+    for (let index = 0; index < 3; index++) {
+        if (have[index] !== need[index])
+            return have[index] < need[index];
     }
-    return installedRelease(kind);
+    return found.includes('-') && !minimum.includes('-');
 }

package/dist/codex-main.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import { connect } from 'node:net';
+const KIT_ANSWER = '"house-kit-';
+const SYNC = 'house-kit/sync';
+function lines(each) {
+    let buffer = '';
+    return (chunk) => {
+        buffer += chunk;
+        for (let index = buffer.indexOf('\n'); index >= 0; index = buffer.indexOf('\n')) {
+            each(buffer.slice(0, index + 1));
+            buffer = buffer.slice(index + 1);
+        }
+    };
+}
+function answersKit(line) {
+    if (!line.includes(KIT_ANSWER))
+        return false;
+    try {
+        const message = JSON.parse(line);
+        return message.method === undefined && typeof message.id === 'string' && message.id.startsWith(KIT_ANSWER.slice(1));
+    }
+    catch {
+        return false;
+    }
+}
+const args = process.argv.slice(2);
+const serving = args[0] === 'app-server';
+if (process.env.HOUSE_KIT_SANDBOX === '1' && serving)
+    args.push('--disable', 'memories');
+const codex = spawn(process.env.HOUSE_KIT_CODEX, args, { stdio: ['pipe', 'pipe', 'inherit'] });
+const stream = serving ? connect(process.env.HOUSE_KIT_CODEX_STREAM) : null;
+stream?.on('error', () => undefined);
+process.stdin.setEncoding('utf8').on('data', lines((line) => codex.stdin.write(line)));
+process.stdin.on('end', () => codex.stdin.end());
+stream?.setEncoding('utf8').on('data', lines((line) => {
+    const message = JSON.parse(line);
+    if (message.method === SYNC)
+        stream.write(`${JSON.stringify({ jsonrpc: '2.0', id: message.id, result: {} })}\n`);
+    else
+        codex.stdin.write(line);
+}));
+codex.stdout.setEncoding('utf8').on('data', lines((line) => {
+    stream?.write(line);
+    if (answersKit(line) || process.stdout.write(line))
+        return;
+    codex.stdout.pause();
+    process.stdout.once('drain', () => codex.stdout.resume());
+}));
+codex.stdin.on('error', () => undefined);
+for (const signal of ['SIGTERM', 'SIGINT', 'SIGHUP'])
+    process.on(signal, () => codex.kill(signal));
+codex.on('exit', (code, signal) => {
+    if (signal === null)
+        process.exit(code ?? 1);
+    process.removeAllListeners(signal);
+    process.kill(process.pid, signal);
+});

package/dist/configure-main.js

@@ -0,0 +1,6 @@
+import { readConfiguration, writeConfiguration } from './home.js';
+const skills = !process.argv.slice(2).includes('--no-skills');
+const stored = await readConfiguration();
+await writeConfiguration({ skills });
+if (stored.skills !== skills)
+    process.stdout.write('changed\n');

package/dist/connection.js

@@ -0,0 +1,126 @@
+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 { endUnserved, KIT_WIRE } from './wire.js';
+const PATH = '/kit/stream';
+const SUBPROTOCOL = `house.kit.stream.${KIT_WIRE}`;
+const REFUSAL_HEADER = 'x-house-refusal';
+// House beats each Kit connection every thirty seconds, so two silent beats mean this Kit process cannot hear House.
+export const CONNECTION_SILENCE_MS = 60_000;
+const SYSTEM_CONNECTION_CLOCK = {
+    later: (delay, callback) => setTimeout(callback, delay),
+    clear: (timer) => clearTimeout(timer),
+};
+export class ConnectionSilence {
+    timer = null;
+    silent;
+    clock;
+    interval;
+    constructor(silent, clock = SYSTEM_CONNECTION_CLOCK, interval = CONNECTION_SILENCE_MS) {
+        this.silent = silent;
+        this.clock = clock;
+        this.interval = interval;
+    }
+    heard() {
+        this.stop();
+        this.timer = this.clock.later(this.interval, () => {
+            this.timer = null;
+            this.silent();
+        });
+    }
+    stop() {
+        if (this.timer === null)
+            return;
+        this.clock.clear(this.timer);
+        this.timer = null;
+    }
+}
+function connectionUrl(house) {
+    const url = new URL(PATH, house);
+    url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
+    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 failures = 0;
+    const connect = async () => {
+        const { house, credential } = (await readEnrolment());
+        refused = null;
+        const opening = new WebSocket(relayed(connectionUrl(house)), {
+            protocols: [SUBPROTOCOL],
+            headers: { authorization: `Bearer ${credential}` },
+        });
+        let opened = false;
+        let silence = null;
+        const closed = (event) => {
+            silence?.stop();
+            silence = 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`);
+            // 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 ConnectionSilence(() => {
+                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;
+        },
+    };
+}