chrome-openclaw-sider 1.0.2 → 1.0.26

package/dist/src/channel-monitor.js

@@ -0,0 +1,341 @@
+import { WebSocket } from "ws";
+import {
+  DEFAULT_MONITOR_KEEPALIVE_MS,
+  DEFAULT_MONITOR_PONG_TIMEOUT_MS
+} from "./channel-types.js";
+import {
+  logDebug,
+  createMonitorLogger,
+  siderRelayMonitors,
+  sleep
+} from "./channel-runtime.js";
+import {
+  connectRelaySocket,
+  setRelaySocketConnected,
+  clearRelaySocketState,
+  closeSocketQuietly,
+  wsDataToText,
+  parseInboundFrame,
+  resolveAckSessionId,
+  resolveAckId,
+  resolveAckClientReqId,
+  resolveManagedAck,
+  describeSocketClose,
+  getSocketCloseInfo,
+  waitForAbortSignal,
+  buildRelayMonitorAccountSignature
+} from "./channel-relay.js";
+import { toRecord } from "./channel-util.js";
+async function monitorSiderSession(params) {
+  const { cfg, account, abortSignal, log } = params;
+  let currentCfg = cfg;
+  let currentAccount = account;
+  const monitorLog = createMonitorLogger(log);
+  while (!abortSignal.aborted) {
+    let ws = null;
+    let skipSleep = false;
+    try {
+      monitorLog.info(`[${currentAccount.accountId}] opening sider relay websocket`, {
+        accountId: currentAccount.accountId,
+        relayId: currentAccount.relayId
+      });
+      ws = await connectRelaySocket({
+        account: currentAccount,
+        relayId: currentAccount.relayId
+      });
+      setRelaySocketConnected({
+        account: currentAccount,
+        ws,
+        relayId: currentAccount.relayId
+      });
+      monitorLog.info(`[${currentAccount.accountId}] sider relay connected`, {
+        accountId: currentAccount.accountId,
+        relayId: currentAccount.relayId
+      });
+      await new Promise((resolve) => {
+        const socket = ws;
+        if (!socket) {
+          resolve();
+          return;
+        }
+        let settled = false;
+        let pendingPingSince = 0;
+        const finish = (params2) => {
+          if (settled) {
+            return;
+          }
+          settled = true;
+          if (params2.logMessage) {
+            const data = {
+              accountId: currentAccount.accountId,
+              relayId: currentAccount.relayId
+            };
+            const writeLog = params2.warn ? monitorLog.warn : monitorLog.info;
+            writeLog(params2.logMessage, data);
+          }
+          if (params2.closeSocket) {
+            closeSocketQuietly(socket);
+          }
+          cleanup();
+          clearRelaySocketState({
+            accountId: currentAccount.accountId,
+            expectedWs: socket,
+            closeSocket: false,
+            reason: params2.reason
+          });
+          resolve();
+        };
+        const keepalive = setInterval(() => {
+          if (socket.readyState !== WebSocket.OPEN) {
+            return;
+          }
+          const now = Date.now();
+          if (pendingPingSince > 0 && now - pendingPingSince >= DEFAULT_MONITOR_PONG_TIMEOUT_MS) {
+            finish({
+              reason: `relay keepalive timeout after ${DEFAULT_MONITOR_PONG_TIMEOUT_MS}ms`,
+              closeSocket: true,
+              logMessage: `[${currentAccount.accountId}] sider relay keepalive timeout; reconnecting`,
+              warn: true
+            });
+            return;
+          }
+          try {
+            socket.send(JSON.stringify({ type: "ping" }));
+            if (pendingPingSince === 0) {
+              pendingPingSince = now;
+            }
+            logDebug("sent sider relay keepalive ping", {
+              accountId: currentAccount.accountId,
+              relayId: currentAccount.relayId
+            });
+          } catch (err) {
+            monitorLog.warn(`[${currentAccount.accountId}] sider relay keepalive failed: ${String(err)}`, {
+              accountId: currentAccount.accountId,
+              relayId: currentAccount.relayId,
+              error: String(err)
+            });
+            closeSocketQuietly(socket);
+          }
+        }, DEFAULT_MONITOR_KEEPALIVE_MS);
+        const cleanup = () => {
+          clearInterval(keepalive);
+          socket.off("message", onMessage);
+          socket.off("close", onClose);
+          socket.off("error", onError);
+          abortSignal.removeEventListener("abort", onAbort);
+        };
+        const onMessage = (data) => {
+          void (async () => {
+            const text = await wsDataToText(data);
+            const frame = parseInboundFrame(text);
+            if (!frame) {
+              return;
+            }
+            if (frame.type === "event") {
+              return;
+            }
+            pendingPingSince = 0;
+            const frameRecord = toRecord(frame);
+            monitorLog.info("ws frame message", {
+              type: frame.type,
+              sessionId: typeof frameRecord?.session_id === "string" ? frameRecord.session_id : void 0,
+              messageId: typeof frameRecord?.message_id === "string" ? frameRecord.message_id : void 0,
+              eventId: typeof frameRecord?.event_id === "string" ? frameRecord.event_id : void 0
+            });
+            if (frame.type === "ping") {
+              socket.send(JSON.stringify({ type: "pong" }));
+              return;
+            }
+            if (frame.type === "pong") {
+              logDebug("received sider relay keepalive pong", {
+                accountId: currentAccount.accountId,
+                relayId: currentAccount.relayId
+              });
+              return;
+            }
+            if (frame.type === "replaced") {
+              monitorLog.warn(`[${currentAccount.accountId}] sider relay replaced by a newer connection`, {
+                accountId: currentAccount.accountId,
+                relayId: currentAccount.relayId
+              });
+              closeSocketQuietly(socket);
+              return;
+            }
+            if (frame.type === "ack") {
+              const ackFrame = frame;
+              const resolved = resolveManagedAck({
+                accountId: currentAccount.accountId,
+                frame: ackFrame
+              });
+              logDebug("received sider ack on monitor socket", {
+                accountId: currentAccount.accountId,
+                sessionId: resolveAckSessionId(ackFrame),
+                id: resolveAckId(ackFrame),
+                clientReqId: resolveAckClientReqId(ackFrame),
+                resolved
+              });
+              return;
+            }
+            if (frame.type !== "message") {
+              return;
+            }
+            await params.onInboundMessage({
+              cfg: currentCfg,
+              account: currentAccount,
+              event: frame
+            });
+          })().catch((err) => {
+            log?.error(`[${currentAccount.accountId}] sider inbound handling failed: ${String(err)}`);
+          });
+        };
+        const onClose = (code, reason) => {
+          const closeInfo = getSocketCloseInfo({ code, reason });
+          if (closeInfo.code === 1008 && closeInfo.reason === "relay replaced") {
+            finish({
+              reason: `relay socket closed${describeSocketClose(closeInfo)}`,
+              logMessage: `[${currentAccount.accountId}] sider relay closed by gateway: relay replaced`,
+              warn: true
+            });
+          } else {
+            finish({
+              reason: `relay socket closed${describeSocketClose(closeInfo)}`,
+              logMessage: `[${currentAccount.accountId}] sider relay socket closed${describeSocketClose(closeInfo)}`
+            });
+          }
+        };
+        const onError = () => {
+          finish({
+            reason: "relay socket error",
+            logMessage: `[${currentAccount.accountId}] sider relay socket error`,
+            warn: true
+          });
+        };
+        const onAbort = () => {
+          finish({
+            reason: "relay monitor aborted",
+            closeSocket: true
+          });
+        };
+        socket.on("message", onMessage);
+        socket.on("close", onClose);
+        socket.on("error", onError);
+        abortSignal.addEventListener("abort", onAbort, { once: true });
+        if (abortSignal.aborted) {
+          onAbort();
+        }
+      });
+    } catch (err) {
+      monitorLog.warn(`[${currentAccount.accountId}] sider relay loop error: ${String(err)}`, {
+        accountId: currentAccount.accountId,
+        relayId: currentAccount.relayId,
+        error: String(err)
+      });
+    } finally {
+      if (ws) {
+        clearRelaySocketState({
+          accountId: currentAccount.accountId,
+          expectedWs: ws,
+          closeSocket: false,
+          reason: "relay reconnecting"
+        });
+        closeSocketQuietly(ws);
+      }
+    }
+    if (!abortSignal.aborted && !skipSleep) {
+      await sleep(currentAccount.reconnectDelayMs);
+    }
+  }
+  clearRelaySocketState({
+    accountId: currentAccount.accountId,
+    closeSocket: true
+  });
+}
+function launchManagedRelayMonitor(registration) {
+  const controller = new AbortController();
+  registration.controller = controller;
+  const runCfg = registration.cfg;
+  const runAccount = registration.account;
+  const runLog = registration.log;
+  registration.runner = (async () => {
+    try {
+      await monitorSiderSession({
+        cfg: runCfg,
+        account: runAccount,
+        abortSignal: controller.signal,
+        log: runLog,
+        onInboundMessage: registration.onInboundMessage
+      });
+    } finally {
+      const current = siderRelayMonitors.get(runAccount.accountId);
+      if (current !== registration || current.controller !== controller) {
+        return;
+      }
+      if (current.restartRequested && current.subscribers.size > 0) {
+        current.restartRequested = false;
+        launchManagedRelayMonitor(current);
+        return;
+      }
+      if (current.subscribers.size > 0) {
+        current.log?.warn(
+          `[${current.account.accountId}] managed sider relay monitor stopped unexpectedly; restarting`
+        );
+        launchManagedRelayMonitor(current);
+        return;
+      }
+      siderRelayMonitors.delete(runAccount.accountId);
+    }
+  })();
+}
+async function runManagedSiderRelayMonitor(params) {
+  const { account, abortSignal, log } = params;
+  const subscriberId = crypto.randomUUID();
+  const monitorSignature = buildRelayMonitorAccountSignature(account);
+  let registration = siderRelayMonitors.get(account.accountId);
+  if (!registration) {
+    registration = {
+      cfg: params.cfg,
+      account,
+      monitorSignature,
+      subscribers: /* @__PURE__ */ new Set([subscriberId]),
+      controller: new AbortController(),
+      runner: Promise.resolve(),
+      restartRequested: false,
+      log,
+      onInboundMessage: params.onInboundMessage
+    };
+    siderRelayMonitors.set(account.accountId, registration);
+    launchManagedRelayMonitor(registration);
+  } else {
+    registration.subscribers.add(subscriberId);
+    registration.log = log ?? registration.log;
+    if (registration.monitorSignature !== monitorSignature) {
+      registration.cfg = params.cfg;
+      registration.account = account;
+      registration.monitorSignature = monitorSignature;
+      registration.restartRequested = true;
+      log?.info(`[${account.accountId}] restarting sider relay monitor with updated settings`);
+      registration.controller.abort();
+    } else {
+      log?.info(`[${account.accountId}] reusing existing sider relay monitor`);
+    }
+  }
+  try {
+    await waitForAbortSignal(abortSignal);
+  } finally {
+    const current = siderRelayMonitors.get(account.accountId);
+    if (!current) {
+      return;
+    }
+    current.subscribers.delete(subscriberId);
+    if (current.subscribers.size > 0) {
+      return;
+    }
+    current.controller.abort();
+    await current.runner;
+  }
+}
+export {
+  launchManagedRelayMonitor,
+  monitorSiderSession,
+  runManagedSiderRelayMonitor
+};

