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

package/dist/enrol-main.js

@@ -0,0 +1,4 @@
+import { readFileSync } from 'node:fs';
+import { writeEnrolment } from './home.js';
+const [house, environment] = process.argv.slice(2);
+await writeEnrolment({ house: house, environment: environment, credential: readFileSync(0, 'utf8').trim() });

package/dist/git-main.js

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+import { spawn, spawnSync } from 'node:child_process';
+import { accessSync, constants, realpathSync, statSync } from 'node:fs';
+import { request } from 'node:http';
+import { constants as system } from 'node:os';
+import { delimiter, dirname, join } from 'node:path';
+import { workingCopies } from './git.js';
+import { kitHome } from './home.js';
+const VALUED = new Set(['-C', '-c', '--git-dir', '--work-tree', '--namespace', '--config-env', '--attr-source', '--super-prefix']);
+const READS = new Set([
+    'blame',
+    'branch',
+    'cat-file',
+    'check-ignore',
+    'config',
+    'describe',
+    'diff',
+    'fetch',
+    'for-each-ref',
+    'grep',
+    'help',
+    'log',
+    'ls-files',
+    'ls-tree',
+    'reflog',
+    'remote',
+    'rev-list',
+    'rev-parse',
+    'shortlog',
+    'show',
+    'show-ref',
+    'status',
+    'tag',
+    'version',
+]);
+const RELAYED = ['SIGINT', 'SIGTERM', 'SIGHUP', 'SIGQUIT'];
+function nativeGit() {
+    const shim = join(kitHome(), 'shim');
+    for (const directory of (process.env.PATH ?? '').split(delimiter)) {
+        if (directory === '')
+            continue;
+        try {
+            if (realpathSync(directory) === realpathSync(shim))
+                continue;
+            const candidate = join(directory, 'git');
+            if (!statSync(candidate).isFile())
+                continue;
+            accessSync(candidate, constants.X_OK);
+            return candidate;
+        }
+        catch { }
+    }
+    return null;
+}
+function captured(git, args) {
+    const ran = spawnSync(git, args, {
+        stdio: ['ignore', 'pipe', 'ignore'],
+        maxBuffer: Infinity,
+        env: { ...process.env, LC_ALL: 'C' },
+    });
+    return ran.status === 0 ? ran.stdout.toString('utf8') : null;
+}
+function delegated(git, args) {
+    return new Promise((resolve) => {
+        const child = spawn(git, args, { stdio: 'inherit' });
+        const relay = (signal) => child.kill(signal);
+        for (const signal of RELAYED)
+            process.on(signal, relay);
+        const settle = (outcome) => {
+            for (const signal of RELAYED)
+                process.off(signal, relay);
+            resolve(outcome);
+        };
+        child.once('error', (error) => {
+            process.stderr.write(`git: ${error.message}\n`);
+            settle({ status: 127, signal: null });
+        });
+        child.once('close', (status, signal) => settle({ status, signal }));
+    });
+}
+function staged(listing) {
+    const entries = new Map();
+    for (const record of (listing ?? '').split('\0')) {
+        const tab = record.indexOf('\t');
+        if (tab >= 0)
+            entries.set(record.slice(tab + 1), record.slice(0, tab).split(' ')[1]);
+    }
+    return entries;
+}
+function moved(planned, before, after) {
+    const moves = [];
+    for (const line of planned.split('\n')) {
+        if (!line.startsWith('Renaming '))
+            continue;
+        const renaming = line.slice('Renaming '.length);
+        for (let at = renaming.indexOf(' to '); at >= 0; at = renaming.indexOf(' to ', at + 1)) {
+            const from = renaming.slice(0, at);
+            const to = renaming.slice(at + 4);
+            if (before.has(from) && !after.has(from) && after.get(to) === before.get(from)) {
+                moves.push({ from, to });
+                break;
+            }
+        }
+    }
+    return moves;
+}
+function reported(socketPath, body) {
+    return new Promise((resolve) => {
+        const sent = request({ socketPath, path: '/git/observed', method: 'POST' }, (answer) => {
+            answer.resume();
+            answer.on('end', resolve);
+        });
+        sent.on('error', () => resolve());
+        sent.end(JSON.stringify(body));
+    });
+}
+async function observed(git, args) {
+    let index = 0;
+    while (index < args.length && args[index].startsWith('-'))
+        index += VALUED.has(args[index]) ? 2 : 1;
+    const globals = args.slice(0, index);
+    const name = args[index];
+    const bridge = process.env.HOUSE_BRIDGE;
+    if (bridge === undefined || name === undefined || READS.has(name))
+        return delegated(git, args);
+    const located = captured(git, [...globals, 'rev-parse', '--path-format=absolute', '--git-common-dir', '--show-toplevel']);
+    const [common, worktree] = located?.split('\n') ?? [];
+    if (common === undefined || worktree === undefined || !dirname(common).startsWith(`${workingCopies()}/`)) {
+        return delegated(git, args);
+    }
+    const listing = [...globals, '-C', worktree, 'ls-files', '--stage', '-z'];
+    const before = name === 'mv' ? staged(captured(git, listing)) : null;
+    const planned = name === 'mv' ? (captured(git, [...globals, 'mv', '--dry-run', ...args.slice(index + 1)]) ?? '') : '';
+    const outcome = await delegated(git, args);
+    const moves = before !== null && outcome.status === 0 ? moved(planned, before, staged(captured(git, listing))) : [];
+    await reported(bridge, { common, worktree, moves });
+    return outcome;
+}
+const git = nativeGit();
+if (git === null) {
+    process.stderr.write('git: no installed Git found on PATH\n');
+    process.exitCode = 127;
+}
+else {
+    observed(git, process.argv.slice(2)).then(({ status, signal }) => {
+        if (signal === null) {
+            process.exitCode = status ?? 1;
+            return;
+        }
+        process.exitCode = 128 + system.signals[signal];
+        process.kill(process.pid, signal);
+    });
+}

