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

package/src/index.ts

@@ -1,516 +1,428 @@
-import { Context, Schema, Logger, h } from 'koishi'
-import axios from 'axios'
+import { Context, Schema, h, Logger, Session } from 'koishi'
 import fs from 'node:fs'
 import path from 'node:path'
 import os from 'node:os'
 import crypto from 'node:crypto'
+import { spawn } from 'node:child_process'
 
-export const name = 'music-voice-pro'
+export const name = 'music-to-voice'
 const logger = new Logger(name)
 
-type MusicSource = 'netease' | 'tencent' | 'kugou' | 'kuwo' | 'migu' | 'baidu'
-
 export interface Config {
-  // 命令
   commandName: string
   commandAlias: string
-
-  // API
   apiBase: string
-  source: MusicSource
+  source: 'netease' | 'tencent' | 'kugou' | 'kuwo' | 'migu'
   searchListCount: number
-
-  // 交互
   waitForTimeout: number
+
   nextPageCommand: string
   prevPageCommand: string
   exitCommandList: string[]
   menuExitCommandTip: boolean
 
-  // 图片歌单（预留）
-  imageMode: boolean
-
-  // 发送类型
-  sendAs: 'record' | 'audio'
+  // 撤回策略
+  menuRecallSec: number
+  tipRecallSec: number
+  recallOnlyAfterSuccess: boolean
+  keepMenuIfSendFailed: boolean
 
-  // 转码与缓存
+  // 发送
+  sendAs: 'record' | 'audio' | 'file'
   forceTranscode: boolean
-  tempDir: string
-  cacheMinutes: number
-
-  // 提示与撤回
+  maxSongDuration: number // 分钟，0=不限制
+  userAgent: string
   generationTip: string
-  recallSearchMenuMessage: boolean
-  recallTipMessage: boolean
-  recallUserSelectMessage: boolean
-  recallVoiceMessage: boolean
+}
 
-  // 调试
-  loggerinfo: boolean
+/**
+ * 可选注入：不装也能跑，只是能力不同
+ * - downloads：下载到文件
+ * - silk：编码 silk（QQ 语音更稳）
+ * - ffmpeg：转 PCM（silk 前置）
+ * - puppeteer：未来可做图片歌单（你现在先不启用也没事）
+ */
+export const inject = {
+  optional: ['downloads', 'ffmpeg', 'silk', 'puppeteer'],
 }
 
+/**
+ * ✅ 这段会显示在“插件设置页”，不会在后台日志刷屏
+ */
+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().default('听歌').description('指令名称'),
-  commandAlias: Schema.string().default('music').description('指令别名'),
+  commandName: Schema.string().description('指令名称').default('听歌'),
+  commandAlias: Schema.string().description('指令别名').default('music'),
 
-  apiBase: Schema.string().default('https://music-api.gdstudio.xyz/api.php').description('音乐 API 地址（GD音乐台 API）'),
+  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('咪咕'),
-    Schema.const('baidu').description('百度'),
-  ]).default('netease').description('音源（下拉选择）'),
-  searchListCount: Schema.number().min(5).max(50).default(20).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),
 
-  waitForTimeout: Schema.number().min(10).max(180).default(45).description('等待输入序号超时（秒）'),
-  nextPageCommand: Schema.string().default('下一页').description('下一页指令'),
-  prevPageCommand: Schema.string().default('上一页').description('上一页指令'),
-  exitCommandList: Schema.array(String).default(['0', '不听了', '退出']).description('退出指令列表'),
-  menuExitCommandTip: Schema.boolean().default(false).description('是否在歌单末尾提示退出指令'),
+  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),
 
-  imageMode: Schema.boolean().default(false).description('图片歌单模式（可选：需要 puppeteer 插件，当前仅保留开关）'),
+  // ✅ 解决“太快撤回”的关键：默认 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('record').description('语音 record（推荐）'),
     Schema.const('audio').description('音频 audio'),
-  ]).default('record').description('发送类型'),
-
-  forceTranscode: Schema.boolean().default(true).description('是否强制转码为 silk（需要 ffmpeg + silk 插件）'),
-  tempDir: Schema.string().default(path.join(os.tmpdir(), 'koishi-music-voice')).description('临时目录'),
-  cacheMinutes: Schema.number().min(0).max(1440).default(120).description('缓存时长（分钟，0=不缓存）'),
-
-  generationTip: Schema.string().default('生成语音中...').description('用户选歌后提示'),
+    Schema.const('file').description('文件 file'),
+  ]).description('发送类型').default('record'),
 
