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

package/dist/house-main.js

@@ -1,13 +1,31 @@
 #!/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_HELP = 'Submit a Room commit to House; default HEAD. Use --owner only outside an Agent conversation. Native git push is not a House remote.';
-const GIT_USAGE = `usage: house git push [commit] [--owner]\n${GIT_HELP}`;
+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);
+    if (refusal !== null)
+        return refusal.text;
+    if (status === 401)
+        return REVOKED;
+    if (URL.canParse(path))
+        return `the upload answered ${status}; upload the file again`;
+    if (status === 502 && /^[A-Za-z]/.test(text))
+        return text;
+    return `${path} answered ${status}`;
+}
 function bridged(path, body, headers = { 'content-type': 'application/json' }, to = socketPath) {
     return new Promise((resolve, reject) => {
         const sent = request({ socketPath: to, path, method: 'POST', headers }, (answer) => {
@@ -20,15 +38,28 @@ function bridged(path, body, headers = { 'content-type': 'application/json' }, t
                 if (answer.statusCode === 200)
                     resolve(text);
                 else
-                    reject(new Error(`${path} answered ${answer.statusCode}: ${text}`));
+                    reject(new Error(refused(path, answer.statusCode, text)));
             });
         });
-        sent.on('error', reject);
+        sent.on('error', () => reject(new Error(CLOSED)));
         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: 1, 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;
@@ -36,29 +67,45 @@ async function mcp(method, params) {
 async function tools() {
     return (await mcp('tools/list', {})).tools;
 }
-async function upload(path, roomRef) {
-    const bytes = await readFile(path);
+async function localFile(path) {
+    try {
+        return await readFile(path);
+    }
+    catch (error) {
+        throw new Error(error.code === 'EISDIR'
+            ? `${path} is a folder; upload one file at a time`
+            : `${path} is not a readable file`);
+    }
+}
+async function upload(path, roomRef, missing) {
+    if (typeof path !== 'string' || path === '')
+        throw new Error(missing);
+    const bytes = await localFile(path);
     const declared = JSON.parse(await bridged('/kit/attachments/upload', {
         ...(roomRef === undefined ? {} : { room_ref: roomRef }),
-        version: randomUUID(),
         name: basename(path),
         bytes: bytes.length,
         sha256: createHash('sha256').update(bytes).digest('hex'),
     }));
-    return bridged(declared.upload.url, bytes, {
+    if (declared.upload === undefined)
+        return declared.attachment;
+    const saved = JSON.parse(await bridged(declared.upload.url, bytes, {
         'content-type': 'application/octet-stream',
         'x-house-byte-operation': declared.upload.operation,
-    });
+    }));
+    if (saved.upload_failure !== undefined)
+        throw new Error(`${path} was not saved: ${saved.upload_failure}; call again later`);
+    return saved.attachment;
 }
 async function gitPush(args) {
     if (args.includes('--help'))
         return GIT_USAGE;
     if (args[0] !== 'push')
-        throw new Error(GIT_USAGE);
+        throw new Error('only house git push [commit] exists; use plain git for the rest');
     const owner = args.includes('--owner');
     const commit = args.slice(1).find((arg) => arg !== '--owner') ?? 'HEAD';
     if (owner && socketPath !== undefined)
-        throw new Error('house git push --owner runs outside an Agent conversation');
+        throw new Error('--owner is not for Agent conversations; run house git push without it');
     if (!owner && socketPath === undefined)
         throw new Error('outside an Agent conversation, house git push needs --owner');
     const pushed = JSON.parse(await bridged('/git/push', { cwd: process.cwd(), commit }, undefined, owner ? join(kitHome(), 'owner.sock') : socketPath));
@@ -66,42 +113,51 @@ async function gitPush(args) {
         throw new Error(pushed.text);
     return pushed.text;
 }
+function argumentsOf(argument) {
+    if (argument === undefined)
+        return {};
+    let parsed;
+    try {
+        parsed = JSON.parse(argument);
+    }
+    catch {
+        throw new Error(ARGUMENTS);
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+        throw new Error(ARGUMENTS);
+    return parsed;
+}
 async function house([verb, argument]) {
     if (verb === undefined || verb === '--help') {
-        return [USAGE, `git push [commit]: ${GIT_HELP}`, ...(await tools()).map((tool) => `${tool.name}: ${tool.description}`)].join('\n');
+        return [USAGE, 'git push [commit]', ...(await tools()).map((tool) => `${tool.name}: ${tool.description}`)].join('\n');
     }
     if (argument === '--help') {
         const tool = (await tools()).find((listed) => listed.name === verb);
         if (tool === undefined)
-            throw new Error(`House has no tool ${verb}`);
-        return `${tool.description}\n${JSON.stringify(tool.inputSchema, null, 2)}`;
+            throw new Error(`${verb} is no Tool; house find_command '{"query":"${verb}"}' finds Commands`);
+        return `${tool.description}\n${JSON.stringify(tool.inputSchema)}`;
+    }
+    const args = argumentsOf(argument);
+    if (socketPath !== undefined && verb === 'upload_attachment') {
+        return JSON.stringify({ attachment: await upload(args.path, args.room_ref, 'upload_attachment needs "path", a local file') });
     }
-    const args = (argument === undefined ? {} : JSON.parse(argument));
-    if (verb === 'upload_attachment')
-        return upload(String(args.path), args.room_ref);
-    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(JSON.parse(await upload(String(path), args.room_ref)).attachment);
+            attachments.push(await upload(path, args.room_ref, 'each attachments entry is the path of a local file'));
         }
         args.attachments = attachments;
     }
     const result = await mcp('tools/call', { name: verb, arguments: args });
     const text = result.content.map((content) => content.text).join('\n');
     if (result.isError === true)
-        throw new Error(text);
+        throw new Error(text.replace(/\n+$/, ''));
     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/instructions.js

@@ -1,33 +1,34 @@
-import { readEnrolment } from './home.js';
 import { HOW_WE_WORK } from './skills.js';
 const HOUSE_LINE = 'Work with House through the `house` CLI: run `house --help`.';
-const FILE_LINE = 'To give the User a file, upload it with `house upload_attachment` and link it in your answer.';
-const COPIES_LINE = 'These House paths are Git working copies here; commit in one and run `house git push` to send the commit to House:';
+const FILE_LINE = 'To give the User a file or a page, upload it with `house upload_attachment` and link it; never start a server.';
+const READ_LINE = 'Before working in a Room, read `/private/rooms/<handle>/AGENTS.md`.';
+const COPIES_LINE = 'House Local copies; commit, then `house git push`:';
 const UNREADABLE = /^(?:\S+: )?(?:path_not_found|room_not_found|operation_denied)\b/;
+const FAILED = /^exit: [1-9]\d*$/;
 const CUT = /^stderr: shell: output_cut (\d+) of \d+ bytes; continue with: (.+)$/;
+function cutOf(lines) {
+    const cut = CUT.exec(lines[0] ?? '');
+    return cut !== null && Buffer.byteLength(lines.slice(1).join('\n')) === Number(cut[1]) ? cut : null;
+}
 async function howWeWork(bridge) {
     let document = '';
     for (let command = `cat ${HOW_WE_WORK}`; command !== undefined;) {
         const read = await bridge.tool('shell', { command });
         const text = read.content.map((content) => content.text).join('\n');
         const lines = text.split('\n');
-        let at = lines[5]?.startsWith('authority: ') ? 6 : 5;
-        if (read.isError === true || lines[2] !== 'exit: 0') {
-            const refusal = read.isError === true ? text : lines.slice(at).join('\n').replace(/^stderr: /gm, '');
+        if (read.isError === true || (FAILED.test(lines[0] ?? '') && lines[1]?.startsWith('stderr: '))) {
+            const refusal = read.isError === true ? text : lines.slice(1).join('\n').replace(/^stderr: /gm, '');
             if (UNREADABLE.test(refusal))
                 return '';
             throw new Error(refusal);
         }
-        const cut = lines[3] === 'truncation: egress' ? CUT.exec(lines[at++] ?? '') : null;
-        const shown = Buffer.from(`${lines.slice(at).join('\n')}\n`);
-        document += (cut === null ? shown : shown.subarray(0, Number(cut[1]))).toString();
+        const cut = cutOf(lines);
+        document += lines.slice(cut === null ? 0 : 1).join('\n');
         command = cut?.[2];
     }
     return document.replace(/\n$/, '');
 }
 export async function instructions(bridge, base, copies) {
-    const app = new URL('/app/new.git', (await readEnrolment()).house).href;
-    const appLine = `To show the User a page, upload it or push it to an App instead of starting a server; \`git clone ${app}\` starts a new App.`;
-    const lines = [HOUSE_LINE, FILE_LINE, appLine, ...(copies.length === 0 ? [] : [COPIES_LINE, ...copies])];
+    const lines = [HOUSE_LINE, FILE_LINE, READ_LINE, ...(copies.length === 0 ? [] : [COPIES_LINE, ...copies])];
     return [lines.join('\n'), base, await howWeWork(bridge)].filter((part) => part !== '').join('\n\n');
 }

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) => {
@@ -71,18 +80,29 @@ export async function login(argv) {
     });
     const enrolled = await readEnrolment();
     const house = values.house ?? enrolled?.house ?? DEFAULT_HOUSE;
-    const environment = values.environment ?? (enrolled?.house === house ? enrolled.environment : undefined);
+    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() }
+            ? { 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/dist/operation.js

@@ -1,9 +1,12 @@
 import { randomBytes } from 'node:crypto';
+export function uuidOf(bytes, version) {
+    bytes[6] = (version << 4) | (bytes[6] & 0x0f);
+    bytes[8] = 0x80 | (bytes[8] & 0x3f);
+    const hex = bytes.toString('hex', 0, 16);
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
 export 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)}`;
+    return uuidOf(bytes, 7);
 }

package/dist/refusals.js

@@ -0,0 +1,41 @@
+import { parse } from 'yaml';
+const HEAD = /^([a-z][a-z0-9_]*): \S/;
+function conflictCodes(detail) {
+    let parsed;
+    try {
+        parsed = parse(detail);
+    }
+    catch {
+        return [];
+    }
+    const conflicts = parsed?.conflicts;
+    if (!Array.isArray(conflicts))
+        return [];
+    return conflicts.flatMap((conflict) => typeof conflict?.code === 'string' ? [conflict.code] : []);
+}
+function spoken(text) {
+    const head = HEAD.exec(text);
+    if (head === null)
+        return null;
+    const said = text.replace(/\n+$/, '');
+    const detail = said.indexOf('\n');
+    return { code: head[1], text: said, conflicts: detail === -1 ? [] : conflictCodes(said.slice(detail + 1)) };
+}
+export function refusalOf(text) {
+    let body;
+    try {
+        body = JSON.parse(text);
+    }
+    catch {
+        return spoken(text);
+    }
+    const error = body?.error;
+    if (typeof error !== 'object' || error === null)
+        return null;
+    const { code, message, data } = error;
+    const said = typeof message === 'string' ? spoken(message) : null;
+    if (said !== null)
+        return said;
+    const named = typeof code === 'string' ? code : typeof data?.code === 'string' ? data.code : null;
+    return named === null ? null : { code: named, text: named, conflicts: [] };
+}

package/dist/resident.js

@@ -8,11 +8,12 @@ import { Agents } from './agents.js';
 import { house } from './api.js';
 import { received } from './bridge.js';
 import { Conversations } from './conversations.js';
-import { WorkingCopies } from './copies.js';
-import { kitHome, readEnrolment } from './home.js';
+import { LocalCopies } from './copies.js';
+import { agentBase, kitHome, readEnrolment } from './home.js';
 import { SignIns } from './sign-in.js';
 import { placeSkillSet } from './skills.js';
 import { holdStream } from './stream.js';
+import { Updates } from './update.js';
 function report(error) {
     process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
 }
@@ -56,9 +57,10 @@ export async function resident() {
         return;
     }
     await placeSkillSet();
+    await mkdir(agentBase(), { recursive: true });
     process.env.HOUSE_KIT_RESIDENT = String(process.pid);
     const agents = new Agents(house);
-    const copies = new WorkingCopies(house);
+    const copies = new LocalCopies(house);
     await copies.load();
     await installShim();
     await serveOwner(copies);
@@ -82,6 +84,7 @@ export async function resident() {
         changed,
     });
     const signIns = new SignIns(house, agents, changed);
+    const updates = new Updates(house);
     for (const signal of ['SIGTERM', 'SIGINT']) {
         process.once(signal, () => {
             killDescendants();
@@ -89,6 +92,7 @@ export async function resident() {
         });
     }
     await house.deliver('/kit/restarted', {}).catch(report);
+    await updates.resumed().catch(report);
     logged(agents.refresh());
     stream = holdStream({
         opened: () => {
@@ -99,7 +103,7 @@ export async function resident() {
         frame: (arrived) => {
             if (arrived.type === 'work_available' && arrived.subject === 'agents')
                 logged(agents.refresh());
-            if (arrived.type === 'work_available' && arrived.subject === 'working_copy')
+            if (arrived.type === 'work_available' && arrived.subject === 'local_copy')
                 logged(copies.select());
             if (arrived.type === 'entries') {
                 copies.entries(arrived);
@@ -108,6 +112,8 @@ export async function resident() {
                 reported = false;
                 if (arrived.kind === 'sign_in')
                     signIns.start(arrived);
+                else if (arrived.kind === 'update')
+                    updates.start(arrived);
                 else
                     conversations.input(arrived);
             }

package/dist/secret-input.js

@@ -1,15 +1,17 @@
+import { retryDelay } from './api.js';
 export async function holdSecretInput(house, subject, steps, waiting) {
-    while (waiting()) {
+    for (let failures = 0; waiting();) {
         try {
             const held = await house.post(`/kit/secret-input/${subject}`, { steps });
             if (held.outcome === 'collected')
                 return held.content;
             if (held.release !== 'held')
                 return null;
+            failures = 0;
         }
         catch (error) {
             process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
-            await new Promise((resolve) => setTimeout(resolve, 1000));
+            await new Promise((resolve) => setTimeout(resolve, retryDelay(failures++)));
         }
     }
     return null;

package/dist/sign-in.js

@@ -1,13 +1,16 @@
 import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
 import { killTree } from './acp.js';
-import { CLIS, cliCommand, withoutProxy } from './clis.js';
+import { CLIS, withoutProxy } from './clis.js';
 import { holdSecretInput } from './secret-input.js';
 const ESCAPE = /\u001b\[[\d;]*m/g;
 const LINK = /https:\/\/\S+/;
 const CODE = /^[A-Z0-9]+-[A-Z0-9]+$/;
+function causeOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 function logged(error) {
-    process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
+    process.stderr.write(`kit: ${causeOf(error)}\n`);
 }
 export class SignIns {
     house;
@@ -28,7 +31,7 @@ export class SignIns {
         this.running.add(input.input_id);
         this.changed();
         this.login(input)
-            .then(() => this.agents.report())
+            .then(() => this.agents.reread(input.cli))
             .then(() => this.house.deliver(`/kit/inputs/${input.input_id}/ack`, {}))
             .catch(logged)
             .finally(() => {
@@ -37,9 +40,16 @@ export class SignIns {
         });
     }
     async login(input) {
-        await this.agents.installed();
+        let cli;
+        try {
+            cli = await this.agents.located(input.cli);
+        }
+        catch (error) {
+            process.stderr.write(`kit: the ${input.cli} sign-in failed: ${causeOf(error)}\n`);
+            return;
+        }
         const login = CLIS[input.cli].login;
-        const child = spawn(cliCommand(input.cli), login.args, {
+        const child = spawn(cli, login.args, {
             stdio: ['pipe', 'pipe', 'pipe'],
             detached: true,
             env: withoutProxy(),
@@ -54,6 +64,8 @@ export class SignIns {
             if (plain === '')
                 return;
             last = plain;
+            if (login.code === 'collect' && plain.includes(login.rejected))
+                killTree(child);
             link ??= LINK.exec(plain)?.[0];
             if (CODE.test(plain))
                 code ??= plain;

package/dist/skills.js

@@ -3,11 +3,10 @@ import { cp, lstat, mkdir, readdir, realpath, rm, symlink, writeFile } from 'nod
 import { homedir } from 'node:os';
 import { join, relative } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { parse } from 'yaml';
 import { KIT_VERSION } from './clis.js';
-import { refusalCode } from './copies.js';
 import { kitHome, readConfiguration, readHome, writeHome } from './home.js';
-export const HOW_WE_WORK = '/private/library/how-we-work.md';
+import { refusalOf } from './refusals.js';
+export const HOW_WE_WORK = '/private/how-we-work.md';
 const SKILL_SET = fileURLToPath(new URL('../skills/', import.meta.url));
 const HOW_WE_WORK_TEXT = readFileSync(new URL('../how-we-work.md', import.meta.url), 'utf8');
 const RECORD = 'skill-set.json';
@@ -63,20 +62,16 @@ export async function placeSkillSet() {
     else
         await rm(join(kitHome(), RECORD), { force: true });
 }
-function documentPresent(refusal) {
-    const { conflicts } = parse(refusal.slice(refusal.indexOf('\n') + 1));
-    return conflicts.some((conflict) => conflict.code === 'path_exists');
-}
 export async function createHowWeWork(bridge) {
     if ((await readHome(RECORD)) === null || (await present(join(kitHome(), CREATED))))
         return;
     const created = await bridge.tool('edit', { changes: [{ op: 'create', path: HOW_WE_WORK, content: HOW_WE_WORK_TEXT }] });
     if (created.isError === true) {
         const text = created.content.map((content) => content.text).join('\n');
-        const code = refusalCode(text);
-        if (UNWRITABLE.has(code))
+        const refusal = refusalOf(text);
+        if (UNWRITABLE.has(refusal?.code ?? ''))
             return;
-        if (code !== 'edit_conflict' || !documentPresent(text))
+        if (refusal?.code !== 'edit_conflict' || !refusal.conflicts.includes('path_exists'))
             throw new Error(text);
     }
     await writeFile(join(kitHome(), CREATED), '');

package/dist/stream.js

@@ -1,3 +1,4 @@
+import { retryDelay } from './api.js';
 import { readEnrolment } from './home.js';
 const SUBPROTOCOL = 'house.kit.stream.1';
 function streamUrl(house) {
@@ -29,9 +30,7 @@ export function holdStream(handlers) {
             if (socket === opening)
                 socket = null;
             process.stderr.write(`kit: control stream closed ${event.code} ${event.reason}\n`);
-            const delay = opened
-                ? 1000 + Math.random() * 2000
-                : Math.min(30_000, 1000 * 2 ** failures++);
+            const delay = opened ? 1000 + Math.random() * 2000 : retryDelay(failures++);
             setTimeout(() => void connect(), delay);
         };
     };