@agentshouse/kit 0.2.1-c30728be20485 → 0.2.1-c3cf4b145dcda

package/dist/logout.js

@@ -1,8 +1,10 @@
 import { HouseRefusal, post } from './api.js';
+import { forgetAppGit } from './app-git.js';
 import { forgetEnrolment, readEnrolment } from './home.js';
 export async function logout() {
     const enrolled = await readEnrolment();
     if (enrolled === null) {
+        await forgetAppGit();
         process.stdout.write('This computer is not connected to House.\n');
         return;
     }
@@ -14,5 +16,6 @@ export async function logout() {
             throw error;
     }
     await forgetEnrolment(enrolled);
+    await forgetAppGit();
     process.stdout.write(`Environment ${enrolled.environment} is disconnected; kit login reconnects it.\n`);
 }

package/dist/parts.js

@@ -0,0 +1,64 @@
+export class Parts {
+    parts = [];
+    context = null;
+    emit;
+    writing = null;
+    planned = null;
+    constructor(emit) {
+        this.emit = emit;
+    }
+    write(type, id, text) {
+        if (text === '')
+            return;
+        const last = this.parts.length - 1;
+        const part = this.parts[last];
+        if (this.writing?.type === type && this.writing.id === id && part?.type === type) {
+            part.text += text;
+            this.emit({ op: 'append', index: last, text });
+            return;
+        }
+        this.start({ type, text });
+        this.writing = { type, id };
+    }
+    command() {
+        const last = this.parts.length - 1;
+        const part = this.parts[last];
+        if (part?.type !== 'commands') {
+            this.start({ type: 'commands', count: 1 });
+            return;
+        }
+        part.count++;
+        this.emit({ op: 'count', index: last, count: part.count });
+    }
+    start(part) {
+        this.writing = null;
+        this.parts.push(part);
+        const index = this.parts.length - 1;
+        this.emit({ op: 'start', index, part });
+        return index;
+    }
+    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 });
+    }
+    operations() {
+        return [
+            ...this.parts.map((part, index) => ({ op: 'start', index, part })),
+            ...(this.context === null ? [] : [{ op: 'context', ...this.context }]),
+        ];
+    }
+}

package/dist/resident.js

@@ -11,6 +11,7 @@ import { received } from './bridge.js';
 import { Conversations } from './conversations.js';
 import { LocalCopies } from './copies.js';
 import { agentBase, enrolled, kitHome } from './home.js';
+import { quoted } from './shell.js';
 import { SignIns } from './sign-in.js';
 import { placeSkillSet } from './skills.js';
 import { holdStream } from './stream.js';
@@ -21,9 +22,6 @@ function report(error) {
 function logged(work) {
     work.catch(report);
 }
-function quoted(value) {
-    return `'${value.replaceAll("'", `'\\''`)}'`;
-}
 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 });
@@ -120,6 +118,8 @@ export async function resident() {
             logged(copies.select());
         },
         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 === 'work_available' && arrived.subject === 'local_copy')

package/dist/shell.js

@@ -0,0 +1,3 @@
+export function quoted(value) {
+    return `'${value.replaceAll("'", `'\\''`)}'`;
+}

package/dist/sign-in.js

@@ -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,25 +33,43 @@ export class SignIns {
             return;
         this.running.add(input.input_id);
         this.changed();
-        this.login(input)
-            .then(() => this.agents.recheck(input.cli))
-            .then(() => this.house.deliver(`/kit/inputs/${input.input_id}/ack`, {}))
-            .then(() => this.agents.reread(input.cli))
+        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'],
@@ -56,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 = '';
@@ -92,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/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,7 +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 conversation's interrupt or end aborts it instead.
+    // 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)));
@@ -55,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));
@@ -69,7 +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 transcription fails.
+            // 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`);
@@ -85,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',
@@ -108,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) => {
@@ -116,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/kit",
-  "version": "0.2.1-c30728be20485",
+  "version": "0.2.1-c3cf4b145dcda",
   "description": "House Kit connects an Environment to agents.house.",
   "license": "MIT",
   "repository": {

package/dist/blocks.js

@@ -1,51 +0,0 @@
-const FENCE = /^\s*(`{3,}|~{3,})\s*(\S*)/;
-export function blocksOf(text) {
-    const blocks = [];
-    let paragraph = [];
-    let fence = null;
-    const closeParagraph = () => {
-        const joined = paragraph.join('\n').trim();
-        if (joined.length > 0)
-            blocks.push({ type: 'paragraph', text: joined });
-        paragraph = [];
-    };
-    const closeFence = () => {
-        const joined = fence.lines.join('\n');
-        if (joined.length > 0)
-            blocks.push({ type: 'code', language: fence.language, text: joined });
-        fence = null;
-    };
-    for (const line of text.split('\n')) {
-        if (fence !== null) {
-            if (line.trim().startsWith(fence.marker))
-                closeFence();
-            else
-                fence.lines.push(line);
-            continue;
-        }
-        const opening = FENCE.exec(line);
-        if (opening !== null) {
-            closeParagraph();
-            fence = { marker: opening[1], language: opening[2] || null, lines: [] };
-        }
-        else if (line.trim().length === 0) {
-            closeParagraph();
-        }
-        else {
-            paragraph.push(line);
-        }
-    }
-    if (fence !== null)
-        closeFence();
-    closeParagraph();
-    return blocks;
-}
-export function firstChange(before, after) {
-    let index = 0;
-    while (index < before.length &&
-        index < after.length &&
-        JSON.stringify(before[index]) === JSON.stringify(after[index])) {
-        index++;
-    }
-    return index;
-}