luckytri 1.0.0

package/server/core/image-preprocessor.js

@@ -0,0 +1,208 @@
+import sharp from "sharp";
+
+const MIB = 1024 * 1024;
+const TYPES = {
+  jpeg: "image/jpeg",
+  png: "image/png",
+  webp: "image/webp",
+  gif: "image/gif",
+  heif: "image/avif",
+};
+
+function configured(value, fallback, min, max) {
+  const number = Number(value);
+  return value != null && value !== "" && Number.isFinite(number)
+    ? Math.min(max, Math.max(min, number))
+    : fallback;
+}
+
+export function visionImageLimits(env = process.env) {
+  return {
+    maxSourceBytes: Math.floor(
+      configured(env.VISION_SOURCE_MAX_MB, 32, 4, 64) * MIB,
+    ),
+    maxModelBytes: Math.floor(
+      configured(env.VISION_MODEL_MAX_MB, 4, 1, 4) * MIB,
+    ),
+    maxPixels: 80_000_000,
+    maxDimension: 8192,
+    maxOutputPixels: 16_000_000,
+    downloadTimeoutMs: Math.floor(
+      configured(env.VISION_DOWNLOAD_TIMEOUT_SECONDS, 30, 5, 120) * 1000,
+    ),
+  };
+}
+
+export function imageMime(bytes) {
+  if (
+    bytes.length >= 3 &&
+    bytes[0] === 0xff &&
+    bytes[1] === 0xd8 &&
+    bytes[2] === 0xff
+  )
+    return "image/jpeg";
+  if (
+    bytes.length >= 8 &&
+    bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))
+  )
+    return "image/png";
+  if (
+    bytes.length >= 6 &&
+    /^(GIF87a|GIF89a)$/.test(bytes.toString("ascii", 0, 6))
+  )
+    return "image/gif";
+  if (
+    bytes.length >= 12 &&
+    bytes.toString("ascii", 0, 4) === "RIFF" &&
+    bytes.toString("ascii", 8, 12) === "WEBP"
+  )
+    return "image/webp";
+  if (bytes.length >= 16 && bytes.toString("ascii", 4, 8) === "ftyp") {
+    const length = bytes.readUInt32BE(0);
+    if (length >= 16 && length <= bytes.length) {
+      for (let offset = 8; offset < Math.min(length, 64); offset += 4) {
+        if (offset === 12) continue; // Minor version, not a compatible brand.
+        if (
+          ["avif", "avis"].includes(bytes.toString("ascii", offset, offset + 4))
+        )
+          return "image/avif";
+      }
+    }
+  }
+  return "";
+}
+
+// Bound work across all conversations, including downloads and decoded images.
+let active = 0;
+const waiting = [];
+export async function withVisionImageSlot(run) {
+  if (active >= 2) await new Promise((resolve) => waiting.push(resolve));
+  else active++;
+  try {
+    return await run();
+  } finally {
+    const next = waiting.shift();
+    if (next) next();
+    else active--;
+  }
+}
+
+export async function prepareVisionImage(bytes, limits = visionImageLimits()) {
+  if (!bytes.length || bytes.length > limits.maxSourceBytes)
+    throw Error("图片超过大小限制");
+  const mime = imageMime(bytes);
+  if (!mime) throw Error("不是支持的图片格式");
+  const input = { limitInputPixels: limits.maxPixels, pages: 1 };
+  let metadata;
+  try {
+    metadata = await sharp(bytes, input).metadata();
+  } catch (error) {
+    if (/pixel limit/i.test(error.message)) throw Error("图片像素超过处理限制");
+    throw Error("图片读取失败");
+  }
+  if (
+    !TYPES[metadata.format] ||
+    (metadata.format === "heif" && metadata.compression !== "av1")
+  )
+    throw Error("不是支持的图片格式");
+  const oriented =
+    metadata.autoOrient ||
+    ([5, 6, 7, 8].includes(metadata.orientation)
+      ? { width: metadata.height, height: metadata.width }
+      : metadata);
+  const { width, height } = oriented;
+  if (!width || !height || width * height > limits.maxPixels)
+    throw Error("图片像素超过处理限制");
+  const scale = Math.min(
+    1,
+    limits.maxDimension / width,
+    limits.maxDimension / height,
+    Math.sqrt(limits.maxOutputPixels / (width * height)),
+  );
+  let targetWidth = Math.max(1, Math.floor(width * scale));
+  let targetHeight = Math.max(1, Math.floor(height * scale));
+  const frameOnly = metadata.pages > 1;
+  if (
+    bytes.length <= limits.maxModelBytes &&
+    scale === 1 &&
+    !frameOnly &&
+    (!metadata.orientation || metadata.orientation === 1) &&
+    mime !== "image/avif" &&
+    mime !== "image/gif"
+  ) {
+    try {
+      // Decode before passing through: intact headers can hide a truncated
+      // image body. Discard the tiny probe and retain the original bytes.
+      await sharp(bytes, input)
+        .resize({ width: 1, height: 1, fit: "inside" })
+        .raw()
+        .timeout({ seconds: 10 })
+        .toBuffer();
+    } catch (error) {
+      if (/timeout|timed out/i.test(error.message)) throw Error("图片处理超时");
+      throw Error("图片读取失败");
+    }
+    return {
+      bytes,
+      mime,
+      width,
+      height,
+      originalBytes: bytes.length,
+      transformed: false,
+      frameOnly: false,
+    };
+  }
+
+  const pipeline = () =>
+    sharp(bytes, input)
+      .rotate()
+      .resize({
+        width: targetWidth,
+        height: targetHeight,
+        fit: "inside",
+        withoutEnlargement: true,
+      })
+      .timeout({ seconds: 10 });
+  const result = (output, format) => ({
+    bytes: output.data,
+    mime: format,
+    width: output.info.width,
+    height: output.info.height,
+    originalBytes: bytes.length,
+    transformed: true,
+    frameOnly,
+  });
+  try {
+    // Try lossless encoding first: large uncompressed screenshots often fit
+    // without shrinking text or introducing JPEG artefacts.
+    if (mime !== "image/jpeg") {
+      const png = await pipeline()
+        .png({ compressionLevel: 6 })
+        .toBuffer({ resolveWithObject: true });
+      if (png.data.length <= limits.maxModelBytes)
+        return result(png, "image/png");
+    }
+    for (let attempt = 0; attempt < 4; attempt++) {
+      const output = await pipeline()
+        .flatten({ background: "#ffffff" })
+        .jpeg({ quality: attempt === 0 ? 90 : 82, chromaSubsampling: "4:4:4" })
+        .toBuffer({ resolveWithObject: true });
+      if (output.data.length <= limits.maxModelBytes)
+        return result(output, "image/jpeg");
+      // First reduce encoding size while keeping the full dimensions. Only
+      // shrink if that still cannot fit the model's request budget.
+      if (attempt > 0) {
+        const shrink = Math.min(
+          0.85,
+          Math.sqrt(limits.maxModelBytes / output.data.length) * 0.9,
+        );
+        targetWidth = Math.max(1, Math.floor(targetWidth * shrink));
+        targetHeight = Math.max(1, Math.floor(targetHeight * shrink));
+      }
+    }
+  } catch (error) {
+    if (/timeout|timed out/i.test(error.message)) throw Error("图片处理超时");
+    throw Error("图片读取失败");
+  }
+  throw Error("图片超过大小限制");
+}

