@agentshouse/kit 0.2.1-cbabe8ad337ff → 0.2.1-cbdf76b9a90a3

package/dist/instructions.js

@@ -1,34 +1,12 @@
-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 or a page, upload it with `house upload` and link it; never start a server.';
-const READ_LINE = 'Before working in a Room, read `/rooms/private/rooms/<handle>/AGENTS.md`.';
-const COPIES_LINE = 'House Local copies; commit, then `house 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');
-        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 = cutOf(lines);
-        document += lines.slice(cut === null ? 0 : 1).join('\n');
-        command = cut?.[2];
-    }
-    return document.replace(/\n$/, '');
-}
+import { HOUSE_REF } from './git.js';
+import { readHowWeWork } from './skills.js';
+const SOURCE_LINE = "From House:";
+const HOUSE_LINE = "Work with House through the `house` CLI: run `house --help`, and `house find_command` for House's guides and formats.";
+const FILE_LINE = 'To give the User a file, upload it with `house upload` and link it; for an App, a Site or a website, follow `house find_command \'{"query":"app"}\'`. Never start a server.';
+const READ_LINE = "Optional per-Room instructions: `/rooms/private/rooms/<handle>/AGENTS.md`.";
+const WAIT_LINE = 'To get what another Agent will write into a Room, `create_trigger` on where it will land with a `conversation` action, then end your turn: this conversation continues when it lands.';
+const COPIES_LINE = `House Local copies; before work run \`house fetch\` and rebase onto \`${HOUSE_REF}\`; after it commit, then \`house push\`:`;
 export async function instructions(bridge, base, 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');
+    const lines = [SOURCE_LINE, HOUSE_LINE, FILE_LINE, READ_LINE, WAIT_LINE, ...(copies.length === 0 ? [] : [COPIES_LINE, ...copies])];
+    return [lines.join('\n'), base, (await readHowWeWork(bridge)).replace(/\n$/, '')].filter((part) => part !== '').join('\n\n');
 }

package/dist/kit-cli.js

