@agentshouse/kit 0.2.1-cb6679d048e60 → 0.2.1-cbabe8ad337ff

package/dist/bridge.js

@@ -6,15 +6,15 @@ import { createServer, request as httpRequest } from 'node:http';
 import { request as httpsRequest } from 'node:https';
 import { delimiter, dirname, join } from 'node:path';
 import { parse } from 'yaml';
-import { HouseRefusal, retryDelay } from './api.js';
+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 { callHouse, mcpBody, rpc, UNREACHABLE } from './mcp.js';
-import { operationId, uuidOf } from './operation.js';
-import { refusalOf } from './refusals.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 ATTACHMENTS = '/kit/attachments/upload';
 export async function received(request) {
     let text = '';
     request.setEncoding('utf8');
@@ -22,7 +22,8 @@ export async function received(request) {
         text += chunk;
     return text;
 }
-function relay(request, response, target, authorization) {
+function relay(request, response, house, authorization) {
+    const target = relayed(house);
     const send = target.protocol === 'https:' ? httpsRequest : httpRequest;
     const forwarded = send(target, {
         method: request.method,
@@ -38,8 +39,6 @@ function refusalIn(text, status) {
     return refusalOf(text) ?? { code: '', text: text === '' ? `House refused it with ${status}` : text, conflicts: [] };
 }
 function answered(forwarded) {
-    if (forwarded.status >= 500)
-        throw new HouseRefusal('/', forwarded.status, forwarded.text);
     if (forwarded.status !== 200)
         return { refused: refusalIn(forwarded.text, forwarded.status) };
     const answer = JSON.parse(forwarded.text);
@@ -63,16 +62,11 @@ function pendingSeconds(forwarded) {
 function resendAfter(forwarded, attempt) {
     if (forwarded === null)
         return retryDelay(attempt);
-    if (forwarded.status >= 500)
-        return refusalOf(forwarded.text) === null ? retryDelay(attempt) : null;
+    if (forwarded.status !== 200)
+        return retryable(forwarded.text) === false ? null : retryDelay(attempt);
     const seconds = pendingSeconds(forwarded);
     return seconds === null ? null : seconds * 1000;
 }
-function versioned(conversationId, text) {
-    const file = JSON.parse(text);
-    const identity = JSON.stringify([conversationId, file.room_ref ?? null, file.name, file.sha256]);
-    return JSON.stringify({ ...file, version: uuidOf(createHash('sha256').update(identity).digest(), 8) });
-}
 function editAnswer(forwarded) {
     const answer = answered(forwarded);
     if ('refused' in answer)
@@ -103,6 +97,7 @@ export async function openBridge(house, copies, conversationId, signal) {
             const after = resendAfter(forwarded, attempt);
             if (after === null)
                 return forwarded;
+            // A write House did not settle is sent again on the jittered curve, or after the wait House names for a pending one.
             await delay(after, undefined, { signal: closed.signal });
         }
     };
@@ -117,17 +112,26 @@ export async function openBridge(house, copies, conversationId, signal) {
         if ('refused' in prepared)
             return prepared;
         const { transfer } = parse(prepared.text);
-        const posted = await fetch(transfer.url, {
-            method: 'POST',
-            headers: { 'content-type': 'text/plain; charset=utf-8' },
-            body: Buffer.concat([Buffer.from(`${transfer.operation}\n`), bytes]),
-            signal: closed.signal,
-        });
-        const text = await posted.text();
-        if (posted.status >= 500)
-            throw new HouseRefusal('/', posted.status, text);
-        if (!posted.ok)
-            return { refused: refusalIn(text, posted.status) };
+        let text;
+        try {
+            text = await retrying(async () => {
+                const posted = await fetch(relayed(transfer.url), {
+                    method: 'POST',
+                    headers: { 'content-type': 'text/plain; charset=utf-8' },
+                    body: Buffer.concat([Buffer.from(`${transfer.operation}\n`), bytes]),
+                    signal: closed.signal,
+                });
+                const answer = await posted.text();
+                if (!posted.ok)
+                    throw new HouseRefusal('/', posted.status, answer);
+                return answer;
+            }, closed.signal);
+        }
+        catch (error) {
+            if (!finalRefusal(error))
+                throw error;
+            return { refused: refusalIn(error.text, error.status) };
+        }
         const held = JSON.parse(text).transfer;
         return { url: held.url, operation: held.operation, bytes: bytes.length, sha256 };
     };
@@ -144,19 +148,10 @@ export async function openBridge(house, copies, conversationId, signal) {
             throw error;
         }
     };
-    const forward = async (path, text) => {
-        if (path === '/') {
-            const message = JSON.parse(text);
-            const tool = message.method === 'tools/call' ? String(message.params.name) : null;
-            return send(message, tool !== null && (await writes(tool)) ? operationId() : null);
-        }
-        const answer = await fetch(new URL(path, origin), {
-            method: 'POST',
-            headers: { 'content-type': 'application/json', authorization: `Bearer ${credential}` },
-            body: versioned(conversationId, text),
-            signal: closed.signal,
-        });
-        return { status: answer.status, text: await answer.text() };
+    const forward = async (text) => {
+        const message = JSON.parse(text);
+        const tool = message.method === 'tools/call' ? String(message.params.name) : null;
+        return send(message, tool !== null && (await writes(tool)) ? operationId() : null);
     };
     const caller = {
         key: `conversation:${conversationId}`,
@@ -182,7 +177,7 @@ export async function openBridge(house, copies, conversationId, signal) {
             await copies.observed(JSON.parse(text));
             return { status: 200, text: '{}' };
         }
-        return path === '/' || path === ATTACHMENTS ? forward(path, text) : { status: 404, text: '' };
+        return path === '/' ? forward(text) : { status: 404, text: '' };
     };
     const sockets = join(kitHome(), 'bridges');
     await mkdir(sockets, { recursive: true, mode: 0o700 });
@@ -229,7 +224,7 @@ export async function openBridge(house, copies, conversationId, signal) {
             GIT_CONFIG_VALUE_0: app,
         },
         tool: async (name, args) => {
-            const forwarded = await forward('/', JSON.stringify(call(name, args)));
+            const forwarded = await forward(JSON.stringify(call(name, args)));
             if (forwarded.status !== 200)
                 throw new Error(`House refused ${name} with ${forwarded.status}: ${forwarded.text}`);
             const answer = JSON.parse(forwarded.text);

package/dist/clis.js

@@ -1,48 +1,60 @@
 import { spawn } from 'node:child_process';
-import { readFileSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
-import { userInfo } from 'node:os';
-import { join } from 'node:path';
+import { constants, readFileSync } from 'node:fs';
+import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir, userInfo } from 'node:os';
+import { delimiter, 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 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;
 }
-function airPhase({ _meta }) {
-    const phase = _meta?.jetbrains?.air?.phase;
-    if (phase === 'commentary')
-        return 'note';
-    if (phase === 'final_answer')
-        return 'answer';
-    return null;
+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');
+    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`);
+}
+async function nothing() { }
+function bridgeInClaudeSandbox(bridge) {
+    return process.platform === 'darwin' ? { allowUnixSockets: [bridge] } : { allowAllUnixSockets: true };
 }
 export const CLIS = {
     '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: {} },
+        adapter: {
+            package: '@agentclientprotocol/codex-acp',
+            bin: 'codex-acp',
+            executable: 'CODEX_PATH',
+            env: { CODEX_CONFIG: JSON.stringify({ features: { shell_zsh_fork: true } }) },
+        },
         args: [],
+        fullAccess: 'agent-full-access',
+        sessionMeta: () => ({}),
+        renames: true,
+        allowHouse: allowHouseInCodex,
         signedIn: { command: ['login', 'status'] },
         login: { args: ['login', '--device-auth'], code: 'show' },
-        queues: false,
-        turnStarted: (notice) => threadStatus(notice) === 'active',
-        turnEnded: (notice) => threadStatus(notice) === 'idle',
-        job: asyncTask,
-        phase: airPhase,
+        air: ['asyncTasks', 'nativeSubagentSessions'],
     },
     'claude-agent-acp': {
         bin: 'claude',
@@ -52,45 +64,49 @@ export const CLIS = {
             package: '@agentclientprotocol/claude-agent-acp',
             bin: 'claude-agent-acp',
             executable: 'CLAUDE_CODE_EXECUTABLE',
-            env: { CLAUDE_CODE_ENTRYPOINT: 'claude-agent-acp' },
+            env: { CLAUDE_CODE_ENTRYPOINT: 'claude-agent-acp', IS_SANDBOX: '1' },
         },
         args: [],
+        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 })),
+            },
+        }),
+        renames: false,
+        allowHouse: nothing,
         signedIn: { command: ['auth', 'status'] },
         login: { args: ['auth', 'login', '--claudeai'], code: 'collect', rejected: 'Invalid code' },
-        queues: false,
-        turnStarted: () => false,
-        turnEnded: ({ method, params }) => method === 'session/update' &&
-            params?.update?.sessionUpdate === 'usage_update' &&
-            params.update._meta?.['_claude/origin'] !== undefined,
-        job: asyncTask,
-        phase: () => null,
+        air: ['asyncTasks', 'sessionFailure'],
     },
     'grok-build': {
         bin: 'grok',
         minimum: '1.0.46',
         install: 'curl -fsSL https://x.ai/cli/install.sh | bash',
         adapter: null,
-        args: ['agent', '--no-leader', 'stdio'],
+        args: ['--sandbox', 'off', 'agent', '--always-approve', '--no-leader', 'stdio'],
+        fullAccess: null,
+        sessionMeta: () => ({}),
+        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;
-        },
-        phase: () => null,
+        air: ['asyncTasks'],
     },
 };
 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;
 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) {
@@ -118,8 +134,22 @@ export function run(command, args, timeoutMs, detached = false, signal) {
             timeout: timeoutMs,
             env: withoutProxy(),
             detached,
-            signal,
+            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.setEncoding('utf8').on('data', (chunk) => {
@@ -129,25 +159,25 @@ export function run(command, args, timeoutMs, detached = false, signal) {
         child.stderr.setEncoding('utf8').on('data', (chunk) => {
             output += chunk;
         });
-        child.on('error', (error) => resolve({ status: null, stdout, output: error.message }));
-        child.on('close', (status) => resolve({ status, stdout, output }));
+        child.on('error', (error) => ended({ status: null, stdout, output: error.message }));
+        child.on('close', (status) => ended({ status, stdout, output }));
     });
 }
 export function failureOf(ran, program) {
     return ran.output.trim().slice(-CAUSE_CHARACTERS) || `${program} exited with ${ran.status ?? 'a signal'}`;
 }
-export async function installAdapter(kind) {
+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), '--no-save', '--no-audit', '--no-fund', '--omit=optional', `${adapter.package}@${release}`], INSTALL_MS);
+    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');
 }
-export async function installCli(kind) {
-    const ran = await run('bash', ['-o', 'pipefail', '-c', CLIS[kind].install], INSTALL_MS, true);
+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() {
@@ -156,11 +186,11 @@ 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 = '') {
-    return run(loginShell(), ['-l', '-i', '-c', `exec /bin/sh -c '${USER_BIN}; ${script}' sh ${argument}`], READ_MS, true);
+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) {
-    const ran = await inLoginShell(LOOKUP, CLIS[kind].bin);
+export async function locate(kind, signal) {
+    const ran = await inLoginShell(LOOKUP, CLIS[kind].bin, signal);
     return ran.stdout.split('\n').findLast((line) => line.startsWith(FOUND))?.slice(FOUND.length) ?? null;
 }
 export async function loginPath() {
@@ -168,8 +198,8 @@ export async function loginPath() {
     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 versionOf(path) {
-    return VERSION.exec((await run(path, ['--version'], READ_MS)).stdout)?.[0] ?? null;
+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);

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);
+});