@agentshouse/kit 0.2.1-cbabe8ad337ff → 0.2.1-cbdf76b9a90a3

package/dist/bridge.js

@@ -1,7 +1,6 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { once } from 'node:events';
 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, dirname, join } from 'node:path';
@@ -9,7 +8,7 @@ import { parse } from 'yaml';
 import { finalRefusal, HouseRefusal, retryDelay, retrying } from './api.js';
 import { loginPath } from './clis.js';
 import { changedPaths, } from './copies.js';
-import { kitHome, readEnrolment } from './home.js';
+import { kitHome, readEnrolment, socketDirectory } from './home.js';
 import { callHouse, mcpBody, rpc, UNREACHABLE } from './mcp.js';
 import { operationId } from './operation.js';
 import { refusalOf, retryable } from './refusals.js';
@@ -82,7 +81,7 @@ 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 { credential } = await retrying(() => house.post(`/kit/conversations/${conversationId}/credential`, {}, signal), signal);
     const closed = new AbortController();
     const sent = (message, operation) => callHouse(origin, credential, message, operation, closed.signal);
     const send = async (message, operation) => {
@@ -97,7 +96,7 @@ export async function openBridge(house, copies, conversationId, signal) {
             const after = resendAfter(forwarded, attempt);
             if (after === null)
                 return forwarded;
-            // A write House did not settle is sent again on the jittered curve, or after the wait House names for a pending one.
+            // A Tool call House did not settle is sent again on the jittered curve, or after the wait House names for a pending one.
             await delay(after, undefined, { signal: closed.signal });
         }
     };
@@ -135,23 +134,9 @@ export async function openBridge(house, copies, conversationId, signal) {
         const held = JSON.parse(text).transfer;
         return { url: held.url, operation: held.operation, bytes: bytes.length, sha256 };
     };
