pikiloom 0.4.36 → 0.4.38

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

@@ -0,0 +1,44 @@
+import type { AgentDriver, TuiSpec } from '../contracts/driver.js';
+import type { SessionStore, ModelResolver, ToolProvider, SystemPromptBuilder, Catalog, InteractionHandler } from '../contracts/ports.js';
+import type { LoomIO, Surface, Plugin } from '../contracts/surface.js';
+import { PtyBridge, type PtyOpenOpts, type PtyExit } from './pty.js';
+export interface TuiLaunchOptions {
+    agent?: string;
+    workdir?: string;
+    model?: string | null;
+    sessionId?: string | null;
+}
+export interface LoomConfig {
+    appNamespace?: string;
+    workdir?: string;
+    defaultAgent?: string;
+    drivers?: AgentDriver[];
+    surfaces?: Surface[];
+    plugins?: Plugin[];
+    sessionStore?: SessionStore;
+    modelResolver?: ModelResolver;
+    toolProvider?: ToolProvider;
+    systemPromptBuilder?: SystemPromptBuilder;
+    catalog?: Catalog;
+    interactionHandler?: InteractionHandler;
+    serialPerSession?: boolean;
+    systemPromptBase?: string;
+    log?: (msg: string) => void;
+}
+export interface Loom {
+    readonly io: LoomIO;
+    registerDriver(driver: AgentDriver): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    status(): {
+        agents: string[];
+        surfaces: string[];
+        started: boolean;
+    };
+    resolveTui(opts: TuiLaunchOptions): Promise<TuiSpec>;
+    openTui(opts: TuiLaunchOptions & PtyOpenOpts): Promise<PtyBridge>;
+    runTui(opts: TuiLaunchOptions & {
+        observers?: Array<(c: string) => void>;
+    }): Promise<PtyExit>;
+}
+export declare function createLoom(config?: LoomConfig): Loom;

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

@@ -0,0 +1,69 @@
+import { FsSessionStore, NullModelResolver, NoopToolProvider, PassthroughSystemPromptBuilder, NoopCatalog, DeferToTerminalInteractionHandler, defaultBaseDir, } from '../ports/defaults.js';
+import { Hub } from './hub.js';
+import { PtyBridge } from './pty.js';
+import { attachTui } from './tui.js';
+export function createLoom(config = {}) {
+    const appNamespace = config.appNamespace || 'loom';
+    const workdir = config.workdir || process.cwd();
+    const log = config.log || (() => { });
+    const drivers = new Map();
+    for (const d of config.drivers || [])
+        drivers.set(d.id, d);
+    const defaultAgent = config.defaultAgent || config.drivers?.[0]?.id || 'echo';
+    const hub = new Hub({
+        drivers,
+        defaultAgent,
+        workdir,
+        sessionStore: config.sessionStore || new FsSessionStore(defaultBaseDir(appNamespace)),
+        modelResolver: config.modelResolver || new NullModelResolver(),
+        toolProvider: config.toolProvider || new NoopToolProvider(),
+        systemPromptBuilder: config.systemPromptBuilder || new PassthroughSystemPromptBuilder(),
+        catalog: config.catalog || new NoopCatalog(),
+        interactionHandler: config.interactionHandler || new DeferToTerminalInteractionHandler(),
+        serialPerSession: config.serialPerSession,
+        plugins: config.plugins || [],
+        systemPromptBase: config.systemPromptBase,
+        log,
+    });
+    const surfaces = config.surfaces || [];
+    let started = false;
+    // Lane R opener (raw PTY): resolve the agent's TUI spec (with model injection) and
+    // spawn it in a PtyBridge. Shared by Loom.openTui and the TuiHost given to surfaces.
+    const openTui = async (opts) => {
+        const spec = await hub.resolveTui(opts);
+        return PtyBridge.open(spec, { cols: opts.cols, rows: opts.rows });
+    };
+    return {
+        io: hub,
+        registerDriver(driver) { drivers.set(driver.id, driver); },
+        async start() {
+            if (started)
+                return;
+            started = true;
+            for (const t of surfaces) {
+                await t.start(hub, { openTui }); // hub = Lane S (LoomIO); openTui = Lane R
+                log(`[loom] terminal started: ${t.id}`);
+            }
+        },
+        async stop() {
+            if (!started)
+                return;
+            started = false;
+            for (const t of surfaces) {
+                try {
+                    await t.stop();
+                }
+                catch { /* ignore */ }
+            }
+        },
+        status() {
+            return { agents: [...drivers.keys()], surfaces: surfaces.map(t => t.id), started };
+        },
+        resolveTui(opts) { return hub.resolveTui(opts); },
+        openTui,
+        async runTui(opts) {
+            const spec = await hub.resolveTui(opts);
+            return attachTui(spec, { observers: opts.observers });
+        },
+    };
+}

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

