@agentshouse/kit 0.2.1-cf6326dfa5c3e → 0.2.1-cf6a92e13f031

package/README.md

@@ -1,33 +1,33 @@
-# House Kit
+# Kit
 
-House Kit connects an Environment, a Linux computer or server, to [agents.house](https://agents.house). It runs
+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 `sh -c 'kit=$(curl -fsSL "$0") || { echo "House Kit could not be downloaded; run this command again." >&2; exit 1; }; eval "$kit"' agents.house/kit`,
-or `& { try { $kit = irm agents.house/kit.ps1 } catch { throw 'House Kit could not be downloaded; run this command again.' }; & ([scriptblock]::Create($kit)) @args }` on Windows, which run nothing of a failed download, and again to update; options follow `agents.house/kit`.
-On macOS and Linux it installs House Kit natively under your own account, without an admin password, as a service that runs
+Run `sh -c 'kit=$(curl -fsSL "$0") || { echo "Kit could not be downloaded; run this command again." >&2; exit 1; }; eval "$kit"' agents.house/kit`,
+or `& { try { $kit = irm agents.house/kit.ps1 } catch { throw 'Kit could not be downloaded; run this command again.' }; & ([scriptblock]::Create($kit)) @args }` on Windows, which run nothing of a failed download, and again to update; options follow `agents.house/kit`.
+On macOS and Linux it installs 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>`.
 
-Add `--container` to run House Kit in one Docker container instead, with your
+Add `--container` to run Kit in one Docker container instead, with your
 workspace mounted at `/agents/house`; your Agents then reach only that
 workspace. On Windows 11 the container is the one choice. Append a `kit` or `house` command to the container's options to run it in that container.
 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. Running it with another `HOUSE_KIT_HOME`
-than the installed Kit's asks you to confirm before it replaces that Kit, and leaves that Kit home as it was.
+confirm, then replaces its Environment, whose Agents end, with a new one. Running it with a different `HOUSE_KIT_HOME`
+from the running Kit process asks you to confirm before it replaces that process, and leaves the earlier Kit home as it was.
 
 On your own Linux server, run the Linux command with `--linux` to
-install House Kit natively, with its workspace at `/agents/house`; `kit` and
+install Kit natively, with its workspace at `/agents/house`; `kit` and
 `house` are then on the server's `PATH`.
 
-House Kit runs the agent CLIs your login shell finds and installs a missing one
+Kit runs the agent CLIs your login shell finds and installs a missing one
 through that CLI's own installer. Running the command again offers to update
-each CLI older than House Kit needs; add `--update-clis` to update every one to
-its latest release without asking. House Kit also gives every Agent on the
-Environment a set of agent skills. Add `--no-skills` to the command to leave
-them out; running it again without the flag brings them back.
+each CLI older than Kit needs; add `--update-clis` to update every one to
+its latest release without asking. Kit also gives every Agent on the
+Environment the agent skills of `@agentshouse/skills`, at the version each Kit
+release installs. Add `--no-skills` to the command to leave them out; running it again without the flag brings them back.
 
 ## Commands
 
@@ -40,21 +40,21 @@ A login also connects your own agent: outside an Agent conversation, `house <too
 House as you and `git` clones and pushes your Apps at `<house>/app/` as you, each through the Kit
 home `$HOUSE_KIT_HOME` names where it runs, 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
+computer, stops the Kit process 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, or connects
 this computer as a new one when House no longer holds it.
 In a container you do not control, such as ChatGPT's, `npm i -g @agentshouse/kit` and `kit chatgpt --key <key>` with a key made on Connections let `house <tool>` act as you, starting and configuring nothing else.
 
 `kit resident` keeps the Environment connected and, as it connects, copies the text of each Room you chose for it as a
-Git repository in the workspace's `local-copies`, and erases a Room's copy, unpushed commits included, once the Room
-may no longer be copied here. `house fetch` does the same and records House's changes on each copy's
+Git repository in the workspace's `local-copies`, and keeps a Room's copy as it is, no longer refreshing it, once the
+Room may no longer be copied here. `house fetch` does the same and 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 upload` and `house download` move a Room's other files.
+the container. An Agent runs both, without `--owner`. `house upload` and `house download` move a Room's other files straight between disk and House's store, and a broken upload resumes on its own.
 
-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
-engine and model use about 425 MB beside the Environment's credential; turning it off deletes them.
+Kit turns each audio file your message to an Agent links into text on this computer before the Agent reads it, and keeps a message whose audio it cannot turn into text from starting. While transcription is on, the speech engine and model use about 425 MB beside the Environment's credential; turning it off deletes them.
+
+When you press Run on a Web Wizard's page, Kit runs its script with `bash` in a terminal on this computer, as you, in the home and directory it runs agent CLIs from, with your login shell's `PATH`; the page shows that terminal and takes your typing, and closing the page, or Kit losing its connection to House, ends the script and its child processes. Kit keeps nothing the script prints or you type.
 
 ## License
 
-MIT. The skills come from [mattpocock/skills](https://github.com/mattpocock/skills); thank you, Matt Pocock.
+MIT.

package/dist/acp.js

@@ -1,7 +1,7 @@
 import { ndJsonStream, PROTOCOL_VERSION, } from '@agentclientprotocol/sdk';
 import { spawn } from 'node:child_process';
 import { Readable, Writable } from 'node:stream';
-import { CLIS, KIT_VERSION, adapterCommand, withoutProxy } from './clis.js';
+import { CLIS, KIT_RELEASE, adapterCommand, withoutProxy } from './clis.js';
 import { killTree } from './scope.js';
 const RETIRED = 'the CLI was retired';
 export async function startAdapter(kind, cli, cwd, app, events = () => undefined, added = {}, signal, scope = null) {
@@ -71,7 +71,7 @@ export async function startAdapter(kind, cli, cwd, app, events = () => undefined
                 session: { compaction: {}, notices: {} },
                 _meta: { jetbrains: { air: { version: 1, capabilities: CLIS[kind].air } } },
             },
-            clientInfo: { name: '@agentshouse/kit', version: KIT_VERSION },
+            clientInfo: { name: '@agentshouse/kit', version: KIT_RELEASE },
         });
         scope?.entered(child.pid);
         return { connection, initialized, exited, lost, retire };

package/dist/agents.js

@@ -2,7 +2,7 @@ import { client } from '@agentclientprotocol/sdk';
 import { readFile, realpath } from 'node:fs/promises';
 import { setTimeout as delay } from 'node:timers/promises';
 import { startAdapter } from './acp.js';
-import { CLIS, KIT_VERSION, below, installAdapter, installCli, locate, run, versionOf } from './clis.js';
+import { CLIS, KIT_RELEASE, below, installAdapter, installCli, locate, run, versionOf } from './clis.js';
 import { agentBase, kitHome } from './home.js';
 import { updatesItself } from './placement.js';
 import { holdTranscription, transcriptionReport } from './transcription.js';
@@ -354,7 +354,7 @@ export class Agents {
         const body = {
             os: await operatingSystem(),
             ...(form === undefined ? {} : { form }),
-            kit_version: KIT_VERSION,
+            kit_release: KIT_RELEASE,
             wire: KIT_WIRE,
             updates_itself: await updatesItself(),
             agent_base: agentBase(),

package/dist/api.js

@@ -1,9 +1,9 @@
 import { setTimeout as delay } from 'node:timers/promises';
-import { signInAgain, updateRequired } from './end.js';
+import { signInAgain } 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';
+import { endUnserved, KIT_WIRE, KIT_WIRE_HEADER } from './wire.js';
 export class HouseRefusal extends Error {
     status;
     text;
@@ -17,7 +17,7 @@ export function finalRefusal(error) {
     return error instanceof HouseRefusal && retryable(error.text) === false;
 }
 export function retryDelay(attempt) {
-    // Full jitter, doubling from one second to a 30-second cap, spreads the Kits one outage dropped and retries within half a minute of House's return.
+    // Full jitter, doubling from one second to a 30-second cap, spreads the Kit processes one outage dropped and retries within half a minute of House's return.
     return Math.random() * Math.min(30_000, 1000 * 2 ** attempt);
 }
 export async function retrying(sent, signal, pause = retryDelay) {
@@ -45,8 +45,8 @@ export async function post(house, path, body, credential, signal) {
         signal,
     });
     const text = await answer.text();
-    if (!answer.ok && tooOld(text))
-        updateRequired();
+    if (!answer.ok)
+        endUnserved(text);
     if (!answer.ok)
         throw new HouseRefusal(path, answer.status, text);
     return JSON.parse(text);

package/dist/bootstrap.json

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

package/dist/bridge.js

@@ -13,7 +13,7 @@ import { callHouse, mcpBody, rpc, UNREACHABLE } from './mcp.js';
 import { operationId } from './operation.js';
 import { refusalOf, retryable } from './refusals.js';
 import { relayed } from './relay.js';
-const MCP_REQUEST_BYTES = 4 * 1024 * 1024;
+const MCP_REQUEST_BYTES = 4_000_000;
 export async function received(request) {
     let text = '';
     request.setEncoding('utf8');

package/dist/{inputs.js → calls.js}

@@ -4,50 +4,50 @@ import { kitHome } from './home.js';
 function logged(error) {
     process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
 }
-export class Inputs {
+export class Calls {
     house;
     changed;
     carried = new Map();
-    path = join(kitHome(), 'handed-inputs.json');
-    handed;
-    answered = new Set();
+    path = join(kitHome(), 'call-results.json');
+    results;
+    returned = new Set();
     open = 0;
     constructor(house, changed) {
         this.house = house;
         this.changed = changed;
-        this.handed = new Map(existsSync(this.path) ? Object.entries(JSON.parse(readFileSync(this.path, 'utf8'))) : []);
+        this.results = new Map(existsSync(this.path) ? Object.entries(JSON.parse(readFileSync(this.path, 'utf8'))) : []);
     }
-    hands(inputId, ack) {
-        if (this.answered.has(inputId))
+    keepResult(callId, result) {
+        if (this.returned.has(callId))
             return;
-        this.handed.set(inputId, ack);
+        this.results.set(callId, result);
         this.save();
     }
     idle() {
         return this.open === 0;
     }
-    carry(inputId, work) {
-        const known = this.carried.get(inputId);
-        const handed = this.handed.get(inputId);
-        const carried = known ?? (handed === undefined ? work() : Promise.resolve({ ack: handed }));
+    carry(callId, work) {
+        const known = this.carried.get(callId);
+        const result = this.results.get(callId);
+        const carried = known ?? (result === undefined ? work() : Promise.resolve({ result }));
         if (known === undefined) {
-            this.carried.set(inputId, carried);
-            carried.catch(() => this.carried.delete(inputId));
+            this.carried.set(callId, carried);
+            carried.catch(() => this.carried.delete(callId));
         }
         this.open++;
         this.changed();
         return carried
-            .then(async ({ ack, acknowledged }) => {
+            .then(async ({ result, returned }) => {
             try {
-                await this.house.deliver(`/kit/inputs/${inputId}/ack`, ack);
+                await this.house.deliver(`/kit/inputs/${callId}/ack`, result);
             }
             finally {
-                this.answered.add(inputId);
-                if (this.handed.delete(inputId))
+                this.returned.add(callId);
+                if (this.results.delete(callId))
                     this.save();
             }
             if (known === undefined)
-                await acknowledged?.();
+                await returned?.();
         })
             .catch(logged)
             .finally(() => {
@@ -57,7 +57,7 @@ export class Inputs {
     }
     save() {
         const temporary = `${this.path}.${process.pid}`;
-        writeFileSync(temporary, JSON.stringify(Object.fromEntries(this.handed)), { mode: 0o600 });
+        writeFileSync(temporary, JSON.stringify(Object.fromEntries(this.results)), { mode: 0o600 });
         renameSync(temporary, this.path);
     }
 }

package/dist/clis.js

@@ -137,7 +137,7 @@ export const CLIS = {
     },
 };
 const KIT_PACKAGE = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
-export const KIT_VERSION = KIT_PACKAGE.version;
+export const KIT_RELEASE = KIT_PACKAGE.version;
 const PROXY = /^https?_proxy$/i;
 const VERSION = /\d+\.\d+\.\d+(?:-[0-9A-Za-z.]+)?/;
 // An install still running after fifteen minutes is ended and reported as failed, so a hung download cannot hold its CLI's report.
@@ -225,10 +225,13 @@ const USER_BIN = 'case ":$PATH:" in *":$HOME/.local/bin:"*) ;; *) PATH="$PATH:$H
 function inLoginShell(script, argument = '', signal) {
     return run(loginShell(), ['-l', '-i', '-c', `exec /bin/sh -c '${USER_BIN}; ${script}' sh ${argument}`], READ_MS, true, signal);
 }
-export async function locate(kind, signal) {
-    const ran = await inLoginShell(LOOKUP, CLIS[kind].bin, signal);
+export async function onLoginPath(program, signal) {
+    const ran = await inLoginShell(LOOKUP, program, signal);
     return ran.stdout.split('\n').findLast((line) => line.startsWith(FOUND))?.slice(FOUND.length) ?? null;
 }
+export function locate(kind, signal) {
+    return onLoginPath(CLIS[kind].bin, signal);
+}
 export async function loginPath() {
     const marker = 'house-kit-path ';
     const ran = await inLoginShell(`printf "${marker}%s\\n" "$PATH"`);

package/dist/{stream.js → connection.js}

@@ -1,24 +1,24 @@
 import { subscribe } from 'node:diagnostics_channel';
 import { HouseRefusal, retryDelay } from './api.js';
-import { end, REPLACED, signInAgain, updateRequired } from './end.js';
+import { end, REPLACED, signInAgain } from './end.js';
 import { readEnrolment } from './home.js';
 import { relayed } from './relay.js';
-import { KIT_WIRE, tooOld } from './wire.js';
+import { endUnserved, KIT_WIRE } from './wire.js';
 const PATH = '/kit/stream';
 const SUBPROTOCOL = `house.kit.stream.${KIT_WIRE}`;
 const REFUSAL_HEADER = 'x-house-refusal';
-// House beats each stream every thirty seconds, so two silent beats mean this Kit cannot hear House.
-export const STREAM_SILENCE_MS = 60_000;
-const SYSTEM_STREAM_CLOCK = {
+// House beats each Kit connection every thirty seconds, so two silent beats mean this Kit process cannot hear House.
+export const CONNECTION_SILENCE_MS = 60_000;
+const SYSTEM_CONNECTION_CLOCK = {
     later: (delay, callback) => setTimeout(callback, delay),
     clear: (timer) => clearTimeout(timer),
 };
-export class StreamSilence {
+export class ConnectionSilence {
     timer = null;
     silent;
     clock;
     interval;
-    constructor(silent, clock = SYSTEM_STREAM_CLOCK, interval = STREAM_SILENCE_MS) {
+    constructor(silent, clock = SYSTEM_CONNECTION_CLOCK, interval = CONNECTION_SILENCE_MS) {
         this.silent = silent;
         this.clock = clock;
         this.interval = interval;
@@ -37,7 +37,7 @@ export class StreamSilence {
         this.timer = null;
     }
 }
-function streamUrl(house) {
+function connectionUrl(house) {
     const url = new URL(PATH, house);
     url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
     return url;
@@ -56,13 +56,13 @@ subscribe('undici:request:headers', (message) => {
         return;
     refused = new HouseRefusal(PATH, response.statusCode, header(response.headers, REFUSAL_HEADER) || response.statusText);
 });
-export function holdStream(handlers) {
-    let socket = null;
+export function holdConnection(handlers) {
+    let connection = null;
     let failures = 0;
     const connect = async () => {
         const { house, credential } = (await readEnrolment());
         refused = null;
-        const opening = new WebSocket(relayed(streamUrl(house)), {
+        const opening = new WebSocket(relayed(connectionUrl(house)), {
             protocols: [SUBPROTOCOL],
             headers: { authorization: `Bearer ${credential}` },
         });
@@ -71,30 +71,31 @@ export function holdStream(handlers) {
         const closed = (event) => {
             silence?.stop();
             silence = null;
-            if (socket === opening)
-                socket = null;
-            process.stderr.write(`kit: control stream closed ${event.code} ${event.reason}\n`);
+            if (connection === opening)
+                connection = null;
+            handlers.closed();
+            process.stderr.write(`kit: connection closed ${event.code} ${event.reason}\n`);
             if (event.reason === 'replaced')
                 end(REPLACED);
             if (event.reason === 'credential_rejected' || refused?.status === 401) {
                 void signInAgain(credential);
                 return;
             }
-            if (refused !== null && tooOld(refused.text))
-                updateRequired();
+            if (refused !== null)
+                endUnserved(refused.text);
             if (!opened && refused !== null)
                 process.stderr.write(`kit: ${refused.message}\n`);
-            // A closed socket reopens in one to three seconds, spread so Kits one restart closed return apart; an opening House refused or left unanswered backs off on the jittered curve, retryable or not, since a resident outlives a House deploy.
+            // A closed connection reopens in one to three seconds, spread so Kit processes one restart closed return apart; an opening House refused or left unanswered backs off on the jittered curve, retryable or not, since a resident outlives a House deploy.
             setTimeout(() => void connect(), opened ? 1000 + Math.random() * 2000 : retryDelay(failures++));
         };
         opening.onopen = () => {
             opened = true;
             failures = 0;
-            socket = opening;
-            silence = new StreamSilence(() => {
-                if (socket !== opening)
+            connection = opening;
+            silence = new ConnectionSilence(() => {
+                if (connection !== opening)
                     return;
-                socket = null;
+                connection = null;
                 opening.onclose = null;
                 opening.close();
                 closed(new CloseEvent('close', { code: 1006, reason: 'heartbeat_missed' }));
@@ -104,19 +105,21 @@ export function holdStream(handlers) {
         };
         opening.onmessage = (event) => {
             silence?.heard();
-            const frame = JSON.parse(String(event.data));
-            if (frame.type !== 'beat')
-                handlers.frame(frame);
+            const arrived = JSON.parse(String(event.data));
+            if (arrived.type === 'input')
+                handlers.call(arrived);
+            else if (arrived.type !== 'beat')
+                handlers.notification(arrived);
         };
         opening.onerror = () => undefined;
         opening.onclose = closed;
     };
     void connect();
     return {
-        send(frame) {
-            if (socket === null || socket.readyState !== WebSocket.OPEN)
+        send(notification) {
+            if (connection === null || connection.readyState !== WebSocket.OPEN)
                 return false;
-            socket.send(JSON.stringify(frame));
+            connection.send(JSON.stringify(notification));
             return true;
         },
     };