package/dist/src/channel-relay.d.ts

@@ -0,0 +1,117 @@
+import { WebSocket } from 'ws';
+import { SiderRelaySocketState, SiderPendingAck, SiderInboundFrame, SiderInboundAck, SiderPart, SiderAggregation, SiderSampleEvent } from './channel-types.js';
+import { ResolvedSiderAccount } from './account.js';
+import 'openclaw/plugin-sdk';
+import 'openclaw/plugin-sdk/setup';
+import './auth.js';
+import 'openclaw/plugin-sdk/plugin-entry';
+import './auto-title.js';
+
+declare function getSocketCloseInfo(closeInfo?: {
+    code?: number;
+    reason?: string | Buffer;
+    wasClean?: boolean;
+}): {
+    code?: number;
+    reason?: string;
+    wasClean?: boolean;
+};
+declare function describeSocketClose(closeInfo?: {
+    code?: number;
+    reason?: string | Buffer;
+    wasClean?: boolean;
+}): string;
+declare function resolveRelayWsUrl(gatewayUrl: string): string;
+declare function wsDataToText(data: unknown): Promise<string>;
+declare function parseInboundFrame(rawText: string): SiderInboundFrame | null;
+declare function waitForSocketOpen(params: {
+    ws: WebSocket;
+    timeoutMs: number;
+    accountId: string;
+}): Promise<void>;
+declare function closeSocketQuietly(ws: WebSocket): void;
+declare function normalizeRelaySocketToken(token?: string): string | undefined;
+declare function getOrCreateRelaySocketState(accountId: string): SiderRelaySocketState;
+declare function buildRelaySocketAccountSignature(account: ResolvedSiderAccount): string;
+declare function buildRelayMonitorAccountSignature(account: ResolvedSiderAccount): string;
+declare function waitForAbortSignal(signal: AbortSignal): Promise<void>;
+declare function clearRelaySocketState(params: {
+    accountId: string;
+    expectedWs?: WebSocket;
+    closeSocket?: boolean;
+    reason?: string;
+}): void;
+declare function setRelaySocketConnected(params: {
+    account: ResolvedSiderAccount;
+    ws: WebSocket;
+    relayId: string;
+}): void;
+declare function waitForRelaySocketReady(params: {
+    account: ResolvedSiderAccount;
+    timeoutMs: number;
+}): Promise<{
+    ws: WebSocket;
+    state: SiderRelaySocketState;
+}>;
+declare function waitForManagedAck(params: {
+    state: SiderRelaySocketState;
+    accountId: string;
+    sessionId: string;
+    timeoutMs: number;
+    clientReqId?: string;
+}): Promise<string>;
+declare function readAckToken(value: unknown): string | undefined;
+declare function resolveAckSessionId(frame: SiderInboundAck): string | undefined;
+declare function resolveAckClientReqId(frame: SiderInboundAck): string | undefined;
+declare function resolveAckId(frame: SiderInboundAck): string | undefined;
+declare function countPendingAcks(state: SiderRelaySocketState): number;
+declare function detachPendingAck(state: SiderRelaySocketState, pendingAck: SiderPendingAck): void;
+declare function settlePendingAck(params: {
+    accountId: string;
+    state: SiderRelaySocketState;
+    pendingAck: SiderPendingAck;
+    ackId?: string;
+    ackClientReqId?: string;
+}): boolean;
+declare function resolveManagedAck(params: {
+    accountId: string;
+    frame: SiderInboundAck;
+}): boolean;
+declare function resolveFrameClientReqId(frame: Record<string, unknown>): string | undefined;
+declare function isAckTimeoutError(error: unknown): boolean;
+declare function sendRelayFrameWithAck(params: {
+    account: ResolvedSiderAccount;
+    sessionId: string;
+    frame: Record<string, unknown>;
+    timeoutMs: number;
+}): Promise<string>;
+declare function connectRelaySocket(params: {
+    account: ResolvedSiderAccount;
+    relayId: string;
+}): Promise<WebSocket>;
+declare function sendMessageToSider(params: {
+    account: ResolvedSiderAccount;
+    sessionId: string;
+    parts: SiderPart[];
+    aggregation?: SiderAggregation;
+    meta?: Record<string, unknown>;
+}): Promise<{
+    messageId: string;
+    conversationId: string;
+}>;
+declare function sendSiderEventBestEffort(params: {
+    account: ResolvedSiderAccount;
+    sessionId: string;
+    event: SiderSampleEvent;
+    context: string;
+}): Promise<void>;
+declare function sendSiderMessageBestEffort(params: {
+    account: ResolvedSiderAccount;
+    sessionId: string;
+    parts: SiderPart[];
+    aggregation?: SiderAggregation;
+    meta?: Record<string, unknown>;
+    context: string;
+}): Promise<void>;
+
+export { buildRelayMonitorAccountSignature, buildRelaySocketAccountSignature, clearRelaySocketState, closeSocketQuietly, connectRelaySocket, countPendingAcks, describeSocketClose, detachPendingAck, getOrCreateRelaySocketState, getSocketCloseInfo, isAckTimeoutError, normalizeRelaySocketToken, parseInboundFrame, readAckToken, resolveAckClientReqId, resolveAckId, resolveAckSessionId, resolveFrameClientReqId, resolveManagedAck, resolveRelayWsUrl, sendMessageToSider, sendRelayFrameWithAck, sendSiderEventBestEffort, sendSiderMessageBestEffort, setRelaySocketConnected, settlePendingAck, waitForAbortSignal, waitForManagedAck, waitForRelaySocketReady, waitForSocketOpen, wsDataToText };