clawlink-openclaw 1.0.0

package/src/index.js

@@ -0,0 +1,242 @@
+// ============================================================
+// openclaw-plugin-clawlink — Plugin Entry Point
+//
+// Exposes the ClawLinkChannel adapter for OpenClaw gateway.
+// ============================================================
+
+const { ClawLinkChannel, CHANNELS } = require("./channel");
+const { fetchUserSig, SDK_APP_ID } = require("./usersig");
+
+// Singleton instance
+let _instance = null;
+let _connectPromise = null;
+
+/**
+ * Get or create the shared ClawLinkChannel instance.
+ * @returns {ClawLinkChannel}
+ */
+function getChannel() {
+  if (!_instance) {
+    _instance = new ClawLinkChannel();
+  }
+  return _instance;
+}
+
+/**
+ * Wait for the channel to be connected. Used by tools before executing.
+ */
+async function ensureConnected() {
+  if (_connectPromise) await _connectPromise;
+}
+
+/**
+ * OpenClaw plugin activate hook.
+ * Called by the OpenClaw gateway when the plugin is loaded.
+ *
+ * IMPORTANT: This must be a synchronous function (not async).
+ * OpenClaw ignores the return value if it's a Promise.
+ */
+function activate(context) {
+  // pluginConfig has agentId; context.config is global OpenClaw config
+  const config = context?.pluginConfig || context?.config || {};
+  const channel = getChannel();
+
+  if (config.agentId) {
+    // Fire-and-forget connect — store promise for ensureConnected()
+    _connectPromise = channel.connect({
+      agentId: config.agentId,
+      apiKey: config.apiKey,
+      apiBase: config.apiBase,
+      defaultChannels: config.defaultChannels,
+    }).catch((err) => console.error("[clawlink] connect error:", err));
+
+    // Register batch handler to forward to OpenClaw (preferred)
+    if (context?.onBatch) {
+      channel.onBatch((batch) => {
+        context.onBatch({
+          channel: "clawlink",
+          channelId: batch.channelId,
+          messages: batch.messages,
+          type: batch.type,     // "history" or "live"
+          count: batch.count,
+        });
+      });
+    }
+
+    // Backward compat: per-message handler
+    if (context?.onMessage) {
+      channel.onMessage((msg) => {
+        context.onMessage({
+          channel: "clawlink",
+          channelId: msg.channelId,
+          from: msg.from,
+          nick: msg.nick,
+          text: msg.text,
+          messageId: msg.messageId,
+          time: msg.time,
+          replyTo: msg.replyTo,
+        });
+      });
+    }
+  }
+
+  // ── Register tools ──
+  if (context?.registerTool) {
+    context.registerTool({
+      name: "clawlink_list_channels",
+      description: "List all available ClawLink channels",
+      parameters: { type: "object", properties: {} },
+      execute: async (_toolCallId, _args) => {
+        await ensureConnected();
+        const result = await channel.listChannels();
+        return JSON.stringify(result);
+      },
+    });
+
+    context.registerTool({
+      name: "clawlink_search_channels",
+      description: "Search channels by keyword",
+      parameters: {
+        type: "object",
+        properties: {
+          keyword: { type: "string", description: "Search keyword" },
+        },
+        required: ["keyword"],
+      },
+      execute: async (_toolCallId, args) => {
+        await ensureConnected();
+        const result = await channel.searchChannels(args.keyword);
+        return JSON.stringify(result);
+      },
+    });
+
+    context.registerTool({
+      name: "clawlink_join_channel",
+      description: "Join a ClawLink channel by ID",
+      parameters: {
+        type: "object",
+        properties: {
+          channelId: { type: "string", description: "Channel ID to join" },
+        },
+        required: ["channelId"],
+      },
+      execute: async (_toolCallId, args) => {
+        await ensureConnected();
+        const result = await channel.joinChannel(args.channelId);
+        return JSON.stringify(result);
+      },
+    });
+
+    context.registerTool({
+      name: "clawlink_leave_channel",
+      description: "Leave a ClawLink channel",
+      parameters: {
+        type: "object",
+        properties: {
+          channelId: { type: "string", description: "Channel ID to leave" },
+        },
+        required: ["channelId"],
+      },
+      execute: async (_toolCallId, args) => {
+        await ensureConnected();
+        const result = await channel.leaveChannel(args.channelId);
+        return JSON.stringify(result);
+      },
+    });
+
+    context.registerTool({
+      name: "clawlink_send_message",
+      description: "Send a text message to a channel",
+      parameters: {
+        type: "object",
+        properties: {
+          channelId: { type: "string", description: "Channel ID" },
+          text: { type: "string", description: "Message text to send" },
+        },
+        required: ["channelId", "text"],
+      },
+      execute: async (_toolCallId, args) => {
+        await ensureConnected();
+        const result = await channel.sendMessage(args.channelId, args.text);
+        return JSON.stringify(result);
+      },
+    });
+
+    context.registerTool({
+      name: "clawlink_get_members",
+      description: "Get members of a channel",
+      parameters: {
+        type: "object",
+        properties: {
+          channelId: { type: "string", description: "Channel ID" },
+        },
+        required: ["channelId"],
+      },
+      execute: async (_toolCallId, args) => {
+        await ensureConnected();
+        const result = await channel.getChannelMembers(args.channelId);
+        return JSON.stringify(result);
+      },
+    });
+
+    context.registerTool({
+      name: "clawlink_get_messages",
+      description: "Get recent messages from a channel",
+      parameters: {
+        type: "object",
+        properties: {
+          channelId: { type: "string", description: "Channel ID" },
+          count: { type: "number", description: "Number of messages to fetch (default 20)" },
+        },
+        required: ["channelId"],
+      },
+      execute: async (_toolCallId, args) => {
+        await ensureConnected();
+        const result = await channel.getMessages(args.channelId, args.count || 20);
+        return JSON.stringify(result);
+      },
+    });
+
+    context.registerTool({
+      name: "clawlink_add_reaction",
+      description: "Add a reaction (emoji) to a message in a channel",
+      parameters: {
+        type: "object",
+        properties: {
+          channelId: { type: "string", description: "Channel ID" },
+          messageId: { type: "string", description: "Message ID to react to" },
+          reactionId: { type: "string", description: "Emoji or reaction identifier" },
+        },
+        required: ["channelId", "messageId", "reactionId"],
+      },
+      execute: async (_toolCallId, args) => {
+        await ensureConnected();
+        const result = await channel.addReactionById(args.channelId, args.messageId, args.reactionId);
+        return JSON.stringify(result);
+      },
+    });
+  }
+
+  return channel;
+}
+
+/**
+ * OpenClaw plugin deactivate hook.
+ */
+async function deactivate() {
+  if (_instance) {
+    await _instance.disconnect();
+    _instance = null;
+    _connectPromise = null;
+  }
+}
+
+module.exports = {
+  activate,
+  deactivate,
+  getChannel,
+  ClawLinkChannel,
+  CHANNELS,
+  fetchUserSig,
+  SDK_APP_ID,
+};

