@sider-ai/chrome-openclaw-sider 1.0.31

package/dist/src/channel-relay.js

@@ -0,0 +1,574 @@
+import { WebSocket } from "ws";
+import { createSiderWebSocket, logDebug, logWarn, siderRelaySockets } from "./channel-runtime.js";
+import { appendTokenQuery } from "./auth.js";
+function getSocketCloseInfo(closeInfo) {
+  if (!closeInfo || typeof closeInfo !== "object") {
+    return {};
+  }
+  return {
+    code: typeof closeInfo.code === "number" ? closeInfo.code : void 0,
+    reason: typeof closeInfo.reason === "string" ? closeInfo.reason : Buffer.isBuffer(closeInfo.reason) ? closeInfo.reason.toString("utf8") : void 0,
+    wasClean: typeof closeInfo.wasClean === "boolean" ? closeInfo.wasClean : void 0
+  };
+}
+function describeSocketClose(closeInfo) {
+  const { code, reason, wasClean } = getSocketCloseInfo(closeInfo);
+  const parts = [];
+  if (typeof code === "number") {
+    parts.push(`code=${code}`);
+  }
+  if (typeof reason === "string" && reason) {
+    parts.push(`reason=${reason}`);
+  }
+  if (typeof wasClean === "boolean") {
+    parts.push(`clean=${wasClean}`);
+  }
+  return parts.length > 0 ? ` (${parts.join(", ")})` : "";
+}
+function resolveRelayWsUrl(gatewayUrl) {
+  const url = new URL(gatewayUrl);
+  if (url.pathname === "" || url.pathname === "/") {
+    url.pathname = "/ws/relay";
+  } else if (!url.pathname.endsWith("/ws/relay")) {
+    url.pathname = `${url.pathname.replace(/\/+$/, "")}/ws/relay`;
+  }
+  if (url.protocol === "http:") {
+    url.protocol = "ws:";
+  } else if (url.protocol === "https:") {
+    url.protocol = "wss:";
+  } else if (url.protocol !== "ws:" && url.protocol !== "wss:") {
+    throw new Error(`Unsupported gateway URL protocol: ${url.protocol}`);
+  }
+  return url.toString();
+}
+async function wsDataToText(data) {
+  if (typeof data === "string") {
+    return data;
+  }
+  if (Buffer.isBuffer(data)) {
+    return data.toString("utf8");
+  }
+  if (Array.isArray(data) && data.every((item) => Buffer.isBuffer(item))) {
+    return Buffer.concat(data).toString("utf8");
+  }
+  if (data instanceof ArrayBuffer) {
+    return new TextDecoder().decode(data);
+  }
+  if (ArrayBuffer.isView(data)) {
+    return new TextDecoder().decode(data);
+  }
+  if (typeof Blob !== "undefined" && data instanceof Blob) {
+    return await data.text();
+  }
+  return String(data ?? "");
+}
+function parseInboundFrame(rawText) {
+  try {
+    const parsed = JSON.parse(rawText);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
+    }
+    if (typeof parsed.type !== "string" || !parsed.type.trim()) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function waitForSocketOpen(params) {
+  const { ws, timeoutMs, accountId } = params;
+  await new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      cleanup();
+      reject(new Error(`[${accountId}] websocket open timeout (${timeoutMs}ms)`));
+    }, timeoutMs);
+    const cleanup = () => {
+      clearTimeout(timeout);
+      ws.off("open", onOpen);
+      ws.off("close", onClose);
+      ws.off("error", onError);
+    };
+    const onOpen = () => {
+      cleanup();
+      resolve();
+    };
+    const onClose = (code, reason) => {
+      cleanup();
+      reject(new Error(`[${accountId}] websocket closed before open${describeSocketClose({ code, reason })}`));
+    };
+    const onError = () => {
+      cleanup();
+      reject(new Error(`[${accountId}] websocket failed before open`));
+    };
+    ws.on("open", onOpen);
+    ws.on("close", onClose);
+    ws.on("error", onError);
+  });
+}
+function closeSocketQuietly(ws) {
+  try {
+    ws.close();
+  } catch {
+  }
+}
+function normalizeRelaySocketToken(token) {
+  const trimmed = token?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function getOrCreateRelaySocketState(accountId) {
+  const existing = siderRelaySockets.get(accountId);
+  if (existing) {
+    return existing;
+  }
+  const next = {
+    ws: null,
+    accountSignature: void 0,
+    relayId: void 0,
+    pendingAcksBySession: /* @__PURE__ */ new Map(),
+    pendingAcksByClientReqId: /* @__PURE__ */ new Map(),
+    readyWaiters: /* @__PURE__ */ new Set()
+  };
+  siderRelaySockets.set(accountId, next);
+  return next;
+}
+function buildRelaySocketAccountSignature(account) {
+  return `${account.gatewayUrl}|${account.relayId}|${normalizeRelaySocketToken(account.token) ?? ""}`;
+}
+function buildRelayMonitorAccountSignature(account) {
+  return [
+    buildRelaySocketAccountSignature(account),
+    String(account.connectTimeoutMs),
+    String(account.reconnectDelayMs)
+  ].join("|");
+}
+function waitForAbortSignal(signal) {
+  if (signal.aborted) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => {
+    const onAbort = () => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function clearRelaySocketState(params) {
+  const state = siderRelaySockets.get(params.accountId);
+  if (!state) {
+    return;
+  }
+  if (params.expectedWs && state.ws && state.ws !== params.expectedWs) {
+    return;
+  }
+  if (params.closeSocket && state.ws && state.ws.readyState !== WebSocket.CLOSED) {
+    closeSocketQuietly(state.ws);
+  }
+  state.ws = null;
+  state.relayId = void 0;
+  state.accountSignature = void 0;
+  const ackError = new Error(
+    params.reason ? `[${params.accountId}] ${params.reason}` : `[${params.accountId}] relay socket closed`
+  );
+  const rejected = /* @__PURE__ */ new Set();
+  for (const pendingAcks of state.pendingAcksBySession.values()) {
+    for (const pendingAck of pendingAcks) {
+      if (rejected.has(pendingAck)) {
+        continue;
+      }
+      rejected.add(pendingAck);
+      clearTimeout(pendingAck.timeout);
+      pendingAck.reject(ackError);
+    }
+  }
+  state.pendingAcksBySession.clear();
+  state.pendingAcksByClientReqId.clear();
+}
+function setRelaySocketConnected(params) {
+  const state = getOrCreateRelaySocketState(params.account.accountId);
+  state.ws = params.ws;
+  state.relayId = params.relayId;
+  state.accountSignature = buildRelaySocketAccountSignature(params.account);
+  for (const waiter of state.readyWaiters) {
+    clearTimeout(waiter.timeout);
+    waiter.resolve(params.ws);
+  }
+  state.readyWaiters.clear();
+}
+async function waitForRelaySocketReady(params) {
+  const state = getOrCreateRelaySocketState(params.account.accountId);
+  const expectedSignature = buildRelaySocketAccountSignature(params.account);
+  const liveSocket = state.ws;
+  if (liveSocket && liveSocket.readyState === WebSocket.OPEN && state.accountSignature === expectedSignature) {
+    return { ws: liveSocket, state };
+  }
+  if (liveSocket && state.accountSignature !== expectedSignature) {
+    closeSocketQuietly(liveSocket);
+    clearRelaySocketState({
+      accountId: params.account.accountId,
+      expectedWs: liveSocket,
+      closeSocket: false,
+      reason: "relay socket account settings changed"
+    });
+  }
+  const ws = await new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      state.readyWaiters.delete(waiter);
+      reject(new Error(`[${params.account.accountId}] timeout waiting managed relay socket`));
+    }, params.timeoutMs);
+    const waiter = {
+      timeout,
+      resolve,
+      reject
+    };
+    state.readyWaiters.add(waiter);
+  });
+  if (state.accountSignature !== expectedSignature) {
+    throw new Error(`[${params.account.accountId}] managed relay socket account signature mismatch`);
+  }
+  return { ws, state };
+}
+function waitForManagedAck(params) {
+  return new Promise((resolve, reject) => {
+    const pendingAck = {
+      sessionId: params.sessionId,
+      clientReqId: params.clientReqId,
+      timeout: setTimeout(() => {
+        const queue2 = params.state.pendingAcksBySession.get(params.sessionId);
+        if (!queue2) {
+          if (params.clientReqId) {
+            params.state.pendingAcksByClientReqId.delete(params.clientReqId);
+          }
+          reject(new Error(`[${params.accountId}] timeout waiting sider ack`));
+          return;
+        }
+        const idx = queue2.indexOf(pendingAck);
+        if (idx >= 0) {
+          queue2.splice(idx, 1);
+          if (queue2.length === 0) {
+            params.state.pendingAcksBySession.delete(params.sessionId);
+          }
+        }
+        if (params.clientReqId) {
+          params.state.pendingAcksByClientReqId.delete(params.clientReqId);
+        }
+        reject(new Error(`[${params.accountId}] timeout waiting sider ack`));
+      }, params.timeoutMs),
+      resolve,
+      reject
+    };
+    const queue = params.state.pendingAcksBySession.get(params.sessionId) ?? [];
+    queue.push(pendingAck);
+    params.state.pendingAcksBySession.set(params.sessionId, queue);
+    if (params.clientReqId) {
+      params.state.pendingAcksByClientReqId.set(params.clientReqId, pendingAck);
+    }
+  });
+}
+function readAckToken(value) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed || void 0;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
+  }
+  return void 0;
+}
+function resolveAckSessionId(frame) {
+  const record = frame;
+  return readAckToken(record.session_id) ?? readAckToken(record.sessionId) ?? readAckToken(record.conversation_id) ?? readAckToken(record.conversationId);
+}
+function resolveAckClientReqId(frame) {
+  const record = frame;
+  return readAckToken(record.client_req_id) ?? readAckToken(record.clientReqId) ?? readAckToken(record.request_id) ?? readAckToken(record.requestId);
+}
+function resolveAckId(frame) {
+  const record = frame;
+  return readAckToken(record.id) ?? readAckToken(record.message_id) ?? readAckToken(record.messageId) ?? readAckToken(record.event_id) ?? readAckToken(record.eventId) ?? readAckToken(record.ack_id) ?? readAckToken(record.ackId);
+}
+function countPendingAcks(state) {
+  let count = 0;
+  for (const queue of state.pendingAcksBySession.values()) {
+    count += queue.length;
+  }
+  return count;
+}
+function detachPendingAck(state, pendingAck) {
+  const queue = state.pendingAcksBySession.get(pendingAck.sessionId);
+  if (queue) {
+    const index = queue.indexOf(pendingAck);
+    if (index >= 0) {
+      queue.splice(index, 1);
+      if (queue.length === 0) {
+        state.pendingAcksBySession.delete(pendingAck.sessionId);
+      }
+    }
+  }
+  if (pendingAck.clientReqId) {
+    const existing = state.pendingAcksByClientReqId.get(pendingAck.clientReqId);
+    if (existing === pendingAck) {
+      state.pendingAcksByClientReqId.delete(pendingAck.clientReqId);
+    }
+  }
+}
+function settlePendingAck(params) {
+  detachPendingAck(params.state, params.pendingAck);
+  clearTimeout(params.pendingAck.timeout);
+  const resolvedId = params.ackId ?? params.ackClientReqId ?? params.pendingAck.clientReqId;
+  if (!resolvedId) {
+    params.pendingAck.reject(
+      new Error(
+        `[${params.accountId}] ack missing id for session ${params.pendingAck.sessionId}`
+      )
+    );
+    return true;
+  }
+  params.pendingAck.resolve(resolvedId);
+  return true;
+}
+function resolveManagedAck(params) {
+  const state = siderRelaySockets.get(params.accountId);
+  if (!state || countPendingAcks(state) === 0) {
+    return false;
+  }
+  const ackSession = resolveAckSessionId(params.frame);
+  const ackId = resolveAckId(params.frame);
+  const ackClientReqId = resolveAckClientReqId(params.frame);
+  if (ackClientReqId) {
+    const pendingByReq = state.pendingAcksByClientReqId.get(ackClientReqId);
+    if (pendingByReq) {
+      return settlePendingAck({
+        accountId: params.accountId,
+        state,
+        pendingAck: pendingByReq,
+        ackId,
+        ackClientReqId
+      });
+    }
+  }
+  if (ackSession) {
+    const queue = state.pendingAcksBySession.get(ackSession);
+    if (queue && queue.length > 0) {
+      const pendingAck = queue[0];
+      return settlePendingAck({
+        accountId: params.accountId,
+        state,
+        pendingAck,
+        ackId,
+        ackClientReqId
+      });
+    }
+  }
+  if (countPendingAcks(state) === 1) {
+    for (const queue of state.pendingAcksBySession.values()) {
+      const pendingAck = queue[0];
+      if (pendingAck) {
+        return settlePendingAck({
+          accountId: params.accountId,
+          state,
+          pendingAck,
+          ackId,
+          ackClientReqId
+        });
+      }
+    }
+  }
+  return false;
+}
+function resolveFrameClientReqId(frame) {
+  return readAckToken(frame.client_req_id) ?? readAckToken(frame.clientReqId);
+}
+function isAckTimeoutError(error) {
+  const text = String(error ?? "");
+  return text.includes("timeout waiting sider ack");
+}
+async function sendRelayFrameWithAck(params) {
+  const { ws, state } = await waitForRelaySocketReady({
+    account: params.account,
+    timeoutMs: params.account.connectTimeoutMs
+  });
+  const ackPromise = waitForManagedAck({
+    state,
+    accountId: params.account.accountId,
+    sessionId: params.sessionId,
+    timeoutMs: params.timeoutMs,
+    clientReqId: resolveFrameClientReqId(params.frame)
+  });
+  try {
+    ws.send(JSON.stringify(params.frame));
+  } catch (err) {
+    clearRelaySocketState({
+      accountId: params.account.accountId,
+      expectedWs: ws,
+      closeSocket: true,
+      reason: `relay send failed: ${String(err)}`
+    });
+    throw err;
+  }
+  return await ackPromise;
+}
+async function connectRelaySocket(params) {
+  const wsUrl = resolveRelayWsUrl(params.account.gatewayUrl);
+  const authorizedWsUrl = appendTokenQuery(wsUrl, params.account.token);
+  logDebug("opening sider relay websocket", {
+    accountId: params.account.accountId,
+    wsUrl,
+    relayId: params.relayId,
+    hasTokenQuery: Boolean(params.account.token?.trim())
+  });
+  const ws = createSiderWebSocket(authorizedWsUrl);
+  await waitForSocketOpen({
+    ws,
+    timeoutMs: params.account.connectTimeoutMs,
+    accountId: params.account.accountId
+  });
+  const registerPayload = {
+    type: "register",
+    relay_id: params.relayId
+  };
+  if (params.account.token) {
+    registerPayload.token = params.account.token;
+  }
+  ws.send(JSON.stringify(registerPayload));
+  return ws;
+}
+async function sendMessageToSider(params) {
+  if (params.parts.length === 0) {
+    throw new Error("Cannot send sider message with empty parts");
+  }
+  logDebug("-> sendMessageToSider.parts:", params.parts);
+  const clientReqId = crypto.randomUUID();
+  let messageId = clientReqId;
+  let acked = false;
+  const frame = {
+    type: "message",
+    session_id: params.sessionId,
+    client_req_id: clientReqId,
+    ...params.aggregation ? { aggregation: params.aggregation } : {},
+    parts: params.parts,
+    meta: params.meta ?? {}
+  };
+  try {
+    messageId = await sendRelayFrameWithAck({
+      account: params.account,
+      sessionId: params.sessionId,
+      timeoutMs: params.account.sendTimeoutMs,
+      frame
+    });
+    acked = true;
+  } catch (err) {
+    if (!isAckTimeoutError(err)) {
+      throw err;
+    }
+    logWarn("sider outbound ack timeout; treating message as sent", {
+      accountId: params.account.accountId,
+      sessionId: params.sessionId,
+      clientReqId,
+      timeoutMs: params.account.sendTimeoutMs
+    });
+  }
+  logDebug("sider outbound message dispatched", {
+    accountId: params.account.accountId,
+    sessionId: params.sessionId,
+    clientReqId,
+    messageId,
+    acked,
+    aggregationId: params.aggregation?.id,
+    aggregationIndex: params.aggregation?.index,
+    aggregationFinal: params.aggregation?.final
+  });
+  return { messageId, conversationId: params.sessionId };
+}
+async function sendSiderEventBestEffort(params) {
+  try {
+    const { ws } = await waitForRelaySocketReady({
+      account: params.account,
+      timeoutMs: params.account.connectTimeoutMs
+    });
+    try {
+      ws.send(
+        JSON.stringify({
+          type: "event",
+          session_id: params.sessionId,
+          client_req_id: crypto.randomUUID(),
+          event_type: params.event.eventType,
+          payload: params.event.payload,
+          meta: params.event.meta ?? {}
+        })
+      );
+    } catch (err) {
+      clearRelaySocketState({
+        accountId: params.account.accountId,
+        expectedWs: ws,
+        closeSocket: true,
+        reason: `relay send failed: ${String(err)}`
+      });
+      throw err;
+    }
+  } catch (err) {
+    logWarn("sider outbound event failed", {
+      accountId: params.account.accountId,
+      sessionId: params.sessionId,
+      eventType: params.event.eventType,
+      context: params.context,
+      error: String(err)
+    });
+  }
+}
+async function sendSiderMessageBestEffort(params) {
+  try {
+    await sendMessageToSider({
+      account: params.account,
+      sessionId: params.sessionId,
+      parts: params.parts,
+      aggregation: params.aggregation,
+      meta: params.meta
+    });
+  } catch (err) {
+    logWarn("sider outbound message failed", {
+      accountId: params.account.accountId,
+      sessionId: params.sessionId,
+      partTypes: params.parts.map((part) => part.type),
+      aggregationId: params.aggregation?.id,
+      aggregationIndex: params.aggregation?.index,
+      aggregationFinal: params.aggregation?.final,
+      context: params.context,
+      error: String(err)
+    });
+  }
+}
+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
+};

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