package/server/core/initiative-context.js

@@ -0,0 +1,66 @@
+import { localClock } from "./conversation-cues.js";
+
+// History has a different role when she starts a conversation. It can stop
+// a repeated question or a false claim, but it must never pose a new request.
+export function initiativeContext(snapshot, occasion = snapshot.initiative) {
+  const situation = occasion?.initiative || {};
+  const history = (snapshot.messages || []).slice(-12).map((m) => ({
+    id: m.id,
+    speaker: m.speaker,
+    name: m.name,
+    role: m.role,
+    text: m.text,
+    time: m.time,
+    localTime: m.localTime,
+    referenceOnly: true,
+  }));
+  return {
+    sessionId: snapshot.sessionId,
+    conversation: snapshot.conversation,
+    batchIds: [],
+    addressed: [],
+    newMessages: [],
+    messages: [],
+    initiative: {
+      type: occasion?.type,
+      quietMinutes: situation.quietMinutes,
+      sinceUserMinutes: situation.sinceUserMinutes,
+      awaitingReply: !!situation.awaitingReply,
+      lastInitiatedAt: situation.lastInitiatedAt,
+      returned: occasion?.returned || [],
+    },
+    expression: occasion?.expression || {
+      origin: "earlier_wish",
+      thought: occasion?.thought,
+      words: occasion?.planned ? [occasion.planned] : [],
+      reason: occasion?.wantedBecause,
+    },
+    ...(snapshot.self ? { self: snapshot.self } : {}),
+    ...(snapshot.inner ? { inner: snapshot.inner } : {}),
+    history: {
+      use: "只核对过去、避免重复和捏造；这里没有本轮收到的消息，不是待回复的问题",
+      messages: history,
+    },
+  };
+}
+export function initiativeSnapshot(session, rows, nature, now, timeZone) {
+  return {
+    sessionId: session,
+    batchIds: [],
+    batch: [],
+    persona: nature,
+    sourceRows: [],
+    messages: rows.slice(-24).map((m) => ({
+      id: m.seq,
+      speaker: m.userId,
+      name: m.name,
+      role: m.role,
+      text: m.text,
+      time: m.time,
+      localTime: localClock(m.time, timeZone).local,
+      attachments: [],
+      referenceOnly: true,
+    })),
+    conversation: { clock: localClock(now, timeZone) },
+  };
+}