@@ -0,0 +1,68 @@
+import { setGlobalProxyFromEnv } from 'node:http';
+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 { 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 House Kit and ends your own agent's connection",
+            operands: 0,
+            run: logout,
+        },
+    ],
+    [
+        'resident',
+        {
+            usage: 'usage: kit resident',
+            about: "keeps this Environment connected; House 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);
+setGlobalProxyFromEnv();
+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,24 +1,10 @@
 #!/usr/bin/env node
-import { setGlobalProxyFromEnv } from 'node:http';
-import { answerGitCredential } from './app-git.js';
-import { login } from './login.js';
-import { logout } from './logout.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 === 'logout')
-        return logout();
-    if (command === 'resident')
-        return resident();
-    if (command === 'git-credential')
-        return answerGitCredential(argv[0]);
-    process.stderr.write('usage: kit <login|logout|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] = process.versions.node.split('.').map(Number);
+if (major < 24 || (major === 24 && minor < 14)) {
+    process.stderr.write(`kit: the Kit needs Node 24.14.0 or newer; this is ${process.versions.node}\n`);
     process.exitCode = 1;
-});
+}
+else {
+    await import('./kit-cli.js');
+}
+export {};

package/dist/login.js

@@ -2,11 +2,16 @@ import { spawn } from 'node:child_process';
 import { createHash, randomBytes } from 'node:crypto';
 import { hostname } from 'node:os';
 import { parseArgs } from 'node:util';
-import { post, retrying } from './api.js';
+import { HouseRefusal, post, retrying } from './api.js';
 import { placeAppGit } from './app-git.js';
-import { forgetOwnAgent, readDisconnected, readEnrolment, readOwnAgent, writeEnrolment, writeOwnAgent } from './home.js';
+import { writeCodexRule } from './clis.js';
+import { forgetDisconnected, forgetOwnAgent, readDisconnected, readEnrolment, readOwnAgent, writeEnrolment, writeOwnAgent, } from './home.js';
 import { callHouse, rpc } from './mcp.js';
-const DEFAULT_HOUSE = 'https://agents.house';
+import { refusalOf } from './refusals.js';
+import { selectRelay } from './relay.js';
+import { startService } from './service.js';
+import { placeSkillSet } from './skills.js';
+export const DEFAULT_HOUSE = 'https://agents.house';
 const OPENER = process.platform === 'darwin' ? 'open' : 'xdg-open';
 // Polling every two seconds brings the User's confirmation to the waiting Kit moments after they give it.
 const POLL_INTERVAL_MS = 2000;
@@ -15,7 +20,7 @@ function open(link) {
         .on('error', () => undefined)
         .unref();
 }
-async function accepted(house, credential) {
+export async function accepted(house, credential) {
     const checked = await callHouse(house, credential, rpc('tools/list', {}));
     if (checked.status === 200)
         return true;
@@ -23,39 +28,124 @@ async function accepted(house, credential) {
         return false;
     throw new Error(`House answered ${checked.status} when Kit checked this computer's own agent's connection: ${checked.text}`);
 }
+const USAGE = `usage: kit login [--house <origin>] [--environment <id>] [--rooms <ref>[,<ref>...] | --no-private]
+       kit login [--house <origin>] --code <code>
+  --house <origin>          the House to connect to, ${DEFAULT_HOUSE} unless one is stored
+  --environment <id>        reconnect this Environment
+  --rooms <ref>[,<ref>...]  give this Environment only these Rooms
+  --no-private              give this Environment every Room but your Private Room
+  --code <code>             connect this machine with a login code
+`;
+function connected(house, named, environment) {
+    if (named === undefined)
+        return `Environment ${environment} is connected to ${house}.\n`;
+    if (named === environment)
+        return `Environment ${environment} is reconnected to ${house}.\n`;
+    return `Environment ${named} stays with its account; this computer is connected to ${house} as new Environment ${environment} of the account that confirmed.\n`;
+}
+function gone(error) {
+    return error instanceof HouseRefusal && refusalOf(error.text)?.code === 'kit_environment_not_found';
+}
+function chosenRooms(rooms, noPrivate) {
+    if (rooms !== undefined && noPrivate)
+        throw new Error('--rooms and --no-private are two choices of Rooms; pass one');
+    if (rooms !== undefined)
+        return { rooms: { reach: 'selected', refs: rooms.split(',') } };
+    return noPrivate ? { rooms: { reach: 'all_but_private' } } : {};
+}
 export async function login(argv) {
     const { values } = parseArgs({
         args: argv,
         options: {
             house: { type: 'string' },
             environment: { type: 'string' },
+            rooms: { type: 'string' },
+            'no-private': { type: 'boolean', default: false },
+            code: { type: 'string' },
+            help: { type: 'boolean', default: false },
         },
     });
+    if (values.help) {
+        process.stdout.write(USAGE);
+        return;
+    }
+    if (values.code !== undefined && values.rooms !== undefined)
+        throw new Error('--code cannot be used with --rooms');
+    if (values.code !== undefined && values['no-private'])
+        throw new Error('--code cannot be used with --no-private');
+    if (values.code !== undefined && values.environment !== undefined)
+        throw new Error('--code cannot be used with --environment');
+    const rooms = chosenRooms(values.rooms, values['no-private']);
     const enrolled = (await readEnrolment()) ?? (await readDisconnected());
+    if (values.code !== undefined && enrolled !== null) {
+        throw new Error(`--code connects a new machine; this Kit home records Environment ${enrolled.environment}, so run kit login to reconnect it`);
+    }
+    const relay = process.env.HOUSE_KIT_RELAY || undefined;
+    selectRelay(relay);
     const house = values.house ?? enrolled?.house ?? DEFAULT_HOUSE;
     const replaces = process.env.HOUSE_KIT_REPLACES;
-    const environment = replaces === undefined ? (values.environment ?? (enrolled?.house === house ? enrolled.environment : undefined)) : undefined;
+    const remembered = replaces === undefined && values.environment === undefined && enrolled?.house === house ? enrolled.environment : undefined;
+    const environment = replaces === undefined ? (values.environment ?? remembered) : 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 = await retrying(() => post(house, '/kit', {
-        ...(environment === undefined
-            ? { 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 }),
-    }));
-    process.stdout.write(`Open this link and confirm: ${started.start_url}\n`);
-    open(started.start_url);
-    const exchanged = await retrying(() => post(house, '/kit/token', { login: started.login, code_verifier: verifier }), undefined, () => POLL_INTERVAL_MS);
-    await writeEnrolment({ house, environment: exchanged.environment, credential: exchanged.credential });
-    process.stdout.write(`Environment ${exchanged.environment} is connected to ${house}.\n`);
+    let held = false;
+    let named = environment;
+    let exchanged;
+    if (values.code !== undefined) {
+        exchanged = await post(house, '/kit/token', { code: values.code, label: hostname() });
+    }
+    else {
+        held = ownAgent !== null && ownAgent.house === house && (await accepted(house, ownAgent.credential));
+        const verifier = randomBytes(32).toString('base64url');
+        const start = () => retrying(() => post(house, '/kit', {
+            label: hostname(),
+            ...(named === undefined
+                ? { act: 'new_environment', ...(replaces === undefined ? {} : { replaces }) }
+                : { act: 'existing_environment', environment_id: named }),
+            ...rooms,
+            code_challenge: createHash('sha256').update(verifier).digest('base64url'),
+            ...(held ? {} : { headless: true }),
+        }));
+        let started;
+        try {
+            started = await start();
+        }
+        catch (error) {
+            if (remembered === undefined || !gone(error))
+                throw error;
+            await forgetDisconnected();
+            process.stdout.write(`House no longer holds Environment ${remembered}; connecting this computer as a new one.\n`);
+            named = undefined;
+            started = await start();
+        }
+        process.stdout.write(`Open this link and confirm: ${started.start_url}\n`);
+        open(started.start_url);
+        exchanged = await retrying(() => post(house, '/kit/token', { login: started.login, code_verifier: verifier }), undefined, () => POLL_INTERVAL_MS);
+    }
+    await placeSkillSet();
+    await writeCodexRule().catch((error) => process.stderr.write(`kit: ${error.message}\n`));
+    const relayRecord = relay === undefined ? {} : { relay };
+    await writeEnrolment({
+        house,
+        ...relayRecord,
+        environment: exchanged.environment,
+        credential: exchanged.credential,
+    });
+    process.stdout.write(connected(house, named, exchanged.environment));
     if (exchanged.headless_credential !== undefined) {
-        await writeOwnAgent({ house, user: exchanged.user, credential: exchanged.headless_credential });
+        await writeOwnAgent({ house, ...relayRecord, user: exchanged.user, credential: exchanged.headless_credential });
     }
-    else if (held && ownAgent.user !== exchanged.user) {
+    else if (held && ownAgent !== null && 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");
     }
-    await placeAppGit(ownAgent, await readOwnAgent());
+    else if (held && ownAgent !== null) {
+        await writeOwnAgent({ house, ...relayRecord, user: ownAgent.user, credential: ownAgent.credential });
+    }
+    await placeAppGit(await readOwnAgent()).catch((error) => process.stderr.write(`kit: ${error.message}\n`));
+    try {
+        startService();
+    }
+    catch (error) {
+        process.stderr.write(`kit: ${error.message}\n`);
+    }
 }

package/dist/logout.js

@@ -1,5 +1,4 @@
 import { HouseRefusal, post } from './api.js';
-import { forgetAppGit } from './app-git.js';
 import { forgetEnrolment, forgetOwnAgent, readEnrolment } from './home.js';
 export async function logout() {
     const enrolled = await readEnrolment();
@@ -13,7 +12,6 @@ export async function logout() {
         }
         await forgetEnrolment(enrolled);
     }
-    await forgetAppGit();
     await forgetOwnAgent();
     process.stdout.write(enrolled === null
         ? 'This computer is not connected to House.\n'

package/dist/parts.js

@@ -2,7 +2,10 @@ export class Parts {
     parts = [];
     context = null;
     emit;
+    made = [];
+    events = 0;
     writing = null;
+    counting = null;
     planned = null;
     constructor(emit) {
         this.emit = emit;
@@ -10,32 +13,34 @@ export class Parts {
     write(type, id, text) {
         if (text === '')
             return;
-        const last = this.parts.length - 1;
-        const part = this.parts[last];
-        if (this.writing?.type === type && this.writing.id === id && part?.type === type) {
-            part.text += text;
-            this.emit({ op: 'append', index: last, text });
+        if (this.writing?.type === type && this.writing.id === id) {
+            this.parts[this.writing.index].text += text;
+            this.emit({ op: 'append', index: this.writing.index, text });
             return;
         }
-        this.start({ type, text });
-        this.writing = { type, id };
+        this.writing = { type, id, index: this.start({ type, text }) };
     }
     command() {
-        const last = this.parts.length - 1;
-        const part = this.parts[last];
-        if (part?.type !== 'commands') {
-            this.start({ type: 'commands', count: 1 });
+        if (this.counting === null) {
+            this.counting = this.start({ type: 'commands', count: 1 });
             return;
         }
+        const part = this.parts[this.counting];
         part.count++;
-        this.emit({ op: 'count', index: last, count: part.count });
+        this.emit({ op: 'count', index: this.counting, count: part.count });
     }
     start(part) {
         this.writing = null;
-        this.parts.push(part);
-        const index = this.parts.length - 1;
-        this.emit({ op: 'start', index, part });
-        return index;
+        this.counting = null;
+        return this.add(part, ++this.events);
+    }
+    reserve() {
+        this.writing = null;
+        this.counting = null;
+        return ++this.events;
+    }
+    arrive(part, reserved) {
+        this.add(part, reserved);
     }
     done(index, result) {
         const part = this.parts[index];
@@ -55,10 +60,23 @@ export class Parts {
         this.context = context;
         this.emit({ op: 'context', ...context });
     }
+    saved() {
+        return this.parts
+            .map((part, index) => ({ part, made: this.made[index] }))
+            .sort((a, b) => a.made - b.made)
+            .map(({ part }) => part);
+    }
     operations() {
         return [
             ...this.parts.map((part, index) => ({ op: 'start', index, part })),
             ...(this.context === null ? [] : [{ op: 'context', ...this.context }]),
         ];
     }
+    add(part, made) {
+        this.parts.push(part);
+        this.made.push(made);
+        const index = this.parts.length - 1;
+        this.emit({ op: 'start', index, part });
+        return index;
+    }
 }

package/dist/placement.js

@@ -0,0 +1,39 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { run } from './clis.js';
+import { kitHome } from './home.js';
+export function service() {
+    if (process.platform !== 'linux' || !process.env.INVOCATION_ID)
+        return null;
+    return process.env.MANAGERPID ? 'user' : 'system';
+}
+export function throughSudo() {
+    return service() === 'system' && process.getuid() !== 0;
+}
+export async function updatesItself() {
+    if (service() === null)
+        return false;
+    if (!throughSudo())
+        return true;
+    // sudo answers at once, so ten seconds only bounds a stuck sudo.
+    return (await run('sudo', ['-n', 'true'], 10_000)).status === 0;
+}
+function recorded(name) {
+    try {
+        return readFileSync(join(kitHome(), name), 'utf8').trim();
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+export function installCommand() {
+    return recorded('install-command');
+}
+export function machine() {
+    const placed = recorded('placement');
+    if (placed === 'container' || placed === 'server' || placed === 'windows')
+        return placed;
+    return process.platform === 'darwin' ? 'macos' : 'linux';
+}

package/dist/relay.js

@@ -1,7 +1,17 @@
+let selected;
+export function selectRelay(relay) {
+    selected = relay === undefined || relay === '' ? null : relay;
+}
+export function relayOrigin() {
+    if (selected !== undefined)
+        return selected ?? undefined;
+    const ambient = process.env.HOUSE_KIT_RELAY;
+    return ambient === undefined || ambient === '' ? undefined : ambient;
+}
 export function relayed(target) {
     const url = new URL(target);
-    const relay = process.env.HOUSE_KIT_RELAY;
-    if (relay === undefined || relay === '')
+    const relay = relayOrigin();
+    if (relay === undefined)
         return url;
     const through = new URL(`${url.host}${url.pathname}${url.search}`, `${relay}/`);
     if (url.protocol === 'wss:' || url.protocol === 'ws:')