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

package/dist/house-cli.js

@@ -0,0 +1,299 @@
+import { createHash } from 'node:crypto';
+import { createReadStream } from 'node:fs';
+import { request } from 'node:http';
+import { request as httpsRequest } from 'node:https';
+import { extname, join, resolve } from 'node:path';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { downloaded, inspectedFile, storeRefusal, uploaded } from './files.js';
+import { HOUSE_REF } from './git.js';
+import { ownerSocket, readOwnAgent } from './home.js';
+import { callHouse, rpc, UNREACHABLE, Unsettled } from './mcp.js';
+import { refusalOf, retryable } from './refusals.js';
+import { proxyUnlessRelayed, relayed, selectRelay } from './relay.js';
+import { parse } 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, status, text, local) {
+    const refusal = refusalOf(text);
+    if (refusal !== null)
+        return refusal.text;
+    if (status === 401)
+        return REVOKED;
+    if (status === 502 && local)
+        return text;
+    return path === '/' ? unconfirmed(status) : `${path} answered ${status}`;
+}
+function unconfirmed(status) {
+    return `House answered ${status} ${UNCONFIRMED}`;
+}
+function bridged(path, body, to = socketPath) {
+    return new Promise((resolve, reject) => {
+        const sent = request({ socketPath: to, path, method: 'POST', headers: { 'content-type': 'application/json' } }, (answer) => {
+            const chunks = [];
+            answer.on('data', (chunk) => chunks.push(chunk));
+            answer.on('end', () => {
+                const text = Buffer.concat(chunks).toString('utf8');
+                if (answer.statusCode === 200)
+                    resolve(text);
+                else
+                    reject(new Error(refused(path, answer.statusCode, text, answer.headers['content-type'] === undefined)));
+            });
+        });
+        sent.on('error', (error) => reject(new Error(error.code === 'EPERM' || error.code === 'EACCES' ? SANDBOXED : CLOSED)));
+        sent.end(JSON.stringify(body));
+    });
+}
+async function direct(message) {
+    const ownAgent = await readOwnAgent();
+    if (ownAgent === null)
+        throw new Error(UNCONNECTED);
+    selectRelay(process.env.HOUSE_KIT_RELAY || ownAgent.relay);
+    const answer = await callHouse(ownAgent.house, ownAgent.credential, message).catch(() => {
+        throw new Unsettled(UNREACHABLE);
+    });
+    if (answer.status === 200)
+        return answer.text;
+    if (answer.status === 401)
+        throw new Error(DISCONNECTED);
+    const refusal = refusalOf(answer.text)?.text ?? unconfirmed(answer.status);
+    throw retryable(answer.text) === false ? new Error(refusal) : new Unsettled(refusal);
+}
+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;
+}
+function unreadable(path, error) {
+    return new Error(error.code === 'EISDIR'
+        ? `${path} is a folder; upload one file at a time`
+        : `${path} is not a readable file`);
+}
+function opened(url, method, headers, body) {
+    return new Promise((answered, failed) => {
+        const local = socketPath !== undefined;
+        const target = local ? null : relayed(url);
+        if (!local)
+            proxyUnlessRelayed();
+        const sent = target === null
+            ? request({ socketPath, path: url, method, headers }, answered)
+            : (target.protocol === 'https:' ? httpsRequest : request)(target, { method, headers }, answered);
+        sent.on('error', (error) => failed(new Error(!local ? UNREACHABLE : error.code === 'EPERM' || error.code === 'EACCES' ? SANDBOXED : CLOSED)));
+        if (body === undefined)
+            sent.end();
+        else
+            pipeline(body, sent).catch(() => undefined);
+    });
+}
+function ranged(file, start, end) {
+    return end === start ? undefined : createReadStream(file, { start, end: end - 1 });
+}
+async function* read(file, start, end) {
+    try {
+        yield* ranged(file, start, end) ?? [];
+    }
+    catch (error) {
+        throw unreadable(file, error);
+    }
+}
+async function sentPart(url, file, start, end, headers) {
+    const answer = await opened(url, 'PUT', { ...headers, 'content-length': String(end - start) }, ranged(file, start, end));
+    await answer.toArray();
+    if (answer.statusCode !== 200)
+        throw storeRefusal('upload', answer.statusCode);
+}
+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 written = resolve(file);
+    await downloaded(async () => {
+        const file = inspectedFile(await called('inspect', selected));
+        if (file === null)
+            throw new Error(`${String(selected.path)} holds no binary file; shell reads its text`);
+        return file;
+    }, async (url) => {
+        const answer = await opened(url, 'GET', {});
+        return { status: answer.statusCode, body: answer };
+    }, written, String(selected.path));
+    return written;
+}
+async function described(file) {
+    const digest = createHash('sha256');
+    let bytes = 0;
+    try {
+        for await (const chunk of createReadStream(file)) {
+            digest.update(chunk);
+            bytes += chunk.length;
+        }
+    }
+    catch (error) {
+        throw unreadable(file, error);
+    }
+    const mediaType = MEDIA_TYPES.get(extname(file).slice(1).toLowerCase());
+    return { bytes, sha256: digest.digest('hex'), ...(mediaType === undefined ? {} : { media_type: mediaType }) };
+}
+async function finished(upload, room, partSha256) {
+    const text = await called('upload', { upload, room_ref: room, part_sha256: partSha256 });
+    const answer = parse(text);
+    return answer !== null && 'upload' in answer ? answer : { text };
+}
+async function upload({ file, ...destination }) {
+    if (typeof file !== 'string' || file === '')
+        throw new Error('upload needs "file", a local file');
+    const description = await described(file);
+    const answer = await called('upload', { ...destination, ...description });
+    const declared = parse(answer);
+    if (declared?.upload === undefined)
+        return answer;
+    const accepted = await uploaded(declared.upload, {
+        name: file,
+        bytes: description.bytes,
+        sha256: description.sha256,
+        read: (start, end) => read(file, start, end),
+        send: (url, start, end, headers) => sentPart(url, file, start, end, headers),
+        finish: (id, partSha256) => finished(id, destination.room_ref, partSha256),
+    });
+    return accepted.text;
+}
+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 }, 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', {}, 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) : 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,107 +1,10 @@
 #!/usr/bin/env node
