@agentshouse/kit 0.2.1-cb0bd1cadcfed → 0.2.1-cbabe8ad337ff

package/dist/login.js

@@ -1,53 +1,19 @@
+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';
 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', {}));
@@ -57,25 +23,12 @@ 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();
-    }
-}
 export async function login(argv) {
     const { values } = parseArgs({
         args: argv,
         options: {
             house: { type: 'string' },
             environment: { type: 'string' },
-            manual: { type: 'boolean', default: false },
         },
     });
     const enrolled = (await readEnrolment()) ?? (await readDisconnected());
@@ -85,52 +38,24 @@ export async function login(argv) {
     const ownAgent = await readOwnAgent();
     const held = ownAgent !== null && ownAgent.house === house && (await accepted(house, ownAgent.credential));
     const verifier = randomBytes(32).toString('base64url');
-    const started = {
+    const started = await retrying(() => post(house, '/kit', {
         ...(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");
-        }
-    };
-    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: '));
-        return;
-    }
-    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.');
+    }));
+    process.stdout.write(`Open this link and confirm: ${started.start_url}\n`);
+    open(started.start_url);
+    const exchanged = await retrying(() => post(house, '/kit/token', { login: started.login, code_verifier: verifier }), undefined, () => POLL_INTERVAL_MS);
+    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 });
     }
-    finally {
-        callback.close();
+    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");
     }
+    await placeAppGit(ownAgent, await readOwnAgent());
 }

package/dist/logout.js

@@ -1,18 +1,21 @@
 import { HouseRefusal, post } from './api.js';
-import { forgetEnrolment, readEnrolment } from './home.js';
+import { forgetAppGit } from './app-git.js';
+import { forgetEnrolment, forgetOwnAgent, readEnrolment } from './home.js';
 export async function logout() {
     const enrolled = await readEnrolment();
-    if (enrolled === null) {
-        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);
-    process.stdout.write(`Environment ${enrolled.environment} is disconnected; kit login reconnects it.\n`);
+    await forgetAppGit();
+    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

@@ -0,0 +1,64 @@
+export class Parts {
+    parts = [];
+    context = null;
+    emit;
+    writing = null;
+    planned = null;
+    constructor(emit) {
+        this.emit = emit;
+    }
+    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 });
+            return;
+        }
+        this.start({ type, text });
+        this.writing = { type, id };
+    }
+    command() {
+        const last = this.parts.length - 1;
+        const part = this.parts[last];
+        if (part?.type !== 'commands') {
+            this.start({ type: 'commands', count: 1 });
+            return;
+        }
+        part.count++;
+        this.emit({ op: 'count', index: last, 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;
+    }
+    done(index, result) {
+        const part = this.parts[index];
+        part.status = 'done';
+        part.result = result;
+        this.emit({ op: 'status', index, status: 'done', result });
+    }
+    plan(entries) {
+        if (this.planned === null) {
+            this.planned = this.start({ type: 'plan', entries });
+            return;
+        }
+        this.parts[this.planned].entries = entries;
+        this.emit({ op: 'plan', index: this.planned, entries });
+    }
+    measure(context) {
+        this.context = context;
+        this.emit({ op: 'context', ...context });
+    }
+    operations() {
+        return [
+            ...this.parts.map((part, index) => ({ op: 'start', index, part })),
+            ...(this.context === null ? [] : [{ op: 'context', ...this.context }]),
+        ];
+    }
+}

package/dist/resident.js

@@ -2,34 +2,31 @@ 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 { 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);
 }
