@agentshouse/kit 0.2.1-c5262a8cc063d → 0.2.1-c534eec03292e

package/dist/agents.js

@@ -1,15 +1,29 @@
 import { client } from '@agentclientprotocol/sdk';
-import { readFile, realpath } from 'node:fs/promises';
-import { killTree, startAdapter } from './acp.js';
-import { CLIS, KIT_VERSION, below, installAdapter, installCli, locate, run, versionOf } from './clis.js';
+import { readFile } from 'node:fs/promises';
+import { setTimeout as delay } from 'node:timers/promises';
+import { signedOut, startAdapter } from './acp.js';
+import { CLIS, KIT_RELEASE, below, installAdapter, installCli, locate, run, updateCli, versionOf } from './clis.js';
 import { agentBase, kitHome } from './home.js';
-const SIGNED_OUT = { signed_in: false, models: [] };
+import { updatesItself } from './placement.js';
+import { holdTranscription, transcriptionReport } from './transcription.js';
+import { KIT_WIRE } from './wire.js';
+// Two quiet seconds let a fresh conversation start before background model discovery competes for its CPU.
+const MODEL_PROBE_QUIET_MS = 2_000;
+// A CLI's maker can publish several releases a day, so running each chosen CLI's update command hourly brings a new one to the next conversation within the hour for one small check.
+export const CLI_UPDATE_MS = 60 * 60_000;
+// A sign-in's model read that has not answered in ten seconds leaves its sign-in to the status check, so a hung CLI never holds the sign-in's result.
+const SIGNED_IN_READ_MS = 10_000;
+const SIGNED_OUT = { signed_in: false, models: [], modes: [] };
+const INSTALLING = { release: null, failure: null, installing: true, ...SIGNED_OUT };
 function select(options, category) {
     const option = options.find((candidate) => candidate.category === category);
     return option?.type === 'select' ? option : undefined;
 }