-import { createHash, randomUUID } from 'node:crypto';
-import { readFile } from 'node:fs/promises';
-import { request } from 'node:http';
-import { basename, join } from 'node:path';
-import { kitHome } from './home.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 socketPath = process.env.HOUSE_BRIDGE;
-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(`${path} answered ${answer.statusCode}: ${text}`));
-            });
-        });
-        sent.on('error', reject);
-        sent.end(body instanceof Buffer ? body : JSON.stringify(body));
-    });
-}
-async function mcp(method, params) {
-    const answer = JSON.parse(await bridged('/', { jsonrpc: '2.0', id: 1, method, params }));
-    if (answer.error !== undefined)
-        throw new Error(answer.error.message);
-    return answer.result;
-}
-async function tools() {
-    return (await mcp('tools/list', {})).tools;
-}
-async function upload(path, roomRef) {
-    const bytes = await readFile(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, {
-        'content-type': 'application/octet-stream',
-        'x-house-byte-operation': declared.upload.operation,
-    });
-}
-async function gitPush(args) {
-    if (args.includes('--help'))
-        return GIT_USAGE;
-    if (args[0] !== 'push')
-        throw new Error(GIT_USAGE);
-    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');
-    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));
-    if (pushed.refused)
-        throw new Error(pushed.text);
-    return pushed.text;
-}
-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');
-    }
-    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)}`;
-    }
-    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)) {
-        const attachments = [];
-        for (const path of args.attachments) {
-            attachments.push(JSON.parse(await upload(String(path), args.room_ref)).attachment);
-        }
-        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);
-    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');
+const [major = 0, minor = 0, patch = 0] = process.versions.node.split('.').map(Number);
+if (major < 24 || (major === 24 && (minor < 22 || (minor === 22 && patch < 1)))) {
+    process.stderr.write(`house: the Kit needs Node 24.22.1 or newer; this is ${process.versions.node}\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;
-    });
+    await import('./house-cli.js');
 }
+export {};

package/dist/instructions.js

