@agentshouse/kit 0.2.1-alpha.1 → 0.2.1-alpha.11

package/README.md

@@ -7,7 +7,19 @@ through the agent CLIs you chose and gives each Agent the `house` command.
 ## Install
 
 Connect a computer from agents.house. It gives you the one command that
-installs House Kit on that computer and updates it when you run it again.
+installs House Kit on that computer and updates it when you run it again. On
+Linux, macOS and Windows 11 it runs House Kit in one Docker container with
+your workspace, `~/AgentsHouse` unless you pass `--workspace <path>`, mounted
+at `/agents/house`. Append a `kit` or `house` command to the same command to
+run it in that container.
+
+On your own Ubuntu 26.04 server, run the Linux command with `--linux` to
+install House Kit natively, with its workspace at `/agents/house`; `kit` and
+`house` are then on the server's `PATH`.
+
+House Kit also gives every Agent on the Environment a set of agent skills. Add
+`--no-skills` to the command to leave them out; running it again without the
+flag brings them back.
 
 ## Commands
 
@@ -16,8 +28,14 @@ Environment's credential in `~/.house-kit`, or in `$HOUSE_KIT_HOME` when it is
 set. Pass `--manual` to paste the code by hand on a machine without a browser,
 and `--environment <id>` to reconnect an Environment you already have.
 
-`kit resident` keeps the Environment connected.
+`kit resident` keeps the Environment connected, and keeps the Rooms you chose
+for this Environment as Git repositories under `/agents/house/working-copies`.
+Commit in one and run `house git push --owner` there to send the commit to
+House; on a computer, run it through the install command from the copy's
+directory. Inside an Agent conversation the Agent runs `house git push`.
 
 ## License
 
 MIT
