luckytri 1.0.0

package/server/channels/hub.js

@@ -0,0 +1,165 @@
+import { parseSessionKey } from "./session-key.js";
+
+export const CHANNEL_TYPES = ["onebot", "qqbot"];
+
+// Which channel is wanted: the environment wins over the saved setting, the
+// same way LLM_API_KEY wins over a key saved in the studio.
+export function selectedChannel(store, env = process.env) {
+  const forced = String(env.LUCKYTRI_CHANNEL || "")
+    .trim()
+    .toLowerCase();
+  if (CHANNEL_TYPES.includes(forced)) return { type: forced, locked: true };
+  const saved = String(store.settings().channel || "");
+  return {
+    type: CHANNEL_TYPES.includes(saved) ? saved : "onebot",
+    locked: false,
+  };
+}
+
+// Exactly one channel is connected at a time. Everything above the hub talks
+// to it as if it were the channel itself, so the core, her mind and her life
+// are the same whichever platform she is on; switching is a setting, not a
+// restart.
+const QQ = new Set(CHANNEL_TYPES);
+
+export function createChannelHub(store, channels, { env = process.env } = {}) {
+  const registry = new Map(channels.map((channel) => [channel.type, channel]));
+  if (!registry.size) throw new Error("channel hub needs at least one channel");
+  let active = null;
+  let locked = false;
+  let attached = null;
+  // Plugin channels stay connected beside the one QQ channel in use.
+  const started = new Set();
+
+  const current = () => registry.get(active) || registry.values().next().value;
+
+  function resolve(sessionId) {
+    let type = active;
+    if (sessionId) {
+      try {
+        type = parseSessionKey(sessionId).channel;
+      } catch {
+        /* A session without a channel key is spoken to over the active one. */
+      }
+    }
+    if (QQ.has(type) && type !== active)
+      throw new Error("这个会话属于另一种 QQ 接入方式，当前不能向它发送");
+    const channel = registry.get(type);
+    if (!channel || (!QQ.has(type) && !started.has(type)))
+      throw new Error("这个会话的通道没有接上");
+    return channel;
+  }
+
+  // Bring the connected channel in line with the settings. Cheap when nothing
+  // changed, so it is also what runs after the credentials are edited.
+  function sync() {
+    const wanted = selectedChannel(store, env);
+    const type = registry.has(wanted.type)
+      ? wanted.type
+      : registry.keys().next().value;
+    locked = wanted.locked;
+    if (active && active !== type) registry.get(active).stop();
+    const switched = active !== type;
+    active = type;
+    registry.get(type).start();
+    if (switched)
+      registry
+        .get(type)
+        .refreshDirectory()
+        .catch(() => {});
+    return type;
+  }
+
+  function attach(server, chat) {
+    attached = { server, chat };
+    for (const channel of registry.values()) channel.attach(server, chat);
+    for (const type of started) registry.get(type)?.start();
+    sync();
+  }
+
+  function register(channel) {
+    if (!channel?.type || QQ.has(channel.type) || registry.has(channel.type))
+      throw new Error("这个通道不能接上");
+    registry.set(channel.type, channel);
+    started.add(channel.type);
+    if (attached) {
+      channel.attach(attached.server, attached.chat);
+      channel.start();
+    }
+    return channel.type;
+  }
+
+  function unregister(type) {
+    if (QQ.has(type) || !registry.has(type)) return false;
+    started.delete(type);
+    const channel = registry.get(type);
+    try {
+      channel.stop();
+      channel.close();
+    } catch {
+      /* A plugin channel that already died should still leave the hub. */
+    }
+    registry.delete(type);
+    return true;
+  }
+
+  const send = async (message, text) => {
+    if (message?.simulated) return { message_id: "sim" };
+    return resolve(message.sessionId).send(message, text);
+  };
+
+  function canReach(sessionId) {
+    try {
+      return resolve(sessionId).canReach(sessionId);
+    } catch {
+      return false;
+    }
+  }
+
+  function status() {
+    const channel = current();
+    const own = channel.status();
+    const all = {};
+    for (const item of registry.values()) all[item.type] = item.status();
+    return {
+      channel: channel.type,
+      locked,
+      online: !!own.online,
+      connectedAt: own.connectedAt ?? null,
+      lastEventAt: own.lastEventAt ?? null,
+      lastDisconnectAt: own.lastDisconnectAt ?? null,
+      adminProtected: !!env.ADMIN_TOKEN,
+      port: Number(env.PORT || 3210),
+      capabilities: channel.capabilities,
+      ...all,
+    };
+  }
+
+  return {
+    attach,
+    sync,
+    register,
+    unregister,
+    send,
+    canReach,
+    status,
+    type: () => current().type,
+    online: () =>
+      !!current().status().online ||
+      [...started].some((type) => registry.get(type)?.status().online),
+    fetchQuoted: (message) =>
+      (message?.sessionId ? resolve(message.sessionId) : current()).fetchQuoted(
+        message,
+      ),
+    fetchImage: (file, sessionId) =>
+      (sessionId ? resolve(sessionId) : current()).fetchImage(file),
+    fetchMedia: (file, sessionId, type) => {
+      const channel = sessionId ? resolve(sessionId) : current();
+      return channel.fetchMedia ? channel.fetchMedia(file, type) : null;
+    },
+    refreshDirectory: () => current().refreshDirectory(),
+    close() {
+      for (const channel of registry.values()) channel.close();
+    },
+  };
+}

