pikiloom 0.4.37 → 0.4.39

package/packages/kernel/dist/runtime/session-runner.js

@@ -0,0 +1,210 @@
+// Drives ONE turn of ONE session: applies driver events into an accumulating
+// UniversalSnapshot and owns the single-session control verbs (stop/steer/interact).
+// Knows nothing about chat ids, queues, or transports.
+export class SessionRunner {
+    sessionKey;
+    agent;
+    taskId;
+    onUpdate;
+    interactionHandler;
+    snapshot;
+    seq = 0;
+    abort = new AbortController();
+    steerFn = null;
+    pending = null;
+    finished = false;
+    constructor(sessionKey, agent, taskId, onUpdate, interactionHandler) {
+        this.sessionKey = sessionKey;
+        this.agent = agent;
+        this.taskId = taskId;
+        this.onUpdate = onUpdate;
+        this.interactionHandler = interactionHandler;
+        this.snapshot = {
+            phase: 'queued', taskId, agent, sessionId: null,
+            text: '', reasoning: '', activity: '',
+            toolCalls: [], interactions: [], artifacts: [],
+            updatedAt: Date.now(),
+        };
+    }
+    get currentSeq() { return this.seq; }
+    publish() {
+        this.snapshot.updatedAt = Date.now();
+        this.seq += 1;
+        this.onUpdate(this.snapshot, this.seq);
+    }
+    async run(driver, input, prompt, model, effort) {
+        this.snapshot.phase = 'streaming';
+        this.snapshot.prompt = prompt;
+        this.snapshot.model = model;
+        this.snapshot.effort = effort;
+        this.snapshot.startedAt = Date.now();
+        this.publish();
+        const ctx = {
+            signal: this.abort.signal,
+            emit: (e) => this.applyEvent(e),
+            askUser: (interaction) => this.askUser(interaction),
+            registerSteer: (fn) => { this.steerFn = fn; },
+        };
+        let result;
+        try {
+            result = await driver.run(input, ctx);
+        }
+        catch (err) {
+            result = { ok: false, text: this.snapshot.text || '', error: err?.message || String(err), stopReason: 'error' };
+        }
+        // Merge terminal result into the snapshot (driver may have only streamed deltas).
+        if (result.text && result.text.trim() && result.text.length >= (this.snapshot.text || '').length) {
+            this.snapshot.text = result.text;
+        }
+        if (result.reasoning && !(this.snapshot.reasoning || '').trim())
+            this.snapshot.reasoning = result.reasoning;
+        if (result.sessionId)
+            this.snapshot.sessionId = result.sessionId;
+        if (result.usage)
+            this.snapshot.usage = result.usage;
+        this.snapshot.error = result.error ?? null;
+        this.snapshot.incomplete = !result.ok;
+        this.snapshot.phase = 'done';
+        this.snapshot.interactions = [];
+        this.finished = true;
+        this.flushPending({});
+        this.publish();
+        return result;
+    }
+    applyEvent(e) {
+        switch (e.type) {
+            case 'session':
+                this.snapshot.sessionId = e.sessionId;
+                break;
+            case 'text':
+                this.snapshot.text = (this.snapshot.text || '') + e.delta;
+                break;
+            case 'reasoning':
+                this.snapshot.reasoning = (this.snapshot.reasoning || '') + e.delta;
+                break;
+            case 'activity':
+                this.snapshot.activity = e.line;
+                break;
+            case 'plan':
+                this.snapshot.plan = e.plan;
+                break;
+            case 'artifact':
+                (this.snapshot.artifacts ||= []).push(e.artifact);
+                break;
+            case 'usage':
+                this.snapshot.usage = mergeUsage(this.snapshot.usage, e.usage);
+                break;
+            // toolCalls is the structured SSOT; activity is its derived human-readable view.
+            // A driver that streams explicit `activity` lines (e.g. echo) owns activity directly;
+            // any driver that emits structured tool/subagent events gets the projection for free.
+            case 'tool':
+                upsertTool(this.snapshot, e.call);
+                this.snapshot.activity = projectActivity(this.snapshot);
+                break;
+            case 'subagent':
+                upsertSubAgent(this.snapshot, e.subagent);
+                this.snapshot.activity = projectActivity(this.snapshot);
+                break;
+        }
+        this.publish();
+    }
+    askUser(interaction) {
+        if (this.finished || this.abort.signal.aborted)
+            return Promise.resolve({});
+        (this.snapshot.interactions ||= []).push(interaction);
+        this.publish();
+        return new Promise((resolve) => {
+            let settled = false;
+            const finish = (answers) => {
+                if (settled)
+                    return;
+                settled = true;
+                this.pending = null;
+                this.snapshot.interactions = (this.snapshot.interactions || []).filter(i => i.promptId !== interaction.promptId);
+                this.publish();
+                resolve(answers);
+            };
+            this.pending = { promptId: interaction.promptId, resolve: finish };
+            // A programmatic resolver may answer (or auto-cancel) the interaction; returning
+            // null defers to a terminal calling interact(). The default handler defers.
+            Promise.resolve(this.interactionHandler?.askUser(interaction) ?? null)
+                .then((answers) => { if (answers)
+                finish(answers); })
+                .catch(() => { });
+        });
+    }
+    flushPending(answers) {
+        this.pending?.resolve(answers);
+    }
+    // ---- control verbs ----
+    stop() {
+        this.abort.abort();
+        this.flushPending({});
+    }
+    async steer(prompt, attachments) {
+        if (this.finished || !this.steerFn)
+            return false;
+        return this.steerFn(prompt, attachments);
+    }
+    interact(promptId, action, value) {
+        if (!this.pending || this.pending.promptId !== promptId)
+            return false;
+        const interaction = (this.snapshot.interactions || []).find(i => i.promptId === promptId);
+        const q = interaction?.questions[interaction.currentIndex ?? 0] || interaction?.questions[0];
+        const qid = q?.id || 'answer';
+        const resolve = this.pending.resolve; // resolver does its own cleanup (pending/snapshot/publish)
+        if (action === 'cancel')
+            resolve({});
+        else if (action === 'skip')
+            resolve({ [qid]: [] });
+        else
+            resolve({ [qid]: [value ?? ''] });
+        return true;
+    }
+}
+// Derive the human-readable activity trail from the structured tool/subagent calls.
+// One line per call, with a status suffix: running -> "summary", done -> "summary done"
+// (or "summary -> detail"), failed -> "summary failed[: detail]". This is the kernel's
+// activity line contract — a lowest-common-denominator view every terminal can render
+// without re-deriving it from toolCalls itself.
+export function projectActivity(snap) {
+    const lines = [];
+    for (const t of snap.toolCalls || []) {
+        if (t.status === 'failed')
+            lines.push(t.result ? `${t.summary} failed: ${t.result}` : `${t.summary} failed`);
+        else if (t.status === 'done')
+            lines.push(t.result ? `${t.summary} -> ${t.result}` : `${t.summary} done`);
+        else
+            lines.push(t.summary);
+    }
+    for (const sub of snap.subAgents || []) {
+        const label = sub.description || sub.kind || 'subagent';
+        if (sub.status === 'failed')
+            lines.push(`Run task: ${label} failed`);
+        else if (sub.status === 'done')
+            lines.push(`Run task: ${label} done`);
+        else
+            lines.push(`Run task: ${label}`);
+    }
+    return lines.join('\n');
+}
+function upsertTool(snap, call) {
+    const list = (snap.toolCalls ||= []);
+    const idx = list.findIndex(t => t.id === call.id);
+    if (idx >= 0)
+        list[idx] = { ...list[idx], ...call };
+    else
+        list.push(call);
+}
+function upsertSubAgent(snap, sub) {
+    const list = (snap.subAgents ||= []);
+    const idx = list.findIndex(s => s.id === sub.id);
+    if (idx >= 0)
+        list[idx] = { ...list[idx], ...sub };
+    else
+        list.push(sub);
+}
+function mergeUsage(prev, next) {
+    const base = prev || { inputTokens: null, outputTokens: null, cachedInputTokens: null, contextPercent: null };
+    return { ...base, ...next };
+}

