luckytri 1.0.0

package/server/channels/qqbot/index.js

@@ -0,0 +1,389 @@
+import { WebSocket } from "ws";
+import { defineChannel } from "../contract.js";
+import { parseSessionKey } from "../session-key.js";
+import { channelState } from "../state.js";
+import { QQBotApi, QQBotError } from "./api.js";
+import { qqbotCredentials } from "./credentials.js";
+import {
+  isPlaceholderName,
+  normalize,
+  openidOf,
+  qqbot,
+  quotedElement,
+  quotedMessage,
+} from "./adapter.js";
+import { QQBotGateway } from "./gateway.js";
+
+// The platform's windows for answering a message without it counting as a
+// proactive one. A little margin is kept off both so a late reply is sent as a
+// proactive message instead of being refused.
+const WINDOW = { group: 5 * 60000 - 15000, private: 60 * 60000 - 60000 };
+const REPLIES = { group: 5, private: 4 };
+const WAKEUP_EVERY = 30 * 86400000;
+const REMEMBER = 2000;
+
+// Answers that mean the message id cannot be used (any more) as a passive reply.
+const EXPIRED = new Set([304103, 40034005, 40034128, 40034024]);
+// The person or room has not allowed proactive messages.
+const NOT_ALLOWED = new Set([40034105]);
+const EXPLAIN = new Map([
+  [40034100, "主动消息太频繁，平台暂时限制了发送"],
+  [40034105, "对方或这个群没有开启机器人的主动消息"],
+  [40034101, "机器人已不在这个群里"],
+  [40054003, "机器人已不在这个群里"],
+  [40054002, "机器人在这个群里被禁言"],
+  [40054007, "消息太长，平台没有接收"],
+  [40054010, "平台不允许发送链接"],
+  [40034006, "消息内容没有通过平台审核"],
+  [40054016, "机器人已下线，请检查机器人状态"],
+]);
+
+function bounded(map, key, value, limit = REMEMBER) {
+  map.set(key, value);
+  while (map.size > limit) map.delete(map.keys().next().value);
+}
+
+// The QQ 开放平台 channel: she connects out to the platform's gateway with an
+// AppID and AppSecret, instead of waiting for a OneBot client to connect in.
+// Everything above the channel is shared with OneBot.
+export function createQqBotChannel(
+  store,
+  {
+    fetch,
+    WebSocketImpl = WebSocket,
+    now = Date.now,
+    apiBase,
+    tokenUrls,
+    backoff,
+    timeoutMs,
+    env = process.env,
+  } = {},
+) {
+  const state = channelState(store.db);
+  const seen = new Map();
+  const passive = new Map();
+  const latest = new Map();
+  const quotes = new Map();
+  const botRefs = new Set();
+  const names = new Map();
+  let chat = null;
+  let api = null;
+  let gateway = null;
+  let creds = qqbotCredentials(store, env);
+  let signature = "";
+  let connection = { state: "idle", error: "" };
+  let botId = "";
+  let botName = "";
+  let connectedAt = null;
+  let lastEventAt = null;
+  let lastDisconnectAt = null;
+  let sawAllGroupMessages = false;
+  let sawAtOnlyGroupMessages = false;
+
+  const key = (kind, id) => `${kind}:${creds.appId}:${id}`;
+
+  function knownName(person) {
+    if (names.has(person)) return names.get(person);
+    let name = "";
+    try {
+      const row = store.db
+        .prepare(
+          "SELECT json_extract(payload,'$.name') name FROM core_events WHERE role='user' AND json_extract(payload,'$.userId')=? ORDER BY seq DESC LIMIT 20",
+        )
+        .all(person)
+        .find((item) => item.name && !isPlaceholderName(item.name));
+      name = row?.name || "";
+    } catch {
+      /* The core tables may not exist yet. */
+    }
+    names.set(person, name);
+    return name;
+  }
+
+  function roomOf(type, d) {
+    if (type.startsWith("GROUP_") && d?.group_openid)
+      return `qqbot:${creds.appId}:group:${d.group_openid}`;
+    const openid = String(d?.openid || "");
+    if (!openid) return "";
+    const person = state.get(key("person", openid)) || openid;
+    return `qqbot:${creds.appId}:private:${person}`;
+  }
+
+  function permission(type, d) {
+    const room = roomOf(type, d);
+    if (!room) return;
+    if (/_(REJECT|DEL_ROBOT|DEL)$/.test(type))
+      state.set(key("closed", room), type);
+    else state.delete(key("closed", room));
+  }
+
+  function inbound(type, d) {
+    const id = String(d?.id ?? "");
+    if (!id || seen.has(id)) return;
+    bounded(seen, id, true);
+    const person = String(d?.author?.union_openid || "");
+    const message = normalize(type, d, {
+      appId: creds.appId,
+      botId,
+      botRefs,
+      knownName,
+    });
+    if (!message) return;
+    if (
+      type === "GROUP_MESSAGE_CREATE" &&
+      !(d.mentions || []).some((u) => u?.is_you)
+    )
+      sawAllGroupMessages = true;
+    if (type === "GROUP_AT_MESSAGE_CREATE") sawAtOnlyGroupMessages = true;
+    const openid = openidOf(type, d);
+    if (message.kind === "private" && person && person !== openid) {
+      state.set(key("openid", message.userId), openid);
+      state.set(key("person", openid), message.userId);
+    }
+    if (d.author?.username && !isPlaceholderName(message.name))
+      names.set(message.userId, message.name);
+    const entry = {
+      msgId: id,
+      session: message.sessionId,
+      kind: message.kind,
+      at: now(),
+      seq: 0,
+      expired: false,
+    };
+    bounded(passive, message.platformId, entry);
+    if (message.platformId !== id) bounded(passive, id, entry);
+    latest.set(message.sessionId, entry);
+    if (message.replyId) {
+      const element = quotedElement(d, message.replyId);
+      if (element) bounded(quotes, message.replyId, element);
+    }
+    chat?.receive(message);
+  }
+
+  function onDispatch(type, d) {
+    lastEventAt = now();
+    switch (type) {
+      case "GROUP_AT_MESSAGE_CREATE":
+      case "GROUP_MESSAGE_CREATE":
+      case "C2C_MESSAGE_CREATE":
+        return inbound(type, d);
+      case "C2C_MSG_REJECT":
+      case "C2C_MSG_RECEIVE":
+      case "GROUP_MSG_REJECT":
+      case "GROUP_MSG_RECEIVE":
+      case "GROUP_ADD_ROBOT":
+      case "GROUP_DEL_ROBOT":
+      case "FRIEND_ADD":
+      case "FRIEND_DEL":
+        return permission(type, d);
+      default:
+    }
+  }
+
+  function onState(next) {
+    if (next.state === "ready") {
+      botId = String(next.user?.id || botId || "");
+      botName = String(next.user?.username || botName || "");
+      connectedAt = now();
+      connection = { state: "ready", error: "" };
+    } else if (next.state === "closed") {
+      lastDisconnectAt = now();
+      connection = { state: "closed", error: connection.error };
+    } else if (next.state === "error") {
+      connection = { state: "error", error: next.error || "" };
+      if (next.fatal) lastDisconnectAt = now();
+    } else connection = { state: next.state, error: "" };
+  }
+
+  function usable(entry, kind) {
+    return (
+      !!entry &&
+      !entry.expired &&
+      now() - entry.at < WINDOW[kind] &&
+      entry.seq < REPLIES[kind]
+    );
+  }
+
+  function passiveFor(message, kind) {
+    const direct = passive.get(String(message.platformId || ""));
+    if (direct?.session === message.sessionId && usable(direct, kind))
+      return direct;
+    const recent = latest.get(message.sessionId);
+    return usable(recent, kind) ? recent : null;
+  }
+
+  function explain(error) {
+    if (error instanceof QQBotError && EXPLAIN.has(error.code))
+      error.message = EXPLAIN.get(error.code);
+    return error;
+  }
+
+  async function sendActive(post, route, body, session) {
+    try {
+      return await post(body);
+    } catch (error) {
+      if (NOT_ALLOWED.has(error?.code)) {
+        state.set(key("closed", session), "NOT_ALLOWED");
+        // One recall message per person each cycle is the platform's own
+        // way back to someone who has stopped hearing from her.
+        const wakeKey = key("wakeup", route.nativeId);
+        const last = Number(state.get(wakeKey, 0));
+        if (route.kind === "private" && now() - last > WAKEUP_EVERY) {
+          state.set(wakeKey, now());
+          try {
+            return await post({ ...body, is_wakeup: true });
+          } catch (again) {
+            throw explain(again);
+          }
+        }
+      }
+      throw explain(error);
+    }
+  }
+
+  async function send(message, text) {
+    if (message.simulated) return { message_id: "sim" };
+    if (!gateway?.ready || !api) throw new Error("QQ 官方机器人尚未连接");
+    const route = parseSessionKey(message.sessionId);
+    if (route.channel !== "qqbot" || route.accountId !== creds.appId)
+      throw new Error("这个会话不属于当前连接的 QQ 官方机器人");
+    const to =
+      route.kind === "group"
+        ? route.nativeId
+        : state.get(key("openid", route.nativeId)) || route.nativeId;
+    const post = (body) =>
+      route.kind === "group" ? api.sendGroup(to, body) : api.sendUser(to, body);
+    const body = { msg_type: 0, content: text };
+    let result = null;
+    const anchor = passiveFor(message, route.kind);
+    if (anchor) {
+      // The sequence number is spent before the request: if the answer never
+      // comes, the same number can never be sent twice.
+      anchor.seq += 1;
+      try {
+        result = await post({
+          ...body,
+          msg_id: anchor.msgId,
+          msg_seq: anchor.seq,
+        });
+      } catch (error) {
+        if (!EXPIRED.has(error?.code)) throw explain(error);
+        anchor.expired = true;
+      }
+    }
+    result ||= await sendActive(post, route, body, message.sessionId);
+    const ref = String(result?.ext_info?.ref_idx || "");
+    if (ref) {
+      botRefs.add(ref);
+      while (botRefs.size > REMEMBER)
+        botRefs.delete(botRefs.values().next().value);
+    }
+    return { message_id: ref || String(result?.id || ""), id: result?.id };
+  }
+
+  async function fetchQuoted(message) {
+    const element = quotes.get(String(message.replyId || ""));
+    return element ? quotedMessage(message, element, { botId, botRefs }) : null;
+  }
+
+  function canReach(sessionId) {
+    if (!gateway?.ready) return false;
+    let route;
+    try {
+      route = parseSessionKey(sessionId);
+    } catch {
+      return false;
+    }
+    if (route.channel !== "qqbot" || route.accountId !== creds.appId)
+      return false;
+    if (usable(latest.get(sessionId), route.kind)) return true;
+    return !state.get(key("closed", sessionId));
+  }
+
+  function stopConnection() {
+    gateway?.stop();
+    gateway = null;
+    api = null;
+    signature = "";
+    connection = { state: "idle", error: "" };
+  }
+
+  function start() {
+    creds = qqbotCredentials(store, env);
+    if (!creds.appId || !creds.secret) {
+      stopConnection();
+      connection = { state: "unconfigured", error: "" };
+      return;
+    }
+    const next = `${creds.appId}\n${creds.secret}`;
+    if (gateway && next === signature) return gateway.start();
+    stopConnection();
+    signature = next;
+    botId = "";
+    botName = "";
+    api = new QQBotApi({
+      appId: creds.appId,
+      secret: creds.secret,
+      fetch,
+      apiBase,
+      tokenUrls,
+      now,
+      timeoutMs,
+    });
+    gateway = new QQBotGateway({
+      api,
+      onDispatch,
+      onState,
+      WebSocketImpl,
+      now,
+      backoff,
+    });
+    gateway.start();
+  }
+
+  function status() {
+    const current = qqbotCredentials(store, env);
+    return {
+      type: "qqbot",
+      online: !!gateway?.ready,
+      configured: !!(current.appId && current.secret),
+      appId: current.appId,
+      secretConfigured: !!current.secret,
+      appIdFromEnv: current.appIdFromEnv,
+      secretFromEnv: current.secretFromEnv,
+      state: connection.state,
+      error: connection.error,
+      botName,
+      connectedAt,
+      lastEventAt,
+      lastDisconnectAt,
+      // What the platform has actually delivered. Without "receive all
+      // messages" switched on in the platform's console, only messages that
+      // mention her arrive.
+      groupMessages: sawAllGroupMessages
+        ? "all"
+        : sawAtOnlyGroupMessages
+          ? "mentions"
+          : "unknown",
+      closedRooms: state.list(`closed:${current.appId}:`).length,
+      adminProtected: !!env.ADMIN_TOKEN,
+    };
+  }
+
+  return defineChannel({
+    type: "qqbot",
+    capabilities: qqbot.capabilities,
+    attach(_server, chatSystem) {
+      chat = chatSystem;
+    },
+    start,
+    stop: stopConnection,
+    send,
+    fetchQuoted,
+    fetchImage: async () => null,
+    refreshDirectory: async () => 0,
+    canReach,
+    status,
+    close: stopConnection,
+  });
+}