-    let mutations = null;
-    const writes = async (tool) => {
-        mutations ??= house
-            .post('/kit/tools/mutations', {}, closed.signal)
-            .then(({ tools }) => new Set(tools.filter((listed) => listed.writes).map((listed) => listed.name)));
-        try {
-            return (await mutations).has(tool);
-        }
-        catch (error) {
-            mutations = null;
-            throw error;
-        }
-    };
-    const forward = async (text) => {
+    const forward = (text) => {
         const message = JSON.parse(text);
-        const tool = message.method === 'tools/call' ? String(message.params.name) : null;
-        return send(message, tool !== null && (await writes(tool)) ? operationId() : null);
+        return send(message, message.method === 'tools/call' ? operationId() : null);
     };
     const caller = {
         key: `conversation:${conversationId}`,
@@ -173,15 +158,15 @@ export async function openBridge(house, copies, conversationId, signal) {
             const { cwd, commit } = JSON.parse(text);
             return { status: 200, text: JSON.stringify(await copies.push(cwd, commit, caller)) };
         }
+        if (path === '/git/fetch')
+            return { status: 200, text: JSON.stringify(await copies.fetch()) };
         if (path === '/git/observed') {
             await copies.observed(JSON.parse(text));
             return { status: 200, text: '{}' };
         }
         return path === '/' ? forward(text) : { status: 404, text: '' };
     };
-    const sockets = join(kitHome(), 'bridges');
-    await mkdir(sockets, { recursive: true, mode: 0o700 });
-    const socketPath = join(sockets, `${randomUUID()}.sock`);
+    const socketPath = join(socketDirectory(), `${randomUUID()}.sock`);
     const bridge = createServer(async (request, response) => {
         try {
             const path = request.url ?? '';
@@ -197,7 +182,8 @@ export async function openBridge(house, copies, conversationId, signal) {
                 response.writeHead(error.status, { 'content-type': 'application/json' }).end(error.text);
                 return;
             }
-            response.writeHead(502).end(request.url === '/git/push' && error instanceof Error ? error.message : UNREACHABLE);
+            const verb = request.url === '/git/push' || request.url === '/git/fetch';
+            response.writeHead(502).end(verb && error instanceof Error ? error.message : UNREACHABLE);
         }
     });
     bridge.listen(socketPath);

package/dist/chatgpt.js

@@ -0,0 +1,32 @@
+import { parseArgs } from 'node:util';
+import { placeAppGit } from './app-git.js';
+import { kitHome, readOwnAgent, writeOwnAgent } from './home.js';
+import { accepted, DEFAULT_HOUSE } from './login.js';
+const KEY_SOURCE = 'New key for a script on Connections';
+const USAGE = `usage: kit chatgpt --key <key> [--house <origin>]
+  --key <key>       a key from ${KEY_SOURCE}
+  --house <origin>  the House of the key, ${DEFAULT_HOUSE} unless one is stored
+`;
+export async function chatgpt(argv) {
+    const { values } = parseArgs({
+        args: argv,
+        options: { key: { type: 'string' }, house: { type: 'string' }, help: { type: 'boolean', default: false } },
+    });
+    if (values.help) {
+        process.stdout.write(USAGE);
+        return;
+    }
+    if (values.key === undefined)
+        throw new Error(`pass --key with a key from ${KEY_SOURCE}`);
+    const before = await readOwnAgent();
+    const house = values.house ?? before?.house ?? DEFAULT_HOUSE;
+    if (!(await accepted(house, values.key)))
+        throw new Error(`${house} does not accept this key; pass one from ${KEY_SOURCE}`);
+    const relay = process.env.HOUSE_KIT_RELAY || undefined;
+    await writeOwnAgent({ house, ...(relay === undefined ? {} : { relay }), credential: values.key });
+    await placeAppGit(await readOwnAgent()).catch((error) => process.stderr.write(`kit: ${error.message}\n`));
+    if (before !== null && before.credential !== values.key) {
+        process.stdout.write('This replaced the key this Kit home held; give each session its own HOUSE_KIT_HOME to keep its own key.\n');
+    }
+    process.stdout.write(`house now calls ${house} as you, with the key kept in ${kitHome()}.\n`);
+}

package/dist/clis.js

@@ -1,9 +1,14 @@
 import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
 import { constants, readFileSync } from 'node:fs';
-import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { access, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
 import { homedir, userInfo } from 'node:os';
-import { delimiter, isAbsolute, join } from 'node:path';
+import { delimiter, dirname, isAbsolute, join } from 'node:path';
 import { kitHome } from './home.js';
+const HOUSE_EXECUTABLES = /^host_executable\(name = "house", paths = (\[.*\])\)$/m;
+function houseRule(houses) {
+    return `prefix_rule(pattern = ["house"], decision = "allow")\nhost_executable(name = "house", paths = ${JSON.stringify(houses)})\n`;
+}
 const RAW_SUBTYPES = [
     'background_tasks_changed',
     'task_started',
@@ -22,17 +27,42 @@ async function executable(path) {
         return false;
     }
 }
-async function allowHouseInCodex(path) {
+async function listedHouses(file) {
+    let text;
+    try {
+        text = await readFile(file, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+    try {
+        const listed = JSON.parse(HOUSE_EXECUTABLES.exec(text)?.[1] ?? '[]');
+        return Array.isArray(listed) ? listed.filter((house) => typeof house === 'string') : [];
+    }
+    catch {
+        return [];
+    }
+}
+export async function allowHouseInCodex(path) {
     const candidates = [...new Set(path.split(delimiter).filter((directory) => isAbsolute(directory)))].map((directory) => join(directory, 'house'));
-    const houses = [];
-    for (const candidate of candidates)
-        if (await executable(candidate))
-            houses.push(candidate);
     const rules = join(process.env.CODEX_HOME || join(homedir(), '.codex'), 'rules');
+    const file = join(rules, 'house.rules');
+    const houses = [];
+    for (const house of [...(await listedHouses(file)), ...candidates]) {
+        if (!houses.includes(house) && (await executable(house)))
+            houses.push(house);
+    }
     await mkdir(rules, { recursive: true });
-    await writeFile(join(rules, 'house.rules'), `prefix_rule(pattern = ["house"], decision = "allow")\nhost_executable(name = "house", paths = ${JSON.stringify(houses)})\n`);
+    const temporary = `${file}.${randomUUID()}`;
+    await writeFile(temporary, houseRule(houses));
+    await rename(temporary, file);
 }
 async function nothing() { }
+function answered(error) {
+    return typeof error === 'object' && error !== null ? error : {};
+}
 function bridgeInClaudeSandbox(bridge) {
     return process.platform === 'darwin' ? { allowUnixSockets: [bridge] } : { allowAllUnixSockets: true };
 }
@@ -50,6 +80,10 @@ export const CLIS = {
         args: [],
         fullAccess: 'agent-full-access',
         sessionMeta: () => ({}),
+        unknownSession: (error) => {
+            const { code, data } = answered(error);
+            return code === -32603 && typeof data?.details === 'string' && data.details.startsWith('no rollout found');
+        },
         renames: true,
         allowHouse: allowHouseInCodex,
         signedIn: { command: ['login', 'status'] },
@@ -79,6 +113,7 @@ export const CLIS = {
                 emitRawSDKMessages: RAW_SUBTYPES.map((subtype) => ({ type: 'system', subtype })),
             },
         }),
+        unknownSession: (error) => answered(error).code === -32002,
         renames: false,
         allowHouse: nothing,
         signedIn: { command: ['auth', 'status'] },
@@ -93,6 +128,7 @@ export const CLIS = {
         args: ['--sandbox', 'off', 'agent', '--always-approve', '--no-leader', 'stdio'],
         fullAccess: null,
         sessionMeta: () => ({}),
+        unknownSession: (error) => answered(error).data?.code === 'FS_NOT_FOUND',
         renames: false,
         allowHouse: nothing,
         signedIn: { initializeMeta: 'defaultAuthMethodId' },
@@ -173,7 +209,7 @@ export async function installAdapter(kind, signal) {
     const release = KIT_PACKAGE.peerDependencies[adapter.package];
     if ((await installedAdapter(kind)) === release)
         return null;
-    const ran = await run('npm', ['install', '--prefix', prefix(kind), '--no-save', '--no-audit', '--no-fund', '--omit=optional', `${adapter.package}@${release}`], INSTALL_MS, true, signal);
+    const ran = await run('npm', ['install', '--prefix', prefix(kind), '--cache', join(kitHome(), 'npm-cache'), '--no-save', '--no-audit', '--no-fund', '--omit=optional', `${adapter.package}@${release}`], INSTALL_MS, true, signal);
     return ran.status === 0 ? null : failureOf(ran, 'npm');
 }
 export async function installCli(kind, signal) {
@@ -198,6 +234,12 @@ export async function loginPath() {
     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 writeCodexRule() {
+    const shell = await loginPath().catch(() => '');
+    await allowHouseInCodex([dirname(process.execPath), process.env.PATH ?? '', shell].join(delimiter)).catch((error) => {
+        throw new Error(`Codex's rule for house could not be written: ${error.message}`);
+    });
+}
 export async function versionOf(path, signal) {
     return VERSION.exec((await run(path, ['--version'], READ_MS, false, signal)).stdout)?.[0] ?? null;
 }