package/packages/kernel/dist/runtime/tui.d.ts

@@ -0,0 +1,8 @@
+import type { TuiSpec } from '../contracts/driver.js';
+import { type PtyExit } from './pty.js';
+export interface AttachTuiOptions {
+    stdin?: NodeJS.ReadStream;
+    stdout?: NodeJS.WriteStream;
+    observers?: Array<(chunk: string) => void>;
+}
+export declare function attachTui(spec: TuiSpec, opts?: AttachTuiOptions): Promise<PtyExit>;

package/packages/kernel/dist/runtime/tui.js

@@ -0,0 +1,35 @@
+import { PtyBridge } from './pty.js';
+// Full terminal passthrough: spawn the agent's TUI in a PTY and wire the caller's
+// stdin/stdout to it raw (so the user is "inside" the real Claude/Codex TUI), while
+// optionally tee-ing every byte to observers. Resolves with the exit code.
+export async function attachTui(spec, opts = {}) {
+    const stdin = opts.stdin ?? process.stdin;
+    const stdout = opts.stdout ?? process.stdout;
+    const bridge = PtyBridge.open(spec, { cols: stdout.columns, rows: stdout.rows });
+    for (const obs of opts.observers ?? [])
+        bridge.onData(obs);
+    const offData = bridge.onData((d) => { stdout.write(d); });
+    const wasRaw = !!stdin.isRaw;
+    if (stdin.isTTY)
+        stdin.setRawMode(true);
+    stdin.resume();
+    const onInput = (chunk) => bridge.write(typeof chunk === 'string' ? chunk : chunk.toString('utf8'));
+    stdin.on('data', onInput);
+    const onResize = () => bridge.resize(stdout.columns || 80, stdout.rows || 24);
+    stdout.on('resize', onResize);
+    return await new Promise((resolve) => {
+        bridge.onExit((e) => {
+            stdin.off('data', onInput);
+            stdout.off('resize', onResize);
+            offData();
+            if (stdin.isTTY) {
+                try {
+                    stdin.setRawMode(wasRaw);
+                }
+                catch { /* ignore */ }
+            }
+            stdin.pause();
+            resolve(e);
+        });
+    });
+}

