@agentshouse/kit 0.2.1-c5d51f1e4ce19 → 0.2.1-c64c31420c9bf

package/README.md

@@ -5,18 +5,18 @@ your Agents' conversations through the agent CLIs you chose and gives each Agent
 
 ## 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,
-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
+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
+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 options to run it in that container.
+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.
+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.
 
 On your own Linux server, run the Linux command with `--linux` to
 install House Kit natively, with its workspace at `/agents/house`; `kit` and
@@ -37,8 +37,8 @@ or another, continues on its own and keeps the Environment's credential in
 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
+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
 longer act as you here; a later `kit login` reconnects the same Environment, or connects

package/dist/agents.js

@@ -125,6 +125,7 @@ function reported(kind, reading) {
         full_access: CLIS[kind].fullAccess,
     };
 }
+const NOT_READY = "the Agent's CLI is not ready on this computer";
 function tooOld(kind, release) {
     const cli = CLIS[kind];
     return `${cli.bin} ${release} is older than ${cli.minimum}, the oldest this Kit runs`;
@@ -213,7 +214,7 @@ export class Agents {
             const resolved = await this.resolve(kind);
             if (!('cli' in resolved)) {
                 this.update(kind, resolved);
-                throw new Error(resolved.failure ?? tooOld(kind, resolved.release));
+                throw new Error(resolved.failure === null ? tooOld(kind, resolved.release) : NOT_READY);
             }
             const { cli, release } = resolved;
             const known = this.readings.get(kind);

package/dist/api.js

@@ -46,7 +46,7 @@ export async function post(house, path, body, credential, signal) {
     });
     const text = await answer.text();
     if (!answer.ok && tooOld(text))
-        updateRequired(house);
+        updateRequired();
     if (!answer.ok)
         throw new HouseRefusal(path, answer.status, text);
     return JSON.parse(text);

package/dist/app-git.js

@@ -1,15 +1,9 @@
-import { extname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
 import { run } from './git.js';
 import { kitHome, readOwnAgent } from './home.js';
-import { quoted } from './shell.js';
+const HELPER = '!kit git-credential';
 function section(house) {
     return `credential.${new URL('/app/', house).href}`;
 }
-function helper() {
-    const main = fileURLToPath(new URL(`./kit-main${extname(fileURLToPath(import.meta.url))}`, import.meta.url));
-    return `!HOUSE_KIT_HOME=${quoted(resolve(kitHome()))} ${quoted(process.execPath)} ${quoted(main)} git-credential`;
-}
 async function configured(args) {
     try {
         return await run(kitHome(), ['config', '--global', ...args]);
@@ -20,30 +14,18 @@ async function configured(args) {
         throw error;
     }
 }
-async function forget(house) {
-    await configured(['--remove-section', section(house)]);
-}
-async function register(house) {
-    await forget(house);
-    for (const value of ['', helper()]) {
-        const ran = await configured(['--add', `${section(house)}.helper`, value]);
+export async function placeAppGit(ownAgent) {
+    if (ownAgent === null)
+        return;
+    await configured(['--remove-section', section(ownAgent.house)]);
+    for (const value of ['', HELPER]) {
+        const ran = await configured(['--add', `${section(ownAgent.house)}.helper`, value]);
         if (ran === null)
             return;
         if (ran.status !== 0)
             throw new Error(`git config failed: ${ran.stderr.trim()}`);
     }
 }
-export async function placeAppGit(before, after) {
-    if (before !== null && before.house !== after?.house)
-        await forget(before.house);
-    if (after !== null)
-        await register(after.house);
-}
-export async function forgetAppGit() {
-    const ownAgent = await readOwnAgent();
-    if (ownAgent !== null)
-        await forget(ownAgent.house);
-}
 export async function answerGitCredential(operation) {
     let asked = '';
     for await (const chunk of process.stdin)
@@ -55,8 +37,10 @@ export async function answerGitCredential(operation) {
         .filter((line) => line.includes('='))
         .map((line) => [line.slice(0, line.indexOf('=')), line.slice(line.indexOf('=') + 1)]));
     const ownAgent = await readOwnAgent();
-    if (ownAgent === null)
+    if (ownAgent === null) {
+        process.stderr.write(`kit: Kit home ${kitHome()} is not signed in; run kit login\n`);
         return;
+    }
     const house = new URL(ownAgent.house);
     if (attributes.get('protocol') !== house.protocol.slice(0, -1) || attributes.get('host') !== house.host)
         return;

package/dist/bootstrap.json

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

package/dist/bridge.js

@@ -1,7 +1,6 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { once } from 'node:events';
 import { setTimeout as delay } from 'node:timers/promises';
-import { mkdir } from 'node:fs/promises';
 import { createServer, request as httpRequest } from 'node:http';
 import { request as httpsRequest } from 'node:https';
 import { delimiter, dirname, join } from 'node:path';
@@ -9,7 +8,7 @@ import { parse } from 'yaml';
 import { finalRefusal, HouseRefusal, retryDelay, retrying } from './api.js';
 import { loginPath } from './clis.js';
 import { changedPaths, } from './copies.js';
-import { kitHome, readEnrolment } from './home.js';
+import { kitHome, readEnrolment, socketDirectory } from './home.js';
 import { callHouse, mcpBody, rpc, UNREACHABLE } from './mcp.js';
 import { operationId } from './operation.js';
 import { refusalOf, retryable } from './refusals.js';
@@ -167,9 +166,7 @@ export async function openBridge(house, copies, conversationId, signal) {
         }
         return path === '/' ? forward(text) : { status: 404, text: '' };
     };
-    const sockets = join(kitHome(), 'bridges');
-    await mkdir(sockets, { recursive: true, mode: 0o700 });
-    const socketPath = join(sockets, `${randomUUID()}.sock`);
+    const socketPath = join(socketDirectory(), `${randomUUID()}.sock`);
     const bridge = createServer(async (request, response) => {
         try {
             const path = request.url ?? '';

package/dist/chatgpt.js

@@ -24,7 +24,7 @@ export async function chatgpt(argv) {
         throw new Error(`${house} does not accept this key; pass one from ${KEY_SOURCE}`);
     const relay = process.env.HOUSE_KIT_RELAY || undefined;
     await writeOwnAgent({ house, ...(relay === undefined ? {} : { relay }), credential: values.key });
-    await placeAppGit(before, await readOwnAgent()).catch((error) => process.stderr.write(`kit: ${error.message}\n`));
+    await placeAppGit(await readOwnAgent()).catch((error) => process.stderr.write(`kit: ${error.message}\n`));
     if (before !== null && before.credential !== values.key) {
         process.stdout.write('This replaced the key this Kit home held; give each session its own HOUSE_KIT_HOME to keep its own key.\n');
     }

package/dist/conversations.js

@@ -18,6 +18,21 @@ import { transcribe } from './transcription.js';
 import { workFor } from './work.js';
 const KILLED = 'the conversation was killed';
 const REFUSED = 'the CLI refused the prompt';
+const NO_CONNECTION = "the Kit could not open this conversation's connection";
+const NO_START = "the Agent's CLI did not start";
+const NO_SESSION = "the Agent's CLI did not open a session";
+const NO_RESUME = "the Agent's CLI could not resume this conversation";
+const NO_SETTINGS = "the Agent's CLI refused the Agent's model, mode or effort";
+class NotStarted extends Error {
+}
+async function step(reason, work) {
+    try {
+        return await work;
+    }
+    catch (error) {
+        throw new NotStarted(reason, { cause: error });
+    }
+}
 const EXIT_PLAN_MODE = {
     parse(value) {
         if (typeof value !== 'object' || value === null || Array.isArray(value)) {
@@ -36,6 +51,13 @@ function answerMessage(request, response) {
 function logged(error) {
     process.stderr.write(`kit: ${causeOf(error)}\n`);
 }
+function refusal(conversation, error) {
+    if (conversation.kills > 0)
+        return KILLED;
+    const cause = error instanceof NotStarted ? `${error.message}: ${causeOf(error.cause)}` : causeOf(error);
+    logged(new Error(`conversation ${conversation.id} did not start: ${cause}`));
+    return causeOf(error);
+}
 function marker(bridge) {
     return `HOUSE_BRIDGE=${bridge.env.HOUSE_BRIDGE}`;
 }
@@ -212,7 +234,7 @@ export class Conversations {
             return { provider_session_id: await this.start(conversation, await this.route(conversation, input.agent_id), null) };
         }
         catch (error) {
-            return { refused: causeOf(error) };
+            return { refused: refusal(conversation, error) };
         }
     }
     async message(conversation, input) {
@@ -229,7 +251,7 @@ export class Conversations {
                 throw new Error(KILLED);
         }
         catch (error) {
-            return { ack: Promise.resolve({ refused: conversation.kills > 0 ? KILLED : causeOf(error) }) };
+            return { ack: Promise.resolve({ refused: refusal(conversation, error) }) };
         }
         return {
             ack: new Promise((settle) => {
@@ -274,7 +296,7 @@ export class Conversations {
                 conversation.session = null;
                 await this.kill(conversation);
             }
-            waiting.settle({ refused: conversation.kills > 0 ? KILLED : causeOf(error) });
+            waiting.settle({ refused: refusal(conversation, error) });
             return;
         }
         this.prompt(conversation, [...prompt, ...waiting.content]);
@@ -360,7 +382,7 @@ export class Conversations {
             .onRequest('elicitation/create', ({ params, signal }) => this.ask(conversation, 'elicitation/create', params, asksSecret(params), signal))
             .onRequest('_x.ai/exit_plan_mode', EXIT_PLAN_MODE, ({ params, signal }) => this.ask(conversation, '_x.ai/exit_plan_mode', params, false, signal));
         const cli = await unlessAborted(this.kit.agents.cli(route.kind), conversation.killed.signal);
-        const bridge = await openBridge(this.kit.house, this.kit.copies, conversation.id, conversation.killed.signal);
+        const bridge = await step(NO_CONNECTION, openBridge(this.kit.house, this.kit.copies, conversation.id, conversation.killed.signal));
         if (conversation.kills > 0) {
             bridge.close();
             throw new Error(KILLED);
@@ -371,24 +393,25 @@ export class Conversations {
         try {
             await unlessAborted(createHowWeWork(bridge), conversation.killed.signal);
             await CLIS[route.kind].allowHouse(bridge.env.PATH);
-            const adapter = await startAdapter(route.kind, cli, route.working_directory, app, (message) => {
+            const streamed = await step(NO_CONNECTION, work.open(cli));
+            const adapter = await step(NO_START, startAdapter(route.kind, cli, route.working_directory, app, (message) => {
                 work.read(message);
                 this.read(conversation, reader, message);
-            }, { ...bridge.env, ...(await work.open(cli)) }, undefined, scope);
+            }, { ...bridge.env, ...streamed }, undefined, scope));
             void adapter.exited.then(() => bridge.close());
             const agent = adapter.connection.agent;
             const cwd = route.working_directory;
             const _meta = CLIS[route.kind].sessionMeta(bridge.env.HOUSE_BRIDGE, conversation.id);
             const opened = sessionId === null
-                ? await agent.request('session/new', { cwd, mcpServers: [], _meta })
-                : { ...(await agent.request('session/resume', { sessionId, cwd, mcpServers: [], _meta })), sessionId };
+                ? await step(NO_SESSION, agent.request('session/new', { cwd, mcpServers: [], _meta }))
+                : { ...(await step(NO_RESUME, agent.request('session/resume', { sessionId, cwd, mcpServers: [], _meta }))), sessionId };
             reader.session = opened.sessionId;
             if (sessionId === null && CLIS[route.kind].renames) {
                 const prompt = [{ type: 'text', text: `/rename ${conversation.id}` }];
-                await agent.request('session/prompt', { sessionId: opened.sessionId, prompt });
+                await step(NO_SESSION, agent.request('session/prompt', { sessionId: opened.sessionId, prompt }));
             }
             const running = { adapter, bridge, sessionId: opened.sessionId, killed: false, reader, work, scope };
-            const options = await this.launchSettings(running, route, opened.configOptions ?? []);
+            const options = await step(NO_SETTINGS, this.launchSettings(running, route, opened.configOptions ?? []));
             void work.settled().then(() => scope.record());
             conversation.running = running;
             conversation.session = running.sessionId;

package/dist/copies.js

@@ -15,6 +15,9 @@ const IDENTITY = { GIT_COMMITTER_NAME: 'House Kit', GIT_COMMITTER_EMAIL: 'house-
 function causeOf(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function houseCause(error) {
+    return error instanceof HouseRefusal ? (refusalOf(error.text)?.text ?? causeOf(error)) : causeOf(error);
+}
 function logged(error) {
     process.stderr.write(`kit: ${causeOf(error)}\n`);
 }
@@ -261,7 +264,7 @@ export class LocalCopies {
                 }
                 catch (error) {
                     refused = true;
-                    said.push(error instanceof HouseRefusal ? (refusalOf(error.text)?.text ?? causeOf(error)) : causeOf(error));
+                    said.push(houseCause(error));
                 }
             }
             return { refused, text: said.length === 0 ? 'Nothing new from House.' : said.join('\n') };
@@ -549,7 +552,7 @@ export class LocalCopies {
             changes = await this.derived(copy, base, commit);
         }
         catch (error) {
-            return { refused: true, text: causeOf(error) };
+            return { refused: true, text: houseCause(error) };
         }
         if (changes.length === 0)
             return { refused: false, text: `Nothing to submit: ${short(commit)} matches House.` };
@@ -576,12 +579,17 @@ export class LocalCopies {
         const after = await tree(copy.repository, commit);
         const moved = movedPaths(copy.moves, before, after);
         const arrived = new Set(moved.values());
-        const binary = [];
-        for (const [path, entry] of after)
-            if (before.get(path) !== entry && !(await isText(copy.repository, entry)))
-                binary.push(path);
-        if (binary.length > 0)
-            throw new Error(textOnly(binary));
+        const arriving = [...after].filter(([path, entry]) => before.get(path) !== entry);
+        if (arriving.length > 0) {
+            const { bounds } = await this.house.post('/kit/door/discover', { prefixes: [root] });
+            const binary = [];
+            for (const [path, entry] of arriving) {
+                if (!(await isText(copy.repository, entry, bounds.max_authored_file_bytes)))
+                    binary.push(path);
+            }
+            if (binary.length > 0)
+                throw new Error(textOnly(binary));
+        }
         const text = (entry) => blobText(copy.repository, entry);
         const changes = [];
         for (const path of [...new Set([...before.keys(), ...after.keys()])].sort()) {

package/dist/end.js

@@ -13,8 +13,9 @@ export function end(reason) {
 export function restart(reason) {
     exit(reason, 1);
 }
-export function updateRequired(house) {
-    end(`This Kit is too old for House. Update it: ${installCommand(house)}`);
+export function updateRequired() {
+    const command = installCommand();
+    end(command === null ? 'This Kit is too old for House; install it again.' : `This Kit is too old for House. Update it: ${command}`);
 }
 export async function signInAgain(rejected) {
     await forgetRejected(rejected);

package/dist/git.js

@@ -49,16 +49,15 @@ export async function tree(repository, commit) {
     }
     return entries;
 }
-const TEXT_MAX_BYTES = 16 * 1024 * 1024;
 async function blob(repository, object) {
     return (await run(repository, ['cat-file', 'blob', object])).stdout;
 }
 export async function blobText(repository, object) {
     return (await blob(repository, object)).toString('utf8');
 }
-export async function isText(repository, object) {
+export async function isText(repository, object, maxBytes) {
     const bytes = await blob(repository, object);
-    return bytes.length <= TEXT_MAX_BYTES && isUtf8(bytes) && !bytes.includes(0);
+    return bytes.length <= maxBytes && isUtf8(bytes) && !bytes.includes(0);
 }
 export function blobId(content) {
     const bytes = Buffer.from(content, 'utf8');

package/dist/home.js

@@ -1,8 +1,8 @@
-import { randomUUID } from 'node:crypto';
-import { accessSync, chmodSync, constants, existsSync, linkSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync } from 'node:fs';
+import { createHash, randomUUID } from 'node:crypto';
+import { accessSync, chmodSync, constants, existsSync, linkSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync } from 'node:fs';
 import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { homedir, tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
 import { selectRelay } from './relay.js';
 const ENROLMENT = 'credential.json';
 const DISCONNECTED = 'disconnected.json';
@@ -19,24 +19,26 @@ function writable(directory) {
         return false;
     }
 }
-function ownTemporaryHome() {
-    const home = join(tmpdir(), `house-kit-${process.getuid()}`);
+function privateDirectory(path) {
     try {
-        mkdirSync(home, { mode: 0o700 });
+        mkdirSync(path, { mode: 0o700 });
     }
     catch (error) {
         if (error.code !== 'EEXIST')
             throw error;
     }
-    const found = lstatSync(home);
+    const found = lstatSync(path);
     if (found.isSymbolicLink())
-        throw new Error(`${home} is a symbolic link`);
+        throw new Error(`${path} is a symbolic link`);
     if (!found.isDirectory())
-        throw new Error(`${home} is not a directory`);
-    if (found.uid !== process.getuid())
-        throw new Error(`${home} is not owned by this User`);
-    chmodSync(home, 0o700);
-    return home;
+        throw new Error(`${path} is not a directory`);
+    if (found.uid !== process.geteuid())
+        throw new Error(`${path} is not owned by this User`);
+    chmodSync(path, 0o700);
+    return path;
+}
+function ownTemporaryHome() {
+    return privateDirectory(join(tmpdir(), `house-kit-${process.getuid()}`));
 }
 function defaultHome() {
     const home = join(homedir(), '.house-kit');
@@ -45,6 +47,18 @@ function defaultHome() {
 export function kitHome() {
     return process.env.HOUSE_KIT_HOME || (defaulted ??= defaultHome());
 }
+export function socketDirectory() {
+    const sockets = privateDirectory(join(realpathSync('/tmp'), `hk-${process.geteuid()}`));
+    const home = kitHome();
+    const physical = existsSync(home) ? realpathSync(home) : resolve(home);
+    return privateDirectory(join(sockets, createHash('sha256').update(physical).digest('hex').slice(0, 12)));
+}
+export function ownerSocket() {
+    return join(socketDirectory(), 'owner.sock');
+}
+export function ownerLock() {
+    return join(socketDirectory(), 'owner.lock');
+}
 export function workspaceRoot() {
     return process.env.HOUSE_KIT_WORKSPACE ?? '/agents/house';
 }

package/dist/house-cli.js

@@ -4,7 +4,7 @@ import { request, setGlobalProxyFromEnv } from 'node:http';
 import { basename, dirname, extname, join, resolve } from 'node:path';
 import { verified } from './files.js';
 import { HOUSE_REF } from './git.js';
-import { kitHome, readOwnAgent } from './home.js';
+import { ownerSocket, readOwnAgent } from './home.js';
 import { callHouse, rpc, UNREACHABLE } from './mcp.js';
 import { refusalOf } from './refusals.js';
 import { relayed, selectRelay } from './relay.js';
@@ -220,7 +220,7 @@ async function push(args) {
         throw new Error('--owner is not for Agent conversations; run house push without it');
     if (!owner && socketPath === undefined)
         throw new Error('outside an Agent conversation, house push needs --owner');
-    const pushed = JSON.parse(await bridged('/git/push', { cwd: process.cwd(), commit }, undefined, owner ? join(kitHome(), 'owner.sock') : socketPath));
+    const pushed = JSON.parse(await bridged('/git/push', { cwd: process.cwd(), commit }, undefined, owner ? ownerSocket() : socketPath));
     if (pushed.refused)
         throw new Error(pushed.text);
     return pushed.text;
@@ -228,7 +228,7 @@ async function push(args) {
 async function fetched(args) {
     if (accepted(args, ['--help'], 0, FETCH_USAGE).flags.has('--help'))
         return FETCH_USAGE;
-    const answer = JSON.parse(await bridged('/git/fetch', {}, undefined, socketPath ?? join(kitHome(), 'owner.sock')));
+    const answer = JSON.parse(await bridged('/git/fetch', {}, undefined, socketPath ?? ownerSocket()));
     if (answer.refused)
         throw new Error(answer.text);
     return answer.text;

package/dist/login.js

@@ -36,6 +36,13 @@ const USAGE = `usage: kit login [--house <origin>] [--environment <id>] [--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';
 }
@@ -81,6 +88,7 @@ export async function login(argv) {
     const environment = replaces === undefined ? (values.environment ?? remembered) : undefined;
     const ownAgent = await readOwnAgent();
     let held = false;
+    let named = environment;
     let exchanged;
     if (values.code !== undefined) {
         exchanged = await post(house, '/kit/token', { code: values.code, label: hostname() });
@@ -88,7 +96,7 @@ export async function login(argv) {
     else {
         held = ownAgent !== null && ownAgent.house === house && (await accepted(house, ownAgent.credential));
         const verifier = randomBytes(32).toString('base64url');
-        const start = (named) => retrying(() => post(house, '/kit', {
+        const start = () => retrying(() => post(house, '/kit', {
             label: hostname(),
             ...(named === undefined
                 ? { act: 'new_environment', ...(replaces === undefined ? {} : { replaces }) }
@@ -99,14 +107,15 @@ export async function login(argv) {
         }));
         let started;
         try {
-            started = await start(environment);
+            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`);
-            started = await start(undefined);
+            named = undefined;
+            started = await start();
         }
         process.stdout.write(`Open this link and confirm: ${started.start_url}\n`);
         open(started.start_url);
@@ -121,7 +130,7 @@ export async function login(argv) {
         environment: exchanged.environment,
         credential: exchanged.credential,
     });
-    process.stdout.write(`Environment ${exchanged.environment} is connected to ${house}.\n`);
+    process.stdout.write(connected(house, named, exchanged.environment));
     if (exchanged.headless_credential !== undefined) {
         await writeOwnAgent({ house, ...relayRecord, user: exchanged.user, credential: exchanged.headless_credential });
     }
@@ -132,7 +141,7 @@ export async function login(argv) {
     else if (held && ownAgent !== null) {
         await writeOwnAgent({ house, ...relayRecord, user: ownAgent.user, credential: ownAgent.credential });
     }
-    await placeAppGit(ownAgent, await readOwnAgent()).catch((error) => process.stderr.write(`kit: ${error.message}\n`));
+    await placeAppGit(await readOwnAgent()).catch((error) => process.stderr.write(`kit: ${error.message}\n`));
     try {
         startService();
     }

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/placement.js

@@ -2,7 +2,6 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { run } from './clis.js';
 import { kitHome } from './home.js';
-import { relayOrigin } from './relay.js';
 export function service() {
     if (process.platform !== 'linux' || !process.env.INVOCATION_ID)
         return null;
@@ -19,9 +18,9 @@ export async function updatesItself() {
     // sudo answers at once, so ten seconds only bounds a stuck sudo.
     return (await run('sudo', ['-n', 'true'], 10_000)).status === 0;
 }
-function installed() {
+export function installCommand() {
     try {
-        return readFileSync(join(kitHome(), 'placement'), 'utf8').trim();
+        return readFileSync(join(kitHome(), 'install-command'), 'utf8').trim();
     }
     catch (error) {
         if (error.code === 'ENOENT')
@@ -29,20 +28,3 @@ function installed() {
         throw error;
     }
 }
-function entries(house) {
-    const host = new URL(house).host;
-    const relay = relayOrigin();
-    if (relay === undefined)
-        return [`curl -fsSL ${host}/kit | sh`, `irm ${host}/kit.ps1 | iex`];
-    const entry = `${relay}/${host}/kit`;
-    return [`curl -fsSL ${entry} | HOUSE_KIT_RELAY=${relay} sh`, `$env:HOUSE_KIT_RELAY='${relay}'; irm ${entry}.ps1 | iex`];
-}
-export function installCommand(house) {
-    const [shell, windows] = entries(house);
-    const placement = installed();
-    if (placement === 'native')
-        return shell;
-    if (placement === 'server')
-        return `${shell} -s -- --linux`;
-    return `${shell} -s -- --container, or ${windows} on Windows`;
-}

package/dist/resident.js

@@ -1,8 +1,9 @@
 import { once } from 'node:events';
 import { watch } from 'node:fs';
 import { mkdir, rm, writeFile } from 'node:fs/promises';
-import { createServer } from 'node:http';
+import { createServer, get } from 'node:http';
 import { dirname, extname, join } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
 import { fileURLToPath } from 'node:url';
 import { Agents } from './agents.js';
 import { house } from './api.js';
@@ -10,7 +11,7 @@ import { received } from './bridge.js';
 import { CONVERSATION_INPUTS, Conversations } from './conversations.js';
 import { LocalCopies } from './copies.js';
 import { restart } from './end.js';
-import { agentBase, enrolled, forgetRestart, kitHome, restartAsked } from './home.js';
+import { agentBase, enrolled, forgetRestart, kitHome, ownerLock, ownerSocket, restartAsked } from './home.js';
 import { killDescendants } from './scope.js';
 import { quoted } from './shell.js';
 import { SignIns } from './sign-in.js';
@@ -29,13 +30,32 @@ async function installShim(path, module) {
     await mkdir(dirname(path), { recursive: true });
     await writeFile(path, `#!/bin/sh\nexec ${quoted(process.execPath)} ${quoted(main)} "$@"\n`, { mode: 0o755 });
 }
+function claimed(lock) {
+    try {
+        lock.exec('BEGIN EXCLUSIVE');
+        return true;
+    }
+    catch (error) {
+        if (error.errcode === 5)
+            return false;
+        throw error;
+    }
+}
 async function serveOwner(copies) {
-    const socketPath = join(kitHome(), 'owner.sock');
-    await rm(socketPath, { force: true });
+    const lock = new DatabaseSync(ownerLock());
+    if (!claimed(lock)) {
+        lock.close();
+        const running = await runningResident();
+        throw new Error(`${running === null ? 'another Kit' : `Kit ${running}`} already runs this Environment from Kit home ${kitHome()}; stop it first to run another here`);
+    }
     const server = createServer(async (request, response) => {
         try {
             const text = await received(request);
             let answered;
+            if (request.url === '/resident') {
+                response.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify({ pid: process.pid }));
+                return;
+            }
             if (request.url === '/git/fetch') {
                 answered = await copies.fetch();
             }
@@ -53,9 +73,23 @@ async function serveOwner(copies) {
             response.writeHead(502).end(error instanceof Error ? error.message : String(error));
         }
     });
-    server.listen(socketPath);
+    server.on('close', () => lock.close());
+    await rm(ownerSocket(), { force: true });
+    server.listen(ownerSocket());
     await once(server, 'listening');
 }
+function runningResident() {
+    return new Promise((resolve, reject) => {
+        get({ socketPath: ownerSocket(), path: '/resident' }, (answer) => {
+            received(answer).then((text) => resolve(JSON.parse(text).pid), reject);
+        }).on('error', (error) => {
+            if (error.code === 'ENOENT' || error.code === 'ECONNREFUSED')
+                resolve(null);
+            else
+                reject(error);
+        });
+    });
+}
 function connected() {
     return new Promise((resolve) => {
         const watcher = watch(kitHome(), () => {
@@ -72,7 +106,7 @@ function connected() {
         resolve();
     });
 }
-export async function resident() {
+async function started() {
     await connected();
     await forgetRestart();
     watch(kitHome(), () => {
@@ -83,13 +117,20 @@ export async function resident() {
     });
     await placeSkillSet();
     await mkdir(agentBase(), { recursive: true });
-    process.env.HOUSE_KIT_RESIDENT = String(process.pid);
-    const agents = new Agents(house, () => changed());
-    const copies = new LocalCopies(house);
-    await copies.load();
     await installShim(join(kitHome(), 'shim', 'git'), 'git-main');
     await installShim(codexLauncher(), 'codex-main');
+}
+export async function resident() {
+    await mkdir(kitHome(), { recursive: true, mode: 0o700 });
+    const copies = new LocalCopies(house);
+    await copies.load();
     await serveOwner(copies);
+    await started().catch((error) => {
+        report(error);
+        process.exit(1);
+    });
+    process.env.HOUSE_KIT_RESIDENT = String(process.pid);
+    const agents = new Agents(house, () => changed());
     let stream = null;
     let reported = false;
     const idle = () => conversations.idle() && signIns.idle() && agents.idle();

package/dist/stream.js

@@ -81,7 +81,7 @@ export function holdStream(handlers) {
                 return;
             }
             if (refused !== null && tooOld(refused.text))
-                updateRequired(house);
+                updateRequired();
             if (finalRefusal(refused))
                 end(refused.message);
             // A closed socket reopens in one to three seconds, spread so Kits one restart closed return apart; an opening House refused as retryable or left unanswered backs off on the jittered curve.

package/dist/work.js

@@ -1,11 +1,11 @@
 import { randomUUID } from 'node:crypto';
 import { once } from 'node:events';
 import { readFileSync } from 'node:fs';
-import { mkdir, rm } from 'node:fs/promises';
+import { rm } from 'node:fs/promises';
 import { createServer } from 'node:net';
 import { join } from 'node:path';
 import { RUNNING_JOB } from './events.js';
-import { kitHome } from './home.js';
+import { kitHome, socketDirectory } from './home.js';
 const ENDED_TASK = new Set(['completed', 'failed', 'killed']);
 const SCHEDULING = new Set(['CronCreate', 'CronDelete', 'ScheduleWakeup']);
 const QUEUE_LIST = 'house-kit-queue-';
@@ -194,9 +194,7 @@ class CodexWork extends Work {
     proving = -1;
     proven = -1;
     async open(cli) {
-        const sockets = join(kitHome(), 'bridges');
-        await mkdir(sockets, { recursive: true, mode: 0o700 });
-        this.path = join(sockets, `${randomUUID()}.sock`);
+        this.path = join(socketDirectory(), `${randomUUID()}.sock`);
         this.server = createServer((socket) => this.connected(socket));
         this.server.listen(this.path);
         await once(this.server, 'listening');

package/package.json

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