@agentshouse/kit 0.2.1-c30728be20485 → 0.2.1-c35516351ef49

package/dist/stream.js

@@ -1,11 +1,42 @@
 import { subscribe } from 'node:diagnostics_channel';
 import { finalRefusal, HouseRefusal, retryDelay } from './api.js';
-import { end, REPLACED, SIGN_IN_AGAIN } from './end.js';
+import { end, REPLACED, signInAgain, updateRequired } from './end.js';
 import { readEnrolment } from './home.js';
 import { relayed } from './relay.js';
+import { KIT_WIRE, tooOld } from './wire.js';
 const PATH = '/kit/stream';
-const SUBPROTOCOL = 'house.kit.stream.1';
+const SUBPROTOCOL = `house.kit.stream.${KIT_WIRE}`;
 const REFUSAL_HEADER = 'x-house-refusal';
+// House beats each stream every thirty seconds, so two silent beats mean this Kit cannot hear House.
+export const STREAM_SILENCE_MS = 60_000;
+const SYSTEM_STREAM_CLOCK = {
+    later: (delay, callback) => setTimeout(callback, delay),
+    clear: (timer) => clearTimeout(timer),
+};
+export class StreamSilence {
+    timer = null;
+    silent;
+    clock;
+    interval;
+    constructor(silent, clock = SYSTEM_STREAM_CLOCK, interval = STREAM_SILENCE_MS) {
+        this.silent = silent;
+        this.clock = clock;
+        this.interval = interval;
+    }
+    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;
+    }
+}
 function streamUrl(house) {
     const url = new URL(PATH, house);
     url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
@@ -36,29 +67,49 @@ export function holdStream(handlers) {
             headers: { authorization: `Bearer ${credential}` },
         });
         let opened = false;
-        opening.onopen = () => {
-            opened = true;
-            failures = 0;
-            socket = opening;
-            handlers.opened();
-        };
-        opening.onmessage = (event) => {
-            handlers.frame(JSON.parse(String(event.data)));
-        };
-        opening.onerror = () => undefined;
-        opening.onclose = (event) => {
+        let silence = null;
+        const closed = (event) => {
+            silence?.stop();
+            silence = null;
             if (socket === opening)
                 socket = null;
             process.stderr.write(`kit: control stream closed ${event.code} ${event.reason}\n`);
             if (event.reason === 'replaced')
                 end(REPLACED);
-            if (event.reason === 'credential_rejected' || refused?.status === 401)
-                end(SIGN_IN_AGAIN);
+            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++));
         };
