@agentshouse/kit 0.2.0 → 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

@@ -0,0 +1,120 @@
+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, 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, added = {}) {
+    const child = spawn(cliCommand(kind), CLIS[kind].args, {
+        cwd,
+        env: { ...withoutProxy(), ...added },
+        stdio: ['pipe', 'pipe', 'pipe'],
+        detached: true,
+    });
+    let stderr = '';
+    child.stderr.on('data', (chunk) => {
+        stderr = (stderr + chunk.toString('utf8')).slice(-4000);
+    });
+    const exited = new Promise((resolve) => {
+        child.on('error', (error) => resolve(`the CLI did not start: ${error.message}`));
+        child.on('exit', (code, signal) => {
+            const last = stderr.trim().split('\n').at(-1);
+            resolve(`the CLI exited with ${code ?? signal}${last ? `: ${last}` : ''}`);
+        });
+    });
+    const stream = ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
+    const connection = app.connect({
+        writable: stream.writable,
+        readable: stream.readable.pipeThrough(new TransformStream({
+            transform(message, controller) {
+                const notice = message;
+                const job = CLIS[kind].job(notice);
+                if (job !== null)
+                    jobs(job);
+                if (!notice.params?.update?.sessionUpdate?.startsWith('async_task_'))
+                    controller.enqueue(message);
+                if (CLIS[kind].turnStarted(notice))
+                    controller.enqueue({ jsonrpc: '2.0', method: TURN_STARTED });
+                if (CLIS[kind].turnEnded(notice))
+                    controller.enqueue({ jsonrpc: '2.0', method: TURN_ENDED });
+            },
+        })),
+    });
+    void exited.then((cause) => connection.close(new Error(cause)));
+    try {
+        const initialized = await connection.agent.request('initialize', {
+            protocolVersion: PROTOCOL_VERSION,
+            clientCapabilities: {
+                fs: { readTextFile: false, writeTextFile: false },
+                terminal: false,
+                elicitation: { form: {} },
+                _meta: { jetbrains: { air: { version: 1, capabilities: ['asyncTasks'] } } },
+            },
+            clientInfo: { name: '@agentshouse/kit', version: KIT_VERSION },
+        });
+        return { child, connection, initialized, exited };
+    }
+    catch (error) {
+        child.kill('SIGKILL');
+        throw error;
+    }
+}
+function parents() {
+    const children = new Map();
+    for (const entry of readdirSync('/proc')) {
+        if (!/^\d+$/.test(entry))
+            continue;
+        try {
+            const stat = readFileSync(`/proc/${entry}/stat`, 'utf8');
+            const parent = Number(stat.slice(stat.lastIndexOf(')') + 2).split(' ')[1]);
+            children.set(parent, [...(children.get(parent) ?? []), Number(entry)]);
+        }
+        catch { }
+    }
+    return children;
+}
+function descendants(roots) {
+    const children = parents();
+    const tree = [];
+    const pending = roots.flatMap((root) => children.get(root) ?? []);
+    while (pending.length > 0) {
+        const pid = pending.pop();
+        tree.push(pid);
+        pending.push(...(children.get(pid) ?? []));
+    }
+    return tree;
+}
+function killAll(pids) {
+    for (const pid of pids) {
+        for (const target of [-pid, pid]) {
+            try {
+                process.kill(target, 'SIGKILL');
+            }
+            catch { }
+        }
+    }
+}
+function marked(marker) {
+    return readdirSync('/proc')
+        .filter((entry) => {
+        try {
+            return /^\d+$/.test(entry) && readFileSync(`/proc/${entry}/environ`, 'utf8').split('\0').includes(marker);
+        }
+        catch {
+            return false;
+        }
+    })
+        .map(Number);
+}
+export function killTree(child) {
+    killAll([child.pid, ...descendants([child.pid])]);
+}
+export function killMarked(marker) {
+    const pids = marked(marker);
+    killAll([...pids, ...descendants(pids)]);
+}
+export function killDescendants() {
+    const pids = marked(`HOUSE_KIT_RESIDENT=${process.pid}`);
+    killAll([...pids, ...descendants([process.pid, ...pids])]);
+}

package/dist/agents.js