-function quoted(value) {
-    return `'${value.replaceAll("'", `'\\''`)}'`;
-}
-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');
@@ -81,7 +78,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;
@@ -120,6 +118,8 @@ export async function resident() {
             logged(copies.select());
         },
         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')

package/dist/scope.js

@@ -0,0 +1,203 @@
+import { execFileSync } from 'node:child_process';
+import { mkdirSync, readdirSync, readFileSync, rmdirSync, statSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+const LISTING_BYTES = 1 << 28;
+const CGROUPS = '/sys/fs/cgroup';
+const GONE = new Set(['ENOENT', 'ESRCH']);
+function failure(error) {
+    return error.code ?? '';
+}
+function listed(environment) {
+    const found = new Map();
+    const output = execFileSync('ps', [environment ? '-AEww' : '-Aww', '-o', 'pid=,ppid=,sess=,command='], {
+        encoding: 'utf8',
+        maxBuffer: LISTING_BYTES,
+    });
+    for (const line of output.split('\n')) {
+        const fields = /^\s*(\d+)\s+(\d+)\s+(\S+)\s?(.*)$/.exec(line);
+        if (fields !== null)
+            found.set(Number(fields[1]), { parent: Number(fields[2]), session: fields[3], command: fields[4] });
+    }
+    return found;
+}
+function read(pid) {
+    try {
+        const stat = readFileSync(`/proc/${pid}/stat`, 'utf8');
+        const fields = stat.slice(stat.lastIndexOf(')') + 2).split(' ');
+        const command = readFileSync(`/proc/${pid}/cmdline`, 'utf8').replaceAll('\0', ' ');
+        return { parent: Number(fields[1]), session: fields[3], command };
+    }
+    catch (error) {
+        if (GONE.has(failure(error)))
+            return null;
+        throw error;
+    }
+}
+function processes() {
+    if (process.platform === 'darwin')
+        return listed(false);
+    const found = new Map();
+    for (const entry of readdirSync('/proc')) {
+        const running = /^\d+$/.test(entry) ? read(entry) : null;
+        if (running !== null)
+            found.set(Number(entry), running);
+    }
+    return found;
+}
+function descendants(roots, table = processes()) {
+    const children = new Map();
+    for (const [pid, { parent }] of table)
+        children.set(parent, [...(children.get(parent) ?? []), pid]);
+    const tree = [];
+    const pending = roots.flatMap((root) => children.get(root) ?? []);
+    while (pending.length > 0) {
+        const pid = pending.pop();
+        tree.push(pid);
+        pending.push(...(children.get(pid) ?? []));
+    }
+    return tree;
+}
+function marked(marker, doubted) {
+    if (process.platform === 'darwin') {
+        return [...listed(true)].filter(([, { command }]) => ` ${command} `.includes(` ${marker} `)).map(([pid]) => pid);
+    }
+    return readdirSync('/proc')
+        .filter((entry) => /^\d+$/.test(entry) && carries(entry, marker, doubted))
+        .map(Number);
+}
+function carries(pid, marker, doubted) {
+    try {
+        return readFileSync(`/proc/${pid}/environ`, 'utf8').split('\0').includes(marker);
+    }
+    catch (error) {
+        if (GONE.has(failure(error)))
+            return false;
+        if (failure(error) !== 'EACCES')
+            throw error;
+        return doubted && statSync(`/proc/${pid}`, { throwIfNoEntry: false })?.uid === process.getuid();
+    }
+}
+function killAll(pids) {
+    for (const pid of pids) {
+        for (const target of [-pid, pid]) {
+            try {
+                process.kill(target, 'SIGKILL');
+            }
+            catch { }
+        }
+    }
+}
+export function killTree(child) {
+    killAll([child.pid, ...descendants([child.pid])]);
+}
+export function killMarked(marker) {
+    const pids = marked(marker, false);
+    killAll([...pids, ...descendants(pids)]);
+}
+export function killDescendants() {
+    const pids = marked(`HOUSE_KIT_RESIDENT=${process.pid}`, false);
+    killAll([...pids, ...descendants([process.pid, ...pids])]);
+}
+function ownGroup() {
+    if (process.platform !== 'linux')
+        return null;
+    try {
+        const line = readFileSync('/proc/self/cgroup', 'utf8')
+            .split('\n')
+            .find((entry) => entry.startsWith('0::'));
+        return line === undefined ? null : join(CGROUPS, line.slice(3));
+    }
+    catch {
+        return null;
+    }
+}
+function members(group) {
+    const pids = readFileSync(join(group, 'cgroup.procs'), 'utf8').split('\n').filter(Boolean).map(Number);
+    for (const entry of readdirSync(group, { withFileTypes: true })) {
+        if (entry.isDirectory())
+            pids.push(...members(join(group, entry.name)));
+    }
+    return pids;
+}
+export class Scope {
+    marker;
+    cli;
+    group;
+    session = null;
+    recorded = null;
+    constructor(marker, name, cli) {
+        this.marker = marker;
+        this.cli = cli;
+        const own = ownGroup();
+        this.group = own === null ? null : join(own, name);
+        try {
+            if (this.group !== null)
+                mkdirSync(this.group);
+        }
+        catch {
+            this.group = null;
+        }
+    }
+    command(command, args) {
+        if (this.group === null)
+            return [command, args];
+        return ['/bin/sh', ['-c', 'echo $$ > "$0/cgroup.procs" 2>/dev/null; exec "$@"', this.group, command, ...args]];
+    }
+    entered(pid) {
+        this.session = process.platform === 'darwin' ? (listed(false).get(pid)?.session ?? null) : String(pid);
+        if (this.group === null)
+            return;
+        const joined = readFileSync(`/proc/${pid}/cgroup`, 'utf8').split('\n').find((entry) => entry.startsWith('0::'));
+        if (joined !== undefined && join(CGROUPS, joined.slice(3)) === this.group)
+            return;
+        this.close();
+        this.group = null;
+    }
+    record() {
+        const found = this.found();
+        if (found === null)
+            return;
+        this.recorded = new Set([...found].filter(([, { session }]) => session === this.session).map(([pid]) => pid));
+    }
+    working() {
+        const found = this.found();
+        if (found === null)
+            return true;
+        if (this.recorded === null)
+            return found.size > 0;
+        return [...found].some(([pid, { session, command }]) => session !== this.session || !(this.recorded.has(pid) || command.startsWith(`${this.cli}-`)));
+    }
+    empty() {
+        return this.found()?.size === 0;
+    }
+    kill() {
+        killMarked(this.marker);
+        if (this.group === null)
+            return;
+        try {
+            writeFileSync(join(this.group, 'cgroup.kill'), '1');
+        }
+        catch {
+            killAll([...(this.found()?.keys() ?? [])]);
+        }
+    }
+    close() {
+        if (this.group === null)
+            return;
+        try {
+            rmdirSync(this.group);
+        }
+        catch { }
+    }
+    found() {
+        try {
+            const table = processes();
+            const roots = this.group === null ? marked(this.marker, true) : members(this.group);
+            const pids = this.group === null ? [...roots, ...descendants(roots, table)] : roots;
+            return new Map(pids.flatMap((pid) => (table.has(pid) ? [[pid, table.get(pid)]] : [])));
+        }
+        catch {
+            return null;
+        }
+    }
+}

package/dist/shell.js

@@ -0,0 +1,3 @@
+export function quoted(value) {
+    return `'${value.replaceAll("'", `'\\''`)}'`;
+}