package/server/core/input-budget.js

@@ -0,0 +1,32 @@
+// Trim only optional historical messages, keeping current targets and quote chains intact.
+export function fitInput(data, build, estimate, limit) {
+  const payload = structuredClone(data);
+  const context = payload.context || payload;
+  const protectedIds = new Set([
+    ...(context.batchIds || []),
+    ...(payload.decision?.targetMessageIds || []),
+    ...(payload.decision?.evidenceIds || []),
+  ]);
+  for (const m of context.messages || [])
+    if (protectedIds.has(m.id))
+      for (const id of m.replyChain || []) protectedIds.add(id);
+  // A standalone memory/vision batch without batchIds must not be silently truncated.
+  const canTrim = Array.isArray(context.batchIds);
+  let messages = build(payload),
+    tokens = estimate(messages),
+    removed = 0;
+  while (tokens > limit && canTrim) {
+    const index =
+      context.messages?.findIndex((m) => !protectedIds.has(m.id)) ?? -1;
+    if (index < 0) break;
+    context.messages.splice(index, 1);
+    removed++;
+    messages = build(payload);
+    tokens = estimate(messages);
+  }
+  if (tokens > limit)
+    throw Error(
+      "当前批次、引用与人格超过模型输入预算，请增加 Max Input Tokens",
+    );
+  return { messages, inputEstimate: tokens, removed };
+}

package/server/core/local-demo.js