@@ -0,0 +1,33 @@
+import { PluginRuntime } from 'openclaw/plugin-sdk';
+import { WebSocket } from 'ws';
+import { SiderMonitorLogger, SiderRelayMonitorRegistration, SiderRelaySocketState, SiderRunState, SiderSessionBinding } from './channel-types.js';
+import '../account-cW9SLuNu.js';
+import 'openclaw/plugin-sdk/setup';
+import './auth.js';
+import 'openclaw/plugin-sdk/plugin-entry';
+import 'openclaw/plugin-sdk/config-runtime';
+
+declare let runtimeRef: PluginRuntime | null;
+declare const siderSessionBindings: Map<string, SiderSessionBinding>;
+declare const siderRunStates: Map<string, SiderRunState>;
+declare const siderRelaySockets: Map<string, SiderRelaySocketState>;
+declare const siderRelayMonitors: Map<string, SiderRelayMonitorRegistration>;
+declare function createSiderWebSocket(url: string): WebSocket;
+declare function setSiderRuntime(runtime: PluginRuntime): void;
+declare function getSiderRuntime(): PluginRuntime;
+type LogArg = unknown;
+declare function logDebug(...args: LogArg[]): void;
+declare function logInfo(...args: LogArg[]): void;
+declare function logWarn(...args: LogArg[]): void;
+declare function logError(...args: LogArg[]): void;
+declare function createMonitorLogger(log?: SiderMonitorLogger): {
+    info: (...args: LogArg[]) => void;
+    warn: (...args: LogArg[]) => void;
+};
+declare function sleep(ms: number): Promise<void>;
+declare const siderOutboundLogger: {
+    debug: typeof logDebug;
+    warn: typeof logWarn;
+};
+
+export { createMonitorLogger, createSiderWebSocket, getSiderRuntime, logDebug, logError, logInfo, logWarn, runtimeRef, setSiderRuntime, siderOutboundLogger, siderRelayMonitors, siderRelaySockets, siderRunStates, siderSessionBindings, sleep };