+        opening.onopen = () => {
+            opened = true;
+            failures = 0;
+            socket = opening;
+            silence = new StreamSilence(() => {
+                if (socket !== opening)
+                    return;
+                socket = null;
+                opening.onclose = null;
+                opening.close();
+                closed(new CloseEvent('close', { code: 1006, reason: 'heartbeat_missed' }));
+            });
+            silence.heard();
+            handlers.opened();
+        };
+        opening.onmessage = (event) => {
+            silence?.heard();
+            const frame = JSON.parse(String(event.data));
+            if (frame.type !== 'beat')
+                handlers.frame(frame);
+        };
+        opening.onerror = () => undefined;
+        opening.onclose = closed;
     };
     void connect();
     return {

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)));
@@ -45,16 +49,22 @@ async function executed(command, args, signal) {
 function present(path) {
     return stat(path).then(() => true, () => false);
 }
-async function cpus() {
+async function threads() {
     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);
+    return Math.max(1, Math.floor(Math.min(availableParallelism(), allowed) / 2));
 }
 async function sha256(path) {
     const hash = createHash('sha256');
     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,18 +95,52 @@ 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',
             '-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);
+        const text = await executed(installed(pinned.engine), ['-t', String(await threads()), '-np', '-m', installed(MODEL), ...parts], signal);
         return text
             .split('\n')
             .map((line) => line.trim())
@@ -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/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;
@@ -41,7 +56,7 @@ async function finished(inputId) {
         if (ack !== null)
             return ack;
         // systemctl answers at once, so ten seconds only bounds a stuck service manager.
-        if ((await run('systemctl', ['is-active', '--quiet', unit(inputId)], 10_000)).status !== 0) {
+        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.
@@ -50,19 +65,26 @@ async function finished(inputId) {
 }
 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',
             `--unit=${unit(inputId)}`,
             `--setenv=HOME=${homedir()}`,
+            `--setenv=HOUSE_KIT_HOME=${kitHome()}`,
             '/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';
+}

package/dist/work.js

@@ -0,0 +1,348 @@
+import { randomUUID } from 'node:crypto';
+import { once } from 'node:events';
+import { readFileSync } from 'node:fs';
+import { mkdir, rm } from 'node:fs/promises';
+import { createServer } from 'node:net';
+import { join } from 'node:path';
+import { RUNNING_JOB } from './events.js';
+import { kitHome } from './home.js';
+const ENDED_TASK = new Set(['completed', 'failed', 'killed']);
+const SCHEDULING = new Set(['CronCreate', 'CronDelete', 'ScheduleWakeup']);
+const QUEUE_LIST = 'house-kit-queue-';
+const SYNC = 'house-kit-sync-';
+const WAKEUP = /Next wakeup scheduled for (\d\d):(\d\d):(\d\d) \(in (\d+)s\)/;
+const HALF_DAY = 12 * 60 * 60 * 1000;
+export function codexLauncher() {
+    return join(kitHome(), 'launchers', 'codex');
+}
+export class Work {
+    changed;
+    jobs = new Set();
+    constructor(changed) {
+        this.changed = changed;
+    }
+    async open(_cli) {
+        return {};
+    }
+    async settled() { }
+    read(message) {
+        this.take(message);
+        this.changed();
+    }
+    take(message) {
+        const update = message.params?.update;
+        if (message.method !== 'session/update' || update?.asyncTaskId === undefined)
+            return;
+        if (update.sessionUpdate === 'async_task_spawned')
+            this.jobs.add(update.asyncTaskId);
+        if (update.sessionUpdate === 'async_task_state_update' && !RUNNING_JOB.has(update.state))
+            this.jobs.delete(update.asyncTaskId);
+    }
+    busy() {
+        return this.jobs.size > 0;
+    }
+    close() { }
+}
+class ClaudeWork extends Work {
+    cwd;
+    level = new Set();
+    listed = new Set();
+    started = new Set();
+    running = false;
+    hooks = new Set();
+    calls = new Map();
+    crons = new Map();
+    wakeups = [];
+    goal = false;
+    constructor(cwd, changed) {
+        super(changed);
+        this.cwd = cwd;
+    }
+    take(message) {
+        super.take(message);
+        if (message.method === '_claude/sdkMessage')
+            this.sdk(message.params.message);
+        if (message.method === 'session/update')
+            this.update(message.params.update);
+    }
+    busy() {
+        return (super.busy() ||
+            this.level.size > 0 ||
+            this.started.size > 0 ||
+            this.running ||
+            this.hooks.size > 0 ||
+            this.crons.size > 0 ||
+            this.wakeups.length > 0 ||
+            this.goal ||
+            this.durable());
+    }
+    sdk(message) {
+        switch (message.subtype) {
+            case 'background_tasks_changed':
+                this.level = new Set(message.tasks.map((task) => task.task_id));
+                for (const id of this.level) {
+                    this.listed.add(id);
+                    this.started.delete(id);
+                }
+                break;
+            case 'task_started':
+                if (!this.listed.has(message.task_id))
+                    this.started.add(message.task_id);
+                break;
+            case 'task_updated':
+                if (ENDED_TASK.has(message.patch.status))
+                    this.started.delete(message.task_id);
+                break;
+            case 'task_notification':
+                this.started.delete(message.task_id);
+                break;
+            case 'session_state_changed':
+                if (message.state === 'running' && !this.running)
+                    this.wakeups = this.wakeups.filter((due) => due > Date.now());
+                this.running = message.state === 'running';
+                break;
+            case 'hook_started':
+                this.hooks.add(message.hook_id);
+                break;
+            case 'hook_response':
+                this.hooks.delete(message.hook_id);
+                break;
+        }
+    }
+    update(update) {
+        const air = update._meta?.jetbrains?.air;
+        if (update.sessionUpdate === 'session_info_update' && air !== undefined && 'goal' in air) {
+            this.goal = air.goal?.status === 'active';
+        }
+        if (update.sessionUpdate !== 'tool_call' && update.sessionUpdate !== 'tool_call_update')
+            return;
+        const tool = update._meta?.claudeCode?.toolName;
+        if (update.sessionUpdate === 'tool_call' && SCHEDULING.has(tool ?? ''))
+            this.calls.set(update.toolCallId, { tool });
+        const call = this.calls.get(update.toolCallId);
+        if (call === undefined)
+            return;
+        if (update.rawInput !== undefined)
+            call.input = update.rawInput;
+        if (update.content !== undefined)
+            call.content = update.content;
+        if (update.status === 'failed')
+            this.calls.delete(update.toolCallId);
+        if (update.status !== 'completed')
+            return;
+        this.calls.delete(update.toolCallId);
+        if (call.tool === 'CronCreate')
+            this.crons.set(update.toolCallId, JSON.stringify(call.content ?? []));
+        if (call.tool === 'ScheduleWakeup')
+            this.wakeup(call);
+        if (call.tool !== 'CronDelete')
+            return;
+        for (const [id, text] of this.crons)
+            if (text.includes(String(call.input?.id)))
+                this.crons.delete(id);
+    }
+    wakeup(call) {
+        if (call.input?.stop === true) {
+            this.wakeups = [];
+            return;
+        }
+        const time = WAKEUP.exec(JSON.stringify(call.content ?? []));
+        if (time === null) {
+            this.wakeups.push(Infinity);
+            return;
+        }
+        const fires = Date.now() + Number(time[4]) * 1000;
+        const due = new Date(fires);
+        due.setHours(Number(time[1]), Number(time[2]), Number(time[3]), 0);
+        if (due.getTime() - fires > HALF_DAY)
+            due.setDate(due.getDate() - 1);
+        if (fires - due.getTime() > HALF_DAY)
+            due.setDate(due.getDate() + 1);
+        this.wakeups.push(due.getTime());
+    }
+    durable() {
+        let text;
+        try {
+            text = readFileSync(join(this.cwd, '.claude', 'scheduled_tasks.json'), 'utf8');
+        }
+        catch (error) {
+            return error.code !== 'ENOENT';
+        }
+        try {
+            return JSON.parse(text).tasks?.length !== 0;
+        }
+        catch {
+            return true;
+        }
+    }
+}
+class CodexWork extends Work {
+    threads = new Map();
+    queues = new Map();
+    goals = new Set();
+    items = new Set();
+    hooks = new Set();
+    starting = new Set();
+    settling = [];
+    memories = null;
+    lost = false;
+    server = null;
+    path = null;
+    socket = null;
+    asked = 0;
+    heard = 0;
+    proving = -1;
+    proven = -1;
+    async open(cli) {
+        const sockets = join(kitHome(), 'bridges');
+        await mkdir(sockets, { recursive: true, mode: 0o700 });
+        this.path = join(sockets, `${randomUUID()}.sock`);
+        this.server = createServer((socket) => this.connected(socket));
+        this.server.listen(this.path);
+        await once(this.server, 'listening');
+        return { CODEX_PATH: codexLauncher(), HOUSE_KIT_CODEX: cli, HOUSE_KIT_CODEX_STREAM: this.path };
+    }
+    settled() {
+        return new Promise((resolve) => {
+            this.settling.push(resolve);
+            this.settle();
+        });
+    }
+    take(message) {
+        super.take(message);
+        this.heard++;
+    }
+    busy() {
+        if (super.busy() ||
+            this.lost ||
+            this.memories !== false ||
+            [...this.threads.values()].some(Boolean) ||
+            this.queues.size > 0 ||
+            this.goals.size > 0 ||
+            this.items.size > 0 ||
+            this.hooks.size > 0) {
+            return true;
+        }
+        if (this.proven === this.heard)
+            return false;
+        this.prove();
+        return true;
+    }
+    close() {
+        this.server?.close();
+        if (this.path !== null)
+            void rm(this.path, { force: true });
+    }
+    connected(socket) {
+        this.socket = socket;
+        let buffer = '';
+        socket.on('error', () => this.lose());
+        socket.on('close', () => this.lose());
+        socket.setEncoding('utf8').on('data', (chunk) => {
+            buffer += chunk;
+            for (let index = buffer.indexOf('\n'); index >= 0; index = buffer.indexOf('\n')) {
+                const message = this.parsed(buffer.slice(0, index));
+                buffer = buffer.slice(index + 1);
+                if (message !== null)
+                    this.stream(message, socket);
+            }
+            this.settle();
+            this.changed();
+        });
+    }
+    parsed(line) {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            this.lost = true;
+            return null;
+        }
+    }
+    lose() {
+        this.lost = true;
+        this.changed();
+    }
+    prove() {
+        if (this.proving === this.heard)
+            return;
+        this.proving = this.heard;
+        this.socket.write(`${JSON.stringify({ jsonrpc: '2.0', id: `${SYNC}${this.heard}`, method: 'house-kit/sync' })}\n`);
+    }
+    settle() {
+        if (this.starting.size === 0)
+            for (const resolve of this.settling.splice(0))
+                resolve();
+    }
+    stream(message, socket) {
+        const params = message.params;
+        switch (message.method) {
+            case 'thread/status/changed':
+                this.threads.set(params.threadId, params.status.type === 'active' && params.status.activeFlags.length === 0);
+                break;
+            case 'thread/closed':
+                this.threads.delete(params.threadId);
+                break;
+            case 'thread/queue/changed':
+                this.queues.set(params.threadId, ++this.asked);
+                socket.write(`${JSON.stringify({ jsonrpc: '2.0', id: `${QUEUE_LIST}${this.asked}`, method: 'thread/queue/list', params: { threadId: params.threadId } })}\n`);
+                break;
+            case 'thread/goal/updated':
+                if (params.goal.status === 'active')
+                    this.goals.add(params.threadId);
+                else
+                    this.goals.delete(params.threadId);
+                break;
+            case 'thread/goal/cleared':
+                this.goals.delete(params.threadId);
+                break;
+            case 'item/started':
+                this.items.add(`${params.threadId} ${params.item.id}`);
+                break;
+            case 'item/completed':
+                this.items.delete(`${params.threadId} ${params.item.id}`);
+                break;
+            case 'hook/started':
+                this.hooks.add(params.run.id);
+                break;
+            case 'hook/completed':
+                this.hooks.delete(params.run.id);
+                break;
+            case 'mcpServer/startupStatus/updated':
+                if (params.status === 'starting')
+                    this.starting.add(`${params.threadId} ${params.name}`);
+                else
+                    this.starting.delete(`${params.threadId} ${params.name}`);
+                break;
+            case undefined:
+                this.answered(message);
+        }
+    }
+    answered(message) {
+        if (typeof message.id === 'string' && message.id.startsWith(SYNC)) {
+            this.proven = Number(message.id.slice(SYNC.length));
+        }
+        else if (typeof message.id === 'string' && message.id.startsWith(QUEUE_LIST)) {
+            const asked = Number(message.id.slice(QUEUE_LIST.length));
+            for (const [thread, latest] of this.queues) {
+                if (latest === asked && message.result?.data?.length === 0)
+                    this.queues.delete(thread);
+            }
+        }
+        else if (message.result?.config?.features !== undefined) {
+            this.memories = message.result.config.features.memories !== false;
+        }
+    }
+}
+class GrokWork extends Work {
+    busy() {
+        return true;
+    }
+}
+export function workFor(kind, cwd, changed) {
+    if (kind === 'claude-agent-acp')
+        return new ClaudeWork(cwd, changed);
+    if (kind === 'codex-acp')
+        return new CodexWork(changed);
+    return new GrokWork(changed);
+}