package/packages/kernel/dist/runtime/turn.d.ts

@@ -0,0 +1,17 @@
+import type { UniversalSnapshot } from '../protocol/index.js';
+import type { AgentDriver, AgentTurnInput, DriverResult } from '../contracts/driver.js';
+import type { InteractionHandler } from '../contracts/ports.js';
+export interface RunTurnOptions {
+    prompt?: string;
+    model?: string | null;
+    effort?: string | null;
+    onSnapshot?: (snapshot: UniversalSnapshot) => void;
+    onSteer?: (steer: (prompt: string, attachments?: string[]) => Promise<boolean>) => void;
+    signal?: AbortSignal;
+    interactionHandler?: InteractionHandler;
+}
+export interface TurnOutcome {
+    result: DriverResult;
+    snapshot: UniversalSnapshot;
+}
+export declare function runTurn(driver: AgentDriver, input: AgentTurnInput, opts?: RunTurnOptions): Promise<TurnOutcome>;

package/packages/kernel/dist/runtime/turn.js

@@ -0,0 +1,16 @@
+import { SessionRunner } from './session-runner.js';
+import { AutoCancelInteractionHandler } from '../ports/defaults.js';
+export async function runTurn(driver, input, opts = {}) {
+    const handler = opts.interactionHandler ?? new AutoCancelInteractionHandler();
+    const runner = new SessionRunner('turn', driver.id, 'turn', (snap) => { opts.onSnapshot?.(snap); }, handler);
+    if (opts.onSteer)
+        opts.onSteer((p, a) => runner.steer(p, a));
+    if (opts.signal) {
+        if (opts.signal.aborted)
+            runner.stop();
+        else
+            opts.signal.addEventListener('abort', () => runner.stop(), { once: true });
+    }
+    const result = await runner.run(driver, input, opts.prompt ?? input.prompt, opts.model ?? input.model ?? null, opts.effort ?? input.effort ?? null);
+    return { result, snapshot: runner.snapshot };
+}