package/dist/git.js

@@ -0,0 +1,85 @@
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { join } from 'node:path';
+import { withoutProxy } from './clis.js';
+import { workspaceRoot } from './home.js';
+export function workingCopies() {
+    return join(workspaceRoot(), 'working-copies');
+}
+export const HOUSE_REF = 'refs/house/received';
+const COMMITTER = 'House Kit <house-kit@localhost>';
+export function run(cwd, args, input, env = {}) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('git', args, { cwd, env: { ...withoutProxy(), ...env } });
+        const stdout = [];
+        let stderr = '';
+        child.stdout.on('data', (chunk) => stdout.push(chunk));
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk.toString('utf8');
+        });
+        child.on('error', reject);
+        child.on('close', (status) => resolve({ status, stdout: Buffer.concat(stdout), stderr }));
+        child.stdin.on('error', () => undefined);
+        child.stdin.end(input);
+    });
+}
+export async function git(cwd, args, input, env) {
+    const ran = await run(cwd, args, input, env);
+    if (ran.status !== 0)
+        throw new Error(`git ${args[0]} failed: ${ran.stderr.trim()}`);
+    return ran.stdout.toString('utf8');
+}
+export async function succeeded(cwd, args, env) {
+    return (await run(cwd, args, undefined, env)).status === 0;
+}
+export async function revision(cwd, name) {
+    return (await git(cwd, ['rev-parse', '--verify', `${name}^{commit}`])).trim();
+}
+export async function tree(repository, commit) {
+    const listed = await git(repository, ['ls-tree', '-r', '-z', commit]);
+    const entries = new Map();
+    for (const entry of listed.split('\0')) {
+        const tab = entry.indexOf('\t');
+        if (tab < 0)
+            continue;
+        const [, type, object] = entry.slice(0, tab).split(' ');
+        if (type === 'blob')
+            entries.set(entry.slice(tab + 1), object);
+    }
+    return entries;
+}
+export async function blobText(repository, object, path) {
+    const bytes = (await run(repository, ['cat-file', 'blob', object])).stdout;
+    try {
+        return new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(bytes);
+    }
+    catch {
+        throw new Error(`${path} is binary and House stores only text; remove it from the commit`);
+    }
+}
+export function blobId(content) {
+    const bytes = Buffer.from(content, 'utf8');
+    return createHash('sha1').update(`blob ${bytes.length}\0`).update(bytes).digest('hex');
+}
+function quoted(path) {
+    return `"${path.replace(/[\\"]/g, '\\$&').replace(/\n/g, '\\n')}"`;
+}
+function data(text) {
+    const bytes = Buffer.from(text, 'utf8');
+    return [Buffer.from(`data ${bytes.length}\n`), bytes, Buffer.from('\n')];
+}
+export async function importCommits(repository, commits) {
+    const stream = [];
+    for (const [index, commit] of commits.entries()) {
+        stream.push(Buffer.from(`commit ${HOUSE_REF}\nmark :${index + 1}\ncommitter ${COMMITTER} ${Math.floor(Date.now() / 1000)} +0000\n`), ...data(commit.message), ...(commit.from === null ? [] : [Buffer.from(`from ${commit.from}\n`)]), ...(commit.merge === undefined ? [] : [Buffer.from(`merge ${commit.merge}\n`)]), ...(commit.replaces === true ? [Buffer.from('deleteall\n')] : []));
+        for (const [path, content] of commit.files) {
+            if (content === null)
+                stream.push(Buffer.from(`D ${quoted(path)}\n`));
+            else
+                stream.push(Buffer.from(`M 100644 inline ${quoted(path)}\n`), ...data(content));
+        }
+        stream.push(Buffer.from('\n'));
+    }
+    await git(repository, ['fast-import', '--quiet', '--force'], Buffer.concat(stream));
+    return revision(repository, HOUSE_REF);
+}

