@newbase-clawchat/openclaw-clawchat 2026.5.4 → 2026.5.12-13

package/dist/src/ws-alignment.js

@@ -0,0 +1,178 @@
+import { formatWsLog } from "./ws-log.js";
+export const MAX_WS_QUEUE_SIZE = 128;
+export function createAlignedWsQueue(options) {
+    const maxSize = options.maxSize ?? MAX_WS_QUEUE_SIZE;
+    const queue = [];
+    const context = () => options.context?.() ?? {
+        attempt: options.attempt ?? 1,
+        reconnectCount: options.reconnectCount ?? 0,
+        state: options.state ?? "ready",
+    };
+    const logFrame = (event, action, item, fields = [], logState) => {
+        const current = context();
+        options.log(formatWsLog({
+            event,
+            accountId: options.accountId,
+            attempt: current.attempt,
+            reconnectCount: current.reconnectCount,
+            state: logState ?? current.state,
+            action,
+            fields: [
+                ["event_name", item.eventName],
+                ["trace_id", item.traceId],
+                ["chat_id", item.chatId],
+                ...fields,
+            ],
+        }));
+    };
+    return {
+        enqueue(item) {
+            if (queue.length >= maxSize) {
+                const dropped = queue.shift();
+                if (dropped) {
+                    logFrame("send_queue_drop", "drop_oldest", dropped, [
+                        ["queue_size", queue.length],
+                        ["queue_max", maxSize],
+                    ], context().state);
+                    dropped.onDrop?.();
+                }
+            }
+            queue.push(item);
+            logFrame("send_queued", "queue", item, [["queue_size", queue.length]]);
+        },
+        flush(write) {
+            while (queue.length > 0) {
+                const item = queue[0];
+                try {
+                    write(item.wire);
+                    queue.shift();
+                    item.onWrite?.();
+                    logFrame("send_flush", "send", item, [["remaining", queue.length]], "ready");
+                }
+                catch (err) {
+                    logFrame("send_failed", "requeue_reconnect", item, [["queue_size", queue.length]]);
+                    throw err;
+                }
+            }
+        },
+        remove(item) {
+            const index = queue.indexOf(item);
+            if (index < 0)
+                return false;
+            queue.splice(index, 1);
+            return true;
+        },
+        snapshot() {
+            return [...queue];
+        },
+    };
+}
+export function createReconnectTracker(options) {
+    const stableResetMs = options.stableResetMs ?? 5000;
+    let attempt = 0;
+    let reconnectCount = 0;
+    let state = "idle";
+    let stableResetTimer;
+    const clearStableReset = () => {
+        if (!stableResetTimer)
+            return;
+        clearTimeout(stableResetTimer);
+        stableResetTimer = undefined;
+    };
+    return {
+        connectStart() {
+            clearStableReset();
+            attempt += 1;
+            state = "connecting";
+            return { attempt, reconnectCount };
+        },
+        scheduleReconnect(reason, details = {}) {
+            clearStableReset();
+            reconnectCount += 1;
+            state = "reconnecting";
+            if (details.delayMs !== undefined || details.maxDelayMs !== undefined) {
+                options.log(formatWsLog({
+                    event: "reconnect_scheduled",
+                    accountId: options.accountId,
+                    attempt,
+                    reconnectCount,
+                    state: "reconnecting",
+                    action: "wait",
+                    fields: [
+                        ["delay_ms", details.delayMs],
+                        ["max_delay_ms", details.maxDelayMs ?? options.maxDelayMs],
+                        ["reason", reason],
+                    ],
+                }));
+            }
+            return { attempt, reconnectCount };
+        },
+        markReady() {
+            clearStableReset();
+            state = "ready";
+            stableResetTimer = setTimeout(() => {
+                reconnectCount = 0;
+                options.log(formatWsLog({
+                    event: "reconnect_backoff_reset",
+                    accountId: options.accountId,
+                    attempt,
+                    reconnectCount,
+                    state: "ready",
+                    action: "reset",
+                    fields: [["stable_ms", stableResetMs]],
+                }));
+                stableResetTimer = undefined;
+            }, stableResetMs);
+        },
+        markClosed() {
+            clearStableReset();
+            state = "closed";
+        },
+        snapshot() {
+            return { attempt, reconnectCount, state };
+        },
+    };
+}
+export function createProtocolControlHandler(options) {
+    const context = () => options.context?.() ?? {
+        attempt: options.attempt ?? 1,
+        reconnectCount: options.reconnectCount ?? 0,
+        state: options.state ?? "ready",
+    };
+    const logControl = (event, action, fields) => {
+        const current = context();
+        options.log(formatWsLog({
+            event,
+            accountId: options.accountId,
+            attempt: current.attempt,
+            reconnectCount: current.reconnectCount,
+            state: current.state,
+            action,
+            fields,
+        }));
+    };
+    return {
+        handleInbound(env) {
+            if (env.event === "ping") {
+                logControl("protocol_ping_received", "send_pong", [["trace_id", env.trace_id]]);
+                options.send(JSON.stringify({
+                    version: "2",
+                    event: "pong",
+                    trace_id: env.trace_id ?? "-",
+                    emitted_at: Date.now(),
+                    payload: {},
+                }));
+                return true;
+            }
+            if (env.event === "pong") {
+                logControl("protocol_pong_received", "ignore", [["trace_id", env.trace_id]]);
+                return true;
+            }
+            return false;
+        },
+        heartbeatTimeout(timeoutMs) {
+            logControl("heartbeat_timeout", "reconnect", [["timeout_ms", timeoutMs]]);
+            options.scheduleReconnect?.("heartbeat_timeout");
+        },
+    };
+}