@@ -1,33 +1,32 @@
-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:';
+import { agentInstructions } from '@agentshouse/skills';
+import { HOUSE_REF } from './git.js';
+const OWNER_RULES = '/rooms/private/owner-rules.md';
 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: (.+)$/;
-async function howWeWork(bridge) {
+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 readOwnerRules(bridge) {
     let document = '';
-    for (let command = `cat ${HOW_WE_WORK}`; command !== undefined;) {
+    for (let command = `cat ${OWNER_RULES}`; 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$/, '');
+    return document;
 }
 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])];
-    return [lines.join('\n'), base, await howWeWork(bridge)].filter((part) => part !== '').join('\n\n');
+    const lines = agentInstructions(HOUSE_REF, copies);
+    return [lines.join('\n'), base, (await readOwnerRules(bridge)).replace(/\n$/, '')].filter((part) => part !== '').join('\n\n');
 }

package/dist/kit-cli.js

@@ -0,0 +1,68 @@
+import { parseArgs } from 'node:util';
+import { answerGitCredential } from './app-git.js';
+import { chatgpt } from './chatgpt.js';
+import { login } from './login.js';
+import { logout } from './logout.js';
+import { proxyUnlessRelayed } from './relay.js';
+import { resident } from './resident.js';
+const USAGE = 'usage: kit <login|logout|resident|chatgpt>\n';
+const COMMANDS = new Map([
+    [
+        'logout',
+        {
+            usage: 'usage: kit logout',
+            about: "disconnects this computer, stops the Kit process and ends your own agent's connection",
+            operands: 0,
+            run: logout,
+        },
+    ],
+    [
+        'resident',
+        {
+            usage: 'usage: kit resident',
+            about: "keeps this Environment connected; Kit's service runs it",
+            operands: 0,
+            run: resident,
+        },
+    ],
+    [
+        'git-credential',
+        {
+            usage: 'usage: kit git-credential <get|store|erase>',
+            about: "answers git with your own agent's House credential; git runs it",
+            operands: 1,
+            run: ([operation]) => answerGitCredential(operation),
+        },
+    ],
+]);
+const [command, ...argv] = process.argv.slice(2);
+proxyUnlessRelayed();
+async function run() {
+    if (command === 'login')
+        return login(argv);
+    if (command === 'chatgpt')
+        return chatgpt(argv);
+    if (command === '--help') {
+        parseArgs({ args: argv });
+        process.stdout.write(USAGE);
+        return;
+    }
+    const chosen = COMMANDS.get(command ?? '');
+    if (chosen === undefined) {
+        process.stderr.write(USAGE);
+        process.exitCode = 2;
+        return;
+    }
+    const { values, positionals } = parseArgs({ args: argv, options: { help: { type: 'boolean', default: false } }, allowPositionals: true });
+    if (positionals.length > chosen.operands)
+        throw new Error(`unexpected argument ${positionals[chosen.operands]}; ${chosen.usage}`);
+    if (values.help) {
+        process.stdout.write(`${chosen.usage}\n  ${chosen.about}\n`);
+        return;
+    }
+    return chosen.run(positionals);
+}
+run().catch((error) => {
+    process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+});

package/dist/kit-main.js

@@ -1,18 +1,10 @@
 #!/usr/bin/env node
-import { setGlobalProxyFromEnv } from 'node:http';
-import { login } from './login.js';
-import { resident } from './resident.js';
-const [command, ...argv] = process.argv.slice(2);
-setGlobalProxyFromEnv();
-async function run() {
-    if (command === 'login')
-        return login(argv);
-    if (command === 'resident')
-        return resident();
-    process.stderr.write('usage: kit <login|resident>\n');
-    process.exitCode = 2;
-}
-run().catch((error) => {
-    process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
+const [major = 0, minor = 0, patch = 0] = process.versions.node.split('.').map(Number);
+if (major < 24 || (major === 24 && (minor < 22 || (minor === 22 && patch < 1)))) {
+    process.stderr.write(`kit: the Kit needs Node 24.22.1 or newer; this is ${process.versions.node}\n`);
     process.exitCode = 1;
-});
+}
+else {
+    await import('./kit-cli.js');
+}
+export {};