@agentshouse/kit 0.2.1-c3cf4b145dcda → 0.2.1-c46722ad48058

package/dist/events.js

@@ -1,7 +1,7 @@
 const COMMAND = { shown: 'command' };
 const HIDDEN = { shown: 'hidden' };
 const FINISHED = new Set(['completed', 'failed']);
-const RUNNING_JOB = new Set(['running', 'paused']);
+export const RUNNING_JOB = new Set(['running', 'paused']);
 const ROUTINE_TARGETS = { send_routine_request: 'access', cancel_routine_request: 'request' };
 function words(line) {
     const found = [];
@@ -113,9 +113,6 @@ class Reader {
     refused(option) {
         this.requestedOptions.delete(option);
     }
-    turnStarted() {
-        return [];
-    }
     closeTurn() {
         const events = [];
         for (const [id, call] of this.calls) {
@@ -187,10 +184,7 @@ class Reader {
         const label = this.jobs.get(id) ?? '';
         if (state !== 'running')
             this.jobs.delete(id);
-        return [
-            { kind: 'busy', key: `job:${id}`, running: state === 'running' },
-            { kind: 'marker', marker: 'job', text: `${label}: ${state}` },
-        ];
+        return [{ kind: 'marker', marker: 'job', text: `${label}: ${state}` }];
     }
     optionsChanged(options) {
         const events = [];
@@ -275,7 +269,6 @@ class Reader {
 class ClaudeReader extends Reader {
     watchedOptions = { model: 'model' };
     tasks = new Map();
-    scheduled = new Map();
     own(message) {
         if (message.params?.update?._meta?.claudeCode?.parentToolUseId !== undefined)
             return [];
@@ -295,10 +288,6 @@ class ClaudeReader extends Reader {
             return [];
         const sdk = message.params.message;
         switch (sdk.subtype) {
-            case 'background_tasks_changed':
-                return [{ kind: 'busy', key: 'tasks', running: sdk.tasks.length > 0 }];
-            case 'session_state_changed':
-                return [{ kind: 'busy', key: 'state', running: sdk.state === 'running' }];
             case 'task_started':
                 if (sdk.tool_use_id !== undefined)
                     this.tasks.set(sdk.task_id, sdk.tool_use_id);
@@ -309,16 +298,6 @@ class ClaudeReader extends Reader {
                 return [];
         }
     }
-    turnStarted() {
-        const events = [];
-        for (const [id, entry] of this.scheduled) {
-            if (entry.recurring)
-                continue;
-            this.scheduled.delete(id);
-            events.push({ kind: 'busy', key: `scheduled:${id}`, running: false });
-        }
-        return events;
-    }
     decide(call, final) {
         const tool = call.meta.claudeCode?.toolName;
         if (tool === 'Agent' || tool === 'Task' || call.meta.jetbrains?.air?.subagent === true) {
@@ -350,22 +329,7 @@ class ClaudeReader extends Reader {
         if (call.status !== 'completed')
             return [];
         if (tool === 'CronCreate' || (tool === 'ScheduleWakeup' && call.rawInput?.stop !== true)) {
-            this.scheduled.set(call.id, {
-                recurring: tool === 'CronCreate' && call.rawInput?.recurring !== false,
-                text: contentText(call.content) ?? '',
-            });
-            return [
-                { kind: 'busy', key: `scheduled:${call.id}`, running: true },
-                { kind: 'marker', marker: 'job', text: `${call.rawInput?.prompt ?? call.title ?? ''}: scheduled` },
-            ];
-        }
-        if (tool === 'CronDelete') {
-            for (const [id, entry] of this.scheduled) {
-                if (!entry.text.includes(String(call.rawInput?.id)))
-                    continue;
-                this.scheduled.delete(id);
-                return [{ kind: 'busy', key: `scheduled:${id}`, running: false }];
-            }
+            return [{ kind: 'marker', marker: 'job', text: `${call.rawInput?.prompt ?? call.title ?? ''}: scheduled` }];
         }
         return [];
     }
@@ -402,15 +366,9 @@ class CodexReader extends Reader {
             case 'subagent_spawned':
                 this.children.set(update.subagentSessionId, { id: null, text: '' });
                 this.subagents.add(update.subagentSessionId);
-                return [
-                    { kind: 'busy', key: `subagent:${update.subagentSessionId}`, running: true },
-                    { kind: 'subagent', id: update.subagentSessionId, description: update.name },
-                ];
+                return [{ kind: 'subagent', id: update.subagentSessionId, description: update.name }];
             case 'subagent_state_update':
-                return [
-                    { kind: 'busy', key: `subagent:${update.subagentSessionId}`, running: false },
-                    ...this.finish(update.subagentSessionId, this.children.get(update.subagentSessionId)?.text || null),
-                ];
+                return this.finish(update.subagentSessionId, this.children.get(update.subagentSessionId)?.text || null);
             default:
                 return super.update(update);
         }
@@ -427,10 +385,6 @@ class CodexReader extends Reader {
             child.id = id;
             child.text += update.content.text;
         }
-        const status = update._meta?.codex?.threadStatus?.type;
-        if (update.sessionUpdate === 'session_info_update' && status !== undefined) {
-            return [{ kind: 'busy', key: `thread:${session}`, running: status === 'active' }];
-        }
         return [];
     }
     decide(call) {
@@ -460,7 +414,6 @@ class CodexReader extends Reader {
 class GrokReader extends Reader {
     watchedOptions = {};
     children = new Map();
-    queues = new Map();
     models = [];
     model = null;
     answered(result) {
@@ -473,15 +426,10 @@ class GrokReader extends Reader {
         if (this.session !== null && session !== undefined && session !== this.session && !this.children.has(session))
             return [];
         if (message.method === '_x.ai/queue/changed') {
-            const running = message.params.runningPromptId ?? null;
-            this.queues.set(session, { running, entries: message.params.entries.length });
-            return [this.queued(session), ...(running !== null && session === this.session ? [{ kind: 'started' }] : [])];
+            return (message.params.runningPromptId ?? null) !== null && session === this.session ? [{ kind: 'started' }] : [];
         }
         if (message.params?.update?.sessionUpdate === 'turn_completed') {
-            const queue = this.queues.get(session);
-            if (queue !== undefined && queue.running === message.params.update.prompt_id)
-                queue.running = null;
-            return [this.queued(session), ...(session === this.session ? [{ kind: 'ended' }] : [])];
+            return session === this.session ? [{ kind: 'ended' }] : [];
         }
         if (message.method === '_x.ai/models/update') {
             this.offered(message.params);
@@ -489,10 +437,6 @@ class GrokReader extends Reader {
         }
         return super.read(message);
     }
-    queued(session) {
-        const queue = this.queues.get(session);
-        return { kind: 'busy', key: `queue:${session}`, running: queue !== undefined && (queue.running !== null || queue.entries > 0) };
-    }
     offered(models) {
         this.models = models.availableModels ?? this.models;
         this.model = models.currentModelId ?? this.model;
@@ -508,16 +452,9 @@ class GrokReader extends Reader {
             case '_x.ai/task_completed':
                 return this.job(update.task_snapshot.task_id, null, update.task_snapshot.exit_code === 0 ? 'completed' : 'failed');
             case '_x.ai/scheduled_task_created':
-                return [
-                    { kind: 'busy', key: `scheduled:${update.task_id}`, running: true },
-                    { kind: 'marker', marker: 'job', text: `${update.prompt}: next run ${update.next_fire_at}` },
-                ];
-            case '_x.ai/scheduled_task_deleted':
-                return [{ kind: 'busy', key: `scheduled:${update.task_id}`, running: false }];
+                return [{ kind: 'marker', marker: 'job', text: `${update.prompt}: next run ${update.next_fire_at}` }];
             case '_x.ai/session_notification':
                 return this.notification(update);
-            case '_x.ai/mcp_initialized':
-                return [{ kind: 'servers' }];
             default:
                 return [];
         }
@@ -538,14 +475,11 @@ class GrokReader extends Reader {
                     candidate.decided.description === update.description) ??
                     [...this.calls.values()].find((candidate) => candidate.decided?.shown === 'subagent' && ![...this.children.values()].includes(candidate.id));
                 this.children.set(update.child_session_id, call?.id ?? null);
-                return [{ kind: 'busy', key: `subagent:${update.child_session_id}`, running: true }];
+                return [];
             }
             case 'subagent_finished': {
                 const call = this.children.get(update.child_session_id);
-                return [
-                    { kind: 'busy', key: `subagent:${update.child_session_id}`, running: false },
-                    ...(typeof call === 'string' ? this.finish(call, update.output ?? null) : []),
-                ];
+                return typeof call === 'string' ? this.finish(call, update.output ?? null) : [];
             }
             case 'auto_compact_completed':
                 return [{ kind: 'marker', marker: 'compaction', text: '' }];

package/dist/home.js

@@ -2,6 +2,7 @@ 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';
+import { selectRelay } from './relay.js';
 const ENROLMENT = 'credential.json';
 const DISCONNECTED = 'disconnected.json';
 const CONFIGURATION = 'kit.json';
@@ -32,8 +33,11 @@ export async function writeHome(name, value) {
     await writeFile(temporary, `${JSON.stringify(value)}\n`, { mode: 0o600 });
     await rename(temporary, join(home, name));
 }
-export function readEnrolment() {
-    return readHome(ENROLMENT);
+export async function readEnrolment() {
+    const enrolment = await readHome(ENROLMENT);
+    if (enrolment !== null)
+        selectRelay(process.env.HOUSE_KIT_RELAY || enrolment.relay);
+    return enrolment;
 }
 export async function writeEnrolment(enrolment) {
     await writeHome(ENROLMENT, enrolment);

package/dist/house-main.js

@@ -3,15 +3,20 @@ import { createHash } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
 import { request, setGlobalProxyFromEnv } from 'node:http';
 import { basename, join } from 'node:path';
-import { kitHome, readOwnAgent } from './home.js';
+import { HOUSE_REF } from './git.js';
+import { kitHome, readEnrolment, readOwnAgent } from './home.js';
 import { callHouse, rpc, UNREACHABLE } from './mcp.js';
 import { refusalOf } from './refusals.js';
+import { relayed } from './relay.js';
+import { parse } from 'yaml';
 const USAGE = "usage: house <tool> ['<arguments as JSON>']";
 const PUSH_USAGE = 'usage: house push [commit] [--owner]';
 const PUSH = "push [commit]: sends the Local copy's committed changes to House";
+const FETCH_USAGE = 'usage: house fetch';
+const FETCH = `fetch: records House's changes on each Local copy's ${HOUSE_REF}`;
 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 SANDBOXED = "your CLI's sandbox kept house from House; run house as a command of its own, with no pipe, chain or redirect";
+const SANDBOXED = "your CLI's sandbox kept house from House; run house directly, not through another program";
 const REVOKED = 'this conversation no longer has House access; nothing to do from here';
 const UNCONNECTED = "this computer's own agent has no House connection; run kit login";
 const DISCONNECTED = "House no longer accepts this computer's own agent; run kit login";
@@ -51,6 +56,7 @@ async function direct(message) {
     const ownAgent = await readOwnAgent();
     if (ownAgent === null)
         throw new Error(UNCONNECTED);
+    await readEnrolment();
     setGlobalProxyFromEnv();
     const answer = await callHouse(ownAgent.house, ownAgent.credential, message).catch(() => {
         throw new Error(UNREACHABLE);
@@ -79,11 +85,24 @@ async function localFile(path) {
             : `${path} is not a readable file`);
     }
 }
+async function sent(url, bytes, operation) {
+    const headers = { 'content-type': 'application/octet-stream', 'x-house-byte-operation': operation };
+    if (socketPath !== undefined)
+        return bridged(url, bytes, headers);
+    setGlobalProxyFromEnv();
+    const answer = await fetch(relayed(url), { method: 'POST', headers, body: bytes }).catch(() => {
+        throw new Error(UNREACHABLE);
+    });
+    const text = await answer.text();
+    if (answer.status === 200)
+        return text;
+    throw new Error(refused(url, answer.status, text));
+}
 async function upload(path, roomRef, missing) {
     if (typeof path !== 'string' || path === '')
         throw new Error(missing);
     const bytes = await localFile(path);
-    const declared = JSON.parse(await bridged('/kit/attachments/upload', {
+    const declared = parse(await called('upload', {
         ...(roomRef === undefined ? {} : { room_ref: roomRef }),
         name: basename(path),
         bytes: bytes.length,
@@ -91,10 +110,7 @@ async function upload(path, roomRef, missing) {
     }));
     if (declared.upload === undefined)
         return declared.attachment;
-    const saved = JSON.parse(await bridged(declared.upload.url, bytes, {
-        'content-type': 'application/octet-stream',
-        'x-house-byte-operation': declared.upload.operation,
-    }));
+    const saved = JSON.parse(await sent(declared.upload.url, bytes, declared.upload.operation));
     if (saved.upload_failure !== undefined)
         throw new Error(`${path} was not saved: ${saved.upload_failure}; call again later`);
     return saved.attachment;
@@ -113,6 +129,14 @@ async function push(args) {
         throw new Error(pushed.text);
     return pushed.text;
 }
+async function fetched(args) {
+    if (args.includes('--help'))
+        return FETCH_USAGE;
+    const answer = JSON.parse(await bridged('/git/fetch', {}, undefined, socketPath ?? join(kitHome(), 'owner.sock')));
+    if (answer.refused)
+        throw new Error(answer.text);
+    return answer.text;
+}
 function argumentsOf(argument) {
     if (argument === undefined)
         return {};
@@ -129,7 +153,7 @@ function argumentsOf(argument) {
 }
 async function house([verb, argument]) {
     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');
+        return [USAGE, 'help', PUSH, FETCH, ...(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);
@@ -138,24 +162,27 @@ async function house([verb, argument]) {
         return [...(tool.description === undefined ? [] : [tool.description]), JSON.stringify(tool.inputSchema)].join('\n');
     }
     const args = argumentsOf(argument);
-    if (socketPath !== undefined && verb === 'upload_attachment') {
-        return JSON.stringify({ attachment: await upload(args.path, args.room_ref, 'upload_attachment needs "path", a local file') });
+    if (verb === 'upload') {
+        return JSON.stringify({ attachment: await upload(args.path, args.room_ref, 'upload needs "path", a local file') });
     }
-    if (socketPath !== undefined && verb === 'append_record' && Array.isArray(args.attachments)) {
+    if (verb === 'append_record' && Array.isArray(args.attachments)) {
         const attachments = [];
         for (const path of args.attachments) {
             attachments.push(await upload(path, args.room_ref, 'each attachments entry is the path of a local file'));
         }
         args.attachments = attachments;
     }
-    const result = await mcp('tools/call', { name: verb, arguments: args });
+    return called(verb, args);
+}
+async function called(name, args) {
+    const result = await mcp('tools/call', { name, arguments: args });
     const text = result.content.map((content) => content.text).join('\n');
     if (result.isError === true)
         throw new Error(text.replace(/\n+$/, ''));
     return text;
 }
 const argv = process.argv.slice(2);
-(argv[0] === 'push' ? push(argv.slice(1)) : house(argv)).then((text) => {
+(argv[0] === 'push' ? push(argv.slice(1)) : argv[0] === 'fetch' ? fetched(argv.slice(1)) : house(argv)).then((text) => {
     process.stdout.write(`${text}\n`);
     if (argv[0] === 'shell')
         process.exitCode = Number(/^exit: (\d+)(?:\n|$)/.exec(text)?.[1] ?? 0);

package/dist/instructions.js

@@ -1,8 +1,10 @@
+import { HOUSE_REF } from './git.js';
 import { HOW_WE_WORK } from './skills.js';
+const SOURCE_LINE = "From House, not the User's message:";
 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 `/rooms/private/rooms/<handle>/AGENTS.md`.';
-const COPIES_LINE = 'House Local copies; commit, then `house push`:';
+const FILE_LINE = 'To give the User a file or a page, upload it with `house upload` and link it; never start a server.';
+const READ_LINE = "Your User's instructions for a Room, if any: `/rooms/private/rooms/<handle>/AGENTS.md`.";
+const COPIES_LINE = `House Local copies; before work run \`house fetch\` and rebase onto \`${HOUSE_REF}\`; after it 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: (.+)$/;
@@ -29,6 +31,6 @@ async function howWeWork(bridge) {
     return document.replace(/\n$/, '');
 }
 export async function instructions(bridge, base, copies) {
-    const lines = [HOUSE_LINE, FILE_LINE, READ_LINE, ...(copies.length === 0 ? [] : [COPIES_LINE, ...copies])];
+    const lines = [SOURCE_LINE, HOUSE_LINE, FILE_LINE, READ_LINE, ...(copies.length === 0 ? [] : [COPIES_LINE, ...copies])];
     return [lines.join('\n'), base, await howWeWork(bridge)].filter((part) => part !== '').join('\n\n');
 }

package/dist/login.js

@@ -1,54 +1,20 @@
+import { spawn } from 'node:child_process';
 import { createHash, randomBytes } from 'node:crypto';
-import { createServer } from 'node:http';
 import { hostname } from 'node:os';
-import { createInterface } from 'node:readline/promises';
 import { parseArgs } from 'node:util';
-import { post } from './api.js';
+import { post, retrying } from './api.js';
 import { placeAppGit } from './app-git.js';
 import { forgetOwnAgent, readDisconnected, readEnrolment, readOwnAgent, writeEnrolment, writeOwnAgent } from './home.js';
 import { callHouse, rpc } from './mcp.js';
+import { selectRelay } from './relay.js';
 const DEFAULT_HOUSE = 'https://agents.house';
-function listen() {
-    return new Promise((resolve, reject) => {
-        let deliver = () => undefined;
-        let held = null;
-        const code = new Promise((settle) => {
-            deliver = settle;
-        });
-        const server = createServer((request, response) => {
-            const received = new URL(request.url ?? '/', 'http://127.0.0.1').searchParams.get('code');
-            if (received === null || held !== null) {
-                response.writeHead(404).end();
-                return;
-            }
-            held = response;
-            deliver(received);
-        });
-        const close = () => {
-            server.close();
-            server.closeAllConnections();
-        };
-        const port = Number(process.env.HOUSE_KIT_LOGIN_PORT ?? 0);
-        server.once('error', reject);
-        server.listen(port, port === 0 ? '127.0.0.1' : '0.0.0.0', () => {
-            const address = server.address();
-            if (address === null || typeof address === 'string') {
-                reject(new Error('the login callback has no port'));
-                return;
-            }
-            resolve({
-                uri: `http://127.0.0.1:${address.port}/callback`,
-                code,
-                answer: (text) => new Promise((written) => {
-                    if (held === null || held.destroyed || !held.socket || held.socket.destroyed)
-                        return written();
-                    held.once('close', () => written());
-                    held.writeHead(200, { 'content-type': 'text/plain; charset=utf-8', connection: 'close' }).end(`${text}\n`);
-                }),
-                close,
-            });
-        });
-    });
+const OPENER = process.platform === 'darwin' ? 'open' : 'xdg-open';
+// Polling every two seconds brings the User's confirmation to the waiting Kit moments after they give it.
+const POLL_INTERVAL_MS = 2000;
+function open(link) {
+    spawn(OPENER, [link], { detached: true, stdio: 'ignore' })
+        .on('error', () => undefined)
+        .unref();
 }
 async function accepted(house, credential) {
     const checked = await callHouse(house, credential, rpc('tools/list', {}));
@@ -58,17 +24,19 @@ async function accepted(house, credential) {
         return false;
     throw new Error(`House answered ${checked.status} when Kit checked this computer's own agent's connection: ${checked.text}`);
 }
-async function typed(question) {
-    const reader = createInterface({ input: process.stdin, output: process.stdout });
-    const closed = new Promise((_, reject) => {
-        reader.once('close', () => reject(new Error('no code was typed')));
-    });
-    try {
-        return (await Promise.race([reader.question(question), closed])).trim();
-    }
-    finally {
-        reader.close();
-    }
+const USAGE = `usage: kit login [--house <origin>] [--environment <id>] [--rooms <ref>[,<ref>...] | --no-private] [--code <code>]
+  --house <origin>          the House to connect to, ${DEFAULT_HOUSE} unless one is stored
+  --environment <id>        reconnect this Environment
+  --rooms <ref>[,<ref>...]  give this Environment only these Rooms
+  --no-private              give this Environment every Room but your Private Room
+  --code <code>             connect this machine with a login code
+`;
+function chosenRooms(rooms, noPrivate) {
+    if (rooms !== undefined && noPrivate)
+        throw new Error('--rooms and --no-private are two choices of Rooms; pass one');
+    if (rooms !== undefined)
+        return { rooms: { reach: 'selected', refs: rooms.split(',') } };
+    return noPrivate ? { rooms: { reach: 'all_but_private' } } : {};
 }
 export async function login(argv) {
     const { values } = parseArgs({
@@ -76,65 +44,66 @@ export async function login(argv) {
         options: {
             house: { type: 'string' },
             environment: { type: 'string' },
-            manual: { type: 'boolean', default: false },
+            rooms: { type: 'string' },
+            'no-private': { type: 'boolean', default: false },
+            code: { type: 'string' },
+            help: { type: 'boolean', default: false },
         },
     });
+    if (values.help) {
+        process.stdout.write(USAGE);
+        return;
+    }
+    if (values.code !== undefined && values.rooms !== undefined)
+        throw new Error('--code cannot be used with --rooms');
+    if (values.code !== undefined && values['no-private'])
+        throw new Error('--code cannot be used with --no-private');
+    if (values.code !== undefined && values.environment !== undefined)
+        throw new Error('--code cannot be used with --environment');
+    const rooms = chosenRooms(values.rooms, values['no-private']);
     const enrolled = (await readEnrolment()) ?? (await readDisconnected());
+    if (values.code !== undefined && enrolled !== null) {
+        throw new Error(`--code connects a new machine; this Kit home records Environment ${enrolled.environment}, so run kit login to reconnect it`);
+    }
+    const relay = process.env.HOUSE_KIT_RELAY || undefined;
+    selectRelay(relay);
     const house = values.house ?? enrolled?.house ?? DEFAULT_HOUSE;
     const replaces = process.env.HOUSE_KIT_REPLACES;
     const environment = replaces === undefined ? (values.environment ?? (enrolled?.house === house ? enrolled.environment : undefined)) : undefined;
     const ownAgent = await readOwnAgent();
-    const held = ownAgent !== null && ownAgent.house === house && (await accepted(house, ownAgent.credential));
-    const verifier = randomBytes(32).toString('base64url');
-    const started = {
-        ...(environment === undefined
-            ? { act: 'new_environment', label: hostname(), ...(replaces === undefined ? {} : { replaces }) }
-            : { act: 'existing_environment', environment_id: environment }),
-        code_challenge: createHash('sha256').update(verifier).digest('base64url'),
-        ...(held ? {} : { headless: true }),
-    };
-    const exchange = async (code) => {
-        const exchanged = await post(house, '/kit/token', { code, code_verifier: verifier });
-        await writeEnrolment({ house, environment: exchanged.environment, credential: exchanged.credential });
-        process.stdout.write(`Environment ${exchanged.environment} is connected to ${house}.\n`);
-        if (exchanged.headless_credential !== undefined) {
-            await writeOwnAgent({ house, user: exchanged.user, credential: exchanged.headless_credential });
-        }
-        else if (held && ownAgent.user !== exchanged.user) {
-            await forgetOwnAgent();
-            process.stdout.write("This computer's own agent was another User's; run kit login again to connect it to you.\n");
-        }
-    };
-    const placeGit = async () => placeAppGit(ownAgent, await readOwnAgent());
-    if (values.manual) {
-        const { start_url } = await post(house, '/kit', {
-            ...started,
-            presentation: 'manual',
-        });
-        process.stdout.write(`Open this link and confirm: ${start_url}\n`);
-        await exchange(await typed('Code: '));
-        await placeGit();
-        return;
+    let held = false;
+    let exchanged;
+    if (values.code !== undefined) {
+        exchanged = await post(house, '/kit/token', { code: values.code, label: hostname() });
     }
-    const callback = await listen();
-    try {
-        const { start_url } = await post(house, '/kit', {
-            ...started,
-            presentation: 'loopback',
-            loopback_uri: callback.uri,
-        });
-        process.stdout.write(`Open this link and confirm: ${start_url}\n`);
-        try {
-            await exchange(await callback.code);
-        }
-        catch (error) {
-            await callback.answer(`This Environment was not connected: ${error.message}`);
-            throw error;
-        }
-        await callback.answer('This Environment is connected. You can close this tab.');
+    else {
+        held = ownAgent !== null && ownAgent.house === house && (await accepted(house, ownAgent.credential));
+        const verifier = randomBytes(32).toString('base64url');
+        const started = await retrying(() => post(house, '/kit', {
+            ...(environment === undefined
+                ? { act: 'new_environment', label: hostname(), ...(replaces === undefined ? {} : { replaces }) }
+                : { act: 'existing_environment', environment_id: environment }),
+            ...rooms,
+            code_challenge: createHash('sha256').update(verifier).digest('base64url'),
+            ...(held ? {} : { headless: true }),
+        }));
+        process.stdout.write(`Open this link and confirm: ${started.start_url}\n`);
+        open(started.start_url);
+        exchanged = await retrying(() => post(house, '/kit/token', { login: started.login, code_verifier: verifier }), undefined, () => POLL_INTERVAL_MS);
+    }
+    await writeEnrolment({
+        house,
+        ...(relay === undefined ? {} : { relay }),
+        environment: exchanged.environment,
+        credential: exchanged.credential,
+    });
+    process.stdout.write(`Environment ${exchanged.environment} is connected to ${house}.\n`);
+    if (exchanged.headless_credential !== undefined) {
+        await writeOwnAgent({ house, user: exchanged.user, credential: exchanged.headless_credential });
     }
-    finally {
-        callback.close();
+    else if (held && ownAgent !== null && ownAgent.user !== exchanged.user) {
+        await forgetOwnAgent();
+        process.stdout.write("This computer's own agent was another User's; run kit login again to connect it to you.\n");
     }
-    await placeGit();
+    await placeAppGit(ownAgent, await readOwnAgent());
 }

package/dist/logout.js

@@ -1,21 +1,21 @@
 import { HouseRefusal, post } from './api.js';
 import { forgetAppGit } from './app-git.js';
-import { forgetEnrolment, readEnrolment } from './home.js';
+import { forgetEnrolment, forgetOwnAgent, readEnrolment } from './home.js';
 export async function logout() {
     const enrolled = await readEnrolment();
-    if (enrolled === null) {
-        await forgetAppGit();
-        process.stdout.write('This computer is not connected to House.\n');
-        return;
+    if (enrolled !== null) {
+        try {
+            await post(enrolled.house, '/kit/logout', {}, enrolled.credential);
+        }
+        catch (error) {
+            if (!(error instanceof HouseRefusal && error.status === 401))
+                throw error;
+        }
+        await forgetEnrolment(enrolled);
     }
-    try {
-        await post(enrolled.house, '/kit/logout', {}, enrolled.credential);
-    }
-    catch (error) {
-        if (!(error instanceof HouseRefusal && error.status === 401))
-            throw error;
-    }
-    await forgetEnrolment(enrolled);
     await forgetAppGit();
-    process.stdout.write(`Environment ${enrolled.environment} is disconnected; kit login reconnects it.\n`);
+    await forgetOwnAgent();
+    process.stdout.write(enrolled === null
+        ? 'This computer is not connected to House.\n'
+        : `Environment ${enrolled.environment} is disconnected; kit login reconnects it.\n`);
 }

package/dist/relay.js

@@ -1,7 +1,17 @@
+let selected;
+export function selectRelay(relay) {
+    selected = relay === undefined || relay === '' ? null : relay;
+}
+function relayOrigin() {
+    if (selected !== undefined)
+        return selected ?? undefined;
+    const ambient = process.env.HOUSE_KIT_RELAY;
+    return ambient === undefined || ambient === '' ? undefined : ambient;
+}
 export function relayed(target) {
     const url = new URL(target);
-    const relay = process.env.HOUSE_KIT_RELAY;
-    if (relay === undefined || relay === '')
+    const relay = relayOrigin();
+    if (relay === undefined)
         return url;
     const through = new URL(`${url.host}${url.pathname}${url.search}`, `${relay}/`);
     if (url.protocol === 'wss:' || url.protocol === 'ws:')