@agentshouse/kit 0.2.1-alpha.2 → 0.2.1-alpha.21

package/README.md

@@ -7,17 +7,53 @@ through the agent CLIs you chose and gives each Agent the `house` command.
 ## Install
 
 Connect a computer from agents.house. It gives you the one command that
-installs House Kit on that computer and updates it when you run it again.
+installs House Kit on that computer and updates it when you run it again. 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>`.
+
+Add `--container` to run House 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 command 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.
+
+On your own Ubuntu 26.04 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`.
+
+House 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.
 
 ## Commands
 
 `kit login` opens a link you confirm in your browser and keeps the
 Environment's credential in `~/.house-kit`, or in `$HOUSE_KIT_HOME` when it is
 set. Pass `--manual` to paste the code by hand on a machine without a browser,
-and `--environment <id>` to reconnect an Environment you already have.
+and `--environment <id>` to reconnect an Environment you already have. It also
+connects your own agent: `house <tool>` run outside an Agent conversation calls
+House as you, until you revoke that connection on Connections.
 
-`kit resident` keeps the Environment connected.
+`kit resident` keeps the Environment connected, and keeps the Rooms you chose
+for this Environment as Git repositories under `working-copies` in the
+workspace. Commit in one and run `house git push --owner` there to send the
+commit to House; in the container, run it through the install command from the
+copy's directory. Inside an Agent conversation the Agent runs `house git push`.
+
+House Kit turns each audio file of your message to an Agent into text on this
+computer before the Agent reads the message. The first audio file downloads the
+speech engine and model, about 425 MB, into `~/.house-kit`.
 
 ## License
 
 MIT
