@agentshouse/kit 0.2.1-c4ea88ba9424e → 0.2.1-c534eec03292e

package/dist/parts.js

@@ -0,0 +1,82 @@
+export class Parts {
+    parts = [];
+    context = null;
+    emit;
+    made = [];
+    events = 0;
+    writing = null;
+    counting = null;
+    planned = null;
+    constructor(emit) {
+        this.emit = emit;
+    }
+    write(type, id, text) {
+        if (text === '')
+            return;
+        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.writing = { type, id, index: this.start({ type, text }) };
+    }
+    command() {
+        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: this.counting, count: part.count });
+    }
+    start(part) {
+        this.writing = null;
+        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];
+        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 });
+    }
+    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/placement.js

@@ -0,0 +1,39 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { run } from './clis.js';
+import { kitHome } from './home.js';
+export function service() {
+    if (process.platform !== 'linux' || !process.env.INVOCATION_ID)
+        return null;
+    return process.env.MANAGERPID ? 'user' : 'system';
+}
+export function throughSudo() {
+    return service() === 'system' && process.getuid() !== 0;
+}
+export async function updatesItself() {
+    if (service() === null)
+        return false;
+    if (!throughSudo())
+        return true;
+    // sudo answers at once, so ten seconds only bounds a stuck sudo.
+    return (await run('sudo', ['-n', 'true'], 10_000)).status === 0;
+}
+function recorded(name) {
+    try {
+        return readFileSync(join(kitHome(), name), 'utf8').trim();
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+export function installCommand() {
+    return recorded('install-command');
+}
+export function machine() {
+    const placed = recorded('placement');
+    if (placed === 'container' || placed === 'server' || placed === 'windows')
+        return placed;
+    return process.platform === 'darwin' ? 'macos' : 'linux';
+}

package/dist/relay.js

@@ -1,7 +1,38 @@
+import { setGlobalProxyFromEnv } from 'node:http';
+const PROXY = /^https?_proxy$/i;
+const LOOPBACK = ['127.0.0.1', 'localhost', '::1'];
+let selected;
+let restoreProxy;
+export function selectRelay(relay) {
+    selected = relay === undefined || relay === '' ? null : relay;
+    proxyUnlessRelayed();
+}
+export function relayOrigin() {
+    if (selected !== undefined)
+        return selected ?? undefined;
+    const ambient = process.env.HOUSE_KIT_RELAY;
+    return ambient === undefined || ambient === '' ? undefined : ambient;
+}
+function unlessRelayed() {
+    if (relayOrigin() === undefined)
+        return { ...process.env };
+    return Object.fromEntries(Object.entries(process.env).filter(([name]) => !PROXY.test(name)));
+}
+export function proxyUnlessRelayed() {
+    restoreProxy?.();
+    restoreProxy = setGlobalProxyFromEnv(unlessRelayed());
+}
+export function childEnvironment() {
+    const environment = unlessRelayed();
+    if (!Object.keys(environment).some((name) => PROXY.test(name)))
+        return environment;
+    const bypassed = [environment.NO_PROXY ?? environment.no_proxy, ...LOOPBACK].filter((entry) => entry !== undefined && entry !== '').join(',');
+    return { ...environment, NO_PROXY: bypassed, no_proxy: bypassed };
+}
 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

@@ -1,54 +1,97 @@
 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 { createServer, get } from 'node:http';
+import { dirname, extname, join } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
 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 { CONVERSATION_METHODS, Conversations } from './conversations.js';
 import { LocalCopies } from './copies.js';
-import { agentBase, enrolled, kitHome } from './home.js';
+import { unknownMethod } from './end.js';
+import { agentBase, enrolled, kitHome, ownerLock, ownerSocket, readEnrolment } from './home.js';
+import { Calls } from './calls.js';
+import { killDescendants } from './scope.js';
+import { removeInputs, Scripts } from './scripts.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 { holdConnection } from './connection.js';
+import { KitUpdate } 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 });
+}
+function claimed(lock) {
+    try {
+        lock.exec('BEGIN EXCLUSIVE');
+        return true;
+    }
+    catch (error) {
+        if (error.errcode === 5)
+            return false;
+        throw error;
+    }
 }
 async function serveOwner(copies) {
-    const socketPath = join(kitHome(), 'owner.sock');
-    await rm(socketPath, { force: true });
+    const lock = new DatabaseSync(ownerLock());
+    if (!claimed(lock)) {
+        lock.close();
+        const running = await runningResident();
+        throw new Error(`${running === null ? 'another Kit process' : `Kit process ${running}`} already runs this Environment from Kit home ${kitHome()}; stop it first to run another Kit process here`);
+    }
     const server = createServer(async (request, response) => {
         try {
-            if (request.url !== '/git/push') {
+            const text = await received(request);
+            let answered;
+            if (request.url === '/resident') {
+                response.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify({ pid: process.pid }));
+                return;
+            }
+            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));
         }
     });
-    server.listen(socketPath);
+    server.on('close', () => lock.close());
+    await rm(ownerSocket(), { force: true });
+    server.listen(ownerSocket());
     await once(server, 'listening');
 }