package/packages/kernel/dist/surfaces/cli.d.ts

@@ -0,0 +1,19 @@
+import type { LoomIO, Surface } from '../contracts/surface.js';
+export declare class CliSurface implements Surface {
+    private readonly opts;
+    readonly id = "cli";
+    readonly capabilities: {
+        editMessages: boolean;
+        images: boolean;
+        buttons: boolean;
+    };
+    private rl?;
+    private unsub?;
+    constructor(opts?: {
+        agent?: string;
+        input?: NodeJS.ReadableStream;
+        output?: NodeJS.WritableStream;
+    });
+    start(io: LoomIO): Promise<void>;
+    stop(): Promise<void>;
+}

package/packages/kernel/dist/surfaces/cli.js

@@ -0,0 +1,65 @@
+import readline from 'node:readline';
+// Simplest possible terminal: stdin lines -> prompts, snapshot text -> stdout.
+// Demonstrates that IM/Web/CLI are all just Terminals over the same LoomIO.
+export class CliSurface {
+    opts;
+    id = 'cli';
+    capabilities = { editMessages: false, images: false, buttons: false };
+    rl;
+    unsub;
+    constructor(opts = {}) {
+        this.opts = opts;
+    }
+    async start(io) {
+        const out = this.opts.output || process.stdout;
+        let sessionKey; // conversation continuity across lines
+        let pendingPromptId = null; // a HITL question awaiting an answer from this terminal
+        let lastQueued = 0;
+        this.unsub = io.subscribe((key, snap) => {
+            if (sessionKey && key !== sessionKey)
+                return; // single-conversation terminal
+            const interaction = (snap.interactions || [])[0];
+            if (interaction && interaction.promptId !== pendingPromptId && snap.phase !== 'done') {
+                pendingPromptId = interaction.promptId; // surface HITL; next line answers it
+                const q = interaction.questions[interaction.currentIndex ?? 0] || interaction.questions[0];
+                out.write(`\n[?] ${q?.text || interaction.title}\n> `);
+                return;
+            }
+            const q = snap.queued?.length ?? 0;
+            if (q !== lastQueued && snap.phase !== 'done') {
+                lastQueued = q;
+                if (q)
+                    out.write(`\n[queued: ${q}]\n> `);
+            }
+            if (snap.phase !== 'done')
+                return;
+            pendingPromptId = null;
+            lastQueued = 0;
+            out.write(`\n${snap.text || snap.error || '(no output)'}\n> `);
+        });
+        this.rl = readline.createInterface({ input: this.opts.input || process.stdin, output: out, prompt: '> ' });
+        this.rl.prompt();
+        this.rl.on('line', (line) => {
+            const text = line.trim();
+            if (!text) {
+                this.rl.prompt();
+                return;
+            }
+            if (pendingPromptId) {
+                const pid = pendingPromptId;
+                pendingPromptId = null;
+                io.interact(pid, 'text', text);
+                return;
+            } // HITL answer
+            if (text === '/models') { // discovery from the terminal (C2)
+                void io.listModels(this.opts.agent || io.listAgents()[0] || '').then(ms => out.write(`\n${ms.map(m => m.id).join(', ') || '(no models)'}\n> `));
+                return;
+            }
+            void io.prompt({ prompt: text, agent: this.opts.agent, sessionKey }).then(r => { sessionKey = r.sessionKey; }); // continue the conversation
+        });
+    }
+    async stop() {
+        this.unsub?.();
+        this.rl?.close();
+    }
+}

