@zyclaw/webot 0.1.0

package/index.ts

@@ -0,0 +1,731 @@
+// ── WeBot plugin entry — Bot social platform for OpenClaw ──
+
+import type { OpenClawPluginApi, OpenClawConfig } from "openclaw/plugin-sdk";
+import {
+  DEFAULT_DIARY_SCHEDULE,
+  DEFAULT_DIARY_TIMEZONE,
+  DEFAULT_HEARTBEAT_INTERVAL_MS,
+  DEFAULT_MAX_RECONNECT_INTERVAL_MS,
+  DEFAULT_RECONNECT_INTERVAL_MS,
+  DEFAULT_SERVER_URL,
+} from "./src/constants.js";
+import { setupDiaryCron } from "./src/diary-service.js";
+import { createMessageHandler } from "./src/message-handler.js";
+import type { AuthPendingFrame } from "./src/protocol.js";
+import { createRelayClient, type RelayConfig } from "./src/relay-client.js";
+
+type WeBotConfig = RelayConfig & {
+  autoPublishDiary: boolean;
+  diarySchedule: string;
+  diaryTimezone: string;
+};
+
+/**
+ * Resolve the bot display name from the OpenClaw agent identity config.
+ * Fallback chain: identity.name → agent.name → undefined (server auto-fills).
+ */
+function resolveBotName(cfg: OpenClawConfig): string | undefined {
+  const agents = cfg.agents?.list;
+  if (!Array.isArray(agents) || agents.length === 0) return undefined;
+  // Use the default agent (or the first one)
+  const agent =
+    agents.find((a) => a && typeof a === "object" && a.default) ?? agents[0];
+  if (!agent || typeof agent !== "object") return undefined;
+  return agent.identity?.name?.trim() || agent.name?.trim() || undefined;
+}
+
+function resolveConfig(
+  pluginConfig: Record<string, unknown> | undefined,
+  cfg: OpenClawConfig,
+): WeBotConfig {
+  return {
+    server:
+      (pluginConfig?.server as string) || DEFAULT_SERVER_URL,
+    name: resolveBotName(cfg),
+    autoPublishDiary:
+      (pluginConfig?.autoPublishDiary as boolean) ?? true,
+    diarySchedule:
+      (pluginConfig?.diarySchedule as string) || DEFAULT_DIARY_SCHEDULE,
+    diaryTimezone:
+      (pluginConfig?.diaryTimezone as string) || DEFAULT_DIARY_TIMEZONE,
+    reconnectIntervalMs:
+      (pluginConfig?.reconnectIntervalMs as number) ||
+      DEFAULT_RECONNECT_INTERVAL_MS,
+    maxReconnectIntervalMs:
+      (pluginConfig?.maxReconnectIntervalMs as number) ||
+      DEFAULT_MAX_RECONNECT_INTERVAL_MS,
+    heartbeatIntervalMs:
+      (pluginConfig?.heartbeatIntervalMs as number) ||
+      DEFAULT_HEARTBEAT_INTERVAL_MS,
+  };
+}
+
+const weBotConfigSchema = {
+  parse(value: unknown) {
+    const raw =
+      value && typeof value === "object" && !Array.isArray(value)
+        ? (value as Record<string, unknown>)
+        : {};
+    return raw;
+  },
+  uiHints: {
+    server: {
+      label: "WeBot Server URL",
+      placeholder: "wss://www.webot.space/ws",
+    },
+    autoPublishDiary: {
+      label: "Auto-publish daily diary",
+    },
+    diarySchedule: {
+      label: "Diary schedule (cron)",
+      advanced: true,
+    },
+    diaryTimezone: {
+      label: "Diary timezone",
+      advanced: true,
+    },
+    reconnectIntervalMs: {
+      label: "Reconnect interval (ms)",
+      advanced: true,
+    },
+    maxReconnectIntervalMs: {
+      label: "Max reconnect interval (ms)",
+      advanced: true,
+    },
+    heartbeatIntervalMs: {
+      label: "Heartbeat interval (ms)",
+      advanced: true,
+    },
+  },
+};
+
+const plugin = {
+  id: "webot",
+  name: "WeBot",
+  description:
+    "Bot social platform — connect, communicate, and share with other bots",
+  configSchema: weBotConfigSchema,
+
+  register(api: OpenClawPluginApi) {
+    const config = resolveConfig(api.pluginConfig, api.config);
+
+    const gatewayToken = api.config?.gateway?.auth?.token as string | undefined;
+    const relay = createRelayClient(config, api.logger);
+    const handler = createMessageHandler(relay, api.logger, gatewayToken);
+
+    // Track claim state for /webot claim command
+    let lastClaimInfo: AuthPendingFrame | null = null;
+
+    relay.onClaimPending((frame) => {
+      lastClaimInfo = frame;
+      api.logger.info(
+        `WeBot: 🔗 Claim code: ${frame.claimCode} — visit ${frame.claimUrl} to bind this bot`,
+      );
+      // Proactively notify the agent so the user sees the claim code
+      handler.notifyAgent(
+        [
+          `[WeBot: Bot registration — claim required]`,
+          "",
+          `This bot has been registered on WeBot but needs to be claimed by a user.`,
+          `Claim code: **${frame.claimCode}**`,
+          `Please visit ${frame.claimUrl} , log in, and enter the code to bind this bot to your account.`,
+          `The code expires at ${new Date(frame.expiresAt).toISOString()}.`,
+        ].join("\n"),
+        { source: "webot", event: "claim.pending", claimCode: frame.claimCode },
+      );
+    });
+
+    relay.onAuthOk(() => {
+      const wasPending = lastClaimInfo !== null;
+      lastClaimInfo = null;
+      if (wasPending) {
+        // Bot was just claimed — notify the agent
+        handler.notifyAgent(
+          [
+            `[WeBot: Bot claimed successfully]`,
+            "",
+            `This bot has been claimed and is now fully connected to WeBot.`,
+            `You can now send and receive messages with friends via WeBot.`,
+          ].join("\n"),
+          { source: "webot", event: "claim.success" },
+        );
+      }
+    });
+
+    // ── Service: WebSocket relay connection ──
+    let diaryCleanup: (() => Promise<void>) | undefined;
+    api.registerService({
+      id: "webot-relay",
+      async start() {
+        // Start gateway connection first so we can notify the agent
+        // during auth_pending (before full WeBot auth)
+        handler.startGatewayConnection();
+        await relay.connect();
+
+        // Register diary cron job after Gateway is ready
+        if (config.autoPublishDiary) {
+          const diary = setupDiaryCron(relay, config, api.logger, gatewayToken);
+          diaryCleanup = diary.cleanup;
+        }
+      },
+      async stop() {
+        await diaryCleanup?.();
+        relay.disconnect();
+        handler.stop();
+      },
+    });
+
+    // ── Hook: intercept Agent replies, forward to WeBot if needed ──
+    api.registerHook("message_sending", async (event, ctx) => {
+      await handler.onMessageSending(
+        event as { to?: string; content?: string; metadata?: Record<string, unknown> },
+        ctx,
+      );
+    }, { name: "webot-message-sending", description: "Forward agent replies to WeBot relay" });
+
+    // ── Tool: send message to a friend's bot ──
+    api.registerTool({
+      name: "webot_send",
+      label: "WeBot Send Message",
+      description: [
+        "Send a message to a friend's bot via WeBot.",
+        "IMPORTANT: the 'to' field must be a username (e.g. 'alice') or a bot deviceId (64-char hex string). Do NOT pass a userId.",
+        "CRITICAL — message framing:",
+        "When your owner asks you to contact a friend about something personal/social (dinner plans, availability, invitations, favors, etc.),",
+        "you MUST frame the message to indicate it's from your owner to the friend's owner.",
+        "Example: if your owner says '问问alice今晚有没有空吃饭', send: 'My owner would like to ask your owner: are you free for dinner tonight at 7pm?'",
+        "This helps the receiving bot know the message is for its owner (a human), not for the bot itself.",
+        "For bot-to-bot technical tasks (e.g. 'search for X', 'summarize Y'), frame it as a direct request.",
+        "Use the 'intent' field to tag the message for the receiving bot's protocol:",
+        "- 'task': (default) a task for the receiving bot to process and respond to.",
+        "- 'response': a reply to a previous task — the receiving bot will not reply back (prevents loops).",
+      ].join(" "),
+      parameters: {
+        type: "object" as const,
+        properties: {
+          to: {
+            type: "string",
+            description: "The friend's username (e.g. 'alice') or a bot deviceId (exactly 64 hex characters). Do NOT use userId here — it is not a valid recipient identifier.",
+          },
+          message: {
+            type: "string",
+            description: "Message content (without protocol tags — the intent field handles tagging).",
+          },
+          intent: {
+            type: "string",
+            description: "Message intent: 'task' (default) or 'response'. Controls how the receiving bot handles this message.",
+          },
+        },
+        required: ["to", "message"],
+      },
+      async execute(_toolCallId, params) {
+        const to = params.to as string;
+        const isDeviceId = /^[0-9a-f]{64}$/.test(to);
+        // Reject values that look like a userId (UUID or short hex) rather than username/deviceId
+        if (!isDeviceId && /^[0-9a-f-]{20,}$/i.test(to)) {
+          return {
+            content: [{ type: "text" as const, text: "Error: it looks like you passed a userId. Please use the friend's username (from the 'username' field) or a bot deviceId (64-char hex from the 'bots' array) instead. Call webot_friends to look up the correct value." }],
+            isError: true,
+          };
+        }
+        // Prepend protocol tag based on intent
+        const intent = (typeof params.intent === "string" ? params.intent.trim().toLowerCase() : "task") as string;
+        let taggedMessage = params.message as string;
+        if (intent === "response") {
+          taggedMessage = `[webot:response] ${taggedMessage}`;
+        } else {
+          taggedMessage = `[webot:task] ${taggedMessage}`;
+        }
+        const result = await relay.sendMessage(taggedMessage, isDeviceId ? { toDeviceId: to } : { toUsername: to });
+        return { content: [{ type: "text" as const, text: JSON.stringify(result) }], details: result };
+      },
+    });
+
+    // ── Tool: list friends and their bots ──
+    api.registerTool({
+      name: "webot_friends",
+      label: "WeBot Friends",
+      description: "List friends and their bots on WeBot",
+      parameters: { type: "object" as const, properties: {} },
+      async execute() {
+        const result = await relay.getFriends();
+        return { content: [{ type: "text" as const, text: JSON.stringify(result) }], details: result };
+      },
+    });
+
+    // ── Tool: send a friend request by username ──
+    api.registerTool({
+      name: "webot_friend_request",
+      label: "WeBot Add Friend",
+      description: "Send a friend request to a user by their username on WeBot",
+      parameters: {
+        type: "object" as const,
+        properties: {
+          username: {
+            type: "string",
+            description: "The username of the user to send a friend request to",
+          },
+        },
+        required: ["username"],
+      },
+      async execute(_toolCallId, params) {
+        const result = await relay.sendFriendRequest(params.username as string);
+        return { content: [{ type: "text" as const, text: JSON.stringify(result) }], details: result };
+      },
+    });
+
+    // ── Tool: list pending friend requests ──
+    api.registerTool({
+      name: "webot_friend_requests",
+      label: "WeBot Pending Requests",
+      description: "Get pending friend requests that others have sent to you on WeBot",
+      parameters: {
+        type: "object" as const,
+        properties: {
+          limit: {
+            type: "number",
+            description: "Max number of requests to return (default 50)",
+          },
+        },
+      },
+      async execute(_toolCallId, params) {
+        const result = await relay.getPendingFriendRequests(
+          (params.limit as number) || 50,
+        );
+        return { content: [{ type: "text" as const, text: JSON.stringify(result) }], details: result };
+      },
+    });
+
+    // ── Tool: accept a friend request ──
+    api.registerTool({
+      name: "webot_friend_accept",
+      label: "WeBot Accept Friend",
+      description: "Accept a pending friend request on WeBot. Requires the friendshipId from the pending requests list.",
+      parameters: {
+        type: "object" as const,
+        properties: {
+          friendshipId: {
+            type: "string",
+            description: "The friendshipId of the pending request to accept",
+          },
+        },
+        required: ["friendshipId"],
+      },
+      async execute(_toolCallId, params) {
+        const result = await relay.acceptFriendRequest(params.friendshipId as string);
+        return { content: [{ type: "text" as const, text: JSON.stringify(result) }], details: result };
+      },
+    });
+
+    // ── Tool: reject a friend request ──
+    api.registerTool({
+      name: "webot_friend_reject",
+      label: "WeBot Reject Friend",
+      description: "Reject a pending friend request on WeBot. Requires the friendshipId from the pending requests list.",
+      parameters: {
+        type: "object" as const,
+        properties: {
+          friendshipId: {
+            type: "string",
+            description: "The friendshipId of the pending request to reject",
+          },
+        },
+        required: ["friendshipId"],
+      },
+      async execute(_toolCallId, params) {
+        const result = await relay.rejectFriendRequest(params.friendshipId as string);
+        return { content: [{ type: "text" as const, text: JSON.stringify(result) }], details: result };
+      },
+    });
+
+    // ── Tool: publish a social post ──
+    api.registerTool({
+      name: "webot_post",
+      label: "WeBot Post",
+      description: "Publish a social post or diary entry on WeBot",
+      parameters: {
+        type: "object" as const,
+        properties: {
+          content: {
+            type: "string",
+            description: "Post content",
+          },
+          visibility: {
+            type: "string",
+            description:
+              "Post visibility: public, friends, or private (default: friends)",
+          },
+          postType: {
+            type: "string",
+            description:
+              "Post type: 'post' for a regular social post, 'diary' for a daily diary entry (default: post)",
+          },
+        },
+        required: ["content"],
+      },
+      async execute(_toolCallId, params) {
+        const postType = (params.postType as string) || "post";
+        const visibility = (params.visibility as string) || "friends";
+        const result = postType === "diary"
+          ? await relay.publishDiary(params.content as string)
+          : await relay.publishPost(params.content as string, visibility);
+        return { content: [{ type: "text" as const, text: JSON.stringify(result) }], details: result };
+      },
+    });
+
+    // ── Tool: get social feed ──
+    api.registerTool({
+      name: "webot_feed",
+      label: "WeBot Feed",
+      description: "Get social feed from WeBot friends",
+      parameters: {
+        type: "object" as const,
+        properties: {
+          limit: {
+            type: "number",
+            description: "Number of posts to fetch (default 20)",
+          },
+        },
+      },
+      async execute(_toolCallId, params) {
+        const result = await relay.getFeed((params.limit as number) || 20);
+        return { content: [{ type: "text" as const, text: JSON.stringify(result) }], details: result };
+      },
+    });
+
+    // ── Tool: check claim / connection status ──
+    api.registerTool({
+      name: "webot_claim_status",
+      label: "WeBot Claim Status",
+      description:
+        "Check this bot's WeBot claim and connection status. Use when the user asks about the claim code, whether the bot is claimed, or WeBot connection status.",
+      parameters: { type: "object" as const, properties: {} },
+      async execute() {
+        // 1) Already authenticated — bot is claimed
+        if (relay.isConnected() && !relay.isClaimPending()) {
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: `✅ Bot is claimed and connected to WeBot (deviceId: ${relay.getDeviceId().slice(0, 8)}…)`,
+              },
+            ],
+            details: { status: "claimed", deviceId: relay.getDeviceId() },
+          };
+        }
+
+        // 2) auth_pending — return cached claim info
+        if (relay.isClaimPending()) {
+          const info = relay.getClaimInfo();
+          if (info) {
+            return {
+              content: [
+                {
+                  type: "text" as const,
+                  text: `🔗 Awaiting claim — code: ${info.claimCode}\nVisit ${info.claimUrl} to bind this bot.\nExpires: ${new Date(info.expiresAt).toISOString()}`,
+                },
+              ],
+              details: {
+                status: "unclaimed",
+                claimCode: info.claimCode,
+                claimUrl: info.claimUrl,
+                expiresAt: info.expiresAt,
+              },
+            };
+          }
+
+          // No cached info — query the server
+          try {
+            const fresh = await relay.getClaimStatus();
+            if (fresh.status === "claimed") {
+              return {
+                content: [
+                  {
+                    type: "text" as const,
+                    text: `✅ Bot is claimed by @${fresh.owner?.username}`,
+                  },
+                ],
+                details: fresh,
+              };
+            }
+            return {
+              content: [
+                {
+                  type: "text" as const,
+                  text: `🔗 Claim code: ${fresh.claimCode}\nVisit ${fresh.claimUrl} to bind this bot.\nExpires: ${fresh.expiresAt ? new Date(fresh.expiresAt).toISOString() : "unknown"}`,
+                },
+              ],
+              details: fresh,
+            };
+          } catch (err) {
+            return {
+              content: [
+                {
+                  type: "text" as const,
+                  text: `⚠️ Unable to get claim status: ${err instanceof Error ? err.message : String(err)}`,
+                },
+              ],
+              details: { status: "error", error: String(err) },
+            };
+          }
+        }
+
+        // 3) Not connected at all
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: "❌ Bot is not connected to WeBot. It may be reconnecting.",
+            },
+          ],
+          details: { status: "disconnected" },
+        };
+      },
+    });
+
+    // ── Tool: update bot status ──
+    api.registerTool({
+      name: "webot_status_update",
+      label: "WeBot Update Status",
+      description: "Update this bot's status on WeBot",
+      parameters: {
+        type: "object" as const,
+        properties: {
+          text: {
+            type: "string",
+            description: "Status text",
+          },
+          emoji: {
+            type: "string",
+            description: "Status emoji",
+          },
+        },
+      },
+      async execute(_toolCallId, params) {
+        const result = await relay.updateStatus(
+          params.text as string | undefined,
+          params.emoji as string | undefined,
+        );
+        return { content: [{ type: "text" as const, text: JSON.stringify(result) }], details: result };
+      },
+    });
+
+    // ── Gateway RPC: webot.status ──
+    api.registerGatewayMethod("webot.status", async ({ respond }) => {
+      try {
+        const claimInfo = relay.getClaimInfo();
+        respond(true, {
+          connected: relay.isConnected(),
+          claimPending: relay.isClaimPending(),
+          ...(claimInfo
+            ? {
+                claimCode: claimInfo.claimCode,
+                claimUrl: claimInfo.claimUrl,
+                claimExpiresAt: claimInfo.expiresAt,
+              }
+            : {}),
+          deviceId: relay.getDeviceId(),
+          server: config.server,
+        });
+      } catch (err) {
+        respond(false, undefined, {
+          code: "WEBOT_ERROR",
+          message: err instanceof Error ? err.message : String(err),
+        });
+      }
+    });
+
+    // ── Gateway RPC: webot.friends ──
+    api.registerGatewayMethod(
+      "webot.friends",
+      async ({ respond }) => {
+        try {
+          const friends = await relay.getFriends();
+          respond(true, { friends });
+        } catch (err) {
+          respond(false, undefined, {
+            code: "WEBOT_ERROR",
+            message:
+              err instanceof Error ? err.message : String(err),
+          });
+        }
+      },
+    );
+
+    // ── Command: /webot ──
+    api.registerCommand({
+      name: "webot",
+      description: "WeBot status and controls",
+      acceptsArgs: true,
+      handler: async ({ args }) => {
+        const sub = args?.trim().split(/\s+/)[0];
+
+        switch (sub) {
+          case "status":
+            if (relay.isClaimPending()) {
+              const info = relay.getClaimInfo();
+              return {
+                text: info
+                  ? `🔗 Awaiting claim — code: ${info.claimCode}\nVisit ${info.claimUrl} to bind this bot`
+                  : "🔗 Awaiting claim (no claim info available)",
+              };
+            }
+            return {
+              text: relay.isConnected()
+                ? `✅ Connected to WeBot (${relay.getDeviceId().slice(0, 8)}...)`
+                : "❌ Disconnected from WeBot",
+            };
+
+          case "claim": {
+            if (relay.isConnected() && !relay.isClaimPending()) {
+              return { text: "✅ Bot is already claimed and connected" };
+            }
+            if (relay.isClaimPending()) {
+              const info = relay.getClaimInfo();
+              if (info) {
+                return {
+                  text: `🔗 Claim code: ${info.claimCode}\nVisit ${info.claimUrl} to bind this bot\nExpires: ${new Date(info.expiresAt).toISOString()}`,
+                };
+              }
+            }
+            // Try querying the server for fresh claim status
+            try {
+              const status = await relay.getClaimStatus();
+              if (status.status === "claimed") {
+                return {
+                  text: `✅ Bot is claimed by @${status.owner?.username}`,
+                };
+              }
+              return {
+                text: `🔗 Claim code: ${status.claimCode}\nVisit ${status.claimUrl} to bind this bot\nExpires: ${status.expiresAt ? new Date(status.expiresAt).toISOString() : "unknown"}`,
+              };
+            } catch (err) {
+              return {
+                text: `⚠️ Unable to get claim status: ${err instanceof Error ? err.message : String(err)}`,
+              };
+            }
+          }
+
+          case "friends": {
+            try {
+              const result = await relay.getFriends();
+              const lines = result.friends.map(
+                (f) =>
+                  `${f.displayName} (@${f.username}): ${f.bots
+                    .map(
+                      (b) =>
+                        `${b.isOnline ? "🟢" : "🔴"} ${b.displayName}`,
+                    )
+                    .join(", ")}`,
+              );
+              return {
+                text: lines.join("\n") || "No friends yet",
+              };
+            } catch (err) {
+              return {
+                text: `Failed to fetch friends: ${err instanceof Error ? err.message : String(err)}`,
+              };
+            }
+          }
+
+          case "feed": {
+            try {
+              const feed = await relay.getFeed(5);
+              const posts = feed.posts.map(
+                (p) =>
+                  `📝 ${p.authorUsername} (${p.createdAt})\n${p.content}`,
+              );
+              return {
+                text: posts.join("\n\n") || "Feed is empty",
+              };
+            } catch (err) {
+              return {
+                text: `Failed to fetch feed: ${err instanceof Error ? err.message : String(err)}`,
+              };
+            }
+          }
+
+          case "requests": {
+            try {
+              const result = await relay.getPendingFriendRequests();
+              if (result.requests.length === 0) {
+                return { text: "No pending friend requests" };
+              }
+              const lines = result.requests.map(
+                (r) =>
+                  `• ${r.fromUser.displayName} (@${r.fromUser.username}) — ${r.friendshipId}`,
+              );
+              return {
+                text: `Pending friend requests:\n${lines.join("\n")}`,
+              };
+            } catch (err) {
+              return {
+                text: `Failed to fetch requests: ${err instanceof Error ? err.message : String(err)}`,
+              };
+            }
+          }
+
+          case "add": {
+            const username = args?.trim().split(/\s+/)[1];
+            if (!username) {
+              return { text: "Usage: /webot add <username>" };
+            }
+            try {
+              const result = await relay.sendFriendRequest(username);
+              return {
+                text: `✅ Friend request sent to @${username} (${result.friendshipId})`,
+              };
+            } catch (err) {
+              return {
+                text: `Failed to send request: ${err instanceof Error ? err.message : String(err)}`,
+              };
+            }
+          }
+
+          case "accept": {
+            const fid = args?.trim().split(/\s+/)[1];
+            if (!fid) {
+              return { text: "Usage: /webot accept <friendshipId>" };
+            }
+            try {
+              const result = await relay.acceptFriendRequest(fid);
+              return {
+                text: `✅ Accepted friend request — now friends with @${result.friend.username}`,
+              };
+            } catch (err) {
+              return {
+                text: `Failed to accept: ${err instanceof Error ? err.message : String(err)}`,
+              };
+            }
+          }
+
+          case "reject": {
+            const fid = args?.trim().split(/\s+/)[1];
+            if (!fid) {
+              return { text: "Usage: /webot reject <friendshipId>" };
+            }
+            try {
+              await relay.rejectFriendRequest(fid);
+              return {
+                text: `✅ Friend request rejected`,
+              };
+            } catch (err) {
+              return {
+                text: `Failed to reject: ${err instanceof Error ? err.message : String(err)}`,
+              };
+            }
+          }
+
+          default:
+            return {
+              text: "Usage: /webot status | claim | friends | feed | requests | add <username> | accept <friendshipId> | reject <friendshipId>",
+            };
+        }
+      },
+    });
+
+    api.logger.info("WeBot plugin registered");
+  },
+};
+
+export default plugin;