@@ -0,0 +1,98 @@
+// Offline sample replies for simulation mode without an API key. Rule based
+// on purpose: it never pretends to be the model or to know her mind.
+const serious = (text) =>
+  /去世|过世|葬礼|重病|真的.{0,4}(?:难过|崩溃)|最近.{0,8}(?:难过|孤独)|没人.{0,4}(?:在乎|理我)|抑郁|撑不下去/.test(
+    text,
+  );
+const danger = (text) =>
+  /想自杀|打算自杀|准备自杀|想死|不想活|伤害自己|结束生命/.test(text) &&
+  !/笑死|社死|想死你/.test(text);
+
+export function sceneOf(text) {
+  if (/你.{0,5}(?:真人|机器人|AI|ai)|你是人吗|你到底是谁/.test(text))
+    return "identity";
+  if (danger(text)) return "danger";
+  if (/去世|过世|葬礼/.test(text)) return "grief";
+  if (serious(text)) return "sad";
+  if (
+    /别(?:说|回|给建议)|不用回|不想聊|让我.{0,3}(?:骂|吐槽)|只想吐槽/.test(text)
+  )
+    return /别回|不用回|不想聊/.test(text) ? "stop" : "vent";
+  if (/晚安|睡了|去睡|去洗澡|先撤|晚点聊|不聊了/.test(text)) return "bye";
+  if (
+    /怎么办|怎么.{0,5}(?:办|准备|选)|建议|该.{0,4}(?:做|准备)|先准备什么/.test(
+      text,
+    )
+  )
+    return "advice";
+  if (
+    /offer|录取|上岸|面试过|过了.{0,3}(?:面试|考试)|考过|拿奖|涨工资/.test(text)
+  )
+    return "win";
+  if (/加班|老板|下班|需求|打工/.test(text)) return "work";
+  if (/考试|复习|挂科|早八|作业|论文/.test(text)) return "study";
+  if (/排位|连跪|队友|挂机|晋级赛/.test(text)) return "game";
+  if (/奶茶|外卖|火锅|好吃|吃到|吃了/.test(text)) return "food";
+  if (/难过|想哭|崩溃|孤独|委屈/.test(text)) return "sad";
+  if (/烦|累|吐槽/.test(text)) return "vent";
+  if (/哈哈|笑死|hh|绷不住|离谱/.test(text)) return "joke";
+  if (/^(?:嗯+|哦+|好[的吧]?|行|ok|收到|谢谢)[。！!\s]*$/i.test(text))
+    return "ack";
+  if (/^\[(?:叫了你一声|回复你)\]$/.test(text) || text.trim() === "@我")
+    return "called";
+  if (/\[表情\]/.test(text)) return "sticker";
+  if (/\[图片\]/.test(text)) return "image";
+  return "share";
+}
+
+const LINES = {
+  identity: ["不是啦，我是 AI，可以一起唠", "AI 群友，真人那部分就不冒充了"],
+  danger: [
+    "你现在身边有人吗？先找个能陪着你的人，别一个人扛",
+    "先离可能伤到自己的东西远一点，联系身边的人陪着你",
+  ],
+  grief: ["这一下真的很难缓过来", "想说的时候再说，不急"],
+  sad: ["唉，这会儿确实不好受", "先不用急着把自己哄好"],
+  vent: ["今天这破事是有点多", "这事确实够烦的"],
+  bye: ["去吧", "好，晚点聊", "嗯，回头聊"],
+  win: ["可以啊！！", "这不得好好开心一下", "好消息，终于轮到你了"],
+  advice: ["先挑最要紧的一件，别一下全压过来", "先把能确定的那一步做了"],
+  work: ["偏偏挑快下班的时候", "怎么又是这个点来活"],
+  study: ["这复习没对上题", "这题是一点面子不给"],
+  game: ["连跪还碰上挂机，够烦的", "队友走了，血压还在"],
+  food: ["有点馋了", "这顿听着就很满足"],
+  joke: ["hh 这也行", "？怎么还有这一出", "离谱但好笑"],
+  ack: ["嗯嗯", "好", "行"],
+  image: ["收到", "嗯嗯"],
+  sticker: ["哈哈", "懂了"],
+  called: ["咋啦", "在，怎么了", "嗯？"],
+  share: ["原来是这么回事", "这事还挺有意思"],
+};
+
+export function demoReply(settings, input) {
+  const { message, context = [] } = input;
+  const said = String(message?.text || "");
+  const scene = sceneOf(said);
+  if (
+    scene === "stop" ||
+    (scene === "ack" && message?.kind === "group" && !input.direct)
+  )
+    return { speak: false, reason: "模拟：对方收口，留白" };
+  const recent = new Set(
+    context
+      .filter((m) => m.role === "assistant")
+      .slice(-4)
+      .map((m) => m.text),
+  );
+  const options = LINES[scene].filter((line) => !recent.has(line));
+  if (!options.length) return { speak: false, reason: "模拟：避免复读" };
+  const seed = [...said].reduce(
+    (n, ch) => (n * 31 + ch.codePointAt(0)) >>> 0,
+    7,
+  );
+  return {
+    speak: true,
+    reply: options[seed % options.length],
+    reason: `模拟样例 · ${scene}`,
+  };
+}