package/packages/kernel/dist/surfaces/index.d.ts

@@ -0,0 +1,2 @@
+export { WebSurface, type WebSurfaceOptions } from './web.js';
+export { CliSurface } from './cli.js';

package/packages/kernel/dist/surfaces/index.js

@@ -0,0 +1,2 @@
+export { WebSurface } from './web.js';
+export { CliSurface } from './cli.js';

package/packages/kernel/dist/surfaces/web.d.ts

@@ -0,0 +1,39 @@
+import type http from 'node:http';
+import type { LoomIO, Surface, SurfaceCapabilities, TuiHost } from '../contracts/surface.js';
+export interface WebSurfaceOptions {
+    port?: number;
+    server?: http.Server;
+    token?: string;
+    name?: string;
+    allowTui?: boolean;
+    access?: {
+        prompt?: boolean;
+        tui?: boolean;
+        tuiReadonly?: boolean;
+    };
+}
+export declare class WebSurface implements Surface {
+    private readonly opts;
+    readonly id = "web";
+    readonly capabilities: SurfaceCapabilities;
+    private wss?;
+    private io?;
+    private host?;
+    private unsub?;
+    private unsubSessions?;
+    private readonly peers;
+    constructor(opts?: WebSurfaceOptions);
+    get port(): number | null;
+    start(io: LoomIO, host?: TuiHost): Promise<void>;
+    stop(): Promise<void>;
+    private get tuiEnabled();
+    private get promptEnabled();
+    private killPeerPtys;
+    private hostInfo;
+    private onConnection;
+    private handle;
+    private sendFull;
+    private broadcastPatch;
+    private broadcast;
+    private send;
+}

package/packages/kernel/dist/surfaces/web.js