package/dist/sign-in.js

@@ -1,7 +1,7 @@
 import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
-import { killTree } from './acp.js';
 import { CLIS, withoutProxy } from './clis.js';
+import { killTree } from './scope.js';
 import { holdSecretInput } from './secret-input.js';
 const ESCAPE = /\u001b\[[\d;]*m/g;
 const LINK = /https:\/\/\S+/;
@@ -12,6 +12,9 @@ function causeOf(error) {
 function logged(error) {
     process.stderr.write(`kit: ${causeOf(error)}\n`);
 }
+function endOf(signal) {
+    return new Promise((resolve) => signal.addEventListener('abort', () => resolve(true), { once: true }));
+}
 export class SignIns {
     house;
     agents;
@@ -30,25 +33,43 @@ export class SignIns {
             return;
         this.running.add(input.input_id);
         this.changed();
-        this.login(input)
-            .then(() => this.agents.recheck(input.cli))
-            .then(() => this.house.deliver(`/kit/inputs/${input.input_id}/ack`, {}))
-            .then(() => this.agents.reread(input.cli))
+        this.signIn(input)
             .catch(logged)
             .finally(() => {
             this.running.delete(input.input_id);
             this.changed();
         });
     }
-    async login(input) {
+    async signIn(input) {
+        const ending = new AbortController();
+        // House stops waiting for a sign-in ten minutes after it wrote it and sends the seconds left, so its install and login end with the page.
+        const timer = setTimeout(() => ending.abort(), input.ends_in * 1000);
+        const ended = await Promise.race([this.signedIn(input, ending.signal), endOf(ending.signal)]);
+        clearTimeout(timer);
+        if (ended)
+            process.stderr.write(`kit: the ${input.cli} sign-in reached the end House set for it\n`);
+        await this.house.deliver(`/kit/inputs/${input.input_id}/ack`, {});
+        if (!ended)
+            await this.agents.reread(input.cli);
+    }
+    async signedIn(input, signal) {
+        await this.login(input, signal);
+        if (!signal.aborted)
+            await this.agents.recheck(input.cli, signal);
+        return false;
+    }
+    async login(input, signal) {
         let cli;
         try {
-            cli = await this.agents.located(input.cli);
+            cli = await this.agents.located(input.cli, signal);
         }
         catch (error) {
-            process.stderr.write(`kit: the ${input.cli} sign-in failed: ${causeOf(error)}\n`);
+            if (!signal.aborted)
+                process.stderr.write(`kit: the ${input.cli} sign-in failed: ${causeOf(error)}\n`);
             return;
         }
+        if (signal.aborted)
+            return;
         const login = CLIS[input.cli].login;
         const child = spawn(cli, login.args, {
             stdio: ['pipe', 'pipe', 'pipe'],
@@ -56,6 +77,8 @@ export class SignIns {
             env: withoutProxy(),
         });
         const running = () => child.exitCode === null && child.signalCode === null;
+        const stop = () => killTree(child);
+        signal.addEventListener('abort', stop, { once: true });
         let link;
         let code;
         let last = '';
@@ -92,9 +115,10 @@ export class SignIns {
             createInterface({ input: output }).on('line', read);
         const failed = await new Promise((resolve) => {
             child.on('error', (error) => resolve(error.message));
-            child.on('close', (status, signal) => resolve(status === 0 ? null : `exited with ${status ?? signal}${last ? `: ${last}` : ''}`));
+            child.on('close', (status, killed) => resolve(status === 0 ? null : `exited with ${status ?? killed}${last ? `: ${last}` : ''}`));
         });
-        if (failed !== null)
+        signal.removeEventListener('abort', stop);
+        if (failed !== null && !signal.aborted)
             process.stderr.write(`kit: the ${input.cli} sign-in failed: ${failed}\n`);
     }
 }