@agentshouse/kit 0.2.1-cd646adba3f64 → 0.2.1-cde47fd72fe59

package/dist/home.js

@@ -1,13 +1,63 @@
-import { existsSync } from 'node:fs';
+import { createHash, randomUUID } from 'node:crypto';
+import { accessSync, chmodSync, constants, existsSync, linkSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync } from 'node:fs';
 import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { homedir, tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { selectRelay } from './relay.js';
 const ENROLMENT = 'credential.json';
 const DISCONNECTED = 'disconnected.json';
 const CONFIGURATION = 'kit.json';
 const OWN_AGENT = 'own-agent.json';
+const RESTART = 'restart';
+let defaulted;
+function writable(directory) {
+    try {
+        accessSync(directory, constants.W_OK | constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function privateDirectory(path) {
+    try {
+        mkdirSync(path, { mode: 0o700 });
+    }
+    catch (error) {
+        if (error.code !== 'EEXIST')
+            throw error;
+    }
+    const found = lstatSync(path);
+    if (found.isSymbolicLink())
+        throw new Error(`${path} is a symbolic link`);
+    if (!found.isDirectory())
+        throw new Error(`${path} is not a directory`);
+    if (found.uid !== process.geteuid())
+        throw new Error(`${path} is not owned by this User`);
+    chmodSync(path, 0o700);
+    return path;
+}
+function ownTemporaryHome() {
+    return privateDirectory(join(tmpdir(), `house-kit-${process.getuid()}`));
+}
+function defaultHome() {
+    const home = join(homedir(), '.house-kit');
+    return existsSync(home) || writable(homedir()) ? home : ownTemporaryHome();
+}
 export function kitHome() {
-    return process.env.HOUSE_KIT_HOME ?? join(homedir(), '.house-kit');
+    return process.env.HOUSE_KIT_HOME || (defaulted ??= defaultHome());
+}
+export function socketDirectory() {
+    const sockets = privateDirectory(join(realpathSync('/tmp'), `hk-${process.geteuid()}`));
+    const home = kitHome();
+    const physical = existsSync(home) ? realpathSync(home) : resolve(home);
+    return privateDirectory(join(sockets, createHash('sha256').update(physical).digest('hex').slice(0, 12)));
+}
+export function ownerSocket() {
+    return join(socketDirectory(), 'owner.sock');
+}
+export function ownerLock() {
+    return join(socketDirectory(), 'owner.lock');
 }
 export function workspaceRoot() {
     return process.env.HOUSE_KIT_WORKSPACE ?? '/agents/house';
@@ -28,12 +78,15 @@ export async function readHome(name) {
 export async function writeHome(name, value) {
     const home = kitHome();
     await mkdir(home, { recursive: true, mode: 0o700 });
-    const temporary = join(home, `${name}.${process.pid}`);
+    const temporary = join(home, `${name}.${randomUUID()}`);
     await writeFile(temporary, `${JSON.stringify(value)}\n`, { mode: 0o600 });
     await rename(temporary, join(home, name));
 }
-export function readEnrolment() {
-    return readHome(ENROLMENT);
+export async function readEnrolment() {
+    const enrolment = await readHome(ENROLMENT);
+    if (enrolment !== null)
+        selectRelay(process.env.HOUSE_KIT_RELAY || enrolment.relay);
+    return enrolment;
 }
 export async function writeEnrolment(enrolment) {
     await writeHome(ENROLMENT, enrolment);
@@ -42,13 +95,49 @@ export async function writeEnrolment(enrolment) {
 export function readDisconnected() {
     return readHome(DISCONNECTED);
 }
+export function forgetDisconnected() {
+    return rm(join(kitHome(), DISCONNECTED), { force: true });
+}
 export async function forgetEnrolment({ house, environment }) {
     await writeHome(DISCONNECTED, { house, environment });
     await rm(join(kitHome(), ENROLMENT), { force: true });
 }
+export async function forgetRejected(rejected) {
+    const held = await readHome(ENROLMENT);
+    if (held?.credential !== rejected)
+        return;
+    await writeHome(DISCONNECTED, { house: held.house, environment: held.environment });
+    const enrolment = join(kitHome(), ENROLMENT);
+    const taken = `${enrolment}.${process.pid}`;
+    try {
+        renameSync(enrolment, taken);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return;
+        throw error;
+    }
+    if (JSON.parse(readFileSync(taken, 'utf8')).credential !== rejected) {
+        try {
+            linkSync(taken, enrolment);
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+        }
+        rmSync(join(kitHome(), DISCONNECTED), { force: true });
+    }
+    rmSync(taken);
+}
 export function enrolled() {
     return existsSync(join(kitHome(), ENROLMENT));
 }
+export function restartAsked() {
+    return existsSync(join(kitHome(), RESTART));
+}
+export function forgetRestart() {
+    return rm(join(kitHome(), RESTART), { force: true });
+}
 export function readOwnAgent() {
     return readHome(OWN_AGENT);
 }

package/dist/house-cli.js

@@ -0,0 +1,291 @@
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { request, setGlobalProxyFromEnv } from 'node:http';
+import { basename, dirname, extname, join, resolve } from 'node:path';
+import { verified } from './files.js';
+import { HOUSE_REF } from './git.js';
+import { ownerSocket, readOwnAgent } from './home.js';
+import { callHouse, rpc, UNREACHABLE } from './mcp.js';
+import { refusalOf } from './refusals.js';
+import { relayed, selectRelay } from './relay.js';
+import { parse, stringify } from 'yaml';
+const USAGE = "usage: house <tool> ['<arguments as JSON>']";
+const PUSH_USAGE = 'usage: house push [commit] [--owner]';
+const PUSH = "push [commit]: sends the Local copy's committed changes to House";
+const FETCH_USAGE = 'usage: house fetch';
+const FETCH = `fetch: records House's changes on each Local copy's ${HOUSE_REF}`;
+const DOWNLOAD_USAGE = `usage: house download '{"path":"/rooms/<handle>/<path>","file":"<local file>"}', adding "ref" for a revision`;
+const DOWNLOAD = 'download: writes a binary file of a Room to the local file named by file';
+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 SANDBOXED = "your CLI's sandbox kept house from House; run house directly, not through another program";
+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, or kit chatgpt --key <key> with a script key";
+const DISCONNECTED = "House no longer accepts this computer's own agent; run kit login, or kit chatgpt --key <key> with a script key";
+const UNCONFIRMED = 'with no result; a write may or may not have taken effect, so read before you repeat it';
+const socketPath = process.env.HOUSE_BRIDGE;
+const MEDIA_TYPES = new Map([
+    ['avif', 'image/avif'],
+    ['csv', 'text/csv'],
+    ['docx', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'],
+    ['gif', 'image/gif'],
+    ['heic', 'image/heic'],
+    ['html', 'text/html'],
+    ['jpeg', 'image/jpeg'],
+    ['jpg', 'image/jpeg'],
+    ['json', 'application/json'],
+    ['m4a', 'audio/mp4'],
+    ['md', 'text/markdown'],
+    ['mov', 'video/quicktime'],
+    ['mp3', 'audio/mpeg'],
+    ['mp4', 'video/mp4'],
+    ['ogg', 'audio/ogg'],
+    ['pdf', 'application/pdf'],
+    ['png', 'image/png'],
+    ['pptx', 'application/vnd.openxmlformats-officedocument.presentationml.presentation'],
+    ['svg', 'image/svg+xml'],
+    ['txt', 'text/plain'],
+    ['wav', 'audio/wav'],
+    ['webm', 'video/webm'],
+    ['webp', 'image/webp'],
+    ['xlsx', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'],
+    ['zip', 'application/zip'],
+]);
+function refused(path, method, status, text, local) {
+    const refusal = refusalOf(text);
+    if (refusal !== null)
+        return refusal.text;
+    if (status === 401)
+        return REVOKED;
+    const act = method === 'GET' ? 'download' : 'upload';
+    if (URL.canParse(path))
+        return `the ${act} answered ${status}; ${act} the file again`;
+    if (status === 502 && local)
+        return text;
+    return path === '/' ? unconfirmed(status) : `${path} answered ${status}`;
+}
+function unconfirmed(status) {
+    return `House answered ${status} ${UNCONFIRMED}`;
+}
+function exchanged(path, method, body, headers = { 'content-type': 'application/json' }, to = socketPath) {
+    return new Promise((resolve, reject) => {
+        const sent = request({ socketPath: to, path, method, headers }, (answer) => {
+            const chunks = [];
+            answer.on('data', (chunk) => chunks.push(chunk));
+            answer.on('end', () => {
+                const bytes = Buffer.concat(chunks);
+                if (answer.statusCode === 200)
+                    resolve(bytes);
+                else
+                    reject(new Error(refused(path, method, answer.statusCode, bytes.toString('utf8'), answer.headers['content-type'] === undefined)));
+            });
+        });
+        sent.on('error', (error) => reject(new Error(error.code === 'EPERM' || error.code === 'EACCES' ? SANDBOXED : CLOSED)));
+        sent.end(body === undefined ? undefined : body instanceof Buffer ? body : JSON.stringify(body));
+    });
+}
+async function bridged(path, body, headers, to = socketPath) {
+    return (await exchanged(path, 'POST', body, headers, to)).toString('utf8');
+}
+async function direct(message) {
+    const ownAgent = await readOwnAgent();
+    if (ownAgent === null)
+        throw new Error(UNCONNECTED);
+    selectRelay(process.env.HOUSE_KIT_RELAY || ownAgent.relay);
+    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 ?? unconfirmed(answer.status)));
+}
+async function mcp(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;
+}
+async function tools() {
+    return (await mcp('tools/list', {})).tools;
+}
+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 transferred(url, method, bytes, headers) {
+    if (socketPath !== undefined)
+        return exchanged(url, method, bytes, headers);
+    setGlobalProxyFromEnv();
+    const answer = await fetch(relayed(url), { method, ...(headers === undefined ? {} : { headers }), ...(bytes === undefined ? {} : { body: bytes }) }).catch(() => {
+        throw new Error(UNREACHABLE);
+    });
+    const received = Buffer.from(await answer.arrayBuffer());
+    if (answer.status === 200)
+        return received;
+    throw new Error(refused(url, method, answer.status, received.toString('utf8'), false));
+}
+async function sent(url, bytes, operation) {
+    const headers = { 'content-type': 'application/octet-stream', 'x-house-byte-operation': operation };
+    return (await transferred(url, 'POST', bytes, headers)).toString('utf8');
+}
+async function download(args) {
+    const { flags, positionals: [argument] } = accepted(args, ['--help'], 1, DOWNLOAD_USAGE);
+    if (flags.has('--help'))
+        return DOWNLOAD_USAGE;
+    const { file, ...selected } = argumentsOf(argument);
+    if (typeof file !== 'string' || file === '')
+        throw new Error('download needs "file", the local file to write');
+    const inspected = parse(await called('inspect', selected));
+    if (typeof inspected?.download !== 'string')
+        throw new Error(`${String(selected.path)} holds no binary file; shell reads its text`);
+    const bytes = verified(await transferred(inspected.download, 'GET'), String(inspected.sha256), String(selected.path));
+    const written = resolve(file);
+    await mkdir(dirname(written), { recursive: true });
+    await writeFile(written, bytes);
+    return written;
+}
+async function described(file) {
+    const bytes = await localFile(file);
+    const mediaType = MEDIA_TYPES.get(extname(file).slice(1).toLowerCase());
+    return {
+        bytes,
+        description: {
+            bytes: bytes.length,
+            sha256: createHash('sha256').update(bytes).digest('hex'),
+            ...(mediaType === undefined ? {} : { media_type: mediaType }),
+        },
+    };
+}
+async function upload({ file, ...destination }) {
+    if (typeof file !== 'string' || file === '')
+        throw new Error('upload needs "file", a local file');
+    const { bytes, description } = await described(file);
+    const answer = await called('upload', { ...destination, ...description });
+    const declared = parse(answer);
+    if (declared.upload === undefined)
+        return answer;
+    const written = JSON.parse(await sent(declared.upload.url, bytes, declared.upload.operation));
+    return stringify(written, { lineWidth: 0 }).trimEnd();
+}
+async function appendRecord(args) {
+    const held = new Map();
+    const attachments = Array.isArray(args.attachments)
+        ? await Promise.all(args.attachments.map(async (attachment) => {
+            if (typeof attachment !== 'string')
+                return attachment;
+            const { bytes, description } = await described(attachment);
+            held.set(description.sha256, bytes);
+            return { name: basename(attachment), ...description };
+        }))
+        : args.attachments;
+    const record = { ...args, attachments };
+    for (;;) {
+        const answer = await called('append_record', record);
+        const { upload } = parse(answer);
+        if (upload === undefined)
+            return answer;
+        for (const grant of upload)
+            await sent(grant.url, held.get(grant.sha256), grant.operation);
+    }
+}
+function unexpected(argument, usage) {
+    return new Error(`unexpected argument ${argument}; ${usage}`);
+}
+function accepted(args, flags, positionals, usage) {
+    const given = { flags: new Set(), positionals: [] };
+    for (const arg of args) {
+        if (flags.includes(arg))
+            given.flags.add(arg);
+        else if (!arg.startsWith('-') && given.positionals.length < positionals)
+            given.positionals.push(arg);
+        else
+            throw unexpected(arg, usage);
+    }
+    return given;
+}
+async function push(args) {
+    const { flags, positionals: [commit = 'HEAD'] } = accepted(args, ['--help', '--owner'], 1, PUSH_USAGE);
+    if (flags.has('--help'))
+        return PUSH_USAGE;
+    const owner = flags.has('--owner');
+    if (owner && socketPath !== undefined)
+        throw new Error('--owner is not for Agent conversations; run house push without it');
+    if (!owner && socketPath === undefined)
+        throw new Error('outside an Agent conversation, house push needs --owner');
+    const pushed = JSON.parse(await bridged('/git/push', { cwd: process.cwd(), commit }, undefined, owner ? ownerSocket() : socketPath));
+    if (pushed.refused)
+        throw new Error(pushed.text);
+    return pushed.text;
+}
+async function fetched(args) {
+    if (accepted(args, ['--help'], 0, FETCH_USAGE).flags.has('--help'))
+        return FETCH_USAGE;
+    const answer = JSON.parse(await bridged('/git/fetch', {}, undefined, socketPath ?? ownerSocket()));
+    if (answer.refused)
+        throw new Error(answer.text);
+    return answer.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(args) {
+    const { flags, positionals: [verb, argument] } = accepted(args, ['--help'], 2, USAGE);
+    if (verb === 'help' && argument !== undefined)
+        throw unexpected(argument, USAGE);
+    if (flags.has('--help') && argument !== undefined)
+        throw unexpected('--help', USAGE);
+    if (verb === undefined || verb === 'help') {
+        return [USAGE, 'help', PUSH, FETCH, DOWNLOAD, ...(await tools()).map((tool) => (tool.description === undefined ? tool.name : `${tool.name}: ${tool.description}`))].join('\n');
+    }
+    if (flags.has('--help')) {
+        const tool = (await tools()).find((listed) => listed.name === verb);
+        if (tool === undefined)
+            throw new Error(`${verb} is no Tool; house find_command '{"query":"${verb}"}' finds Commands`);
+        return [...(tool.description === undefined ? [] : [tool.description]), JSON.stringify(tool.inputSchema)].join('\n');
+    }
+    const parsed = argumentsOf(argument);
+    return verb === 'upload' ? upload(parsed) : verb === 'append_record' ? appendRecord(parsed) : called(verb, parsed);
+}
+async function called(name, args) {
+    const result = await mcp('tools/call', { name, arguments: args });
+    const text = result.content.map((content) => content.text).join('\n');
+    if (result.isError === true)
+        throw new Error(text.replace(/\n+$/, ''));
+    return text;
+}
+const argv = process.argv.slice(2);
+const named = argv.findIndex((arg) => !arg.startsWith('-'));
+const rest = argv.filter((_arg, index) => index !== named);
+(argv[named] === 'push'
+    ? push(rest)
+    : argv[named] === 'fetch'
+        ? fetched(rest)
+        : argv[named] === 'download'
+            ? download(rest)
+            : house(argv)).then((text) => {
+    process.stdout.write(`${text}\n`);
+    if (argv[0] === 'shell')
+        process.exitCode = Number(/^exit: (\d+)(?:\n|$)/.exec(text)?.[1] ?? 0);
+}, (error) => {
+    process.stderr.write(`house: ${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+});

package/dist/house-main.js

@@ -1,162 +1,10 @@
 #!/usr/bin/env node
-import { createHash } from 'node:crypto';
-import { readFile } from 'node:fs/promises';
-import { request, setGlobalProxyFromEnv } from 'node:http';
-import { basename, join } from 'node:path';
-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 PUSH_USAGE = 'usage: house push [commit] [--owner]';
-const PUSH = "push [commit]: sends the Local copy's committed changes to House";
-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) => {
-            let text = '';
-            answer.setEncoding('utf8');
-            answer.on('data', (chunk) => {
-                text += chunk;
-            });
-            answer.on('end', () => {
-                if (answer.statusCode === 200)
-                    resolve(text);
-                else
-                    reject(new Error(refused(path, answer.statusCode, text)));
-            });
-        });
-        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 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;
-}
-async function tools() {
-    return (await mcp('tools/list', {})).tools;
-}
-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 }),
-        name: basename(path),
-        bytes: bytes.length,
-        sha256: createHash('sha256').update(bytes).digest('hex'),
-    }));
-    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 push(args) {
-    if (args.includes('--help'))
-        return PUSH_USAGE;
-    const owner = args.includes('--owner');
-    const commit = args.find((arg) => arg !== '--owner') ?? 'HEAD';
-    if (owner && socketPath !== undefined)
-        throw new Error('--owner is not for Agent conversations; run house push without it');
-    if (!owner && socketPath === undefined)
-        throw new Error('outside an Agent conversation, house push needs --owner');
-    const pushed = JSON.parse(await bridged('/git/push', { cwd: process.cwd(), commit }, undefined, owner ? join(kitHome(), 'owner.sock') : socketPath));
-    if (pushed.refused)
-        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;
+const [major = 0, minor = 0] = process.versions.node.split('.').map(Number);
+if (major < 24 || (major === 24 && minor < 14)) {
+    process.stderr.write(`house: the Kit needs Node 24.14.0 or newer; this is ${process.versions.node}\n`);
+    process.exitCode = 1;
 }
-async function house([verb, argument]) {
-    if (verb === undefined || verb === '--help' || verb === 'help') {
-        return [USAGE, 'help', PUSH, ...(await tools()).map((tool) => (tool.description === undefined ? tool.name : `${tool.name}: ${tool.description}`))].join('\n');
-    }
-    if (argument === '--help') {
-        const tool = (await tools()).find((listed) => listed.name === verb);
-        if (tool === undefined)
-            throw new Error(`${verb} is no Tool; house find_command '{"query":"${verb}"}' finds Commands`);
-        return [...(tool.description === undefined ? [] : [tool.description]), JSON.stringify(tool.inputSchema)].join('\n');
-    }
-    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') });
-    }
-    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'));
-        }
-        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.replace(/\n+$/, ''));
-    return text;
+else {
+    await import('./house-cli.js');
 }
-const argv = process.argv.slice(2);
-(argv[0] === 'push' ? push(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;
-});
+export {};

package/dist/inputs.js

@@ -0,0 +1,37 @@
+function logged(error) {
+    process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
+}
+export class Inputs {
+    house;
+    changed;
+    carried = new Map();
+    open = 0;
+    constructor(house, changed) {
+        this.house = house;
+        this.changed = changed;
+    }
+    idle() {
+        return this.open === 0;
+    }
+    carry(inputId, work) {
+        const known = this.carried.get(inputId);
+        const carried = known ?? work();
+        if (known === undefined) {
+            this.carried.set(inputId, carried);
+            carried.catch(() => this.carried.delete(inputId));
+        }
+        this.open++;
+        this.changed();
+        return carried
+            .then(async ({ ack, acknowledged }) => {
+            await this.house.deliver(`/kit/inputs/${inputId}/ack`, ack);
+            if (known === undefined)
+                await acknowledged?.();
+        })
+            .catch(logged)
+            .finally(() => {
+            this.open--;
+            this.changed();
+        });
+    }
+}