@agentshouse/kit 0.2.1-c5262a8cc063d → 0.2.1-c5987c9cb6553

package/dist/sign-in.js

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

package/dist/skills.js

@@ -6,7 +6,7 @@ import { fileURLToPath } from 'node:url';
 import { KIT_VERSION } from './clis.js';
 import { kitHome, readConfiguration, readHome, writeHome } from './home.js';
 import { refusalOf } from './refusals.js';
-export const HOW_WE_WORK = '/private/how-we-work.md';
+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';

package/dist/stream.js

@@ -1,17 +1,38 @@
-import { retryDelay } from './api.js';
+import { subscribe } from 'node:diagnostics_channel';
+import { finalRefusal, HouseRefusal, retryDelay } from './api.js';
+import { end, REPLACED, signInAgain, updateRequired } from './end.js';
 import { readEnrolment } from './home.js';
-const SUBPROTOCOL = 'house.kit.stream.1';
+import { relayed } from './relay.js';
+import { KIT_WIRE, tooOld } from './wire.js';
+const PATH = '/kit/stream';
+const SUBPROTOCOL = `house.kit.stream.${KIT_WIRE}`;
+const REFUSAL_HEADER = 'x-house-refusal';
 function streamUrl(house) {
-    const url = new URL('/kit/stream', house);
+    const url = new URL(PATH, house);
     url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
     return url;
 }
