@co0ontty/wand 0.3.0 → 0.4.0

package/dist/web-ui/index.js

@@ -18,7 +18,7 @@ export function renderApp(configPath) {
   <meta name="theme-color" content="#f6f1e8" media="(prefers-color-scheme: light)" />
   <meta name="theme-color" content="#1f1b17" media="(prefers-color-scheme: dark)" />
   <meta name="apple-mobile-web-app-capable" content="yes" />
-  <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
+  <meta name="apple-mobile-web-app-status-bar-style" content="default" />
   <meta name="apple-mobile-web-app-title" content="Wand" />
   <meta name="mobile-web-app-capable" content="yes" />
   <meta name="application-name" content="Wand" />
@@ -26,7 +26,7 @@ export function renderApp(configPath) {
   <meta name="msapplication-TileColor" content="#c5653d" />
   <meta name="msapplication-tap-highlight" content="no" />
   <link rel="icon" href="/icon.svg" type="image/svg+xml" />
-  <link rel="apple-touch-icon" href="/icon.svg" />
+  <link rel="apple-touch-icon" href="/icon-192.png" />
   <link rel="manifest" href="/manifest.json" />
   <link rel="stylesheet" href="/vendor/xterm/css/xterm.css" />
   <style>

package/dist/ws-broadcast.d.ts

@@ -0,0 +1,27 @@
+/**
+ * WebSocket broadcast manager for process events.
+ * Handles debounced output events, backpressure control, and client subscriptions.
+ */
+import { WebSocketServer } from "ws";
+import type { SessionSnapshot } from "./types.js";
+export interface ProcessEvent {
+    type: "output" | "status" | "started" | "ended" | "usage" | "task";
+    sessionId: string;
+    data?: unknown;
+}
+export declare class WsBroadcastManager {
+    private wss;
+    private clients;
+    private outputDebounceCache;
+    private eventEmitter;
+    constructor(wss: WebSocketServer);
+    /** Set up connection handling. Should be called once during server startup. */
+    setup(getSession: (id: string) => SessionSnapshot | null): void;
+    /** Emit a process event to all subscribed WebSocket clients. */
+    emitEvent(event: ProcessEvent): void;
+    /** Flush any pending debounced output for a session (e.g., before session close). */
+    flushOutput(sessionId: string): void;
+    private broadcast;
+    private processWsQueue;
+    private readSessionCookie;
+}

package/dist/ws-broadcast.js

@@ -0,0 +1,160 @@
+/**
+ * WebSocket broadcast manager for process events.
+ * Handles debounced output events, backpressure control, and client subscriptions.
+ */
+import { WebSocket } from "ws";
+import { EventEmitter } from "node:events";
+import { validateSession } from "./auth.js";
+// ── Constants ──
+const MAX_QUEUE_SIZE = 500;
+const OUTPUT_DEBOUNCE_MS = 16;
+// ── Manager ──
+export class WsBroadcastManager {
+    wss;
+    clients = new Set();
+    outputDebounceCache = new Map();
+    eventEmitter = new EventEmitter();
+    constructor(wss) {
+        this.wss = wss;
+    }
+    /** Set up connection handling. Should be called once during server startup. */
+    setup(getSession) {
+        this.wss.on("connection", (ws, req) => {
+            const sessionToken = this.readSessionCookie(req);
+            if (!sessionToken || !validateSession(sessionToken)) {
+                ws.close(1008, "Unauthorized");
+                return;
+            }
+            const client = {
+                ws,
+                sendQueue: [],
+                sendInProgress: false,
+                backpressurePaused: false,
+                lastOutputBySession: new Map(),
+            };
+            this.clients.add(client);
+            ws.on("close", () => {
+                this.clients.delete(client);
+            });
+            ws.on("error", () => {
+                // Already closed, ignore
+            });
+            ws.on("message", (data) => {
+                try {
+                    const msg = JSON.parse(data.toString());
+                    if (msg.type === "subscribe" && msg.sessionId) {
+                        const snapshot = getSession(msg.sessionId);
+                        if (snapshot) {
+                            ws.send(JSON.stringify({
+                                type: "init",
+                                sessionId: msg.sessionId,
+                                data: { ...snapshot, messages: snapshot.messages, output: snapshot.output },
+                            }));
+                        }
+                        else {
+                            ws.send(JSON.stringify({
+                                type: "error",
+                                sessionId: msg.sessionId,
+                                error: "Session not found",
+                            }));
+                        }
+                    }
+                }
+                catch {
+                    // Ignore malformed messages
+                }
+            });
+        });
+    }
+    /** Emit a process event to all subscribed WebSocket clients. */
+    emitEvent(event) {
+        // Debounce output events to reduce flicker during rapid streaming
+        if (event.type === "output") {
+            const existing = this.outputDebounceCache.get(event.sessionId);
+            if (existing) {
+                clearTimeout(existing.timer);
+                // Accumulate chunk data across debounce window so the browser can
+                // write incrementally instead of doing a full terminal reset.
+                const prevData = existing.event.data;
+                const curData = event.data;
+                const prevChunk = prevData?.chunk;
+                const curChunk = curData?.chunk;
+                if (prevChunk && curChunk) {
+                    event = { ...event, data: { ...curData, chunk: prevChunk + curChunk } };
+                }
+                else if (prevChunk && !curChunk) {
+                    event = { ...event, data: { ...curData, chunk: prevChunk } };
+                }
+            }
+            const timer = setTimeout(() => {
+                this.outputDebounceCache.delete(event.sessionId);
+                this.broadcast(event);
+            }, OUTPUT_DEBOUNCE_MS);
+            this.outputDebounceCache.set(event.sessionId, { event, timer });
+            return;
+        }
+        // Non-output events are sent immediately
+        this.broadcast(event);
+    }
+    /** Flush any pending debounced output for a session (e.g., before session close). */
+    flushOutput(sessionId) {
+        const existing = this.outputDebounceCache.get(sessionId);
+        if (existing) {
+            clearTimeout(existing.timer);
+            this.outputDebounceCache.delete(sessionId);
+            this.broadcast(existing.event);
+        }
+    }
+    // ── Internal ──
+    broadcast(event) {
+        const message = JSON.stringify(event);
+        for (const client of this.clients) {
+            if (client.ws.readyState !== WebSocket.OPEN)
+                continue;
+            // Apply backpressure if queue is too large
+            if (client.sendQueue.length >= MAX_QUEUE_SIZE) {
+                client.backpressurePaused = true;
+                continue;
+            }
+            if (client.backpressurePaused)
+                continue;
+            client.sendQueue.push(message);
+            this.processWsQueue(client);
+        }
+    }
+    processWsQueue(client) {
+        if (client.sendInProgress || client.sendQueue.length === 0) {
+            return;
+        }
+        if (client.backpressurePaused) {
+            if (client.sendQueue.length < MAX_QUEUE_SIZE * 0.8) {
+                client.backpressurePaused = false;
+            }
+            else {
+                return;
+            }
+        }
+        // Check socket state before dequeuing to avoid dropping messages
+        if (client.ws.readyState !== WebSocket.OPEN) {
+            // Socket closed — discard remaining queue and remove client
+            client.sendQueue.length = 0;
+            this.clients.delete(client);
+            return;
+        }
+        client.sendInProgress = true;
+        const message = client.sendQueue.shift();
+        client.ws.send(message, (err) => {
+            client.sendInProgress = false;
+            if (err)
+                return;
+            this.processWsQueue(client);
+        });
+    }
+    readSessionCookie(req) {
+        const cookie = req.headers.cookie;
+        if (!cookie)
+            return undefined;
+        const match = cookie.split(";").map((part) => part.trim()).find((part) => part.startsWith("wand_session="));
+        return match?.slice("wand_session=".length);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@co0ontty/wand",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "A web terminal for local CLI tools like Claude.",
   "type": "module",
   "bin": {