package/server/channels/segments.js

@@ -0,0 +1,40 @@
+// What a list of OneBot-style message segments says: who is mentioned, which
+// message is quoted, and which attachments came along. The OneBot adapter uses
+// it to fill the neutral message; `messageEnvelope` falls back to it for events
+// that were saved before adapters filled those fields themselves.
+const ATTACHMENT_TYPES = new Set([
+  "image",
+  "mface",
+  "market_face",
+  "sticker",
+  "file",
+  "video",
+  "record",
+  "face",
+]);
+
+export function segmentFacts(segments = []) {
+  const list = Array.isArray(segments) ? segments : [];
+  return {
+    mentions: list
+      .filter((s) => String(s?.type || "").toLowerCase() === "at")
+      .map((s) => {
+        const id = s.data?.qq ?? s.data?.user_id;
+        return id == null || id === "" ? "" : String(id);
+      })
+      .filter(Boolean),
+    replyId: String(list.find((s) => s?.type === "reply")?.data?.id || ""),
+    attachments: list
+      .filter((s) => ATTACHMENT_TYPES.has(s?.type))
+      .map((s) => ({
+        type: s.type,
+        ...s.data,
+        // QQ's built-in faces carry their readable name inside raw. Keep it
+        // alongside the placeholder so a reaction is not reduced to [表情].
+        summary: String(s.data?.summary || s.data?.raw?.faceText || "").slice(
+          0,
+          80,
+        ),
+      })),
+  };
+}