-  recallSearchMenuMessage: Schema.boolean().default(true).description('撤回：歌单消息'),
-  recallTipMessage: Schema.boolean().default(true).description('撤回：生成提示消息'),
-  recallUserSelectMessage: Schema.boolean().default(true).description('撤回：用户输入的序号消息'),
-  recallVoiceMessage: Schema.boolean().default(false).description('撤回：语音消息'),
+  // ✅ 装了 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),
 
-  loggerinfo: Schema.boolean().default(false).description('日志调试模式'),
-}).description('点歌语音（支持翻页 + 可选 silk/ffmpeg）')
+  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
+  artist?: string[] | string
   album?: string
+  url_id?: string
+  pic_id?: string
+  source: string
+  duration?: number // 秒（有些源会返回）
 }
 
 type PendingState = {
   userId: string
   channelId: string
-  guildId?: string
-
   keyword: string
   page: number
-  list: SearchItem[]
-  expiresAt: number
-
-  menuMessageId?: string
-  tipMessageId?: string
-  voiceMessageId?: string
-}
-
-function safeText(x: unknown): string {
-  return typeof x === 'string' ? x : x == null ? '' : String(x)
+  items: SearchItem[]
+  menuMessageIds: string[]
+  tipMessageIds: string[]
+  timer?: NodeJS.Timeout
 }
 
-function normalizeSearchList(data: any): SearchItem[] {
-  const arr: any[] =
-    Array.isArray(data) ? data
-      : Array.isArray(data?.result) ? data.result
-        : Array.isArray(data?.data) ? data.data
-          : Array.isArray(data?.songs) ? data.songs
-            : []
-
-  return arr.map((it: any) => {
-    const id = safeText(it?.id ?? it?.songid ?? it?.rid ?? it?.hash ?? it?.mid)
-    const name = safeText(it?.name ?? it?.songname ?? it?.title)
-    const artist =
-      safeText(it?.artist) ||
-      safeText(it?.singer) ||
-      safeText(it?.author) ||
-      (Array.isArray(it?.artists) ? it.artists.map((a: any) => safeText(a?.name)).filter(Boolean).join('/') : '')
-
-    const album = safeText(it?.album ?? it?.albummid ?? it?.albumname)
-    return { id, name, artist, album }
-  }).filter((x: SearchItem) => x.id && x.name)
-}
-
-function normalizeUrl(data: any): string {
-  return (
-    safeText(data?.url) ||
-    safeText(data?.data?.url) ||
-    safeText(data?.result?.url) ||
-    safeText(data?.data) ||
-    ''
-  )
-}
-
-function md5(s: string) {
-  return crypto.createHash('md5').update(s).digest('hex')
-}
-
-function ensureDir(p: string) {
-  fs.mkdirSync(p, { recursive: true })
-}
+const pending = new Map<string, PendingState>()
 
