koishi-plugin-music-to-voice 1.0.1 → 1.0.2

package/src/index.ts

@@ -1,460 +1,428 @@
-import { Context, Schema, h, Logger, Session, isNullable } from 'koishi'
-import os from 'node:os'
+import { Context, Schema, h, Logger, Session } from 'koishi'
 import fs from 'node:fs'
-import crypto from 'node:crypto'
 import path from 'node:path'
-import { pathToFileURL } from 'node:url'
+import os from 'node:os'
+import crypto from 'node:crypto'
+import { spawn } from 'node:child_process'
 
 export const name = 'music-to-voice'
 const logger = new Logger(name)
 
-// ✅ 只声明可选依赖，不在后台日志刷屏
-export const inject = {
-  required: ['http', 'i18n'],
-  optional: ['puppeteer', 'downloads', 'ffmpeg', 'silk'],
-} as const
-
-// ✅ 提示放插件设置页，不要后台日志输出
-export const usage = `
----
-
-本插件提供“点歌 → 列表选序号 → 发送语音/音频/文件”的音乐聚合能力。
-
-数据来源：**GD音乐台 API**（https://music-api.gdstudio.xyz/api.php）
-
----
-
-## 开启插件前，请确保以下服务已经启用（可选安装）
-
-所需服务：
-
-- puppeteer 服务（可选安装，用于图片歌单）
-
-此外可能还需要这些服务才能发送语音（最稳：下载 + 转码）：
-
-- downloads 服务（可选安装）
-- ffmpeg 服务（可选安装，可能依赖 downloads）
-- silk 服务（可选安装）
-
----
-`
-
-type MusicSource = 'netease' | 'tencent' | 'kugou' | 'kuwo' | 'migu'
-type SendAs = 'record' | 'audio' | 'file'
-
 export interface Config {
   commandName: string
   commandAlias: string
-
   apiBase: string
-  source: MusicSource
+  source: 'netease' | 'tencent' | 'kugou' | 'kuwo' | 'migu'
   searchListCount: number
-
-  imageMode: boolean
-  textColor?: string
-  backgroundColor?: string
+  waitForTimeout: number
 
   nextPageCommand: string
   prevPageCommand: string
   exitCommandList: string[]
   menuExitCommandTip: boolean
 
-  waitForTimeout: number
-  generationTip: string
+  // 撤回策略
+  menuRecallSec: number
+  tipRecallSec: number
+  recallOnlyAfterSuccess: boolean
+  keepMenuIfSendFailed: boolean
 
-  sendAs: SendAs
+  // 发送
+  sendAs: 'record' | 'audio' | 'file'
   forceTranscode: boolean
+  maxSongDuration: number // 分钟，0=不限制
+  userAgent: string
+  generationTip: string
+}
 
-  // 勾选=撤回/不保留
-  recallMenu: boolean
-  recallGeneratingTip: boolean
-  recallSongMessage: boolean
-  recallTimeoutTip: boolean
-  recallExitTip: boolean
-  recallInvalidTip: boolean
-  recallFetchFailTip: boolean
-
-  // 频率限制（可选）
-  enableRateLimit: boolean
-  rateLimitScope?: 'user' | 'channel' | 'platform'
-  rateLimitIntervalSec?: number
+/**
+ * 可选注入：不装也能跑，只是能力不同
+ * - downloads：下载到文件
+ * - silk：编码 silk（QQ 语音更稳）
+ * - ffmpeg：转 PCM（silk 前置）
+ * - puppeteer：未来可做图片歌单（你现在先不启用也没事）
+ */
+export const inject = {
+  optional: ['downloads', 'ffmpeg', 'silk', 'puppeteer'],
 }
 
