@agentshouse/kit 0.2.1-alpha.11 → 0.2.1-alpha.13

package/README.md

@@ -8,10 +8,15 @@ through the agent CLIs you chose and gives each Agent the `house` command.
 
 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. On
-Linux, macOS and Windows 11 it runs House Kit in one Docker container with
-your workspace, `~/AgentsHouse` unless you pass `--workspace <path>`, mounted
-at `/agents/house`. Append a `kit` or `house` command to the same command to
-run it in that container.
+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.
 
 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
@@ -29,10 +34,10 @@ 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.
 
 `kit resident` keeps the Environment connected, and keeps the Rooms you chose
-for this Environment as Git repositories under `/agents/house/working-copies`.
-Commit in one and run `house git push --owner` there to send the commit to
-House; on a computer, run it through the install command from the copy's
-directory. Inside an Agent conversation the Agent runs `house git push`.
+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`.
 
 ## License
 

package/dist/acp.js

@@ -1,5 +1,5 @@
 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, withoutProxy } from './clis.js';
@@ -60,15 +60,29 @@ export async function startAdapter(kind, cwd, app, jobs = () => undefined, added
         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 +110,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,21 +1,64 @@
 import { client } from '@agentclientprotocol/sdk';
 import { readFile } from 'node:fs/promises';
-import { startAdapter } from './acp.js';
+import { killTree, 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 { 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);
+}
+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, known) {
+    const probe = CLIS[kind].signedIn;
+    if ('command' in probe && (await run(cliCommand(kind), 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, 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 (error) {
+        process.stderr.write(`kit: ${kind} did not offer its models: ${causeOf(error)}\n`);
+        return adapter === undefined && 'initializeMeta' in probe ? known : { signed_in: true, models: known.models };
     }
-    catch {
-        return false;
+    finally {
+        if (adapter !== undefined)
+            killTree(adapter.child);
     }
 }
 async function sshHostKey() {
@@ -23,6 +66,8 @@ async function sshHostKey() {
     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;
 }
@@ -31,9 +76,12 @@ export class Agents {
     house;
     reading = Promise.resolve();
     installing = Promise.resolve();
-    releases = new Map();
+    installs = new Map();
+    offers = new Map();
     reporting = null;
     again = false;
+    sending = Promise.resolve();
+    sent = null;
     constructor(house) {
         this.house = house;
     }
@@ -62,24 +110,37 @@ export class Agents {
             this.again = true;
         return Promise.all([installing, this.reporting]).then(() => undefined);
     }
-    async report() {
+    report() {
+        const sending = this.sending.catch(() => undefined).then(() => this.send());
+        this.sending = sending;
+        return sending;
+    }
+    async send() {
         const agents = [];
-        for (const [kind, release] of this.releases) {
-            agents.push({ kind, release, signed_in: release !== null && (await signedIn(kind)) });
+        for (const [kind, installed] of this.installs) {
+            const offered = installed.release === null ? SIGNED_OUT : await offer(kind, this.offers.get(kind) ?? SIGNED_OUT);
+            this.offers.set(kind, offered);
+            agents.push({ kind, ...installed, ...offered });
         }
         const hostKey = await sshHostKey();
-        await this.house.deliver('/kit/agents/report', {
+        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;
     }
     async install(kinds) {
-        const releases = new Map();
+        const installs = new Map();
         for (const kind of kinds)
-            releases.set(kind, await install(kind));
-        this.releases = releases;
+            installs.set(kind, await install(kind));
+        this.installs = installs;
     }
     async reports() {
         try {

package/dist/bootstrap.json

@@ -1,23 +1,26 @@
 {
   "schemaVersion": 1,
-  "version": "0.2.1-alpha.11",
+  "version": "0.2.1-alpha.13",
   "hosts": {
     "linux": {
-      "command": "bash <(curl -fsSL https://github.com/agentshouse/kit/releases/download/v0.2.1-alpha.11/connect-linux.sh)",
+      "command": "bash <(curl -fsSL https://github.com/agentshouse/kit/releases/download/v0.2.1-alpha.13/connect-linux.sh)",
       "asset": {
         "name": "connect-linux.sh",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-alpha.11/connect-linux.sh"
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-alpha.13/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.11/connect-windows.ps1)))",
+      "command": "& ([scriptblock]::Create((irm https://github.com/agentshouse/kit/releases/download/v0.2.1-alpha.13/connect-windows.ps1)))",
       "asset": {
         "name": "connect-windows.ps1",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-alpha.11/connect-windows.ps1"
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-alpha.13/connect-windows.ps1"
       },
       "workspace": {
         "argument": "--workspace",

package/dist/clis.js

@@ -115,11 +115,12 @@ export function run(command, args, timeoutMs) {
 export async function install(kind) {
     const release = pinned(kind);
     if ((await installedRelease(kind)) === release)
-        return release;
+        return { release, failure: null };
     const ran = await run('npm', ['install', '--prefix', prefix(kind), '--no-save', '--no-audit', '--no-fund', `${CLIS[kind].package}@${release}`], 15 * 60_000);
     if (ran.status !== 0) {
-        process.stderr.write(`kit: ${kind} did not install: ${ran.output.trim()}\n`);
-        return null;
+        const failure = ran.output.trim() || `npm exited with ${ran.status ?? 'a signal'}`;
+        process.stderr.write(`kit: ${kind} did not install: ${failure}\n`);
+        return { release: null, failure };
     }
-    return installedRelease(kind);
+    return { release: await installedRelease(kind), failure: null };
 }

package/dist/conversations.js

@@ -7,10 +7,10 @@ import { blocksOf, firstChange } from './blocks.js';
 import { openBridge } from './bridge.js';
 import { CLIS } from './clis.js';
 import { placeFiles } from './files.js';
+import { agentBase } from './home.js';
 import { instructions } from './instructions.js';
 import { holdSecretInput } from './secret-input.js';
 import { createHowWeWork } from './skills.js';
-const LAUNCH_BASE = '/agents/house';
 const KILLED = 'the conversation was killed';
 function causeOf(error) {
     return error instanceof Error ? error.message : String(error);
@@ -241,7 +241,7 @@ export class Conversations {
         const route = this.kit.agents.route(agentId);
         if (route === undefined)
             throw new Error(`this Environment hosts no Agent ${agentId}`);
-        if (route.working_directory === join(LAUNCH_BASE, route.agent_id)) {
+        if (route.working_directory === join(agentBase(), route.agent_id)) {
             await mkdir(route.working_directory, { recursive: true });
         }
         return route;

package/dist/copies.js

@@ -3,7 +3,7 @@ import { randomUUID } from 'node:crypto';
 import { mkdir, readFile, readdir, realpath, rename, rm, rmdir, stat, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { HouseRefusal } from './api.js';
-import { blobId, blobText, git, HOUSE_REF, importCommits, revision, run, succeeded, tree, WORKING_COPIES, } from './git.js';
+import { blobId, blobText, git, HOUSE_REF, importCommits, revision, run, succeeded, tree, workingCopies, } from './git.js';
 import { kitHome } from './home.js';
 import { operationId } from './operation.js';
 import { refusalOf } from './refusals.js';
@@ -369,7 +369,7 @@ export class WorkingCopies {
             logged(`House serves nothing of ${rootOf({ private: scope.private, room_handle: scope.handle })} to copy`);
             return;
         }
-        const repository = scope.private ? join(WORKING_COPIES, 'private') : join(WORKING_COPIES, 'rooms', read.anchor);
+        const repository = scope.private ? join(workingCopies(), 'private') : join(workingCopies(), 'rooms', read.anchor);
         if (await exists(repository)) {
             logged(`${repository} already exists and House Kit leaves it as it is`);
             return;

package/dist/git-main.js

@@ -4,7 +4,7 @@ import { accessSync, constants, realpathSync, statSync } from 'node:fs';
 import { request } from 'node:http';
 import { constants as system } from 'node:os';
 import { delimiter, dirname, join } from 'node:path';
-import { WORKING_COPIES } from './git.js';
+import { workingCopies } from './git.js';
 import { kitHome } from './home.js';
 const VALUED = new Set(['-C', '-c', '--git-dir', '--work-tree', '--namespace', '--config-env', '--attr-source', '--super-prefix']);
 const READS = new Set([
@@ -125,7 +125,7 @@ async function observed(git, args) {
         return delegated(git, args);
     const located = captured(git, [...globals, 'rev-parse', '--path-format=absolute', '--git-common-dir', '--show-toplevel']);
     const [common, worktree] = located?.split('\n') ?? [];
-    if (common === undefined || worktree === undefined || !dirname(common).startsWith(`${WORKING_COPIES}/`)) {
+    if (common === undefined || worktree === undefined || !dirname(common).startsWith(`${workingCopies()}/`)) {
         return delegated(git, args);
     }
     const listing = [...globals, '-C', worktree, 'ls-files', '--stage', '-z'];

package/dist/git.js

@@ -1,7 +1,11 @@
 import { spawn } from 'node:child_process';
 import { createHash } from 'node:crypto';
+import { join } from 'node:path';
 import { withoutProxy } from './clis.js';
-export const WORKING_COPIES = '/agents/house/working-copies';
+import { agentBase } from './home.js';
+export function workingCopies() {
+    return join(agentBase(), 'working-copies');
+}
 export const HOUSE_REF = 'refs/house/received';
 const COMMITTER = 'House Kit <house-kit@localhost>';
 export function run(cwd, args, input, env = {}) {

package/dist/home.js

@@ -6,6 +6,9 @@ const CONFIGURATION = 'kit.json';
 export function kitHome() {
     return process.env.HOUSE_KIT_HOME ?? join(homedir(), '.house-kit');
 }
+export function agentBase() {
+    return process.env.HOUSE_KIT_WORKSPACE ?? '/agents/house';
+}
 export async function readHome(name) {
     try {
         return JSON.parse(await readFile(join(kitHome(), name), 'utf8'));

package/dist/resident.js

@@ -14,6 +14,7 @@ import { SignIns } from './sign-in.js';
 import { placeSkillSet } from './skills.js';
 import { holdStream } from './stream.js';
 import { Updates } from './update.js';
+const AGENTS_REREAD_MS = 60 * 60_000;
 function report(error) {
     process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
 }
@@ -93,6 +94,7 @@ export async function resident() {
     await house.deliver('/kit/restarted', {}).catch(report);
     await updates.resumed().catch(report);
     logged(agents.refresh());
+    setInterval(() => logged(agents.refresh()), AGENTS_REREAD_MS);
     stream = holdStream({
         opened: () => {
             conversations.opened();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/kit",
-  "version": "0.2.1-alpha.11",
+  "version": "0.2.1-alpha.13",
   "description": "House Kit connects an Environment to agents.house.",
   "license": "MIT",
   "repository": {