package/server/channels/index.js

@@ -0,0 +1,25 @@
+import { createOneBotChannel } from "./onebot/index.js";
+import { createQqBotChannel } from "./qqbot/index.js";
+
+// Adding a platform: write a folder that fulfils channels/contract.js, give its
+// adapter an entry in adapters.js (so the core can ask what its media links
+// look like) and its factory a line in createChannels. Nothing above the hub
+// changes.
+export function createChannels(store, options = {}) {
+  return [createOneBotChannel(store), createQqBotChannel(store, options.qqbot)];
+}
+
+export { createChannelHub, selectedChannel, CHANNEL_TYPES } from "./hub.js";
+export { defineChannel } from "./contract.js";
+export { adapterFor, registerChannel, onebot, qqbot } from "./adapters.js";
+export {
+  bindSessionId,
+  formatSessionKey,
+  isGroupSession,
+  parseSessionKey,
+  publicSession,
+  sessionAliases,
+  sessionKind,
+  sessionNativeId,
+} from "./session-key.js";
+export { normalize } from "./onebot/adapter.js";

package/server/channels/onebot/adapter.js

@@ -0,0 +1,288 @@
+import { formatSessionKey, parseSessionKey } from "../session-key.js";
+import { segmentFacts } from "../segments.js";
+
+const CQ_ESCAPES = {
+  ",": ",",
+  "[": "[",
+  "]": "]",
+  "&": "&",
+};
+const decodeCq = (value) =>
+  String(value).replace(
+    /,|[|]|&/g,
+    (token) => CQ_ESCAPES[token],
+  );
+
+function parseCqMessage(raw) {
+  const source = String(raw || ""),
+    segments = [],
+    pattern = /\[CQ:([^,\]]+)((?:,[^\]]*)?)\]/g;
+  let cursor = 0,
+    match;
+  while ((match = pattern.exec(source))) {
+    if (match.index > cursor)
+      segments.push({
+        type: "text",
+        data: { text: source.slice(cursor, match.index) },
+      });
+    const data = {};
+    for (const item of match[2].replace(/^,/, "").split(",")) {
+      if (!item) continue;
+      const [key, ...parts] = item.split("=");
+      if (key) data[key] = decodeCq(parts.join("="));
+    }
+    segments.push({ type: match[1], data });
+    cursor = pattern.lastIndex;
+  }
+  if (cursor < source.length)
+    segments.push({ type: "text", data: { text: source.slice(cursor) } });
+  return segments.length
+    ? segments
+    : [{ type: "text", data: { text: source } }];
+}
+
+const stickerTypes = new Set([
+  "face",
+  "mface",
+  "market_face",
+  "bface",
+  "sface",
+  "sticker",
+  "dice",
+  "rps",
+  "poke",
+]);
+export function senderLabel(sender, userId) {
+  const id = String(userId ?? "");
+  const values = [sender?.card, sender?.nickname, sender?.nick]
+    .map((value) => String(value || "").trim())
+    .filter(Boolean);
+  const readable = values.find(
+    (value) => value !== id && !/^\d{4,20}$/.test(value),
+  );
+  return (readable || values.find((value) => value !== id) || id).slice(0, 100);
+}
+
+export const isSticker = (segment) =>
+  stickerTypes.has(String(segment?.type || "").toLowerCase()) ||
+  [segment?.data?.sub_type, segment?.data?.type]
+    .map((value) => String(value || "").toLowerCase())
+    .includes("sticker") ||
+  (String(segment?.type || "").toLowerCase() === "image" &&
+    Boolean(
+      segment?.data?.emoji_id ||
+      segment?.data?.emoji_package_id ||
+      (segment?.data?.summary && segment?.data?.key),
+    ));
+
+function replyTarget(event, safeSegments, botMessageIds) {
+  const replies = safeSegments.filter((segment) => segment.type === "reply"),
+    ids = replies
+      .map((segment) => segment.data.id)
+      .filter((id) => id != null)
+      .map(String),
+    senderIds = [
+      event.reply?.user_id,
+      event.reply?.sender?.user_id,
+      event.reply?.sender?.id,
+      ...replies.map((segment) => segment.data.qq),
+      ...replies.map((segment) => segment.data.user_id),
+      ...replies.map((segment) => segment.data.sender?.user_id),
+      ...replies.map((segment) => segment.data.sender?.id),
+    ]
+      .filter((id) => id != null)
+      .map(String),
+    known =
+      typeof botMessageIds?.has === "function" &&
+      ids.some((id) => botMessageIds.has(id));
+  return known || senderIds.includes(String(event.self_id));
+}
+
+export const onebot = {
+  type: "onebot",
+  capabilities: {
+    mention: true,
+    quote: true,
+    image: true,
+    thread: false,
+    sticker: true,
+  },
+  mediaHosts: /(^|\.)(qpic\.cn|gtimg\.cn|qq\.com\.cn|qq\.com|myqcloud\.com)$/i,
+  usableMediaUrl(url) {
+    try {
+      const u = new URL(url);
+      return (
+        u.protocol === "https:" &&
+        !u.username &&
+        !u.password &&
+        this.mediaHosts.test(u.hostname)
+      );
+    } catch {
+      return false;
+    }
+  },
+  sendAction(message) {
+    return parseSessionKey(message.sessionId).kind === "group"
+      ? "send_group_msg"
+      : "send_private_msg";
+  },
+  sendParams(message, text) {
+    const parsed = parseSessionKey(message.sessionId);
+    return {
+      message: [{ type: "text", data: { text } }],
+      [parsed.kind === "group" ? "group_id" : "user_id"]:
+        parsed.kind === "group"
+          ? Number(message.raw?.group_id ?? parsed.nativeId)
+          : Number(message.raw?.user_id ?? message.userId ?? parsed.nativeId),
+    };
+  },
+  nativeChatId(sessionId) {
+    return Number(parseSessionKey(sessionId).nativeId);
+  },
+  quotedMessage(data, current) {
+    if (!data || typeof data !== "object" || !Array.isArray(data.message))
+      return null;
+    try {
+      const parsed = parseSessionKey(current.sessionId);
+      if (data.group_id && String(data.group_id) !== parsed.nativeId)
+        return null;
+    } catch {
+      return null;
+    }
+    const sender = String(data.sender?.user_id || data.user_id || "unknown");
+    return {
+      sessionId: current.sessionId,
+      kind: current.kind,
+      userId: sender === current.accountId ? "bot" : sender,
+      name: senderLabel(data.sender, sender),
+      text: data.message
+        .filter((s) => s.type === "text")
+        .map((s) => s.data?.text || "")
+        .join(""),
+      role: sender === current.accountId ? "assistant" : "user",
+      raw: {
+        ...data,
+        self_id: current.accountId,
+        message_id: current.replyId,
+      },
+    };
+  },
+};
+
+export function normalize(event, { botMessageIds } = {}) {
+  if (
+    !event ||
+    typeof event !== "object" ||
+    event.post_type !== "message" ||
+    !["group", "private"].includes(event.message_type) ||
+    String(event.user_id) === String(event.self_id)
+  )
+    return null;
+  if (
+    !/^\d+$/.test(String(event.user_id)) ||
+    !/^\d+$/.test(String(event.self_id)) ||
+    event.message_id == null ||
+    (event.message_type === "group" && !/^\d+$/.test(String(event.group_id)))
+  )
+    return null;
+  const segments = Array.isArray(event.message)
+    ? event.message
+    : parseCqMessage(event.raw_message || event.message || "");
+  const safeSegments = segments.filter(
+    (s) => s && typeof s === "object" && s.data && typeof s.data === "object",
+  );
+  const atId = (segment) => {
+    const data = segment?.data || {};
+    const id = data.qq ?? data.user_id;
+    return id == null || id === "" ? "" : String(id);
+  };
+  const atSelf = safeSegments.some(
+      (s) =>
+        String(s.type || "").toLowerCase() === "at" &&
+        atId(s) === String(event.self_id),
+    ),
+    replyToBot = replyTarget(event, safeSegments, botMessageIds),
+    media = {
+      images: safeSegments.filter(
+        (s) => String(s.type).toLowerCase() === "image" && !isSticker(s),
+      ).length,
+      stickers: safeSegments.filter(isSticker).length,
+      other: safeSegments.filter((s) =>
+        ["record", "video", "file", "json", "xml"].includes(
+          String(s.type).toLowerCase(),
+        ),
+      ).length,
+    },
+    textParts = safeSegments.map((s) => {
+      const type = String(s.type || "").toLowerCase();
+      if (type === "text" && typeof s.data.text === "string")
+        return s.data.text;
+      if (type === "at")
+        return atId(s) === String(event.self_id) ? "@我" : "[提及成员]";
+      if (type === "image" && !isSticker(s)) return "[图片]";
+      if (isSticker(s)) return "[表情]";
+      if (["record", "video", "file", "json", "xml"].includes(type))
+        return "[媒体]";
+      return "";
+    }),
+    plainText = safeSegments
+      .filter((s) => s.type === "text" && typeof s.data.text === "string")
+      .map((s) => s.data.text)
+      .join("")
+      .trim(),
+    visibleText = textParts.join("").trim(),
+    text =
+      visibleText ||
+      (atSelf || replyToBot ? (replyToBot ? "[回复你]" : "[叫了你一声]") : "");
+  if (!text) return null;
+  const mediaCount = media.images + media.stickers + media.other;
+  const kind = event.message_type;
+  const nativeId = String(event.group_id || event.user_id);
+  const facts = segmentFacts(safeSegments);
+  return {
+    sessionId: formatSessionKey({
+      channel: "onebot",
+      accountId: String(event.self_id),
+      kind,
+      nativeId,
+    }),
+    channel: "onebot",
+    accountId: String(event.self_id),
+    nativeId,
+    segments: safeSegments,
+    kind,
+    userId: String(event.user_id),
+    name: senderLabel(event.sender, event.user_id),
+    accountName: senderLabel(
+      { nickname: event.sender?.nickname, nick: event.sender?.nick },
+      event.user_id,
+    ),
+    text: text.slice(0, 4000),
+    mentioned: atSelf || replyToBot,
+    replyToBot,
+    platformId: String(event.message_id),
+    time: event.time ? event.time * 1000 : Date.now(),
+    mentions: facts.mentions,
+    replyId: facts.replyId,
+    attachments: facts.attachments,
+    media: {
+      ...media,
+      count: mediaCount,
+      only: mediaCount > 0 && !plainText && !atSelf && !replyToBot,
+      imageOnly:
+        media.images > 0 &&
+        mediaCount === media.images &&
+        !plainText &&
+        !atSelf &&
+        !replyToBot,
+      stickerOnly:
+        media.stickers > 0 &&
+        mediaCount === media.stickers &&
+        !plainText &&
+        !atSelf &&
+        !replyToBot,
+    },
+    eventId: `${event.self_id}:${event.message_type}:${event.group_id || event.user_id}:${event.message_id}`,
+    raw: event,
+  };
+}