-export const Config: Schema<Config> = Schema.intersect([
-  Schema.object({
-    commandName: Schema.string().default('听歌').description('指令名称'),
-    commandAlias: Schema.string().default('music2').description('指令别名（避免命令冲突）'),
-  }).description('基础设置'),
-
-  Schema.object({
-    apiBase: Schema.string().default('https://music-api.gdstudio.xyz/api.php').description('GD音乐台 API 地址'),
-    source: Schema.union([
-      Schema.const('netease').description('源1'),
-      Schema.const('tencent').description('源2'),
-      Schema.const('kugou').description('源3'),
-      Schema.const('kuwo').description('源4'),
-      Schema.const('migu').description('源5'),
-    ])
-      .default('kuwo')
-      .description('音源（下拉选择）'),
-    searchListCount: Schema.natural().min(5).max(50).default(20).description('每页显示条数'),
-  }).description('API 设置'),
-
-  Schema.object({
-    imageMode: Schema.boolean().default(false).description('图片歌单模式（需要 puppeteer，可选安装）'),
-    textColor: Schema.string().role('color').default('rgba(255,255,255,1)').description('图片歌单文字颜色'),
-    backgroundColor: Schema.string().role('color').default('rgba(0,0,0,1)').description('图片歌单背景颜色'),
-  }).description('歌单样式'),
-
-  Schema.object({
-    nextPageCommand: Schema.string().default('下一页').description('下一页指令'),
-    prevPageCommand: Schema.string().default('上一页').description('上一页指令'),
-    exitCommandList: Schema.array(Schema.string()).default(['0', '退出', '不听了']).description('退出指令列表'),
-    menuExitCommandTip: Schema.boolean().default(false).description('是否在歌单尾部提示退出指令'),
-    waitForTimeout: Schema.natural().min(5).max(180).default(45).description('等待输入序号超时（秒）'),
-    generationTip: Schema.string().default('生成语音中…').description('生成提示文本'),
-  }).description('交互设置'),
-
-  Schema.object({
-    sendAs: Schema.union([
-      Schema.const('record').description('语音 record'),
-      Schema.const('audio').description('音频 audio'),
-      Schema.const('file').description('文件 file'),
-    ])
-      .default('record')
-      .description('发送类型'),
-    forceTranscode: Schema.boolean()
-      .default(true)
-      .description('最稳模式：下载 + ffmpeg + silk 转码（可选依赖，缺依赖自动降级直链）'),
-  }).description('发送设置'),
-
-  Schema.object({
-    recallMenu: Schema.boolean().default(true).description('撤回歌单消息'),
-    recallGeneratingTip: Schema.boolean().default(true).description('撤回生成提示消息'),
-    recallSongMessage: Schema.boolean().default(false).description('撤回歌曲消息（语音/音频/文件）'),
-    recallTimeoutTip: Schema.boolean().default(true).description('撤回超时提示'),
-    recallExitTip: Schema.boolean().default(false).description('撤回退出提示'),
-    recallInvalidTip: Schema.boolean().default(false).description('撤回序号错误提示'),
-    recallFetchFailTip: Schema.boolean().default(true).description('撤回获取失败提示'),
-  }).description('撤回设置'),
-
-  Schema.object({
-    enableRateLimit: Schema.boolean().default(false).description('是否开启频率限制'),
-    rateLimitScope: Schema.union([
-      Schema.const('user').description('按用户'),
-      Schema.const('channel').description('按频道'),
-      Schema.const('platform').description('按平台'),
-    ]).default('user').description('限制范围'),
-    rateLimitIntervalSec: Schema.natural().min(1).max(3600).default(60).description('间隔秒数'),
-  }).description('频率限制'),
-])
-
-interface SongItem {
+/**
+ * ✅ 这段会显示在“插件设置页”，不会在后台日志刷屏
+ */
+export const usage = `
+### 点歌语音（支持翻页 + 可选 silk/ffmpeg）
+
+开启插件前，请确保以下服务已经启用（可选安装）：
+
+- **puppeteer 服务（可选安装）**
+
+此外可能还需要这些服务才能发送语音：
+
+- **ffmpeg 服务（可选安装）**（此服务可能额外依赖 **downloads** 服务）
+- **silk 服务（可选安装）**
+
+> 本插件使用音乐聚合接口（GD音乐台 API）：https://music-api.gdstudio.xyz/api.php
+`
+
+export const Config: Schema<Config> = Schema.object({
+  commandName: Schema.string().description('指令名称').default('听歌'),
+  commandAlias: Schema.string().description('指令别名').default('music'),
+
+  apiBase: Schema.string()
+    .description('音乐 API 地址（GD音乐台 API）')
+    .default('https://music-api.gdstudio.xyz/api.php'),
+
+  // ✅ 后台显示品牌名（你要求的）
+  source: Schema.union([
+    Schema.const('netease').description('网易云'),
+    Schema.const('tencent').description('QQ音乐'),
+    Schema.const('kugou').description('酷狗'),
+    Schema.const('kuwo').description('酷我'),
+    Schema.const('migu').description('咪咕'),
+  ]).description('音源（下拉选择）').default('kuwo'),
+
+  searchListCount: Schema.natural().min(1).max(30).step(1).description('搜索列表数量').default(20),
+  waitForTimeout: Schema.natural().min(5).max(300).step(1).description('等待输入序号超时（秒）').default(45),
+
+  nextPageCommand: Schema.string().description('下一页指令').default('下一页'),
+  prevPageCommand: Schema.string().description('上一页指令').default('上一页'),
+  exitCommandList: Schema.array(Schema.string()).role('table').description('退出指令列表（一行一个）').default(['0', '不听了', '退出']),
+  menuExitCommandTip: Schema.boolean().description('是否在歌单末尾提示退出指令').default(false),
+
+  // ✅ 解决“太快撤回”的关键：默认 60 秒撤回歌单；并且默认“发送成功才撤回”
+  menuRecallSec: Schema.natural().min(0).max(3600).step(1).description('歌单撤回秒数（0=不撤回）').default(60),
+  tipRecallSec: Schema.natural().min(0).max(3600).step(1).description('“生成中”提示撤回秒数（0=不撤回）').default(10),
+  recallOnlyAfterSuccess: Schema.boolean().description('仅在发送成功后才撤回（推荐开启）').default(true),
+  keepMenuIfSendFailed: Schema.boolean().description('发送失败时保留歌单（推荐开启）').default(true),
+
+  sendAs: Schema.union([
+    Schema.const('record').description('语音 record（推荐）'),
+    Schema.const('audio').description('音频 audio'),
+    Schema.const('file').description('文件 file'),
+  ]).description('发送类型').default('record'),
+
+  // ✅ 装了 downloads+ffmpeg+silk 后会更稳（QQ 语音经常只认 silk）
+  forceTranscode: Schema.boolean().description('强制转码（需要 downloads + ffmpeg + silk；更稳但依赖更多）').default(true),
+  maxSongDuration: Schema.natural().min(0).max(180).step(1).description('歌曲最长时长（分钟，0=不限制）').default(30),
+
+  userAgent: Schema.string().description('请求 UA（部分环境可避免风控/403）').default('koishi-music-to-voice/1.0'),
+  generationTip: Schema.string().description('选择序号后发送的提示文案').default('音乐生成中…'),
+})
+
+type SearchItem = {
   id: string
   name: string
-  artist: string
-  album: string
-  source: MusicSource
+  artist?: string[] | string
+  album?: string
+  url_id?: string
+  pic_id?: string
+  source: string
+  duration?: number // 秒（有些源会返回）
 }
 
-// --------- 小工具 ---------
+type PendingState = {
+  userId: string
+  channelId: string
+  keyword: string
+  page: number
+  items: SearchItem[]
+  menuMessageIds: string[]
+  tipMessageIds: string[]
+  timer?: NodeJS.Timeout
+}
 
-function artistsToString(x: any): string {
-  if (!x) return ''
-  if (Array.isArray(x)) return x.join(' / ')
-  return String(x)
+const pending = new Map<string, PendingState>()
+
+function ms(sec: number) {
+  return Math.max(1, sec) * 1000
 }
 
-async function safeDelete(session: Session, messageId?: string | null) {
-  if (!messageId) return
-  const channelId = session.channelId
-  if (!channelId) return
-  try {
-    await session.bot.deleteMessage(channelId, messageId)
-  } catch {}
+function keyOf(session: Session) {
+  return `${session.platform}:${session.userId || 'unknown'}:${session.channelId || session.guildId || 'unknown'}`
 }
 
-function buildRateKey(session: Session, scope: 'user' | 'channel' | 'platform') {
-  if (scope === 'platform') return session.platform
-  if (scope === 'channel') return `${session.platform}:${session.channelId ?? ''}`
-  return `${session.platform}:${session.userId ?? ''}`
+function normalizeArtist(a: any): string {
+  if (!a) return ''
+  if (Array.isArray(a)) return a.join(' / ')
+  return String(a)
 }
 
-async function gdSearch(ctx: Context, config: Config, keyword: string, page: number): Promise<SongItem[]> {
-  const data = await ctx.http.get(config.apiBase, {
-    timeout: 15000,
-    params: { types: 'search', source: config.source, name: keyword, count: config.searchListCount, pages: page },
-    headers: { 'user-agent': 'koishi-music-to-voice' },
+function formatMenu(state: PendingState, config: Config) {
+  const lines: string[] = []
+  lines.push(`点歌列表（第 ${state.page} 页）`)
+  lines.push(`关键词：${state.keyword}`)
+  lines.push('')
+  state.items.forEach((it, idx) => {
+    const n = idx + 1
+    const artist = normalizeArtist(it.artist)
+    lines.push(`${n}. ${it.name}${artist ? ` - ${artist}` : ''}`)
   })
-  if (!Array.isArray(data)) return []
-  return data
-    .map((x: any) => ({
-      id: String(x.id ?? x.url_id ?? ''),
-      name: String(x.name ?? ''),
-      artist: artistsToString(x.artist),
-      album: String(x.album ?? ''),
-      source: String(x.source ?? config.source) as MusicSource,
-    }))
-    .filter((x: SongItem) => x.id && x.name)
+  lines.push('')
+  lines.push(`请在 ${config.waitForTimeout} 秒内输入歌曲序号`)
+  lines.push(`翻页：${config.prevPageCommand} / ${config.nextPageCommand}`)
+  if (config.menuExitCommandTip) lines.push(`退出：${config.exitCommandList.join(' / ')}`)
+  return lines.join('\n')
+}
+
+async function safeSend(session: Session, content: any) {
+  const ids = await session.send(content)
+  if (Array.isArray(ids)) return ids.filter(Boolean)
+  return ids ? [ids] : []
 }
 
-async function gdUrl(ctx: Context, config: Config, item: SongItem): Promise<string> {
-  const data = await ctx.http.get(config.apiBase, {
+function recall(session: Session, ids: string[], sec: number) {
+  if (!ids?.length || sec <= 0) return
+  const channelId = session.channelId
+  if (!channelId) return
+  setTimeout(() => {
+    ids.forEach((id) => session.bot.deleteMessage(channelId, id).catch(() => {}))
+  }, sec * 1000)
+}
+
+async function apiSearch(ctx: Context, config: Config, keyword: string, page: number) {
+  const params = new URLSearchParams({
+    types: 'search',
+    source: config.source,
+    name: keyword,
+    count: String(config.searchListCount),
+    pages: String(page),
+  })
+  const url = `${config.apiBase}?${params.toString()}`
+  const data = await ctx.http.get(url, {
+    headers: { 'user-agent': config.userAgent },
+    responseType: 'json',
     timeout: 15000,
-    params: { types: 'url', source: item.source || config.source, id: item.id },
-    headers: { 'user-agent': 'koishi-music-to-voice' },
   })
+  if (!Array.isArray(data)) throw new Error('search response is not array')
+  return data as SearchItem[]
+}
 
-  if (typeof data === 'string') return data
-  if (data?.url) return String(data.url)
-  if (data?.data?.url) return String(data.data.url)
-  return ''
+async function apiGetSongUrl(ctx: Context, config: Config, item: SearchItem) {
+  const id = item.url_id || item.id
+  const params = new URLSearchParams({
+    types: 'url',
+    id: String(id),
+    source: item.source || config.source,
+  })
+  const url = `${config.apiBase}?${params.toString()}`
+  const data = await ctx.http.get(url, {
+    headers: { 'user-agent': config.userAgent },
+    responseType: 'json',
+    timeout: 15000,
+  })
+  const u = (Array.isArray(data) ? data[0]?.url : data?.url) as string | undefined
+  if (!u) throw new Error('url not found from api')
+  return u
 }
 
-async function downloadToTemp(ctx: Context, src: string): Promise<string | null> {
-  try {
-    const file = await ctx.http.file(src)
-    const ext = '.mp3'
-    const fp = path.join(os.tmpdir(), `music_${crypto.randomBytes(8).toString('hex')}${ext}`)
-    fs.writeFileSync(fp, Buffer.from(file.data))
-    return fp
-  } catch (e) {
-    return null
-  }
+function tmpFile(ext: string) {
+  const id = crypto.randomBytes(8).toString('hex')
+  return path.join(os.tmpdir(), `koishi-music-${id}.${ext}`)
 }
 
-async function tryTranscode(ctx: Context, localPath: string): Promise<string> {
-  // ✅ 完全可选：缺依赖就原样返回
+async function downloadToFile(ctx: Context, config: Config, url: string, filePath: string) {
   const anyCtx = ctx as any
-  if (!anyCtx.ffmpeg || !anyCtx.silk) return localPath
-
-  const wav = localPath.replace(/\.\w+$/, '') + '.wav'
-  const silk = localPath.replace(/\.\w+$/, '') + '.silk'
-  try {
-    await anyCtx.ffmpeg.convert(localPath, wav)
-    await anyCtx.silk.encode(wav, silk)
-    return silk
-  } catch {
-    return localPath
-  } finally {
-    try { fs.existsSync(wav) && fs.unlinkSync(wav) } catch {}
+  if (anyCtx.downloads?.download) {
+    await anyCtx.downloads.download(url, filePath, {
+      headers: { 'user-agent': config.userAgent },
+    })
+    return
   }
+  const buf = await ctx.http.get<ArrayBuffer>(url, {
+    headers: { 'user-agent': config.userAgent },
+    responseType: 'arraybuffer',
+    timeout: 30000,
+  })
+  fs.writeFileSync(filePath, Buffer.from(buf))
 }
 
-async function renderListImage(ctx: Context, html: string): Promise<Buffer | null> {
-  const anyCtx = ctx as any
-  if (!anyCtx.puppeteer) return null
-  const page = await anyCtx.puppeteer.page()
-  await page.setContent(html)
-  const el = await page.$('#song-list')
-  if (!el) return null
-  const buf = (await el.screenshot({})) as Buffer
-  await page.close()
-  return buf
+function runFfmpegToPcm(input: string, output: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const p = spawn('ffmpeg', ['-y', '-i', input, '-ac', '1', '-ar', '48000', '-f', 's16le', output], { stdio: 'ignore' })
+    p.on('error', reject)
+    p.on('exit', (code) => (code === 0 ? resolve() : reject(new Error(`ffmpeg exit code ${code}`))))
+  })
 }
 
-function makeListText(config: Config, list: SongItem[], page: number) {
-  const start = (page - 1) * config.searchListCount
-  const lines = list.map((s, i) => `${start + i + 1}. ${s.name} -- ${s.artist}${s.album ? ' -- ' + s.album : ''}`)
-  let tail = `\n\n翻页：${config.prevPageCommand} / ${config.nextPageCommand}`
-  if (config.menuExitCommandTip && config.exitCommandList?.length) {
-    tail += `\n退出：${config.exitCommandList.join(' / ')}`
+async function encodeSilk(ctx: Context, pcmPath: string): Promise<Buffer> {
+  const anyCtx = ctx as any
+  if (anyCtx.silk?.encode) {
+    const pcm = fs.readFileSync(pcmPath)
+    const out = await anyCtx.silk.encode(pcm, 48000)
+    return Buffer.isBuffer(out) ? out : Buffer.from(out)
   }
-  return `音乐列表：\n${lines.join('\n')}${tail}\n\n请在 ${config.waitForTimeout} 秒内输入序号：`
+  throw new Error('silk service encode not available')
 }
 
-// --------- 主逻辑 ---------
+/**
+ * ✅ 为什么“人家的插件可选安装也能成功”？
+ * 关键在于：它通常会在“能转 silk 就转”，否则回退为“直接发音频/文件/直链 record”。
+ * 这样没装依赖也能出结果，只是 QQ 语音成功率可能低一些。
+ */
+async function sendSong(session: Session, ctx: Context, config: Config, url: string) {
+  // record + 强制转码：downloads -> ffmpeg -> silk（QQ 最稳）
+  if (config.sendAs === 'record' && config.forceTranscode) {
+    const anyCtx = ctx as any
+    if (anyCtx.downloads && anyCtx.silk) {
+      try {
+        const inFile = tmpFile('mp3')
+        const pcmFile = tmpFile('pcm')
+        await downloadToFile(ctx, config, url, inFile)
+        await runFfmpegToPcm(inFile, pcmFile)
+        const silkBuf = await encodeSilk(ctx, pcmFile)
+        try { fs.unlinkSync(inFile) } catch {}
+        try { fs.unlinkSync(pcmFile) } catch {}
+        return await safeSend(session, h('record', { src: silkBuf }))
+      } catch (e) {
+        logger.warn('transcode/send record failed, fallback: %s', (e as Error).message)
+      }
+    }
+  }
+
+  // 回退策略：不装依赖也能发（但 QQ “语音 record(url)” 可能不稳定）
+  if (config.sendAs === 'record') return await safeSend(session, h('record', { src: url }))
+  if (config.sendAs === 'audio') return await safeSend(session, h.audio(url))
+  return await safeSend(session, h.file(url))
+}
 
 export function apply(ctx: Context, config: Config) {
-  // 频率限制记录
-  const lastUse = new Map<string, number>()
-
-  ctx.command(`${config.commandName} <keyword:text>`, '音乐聚合点歌并发送语音')
+  // 主命令：听歌 <keyword>
+  ctx.command(`${config.commandName} <keyword:text>`, '点歌并发送语音/音频')
     .alias(config.commandAlias)
-    .action(async (argv, keyword?: string) => {
-      const session = argv.session
-      const options = argv.options ?? {}
-
-      // ✅ 解决 “session 可能为 undefined”
+    .action(async ({ session }, keyword) => {
       if (!session) return
-      keyword = (keyword ?? '').trim()
+      keyword = (keyword || '').trim()
       if (!keyword) return `用法：${config.commandName} 歌曲名`
 
-      // 频率限制（可选）
-      if (config.enableRateLimit) {
-        const scope = config.rateLimitScope ?? 'user'
-        const key = buildRateKey(session, scope)
-        const now = Date.now()
-        const last = lastUse.get(key) ?? 0
-        const interval = (config.rateLimitIntervalSec ?? 60) * 1000
-        if (now - last < interval) {
-          const remain = Math.ceil((interval - (now - last)) / 1000)
-          return `操作太频繁，请 ${remain} 秒后再试。`
-        }
-        lastUse.set(key, now)
+      const k = keyOf(session)
+      const old = pending.get(k)
+      if (old?.timer) clearTimeout(old.timer)
+      pending.delete(k)
+
+      let items: SearchItem[]
+      try {
+        items = await apiSearch(ctx, config, keyword, 1)
+      } catch (e) {
+        logger.warn('search failed: %s', (e as Error).message)
+        return '搜索失败（API 不可用或超时），请稍后再试。'
       }
+      if (!items.length) return '没有搜索到结果。'
+
+      const state: PendingState = {
+        userId: session.userId || '',
+        channelId: session.channelId || '',
+        keyword,
+        page: 1,
+        items,
+        menuMessageIds: [],
+        tipMessageIds: [],
+      }
+      pending.set(k, state)
 
-      let page = 1
-      let menuMsgId: string | null = null
-
-      while (true) {
-        let list: SongItem[] = []
-        try {
-          list = await gdSearch(ctx, config, keyword, page)
-        } catch (e: any) {
-          logger.warn(`[search] ${String(e?.message || e)}`)
-          const ids = await session.send('搜索失败（API 不可用或超时），请稍后再试。')
-          const mid = Array.isArray(ids) ? ids[0] : (ids as any)
-          if (config.recallFetchFailTip) await safeDelete(session, mid)
-          return
-        }
-
-        if (!list.length) {
-          const ids = await session.send('没有搜索到结果，请换个关键词试试。')
-          const mid = Array.isArray(ids) ? ids[0] : (ids as any)
-          if (config.recallFetchFailTip) await safeDelete(session, mid)
-          return
-        }
+      const menuText = formatMenu(state, config)
+      state.menuMessageIds = await safeSend(session, menuText)
 
-        // 发送歌单（文本/图片）
-        if (menuMsgId && config.recallMenu) await safeDelete(session, menuMsgId)
-
-        if (config.imageMode) {
-          const text = makeListText(config, list, page).replace(/\n/g, '<br/>')
-          const html = `<!doctype html><html><head><meta charset="utf-8"/><style>
-            body{margin:0;background:${config.backgroundColor};color:${config.textColor};font-size:16px;}
-            #song-list{padding:18px;white-space:nowrap;}
-          </style></head><body><div id="song-list">${text}</div></body></html>`
-          const buf = await renderListImage(ctx, html)
-
-          if (!buf) {
-            const ids = await session.send('图片歌单生成失败：未安装 puppeteer 服务或其不可用。')
-            const mid = Array.isArray(ids) ? ids[0] : (ids as any)
-            if (config.recallFetchFailTip) await safeDelete(session, mid)
-            return
-          }
-          const ids = await session.send([h.image(buf, 'image/png')])
-          menuMsgId = Array.isArray(ids) ? ids[0] : (ids as any)
-        } else {
-          const txt = makeListText(config, list, page)
-          const ids = await session.send(txt)
-          menuMsgId = Array.isArray(ids) ? ids[0] : (ids as any)
-        }
+      // ✅ 你说的“太快撤回”就是这里：我们默认给 60 秒，并且发送成功才撤回
+      if (config.menuRecallSec > 0 && !config.recallOnlyAfterSuccess) {
+        recall(session, state.menuMessageIds, config.menuRecallSec)
+      }
 
-        // 等待输入
-        const input = await session.prompt(
-          (s) => {
-            // ✅ elements 可能 undefined
-            const els = s.elements ?? []
-            return h.select(els, 'text').join('')
-          },
-          { timeout: config.waitForTimeout * 1000 }
-        )
-
-        if (isNullable(input)) {
-          if (config.recallMenu) await safeDelete(session, menuMsgId)
-          const ids = await session.send('输入超时，已取消点歌。')
-          const mid = Array.isArray(ids) ? ids[0] : (ids as any)
-          if (config.recallTimeoutTip) await safeDelete(session, mid)
-          return
-        }
+      state.timer = setTimeout(async () => {
+        const cur = pending.get(k)
+        if (!cur) return
+        pending.delete(k)
+        await session.send('输入超时，已取消点歌。')
+      }, ms(config.waitForTimeout))
 
-        const text = String(input).trim()
-        if (!text) continue
+      return
+    })
 
-        // 退出
-        if (config.exitCommandList.includes(text)) {
-          if (config.recallMenu) await safeDelete(session, menuMsgId)
-          const ids = await session.send('已退出歌曲选择。')
-          const mid = Array.isArray(ids) ? ids[0] : (ids as any)
-          if (config.recallExitTip) await safeDelete(session, mid)
+  // 捕获“序号 / 翻页 / 退出”
+  ctx.middleware(async (session, next) => {
+    const k = keyOf(session)
+    const state = pending.get(k)
+    if (!state) return next()
+
+    // 只允许同一用户、同一频道继续操作
+    if ((session.userId || '') !== state.userId || (session.channelId || '') !== state.channelId) return next()
+
+    const content = (session.content || '').trim()
+    if (!content) return next()
+
+    // 退出
+    if (config.exitCommandList.map(s => s.trim()).filter(Boolean).includes(content)) {
+      pending.delete(k)
+      if (state.timer) clearTimeout(state.timer)
+      await session.send('已退出歌曲选择。')
+      return
+    }
+
+    // 翻页
+    if (content === config.nextPageCommand || content === config.prevPageCommand) {
+      const target = content === config.nextPageCommand ? state.page + 1 : Math.max(1, state.page - 1)
+      if (target === state.page) {
+        await session.send('已经是第一页。')
+        return
+      }
+      try {
+        const items = await apiSearch(ctx, config, state.keyword, target)
+        if (!items.length) {
+          await session.send('没有更多结果了。')
           return
         }
+        state.page = target
+        state.items = items
+        const menuText = formatMenu(state, config)
+        const newIds = await safeSend(session, menuText)
+        state.menuMessageIds.push(...newIds)
+        if (config.menuRecallSec > 0 && !config.recallOnlyAfterSuccess) recall(session, newIds, config.menuRecallSec)
+      } catch (e) {
+        logger.warn('page search failed: %s', (e as Error).message)
+        await session.send('翻页失败（API 不可用或超时）。')
+      }
+      return
+    }
 
-        // 翻页
-        if (text === config.nextPageCommand) {
-          page += 1
-          continue
-        }
-        if (text === config.prevPageCommand) {
-          page = Math.max(1, page - 1)
-          continue
-        }
+    // 选择序号
+    const n = Number(content)
+    if (!Number.isInteger(n) || n < 1 || n > state.items.length) return next()
 
-        // 序号
-        if (!/^\d+$/.test(text)) continue
-        const idx = parseInt(text, 10)
-        const start = (page - 1) * config.searchListCount
-        const local = idx - start - 1
-        if (local < 0 || local >= list.length) {
-          if (config.recallMenu) await safeDelete(session, menuMsgId)
-          const ids = await session.send('序号输入错误，已退出歌曲选择。')
-          const mid = Array.isArray(ids) ? ids[0] : (ids as any)
-          if (config.recallInvalidTip) await safeDelete(session, mid)
-          return
-        }
+    if (state.timer) clearTimeout(state.timer)
 
-        const chosen = list[local]
+    const tipIds = await safeSend(session, config.generationTip)
+    state.tipMessageIds.push(...tipIds)
+    if (config.tipRecallSec > 0 && !config.recallOnlyAfterSuccess) recall(session, tipIds, config.tipRecallSec)
 
-        // 生成提示
-        let tipMsgId: string | null = null
-        {
-          const ids = await session.send(config.generationTip)
-          tipMsgId = Array.isArray(ids) ? ids[0] : (ids as any)
-        }
+    try {
+      const item = state.items[n - 1]
+      const songUrl = await apiGetSongUrl(ctx, config, item)
 
-        // 获取播放 URL
-        let playUrl = ''
-        try {
-          playUrl = await gdUrl(ctx, config, chosen)
-        } catch (e: any) {
-          logger.warn(`[url] ${String(e?.message || e)}`)
-        }
+      // 最长时长控制（只有 API 返回 duration 才会生效）
+      if (config.maxSongDuration > 0 && item.duration && item.duration / 60 > config.maxSongDuration) {
+        await session.send(`该歌曲时长超出限制（>${config.maxSongDuration} 分钟），已取消发送。`)
+        return
+      }
 
-        if (!playUrl) {
-          if (config.recallGeneratingTip) await safeDelete(session, tipMsgId)
-          if (config.recallMenu) await safeDelete(session, menuMsgId)
-          const ids = await session.send('获取歌曲失败，请稍后再试。')
-          const mid = Array.isArray(ids) ? ids[0] : (ids as any)
-          if (config.recallFetchFailTip) await safeDelete(session, mid)
-          return
-        }
+      await sendSong(session, ctx, config, songUrl)
 
-        // 发送（转码可选）
-        try {
-          let finalSrc = playUrl
-
-          if (config.forceTranscode) {
-            const localPath = await downloadToTemp(ctx, playUrl)
-            if (localPath) {
-              const out = await tryTranscode(ctx, localPath)
-              finalSrc = pathToFileURL(out).href
-            }
-          }
-
-          // ✅ 不要用 `+` 拼 Element；直接发 Fragment 数组
-          let sendIds: any
-          if (config.sendAs === 'file') {
-            sendIds = await session.send([h.file(finalSrc)])
-          } else if (config.sendAs === 'audio') {
-            sendIds = await session.send([h.audio(finalSrc)])
-          } else {
-            sendIds = await session.send([h('record', { src: finalSrc })])
-          }
-
-          const songMsgId = Array.isArray(sendIds) ? sendIds[0] : sendIds
-          if (config.recallSongMessage) await safeDelete(session, songMsgId)
-        } catch (e: any) {
-          logger.warn(`[send] ${String(e?.message || e)}`)
-          const ids = await session.send('发送失败（可能缺少转码依赖或链接失效）。')
-          const mid = Array.isArray(ids) ? ids[0] : (ids as any)
-          if (config.recallFetchFailTip) await safeDelete(session, mid)
-        } finally {
-          if (config.recallGeneratingTip) await safeDelete(session, tipMsgId)
-          if (config.recallMenu) await safeDelete(session, menuMsgId)
-        }
+      // ✅ 发送成功后才撤回（默认开启），解决你截图那种“瞬间撤回导致看不到/发不出来”
+      if (config.recallOnlyAfterSuccess) {
+        if (config.tipRecallSec > 0) recall(session, tipIds, 1)
+        if (config.menuRecallSec > 0) recall(session, state.menuMessageIds, 1)
+      }
 
-        return
+      pending.delete(k)
+      return
+    } catch (e) {
+      logger.warn('send failed: %s', (e as Error).stack || (e as Error).message)
+      await session.send('获取/发送失败，请稍后再试。')
+
+      if (!config.keepMenuIfSendFailed) {
+        pending.delete(k)
+      } else {
+        state.timer = setTimeout(() => pending.delete(k), ms(config.waitForTimeout))
       }
-    })
+      return
+    }
+  })
 }