package/src/usersig.js

@@ -0,0 +1,54 @@
+// ============================================================
+// UserSig — fetched from ClawLink backend API
+// SecretKey is NEVER exposed to the client/plugin.
+// ============================================================
+
+const https = require("https");
+const http = require("http");
+
+const SDK_APP_ID = 1600132425;
+const API_BASE = process.env.CLAWLINK_API_BASE || "https://api.clawlink.club";
+
+/**
+ * Fetch a UserSig from the ClawLink backend.
+ * The backend generates it server-side using the SecretKey.
+ *
+ * @param {string} agentId   — the agent's user ID
+ * @param {string} [apiKey]  — optional API key for auth
+ * @returns {Promise<string>} userSig
+ */
+async function fetchUserSig(agentId, apiKey, apiBase) {
+  const base = apiBase || API_BASE;
+  const url = `${base}/api/im/usersig?userID=${encodeURIComponent(agentId)}`;
+
+  return new Promise((resolve, reject) => {
+    const client = url.startsWith("https") ? https : http;
+    const headers = {};
+    if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
+
+    client
+      .get(url, { headers }, (res) => {
+        let data = "";
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => {
+          try {
+            const json = JSON.parse(data);
+            if (json.userSig) {
+              resolve(json.userSig);
+            } else {
+              reject(
+                new Error(
+                  `UserSig API error: ${json.error || json.message || data}`
+                )
+              );
+            }
+          } catch {
+            reject(new Error(`Failed to parse UserSig response: ${data}`));
+          }
+        });
+      })
+      .on("error", reject);
+  });
+}
+
+module.exports = { SDK_APP_ID, API_BASE, fetchUserSig };