@agentshouse/kit 0.2.1-c3cf4b145dcda → 0.2.1-c3e86aacccc80

package/dist/login.js

@@ -1,54 +1,22 @@
+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';
+import { startService } from './service.js';
+import { placeSkillSet } from './skills.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 +26,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 +46,79 @@ 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() });
+    }
+    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', {
+            label: hostname(),
+            ...(environment === undefined
+                ? { act: 'new_environment', ...(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);
+    }
+    try {
+        await placeSkillSet();
+    }
+    catch (error) {
+        process.stderr.write(`kit: the skills could not be placed: ${error.message}\n`);
+    }
+    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 });
+    }
+    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");
     }
-    const callback = await listen();
+    await placeAppGit(ownAgent, await readOwnAgent());
     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.');
+        startService();
     }
-    finally {
-        callback.close();
+    catch (error) {
+        process.stderr.write(`kit: ${error.message}\n`);
     }
-    await placeGit();
 }

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

@@ -2,7 +2,10 @@ export class Parts {
     parts = [];
     context = null;
     emit;
+    made = [];
+    events = 0;
     writing = null;
+    counting = null;
     planned = null;
     constructor(emit) {
         this.emit = emit;
@@ -10,32 +13,34 @@ export class Parts {
     write(type, id, text) {
         if (text === '')
             return;
-        const last = this.parts.length - 1;
-        const part = this.parts[last];
-        if (this.writing?.type === type && this.writing.id === id && part?.type === type) {
-            part.text += text;
-            this.emit({ op: 'append', index: last, text });
+        if (this.writing?.type === type && this.writing.id === id) {
+            this.parts[this.writing.index].text += text;
+            this.emit({ op: 'append', index: this.writing.index, text });
             return;
         }
-        this.start({ type, text });
-        this.writing = { type, id };
+        this.writing = { type, id, index: this.start({ type, text }) };
     }
     command() {
-        const last = this.parts.length - 1;
-        const part = this.parts[last];
-        if (part?.type !== 'commands') {
-            this.start({ type: 'commands', count: 1 });
+        if (this.counting === null) {
+            this.counting = this.start({ type: 'commands', count: 1 });
             return;
         }
+        const part = this.parts[this.counting];
         part.count++;
-        this.emit({ op: 'count', index: last, count: part.count });
+        this.emit({ op: 'count', index: this.counting, count: part.count });
     }
     start(part) {
         this.writing = null;
-        this.parts.push(part);
-        const index = this.parts.length - 1;
-        this.emit({ op: 'start', index, part });
-        return index;
+        this.counting = null;
+        return this.add(part, ++this.events);
+    }
+    reserve() {
+        this.writing = null;
+        this.counting = null;
+        return ++this.events;
+    }
+    arrive(part, reserved) {
+        this.add(part, reserved);
     }
     done(index, result) {
         const part = this.parts[index];
@@ -55,10 +60,23 @@ export class Parts {
         this.context = context;
         this.emit({ op: 'context', ...context });
     }
+    saved() {
+        return this.parts
+            .map((part, index) => ({ part, made: this.made[index] }))
+            .sort((a, b) => a.made - b.made)
+            .map(({ part }) => part);
+    }
     operations() {
         return [
             ...this.parts.map((part, index) => ({ op: 'start', index, part })),
             ...(this.context === null ? [] : [{ op: 'context', ...this.context }]),
         ];
     }
+    add(part, made) {
+        this.parts.push(part);
+        this.made.push(made);
+        const index = this.parts.length - 1;
+        this.emit({ op: 'start', index, part });
+        return index;
+    }
 }

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:')

package/dist/resident.js

@@ -2,45 +2,52 @@ import { once } from 'node:events';
 import { watch } from 'node:fs';
 import { mkdir, rm, writeFile } from 'node:fs/promises';
 import { createServer } from 'node:http';
-import { extname, join } from 'node:path';
+import { dirname, extname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { killDescendants } from './acp.js';
 import { Agents } from './agents.js';
 import { house } from './api.js';
 import { received } from './bridge.js';
 import { Conversations } from './conversations.js';
 import { LocalCopies } from './copies.js';
-import { agentBase, enrolled, kitHome } from './home.js';
+import { restart } from './end.js';
+import { agentBase, enrolled, forgetRestart, kitHome, restartAsked } from './home.js';
+import { killDescendants } from './scope.js';
 import { quoted } from './shell.js';
 import { SignIns } from './sign-in.js';
 import { placeSkillSet } from './skills.js';
 import { holdStream } from './stream.js';
 import { Updates } from './update.js';
+import { codexLauncher } from './work.js';
 function report(error) {
     process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
 }
 function logged(work) {
     work.catch(report);
 }
-async function installShim() {
-    const main = fileURLToPath(new URL(`./git-main${extname(fileURLToPath(import.meta.url))}`, import.meta.url));
-    await mkdir(join(kitHome(), 'shim'), { recursive: true });
-    await writeFile(join(kitHome(), 'shim', 'git'), `#!/bin/sh\nexec ${quoted(process.execPath)} ${quoted(main)} "$@"\n`, {
-        mode: 0o755,
-    });
+async function installShim(path, module) {
+    const main = fileURLToPath(new URL(`./${module}${extname(fileURLToPath(import.meta.url))}`, import.meta.url));
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `#!/bin/sh\nexec ${quoted(process.execPath)} ${quoted(main)} "$@"\n`, { mode: 0o755 });
 }
 async function serveOwner(copies) {
     const socketPath = join(kitHome(), 'owner.sock');
     await rm(socketPath, { force: true });
     const server = createServer(async (request, response) => {
         try {
-            if (request.url !== '/git/push') {
+            const text = await received(request);
+            let answered;
+            if (request.url === '/git/fetch') {
+                answered = await copies.fetch();
+            }
+            else if (request.url === '/git/push') {
+                const { cwd, commit } = JSON.parse(text);
+                answered = await copies.push(cwd, commit, copies.owner);
+            }
+            else {
                 response.writeHead(404).end();
                 return;
             }
-            const { cwd, commit } = JSON.parse(await received(request));
-            const pushed = await copies.push(cwd, commit, copies.owner);
-            response.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify(pushed));
+            response.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify(answered));
         }
         catch (error) {
             response.writeHead(502).end(error instanceof Error ? error.message : String(error));
@@ -67,6 +74,7 @@ function connected() {
 }
 export async function resident() {
     await connected();
+    await forgetRestart();
     watch(kitHome(), () => {
         if (enrolled())
             return;
@@ -79,7 +87,8 @@ export async function resident() {
     const agents = new Agents(house);
     const copies = new LocalCopies(house);
     await copies.load();
-    await installShim();
+    await installShim(join(kitHome(), 'shim', 'git'), 'git-main');
+    await installShim(codexLauncher(), 'codex-main');
     await serveOwner(copies);
     let stream = null;
     let reported = false;
@@ -88,6 +97,9 @@ export async function resident() {
         if (!idle()) {
             reported = false;
         }
+        else if (restartAsked() && conversations.quiet()) {
+            restart('restarting for an updated CLI');
+        }
         else if (!reported) {
             reported = true;
             logged(house.deliver('/kit/idle', {}, idle));
@@ -115,18 +127,13 @@ export async function resident() {
         opened: () => {
             conversations.opened();
             changed();
-            logged(copies.select());
+            logged(copies.connected());
         },
         frame: (arrived) => {
             if (arrived.type === 'watching')
                 conversations.watching(arrived.watching === true);
             if (arrived.type === 'work_available' && arrived.subject === 'agents')
                 logged(agents.refresh());
-            if (arrived.type === 'work_available' && arrived.subject === 'local_copy')
-                logged(copies.select());
-            if (arrived.type === 'entries') {
-                copies.entries(arrived);
-            }
             if (arrived.type === 'input') {
                 reported = false;
                 if (arrived.kind === 'sign_in')