@ssfxx44533/onebot-qq 0.1.2

package/src/inbound.ts

@@ -0,0 +1,587 @@
+import path from "node:path";
+import { readFile, stat } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+
+import {
+  issuePairingChallenge,
+} from "openclaw/plugin-sdk/conversation-runtime";
+import {
+  buildAgentMediaPayload,
+  resolveChannelMediaMaxBytes,
+} from "openclaw/plugin-sdk/media-runtime";
+import {
+  readStoreAllowFromForDmPolicy,
+  resolveDmGroupAccessWithCommandGate,
+} from "openclaw/plugin-sdk/security-runtime";
+import {
+  resolveInboundRouteEnvelopeBuilderWithRuntime,
+} from "openclaw/plugin-sdk/googlechat";
+import {
+  dispatchInboundReplyWithBase,
+} from "openclaw/plugin-sdk/irc";
+
+import {
+  matchAllowedSender,
+  normalizeOneBotUserId,
+  resolveOneBotGroupConfig,
+} from "./config.js";
+import {
+  buildAgentBody,
+  extractAttachments,
+  extractMessageText,
+  extractReplyToId,
+  isAtSelf,
+  makeEventKey,
+} from "./message.js";
+import {
+  enqueueSessionWork,
+  hasSeenEvent,
+  rememberEvent,
+} from "./runtime.js";
+
+const DEFAULT_INBOUND_MEDIA_MAX_BYTES = 20 * 1024 * 1024;
+const CACHED_MEDIA_KINDS = new Set(["image", "video", "audio"]);
+const CONTENT_TYPES_BY_EXTENSION = new Map([
+  [".png", "image/png"],
+  [".jpg", "image/jpeg"],
+  [".jpeg", "image/jpeg"],
+  [".gif", "image/gif"],
+  [".webp", "image/webp"],
+  [".bmp", "image/bmp"],
+  [".mp4", "video/mp4"],
+  [".mov", "video/quicktime"],
+  [".webm", "video/webm"],
+  [".mkv", "video/x-matroska"],
+  [".mp3", "audio/mpeg"],
+  [".wav", "audio/wav"],
+  [".ogg", "audio/ogg"],
+  [".m4a", "audio/mp4"],
+  [".aac", "audio/aac"],
+  [".flac", "audio/flac"],
+  [".amr", "audio/amr"],
+  [".silk", "audio/silk"],
+]);
+
+function hasControlCommand(text) {
+  return String(text ?? "").trim().startsWith("/");
+}
+
+function resolveSessionKey(account, event) {
+  if (event.message_type === "group") {
+    return `${account.accountId}:qq-group:${event.group_id}`;
+  }
+  return `${account.accountId}:qq-private:${normalizeOneBotUserId(event.user_id)}`;
+}
+
+function resolveDefaultReplyToId(event) {
+  const messageId = String(event?.message_id ?? "").trim();
+  return messageId || null;
+}
+
+function buildTargetInfo(event) {
+  const isGroup = event.message_type === "group";
+  const userId = normalizeOneBotUserId(event.user_id);
+  return {
+    chatType: isGroup ? "group" : "private",
+    targetId: String(isGroup ? event.group_id ?? "" : userId).trim(),
+    groupId: isGroup ? String(event.group_id ?? "").trim() || null : null,
+    userId: userId || null,
+    replyToId: resolveDefaultReplyToId(event),
+  };
+}
+
+async function resolveInboundAccess({
+  account,
+  cfg,
+  runtime,
+  event,
+  rawText,
+  wasMentioned,
+  targetInfo,
+  deliver,
+}) {
+  const senderId = normalizeOneBotUserId(event.user_id);
+  const isGroup = event.message_type === "group";
+  if (!senderId) {
+    return { allowed: false, commandAuthorized: false, groupConfig: null };
+  }
+  const groupConfig = isGroup ? resolveOneBotGroupConfig(account, event.group_id) : null;
+  const groupAllowFrom = groupConfig?.allowFrom?.length > 0 ? groupConfig.allowFrom : account.groupAllowFrom;
+  const controlCommand = hasControlCommand(rawText);
+  const allowTextCommands = runtime?.commands?.shouldHandleTextCommands
+    ? runtime.commands.shouldHandleTextCommands({
+        cfg,
+        surface: "onebot-qq",
+        commandSource: "text",
+      })
+    : true;
+  const useAccessGroups = cfg?.commands?.useAccessGroups !== false;
+
+  if (isGroup) {
+    if (groupConfig && groupConfig.enabled === false) {
+      return { allowed: false, commandAuthorized: false, groupConfig };
+    }
+  }
+
+  const storeAllowFrom = runtime?.pairing?.readAllowFromStore
+    ? await readStoreAllowFromForDmPolicy({
+        provider: "onebot-qq",
+        accountId: account.accountId,
+        dmPolicy: account.dmPolicy,
+        readStore: async (provider, accountId) =>
+          await runtime.pairing.readAllowFromStore({
+            channel: provider,
+            accountId,
+          }),
+      })
+    : [];
+
+  const access = resolveDmGroupAccessWithCommandGate({
+    isGroup,
+    dmPolicy: account.dmPolicy,
+    groupPolicy: account.groupPolicy,
+    allowFrom: account.allowFrom,
+    groupAllowFrom,
+    storeAllowFrom,
+    isSenderAllowed: (allowFrom) => matchAllowedSender(senderId, allowFrom),
+    command: {
+      useAccessGroups,
+      allowTextCommands,
+      hasControlCommand: controlCommand,
+    },
+  });
+
+  if (access.decision === "pairing" && !isGroup && runtime?.pairing?.upsertPairingRequest) {
+    const senderName = String(
+      event.sender?.card || event.sender?.nickname || event.sender?.remark || "",
+    ).trim();
+    await issuePairingChallenge({
+      channel: "onebot-qq",
+      senderId,
+      senderIdLine: `Your QQ ID: ${senderId}`,
+      meta: {
+        name: senderName || undefined,
+      },
+      upsertPairingRequest: async ({ id, meta }) =>
+        await runtime.pairing.upsertPairingRequest({
+          channel: "onebot-qq",
+          accountId: account.accountId,
+          id,
+          meta,
+        }),
+      sendPairingReply: async (text) => {
+        await deliver({
+          account,
+          target: targetInfo,
+          payload: {
+            text,
+            replyToId: targetInfo.replyToId,
+          },
+        });
+      },
+    });
+    return { allowed: false, commandAuthorized: false, groupConfig };
+  }
+
+  if (access.decision !== "allow" || access.shouldBlockControlCommand) {
+    return {
+      allowed: false,
+      commandAuthorized: access.commandAuthorized,
+      groupConfig,
+    };
+  }
+
+  if (isGroup) {
+    const requireMention =
+      groupConfig?.requireMention ?? account.requireMention;
+    if (requireMention && !wasMentioned && !(controlCommand && access.commandAuthorized)) {
+      return {
+        allowed: false,
+        commandAuthorized: access.commandAuthorized,
+        groupConfig,
+      };
+    }
+  }
+
+  return {
+    allowed: true,
+    commandAuthorized: access.commandAuthorized,
+    groupConfig,
+  };
+}
+
+function buildContextAddresses(event) {
+  const isGroup = event.message_type === "group";
+  const userId = normalizeOneBotUserId(event.user_id);
+  const groupId = String(event.group_id ?? "").trim();
+  return {
+    from: `onebot-qq:user:${userId}`,
+    to: isGroup ? `onebot-qq:group:${groupId}` : `onebot-qq:private:${userId}`,
+  };
+}
+
+function buildConversationLabel(event) {
+  const nickname = String(
+    event.sender?.card || event.sender?.nickname || event.sender?.remark || event.user_id || "unknown",
+  ).trim();
+  if (event.message_type === "group") {
+    return `QQ Group ${String(event.group_id ?? "").trim()}`;
+  }
+  return nickname || `QQ ${String(event.user_id ?? "").trim()}`;
+}
+
+function buildFirstAttachmentContext(attachments) {
+  const first = attachments[0];
+  if (!first) {
+    return {};
+  }
+  return {
+    MediaType: first.kind,
+    MediaUrl: first.url || undefined,
+  };
+}
+
+function parseAttachmentSizeBytes(value) {
+  const parsed = Number.parseInt(String(value ?? "").trim(), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+}
+
+function isSupportedCachedAttachment(attachment) {
+  return CACHED_MEDIA_KINDS.has(String(attachment?.kind ?? "").trim());
+}
+
+function resolveAttachmentOriginalName(attachment) {
+  const candidate = String(
+    attachment?.name || attachment?.file || attachment?.url || "",
+  ).trim();
+  if (!candidate) {
+    return undefined;
+  }
+  try {
+    if (/^(?:https?|file):\/\//i.test(candidate)) {
+      const fromUrl = path.basename(new URL(candidate).pathname);
+      return fromUrl || undefined;
+    }
+  } catch {
+    // fall through
+  }
+  const basename = path.basename(candidate);
+  return basename || undefined;
+}
+
+function guessAttachmentContentType(attachment, sourceValue = "") {
+  const originalName = resolveAttachmentOriginalName(attachment) ?? String(sourceValue ?? "").trim();
+  const ext = path.extname(originalName).toLowerCase();
+  if (CONTENT_TYPES_BY_EXTENSION.has(ext)) {
+    return CONTENT_TYPES_BY_EXTENSION.get(ext);
+  }
+  if (attachment?.kind === "image") {
+    return "image/jpeg";
+  }
+  if (attachment?.kind === "video") {
+    return "video/mp4";
+  }
+  if (attachment?.kind === "audio") {
+    return "audio/mpeg";
+  }
+  return undefined;
+}
+
+function resolveAttachmentSource(attachment) {
+  const attachmentUrl = String(attachment?.url ?? "").trim();
+  if (/^https?:\/\//i.test(attachmentUrl)) {
+    return { kind: "remote", value: attachmentUrl };
+  }
+  if (attachmentUrl.startsWith("file://")) {
+    return { kind: "local", value: fileURLToPath(new URL(attachmentUrl)) };
+  }
+  if (path.isAbsolute(attachmentUrl)) {
+    return { kind: "local", value: attachmentUrl };
+  }
+
+  const attachmentFile = String(attachment?.file ?? "").trim();
+  if (attachmentFile.startsWith("file://")) {
+    return { kind: "local", value: fileURLToPath(new URL(attachmentFile)) };
+  }
+  if (path.isAbsolute(attachmentFile)) {
+    return { kind: "local", value: attachmentFile };
+  }
+
+  return null;
+}
+
+function buildAttachmentMediaContext(attachments) {
+  const entries = attachments
+    .filter((attachment) => isSupportedCachedAttachment(attachment))
+    .map((attachment) => {
+      const source = resolveAttachmentSource(attachment);
+      const mediaUrl = source?.value || String(attachment?.url ?? "").trim();
+      if (!mediaUrl) {
+        return null;
+      }
+      return {
+        url: mediaUrl,
+        contentType: guessAttachmentContentType(attachment, mediaUrl),
+      };
+    })
+    .filter(Boolean);
+
+  if (entries.length === 0) {
+    return buildFirstAttachmentContext(attachments);
+  }
+
+  return {
+    MediaUrl: entries[0]?.url,
+    MediaUrls: entries.map((entry) => entry.url),
+    MediaType: entries[0]?.contentType,
+    MediaTypes: entries
+      .map((entry) => entry.contentType)
+      .filter(Boolean),
+  };
+}
+
+async function cacheInboundAttachments({
+  account,
+  cfg,
+  runtime,
+  attachments,
+  log,
+}) {
+  if (!runtime?.media?.saveMediaBuffer || attachments.length === 0) {
+    return [];
+  }
+
+  const maxBytes = resolveChannelMediaMaxBytes({
+    cfg,
+    accountId: account.accountId,
+    resolveChannelLimitMb: ({ cfg, accountId }) =>
+      cfg.channels?.["onebot-qq"]?.accounts?.[accountId]?.mediaMaxMb ??
+      cfg.channels?.["onebot-qq"]?.mediaMaxMb,
+  }) ?? DEFAULT_INBOUND_MEDIA_MAX_BYTES;
+
+  const cached = [];
+  for (const attachment of attachments) {
+    if (!isSupportedCachedAttachment(attachment)) {
+      continue;
+    }
+
+    const source = resolveAttachmentSource(attachment);
+    if (!source) {
+      continue;
+    }
+
+    const advertisedSize = parseAttachmentSizeBytes(attachment.fileSize);
+    if (advertisedSize && advertisedSize > maxBytes) {
+      log?.debug?.(
+        `onebot-qq: skip inbound media cache (${attachment.kind}) size=${advertisedSize} > maxBytes=${maxBytes}`,
+      );
+      continue;
+    }
+
+    try {
+      let buffer;
+      let contentType;
+      let originalFilename = resolveAttachmentOriginalName(attachment);
+
+      if (source.kind === "remote") {
+        if (!runtime.media.fetchRemoteMedia) {
+          continue;
+        }
+        const fetched = await runtime.media.fetchRemoteMedia({
+          url: source.value,
+          maxBytes,
+          filePathHint: originalFilename,
+        });
+        buffer = fetched.buffer;
+        contentType = fetched.contentType ?? guessAttachmentContentType(attachment, source.value);
+        originalFilename ||= fetched.fileName;
+      } else {
+        const stats = await stat(source.value);
+        if (stats.size > maxBytes) {
+          log?.debug?.(
+            `onebot-qq: skip inbound local media cache (${attachment.kind}) size=${stats.size} > maxBytes=${maxBytes}`,
+          );
+          continue;
+        }
+        buffer = await readFile(source.value);
+        contentType = guessAttachmentContentType(attachment, source.value);
+        originalFilename ||= path.basename(source.value) || undefined;
+      }
+
+      const saved = await runtime.media.saveMediaBuffer(
+        Buffer.from(buffer),
+        contentType,
+        "inbound",
+        maxBytes,
+        originalFilename,
+      );
+      cached.push({
+        path: saved.path,
+        contentType: saved.contentType ?? contentType ?? undefined,
+      });
+    } catch (error) {
+      log?.debug?.(`onebot-qq: inbound media cache failed (${attachment.kind}): ${String(error)}`);
+    }
+  }
+
+  return cached;
+}
+
+export async function handleOneBotInboundMessage({
+  account,
+  cfg,
+  runtime,
+  event,
+  selfId,
+  deliver,
+  log,
+  onStatus,
+}) {
+  if (!runtime) {
+    log?.error?.("onebot-qq: channelRuntime is unavailable; inbound message skipped");
+    return;
+  }
+
+  if (event?.post_type !== "message") {
+    return;
+  }
+
+  const eventKey = makeEventKey(account.accountId, event);
+  if (hasSeenEvent(eventKey)) {
+    return;
+  }
+  rememberEvent(eventKey);
+
+  if (selfId && String(event.user_id ?? "") === String(selfId)) {
+    return;
+  }
+
+  const text = extractMessageText(event, selfId);
+  const attachments = extractAttachments(event);
+  if (!text && attachments.length === 0) {
+    return;
+  }
+
+  const targetInfo = buildTargetInfo(event);
+  const wasMentioned = event.message_type === "group" ? isAtSelf(event, selfId) : false;
+  const access = await resolveInboundAccess({
+    account,
+    cfg,
+    runtime,
+    event,
+    rawText: text,
+    wasMentioned,
+    targetInfo,
+    deliver,
+  });
+  if (!access.allowed) {
+    return;
+  }
+
+  const sessionKey = resolveSessionKey(account, event);
+
+  try {
+    await enqueueSessionWork(sessionKey, async () => {
+      onStatus?.({ lastInboundAt: Date.now() });
+
+      const senderName = String(
+        event.sender?.card || event.sender?.nickname || event.sender?.remark || "",
+      ).trim();
+      const senderId = normalizeOneBotUserId(event.user_id);
+      const channelRuntime = runtime;
+      const cachedMedia = await cacheInboundAttachments({
+        account,
+        cfg,
+        runtime: channelRuntime,
+        attachments,
+        log,
+      });
+      const agentBody = buildAgentBody(text, attachments);
+      const bodyForAgent = agentBody || text || "[empty]";
+      const peer = targetInfo.chatType === "group"
+        ? { kind: "group", id: targetInfo.groupId }
+        : { kind: "direct", id: targetInfo.userId };
+
+      const { route, buildEnvelope } = resolveInboundRouteEnvelopeBuilderWithRuntime({
+        cfg,
+        channel: "onebot-qq",
+        accountId: account.accountId,
+        peer,
+        runtime: channelRuntime,
+        sessionStore: cfg.session?.store,
+      });
+
+      const { storePath, body } = buildEnvelope({
+        channel: "QQ",
+        from: buildConversationLabel(event),
+        timestamp: Number.isFinite(event.time) ? Number(event.time) * 1000 : Date.now(),
+        body: bodyForAgent,
+      });
+
+      const addresses = buildContextAddresses(event);
+      const ctxPayload = channelRuntime.reply.finalizeInboundContext({
+        Body: body,
+        BodyForAgent: bodyForAgent,
+        RawBody: text || bodyForAgent,
+        CommandBody: text || "",
+        From: addresses.from,
+        To: addresses.to,
+        SessionKey: route.sessionKey,
+        AccountId: route.accountId ?? account.accountId,
+        ChatType: targetInfo.chatType === "group" ? "group" : "direct",
+        ConversationLabel: buildConversationLabel(event),
+        SenderName: senderName || undefined,
+        SenderId: senderId,
+        WasMentioned: targetInfo.chatType === "group" ? wasMentioned : undefined,
+        CommandAuthorized: access.commandAuthorized,
+        Provider: "onebot-qq",
+        Surface: "onebot-qq",
+        MessageSid: String(event.message_id ?? ""),
+        MessageSidFull: String(event.message_id ?? ""),
+        ReplyToId: extractReplyToId(event),
+        ReplyToIdFull: extractReplyToId(event),
+        GroupSubject:
+          targetInfo.chatType === "group" && targetInfo.groupId
+            ? `QQ Group ${targetInfo.groupId}`
+            : undefined,
+        GroupSystemPrompt:
+          targetInfo.chatType === "group" ? access.groupConfig?.systemPrompt : undefined,
+        OriginatingChannel: "onebot-qq",
+        OriginatingTo: addresses.to,
+        ...buildAttachmentMediaContext(attachments),
+        ...buildAgentMediaPayload(cachedMedia),
+      });
+
+      try {
+        await dispatchInboundReplyWithBase({
+          cfg,
+          channel: "onebot-qq",
+          accountId: account.accountId,
+          route,
+          storePath,
+          ctxPayload,
+          core: { channel: channelRuntime },
+          deliver: async (payload) => {
+            await deliver({
+              account,
+              target: targetInfo,
+              payload,
+            });
+            onStatus?.({ lastOutboundAt: Date.now() });
+          },
+          onRecordError: (error) => {
+            log?.error?.(`onebot-qq: failed updating session meta: ${String(error)}`);
+          },
+          onDispatchError: (error, info) => {
+            log?.error?.(`onebot-qq ${info.kind} reply failed: ${String(error)}`);
+          },
+        });
+      } catch (error) {
+        log?.error?.(`onebot-qq: inbound dispatch failed: ${String(error)}`);
+        throw error;
+      }
+    });
+  } catch (error) {
+    log?.error?.(`onebot-qq: session work failed: ${String(error)}`);
+  }
+}