@agentshouse/kit 0.2.1-alpha.16 → 0.2.1-alpha.18

package/README.md

@@ -38,7 +38,9 @@ flag brings them back.
 `kit login` opens a link you confirm in your browser and keeps the
 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.
+and `--environment <id>` to reconnect an Environment you already have. It also
+connects your own agent: `house <tool>` run outside an Agent conversation calls
+House as you, until you revoke that connection on Connections.
 
 `kit resident` keeps the Environment connected, and keeps the Rooms you chose
 for this Environment as Git repositories under `working-copies` in the

package/dist/acp.js

@@ -9,7 +9,7 @@ export async function startAdapter(kind, cli, cwd, app, jobs = () => undefined,
     const adapter = CLIS[kind].adapter;
     const child = spawn(adapter === null ? cli : adapterCommand(kind), CLIS[kind].args, {
         cwd,
-        env: { ...withoutProxy(), ...(adapter === null ? {} : { [adapter.executable]: cli }), ...added },
+        env: { ...withoutProxy(), ...(adapter === null ? {} : { ...adapter.env, [adapter.executable]: cli }), ...added },
         stdio: ['pipe', 'pipe', 'pipe'],
         detached: true,
     });

package/dist/bootstrap.json

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

package/dist/bridge.js

@@ -4,15 +4,15 @@ 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 { delimiter, join } from 'node:path';
+import { delimiter, dirname, join } from 'node:path';
 import { parse } from 'yaml';
 import { HouseRefusal, retryDelay } from './api.js';
-import { KIT_VERSION } from './clis.js';
+import { loginPath } from './clis.js';
 import { changedPaths, } from './copies.js';
 import { kitHome, readEnrolment } from './home.js';
+import { callHouse, mcpBody, rpc, UNREACHABLE } from './mcp.js';
 import { operationId, uuidOf } from './operation.js';
 import { refusalOf } from './refusals.js';
-const MCP_PROTOCOL_VERSION = '2026-07-28';
 const MCP_REQUEST_BYTES = 4 * 1024 * 1024;
 const ATTACHMENTS = '/kit/attachments/upload';
 export async function received(request) {
@@ -34,7 +34,6 @@ function relay(request, response, target, authorization) {
     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: [] };
 }
@@ -87,38 +86,11 @@ function editAnswer(forwarded) {
     };
 }
 export async function openBridge(house, copies, conversationId, signal) {
+    const path = [join(kitHome(), 'shim'), dirname(process.execPath), await loginPath()].join(delimiter);
     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 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: body(message, operation),
-            signal: closed.signal,
-        });
-        return { status: answer.status, text: await answer.text() };
-    };
+    const sent = (message, operation) => callHouse(origin, credential, message, operation, closed.signal);
     const send = async (message, operation) => {
         if (operation === null)
             return sent(message, null);
@@ -134,7 +106,7 @@ export async function openBridge(house, copies, conversationId, signal) {
             await delay(after, undefined, { signal: closed.signal });
         }
     };
