@agentshouse/kit 0.2.1-alpha.2 → 0.2.1-alpha.20

package/dist/bridge.js

@@ -1,79 +1,208 @@
-import { randomBytes, randomUUID } from 'node:crypto';
+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 { join } from 'node:path';
-import { KIT_VERSION } from './clis.js';
+import { delimiter, dirname, join } from 'node:path';
+import { parse } from 'yaml';
+import { HouseRefusal, retryDelay } from './api.js';
+import { loginPath } from './clis.js';
+import { changedPaths, } from './copies.js';
 import { kitHome, readEnrolment } from './home.js';
-const MCP_PROTOCOL_VERSION = '2026-07-28';
-const FORWARDED = new Set(['/', '/kit/attachments/upload']);
-function operationId() {
-    const bytes = randomBytes(16);
-    bytes.writeUIntBE(Date.now(), 0, 6);
-    bytes[6] = 0x70 | (bytes[6] & 0x0f);
-    bytes[8] = 0x80 | (bytes[8] & 0x3f);
-    const hex = bytes.toString('hex');
-    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
-}
-async function received(request) {
+import { callHouse, mcpBody, rpc, UNREACHABLE } from './mcp.js';
+import { operationId, uuidOf } from './operation.js';
+import { refusalOf } from './refusals.js';
+const MCP_REQUEST_BYTES = 4 * 1024 * 1024;
+const ATTACHMENTS = '/kit/attachments/upload';
+export async function received(request) {
     let text = '';
     request.setEncoding('utf8');
     for await (const chunk of request)
         text += chunk;
     return text;
 }
-export async function openBridge(house, conversationId, signal) {
+function relay(request, response, target, authorization) {
+    const send = target.protocol === 'https:' ? httpsRequest : httpRequest;
+    const forwarded = send(target, {
+        method: request.method,
+        headers: { ...request.headers, host: target.host, ...(authorization === undefined ? {} : { authorization }) },
+    }, (answer) => {
+        response.writeHead(answer.statusCode, answer.headers);
+        answer.pipe(response);
+    });
+    forwarded.on('error', () => response.destroy());
+    request.pipe(forwarded);
+}
+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);
+    if (answer.error !== undefined)
+        return { refused: refusalIn(answer.error.message, forwarded.status) };
+    const text = answer.result.content.map((content) => content.text).join('\n');
+    return answer.result.isError === true ? { refused: refusalIn(text, forwarded.status) } : { text };
+}
+function pendingSeconds(forwarded) {
+    if (forwarded.status !== 200)
+        return null;
+    const { result } = JSON.parse(forwarded.text);
+    if (result === undefined || result.isError === true)
+        return null;
+    const text = result.content.map((content) => content.text).join('\n');
+    if (!text.startsWith('{"pending":'))
+        return null;
+    const seconds = JSON.parse(text).pending.retry_after;
+    return typeof seconds === 'number' ? seconds : null;
+}
+function resendAfter(forwarded, attempt) {
+    if (forwarded === null)
+        return retryDelay(attempt);
+    if (forwarded.status >= 500)
+        return refusalOf(forwarded.text) === null ? retryDelay(attempt) : null;
+    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)
+        return answer;
+    const { results } = parse(answer.text);
+    return {
+        accepted: results.flatMap((result) => [
+            ...(result.from === undefined ? [] : [{ path: result.from, revision: null, content: null }]),
+            { path: result.path, revision: result.revision ?? null },
+        ]),
+    };
+}
+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 closed = new AbortController();
-    const mcp = async (message) => {
-        const params = message.params ?? {};
-        const tool = message.method === 'tools/call' ? String(params.name) : null;
-        const writes = tool !== null &&
-            (await house.post('/kit/tools/mutations', {}, closed.signal)).tools.some((listed) => listed.name === tool && listed.writes);
-        return {
-            headers: {
-                accept: 'application/json, text/event-stream',
-                'mcp-protocol-version': MCP_PROTOCOL_VERSION,
-                'mcp-method': message.method,
-                ...(tool === null ? {} : { 'mcp-name': tool }),
-            },
-            body: {
-                ...message,
-                params: {
-                    ...params,
-                    _meta: {
-                        'io.modelcontextprotocol/protocolVersion': MCP_PROTOCOL_VERSION,
-                        'io.modelcontextprotocol/clientInfo': { name: '@agentshouse/kit', version: KIT_VERSION },
-                        'io.modelcontextprotocol/clientCapabilities': {},
-                        ...(writes ? { 'agents.house/agent-operation': operationId() } : {}),
-                    },
-                },
-            },
-        };
+    const sent = (message, operation) => callHouse(origin, credential, message, operation, closed.signal);
+    const send = async (message, operation) => {
+        if (operation === null)
+            return sent(message, null);
+        for (let attempt = 0;; attempt++) {
+            const forwarded = await sent(message, operation).catch((error) => {
+                if (closed.signal.aborted)
+                    throw error;
+                return null;
+            });
+            const after = resendAfter(forwarded, attempt);
+            if (after === null)
+                return forwarded;
+            await delay(after, undefined, { signal: closed.signal });
+        }
+    };
+    const call = (name, args) => rpc('tools/call', { name, arguments: args });
+    const staged = async (operation, changes) => {
+        const bytes = Buffer.from(JSON.stringify({ changes }));
+        const sha256 = createHash('sha256').update(bytes).digest('hex');
+        const prepared = answered(await send(call('run_command', {
+            command: 'prepare_edit_upload',
+            arguments: { paths: changedPaths(changes), bytes: bytes.length, sha256 },
+        }), operation));
+        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) };
+        const held = JSON.parse(text).transfer;
+        return { url: held.url, operation: held.operation, bytes: bytes.length, sha256 };
+    };
+    let mutations = null;
+    const writes = async (tool) => {
+        mutations ??= house
+            .post('/kit/tools/mutations', {}, closed.signal)
+            .then(({ tools }) => new Set(tools.filter((listed) => listed.writes).map((listed) => listed.name)));
+        try {
+            return (await mutations).has(tool);
+        }
+        catch (error) {
+            mutations = null;
+            throw error;
+        }
     };
     const forward = async (path, text) => {
-        const call = path === '/' ? await mcp(JSON.parse(text)) : null;
+        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}`, ...call?.headers },
-            body: call === null ? text : JSON.stringify(call.body),
+            headers: { 'content-type': 'application/json', authorization: `Bearer ${credential}` },
+            body: versioned(conversationId, text),
             signal: closed.signal,
         });
         return { status: answer.status, text: await answer.text() };
     };
+    const caller = {
+        key: `conversation:${conversationId}`,
+        submit: async (operation, changes, held, retain) => {
+            const inline = call('edit', { changes });
+            let upload = held;
+            if (upload === undefined && Buffer.byteLength(mcpBody(inline, operation)) > MCP_REQUEST_BYTES) {
+                const prepared = await staged(operation, changes);
+                if ('refused' in prepared)
+                    return prepared;
+                upload = prepared;
+                await retain(upload);
+            }
+            return editAnswer(await send(upload === undefined ? inline : call('edit', { paths: changedPaths(changes), upload }), operation));
+        },
+    };
+    const local = async (path, text) => {
+        if (path === '/git/push') {
+            const { cwd, commit } = JSON.parse(text);
+            return { status: 200, text: JSON.stringify(await copies.push(cwd, commit, caller)) };
+        }
+        if (path === '/git/observed') {
+            await copies.observed(JSON.parse(text));
+            return { status: 200, text: '{}' };
+        }
+        return path === '/' || path === ATTACHMENTS ? forward(path, text) : { status: 404, text: '' };
+    };
     const sockets = join(kitHome(), 'bridges');
     await mkdir(sockets, { recursive: true, mode: 0o700 });
     const socketPath = join(sockets, `${randomUUID()}.sock`);
     const bridge = createServer(async (request, response) => {
         try {
             const path = request.url ?? '';
-            const forwarded = FORWARDED.has(path) ? await forward(path, await received(request)) : { status: 404, text: '' };
-            response.writeHead(forwarded.status, { 'content-type': 'application/json' }).end(forwarded.text);
+            if (URL.canParse(path)) {
+                relay(request, response, new URL(path));
+                return;
+            }
+            const answered = await local(path, await received(request));
+            response.writeHead(answered.status, { 'content-type': 'application/json' }).end(answered.text);
         }
         catch (error) {
-            response.writeHead(502).end(error instanceof Error ? error.message : String(error));
+            if (error instanceof HouseRefusal) {
+                response.writeHead(error.status, { 'content-type': 'application/json' }).end(error.text);
+                return;
+            }
+            response.writeHead(502).end(request.url === '/git/push' && error instanceof Error ? error.message : UNREACHABLE);
         }
     });
     bridge.listen(socketPath);
@@ -86,13 +215,7 @@ export async function openBridge(house, conversationId, signal) {
             response.writeHead(404).end();
             return;
         }
-        const send = target.protocol === 'https:' ? httpsRequest : httpRequest;
-        const forwarded = send(target, { method: request.method, headers: { ...request.headers, host: target.host, authorization } }, (answer) => {
-            response.writeHead(answer.statusCode, answer.headers);
-            answer.pipe(response);
-        });
-        forwarded.on('error', () => response.destroy());
-        request.pipe(forwarded);
+        relay(request, response, target, authorization);
     });
     git.listen(0, '127.0.0.1');
     await once(git, 'listening');
@@ -100,12 +223,13 @@ export async function openBridge(house, conversationId, signal) {
     return {
         env: {
             HOUSE_BRIDGE: socketPath,
+            PATH: path,
             GIT_CONFIG_COUNT: '1',
             GIT_CONFIG_KEY_0: `url.${proxy}/app/.insteadOf`,
             GIT_CONFIG_VALUE_0: app,
         },
         tool: async (name, args) => {
-            const forwarded = await forward('/', JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'tools/call', params: { name, arguments: 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-main.js

@@ -0,0 +1,23 @@
+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/clis.js

@@ -1,6 +1,7 @@
 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 { kitHome } from './home.js';
 const RUNNING_JOB = new Set(['running', 'paused']);
@@ -20,34 +21,55 @@ function asyncTask({ method, params }) {
     }
     return null;
 }
+function airPhase({ _meta }) {
+    const phase = _meta?.jetbrains?.air?.phase;
+    if (phase === 'commentary')
+        return 'note';
+    if (phase === 'final_answer')
+        return 'answer';
+    return null;
+}
 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: {} },
         args: [],
-        signedIn: { command: ['cli', 'login', 'status'] },
-        login: { args: ['cli', 'login', '--device-auth'], code: 'show' },
+        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,
     },
     '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' },
+        },
         args: [],
-        signedIn: { command: ['--cli', 'auth', 'status'] },
-        login: { args: ['--cli', 'auth', 'login', '--claudeai'], code: 'collect' },
+        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,
     },
     'grok-build': {
-        package: '@xai-official/grok',
         bin: 'grok',
+        minimum: '1.0.46',
+        install: 'curl -fsSL https://x.ai/cli/install.sh | bash',
+        adapter: null,
         args: ['agent', '--no-leader', 'stdio'],
         signedIn: { initializeMeta: 'defaultAuthMethodId' },
         login: { args: ['login', '--device-auth'], code: 'show' },
@@ -61,50 +83,102 @@ export const CLIS = {
                 return { id: params.update.task_snapshot.task_id, running: false };
             return null;
         },
+        phase: () => null,
     },
 };
 const KIT_PACKAGE = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
 export const KIT_VERSION = KIT_PACKAGE.version;
-export function pinned(kind) {
-    return KIT_PACKAGE.peerDependencies[CLIS[kind].package];
-}
+const PROXY = /^https?_proxy$/i;
+const VERSION = /\d+\.\d+\.\d+(?:-[0-9A-Za-z.]+)?/;
+const INSTALL_MS = 15 * 60_000;
+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 {
         return null;
     }
 }
-export function run(command, args, timeoutMs) {
+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 });
+        const child = spawn(command, args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            timeout: timeoutMs,
+            env: withoutProxy(),
+            detached,
+            signal,
+        });
+        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) => resolve({ status: null, stdout, output: error.message }));
+        child.on('close', (status) => resolve({ 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) {
+    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);
+    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);
+    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 = '') {
+    return run(loginShell(), ['-l', '-i', '-c', `exec /bin/sh -c '${USER_BIN}; ${script}' sh ${argument}`], READ_MS, true);
+}
+export async function locate(kind) {
+    const ran = await inLoginShell(LOOKUP, CLIS[kind].bin);
+    return ran.stdout.split('\n').findLast((line) => line.startsWith(FOUND))?.slice(FOUND.length) ?? null;
+}
+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 versionOf(path) {
+    return VERSION.exec((await run(path, ['--version'], READ_MS)).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/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');