@@ -0,0 +1,244 @@
+import { WebSocketServer, WebSocket } from 'ws';
+import { PROTOCOL_VERSION, isClientMessage, } from '../protocol/index.js';
+import { randomUUID } from 'node:crypto';
+const SUBSCRIBE_ALL = '*';
+// The built-in Web/remote terminal: a ws host speaking the UniversalSnapshot wire
+// protocol over LoomIO. Any pikichannel client (incl. the existing pikiloom dashboard
+// SPA) can connect: hello -> subscribe -> receive `session` patches -> prompt/stop/steer.
+export class WebSurface {
+    opts;
+    id = 'web';
+    capabilities = { tunnel: true, images: true, buttons: true, editMessages: true };
+    wss;
+    io;
+    host;
+    unsub;
+    unsubSessions;
+    peers = new Set();
+    constructor(opts = {}) {
+        this.opts = opts;
+    }
+    get port() {
+        const a = this.wss?.address();
+        return a && typeof a === 'object' ? a.port : null;
+    }
+    async start(io, host) {
+        this.io = io;
+        this.host = host;
+        this.wss = this.opts.server
+            ? new WebSocketServer({ server: this.opts.server })
+            : new WebSocketServer({ port: this.opts.port ?? 0 });
+        if (!this.opts.server) {
+            await new Promise((resolve, reject) => {
+                this.wss.once('listening', resolve);
+                this.wss.once('error', reject);
+            });
+        }
+        this.wss.on('connection', (ws) => this.onConnection(ws));
+        this.unsub = io.subscribe((key, _snap, patch, seq) => this.broadcastPatch(key, patch, seq));
+        this.unsubSessions = io.onSessionsChanged((sessions) => this.broadcast({ type: 'sessions', sessions }, true));
+    }
+    async stop() {
+        this.unsub?.();
+        this.unsubSessions?.();
+        for (const p of this.peers) {
+            this.killPeerPtys(p);
+            try {
+                p.ws.close();
+            }
+            catch { /* ignore */ }
+        }
+        this.peers.clear();
+        await new Promise((resolve) => { if (this.wss)
+            this.wss.close(() => resolve());
+        else
+            resolve(); });
+    }
+    get tuiEnabled() { return !!this.host && this.opts.allowTui !== false && this.opts.access?.tui !== false; }
+    get promptEnabled() { return this.opts.access?.prompt !== false; }
+    killPeerPtys(peer) {
+        for (const b of peer.ptys.values()) {
+            try {
+                b.kill();
+            }
+            catch { /* ignore */ }
+        }
+        peer.ptys.clear();
+    }
+    hostInfo() {
+        const capabilities = ['subscribe-all', 'artifacts', 'history', 'catalog'];
+        if (this.promptEnabled)
+            capabilities.push('prompt', 'stop', 'steer', 'interact');
+        if (this.tuiEnabled)
+            capabilities.push('tui');
+        return { name: this.opts.name || 'loom', version: '0.1.0', transport: 'websocket', capabilities, authRequired: !!this.opts.token };
+    }
+    onConnection(ws) {
+        const peer = { ws, subs: new Set(), authed: !this.opts.token, ptys: new Map() };
+        this.peers.add(peer);
+        ws.on('message', (data) => {
+            let msg;
+            try {
+                msg = JSON.parse(data.toString());
+            }
+            catch {
+                return;
+            }
+            if (!isClientMessage(msg))
+                return;
+            this.handle(peer, msg).catch((err) => this.send(peer, { type: 'error', message: err?.message || String(err) }));
+        });
+        const cleanup = () => { this.killPeerPtys(peer); this.peers.delete(peer); };
+        ws.on('close', cleanup);
+        ws.on('error', cleanup);
+    }
+    async handle(peer, msg) {
+        if (msg.type === 'ping') {
+            this.send(peer, { type: 'pong', t: msg.t });
+            return;
+        }
+        if (!peer.authed) {
+            if (msg.type !== 'hello') {
+                this.send(peer, { type: 'error', message: 'not authenticated', code: 'auth' });
+                return;
+            }
+            if (this.opts.token && msg.token !== this.opts.token) {
+                this.send(peer, { type: 'error', message: 'unauthorized', code: 'auth' });
+                peer.ws.close();
+                return;
+            }
+            peer.authed = true;
+        }
+        if (msg.type === 'hello') {
+            this.send(peer, { type: 'welcome', v: PROTOCOL_VERSION, host: this.hostInfo(), sessions: this.io.listSessions() });
+            return;
+        }
+        switch (msg.type) {
+            case 'subscribe': {
+                peer.subs.add(msg.sessionKey);
+                if (msg.sessionKey === SUBSCRIBE_ALL)
+                    for (const m of this.io.listSessions())
+                        this.sendFull(peer, m.sessionKey);
+                else
+                    this.sendFull(peer, msg.sessionKey);
+                return;
+            }
+            case 'unsubscribe':
+                peer.subs.delete(msg.sessionKey);
+                return;
+            case 'getSnapshot':
+                this.sendFull(peer, msg.sessionKey);
+                return;
+            case 'listSessions':
+                this.send(peer, { type: 'sessions', sessions: this.io.listSessions() });
+                return;
+            case 'getHistory': {
+                const turns = await this.io.getHistory(msg.sessionKey);
+                this.send(peer, { type: 'history', sessionKey: msg.sessionKey, turns, ref: msg.ref });
+                return;
+            }
+            case 'getCatalog': {
+                const agent = msg.agent;
+                const agents = this.io.listAgentInfo();
+                const models = agent ? await this.io.listModels(agent) : [];
+                const effort = agent ? await this.io.listEffort(agent, msg.model ?? null) : [];
+                const tools = agent ? await this.io.listTools(agent, msg.workdir) : [];
+                const skills = agent ? await this.io.listSkills(agent, msg.workdir) : [];
+                this.send(peer, { type: 'catalog', agents, agent, models, effort, tools, skills, ref: msg.ref });
+                return;
+            }
+            case 'prompt': {
+                if (!this.promptEnabled) {
+                    this.send(peer, { type: 'error', message: 'prompt not permitted (read-only)', code: 'access', clientRef: msg.clientRef });
+                    return;
+                }
+                const res = await this.io.prompt({
+                    sessionKey: msg.sessionKey, prompt: msg.prompt, agent: msg.agent, workdir: msg.workdir,
+                    model: msg.model, effort: msg.effort, attachments: msg.attachments,
+                }).catch((e) => ({ error: e?.message || 'prompt failed' }));
+                if (res.error) {
+                    this.send(peer, { type: 'error', message: res.error, clientRef: msg.clientRef });
+                    return;
+                }
+                peer.subs.add(res.sessionKey);
+                this.send(peer, { type: 'accepted', sessionKey: res.sessionKey, taskId: res.taskId, clientRef: msg.clientRef });
+                this.sendFull(peer, res.sessionKey);
+                return;
+            }
+            case 'stop':
+                this.io.stop(msg.sessionKey);
+                return;
+            case 'steer':
+                await this.io.steer(msg.taskId, msg.prompt);
+                return;
+            case 'interact':
+                this.io.interact(msg.promptId, msg.action, msg.value);
+                return;
+            // ---- Lane R: raw PTY (TUI passthrough) ----
+            case 'openTui': {
+                if (!this.tuiEnabled || !this.host) {
+                    this.send(peer, { type: 'error', message: 'TUI not available', code: 'tui', clientRef: msg.ref });
+                    return;
+                }
+                let bridge;
+                try {
+                    bridge = await this.host.openTui({ agent: msg.agent, workdir: msg.workdir, model: msg.model, sessionId: msg.sessionId, cols: msg.cols, rows: msg.rows });
+                }
+                catch (e) {
+                    this.send(peer, { type: 'error', message: e?.message || 'openTui failed', code: 'tui', clientRef: msg.ref });
+                    return;
+                }
+                const tuiId = randomUUID();
+                peer.ptys.set(tuiId, bridge);
+                bridge.onData((data) => this.send(peer, { type: 'tuiData', tuiId, data }));
+                bridge.onExit((e) => { peer.ptys.delete(tuiId); this.send(peer, { type: 'tuiExit', tuiId, exitCode: e.exitCode, signal: e.signal }); });
+                this.send(peer, { type: 'tuiOpened', tuiId, ref: msg.ref });
+                return;
+            }
+            case 'tuiInput':
+                if (!this.opts.access?.tuiReadonly)
+                    peer.ptys.get(msg.tuiId)?.write(msg.data);
+                return; // readonly = spectator
+            case 'tuiResize':
+                peer.ptys.get(msg.tuiId)?.resize(msg.cols, msg.rows);
+                return;
+            case 'tuiClose': {
+                const b = peer.ptys.get(msg.tuiId);
+                if (b) {
+                    peer.ptys.delete(msg.tuiId);
+                    try {
+                        b.kill();
+                    }
+                    catch { /* ignore */ }
+                }
+                return;
+            }
+        }
+    }
+    sendFull(peer, sessionKey) {
+        const snap = this.io.getSnapshot(sessionKey);
+        if (!snap)
+            return;
+        this.send(peer, { type: 'session', sessionKey, seq: snap.seq, patch: { full: snap.snapshot } });
+    }
+    broadcastPatch(sessionKey, patch, seq) {
+        const frame = { type: 'session', sessionKey, seq, patch };
+        for (const peer of this.peers) {
+            if (peer.authed && (peer.subs.has(SUBSCRIBE_ALL) || peer.subs.has(sessionKey)))
+                this.send(peer, frame);
+        }
+    }
+    broadcast(frame, authedOnly = false) {
+        for (const peer of this.peers)
+            if (!authedOnly || peer.authed)
+                this.send(peer, frame);
+    }
+    send(peer, frame) {
+        if (peer.ws.readyState !== WebSocket.OPEN)
+            return;
+        try {
+            peer.ws.send(JSON.stringify(frame));
+        }
+        catch { /* ignore */ }
+    }
+}