@@ -0,0 +1,23 @@
+import type { TuiSpec } from '../contracts/driver.js';
+export declare function ptyAvailable(): boolean;
+export interface PtyOpenOpts {
+    cols?: number;
+    rows?: number;
+}
+export interface PtyExit {
+    exitCode: number;
+    signal?: number;
+}
+export declare class PtyBridge {
+    private readonly proc;
+    private readonly dataCbs;
+    private readonly exitCbs;
+    private constructor();
+    static open(spec: TuiSpec, opts?: PtyOpenOpts): PtyBridge;
+    onData(cb: (d: string) => void): () => void;
+    onExit(cb: (e: PtyExit) => void): () => void;
+    write(data: string): void;
+    resize(cols: number, rows: number): void;
+    kill(signal?: string): void;
+    get pid(): number;
+}

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

@@ -0,0 +1,69 @@
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+let _pty;
+function loadPty() {
+    if (_pty === undefined) {
+        try {
+            _pty = require('node-pty');
+        }
+        catch {
+            _pty = null;
+        }
+    }
+    return _pty;
+}
+export function ptyAvailable() { return !!loadPty(); }
+// A pseudo-terminal bridge around an agent's interactive process. Carries raw TUI bytes
+// in both directions and fans `onData` out to many observers (full passthrough + tee/mirror).
+// This is the capability the kernel previously lacked: transparently passing through
+// Claude/Codex TUI traffic instead of only the structured -p stream.
+export class PtyBridge {
+    proc;
+    dataCbs = new Set();
+    exitCbs = new Set();
+    constructor(proc) {
+        this.proc = proc;
+        proc.onData((d) => { for (const cb of this.dataCbs) {
+            try {
+                cb(d);
+            }
+            catch { /* isolate */ }
+        } });
+        proc.onExit((e) => {
+            for (const cb of this.exitCbs) {
+                try {
+                    cb({ exitCode: e.exitCode, signal: e.signal });
+                }
+                catch { /* isolate */ }
+            }
+        });
+    }
+    static open(spec, opts = {}) {
+        const pty = loadPty();
+        if (!pty)
+            throw new Error('node-pty is not available — install the optional dependency `node-pty` to use TUI passthrough.');
+        const proc = pty.spawn(spec.command, spec.args, {
+            name: 'xterm-256color',
+            cols: opts.cols || 80,
+            rows: opts.rows || 24,
+            cwd: spec.cwd,
+            env: { ...process.env, ...(spec.env || {}) },
+        });
+        return new PtyBridge(proc);
+    }
+    onData(cb) { this.dataCbs.add(cb); return () => this.dataCbs.delete(cb); }
+    onExit(cb) { this.exitCbs.add(cb); return () => this.exitCbs.delete(cb); }
+    write(data) { try {
+        this.proc.write(data);
+    }
+    catch { /* closed */ } }
+    resize(cols, rows) { try {
+        this.proc.resize(Math.max(1, cols), Math.max(1, rows));
+    }
+    catch { /* closed */ } }
+    kill(signal) { try {
+        this.proc.kill(signal);
+    }
+    catch { /* closed */ } }
+    get pid() { return this.proc.pid; }
+}

package/packages/kernel/dist/runtime/session-runner.d.ts

@@ -0,0 +1,27 @@
+import type { UniversalSnapshot } from '../protocol/index.js';
+import type { AgentDriver, AgentTurnInput, DriverResult } from '../contracts/driver.js';
+import type { InteractionHandler } from '../contracts/ports.js';
+export declare class SessionRunner {
+    readonly sessionKey: string;
+    readonly agent: string;
+    readonly taskId: string;
+    private readonly onUpdate;
+    private readonly interactionHandler?;
+    readonly snapshot: UniversalSnapshot;
+    private seq;
+    private readonly abort;
+    private steerFn;
+    private pending;
+    private finished;
+    constructor(sessionKey: string, agent: string, taskId: string, onUpdate: (snapshot: UniversalSnapshot, seq: number) => void, interactionHandler?: InteractionHandler | undefined);
+    get currentSeq(): number;
+    private publish;
+    run(driver: AgentDriver, input: AgentTurnInput, prompt: string, model: string | null, effort: string | null): Promise<DriverResult>;
+    private applyEvent;
+    private askUser;
+    private flushPending;
+    stop(): void;
+    steer(prompt: string, attachments?: string[]): Promise<boolean>;
+    interact(promptId: string, action: 'select' | 'text' | 'skip' | 'cancel', value?: string): boolean;
+}
+export declare function projectActivity(snap: UniversalSnapshot): string;

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;
+}