@agentshouse/kit 0.1.0-alpha.9 → 0.2.1-alpha.1

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 } 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) {
+    const child = spawn(cliCommand(kind), CLIS[kind].args, {
+        cwd,
+        env,
+        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,90 @@
+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 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)) });
+        }
+        await this.house.deliver('/kit/agents/report', {
+            os: await operatingSystem(),
+            kit_version: KIT_VERSION,
+            agents,
+        });
+    }
+    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

@@ -0,0 +1,45 @@
+import { readEnrolment } from './home.js';
+export class HouseRefusal extends Error {
+    status;
+    constructor(path, status, text) {
+        super(`House refused ${path} with ${status}: ${text}`);
+        this.status = status;
+    }
+}
+export async function post(house, path, body, credential, signal) {
+    const answer = await fetch(new URL(path, house), {
+        method: 'POST',
+        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 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/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/bridge.js

@@ -0,0 +1,124 @@
+import { randomBytes, 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 { KIT_VERSION } from './clis.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) {
+    let text = '';
+    request.setEncoding('utf8');
+    for await (const chunk of request)
+        text += chunk;
+    return text;
+}
+export async function openBridge(house, 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 {
+            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 forward = async (path, text) => {
+        const call = path === '/' ? await mcp(JSON.parse(text)) : 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),
+            signal: closed.signal,
+        });
+        return { status: answer.status, text: await answer.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);
+        }
+        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;
+        }
+        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);
+    });
+    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,
+            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();
+        },
+    };
+}

package/dist/clis.js

@@ -0,0 +1,110 @@
+import { spawn } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { kitHome } from './home.js';
+const RUNNING_JOB = new Set(['running', 'paused']);
+function threadStatus({ method, params }) {
+    if (method !== 'session/update' || params?.update?.sessionUpdate !== 'session_info_update')
+        return undefined;
+    return params.update._meta?.codex?.threadStatus?.type;
+}
+function asyncTask({ method, params }) {
+    const update = params?.update;
+    if (method !== 'session/update' || update?.asyncTaskId === undefined)
+        return null;
+    if (update.sessionUpdate === 'async_task_spawned')
+        return { id: update.asyncTaskId, running: true };
+    if (update.sessionUpdate === 'async_task_state_update' && !RUNNING_JOB.has(update.state ?? '')) {
+        return { id: update.asyncTaskId, running: false };
+    }
+    return null;
+}
+export const CLIS = {
+    'codex-acp': {
+        package: '@agentclientprotocol/codex-acp',
+        bin: 'codex-acp',
+        args: [],
+        signedIn: { command: ['cli', 'login', 'status'] },
+        login: { args: ['cli', 'login', '--device-auth'], code: 'show' },
+        queues: false,
+        turnStarted: (notice) => threadStatus(notice) === 'active',
+        turnEnded: (notice) => threadStatus(notice) === 'idle',
+        job: asyncTask,
+    },
+    'claude-agent-acp': {
+        package: '@agentclientprotocol/claude-agent-acp',
+        bin: 'claude-agent-acp',
+        args: [],
+        signedIn: { command: ['--cli', 'auth', 'status'] },
+        login: { args: ['--cli', 'auth', 'login', '--claudeai'], code: 'collect' },
+        queues: false,
+        turnStarted: () => false,
+        turnEnded: ({ method, params }) => method === 'session/update' &&
+            params?.update?.sessionUpdate === 'usage_update' &&
+            params.update._meta?.['_claude/origin'] !== undefined,
+        job: asyncTask,
+    },
+    'grok-build': {
+        package: '@xai-official/grok',
+        bin: 'grok',
+        args: ['agent', '--no-leader', 'stdio'],
+        signedIn: { initializeMeta: 'defaultAuthMethodId' },
+        login: { args: ['login', '--device-auth'], code: 'show' },
+        queues: true,
+        turnStarted: ({ method, params }) => method === '_x.ai/queue/changed' && params?.runningPromptId !== undefined,
+        turnEnded: ({ method, params }) => method === '_x.ai/session_notification' && params?.update?.sessionUpdate === 'turn_completed',
+        job: ({ method, params }) => {
+            if (method === '_x.ai/task_backgrounded')
+                return { id: params.update.task_id, running: true };
+            if (method === '_x.ai/task_completed')
+                return { id: params.update.task_snapshot.task_id, running: false };
+            return 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];
+}
+function prefix(kind) {
+    return join(kitHome(), 'agents', kind);
+}
+export function cliCommand(kind) {
+    return join(prefix(kind), 'node_modules', '.bin', CLIS[kind].bin);
+}
+export async function installedRelease(kind) {
+    try {
+        const manifest = join(prefix(kind), 'node_modules', CLIS[kind].package, 'package.json');
+        return JSON.parse(await readFile(manifest, 'utf8')).version;
+    }
+    catch {
+        return null;
+    }
+}
+export function run(command, args, timeoutMs) {
+    return new Promise((resolve) => {
+        const child = spawn(command, args, { stdio: ['ignore', 'pipe', 'pipe'], timeout: timeoutMs });
+        let output = '';
+        child.stdout.on('data', (chunk) => {
+            output += chunk.toString('utf8');
+        });
+        child.stderr.on('data', (chunk) => {
+            output += chunk.toString('utf8');
+        });
+        child.on('error', (error) => resolve({ status: null, output: error.message }));
+        child.on('close', (status) => resolve({ status, 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`);
+        return null;
+    }
+    return installedRelease(kind);
+}