+function runningResident() {
+    return new Promise((resolve, reject) => {
+        get({ socketPath: ownerSocket(), path: '/resident' }, (answer) => {
+            received(answer).then((text) => resolve(JSON.parse(text).pid), reject);
+        }).on('error', (error) => {
+            if (error.code === 'ENOENT' || error.code === 'ECONNREFUSED')
+                resolve(null);
+            else
+                reject(error);
+        });
+    });
+}
 function connected() {
     return new Promise((resolve) => {
         const watcher = watch(kitHome(), () => {
@@ -65,7 +108,7 @@ function connected() {
         resolve();
     });
 }
-export async function resident() {
+async function started() {
     await connected();
     watch(kitHome(), () => {
         if (enrolled())
@@ -73,67 +116,90 @@ export async function resident() {
         killDescendants();
         process.exit(1);
     });
-    await placeSkillSet();
+    await placeSkillSet((await readEnrolment()).house);
     await mkdir(agentBase(), { recursive: true });
-    process.env.HOUSE_KIT_RESIDENT = String(process.pid);
-    const agents = new Agents(house);
+    await installShim(join(kitHome(), 'shim', 'git'), 'git-main');
+    await installShim(codexLauncher(), 'codex-main');
+}
+export async function resident() {
+    await mkdir(kitHome(), { recursive: true, mode: 0o700 });
     const copies = new LocalCopies(house);
     await copies.load();
-    await installShim();
     await serveOwner(copies);
-    let stream = null;
+    await started().catch((error) => {
+        report(error);
+        process.exit(1);
+    });
+    process.env.HOUSE_KIT_RESIDENT = String(process.pid);
+    const agents = new Agents(house, () => changed());
+    let connection = null;
     let reported = false;
-    const idle = () => conversations.idle() && signIns.idle();
+    const idle = () => calls.idle() && conversations.idle() && agents.idle();
     const changed = () => {
         if (!idle()) {
             reported = false;
         }
+        else if (update.held() && conversations.quiet()) {
+            update.apply(connection.pause());
+        }
         else if (!reported) {
             reported = true;
             logged(house.deliver('/kit/idle', {}, idle));
         }
     };
+    const calls = new Calls(house, changed);
     const conversations = new Conversations({
         house,
         agents,
         copies,
-        send: (frame) => stream?.send(frame) ?? false,
+        calls,
+        send: (notification) => connection?.send(notification) ?? false,
         changed,
     });
-    const signIns = new SignIns(house, agents, changed);
-    const updates = new Updates(house);
+    const signIns = new SignIns(house, agents, calls);
+    const update = new KitUpdate(calls, changed);
+    removeInputs();
+    const scripts = new Scripts(calls, (notification) => connection?.send(notification) ?? false);
     for (const signal of ['SIGTERM', 'SIGINT']) {
         process.once(signal, () => {
             killDescendants();
+            removeInputs();
             process.kill(process.pid, signal);
         });
     }
     await house.deliver('/kit/restarted', {}).catch(report);
-    await updates.resumed().catch(report);
+    await update.resumed().catch(report);
     logged(agents.refresh());
-    stream = holdStream({
+    agents.keepCurrent();
+    connection = holdConnection({
         opened: () => {
             conversations.opened();
             changed();
-            logged(copies.select());
+            logged(copies.connected());
         },
-        frame: (arrived) => {
-            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')
-                    signIns.start(arrived);
-                else if (arrived.kind === 'update')
-                    updates.start(arrived);
-                else
-                    conversations.input(arrived);
+        closed: () => scripts.disconnected(),
+        call: (call) => {
+            if (call.kind === 'sign_in')
+                signIns.start(call);
+            else if (call.kind === 'update')
+                update.hold(call);
+            else if (call.kind === 'run_wizard' || call.kind === 'run_function')
+                scripts.start(call);
+            else if (CONVERSATION_METHODS.has(call.kind))
+                conversations.call(call);
+            else {
+                const refused = { refused: unknownMethod(call.kind) };
+                void calls.carry(call.input_id, async () => ({ result: refused }));
             }
         },
+        notification: (notification) => {
+            if (notification.type === 'watching')
+                conversations.watching(notification.watching === true);
+            if (notification.type === 'authority_changed')
+                logged(copies.changed(notification.rooms));
+            if (notification.type === 'work_available' && notification.subject === 'agents')
+                logged(agents.refresh());
+            scripts.notified(notification);
+        },
     });
 }

package/dist/scope.js

@@ -0,0 +1,214 @@
+import { execFileSync } from 'node:child_process';
+import { mkdirSync, readdirSync, readFileSync, realpathSync, 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']);
+const EXITED = new Set(['Z', 'X']);
+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(' ');
+        if (EXITED.has(fields[0]))
+            return null;
+        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;
+}
+function besideCli(cli) {
+    try {
+        return `${realpathSync(cli)}-`;
+    }
+    catch {
+        return null;
+    }
+}
+export class Scope {
+    marker;
+    helpers;
+    group;
+    session = null;
+    recorded = null;
+    constructor(marker, name, cli) {
+        this.marker = marker;
+        this.helpers = besideCli(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) || (this.helpers !== null && command.startsWith(this.helpers))));
+    }
+    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;
+        }
+    }
+}