package/dist/home.js

@@ -1,13 +1,21 @@
-import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+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 CONFIGURATION = 'kit.json';
+const OWN_AGENT = 'own-agent.json';
 export function kitHome() {
     return process.env.HOUSE_KIT_HOME ?? join(homedir(), '.house-kit');
 }
-export async function readEnrolment() {
+export function workspaceRoot() {
+    return process.env.HOUSE_KIT_WORKSPACE ?? '/agents/house';
+}
+export function agentBase() {
+    return join(workspaceRoot(), 'agents');
+}
+export async function readHome(name) {
     try {
-        return JSON.parse(await readFile(join(kitHome(), ENROLMENT), 'utf8'));
+        return JSON.parse(await readFile(join(kitHome(), name), 'utf8'));
     }
     catch (error) {
         if (error.code === 'ENOENT')
@@ -15,10 +23,31 @@ export async function readEnrolment() {
         throw error;
     }
 }
-export async function writeEnrolment(enrolment) {
+export async function writeHome(name, value) {
     const home = kitHome();
     await mkdir(home, { recursive: true, mode: 0o700 });
-    const temporary = join(home, `${ENROLMENT}.${process.pid}`);
-    await writeFile(temporary, `${JSON.stringify(enrolment)}\n`, { mode: 0o600 });
-    await rename(temporary, join(home, ENROLMENT));
+    const temporary = join(home, `${name}.${process.pid}`);
+    await writeFile(temporary, `${JSON.stringify(value)}\n`, { mode: 0o600 });
+    await rename(temporary, join(home, name));
+}
+export function readEnrolment() {
+    return readHome(ENROLMENT);
+}
+export function writeEnrolment(enrolment) {
+    return writeHome(ENROLMENT, enrolment);
+}
+export function readOwnAgent() {
+    return readHome(OWN_AGENT);
+}
+export function writeOwnAgent(ownAgent) {
+    return writeHome(OWN_AGENT, ownAgent);
+}
+export function forgetOwnAgent() {
+    return rm(join(kitHome(), OWN_AGENT), { force: true });
+}
+export async function readConfiguration() {
+    return { skills: (await readHome(CONFIGURATION))?.skills !== false };
+}
+export function writeConfiguration(configuration) {
+    return writeHome(CONFIGURATION, configuration);
 }

package/dist/house-main.js

@@ -1,13 +1,34 @@
 #!/usr/bin/env node
-import { createHash, randomUUID } from 'node:crypto';
+import { createHash } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
-import { request } from 'node:http';
-import { basename } from 'node:path';
+import { request, setGlobalProxyFromEnv } from 'node:http';
+import { basename, join } from 'node:path';
+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 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';
+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";
 const socketPath = process.env.HOUSE_BRIDGE;
-function bridged(path, body) {
+function refused(path, status, text) {
+    const refusal = refusalOf(text);
+    if (refusal !== null)
+        return refusal.text;
+    if (status === 401)
+        return REVOKED;
+    if (URL.canParse(path))
+        return `the upload answered ${status}; upload the file again`;
+    if (status === 502 && /^[A-Za-z]/.test(text))
+        return text;
+    return `${path} answered ${status}`;
+}
+function bridged(path, body, headers = { 'content-type': 'application/json' }, to = socketPath) {
     return new Promise((resolve, reject) => {
-        const sent = request({ socketPath, path, method: 'POST', headers: { 'content-type': 'application/json' } }, (answer) => {
+        const sent = request({ socketPath: to, path, method: 'POST', headers }, (answer) => {
             let text = '';
             answer.setEncoding('utf8');
             answer.on('data', (chunk) => {
@@ -17,15 +38,28 @@ function bridged(path, body) {
                 if (answer.statusCode === 200)
                     resolve(text);
                 else
-                    reject(new Error(`${path} answered ${answer.statusCode}: ${text}`));
+                    reject(new Error(refused(path, answer.statusCode, text)));
             });
         });
-        sent.on('error', reject);
-        sent.end(JSON.stringify(body));
+        sent.on('error', () => reject(new Error(CLOSED)));
+        sent.end(body instanceof Buffer ? body : JSON.stringify(body));
+    });
+}
+async function direct(message) {
+    const ownAgent = await readOwnAgent();
+    if (ownAgent === null)
+        throw new Error(UNCONNECTED);
+    setGlobalProxyFromEnv();
+    const answer = await callHouse(ownAgent.house, ownAgent.credential, message).catch(() => {
+        throw new Error(UNREACHABLE);
     });
+    if (answer.status === 200)
+        return answer.text;
+    throw new Error(answer.status === 401 ? DISCONNECTED : (refusalOf(answer.text)?.text ?? `House answered ${answer.status}`));
 }
 async function mcp(method, params) {
-    const answer = JSON.parse(await bridged('/', { jsonrpc: '2.0', id: 1, method, params }));
+    const message = rpc(method, params);
+    const answer = JSON.parse(socketPath === undefined ? await direct(message) : await bridged('/', message));
     if (answer.error !== undefined)
         throw new Error(answer.error.message);
     return answer.result;
@@ -33,60 +67,97 @@ async function mcp(method, params) {
 async function tools() {
     return (await mcp('tools/list', {})).tools;
 }
-async function upload(path, roomRef) {
-    const bytes = await readFile(path);
+async function localFile(path) {
+    try {
+        return await readFile(path);
+    }
+    catch (error) {
+        throw new Error(error.code === 'EISDIR'
+            ? `${path} is a folder; upload one file at a time`
+            : `${path} is not a readable file`);
+    }
+}
+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', {
         ...(roomRef === undefined ? {} : { room_ref: roomRef }),
-        version: randomUUID(),
         name: basename(path),
         bytes: bytes.length,
         sha256: createHash('sha256').update(bytes).digest('hex'),
     }));
-    const answer = await fetch(declared.upload.url, {
-        method: 'POST',
-        headers: { 'content-type': 'application/octet-stream', 'x-house-byte-operation': declared.upload.operation },
-        body: bytes,
-    });
-    const text = await answer.text();
-    if (!answer.ok)
-        throw new Error(`House refused the bytes of ${path} with ${answer.status}: ${text}`);
-    return text;
+    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,
+    }));
+    if (saved.upload_failure !== undefined)
+        throw new Error(`${path} was not saved: ${saved.upload_failure}; call again later`);
+    return saved.attachment;
+}
+async function gitPush(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');
+    const owner = args.includes('--owner');
+    const commit = args.slice(1).find((arg) => arg !== '--owner') ?? 'HEAD';
+    if (owner && socketPath !== undefined)
+        throw new Error('--owner is not for Agent conversations; run house git push without it');
+    if (!owner && socketPath === undefined)
+        throw new Error('outside an Agent conversation, house git 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);
+    return pushed.text;
+}
+function argumentsOf(argument) {
+    if (argument === undefined)
+        return {};
+    let parsed;
+    try {
+        parsed = JSON.parse(argument);
+    }
+    catch {
+        throw new Error(ARGUMENTS);
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+        throw new Error(ARGUMENTS);
+    return parsed;
 }
 async function house([verb, argument]) {
     if (verb === undefined || verb === '--help') {
-        return [USAGE, ...(await tools()).map((tool) => `${tool.name}: ${tool.description}`)].join('\n');
+        return [USAGE, 'git push [commit]', ...(await tools()).map((tool) => `${tool.name}: ${tool.description}`)].join('\n');
     }
     if (argument === '--help') {
         const tool = (await tools()).find((listed) => listed.name === verb);
         if (tool === undefined)
-            throw new Error(`House has no tool ${verb}`);
-        return `${tool.description}\n${JSON.stringify(tool.inputSchema, null, 2)}`;
+            throw new Error(`${verb} is no Tool; house find_command '{"query":"${verb}"}' finds Commands`);
+        return `${tool.description}\n${JSON.stringify(tool.inputSchema)}`;
     }
-    const args = (argument === undefined ? {} : JSON.parse(argument));
-    if (verb === 'upload_attachment')
-        return upload(String(args.path), args.room_ref);
-    if (verb === 'append_record' && Array.isArray(args.attachments)) {
+    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 (socketPath !== undefined && verb === 'append_record' && Array.isArray(args.attachments)) {
         const attachments = [];
         for (const path of args.attachments) {
-            attachments.push(JSON.parse(await upload(String(path), args.room_ref)).attachment);
+            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 });
     const text = result.content.map((content) => content.text).join('\n');
     if (result.isError === true)
-        throw new Error(text);
+        throw new Error(text.replace(/\n+$/, ''));
     return text;
 }
-if (socketPath === undefined) {
-    process.stderr.write('house: house runs inside an Agent conversation\n');
+const argv = process.argv.slice(2);
+(argv[0] === 'git' ? gitPush(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`);
     process.exitCode = 1;
-}
-else {
-    house(process.argv.slice(2)).then((text) => {
-        process.stdout.write(`${text}\n`);
-    }, (error) => {
-        process.stderr.write(`house: ${error instanceof Error ? error.message : String(error)}\n`);
-        process.exitCode = 1;
-    });
-}
+});

package/dist/instructions.js

@@ -1,28 +1,34 @@
+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, upload it with `house upload_attachment` and link it in your answer.';
-const HOW_WE_WORK = '/private/library/how-we-work.md';
+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`, and before editing its Wiki, `/rooms/<handle>/library/wiki/RULES.md`.';
+const COPIES_LINE = 'House working copies; commit, then `house git 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: (.+)$/;
+function cutOf(lines) {
+    const cut = CUT.exec(lines[0] ?? '');
+    return cut !== null && Buffer.byteLength(lines.slice(1).join('\n')) === Number(cut[1]) ? cut : null;
+}
 async function howWeWork(bridge) {
     let document = '';
     for (let command = `cat ${HOW_WE_WORK}`; command !== undefined;) {
         const read = await bridge.tool('shell', { command });
         const text = read.content.map((content) => content.text).join('\n');
         const lines = text.split('\n');
-        let at = lines[5]?.startsWith('authority: ') ? 6 : 5;
-        if (read.isError === true || lines[2] !== 'exit: 0') {
-            const refusal = read.isError === true ? text : lines.slice(at).join('\n').replace(/^stderr: /gm, '');
+        if (read.isError === true || (FAILED.test(lines[0] ?? '') && lines[1]?.startsWith('stderr: '))) {
+            const refusal = read.isError === true ? text : lines.slice(1).join('\n').replace(/^stderr: /gm, '');
             if (UNREADABLE.test(refusal))
                 return '';
             throw new Error(refusal);
         }
-        const cut = lines[3] === 'truncation: egress' ? CUT.exec(lines[at++] ?? '') : null;
-        const shown = Buffer.from(`${lines.slice(at).join('\n')}\n`);
-        document += (cut === null ? shown : shown.subarray(0, Number(cut[1]))).toString();
+        const cut = cutOf(lines);
+        document += lines.slice(cut === null ? 0 : 1).join('\n');
         command = cut?.[2];
     }
     return document.replace(/\n$/, '');
 }
-export async function instructions(bridge, base) {
-    return [`${HOUSE_LINE}\n${FILE_LINE}`, base, await howWeWork(bridge)].filter((part) => part !== '').join('\n\n');
+export async function instructions(bridge, base, copies) {
+    const lines = [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/kit-main.js

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
+import { setGlobalProxyFromEnv } from 'node:http';
 import { login } from './login.js';
 import { resident } from './resident.js';
 const [command, ...argv] = process.argv.slice(2);
+setGlobalProxyFromEnv();
 async function run() {
     if (command === 'login')
         return login(argv);

package/dist/login.js

@@ -4,7 +4,8 @@ import { hostname } from 'node:os';
 import { createInterface } from 'node:readline/promises';
 import { parseArgs } from 'node:util';
 import { post } from './api.js';
-import { readEnrolment, writeEnrolment } from './home.js';
+import { forgetOwnAgent, readEnrolment, readOwnAgent, writeEnrolment, writeOwnAgent } from './home.js';
+import { callHouse, rpc } from './mcp.js';
 const DEFAULT_HOUSE = 'https://agents.house';
 function listen() {
     return new Promise((resolve, reject) => {
@@ -26,8 +27,9 @@ function listen() {
             server.close();
             server.closeAllConnections();
         };
+        const port = Number(process.env.HOUSE_KIT_LOGIN_PORT ?? 0);
         server.once('error', reject);
-        server.listen(0, '127.0.0.1', () => {
+        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'));
@@ -47,10 +49,21 @@ function listen() {
         });
     });
 }
+async function accepted(house, credential) {
+    const checked = await callHouse(house, credential, rpc('tools/list', {}));
+    if (checked.status === 200)
+        return true;
+    if (checked.status === 401)
+        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 reader.question(question)).trim();
+        return (await Promise.race([reader.question(question), closed])).trim();
     }
     finally {
         reader.close();
@@ -67,18 +80,29 @@ export async function login(argv) {
     });
     const enrolled = await readEnrolment();
     const house = values.house ?? enrolled?.house ?? DEFAULT_HOUSE;
-    const environment = values.environment ?? (enrolled?.house === house ? enrolled.environment : undefined);
+    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() }
+            ? { 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");
+        }
     };
     if (values.manual) {
         const { start_url } = await post(house, '/kit', {