package/server/channels/session-key.js

@@ -0,0 +1,153 @@
+const KINDS = new Set(["group", "private"]);
+
+export function formatSessionKey({
+  channel = "onebot",
+  accountId = "_",
+  kind,
+  nativeId,
+}) {
+  if (!KINDS.has(kind) || nativeId == null || String(nativeId) === "")
+    throw Error("会话身份不完整");
+  return `${channel}:${accountId || "_"}:${kind}:${nativeId}`;
+}
+
+export function parseSessionKey(id) {
+  const raw = String(id || "");
+  const parts = raw.split(":");
+  if (parts.length === 2 && KINDS.has(parts[0]) && parts[1])
+    return {
+      channel: "onebot",
+      accountId: "_",
+      kind: parts[0],
+      nativeId: parts[1],
+      legacy: true,
+      id: raw,
+    };
+  if (parts.length >= 4 && KINDS.has(parts[2]) && parts[3])
+    return {
+      channel: parts[0],
+      accountId: parts[1] || "_",
+      kind: parts[2],
+      nativeId: parts.slice(3).join(":"),
+      legacy: false,
+      id: raw,
+    };
+  throw Error("会话 ID 无效");
+}
+
+export function sessionKind(id) {
+  return parseSessionKey(id).kind;
+}
+
+export function sessionNativeId(id) {
+  return parseSessionKey(id).nativeId;
+}
+
+export function sessionAliases(id) {
+  const parsed = parseSessionKey(id);
+  // The short `group:<id>` forms are how OneBot rooms were keyed before keys
+  // carried a channel; no other channel ever used them.
+  if (parsed.channel !== "onebot")
+    return [...new Set([id, formatSessionKey(parsed)])];
+  return [
+    ...new Set([
+      id,
+      formatSessionKey(parsed),
+      `${parsed.kind}:${parsed.nativeId}`,
+      formatSessionKey({ ...parsed, accountId: "_" }),
+    ]),
+  ];
+}
+
+export function scopedSessionAliases(db, id) {
+  const aliases = sessionAliases(id);
+  try {
+    const parsed = parseSessionKey(id);
+    if (
+      parsed.legacy ||
+      parsed.channel !== "onebot" ||
+      parsed.accountId === "_" ||
+      parsed.kind !== "group"
+    )
+      return aliases;
+    const legacy = `${parsed.kind}:${parsed.nativeId}`;
+    const accounts = db
+      .prepare(
+        "SELECT DISTINCT account_id FROM core_events WHERE session_id=? AND account_id IS NOT NULL AND account_id!=''",
+      )
+      .all(legacy)
+      .map((row) => String(row.account_id));
+    if (
+      accounts.length &&
+      accounts.some((account) => account !== parsed.accountId)
+    )
+      return aliases.filter(
+        (alias) =>
+          alias !== legacy &&
+          alias !== formatSessionKey({ ...parsed, accountId: "_" }),
+      );
+  } catch {
+    /* Keep the broad legacy aliases for malformed or pre-core databases. */
+  }
+  return aliases;
+}
+
+export function isGroupSession(id) {
+  try {
+    return parseSessionKey(id).kind === "group";
+  } catch {
+    return String(id).startsWith("group:");
+  }
+}
+
+export function bindSessionId(db, sessionId) {
+  const parsed = parseSessionKey(sessionId);
+  const aliases = sessionAliases(sessionId);
+  const placeholders = aliases.map(() => "?").join(",");
+  const requested = parsed.accountId;
+  const keepAccountScope = (id) => {
+    // Legacy `group:<id>` rows predate account-qualified channels. Reuse one
+    // only for the account that already owns its events; a second bot account
+    // gets its own canonical session instead of silently sharing memory.
+    if (
+      parsed.channel !== "onebot" ||
+      parsed.legacy ||
+      id !== `${parsed.kind}:${parsed.nativeId}`
+    )
+      return id;
+    const accounts = db
+      .prepare(
+        "SELECT DISTINCT account_id FROM core_events WHERE session_id=? AND account_id IS NOT NULL AND account_id!=''",
+      )
+      .all(id)
+      .map((row) => String(row.account_id));
+    return accounts.length && !accounts.includes(requested)
+      ? formatSessionKey(parsed)
+      : id;
+  };
+  const session = db
+    .prepare(`SELECT id FROM sessions WHERE id IN (${placeholders}) LIMIT 1`)
+    .get(...aliases);
+  if (session) return keepAccountScope(session.id);
+  const event = db
+    .prepare(
+      `SELECT session_id AS id FROM core_events WHERE session_id IN (${placeholders}) LIMIT 1`,
+    )
+    .get(...aliases);
+  if (event) return keepAccountScope(event.id);
+  const message = db
+    .prepare(
+      `SELECT session_id AS id FROM messages WHERE session_id IN (${placeholders}) LIMIT 1`,
+    )
+    .get(...aliases);
+  if (message) return keepAccountScope(message.id);
+  return parsed.legacy ? parsed.id : formatSessionKey(parsed);
+}
+
+export function publicSession(row) {
+  try {
+    return { ...row, ...parseSessionKey(row.id) };
+  } catch {
+    return { ...row, channel: "onebot", accountId: "_", nativeId: row.id };
+  }
+}

