@agentshouse/kit 0.2.1-alpha.9 → 0.2.1-c073f4e9391b2

package/dist/app-git.js

@@ -0,0 +1,64 @@
+import { extname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { run } from './git.js';
+import { kitHome, readOwnAgent } from './home.js';
+import { quoted } from './shell.js';
+function section(house) {
+    return `credential.${new URL('/app/', house).href}`;
+}
+function helper() {
+    const main = fileURLToPath(new URL(`./kit-main${extname(fileURLToPath(import.meta.url))}`, import.meta.url));
+    return `!HOUSE_KIT_HOME=${quoted(resolve(kitHome()))} ${quoted(process.execPath)} ${quoted(main)} git-credential`;
+}
+async function configured(args) {
+    try {
+        return await run(kitHome(), ['config', '--global', ...args]);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+async function forget(house) {
+    await configured(['--remove-section', section(house)]);
+}
+async function register(house) {
+    await forget(house);
+    for (const value of ['', helper()]) {
+        const ran = await configured(['--add', `${section(house)}.helper`, value]);
+        if (ran === null)
+            return;
+        if (ran.status !== 0)
+            throw new Error(`git config failed: ${ran.stderr.trim()}`);
+    }
+}
+export async function placeAppGit(before, after) {
+    if (before !== null && before.house !== after?.house)
+        await forget(before.house);
+    if (after !== null)
+        await register(after.house);
+}
+export async function forgetAppGit() {
+    const ownAgent = await readOwnAgent();
+    if (ownAgent !== null)
+        await forget(ownAgent.house);
+}
+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)
+        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/bootstrap.json

@@ -1,27 +1,23 @@
 {
-  "schemaVersion": 1,
-  "version": "0.2.1-alpha.9",
+  "schemaVersion": 2,
+  "version": "0.2.1-c073f4e9391b2",
   "hosts": {
+    "macos": {
+      "asset": {
+        "name": "connect-linux.sh",
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-c073f4e9391b2/connect-linux.sh"
+      }
+    },
     "linux": {
-      "command": "bash <(curl -fsSL https://github.com/agentshouse/kit/releases/download/v0.2.1-alpha.9/connect-linux.sh)",
       "asset": {
         "name": "connect-linux.sh",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-alpha.9/connect-linux.sh"
-      },
-      "workspace": {
-        "argument": "--workspace",
-        "quoting": "posix"
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-c073f4e9391b2/connect-linux.sh"
       }
     },
     "windows": {
-      "command": "& ([scriptblock]::Create((irm https://github.com/agentshouse/kit/releases/download/v0.2.1-alpha.9/connect-windows.ps1)))",
       "asset": {
         "name": "connect-windows.ps1",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-alpha.9/connect-windows.ps1"
-      },
-      "workspace": {
-        "argument": "--workspace",
-        "quoting": "powershell"
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-c073f4e9391b2/connect-windows.ps1"
       }
     }
   }

package/dist/bridge.js

@@ -1,17 +1,20 @@
 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, join } from 'node:path';
+import { delimiter, dirname, join } from 'node:path';
 import { parse } from 'yaml';
-import { KIT_VERSION } from './clis.js';
-import { changedPaths, refusalCode, } from './copies.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 { callHouse, mcpBody, rpc, UNREACHABLE } from './mcp.js';
 import { operationId } from './operation.js';
-const MCP_PROTOCOL_VERSION = '2026-07-28';
+import { refusalOf, retryable } from './refusals.js';
+import { relayed } from './relay.js';
 const MCP_REQUEST_BYTES = 4 * 1024 * 1024;
-const FORWARDED = new Set(['/', '/kit/attachments/upload']);
 export async function received(request) {
     let text = '';
     request.setEncoding('utf8');
@@ -19,7 +22,8 @@ export async function received(request) {
         text += chunk;
     return text;
 }
-function relay(request, response, target, authorization) {
+function relay(request, response, house, authorization) {
+    const target = relayed(house);
     const send = target.protocol === 'https:' ? httpsRequest : httpRequest;
     const forwarded = send(target, {
         method: request.method,
@@ -31,16 +35,37 @@ function relay(request, response, target, authorization) {
     forwarded.on('error', () => response.destroy());
     request.pipe(forwarded);
 }
+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 Error(`House answered ${forwarded.status}`);
     if (forwarded.status !== 200)
-        return { refused: { code: refusalCode(forwarded.text), text: forwarded.text } };
+        return { refused: refusalIn(forwarded.text, forwarded.status) };
     const answer = JSON.parse(forwarded.text);
     if (answer.error !== undefined)
-        return { refused: { code: refusalCode(answer.error.message), text: answer.error.message } };
+        return { refused: refusalIn(answer.error.message, forwarded.status) };
     const text = answer.result.content.map((content) => content.text).join('\n');
-    return answer.result.isError === true ? { refused: { code: refusalCode(text), text } } : { text };
+    return answer.result.isError === true ? { refused: refusalIn(text, forwarded.status) } : { text };
+}
+function pendingSeconds(forwarded) {
+    if (forwarded.status !== 200)
+        return null;
+    const { result } = JSON.parse(forwarded.text);
+    if (result === undefined || result.isError === true)
+        return null;
+    const text = result.content.map((content) => content.text).join('\n');
+    if (!text.startsWith('{"pending":'))
+        return null;
+    const seconds = JSON.parse(text).pending.retry_after;
+    return typeof seconds === 'number' ? seconds : null;
+}
+function resendAfter(forwarded, attempt) {
+    if (forwarded === null)
+        return retryDelay(attempt);
+    if (forwarded.status !== 200)
+        return retryable(forwarded.text) === false ? null : retryDelay(attempt);
+    const seconds = pendingSeconds(forwarded);
+    return seconds === null ? null : seconds * 1000;
 }
 function editAnswer(forwarded) {
     const answer = answered(forwarded);
@@ -50,44 +75,33 @@ function editAnswer(forwarded) {
     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 },
+            { path: result.path, revision: result.revision ?? null },
         ]),
     };
 }
 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 = (message, operation) => callHouse(origin, credential, message, operation, closed.signal);
     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() };
+        if (operation === null)
+            return sent(message, null);
+        for (let attempt = 0;; attempt++) {
+            const forwarded = await sent(message, operation).catch((error) => {
+                if (closed.signal.aborted)
+                    throw error;
+                return null;
+            });
+            const after = resendAfter(forwarded, attempt);
+            if (after === null)
+                return forwarded;
+            // 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 });
+        }
     };
-    const call = (name, args) => ({ jsonrpc: '2.0', id: 1, 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');
@@ -98,42 +112,39 @@ export async function openBridge(house, copies, conversationId, signal) {
         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 } };
+        let text;
+        try {
+            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) {
+            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;
-            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 forward = (text) => {
+        const message = JSON.parse(text);
+        return send(message, message.method === 'tools/call' ? operationId() : null);
     };
     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) {
+            if (upload === undefined && Buffer.byteLength(mcpBody(inline, operation)) > MCP_REQUEST_BYTES) {
                 const prepared = await staged(operation, changes);
                 if ('refused' in prepared)
                     return prepared;
@@ -148,11 +159,13 @@ 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 FORWARDED.has(path) ? 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 });
@@ -168,7 +181,12 @@ export async function openBridge(house, copies, conversationId, signal) {
             response.writeHead(answered.status, { 'content-type': 'application/json' }).end(answered.text);
         }
         catch (error) {
-            response.writeHead(502).end(error instanceof Error ? error.message : String(error));
+            if (error instanceof HouseRefusal) {
+                response.writeHead(error.status, { 'content-type': 'application/json' }).end(error.text);
+                return;
+            }
+            const verb = request.url === '/git/push' || request.url === '/git/fetch';
+            response.writeHead(502).end(verb && error instanceof Error ? error.message : UNREACHABLE);
         }
     });
     bridge.listen(socketPath);
