@byokit/herdr 0.1.0-next.dbe7142

package/dist/supervise.js

@@ -0,0 +1,137 @@
+import { spawn } from 'node:child_process';
+import { accessSync, closeSync, constants, existsSync, mkdirSync, openSync, readFileSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { isAbsolute, join } from 'node:path';
+import { HERDR_PROTOCOL } from "./constants.js";
+import { socketTransport } from "./socket.js";
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+export class Supervisor {
+    transport;
+    child;
+    stopping = false;
+    retry;
+    failures = 0;
+    root;
+    socketPath;
+    o;
+    onState;
+    constructor(o, onState) {
+        this.o = o;
+        this.onState = onState;
+        this.root = o.mode === 'own' ? join(o.stateDir, 'herdr') : undefined;
+        this.socketPath = o.mode === 'own' ? join(o.stateDir, 'herdr', 'herdr.sock') : o.socketPath;
+    }
+    env() {
+        if (this.o.mode === 'adopt') {
+            return { HERDR_SOCKET_PATH: this.socketPath, PATH: this.o.path?.join(':') || '/usr/bin:/bin', LANG: 'C.UTF-8', ...this.o.env };
+        }
+        const home = join(this.root, 'home');
+        return {
+            HOME: home, XDG_CONFIG_HOME: join(home, '.config'), XDG_STATE_HOME: join(home, '.local/state'),
+            XDG_CACHE_HOME: join(home, '.cache'), HERDR_SOCKET_PATH: this.socketPath,
+            PATH: this.o.path?.join(':') || '/usr/bin:/bin', LANG: 'C.UTF-8', ...this.o.env,
+        };
+    }
+    state(phase, why) { this.onState({ phase, ...(why ? { why } : {}) }); }
+    async start() {
+        this.stopping = false;
+        this.state('connecting');
+        if (this.o.mode === 'own') {
+            if (!isAbsolute(this.o.bin) || !existsSync(this.o.bin)) {
+                this.state('missing', 'binary');
+                throw new Error('herdr: executable binary required');
+            }
+            try {
+                if (!statSync(this.o.bin).isFile())
+                    throw new Error();
+                accessSync(this.o.bin, constants.X_OK);
+            }
+            catch {
+                this.state('missing', 'binary');
+                throw new Error('herdr: binary not executable');
+            }
+            mkdirSync(join(this.root, 'home'), { recursive: true });
+            const pidfile = join(this.root, 'server.pid');
+            if (existsSync(pidfile)) {
+                const pid = Number(readFileSync(pidfile, 'utf8'));
+                try {
+                    const cmdline = readFileSync(`/proc/${pid}/cmdline`, 'utf8');
+                    if (cmdline.includes(this.o.bin) && cmdline.includes('server'))
+                        process.kill(-pid, 'SIGTERM');
+                }
+                catch { /* no matching owned process */ }
+                unlinkSync(pidfile);
+            }
+            const log = openSync(join(this.root, 'server.log'), 'a', 0o600);
+            this.child = spawn(this.o.bin, ['server'], { env: this.env(), detached: true, stdio: ['ignore', log, log] });
+            const child = this.child;
+            child.on('error', () => { if (!this.stopping)
+                this.state('failed', 'server-exited'); });
+            child.on('exit', () => {
+                if (this.stopping || this.child !== child)
+                    return;
+                this.state('reconnecting', 'server-exited');
+                this.retry = setTimeout(() => { void this.start().catch(() => { }); }, Math.min(30_000, 1000 * 2 ** this.failures++));
+            });
+            if (child.pid)
+                writeFileSync(pidfile, String(child.pid), { mode: 0o600 });
+            closeSync(log);
+        }
+        const transport = this.transport ?? this.o.transport ?? socketTransport(this.socketPath);
+        this.transport = transport;
+        for (const ms of [0, 250, 500, 1000, 2000]) {
+            if (ms)
+                await delay(ms);
+            if (this.stopping)
+                throw new Error('herdr: stopped');
+            try {
+                const ping = await transport.call('ping', {}, 1000);
+                if (ping.protocol !== HERDR_PROTOCOL) {
+                    this.state('needs-update', 'version');
+                    throw new Error('herdr: protocol mismatch');
+                }
+                this.failures = 0;
+                return transport;
+            }
+            catch (error) {
+                if (error.message === 'herdr: protocol mismatch')
+                    throw error;
+            }
+        }
+        this.state('failed', 'socket');
+        throw new Error('herdr: socket unavailable');
+    }
+    async stop() {
+        this.stopping = true;
+        clearTimeout(this.retry);
+        if (this.o.mode === 'own' && this.child?.pid) {
+            try {
+                await this.transport?.call('server.stop', {}, 1000);
+            }
+            catch { /* process may have exited */ }
+            const child = this.child;
+            const exited = new Promise((resolve) => { if (child.exitCode !== null)
+                resolve();
+            else
+                child.once('exit', () => resolve()); });
+            for (const signal of ['SIGTERM', 'SIGKILL']) {
+                if (child.exitCode !== null)
+                    break;
+                if (signal === 'SIGTERM')
+                    await Promise.race([exited, delay(3000)]);
+                if (child.exitCode !== null)
+                    break;
+                try {
+                    process.kill(-child.pid, signal);
+                }
+                catch { /* already gone */ }
+            }
+            await Promise.race([exited, delay(3000)]);
+            try {
+                unlinkSync(join(this.root, 'server.pid'));
+            }
+            catch { /* absent */ }
+        }
+        this.transport?.close();
+        this.state('stopped');
+    }
+}

package/dist/terminal.d.ts

@@ -0,0 +1,6 @@
+import type { TerminalSession } from './types.ts';
+export declare function openTerminal(bin: string, env: Record<string, string>, paneId: string, o: {
+    mode: 'control' | 'observe';
+    cols: number;
+    rows: number;
+}): TerminalSession;

package/dist/terminal.js

@@ -0,0 +1,105 @@
+// `herdr terminal session <control|observe> <paneId>`: Herdr's own NDJSON terminal frames passed through untouched
+// (docs/runtime-kits.md 6.5). Frames arrive byte-identical (split on `\n` only, no trimming); `send` writes one line
+// plus `\n`. `pause`/`resume` stop and restart reading stdout, so a slow consumer holds Herdr back instead of
+// buffering in the host. The env comes from the caller per 6.5 — never `process.env`.
+import { spawn } from 'node:child_process';
+import { missingBinary } from "./cli.js";
+const STDERR_TAIL_BYTES = 4 * 1024;
+export function openTerminal(bin, env, paneId, o) {
+    if (typeof bin !== 'string' || bin.length === 0)
+        throw new Error('herdr: bin must be a non-empty string');
+    if (typeof paneId !== 'string' || paneId.length === 0 || paneId.includes('\0')) {
+        throw new Error('herdr: paneId must be a non-empty string without NUL');
+    }
+    const args = ['terminal', 'session', o.mode, paneId];
+    if (o.mode === 'control')
+        args.push('--takeover'); // takeover is a control-only flag (6.5)
+    args.push('--cols', String(o.cols), '--rows', String(o.rows));
+    const child = spawn(bin, args, { env, stdio: ['pipe', 'pipe', 'pipe'] });
+    const frames = new Set();
+    let readyResolve;
+    let readyReject;
+    let firstFrame = false;
+    let stderrTail = Buffer.alloc(0);
+    let pending = Buffer.alloc(0);
+    let exitedSettled = false;
+    let paused = false;
+    const ready = new Promise((resolve, reject) => { readyResolve = resolve; readyReject = reject; });
+    const exited = new Promise((resolve) => {
+        const settle = (code) => {
+            if (exitedSettled)
+                return;
+            exitedSettled = true;
+            resolve({ code, stderrTail: stderrTail.toString('utf8') });
+        };
+        child.on('error', (e) => {
+            settle(null);
+            readyReject?.(e.code === 'ENOENT' ? missingBinary(bin, 'no executable') : e);
+        });
+        child.on('close', (code) => settle(code));
+    });
+    child.on('close', () => {
+        if (!firstFrame)
+            readyReject?.(new Error(`herdr terminal exited before output: ${stderrTail.toString('utf8')}`));
+    });
+    // While paused, lines already read stay in `pending` and stdout stops reading, so the pipe fills and Herdr blocks.
+    // A resume() from inside a handler must not deliver the next frame before this one reaches every handler.
+    let delivering = false;
+    const deliver = () => {
+        if (delivering)
+            return;
+        delivering = true;
+        try {
+            for (let i = pending.indexOf(0x0a); i !== -1 && !paused; i = pending.indexOf(0x0a)) {
+                const line = pending.subarray(0, i).toString('utf8'); // bytes between newlines, unmodified
+                pending = pending.subarray(i + 1);
+                if (!firstFrame) {
+                    firstFrame = true;
+                    readyResolve?.();
+                }
+                for (const fn of frames)
+                    fn(line);
+            }
+        }
+        finally {
+            delivering = false;
+        }
+    };
+    child.stdout.on('data', (chunk) => {
+        pending = Buffer.concat([pending, chunk]);
+        deliver();
+    });
+    child.stderr.on('data', (chunk) => {
+        stderrTail = stderrTail.length + chunk.length > STDERR_TAIL_BYTES
+            ? Buffer.concat([stderrTail, chunk]).subarray(-STDERR_TAIL_BYTES)
+            : Buffer.concat([stderrTail, chunk]);
+    });
+    child.stdin.on('error', () => { }); // a send after the child died must not crash the host
+    return {
+        ready,
+        onFrame(fn) {
+            frames.add(fn);
+            return () => frames.delete(fn);
+        },
+        send(line) {
+            if (child.stdin.writable)
+                child.stdin.write(line + '\n');
+        },
+        pause() {
+            paused = true;
+            child.stdout.pause();
+        },
+        resume() {
+            paused = false;
+            deliver();
+            if (!paused)
+                child.stdout.resume(); // a frame handler may have paused again
+        },
+        close() {
+            child.kill();
+            if (paused)
+                child.stdout.removeAllListeners('data').resume(); // drain unread output so `exited` settles
+        },
+        exited,
+    };
+}

package/dist/testing/contract.d.ts

@@ -0,0 +1,9 @@
+import type { HerdrKit } from '../kit.ts';
+import type { FakeHerdr } from './fake-herdr/server.ts';
+import type { HerdrTransport } from '../types.ts';
+export type HerdrContractBench = {
+    kit: HerdrKit;
+    fake?: FakeHerdr;
+    withTransport?: (transport: HerdrTransport) => HerdrKit;
+};
+export declare function herdrContract(make: () => Promise<HerdrContractBench>): void;

package/dist/testing/contract.js

@@ -0,0 +1,308 @@
+// The contract suite (docs/runtime-kits.md 6.8): the same kit-level assertions run against the fake
+// in later work packages' tests (H3/H5 wire `make` up) and against the real pinned Herdr in the lab
+// (H9, which passes no `fake`). Cases that need to script the transport's wire answers use
+// `withTransport`; when a `make` omits it, those cases skip.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { HERDR_PROTOCOL } from "../constants.js";
+export function herdrContract(make) {
+    const settle = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    async function until(probe, ok, ms = 2000) {
+        const deadline = Date.now() + ms;
+        for (;;) {
+            const value = probe();
+            if (value !== undefined && value !== null && ok(value))
+                return value;
+            if (Date.now() >= deadline) {
+                assert.fail(`condition not reached within ${ms}ms: ${JSON.stringify(value ?? null)}`);
+            }
+            await settle(10);
+        }
+    }
+    async function bench(run) {
+        const made = await make();
+        try {
+            await run(made);
+        }
+        finally {
+            await made.kit.stop().catch(() => { });
+            await made.fake?.stop().catch(() => { });
+        }
+    }
+    function agentStatusOf(snapshot, paneId) {
+        let panes = 0;
+        let status;
+        for (const workspace of snapshot.workspaces) {
+            for (const tab of workspace.tabs) {
+                for (const pane of tab.panes) {
+                    panes += 1;
+                    if (pane.id === paneId)
+                        status = pane.agent?.status;
+                }
+            }
+        }
+        return { status, panes };
+    }
+    test('contract: start reaches ready and ping speaks the pinned protocol', async () => {
+        await bench(async ({ kit }) => {
+            await kit.start();
+            assert.equal(kit.state.phase, 'ready');
+            const ping = (await kit.call('ping', {}));
+            assert.equal(ping.protocol, HERDR_PROTOCOL);
+            assert.equal(typeof ping.version, 'string');
+        });
+    });
+    test('contract: a protocol mismatch reports needs-update', async (t) => {
+        await bench(async ({ withTransport }) => {
+            if (!withTransport)
+                return t.skip('make provides no transport double');
+            const kit = withTransport({
+                call: async () => ({ protocol: HERDR_PROTOCOL + 999 }),
+                subscribe: () => () => { },
+                close: () => { },
+            });
+            try {
+                await kit.start().catch(() => { });
+                assert.equal(kit.state.phase, 'needs-update');
+            }
+            finally {
+                await kit.stop().catch(() => { });
+            }
+        });
+    });
+    test('contract: an event racing the bootstrap snapshot is applied after it, once', async (t) => {
+        await bench(async ({ withTransport }) => {
+            if (!withTransport)
+                return t.skip('make provides no transport double');
+            const snapshot = {
+                snapshot: {
+                    workspaces: [{ workspace_id: 'w1', label: 'x', focused: true, tab_count: 1, active_tab_id: 'w1:t1' }],
+                    tabs: [{ tab_id: 'w1:t1', workspace_id: 'w1', label: 'main' }],
+                    panes: [{ pane_id: 'w1:p2', tab_id: 'w1:t1', workspace_id: 'w1', focused: false, agent_status: 'idle' }],
+                    agents: [{ pane_id: 'w1:p2', agent_status: 'idle', revision: 0 }],
+                },
+            };
+            const kit = withTransport({
+                // The ack carries the race: `pane.updated` lands after the subscribe but before the kit
+                // installs the snapshot, so buffering must order it after — and never duplicate it.
+                call: async (method) => (method === 'session.snapshot' ? snapshot : { protocol: HERDR_PROTOCOL }),
+                subscribe: (_subs, on) => {
+                    queueMicrotask(() => on({ type: 'pane.updated', pane: { pane_id: 'w1:p2', agent_status: 'working' } }));
+                    return () => { };
+                },
+                close: () => { },
+            });
+            try {
+                await kit.start();
+                assert.equal(kit.state.phase, 'ready');
+                assert.equal(kit.snapshot().workspaces.length, 1, 'the snapshot still installs');
+                await until(() => agentStatusOf(kit.snapshot(), 'w1:p2').status, (s) => s === 'working');
+                assert.equal(agentStatusOf(kit.snapshot(), 'w1:p2').panes, 1, 'no duplicate pane from the race');
+            }
+            finally {
+                await kit.stop().catch(() => { });
+            }
+        });
+    });
+    test('contract: a rejected subscription surfaces once and is not retried', async (t) => {
+        await bench(async ({ withTransport }) => {
+            if (!withTransport)
+                return t.skip('make provides no transport double');
+            let subscribeCalls = 0;
+            const kit = withTransport({
+                call: async () => ({ protocol: HERDR_PROTOCOL }),
+                subscribe: (subs, _on, onError) => {
+                    subscribeCalls += 1;
+                    if (subs.some((s) => s.type === 'pane.agent_status_changed')) {
+                        onError('invalid_subscription', 'pane.agent_status_changed needs a pane_id');
+                    }
+                    return () => { };
+                },
+                close: () => { },
+            });
+            try {
+                await kit.start().catch(() => { });
+                const bootstrapCalls = subscribeCalls;
+                // Deliberately schema-invalid: the pinned schema (6.7) requires pane_id for this filtered
+                // kind, so the server rejects the batch — the exact answer the transport double gives here.
+                const rejected = { type: 'pane.agent_status_changed' };
+                kit.subscribe([rejected], () => { });
+                await settle(1200); // longer than the 1 s reconnect delay a retry would use
+                assert.equal(subscribeCalls, bootstrapCalls + 1, 'the rejected subscription is never retried');
+            }
+            finally {
+                await kit.stop().catch(() => { });
+            }
+        });
+    });
+    test('contract: events reach a subscriber; unsubscribe stops them', async () => {
+        await bench(async ({ kit, fake }) => {
+            if (!fake)
+                return;
+            await kit.start();
+            const seen = [];
+            const stop = kit.subscribe([{ type: 'pane.created' }], (event) => seen.push(event));
+            await settle(100); // the subscribe registers on its own socket; an emit before that never arrives
+            fake.emit({ type: 'pane.created', pane_id: 'w9:p9' });
+            await until(() => seen.length, (n) => n >= 1);
+            assert.equal(seen[0].pane_id, 'w9:p9');
+            stop();
+            fake.emit({ type: 'pane.created', pane_id: 'w9:p10' });
+            await settle(100);
+            assert.equal(seen.length, 1, 'no frames after unsubscribe');
+        });
+    });
+    test('contract: the per-pane status watch keeps the tree and blocked list current', async () => {
+        await bench(async ({ kit, fake }) => {
+            if (!fake)
+                return;
+            await kit.start();
+            await settle(100); // the bootstrap's per-pane watch registers on its own socket
+            fake.setStatus('w1:p2', 'working');
+            await until(() => agentStatusOf(kit.snapshot(), 'w1:p2').status, (s) => s === 'working');
+            fake.setStatus('w1:p2', 'blocked');
+            const blocked = await until(() => kit.blocked(), (list) => list.length === 1);
+            assert.equal(blocked[0].paneId, 'w1:p2');
+            assert.equal(blocked[0].prompt, 'Allow this? (y/n)');
+            assert.equal(typeof blocked[0].revision, 'number');
+            assert.ok(blocked[0].revision >= 1);
+            fake.setStatus('w1:p2', 'idle');
+            await until(() => kit.blocked().length, (n) => n === 0);
+        });
+    });
+    test('contract: startAgent returns fresh pane ids in every placement', async () => {
+        await bench(async ({ kit }) => {
+            await kit.start();
+            const taken = new Set(['w1:p1', 'w1:p2']);
+            const start = (place, extra = {}) => kit.startAgent({ kind: 'pi', cwd: '/tmp/h6', place, ...extra });
+            const ws = await start({ workspace: 'new' });
+            const tab = await start({ tab: 'new', workspaceId: 'w1' });
+            const split = await start({ split: 'w1:p1', direction: 'right' });
+            const pane = await start({ pane: 'w1:p1' });
+            const tree = await start({ workspace: 'new' }, { worktree: { branch: 'h6' } });
+            for (const [name, ref] of [['workspace', ws], ['tab', tab], ['split', split], ['worktree', tree]]) {
+                assert.match(ref.paneId, /^w\d+:p\d+$/, `${name} placement gets a live-shaped pane id`);
+                assert.ok(!taken.has(ref.paneId), `${name} placement never predicts an existing pane id`);
+                taken.add(ref.paneId);
+            }
+            assert.equal(pane.paneId, 'w1:p1', 'the pane placement uses the pane as given');
+            assert.equal(typeof ws.name, 'string');
+            const workspaces = (await kit.call('workspace.list', {}));
+            assert.ok(workspaces.workspaces?.some((workspace) => workspace.worktree?.is_linked_worktree === true), 'the worktree placement registers a linked checkout');
+        });
+    });
+    test('contract: prompt validates the receipt and appends the reply text', async () => {
+        await bench(async ({ kit }) => {
+            await kit.start();
+            const receipt = await kit.prompt({ paneId: 'w1:p2' }, 'hello world');
+            const shaped = receipt; // compile-time: the receipt keeps the frozen shape
+            assert.equal(shaped.paneId, 'w1:p2');
+            assert.equal(typeof shaped.terminalId, 'string');
+            assert.equal(shaped.status, 'working');
+            assert.ok(shaped.revision >= 1);
+            assert.equal(await kit.wait({ paneId: 'w1:p2' }, { until: ['idle'], timeoutMs: 2000 }), 'idle');
+            const read = await kit.read('w1:p2');
+            assert.match(read.text, /fake pi: hello world/);
+        });
+    });
+    test('contract: a malformed prompt receipt fails', async (t) => {
+        await bench(async ({ withTransport }) => {
+            if (!withTransport)
+                return t.skip('make provides no transport double');
+            const kit = withTransport({
+                call: async (method) => {
+                    if (method === 'agent.prompt')
+                        return { type: 'nonsense' };
+                    if (method === 'session.snapshot') {
+                        return { snapshot: {
+                                workspaces: [{ workspace_id: 'w1', label: 'x' }],
+                                tabs: [{ tab_id: 'w1:t1', workspace_id: 'w1', label: 'main' }],
+                                panes: [{ pane_id: 'w1:p2', tab_id: 'w1:t1', workspace_id: 'w1' }],
+                                agents: [{ pane_id: 'w1:p2', agent_status: 'idle', revision: 1 }],
+                            } };
+                    }
+                    return { protocol: HERDR_PROTOCOL };
+                },
+                subscribe: () => () => { },
+                close: () => { },
+            });
+            try {
+                await kit.start().catch(() => { });
+                await assert.rejects(kit.prompt({ paneId: 'w1:p2' }, 'x'), /did not queue/);
+            }
+            finally {
+                await kit.stop().catch(() => { });
+            }
+        });
+    });
+    test('contract: wait resolves on a matching status and honors its timeout', async () => {
+        await bench(async ({ kit }) => {
+            await kit.start();
+            assert.equal(await kit.wait({ paneId: 'w1:p2' }, { until: ['idle'], timeoutMs: 2000 }), 'idle');
+            const started = Date.now();
+            const status = await kit.wait({ paneId: 'w1:p2' }, { until: ['done'], timeoutMs: 60 });
+            assert.equal(status, 'idle', 'the deadline returns the current status');
+            assert.ok(Date.now() - started < 2000, 'the wait honors its timeout instead of hanging');
+        });
+    });
+    test('contract: read unwraps result.read', async () => {
+        await bench(async ({ kit }) => {
+            await kit.start();
+            assert.deepEqual(await kit.read('w1:p1'), { text: 'ready.', truncated: false });
+            assert.deepEqual(await kit.read('w1:p1', { lines: 5 }), { text: 'ready.', truncated: false });
+            assert.equal((await kit.read('w1:p2', { source: 'detection' })).text, '', 'an unblocked agent has no detection text');
+        });
+    });
+    test('contract: blocked answers refuse a stale revision and accept the current one', async () => {
+        await bench(async ({ kit }) => {
+            await kit.start();
+            await kit.prompt({ paneId: 'w1:p2' }, 'ask permission');
+            const blocked = await until(() => kit.blocked(), (list) => list.length === 1);
+            const revision = blocked[0].revision;
+            await assert.rejects(kit.answer('w1:p2', ['y'], { revision: revision - 1 }), (e) => e.code === 'approval-stale', 'a stale revision is refused');
+            assert.equal(kit.blocked().length, 1, 'the refusal leaves the question open');
+            await kit.answer('w1:p2', ['y'], { revision });
+            await until(() => kit.blocked().length, (n) => n === 0);
+            assert.equal(await kit.wait({ paneId: 'w1:p2' }, { until: ['idle'], timeoutMs: 2000 }), 'idle');
+        });
+    });
+    test('contract: close guards refuse widening and close exact', async () => {
+        await bench(async ({ kit }) => {
+            await kit.start();
+            // A fresh workspace holds exactly one tab with exactly one pane: the widening cases.
+            const made = (await kit.call('workspace.create', { cwd: '/tmp/h6-other' }));
+            const w2 = made.workspace?.workspace_id;
+            assert.equal(typeof w2, 'string');
+            await assert.rejects(kit.closePane(`${w2}:p1`), (e) => e.code === 'pane-close-would-widen', 'closing the last pane would close the tab');
+            await assert.rejects(kit.closeTab(`${w2}:t1`), (e) => e.code === 'tab-close-would-widen', 'closing the only tab would close the workspace');
+            // worktree.create links a checkout into w1's group: the root now widens on close.
+            await kit.startAgent({ kind: 'pi', cwd: '/tmp/h6', place: { workspace: 'new' }, worktree: { branch: 'h6' } });
+            await assert.rejects(kit.closeWorkspace('w1'), (e) => e.code === 'workspace-close-would-widen', 'closing a worktree group parent would close the group');
+            // The exact closes still go through.
+            await kit.call('pane.split', { target_pane_id: `${w2}:p1`, direction: 'right' });
+            await kit.closePane(`${w2}:p1`);
+            await kit.call('tab.create', { workspace_id: w2, cwd: '/tmp/h6-other' });
+            await kit.closeTab(`${w2}:t1`);
+            await kit.closeWorkspace(w2);
+        });
+    });
+    test('contract: the cli answers --version and the terminal echoes', async () => {
+        await bench(async ({ kit }) => {
+            await kit.start();
+            const cli = await kit.cli(['--version']);
+            assert.equal(cli.exitCode, 0);
+            assert.match(cli.stdout, /^herdr 0\.9\.1\n$/);
+            const terminal = kit.terminal('w1:p1', { mode: 'observe', cols: 80, rows: 24 });
+            const frames = [];
+            terminal.onFrame((line) => frames.push(line));
+            await terminal.ready;
+            assert.match(frames[0], /terminal\.ready/);
+            terminal.send(`${JSON.stringify({ type: 'terminal.input', data: 'echo hi' })}\n`);
+            await until(() => frames.length, (n) => n >= 2);
+            assert.match(frames[1], /echo hi/);
+            terminal.close();
+            const exited = await terminal.exited;
+            assert.ok(exited.code === 0 || exited.code === null);
+        });
+    });
+}

package/dist/testing/fake-herdr/bin.d.ts

@@ -0,0 +1,5 @@
+export declare function writeBinShim({ dir, socketPath }: {
+    dir: string;
+    socketPath: string;
+}): string;
+export declare function main(argv: string[]): Promise<void>;