@ssfxx44533/onebot-qq 0.1.2

package/src/message.js

@@ -0,0 +1,235 @@
+export function makeEventKey(accountId, event) {
+  return [
+    String(accountId ?? ""),
+    String(event?.post_type ?? ""),
+    String(event?.message_type ?? ""),
+    String(event?.message_id ?? ""),
+    String(event?.group_id ?? ""),
+    String(event?.user_id ?? ""),
+    String(event?.time ?? ""),
+  ].join(":");
+}
+
+export function extractReplyToId(event) {
+  if (!Array.isArray(event?.message)) {
+    return null;
+  }
+  const replySegment = event.message.find((segment) => segment?.type === "reply");
+  const value = String(replySegment?.data?.id ?? "").trim();
+  return value || null;
+}
+
+export function isAtSelf(event, selfId) {
+  const normalizedSelfId = String(selfId ?? "").trim();
+  if (!normalizedSelfId) {
+    return false;
+  }
+  if (Array.isArray(event?.message)) {
+    return event.message.some(
+      (segment) => segment?.type === "at" && String(segment?.data?.qq ?? "") === normalizedSelfId,
+    );
+  }
+  return String(event?.raw_message ?? "").includes(`[CQ:at,qq=${normalizedSelfId}]`);
+}
+
+export function normalizeSegment(segment, selfId) {
+  if (!segment || typeof segment !== "object") {
+    return "";
+  }
+  const type = segment.type;
+  const data = segment.data ?? {};
+
+  if (type === "text") {
+    return String(data.text ?? "");
+  }
+  if (type === "at") {
+    const target = String(data.qq ?? "");
+    if (selfId && target === String(selfId)) {
+      return "";
+    }
+    return target ? `@${target}` : "@";
+  }
+  if (type === "reply" || type === "forward") {
+    return "";
+  }
+  if (type === "image") {
+    return "[image]";
+  }
+  if (type === "video") {
+    return "[video]";
+  }
+  if (type === "record" || type === "audio") {
+    return "[voice]";
+  }
+  if (type === "file" || type === "onlinefile") {
+    const name = String(data.name ?? data.file ?? data.fileName ?? "").trim();
+    return name ? `[file: ${name}]` : "[file]";
+  }
+  if (type === "face") {
+    return "[sticker]";
+  }
+  if (type === "json" || type === "xml") {
+    return "[card]";
+  }
+  return `[${type}]`;
+}
+
+function normalizeInboundText(text) {
+  return String(text ?? "").trim();
+}
+
+export function extractMessageText(event, selfId) {
+  if (Array.isArray(event?.message)) {
+    return normalizeInboundText(
+      event.message
+      .map((segment) => normalizeSegment(segment, selfId))
+      .join("")
+      .replace(/\u00a0/g, " ")
+      .replace(/[ \t]+\n/g, "\n")
+      .replace(/\n{3,}/g, "\n\n")
+      .trim(),
+    );
+  }
+
+  return normalizeInboundText(
+    String(event?.raw_message ?? "")
+      .replace(/\[CQ:at,qq=\d+\]/g, "")
+      .replace(/\[CQ:reply,id=\d+\]/g, "")
+      .trim(),
+  );
+}
+
+function stripAttachmentMarkerText(text) {
+  return String(text ?? "")
+    .replace(/\[(?:image|video|voice)\]/g, "")
+    .replace(/\[file(?:: [^\]]+)?\]/g, "")
+    .replace(/[ \t]+\n/g, "\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+}
+
+export function extractAttachments(event) {
+  if (!Array.isArray(event?.message)) {
+    return [];
+  }
+
+  const attachments = [];
+  for (const segment of event.message) {
+    if (!segment || typeof segment !== "object") {
+      continue;
+    }
+    const type = segment.type;
+    const data = segment.data ?? {};
+
+    if (type === "image") {
+      attachments.push({
+        kind: "image",
+        summary: typeof data.summary === "string" ? data.summary : "[image]",
+        file: typeof data.file === "string" ? data.file : "",
+        url: typeof data.url === "string" ? data.url : "",
+        fileSize: data.file_size ?? "",
+      });
+      continue;
+    }
+
+    if (type === "video") {
+      attachments.push({
+        kind: "video",
+        file: typeof data.file === "string" ? data.file : "",
+        url: typeof data.url === "string" ? data.url : "",
+      });
+      continue;
+    }
+
+    if (type === "record" || type === "audio") {
+      attachments.push({
+        kind: "audio",
+        file: typeof data.file === "string" ? data.file : "",
+        url: typeof data.url === "string" ? data.url : "",
+      });
+      continue;
+    }
+
+    if (type === "file" || type === "onlinefile") {
+      attachments.push({
+        kind: "file",
+        name:
+          typeof data.file === "string"
+            ? data.file
+            : typeof data.fileName === "string"
+              ? data.fileName
+              : "",
+        url: typeof data.url === "string" ? data.url : "",
+        fileId:
+          typeof data.file_id === "string"
+            ? data.file_id
+            : typeof data.fileId === "string"
+              ? data.fileId
+              : "",
+        fileSize: data.file_size ?? data.fileSize ?? "",
+      });
+    }
+  }
+
+  return attachments;
+}
+
+export function buildAgentBody(text, attachments) {
+  const lines = [];
+  const trimmedText = stripAttachmentMarkerText(text);
+  if (trimmedText) {
+    lines.push(trimmedText);
+  } else if (attachments.length > 0) {
+    lines.push(
+      "[No text provided — attachment only. Focus on the attached content and respond accordingly; if it is an image, describe what is visually present.]",
+    );
+  }
+
+  if (attachments.length > 0) {
+    if (lines.length > 0) {
+      lines.push("");
+    }
+    lines.push("Attachments:");
+    for (const [index, attachment] of attachments.entries()) {
+      const details = [`${index + 1}. type=${attachment.kind}`];
+      if (attachment.summary) details.push(`summary=${attachment.summary}`);
+      if (attachment.name) details.push(`name=${attachment.name}`);
+      if (attachment.file) details.push(`file=${attachment.file}`);
+      if (attachment.fileId) details.push(`file_id=${attachment.fileId}`);
+      if (attachment.fileSize) details.push(`size=${attachment.fileSize}`);
+      if (attachment.url) details.push(`url=${attachment.url}`);
+      lines.push(`- ${details.join(", ")}`);
+    }
+  }
+
+  return lines.join("\n").trim();
+}
+
+export function splitTextChunks(text, limit) {
+  const normalized = String(text ?? "").replace(/\r\n/g, "\n").trim();
+  if (!normalized) {
+    return [];
+  }
+
+  const chunks = [];
+  let remaining = normalized;
+  while (remaining.length > limit) {
+    let splitAt = remaining.lastIndexOf("\n\n", limit);
+    if (splitAt < Math.floor(limit / 2)) {
+      splitAt = remaining.lastIndexOf("\n", limit);
+    }
+    if (splitAt < Math.floor(limit / 2)) {
+      splitAt = remaining.lastIndexOf(" ", limit);
+    }
+    if (splitAt < Math.floor(limit / 2)) {
+      splitAt = limit;
+    }
+    chunks.push(remaining.slice(0, splitAt).trim());
+    remaining = remaining.slice(splitAt).trim();
+  }
+
+  if (remaining) {
+    chunks.push(remaining);
+  }
+  return chunks;
+}

package/src/onebot-client.js

@@ -0,0 +1,226 @@
+import crypto from "node:crypto";
+import { setTimeout as sleep } from "node:timers/promises";
+
+function parseWsData(data) {
+  if (typeof data === "string") {
+    return data;
+  }
+  if (Buffer.isBuffer(data)) {
+    return data.toString("utf8");
+  }
+  if (data instanceof ArrayBuffer) {
+    return Buffer.from(data).toString("utf8");
+  }
+  if (ArrayBuffer.isView(data)) {
+    return Buffer.from(data.buffer, data.byteOffset, data.byteLength).toString("utf8");
+  }
+  return String(data);
+}
+
+export class OneBotSocket {
+  constructor(ws, options) {
+    this.ws = ws;
+    this.callTimeoutMs = options.callTimeoutMs;
+    this.onEvent = options.onEvent;
+    this.pending = new Map();
+    this.closed = false;
+    this.closedPromise = new Promise((resolve) => {
+      this.#resolveClosed = resolve;
+    });
+    this.#attach();
+  }
+
+  #resolveClosed;
+
+  static async connect(options) {
+    const ws = new WebSocket(options.wsUrl);
+    await new Promise((resolve, reject) => {
+      ws.addEventListener("open", () => resolve(), { once: true });
+      ws.addEventListener(
+        "error",
+        (event) => reject(event?.error ?? new Error("OneBot WebSocket error")),
+        { once: true },
+      );
+    });
+    return new OneBotSocket(ws, options);
+  }
+
+  #attach() {
+    this.ws.addEventListener("message", (event) => {
+      void this.#onMessage(event.data);
+    });
+    this.ws.addEventListener("close", () => {
+      this.closed = true;
+      for (const [echo, pending] of this.pending.entries()) {
+        clearTimeout(pending.timeout);
+        pending.reject(new Error(`OneBot disconnected before response: ${echo}`));
+      }
+      this.pending.clear();
+      this.#resolveClosed();
+    });
+  }
+
+  async #onMessage(rawData) {
+    let parsed;
+    try {
+      parsed = JSON.parse(parseWsData(rawData));
+    } catch {
+      return;
+    }
+
+    if (parsed?.echo && this.pending.has(parsed.echo)) {
+      const pending = this.pending.get(parsed.echo);
+      this.pending.delete(parsed.echo);
+      clearTimeout(pending.timeout);
+      if (parsed.status && parsed.status !== "ok" && parsed.retcode !== 0) {
+        pending.reject(
+          new Error(
+            parsed.wording || parsed.message || parsed.msg || `retcode=${parsed.retcode}`,
+          ),
+        );
+      } else {
+        pending.resolve(parsed);
+      }
+      return;
+    }
+
+    if (parsed?.post_type === "message") {
+      await this.onEvent?.(parsed);
+    }
+  }
+
+  async call(action, params = {}) {
+    if (this.closed || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("OneBot WebSocket is not connected");
+    }
+    const echo = crypto.randomUUID();
+    const payload = { action, params, echo };
+
+    return await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pending.delete(echo);
+        reject(new Error(`OneBot action timed out: ${action}`));
+      }, this.callTimeoutMs);
+
+      this.pending.set(echo, { resolve, reject, timeout });
+      try {
+        this.ws.send(JSON.stringify(payload));
+      } catch (error) {
+        clearTimeout(timeout);
+        this.pending.delete(echo);
+        reject(error);
+      }
+    });
+  }
+
+  async getLoginInfo() {
+    const result = await this.call("get_login_info");
+    return result?.data ?? {};
+  }
+
+  close() {
+    if (this.closed) {
+      return;
+    }
+    try {
+      this.ws.close();
+    } catch {
+      this.closed = true;
+      this.#resolveClosed();
+    }
+  }
+}
+
+export async function withOneBotSocket(options, work) {
+  const socket = await OneBotSocket.connect(options);
+  try {
+    return await work(socket);
+  } finally {
+    socket.close();
+    await socket.closedPromise.catch(() => undefined);
+  }
+}
+
+export function startOneBotMonitor(options) {
+  let stopped = false;
+  let activeSocket = null;
+  let loopPromise = null;
+
+  async function loop() {
+    let delayMs = Math.max(1, options.account.reconnectBaseMs);
+    while (!stopped) {
+      try {
+        options.onStatus?.({
+          running: true,
+          lastError: null,
+          lastStartAt: Date.now(),
+        });
+        const socket = await OneBotSocket.connect({
+          wsUrl: options.account.wsUrl,
+          callTimeoutMs: options.account.callTimeoutMs,
+          onEvent: options.onEvent,
+        });
+        activeSocket = socket;
+
+        let selfId = options.account.selfId;
+        try {
+          const loginInfo = await socket.getLoginInfo();
+          if (loginInfo?.user_id) {
+            selfId = String(loginInfo.user_id);
+          }
+        } catch (error) {
+          options.log?.debug?.(`onebot-qq: get_login_info failed: ${String(error)}`);
+        }
+
+        options.onConnected?.({
+          socket,
+          selfId: selfId || null,
+        });
+        delayMs = Math.max(1, options.account.reconnectBaseMs);
+
+        await socket.closedPromise;
+        if (stopped) {
+          break;
+        }
+        options.onStatus?.({
+          running: false,
+          lastStopAt: Date.now(),
+        });
+      } catch (error) {
+        options.onStatus?.({
+          running: false,
+          lastError: error instanceof Error ? error.message : String(error),
+          lastStopAt: Date.now(),
+        });
+        options.log?.warn?.(`onebot-qq: connection failed: ${String(error)}`);
+      } finally {
+        if (activeSocket) {
+          options.onDisconnected?.(activeSocket);
+        }
+        activeSocket = null;
+      }
+
+      if (stopped) {
+        break;
+      }
+      await sleep(delayMs);
+      delayMs = Math.min(
+        Math.max(1, delayMs * 2),
+        Math.max(options.account.reconnectBaseMs, options.account.reconnectMaxMs),
+      );
+    }
+  }
+
+  loopPromise = loop();
+
+  return {
+    waitUntilStopped() {
+      return loopPromise;
+    },
+    async stop() {
+      stopped = true;
+      activeSocket?.close();
+      await loopPromise;
+    },
+  };
+}