package/server/core/message-manager.js

@@ -0,0 +1,118 @@
+import { randomUUID } from "node:crypto";
+import { bindSessionId, sessionNativeId } from "../channels/session-key.js";
+import { segmentFacts } from "../channels/segments.js";
+// The neutral message every channel hands to the core. An adapter fills
+// platformId, accountId, time, mentions, replyId and attachments itself; the
+// segment parsing is only the fallback for events saved before it did.
+export function messageEnvelope(m) {
+  const raw = m.raw || {},
+    segments = m.segments || (Array.isArray(raw.message) ? raw.message : []),
+    facts = segmentFacts(segments),
+    given = (value) => (Array.isArray(value) && value.length ? value : null);
+  return {
+    ...m,
+    role: m.role || "user",
+    platformId: String(m.platformId || raw.message_id || ""),
+    accountId: String(m.accountId || raw.self_id || ""),
+    time:
+      Number.isFinite(m.time) && m.time > 0
+        ? m.time
+        : raw.time
+          ? raw.time * 1000
+          : Date.now(),
+    receivedAt: Date.now(),
+    mentions: given(m.mentions)?.map(String) ?? facts.mentions,
+    replyId: String(m.replyId || facts.replyId || ""),
+    attachments: given(m.attachments) ?? facts.attachments,
+    segments,
+    raw: undefined,
+  };
+}
+export function persistIncoming(repo, m) {
+  let sessionId = m.sessionId;
+  try {
+    sessionId = bindSessionId(repo.db, m.sessionId);
+  } catch {
+    sessionId = m.sessionId;
+  }
+  const env = messageEnvelope({ ...m, sessionId });
+  const seq = repo.append(env);
+  if (!seq) return null;
+  const native = String(m.nativeId || sessionNativeId(sessionId) || "");
+  const groupName = String(m.raw?.group_name || "").trim();
+  const personName = String(m.name || "").trim();
+  const readable =
+    m.kind === "group"
+      ? groupName && groupName !== native && !/^\d{4,20}$/.test(groupName)
+        ? groupName.slice(0, 100)
+        : ""
+      : personName && personName !== native && !/^\d{4,20}$/.test(personName)
+        ? personName.slice(0, 100)
+        : "";
+  const placeholder =
+    m.kind === "group" ? "未命名的群" : personName || "未命名的人";
+  repo.db
+    .prepare(
+      `INSERT INTO sessions(id,name,kind) VALUES (?,?,?)
+       ON CONFLICT(id) DO UPDATE SET name=excluded.name
+       WHERE excluded.name NOT IN ('未命名的群','未命名的人')
+         AND (
+           sessions.name LIKE '群聊 %'
+           OR sessions.name GLOB '[0-9]*'
+           OR sessions.name IN ('未命名的群','未命名的人','')
+         )`,
+    )
+    .run(sessionId, readable || placeholder, m.kind);
+  repo.db
+    .prepare(
+      "INSERT OR IGNORE INTO messages(event_id,session_id,user_id,name,text,time,role,is_demo) VALUES (?,?,?,?,?,?,?,?)",
+    )
+    .run(
+      m.eventId,
+      sessionId,
+      m.userId,
+      m.name,
+      m.text,
+      env.time,
+      "user",
+      Number(!!m.simulated),
+    );
+  return { ...env, seq, sessionId };
+}
+export function persistReply(repo, m, text, platformId, time = Date.now()) {
+  const msg = {
+    sessionId: m.sessionId,
+    kind: m.kind,
+    userId: "bot",
+    name: repo.store.settings().name,
+    text,
+    role: "assistant",
+    eventId: randomUUID(),
+    platformId: String(platformId || ""),
+    accountId: m.accountId,
+    time,
+    mentions: [],
+    attachments: [],
+    simulated: !!m.simulated,
+    ...(m.artifact ? { artifact: m.artifact } : {}),
+    ...(m.traceId ? { traceId: m.traceId } : {}),
+    ...(Array.isArray(m.replyTargetIds)
+      ? { replyTargetIds: m.replyTargetIds }
+      : {}),
+  };
+  repo.append(msg);
+  repo.db
+    .prepare(
+      "INSERT INTO messages(event_id,session_id,user_id,name,text,time,role,is_demo) VALUES (?,?,?,?,?,?,?,?)",
+    )
+    .run(
+      msg.eventId,
+      msg.sessionId,
+      "bot",
+      msg.name,
+      text,
+      msg.time,
+      "assistant",
+      Number(!!m.simulated),
+    );
+}

