luckytri 1.2.3 → 1.3.0

package/server/actions/index.js

@@ -0,0 +1,268 @@
+// What she can do besides typing: quote a message, poke someone, put a
+// reaction on a message, throw a die or play rock-paper-scissors, take back
+// her own last line. They belong to her the way words do: offered only when
+// this channel can do them right now, chosen by her, never by a counter.
+
+// QQ face ids accepted by set_msg_emoji_like; a short list she can
+// name. Unknown names are dropped, not guessed.
+export const REACTIONS = {
+  赞: "76",
+  爱心: "66",
+  笑哭: "182",
+  哈哈: "101",
+  抱抱: "49",
+  OK: "124",
+  鼓掌: "99",
+  疑问: "32",
+  震惊: "110",
+  玫瑰: "63",
+};
+
+const NOTES = {
+  reply: "reply:{to:消息序号}，引用那条再说（话题被刷下去、或要明确接哪句时）",
+  poke: "poke:{to:userId}，戳一下（逗人、叫人、回戳）",
+  react: `react:{to:消息序号,emoji:${Object.keys(REACTIONS).join("|")}}，给那条点个表情回应，可以不说话`,
+  dice: "dice:{}，扔个骰子",
+  rps: "rps:{}，出个猜拳",
+  recall: "recall:{}，撤回自己刚发的上一条（只在发错了的时候）",
+  voice:
+    "voice:{}，这句用说的发语音（60字内）；有人请你唱歌，你此刻心情好也想唱，可以把歌词写进 say 并选 voice，不想就不唱",
+  music:
+    'music:{query:"歌名 歌手"}，分享一首歌的卡片（真想推荐、或有人要歌时）',
+  forward:
+    "forward:{ids:[消息序号,…]}，把这里的几条消息打包成合并转发发出来（翻旧账、给人看前情时，最多20条）",
+  file: 'file:{name:"标题",text:"全文"}，把你自己写的东西作为 .md 文件发出来（篇幅长、对方要文件时）',
+};
+
+// Guards against a burst, per session, in her time.
+const LIMITS = {
+  poke: { per: 10 * 60000, max: 1, key: "to" },
+  react: { per: 3600000, max: 6 },
+  dice: { per: 3600000, max: 3 },
+  rps: { per: 3600000, max: 3 },
+  recall: { per: 3600000, max: 2 },
+  voice: { per: 3600000, max: 3 },
+  music: { per: 3600000, max: 3 },
+  forward: { per: 3600000, max: 2 },
+  file: { per: 3600000, max: 2 },
+};
+
+export class ActionLedger {
+  constructor(db, { now = Date.now } = {}) {
+    this.db = db;
+    this.now = now;
+    db?.exec?.(
+      "CREATE TABLE IF NOT EXISTS core_action_events (id INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT NOT NULL, direction TEXT NOT NULL, type TEXT NOT NULL, target TEXT, detail TEXT, result TEXT, time INTEGER NOT NULL)",
+    );
+  }
+  count(session, type, since, target) {
+    if (!this.db) return 0;
+    return this.db
+      .prepare(
+        `SELECT COUNT(*) n FROM core_action_events WHERE session_id=? AND type=? AND direction='out' AND result='done' AND time>=?${target ? " AND target=?" : ""}`,
+      )
+      .get(session, type, since, ...(target ? [String(target)] : [])).n;
+  }
+  allowed(session, type, target) {
+    const limit = LIMITS[type];
+    if (!limit) return true;
+    return (
+      this.count(
+        session,
+        type,
+        this.now() - limit.per,
+        limit.key ? target : undefined,
+      ) < limit.max
+    );
+  }
+  record(
+    session,
+    { direction = "out", type, target = "", detail = "", result },
+  ) {
+    this.db
+      ?.prepare(
+        "INSERT INTO core_action_events(session_id,direction,type,target,detail,result,time) VALUES (?,?,?,?,?,?,?)",
+      )
+      .run(
+        session,
+        direction,
+        type,
+        String(target),
+        detail,
+        result,
+        this.now(),
+      );
+  }
+}
+
+// What reaches her this turn: only what this channel can do here now.
+export function actionOffer(available, snapshot, session, ledger) {
+  if (!Array.isArray(available) || !available.length) return [];
+  if (snapshot.initiative || snapshot.stopped) return [];
+  return available.filter(
+    (type) =>
+      NOTES[type] &&
+      (type !== "recall" ||
+        (snapshot.messages || []).some((m) => m.role === "assistant")) &&
+      (!ledger || type === "poke" || ledger.allowed(session, type)),
+  );
+}
+
+export function actionNote(offered) {
+  return {
+    actions: offered.map((type) => NOTES[type]),
+    actionsNote:
+      '想做时返回 actions:[{"type":"…",…}]，最多两个；不做就不写。和说话一样由你决定，不用为用而用。',
+  };
+}
+
+// What she chose, kept only when it points at something real this turn.
+export function chosenActions(raw, snapshot) {
+  const offered = new Set(snapshot.actionsOffered || []);
+  if (!offered.size || !Array.isArray(raw)) return [];
+  const byIndex = (to) =>
+    (snapshot.batch || []).find((m) => String(m.id) === String(to)) ||
+    (snapshot.messages || []).find(
+      (m) => m.role === "user" && String(m.id) === String(to),
+    );
+  const people = new Map(
+    [
+      ...(snapshot.canAt || []),
+      ...(snapshot.batch || []).map((m) => ({
+        userId: String(m.speaker ?? m.userId ?? ""),
+        name: m.name,
+      })),
+    ]
+      .filter((p) => p.userId)
+      .map((p) => [String(p.userId), p]),
+  );
+  const out = [];
+  for (const item of raw) {
+    if (!item || typeof item !== "object" || !offered.has(item.type)) continue;
+    if (out.some((a) => a.type === item.type)) continue;
+    if (item.type === "reply" || item.type === "react") {
+      const m = byIndex(item.to);
+      if (!m?.platformId) continue;
+      if (item.type === "react" && !REACTIONS[item.emoji]) continue;
+      out.push({
+        type: item.type,
+        to: m.id,
+        platformId: String(m.platformId),
+        name: m.name || "",
+        ...(item.type === "react" ? { emoji: item.emoji } : {}),
+      });
+    } else if (item.type === "poke") {
+      const p = people.get(String(item.to ?? ""));
+      if (!p) continue;
+      out.push({ type: "poke", to: p.userId, name: p.name || "" });
+    } else if (item.type === "music") {
+      const query = String(item.query || "")
+        .trim()
+        .slice(0, 60);
+      if (!query) continue;
+      out.push({ type: "music", query });
+    } else if (item.type === "forward") {
+      const ids = (Array.isArray(item.ids) ? item.ids : [])
+        .map((id) =>
+          (snapshot.messages || []).find((m) => String(m.id) === String(id)),
+        )
+        .filter((m) => m?.platformId)
+        .slice(0, 20);
+      if (!ids.length) continue;
+      out.push({
+        type: "forward",
+        platformIds: [...new Set(ids.map((m) => String(m.platformId)))],
+      });
+    } else if (item.type === "file") {
+      const text = String(item.text || "").trim();
+      const name = String(item.name || "")
+        .replace(/[\\/:*?"<>|\n\r]/g, "")
+        .trim()
+        .slice(0, 40);
+      if (!text || !name || text.length > 20000) continue;
+      out.push({ type: "file", name: `${name}.md`, text });
+    } else out.push({ type: item.type });
+    if (out.length >= 2) break;
+  }
+  return out;
+}
+
+// How it reads in her own history afterwards.
+export function actionLine(action) {
+  switch (action.type) {
+    case "poke":
+      return `[你戳了戳${action.name || "对方"}]`;
+    case "react":
+      return `[你给${action.name || "那条消息"}点了「${action.emoji}」]`;
+    case "dice":
+      return "[你扔了个骰子]";
+    case "rps":
+      return "[你出了个猜拳]";
+    case "recall":
+      return "[你撤回了上一条]";
+    case "voice":
+      return "[你发了语音]";
+    case "music":
+      return `[你分享了歌：${action.query}]`;
+    case "forward":
+      return `[你转发了${action.platformIds?.length || 0}条聊天记录]`;
+    case "file":
+      return `[你发了文件：${action.name}]`;
+    default:
+      return "";
+  }
+}
+
+// Runs the non-text actions; a failed one is noted and dropped, the words
+// still go out.
+export async function performActions(owner, message, actions, trace, session) {
+  const done = [];
+  if (!owner.perform) return done;
+  for (const action of actions) {
+    if (action.type === "reply" || action.type === "voice") continue;
+    if (
+      owner.actions &&
+      !owner.actions.allowed(session, action.type, action.to)
+    ) {
+      trace.steps.push(`动作「${action.type}」这段时间做得够多了，这次不做`);
+      continue;
+    }
+    try {
+      const target =
+        action.type === "recall"
+          ? owner.repo.db
+              .prepare(
+                "SELECT platform_id FROM core_outbox WHERE session_id=? AND status='confirmed' AND platform_id<>'' AND time>=? ORDER BY time DESC LIMIT 1",
+              )
+              .get(session, owner.now() - 110000)?.platform_id
+          : undefined;
+      if (action.type === "recall" && !target) {
+        trace.steps.push("想撤回，但上一条已经超过两分钟，不撤了");
+        continue;
+      }
+      await owner.perform(message, {
+        ...action,
+        ...(target ? { platformId: String(target) } : {}),
+        ...(action.type === "react"
+          ? { emojiId: REACTIONS[action.emoji] }
+          : {}),
+      });
+      owner.actions?.record(session, {
+        type: action.type,
+        target: action.to || "",
+        detail: action.emoji || "",
+        result: "done",
+      });
+      trace.steps.push(`做了动作：${actionLine(action) || action.type}`);
+      done.push(action);
+    } catch (error) {
+      owner.actions?.record(session, {
+        type: action.type,
+        target: action.to || "",
+        result: "failed",
+      });
+      trace.steps.push(`动作「${action.type}」没做成：${error.message}`);
+    }
+  }
+  return done;
+}

package/server/app.js

@@ -15,6 +15,7 @@ import { Life } from "./mind/life/index.js";
 import { runtimePaths } from "./paths.js";
 import { mountDataTransfer } from "./storage/data-transfer-api.js";
 import { UpdateChecker, mountUpdates } from "./studio/updates.js";
+import { mountVoice } from "./voice/index.js";
 
 export function createApp({
   store,
@@ -47,6 +48,7 @@ export function createApp({
         "/plugins/import/upload",
         "/storage/transfer/upload",
         "/core/stickers/upload",
+        "/core/stickers/upload-zip",
       ].includes(req.path)
     )
       return res.status(400).json({ error: "请提交 JSON 对象" });
@@ -64,9 +66,10 @@ export function createApp({
     res.status(401).json({ error: "请先登录管理台" });
   });
   app.use("/api", objectBody);
-  mountUpdates(app, updates, runtime.updater);
+  mountUpdates(app, updates, runtime.updater, runtime.autoUpdate);
   mountDataTransfer(app, runtime.transfer);
   if (chatSystem?.stickers) mountStickerUpload(app, chatSystem);
+  if (chatSystem?.repo) mountVoice(app, chatSystem);
   if (plugins) {
     app.post(
       "/api/plugins/import/upload",

package/server/channels/contract.js

@@ -16,6 +16,9 @@
 //                        the message this bubble answers; a channel with the
 //                        quote capability may show it as a quote, any other
 //                        channel ignores it
+//   actions(sessionId)   optional: her non-text actions possible there now,
+//                        from reply, poke, react, dice, rps, recall
+//   perform(message, action)  optional: carry one of them out
 //   fetchQuoted(message) the message that `message.replyId` points to, or null
 //   fetchImage(file)     a fresh URL or bytes for an expired image, or null
 //   fetchMedia(file, type)  optional: a voice or file the same way, or null

package/server/channels/hub.js

@@ -157,6 +157,21 @@ export function createChannelHub(store, channels, { env = process.env } = {}) {
       const channel = sessionId ? resolve(sessionId) : current();
       return channel.fetchMedia ? channel.fetchMedia(file, type) : null;
     },
+    // Her non-text actions; a channel without them offers none.
+    actions: (sessionId) => {
+      try {
+        const channel = resolve(sessionId);
+        return channel.actions ? channel.actions(sessionId) : [];
+      } catch {
+        return [];
+      }
+    },
+    perform: async (message, action) => {
+      if (message?.simulated) return {};
+      const channel = resolve(message.sessionId);
+      if (!channel.perform) throw new Error("这个渠道做不了这个动作");
+      return channel.perform(message, action);
+    },
     refreshDirectory: () => current().refreshDirectory(),
     close() {
       for (const channel of registry.values()) channel.close();

package/server/channels/onebot/adapter.js

@@ -133,28 +133,35 @@ export const onebot = {
       : [];
     // A sticker goes as an image of its own, its bytes inline so the QQ client
     // needs no path or URL on this machine.
-    const body = options?.image
+    const body = options?.record
       ? [
           {
-            type: "image",
-            data: {
-              file: `base64://${options.image.base64}`,
-              sub_type: options.image.sticker ? 1 : 0,
-              ...(options.image.summary
-                ? { summary: options.image.summary }
-                : {}),
-            },
+            type: "record",
+            data: { file: `base64://${options.record.base64}` },
           },
         ]
-      : [
-          ...(Array.isArray(options?.at) ? options.at : [])
-            .filter((id) => /^\d{5,12}$/.test(String(id)))
-            .flatMap((id) => [{ type: "at", data: { qq: String(id) } }]),
-          {
-            type: "text",
-            data: { text: options?.at?.length ? ` ${text}` : text },
-          },
-        ];
+      : options?.image
+        ? [
+            {
+              type: "image",
+              data: {
+                file: `base64://${options.image.base64}`,
+                sub_type: options.image.sticker ? 1 : 0,
+                ...(options.image.summary
+                  ? { summary: options.image.summary }
+                  : {}),
+              },
+            },
+          ]
+        : [
+            ...(Array.isArray(options?.at) ? options.at : [])
+              .filter((id) => /^\d{5,12}$/.test(String(id)))
+              .flatMap((id) => [{ type: "at", data: { qq: String(id) } }]),
+            {
+              type: "text",
+              data: { text: options?.at?.length ? ` ${text}` : text },
+            },
+          ];
     return {
       message: [...reply, ...body],
       [parsed.kind === "group" ? "group_id" : "user_id"]:
@@ -196,6 +203,129 @@ export const onebot = {
   },
 };
 
+// Someone poking her is a way of calling her; poking between others is not.
+export function normalizePoke(event) {
+  if (
+    event?.post_type !== "notice" ||
+    !(event.notice_type === "notify" && event.sub_type === "poke") ||
+    String(event.target_id) !== String(event.self_id) ||
+    String(event.user_id) === String(event.self_id) ||
+    !/^\d+$/.test(String(event.user_id)) ||
+    !/^\d+$/.test(String(event.self_id))
+  )
+    return null;
+  const kind = event.group_id ? "group" : "private";
+  const nativeId = String(event.group_id || event.user_id);
+  const time = event.time ? event.time * 1000 : Date.now();
+  return {
+    sessionId: formatSessionKey({
+      channel: "onebot",
+      accountId: String(event.self_id),
+      kind,
+      nativeId,
+    }),
+    channel: "onebot",
+    accountId: String(event.self_id),
+    nativeId,
+    segments: [],
+    kind,
+    userId: String(event.user_id),
+    name: senderLabel(event.sender, event.user_id),
+    text: "[戳了戳你]",
+    poke: true,
+    mentioned: true,
+    replyToBot: false,
+    platformId: "",
+    time,
+    mentions: [],
+    replyId: "",
+    attachments: [],
+    media: { images: 0, stickers: 0, other: 0, count: 0, only: false },
+    eventId: `${event.self_id}:poke:${nativeId}:${event.user_id}:${time}`,
+    raw: event,
+  };
+}
+
+// One of her non-text actions as an OneBot call. Poke and reactions are
+// extensions of some implementations; dice, rps and recall are OneBot 11.
+export function actionCall(message, action) {
+  const parsed = parseSessionKey(message.sessionId);
+  const group = parsed.kind === "group";
+  const where = group
+    ? { group_id: Number(parsed.nativeId) }
+    : { user_id: Number(parsed.nativeId) };
+  switch (action.type) {
+    case "poke":
+      return group
+        ? ["group_poke", { ...where, user_id: Number(action.to) }]
+        : ["friend_poke", { user_id: Number(action.to) }];
+    case "react":
+      return [
+        "set_msg_emoji_like",
+        {
+          message_id: Number(action.platformId),
+          emoji_id: String(action.emojiId),
+          set: true,
+        },
+      ];
+    case "dice":
+    case "rps":
+      return [
+        group ? "send_group_msg" : "send_private_msg",
+        { ...where, message: [{ type: action.type, data: {} }] },
+      ];
+    case "typing":
+      // "Typing…" in a private chat while she thinks; groups have none.
+      if (group) throw new Error("这个动作 QQ 这边做不了");
+      return [
+        "set_input_status",
+        { user_id: Number(parsed.nativeId), event_type: 1 },
+      ];
+    case "music":
+      return [
+        group ? "send_group_msg" : "send_private_msg",
+        {
+          ...where,
+          message: [
+            {
+              type: "music",
+              data: { type: "163", id: String(action.song.id) },
+            },
+          ],
+        },
+      ];
+    case "text":
+      return [
+        group ? "send_group_msg" : "send_private_msg",
+        { ...where, message: [{ type: "text", data: { text: action.text } }] },
+      ];
+    case "forward":
+      return [
+        group ? "send_group_forward_msg" : "send_private_forward_msg",
+        {
+          ...where,
+          messages: action.platformIds.map((id) => ({
+            type: "node",
+            data: { id: String(id) },
+          })),
+        },
+      ];
+    case "file":
+      return [
+        group ? "upload_group_file" : "upload_private_file",
+        {
+          ...where,
+          file: `base64://${Buffer.from(action.text, "utf8").toString("base64")}`,
+          name: action.name,
+        },
+      ];
+    case "recall":
+      return ["delete_msg", { message_id: Number(action.platformId) }];
+    default:
+      throw new Error("这个动作 QQ 这边做不了");
+  }
+}
+
 export function normalize(event, { botMessageIds } = {}) {
   if (
     !event ||
@@ -235,7 +365,7 @@ export function normalize(event, { botMessageIds } = {}) {
       ).length,
       stickers: safeSegments.filter(isSticker).length,
       other: safeSegments.filter((s) =>
-        ["record", "video", "file", "json", "xml"].includes(
+        ["record", "video", "file", "json", "xml", "forward"].includes(
           String(s.type).toLowerCase(),
         ),
       ).length,
@@ -247,9 +377,20 @@ export function normalize(event, { botMessageIds } = {}) {
       if (type === "at")
         return atId(s) === String(event.self_id) ? "@我" : "[提及成员]";
       if (type === "image" && !isSticker(s)) return "[图片]";
+      if (type === "dice") return "[骰子]";
+      if (type === "rps") return "[猜拳]";
       if (isSticker(s)) return "[表情]";
-      if (["record", "video", "file", "json", "xml"].includes(type))
-        return "[媒体]";
+      if (type === "record") return "[语音]";
+      if (type === "forward") return "[合并转发]";
+      if (type === "file")
+        return `[文件：${String(s.data.name || s.data.file || "").slice(0, 60)}]`;
+      if (type === "video") {
+        const name = String(
+          s.data?.file_name || s.data?.name || s.data?.file || "",
+        ).slice(0, 60);
+        return name ? `[视频：${name}]` : "[视频]";
+      }
+      if (["json", "xml"].includes(type)) return "[媒体]";
       return "";
     }),
     plainText = safeSegments

package/server/channels/onebot/enrich.js

@@ -0,0 +1,132 @@
+// What a QQ message carries beyond text, turned into words before the core
+// sees it: a merged forward is unfolded into its lines, a voice message is
+// transcribed when the owner set up speech recognition, a video keeps its
+// filename when known. All are bounded; when anything fails the placeholder
+// stays and nothing is guessed.
+import { readFile } from "node:fs/promises";
+
+const FORWARD_MAX_LINES = 40;
+const FORWARD_MAX_CHARS = 2000;
+
+function plain(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .map((s) => {
+      const type = String(s?.type || "").toLowerCase();
+      if (type === "text") return s.data?.text || "";
+      if (type === "image") return "[图片]";
+      if (type === "forward") return "[合并转发]";
+      if (type === "record") return "[语音]";
+      if (type === "video") {
+        const name = String(
+          s.data?.file_name || s.data?.name || s.data?.file || "",
+        ).slice(0, 60);
+        return name ? `[视频：${name}]` : "[视频]";
+      }
+      if (type === "face" || type === "mface") return "[表情]";
+      return "";
+    })
+    .join("");
+}
+
+export function forwardText(data) {
+  const list = Array.isArray(data?.messages)
+    ? data.messages
+    : Array.isArray(data)
+      ? data
+      : [];
+  const lines = [];
+  let chars = 0;
+  for (const item of list.slice(0, FORWARD_MAX_LINES)) {
+    const who =
+      item?.sender?.card || item?.sender?.nickname || item?.nickname || "某人";
+    const text = plain(item?.message ?? item?.content).trim();
+    if (!text) continue;
+    const line = `${String(who).slice(0, 30)}：${text}`.slice(0, 300);
+    if (chars + line.length > FORWARD_MAX_CHARS) break;
+    lines.push(line);
+    chars += line.length;
+  }
+  if (!lines.length) return "";
+  const more =
+    list.length > lines.length
+      ? `\n（还有 ${list.length - lines.length} 条没展开）`
+      : "";
+  return `[合并转发：\n${lines.join("\n")}${more}]`;
+}
+
+async function audioOf(data) {
+  if (data?.base64) return Buffer.from(String(data.base64), "base64");
+  if (typeof data?.file === "string" && data.file.startsWith("base64://"))
+    return Buffer.from(data.file.slice(9), "base64");
+  if (typeof data?.file === "string" && data.file.startsWith("/"))
+    return readFile(data.file);
+  return null;
+}
+
+// rpc(action, params, timeoutMs); transcribe(buffer, format) or null.
+export async function enrich(message, { rpc, transcribe } = {}) {
+  const segments = message?.segments || [];
+  let text = message.text;
+  let changed = false;
+  for (const s of segments) {
+    const type = String(s?.type || "").toLowerCase();
+    if (type === "forward" && s.data?.id) {
+      try {
+        const data = await rpc(
+          "get_forward_msg",
+          { id: String(s.data.id), message_id: String(s.data.id) },
+          5000,
+        );
+        const unfolded = forwardText(data);
+        if (unfolded) {
+          text = text.includes("[合并转发]")
+            ? text.replace("[合并转发]", unfolded)
+            : `${text}\n${unfolded}`;
+          changed = true;
+        }
+      } catch {
+        /* The placeholder stays. */
+      }
+    }
+    if (type === "video") {
+      const name = String(
+        s.data?.file_name || s.data?.name || s.data?.file || "",
+      ).slice(0, 60);
+      const label = name ? `[视频：${name}]` : "[视频]";
+      if (text.includes("[媒体]")) {
+        text = text.replace("[媒体]", label);
+        changed = true;
+      } else if (
+        name &&
+        (text === "[视频]" || /(?:^|\n)\[视频\](?!：)/.test(text))
+      ) {
+        text = text.replace("[视频]", label);
+        changed = true;
+      }
+    }
+    if (type === "record" && s.data?.file && transcribe) {
+      try {
+        const data = await rpc(
+          "get_record",
+          { file: String(s.data.file), out_format: "mp3" },
+          8000,
+        );
+        const audio = await audioOf(data);
+        const said = audio
+          ? String((await transcribe(audio, "mp3")) || "").trim()
+          : "";
+        if (said) {
+          text = text.includes("[语音]")
+            ? text.replace("[语音]", `[语音] ${said.slice(0, 500)}`)
+            : `${text}\n[语音] ${said.slice(0, 500)}`;
+          changed = true;
+        }
+      } catch {
+        /* Not heard; the placeholder stays. */
+      }
+    }
+  }
+  return changed ? { ...message, text: text.slice(0, 4000) } : message;
+}