@agentshouse/kit 0.2.1-c5d36e97b0fea → 0.2.1-c8179f06883b6

package/README.md

@@ -1,14 +1,12 @@
 # House Kit
 
-House Kit connects an Environment, a Linux computer or server, to
-[agents.house](https://agents.house). It runs your Agents' conversations
-through the agent CLIs you chose and gives each Agent the `house` command.
+House Kit connects an Environment, a Linux computer or server, to [agents.house](https://agents.house). It runs
+your Agents' conversations through the agent CLIs you chose and gives each Agent the `house` command.
 
 ## Install
 
-Run `curl -fsSL agents.house/kit | sh`, or `irm agents.house/kit.ps1 | iex` on
-Windows, and again to update; options follow `sh -s --`. On macOS and Linux it
-installs House Kit natively under your own account, without an admin password,
+Run `curl -fsSL agents.house/kit | sh`, or `irm agents.house/kit.ps1 | iex` on Windows, and again to update;
+options follow `sh -s --`. On macOS and Linux it installs House Kit natively under your own account, without an admin password,
 as a service that runs while you are logged in. `kit` and `house` are then on
 your login shell's `PATH`, and your workspace is `~/AgentsHouse` unless you
 pass `--workspace <path>`.
@@ -20,7 +18,7 @@ workspace. On Windows 11 the container is the one choice. Append a `kit` or
 Running the command for the other choice on a connected computer asks you to
 confirm, then replaces its Environment, whose Agents end, with a new one.
 
-On your own Ubuntu 26.04 server, run the Linux command with `--linux` to
+On your own Linux server, run the Linux command with `--linux` to
 install House Kit natively, with its workspace at `/agents/house`; `kit` and
 `house` are then on the server's `PATH`.
 
@@ -33,22 +31,24 @@ them out; running it again without the flag brings them back.
 
 ## Commands
 
-`kit login` opens or prints a link you confirm in any browser, on this
-computer or another, continues on its own and keeps the Environment's
-credential in `~/.house-kit`, or in `$HOUSE_KIT_HOME` when it is set. Pass
-`--environment <id>` to reconnect an Environment you already have. It also
-connects your own agent: outside an Agent conversation, `house <tool>` calls
-House as you and `git` clones and pushes your Apps at `<house>/app/` as you,
-until you revoke that connection on Connections. `house help` lists the Tools.
-`kit logout` disconnects this computer, stops House Kit and ends your own
-agent's connection, so `house` and `git` no longer act as you here; a later
-`kit login` reconnects the same Environment.
-
-`kit resident` keeps the Environment connected and the Rooms you chose for it
-as Git repositories under `local-copies` in the workspace. `house fetch`
-records House's changes on each copy's `refs/house/received`; rebase onto it,
-commit and run `house push --owner` in the copy, through the install command in
-the container. An Agent runs both, without `--owner`.
+`kit login` opens or prints a link you confirm in any browser, on this computer
+or another, continues on its own and keeps the Environment's credential in
+`~/.house-kit`, or in `$HOUSE_KIT_HOME` when it is set. `--environment <id>`
+reconnects an Environment you already have; `--rooms <ref>[,<ref>...]` gives it
+only those Rooms and `--no-private` every Room but your Private Room; `--code <code>` connects immediately without a link.
+A login also connects your own agent: outside an Agent conversation, `house <tool>` calls
+House as you and `git` clones and pushes your Apps at `<house>/app/` as you, until you revoke
+that connection on Connections. `house help` lists the Tools. Codex sessions started after a
+login run a lone `house` command outside their sandbox. `kit logout` disconnects this
+computer, stops House Kit and ends your own agent's connection, so `house` and `git` no
+longer act as you here; a later `kit login` reconnects the same Environment.
+`kit codex --key <key>` starts Codex with `house` acting as you through a key made on Connections; next time, just `kit codex`.
+
+`kit resident` keeps the Environment connected and, as it connects, copies each
+Room you chose for it as a Git repository in the workspace's `local-copies`.
+`house fetch` records House's changes on each copy's `refs/house/received`;
+rebase onto it, commit and run `house push --owner` in the copy, through the
+install command in the container. An Agent runs both, without `--owner`.
 
 House Kit turns each audio file of your message to an Agent into text on this
 computer before the Agent reads it. While transcription is on, the speech

package/dist/agents.js

@@ -3,8 +3,10 @@ import { readFile, realpath } from 'node:fs/promises';
 import { startAdapter } from './acp.js';
 import { CLIS, KIT_VERSION, below, installAdapter, installCli, locate, run, versionOf } from './clis.js';
 import { agentBase, kitHome } from './home.js';
+import { updatesItself } from './placement.js';
 import { killTree } from './scope.js';
 import { holdTranscription, transcriptionReport } from './transcription.js';
+import { KIT_WIRE } from './wire.js';
 const SIGNED_OUT = { signed_in: false, models: [], modes: [] };
 function select(options, category) {
     const option = options.find((candidate) => candidate.category === category);
@@ -257,7 +259,7 @@ export class Agents {
     }
     async load(kind) {
         const known = this.readings.get(kind);
-        if (known !== undefined && known.failure === null)
+        if (known !== undefined && known.failure === null && known.minimum === undefined)
             return;
         await this.examine(kind, SIGNED_OUT, offer);
     }
@@ -270,6 +272,8 @@ export class Agents {
         const body = {
             os: await operatingSystem(),
             kit_version: KIT_VERSION,
+            wire: KIT_WIRE,
+            updates_itself: await updatesItself(),
             agent_base: agentBase(),
             agents,
             transcription: transcriptionReport(),

package/dist/api.js

@@ -1,8 +1,9 @@
 import { setTimeout as delay } from 'node:timers/promises';
-import { end, SIGN_IN_AGAIN } from './end.js';
+import { signInAgain, updateRequired } from './end.js';
 import { readEnrolment } from './home.js';
 import { retryable } from './refusals.js';
 import { relayed } from './relay.js';
+import { KIT_WIRE, KIT_WIRE_HEADER, tooOld } from './wire.js';
 export class HouseRefusal extends Error {
     status;
     text;
@@ -37,12 +38,15 @@ export async function post(house, path, body, credential, signal) {
         method: 'POST',
         headers: {
             'content-type': 'application/json',
+            [KIT_WIRE_HEADER]: String(KIT_WIRE),
             ...(credential === undefined ? {} : { authorization: `Bearer ${credential}` }),
         },
         body: JSON.stringify(body),
         signal,
     });
     const text = await answer.text();
+    if (!answer.ok && tooOld(text))
+        updateRequired(house);
     if (!answer.ok)
         throw new HouseRefusal(path, answer.status, text);
     return JSON.parse(text);
@@ -54,7 +58,7 @@ async function enrolledPost(path, body, signal) {
     }
     catch (error) {
         if (error instanceof HouseRefusal && error.status === 401)
-            end(SIGN_IN_AGAIN);
+            await signInAgain(credential);
         throw error;
     }
 }

package/dist/bootstrap.json

@@ -1,23 +1,23 @@
 {
   "schemaVersion": 2,
-  "version": "0.2.1-c5d36e97b0fea",
+  "version": "0.2.1-c8179f06883b6",
   "hosts": {
     "macos": {
       "asset": {
         "name": "connect-linux.sh",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-c5d36e97b0fea/connect-linux.sh"
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-c8179f06883b6/connect-linux.sh"
       }
     },
     "linux": {
       "asset": {
         "name": "connect-linux.sh",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-c5d36e97b0fea/connect-linux.sh"
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-c8179f06883b6/connect-linux.sh"
       }
     },
     "windows": {
       "asset": {
         "name": "connect-windows.ps1",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-c5d36e97b0fea/connect-windows.ps1"
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-c8179f06883b6/connect-windows.ps1"
       }
     }
   }

package/dist/clis.js

@@ -1,9 +1,13 @@
 import { spawn } from 'node:child_process';
 import { constants, readFileSync } from 'node:fs';
-import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { access, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
 import { homedir, userInfo } from 'node:os';
-import { delimiter, isAbsolute, join } from 'node:path';
+import { delimiter, dirname, isAbsolute, join } from 'node:path';
 import { kitHome } from './home.js';
+const HOUSE_EXECUTABLES = /^host_executable\(name = "house", paths = (\[.*\])\)$/m;
+function houseRule(houses) {
+    return `prefix_rule(pattern = ["house"], decision = "allow")\nhost_executable(name = "house", paths = ${JSON.stringify(houses)})\n`;
+}
 const RAW_SUBTYPES = [
     'background_tasks_changed',
     'task_started',
@@ -13,7 +17,7 @@ const RAW_SUBTYPES = [
     'hook_started',
     'hook_response',
 ];
-async function executable(path) {
+export async function executable(path) {
     try {
         await access(path, constants.X_OK);
         return true;
@@ -22,15 +26,37 @@ async function executable(path) {
         return false;
     }
 }
-async function allowHouseInCodex(path) {
+async function listedHouses(file) {
+    let text;
+    try {
+        text = await readFile(file, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+    try {
+        const listed = JSON.parse(HOUSE_EXECUTABLES.exec(text)?.[1] ?? '[]');
+        return Array.isArray(listed) ? listed.filter((house) => typeof house === 'string') : [];
+    }
+    catch {
+        return [];
+    }
+}
+export async function allowHouseInCodex(path) {
     const candidates = [...new Set(path.split(delimiter).filter((directory) => isAbsolute(directory)))].map((directory) => join(directory, 'house'));
-    const houses = [];
-    for (const candidate of candidates)
-        if (await executable(candidate))
-            houses.push(candidate);
     const rules = join(process.env.CODEX_HOME || join(homedir(), '.codex'), 'rules');
+    const file = join(rules, 'house.rules');
+    const houses = [];
+    for (const house of [...(await listedHouses(file)), ...candidates]) {
+        if (!houses.includes(house) && (await executable(house)))
+            houses.push(house);
+    }
     await mkdir(rules, { recursive: true });
-    await writeFile(join(rules, 'house.rules'), `prefix_rule(pattern = ["house"], decision = "allow")\nhost_executable(name = "house", paths = ${JSON.stringify(houses)})\n`);
+    const temporary = `${file}.${process.pid}`;
+    await writeFile(temporary, houseRule(houses));
+    await rename(temporary, file);
 }
 async function nothing() { }
 function bridgeInClaudeSandbox(bridge) {
@@ -198,6 +224,12 @@ export async function loginPath() {
     const ran = await inLoginShell(`printf "${marker}%s\\n" "$PATH"`);
     return ran.stdout.split('\n').findLast((line) => line.startsWith(marker)).slice(marker.length);
 }
+export async function writeCodexRule() {
+    const shell = await loginPath().catch(() => '');
+    await allowHouseInCodex([dirname(process.execPath), process.env.PATH ?? '', shell].join(delimiter)).catch((error) => {
+        throw new Error(`Codex's rule for house could not be written: ${error.message}`);
+    });
+}
 export async function versionOf(path, signal) {
     return VERSION.exec((await run(path, ['--version'], READ_MS, false, signal)).stdout)?.[0] ?? null;
 }

package/dist/codex.js

@@ -0,0 +1,61 @@
+import { homedir } from 'node:os';
+import { delimiter, join, resolve } from 'node:path';
+import { parseArgs } from 'node:util';
+import { CLIS, executable, writeCodexRule } from './clis.js';
+import { kitHome, readOwnAgent, writeOwnAgent } from './home.js';
+import { accepted, DEFAULT_HOUSE } from './login.js';
+const USAGE = `usage: kit codex [--key <key>] [--house <origin>] [<codex argument>...]
+  --key <key>       a key from New key for a script on Connections, kept for later runs
+  --house <origin>  the House of the key, ${DEFAULT_HOUSE} unless one is stored
+`;
+const VALUED = ['--key', '--house'];
+const KEY_SOURCE = 'New key for a script on Connections';
+function codexArgumentsStart(argv) {
+    let index = 0;
+    while (index < argv.length) {
+        const arg = argv[index];
+        if (VALUED.includes(arg))
+            index += 2;
+        else if (arg === '--help' || VALUED.some((option) => arg.startsWith(`${option}=`)))
+            index += 1;
+        else
+            break;
+    }
+    return index;
+}
+async function onPath(name) {
+    for (const directory of (process.env.PATH ?? '').split(delimiter)) {
+        const path = resolve(directory, name);
+        if (await executable(path))
+            return path;
+    }
+    throw new Error(`${name} is not on your PATH; install it with ${CLIS['codex-acp'].install}`);
+}
+export async function codex(argv) {
+    const start = codexArgumentsStart(argv);
+    const { values } = parseArgs({
+        args: argv.slice(0, start),
+        options: { key: { type: 'string' }, house: { type: 'string' }, help: { type: 'boolean', default: false } },
+    });
+    if (values.help) {
+        process.stdout.write(USAGE);
+        return;
+    }
+    process.env.HOUSE_KIT_HOME = resolve(process.env.HOUSE_KIT_HOME || join(homedir(), '.house-kit-outside'));
+    const stored = await readOwnAgent();
+    if (values.key !== undefined) {
+        const house = values.house ?? stored?.house ?? DEFAULT_HOUSE;
+        if (!(await accepted(house, values.key)))
+            throw new Error(`${house} does not accept this key; pass one from ${KEY_SOURCE}`);
+        await writeOwnAgent({ house, credential: values.key });
+    }
+    else if (values.house !== undefined) {
+        throw new Error('--house names the House of a --key; pass the key with it');
+    }
+    else if (stored === null) {
+        throw new Error(`${kitHome()} holds no House key; pass --key with one from ${KEY_SOURCE}`);
+    }
+    await writeCodexRule();
+    const path = await onPath('codex');
+    process.execve(path, [path, ...argv.slice(start)], process.env);
+}

package/dist/conversations.js

@@ -17,6 +17,7 @@ import { createHowWeWork } from './skills.js';
 import { transcribe } from './transcription.js';
 import { workFor } from './work.js';
 const KILLED = 'the conversation was killed';
+export const CONVERSATION_INPUTS = new Set(['open', 'message', 'interrupt', 'kill', 'option', 'answer']);
 function causeOf(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -132,6 +133,9 @@ export class Conversations {
             return false;
         return !conversations.some((conversation) => conversation.running?.scope.working() || [...conversation.leftovers].some((scope) => scope.working()));
     }
+    quiet() {
+        return this.idle() && [...this.conversations.values()].every((conversation) => conversation.open === 0);
+    }
     look() {
         for (const conversation of this.conversations.values()) {
             for (const scope of conversation.leftovers) {
@@ -499,7 +503,7 @@ export class Conversations {
         if (conversation.turn === turn)
             conversation.turn = null;
         const body = Promise.allSettled(turn.uploads).then(() => ({
-            parts: turn.parts.parts,
+            parts: turn.parts.saved(),
             context: turn.parts.context,
             ...failed,
         }));
@@ -644,7 +648,7 @@ export class Conversations {
                 turn.parts.plan(event.entries);
                 return;
             case 'image':
-                turn.uploads.push(this.image(conversation, turn, event.data, event.mediaType));
+                turn.uploads.push(this.image(conversation, turn, turn.parts.reserve(), event.data, event.mediaType));
                 this.kit.changed();
                 return;
         }
@@ -664,7 +668,7 @@ export class Conversations {
         else
             conversation.turn.parts.start(part);
     }
-    async image(conversation, turn, data, mediaType) {
+    async image(conversation, turn, reserved, data, mediaType) {
         const bytes = Buffer.from(data, 'base64');
         const name = `image-${++turn.images}.${mediaType.split('/')[1]}`;
         try {
@@ -677,10 +681,10 @@ export class Conversations {
             const saved = declared.upload === undefined ? declared : await uploadBytes(declared.upload, bytes);
             if (saved.save.status !== 'saved')
                 throw new Error(saved.save.failure ?? saved.save.status);
-            turn.parts.start({ type: 'image', file: saved.version, name, media_type: mediaType });
+            turn.parts.arrive({ type: 'image', file: saved.version, name, media_type: mediaType }, reserved);
         }
         catch (error) {
-            turn.parts.start({ type: 'marker', marker: 'retry', text: `${name} was not saved: ${causeOf(error)}` });
+            turn.parts.arrive({ type: 'marker', marker: 'retry', text: `${name} was not saved: ${causeOf(error)}` }, reserved);
         }
     }
 }

package/dist/copies.js

@@ -42,7 +42,7 @@ function expiredAuthority(error) {
         return undefined;
     try {
         const { error: refused } = JSON.parse(error.text);
-        return refused?.code === 'position_expired' && typeof refused.authority === 'string' ? refused.authority : undefined;
+        return refused?.code === 'expired' && typeof refused.authority === 'string' ? refused.authority : undefined;
     }
     catch {
         return undefined;
@@ -168,7 +168,7 @@ export class LocalCopies {
     house;
     copies = new Map();
     queues = new Map();
-    selecting = Promise.resolve();
+    answering = Promise.resolve();
     constructor(house) {
         this.house = house;
         this.owner = {
@@ -200,39 +200,39 @@ export class LocalCopies {
         }
     }
     async mapping() {
-        await this.selecting;
+        await this.answering;
         return [...this.copies.values()]
             .filter((copy) => copy.active)
             .map((copy) => `${rootOf(copy.room_handle)}: ${copy.repository}`)
             .sort();
     }
-    async select() {
-        const selected = await this.selected(() => this.fetched(false));
-        if (selected.refused)
-            logged(selected.text);
+    async connected() {
+        const copied = await this.answered(() => this.fetched(false));
+        if (copied.refused)
+            logged(copied.text);
     }
     fetch() {
-        return this.selected(() => this.fetched(true));
+        return this.answered(() => this.fetched(true));
     }
-    selected(work) {
-        const selected = this.selecting.then(work);
-        this.selecting = selected.catch(() => undefined);
-        return selected;
+    answered(work) {
+        const answered = this.answering.then(work);
+        this.answering = answered.catch(() => undefined);
+        return answered;
     }
     async fetched(refreshing) {
-        const { local_copy: chosen } = await this.house.post('/kit/local-copy/selection', {});
-        const selected = new Map(chosen.rooms.map((room) => [`rooms/${room.room_ref}`, room.room_handle]));
-        return this.holding([...new Set([...this.copies.keys(), ...selected.keys()])].sort(), async () => {
+        const { local_copy: answer } = await this.house.post('/kit/local-copy/selection', {});
+        const synced = new Map(answer.rooms.map((room) => [`rooms/${room.room_ref}`, room.room_handle]));
+        return this.holding([...new Set([...this.copies.keys(), ...synced.keys()])].sort(), async () => {
             const said = [];
             let refused = false;
             for (const copy of this.copies.values()) {
-                if (selected.has(copy.key) || !copy.active)
+                if (synced.has(copy.key) || !copy.active)
                     continue;
                 await this.save({ ...copy, active: false });
                 said.push(`${rootOf(copy.room_handle)}: no longer synced to this Environment; its files stay`);
             }
             const current = [];
-            for (const [key, handle] of selected) {
+            for (const [key, handle] of synced) {
                 try {
                     const held = this.copies.get(key);
                     if (held === undefined || !(await exists(held.repository))) {
@@ -623,7 +623,7 @@ export class LocalCopies {
                 const { upload, ...unstaged } = copy.push;
                 return this.settle(await this.save({ ...copy, push: unstaged }), caller, true);
             }
-            if (outcome.refused.code === 'operation_expired')
+            if (outcome.refused.code === 'expired')
                 return this.recovered(copy);
             const rebased = rebaseFixes(outcome.refused);
             let settled = await this.save(without(copy));

package/dist/end.js

@@ -1,8 +1,22 @@
+import { forgetRejected } from './home.js';
+import { installCommand } from './placement.js';
 import { killDescendants } from './scope.js';
 export const REPLACED = 'another Kit started for this Environment';
-export const SIGN_IN_AGAIN = 'sign in again';
-export function end(reason) {
+function exit(reason, status) {
     process.stderr.write(`kit: ${reason}\n`);
     killDescendants();
-    process.exit(0);
+    process.exit(status);
+}
+export function end(reason) {
+    exit(reason, 0);
+}
+export function restart(reason) {
+    exit(reason, 1);
+}
+export function updateRequired(house) {
+    end(`This Kit is too old for House. Update it: ${installCommand(house)}`);
+}
+export async function signInAgain(rejected) {
+    await forgetRejected(rejected);
+    restart('sign in again');
 }

package/dist/enrol-main.js

@@ -1,4 +1,10 @@
 import { readFileSync } from 'node:fs';
 import { writeEnrolment } from './home.js';
 const [house, environment] = process.argv.slice(2);
-await writeEnrolment({ house: house, environment: environment, credential: readFileSync(0, 'utf8').trim() });
+const relay = process.env.HOUSE_KIT_RELAY || undefined;
+await writeEnrolment({
+    house: house,
+    ...(relay === undefined ? {} : { relay }),
+    environment: environment,
+    credential: readFileSync(0, 'utf8').trim(),
+});

package/dist/home.js

@@ -1,11 +1,13 @@
-import { existsSync } from 'node:fs';
+import { existsSync, linkSync, readFileSync, 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 { 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';
 export function kitHome() {
     return process.env.HOUSE_KIT_HOME ?? join(homedir(), '.house-kit');
 }
@@ -32,8 +34,11 @@ export async function writeHome(name, value) {
     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);
@@ -46,9 +51,42 @@ 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);
 }