-async function tryRecall(session: any, messageId?: string) {
-  if (!messageId) return
-  try {
-    await session.bot.deleteMessage(session.channelId, messageId)
-  } catch {
-    // ignore
-  }
+function ms(sec: number) {
+  return Math.max(1, sec) * 1000
 }
 
-function hRecord(src: string) {
-  return h('record', { src })
+function keyOf(session: Session) {
+  return `${session.platform}:${session.userId || 'unknown'}:${session.channelId || session.guildId || 'unknown'}`
 }
 
-function hAudio(src: string) {
-  return h('audio', { src })
+function normalizeArtist(a: any): string {
+  if (!a) return ''
+  if (Array.isArray(a)) return a.join(' / ')
+  return String(a)
 }
 
-function buildMenuText(config: Config, keyword: string, list: SearchItem[], page: number) {
+function formatMenu(state: PendingState, config: Config) {
   const lines: string[] = []
-  lines.push(`NetEase Music:`)
-  lines.push(`关键词：${keyword}`)
-  lines.push(`音源：${config.source}  第 ${page} 页`)
+  lines.push(`点歌列表（第 ${state.page} 页）`)
+  lines.push(`关键词：${state.keyword}`)
   lines.push('')
-  for (let i = 0; i < list.length; i++) {
-    const it = list[i]
-    const meta = [it.artist, it.album].filter(Boolean).join(' - ')
-    lines.push(`${i + 1}. ${it.name}${meta ? ` -- ${meta}` : ''}`)
-  }
+  state.items.forEach((it, idx) => {
+    const n = idx + 1
+    const artist = normalizeArtist(it.artist)
+    lines.push(`${n}. ${it.name}${artist ? ` - ${artist}` : ''}`)
+  })
   lines.push('')
-  lines.push(`请在 ${config.waitForTimeout} 秒内输入序号（1-${list.length}）`)
+  lines.push(`请在 ${config.waitForTimeout} 秒内输入歌曲序号`)
   lines.push(`翻页：${config.prevPageCommand} / ${config.nextPageCommand}`)
-  if (config.menuExitCommandTip) {
-    lines.push(`退出：${config.exitCommandList.join(' / ')}`)
-  }
-  lines.push('')
-  lines.push('数据来源：GD音乐台 API')
+  if (config.menuExitCommandTip) lines.push(`退出：${config.exitCommandList.join(' / ')}`)
   return lines.join('\n')
 }
 
-async function apiSearch(config: Config, keyword: string, page = 1): Promise<SearchItem[]> {
-  const params = {
-    types: 'search',
-    source: config.source,
-    name: keyword,
-    count: config.searchListCount,
-    pages: page,
-  }
-  const { data } = await axios.get(config.apiBase, { params, timeout: 15000 })
-  return normalizeSearchList(data)
+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 apiGetSongUrl(config: Config, id: string): Promise<string> {
-  const params = { types: 'url', source: config.source, id }
-  const { data } = await axios.get(config.apiBase, { params, timeout: 15000 })
-  return normalizeUrl(data)
+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 downloadToFile(url: string, filePath: string) {
-  const res = await axios.get(url, { responseType: 'stream', timeout: 30000 })
-  await new Promise<void>((resolve, reject) => {
-    const ws = fs.createWriteStream(filePath)
-    res.data.pipe(ws)
-    ws.on('finish', () => resolve())
-    ws.on('error', reject)
+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,
   })
+  if (!Array.isArray(data)) throw new Error('search response is not array')
+  return data as SearchItem[]
 }
 
-async function sendVoiceByUrl(session: any, config: Config, audioUrl: string) {
-  const seg = config.sendAs === 'record' ? hRecord(audioUrl) : hAudio(audioUrl)
-  const ids = await session.send(seg)
-  return Array.isArray(ids) ? ids[0] : ids
+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 sendVoiceByFile(session: any, config: Config, absPath: string) {
-  const url = `file://${absPath.replace(/\\/g, '/')}`
-  const seg = config.sendAs === 'record' ? hRecord(url) : hAudio(url)
-  const ids = await session.send(seg)
-  return Array.isArray(ids) ? ids[0] : ids
+function tmpFile(ext: string) {
+  const id = crypto.randomBytes(8).toString('hex')
+  return path.join(os.tmpdir(), `koishi-music-${id}.${ext}`)
 }
 
-/**
- * 可选：使用 Koishi 市场的 ffmpeg/silk 服务
- * 返回 silk 文件绝对路径；返回 null 表示无法转码（可降级直链）
- */
-async function buildSilkIfPossible(ctx: Context, config: Config, audioUrl: string, cacheKey: string): Promise<string | null> {
-  const hasFfmpeg = !!(ctx as any).ffmpeg
-  const hasSilk = !!(ctx as any).silk
-  if (!hasFfmpeg || !hasSilk) return null
-
-  ensureDir(config.tempDir)
-
-  const silkPath = path.join(config.tempDir, `${cacheKey}.silk`)
-  if (config.cacheMinutes > 0 && fs.existsSync(silkPath)) {
-    return silkPath
-  }
-
-  const rawPath = path.join(config.tempDir, `${cacheKey}.src`)
-  await downloadToFile(audioUrl, rawPath)
-
-  const wavPath = path.join(config.tempDir, `${cacheKey}.wav`)
-  const ffmpeg: any = (ctx as any).ffmpeg
-
-  try {
-    if (typeof ffmpeg.convert === 'function') {
-      await ffmpeg.convert(rawPath, wavPath, {
-        format: 'wav',
-        audioChannels: 1,
-        audioFrequency: 24000,
-      })
-    } else if (typeof ffmpeg.exec === 'function') {
-      await ffmpeg.exec(['-y', '-i', rawPath, '-ac', '1', '-ar', '24000', wavPath])
-    } else {
-      throw new Error('ffmpeg service API not recognized')
-    }
-  } catch (e: any) {
-    throw new Error(`ffmpeg 转码失败：${e?.message || String(e)}`)
-  }
-
-  const silk: any = (ctx as any).silk
-  try {
-    if (typeof silk.encode === 'function') {
-      await silk.encode(wavPath, silkPath, { rate: 24000 })
-    } else if (typeof silk.encodeWav === 'function') {
-      await silk.encodeWav(wavPath, silkPath, { rate: 24000 })
-    } else {
-      throw new Error('silk service API not recognized')
-    }
-  } catch (e: any) {
-    throw new Error(`silk 编码失败：${e?.message || String(e)}`)
-  } finally {
-    try { fs.unlinkSync(rawPath) } catch {}
-    try { fs.unlinkSync(wavPath) } catch {}
+async function downloadToFile(ctx: Context, config: Config, url: string, filePath: string) {
+  const anyCtx = ctx as any
+  if (anyCtx.downloads?.download) {
+    await anyCtx.downloads.download(url, filePath, {
+      headers: { 'user-agent': config.userAgent },
+    })
+    return
   }
-
-  return silkPath
+  const buf = await ctx.http.get<ArrayBuffer>(url, {
+    headers: { 'user-agent': config.userAgent },
+    responseType: 'arraybuffer',
+    timeout: 30000,
+  })
+  fs.writeFileSync(filePath, Buffer.from(buf))
 }
 
-function logDepsHint(ctx: Context) {
-  const hasPuppeteer = !!(ctx as any).puppeteer
-  const hasFfmpeg = !!(ctx as any).ffmpeg
-  const hasSilk = !!(ctx as any).silk
-  const hasDownloads = !!(ctx as any).downloads
-
-  logger.info('开启插件前，请确保以下服务已经启用（可选安装）：')
-  logger.info(`- puppeteer服务（可选安装）：${hasPuppeteer ? '已检测到' : '未检测到'}`)
-  logger.info('此外可能还需要这些服务才能发送语音：')
-  logger.info(`- ffmpeg服务（可选安装）（此服务可能额外依赖downloads服务）：${hasFfmpeg ? '已检测到' : '未检测到'}`)
-  logger.info(`- silk服务（可选安装）：${hasSilk ? '已检测到' : '未检测到'}`)
-  logger.info(`- downloads服务（可选安装）：${hasDownloads ? '已检测到' : '未检测到'}`)
-  logger.info('Music API 出处：GD音乐台 API（https://music-api.gdstudio.xyz/api.php）')
+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}`))))
+  })
 }
 
-export function apply(ctx: Context, config: Config) {
-  if (config.loggerinfo) logger.level = Logger.DEBUG
-  logDepsHint(ctx)
-
-  const pending = new Map<string, PendingState>() // channelId -> state
-
-  function getKey(session: any) {
-    return String(session?.channelId || '')
-  }
-
-  function isExit(input: string) {
-    const t = input.trim()
-    return config.exitCommandList.map(s => s.trim()).includes(t)
-  }
-
-  function isExpired(state: PendingState) {
-    return Date.now() > state.expiresAt
-  }
-
-  async function refreshMenu(session: any, state: PendingState) {
-    const list = await apiSearch(config, state.keyword, state.page)
-    state.list = list
-    state.expiresAt = Date.now() + config.waitForTimeout * 1000
-
-    if (config.recallSearchMenuMessage) {
-      await tryRecall(session, state.menuMessageId)
-      state.menuMessageId = undefined
-    }
-
-    if (!config.recallSearchMenuMessage) {
-      const text = buildMenuText(config, state.keyword, list, state.page)
-      const ids = await session.send(text)
-      state.menuMessageId = Array.isArray(ids) ? ids[0] : ids
-    } else {
-      await session.send(`已翻到第 ${state.page} 页，请直接发送序号（1-${list.length}）`)
-    }
+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)
   }
+  throw new Error('silk service encode not available')
+}
 
-  async function handlePick(session: any, state: PendingState, pickIndex: number) {
-    const item = state.list[pickIndex]
-    if (!item) {
-      await session.send(`序号无效，请输入 1-${state.list.length}，或输入 ${config.exitCommandList.join('/')} 退出。`)
-      return
-    }
-
-    // 提示：生成中...
-    let tipId: string | undefined
-    if (!config.recallTipMessage && config.generationTip?.trim()) {
-      const ids = await session.send(config.generationTip)
-      tipId = Array.isArray(ids) ? ids[0] : ids
-    }
-
-    // 取直链
-    let songUrl = ''
-    try {
-      songUrl = await apiGetSongUrl(config, item.id)
-      if (!songUrl) throw new Error('empty url')
-    } catch {
-      await session.send('获取歌曲直链失败，请稍后再试，或更换音源。')
-      return
-    }
-
-    const cacheKey = md5(`${config.source}:${item.id}`)
-    let voiceId: string | undefined
-
-    try {
-      const silkPath = await buildSilkIfPossible(ctx, config, songUrl, cacheKey)
-      if (silkPath) {
-        voiceId = await sendVoiceByFile(session, config, silkPath)
-      } else {
-        if (config.forceTranscode) {
-          await session.send(
-            `当前配置为【强制 silk 转码】但未检测到 ffmpeg/silk 服务。\n` +
-            `请在 Koishi 插件市场安装并启用：ffmpeg、silk（可能还需要 downloads）。`
-          )
-          return
-        }
-        voiceId = await sendVoiceByUrl(session, config, songUrl)
+/**
+ * ✅ 为什么“人家的插件可选安装也能成功”？
+ * 关键在于：它通常会在“能转 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)
       }
-    } catch (e: any) {
-      await session.send(`生成语音失败：${e?.message || String(e)}\n请检查 ffmpeg/silk 插件是否启用，或关闭“强制转码”。`)
-      return
-    } finally {
-      state.tipMessageId = tipId
-      state.voiceMessageId = voiceId
     }
-
-    if (config.recallSearchMenuMessage) await tryRecall(session, state.menuMessageId)
-    if (config.recallTipMessage) await tryRecall(session, state.tipMessageId)
-    if (config.recallVoiceMessage) await tryRecall(session, state.voiceMessageId)
-
-    pending.delete(getKey(session))
   }
 
-  // 主命令：听歌 关键词
-  ctx.command(`${config.commandName} <keyword:text>`, '点歌并发送语音（GD音乐台 API）')
+  // 回退策略：不装依赖也能发（但 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) {
+  // 主命令：听歌 <keyword>
+  ctx.command(`${config.commandName} <keyword:text>`, '点歌并发送语音/音频')
     .alias(config.commandAlias)
     .action(async ({ session }, keyword) => {
       if (!session) return
       keyword = (keyword || '').trim()
       if (!keyword) return `用法：${config.commandName} 歌曲名`
 
-      // ✅ DTS 关键修复：强制确认 userId/channelId 存在
-      const userId = session.userId
-      const channelId = session.channelId
-      if (!userId || !channelId) {
-        await session.send('当前适配器未提供 userId/channelId，无法进入选歌模式。')
-        return
-      }
+      const k = keyOf(session)
+      const old = pending.get(k)
+      if (old?.timer) clearTimeout(old.timer)
+      pending.delete(k)
 
-      let list: SearchItem[] = []
+      let items: SearchItem[]
       try {
-        list = await apiSearch(config, keyword, 1)
-      } catch {
+        items = await apiSearch(ctx, config, keyword, 1)
+      } catch (e) {
+        logger.warn('search failed: %s', (e as Error).message)
         return '搜索失败（API 不可用或超时），请稍后再试。'
       }
-      if (!list.length) return '没有搜到结果，换个关键词试试。'
+      if (!items.length) return '没有搜索到结果。'
 
       const state: PendingState = {
-        userId,
-        channelId,
-        guildId: session.guildId,
+        userId: session.userId || '',
+        channelId: session.channelId || '',
         keyword,
         page: 1,
-        list,
-        expiresAt: Date.now() + config.waitForTimeout * 1000,
+        items,
+        menuMessageIds: [],
+        tipMessageIds: [],
       }
+      pending.set(k, state)
 
-      if (!config.recallSearchMenuMessage) {
-        const text = buildMenuText(config, keyword, list, 1)
-        const ids = await session.send(text)
-        state.menuMessageId = Array.isArray(ids) ? ids[0] : ids
-      } else {
-        await session.send(`已进入选歌模式，请直接发送序号（1-${list.length}），或发送“${config.nextPageCommand}/${config.prevPageCommand}”翻页。`)
+      const menuText = formatMenu(state, config)
+      state.menuMessageIds = await safeSend(session, menuText)
+
+      // ✅ 你说的“太快撤回”就是这里：我们默认给 60 秒，并且发送成功才撤回
+      if (config.menuRecallSec > 0 && !config.recallOnlyAfterSuccess) {
+        recall(session, state.menuMessageIds, config.menuRecallSec)
       }
 
-      pending.set(channelId, state)
+      state.timer = setTimeout(async () => {
+        const cur = pending.get(k)
+        if (!cur) return
+        pending.delete(k)
+        await session.send('输入超时，已取消点歌。')
+      }, ms(config.waitForTimeout))
+
+      return
     })
 
-  // 中间件：处理序号 / 翻页 / 退出
+  // 捕获“序号 / 翻页 / 退出”
   ctx.middleware(async (session, next) => {
-    const key = getKey(session)
-    if (!key) return next()
-
-    const state = pending.get(key)
+    const k = keyOf(session)
+    const state = pending.get(k)
     if (!state) return next()
 
-    // 只允许发起者操作
-    if (session.userId !== state.userId) return next()
-
-    // 超时
-    if (isExpired(state)) {
-      pending.delete(key)
-      return next()
-    }
+    // 只允许同一用户、同一频道继续操作
+    if ((session.userId || '') !== state.userId || (session.channelId || '') !== state.channelId) return next()
 
     const content = (session.content || '').trim()
     if (!content) return next()
 
     // 退出
-    if (isExit(content)) {
-      if (config.recallSearchMenuMessage) await tryRecall(session, state.menuMessageId)
-      pending.delete(key)
-      if (!config.recallUserSelectMessage) await session.send('已退出选歌。')
-      return
-    }
-
-    // 下一页
-    if (content === config.nextPageCommand) {
-      if (config.recallUserSelectMessage) await tryRecall(session, session.messageId)
-      state.page += 1
-      try {
-        await refreshMenu(session, state)
-      } catch {
-        state.page -= 1
-        await session.send('翻页失败，请稍后再试。')
-      }
+    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.prevPageCommand) {
-      if (config.recallUserSelectMessage) await tryRecall(session, session.messageId)
-      if (state.page <= 1) {
+    // 翻页
+    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
       }
-      state.page -= 1
       try {
-        await refreshMenu(session, state)
-      } catch {
-        state.page += 1
-        await session.send('翻页失败，请稍后再试。')
+        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
     }
 
-    // 序号
+    // 选择序号
     const n = Number(content)
-    if (!Number.isInteger(n) || n < 1 || n > state.list.length) return next()
+    if (!Number.isInteger(n) || n < 1 || n > state.items.length) return next()
 
-    if (config.recallUserSelectMessage) await tryRecall(session, session.messageId)
-    await handlePick(session, state, n - 1)
+    if (state.timer) clearTimeout(state.timer)
+
+    const tipIds = await safeSend(session, config.generationTip)
+    state.tipMessageIds.push(...tipIds)
+    if (config.tipRecallSec > 0 && !config.recallOnlyAfterSuccess) recall(session, tipIds, config.tipRecallSec)
+
+    try {
+      const item = state.items[n - 1]
+      const songUrl = await apiGetSongUrl(ctx, config, item)
+
+      // 最长时长控制（只有 API 返回 duration 才会生效）
+      if (config.maxSongDuration > 0 && item.duration && item.duration / 60 > config.maxSongDuration) {
+        await session.send(`该歌曲时长超出限制（>${config.maxSongDuration} 分钟），已取消发送。`)
+        return
+      }
+
+      await sendSong(session, ctx, config, songUrl)
+
+      // ✅ 发送成功后才撤回（默认开启），解决你截图那种“瞬间撤回导致看不到/发不出来”
+      if (config.recallOnlyAfterSuccess) {
+        if (config.tipRecallSec > 0) recall(session, tipIds, 1)
+        if (config.menuRecallSec > 0) recall(session, state.menuMessageIds, 1)
+      }
+
+      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
+    }
   })
 }