@@ -0,0 +1,96 @@
+import { client } from '@agentclientprotocol/sdk';
+import { readFile } from 'node:fs/promises';
+import { startAdapter } from './acp.js';
+import { CLIS, KIT_VERSION, cliCommand, install, run } from './clis.js';
+import { kitHome } from './home.js';
+async function signedIn(kind) {
+    const probe = CLIS[kind].signedIn;
+    if ('command' in probe) {
+        return (await run(cliCommand(kind), probe.command, 30_000)).status === 0;
+    }
+    try {
+        const adapter = await startAdapter(kind, kitHome(), client({ name: '@agentshouse/kit' }));
+        adapter.child.kill('SIGKILL');
+        const method = adapter.initialized._meta?.[probe.initializeMeta];
+        return typeof method === 'string' && method.length > 0;
+    }
+    catch {
+        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;
+}
+export class Agents {
+    desired = { agents: [], routes: [] };
+    house;
+    reading = Promise.resolve();
+    installing = Promise.resolve();
+    releases = new Map();
+    reporting = null;
+    again = false;
+    constructor(house) {
+        this.house = house;
+    }
+    read() {
+        return this.reading.then(() => undefined, () => undefined);
+    }
+    installed() {
+        return this.installing.catch(() => undefined);
+    }
+    route(agentId) {
+        return this.desired.routes.find((route) => route.agent_id === agentId);
+    }
+    refresh() {
+        const reading = this.read().then(async () => {
+            this.desired = await this.house.deliver('/kit/agents/desired', {});
+            return this.desired;
+        });
+        this.reading = reading;
+        const installing = this.installed()
+            .then(() => reading)
+            .then(({ agents }) => this.install(agents));
+        this.installing = installing;
+        if (this.reporting === null)
+            this.reporting = this.reports();
+        else
+            this.again = true;
+        return Promise.all([installing, this.reporting]).then(() => undefined);
+    }
+    async report() {
+        const 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) {
+        const releases = new Map();
+        for (const kind of kinds)
+            releases.set(kind, await install(kind));
+        this.releases = releases;
+    }
+    async reports() {
+        try {
+            do {
+                this.again = false;
+                await this.installing;
+                await this.report();
+            } while (this.again);
+        }
+        finally {
+            this.reporting = null;
+        }
+    }
+}

package/dist/api.js

@@ -1,11 +1,47 @@
-export async function post(house, path, body) {
+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) {
     const answer = await fetch(new URL(path, house), {
         method: 'POST',
-        headers: { 'content-type': 'application/json' },
+        headers: {
+            'content-type': 'application/json',
+            ...(credential === undefined ? {} : { authorization: `Bearer ${credential}` }),
+        },
         body: JSON.stringify(body),
+        signal,
     });
     const text = await answer.text();
     if (!answer.ok)
-        throw new Error(`House refused ${path} with ${answer.status}: ${text}`);
+        throw new HouseRefusal(path, answer.status, text);
     return JSON.parse(text);
 }
+async function enrolledPost(path, body, signal) {
+    const { house, credential } = (await readEnrolment());
+    return post(house, path, body, credential, signal);
+}
+export const house = {
+    post: enrolledPost,
+    deliver: async (path, body, current = () => true) => {
+        for (let attempt = 0;; attempt++) {
+            try {
+                return await enrolledPost(path, body);
+            }
+            catch (error) {
+                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)));
+                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/blocks.js

@@ -0,0 +1,51 @@
+const FENCE = /^\s*(`{3,}|~{3,})\s*(\S*)/;
+export function blocksOf(text) {
+    const blocks = [];
+    let paragraph = [];
+    let fence = null;
+    const closeParagraph = () => {
+        const joined = paragraph.join('\n').trim();
+        if (joined.length > 0)
+            blocks.push({ type: 'paragraph', text: joined });
+        paragraph = [];
+    };
+    const closeFence = () => {
+        const joined = fence.lines.join('\n');
+        if (joined.length > 0)
+            blocks.push({ type: 'code', language: fence.language, text: joined });
+        fence = null;
+    };
+    for (const line of text.split('\n')) {
+        if (fence !== null) {
+            if (line.trim().startsWith(fence.marker))
+                closeFence();
+            else
+                fence.lines.push(line);
+            continue;
+        }
+        const opening = FENCE.exec(line);
+        if (opening !== null) {
+            closeParagraph();
+            fence = { marker: opening[1], language: opening[2] || null, lines: [] };
+        }
+        else if (line.trim().length === 0) {
+            closeParagraph();
+        }
+        else {
+            paragraph.push(line);
+        }
+    }
+    if (fence !== null)
+        closeFence();
+    closeParagraph();
+    return blocks;
+}
+export function firstChange(before, after) {
+    let index = 0;
+    while (index < before.length &&
+        index < after.length &&
+        JSON.stringify(before[index]) === JSON.stringify(after[index])) {
+        index++;
+    }
+    return index;
+}

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

@@ -0,0 +1,214 @@
+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 { 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']);
+export async function received(request) {
+    let text = '';
+    request.setEncoding('utf8');
+    for await (const chunk of request)
+        text += chunk;
+    return text;
+}
+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 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: 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) => {
+        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}` },
+            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 ?? '';
+            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));
+        }
+    });
+    bridge.listen(socketPath);
+    await once(bridge, 'listening');
+    const app = new URL('/app/', origin).href;
+    const authorization = `Basic ${Buffer.from(`house:${credential}`).toString('base64')}`;
+    const git = createServer((request, response) => {
+        const target = new URL(request.url ?? '', app);
+        if (!target.href.startsWith(app)) {
+            response.writeHead(404).end();
+            return;
+        }
+        relay(request, response, target, authorization);
+    });
+    git.listen(0, '127.0.0.1');
+    await once(git, 'listening');
+    const proxy = `http://127.0.0.1:${git.address().port}`;
+    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 } }));
+            if (forwarded.status !== 200)
+                throw new Error(`House refused ${name} with ${forwarded.status}: ${forwarded.text}`);
+            const answer = JSON.parse(forwarded.text);
+            if (answer.error !== undefined)
+                throw new Error(`House refused ${name}: ${answer.error.message}`);
+            return answer.result;
+        },
+        close: () => {
+            closed.abort();
+            bridge.close();
+            bridge.closeAllConnections();
+            git.close();
+            git.closeAllConnections();
+        },
+    };
+}