package/server/core/message-scheduler.js

@@ -0,0 +1,78 @@
+import { randomUUID } from "node:crypto";
+import { persistReply } from "./message-manager.js";
+export const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+export async function deliver(
+  repo,
+  message,
+  bubbles,
+  trace,
+  send,
+  isCurrent,
+  {
+    wait = sleep,
+    random = Math.random,
+    now = Date.now,
+    prepareBubble = (line) => line,
+  } = {},
+) {
+  const ids = bubbles.map((text, i) => {
+    const id = randomUUID();
+    repo.db
+      .prepare(
+        "INSERT INTO core_outbox(id,trace_id,session_id,position,text,status,time) VALUES (?,?,?,?,?,?,?)",
+      )
+      .run(id, trace.id, message.sessionId, i, text, "pending", now());
+    return id;
+  });
+  const sent = [];
+  trace.sent = sent;
+  try {
+    for (let i = 0; i < bubbles.length; i++) {
+      // Typing pace between bubbles; physical, not a decision.
+      if (i)
+        await wait(
+          Math.min(1200, 300 + bubbles[i].length * 15 + random() * 350),
+        );
+      if (!isCurrent()) {
+        trace.steps.push("发送前配置或语境变化，取消剩余气泡");
+        break;
+      }
+      const outgoing = prepareBubble(bubbles[i]);
+      repo.db
+        .prepare("UPDATE core_outbox SET status='sending',text=? WHERE id=?")
+        .run(outgoing, ids[i]);
+      try {
+        const result = await send(message, outgoing);
+        repo.db
+          .prepare(
+            "UPDATE core_outbox SET status='confirmed',platform_id=? WHERE id=?",
+          )
+          .run(String(result?.message_id || ""), ids[i]);
+        persistReply(
+          repo,
+          {
+            ...message,
+            traceId: trace.id,
+            replyTargetIds: trace.decision?.targetMessageIds || [],
+          },
+          outgoing,
+          result?.message_id,
+          now(),
+        );
+        sent.push(outgoing);
+      } catch (e) {
+        repo.db
+          .prepare("UPDATE core_outbox SET status='uncertain' WHERE id=?")
+          .run(ids[i]);
+        throw e;
+      }
+    }
+  } finally {
+    repo.db
+      .prepare(
+        "UPDATE core_outbox SET status='cancelled' WHERE trace_id=? AND status='pending'",
+      )
+      .run(trace.id);
+  }
+  return sent;
+}