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

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,9 +1,11 @@
 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 async function post(house, path, body, credential, signal) {

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.10",
+  "hosts": {
+    "linux": {
+      "command": "bash <(curl -fsSL https://github.com/agentshouse/kit/releases/download/v0.2.1-alpha.10/connect-linux.sh)",
+      "asset": {
+        "name": "connect-linux.sh",
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-alpha.10/connect-linux.sh"
+      },
+      "workspace": {
+        "argument": "--workspace",
+        "quoting": "posix"
+      }
+    },
+    "windows": {
+      "command": "& ([scriptblock]::Create((irm https://github.com/agentshouse/kit/releases/download/v0.2.1-alpha.10/connect-windows.ps1)))",
+      "asset": {
+        "name": "connect-windows.ps1",
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-alpha.10/connect-windows.ps1"
+      },
+      "workspace": {
+        "argument": "--workspace",
+        "quoting": "powershell"
+      }
+    }
+  }
+}

package/dist/bridge.js

@@ -1,76 +1,171 @@
-import { randomBytes, randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { once } from 'node:events';
 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 { KIT_VERSION } from './clis.js';
+import { changedPaths, refusalCode, } from './copies.js';
 import { kitHome, readEnrolment } from './home.js';
+import { operationId } from './operation.js';
 const MCP_PROTOCOL_VERSION = '2026-07-28';
+const MCP_REQUEST_BYTES = 4 * 1024 * 1024;
 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) {
+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 answered(forwarded) {
+    if (forwarded.status >= 500)
+        throw new Error(`House answered ${forwarded.status}`);
+    if (forwarded.status !== 200)
+        return { refused: { code: refusalCode(forwarded.text), text: forwarded.text } };
+    const answer = JSON.parse(forwarded.text);
+    if (answer.error !== undefined)
+        return { refused: { code: refusalCode(answer.error.message), text: answer.error.message } };
+    const text = answer.result.content.map((content) => content.text).join('\n');
+    return answer.result.isError === true ? { refused: { code: refusalCode(text), text } } : { text };
+}
+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.op === 'remove' ? null : result.revision },
+        ]),
+    };
+}
+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 send = 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 call = (name, args) => ({ jsonrpc: '2.0', id: 1, 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 Error(`House answered ${posted.status}`);
+        if (!posted.ok)
+            return { refused: { code: refusalCode(text), text } };
+        const held = JSON.parse(text).transfer;
+        return { url: held.url, operation: held.operation, bytes: bytes.length, sha256 };
     };
     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;
+            const writes = tool !== null &&
+                (await house.post('/kit/tools/mutations', {}, closed.signal)).tools.some((listed) => listed.name === tool && listed.writes);
+            return send(message, writes ? 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: 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 FORWARDED.has(path) ? 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));
@@ -86,13 +181,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,6 +189,7 @@ 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,

package/dist/clis.js

@@ -65,6 +65,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 function pinned(kind) {
     return KIT_PACKAGE.peerDependencies[CLIS[kind].package];
 }
@@ -83,9 +84,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');

package/dist/conversations.js

@@ -9,11 +9,15 @@ import { CLIS } from './clis.js';
 import { placeFiles } from './files.js';
 import { instructions } from './instructions.js';
 import { holdSecretInput } from './secret-input.js';
