@agentshouse/kit 0.2.1-c5d36e97b0fea → 0.2.1-c5e51b4e66131

package/dist/resident.js

@@ -1,21 +1,25 @@
 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 { Conversations } from './conversations.js';
+import { CONVERSATION_METHODS, 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, ownerLock, ownerSocket, readEnrolment, restartAsked } from './home.js';
+import { Calls } from './calls.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 { holdConnection } from './connection.js';
+import { KitUpdate } from './update.js';
+import { WebWizards } from './web-wizard.js';
 import { codexLauncher } from './work.js';
 function report(error) {
     process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
@@ -28,13 +32,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();
             }
@@ -52,9 +75,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(), () => {
@@ -71,44 +108,61 @@ 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);
-    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();
+    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.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);
+    const wizards = new WebWizards(calls, (notification) => connection?.send(notification) ?? false);
     for (const signal of ['SIGTERM', 'SIGINT']) {
         process.once(signal, () => {
             killDescendants();
@@ -116,28 +170,37 @@ export async function resident() {
         });
     }
     await house.deliver('/kit/restarted', {}).catch(report);
-    await updates.resumed().catch(report);
+    await update.resumed().catch(report);
     logged(agents.refresh());
-    stream = holdStream({
+    connection = holdConnection({
         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 === 'input') {
-                reported = false;
-                if (arrived.kind === 'sign_in')
-                    signIns.start(arrived);
-                else if (arrived.kind === 'update')
-                    updates.start(arrived);
-                else
-                    conversations.input(arrived);
+        closed: () => wizards.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')
+                wizards.start(call);
+            else if (CONVERSATION_METHODS.has(call.kind))
+                conversations.call(call);
+            else {
+                const refused = { refused: `This Kit does not know ${call.kind}; update the Kit` };
+                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());
+            wizards.notified(notification);
+        },
     });
 }

package/dist/scope.js

@@ -4,6 +4,7 @@ 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 };
     }

package/dist/service-main.js

@@ -0,0 +1,9 @@
+import { startService } from './service.js';
+try {
+    if (startService())
+        process.stdout.write('started\n');
+}
+catch (error) {
+    process.stderr.write(`kit: ${error.message}\n`);
+    process.exitCode = 1;
+}

package/dist/service.js

@@ -0,0 +1,55 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, realpathSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { kitHome } from './home.js';
+const UNIT = 'house-kit.service';
+// launchctl and systemctl answer at once, so ten seconds only bounds a stuck service manager.
+const MANAGER_MS = 10_000;
+function manage(command, args) {
+    return spawnSync(command, args, { encoding: 'utf8', timeout: MANAGER_MS });
+}
+function start(command, args) {
+    const started = manage(command, args);
+    if (started.status === 0)
+        return;
+    const cause = started.error?.message ?? (started.stderr.trim() || `${command} exited with ${started.status ?? 'a signal'}`);
+    throw new Error(`the Kit service could not be started: ${cause}`);
+}
+function physical(path) {
+    return existsSync(path) ? realpathSync(path) : resolve(path);
+}
+function systemdHome(environment) {
+    for (const [, quoted, bare] of environment.matchAll(/"((?:[^"\\]|\\.)*)"|(\S+)/g)) {
+        const assignment = bare ?? quoted.replace(/\\(.)/g, '$1');
+        if (assignment.startsWith('HOUSE_KIT_HOME='))
+            return assignment.slice('HOUSE_KIT_HOME='.length);
+    }
+    return undefined;
+}
+function runsThisHome(served) {
+    return served !== undefined && physical(served) === physical(kitHome());
+}
+export function startService() {
+    if (process.platform === 'darwin') {
+        const service = `gui/${process.getuid()}/house-kit`;
+        const printed = manage('launchctl', ['print', service]);
+        if (printed.status !== 0 || /^\tstate = running$/m.test(printed.stdout))
+            return false;
+        if (!runsThisHome(/^\t+HOUSE_KIT_HOME => (.+)$/m.exec(printed.stdout)?.[1]))
+            return false;
+        start('launchctl', ['kickstart', service]);
+        return true;
+    }
+    for (const scope of [['--user'], []]) {
+        if (manage('systemctl', [...scope, 'is-enabled', '--quiet', UNIT]).status !== 0)
+            continue;
+        const environment = manage('systemctl', [...scope, 'show', '--property=Environment', '--value', UNIT]).stdout;
+        if (!runsThisHome(systemdHome(environment)))
+            continue;
+        if (manage('systemctl', [...scope, 'is-active', '--quiet', UNIT]).status === 0)
+            return false;
+        start('systemctl', [...scope, 'start', UNIT]);
+        return true;
+    }
+    return false;
+}

package/dist/sign-in.js

@@ -1,6 +1,7 @@
 import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
