@zyclaw/webot 0.1.0

package/src/message-handler.ts

@@ -0,0 +1,446 @@
+// ── WeBot message handler — bridge between WeBot relay and local Gateway ──
+//
+// Message protocol between bots:
+//   [webot:task] <content>       — task for the receiving bot to process (expects response)
+//   [webot:response] <content>   — response to a previous task (no reply needed, notify owner)
+//   (no tag)                     — treated as [webot:task] for backward compat
+
+import crypto from "node:crypto";
+import type { PluginLogger } from "openclaw/plugin-sdk";
+import {
+  GATEWAY_RECONNECT_DELAY_MS,
+  GATEWAY_RPC_TIMEOUT_MS,
+  LOCAL_GATEWAY_WS,
+} from "./constants.js";
+import type { FriendRequestFrame, IncomingMessageFrame } from "./protocol.js";
+import type { RelayClient } from "./relay-client.js";
+
+type GatewayPendingCallback = (response: unknown) => void;
+
+// ── Protocol tag helpers ──
+
+const TAG_TASK = "[webot:task]";
+const TAG_RESPONSE = "[webot:response]";
+
+type MessageType = "task" | "response";
+
+function parseMessageType(content: string): { type: MessageType; body: string } {
+  if (content.startsWith(TAG_RESPONSE)) {
+    return { type: "response", body: content.slice(TAG_RESPONSE.length).trim() };
+  }
+  if (content.startsWith(TAG_TASK)) {
+    return { type: "task", body: content.slice(TAG_TASK.length).trim() };
+  }
+  // Untagged → treat as task (backward compat)
+  return { type: "task", body: content };
+}
+
+export type MessageHandler = ReturnType<typeof createMessageHandler>;
+
+export function createMessageHandler(
+  relay: RelayClient,
+  logger: PluginLogger,
+  gatewayToken?: string,
+) {
+  let gwWs: WebSocket | null = null;
+  let gwReqCounter = 0;
+  const gwPending = new Map<string, GatewayPendingCallback>();
+  // Completion callbacks for agent RPCs — called when the second res frame
+  // arrives with the actual agent result (the first is just "accepted").
+  const gwCompletionCallbacks = new Map<string, (frame: unknown) => void>();
+  let gwConnecting = false;
+  let gwStopping = false;
+
+  // Dedup incoming messages (messageId → timestamp) to avoid double-delivery
+  // from real-time + offline.messages overlap
+  const seenMessages = new Map<string, number>();
+  const SEEN_MSG_TTL_MS = 5 * 60_000; // 5 minutes
+
+  // Content-based dedup: server may send the same message with different
+  // messageIds (real-time + offline.messages). Key: `deviceId:contentPrefix`
+  const recentContent = new Map<string, number>();
+  const CONTENT_DEDUP_TTL_MS = 10_000; // 10 seconds
+
+  // ── Gateway self-connection ──
+
+  const connectToGateway = () => {
+    if (gwStopping || gwConnecting) return;
+    gwConnecting = true;
+
+    try {
+      gwWs = new WebSocket(LOCAL_GATEWAY_WS);
+    } catch (err) {
+      logger.error(`WeBot: Gateway connect failed: ${String(err)}`);
+      gwConnecting = false;
+      scheduleGatewayReconnect();
+      return;
+    }
+
+    gwWs.onopen = () => {
+      gwConnecting = false;
+      logger.info("WeBot: gateway WS opened, waiting for connect.challenge…");
+    };
+
+    gwWs.onmessage = (ev) => {
+      try {
+        const frame = JSON.parse(String(ev.data));
+
+        // Handle connect.challenge — gateway sends this immediately after WS open
+        if (frame.type === "event" && frame.event === "connect.challenge") {
+          const nonce =
+            frame.payload && typeof frame.payload.nonce === "string"
+              ? frame.payload.nonce
+              : undefined;
+          const connectFrame = {
+            type: "req",
+            id: `gw-${++gwReqCounter}`,
+            method: "connect",
+            params: {
+              minProtocol: 3,
+              maxProtocol: 3,
+              client: {
+                id: "gateway-client",
+                displayName: "WeBot Plugin",
+                version: "0.1.0",
+                platform: "plugin",
+                mode: "backend",
+              },
+              auth: gatewayToken ? { token: gatewayToken } : undefined,
+              role: "operator",
+              scopes: ["operator.admin"],
+            },
+          };
+          gwWs!.send(JSON.stringify(connectFrame));
+          logger.info("WeBot: connect.challenge received, handshake sent");
+          return;
+        }
+
+        // Handle response frames (RPC results + hello-ok)
+        if (frame.type === "res" && frame.id) {
+          const cb = gwPending.get(frame.id as string);
+          if (cb) {
+            gwPending.delete(frame.id as string);
+            cb(frame);
+          } else {
+            // Second res frame (agent completion) — invoke completion callback
+            const completionCb = gwCompletionCallbacks.get(frame.id as string);
+            if (completionCb) {
+              gwCompletionCallbacks.delete(frame.id as string);
+              try {
+                completionCb(frame);
+              } catch (err) {
+                logger.error(`WeBot: completion callback error: ${String(err)}`);
+              }
+            }
+          }
+        }
+      } catch {
+        // ignore malformed frames
+      }
+    };
+
+    gwWs.onclose = () => {
+      gwConnecting = false;
+      if (!gwStopping) {
+        scheduleGatewayReconnect();
+      }
+    };
+
+    gwWs.onerror = (err) => {
+      logger.error(`WeBot: Gateway WS error: ${String(err)}`);
+      gwWs?.close();
+    };
+  };
+
+  const scheduleGatewayReconnect = () => {
+    if (gwStopping) return;
+    setTimeout(connectToGateway, GATEWAY_RECONNECT_DELAY_MS);
+  };
+
+  const callGatewayRpc = (
+    method: string,
+    params: Record<string, unknown>,
+    onCompletion?: (frame: unknown) => void,
+  ): Promise<unknown> => {
+    return new Promise((resolve, reject) => {
+      if (!gwWs || gwWs.readyState !== WebSocket.OPEN) {
+        reject(new Error("Gateway not connected"));
+        return;
+      }
+
+      const id = `gw-${++gwReqCounter}`;
+      const timer = setTimeout(() => {
+        gwPending.delete(id);
+        gwCompletionCallbacks.delete(id);
+        reject(new Error("Gateway request timeout"));
+      }, GATEWAY_RPC_TIMEOUT_MS);
+
+      gwPending.set(id, (response) => {
+        clearTimeout(timer);
+        resolve(response);
+      });
+
+      if (onCompletion) {
+        gwCompletionCallbacks.set(id, onCompletion);
+      }
+
+      gwWs.send(JSON.stringify({ type: "req", id, method, params }));
+    });
+  };
+
+  // ── Start Gateway connection (call after gateway is listening) ──
+  const startGatewayConnection = () => {
+    connectToGateway();
+  };
+
+  // ── Listen for incoming WeBot messages ──
+  relay.onMessage(async (msg: IncomingMessageFrame) => {
+    // Deduplicate by messageId
+    if (seenMessages.has(msg.messageId)) {
+      logger.info(`WeBot: dedup — skipping already-seen messageId ${msg.messageId}`);
+      return;
+    }
+    seenMessages.set(msg.messageId, Date.now());
+
+    // Content-based dedup: the server may send the same message under
+    // different messageIds (real-time delivery + offline.messages overlap).
+    const contentKey = `${msg.fromDeviceId}:${msg.content.slice(0, 200)}`;
+    if (recentContent.has(contentKey)) {
+      logger.info(`WeBot: dedup — skipping duplicate content from ${msg.fromDeviceId.slice(0, 8)}`);
+      return;
+    }
+    recentContent.set(contentKey, Date.now());
+
+    // Prune old entries from both dedup maps
+    const now = Date.now();
+    for (const [id, ts] of seenMessages) {
+      if (ts < now - SEEN_MSG_TTL_MS) seenMessages.delete(id);
+    }
+    for (const [key, ts] of recentContent) {
+      if (ts < now - CONTENT_DEDUP_TTL_MS) recentContent.delete(key);
+    }
+
+    const preview =
+      msg.content.length > 80
+        ? `${msg.content.slice(0, 80)}...`
+        : msg.content;
+    logger.info(
+      `WeBot: message from ${msg.fromUsername} (${msg.fromBotName}): ${preview}`,
+    );
+
+    // Acknowledge delivery (best-effort)
+    relay.ackMessage(msg.messageId, "delivered").catch(() => {});
+
+    const { type: msgType, body } = parseMessageType(msg.content);
+    const fromDeviceId = msg.fromDeviceId;
+    const sessionKey = `agent:main:webot:dm:${fromDeviceId}`;
+    const sessionLabel = `WeBot: ${msg.fromUsername}`;
+
+    try {
+      switch (msgType) {
+        // ── RESPONSE: result of a task we previously sent ──
+        // Do NOT reply back (break the loop). Notify owner via agent + message tool.
+        case "response": {
+          logger.info(`WeBot: received task response from ${msg.fromUsername}`);
+          // Use a brief trigger as the visible "user" message in session history;
+          // put the full content in extraSystemPrompt so the agent can process it
+          // without the full bot message appearing as a user message in Web UI.
+          const responsePreview = body.length > 60 ? `${body.slice(0, 60)}…` : body;
+          await callGatewayRpc("agent", {
+            message: `[WeBot response from @${msg.fromUsername}]: ${responsePreview}`,
+            sessionKey,
+            label: sessionLabel,
+            idempotencyKey: crypto.randomUUID(),
+            extraSystemPrompt: [
+              `This is a RESPONSE from @${msg.fromUsername}'s bot to a task you previously sent.`,
+              `Full message content:\n---\n${body}\n---`,
+              `DO NOT reply back to this bot via WeBot — the conversation is complete.`,
+              `Review the result and notify your owner using the "message" tool about the outcome.`,
+              `Summarize what was requested and what the result is.`,
+            ].join("\n"),
+          });
+          // No completion callback → no reply sent back → loop broken
+          break;
+        }
+
+        // ── TASK (or untagged): task request for this bot to process ──
+        // Process via agent and send tagged response back.
+        case "task":
+        default: {
+          logger.info(`WeBot: task request from ${msg.fromUsername}`);
+          // Use a brief trigger as the visible "user" message in session history;
+          // put the full content in extraSystemPrompt so the agent can process it
+          // without the full bot message appearing as a user message in Web UI.
+          const taskPreview = body.length > 60 ? `${body.slice(0, 60)}…` : body;
+          await callGatewayRpc(
+            "agent",
+            {
+              message: `[WeBot message from @${msg.fromUsername}]: ${taskPreview}`,
+              sessionKey,
+              label: sessionLabel,
+              idempotencyKey: crypto.randomUUID(),
+              extraSystemPrompt: [
+                `You are receiving a task message via WeBot from @${msg.fromUsername} (bot: "${msg.fromBotName}").`,
+                `Full message content:\n---\n${body}\n---`,
+                `Your reply will be automatically sent back to the sender's bot.`,
+                ``,
+                `CRITICAL — determine who the message is for:`,
+                `1. FOR YOUR OWNER (human): Messages that mention "my owner", "your owner", or are clearly social/personal`,
+                `   (e.g. dinner invitations, availability questions, plans, favors, personal greetings).`,
+                `   → You MUST use the "message" tool to forward this to your owner.`,
+                `   → Reply to the sender: "I've forwarded this to my owner, will get back to you."`,
+                `2. FOR YOU (the bot): Technical requests, information queries, tasks you can handle directly`,
+                `   (e.g. "search for X", "summarize Y", "what's the weather").`,
+                `   → Handle it directly and reply with the result.`,
+                `3. MIXED: Some messages need both — handle what you can and forward the rest to your owner.`,
+                ``,
+                `When in doubt about social/personal messages, ALWAYS forward to your owner.`,
+                `Keep responses concise and actionable.`,
+              ].join("\n"),
+            },
+            // Tag the reply as [webot:response] so receiving bot won't reply again
+            (frame: unknown) => {
+              forwardTaggedResponse(frame, fromDeviceId);
+            },
+          );
+          break;
+        }
+      }
+    } catch (err) {
+      logger.error(`WeBot: failed to forward to Gateway: ${String(err)}`);
+      // Send error feedback to the sender (tagged as response to avoid loop)
+      relay
+        .sendMessage(`${TAG_RESPONSE} [Error: ${String(err)}]`, { toDeviceId: fromDeviceId })
+        .catch(() => { /* best-effort feedback */ });
+    }
+  });
+
+  /**
+   * Extract agent reply text from the completion frame and send it back
+   * to the WeBot sender, prefixed with [webot:response] to prevent loops.
+   */
+  const forwardTaggedResponse = (frame: unknown, toDeviceId: string) => {
+    try {
+      const f = frame as {
+        payload?: {
+          status?: string;
+          error?: string;
+          result?: { payloads?: Array<{ text?: string }> };
+        };
+      };
+      if (f?.payload?.status === "ok" && f.payload.result?.payloads) {
+        const texts = f.payload.result.payloads
+          .map((p) => p.text)
+          .filter(Boolean);
+        const replyText = texts.join("\n").trim();
+        if (replyText) {
+          relay
+            .sendMessage(`${TAG_RESPONSE} ${replyText}`, { toDeviceId })
+            .then(() => {
+              logger.info(`WeBot: tagged response sent to ${toDeviceId.slice(0, 8)}...`);
+            })
+            .catch((err) => {
+              logger.error(`WeBot: failed to send response: ${String(err)}`);
+            });
+        } else {
+          logger.warn(`WeBot: agent returned empty reply for ${toDeviceId.slice(0, 8)}`);
+        }
+      } else if (f?.payload?.status === "error") {
+        const errorMsg = f.payload.error || "unknown error";
+        logger.warn(`WeBot: agent error for ${toDeviceId.slice(0, 8)}: ${errorMsg}`);
+        relay
+          .sendMessage(`${TAG_RESPONSE} [Task failed: ${errorMsg}]`, { toDeviceId })
+          .catch((err) => {
+            logger.error(`WeBot: failed to send error response: ${String(err)}`);
+          });
+      }
+    } catch (err) {
+      logger.error(`WeBot: reply forwarding error: ${String(err)}`);
+    }
+  };
+
+  // ── Listen for incoming friend requests ──
+  relay.onFriendRequest(async (frame: FriendRequestFrame) => {
+    logger.info(
+      `WeBot: friend request from ${frame.fromUsername} (${frame.fromDisplayName})`,
+    );
+
+    try {
+      await callGatewayRpc("agent", {
+        message: [
+          `[WeBot: New friend request]`,
+          "",
+          `You received a friend request from ${frame.fromDisplayName} (@${frame.fromUsername}).`,
+          `Friendship ID: ${frame.friendshipId}`,
+          "",
+          `Use the webot_friend_accept or webot_friend_reject tool to respond, or tell your owner.`,
+        ].join("\n"),
+        sessionKey: "agent:main:webot:system",
+        label: "WeBot: System",
+        idempotencyKey: crypto.randomUUID(),
+      });
+      logger.info("WeBot: agent notified of friend request");
+    } catch (err) {
+      logger.error(
+        `WeBot: failed to notify agent of friend request: ${String(err)}`,
+      );
+    }
+  });
+
+  return {
+    /** Start the gateway self-connection (call after gateway is ready) */
+    startGatewayConnection,
+
+    /**
+     * Send a notification message to the local agent via Gateway RPC.
+     * Best-effort — if the gateway is not connected, retries once after a delay.
+     */
+    notifyAgent: async (
+      message: string,
+      _metadata?: Record<string, unknown>,
+    ) => {
+      const attempt = async () => {
+        await callGatewayRpc("agent", {
+          message,
+          sessionKey: "agent:main:webot:system",
+          label: "WeBot: System",
+          idempotencyKey: crypto.randomUUID(),
+        });
+      };
+      try {
+        await attempt();
+      } catch {
+        // Gateway may not be ready yet — retry once after a short delay
+        await new Promise((r) => setTimeout(r, 3_000));
+        try {
+          await attempt();
+        } catch (err) {
+          logger.warn(
+            `WeBot: failed to notify agent: ${String(err)}`,
+          );
+        }
+      }
+    },
+
+    /**
+     * Hook handler for `message_sending` — kept for potential future use.
+     * Reply routing is handled via the agent RPC completion callback.
+     */
+    onMessageSending: async (
+      _event: { to?: string; content?: string; metadata?: Record<string, unknown> },
+      _ctx: unknown,
+    ) => {
+      // No-op: reply forwarding is handled by the completion callback
+      // in callGatewayRpc. The message_sending hook is currently not
+      // invoked by the gateway, so this is a no-op placeholder.
+    },
+
+    /** Stop the Gateway connection */
+    stop: () => {
+      gwStopping = true;
+      gwWs?.close();
+      gwPending.clear();
+      gwCompletionCallbacks.clear();
+    },
+  };
+}