+
+The skills come from [mattpocock/skills](https://github.com/mattpocock/skills); thank you, Matt Pocock.

package/dist/acp.js

@@ -2,13 +2,13 @@ import { ndJsonStream, PROTOCOL_VERSION, } from '@agentclientprotocol/sdk';
 import { spawn } from 'node:child_process';
 import { readdirSync, readFileSync } from 'node:fs';
 import { Readable, Writable } from 'node:stream';
-import { CLIS, KIT_VERSION, cliCommand } from './clis.js';
+import { CLIS, KIT_VERSION, cliCommand, withoutProxy } from './clis.js';
 export const TURN_STARTED = 'kit/turn_started';
 export const TURN_ENDED = 'kit/turn_ended';
-export async function startAdapter(kind, cwd, app, jobs = () => undefined, env = process.env) {
+export async function startAdapter(kind, cwd, app, jobs = () => undefined, added = {}) {
     const child = spawn(cliCommand(kind), CLIS[kind].args, {
         cwd,
-        env,
+        env: { ...withoutProxy(), ...added },
         stdio: ['pipe', 'pipe', 'pipe'],
         detached: true,
     });

package/dist/agents.js

@@ -18,6 +18,10 @@ async function signedIn(kind) {
         return false;
     }
 }
+async function sshHostKey() {
+    const listed = await run('ssh-keygen', ['-l', '-E', 'sha256', '-f', '/etc/ssh/ssh_host_ed25519_key.pub'], 10_000);
+    return listed.status === 0 ? (/^\d+ (SHA256:\S+)/.exec(listed.output)?.[1] ?? null) : null;
+}
 async function operatingSystem() {
     const release = await readFile('/etc/os-release', 'utf8');
     return /^PRETTY_NAME="?([^"\n]*)"?$/m.exec(release)?.[1] ?? release;
@@ -63,10 +67,12 @@ export class Agents {
         for (const [kind, release] of this.releases) {
             agents.push({ kind, release, signed_in: release !== null && (await signedIn(kind)) });
         }
+        const hostKey = await sshHostKey();
         await this.house.deliver('/kit/agents/report', {
             os: await operatingSystem(),
             kit_version: KIT_VERSION,
             agents,
+            ...(hostKey === null ? {} : { ssh_host_key: hostKey }),
         });
     }
     async install(kinds) {

package/dist/api.js

@@ -1,11 +1,16 @@
 import { readEnrolment } from './home.js';
 export class HouseRefusal extends Error {
     status;
+    text;
     constructor(path, status, text) {
         super(`House refused ${path} with ${status}: ${text}`);
         this.status = status;
+        this.text = text;
     }
 }
+export function retryDelay(attempt) {
+    return Math.min(30_000, 1000 * 2 ** attempt);
+}
 export async function post(house, path, body, credential, signal) {
     const answer = await fetch(new URL(path, house), {
         method: 'POST',
@@ -36,7 +41,7 @@ export const house = {
                 if (error instanceof HouseRefusal && error.status < 500)
                     throw error;
                 process.stderr.write(`kit: ${path} did not reach House: ${error.message}\n`);
-                await new Promise((resolve) => setTimeout(resolve, Math.min(30_000, 1000 * 2 ** attempt)));
+                await new Promise((resolve) => setTimeout(resolve, retryDelay(attempt)));
                 if (!current())
                     throw error;
             }

package/dist/authority-main.js

@@ -0,0 +1,22 @@
+import { setGlobalProxyFromEnv } from 'node:http';
+import { HouseRefusal, post } from './api.js';
+import { readEnrolment } from './home.js';
+function unanswered(error) {
+    return error instanceof HouseRefusal ? error.status >= 500 : error instanceof TypeError && error.message === 'fetch failed';
+}
+setGlobalProxyFromEnv();
+try {
+    const { house, credential } = (await readEnrolment());
+    try {
+        await post(house, '/kit/agents/desired', {}, credential);
+    }
+    catch (error) {
+        if (!unanswered(error))
+            throw error;
+        process.stderr.write(`kit: House did not answer, so the stored credential stands: ${error.message}\n`);
+    }
+}
+catch (error) {
+    process.stderr.write(`kit: ${error.message}\n`);
+    process.exitCode = 1;
+}

package/dist/bootstrap.json

@@ -0,0 +1,28 @@
+{
+  "schemaVersion": 1,
+  "version": "0.2.1-alpha.11",
+  "hosts": {
+    "linux": {
+      "command": "bash <(curl -fsSL https://github.com/agentshouse/kit/releases/download/v0.2.1-alpha.11/connect-linux.sh)",
+      "asset": {
+        "name": "connect-linux.sh",
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-alpha.11/connect-linux.sh"
+      },
+      "workspace": {
+        "argument": "--workspace",
+        "quoting": "posix"
+      }
+    },
+    "windows": {
+      "command": "& ([scriptblock]::Create((irm https://github.com/agentshouse/kit/releases/download/v0.2.1-alpha.11/connect-windows.ps1)))",
+      "asset": {
+        "name": "connect-windows.ps1",
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-alpha.11/connect-windows.ps1"
+      },
+      "workspace": {
+        "argument": "--workspace",
+        "quoting": "powershell"
+      }
+    }
+  }
+}

package/dist/bridge.js

@@ -1,79 +1,236 @@
-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 { delimiter, join } from 'node:path';
+import { parse } from 'yaml';
+import { HouseRefusal, retryDelay } from './api.js';
 import { KIT_VERSION } from './clis.js';
+import { changedPaths, } from './copies.js';
 import { kitHome, readEnrolment } from './home.js';
+import { operationId, uuidOf } from './operation.js';
+import { refusalOf } from './refusals.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) {
+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);
+}
+const UNREACHABLE = 'House is unreachable; call again in a minute';
+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 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 {
+    const body = (message, operation) => JSON.stringify({
+        ...message,
+        params: {
+            ...message.params,
+            _meta: {
+                'io.modelcontextprotocol/protocolVersion': MCP_PROTOCOL_VERSION,
+                'io.modelcontextprotocol/clientInfo': { name: '@agentshouse/kit', version: KIT_VERSION },
+                'io.modelcontextprotocol/clientCapabilities': {},
+                ...(operation === null ? {} : { 'agents.house/agent-operation': operation }),
+            },
+        },
+    });
+    const sent = async (message, operation) => {
+        const tool = message.method === 'tools/call' ? String(message.params?.name) : null;
+        const answer = await fetch(new URL('/', origin), {
+            method: 'POST',
             headers: {
+                'content-type': 'application/json',
+                authorization: `Bearer ${credential}`,
                 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() } : {}),
-                    },
-                },
-            },
-        };
+            body: body(message, operation),
+            signal: closed.signal,
+        });
+        return { status: answer.status, text: await answer.text() };
+    };
+    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) => ({ jsonrpc: '2.0', id: randomUUID(), method: 'tools/call', params: { 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(body(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 +243,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 +251,13 @@ export async function openBridge(house, conversationId, signal) {
     return {
         env: {
             HOUSE_BRIDGE: socketPath,
+            PATH: `${join(kitHome(), 'shim')}${delimiter}${process.env.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({ jsonrpc: '2.0', id: randomUUID(), method: 'tools/call', params: { name, arguments: 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

@@ -20,6 +20,14 @@ 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',
@@ -31,6 +39,7 @@ export const CLIS = {
         turnStarted: (notice) => threadStatus(notice) === 'active',
         turnEnded: (notice) => threadStatus(notice) === 'idle',
         job: asyncTask,
+        phase: airPhase,
     },
     'claude-agent-acp': {
         package: '@agentclientprotocol/claude-agent-acp',
@@ -44,6 +53,7 @@ export const CLIS = {
             params?.update?.sessionUpdate === 'usage_update' &&
             params.update._meta?.['_claude/origin'] !== undefined,
         job: asyncTask,
+        phase: () => null,
     },
     'grok-build': {
         package: '@xai-official/grok',
@@ -61,10 +71,12 @@ 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;
+const PROXY = /^https?_proxy$/i;
 export function pinned(kind) {
     return KIT_PACKAGE.peerDependencies[CLIS[kind].package];
 }
@@ -83,9 +95,12 @@ export async function installedRelease(kind) {
         return null;
     }
 }
+export function withoutProxy() {
+    return Object.fromEntries(Object.entries(process.env).filter(([name]) => !PROXY.test(name)));
+}
 export function run(command, args, timeoutMs) {
     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() });
         let output = '';
         child.stdout.on('data', (chunk) => {
             output += chunk.toString('utf8');

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');