@agentshouse/kit 0.2.1-alpha.4 → 0.2.1-alpha.6

package/README.md

@@ -16,7 +16,10 @@ 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; inside an Agent conversation the Agent runs `house git push`.
 
 ## License
 

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/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/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/conversations.js

@@ -174,7 +174,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)
@@ -247,14 +250,14 @@ 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 });
+            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;