@ssfxx44533/onebot-qq 0.1.2

package/src/channel.ts

@@ -0,0 +1,549 @@
+import {
+  buildAccountScopedDmSecurityPolicy,
+} from "openclaw/plugin-sdk/channel-policy";
+import {
+  PAIRING_APPROVED_MESSAGE,
+} from "openclaw/plugin-sdk/channel-status";
+
+import {
+  DEFAULT_ACCOUNT_ID,
+  DEFAULT_MAX_CHUNK_LENGTH,
+  ONEBOT_QQ_CHANNEL_SCHEMA,
+  normalizeOneBotGroupId,
+  normalizeOneBotSenderEntry,
+  normalizeOneBotUserId,
+  parseOutboundTarget,
+  resolveLocalFilePath,
+  resolveMediaKind,
+  resolveOneBotAccount,
+  resolveUploadName,
+  isRemoteUrl,
+  listOneBotAccountIds,
+} from "./config.js";
+import {
+  splitTextChunks,
+} from "./message.js";
+import {
+  getLiveAccount,
+  registerLiveAccount,
+  unregisterLiveAccount,
+  updateLiveAccountSelfId,
+} from "./runtime.js";
+import {
+  startOneBotMonitor,
+  withOneBotSocket,
+} from "./onebot-client.js";
+import {
+  handleOneBotInboundMessage,
+} from "./inbound.ts";
+
+function buildTextSegments(text, replyToId) {
+  const segments = [];
+  const normalizedReplyToId = String(replyToId ?? "").trim();
+  if (normalizedReplyToId) {
+    segments.push({
+      type: "reply",
+      data: { id: normalizedReplyToId },
+    });
+  }
+  if (text) {
+    segments.push({
+      type: "text",
+      data: { text },
+    });
+  }
+  return segments;
+}
+
+async function withPreferredSocket(account, work) {
+  const live = getLiveAccount(account.accountId);
+  if (live?.socket && live.socket.closed !== true) {
+    try {
+      return await work(live.socket);
+    } catch (error) {
+      if (live.socket.closed !== true) {
+        throw error;
+      }
+    }
+  }
+
+  return await withOneBotSocket(
+    {
+      wsUrl: account.wsUrl,
+      callTimeoutMs: account.callTimeoutMs,
+    },
+    work,
+  );
+}
+
+function resolveActionForTarget(target, baseAction) {
+  if (baseAction === "send_msg") {
+    return target.chatType === "group" ? "send_group_msg" : "send_private_msg";
+  }
+  if (baseAction === "upload_file") {
+    return target.chatType === "group" ? "upload_group_file" : "upload_private_file";
+  }
+  return baseAction;
+}
+
+function resolveTargetParams(target) {
+  if (target.chatType === "group") {
+    return { group_id: String(target.targetId) };
+  }
+  return { user_id: String(target.targetId) };
+}
+
+async function sendTextToTarget(account, target, text, replyToId = null) {
+  const chunks = splitTextChunks(text, account.maxChunkLength);
+  if (chunks.length === 0) {
+    return { channel: "onebot-qq", messageId: "" };
+  }
+
+  let lastMessageId = "";
+  await withPreferredSocket(account, async (socket) => {
+    for (const [index, chunk] of chunks.entries()) {
+      const response = await socket.call(resolveActionForTarget(target, "send_msg"), {
+        ...resolveTargetParams(target),
+        message: buildTextSegments(chunk, index === 0 ? replyToId : null),
+      });
+      lastMessageId = String(response?.data?.message_id ?? lastMessageId ?? "");
+    }
+  });
+
+  return { channel: "onebot-qq", messageId: lastMessageId };
+}
+
+async function sendSegmentMediaToTarget(account, target, mediaKind, mediaUrl, text = "", replyToId = null) {
+  const normalizedMediaUrl = isRemoteUrl(mediaUrl) ? mediaUrl : resolveLocalFilePath(mediaUrl);
+  const segments = buildTextSegments(text, replyToId);
+  segments.push({
+    type:
+      mediaKind === "audio"
+        ? "record"
+        : mediaKind === "video"
+          ? "video"
+          : "image",
+    data: { file: normalizedMediaUrl },
+  });
+
+  let messageId = "";
+  await withPreferredSocket(account, async (socket) => {
+    const response = await socket.call(resolveActionForTarget(target, "send_msg"), {
+      ...resolveTargetParams(target),
+      message: segments,
+    });
+    messageId = String(response?.data?.message_id ?? "");
+  });
+
+  return { channel: "onebot-qq", messageId };
+}
+
+async function uploadFileToTarget(account, target, mediaUrl) {
+  const file = isRemoteUrl(mediaUrl) ? mediaUrl : resolveLocalFilePath(mediaUrl);
+  await withPreferredSocket(account, async (socket) => {
+    await socket.call(resolveActionForTarget(target, "upload_file"), {
+      ...resolveTargetParams(target),
+      file,
+      name: resolveUploadName(mediaUrl),
+    });
+  });
+
+  return { channel: "onebot-qq", messageId: "" };
+}
+
+function resolvePayloadMediaUrls(payload) {
+  if (Array.isArray(payload?.mediaUrls) && payload.mediaUrls.length > 0) {
+    return payload.mediaUrls
+      .map((entry) => String(entry ?? "").trim())
+      .filter(Boolean);
+  }
+  const single = String(payload?.mediaUrl ?? "").trim();
+  return single ? [single] : [];
+}
+
+async function deliverPayloadToChat({ account, target, payload }) {
+  const text = String(payload?.text ?? "");
+  const mediaUrls = resolvePayloadMediaUrls(payload);
+  const replyToId = String(payload?.replyToId ?? target.replyToId ?? "").trim() || null;
+
+  if (mediaUrls.length === 0) {
+    if (!text.trim()) {
+      return { channel: "onebot-qq", messageId: "" };
+    }
+    return await sendTextToTarget(account, target, text, replyToId);
+  }
+
+  let first = true;
+  let lastResult = { channel: "onebot-qq", messageId: "" };
+  for (const mediaUrl of mediaUrls) {
+    const mediaKind = resolveMediaKind(mediaUrl);
+    if (mediaKind === "image" || mediaKind === "audio" || mediaKind === "video") {
+      lastResult = await sendSegmentMediaToTarget(
+        account,
+        target,
+        mediaKind,
+        mediaUrl,
+        first ? text : "",
+        first ? replyToId : null,
+      );
+    } else {
+      if (first && text.trim()) {
+        await sendTextToTarget(account, target, text, replyToId);
+      }
+      lastResult = await uploadFileToTarget(account, target, mediaUrl);
+    }
+    first = false;
+  }
+
+  return lastResult;
+}
+
+function parseTargetOrThrow(account, rawTarget) {
+  const parsed = parseOutboundTarget(rawTarget, account.defaultTo ? parseOutboundTarget(account.defaultTo) : null);
+  if (!parsed) {
+    throw new Error(
+      "Invalid OneBot QQ target. Use a QQ number for private chat, or group:<groupId> for groups.",
+    );
+  }
+  return parsed;
+}
+
+function createStatusSnapshot(account, runtime) {
+  return {
+    accountId: account.accountId,
+    name: account.name,
+    enabled: account.enabled,
+    configured: true,
+    running: runtime?.running ?? false,
+    selfId: runtime?.selfId ?? account.selfId ?? null,
+    dmPolicy: account.dmPolicy,
+    allowFrom: account.allowFrom,
+    lastError: runtime?.lastError ?? null,
+    lastInboundAt: runtime?.lastInboundAt ?? null,
+    lastOutboundAt: runtime?.lastOutboundAt ?? null,
+  };
+}
+
+function uniqueEntries(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+
+function sliceDirectoryEntries(entries, query, limit) {
+  const normalizedQuery = String(query ?? "").trim().toLowerCase();
+  const filtered = normalizedQuery
+    ? entries.filter((entry) => {
+        const haystack = `${entry.id} ${entry.name ?? ""}`.toLowerCase();
+        return haystack.includes(normalizedQuery);
+      })
+    : entries;
+  const max = Number.isFinite(limit) && Number(limit) > 0 ? Number(limit) : filtered.length;
+  return filtered.slice(0, max);
+}
+
+function listConfiguredPeerIds(account) {
+  if (account.allowFrom.includes("*")) {
+    return [];
+  }
+  return uniqueEntries(account.allowFrom.map((entry) => normalizeOneBotSenderEntry(entry)));
+}
+
+function listConfiguredGroupIds(account) {
+  return uniqueEntries(
+    Object.keys(account.groups ?? {})
+      .map((entry) => normalizeOneBotGroupId(entry))
+      .filter(Boolean),
+  );
+}
+
+export const onebotQqPlugin = {
+  id: "onebot-qq",
+  meta: {
+    id: "onebot-qq",
+    label: "OneBot QQ",
+    selectionLabel: "OneBot QQ (NapCat)",
+    docsPath: "/channels/onebot-qq",
+    docsLabel: "OneBot QQ",
+    blurb: "NapCat / OneBot QQ channel for OpenClaw.",
+    order: 76,
+    quickstartAllowFrom: true,
+  },
+  configSchema: {
+    schema: ONEBOT_QQ_CHANNEL_SCHEMA,
+  },
+  pairing: {
+    idLabel: "qqUserId",
+    normalizeAllowEntry: (entry) => normalizeOneBotSenderEntry(entry),
+    notifyApproval: async ({ cfg, id }) => {
+      const targetId = normalizeOneBotUserId(id);
+      if (!targetId) {
+        throw new Error(`Invalid QQ user id for pairing approval: ${id}`);
+      }
+      const account = resolveOneBotAccount(cfg, DEFAULT_ACCOUNT_ID);
+      await sendTextToTarget(
+        account,
+        {
+          chatType: "private",
+          targetId,
+          groupId: null,
+          userId: targetId,
+        },
+        PAIRING_APPROVED_MESSAGE,
+      );
+    },
+  },
+  capabilities: {
+    chatTypes: ["direct", "group"],
+    media: true,
+  },
+  messaging: {
+    normalizeTarget: (target) => String(target ?? "").trim(),
+    targetResolver: {
+      looksLikeId: (value) =>
+        /^(?:\d+|(?:onebot-qq:)?(?:group|qq-group|g|private|user|qq|qq-private|u):\d+)$/i.test(
+          String(value ?? "").trim(),
+        ),
+      hint: "<qq>|group:<qq-group-id>",
+    },
+  },
+  reload: { configPrefixes: ["channels.onebot-qq"] },
+  config: {
+    listAccountIds: (cfg) => listOneBotAccountIds(cfg),
+    resolveAccount: (cfg, accountId) => resolveOneBotAccount(cfg, accountId),
+    isConfigured: () => true,
+    resolveAllowFrom: ({ cfg, accountId }) =>
+      resolveOneBotAccount(cfg, accountId ?? DEFAULT_ACCOUNT_ID).allowFrom,
+    formatAllowFrom: ({ allowFrom }) =>
+      uniqueEntries(allowFrom.map((entry) => normalizeOneBotSenderEntry(entry))),
+    resolveDefaultTo: ({ cfg, accountId }) =>
+      resolveOneBotAccount(cfg, accountId ?? DEFAULT_ACCOUNT_ID).defaultTo ?? undefined,
+    describeAccount: (account) => ({
+      accountId: account.accountId,
+      name: account.name,
+      enabled: account.enabled,
+      configured: true,
+      selfId: account.selfId,
+      wsUrl: account.wsUrl,
+    }),
+  },
+  security: {
+    resolveDmPolicy: ({ cfg, accountId, account }) =>
+      buildAccountScopedDmSecurityPolicy({
+        cfg,
+        channelKey: "onebot-qq",
+        accountId,
+        fallbackAccountId: account.accountId ?? DEFAULT_ACCOUNT_ID,
+        policy: account.dmPolicy,
+        allowFrom: account.allowFrom ?? [],
+        policyPathSuffix: "dmPolicy",
+        normalizeEntry: (raw) => normalizeOneBotSenderEntry(raw),
+      }),
+  },
+  status: {
+    defaultRuntime: {
+      accountId: DEFAULT_ACCOUNT_ID,
+      running: false,
+      selfId: null,
+      lastError: null,
+      lastInboundAt: null,
+      lastOutboundAt: null,
+    },
+    buildChannelSummary: ({ account, snapshot }) =>
+      createStatusSnapshot(account, snapshot),
+    buildAccountSnapshot: ({ account, runtime }) =>
+      createStatusSnapshot(account, runtime),
+  },
+  outbound: {
+    deliveryMode: "direct",
+    textChunkLimit: DEFAULT_MAX_CHUNK_LENGTH,
+    sendText: async (ctx) => {
+      const account = resolveOneBotAccount(ctx.cfg, ctx.accountId ?? DEFAULT_ACCOUNT_ID);
+      const target = parseTargetOrThrow(account, ctx.to);
+      return await sendTextToTarget(account, target, ctx.text, ctx.replyToId ?? null);
+    },
+    sendMedia: async (ctx) => {
+      const account = resolveOneBotAccount(ctx.cfg, ctx.accountId ?? DEFAULT_ACCOUNT_ID);
+      const target = parseTargetOrThrow(account, ctx.to);
+      return await deliverPayloadToChat({
+        account,
+        target,
+        payload: {
+          text: ctx.text,
+          mediaUrl: ctx.mediaUrl,
+          replyToId: ctx.replyToId,
+        },
+      });
+    },
+    sendPayload: async (ctx) => {
+      const account = resolveOneBotAccount(ctx.cfg, ctx.accountId ?? DEFAULT_ACCOUNT_ID);
+      const target = parseTargetOrThrow(account, ctx.to);
+      return await deliverPayloadToChat({
+        account,
+        target,
+        payload: ctx.payload,
+      });
+    },
+  },
+  directory: {
+    self: async ({ cfg, accountId }) => {
+      const account = resolveOneBotAccount(cfg, accountId ?? DEFAULT_ACCOUNT_ID);
+      const live = getLiveAccount(account.accountId);
+      const selfId = live?.selfId ?? account.selfId;
+      if (!selfId) {
+        return null;
+      }
+      return {
+        kind: "user",
+        id: selfId,
+        name: account.name,
+        raw: {
+          accountId: account.accountId,
+          selfId,
+        },
+      };
+    },
+    listPeers: async ({ cfg, accountId, query, limit }) => {
+      const account = resolveOneBotAccount(cfg, accountId ?? DEFAULT_ACCOUNT_ID);
+      return sliceDirectoryEntries(
+        listConfiguredPeerIds(account).map((id) => ({
+          kind: "user",
+          id,
+          name: `QQ user ${id}`,
+        })),
+        query,
+        limit,
+      );
+    },
+    listGroups: async ({ cfg, accountId, query, limit }) => {
+      const account = resolveOneBotAccount(cfg, accountId ?? DEFAULT_ACCOUNT_ID);
+      return sliceDirectoryEntries(
+        listConfiguredGroupIds(account).map((id) => ({
+          kind: "group",
+          id,
+          name: `QQ Group ${id}`,
+        })),
+        query,
+        limit,
+      );
+    },
+  },
+  resolver: {
+    resolveTargets: async ({ inputs, kind }) =>
+      inputs.map((input) => {
+        const trimmed = String(input ?? "").trim();
+        const parsed = parseOutboundTarget(trimmed);
+        if (!parsed) {
+          return {
+            input,
+            resolved: false,
+            note: "invalid QQ target",
+          };
+        }
+        if (kind === "group" && parsed.chatType !== "group") {
+          return {
+            input,
+            resolved: false,
+            note: "expected QQ group target",
+          };
+        }
+        if (kind === "user" && parsed.chatType !== "private") {
+          return {
+            input,
+            resolved: false,
+            note: "expected QQ user target",
+          };
+        }
+        return {
+          input,
+          resolved: true,
+          id: parsed.targetId,
+          name: parsed.chatType === "group" ? `QQ Group ${parsed.targetId}` : `QQ user ${parsed.targetId}`,
+        };
+      }),
+  },
+  agentPrompt: {
+    messageToolHints: () => [
+      "For OneBot QQ private chats, use the recipient QQ number as the target.",
+      "For QQ groups, use group:<groupId> as the target.",
+      "When sending generated images back to QQ, keep them as image attachments instead of converting them to plain links.",
+    ],
+  },
+  auth: {
+    login: async () => {
+      throw new Error(
+        "OneBot QQ login is managed by NapCat. Configure channels.onebot-qq.wsUrl and start NapCat separately.",
+      );
+    },
+  },
+  gateway: {
+    startAccount: async (ctx) => {
+      const account = resolveOneBotAccount(ctx.cfg, ctx.accountId ?? ctx.account?.accountId ?? DEFAULT_ACCOUNT_ID);
+      ctx.setStatus?.({
+        accountId: account.accountId,
+        running: true,
+        lastError: null,
+        selfId: account.selfId,
+      });
+
+      const monitor = startOneBotMonitor({
+        account,
+        log: ctx.log,
+        onStatus: (patch) => {
+          ctx.setStatus?.({
+            accountId: account.accountId,
+            ...patch,
+          });
+        },
+        onConnected: ({ socket, selfId }) => {
+          registerLiveAccount(account.accountId, { socket, selfId });
+          if (selfId) {
+            updateLiveAccountSelfId(account.accountId, selfId);
+            ctx.setStatus?.({
+              accountId: account.accountId,
+              selfId,
+            });
+          }
+          ctx.log?.info?.(
+            `[${account.accountId}] connected to NapCat at ${account.wsUrl}${selfId ? ` as ${selfId}` : ""}`,
+          );
+        },
+        onDisconnected: (socket) => {
+          unregisterLiveAccount(account.accountId, socket);
+        },
+        onEvent: async (event) => {
+          const live = getLiveAccount(account.accountId);
+          await handleOneBotInboundMessage({
+            account,
+            cfg: ctx.cfg,
+            runtime: ctx.channelRuntime,
+            event,
+            selfId: live?.selfId ?? account.selfId,
+            log: ctx.log,
+            onStatus: (patch) => {
+              ctx.setStatus?.({
+                accountId: account.accountId,
+                ...patch,
+              });
+            },
+            deliver: deliverPayloadToChat,
+          });
+        },
+      });
+
+      try {
+        if (ctx.abortSignal.aborted) {
+          return;
+        }
+        await new Promise((resolve) => {
+          ctx.abortSignal.addEventListener("abort", resolve, { once: true });
+        });
+      } finally {
+        await monitor.stop();
+        unregisterLiveAccount(account.accountId);
+        ctx.setStatus?.({
+          accountId: account.accountId,
+          running: false,
+        });
+      }
+    },
+  },
+};