-    const call = (name, args) => ({ jsonrpc: '2.0', id: randomUUID(), method: 'tools/call', params: { name, arguments: args } });
+    const call = (name, args) => rpc('tools/call', { name, arguments: args });
     const staged = async (operation, changes) => {
         const bytes = Buffer.from(JSON.stringify({ changes }));
         const sha256 = createHash('sha256').update(bytes).digest('hex');
@@ -175,7 +147,7 @@ export async function openBridge(house, copies, conversationId, signal) {
     const forward = async (path, text) => {
         if (path === '/') {
             const message = JSON.parse(text);
-            const tool = message.method === 'tools/call' ? String(message.params?.name) : null;
+            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), {
@@ -191,7 +163,7 @@ export async function openBridge(house, copies, conversationId, signal) {
         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) {
+            if (upload === undefined && Buffer.byteLength(mcpBody(inline, operation)) > MCP_REQUEST_BYTES) {
                 const prepared = await staged(operation, changes);
                 if ('refused' in prepared)
                     return prepared;
@@ -251,13 +223,13 @@ export async function openBridge(house, copies, conversationId, signal) {
     return {
         env: {
             HOUSE_BRIDGE: socketPath,
-            PATH: `${join(kitHome(), 'shim')}${delimiter}${process.env.PATH ?? ''}`,
+            PATH: 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: randomUUID(), method: 'tools/call', params: { name, arguments: args } }));
+            const forwarded = await forward('/', JSON.stringify(call(name, 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

@@ -34,7 +34,7 @@ export const CLIS = {
         bin: 'codex',
         minimum: '0.159.1',
         install: 'curl -fsSL https://chatgpt.com/codex/install.sh | sh',
-        adapter: { package: '@agentclientprotocol/codex-acp', bin: 'codex-acp', executable: 'CODEX_PATH' },
+        adapter: { package: '@agentclientprotocol/codex-acp', bin: 'codex-acp', executable: 'CODEX_PATH', env: {} },
         args: [],
         signedIn: { command: ['login', 'status'] },
         login: { args: ['login', '--device-auth'], code: 'show' },
@@ -52,6 +52,7 @@ export const CLIS = {
             package: '@agentclientprotocol/claude-agent-acp',
             bin: 'claude-agent-acp',
             executable: 'CLAUDE_CODE_EXECUTABLE',
+            env: { CLAUDE_CODE_ENTRYPOINT: 'claude-agent-acp' },
         },
         args: [],
         signedIn: { command: ['auth', 'status'] },
@@ -153,10 +154,19 @@ function loginShell() {
 }
 const FOUND = 'house-kit-cli ';
 const LOOKUP = `found=$(command -v "$1") || exit 0; case $found in /*) ;; *) found=$(pwd -P)/$found ;; esac; printf "${FOUND}%s\\n" "$found"`;
+const USER_BIN = 'case ":$PATH:" in *":$HOME/.local/bin:"*) ;; *) PATH="$PATH:$HOME/.local/bin" ;; esac; export PATH';
+function inLoginShell(script, argument = '') {
+    return run(loginShell(), ['-l', '-i', '-c', `exec /bin/sh -c '${USER_BIN}; ${script}' sh ${argument}`], READ_MS, true);
+}
 export async function locate(kind) {
-    const ran = await run(loginShell(), ['-l', '-i', '-c', `exec /bin/sh -c '${LOOKUP}' sh ${CLIS[kind].bin}`], READ_MS, true);
+    const ran = await inLoginShell(LOOKUP, CLIS[kind].bin);
     return ran.stdout.split('\n').findLast((line) => line.startsWith(FOUND))?.slice(FOUND.length) ?? null;
 }
+export async function loginPath() {
+    const marker = 'house-kit-path ';
+    const ran = await inLoginShell(`printf "${marker}%s\\n" "$PATH"`);
+    return ran.stdout.split('\n').findLast((line) => line.startsWith(marker)).slice(marker.length);
+}
 export async function versionOf(path) {
     return VERSION.exec((await run(path, ['--version'], READ_MS)).stdout)?.[0] ?? null;
 }

package/dist/home.js

@@ -1,8 +1,9 @@
-import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 const ENROLMENT = 'credential.json';
 const CONFIGURATION = 'kit.json';
+const OWN_AGENT = 'own-agent.json';
 export function kitHome() {
     return process.env.HOUSE_KIT_HOME ?? join(homedir(), '.house-kit');
 }
@@ -35,6 +36,15 @@ export function readEnrolment() {
 export function writeEnrolment(enrolment) {
     return writeHome(ENROLMENT, enrolment);
 }
+export function readOwnAgent() {
+    return readHome(OWN_AGENT);
+}
+export function writeOwnAgent(ownAgent) {
+    return writeHome(OWN_AGENT, ownAgent);
+}
+export function forgetOwnAgent() {
+    return rm(join(kitHome(), OWN_AGENT), { force: true });
+}
 export async function readConfiguration() {
     return { skills: (await readHome(CONFIGURATION))?.skills !== false };
 }

package/dist/house-main.js

@@ -1,15 +1,18 @@
 #!/usr/bin/env node
-import { createHash, randomUUID } from 'node:crypto';
+import { createHash } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
-import { request } from 'node:http';
+import { request, setGlobalProxyFromEnv } from 'node:http';
 import { basename, join } from 'node:path';
-import { kitHome } from './home.js';
+import { kitHome, readOwnAgent } from './home.js';
+import { callHouse, rpc, UNREACHABLE } from './mcp.js';
 import { refusalOf } from './refusals.js';
 const USAGE = "usage: house <tool> ['<arguments as JSON>']";
 const GIT_USAGE = 'usage: house git push [commit] [--owner]';
 const ARGUMENTS = `the arguments are one JSON object in single quotes, like house search '{"query":"invoice"}'`;
 const CLOSED = "this conversation's House connection is closed; nothing to do from here";
 const REVOKED = 'this conversation no longer has House access; nothing to do from here';
+const UNCONNECTED = "this computer's own agent has no House connection; run kit login";
+const DISCONNECTED = "House no longer accepts this computer's own agent; run kit login";
 const socketPath = process.env.HOUSE_BRIDGE;
 function refused(path, status, text) {
     const refusal = refusalOf(text);
@@ -42,8 +45,21 @@ function bridged(path, body, headers = { 'content-type': 'application/json' }, t
         sent.end(body instanceof Buffer ? body : JSON.stringify(body));
     });
 }
+async function direct(message) {
+    const ownAgent = await readOwnAgent();
+    if (ownAgent === null)
+        throw new Error(UNCONNECTED);
+    setGlobalProxyFromEnv();
+    const answer = await callHouse(ownAgent.house, ownAgent.credential, message).catch(() => {
+        throw new Error(UNREACHABLE);
+    });
+    if (answer.status === 200)
+        return answer.text;
+    throw new Error(answer.status === 401 ? DISCONNECTED : (refusalOf(answer.text)?.text ?? `House answered ${answer.status}`));
+}
 async function mcp(method, params) {
-    const answer = JSON.parse(await bridged('/', { jsonrpc: '2.0', id: randomUUID(), method, params }));
+    const message = rpc(method, params);
+    const answer = JSON.parse(socketPath === undefined ? await direct(message) : await bridged('/', message));
     if (answer.error !== undefined)
         throw new Error(answer.error.message);
     return answer.result;
@@ -122,10 +138,10 @@ async function house([verb, argument]) {
         return `${tool.description}\n${JSON.stringify(tool.inputSchema)}`;
     }
     const args = argumentsOf(argument);
-    if (verb === 'upload_attachment') {
+    if (socketPath !== undefined && verb === 'upload_attachment') {
         return JSON.stringify({ attachment: await upload(args.path, args.room_ref, 'upload_attachment needs "path", a local file') });
     }
-    if (verb === 'append_record' && Array.isArray(args.attachments)) {
+    if (socketPath !== undefined && verb === 'append_record' && Array.isArray(args.attachments)) {
         const attachments = [];
         for (const path of args.attachments) {
             attachments.push(await upload(path, args.room_ref, 'each attachments entry is the path of a local file'));
@@ -139,15 +155,9 @@ async function house([verb, argument]) {
     return text;
 }
 const argv = process.argv.slice(2);
-if (argv[0] !== 'git' && socketPath === undefined) {
-    process.stderr.write('house: house runs inside an Agent conversation\n');
+(argv[0] === 'git' ? gitPush(argv.slice(1)) : house(argv)).then((text) => {
+    process.stdout.write(`${text}\n`);
+}, (error) => {
+    process.stderr.write(`house: ${error instanceof Error ? error.message : String(error)}\n`);
     process.exitCode = 1;
-}
-else {
-    (argv[0] === 'git' ? gitPush(argv.slice(1)) : house(argv)).then((text) => {
-        process.stdout.write(`${text}\n`);
-    }, (error) => {
-        process.stderr.write(`house: ${error instanceof Error ? error.message : String(error)}\n`);
-        process.exitCode = 1;
-    });
-}
+});

package/dist/login.js

@@ -4,7 +4,8 @@ import { hostname } from 'node:os';
 import { createInterface } from 'node:readline/promises';
 import { parseArgs } from 'node:util';
 import { post } from './api.js';
-import { readEnrolment, writeEnrolment } from './home.js';
+import { forgetOwnAgent, readEnrolment, readOwnAgent, writeEnrolment, writeOwnAgent } from './home.js';
+import { callHouse, rpc } from './mcp.js';
 const DEFAULT_HOUSE = 'https://agents.house';
 function listen() {
     return new Promise((resolve, reject) => {
@@ -48,6 +49,14 @@ function listen() {
         });
     });
 }
+async function accepted(house, credential) {
+    const checked = await callHouse(house, credential, rpc('tools/list', {}));
+    if (checked.status === 200)
+        return true;
+    if (checked.status === 401)
+        return false;
+    throw new Error(`House answered ${checked.status} when Kit checked this computer's own agent's connection: ${checked.text}`);
+}
 async function typed(question) {
     const reader = createInterface({ input: process.stdin, output: process.stdout });
     const closed = new Promise((_, reject) => {
@@ -73,17 +82,27 @@ export async function login(argv) {
     const house = values.house ?? enrolled?.house ?? DEFAULT_HOUSE;
     const replaces = process.env.HOUSE_KIT_REPLACES;
     const environment = replaces === undefined ? (values.environment ?? (enrolled?.house === house ? enrolled.environment : undefined)) : undefined;
+    const ownAgent = await readOwnAgent();
+    const held = ownAgent !== null && ownAgent.house === house && (await accepted(house, ownAgent.credential));
     const verifier = randomBytes(32).toString('base64url');
     const started = {
         ...(environment === undefined
             ? { act: 'new_environment', label: hostname(), ...(replaces === undefined ? {} : { replaces }) }
             : { act: 'existing_environment', environment_id: environment }),
         code_challenge: createHash('sha256').update(verifier).digest('base64url'),
+        ...(held ? {} : { headless: true }),
     };
     const exchange = async (code) => {
         const exchanged = await post(house, '/kit/token', { code, code_verifier: verifier });
         await writeEnrolment({ house, environment: exchanged.environment, credential: exchanged.credential });
         process.stdout.write(`Environment ${exchanged.environment} is connected to ${house}.\n`);
+        if (exchanged.headless_credential !== undefined) {
+            await writeOwnAgent({ house, user: exchanged.user, credential: exchanged.headless_credential });
+        }
+        else if (held && ownAgent.user !== exchanged.user) {
+            await forgetOwnAgent();
+            process.stdout.write("This computer's own agent was another User's; run kit login again to connect it to you.\n");
+        }
     };
     if (values.manual) {
         const { start_url } = await post(house, '/kit', {

package/dist/mcp.js

@@ -0,0 +1,38 @@
+import { randomUUID } from 'node:crypto';
+import { KIT_VERSION } from './clis.js';
+const MCP_PROTOCOL_VERSION = '2026-07-28';
+export const UNREACHABLE = 'House is unreachable; call again in a minute';
+export function rpc(method, params) {
+    return { jsonrpc: '2.0', id: randomUUID(), method, params };
+}
+export function mcpBody(message, operation) {
+    return 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 }),
+            },
+        },
+    });
+}
+export async function callHouse(origin, credential, message, operation = null, signal) {
+    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: mcpBody(message, operation),
+        signal,
+    });
+    return { status: answer.status, text: await answer.text() };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/kit",
-  "version": "0.2.1-alpha.16",
+  "version": "0.2.1-alpha.18",
   "description": "House Kit connects an Environment to agents.house.",
   "license": "MIT",
   "repository": {