koishi-plugin-kkk 3.7.0 → 3.7.2

package/src/compat/imageMarkdown.ts

@@ -0,0 +1,263 @@
+/**
+ * 图片段 → markdown 图片（`![#宽px #高px](url)`）。
+ *
+ * 用户反馈两条，这里一起解决：
+ *   1. **「所有的图片发送都要走 md，不然太模糊了」** —— QQ 的普通图片消息（image 段 → 适配器按
+ *      MEDIA 上传）会被客户端二次压缩，卡片上的小字糊成一团；markdown 里的图片不会被压，字是清楚的。
+ *   2. **「![#px大小#px大小]() 必须要 #px，不然手机不会显示」** —— md 图片必须写死尺寸，
+ *      不写尺寸手机端干脆不显示这张图。
+ *
+ * 所以这里在**发送出口**统一改写：compat/node-karin 的 reply / sendMsg / sendMaster 四条路径都过一遍，
+ * 业务代码照旧 e.reply(segment.image(...))，不用一处处改。
+ *
+ * 只在「认 markdown 的平台」上生效（官方 QQ：`qq`）：
+ *   - OneBot 系（NapCat / Lagrange / go-cqhttp / Chronocat…）收到 markdown 只显示成一串文字、
+ *     图片全丢（用户实测），所以那条链路继续发图片段；
+ *   - QQ 频道（`qqguild`）的适配器没有 markdown 分支，md 元素会被当纯文本渲染 → 也排除。
+ *
+ * 另外三种情况**不动**（动了只会更糟）：
+ *   - 消息里还有视频 / 语音 / 文件：适配器遇到附件会把整条消息转成 MEDIA，markdown 内容会被丢掉；
+ *   - 合并转发收集中的消息：转发节点里塞 markdown 客户端不认；
+ *   - 上传拿不到公网地址（没装 assets 服务等）、或者**读不出图片尺寸**：保持原来的图片段。
+ *     读不出尺寸是可以退回普通图片的，但**绝不能发一张不带尺寸的 markdown 图片** ——
+ *     用户实测「必须要 #px，不然手机不会显示」，那种图上手机就是一片空白。
+ */
+import crypto from 'node:crypto'
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import { logger } from './logger'
+import { tryGetRuntime } from './runtime'
+import { segment } from './segment'
+
+/** OneBot 系：不渲染 markdown（见文件头） */
+const ONEBOT_LIKE = /onebot|napcat|lagrange|go-?cqhttp|chronocat|mirai/i
+
+/**
+ * 会渲染 markdown 图片的平台。
+ *
+ * 只认 `qq` 这一个平台名 —— QQ 的 markdown 是**官方机器人**能力，
+ * `qqguild`（频道）走的是另一套编码器，md 元素在那里会被当成纯文本原样发出去。
+ */
+const canUseMarkdownImage = (platform: string): boolean => {
+  const name = String(platform || '').toLowerCase()
+  if (!name) return false
+  if (ONEBOT_LIKE.test(name)) return false
+  if (name.startsWith('qqguild')) return false
+  return name === 'qq' || name.startsWith('qq-') || name.startsWith('qqbot')
+}
+
+/** 媒体段：md 和附件不能塞进同一条消息（会被适配器吃掉），所以要跳过整条改写 */
+const ATTACHMENT_TYPES = new Set(['video', 'audio', 'record', 'file'])
+
+const isImageElement = (element: any): boolean =>
+  !!element && typeof element === 'object' && (element.type === 'img' || element.type === 'image')
+
+const srcOf = (element: any): string => {
+  const attrs = element?.attrs ?? {}
+  const src = attrs.src ?? attrs.url ?? element?.data?.file ?? element?.data?.url
+  return typeof src === 'string' ? src : ''
+}
+
+/** 按二进制头认 mime（发给 assets 用；标错会让适配器按错格式处理） */
+const mimeOfBuffer = (buffer: Buffer): string => {
+  if (buffer.length >= 8 && buffer[0] === 0x89 && buffer.toString('latin1', 1, 4) === 'PNG') return 'image/png'
+  if (buffer.length >= 3 && buffer[0] === 0xff && buffer[1] === 0xd8) return 'image/jpeg'
+  if (buffer.length >= 6 && buffer.toString('latin1', 0, 3) === 'GIF') return 'image/gif'
+  if (buffer.length >= 12 && buffer.toString('latin1', 0, 4) === 'RIFF' && buffer.toString('latin1', 8, 12) === 'WEBP') return 'image/webp'
+  return 'image/jpeg'
+}
+
+/**
+ * 读出图片的**真实像素尺寸** —— md 里的 `#宽px #高px` 就靠它。
+ *
+ * 不引第三方库：卡片是 JPEG、图集是 JPEG、二维码是 PNG、实况图封面是 WebP，四种头都自己认，
+ * 免得又出现「取不到尺寸 → 正方形拉伸」或「没写尺寸 → 手机不显示」。
+ */
+const readImageSize = (buffer: Buffer): { width: number; height: number } => {
+  // PNG：IHDR 就在固定偏移
+  if (buffer.length >= 24 && buffer[0] === 0x89 && buffer.toString('latin1', 1, 4) === 'PNG') {
+    return { width: buffer.readUInt32BE(16), height: buffer.readUInt32BE(20) }
+  }
+  // GIF：逻辑屏幕描述符，小端
+  if (buffer.length >= 10 && buffer.toString('latin1', 0, 3) === 'GIF') {
+    return { width: buffer.readUInt16LE(6), height: buffer.readUInt16LE(8) }
+  }
+  // JPEG：扫到 SOF 段（SOF0..SOF15，跳过 DHT/DAC 这些非 SOF 标记）
+  if (buffer.length > 4 && buffer[0] === 0xff && buffer[1] === 0xd8) {
+    let offset = 2
+    while (offset + 9 < buffer.length) {
+      if (buffer[offset] !== 0xff) { offset++; continue }
+      const marker = buffer[offset + 1]
+      if (marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc) {
+        return { height: buffer.readUInt16BE(offset + 5), width: buffer.readUInt16BE(offset + 7) }
+      }
+      const length = buffer.readUInt16BE(offset + 2)
+      if (length <= 0) break
+      offset += 2 + length
+    }
+  }
+  // WebP：VP8X（扩展）/ VP8L（无损）/ VP8（有损）三种头的写法都不一样
+  if (buffer.length >= 30 && buffer.toString('latin1', 0, 4) === 'RIFF' && buffer.toString('latin1', 8, 12) === 'WEBP') {
+    const format = buffer.toString('latin1', 12, 16)
+    if (format === 'VP8X') {
+      return { width: 1 + buffer.readUIntLE(24, 3), height: 1 + buffer.readUIntLE(27, 3) }
+    }
+    if (format === 'VP8L') {
+      const bits = buffer.readUInt32LE(21)
+      return { width: 1 + (bits & 0x3fff), height: 1 + ((bits >> 14) & 0x3fff) }
+    }
+    if (format === 'VP8 ') {
+      return { width: buffer.readUInt16LE(26) & 0x3fff, height: buffer.readUInt16LE(28) & 0x3fff }
+    }
+  }
+  return { width: 0, height: 0 }
+}
+
+/** 把各种写法读成 Buffer：data URI / base64:// / file:// / 本地路径 / http(s) */
+const loadImageBuffer = async (src: string): Promise<Buffer | null> => {
+  try {
+    if (src.startsWith('base64://')) return Buffer.from(src.slice('base64://'.length), 'base64')
+    if (src.startsWith('data:')) {
+      const comma = src.indexOf(',')
+      if (comma < 0) return null
+      return Buffer.from(src.slice(comma + 1), 'base64')
+    }
+    const localPath = src.startsWith('file://') ? fileURLToPath(src) : src
+    if (!/^https?:\/\//i.test(src)) {
+      if (fs.existsSync(localPath)) return fs.readFileSync(localPath)
+      return null
+    }
+    const response = await fetch(src)
+    if (!response.ok) {
+      logger.mark('[图片md] 下载失败 HTTP ' + response.status + ': ' + src.slice(0, 80))
+      return null
+    }
+    return Buffer.from(await response.arrayBuffer())
+  } catch (error: any) {
+    logger.mark('[图片md] 读取图片失败: ' + String(error?.message ?? error).slice(0, 120))
+    return null
+  }
+}
+
+/**
+ * 上传到宿主的 assets，拿到 QQ 能直接取的 https 地址。
+ *
+ * md 里的图片地址**必须是公网 http(s)**：适配器只对 data: 图片做特殊处理
+ * （见 qq-crack 的 renderMarkdownDataImages —— data 图片会被它转回 MEDIA 上传，等于白改），
+ * 相对路径/本地路径手机端也取不到。
+ */
+let warnedNoAssets = false
+
+const uploadImage = async (buffer: Buffer): Promise<string | null> => {
+  const assets: any = (tryGetRuntime() as any)?.ctx?.assets
+  if (!assets?.upload) {
+    /** 没装 assets 服务就整条链路都用不了，提示一次就够，别每张图刷一遍日志 */
+    if (!warnedNoAssets) {
+      warnedNoAssets = true
+      logger.mark('[图片md] 宿主没有 assets 服务（拿不到公网图片地址），图片继续按普通图片段发送')
+    }
+    return null
+  }
+  const mime = mimeOfBuffer(buffer)
+  const ext = mime === 'image/png' ? '.png' : mime === 'image/gif' ? '.gif' : mime === 'image/webp' ? '.webp' : '.jpg'
+  try {
+    const uploaded: any = await assets.upload('data:' + mime + ';base64,' + buffer.toString('base64'), 'kkk-md' + ext)
+    const url = typeof uploaded === 'string' ? uploaded : uploaded?.url
+    return url && /^https?:\/\//i.test(String(url)) ? String(url) : null
+  } catch (error: any) {
+    logger.mark('[图片md] 上传失败: ' + String(error?.message ?? error).slice(0, 120))
+    return null
+  }
+}
+
+/**
+ * 同一张图反复发（推送里的封面、面板卡片…）不用反复上传：
+ * 按图片内容摘要缓存结果，顺带省掉重复的下载与解码。
+ */
+const imageCache = new Map<string, string | null>()
+const IMAGE_CACHE_MAX = 200
+
+/** 图片段 → md 图片字符串；拿不到尺寸/地址就返回 null（调用方保持原样，别把图弄丢） */
+export const markdownImageOf = async (src: string): Promise<string | null> => {
+  if (!src) return null
+  const key = crypto.createHash('md5').update(src).digest('hex')
+  const cached = imageCache.get(key)
+  if (cached) return cached
+  const buffer = await loadImageBuffer(src)
+  let result: string | null = null
+  if (buffer && buffer.length) {
+    const { width, height } = readImageSize(buffer)
+    /**
+     * **读不出尺寸就不换成 markdown**（退回普通图片段）。
+     *
+     * 用户实测：「必须要 #px，不然手机不会显示」—— 不带尺寸的 md 图片在手机端干脆是空白，
+     * 比糊更糟。所以这里宁可发一张（会被压糊但看得见的）普通图片，
+     * 也不发一张手机上什么都不显示的 markdown 图片。
+     */
+    if (width > 0 && height > 0) {
+      const url = await uploadImage(buffer)
+      if (url) result = '![#' + width + 'px #' + height + 'px](' + url + ')'
+    }
+  }
+  /**
+   * **只缓存成功的结果**：网络 / 图床抖动导致的失败要是也缓存下来，
+   * 这张图之后就一直按普通图片发（糊），得等重启才能恢复。
+   */
+  if (result) {
+    if (imageCache.size >= IMAGE_CACHE_MAX) imageCache.delete(imageCache.keys().next().value as string)
+    imageCache.set(key, result)
+  } else {
+    logger.debug('[图片md] 这张图这次没转成 markdown，按普通图片发送: ' + src.slice(0, 60))
+  }
+  return result
+}
+
+/** 清空缓存（测试用） */
+export const clearMarkdownImageCache = (): void => { imageCache.clear() }
+
+/**
+ * 把一条消息里的图片段改写成 markdown 图片（其它段原样保留、顺序不变）。
+ *
+ * 连续的图片合成**一个** markdown 元素（换行分隔）—— 和官方 QQ 的渲染习惯一致：
+ * 连续图片紧贴显示，视觉上仍是一整张卡片，而不是一张一张孤立的图。
+ *
+ * @param elements 已归一化的消息元素数组
+ * @param platform 适配器平台名（kompat 层从 bot.platform / session.platform 取）
+ * @returns 改写后的数组；不该改或改不动时**原样返回**，绝不让消息发不出去
+ */
+export const imagesToMarkdown = async (elements: any[], platform: string): Promise<any[]> => {
+  const list = Array.isArray(elements) ? elements : []
+  if (!list.length) return list
+  if (!canUseMarkdownImage(platform)) return list
+  if (!list.some(isImageElement)) return list
+  if (list.some((element) => ATTACHMENT_TYPES.has(String(element?.type ?? '')))) return list
+
+  const out: any[] = []
+  /** 攒着的连续图片（遇到非图片段就冲出去） */
+  let run: string[] = []
+  const flushRun = () => {
+    // 有图转不动（上传失败等）时 run 里会是空串占位，这里只冲有内容的
+    if (run.length) out.push(segment.markdown(run.join(String.fromCharCode(10))))
+    run = []
+  }
+
+  for (const element of list) {
+    if (!isImageElement(element)) {
+      flushRun()
+      out.push(element)
+      continue
+    }
+    const markdown = await markdownImageOf(srcOf(element))
+    if (markdown) {
+      run.push(markdown)
+    } else {
+      // 转不了就把它自己按图片段发出去，别丢
+      flushRun()
+      out.push(element)
+    }
+  }
+  flushRun()
+  return out
+}

