@agentshouse/kit 0.2.1-ca18b01951c3b → 0.2.1-cab5821cf0a77

package/dist/placement.js

@@ -1,27 +1,9 @@
 import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { run } from './clis.js';
+import { join, resolve } from 'node:path';
 import { kitHome } from './home.js';
-import { relayOrigin } from './relay.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 installed() {
+function recorded(name) {
     try {
-        return readFileSync(join(kitHome(), 'placement'), 'utf8').trim();
+        return readFileSync(join(kitHome(), name), 'utf8').trim();
     }
     catch (error) {
         if (error.code === 'ENOENT')
@@ -29,20 +11,21 @@ function installed() {
         throw error;
     }
 }
-function entries(house) {
-    const host = new URL(house).host;
-    const relay = relayOrigin();
-    if (relay === undefined)
-        return [`curl -fsSL ${host}/kit | sh`, `irm ${host}/kit.ps1 | iex`];
-    const entry = `${relay}/${host}/kit`;
-    return [`curl -fsSL ${entry} | HOUSE_KIT_RELAY=${relay} sh`, `$env:HOUSE_KIT_RELAY='${relay}'; irm ${entry}.ps1 | iex`];
+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';
+}
+export function placedPrefix() {
+    const prefix = process.env.HOUSE_KIT_PREFIX;
+    if (prefix === undefined || prefix === '')
+        throw new Error('this Kit process was not started by a launcher its installer placed');
+    return resolve(prefix);
 }
-export function installCommand(house) {
-    const [shell, windows] = entries(house);
-    const placement = installed();
-    if (placement === 'native')
-        return shell;
-    if (placement === 'server')
-        return `${shell} -s -- --linux`;
-    return `${shell} -s -- --container, or ${windows} on Windows`;
+export function releaseDirectory(release) {
+    return join(placedPrefix(), 'releases', release);
 }

package/dist/relay.js

@@ -1,6 +1,11 @@
+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)
@@ -8,6 +13,22 @@ export function relayOrigin() {
     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 = relayOrigin();

package/dist/resident.js

@@ -1,22 +1,26 @@
 import { once } from 'node:events';
 import { watch } from 'node:fs';
 import { mkdir, rm, writeFile } from 'node:fs/promises';
-import { createServer } from 'node:http';
+import { createServer, get } from 'node:http';
 import { dirname, extname, join } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
 import { fileURLToPath } from 'node:url';
 import { Agents } from './agents.js';
 import { house } from './api.js';
 import { received } from './bridge.js';
-import { CONVERSATION_INPUTS, Conversations } from './conversations.js';
+import { CONVERSATION_METHODS, Conversations } from './conversations.js';
 import { LocalCopies } from './copies.js';
-import { restart } from './end.js';
-import { agentBase, enrolled, forgetRestart, kitHome, restartAsked } from './home.js';
+import { restart, 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 { takeUnservedRelease } from './wire.js';
 import { codexLauncher } from './work.js';
 function report(error) {
     process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
@@ -29,13 +33,32 @@ async function installShim(path, module) {
     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 {
             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();
             }
@@ -53,9 +76,23 @@ async function serveOwner(copies) {
             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(), () => {
@@ -72,81 +109,99 @@ function connected() {
         resolve();
     });
 }
-export async function resident() {
+async function started() {
     await connected();
-    await forgetRestart();
     watch(kitHome(), () => {
         if (enrolled())
             return;
         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, () => changed());
-    const copies = new LocalCopies(house);
-    await copies.load();
     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 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() && agents.idle();
+    const idle = () => calls.idle() && conversations.idle() && agents.idle();
     const changed = () => {
         if (!idle()) {
             reported = false;
         }
-        else if (restartAsked() && conversations.quiet()) {
-            restart('restarting for an updated CLI');
+        else if (update.placedRelease() !== null && conversations.quiet()) {
+            restart(`Kit ${update.placedRelease()} is placed; its supervisor starts it`);
         }
         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);
+    if (process.env.HOUSE_KIT_SANDBOX !== '1')
+        takeUnservedRelease((release) => logged(update.takeRefused(release)));
+    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);
     logged(agents.refresh());
-    stream = holdStream({
+    agents.keepCurrent();
+    connection = holdConnection({
         opened: () => {
             conversations.opened();
             changed();
             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 === 'input') {
-                reported = false;
-                if (arrived.kind === 'sign_in')
-                    signIns.start(arrived);
-                else if (arrived.kind === 'update')
-                    updates.start(arrived);
-                else if (CONVERSATION_INPUTS.has(arrived.kind))
-                    conversations.input(arrived);
-                else {
-                    const refused = { refused: `This Kit does not know ${arrived.kind}; update the Kit` };
-                    logged(house.deliver(`/kit/inputs/${arrived.input_id}/ack`, refused).finally(changed));
-                }
+        closed: () => scripts.disconnected(),
+        call: (call) => {
+            if (call.kind === 'sign_in')
+                signIns.start(call);
+            else if (call.kind === 'update')
+                update.take(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

@@ -1,9 +1,10 @@
 import { execFileSync } from 'node:child_process';
-import { mkdirSync, readdirSync, readFileSync, rmdirSync, statSync, writeFileSync } from 'node:fs';
+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 ?? '';
 }
@@ -24,6 +25,8 @@ 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 };
     }
@@ -119,15 +122,23 @@ function members(group) {
     }
     return pids;
 }
+function besideCli(cli) {
+    try {
+        return `${realpathSync(cli)}-`;
+    }
+    catch {
+        return null;
+    }
+}
 export class Scope {
     marker;
-    cli;
+    helpers;
     group;
     session = null;
     recorded = null;
     constructor(marker, name, cli) {
         this.marker = marker;
-        this.cli = cli;
+        this.helpers = besideCli(cli);
         const own = ownGroup();
         this.group = own === null ? null : join(own, name);
         try {
@@ -165,7 +176,7 @@ export class Scope {
             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}-`)));
+        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;

package/dist/scripts.js

@@ -0,0 +1,255 @@
+import { spawn as spawnPiped } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { once } from 'node:events';
+import { rmSync } from 'node:fs';
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { constants } from 'node:os';
+import { join } from 'node:path';
+import { loginPath, onLoginPath } from './clis.js';
+import { kitHome } from './home.js';
+import { childEnvironment } from './relay.js';
+import { killTree } from './scope.js';
+const TERMINAL = 'xterm-256color';
+const FIRST_SIZE = { cols: 80, rows: 24 };
+const SIGNALLED = 128;
+const NEWLINE = 0x0a;
+const NO_BASH = "bash is not on the login shell's PATH";
+const LOST = { refused: 'the Kit lost its connection to House' };
+function causeOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function failed(plan, cause) {
+    process.stderr.write(`kit: ${plan.named} could not start: ${cause}\n`);
+    return { refused: `the script could not start: ${cause}` };
+}
+function planned(call) {
+    if (call.kind === 'run_wizard')
+        return { named: 'a Web Wizard', script: call.script, terminal: 'page', function: null };
+    return {
+        named: 'an Environment function',
+        script: call.script,
+        terminal: call.terminal ? 'at once' : null,
+        function: { input: call.input, timeCap: call.time_cap, outputCap: call.output_cap },
+    };
+}
+function inputs() {
+    return join(kitHome(), 'inputs');
+}
+async function inputFile(value) {
+    await mkdir(inputs(), { recursive: true, mode: 0o700 });
+    const path = join(inputs(), `${randomUUID()}.json`);
+    await writeFile(path, JSON.stringify(value), { mode: 0o600, flag: 'wx' });
+    return path;
+}
+export function removeInputs() {
+    rmSync(inputs(), { recursive: true, force: true });
+}
+function struck(line, typed) {
+    return typed.some((typedLine) => line.includes(typedLine));
+}
+class KeptOutput {
+    cap;
+    typedText = '';
+    text = '';
+    bytes = 0;
+    line = '';
+    lineBytes = 0;
+    dropping = false;
+    cut = false;
+    constructor(cap) {
+        this.cap = cap;
+    }
+    typed(data) {
+        this.typedText += data;
+    }
+    add(data) {
+        const pieces = data.split('\n');
+        const rest = pieces.pop();
+        for (const piece of pieces)
+            this.ended(piece);
+        this.extend(rest);
+    }
+    kept() {
+        const typed = this.typedLines(true);
+        this.text = [...this.text.split(/(?<=\n)/), this.line].filter((line) => line !== '' && !struck(line, typed)).join('');
+        this.bytes = Buffer.byteLength(this.text);
+        this.trim();
+        return { output: this.text, cut: this.cut };
+    }
+    typedLines(all) {
+        const lines = this.typedText.split(/\r\n|\r|\n/);
+        if (!all)
+            lines.pop();
+        return lines.filter((line) => line !== '');
+    }
+    ended(piece) {
+        const line = `${this.line}${piece}\n`;
+        const dropped = this.dropping;
+        this.line = '';
+        this.lineBytes = 0;
+        this.dropping = false;
+        if (dropped || struck(line, this.typedLines(false)))
+            return;
+        this.text += line;
+        this.bytes += Buffer.byteLength(line);
+        if (this.bytes > 2 * this.cap)
+            this.trim();
+    }
+    extend(piece) {
+        if (this.dropping)
+            return;
+        this.line += piece;
+        this.lineBytes += Buffer.byteLength(piece);
+        if (this.lineBytes <= this.cap)
+            return;
+        this.text = '';
+        this.bytes = 0;
+        this.line = '';
+        this.lineBytes = 0;
+        this.dropping = true;
+        this.cut = true;
+    }
+    trim() {
+        if (this.bytes <= this.cap)
+            return;
+        const bytes = Buffer.from(this.text);
+        const start = bytes.indexOf(NEWLINE, bytes.length - this.cap - 1) + 1;
+        this.text = bytes.subarray(start).toString('utf8');
+        this.bytes = bytes.length - start;
+        this.cut = true;
+    }
+}
+export class Scripts {
+    calls;
+    send;
+    runs = new Map();
+    constructor(calls, send) {
+        this.calls = calls;
+        this.send = send;
+    }
+    start(call) {
+        void this.calls.carry(call.input_id, () => this.run(call.input_id, planned(call)));
+    }
+    notified(notification) {
+        const run = this.runs.get(String(notification.wizard));
+        if (run === undefined)
+            return;
+        if (notification.type === 'wizard_input')
+            this.typed(run, String(notification.data));
+        if (notification.type === 'wizard_size')
+            this.resized(run, { cols: Number(notification.cols), rows: Number(notification.rows) });
+        if (notification.type === 'wizard_end' && run.plan.terminal === 'page')
+            this.end(run, {});
+    }
+    disconnected() {
+        for (const run of this.runs.values())
+            this.end(run, LOST);
+    }
+    async run(id, plan) {
+        const size = plan.terminal === 'page' ? null : FIRST_SIZE;
+        const output = plan.function === null ? null : new KeptOutput(plan.function.outputCap);
+        const run = { plan, input: null, output, process: null, pipes: [], terminal: null, size, typed: [], ended: null, sized: Promise.withResolvers() };
+        if (size !== null)
+            run.sized.resolve();
+        this.runs.set(id, run);
+        try {
+            return { result: await this.ran(id, run), release: plan.function !== null };
+        }
+        finally {
+            this.runs.delete(id);
+            if (run.input !== null)
+                await rm(run.input, { force: true });
+        }
+    }
+    async ran(id, run) {
+        const { plan, output } = run;
+        let exited;
+        try {
+            const { spawn } = await import('@lydell/node-pty');
+            const shell = await onLoginPath('bash');
+            if (shell === null)
+                return failed(plan, NO_BASH);
+            const path = await loginPath();
+            await run.sized.promise;
+            if (plan.function !== null)
+                run.input = await inputFile(plan.function.input);
+            if (run.ended !== null)
+                return run.ended;
+            const environment = { ...childEnvironment(), PATH: path, ...(run.input === null ? {} : { HOUSE_INPUT: run.input }) };
+            if (plan.terminal === null) {
+                ({ exited } = await this.piped(plan.script, shell, environment, run));
+            }
+            else {
+                const terminal = spawn(shell, ['-c', plan.script], { name: TERMINAL, ...run.size, cwd: process.cwd(), env: environment });
+                run.process = terminal;
+                run.terminal = terminal;
+                terminal.onData((data) => {
+                    this.send({ type: 'wizard_output', wizard: id, data });
+                    output?.add(data);
+                });
+                for (const data of run.typed.splice(0))
+                    terminal.write(data);
+                exited = new Promise((resolve) => terminal.onExit(({ exitCode, signal }) => resolve(signal ? SIGNALLED + signal : exitCode)));
+            }
+        }
+        catch (error) {
+            return failed(plan, causeOf(error));
+        }
+        let timedOut = false;
+        // House sends a function run's time cap in seconds, and a run still going at its cap ends with its process group and the output pipes it holds.
+        const capped = plan.function === null ? undefined : setTimeout(() => {
+            timedOut = true;
+            this.stop(run);
+        }, plan.function.timeCap * 1000);
+        const code = await exited;
+        clearTimeout(capped);
+        if (run.ended !== null)
+            return run.ended;
+        if (output === null)
+            return { exit_code: code };
+        const kept = output.kept();
+        return timedOut ? { timed_out: true, ...kept } : { exit_code: code, ...kept };
+    }
+    async piped(script, shell, environment, run) {
+        const child = spawnPiped(shell, ['-c', script], { cwd: process.cwd(), env: environment, detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
+        const exited = new Promise((resolve) => child.once('close', (code, signal) => resolve(signal === null ? code : SIGNALLED + constants.signals[signal])));
+        await once(child, 'spawn');
+        run.process = { pid: child.pid };
+        run.pipes = [child.stdout, child.stderr];
+        for (const pipe of run.pipes) {
+            pipe.setEncoding('utf8');
+            pipe.on('data', (data) => run.output.add(data));
+        }
+        if (run.ended !== null)
+            this.stop(run);
+        return { exited };
+    }
+    typed(run, data) {
+        run.output?.typed(data);
+        if (run.terminal === null)
+            run.typed.push(data);
+        else
+            run.terminal.write(data);
+    }
+    resized(run, size) {
+        run.size = size;
+        run.sized.resolve();
+        try {
+            run.terminal?.resize(size.cols, size.rows);
+        }
+        catch { }
+    }
+    end(run, result) {
+        if (run.ended !== null)
+            return;
+        run.ended = result;
+        run.sized.resolve();
+        this.stop(run);
+    }
+    stop(run) {
+        if (run.process !== null)
+            killTree(run.process);
+        for (const pipe of run.pipes)
+            pipe.destroy();
+    }
+}