+import { createHowWeWork } from './skills.js';
 const LAUNCH_BASE = '/agents/house';
 const KILLED = 'the conversation was killed';
 function causeOf(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function answerMessage(request, response) {
+    return `The User answered a question you asked earlier.\nQuestion: ${JSON.stringify(request)}\nAnswer: ${JSON.stringify(response)}`;
+}
 function logged(error) {
     process.stderr.write(`kit: ${causeOf(error)}\n`);
 }
@@ -36,11 +40,11 @@ class Turn {
     unsentFrom = null;
     draftSequence = 0;
     planSequence = 0;
+    entries = null;
     questions = 0;
     secrets = 0;
     prompt = null;
     ended = false;
-    ready = Promise.resolve();
 }
 class Conversation {
     id;
@@ -140,8 +144,13 @@ export class Conversations {
         }
         if (input.kind === 'option')
             await this.option(conversation, String(input.option), input.value);
-        if (input.kind === 'answer')
-            this.questions.get(String(input.interaction_id))?.answer(input.response);
+        if (input.kind === 'answer') {
+            const question = this.questions.get(String(input.interaction_id));
+            if (question === undefined) {
+                return this.message(conversation, { ...input, text: answerMessage(input.request, input.response), files: [], first: false });
+            }
+            question.answer(input.response);
+        }
         return {};
     }
     async open(conversation, input) {
@@ -166,7 +175,10 @@ export class Conversations {
                     ack = { provider_session_id: opened };
             }
             if (input.first === true) {
-                prompt.push({ type: 'text', text: await instructions(conversation.running.bridge, route.base_instructions) });
+                prompt.push({
+                    type: 'text',
+                    text: await instructions(conversation.running.bridge, route.base_instructions, await this.kit.copies.mapping()),
+                });
             }
             prompt.push({ type: 'text', text: String(input.text) });
             if (paths.length > 0)
@@ -239,14 +251,15 @@ export class Conversations {
             .onRequest('session/request_permission', ({ params, signal }) => this.ask(conversation, 'session/request_permission', params, false, signal))
             .onRequest('elicitation/create', ({ params, signal }) => this.ask(conversation, 'elicitation/create', params, asksSecret(params), signal));
         await unlessKilled(this.kit.agents.installed(), conversation.killed.signal);
-        const bridge = await openBridge(this.kit.house, conversation.id, conversation.killed.signal);
+        const bridge = await openBridge(this.kit.house, this.kit.copies, conversation.id, conversation.killed.signal);
         if (conversation.kills > 0) {
             bridge.close();
             throw new Error(KILLED);
         }
         conversation.opening = bridge;
         try {
-            const adapter = await startAdapter(route.kind, route.working_directory, app, (job) => this.job(conversation, job), { ...process.env, ...bridge.env });
+            await unlessKilled(createHowWeWork(bridge), conversation.killed.signal);
+            const adapter = await startAdapter(route.kind, route.working_directory, app, (job) => this.job(conversation, job), bridge.env);
             void adapter.exited.then(() => bridge.close());
             const agent = adapter.connection.agent;
             const cwd = route.working_directory;
@@ -340,9 +353,19 @@ export class Conversations {
     report(conversation) {
         const turn = new Turn();
         conversation.open++;
-        turn.ready = this.deliver(conversation, turn, 'started', {}).then(() => undefined, logged);
+        void this.deliver(conversation, turn, 'started', {})
+            .then(() => this.admitted(conversation, turn))
+            .catch(logged);
         return turn;
     }
+    admitted(conversation, turn) {
+        if (turn.text !== '') {
+            turn.unsentFrom = 0;
+            this.draft(conversation, turn);
+        }
+        if (turn.entries !== null)
+            this.plan(conversation, turn);
+    }
     begin(conversation) {
         const turn = this.report(conversation);
         conversation.turn = turn;
@@ -479,12 +502,12 @@ export class Conversations {
         if (update.sessionUpdate === 'agent_message_chunk' && update.content.type === 'text') {
             const turn = this.started(conversation);
             turn.text += update.content.text;
-            const text = turn.text;
-            void turn.ready.then(() => this.draft(conversation, turn, text));
+            this.draft(conversation, turn);
         }
         else if (update.sessionUpdate === 'plan') {
             const turn = this.started(conversation);
-            void turn.ready.then(() => this.plan(conversation, turn, update.entries));
+            turn.entries = update.entries;
+            this.plan(conversation, turn);
         }
         else if (update.sessionUpdate === 'agent_thought_chunk' || update.sessionUpdate === 'tool_call') {
             this.started(conversation);
@@ -503,8 +526,8 @@ export class Conversations {
             conversation.jobs.delete(job.id);
         this.kit.changed();
     }
-    draft(conversation, turn, text) {
-        const blocks = blocksOf(text);
+    draft(conversation, turn) {
+        const blocks = blocksOf(turn.text);
         const from = Math.min(firstChange(turn.sent, blocks), turn.unsentFrom ?? Infinity);
         const sent = this.kit.send({
             type: 'draft',
@@ -523,14 +546,14 @@ export class Conversations {
             turn.unsentFrom = from;
         }
     }
-    plan(conversation, turn, entries) {
+    plan(conversation, turn) {
         const sent = this.kit.send({
             type: 'plan',
             conversation_id: conversation.id,
             turn_id: turn.id,
             sequence: turn.planSequence + 1,
             from: 0,
-            steps: entries.map((entry) => ({ label: entry.content, priority: entry.priority, status: entry.status })),
+            steps: turn.entries.map((entry) => ({ label: entry.content, priority: entry.priority, status: entry.status })),
         });
         if (sent)
             turn.planSequence++;