kiku-agent 1.0.0

package/server/agent/audioPlayer.js

@@ -0,0 +1,673 @@
+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();