@agentshouse/kit 0.2.1-c2c600f2d2b30 → 0.2.1-c2eef9f27f3ab

package/dist/api.js

@@ -1,6 +1,9 @@
-import { end, SIGN_IN_AGAIN } from './end.js';
+import { setTimeout as delay } from 'node:timers/promises';
+import { signInAgain } from './end.js';
 import { readEnrolment } from './home.js';
+import { retryable } from './refusals.js';
 import { relayed } from './relay.js';
+import { endUnserved, KIT_WIRE, KIT_WIRE_HEADER } from './wire.js';
 export class HouseRefusal extends Error {
     status;
     text;
@@ -10,21 +13,40 @@ export class HouseRefusal extends Error {
         this.text = text;
     }
 }
+export function finalRefusal(error) {
+    return error instanceof HouseRefusal && retryable(error.text) === false;
+}
 export function retryDelay(attempt) {
-    // Full jitter, doubling from one second to a 30-second cap, spreads the Kits one outage dropped and retries within half a minute of House's return.
+    // Full jitter, doubling from one second to a 30-second cap, spreads the Kit processes one outage dropped and retries within half a minute of House's return.
     return Math.random() * Math.min(30_000, 1000 * 2 ** attempt);
 }
+export async function retrying(sent, signal, pause = retryDelay) {
+    for (let attempt = 0;; attempt++) {
+        try {
+            return await sent();
+        }
+        catch (error) {
+            if (!(error instanceof HouseRefusal) || retryable(error.text) !== true)
+                throw error;
+        }
+        // A request House refused as retryable is sent again after the caller's pause, the jittered curve unless it names its own.
+        await delay(pause(attempt), undefined, { signal });
+    }
+}
 export async function post(house, path, body, credential, signal) {
     const answer = await fetch(relayed(new URL(path, house)), {
         method: 'POST',
         headers: {
             'content-type': 'application/json',
+            [KIT_WIRE_HEADER]: String(KIT_WIRE),
             ...(credential === undefined ? {} : { authorization: `Bearer ${credential}` }),
         },
         body: JSON.stringify(body),
         signal,
     });
     const text = await answer.text();
+    if (!answer.ok)
+        endUnserved(text);
     if (!answer.ok)
         throw new HouseRefusal(path, answer.status, text);
     return JSON.parse(text);
@@ -36,7 +58,7 @@ async function enrolledPost(path, body, signal) {
     }
     catch (error) {
         if (error instanceof HouseRefusal && error.status === 401)
-            end(SIGN_IN_AGAIN);
+            await signInAgain(credential);
         throw error;
     }
 }