package/src/compat/node-karin.ts

@@ -20,6 +20,7 @@ import { isSemverGreater } from '../karin/module/utils/semver'
 import { resolveAdapterInfo } from './adapter-info'
 import { logger } from './logger'
 import { COLLECTED_MESSAGE_ID, collectForward } from './forward-collect'
+import { imagesToMarkdown } from './imageMarkdown'
 import { UnconfirmedSendError, classifySendFailure, decorateSendError, describeSendFailure, isPassiveLimitFailure } from './sendError'
 import { commandQueue, eventQueue, getRuntime, karinPathBase, taskQueue, tryGetRuntime } from './runtime'
 import { segment } from './segment'
@@ -250,13 +251,15 @@ export class KkkBot {
     }
 
     // 退化路径：整条发一次；失败再逐个元素发，尽量把内容送出去
+    /** 退化发送 = 直接发消息，所以图片同样要改走 markdown（见 compat/imageMarkdown） */
+    const fallback = await imagesToMarkdown(payload.elements, platformOfBot(this.bot))
     try {
-      const ids = await this.bot.sendMessage(channelId, payload.elements as any)
+      const ids = await this.bot.sendMessage(channelId, fallback as any)
       return { messageId: ids[ids.length - 1] ?? '' }
     } catch (error) {
       logger.warn('整条发送失败，改为逐个元素发送: ' + String((error as any)?.message ?? error))
       let lastId = ''
-      for (const item of payload.elements) {
+      for (const item of fallback) {
         const ids = await this.bot.sendMessage(channelId, [item] as any)
         lastId = ids[ids.length - 1] ?? lastId
       }
@@ -351,10 +354,13 @@ export class KkkBot {
 
   /** 发送消息（karin 的 bot.sendMsg） */
   async sendMsg (contact: Contact | string, content: any, _options?: any): Promise<{ messageId: string }> {
+    const elements = normalizeContent(content)
     /** 解析结果合并转发：正在收集就攒起来（见 compat/forward-collect） */
-    if (collectForward(peerOf(contact), content)) return { messageId: COLLECTED_MESSAGE_ID }
+    if (collectForward(peerOf(contact), elements)) return { messageId: COLLECTED_MESSAGE_ID }
     const channelId = typeof contact === 'string' ? contact : contact.peer
-    const ids = await this.bot.sendMessage(channelId, normalizeContent(content) as any)
+    /** 图片统一改走 markdown（见 compat/imageMarkdown） */
+    const outgoing = await imagesToMarkdown(elements, platformOfBot(this.bot))
+    const ids = await this.bot.sendMessage(channelId, outgoing as any)
     // 同 reply/uploadFile：**没拿到消息 ID 就是没发出去**，别当成功返回
     const id = ids?.[ids.length - 1] ?? ''
     if (!id) {
@@ -480,13 +486,22 @@ export class Message {
    * 这时自动改用**主动消息**（不带引用，直接往频道里发），失败才把原错误抛出去。
    */
   async reply (content: any, _options?: any): Promise<{ messageId: string; rawData?: any }> {
-    const elements = normalizeContent(content)
+    const raw = normalizeContent(content)
 
     /**
      * 解析结果合并转发：正在收集就攒起来，等解析结束发一条转发（见 compat/forward-collect）。
      * 回一个假的消息 ID：调用方普遍只看「有没有拿到 ID」（例如 uploadFile 判断发送成没成功）。
      */
-    if (collectForward(this.contact?.peer ?? '', elements)) return { messageId: COLLECTED_MESSAGE_ID }
+    if (collectForward(this.contact?.peer ?? '', raw)) return { messageId: COLLECTED_MESSAGE_ID }
+
+    /**
+     * **图片统一改走 markdown**（上传拿公网地址 + 写死 `#宽px #高px`），见 compat/imageMarkdown。
+     *
+     * 放在这里是因为它是**所有回复的唯一出口** —— 业务代码一律 `e.reply(...)`，
+     * 不用一处处改业务代码。转换不成功会退回原来的图片段（绝不把图弄丢）。
+     * 上面的合并转发分支已经返回了，所以转发节点里仍然是普通图片段。
+     */
+    const elements = await imagesToMarkdown(raw, platformOfMessage(this))
 
     /**
      * 没拿到消息 ID 就是**没发出去**（对齐 qq-chat 的判法）。
@@ -585,6 +600,21 @@ function peerOf (contact: Contact | string): string {
   return typeof contact === 'string' ? contact : String((contact as Contact)?.peer ?? '')
 }
 
+/**
+ * 适配器平台名。
+ *
+ * 发送出口要用它判断「这个平台认不认 markdown 图片」（见 compat/imageMarkdown）：
+ * KkkBot 包装上直接转发真实 Bot 的 platform，传 KkkBot 或裸 Bot 都能取到。
+ */
+function platformOfBot (bot: any): string {
+  return String(bot?.platform ?? bot?.bot?.platform ?? '')
+}
+
+/** 同上，从消息事件取（会话上就带 platform，拿不到再问 bot） */
+function platformOfMessage (message: Message): string {
+  return String(message.session?.platform ?? platformOfBot(message.bot))
+}
+
 /**
  * 合并转发的载荷。
  *
@@ -718,18 +748,22 @@ async function sendMsg (selfId: string, contact: Contact | string, content: any,
       + '），这条消息发不出去。等它重新上线后下次推送会正常发出；如果是长期不在线，检查一下适配器连接')
   }
   const channelId = peerOf(contact)
+  const elements = normalizeContent(content)
   /** 解析结果合并转发：这条也走漏斗（karin.sendMsg 是业务代码另一条常用出口） */
-  if (collectForward(channelId, normalizeContent(content))) {
+  if (collectForward(channelId, elements)) {
     return { messageId: COLLECTED_MESSAGE_ID, rawData: [] }
   }
-  const ids = await bot.bot.sendMessage(channelId, normalizeContent(content) as any)
+  /** 图片统一改走 markdown（见 compat/imageMarkdown） */
+  const outgoing = await imagesToMarkdown(elements, platformOfBot(bot.bot))
+  const ids = await bot.bot.sendMessage(channelId, outgoing as any)
   return { messageId: ids[ids.length - 1] ?? '', rawData: ids }
 }
 
 async function sendMaster (botId: string, master: string, content: any, _options?: any) {
   const bot = resolveBot(botId)
   if (!bot) throw new Error('[kkk] 没有可用的机器人实例，无法发送消息')
-  const elements = normalizeContent(content)
+  // 图片统一改走 markdown（见 compat/imageMarkdown）：私聊和群里一样，md 图片才不会被压糊
+  const elements = await imagesToMarkdown(normalizeContent(content), platformOfBot(bot.bot))
   const target = bot.bot as any
   // Satori 的 Bot 有 sendPrivateMessage；个别适配器没有，退化成私聊频道 id
   const ids = typeof target.sendPrivateMessage === 'function'

package/src/karin/module/utils/Base.ts

@@ -24,11 +24,29 @@ import {
 // 解析阶段（「下载进度」指令读的就是这里登记的状态）
 import { DOWNLOAD_STAGES, clearParseStage, updateDownloadStage } from './Network/Downloader'
 
+/** 发送结果里把消息 ID 抠出来（不同适配器返回的形状不一样：对象带 messageId、或者就是字符串数组） */
+const reportSent = (options: uploadFileOptions | undefined, sent: any): void => {
+  if (!options?.onSent) return
+  try {
+    const id = typeof sent === 'string'
+      ? sent
+      : (sent?.messageId ?? (Array.isArray(sent) ? sent[0] : ''))
+    if (id) options.onSent(String(id))
+  } catch { /* 拿不到 ID 不影响发送本身 */ }
+}
+
 type uploadFileOptions = {
   /** 是否使用群文件上传 */
   useGroupFile?: boolean
   /** 消息ID，如果有，则将使用该消息ID制作回复元素 */
   message_id?: string
+  /**
+   * 发出去了把消息 ID 交回来（可选）。
+   *
+   * 互动视频用它：下一段播出来之后要**撤回上一段那条视频**，群里只留当前这一段
+   * （不然点几次剧情，群里就躺着一串视频）。
+   */
+  onSent?: (messageId: string) => void
   /** 是否为主动消息 */
   active?: boolean
   /** 主动消息参数 */
@@ -351,12 +369,14 @@ export const uploadFile = async (event: Message, file: fileInfo, videoUrl: strin
         // 是群文件
         const bot = karin.getBot(String(options.activeOption?.uin))!
         logger.mark(`${logger.blue('主动消息:')} 视频大小: ${newFileSize.toFixed(1)}MB 正在通过${logger.yellow('bot.uploadFile')}回复...`)
-        await bot.uploadFile(contact, File, file.originTitle ? `${file.originTitle}.mp4` : `${File.split('/').pop()}`)
+        const sent: any = await bot.uploadFile(contact, File, file.originTitle ? `${file.originTitle}.mp4` : `${File.split('/').pop()}`)
+        reportSent(options, sent)
       } else {
         // 不是群文件
         logger.mark(`${logger.blue('主动消息:')} 视频大小: ${newFileSize.toFixed(1)}MB 正在通过${logger.yellow('karin.sendMsg')}回复...`)
         // 兼容层已经把「没拿到消息 ID」当成失败抛出（见 compat/sendError），所以这里没有异常就是发出去了
-        await karin.sendMsg(selfId, contact, [segment.video(File)], { retryCount: 0 })
+        const sent: any = await karin.sendMsg(selfId, contact, [segment.video(File)], { retryCount: 0 })
+        reportSent(options, sent)
         sendStatus = true
       }
     } else {
@@ -364,12 +384,14 @@ export const uploadFile = async (event: Message, file: fileInfo, videoUrl: strin
       if (useGroupFile) {
         // 是文件
         logger.mark(`${logger.blue('被动消息:')} 视频大小: ${newFileSize.toFixed(1)}MB 正在通过${logger.yellow('e.bot.uploadFile')}回复...`)
-        await event.bot.uploadFile(event.contact, File, file.originTitle ? `${file.originTitle}.mp4` : `${File.split('/').pop()}`)
+        const sent: any = await event.bot.uploadFile(event.contact, File, file.originTitle ? `${file.originTitle}.mp4` : `${File.split('/').pop()}`)
+        reportSent(options, sent)
       } else {
         // 不是文件
         logger.mark(`${logger.blue('被动消息:')} 视频大小: ${newFileSize.toFixed(1)}MB 正在通过${logger.yellow('e.reply')}回复...`)
         // 同上：异常才是失败（没拿到消息 ID 已经由兼容层抛出来了）
-        await event.reply(segment.video(File) || videoUrl)
+        const sent: any = await event.reply(segment.video(File) || videoUrl)
+        reportSent(options, sent)
         sendStatus = true
       }
     }

package/src/karin/platform/bilibili/bilibili.ts

@@ -85,7 +85,11 @@ import {
   buildBilibiliVideoDescRichText,
   getUsernameMetadata
 } from '@/platform/bilibili/dynamic-text'
-import { runInteractiveStory, renderInteractiveChart as renderChart } from '@/platform/bilibili/interactive-story'
+import {
+  rememberStoryVideo,
+  renderInteractiveChart as renderChart,
+  runInteractiveStory
+} from '@/platform/bilibili/interactive-story'
 import { BilibiliDataTypes } from '@/types'
 
 let img: ElementTypes[]
@@ -664,14 +668,13 @@ export class Bilibili extends Base {
               await downloadTask
               await this.sendPreparedVideo()
               /**
-               * 互动视频：**群里不再发「选择按钮」了**（用户要求）。
-               *
-               * 剧情选择整个搬到播放页上（选项贴在视频上、点完显示加载进度）；
-               * 群里如果还同步问一遍，用户会被两处剧情各问一次。
-               * 只有「视频直接发到群里、没走播放页」时，顺手补一张**剧情图**（图片，不是按钮）——
-               * 用户至少能看到这张图里有几条分支。
+               * 互动视频的剧情怎么走，看这次的视频发到哪儿：
+               *   · **走在线播放**（视频没发进群里，用户在看播放页）→ 选项在播放页上贴出来，
+               *     群里不再问一遍，免得两处各问一次（见 sendPreparedVideo 里的 story）；
+               *   · **直接发到群里**（没有播放页）→ 照旧在群里发**带按钮的选择面板**，
+               *     用户点一下播下一段，并撤回上一段视频（用户要求）。
                */
-              if (this.interactive && !this.publishedStory) void this.sendInteractiveChartOnly()
+              if (this.interactive && !this.publishedStory) void this.startInteractiveStory()
             })
           }
         }
@@ -1935,35 +1938,6 @@ export class Bilibili extends Base {
     return this.preparedVideo !== null
   }
 
-  /**
-   * 互动视频发到群里时：只补一张**剧情图**，不问选项（用户要求：群里不要选择按钮）。
-   *
-   * 选项流程在播放页里（见 sendPreparedVideo 的 story）；这里只把「有几条分支」画出来。
-   * 失败只记日志 —— 出不了图不影响视频已经发出去这件事。
-   */
-  private async sendInteractiveChartOnly (): Promise<void> {
-    const interactive = this.interactive
-    if (!interactive) return
-    /** 没勾「流程图」就什么都不做（配置说了算） */
-    if (!Config.bilibili.sendContent.some((item) => item === 'chart')) return
-    try {
-      const info = await fetchInteractiveInfo({ bvid: interactive.bvid, cid: interactive.cid, headers: this.headers })
-      if (!info) return
-      await renderChart({
-        e: this.e,
-        bvid: interactive.bvid,
-        graphVersion: info.graphVersion,
-        cid: interactive.cid,
-        title: this.workInfo?.title ?? '互动视频',
-        notice: info.notice,
-        headers: this.headers,
-        full: true
-      })
-    } catch (error: any) {
-      logger.debug('[互动视频] 群里补剧情图失败（不影响视频）: ' + String(error?.message ?? error))
-    }
-  }
-
   /**
    * 起一次互动剧情（后台长跑，不阻塞解析主流程）。
    *
@@ -2136,10 +2110,17 @@ export class Bilibili extends Base {
       }
       logger.warn('[在线播放] 播放会话登记失败，退回直接发送视频文件')
     }
+    /**
+     * 互动视频（发到群里的那种）：把这条视频的消息 ID 记下来 ——
+     * 用户点了下一个选项之后，这条要撤回，群里只留当前这一段。
+     */
+    const sentOptions = this.interactive
+      ? { onSent: (messageId: string) => rememberStoryVideo(this.e, messageId) }
+      : undefined
     if (totalBytes > Config.app.groupfilevalue) {
-      await uploadFile(this.e, { filepath, totalBytes, originTitle }, videoUrl ?? '', { useGroupFile: true })
+      await uploadFile(this.e, { filepath, totalBytes, originTitle }, videoUrl ?? '', { useGroupFile: true, ...sentOptions })
     } else {
-      await uploadFile(this.e, { filepath, totalBytes, originTitle }, videoUrl ?? '')
+      await uploadFile(this.e, { filepath, totalBytes, originTitle }, videoUrl ?? '', sentOptions)
     }
     return true
   }

package/src/karin/platform/bilibili/interactive-story.ts

@@ -41,6 +41,42 @@ export const RENDER_CHART_COMMAND = '渲染流程图'
 /** 每个频道最近一条「选项消息」，用于发下一条之前撤回 */
 const lastChoiceMessages = new Map<string, string>()
 
+/**
+ * 每个频道最近一条「剧情视频」的消息 ID。
+ *
+ * 用户要求：点一下选项，**上一段视频也要撤回** —— 不然玩几段之后群里躺着一串视频。
+ * 视频是解析链路发的（不是这里发的），所以由那边把它发出去的消息 ID 记进来。
+ */
+const lastStoryVideos = new Map<string, string>()
+
+/** 记下刚发出去的剧情视频（由解析链路在上传成功时调用） */
+export const rememberStoryVideo = (e: Message, messageId: string | undefined): void => {
+  if (!messageId) return
+  lastStoryVideos.set(sessionKeyOf(e), String(messageId))
+}
+
+/**
+ * 取出并清掉「上一条剧情视频」的消息 ID。
+ *
+ * 取出来就删：这条只该被撤回一次，撤回失败也不能反复去点。
+ */
+const takeStoryVideo = (e: Message): string | undefined => {
+  const key = sessionKeyOf(e)
+  const messageId = lastStoryVideos.get(key)
+  if (messageId) lastStoryVideos.delete(key)
+  return messageId
+}
+
+/** 撤回某条消息（失败只记日志，绝不影响剧情） */
+const recallMessage = async (e: Message, messageId: string | undefined): Promise<void> => {
+  if (!messageId) return
+  try {
+    await (e.bot as any)?.recallMsg?.(messageId, channelOf(e))
+  } catch (error: any) {
+    logger.debug('[互动视频] 撤回消息失败: ' + String(error?.message ?? error))
+  }
+}
+
 const platformOf = (e: any): string =>
   String(e?.bot?.bot?.platform ?? e?.bot?.platform ?? e?.platform ?? '')
 
@@ -358,11 +394,19 @@ export const runInteractiveStory = async (options: StoryOptions): Promise<StoryR
     currentCid = choice.cid
 
     if (play) {
+      /**
+       * 用户要求：点一下选项，**上一段视频也要撤回**（群里只留当前这一段）。
+       *
+       * 顺序是「发新的 → 撤旧的」：先取走旧 ID（新的那条发出去时会被重新记上），
+       * 新的发完再撤旧的 —— 中间不会出现「一段视频都没有」的空档。
+       */
+      const previousVideo = takeStoryVideo(target)
       try {
         await play(currentCid, target)
       } catch (error: any) {
         logger.warn('[互动视频] 播放下一段失败（cid=' + currentCid + '）: ' + String(error?.message ?? error))
       }
+      await recallMessage(target, previousVideo)
     }
     node = { ...next, cid: currentCid }
   }