+function choices(options) {
+    return options.flatMap((entry) => ('group' in entry ? entry.options : [entry]));
+}
 function values(options) {
-    return options.flatMap((entry) => ('group' in entry ? entry.options : [entry])).map((entry) => entry.value);
+    return choices(options).map((entry) => entry.value);
 }
 function causeOf(error) {
     return error instanceof Error ? error.message : String(error);
@@ -17,13 +31,31 @@ function causeOf(error) {
 function logged(error) {
     process.stderr.write(`kit: ${causeOf(error)}\n`);
 }
+const LAPTOP_CHASSIS = new Set(['8', '9', '10', '14', '30', '31', '32']);
+const DESKTOP_CHASSIS = new Set(['3', '4', '5', '6', '7', '15', '16']);
+const SERVER_CHASSIS = new Set(['17', '18', '19', '20', '21', '22', '23', '24']);
+export function chassisForm(value) {
+    const chassis = value.trim();
+    if (LAPTOP_CHASSIS.has(chassis))
+        return 'laptop';
+    if (DESKTOP_CHASSIS.has(chassis))
+        return 'desktop';
+    if (SERVER_CHASSIS.has(chassis))
+        return 'server';
+    return undefined;
+}
+export function hostVm(version) {
+    return /docker desktop|microsoft|wsl|linuxkit/i.test(version);
+}
 async function models(kind, adapter, known) {
     const agent = adapter.connection.agent;
     const opened = await agent.request('session/new', { cwd: kitHome(), mcpServers: [] });
     let options = opened.configOptions ?? [];
+    const mode = select(options, 'mode');
+    const modes = mode === undefined ? [] : choices(mode.options).map(({ value, name }) => ({ mode: value, name }));
     const model = select(options, 'model');
     if (model === undefined)
-        return [];
+        return { models: [], modes };
     const offered = [];
     for (const value of values(model.options)) {
         if (select(options, 'model')?.currentValue !== value) {
@@ -39,67 +71,111 @@ async function models(kind, adapter, known) {
         const effort = select(options, 'thought_level');
         offered.push({ model: value, efforts: effort === undefined ? [] : values(effort.options) });
     }
-    return offered;
+    return { models: offered, modes };
 }
-async function offer(kind, cli, known) {
+function ended(signal) {
+    return new Promise((_, reject) => {
+        if (signal.aborted)
+            reject(signal.reason);
+        signal.addEventListener('abort', () => reject(signal.reason), { once: true });
+    });
+}
+async function offer(kind, cli, known, signal) {
     const probe = CLIS[kind].signedIn;
-    if ('command' in probe && (await run(cli, probe.command, 30_000)).status !== 0)
+    // A sign-in check that has not answered in half a minute counts as signed out rather than stalling the report.
+    if ('command' in probe && (await run(cli, probe.command, 30_000, false, signal)).status !== 0)
         return SIGNED_OUT;
     let adapter;
     try {
-        adapter = await startAdapter(kind, cli, kitHome(), client({ name: '@agentshouse/kit' }));
+        adapter = await startAdapter(kind, cli, kitHome(), client({ name: '@agentshouse/kit' }), () => undefined, {}, signal);
+        signal?.throwIfAborted();
         if ('initializeMeta' in probe) {
             const method = adapter.initialized._meta?.[probe.initializeMeta];
             if (typeof method !== 'string' || method.length === 0)
                 return SIGNED_OUT;
         }
-        return { signed_in: true, models: await models(kind, adapter, known.models) };
+        return { signed_in: true, ...(await models(kind, adapter, known.models)) };
     }
     catch (error) {
-        process.stderr.write(`kit: ${kind} did not offer its models: ${causeOf(error)}\n`);
-        return { signed_in: adapter === undefined && 'initializeMeta' in probe ? known.signed_in : true, models: known.models };
+        if (!signal?.aborted)
+            process.stderr.write(`kit: ${kind} did not offer its models: ${causeOf(error)}\n`);
+        if (signedOut(error))
+            return SIGNED_OUT;
+        return {
+            signed_in: adapter === undefined && 'initializeMeta' in probe ? known.signed_in : true,
+            models: known.models,
+            modes: known.modes,
+        };
     }
     finally {
-        if (adapter !== undefined)
-            killTree(adapter.child);
+        adapter?.retire();
     }
 }
 function reported(kind, reading) {
+    const { minimum, update } = CLIS[kind];
     return {
         kind,
         release: reading.release,
-        ...(reading.minimum === undefined ? {} : { minimum: reading.minimum }),
+        ...(reading.release !== null && below(reading.release, minimum) ? { minimum, update } : {}),
         failure: reading.failure,
+        ...(reading.installing === undefined ? {} : { installing: reading.installing }),
         signed_in: reading.signed_in,
         models: reading.models,
+        modes: reading.modes,
+        full_access: CLIS[kind].fullAccess,
     };
 }
-function tooOld(kind, release) {
-    const cli = CLIS[kind];
-    return `${cli.bin} ${release} is older than ${cli.minimum}, the oldest this Kit runs`;
-}
+const NOT_READY = "the Agent's CLI is not ready on this computer";
 async function sshHostKey() {
+    // Listing a local host key takes a moment, so ten seconds only bounds a stuck ssh-keygen.
     const listed = await run('ssh-keygen', ['-l', '-E', 'sha256', '-f', '/etc/ssh/ssh_host_ed25519_key.pub'], 10_000);
     return listed.status === 0 ? (/^\d+ (SHA256:\S+)/.exec(listed.output)?.[1] ?? null) : null;
 }
 async function operatingSystem() {
+    // sw_vers answers at once, so ten seconds only bounds a stuck call.
     if (process.platform === 'darwin')
         return `macOS ${(await run('sw_vers', ['-productVersion'], 10_000)).output.trim()}`;
     const release = await readFile('/etc/os-release', 'utf8');
     return /^PRETTY_NAME="?([^"\n]*)"?$/m.exec(release)?.[1] ?? release;
 }
+async function hostForm() {
+    if (process.platform === 'darwin') {
+        const battery = await run('pmset', ['-g', 'batt'], 10_000);
+        return battery.status === 0 && battery.output.includes('InternalBattery') ? 'laptop' : 'desktop';
+    }
+    if (process.platform !== 'linux')
+        return undefined;
+    const [container, version, chassis] = await Promise.all([
+        readFile('/.dockerenv', 'utf8').then(() => true).catch(() => false),
+        readFile('/proc/version', 'utf8').catch(() => ''),
+        readFile('/sys/class/dmi/id/chassis_type', 'utf8').catch(() => ''),
+    ]);
+    if (container && hostVm(version))
+        return undefined;
+    return chassisForm(chassis);
+}
 export class Agents {
-    desired = { agents: [], routes: [] };
+    desired = { agents: [], routes: [], transcribe: false };
     house;
     reading = Promise.resolve();
     queues = new Map();
     installing = Promise.resolve();
+    installs = new Map();
     readings = new Map();
     reads = new Map();
+    starts = 0;
     sending = Promise.resolve();
     sent = null;
-    constructor(house) {
+    refreshing = 0;
+    loaded = Promise.resolve();
+    updating = null;
+    changed;
+    constructor(house, changed = () => undefined) {
         this.house = house;
+        this.changed = changed;
+    }
+    idle() {
+        return this.refreshing === 0 && this.updating === null;
     }
     read() {
         return this.reading.then(() => undefined, () => undefined);
@@ -108,32 +184,49 @@ export class Agents {
         return this.desired.routes.find((route) => route.agent_id === agentId);
     }
     refresh() {
+        this.refreshing++;
+        this.changed();
         const reading = this.read().then(async () => {
             this.desired = await this.house.deliver('/kit/agents/desired', {});
             return this.desired;
         });
         this.reading = reading;
-        return reading.then(({ agents }) => {
-            Promise.all(agents.map((kind) => this.queue(kind, () => this.load(kind))))
+        this.loaded = reading
+            .then(({ agents, transcribe }) => Promise.all([
+            holdTranscription(transcribe)
+                .then((changed) => (changed ? this.report() : undefined))
+                .catch(logged),
+            Promise.all(agents.map((kind) => this.load(kind)))
                 .then(() => this.report())
-                .catch(logged);
+                .catch(logged),
+        ]))
+            .catch(() => undefined)
+            .finally(() => {
+            this.refreshing--;
+            this.changed();
         });
+        return reading.then(() => undefined);
+    }
+    keepCurrent() {
+        this.updateAll(this.loaded);
+        setInterval(() => this.updateAll(Promise.resolve()), CLI_UPDATE_MS);
     }
     cli(kind) {
+        this.starts += 1;
         return this.queue(kind, async () => {
             const resolved = await this.resolve(kind);
             if (!('cli' in resolved)) {
                 this.update(kind, resolved);
-                throw new Error(resolved.failure ?? tooOld(kind, resolved.release));
+                throw new Error(NOT_READY);
             }
             const { cli, release } = resolved;
             const known = this.readings.get(kind);
-            const kept = known?.release === null || known?.minimum !== undefined ? SIGNED_OUT : (known ?? SIGNED_OUT);
-            if (known?.release !== release || known.minimum !== undefined) {
-                this.update(kind, { release, failure: null, signed_in: kept.signed_in, models: kept.models });
+            const kept = known?.release === null ? SIGNED_OUT : (known ?? SIGNED_OUT);
+            if (known?.release !== release || this.installs.has(kind)) {
+                this.update(kind, { release, failure: null, signed_in: kept.signed_in, models: kept.models, modes: kept.modes });
             }
             const read = this.nextRead(kind);
-            offer(kind, cli, kept)
+            this.quietOffer(kind, cli, kept)
                 .then((offered) => {
                 const current = this.readings.get(kind);
                 if (this.reads.get(kind) === read && current?.release === release)
@@ -143,16 +236,26 @@ export class Agents {
             return cli;
         });
     }
-    located(kind) {
-        return this.queue(kind, () => this.ensure(kind));
+    located(kind, signal) {
+        const owner = {};
+        return this.queue(kind, () => this.ensure(kind, signal, owner).finally(() => this.settle(kind, owner)), signal);
     }
     async reread(kind) {
-        await this.queue(kind, async () => {
-            this.nextRead(kind);
-            this.readings.set(kind, await this.examine(kind, this.readings.get(kind) ?? SIGNED_OUT));
-        });
+        await this.examine(kind, this.readings.get(kind) ?? SIGNED_OUT, offer);
         await this.report();
     }
+    async recheck(kind, signal) {
+        const known = this.readings.get(kind) ?? SIGNED_OUT;
+        const owner = {};
+        try {
+            await this.examine(kind, known, (kind, cli) => offer(kind, cli, known, AbortSignal.any([signal, AbortSignal.timeout(SIGNED_IN_READ_MS)])), signal, owner);
+        }
+        finally {
+            this.settle(kind, owner);
+        }
+        if (!signal.aborted)
+            await this.report();
+    }
     report() {
         const sending = this.sending.catch(() => undefined).then(() => this.send());
         this.sending = sending;
@@ -163,74 +266,128 @@ export class Agents {
         this.reads.set(kind, read);
         return read;
     }
-    update(kind, reading) {
+    hold(kind, reading) {
         this.readings.set(kind, reading);
+        this.installs.delete(kind);
+    }
+    update(kind, reading) {
+        this.hold(kind, reading);
+        this.report().catch(logged);
+    }
+    settle(kind, owner) {
+        if (this.installs.get(kind) !== owner)
+            return;
+        this.installs.delete(kind);
         this.report().catch(logged);
     }
-    queue(kind, work) {
-        const queued = (this.queues.get(kind) ?? Promise.resolve()).then(work);
+    queue(kind, work, signal) {
+        const queued = (this.queues.get(kind) ?? Promise.resolve()).then(() => {
+            signal?.throwIfAborted();
+            return work();
+        });
         this.queues.set(kind, queued.catch(() => undefined));
-        return queued;
+        return signal === undefined ? queued : Promise.race([queued, ended(signal)]);
     }
-    async ensure(kind) {
-        const failed = await installAdapter(kind);
+    async ensure(kind, signal, owner = {}) {
+        const failed = await installAdapter(kind, signal);
         if (failed !== null)
             throw new Error(failed);
-        const found = await locate(kind);
+        const found = await locate(kind, signal);
         if (found !== null)
             return found;
-        const installing = this.installing.catch(() => undefined).then(() => installCli(kind));
+        this.installs.set(kind, owner);
+        this.report().catch(logged);
+        const installing = this.installing.catch(() => undefined).then(() => installCli(kind, signal));
         this.installing = installing;
         const failure = await installing;
         if (failure !== null)
             throw new Error(failure);
-        const installed = await locate(kind);
+        const installed = await locate(kind, signal);
         if (installed === null)
             throw new Error(`the login shell does not find ${CLIS[kind].bin} after its install`);
         return installed;
     }
-    async resolve(kind) {
+    async resolve(kind, signal, owner) {
         let cli;
         try {
-            cli = await realpath(await this.ensure(kind));
+            cli = await this.ensure(kind, signal, owner);
         }
         catch (error) {
             const failure = causeOf(error);
             process.stderr.write(`kit: ${kind} did not install: ${failure}\n`);
             return { release: null, failure, ...SIGNED_OUT };
         }
-        const release = await versionOf(cli);
+        const release = await versionOf(cli, signal);
         if (release === null)
             return { release: null, failure: `${cli} --version names no version`, ...SIGNED_OUT };
-        const minimum = CLIS[kind].minimum;
-        if (below(release, minimum))
-            return { release, minimum, failure: null, ...SIGNED_OUT };
         return { cli, release };
     }
-    async examine(kind, known) {
-        const resolved = await this.resolve(kind);
-        if (!('cli' in resolved))
-            return resolved;
-        return { release: resolved.release, failure: null, ...(await offer(kind, resolved.cli, known)) };
+    async examine(kind, known, read, signal, owner) {
+        const current = this.nextRead(kind);
+        const resolved = await this.queue(kind, () => this.resolve(kind, signal, owner), signal);
+        const reading = 'cli' in resolved ? { release: resolved.release, failure: null, ...(await read(kind, resolved.cli, known)) } : resolved;
+        if (this.reads.get(kind) === current && !signal?.aborted)
+            this.hold(kind, reading);
+    }
+    updateAll(after) {
+        if (this.updating !== null)
+            return;
+        this.updating = after
+            .then(async () => {
+            for (const kind of this.desired.agents) {
+                if (this.installs.has(kind) || !this.readings.get(kind)?.release)
+                    continue;
+                const failure = await updateCli(kind);
+                if (failure !== null)
+                    process.stderr.write(`kit: ${kind} did not update: ${failure}\n`);
+                await this.readVersion(kind);
+            }
+        })
+            .catch(logged)
+            .finally(() => {
+            this.updating = null;
+            this.changed();
+        });
+        this.changed();
+    }
+    async readVersion(kind) {
+        const cli = await locate(kind);
+        const release = cli === null ? null : await versionOf(cli);
+        const current = this.readings.get(kind);
+        if (release === null || !current?.release || current.release === release)
+            return;
+        this.update(kind, { ...current, release });
+    }
+    async quietOffer(kind, cli, known) {
+        for (let seen = -1; seen !== this.starts;) {
+            seen = this.starts;
+            await delay(MODEL_PROBE_QUIET_MS);
+        }
+        return offer(kind, cli, known);
     }
     async load(kind) {
         const known = this.readings.get(kind);
         if (known !== undefined && known.failure === null)
             return;
-        this.nextRead(kind);
-        this.readings.set(kind, await this.examine(kind, SIGNED_OUT));
+        await this.examine(kind, SIGNED_OUT, (kind, cli, known) => this.quietOffer(kind, cli, known));
+        await this.report();
     }
     async send() {
         const agents = this.desired.agents.flatMap((kind) => {
-            const reading = this.readings.get(kind);
+            const reading = this.installs.has(kind) ? INSTALLING : this.readings.get(kind);
             return reading === undefined ? [] : [reported(kind, reading)];
         });
         const hostKey = await sshHostKey();
+        const form = await hostForm();
         const body = {
             os: await operatingSystem(),
-            kit_version: KIT_VERSION,
+            ...(form === undefined ? {} : { form }),
+            kit_release: KIT_RELEASE,
+            wire: KIT_WIRE,
+            updates_itself: await updatesItself(),
             agent_base: agentBase(),
             agents,
+            transcription: transcriptionReport(),
             ...(hostKey === null ? {} : { ssh_host_key: hostKey }),
         };
         const state = JSON.stringify(body);

package/dist/api.js

@@ -1,4 +1,9 @@
+import { setTimeout as delay } from 'node:timers/promises';
+import { signInAgain } from './end.js';
 import { readEnrolment } from './home.js';
+import { retryable } from './refusals.js';
+import { relayed } from './relay.js';
+import { endUnserved, KIT_WIRE, KIT_WIRE_HEADER } from './wire.js';
 export class HouseRefusal extends Error {
     status;
     text;
@@ -8,27 +13,54 @@ export class HouseRefusal extends Error {
         this.text = text;
     }
 }
+export function finalRefusal(error) {
+    return error instanceof HouseRefusal && retryable(error.text) === false;
+}
 export function retryDelay(attempt) {
+    // Full jitter, doubling from one second to a 30-second cap, spreads the Kit processes one outage dropped and retries within half a minute of House's return.
     return Math.random() * Math.min(30_000, 1000 * 2 ** attempt);
 }
+export async function retrying(sent, signal, pause = retryDelay) {
+    for (let attempt = 0;; attempt++) {
+        try {
+            return await sent();
+        }
+        catch (error) {
+            if (!(error instanceof HouseRefusal) || retryable(error.text) !== true)
+                throw error;
+        }
+        // A request House refused as retryable is sent again after the caller's pause, the jittered curve unless it names its own.
+        await delay(pause(attempt), undefined, { signal });
+    }
+}
 export async function post(house, path, body, credential, signal) {
-    const answer = await fetch(new URL(path, house), {
+    const answer = await fetch(relayed(new URL(path, house)), {
         method: 'POST',
         headers: {
             'content-type': 'application/json',
+            [KIT_WIRE_HEADER]: String(KIT_WIRE),
             ...(credential === undefined ? {} : { authorization: `Bearer ${credential}` }),
         },
         body: JSON.stringify(body),
         signal,
     });
     const text = await answer.text();
+    if (!answer.ok)
+        endUnserved(text);
     if (!answer.ok)
         throw new HouseRefusal(path, answer.status, text);
     return JSON.parse(text);
 }
 async function enrolledPost(path, body, signal) {
     const { house, credential } = (await readEnrolment());
-    return post(house, path, body, credential, signal);
+    try {
+        return await post(house, path, body, credential, signal);
+    }
+    catch (error) {
+        if (error instanceof HouseRefusal && error.status === 401)
+            await signInAgain(credential);
+        throw error;
+    }
 }
 export const house = {
     post: enrolledPost,
@@ -38,9 +70,10 @@ export const house = {
                 return await enrolledPost(path, body);
             }
             catch (error) {
-                if (error instanceof HouseRefusal && error.status < 500)
+                if (finalRefusal(error))
                     throw error;
                 process.stderr.write(`kit: ${path} did not reach House: ${error.message}\n`);
+                // A delivery House did not take is sent again on the jittered curve for as long as it is still current.
                 await new Promise((resolve) => setTimeout(resolve, retryDelay(attempt)));
                 if (!current())
                     throw error;

package/dist/app-git.js

@@ -0,0 +1,48 @@
+import { run } from './git.js';
+import { kitHome, readOwnAgent } from './home.js';
+const HELPER = '!kit git-credential';
+function section(house) {
+    return `credential.${new URL('/app/', house).href}`;
+}
+async function configured(args) {
+    try {
+        return await run(kitHome(), ['config', '--global', ...args]);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+export async function placeAppGit(ownAgent) {
+    if (ownAgent === null)
+        return;
+    await configured(['--remove-section', section(ownAgent.house)]);
+    for (const value of ['', HELPER]) {
+        const ran = await configured(['--add', `${section(ownAgent.house)}.helper`, value]);
+        if (ran === null)
+            return;
+        if (ran.status !== 0)
+            throw new Error(`git config failed: ${ran.stderr.trim()}`);
+    }
+}
+export async function answerGitCredential(operation) {
+    let asked = '';
+    for await (const chunk of process.stdin)
+        asked += String(chunk);
+    if (operation !== 'get')
+        return;
+    const attributes = new Map(asked
+        .split('\n')
+        .filter((line) => line.includes('='))
+        .map((line) => [line.slice(0, line.indexOf('=')), line.slice(line.indexOf('=') + 1)]));
+    const ownAgent = await readOwnAgent();
+    if (ownAgent === null) {
+        process.stderr.write(`kit: Kit home ${kitHome()} is not signed in; run kit login\n`);
+        return;
+    }
+    const house = new URL(ownAgent.house);
+    if (attributes.get('protocol') !== house.protocol.slice(0, -1) || attributes.get('host') !== house.host)
+        return;
+    process.stdout.write(`username=house\npassword=${ownAgent.credential}\n`);
+}

package/dist/authority-main.js

@@ -1,10 +1,10 @@
-import { setGlobalProxyFromEnv } from 'node:http';
 import { HouseRefusal, post } from './api.js';
 import { readEnrolment } from './home.js';
+import { proxyUnlessRelayed } from './relay.js';
 function unanswered(error) {
     return error instanceof HouseRefusal ? error.status >= 500 : error instanceof TypeError && error.message === 'fetch failed';
 }
-setGlobalProxyFromEnv();
+proxyUnlessRelayed();
 try {
     const { house, credential } = (await readEnrolment());
     try {