@agentshouse/kit 0.2.1-alpha.9 → 0.2.1-c5262a8cc063d

package/dist/stream.js

@@ -1,3 +1,4 @@
+import { retryDelay } from './api.js';
 import { readEnrolment } from './home.js';
 const SUBPROTOCOL = 'house.kit.stream.1';
 function streamUrl(house) {
@@ -29,9 +30,7 @@ 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
-                : Math.min(30_000, 1000 * 2 ** failures++);
+            const delay = opened ? 1000 + Math.random() * 2000 : retryDelay(failures++);
             setTimeout(() => void connect(), delay);
         };
     };

package/dist/transcription.js

@@ -0,0 +1,122 @@
+import { createHash } from 'node:crypto';
+import { createReadStream } from 'node:fs';
+import { chmod, mkdir, mkdtemp, readdir, readFile, rename, rm, stat } from 'node:fs/promises';
+import { availableParallelism, tmpdir } from 'node:os';
+import { basename, join } from 'node:path';
+import { pipeline } from 'node:stream/promises';
+import { unlessAborted } from './abort.js';
+import { failureOf, run } from './clis.js';
+import { kitHome } from './home.js';
+const RELEASE = 'https://github.com/agentshouse/kit/releases/download/engine-2';
+export const MODEL = {
+    url: 'https://huggingface.co/ggml-org/parakeet-GGUF/resolve/35156454d1a39de06863303dd209fd2bed6ee079/ggml-parakeet-tdt-0.6b-v3-q4_k.bin',
+    sha256: '8b205b8b39c6535e153de6fb11c51db46125d45c4f16ba496fe41a0fe71b885e',
+    executable: false,
+};
+export const ENGINES = {
+    'linux-x64': {
+        decoder: { url: `${RELEASE}/ffmpeg-linux-x86_64`, sha256: '1f8235d206428305afb89c6e8ab99d100425a0ba61e22bb4c7aff017db8c8de5', executable: true },
+        engine: { url: `${RELEASE}/parakeet-cli-linux-x86_64`, sha256: 'bb2585695992fe1927a33960002cdf51b8a90a96ad65593c3d0a9f1fbc0865c2', executable: true },
+    },
+    'linux-arm64': {
+        decoder: { url: `${RELEASE}/ffmpeg-linux-aarch64`, sha256: 'a7e08a0fae0179d1078312f6bb13d2a9aa4d4c71a1d82a022953f25dee452f5e', executable: true },
+        engine: { url: `${RELEASE}/parakeet-cli-linux-aarch64`, sha256: 'cbc0bedc8daae97f1ef9dcee4200c06226218e300e0fd62ead1306d22742b7ed', executable: true },
+    },
+    'darwin-arm64': {
+        decoder: { url: `${RELEASE}/ffmpeg-darwin-arm64`, sha256: '7abe154aaed3d6b49f5167ca7221bb66bed51388925d99a7e4261a41fe52fba6', executable: true },
+        engine: { url: `${RELEASE}/parakeet-cli-darwin-arm64`, sha256: '9a2aafc0922ad7c0b6db6eff1641e96572ba32ac40bf995a1df242ed2febf297', executable: true },
+    },
+};
+const CHUNK_SECONDS = 20;
+let held = Promise.resolve();
+function directory() {
+    return join(kitHome(), 'transcription');
+}
+function installed(artifact) {
+    return join(directory(), artifact.sha256);
+}
+async function executed(command, args, signal) {
+    const ran = await run(command, args, 0, false, signal);
+    if (ran.status !== 0)
+        throw new Error(failureOf(ran, basename(command)));
+    return ran.stdout;
+}
+function present(path) {
+    return stat(path).then(() => true, () => false);
+}
+async function cpus() {
+    const [quota, period] = (await readFile('/sys/fs/cgroup/cpu.max', 'utf8').catch(() => 'max')).split(' ');
+    const allowed = quota === 'max' ? Infinity : Math.ceil(Number(quota) / Number(period));
+    return Math.min(availableParallelism(), allowed);
+}
+async function sha256(path) {
+    const hash = createHash('sha256');
+    await pipeline(createReadStream(path), hash);
+    return hash.digest('hex');
+}
+async function install(artifacts, signal) {
+    await mkdir(directory(), { recursive: true });
+    const pinned = new Set(artifacts.map((artifact) => artifact.sha256));
+    for (const name of await readdir(directory())) {
+        if (!pinned.has(name))
+            await rm(join(directory(), name), { recursive: true, force: true });
+    }
+    const missing = [];
+    for (const artifact of artifacts)
+        if (!(await present(installed(artifact))))
+            missing.push(artifact);
+    try {
+        for (const artifact of missing) {
+            const part = `${installed(artifact)}.part`;
+            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`);
+        }
+        for (const artifact of missing) {
+            if (artifact.executable)
+                await chmod(`${installed(artifact)}.part`, 0o755);
+            await rename(`${installed(artifact)}.part`, installed(artifact));
+        }
+    }
+    finally {
+        for (const artifact of missing)
+            await rm(`${installed(artifact)}.part`, { force: true });
+    }
+}
+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 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',
+            '-f', 'segment', '-segment_time', String(CHUNK_SECONDS), join(work, '%05d.wav')], signal);
+        const parts = (await readdir(work)).sort().flatMap((part) => ['-f', join(work, part)]);
+        const text = await executed(installed(pinned.engine), ['-t', String(await cpus()), '-np', '-m', installed(MODEL), ...parts], signal);
+        return text
+            .split('\n')
+            .map((line) => line.trim())
+            .filter((line) => line !== '')
+            .join(' ');
+    }
+    finally {
+        await rm(work, { recursive: true, force: true });
+    }
+}
+export async function transcribe(path, signal) {
+    const before = held;
+    let release;
+    const mine = new Promise((resolve) => {
+        release = resolve;
+    });
+    held = Promise.all([before, mine]);
+    try {
+        await unlessAborted(before, signal);
+        return await transcribed(path, signal);
+    }
+    finally {
+        release();
+    }
+}

package/dist/update.js

@@ -0,0 +1,117 @@
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+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';
+function logged(error) {
+    process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
+}
+function directory() {
+    return join(kitHome(), 'update');
+}
+function pending() {
+    return join(directory(), 'pending.json');
+}
+function outcome() {
+    return join(directory(), 'outcome');
+}
+function unit(inputId) {
+    return `house-kit-update-${inputId}`;
+}
+async function pendingInput() {
+    try {
+        return JSON.parse(await readFile(pending(), 'utf8')).input_id;
+    }
+    catch {
+        return null;
+    }
+}
+async function recorded() {
+    const status = await readFile(outcome(), 'utf8').catch(() => null);
+    if (status === null)
+        return null;
+    return status.trim() === '0' ? {} : { refused: `the Kit bootstrap exited with ${status.trim()}` };
+}
+async function finished(inputId) {
+    for (;;) {
+        const ack = await recorded();
+        if (ack !== null)
+            return ack;
+        if ((await run('systemctl', ['is-active', '--quiet', unit(inputId)], 10_000)).status !== 0) {
+            return (await recorded()) ?? { refused: 'the Kit bootstrap did not finish' };
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+}
+function rerun(script, inputId, flags) {
+    return new Promise((resolve) => {
+        const child = spawn('systemd-run', [
+            '--wait',
+            '--collect',
+            '--quiet',
+            `--unit=${unit(inputId)}`,
+            `--setenv=HOME=${homedir()}`,
+            '/bin/sh',
+            '-c',
+            RECORD,
+            script,
+            outcome(),
+            ...flags,
+        ], { stdio: ['ignore', 'ignore', 'inherit'] });
+        child.on('error', () => resolve({ refused: 'no service manager runs this Kit' }));
+        child.on('close', () => resolve(null));
+    });
+}
+export class Updates {
+    house;
+    held = new Set();
+    queue = Promise.resolve();
+    constructor(house) {
+        this.house = house;
+    }
+    async resumed() {
+        const inputId = await pendingInput();
+        if (inputId === null)
+            return;
+        await this.acknowledge(inputId, await finished(inputId));
+    }
+    start(input) {
+        if (this.held.has(input.input_id))
+            return;
+        this.held.add(input.input_id);
+        this.queue = this.queue
+            .then(() => this.carry(input))
+            .then((ack) => this.acknowledge(input.input_id, ack))
+            .catch(logged)
+            .finally(() => this.held.delete(input.input_id));
+    }
+    async carry(input) {
+        if ((await pendingInput()) === input.input_id)
+            return finished(input.input_id);
+        const answer = await fetch(input.bootstrap);
+        if (!answer.ok)
+            return { refused: `the Kit bootstrap could not be downloaded: ${answer.status}` };
+        const script = Buffer.from(await answer.arrayBuffer());
+        if (createHash('sha256').update(script).digest('hex') !== input.sha256) {
+            return { refused: 'the Kit bootstrap does not match its sha256' };
+        }
+        await mkdir(directory(), { recursive: true, mode: 0o700 });
+        const path = join(directory(), 'connect-linux.sh');
+        await writeFile(path, script, { mode: 0o700 });
+        await rm(outcome(), { force: true });
+        await writeFile(pending(), `${JSON.stringify({ input_id: input.input_id })}\n`, { mode: 0o600 });
+        return (await rerun(path, input.input_id, input.update_clis ? ['--update-clis'] : [])) ?? (await recorded()) ?? {
+            refused: 'the Kit bootstrap did not finish',
+        };
+    }
+    async acknowledge(inputId, ack) {
+        await this.house.deliver(`/kit/inputs/${inputId}/ack`, ack);
+        if ((await pendingInput()) !== inputId)
+            return;
+        await rm(pending(), { force: true });
+        await rm(outcome(), { force: true });
+    }
+}

package/how-we-work.md

@@ -2,24 +2,22 @@
 
 A Room is where information people share is kept; it is not the place for
 private information. Work goes into the Room it belongs to, or the First Room
-when none is named. Read and write Rooms with the `house` CLI.
+when none is named.
 
 The skills are already set up; never run `setup-matt-pocock-skills`.
 
 ## Where skill output goes
 
-- Glossary (`CONTEXT.md`): `library/glossary.md`
-- Decisions (ADRs): `library/decisions/NNNN-<slug>.md`
-- Plan (spec): `library/projects/<name>/plan.md`
-- Tasks (tickets): `library/projects/<name>/tasks/NN-<slug>.md`, with a
+- Glossary (`CONTEXT.md`): `glossary.md`
+- Decisions (ADRs): `decisions/NNNN-<slug>.md`
+- Plan (spec): `projects/<name>/plan.md`
+- Tasks (tickets): `projects/<name>/tasks/NN-<slug>.md`, with a
   `Status:` line (`needs-triage`, `needs-info`, `ready-for-agent`,
   `ready-for-human`, `wontfix`), a `Blocked by:` line and comments under
   `## Comments`
-- Map (Wayfinding): `library/projects/<name>/map.md`, its tasks under
+- Map (Wayfinding): `projects/<name>/map.md`, its tasks under
   `tasks/` with `Type:`, `Status: claimed|resolved` and `Blocked by:` lines
-- Research: `library/research/<slug>.md`
-- Questionnaires: `library/questionnaires/<slug>.md`
-- Learning: `library/learning/<topic>/`
-- Files a person should open, such as HTML pages, are uploaded to the Room and
-  linked from the document they belong to; a prototype is one HTML file with
-  every variant on one page.
+- Research: `research/<slug>.md`
+- Questionnaires: `questionnaires/<slug>.md`
+- Learning: `learning/<topic>/`
+- Prototype: one HTML file with every variant on one page.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/kit",
-  "version": "0.2.1-alpha.9",
+  "version": "0.2.1-c5262a8cc063d",
   "description": "House Kit connects an Environment to agents.house.",
   "license": "MIT",
   "repository": {
@@ -22,17 +22,17 @@
   ],
   "scripts": {
     "build": "tsc -p tsconfig.build.json && node scripts/bootstrap-manifest.mjs",
+    "engine": "mkdir -p tmp/engine && docker run --rm -v \"$PWD:/kit\" -w /kit alpine:3.24@sha256:294b683cb724975bec92580e1e685676bd4b50bda910ddb8c51d4cabeaec77e6 sh scripts/engine.sh tmp/engine",
     "test": "tsc -p tsconfig.json && vitest run"
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "1.7.0",
-    "@agentshouse/mdmodel": "0.1.0-alpha.17",
+    "@agentshouse/mdmodel": "0.1.0-alpha.19",
     "yaml": "2.9.1"
   },
   "peerDependencies": {
     "@agentclientprotocol/claude-agent-acp": "0.85.1",
-    "@agentclientprotocol/codex-acp": "2.1.1",
-    "@xai-official/grok": "1.0.46"
+    "@agentclientprotocol/codex-acp": "2.1.1"
   },
   "peerDependenciesMeta": {
     "@agentclientprotocol/claude-agent-acp": {
@@ -40,9 +40,6 @@
     },
     "@agentclientprotocol/codex-acp": {
       "optional": true
-    },
-    "@xai-official/grok": {
-      "optional": true
     }
   },
   "devDependencies": {