-import { CLIS, withoutProxy } from './clis.js';
+import { CLIS } from './clis.js';
+import { childEnvironment } from './relay.js';
 import { killTree } from './scope.js';
 import { holdSecretInput } from './secret-input.js';
 const ESCAPE = /\u001b\[[\d;]*m/g;
@@ -9,72 +10,54 @@ const CODE = /^[A-Z0-9]+-[A-Z0-9]+$/;
 function causeOf(error) {
     return error instanceof Error ? error.message : String(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;
-    changed;
-    running = new Set();
-    constructor(house, agents, changed) {
+    calls;
+    constructor(house, agents, calls) {
         this.house = house;
         this.agents = agents;
-        this.changed = changed;
-    }
-    idle() {
-        return this.running.size === 0;
+        this.calls = calls;
     }
-    start(input) {
-        if (this.running.has(input.input_id))
-            return;
-        this.running.add(input.input_id);
-        this.changed();
-        this.signIn(input)
-            .catch(logged)
-            .finally(() => {
-            this.running.delete(input.input_id);
-            this.changed();
-        });
+    start(call) {
+        void this.calls.carry(call.input_id, () => this.signIn(call));
     }
-    async signIn(input) {
+    async signIn(call) {
         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)]);
+        const timer = setTimeout(() => ending.abort(), call.ends_in * 1000);
+        const ended = await Promise.race([this.signedIn(call, 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);
+            process.stderr.write(`kit: the ${call.cli} sign-in reached the end House set for it\n`);
+        return ended ? { result: {} } : { result: {}, returned: () => this.agents.reread(call.cli) };
     }
-    async signedIn(input, signal) {
-        await this.login(input, signal);
+    async signedIn(call, signal) {
+        await this.login(call, signal);
         if (!signal.aborted)
-            await this.agents.recheck(input.cli, signal);
+            await this.agents.recheck(call.cli, signal);
         return false;
     }
-    async login(input, signal) {
+    async login(call, signal) {
         let cli;
         try {
-            cli = await this.agents.located(input.cli, signal);
+            cli = await this.agents.located(call.cli, signal);
         }
         catch (error) {
             if (!signal.aborted)
-                process.stderr.write(`kit: the ${input.cli} sign-in failed: ${causeOf(error)}\n`);
+                process.stderr.write(`kit: the ${call.cli} sign-in failed: ${causeOf(error)}\n`);
             return;
         }
         if (signal.aborted)
             return;
-        const login = CLIS[input.cli].login;
+        const login = CLIS[call.cli].login;
         const child = spawn(cli, login.args, {
             stdio: ['pipe', 'pipe', 'pipe'],
             detached: true,
-            env: withoutProxy(),
+            env: childEnvironment(),
         });
         const running = () => child.exitCode === null && child.signalCode === null;
         const stop = () => killTree(child);
@@ -102,7 +85,7 @@ export class SignIns {
                 return;
             held = true;
             const steps = [{ kind: 'visit', label: 'Open this link and sign in', url: link }, step];
-            void holdSecretInput(this.house, input.input_id, steps, running).then((content) => {
+            void holdSecretInput(this.house, call.input_id, steps, running).then((content) => {
                 if (!running())
                     return;
                 if (content === null)
@@ -119,6 +102,6 @@ export class SignIns {
         });
         signal.removeEventListener('abort', stop);
         if (failed !== null && !signal.aborted)
-            process.stderr.write(`kit: the ${input.cli} sign-in failed: ${failed}\n`);
+            process.stderr.write(`kit: the ${call.cli} sign-in failed: ${failed}\n`);
     }
 }

package/dist/silence.js

@@ -0,0 +1,28 @@
+const SYSTEM_CLOCK = {
+    later: (delay, callback) => setTimeout(callback, delay),
+    clear: (timer) => clearTimeout(timer),
+};
+export class Silence {
+    timer = null;
+    interval;
+    silent;
+    clock;
+    constructor(interval, silent, clock = SYSTEM_CLOCK) {
+        this.interval = interval;
+        this.silent = silent;
+        this.clock = clock;
+    }
+    heard() {
+        this.stop();
+        this.timer = this.clock.later(this.interval, () => {
+            this.timer = null;
+            this.silent();
+        });
+    }
+    stop() {
+        if (this.timer === null)
+            return;
+        this.clock.clear(this.timer);
+        this.timer = null;
+    }
+}

package/dist/skills.js

@@ -1,17 +1,14 @@
-import { readFileSync } from 'node:fs';
-import { cp, lstat, mkdir, readdir, realpath, rm, symlink, writeFile } from 'node:fs/promises';
+import { cp, lstat, mkdir, realpath, rm, symlink, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join, relative } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { KIT_VERSION } from './clis.js';
+import { GUIDE, listSkills } from '@agentshouse/skills';
+import { parse } from 'yaml';
+import { KIT_RELEASE } from './clis.js';
 import { kitHome, readConfiguration, readHome, writeHome } from './home.js';
-import { refusalOf } from './refusals.js';
-export const HOW_WE_WORK = '/rooms/private/how-we-work.md';
-const SKILL_SET = fileURLToPath(new URL('../skills/', import.meta.url));
-const HOW_WE_WORK_TEXT = readFileSync(new URL('../how-we-work.md', import.meta.url), 'utf8');
 const RECORD = 'skill-set.json';
-const CREATED = 'how-we-work-created';
-const UNWRITABLE = new Set(['room_not_found', 'operation_denied']);
+const ENTRY = 'SKILL.md';
+const FRONTMATTER = /^---\n([\s\S]*?)\n---\n/u;
+const ORIGIN = '<origin>';
 function skillsDirectory() {
     return join(homedir(), '.agents', 'skills');
 }
@@ -29,50 +26,67 @@ async function present(path) {
         throw error;
     }
 }
-async function install() {
-    const names = [];
-    for (const name of (await readdir(SKILL_SET)).sort()) {
-        if (!(await present(join(skillsDirectory(), name))) && !(await present(join(claudeDirectory(), name)))) {
-            names.push(name);
+function skillName(text) {
+    const front = FRONTMATTER.exec(text);
+    const fields = (front === null ? null : parse(front[1]));
+    return typeof fields?.name === 'string' && typeof fields.description === 'string' ? fields.name : undefined;
+}
+function skillSet(origin) {
+    const upstream = listSkills().map(({ name, directory }) => ({
+        name,
+        place: (destination) => cp(directory, destination, { recursive: true }),
+    }));
+    const pages = GUIDE.flatMap(({ text }) => {
+        const name = skillName(text);
+        if (name === undefined)
+            return [];
+        const place = async (destination) => {
+            await mkdir(destination);
+            await writeFile(join(destination, ENTRY), text.replaceAll(ORIGIN, origin));
+        };
+        return [{ name, place }];
+    });
+    return [...upstream, ...pages].sort((left, right) => (left.name < right.name ? -1 : 1));
+}
+async function install(origin) {
+    const placed = [];
+    for (const skill of skillSet(origin)) {
+        if (!(await present(join(skillsDirectory(), skill.name))) && !(await present(join(claudeDirectory(), skill.name)))) {
+            placed.push(skill);
         }
     }
+    const names = placed.map((skill) => skill.name);
     await writeHome(RECORD, { names });
     await mkdir(skillsDirectory(), { recursive: true });
     await mkdir(claudeDirectory(), { recursive: true });
     const skills = await realpath(skillsDirectory());
     const claude = await realpath(claudeDirectory());
-    for (const name of names) {
-        await cp(join(SKILL_SET, name), join(skillsDirectory(), name), { recursive: true });
+    for (const { name, place } of placed) {
+        await place(join(skillsDirectory(), name));
         if (claude !== skills)
             await symlink(relative(claude, join(skills, name)), join(claudeDirectory(), name));
     }
-    await writeHome(RECORD, { version: KIT_VERSION, names });
+    await writeHome(RECORD, { version: KIT_RELEASE, origin, names });
+}
+export async function placeSkillSet(origin) {
+    try {
+        await replaceSkillSet(origin);
+    }
+    catch (error) {
+        process.stderr.write(`kit: the skills could not be placed: ${error.message}\n`);
+    }
 }
-export async function placeSkillSet() {
+async function replaceSkillSet(origin) {
     const accepted = (await readConfiguration()).skills;
     const installed = await readHome(RECORD);
-    if (accepted && installed?.version === KIT_VERSION)
+    if (accepted && installed?.version === KIT_RELEASE && installed.origin === origin)
         return;
     for (const name of installed?.names ?? []) {
         await rm(join(claudeDirectory(), name), { recursive: true, force: true });
         await rm(join(skillsDirectory(), name), { recursive: true, force: true });
     }
     if (accepted)
-        await install();
+        await install(origin);
     else
         await rm(join(kitHome(), RECORD), { force: true });
 }
-export async function createHowWeWork(bridge) {
-    if ((await readHome(RECORD)) === null || (await present(join(kitHome(), CREATED))))
-        return;
-    const created = await bridge.tool('edit', { changes: [{ op: 'create', path: HOW_WE_WORK, content: HOW_WE_WORK_TEXT }] });
-    if (created.isError === true) {
-        const text = created.content.map((content) => content.text).join('\n');
-        const refusal = refusalOf(text);
-        if (UNWRITABLE.has(refusal?.code ?? ''))
-            return;
-        if (refusal?.code !== 'edit_conflict' || !refusal.conflicts.includes('path_exists'))
-            throw new Error(text);
-    }
-    await writeFile(join(kitHome(), CREATED), '');
-}