@@ -189,13 +207,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: 1, 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/chatgpt.js

@@ -0,0 +1,25 @@
+import { parseArgs } from 'node:util';
+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 house = values.house ?? (await readOwnAgent())?.house ?? DEFAULT_HOUSE;
+    if (!(await accepted(house, values.key)))
+        throw new Error(`${house} does not accept this key; pass one from ${KEY_SOURCE}`);
+    await writeOwnAgent({ house, credential: values.key });
+    process.stdout.write(`house now calls ${house} as you, with the key kept in ${kitHome()}.\n`);
+}

package/dist/clis-main.js

@@ -0,0 +1,23 @@
+import { setGlobalProxyFromEnv } from 'node:http';
+import { post } from './api.js';
+import { CLIS, below, locate, versionOf } from './clis.js';
+import { readEnrolment } from './home.js';
+setGlobalProxyFromEnv();
+try {
+    const { house, credential } = (await readEnrolment());
+    const { agents } = await post(house, '/kit/agents/desired', {}, credential);
+    for (const kind of agents) {
+        const cli = await locate(kind);
+        if (cli === null)
+            continue;
+        const release = await versionOf(cli);
+        if (release === null)
+            continue;
+        const { bin, minimum } = CLIS[kind];
+        process.stdout.write(`${[bin, cli, release, minimum, below(release, minimum) ? 'old' : 'current'].join('\t')}\n`);
+    }
+}
+catch (error) {
+    process.stderr.write(`kit: ${error.message}\n`);
+    process.exitCode = 1;
+}