+
+The skills come from [mattpocock/skills](https://github.com/mattpocock/skills); thank you, Matt Pocock.

package/dist/abort.js

@@ -0,0 +1,9 @@
+export function unlessAborted(work, signal) {
+    return new Promise((resolve, reject) => {
+        const aborted = () => reject(signal.reason);
+        signal.addEventListener('abort', aborted, { once: true });
+        if (signal.aborted)
+            aborted();
+        work.then(resolve, reject).finally(() => signal.removeEventListener('abort', aborted));
+    });
+}

package/dist/acp.js

@@ -1,14 +1,15 @@
 import { ndJsonStream, PROTOCOL_VERSION, } from '@agentclientprotocol/sdk';
-import { spawn } from 'node:child_process';
+import { execFileSync, spawn } from 'node:child_process';
 import { readdirSync, readFileSync } from 'node:fs';
 import { Readable, Writable } from 'node:stream';
-import { CLIS, KIT_VERSION, cliCommand } from './clis.js';
+import { CLIS, KIT_VERSION, adapterCommand, withoutProxy } from './clis.js';
 export const TURN_STARTED = 'kit/turn_started';
 export const TURN_ENDED = 'kit/turn_ended';
-export async function startAdapter(kind, cwd, app, jobs = () => undefined, env = process.env) {
-    const child = spawn(cliCommand(kind), CLIS[kind].args, {
+export async function startAdapter(kind, cli, cwd, app, jobs = () => undefined, added = {}) {
+    const adapter = CLIS[kind].adapter;
+    const child = spawn(adapter === null ? cli : adapterCommand(kind), CLIS[kind].args, {
         cwd,
-        env,
+        env: { ...withoutProxy(), ...(adapter === null ? {} : { ...adapter.env, [adapter.executable]: cli }), ...added },
         stdio: ['pipe', 'pipe', 'pipe'],
         detached: true,
     });
@@ -60,15 +61,29 @@ export async function startAdapter(kind, cwd, app, jobs = () => undefined, env =
         throw error;
     }
 }
+const LISTING_BYTES = 1 << 28;
+function listed(options) {
+    return execFileSync('ps', [options, '-o', 'pid=,ppid=,command='], { encoding: 'utf8', maxBuffer: LISTING_BYTES })
+        .split('\n')
+        .flatMap((line) => {
+        const fields = /^\s*(\d+)\s+(\d+)\s?(.*)$/.exec(line);
+        return fields === null ? [] : [[Number(fields[1]), Number(fields[2]), fields[3]]];
+    });
+}
 function parents() {
     const children = new Map();
+    const adopt = (pid, parent) => children.set(parent, [...(children.get(parent) ?? []), pid]);
+    if (process.platform === 'darwin') {
+        for (const [pid, parent] of listed('-Aww'))
+            adopt(pid, parent);
+        return children;
+    }
     for (const entry of readdirSync('/proc')) {
         if (!/^\d+$/.test(entry))
             continue;
         try {
             const stat = readFileSync(`/proc/${entry}/stat`, 'utf8');
-            const parent = Number(stat.slice(stat.lastIndexOf(')') + 2).split(' ')[1]);
-            children.set(parent, [...(children.get(parent) ?? []), Number(entry)]);
+            adopt(Number(entry), Number(stat.slice(stat.lastIndexOf(')') + 2).split(' ')[1]));
         }
         catch { }
     }
@@ -96,6 +111,11 @@ function killAll(pids) {
     }
 }
 function marked(marker) {
+    if (process.platform === 'darwin') {
+        return listed('-AEww')
+            .filter(([, , command]) => ` ${command} `.includes(` ${marker} `))
+            .map(([pid]) => pid);
+    }
     return readdirSync('/proc')
         .filter((entry) => {
         try {

package/dist/agents.js

@@ -1,24 +1,90 @@
 import { client } from '@agentclientprotocol/sdk';
-import { readFile } from 'node:fs/promises';
-import { startAdapter } from './acp.js';
-import { CLIS, KIT_VERSION, cliCommand, install, run } from './clis.js';
-import { kitHome } from './home.js';
-async function signedIn(kind) {
-    const probe = CLIS[kind].signedIn;
-    if ('command' in probe) {
-        return (await run(cliCommand(kind), probe.command, 30_000)).status === 0;
+import { readFile, realpath } from 'node:fs/promises';
+import { killTree, startAdapter } from './acp.js';
+import { CLIS, KIT_VERSION, below, installAdapter, installCli, locate, run, versionOf } from './clis.js';
+import { agentBase, kitHome } from './home.js';
+const SIGNED_OUT = { signed_in: false, models: [] };
+function select(options, category) {
+    const option = options.find((candidate) => candidate.category === category);
+    return option?.type === 'select' ? option : undefined;
+}
+function values(options) {
+    return options.flatMap((entry) => ('group' in entry ? entry.options : [entry])).map((entry) => entry.value);
+}
+function causeOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function logged(error) {
+    process.stderr.write(`kit: ${causeOf(error)}\n`);
+}
+async function models(kind, adapter, known) {
+    const agent = adapter.connection.agent;
+    const opened = await agent.request('session/new', { cwd: kitHome(), mcpServers: [] });
+    let options = opened.configOptions ?? [];
+    const model = select(options, 'model');
+    if (model === undefined)
+        return [];
+    const offered = [];
+    for (const value of values(model.options)) {
+        if (select(options, 'model')?.currentValue !== value) {
+            try {
+                options = (await agent.request('session/set_config_option', { sessionId: opened.sessionId, configId: model.id, value })).configOptions;
+            }
+            catch (error) {
+                process.stderr.write(`kit: ${kind} refused its model ${value}: ${causeOf(error)}\n`);
+                offered.push({ model: value, efforts: known.find((entry) => entry.model === value)?.efforts ?? [] });
+                continue;
+            }
+        }
+        const effort = select(options, 'thought_level');
+        offered.push({ model: value, efforts: effort === undefined ? [] : values(effort.options) });
     }
+    return offered;
+}
+async function offer(kind, cli, known) {
+    const probe = CLIS[kind].signedIn;
+    if ('command' in probe && (await run(cli, probe.command, 30_000)).status !== 0)
+        return SIGNED_OUT;
+    let adapter;
     try {
-        const adapter = await startAdapter(kind, kitHome(), client({ name: '@agentshouse/kit' }));
-        adapter.child.kill('SIGKILL');
-        const method = adapter.initialized._meta?.[probe.initializeMeta];
-        return typeof method === 'string' && method.length > 0;
+        adapter = await startAdapter(kind, cli, kitHome(), client({ name: '@agentshouse/kit' }));
+        if ('initializeMeta' in probe) {
+            const method = adapter.initialized._meta?.[probe.initializeMeta];
+            if (typeof method !== 'string' || method.length === 0)
+                return SIGNED_OUT;
+        }
+        return { signed_in: true, models: await models(kind, adapter, known.models) };
     }
-    catch {
-        return false;
+    catch (error) {
+        process.stderr.write(`kit: ${kind} did not offer its models: ${causeOf(error)}\n`);
+        return { signed_in: adapter === undefined && 'initializeMeta' in probe ? known.signed_in : true, models: known.models };
     }
+    finally {
+        if (adapter !== undefined)
+            killTree(adapter.child);
+    }
+}
+function reported(kind, reading) {
+    return {
+        kind,
+        release: reading.release,
+        ...(reading.minimum === undefined ? {} : { minimum: reading.minimum }),
+        failure: reading.failure,
+        signed_in: reading.signed_in,
+        models: reading.models,
+    };
+}
+function tooOld(kind, release) {
+    const cli = CLIS[kind];
+    return `${cli.bin} ${release} is older than ${cli.minimum}, the oldest this Kit runs`;
+}
+async function sshHostKey() {
+    const listed = await run('ssh-keygen', ['-l', '-E', 'sha256', '-f', '/etc/ssh/ssh_host_ed25519_key.pub'], 10_000);
+    return listed.status === 0 ? (/^\d+ (SHA256:\S+)/.exec(listed.output)?.[1] ?? null) : null;
 }
 async function operatingSystem() {
+    if (process.platform === 'darwin')
+        return `macOS ${(await run('sw_vers', ['-productVersion'], 10_000)).output.trim()}`;
     const release = await readFile('/etc/os-release', 'utf8');
     return /^PRETTY_NAME="?([^"\n]*)"?$/m.exec(release)?.[1] ?? release;
 }
@@ -26,19 +92,18 @@ export class Agents {
     desired = { agents: [], routes: [] };
     house;
     reading = Promise.resolve();
+    queues = new Map();
     installing = Promise.resolve();
-    releases = new Map();
-    reporting = null;
-    again = false;
+    readings = new Map();
+    reads = new Map();
+    sending = Promise.resolve();
+    sent = null;
     constructor(house) {
         this.house = house;
     }
     read() {
         return this.reading.then(() => undefined, () => undefined);
     }
-    installed() {
-        return this.installing.catch(() => undefined);
-    }
     route(agentId) {
         return this.desired.routes.find((route) => route.agent_id === agentId);
     }
@@ -48,43 +113,130 @@ export class Agents {
             return this.desired;
         });
         this.reading = reading;
-        const installing = this.installed()
-            .then(() => reading)
-            .then(({ agents }) => this.install(agents));
-        this.installing = installing;
-        if (this.reporting === null)
-            this.reporting = this.reports();
-        else
-            this.again = true;
-        return Promise.all([installing, this.reporting]).then(() => undefined);
-    }
-    async report() {
-        const agents = [];
-        for (const [kind, release] of this.releases) {
-            agents.push({ kind, release, signed_in: release !== null && (await signedIn(kind)) });
-        }
-        await this.house.deliver('/kit/agents/report', {
-            os: await operatingSystem(),
-            kit_version: KIT_VERSION,
-            agents,
+        return reading.then(({ agents }) => {
+            Promise.all(agents.map((kind) => this.queue(kind, () => this.load(kind))))
+                .then(() => this.report())
+                .catch(logged);
+        });
+    }
+    cli(kind) {
+        return this.queue(kind, async () => {
+            const resolved = await this.resolve(kind);
+            if (!('cli' in resolved)) {
+                this.update(kind, resolved);
+                throw new Error(resolved.failure ?? tooOld(kind, resolved.release));
+            }
+            const { cli, release } = resolved;
+            const known = this.readings.get(kind);
+            const kept = known?.release === null || known?.minimum !== undefined ? SIGNED_OUT : (known ?? SIGNED_OUT);
+            if (known?.release !== release || known.minimum !== undefined) {
+                this.update(kind, { release, failure: null, signed_in: kept.signed_in, models: kept.models });
+            }
+            const read = this.nextRead(kind);
+            offer(kind, cli, kept)
+                .then((offered) => {
+                const current = this.readings.get(kind);
+                if (this.reads.get(kind) === read && current?.release === release)
+                    this.update(kind, { ...current, ...offered });
+            })
+                .catch(logged);
+            return cli;
         });
     }
-    async install(kinds) {
-        const releases = new Map();
-        for (const kind of kinds)
-            releases.set(kind, await install(kind));
-        this.releases = releases;
+    located(kind) {
+        return this.queue(kind, () => this.ensure(kind));
+    }
+    async reread(kind) {
+        await this.queue(kind, async () => {
+            this.nextRead(kind);
+            this.readings.set(kind, await this.examine(kind, this.readings.get(kind) ?? SIGNED_OUT));
+        });
+        await this.report();
+    }
+    report() {
+        const sending = this.sending.catch(() => undefined).then(() => this.send());
+        this.sending = sending;
+        return sending;
+    }
+    nextRead(kind) {
+        const read = (this.reads.get(kind) ?? 0) + 1;
+        this.reads.set(kind, read);
+        return read;
+    }
+    update(kind, reading) {
+        this.readings.set(kind, reading);
+        this.report().catch(logged);
+    }
+    queue(kind, work) {
+        const queued = (this.queues.get(kind) ?? Promise.resolve()).then(work);
+        this.queues.set(kind, queued.catch(() => undefined));
+        return queued;
     }
-    async reports() {
+    async ensure(kind) {
+        const failed = await installAdapter(kind);
+        if (failed !== null)
+            throw new Error(failed);
+        const found = await locate(kind);
+        if (found !== null)
+            return found;
+        const installing = this.installing.catch(() => undefined).then(() => installCli(kind));
+        this.installing = installing;
+        const failure = await installing;
+        if (failure !== null)
+            throw new Error(failure);
+        const installed = await locate(kind);
+        if (installed === null)
+            throw new Error(`the login shell does not find ${CLIS[kind].bin} after its install`);
+        return installed;
+    }
+    async resolve(kind) {
+        let cli;
         try {
-            do {
-                this.again = false;
-                await this.installing;
-                await this.report();
-            } while (this.again);
+            cli = await realpath(await this.ensure(kind));
         }
-        finally {
-            this.reporting = null;
+        catch (error) {
+            const failure = causeOf(error);
+            process.stderr.write(`kit: ${kind} did not install: ${failure}\n`);
+            return { release: null, failure, ...SIGNED_OUT };
         }
+        const release = await versionOf(cli);
+        if (release === null)
+            return { release: null, failure: `${cli} --version names no version`, ...SIGNED_OUT };
+        const minimum = CLIS[kind].minimum;
+        if (below(release, minimum))
+            return { release, minimum, failure: null, ...SIGNED_OUT };
+        return { cli, release };
+    }
+    async examine(kind, known) {
+        const resolved = await this.resolve(kind);
+        if (!('cli' in resolved))
+            return resolved;
+        return { release: resolved.release, failure: null, ...(await offer(kind, resolved.cli, known)) };
+    }
+    async load(kind) {
+        const known = this.readings.get(kind);
+        if (known !== undefined && known.failure === null)
+            return;
+        this.nextRead(kind);
+        this.readings.set(kind, await this.examine(kind, SIGNED_OUT));
+    }
+    async send() {
+        const agents = this.desired.agents.flatMap((kind) => {
+            const reading = this.readings.get(kind);
+            return reading === undefined ? [] : [reported(kind, reading)];
+        });
+        const hostKey = await sshHostKey();
+        const body = {
+            os: await operatingSystem(),
+            kit_version: KIT_VERSION,
+            agent_base: agentBase(),
+            agents,
+            ...(hostKey === null ? {} : { ssh_host_key: hostKey }),
+        };
+        const state = JSON.stringify(body);
+        if (state === this.sent)
+            return;
+        await this.house.deliver('/kit/agents/report', body);
+        this.sent = state;
     }
 }

package/dist/api.js

@@ -1,11 +1,16 @@
 import { readEnrolment } from './home.js';
 export class HouseRefusal extends Error {
     status;
+    text;
     constructor(path, status, text) {
         super(`House refused ${path} with ${status}: ${text}`);
         this.status = status;
+        this.text = text;
     }
 }
+export function retryDelay(attempt) {
+    return Math.min(30_000, 1000 * 2 ** attempt);
+}
 export async function post(house, path, body, credential, signal) {
     const answer = await fetch(new URL(path, house), {
         method: 'POST',
@@ -36,7 +41,7 @@ export const house = {
                 if (error instanceof HouseRefusal && error.status < 500)
                     throw error;
                 process.stderr.write(`kit: ${path} did not reach House: ${error.message}\n`);
-                await new Promise((resolve) => setTimeout(resolve, Math.min(30_000, 1000 * 2 ** attempt)));
+                await new Promise((resolve) => setTimeout(resolve, retryDelay(attempt)));
                 if (!current())
                     throw error;
             }

package/dist/authority-main.js

@@ -0,0 +1,22 @@
+import { setGlobalProxyFromEnv } from 'node:http';
+import { HouseRefusal, post } from './api.js';
+import { readEnrolment } from './home.js';
+function unanswered(error) {
+    return error instanceof HouseRefusal ? error.status >= 500 : error instanceof TypeError && error.message === 'fetch failed';
+}
+setGlobalProxyFromEnv();
+try {
+    const { house, credential } = (await readEnrolment());
+    try {
+        await post(house, '/kit/agents/desired', {}, credential);
+    }
+    catch (error) {
+        if (!unanswered(error))
+            throw error;
+        process.stderr.write(`kit: House did not answer, so the stored credential stands: ${error.message}\n`);
+    }
+}
+catch (error) {
+    process.stderr.write(`kit: ${error.message}\n`);
+    process.exitCode = 1;
+}

package/dist/bootstrap.json

@@ -0,0 +1,31 @@
+{
+  "schemaVersion": 1,
+  "version": "0.2.1-alpha.21",
+  "hosts": {
+    "linux": {
+      "command": "bash <(curl -fsSL https://github.com/agentshouse/kit/releases/download/v0.2.1-alpha.21/connect-linux.sh)",
+      "asset": {
+        "name": "connect-linux.sh",
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-alpha.21/connect-linux.sh"
+      },
+      "workspace": {
+        "argument": "--workspace",
+        "quoting": "posix"
+      },
+      "container": {
+        "argument": "--container"
+      }
+    },
+    "windows": {
+      "command": "& ([scriptblock]::Create((irm https://github.com/agentshouse/kit/releases/download/v0.2.1-alpha.21/connect-windows.ps1)))",
+      "asset": {
+        "name": "connect-windows.ps1",
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-alpha.21/connect-windows.ps1"
+      },
+      "workspace": {
+        "argument": "--workspace",
+        "quoting": "powershell"
+      }
+    }
+  }
+}