+function header(headers, name) {
+    for (let index = 0; index < headers.length; index += 2) {
+        if (headers[index].toString('latin1').toLowerCase() === name)
+            return headers[index + 1].toString('latin1');
+    }
+    return '';
+}
+let refused = null;
+subscribe('undici:request:headers', (message) => {
+    const { request, response } = message;
+    if (!request.path.endsWith(PATH))
+        return;
+    refused = new HouseRefusal(PATH, response.statusCode, header(response.headers, REFUSAL_HEADER) || response.statusText);
+});
 export function holdStream(handlers) {
     let socket = null;
     let failures = 0;
     const connect = async () => {
         const { house, credential } = (await readEnrolment());
-        const opening = new WebSocket(streamUrl(house), {
+        refused = null;
+        const opening = new WebSocket(relayed(streamUrl(house)), {
             protocols: [SUBPROTOCOL],
             headers: { authorization: `Bearer ${credential}` },
         });
@@ -30,8 +51,18 @@ export function holdStream(handlers) {
             if (socket === opening)
                 socket = null;
             process.stderr.write(`kit: control stream closed ${event.code} ${event.reason}\n`);
-            const delay = opened ? 1000 + Math.random() * 2000 : retryDelay(failures++);
-            setTimeout(() => void connect(), delay);
+            if (event.reason === 'replaced')
+                end(REPLACED);
+            if (event.reason === 'credential_rejected' || refused?.status === 401) {
+                void signInAgain(credential);
+                return;
+            }
+            if (refused !== null && tooOld(refused.text))
+                updateRequired(house);
+            if (finalRefusal(refused))
+                end(refused.message);
+            // A closed socket reopens in one to three seconds, spread so Kits one restart closed return apart; an opening House refused as retryable or left unanswered backs off on the jittered curve.
+            setTimeout(() => void connect(), opened ? 1000 + Math.random() * 2000 : retryDelay(failures++));
         };
     };
     void connect();

package/dist/transcription.js

@@ -29,6 +29,10 @@ export const ENGINES = {
 };
 const CHUNK_SECONDS = 20;
 let held = Promise.resolve();
+let holding = Promise.resolve();
+let setting = null;
+let downloading = null;
+let readiness = { installed: false, failure: null };
 function directory() {
     return join(kitHome(), 'transcription');
 }
@@ -36,6 +40,7 @@ function installed(artifact) {
     return join(directory(), artifact.sha256);
 }
 async function executed(command, args, signal) {
+    // A download or a transcription runs as long as its size needs; the setting turning off or the turn's interrupt or end aborts it instead.
     const ran = await run(command, args, 0, false, signal);
     if (ran.status !== 0)
         throw new Error(failureOf(ran, basename(command)));
@@ -54,6 +59,12 @@ async function sha256(path) {
     await pipeline(createReadStream(path), hash);
     return hash.digest('hex');
 }
+function causeOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function pinnedHere() {
+    return ENGINES[`${process.platform}-${process.arch}`];
+}
 async function install(artifacts, signal) {
     await mkdir(directory(), { recursive: true });
     const pinned = new Set(artifacts.map((artifact) => artifact.sha256));
@@ -68,6 +79,7 @@ async function install(artifacts, signal) {
     try {
         for (const artifact of missing) {
             const part = `${installed(artifact)}.part`;
+            // Three retries carry a large download past a dropped connection before the download fails.
             await executed('curl', ['-fsSL', '--retry', '3', '-o', part, artifact.url], signal);
             if ((await sha256(part)) !== artifact.sha256)
                 throw new Error(`${artifact.url} does not match its sha256`);
@@ -83,12 +95,46 @@ async function install(artifacts, signal) {
             await rm(`${installed(artifact)}.part`, { force: true });
     }
 }
+function reported(next) {
+    const changed = next.installed !== readiness.installed || next.failure !== readiness.failure;
+    readiness = next;
+    return changed;
+}
+async function settle(transcribe) {
+    if (transcribe === setting)
+        return false;
+    setting = transcribe;
+    if (!transcribe) {
+        await rm(directory(), { recursive: true, force: true });
+        return reported({ installed: false, failure: null });
+    }
+    const download = new AbortController();
+    downloading = download;
+    try {
+        const pinned = pinnedHere();
+        await install([pinned.decoder, pinned.engine, MODEL], download.signal);
+        return reported({ installed: true, failure: null });
+    }
+    catch (error) {
+        await rm(directory(), { recursive: true, force: true });
+        return reported({ installed: false, failure: download.signal.aborted ? null : causeOf(error) });
+    }
+    finally {
+        downloading = null;
+    }
+}
+export function holdTranscription(transcribe) {
+    if (!transcribe)
+        downloading?.abort();
+    const settled = holding.then(() => settle(transcribe));
+    holding = settled.catch(() => undefined);
+    return settled;
+}
+export function transcriptionReport() {
+    return readiness;
+}
 async function transcribed(path, signal) {
-    const platform = `${process.platform}-${process.arch}`;
-    const pinned = ENGINES[platform];
-    if (pinned === undefined)
-        throw new Error(`no transcription engine is pinned for ${platform}`);
-    await install([pinned.decoder, pinned.engine, MODEL], signal);
+    const pinned = pinnedHere();
     const work = await mkdtemp(join(tmpdir(), 'kit-transcription-'));
     try {
         await executed(installed(pinned.decoder), ['-nostdin', '-hide_banner', '-loglevel', 'error', '-i', path, '-ar', '16000', '-ac', '1', '-c:a', 'pcm_s16le',
@@ -106,6 +152,8 @@ async function transcribed(path, signal) {
     }
 }
 export async function transcribe(path, signal) {
+    if (!readiness.installed)
+        return null;
     const before = held;
     let release;
     const mine = new Promise((resolve) => {
@@ -114,7 +162,7 @@ export async function transcribe(path, signal) {
     held = Promise.all([before, mine]);
     try {
         await unlessAborted(before, signal);
-        return await transcribed(path, signal);
+        return readiness.installed ? await transcribed(path, signal) : null;
     }
     finally {
         release();

package/dist/update.js

@@ -4,8 +4,8 @@ import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { run } from './clis.js';
-import { kitHome } from './home.js';
-const RECORD = 'outcome=$1; shift; bash "$0" --linux "$@"; printf %s "$?" > "$outcome"; systemctl start house-kit.service';
+import { kitHome, workspaceRoot } from './home.js';
+import { service, throughSudo } from './placement.js';
 function logged(error) {
     process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
 }
@@ -21,6 +21,21 @@ function outcome() {
 function unit(inputId) {
     return `house-kit-update-${inputId}`;
 }
+function manager() {
+    return service() === 'user' ? ['--user'] : [];
+}
+function elevated() {
+    return throughSudo() ? ['sudo', '-n'] : [];
+}
+function account() {
+    return throughSudo() ? [`--uid=${process.getuid()}`, `--gid=${process.getgid()}`] : [];
+}
+function placement() {
+    return service() === 'user' ? ['--workspace', workspaceRoot()] : ['--linux'];
+}
+function record() {
+    return `outcome=$1; shift; bash "$0" "$@"; printf %s "$?" > "$outcome"; ${[...elevated(), 'systemctl', ...manager(), 'start', 'house-kit.service'].join(' ')}`;
+}
 async function pendingInput() {
     try {
         return JSON.parse(await readFile(pending(), 'utf8')).input_id;
@@ -40,15 +55,21 @@ async function finished(inputId) {
         const ack = await recorded();
         if (ack !== null)
             return ack;
-        if ((await run('systemctl', ['is-active', '--quiet', unit(inputId)], 10_000)).status !== 0) {
+        // systemctl answers at once, so ten seconds only bounds a stuck service manager.
+        if ((await run('systemctl', [...manager(), 'is-active', '--quiet', unit(inputId)], 10_000)).status !== 0) {
             return (await recorded()) ?? { refused: 'the Kit bootstrap did not finish' };
         }
+        // The bootstrap runs for minutes, so checking each second sees its outcome within a second at little cost.
         await new Promise((resolve) => setTimeout(resolve, 1000));
     }
 }
 function rerun(script, inputId, flags) {
     return new Promise((resolve) => {
-        const child = spawn('systemd-run', [
+        const [command, ...args] = [
+            ...elevated(),
+            'systemd-run',
+            ...manager(),
+            ...account(),
             '--wait',
             '--collect',
             '--quiet',
@@ -56,11 +77,13 @@ function rerun(script, inputId, flags) {
             `--setenv=HOME=${homedir()}`,
             '/bin/sh',
             '-c',
-            RECORD,
+            record(),
             script,
             outcome(),
+            ...placement(),
             ...flags,
-        ], { stdio: ['ignore', 'ignore', 'inherit'] });
+        ];
+        const child = spawn(command, args, { stdio: ['ignore', 'ignore', 'inherit'] });
         child.on('error', () => resolve({ refused: 'no service manager runs this Kit' }));
         child.on('close', () => resolve(null));
     });

package/dist/wire.js

@@ -0,0 +1,6 @@
+import { refusalOf } from './refusals.js';
+export const KIT_WIRE = 1;
+export const KIT_WIRE_HEADER = 'x-house-kit-wire';
+export function tooOld(text) {
+    return refusalOf(text)?.code === 'kit_update_required';
+}