package/server/channels/state.js

@@ -0,0 +1,42 @@
+// Small durable memory for a channel: which rooms switched proactive messages
+// off, which openid belongs to which person. It lives in the same database as
+// everything else, so backups and recovery carry it along.
+export function channelState(db) {
+  db.exec(
+    "CREATE TABLE IF NOT EXISTS channel_state (key TEXT PRIMARY KEY, value TEXT NOT NULL, time INTEGER NOT NULL)",
+  );
+  const read = db.prepare("SELECT value FROM channel_state WHERE key=?");
+  const write = db.prepare(
+    "INSERT INTO channel_state(key,value,time) VALUES (?,?,?) ON CONFLICT(key) DO UPDATE SET value=excluded.value,time=excluded.time",
+  );
+  const remove = db.prepare("DELETE FROM channel_state WHERE key=?");
+  const cache = new Map();
+  return {
+    get(key, fallback = null) {
+      if (cache.has(key)) return cache.get(key) ?? fallback;
+      const row = read.get(key);
+      const value = row ? row.value : null;
+      cache.set(key, value);
+      return value ?? fallback;
+    },
+    set(key, value, now = Date.now()) {
+      const text = String(value);
+      if (cache.get(key) === text) return false;
+      write.run(key, text, now);
+      cache.set(key, text);
+      return true;
+    },
+    delete(key) {
+      cache.delete(key);
+      remove.run(key);
+    },
+    // Rows whose key starts with `prefix`, for rebuilding in-memory sets.
+    list(prefix) {
+      return db
+        .prepare(
+          "SELECT key,value,time FROM channel_state WHERE substr(key,1,?)=?",
+        )
+        .all(prefix.length, prefix);
+    },
+  };
+}