kiku-agent 1.0.0 → 1.0.4

package/server/agent/audioPlayer.js

@@ -1,673 +1,739 @@
-import ytdl from '@distube/ytdl-core';
-import yts from 'yt-search';
-import ffmpeg from 'fluent-ffmpeg';
-import ffmpegPath from 'ffmpeg-static';
-import Speaker from 'speaker';
-import { spawn } from 'child_process';
-import { existsSync, unlinkSync, readdirSync, statSync } from 'node:fs';
-import { join, dirname, basename } from 'node:path';
-import { ensureYouTubeCookies, getCookieStatus } from './youtubeAuth.js';
-
-ffmpeg.setFfmpegPath(ffmpegPath);
-
-const YTDLP_CMD = process.env.KIKU_YTDLP || 'yt-dlp';
-
-const YTDLP_UA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36';
-
-function ytDlpSpawn(args) {
-  return spawn(YTDLP_CMD, args, { windowsHide: true });
-}
-
-function ytDlpArgs(query, opts = {}) {
-  const arg = /^https?:\/\//.test(query) ? query : `ytsearch1:${query}`;
-  const args = ['-f', 'bestaudio', '--no-warnings', '--ignore-errors'];
-  if (opts.client) args.push('--extractor-args', `youtube:player_client=${opts.client}`);
-  if (opts.cookies) {
-    if (opts.cookies.startsWith('browser:')) args.push('--cookies-from-browser', opts.cookies.slice('browser:'.length));
-    else args.push('--cookies', opts.cookies);
-  }
-  args.push(arg);
-  return args;
-}
-
-const YTDLP_STRATEGIES = [
-  {},
-  { client: 'tv' },
-  { client: 'ios' },
-  { client: 'web' },
-  { cookies: 'browser:chrome' },
-  { cookies: 'browser:edge' },
-  { cookies: 'browser:firefox' },
-  { cookies: 'browser:brave' },
-  { client: 'tv', cookies: 'browser:chrome' },
-  { client: 'ios', cookies: 'browser:chrome' }
-];
-
-function buildStrategies(cookieResult) {
-  const strategies = [];
-
-  const status = getCookieStatus();
-  const cookiesFile = process.env.KIKU_YT_COOKIES || status.envCookies;
-  if (cookiesFile) {
-    strategies.push({ cookies: cookiesFile });
-  }
-
-  const detectedBrowser = cookieResult?.browser || process.env.KIKU_YT_BROWSER;
-  if (detectedBrowser) {
-    strategies.push({ cookies: `browser:${detectedBrowser}` });
-  }
-
-  if (process.env.KIKU_YTDLP_CLIENT) {
-    strategies.push({ client: process.env.KIKU_YTDLP_CLIENT });
-  }
-
-  for (const s of YTDLP_STRATEGIES) {
-    if (!strategies.some(existing => existing.client === s.client && existing.cookies === s.cookies)) {
-      strategies.push(s);
-    }
-  }
-
-  return strategies;
-}
-
-function ytDlpTry(query, opts) {
-  return new Promise((resolve, reject) => {
-    const proc = ytDlpSpawn(ytDlpArgs(query, opts));
-    let gotData = false;
-    let errBuf = '';
-    proc.stdout.once('data', () => { gotData = true; resolve(proc); });
-    proc.stderr.on('data', d => { errBuf += d.toString(); });
-    proc.on('error', e => { if (!gotData) { try { proc.kill('SIGKILL'); } catch {} reject(e); } });
-    proc.on('close', code => {
-      if (!gotData) { try { proc.kill('SIGKILL'); } catch {} reject(new Error(errBuf.trim() || `yt-dlp exited with code ${code}`)); }
-    });
-  });
-}
-
-function findDownloadedFile(dir, baseName) {
-  try {
-    const entries = readdirSync(dir);
-    for (const entry of entries) {
-      if (entry === baseName) {
-        const full = join(dir, entry);
-        try { if (statSync(full).isFile()) return full; } catch {}
-      }
-      if (entry.startsWith(baseName + '.')) {
-        const full = join(dir, entry);
-        try { if (statSync(full).isFile()) return full; } catch {}
-      }
-    }
-  } catch {}
-  return null;
-}
-
-function normalizeSearchQuery(query) {
-  if (!query || typeof query !== 'string') return query;
-  if (/^https?:\/\//.test(query)) return query;
-  if (/jujingyi|จวีจิ้งอี|鞠婧祎|ju jingyi/i.test(query)) return query;
-  return `Ju Jingyi ${query}`;
-}
-
-async function ytDlpDownload(query, opts, outputPath) {
-  const arg = /^https?:\/\//.test(query) ? query : `ytsearch1:${query}`;
-  const args = [
-    '-f', 'bestaudio',
-    '--no-warnings',
-    '--ignore-errors',
-    '-x', '--audio-format', 'mp3',
-    '-o', outputPath + '.%(ext)s',
-    '--no-playlist'
-  ];
-  if (opts.client) args.push('--extractor-args', `youtube:player_client=${opts.client}`);
-  if (opts.cookies) {
-    if (opts.cookies.startsWith('browser:')) args.push('--cookies-from-browser', opts.cookies.slice('browser:'.length));
-    else args.push('--cookies', opts.cookies);
-  }
-  args.push(arg);
-
-  const dir = dirname(outputPath);
-  const baseName = basename(outputPath);
-
-  return new Promise((resolve, reject) => {
-    const p = ytDlpSpawn(args);
-    let err = '';
-    p.stderr.on('data', d => { err += d.toString(); });
-    p.on('error', reject);
-    p.on('close', code => {
-      const found = findDownloadedFile(dir, baseName);
-      if (found) {
-        resolve(found);
-      } else if (code === 0) {
-        resolve(outputPath);
-      } else {
-        reject(new Error(err.trim() || `yt-dlp exited ${code}`));
-      }
-    });
-  });
-}
-
-async function ytDlpDownloadUrl(url, outputPath) {
-  return new Promise((resolve, reject) => {
-    ffmpeg(url)
-      .inputOptions([
-        '-reconnect', '1',
-        '-reconnect_streamed', '1',
-        '-reconnect_delay_max', '5',
-        '-user_agent', YTDLP_UA
-      ])
-      .format('mp3')
-      .on('error', reject)
-      .on('end', () => resolve(outputPath + '.mp3'))
-      .save(outputPath + '.mp3');
-  });
-}
-
-async function ytDlpGetTitle(query, strategies) {
-  if (!strategies) strategies = buildStrategies();
-  for (const s of strategies) {
-    try {
-      const arg = /^https?:\/\//.test(query) ? query : `ytsearch1:${query}`;
-      const args = ['--print', '%(title)s', '--no-warnings'];
-      if (s.client) args.push('--extractor-args', `youtube:player_client=${s.client}`);
-      if (s.cookies) {
-        if (s.cookies.startsWith('browser:')) args.push('--cookies-from-browser', s.cookies.slice('browser:'.length));
-        else args.push('--cookies', s.cookies);
-      }
-      args.push(arg);
-      const title = await new Promise((resolve, reject) => {
-        const p = ytDlpSpawn(args);
-        let out = '';
-        let err = '';
-        p.stdout.on('data', d => { out += d.toString(); });
-        p.stderr.on('data', d => { err += d.toString(); });
-        p.on('error', e => reject(e));
-        p.on('close', c => {
-          const t = out.trim();
-          if (c === 0 && t) resolve(t);
-          else reject(new Error(err.trim() || `yt-dlp exited ${c}`));
-        });
-      });
-      if (title) return title;
-    } catch {}
-  }
-  return null;
-}
-
-async function ytDlpGetStream(query, strategies) {
-  if (!strategies) strategies = buildStrategies();
-  let lastErr;
-  for (const s of strategies) {
-    try {
-      const proc = await ytDlpTry(query, s);
-      return { proc, opts: s };
-    } catch (e) {
-      lastErr = e;
-    }
-  }
-  throw lastErr || new Error('yt-dlp could not extract an audio stream');
-}
-
-async function resolveViaYtdlCore(query) {
-  let videoUrl;
-  if (/^https?:\/\//.test(query)) {
-    videoUrl = query;
-  } else {
-    const searchResult = await yts(query);
-    const searchResults = searchResult.videos || [];
-    if (!searchResults.length) throw new Error(`No video found for: ${query}`);
-    videoUrl = searchResults[0].url;
-  }
-  const info = await ytdl.getInfo(videoUrl);
-  const format = ytdl.chooseFormat(info.formats, { filter: 'audioonly', quality: 'highestaudio' });
-  const title = info.videoDetails?.title || query;
-  if (!format || !format.url) throw new Error('No playable audio format found');
-  return { title, url: format.url };
-}
-
-class AudioPlayer {
-  constructor() {
-    this.ytdlStream = null;
-    this.ffmpegProcess = null;
-    this.speaker = null;
-    this.currentTrack = null;
-    this.isPlaying = false;
-    this.isPaused = false;
-    this.isMuted = false;
-    this.queue = [];
-    this.currentIndex = -1;
-    this._advancing = false;
-    this._playPromise = null;
-    this._ytDlpProc = null;
-    this._intentionalStop = false;
-  }
-
-  _cleanup() {
-    this._intentionalStop = true;
-    if (this.speaker) {
-      try { this.speaker.close(); } catch {}
-      this.speaker = null;
-    }
-    if (this._ytDlpProc) {
-      try { this._ytDlpProc.kill('SIGKILL'); } catch {}
-      this._ytDlpProc = null;
-    }
-    if (this.ffmpegProcess) {
-      try { this.ffmpegProcess.kill('SIGKILL'); } catch {}
-      this.ffmpegProcess = null;
-    }
-    if (this.ytdlStream) {
-      try { this.ytdlStream.destroy(); } catch {}
-      this.ytdlStream = null;
-    }
-  }
-
-  _cleanupTempFile() {
-    if (!this._tempFile) return;
-    try {
-      const dir = dirname(this._tempFile);
-      const baseName = basename(this._tempFile);
-      const entries = readdirSync(dir);
-      for (const entry of entries) {
-        if (entry === baseName || entry.startsWith(baseName + '.')) {
-          try { unlinkSync(join(dir, entry)); } catch {}
-        }
-      }
-    } catch {}
-    this._tempFile = null;
-  }
-
-  _createStream(query) {
-    this._intentionalStop = false;
-    query = normalizeSearchQuery(query);
-    return new Promise(async (resolve, reject) => {
-      try {
-        const cookieResult = await ensureYouTubeCookies({ silent: true });
-        if (!cookieResult.ok) {
-          console.error('  [WARNING] YouTube cookies unavailable (' + (cookieResult.reason || 'unknown') + ')');
-          console.error('    Playback may fail due to YouTube restrictions.');
-          console.error('    Run /login to sign in, or set KIKU_YT_COOKIES in .env\n');
-        } else {
-          console.log(`  [OK] YouTube session: ${cookieResult.source} (${cookieResult.browser || cookieResult.cookiesPath || 'file'})`);
-        }
-
-        const strategies = buildStrategies(cookieResult);
-
-        let tempFile = null;
-        let title = null;
-        let ytProc = null;
-
-        try {
-          title = await ytDlpGetTitle(query, strategies).catch(() => null);
-
-          const { mkdtemp } = await import('node:fs/promises');
-          const { tmpdir } = await import('node:os');
-          const tmpDir = await mkdtemp(join(tmpdir(), 'kiku-audio-'));
-          tempFile = join(tmpDir, 'audio');
-
-          let downloaded = false;
-          for (const s of strategies) {
-            try {
-              const downloadedPath = await ytDlpDownload(query, s, tempFile);
-              tempFile = downloadedPath;
-              downloaded = true;
-              console.log('  [OK] Downloaded audio via yt-dlp to', tempFile);
-              break;
-            } catch (e) {
-              console.log('  Strategy failed:', e.message.slice(0, 80));
-            }
-          }
-
-          if (!downloaded) {
-            console.log('  [WARNING] yt-dlp download failed, trying ytdl-core...');
-            try {
-              const src = await resolveViaYtdlCore(query);
-              title = src.title;
-              const downloadedPath = await ytDlpDownloadUrl(src.url, join(tmpDir, 'audio'));
-              tempFile = downloadedPath;
-              console.log('  [OK] Downloaded via ytdl-core to', tempFile);
-            } catch (ytdlErr) {
-              console.error('  ytdl-core also failed:', ytdlErr.message);
-              tempFile = null;
-            }
-          }
-        } catch (err) {
-          console.error('  All download methods failed:', err.message);
-        }
-
-        if (!tempFile) {
-          this._cleanup();
-          this.isPlaying = false;
-          this.isPaused = false;
-          this._advancing = false;
-          return reject(new Error('No playable audio source found'));
-        }
-
-        this.currentTrack = title || query;
-        this._ytDlpProc = ytProc;
-        this._tempFile = tempFile;
-
-        const speaker = new Speaker({
-          channels: 2,
-          bitDepth: 16,
-          sampleRate: 44100
-        });
-
-        this.speaker = speaker;
-
-        const volumeFilter = this.isMuted ? 'volume=0' : 'volume=1';
-
-        const ff = ffmpeg(tempFile)
-          .format('s16le')
-          .audioFrequency(44100)
-          .audioChannels(2)
-          .audioFilter(volumeFilter)
-          .on('error', (err) => {
-            if (this._intentionalStop) return;
-            console.error('Stream error:', err.message);
-            this._cleanup();
-            this._cleanupTempFile();
-            this.isPlaying = false;
-            this.isPaused = false;
-            this._advancing = false;
-            this._removeCurrentFromQueue();
-            reject(new Error(err.message));
-          })
-           .on('end', () => {
-            if (this._intentionalStop) return;
-            this._cleanup();
-            this._cleanupTempFile();
-            this.isPlaying = false;
-            this.isPaused = false;
-            this._advancing = false;
-            this._autoNext();
-          })
-          .pipe(speaker, { end: true });
-
-        this.ffmpegProcess = ff;
-        this.isPlaying = true;
-        this.isPaused = false;
-        resolve();
-      } catch (err) {
-        this._cleanup();
-        this.isPlaying = false;
-        this.isPaused = false;
-        this._advancing = false;
-        this._removeCurrentFromQueue();
-        reject(err);
-      }
-    });
-  }
-
-  _removeCurrentFromQueue() {
-    if (this.currentIndex < 0 || this.currentIndex >= this.queue.length) return;
-    this.queue.splice(this.currentIndex, 1);
-    if (this.queue.length === 0) {
-      this.currentIndex = -1;
-      this.currentTrack = null;
-    } else if (this.currentIndex >= this.queue.length) {
-      this.currentIndex = this.queue.length - 1;
-    }
-  }
-
-  async play(query) {
-    this._cleanup();
-    this.queue = [query];
-    this.currentIndex = 0;
-    this.currentTrack = query;
-    this._playPromise = this._createStream(query);
-    await this._playPromise;
-    return `Now playing: ${query}`;
-  }
-
-  async playFromQueue(index) {
-    if (index < 0 || index >= this.queue.length) return 'Invalid queue index';
-    this._cleanup();
-    this.currentIndex = index;
-    this.currentTrack = this.queue[index];
-    this._playPromise = this._createStream(this.currentTrack);
-    await this._playPromise;
-    return `Playing from queue [${index + 1}/${this.queue.length}]: ${this.currentTrack}`;
-  }
-
-  async addToQueue(query) {
-    this.queue.push(query);
-    if (!this.isPlaying) {
-      this.currentIndex = this.queue.length - 1;
-      return await this.play(query);
-    }
-    return `Added "${query}" to queue (position ${this.queue.length})`;
-  }
-
-  next() {
-    if (this.currentIndex < this.queue.length - 1) {
-      this._cleanup();
-      this.currentIndex++;
-      this.currentTrack = this.queue[this.currentIndex];
-      this._playPromise = this._createStream(this.currentTrack);
-      return `Playing next track [${this.currentIndex + 1}/${this.queue.length}]: ${this.currentTrack}`;
-    }
-    return 'No next track in queue';
-  }
-
-  prev() {
-    if (this.currentIndex > 0) {
-      this._cleanup();
-      this.currentIndex--;
-      this.currentTrack = this.queue[this.currentIndex];
-      this._playPromise = this._createStream(this.currentTrack);
-      return `Playing previous track [${this.currentIndex + 1}/${this.queue.length}]: ${this.currentTrack}`;
-    }
-    return 'No previous track in queue';
-  }
-
-  removeFromQueue(index) {
-    if (index < 0 || index >= this.queue.length) return 'Invalid queue index';
-    const removed = this.queue[index];
-    this.queue.splice(index, 1);
-    if (this.currentIndex === index) {
-      this._cleanup();
-      this.isPlaying = false;
-      this.isPaused = false;
-      this.currentTrack = null;
-      return `Removed current track: ${removed} (stopped playback)`;
-    } else if (this.currentIndex > index) {
-      this.currentIndex--;
-    }
-    return `Removed "${removed}" from queue`;
-  }
-
-  stop() {
-    this._cleanup();
-    this._cleanupTempFile();
-    this.isPlaying = false;
-    this.isPaused = false;
-    this.currentTrack = null;
-    this.queue = [];
-    this.currentIndex = -1;
-    this._playPromise = null;
-    return 'Stopped playback and cleared queue';
-  }
-
-  clearQueue() {
-    if (this.isPlaying) {
-      this._cleanup();
-      this._cleanupTempFile();
-      this.isPlaying = false;
-      this.isPaused = false;
-      this.currentTrack = null;
-    }
-    const count = this.queue.length;
-    this.queue = [];
-    this.currentIndex = -1;
-    return `Cleared ${count} songs from queue`;
-  }
-
-  pause() {
-    if (!this.isPlaying) return 'No song is currently playing';
-    this.isPaused = true;
-    this._cleanup();
-    return `Paused: ${this.currentTrack}`;
-  }
-
-  resume() {
-    if (!this.isPaused || !this.currentTrack) return 'No track is paused';
-    this.isPaused = false;
-    if (this._tempFile) {
-      this._replayFromTemp();
-    } else {
-      this._playPromise = this._createStream(this.currentTrack);
-    }
-    return `Resumed: ${this.currentTrack}`;
-  }
-
-  mute() {
-    if (!this.isPlaying) return 'No song is currently playing';
-    this.isMuted = true;
-    if (this._tempFile) {
-      this._replayFromTemp();
-    }
-    return `Muted: ${this.currentTrack}`;
-  }
-
-  unmute() {
-    if (!this.isPlaying) return 'No song is currently playing';
-    this.isMuted = false;
-    if (this._tempFile) {
-      this._replayFromTemp();
-    }
-    return `Unmuted: ${this.currentTrack}`;
-  }
-
-  _replayFromTemp() {
-    this._intentionalStop = true;
-
-    if (this.speaker) {
-      try { this.speaker.close(); } catch {}
-      this.speaker = null;
-    }
-    if (this.ffmpegProcess) {
-      try { this.ffmpegProcess.kill('SIGKILL'); } catch {}
-      this.ffmpegProcess = null;
-    }
-
-    const speaker = new Speaker({
-      channels: 2,
-      bitDepth: 16,
-      sampleRate: 44100
-    });
-    this.speaker = speaker;
-
-    const volumeFilter = this.isMuted ? 'volume=0' : 'volume=1';
-
-    this._intentionalStop = false;
-    const ff = ffmpeg(this._tempFile)
-      .format('s16le')
-      .audioFrequency(44100)
-      .audioChannels(2)
-      .audioFilter(volumeFilter)
-      .on('error', (err) => {
-        if (this._intentionalStop) return;
-        console.error('Replay stream error:', err.message);
-        this._cleanup();
-        this._cleanupTempFile();
-        this.isPlaying = false;
-        this.isPaused = false;
-        this._advancing = false;
-        this._removeCurrentFromQueue();
-      })
-      .on('end', () => {
-        if (this._intentionalStop) return;
-        this._cleanup();
-        this._cleanupTempFile();
-        this.isPlaying = false;
-        this.isPaused = false;
-        this._advancing = false;
-        this._autoNext();
-      })
-      .pipe(speaker, { end: true });
-
-    this.ffmpegProcess = ff;
-  }
-
-  async searchYouTube(query) {
-    try {
-      const result = await yts(query);
-      const results = result.videos || [];
-      return results.map(item => {
-        let duration = '--:--';
-        if (item.duration) {
-          if (typeof item.duration === 'number') {
-            duration = `${Math.floor(item.duration / 60)}:${String(item.duration % 60).padStart(2, '0')}`;
-          } else if (typeof item.duration === 'object' && typeof item.duration.seconds === 'number') {
-            const s = item.duration.seconds;
-            duration = `${Math.floor(s / 60)}:${String(s % 60).padStart(2, '0')}`;
-          } else if (typeof item.duration === 'string') {
-            duration = item.duration;
-          }
-        }
-        return {
-          title: item.title,
-          url: item.url,
-          duration,
-          channel: item.author?.name || item.channel?.name || 'Unknown'
-        };
-      });
-    } catch (err) {
-      console.error('YouTube search error:', err.message);
-      return [];
-    }
-  }
-
-  getQueue() {
-    return this.queue.map((track, i) => ({
-      index: i,
-      title: track,
-      isCurrent: i === this.currentIndex
-    }));
-  }
-
-  getStatus() {
-    if (this.isPlaying && this.currentTrack) {
-      const shortName = this.currentTrack.length > 20
-        ? this.currentTrack.slice(0, 20) + '...'
-        : this.currentTrack;
-      const qInfo = this.queue.length > 1 ? ` [${this.queue.length} in queue]` : '';
-      if (this.isMuted) {
-        return `[Muted: ${shortName}${qInfo}]`;
-      }
-      if (this.isPaused) {
-        return `[Paused: ${shortName}${qInfo}]`;
-      }
-      return `[Playing: ${shortName}${qInfo}]`;
-    }
-    if (this.queue.length > 0) {
-      return `[Queue: ${this.queue.length} songs]`;
-    }
-    return '';
-  }
-
-  getFullState() {
-    return {
-      isPlaying: this.isPlaying,
-      isPaused: this.isPaused,
-      currentTrack: this.currentTrack,
-      queue: this.queue,
-      currentIndex: this.currentIndex,
-      queueLength: this.queue.length
-    };
-  }
-
-  _autoNext() {
-    if (this._advancing) return;
-    if (this.queue.length > 0 && this.currentIndex < this.queue.length - 1) {
-      this._advancing = true;
-      this.currentIndex++;
-      this.currentTrack = this.queue[this.currentIndex];
-      this._createStream(this.currentTrack);
-    } else {
-      this.currentTrack = null;
-    }
-  }
-}
-
-export const audioPlayer = new AudioPlayer();
+import { spawn } from 'child_process';
+import { existsSync, unlinkSync, readdirSync, statSync } from 'node:fs';
+import { join, dirname, basename } from 'node:path';
+import { ensureYouTubeCookies, getCookieStatus } from './youtubeAuth.js';
+
+let _ffmpeg = null;
+async function loadFfmpeg() {
+  if (_ffmpeg) return _ffmpeg;
+  try {
+    const [{ default: ffmpeg }, { default: ffmpegPath }] = await Promise.all([
+      import('fluent-ffmpeg'),
+      import('ffmpeg-static'),
+    ]);
+    if (ffmpegPath) ffmpeg.setFfmpegPath(ffmpegPath);
+    _ffmpeg = ffmpeg;
+    return _ffmpeg;
+  } catch {
+    throw new Error('Local audio output is not bundled with the global core CLI because its native dependencies can break installation. You can still use search and media-link features.');
+  }
+}
+
+let _SpeakerCtor = null;
+async function loadSpeaker() {
+  if (_SpeakerCtor) return _SpeakerCtor;
+  try {
+    const mod = await import('speaker');
+    _SpeakerCtor = mod.default;
+  } catch {
+    throw new Error('Local audio output is unavailable in the global core CLI; the native speaker add-on is intentionally not installed.');
+  }
+  return _SpeakerCtor;
+}
+
+const YTDLP_CMD = process.env.KIKU_YTDLP || 'yt-dlp';
+
+function ytDlpSpawn(args) {
+  return spawn(YTDLP_CMD, args, { windowsHide: true });
+}
+
+function ytDlpArgs(query, opts = {}) {
+  const arg = /^https?:\/\//.test(query) ? query : `ytsearch1:${query}`;
+  const args = ['-f', 'bestaudio', '--no-warnings', '--ignore-errors'];
+  if (opts.client) args.push('--extractor-args', `youtube:player_client=${opts.client}`);
+  if (opts.cookies) {
+    if (opts.cookies.startsWith('browser:')) args.push('--cookies-from-browser', opts.cookies.slice('browser:'.length));
+    else args.push('--cookies', opts.cookies);
+  }
+  args.push(arg);
+  return args;
+}
+
+const YTDLP_STRATEGIES = [
+  {},
+  { client: 'tv' },
+  { client: 'ios' },
+  { client: 'web' },
+  { cookies: 'browser:chrome' },
+  { cookies: 'browser:edge' },
+  { cookies: 'browser:firefox' },
+  { cookies: 'browser:brave' },
+  { client: 'tv', cookies: 'browser:chrome' },
+  { client: 'ios', cookies: 'browser:chrome' }
+];
+
+function buildStrategies(cookieResult) {
+  const strategies = [];
+
+  const status = getCookieStatus();
+  const cookiesFile = process.env.KIKU_YT_COOKIES || status.envCookies;
+  if (cookiesFile) {
+    strategies.push({ cookies: cookiesFile });
+  }
+
+  const detectedBrowser = cookieResult?.browser || process.env.KIKU_YT_BROWSER;
+  if (detectedBrowser) {
+    strategies.push({ cookies: `browser:${detectedBrowser}` });
+  }
+
+  if (process.env.KIKU_YTDLP_CLIENT) {
+    strategies.push({ client: process.env.KIKU_YTDLP_CLIENT });
+  }
+
+  for (const s of YTDLP_STRATEGIES) {
+    if (!strategies.some(existing => existing.client === s.client && existing.cookies === s.cookies)) {
+      strategies.push(s);
+    }
+  }
+
+  return strategies;
+}
+
+function ytDlpTry(query, opts) {
+  return new Promise((resolve, reject) => {
+    const proc = ytDlpSpawn(ytDlpArgs(query, opts));
+    let gotData = false;
+    let errBuf = '';
+    proc.stdout.once('data', () => { gotData = true; resolve(proc); });
+    proc.stderr.on('data', d => { errBuf += d.toString(); });
+    proc.on('error', e => { if (!gotData) { try { proc.kill('SIGKILL'); } catch {} reject(e); } });
+    proc.on('close', code => {
+      if (!gotData) { try { proc.kill('SIGKILL'); } catch {} reject(new Error(errBuf.trim() || `yt-dlp exited with code ${code}`)); }
+    });
+  });
+}
+
+function findDownloadedFile(dir, baseName) {
+  try {
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+      if (entry === baseName) {
+        const full = join(dir, entry);
+        try { if (statSync(full).isFile()) return full; } catch {}
+      }
+      if (entry.startsWith(baseName + '.')) {
+        const full = join(dir, entry);
+        try { if (statSync(full).isFile()) return full; } catch {}
+      }
+    }
+  } catch {}
+  return null;
+}
+
+function normalizeSearchQuery(query) {
+  if (!query || typeof query !== 'string') return query;
+  if (/^https?:\/\//.test(query)) return query;
+  if (/jujingyi|จวีจิ้งอี|鞠婧祎|ju jingyi/i.test(query)) return query;
+  return `Ju Jingyi ${query}`;
+}
+
+async function ytDlpDownload(query, opts, outputPath) {
+  const arg = /^https?:\/\//.test(query) ? query : `ytsearch1:${query}`;
+  const args = [
+    '-f', 'bestaudio',
+    '--no-warnings',
+    '--ignore-errors',
+    '-x', '--audio-format', 'mp3',
+    '-o', outputPath + '.%(ext)s',
+    '--no-playlist'
+  ];
+  if (opts.client) args.push('--extractor-args', `youtube:player_client=${opts.client}`);
+  if (opts.cookies) {
+    if (opts.cookies.startsWith('browser:')) args.push('--cookies-from-browser', opts.cookies.slice('browser:'.length));
+    else args.push('--cookies', opts.cookies);
+  }
+  args.push(arg);
+
+  const dir = dirname(outputPath);
+  const baseName = basename(outputPath);
+
+  return new Promise((resolve, reject) => {
+    const p = ytDlpSpawn(args);
+    let err = '';
+    p.stderr.on('data', d => { err += d.toString(); });
+    p.on('error', reject);
+    p.on('close', code => {
+      const found = findDownloadedFile(dir, baseName);
+      if (found) {
+        resolve(found);
+      } else if (code === 0) {
+        resolve(outputPath);
+      } else {
+        reject(new Error(err.trim() || `yt-dlp exited ${code}`));
+      }
+    });
+  });
+}
+
+async function ytDlpGetTitle(query, strategies) {
+  if (!strategies) strategies = buildStrategies();
+  for (const s of strategies) {
+    try {
+      const arg = /^https?:\/\//.test(query) ? query : `ytsearch1:${query}`;
+      const args = ['--print', '%(title)s', '--no-warnings'];
+      if (s.client) args.push('--extractor-args', `youtube:player_client=${s.client}`);
+      if (s.cookies) {
+        if (s.cookies.startsWith('browser:')) args.push('--cookies-from-browser', s.cookies.slice('browser:'.length));
+        else args.push('--cookies', s.cookies);
+      }
+      args.push(arg);
+      const title = await new Promise((resolve, reject) => {
+        const p = ytDlpSpawn(args);
+        let out = '';
+        let err = '';
+        p.stdout.on('data', d => { out += d.toString(); });
+        p.stderr.on('data', d => { err += d.toString(); });
+        p.on('error', e => reject(e));
+        p.on('close', c => {
+          const t = out.trim();
+          if (c === 0 && t) resolve(t);
+          else reject(new Error(err.trim() || `yt-dlp exited ${c}`));
+        });
+      });
+      if (title) return title;
+    } catch {}
+  }
+  return null;
+}
+
+async function ytDlpGetStream(query, strategies) {
+  if (!strategies) strategies = buildStrategies();
+  let lastErr;
+  for (const s of strategies) {
+    try {
+      const proc = await ytDlpTry(query, s);
+      return { proc, opts: s };
+    } catch (e) {
+      lastErr = e;
+    }
+  }
+  throw lastErr || new Error('yt-dlp could not extract an audio stream');
+}
+
+async function ytDlpJsonSearch(query, limit = 10) {
+  return new Promise((resolve, reject) => {
+    const proc = ytDlpSpawn(['--flat-playlist', '--dump-single-json', '--no-warnings', `ytsearch${limit}:${query}`]);
+    let out = '';
+    const timer = setTimeout(() => {
+      try { proc.kill('SIGKILL'); } catch {}
+      reject(new Error('YouTube search timed out'));
+    }, 30000);
+    proc.stdout.on('data', (d) => { out += d.toString(); });
+    proc.on('error', (e) => {
+      clearTimeout(timer);
+      reject(e);
+    });
+    proc.on('close', () => {
+      clearTimeout(timer);
+      try {
+        resolve(JSON.parse(out));
+      } catch {
+        reject(new Error('Could not parse YouTube search results'));
+      }
+    });
+  });
+}
+
+function searchEntryUrl(entry) {
+  if (!entry) return null;
+  return entry.url || (entry.id ? `https://www.youtube.com/watch?v=${entry.id}` : null);
+}
+
+function formatSeconds(secs) {
+  const s = Math.floor(Math.max(0, Number(secs) || 0));
+  const mins = Math.floor(s / 60);
+  const rem = s % 60;
+  return `${mins}:${String(rem).padStart(2, '0')}`;
+}
+
+class AudioPlayer {
+  constructor() {
+    this.ytdlStream = null;
+    this.ffmpegProcess = null;
+    this.speaker = null;
+    this.currentTrack = null;
+    this.isPlaying = false;
+    this.isPaused = false;
+    this.isMuted = false;
+    this.queue = [];
+    this.currentIndex = -1;
+    this._advancing = false;
+    this._playPromise = null;
+    this._ytDlpProc = null;
+    this._intentionalStop = false;
+    this._currentOffsetSeconds = 0;
+    this._playbackStartedAt = 0;
+  }
+
+  _cleanup() {
+    this._intentionalStop = true;
+    if (this.speaker) {
+      try { this.speaker.close(); } catch {}
+      this.speaker = null;
+    }
+    if (this._ytDlpProc) {
+      try { this._ytDlpProc.kill('SIGKILL'); } catch {}
+      this._ytDlpProc = null;
+    }
+    if (this.ffmpegProcess) {
+      try { this.ffmpegProcess.kill('SIGKILL'); } catch {}
+      this.ffmpegProcess = null;
+    }
+    if (this.ytdlStream) {
+      try { this.ytdlStream.destroy(); } catch {}
+      this.ytdlStream = null;
+    }
+  }
+
+  _cleanupTempFile() {
+    this._currentOffsetSeconds = 0;
+    this._playbackStartedAt = 0;
+    if (!this._tempFile) return;
+    try {
+      const dir = dirname(this._tempFile);
+      const baseName = basename(this._tempFile);
+      const entries = readdirSync(dir);
+      for (const entry of entries) {
+        if (entry === baseName || entry.startsWith(baseName + '.')) {
+          try { unlinkSync(join(dir, entry)); } catch {}
+        }
+      }
+    } catch {}
+    this._tempFile = null;
+  }
+
+  _createStream(query) {
+    this._intentionalStop = false;
+    query = normalizeSearchQuery(query);
+    return new Promise(async (resolve, reject) => {
+      try {
+        const cookieResult = await ensureYouTubeCookies({ silent: true });
+        if (!cookieResult.ok) {
+          console.error('  [WARNING] YouTube cookies unavailable (' + (cookieResult.reason || 'unknown') + ')');
+          console.error('    Playback may fail due to YouTube restrictions.');
+          console.error('    Run /login to sign in, or set KIKU_YT_COOKIES in .env\n');
+        } else {
+          console.log(`  [OK] YouTube session: ${cookieResult.source} (${cookieResult.browser || cookieResult.cookiesPath || 'file'})`);
+        }
+
+        const strategies = buildStrategies(cookieResult);
+
+        let tempFile = null;
+        let title = null;
+        let ytProc = null;
+
+        try {
+          title = await ytDlpGetTitle(query, strategies).catch(() => null);
+
+          const { mkdtemp } = await import('node:fs/promises');
+          const { tmpdir } = await import('node:os');
+          const tmpDir = await mkdtemp(join(tmpdir(), 'kiku-audio-'));
+          tempFile = join(tmpDir, 'audio');
+
+          let downloaded = false;
+          for (const s of strategies) {
+            try {
+              const downloadedPath = await ytDlpDownload(query, s, tempFile);
+              tempFile = downloadedPath;
+              downloaded = true;
+              console.log('  [OK] Downloaded audio via yt-dlp to', tempFile);
+              break;
+            } catch (e) {
+              console.log('  Strategy failed:', e.message.slice(0, 80));
+            }
+          }
+
+          if (!downloaded) {
+            console.error('  [WARNING] yt-dlp could not download a playable audio source.');
+            tempFile = null;
+          }
+        } catch (err) {
+          console.error('  All download methods failed:', err.message);
+        }
+
+        if (!tempFile) {
+          this._cleanup();
+          this.isPlaying = false;
+          this.isPaused = false;
+          this._advancing = false;
+          return reject(new Error('No playable audio source found'));
+        }
+
+        this.currentTrack = title || query;
+        this._ytDlpProc = ytProc;
+        this._tempFile = tempFile;
+        this._currentOffsetSeconds = 0;
+        this._playbackStartedAt = Date.now();
+
+        const SpeakerCtor = await loadSpeaker();
+        const speaker = new SpeakerCtor({
+          channels: 2,
+          bitDepth: 16,
+          sampleRate: 44100
+        });
+
+        this.speaker = speaker;
+
+        const volumeFilter = this.isMuted ? 'volume=0' : 'volume=1';
+
+        const ffmpeg = await loadFfmpeg();
+        let ff = ffmpeg(tempFile);
+        if (this._currentOffsetSeconds > 0) {
+          ff = ff.seekInput(this._currentOffsetSeconds);
+        }
+        ff = ff
+          .format('s16le')
+          .audioFrequency(44100)
+          .audioChannels(2)
+          .audioFilter(volumeFilter)
+          .on('error', (err) => {
+            if (this._intentionalStop) return;
+            console.error('Stream error:', err.message);
+            this._cleanup();
+            this._cleanupTempFile();
+            this.isPlaying = false;
+            this.isPaused = false;
+            this._advancing = false;
+            this._removeCurrentFromQueue();
+            reject(new Error(err.message));
+          })
+           .on('end', () => {
+            if (this._intentionalStop) return;
+            this._cleanup();
+            this._cleanupTempFile();
+            this.isPlaying = false;
+            this.isPaused = false;
+            this._advancing = false;
+            this._autoNext();
+          })
+          .pipe(speaker, { end: true });
+
+        this.ffmpegProcess = ff;
+        this.isPlaying = true;
+        this.isPaused = false;
+        resolve();
+      } catch (err) {
+        this._cleanup();
+        this.isPlaying = false;
+        this.isPaused = false;
+        this._advancing = false;
+        this._removeCurrentFromQueue();
+        reject(err);
+      }
+    });
+  }
+
+  _removeCurrentFromQueue() {
+    if (this.currentIndex < 0 || this.currentIndex >= this.queue.length) return;
+    this.queue.splice(this.currentIndex, 1);
+    if (this.queue.length === 0) {
+      this.currentIndex = -1;
+      this.currentTrack = null;
+    } else if (this.currentIndex >= this.queue.length) {
+      this.currentIndex = this.queue.length - 1;
+    }
+  }
+
+  async play(query) {
+    this._cleanup();
+    this.queue = [query];
+    this.currentIndex = 0;
+    this.currentTrack = query;
+    this._playPromise = this._createStream(query);
+    await this._playPromise;
+    return `Now playing: ${query}`;
+  }
+
+  async playFromQueue(index) {
+    if (index < 0 || index >= this.queue.length) return 'Invalid queue index';
+    this._cleanup();
+    this.currentIndex = index;
+    this.currentTrack = this.queue[index];
+    this._playPromise = this._createStream(this.currentTrack);
+    await this._playPromise;
+    return `Playing from queue [${index + 1}/${this.queue.length}]: ${this.currentTrack}`;
+  }
+
+  async addToQueue(query) {
+    this.queue.push(query);
+    if (!this.isPlaying) {
+      this.currentIndex = this.queue.length - 1;
+      return await this.play(query);
+    }
+    return `Added "${query}" to queue (position ${this.queue.length})`;
+  }
+
+  next() {
+    if (this.currentIndex < this.queue.length - 1) {
+      this._cleanup();
+      this.currentIndex++;
+      this.currentTrack = this.queue[this.currentIndex];
+      this._playPromise = this._createStream(this.currentTrack);
+      return `Playing next track [${this.currentIndex + 1}/${this.queue.length}]: ${this.currentTrack}`;
+    }
+    return 'No next track in queue';
+  }
+
+  prev() {
+    if (this.currentIndex > 0) {
+      this._cleanup();
+      this.currentIndex--;
+      this.currentTrack = this.queue[this.currentIndex];
+      this._playPromise = this._createStream(this.currentTrack);
+      return `Playing previous track [${this.currentIndex + 1}/${this.queue.length}]: ${this.currentTrack}`;
+    }
+    return 'No previous track in queue';
+  }
+
+  removeFromQueue(index) {
+    if (index < 0 || index >= this.queue.length) return 'Invalid queue index';
+    const removed = this.queue[index];
+    this.queue.splice(index, 1);
+    if (this.currentIndex === index) {
+      this._cleanup();
+      this.isPlaying = false;
+      this.isPaused = false;
+      this.currentTrack = null;
+      return `Removed current track: ${removed} (stopped playback)`;
+    } else if (this.currentIndex > index) {
+      this.currentIndex--;
+    }
+    return `Removed "${removed}" from queue`;
+  }
+
+  stop() {
+    this._currentOffsetSeconds = 0;
+    this._playbackStartedAt = 0;
+    this._cleanup();
+    this._cleanupTempFile();
+    this.isPlaying = false;
+    this.isPaused = false;
+    this.currentTrack = null;
+    this.queue = [];
+    this.currentIndex = -1;
+    this._playPromise = null;
+    return 'Stopped playback and cleared queue';
+  }
+
+  clearQueue() {
+    if (this.isPlaying) {
+      this._cleanup();
+      this._cleanupTempFile();
+      this.isPlaying = false;
+      this.isPaused = false;
+      this.currentTrack = null;
+    }
+    const count = this.queue.length;
+    this.queue = [];
+    this.currentIndex = -1;
+    this._currentOffsetSeconds = 0;
+    this._playbackStartedAt = 0;
+    return `Cleared ${count} songs from queue`;
+  }
+
+  pause() {
+    if (!this.isPlaying) return 'No song is currently playing';
+    if (this.isPaused) return 'Song is already paused';
+    if (this._playbackStartedAt > 0) {
+      const elapsed = (Date.now() - this._playbackStartedAt) / 1000;
+      this._currentOffsetSeconds += Math.max(0, elapsed);
+      this._playbackStartedAt = 0;
+    }
+    this.isPaused = true;
+    this._cleanup();
+    const pos = formatSeconds(this._currentOffsetSeconds);
+    return `Paused: ${this.currentTrack} (${pos})`;
+  }
+
+  resume() {
+    if (!this.isPaused || !this.currentTrack) return 'No track is paused';
+    this.isPaused = false;
+    this.isPlaying = true;
+    this._playbackStartedAt = Date.now();
+    if (this._tempFile) {
+      this._replayFromTemp();
+    } else {
+      this._playPromise = this._createStream(this.currentTrack);
+    }
+    const pos = formatSeconds(this._currentOffsetSeconds);
+    return `Resumed: ${this.currentTrack} (from ${pos})`;
+  }
+
+  mute() {
+    if (!this.isPlaying) return 'No song is currently playing';
+    this.isMuted = true;
+    if (this._playbackStartedAt > 0 && !this.isPaused) {
+      this._currentOffsetSeconds += (Date.now() - this._playbackStartedAt) / 1000;
+      this._playbackStartedAt = Date.now();
+    }
+    if (this._tempFile && !this.isPaused) {
+      this._replayFromTemp();
+    }
+    return `Muted: ${this.currentTrack}`;
+  }
+
+  unmute() {
+    if (!this.isPlaying) return 'No song is currently playing';
+    this.isMuted = false;
+    if (this._playbackStartedAt > 0 && !this.isPaused) {
+      this._currentOffsetSeconds += (Date.now() - this._playbackStartedAt) / 1000;
+      this._playbackStartedAt = Date.now();
+    }
+    if (this._tempFile && !this.isPaused) {
+      this._replayFromTemp();
+    }
+    return `Unmuted: ${this.currentTrack}`;
+  }
+
+  _replayFromTemp() {
+    this._startTempPlayback().catch((err) => {
+      console.error('Replay error:', err.message);
+      this._cleanup();
+      this._cleanupTempFile();
+      this.isPlaying = false;
+      this.isPaused = false;
+      this._advancing = false;
+    });
+  }
+
+  async _startTempPlayback() {
+    this._intentionalStop = true;
+
+    if (this.speaker) {
+      try { this.speaker.close(); } catch {}
+      this.speaker = null;
+    }
+    if (this.ffmpegProcess) {
+      try { this.ffmpegProcess.kill('SIGKILL'); } catch {}
+      this.ffmpegProcess = null;
+    }
+
+    const SpeakerCtor = await loadSpeaker();
+    const speaker = new SpeakerCtor({
+      channels: 2,
+      bitDepth: 16,
+      sampleRate: 44100
+    });
+    this.speaker = speaker;
+
+    const volumeFilter = this.isMuted ? 'volume=0' : 'volume=1';
+
+    this._intentionalStop = false;
+    const ffmpeg = await loadFfmpeg();
+    let ff = ffmpeg(this._tempFile);
+    if (this._currentOffsetSeconds > 0) {
+      ff = ff.seekInput(this._currentOffsetSeconds);
+    }
+    ff = ff
+      .format('s16le')
+      .audioFrequency(44100)
+      .audioChannels(2)
+      .audioFilter(volumeFilter)
+      .on('error', (err) => {
+        if (this._intentionalStop) return;
+        console.error('Replay stream error:', err.message);
+        this._cleanup();
+        this._cleanupTempFile();
+        this.isPlaying = false;
+        this.isPaused = false;
+        this._advancing = false;
+        this._removeCurrentFromQueue();
+      })
+      .on('end', () => {
+        if (this._intentionalStop) return;
+        this._cleanup();
+        this._cleanupTempFile();
+        this.isPlaying = false;
+        this.isPaused = false;
+        this._advancing = false;
+        this._autoNext();
+      })
+      .pipe(speaker, { end: true });
+
+    this.ffmpegProcess = ff;
+  }
+
+  async searchYouTube(query) {
+    try {
+      const data = await ytDlpJsonSearch(query, 10);
+      const results = data.entries || [];
+      return results
+        .filter(Boolean)
+        .map(item => {
+          let duration = '--:--';
+          if (typeof item.duration === 'number') {
+            duration = `${Math.floor(item.duration / 60)}:${String(Math.round(item.duration % 60)).padStart(2, '0')}`;
+          }
+          const url = searchEntryUrl(item);
+          return {
+            title: item.title,
+            url,
+            duration,
+            channel: item.channel || item.uploader || 'Unknown'
+          };
+        })
+        .filter(item => item.url);
+    } catch (err) {
+      console.error('YouTube search error:', err.message);
+      return [];
+    }
+  }
+
+  getQueue() {
+    return this.queue.map((track, i) => ({
+      index: i,
+      title: track,
+      isCurrent: i === this.currentIndex
+    }));
+  }
+
+  getStatus() {
+    if (this.isPlaying && this.currentTrack) {
+      const shortName = this.currentTrack.length > 20
+        ? this.currentTrack.slice(0, 20) + '...'
+        : this.currentTrack;
+      const qInfo = this.queue.length > 1 ? ` [${this.queue.length} in queue]` : '';
+      let currentPos = this._currentOffsetSeconds;
+      if (!this.isPaused && this._playbackStartedAt > 0) {
+        currentPos += (Date.now() - this._playbackStartedAt) / 1000;
+      }
+      const timeStr = currentPos > 0 ? ` (${formatSeconds(currentPos)})` : '';
+      if (this.isMuted) {
+        return `[Muted: ${shortName}${timeStr}${qInfo}]`;
+      }
+      if (this.isPaused) {
+        return `[Paused: ${shortName}${timeStr}${qInfo}]`;
+      }
+      return `[Playing: ${shortName}${timeStr}${qInfo}]`;
+    }
+    if (this.queue.length > 0) {
+      return `[Queue: ${this.queue.length} songs]`;
+    }
+    return '';
+  }
+
+  getFullState() {
+    return {
+      isPlaying: this.isPlaying,
+      isPaused: this.isPaused,
+      currentTrack: this.currentTrack,
+      queue: this.queue,
+      currentIndex: this.currentIndex,
+      queueLength: this.queue.length
+    };
+  }
+
+  _autoNext() {
+    if (this._advancing) return;
+    if (this.queue.length > 0 && this.currentIndex < this.queue.length - 1) {
+      this._advancing = true;
+      this.currentIndex++;
+      this.currentTrack = this.queue[this.currentIndex];
+      this._createStream(this.currentTrack);
+    } else {
+      this.currentTrack = null;
+    }
+  }
+}
+
+export const audioPlayer = new AudioPlayer();