@agentshouse/kit 0.2.1-c3e4a20bb3183 → 0.2.1-c4ea88ba9424e

package/dist/clis.js

@@ -1,10 +1,16 @@
 import { spawn } from 'node:child_process';
 import { readFileSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
-import { userInfo } from 'node:os';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir, userInfo } from 'node:os';
 import { join } from 'node:path';
 import { kitHome } from './home.js';
 const RUNNING_JOB = new Set(['running', 'paused']);
+async function allowHouseInCodex() {
+    const rules = join(process.env.CODEX_HOME || join(homedir(), '.codex'), 'rules');
+    await mkdir(rules, { recursive: true });
+    await writeFile(join(rules, 'house.rules'), 'prefix_rule(pattern = ["house"], decision = "allow")\n');
+}
+async function nothing() { }
 function threadStatus({ method, params }) {
     if (method !== 'session/update' || params?.update?.sessionUpdate !== 'session_info_update')
         return undefined;
@@ -36,6 +42,9 @@ export const CLIS = {
         install: 'curl -fsSL https://chatgpt.com/codex/install.sh | sh',
         adapter: { package: '@agentclientprotocol/codex-acp', bin: 'codex-acp', executable: 'CODEX_PATH', env: {} },
         args: [],
+        fullAccess: 'agent-full-access',
+        sessionMeta: {},
+        allowHouse: allowHouseInCodex,
         signedIn: { command: ['login', 'status'] },
         login: { args: ['login', '--device-auth'], code: 'show' },
         queues: false,
@@ -52,9 +61,12 @@ export const CLIS = {
             package: '@agentclientprotocol/claude-agent-acp',
             bin: 'claude-agent-acp',
             executable: 'CLAUDE_CODE_EXECUTABLE',
-            env: { CLAUDE_CODE_ENTRYPOINT: 'claude-agent-acp' },
+            env: { CLAUDE_CODE_ENTRYPOINT: 'claude-agent-acp', IS_SANDBOX: '1' },
         },
         args: [],
+        fullAccess: 'bypassPermissions',
+        sessionMeta: { claudeCode: { options: { allowedTools: ['Bash(house:*)'] } } },
+        allowHouse: nothing,
         signedIn: { command: ['auth', 'status'] },
         login: { args: ['auth', 'login', '--claudeai'], code: 'collect', rejected: 'Invalid code' },
         queues: false,
@@ -70,7 +82,10 @@ export const CLIS = {
         minimum: '1.0.46',
         install: 'curl -fsSL https://x.ai/cli/install.sh | bash',
         adapter: null,
-        args: ['agent', '--no-leader', 'stdio'],
+        args: ['agent', '--always-approve', '--no-leader', 'stdio'],
+        fullAccess: null,
+        sessionMeta: {},
+        allowHouse: nothing,
         signedIn: { initializeMeta: 'defaultAuthMethodId' },
         login: { args: ['login', '--device-auth'], code: 'show' },
         queues: true,
@@ -90,7 +105,9 @@ const KIT_PACKAGE = JSON.parse(readFileSync(new URL('../package.json', import.me
 export const KIT_VERSION = 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.
 const INSTALL_MS = 15 * 60_000;
+// A login shell or a version read is ended after half a minute, so a profile that waits for input cannot stall the report.
 const READ_MS = 30_000;
 const CAUSE_CHARACTERS = 4000;
 function prefix(kind) {
@@ -118,8 +135,22 @@ export function run(command, args, timeoutMs, detached = false, signal) {
             timeout: timeoutMs,
             env: withoutProxy(),
             detached,
-            signal,
+            signal: detached ? undefined : signal,
         });
+        const stop = () => {
+            try {
+                process.kill(-child.pid, 'SIGKILL');
+            }
+            catch { }
+        };
+        if (detached && signal?.aborted)
+            stop();
+        if (detached)
+            signal?.addEventListener('abort', stop, { once: true });
+        const ended = (ran) => {
+            signal?.removeEventListener('abort', stop);
+            resolve(ran);
+        };
         let stdout = '';
         let output = '';
         child.stdout.setEncoding('utf8').on('data', (chunk) => {
@@ -129,25 +160,25 @@ export function run(command, args, timeoutMs, detached = false, signal) {
         child.stderr.setEncoding('utf8').on('data', (chunk) => {
             output += chunk;
         });
-        child.on('error', (error) => resolve({ status: null, stdout, output: error.message }));
-        child.on('close', (status) => resolve({ status, stdout, output }));
+        child.on('error', (error) => ended({ status: null, stdout, output: error.message }));
+        child.on('close', (status) => ended({ status, stdout, output }));
     });
 }
 export function failureOf(ran, program) {
     return ran.output.trim().slice(-CAUSE_CHARACTERS) || `${program} exited with ${ran.status ?? 'a signal'}`;
 }
-export async function installAdapter(kind) {
+export async function installAdapter(kind, signal) {
     const adapter = CLIS[kind].adapter;
     if (adapter === null)
         return null;
     const release = KIT_PACKAGE.peerDependencies[adapter.package];
     if ((await installedAdapter(kind)) === release)
         return null;
-    const ran = await run('npm', ['install', '--prefix', prefix(kind), '--no-save', '--no-audit', '--no-fund', '--omit=optional', `${adapter.package}@${release}`], INSTALL_MS);
+    const ran = await run('npm', ['install', '--prefix', prefix(kind), '--no-save', '--no-audit', '--no-fund', '--omit=optional', `${adapter.package}@${release}`], INSTALL_MS, true, signal);
     return ran.status === 0 ? null : failureOf(ran, 'npm');
 }
-export async function installCli(kind) {
-    const ran = await run('bash', ['-o', 'pipefail', '-c', CLIS[kind].install], INSTALL_MS, true);
+export async function installCli(kind, signal) {
+    const ran = await run('bash', ['-o', 'pipefail', '-c', CLIS[kind].install], INSTALL_MS, true, signal);
     return ran.status === 0 ? null : failureOf(ran, 'the install');
 }
 function loginShell() {
@@ -156,11 +187,11 @@ function loginShell() {
 const FOUND = 'house-kit-cli ';
 const LOOKUP = `found=$(command -v "$1") || exit 0; case $found in /*) ;; *) found=$(pwd -P)/$found ;; esac; printf "${FOUND}%s\\n" "$found"`;
 const USER_BIN = 'case ":$PATH:" in *":$HOME/.local/bin:"*) ;; *) PATH="$PATH:$HOME/.local/bin" ;; esac; export PATH';
-function inLoginShell(script, argument = '') {
-    return run(loginShell(), ['-l', '-i', '-c', `exec /bin/sh -c '${USER_BIN}; ${script}' sh ${argument}`], READ_MS, true);
+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) {
-    const ran = await inLoginShell(LOOKUP, CLIS[kind].bin);
+export async function locate(kind, signal) {
+    const ran = await inLoginShell(LOOKUP, CLIS[kind].bin, signal);
     return ran.stdout.split('\n').findLast((line) => line.startsWith(FOUND))?.slice(FOUND.length) ?? null;
 }
 export async function loginPath() {
@@ -168,8 +199,8 @@ export async function loginPath() {
     const ran = await inLoginShell(`printf "${marker}%s\\n" "$PATH"`);
     return ran.stdout.split('\n').findLast((line) => line.startsWith(marker)).slice(marker.length);
 }
-export async function versionOf(path) {
-    return VERSION.exec((await run(path, ['--version'], READ_MS)).stdout)?.[0] ?? null;
+export async function versionOf(path, signal) {
+    return VERSION.exec((await run(path, ['--version'], READ_MS, false, signal)).stdout)?.[0] ?? null;
 }
 function numbers(version) {
     return version.split(/[.-]/, 3).map(Number);

package/dist/conversations.js

@@ -209,7 +209,7 @@ export class Conversations {
                 continue;
             try {
                 const text = await transcribe(path, AbortSignal.any([conversation.killed.signal, conversation.interrupted.signal]));
-                if (text !== '')
+                if (text !== null && text !== '')
                     lines.push(`Transcript: ${text}`);
             }
             catch (error) {
@@ -285,13 +285,15 @@ export class Conversations {
         conversation.opening = bridge;
         try {
             await unlessAborted(createHowWeWork(bridge), conversation.killed.signal);
+            await CLIS[route.kind].allowHouse();
             const adapter = await startAdapter(route.kind, cli, route.working_directory, app, (job) => this.job(conversation, job), bridge.env);
             void adapter.exited.then(() => bridge.close());
             const agent = adapter.connection.agent;
             const cwd = route.working_directory;
+            const _meta = CLIS[route.kind].sessionMeta;
             const opened = sessionId === null
-                ? await agent.request('session/new', { cwd, mcpServers: [] })
-                : { ...(await agent.request('session/resume', { sessionId, cwd, mcpServers: [] })), sessionId };
+                ? await agent.request('session/new', { cwd, mcpServers: [], _meta })
+                : { ...(await agent.request('session/resume', { sessionId, cwd, mcpServers: [], _meta })), sessionId };
             const running = {
                 adapter,
                 bridge,
@@ -321,6 +323,7 @@ export class Conversations {
     async launchSettings(running, route, offered) {
         let options = offered;
         const settings = [
+            ['mode', route.mode ?? CLIS[route.kind].fullAccess],
             ['model', route.model],
             ['thought_level', route.effort],
         ];
@@ -389,10 +392,8 @@ export class Conversations {
         turn.admitted = true;
         for (const note of turn.notes.splice(0))
             this.kit.send(note);
-        if (turn.text !== '') {
-            turn.unsentFrom = 0;
-            this.draft(conversation, turn);
-        }
+        turn.unsentFrom = 0;
+        this.draft(conversation, turn);
         if (turn.entries !== null)
             this.plan(conversation, turn);
     }
@@ -442,8 +443,11 @@ export class Conversations {
             this.attach(conversation.turn ?? this.begin(conversation), sent);
         }
         running.adapter.connection.agent.request('session/prompt', { sessionId: running.sessionId, prompt }).then(() => this.answered(conversation, sent, null), async (error) => {
-            if (!running.adapter.connection.signal.aborted)
+            if (!running.adapter.connection.signal.aborted) {
                 this.answered(conversation, sent, causeOf(error));
+                if (conversation.open === 0 && conversation.running === running)
+                    stop(running.bridge);
+            }
             else if (sent.turn !== null) {
                 this.end(conversation, sent.turn, { failed: running.killed ? KILLED : await running.adapter.exited });
             }

package/dist/copies.js

@@ -2,15 +2,15 @@ import { parse } from '@agentshouse/mdmodel';
 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 { finalRefusal, HouseRefusal, retrying } from './api.js';
 import { blobId, blobText, git, HOUSE_REF, importCommits, localCopies, revision, run, succeeded, tree, } from './git.js';
 import { kitHome } from './home.js';
 import { operationId } from './operation.js';
 import { refusalOf } from './refusals.js';
 import { changed } from './translate.js';
+import { relayed } from './relay.js';
 const BRANCH = 'main';
 const PROVENANCE = '_provenance';
-const REPLICA_RETRY_MS = 30_000;
 const IDENTITY = { GIT_COMMITTER_NAME: 'House Kit', GIT_COMMITTER_EMAIL: 'house-kit@localhost' };
 function causeOf(error) {
     return error instanceof Error ? error.message : String(error);
@@ -40,11 +40,11 @@ function sidecar(path) {
     segments.splice(-1, 0, PROVENANCE);
     return segments.join('/');
 }
-function rootOf(copy) {
-    return copy.private ? '/private' : `/rooms/${copy.room_handle}`;
+function rootOf(handle) {
+    return `/rooms/${handle}`;
 }
 function relative(path) {
-    return path.replace(/^\/private\//, '').replace(/^\/rooms\/[^/]+\//, '');
+    return path.replace(/^\/rooms\/[^/]+\//, '');
 }
 function declaredWritable(path, copy) {
     const deepest = (scopes) => Math.max(-1, ...scopes.filter((scope) => covers(path, scope)).map((scope) => scope.length));
@@ -160,11 +160,11 @@ export class LocalCopies {
             key: 'owner',
             submit: async (operation, changes) => {
                 try {
-                    const outcome = await house.post('/kit/door/batch', { operation_id: operation, changes });
+                    const outcome = await retrying(() => house.post('/kit/door/batch', { operation_id: operation, changes }));
                     return { accepted: outcome.contents };
                 }
                 catch (error) {
-                    if (!(error instanceof HouseRefusal) || error.status >= 500)
+                    if (!finalRefusal(error))
                         throw error;
                     return {
                         refused: refusalOf(error.text) ?? { code: '', text: `House refused it with ${error.status}`, conflicts: [] },
@@ -176,7 +176,7 @@ export class LocalCopies {
     async load() {
         const home = join(kitHome(), 'local-copies');
         const names = (await readdir(join(home, 'rooms')).catch(() => [])).filter((name) => name.endsWith('.json'));
-        for (const path of [...names.map((name) => join(home, 'rooms', name)), join(home, 'private.json')]) {
+        for (const path of names.map((name) => join(home, 'rooms', name))) {
             const text = await readFile(path, 'utf8').catch(() => null);
             if (text === null)
                 continue;
@@ -188,7 +188,7 @@ export class LocalCopies {
         await this.selecting;
         return [...this.copies.values()]
             .filter((copy) => copy.active)
-            .map((copy) => `${rootOf(copy)}: ${copy.repository}`)
+            .map((copy) => `${rootOf(copy.room_handle)}: ${copy.repository}`)
             .sort();
     }
     select() {
@@ -198,12 +198,7 @@ export class LocalCopies {
     }
     async reselect() {
         const { local_copy: chosen } = await this.house.post('/kit/local-copy/selection', {});
-        const selected = [
-            ...(chosen?.rooms ?? [])
-                .filter((room) => room.room_handle !== null)
-                .map((room) => ({ key: `rooms/${room.room_ref}`, private: false, handle: room.room_handle })),
-            ...(chosen?.private === true ? [{ key: 'private', private: true, handle: null }] : []),
-        ];
+        const selected = (chosen?.rooms ?? []).flatMap((room) => room.room_handle === null ? [] : [{ key: `rooms/${room.room_ref}`, handle: room.room_handle }]);
         const keys = new Set(selected.map((scope) => scope.key));
         const work = [];
         for (const key of this.copies.keys()) {
@@ -255,11 +250,11 @@ export class LocalCopies {
     async push(cwd, selector, caller) {
         const located = await run(cwd, ['rev-parse', '--path-format=absolute', '--git-common-dir', '--show-toplevel']);
         if (located.status !== 0)
-            return { refused: true, text: `${cwd} is not a House Local copy; run house git push inside one` };
+            return { refused: true, text: `${cwd} is not a House Local copy; run house push inside one` };
         const [common, worktree] = located.stdout.toString('utf8').split('\n');
         const key = await this.keyAt(dirname(common));
         if (key === undefined)
-            return { refused: true, text: `${worktree} is not a House Local copy; run house git push inside one` };
+            return { refused: true, text: `${worktree} is not a House Local copy; run house push inside one` };
         return this.exclusive(key, () => this.pushed(key, worktree, selector, caller));
     }
     async keyAt(repository) {
@@ -287,7 +282,7 @@ export class LocalCopies {
         }).catch(logged);
     }
     async save(copy) {
-        const path = join(kitHome(), 'local-copies', copy.private ? 'private.json' : `${copy.key}.json`);
+        const path = join(kitHome(), 'local-copies', `${copy.key}.json`);
         await mkdir(dirname(path), { recursive: true, mode: 0o700 });
         const temporary = `${path}.${process.pid}`;
         await writeFile(temporary, JSON.stringify(copy), { mode: 0o600 });
@@ -295,12 +290,12 @@ export class LocalCopies {
         this.copies.set(copy.key, copy);
         return copy;
     }
-    async read(selected) {
-        const prefixes = [rootOf(selected)];
+    async read(handle) {
+        const prefixes = [rootOf(handle)];
         const discovery = await this.house.post('/kit/door/discover', { prefixes });
         let bundle = await this.house.post('/kit/door/bootstrap', { prefixes });
         if ('transfer' in bundle)
-            bundle = (await (await fetch(bundle.transfer.url)).json());
+            bundle = (await (await fetch(relayed(bundle.transfer.url))).json());
         const [view] = bundle.scopes;
         if (view === undefined)
             return null;
@@ -343,13 +338,13 @@ export class LocalCopies {
             return;
         }
         const discovery = await this.house.post('/kit/door/discover', {
-            prefixes: [rootOf(copy)],
+            prefixes: [rootOf(copy.room_handle)],
         });
         const authority = discovery.authorities.find((entry) => entry.room_ref === copy.room_ref);
         if (authority === undefined)
             return;
         if (authority.managed_replication !== 'admitted') {
-            logged(`operation_denied: ${rootOf(copy)} is not synchronized to this Environment`);
+            logged(`operation_denied: ${rootOf(copy.room_handle)} is not synchronized to this Environment`);
             return;
         }
         if (JSON.stringify([authority.operations.write, authority.protected_paths]) !==
@@ -360,12 +355,12 @@ export class LocalCopies {
         await this.save(await this.caughtUp(copy));
     }
     async materialize(scope) {
-        const read = await this.read({ private: scope.private, room_handle: scope.handle });
+        const read = await this.read(scope.handle);
         if (read === null) {
-            logged(`House serves nothing of ${rootOf({ private: scope.private, room_handle: scope.handle })} to copy`);
+            logged(`House serves nothing of ${rootOf(scope.handle)} to copy`);
             return;
         }
-        const repository = scope.private ? join(localCopies(), 'private') : join(localCopies(), 'rooms', read.anchor);
+        const repository = join(localCopies(), 'rooms', read.anchor);
         if (await exists(repository)) {
             logged(`${repository} already exists and House Kit leaves it as it is`);
             return;
@@ -377,7 +372,7 @@ export class LocalCopies {
         try {
             await git(staging, ['init', '-q', '-b', BRANCH]);
             house = await importCommits(staging, [
-                { message: `House ${rootOf({ private: scope.private, room_handle: scope.handle })}`, from: null, files: read.writable },
+                { message: `House ${rootOf(scope.handle)}`, from: null, files: read.writable },
             ]);
             await git(staging, ['update-ref', `refs/heads/${BRANCH}`, house]);
             await git(staging, ['reset', '-q', '--hard']);
@@ -391,7 +386,6 @@ export class LocalCopies {
         }
         await this.save({
             key: scope.key,
-            private: scope.private,
             room_ref: read.anchor,
             room_handle: scope.handle,
             repository,
@@ -407,11 +401,11 @@ export class LocalCopies {
         });
     }
     async received(copy) {
-        const read = await this.read(copy);
+        const read = await this.read(copy.room_handle);
         if (read === null)
             return copy;
         const house = await importCommits(copy.repository, [
-            { message: `House ${rootOf(copy)} at position ${read.position}`, from: copy.house, replaces: true, files: read.writable },
+            { message: `House ${rootOf(copy.room_handle)} at position ${read.position}`, from: copy.house, replaces: true, files: read.writable },
         ]);
         const removed = copy.read_only.filter((path) => !read.readOnly.has(path));
         const readOnly = await readOnlyPlaced(copy.repository, copy.read_only, read.readOnly, removed);
@@ -434,7 +428,7 @@ export class LocalCopies {
             let answer;
             try {
                 answer = await this.house.post('/kit/door/enumerate', {
-                    prefixes: [rootOf(copy)],
+                    prefixes: [rootOf(copy.room_handle)],
                     positions: [{ authority: copy.room_ref, position: copy.position, log_epoch: copy.log_epoch }],
                 });
             }
@@ -444,7 +438,6 @@ export class LocalCopies {
                     return this.received(copy);
                 if (code !== 'replica_behind')
                     throw error;
-                setTimeout(() => this.deliver(copy.key), REPLICA_RETRY_MS).unref();
                 return copy;
             }
             const view = answer.authorities.find((entry) => entry.authority === copy.room_ref);
@@ -484,7 +477,7 @@ export class LocalCopies {
         let { house, manifests } = copy;
         if (files.size > 0) {
             house = await importCommits(copy.repository, [
-                { message: `House ${rootOf(copy)} at position ${position}`, from: copy.house, files },
+                { message: `House ${rootOf(copy.room_handle)} at position ${position}`, from: copy.house, files },
             ]);
             manifests = { ...manifests, [house]: { parent: copy.house, files: revisions } };
         }
@@ -515,7 +508,7 @@ export class LocalCopies {
             copy = await this.save(without(copy));
         }
         if (!copy.active) {
-            return { refused: true, text: `${rootOf(copy)} is no longer synced to this Environment, so House takes no push from it` };
+            return { refused: true, text: `${rootOf(copy.room_handle)} is no longer synced to this Environment, so House takes no push from it` };
         }
         const listed = (await git(copy.repository, ['rev-list', '--topo-order', commit])).split('\n');
         const base = listed.find((ancestor) => ancestor in copy.manifests);
@@ -549,7 +542,7 @@ export class LocalCopies {
         return this.settle(submitted, caller);
     }
     async derived(copy, base, commit) {
-        const root = rootOf(copy);
+        const root = rootOf(copy.room_handle);
         const before = await tree(copy.repository, base);
         const after = await tree(copy.repository, commit);
         const moved = movedPaths(copy.moves, before, after);
@@ -597,7 +590,7 @@ export class LocalCopies {
             const refusal = error instanceof HouseRefusal ? refusalOf(error.text) : null;
             return {
                 refused: true,
-                text: refusal?.text ?? `House's answer to ${short(push.commit)} did not arrive; run house git push again`,
+                text: refusal?.text ?? `House's answer to ${short(push.commit)} did not arrive; run house push again`,
             };
         }
         if ('refused' in outcome) {
@@ -631,12 +624,12 @@ export class LocalCopies {
         const push = copy.push;
         const current = await this.save(await this.caughtUp(copy));
         const house = await tree(copy.repository, current.house);
-        const root = rootOf(current);
+        const root = rootOf(current.room_handle);
         if (!(await this.landed(copy.repository, push.changes, house, await tree(copy.repository, push.commit)))) {
             await this.save(without(current));
             return {
                 refused: true,
-                text: `House does not hold ${short(push.commit)}; run house git push again`,
+                text: `House does not hold ${short(push.commit)}; run house push again`,
             };
         }
         const written = [];
@@ -664,7 +657,7 @@ export class LocalCopies {
         catch {
             return {
                 refused: false,
-                text: `House accepted ${short(commit)}; run house git push again to finish integrating it here`,
+                text: `House accepted ${short(commit)}; run house push again to finish integrating it here`,
             };
         }
     }
@@ -687,7 +680,7 @@ export class LocalCopies {
                 written = [
                     ...written,
                     {
-                        path: `${rootOf(copy)}/${path}`,
+                        path: `${rootOf(copy.room_handle)}/${path}`,
                         revision: entry === undefined ? null : (revisionAt(copy, copy.house, path) ?? null),
                         content: entry === undefined ? null : await blobText(copy.repository, entry, path),
                     },
@@ -707,7 +700,7 @@ export class LocalCopies {
         }
         const edits = new Map([...files].filter(([path, content]) => (content === null ? selected.has(path) : selected.get(path) !== blobId(content))));
         const received = [...files.keys()].filter((path) => revisionAt(copy, copy.house, path) === revisionAt(copy, push.house, path));
-        const accepted = `House ${rootOf(copy)} with ${push.commit} accepted`;
+        const accepted = `House ${rootOf(copy.room_handle)} with ${push.commit} accepted`;
         const house = await importCommits(copy.repository, [
             ...(edits.size === 0 ? [] : [{ message: accepted, from: push.commit, files: edits }]),
             {

package/dist/end.js

@@ -0,0 +1,8 @@
+import { killDescendants } from './acp.js';
+export const REPLACED = 'another Kit started for this Environment';
+export const SIGN_IN_AGAIN = 'sign in again';
+export function end(reason) {
+    process.stderr.write(`kit: ${reason}\n`);
+    killDescendants();
+    process.exit(0);
+}

package/dist/files.js

@@ -1,10 +1,11 @@
 import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { relayed } from './relay.js';
 export async function placeFiles(house, directory, files, signal) {
     const paths = [];
     for (const file of files) {
         const original = await house.post('/kit/conversation/originals/get', { version: file.version, download: true }, signal);
-        const answer = await fetch(original.download.url, { signal });
+        const answer = await fetch(relayed(original.download.url), { signal });
         if (!answer.ok)
             throw new Error(`${file.name} did not download: ${answer.status}`);
         const folder = join(directory, '.house', 'files', original.message, file.version);

package/dist/home.js

@@ -1,7 +1,9 @@
+import { existsSync } from 'node:fs';
 import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 const ENROLMENT = 'credential.json';
+const DISCONNECTED = 'disconnected.json';
 const CONFIGURATION = 'kit.json';
 const OWN_AGENT = 'own-agent.json';
 export function kitHome() {
@@ -33,8 +35,19 @@ export async function writeHome(name, value) {
 export function readEnrolment() {
     return readHome(ENROLMENT);
 }
-export function writeEnrolment(enrolment) {
-    return writeHome(ENROLMENT, enrolment);
+export async function writeEnrolment(enrolment) {
+    await writeHome(ENROLMENT, enrolment);
+    await rm(join(kitHome(), DISCONNECTED), { force: true });
+}
+export function readDisconnected() {
+    return readHome(DISCONNECTED);
+}
+export async function forgetEnrolment({ house, environment }) {
+    await writeHome(DISCONNECTED, { house, environment });
+    await rm(join(kitHome(), ENROLMENT), { force: true });
+}
+export function enrolled() {
+    return existsSync(join(kitHome(), ENROLMENT));
 }
 export function readOwnAgent() {
     return readHome(OWN_AGENT);

package/dist/house-main.js

@@ -7,7 +7,8 @@ import { kitHome, readOwnAgent } from './home.js';
 import { callHouse, rpc, UNREACHABLE } from './mcp.js';
 import { refusalOf } from './refusals.js';
 const USAGE = "usage: house <tool> ['<arguments as JSON>']";
-const GIT_USAGE = 'usage: house git push [commit] [--owner]';
+const PUSH_USAGE = 'usage: house push [commit] [--owner]';
+const PUSH = "push [commit]: sends the Local copy's committed changes to House";
 const ARGUMENTS = `the arguments are one JSON object in single quotes, like house search '{"query":"invoice"}'`;
 const CLOSED = "this conversation's House connection is closed; nothing to do from here";
 const REVOKED = 'this conversation no longer has House access; nothing to do from here';
@@ -97,17 +98,15 @@ async function upload(path, roomRef, missing) {
         throw new Error(`${path} was not saved: ${saved.upload_failure}; call again later`);
     return saved.attachment;
 }
-async function gitPush(args) {
+async function push(args) {
     if (args.includes('--help'))
-        return GIT_USAGE;
-    if (args[0] !== 'push')
-        throw new Error('only house git push [commit] exists; use plain git for the rest');
+        return PUSH_USAGE;
     const owner = args.includes('--owner');
-    const commit = args.slice(1).find((arg) => arg !== '--owner') ?? 'HEAD';
+    const commit = args.find((arg) => arg !== '--owner') ?? 'HEAD';
     if (owner && socketPath !== undefined)
-        throw new Error('--owner is not for Agent conversations; run house git push without it');
+        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 git push needs --owner');
+        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));
     if (pushed.refused)
         throw new Error(pushed.text);
@@ -128,14 +127,14 @@ function argumentsOf(argument) {
     return parsed;
 }
 async function house([verb, argument]) {
-    if (verb === undefined || verb === '--help') {
-        return [USAGE, 'git push [commit]', ...(await tools()).map((tool) => `${tool.name}: ${tool.description}`)].join('\n');
+    if (verb === undefined || verb === '--help' || verb === 'help') {
+        return [USAGE, 'help', PUSH, ...(await tools()).map((tool) => (tool.description === undefined ? tool.name : `${tool.name}: ${tool.description}`))].join('\n');
     }
     if (argument === '--help') {
         const tool = (await tools()).find((listed) => listed.name === verb);
         if (tool === undefined)
             throw new Error(`${verb} is no Tool; house find_command '{"query":"${verb}"}' finds Commands`);
-        return `${tool.description}\n${JSON.stringify(tool.inputSchema)}`;
+        return [...(tool.description === undefined ? [] : [tool.description]), JSON.stringify(tool.inputSchema)].join('\n');
     }
     const args = argumentsOf(argument);
     if (socketPath !== undefined && verb === 'upload_attachment') {
@@ -155,7 +154,7 @@ async function house([verb, argument]) {
     return text;
 }
 const argv = process.argv.slice(2);
-(argv[0] === 'git' ? gitPush(argv.slice(1)) : house(argv)).then((text) => {
+(argv[0] === 'push' ? push(argv.slice(1)) : house(argv)).then((text) => {
     process.stdout.write(`${text}\n`);
 }, (error) => {
     process.stderr.write(`house: ${error instanceof Error ? error.message : String(error)}\n`);

package/dist/instructions.js

@@ -1,8 +1,8 @@
 import { HOW_WE_WORK } from './skills.js';
 const HOUSE_LINE = 'Work with House through the `house` CLI: run `house --help`.';
 const FILE_LINE = 'To give the User a file or a page, upload it with `house upload_attachment` and link it; never start a server.';
-const READ_LINE = 'Before working in a Room, read `/private/rooms/<handle>/AGENTS.md`.';
-const COPIES_LINE = 'House Local copies; commit, then `house git push`:';
+const READ_LINE = 'Before working in a Room, read `/rooms/private/rooms/<handle>/AGENTS.md`.';
+const COPIES_LINE = 'House Local copies; commit, then `house push`:';
 const UNREADABLE = /^(?:\S+: )?(?:path_not_found|room_not_found|operation_denied)\b/;
 const FAILED = /^exit: [1-9]\d*$/;
 const CUT = /^stderr: shell: output_cut (\d+) of \d+ bytes; continue with: (.+)$/;

package/dist/kit-main.js

@@ -1,15 +1,21 @@
 #!/usr/bin/env node
 import { setGlobalProxyFromEnv } from 'node:http';
+import { answerGitCredential } from './app-git.js';
 import { login } from './login.js';
+import { logout } from './logout.js';
 import { resident } from './resident.js';
 const [command, ...argv] = process.argv.slice(2);
 setGlobalProxyFromEnv();
 async function run() {
     if (command === 'login')
         return login(argv);
+    if (command === 'logout')
+        return logout();
     if (command === 'resident')
         return resident();
-    process.stderr.write('usage: kit <login|resident>\n');
+    if (command === 'git-credential')
+        return answerGitCredential(argv[0]);
+    process.stderr.write('usage: kit <login|logout|resident>\n');
     process.exitCode = 2;
 }
 run().catch((error) => {