pikiloom 0.4.36 → 0.4.38

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 */ }
+    }
+}