package/src/plugin.ts

@@ -0,0 +1,16 @@
+import { buildChannelConfigSchema } from "openclaw/plugin-sdk/channel-config-schema";
+
+import { ONEBOT_QQ_CHANNEL_SCHEMA } from "./config.js";
+import { onebotQqPlugin } from "./channel.ts";
+
+const plugin = {
+  id: "onebot-qq",
+  name: "OneBot QQ",
+  description: "NapCat / OneBot QQ channel plugin for OpenClaw",
+  configSchema: buildChannelConfigSchema(ONEBOT_QQ_CHANNEL_SCHEMA),
+  register(api) {
+    api.registerChannel({ plugin: onebotQqPlugin });
+  },
+};
+
+export default plugin;

package/src/runtime.js

@@ -0,0 +1,85 @@
+const MAX_RECENT_EVENT_IDS = 2000;
+
+const state = {
+  liveAccounts: new Map(),
+  sessionQueues: new Map(),
+  recentEventIds: new Set(),
+};
+
+// Periodic cleanup: clear the entire dedup set every 10 minutes so it
+// never accumulates indefinitely in low-traffic scenarios.
+const _recentEventCleanupTimer = setInterval(() => {
+  state.recentEventIds.clear();
+}, 10 * 60 * 1000);
+if (_recentEventCleanupTimer.unref) {
+  _recentEventCleanupTimer.unref();
+}
+
+export function registerLiveAccount(accountId, data) {
+  state.liveAccounts.set(String(accountId), {
+    socket: data.socket,
+    selfId: data.selfId ? String(data.selfId) : null,
+  });
+}
+
+export function updateLiveAccountSelfId(accountId, selfId) {
+  const key = String(accountId);
+  const current = state.liveAccounts.get(key);
+  if (!current) {
+    return;
+  }
+  state.liveAccounts.set(key, {
+    ...current,
+    selfId: selfId ? String(selfId) : null,
+  });
+}
+
+export function getLiveAccount(accountId) {
+  return state.liveAccounts.get(String(accountId)) ?? null;
+}
+
+export function unregisterLiveAccount(accountId, socket) {
+  const key = String(accountId);
+  const current = state.liveAccounts.get(key);
+  if (!current) {
+    return;
+  }
+  if (socket && current.socket !== socket) {
+    return;
+  }
+  state.liveAccounts.delete(key);
+}
+
+export function enqueueSessionWork(sessionKey, work) {
+  const key = String(sessionKey);
+  const previous = state.sessionQueues.get(key) ?? Promise.resolve();
+  const next = previous.catch(() => undefined).then(work);
+
+  state.sessionQueues.set(
+    key,
+    next.finally(() => {
+      if (state.sessionQueues.get(key) === next) {
+        state.sessionQueues.delete(key);
+      }
+    }),
+  );
+
+  return next;
+}
+
+export function hasSeenEvent(eventKey) {
+  return state.recentEventIds.has(String(eventKey));
+}
+
+export function rememberEvent(eventKey) {
+  const key = String(eventKey);
+  if (state.recentEventIds.has(key)) {
+    return;
+  }
+  // Cap the set size: evict the oldest entry (insertion order) when full.
+  if (state.recentEventIds.size >= MAX_RECENT_EVENT_IDS) {
+    const oldest = state.recentEventIds.values().next().value;
+    state.recentEventIds.delete(oldest);
+  }
+  state.recentEventIds.add(key);
+}