@@ -48,7 +70,7 @@ export const house = {
                 return await enrolledPost(path, body);
             }
             catch (error) {
-                if (error instanceof HouseRefusal && error.status < 500)
+                if (finalRefusal(error))
                     throw error;
                 process.stderr.write(`kit: ${path} did not reach House: ${error.message}\n`);
                 // A delivery House did not take is sent again on the jittered curve for as long as it is still current.

package/dist/app-git.js

@@ -0,0 +1,48 @@
+import { run } from './git.js';
+import { kitHome, readOwnAgent } from './home.js';
+const HELPER = '!kit git-credential';
+function section(house) {
+    return `credential.${new URL('/app/', house).href}`;
+}
+async function configured(args) {
+    try {
+        return await run(kitHome(), ['config', '--global', ...args]);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+export async function placeAppGit(ownAgent) {
+    if (ownAgent === null)
+        return;
+    await configured(['--remove-section', section(ownAgent.house)]);
+    for (const value of ['', HELPER]) {
+        const ran = await configured(['--add', `${section(ownAgent.house)}.helper`, value]);
+        if (ran === null)
+            return;
+        if (ran.status !== 0)
+            throw new Error(`git config failed: ${ran.stderr.trim()}`);
+    }
+}
+export async function answerGitCredential(operation) {
+    let asked = '';
+    for await (const chunk of process.stdin)
+        asked += String(chunk);
+    if (operation !== 'get')
+        return;
+    const attributes = new Map(asked
+        .split('\n')
+        .filter((line) => line.includes('='))
+        .map((line) => [line.slice(0, line.indexOf('=')), line.slice(line.indexOf('=') + 1)]));
+    const ownAgent = await readOwnAgent();
+    if (ownAgent === null) {
+        process.stderr.write(`kit: Kit home ${kitHome()} is not signed in; run kit login\n`);
+        return;
+    }
+    const house = new URL(ownAgent.house);
+    if (attributes.get('protocol') !== house.protocol.slice(0, -1) || attributes.get('host') !== house.host)
+        return;
+    process.stdout.write(`username=house\npassword=${ownAgent.credential}\n`);
+}

package/dist/authority-main.js

@@ -1,10 +1,10 @@
-import { setGlobalProxyFromEnv } from 'node:http';
 import { HouseRefusal, post } from './api.js';
 import { readEnrolment } from './home.js';
+import { proxyUnlessRelayed } from './relay.js';
 function unanswered(error) {
     return error instanceof HouseRefusal ? error.status >= 500 : error instanceof TypeError && error.message === 'fetch failed';
 }
-setGlobalProxyFromEnv();
+proxyUnlessRelayed();
 try {
     const { house, credential } = (await readEnrolment());
     try {

package/dist/bridge.js

@@ -1,21 +1,19 @@
 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';
 import { parse } from 'yaml';
-import { HouseRefusal, retryDelay } from './api.js';
+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, uuidOf } from './operation.js';
-import { refusalOf } from './refusals.js';
+import { operationId } from './operation.js';
+import { refusalOf, retryable } from './refusals.js';
 import { relayed } from './relay.js';
-const MCP_REQUEST_BYTES = 4 * 1024 * 1024;
-const ATTACHMENTS = '/kit/attachments/upload';
+const MCP_REQUEST_BYTES = 4_000_000;
 export async function received(request) {
     let text = '';
     request.setEncoding('utf8');
@@ -40,8 +38,6 @@ function refusalIn(text, status) {
     return refusalOf(text) ?? { code: '', text: text === '' ? `House refused it with ${status}` : text, conflicts: [] };
 }
 function answered(forwarded) {
-    if (forwarded.status >= 500)
-        throw new HouseRefusal('/', forwarded.status, forwarded.text);
     if (forwarded.status !== 200)
         return { refused: refusalIn(forwarded.text, forwarded.status) };
     const answer = JSON.parse(forwarded.text);
@@ -65,16 +61,11 @@ function pendingSeconds(forwarded) {
 function resendAfter(forwarded, attempt) {
     if (forwarded === null)
         return retryDelay(attempt);
-    if (forwarded.status >= 500)
-        return refusalOf(forwarded.text) === null ? retryDelay(attempt) : null;
+    if (forwarded.status !== 200)
+        return retryable(forwarded.text) === false ? null : retryDelay(attempt);
     const seconds = pendingSeconds(forwarded);
     return seconds === null ? null : seconds * 1000;
 }
-function versioned(conversationId, text) {
-    const file = JSON.parse(text);
-    const identity = JSON.stringify([conversationId, file.room_ref ?? null, file.name, file.sha256]);
-    return JSON.stringify({ ...file, version: uuidOf(createHash('sha256').update(identity).digest(), 8) });
-}
 function editAnswer(forwarded) {
     const answer = answered(forwarded);
     if ('refused' in answer)
@@ -90,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) => {
@@ -105,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 });
         }
     };
@@ -120,46 +111,32 @@ export async function openBridge(house, copies, conversationId, signal) {
         if ('refused' in prepared)
             return prepared;
         const { transfer } = parse(prepared.text);
-        const posted = await fetch(relayed(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 HouseRefusal('/', posted.status, text);
-        if (!posted.ok)
-            return { refused: refusalIn(text, posted.status) };
-        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)));
+        let text;
         try {
-            return (await mutations).has(tool);
+            text = await retrying(async () => {
+                const posted = await fetch(relayed(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 answer = await posted.text();
+                if (!posted.ok)
+                    throw new HouseRefusal('/', posted.status, answer);
+                return answer;
+            }, closed.signal);
         }
         catch (error) {
-            mutations = null;
-            throw error;
+            if (!finalRefusal(error))
+                throw error;
+            return { refused: refusalIn(error.text, error.status) };
         }
+        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;
-            return send(message, tool !== null && (await writes(tool)) ? operationId() : null);
-        }
-        const answer = await fetch(relayed(new URL(path, origin)), {
-            method: 'POST',
-            headers: { 'content-type': 'application/json', authorization: `Bearer ${credential}` },
-            body: versioned(conversationId, text),
-            signal: closed.signal,
-        });
-        return { status: answer.status, text: await answer.text() };
+    const forward = (text) => {
+        const message = JSON.parse(text);
+        return send(message, message.method === 'tools/call' ? operationId() : null);
     };
     const caller = {
         key: `conversation:${conversationId}`,
@@ -181,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 === '/' || path === ATTACHMENTS ? forward(path, text) : { status: 404, 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 ?? '';
@@ -205,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);
@@ -232,7 +210,7 @@ export async function openBridge(house, copies, conversationId, signal) {
             GIT_CONFIG_VALUE_0: app,
         },
         tool: async (name, args) => {
-            const forwarded = await forward('/', JSON.stringify(call(name, 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/building.js

@@ -0,0 +1,46 @@
+import { createHash } from 'node:crypto';
+import { createWriteStream } from 'node:fs';
+import { rm } from 'node:fs/promises';
+import { Transform } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { readEnrolment } from './home.js';
+import { relayed } from './relay.js';
+const MANIFEST = 'bootstrap.json';
+async function served(name, signal) {
+    const enrolment = await readEnrolment();
+    if (enrolment === null)
+        throw new Error('this Kit is connected to no House');
+    const answer = await fetch(relayed(new URL(`/kit-installer/${encodeURIComponent(name)}`, enrolment.house)), { signal });
+    if (answer.status === 200 && answer.body !== null)
+        return answer;
+    await answer.body?.cancel();
+    throw new Error(`House answered ${answer.status} for ${name}`);
+}
+export async function servedDigest(name, signal) {
+    const manifest = (await (await served(MANIFEST, signal)).json());
+    const sha256 = manifest.files?.[name]?.sha256;
+    return typeof sha256 === 'string' ? sha256 : null;
+}
+export async function downloadServed(name, sha256, destination, signal, most = Infinity) {
+    const answer = await served(name, signal);
+    const digest = createHash('sha256');
+    let bytes = 0;
+    const hashed = new Transform({
+        transform(chunk, _encoding, done) {
+            bytes += chunk.length;
+            if (bytes > most)
+                return done(new Error(`${name} is larger than its pinned ${most} bytes`));
+            digest.update(chunk);
+            done(null, chunk);
+        },
+    });
+    try {
+        await pipeline(answer.body, hashed, createWriteStream(destination), { signal });
+        if (digest.digest('hex') !== sha256)
+            throw new Error(`${name} does not match its sha256`);
+    }
+    catch (error) {
+        await rm(destination, { force: true });
+        throw error;
+    }
+}

package/dist/calls.js

@@ -0,0 +1,63 @@
+import { existsSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { kitHome } from './home.js';
+function logged(error) {
+    process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
+}
+export class Calls {
+    house;
+    changed;
+    carried = new Map();
+    path = join(kitHome(), 'call-results.json');
+    results;
+    returned = new Set();
+    open = 0;
+    constructor(house, changed) {
+        this.house = house;
+        this.changed = changed;
+        this.results = new Map(existsSync(this.path) ? Object.entries(JSON.parse(readFileSync(this.path, 'utf8'))) : []);
+    }
+    keepResult(callId, result) {
+        if (this.returned.has(callId))
+            return;
+        this.results.set(callId, result);
+        this.save();
+    }
+    idle() {
+        return this.open === 0;
+    }
+    carry(callId, work) {
+        const known = this.carried.get(callId);
+        const result = this.results.get(callId);
+        const carried = known ?? (result === undefined ? work() : Promise.resolve({ result }));
+        if (known === undefined) {
+            this.carried.set(callId, carried);
+            carried.catch(() => this.carried.delete(callId));
+        }
+        this.open++;
+        this.changed();
+        return carried
+            .then(async ({ result, returned }) => {
+            try {
+                await this.house.deliver(`/kit/inputs/${callId}/ack`, result);
+            }
+            finally {
+                this.returned.add(callId);
+                if (this.results.delete(callId))
+                    this.save();
+            }
+            if (known === undefined)
+                await returned?.();
+        })
+            .catch(logged)
+            .finally(() => {
+            this.open--;
+            this.changed();
+        });
+    }
+    save() {
+        const temporary = `${this.path}.${process.pid}`;
+        writeFileSync(temporary, JSON.stringify(Object.fromEntries(this.results)), { mode: 0o600 });
+        renameSync(temporary, this.path);
+    }
+}

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-main.js

@@ -1,8 +1,8 @@
-import { setGlobalProxyFromEnv } from 'node:http';
 import { post } from './api.js';
 import { CLIS, below, locate, versionOf } from './clis.js';
 import { readEnrolment } from './home.js';
-setGlobalProxyFromEnv();
+import { proxyUnlessRelayed } from './relay.js';
+proxyUnlessRelayed();
 try {
     const { house, credential } = (await readEnrolment());
     const { agents } = await post(house, '/kit/agents/desired', {}, credential);