@ing.jorgeu/wargaming-overlay 2.4.0 → 3.0.0

package/tts/playback.js

@@ -0,0 +1,28 @@
+// No external player: the npm package contains native CoreAudio/WASAPI/ALSA bindings.
+async function play(samples,sampleRate,{cpal=require('node-cpal')}={}){
+ let host,device,stream;
+ try{
+  host=cpal.defaultHost();device=host.defaultOutputDevice();
+  if(!device)throw Error('No hay salida de audio predeterminada.');
+  let supported=device.defaultOutputConfig();
+  if(supported.sampleFormat()!==cpal.SampleFormat.F32){
+   const candidate=[...device.supportedOutputConfigs()].find(c=>c.sampleFormat()===cpal.SampleFormat.F32);
+   if(!candidate)throw Error('La salida de audio no admite float32.');
+   supported=candidate.tryWithSampleRate(supported.sampleRate())||candidate.tryWithStandardSampleRate()||candidate.withMaxSampleRate();
+  }
+  const config=supported.config();let position=0,finished=false,drainTimer;
+  await new Promise((resolve,reject)=>{
+   stream=device.buildOutputStream(config,cpal.SampleFormat.F32,data=>{
+    for(let frame=0;frame<data.length/config.channels;frame++){
+     const left=Math.floor(position),fraction=position-left;
+     const sample=left<samples.length?(samples[left]*(1-fraction)+(samples[Math.min(left+1,samples.length-1)]||0)*fraction):0;
+     for(let channel=0;channel<config.channels;channel++)data[frame*config.channels+channel]=sample;
+     position+=sampleRate/config.sampleRate;
+    }
+    if(position>=samples.length&&!finished){finished=true;drainTimer=setTimeout(resolve,Math.ceil(data.length/config.channels/config.sampleRate*1000)+250);}
+   },error=>{clearTimeout(drainTimer);reject(error);});
+   stream.play();
+  });
+ }finally{stream?.close();device?.close();host?.close();}
+}
+module.exports={play};

package/tts/queue.js

@@ -0,0 +1,22 @@
+const {speak}=require('./speech');
+class SpeechQueue {
+ constructor({maxQueueLength=10,speech=speak,log=console.log}={}){this.max=maxQueueLength;this.speech=speech;this.log=log;this.queue=[];this.state='IDLE';this.closed=false;this.task=null;this.failed=0;}
+ enqueue(message){
+  if(this.closed)return;
+  if(this.queue.length>=this.max){this.queue.shift();this.log('[TTS] Se descartó el mensaje pendiente más antiguo: cola llena.');}
+  this.queue.push(message);this.log(`[TTS] En cola: ${message.author}. Pendientes: ${this.queue.length}.`);
+  if(!this.task)this.task=this.drain().finally(()=>{this.task=null;});
+ }
+ async drain(){
+  while(!this.closed&&this.queue.length){
+   const item=this.queue.shift();this.state='SPEAKING';this.controller=new AbortController();
+   this.log(`[TTS] Leyendo mensaje de ${item.author}.`);
+   try{await this.speech(item.spoken,{signal:this.controller.signal});}catch{this.failed++;this.log('[TTS] Falló la reproducción; continúo con el siguiente mensaje.');}
+  }
+  this.state='IDLE';
+ }
+ clear(){this.queue=[];this.controller?.abort();}
+ async stop(){this.closed=true;this.clear();await this.task;}
+ async idle(){await this.task;}
+}
+module.exports={SpeechQueue};

package/tts/sanitizer.js

@@ -0,0 +1,31 @@
+// Deliberately small local ES/EN filter, not semantic moderation.
+// Ordinary profanity and in-game violence are not blanket-blocked.
+const severe=[
+ /\b(?:n[i1]gg(?:er|a)s?|f[a4]gg?[o0]ts?|k[i1]kes?|sp[i1]cs?|sudacas?|maricones)\b/giu,
+ /\b(?:heil\s+hitler|sieg\s+heil)\b/giu,
+ /\b(?:te\s+voy\s+a\s+(?:matar|violar)|voy\s+a\s+(?:matarte|violarte)|i(?:'ll|\s+will)\s+(?:kill|rape)\s+you)\b/giu,
+ /\b(?:maten|matad|exterminen|hay\s+que\s+matar|kill|exterminate)\s+(?:(?:a|a\s+los|los|las|all|the)\s+)*(?:judios|negros|gays|musulmanes|inmigrantes|jews|blacks|muslims|immigrants)\b/giu,
+ /\b(?:chupa(?:me)?\s+(?:la\s+)?(?:polla|verga)|suck\s+my\s+(?:dick|cock)|(?:sexo|pornografia|porn)\s+(?:con\s+)?(?:ninos|menores|children))\b/giu
+];
+function truncate(text,max){const chars=Array.from(text);if(chars.length<=max)return text;let cut=chars.slice(0,max-1).join('');const space=cut.lastIndexOf(' ');if(space>max*.7)cut=cut.slice(0,space);return cut.trimEnd()+'…';}
+function clean(input,{filterUrls=true,extraBlockedTerms=[]}={}){
+ let text=String(input||'').slice(0,10000).normalize('NFKC').replace(/[\p{Cc}\p{Cf}]/gu,' ').replace(/[\[\]<>]/g,' ').replace(/\s+/g,' ').trim();
+ if(filterUrls)text=text.replace(/(?:[a-z][a-z\d+.-]*:\/\/|www\.)[^\s]+|\b(?:[\p{L}\d-]+\.)+[a-z]{2,63}(?:\/[^\s]*)?/giu,' Enlace ');
+ // Accent-insensitive matching with offsets mapped back to the original spelling.
+ const chars=Array.from(text),folded=[],offsets=[];let offset=0;
+ for(const ch of chars){const f=ch.normalize('NFD').replace(/\p{M}/gu,'');for(let j=0;j<f.length;j++)offsets.push([offset,offset+ch.length]);folded.push(f);offset+=ch.length;}
+ const normalized=folded.join(''),spans=[];
+ const patterns=[...severe,...extraBlockedTerms.filter(t=>typeof t==='string'&&t.trim()).slice(0,100).map(t=>new RegExp(t.normalize('NFD').replace(/\p{M}/gu,'').replace(/[.*+?^${}()|[\]\\]/g,'\\$&'),'giu'))];
+ for(const re of patterns){re.lastIndex=0;for(const m of normalized.matchAll(re))if(m[0].length)spans.push([offsets[m.index][0],offsets[m.index+m[0].length-1][1]]);}
+ spans.sort((a,b)=>a[0]-b[0]);const merged=[];
+ for(const span of spans){const last=merged.at(-1);if(last&&span[0]<=last[1])last[1]=Math.max(last[1],span[1]);else merged.push([...span]);}
+ for(const [start,end] of merged.reverse())text=text.slice(0,start)+'[censurado]'+text.slice(end);
+ return text.replace(/\s+/g,' ').trim();
+}
+function sanitize(message,config={}){
+ const text=truncate(clean(message.text,config),config.maxMessageLength||300);
+ if(!text || !text.replace(/\[censurado\]|[^\p{L}\p{N}]/gu,''))return null;
+ const author=truncate(clean(message.author,config),40)||'Usuario';
+ return {author,text,spoken:config.readUsername===false?text:`${author} dice: ${text}`};
+}
+module.exports={sanitize,clean,truncate};

package/tts/speech.js

@@ -0,0 +1,72 @@
+const {spawn}=require('node:child_process');
+function say(text,{spawnImpl=spawn,platform=process.platform,signal,timeoutMs=120000}={}){
+ if(platform!=='darwin')return Promise.reject(Error('El TTS local requiere macOS.'));
+ if(signal?.aborted)return Promise.resolve();
+ return new Promise((resolve,reject)=>{
+  // Feed text through stdin, not a shell/option. Remove Apple's embedded speech commands.
+  const child=spawnImpl('/usr/bin/say',[],{stdio:['pipe','ignore','pipe'],shell:false});
+  let timedOut=false,done=false;
+  const stop=()=>{
+   if(platform==='win32'&&child.pid){const killer=spawnImpl('taskkill.exe',['/PID',String(child.pid),'/T','/F'],{shell:false,windowsHide:true,stdio:'ignore'});killer.once('error',()=>child.kill('SIGKILL'));killer.unref?.();}
+   else child.kill('SIGKILL');
+  };
+  const timer=setTimeout(()=>{timedOut=true;stop();},timeoutMs);
+  const finish=(error)=>{if(done)return;done=true;clearTimeout(timer);signal?.removeEventListener('abort',stop);error?reject(error):resolve();};
+  signal?.addEventListener('abort',stop,{once:true});
+  child.stderr?.resume();child.stdin.on('error',()=>{});
+  child.once('error',()=>finish(Error('No se pudo iniciar la voz nativa de macOS.')));
+  child.once('close',code=>finish(signal?.aborted?null:timedOut?Error('Se agotó el tiempo de voz.'):code===0?null:Error('La voz de macOS terminó con un error.')));
+  child.stdin.end(String(text).replace(/[\[\]]/g,''));
+  if(signal?.aborted)stop();
+ });
+}
+
+
+const path=require('node:path'),fs=require('node:fs'),os=require('node:os');
+const {cacheDirectory}=require('./kokoro-assets');
+function settings(config={},env=process.env,platform=process.platform){
+ const opts={provider:env.TTS_PROVIDER||config.ttsProvider||'kokoro',fallback:env.TTS_FALLBACK||config.ttsFallback||(platform==='darwin'?'say':'none'),voice:env.KOKORO_VOICE||config.kokoroVoice||'ef_dora',speed:Number(env.KOKORO_SPEED??config.kokoroSpeed??1),cacheDir:env.KOKORO_CACHE_DIR||config.kokoroCacheDir||cacheDirectory()};
+ if(!['kokoro','say'].includes(opts.provider))throw Error('ttsProvider debe ser kokoro o say.');
+ if(!['say','none'].includes(opts.fallback))throw Error('ttsFallback debe ser say o none.');
+ if((opts.provider==='say'||opts.fallback==='say')&&platform!=='darwin')throw Error('say solo está disponible en macOS. Usa kokoro y ttsFallback=none.');
+ if(!['ef_dora','em_alex','em_santa'].includes(opts.voice))throw Error('kokoroVoice debe ser ef_dora, em_alex o em_santa.');
+ if(!Number.isFinite(opts.speed)||opts.speed<0.5||opts.speed>2)throw Error('kokoroSpeed debe estar entre 0.5 y 2.');
+ if(typeof opts.cacheDir!=='string'||!opts.cacheDir)throw Error('kokoroCacheDir debe ser una ruta.');
+ return opts;
+}
+function kokoro(text,{spawnImpl=spawn,platform=process.platform,signal,timeoutMs=120000,log=console.log,...opts}={}){
+ if(signal?.aborted)return Promise.resolve();
+ return new Promise((resolve,reject)=>{
+  const temporary=fs.mkdtempSync(path.join(os.tmpdir(),'overlay-tts-'));
+  const child=spawnImpl(process.execPath,[path.join(__dirname,'kokoro-worker.js')],{stdio:['pipe','ignore','pipe'],shell:false,windowsHide:true,cwd:temporary,...(temporary?{env:{...process.env,OVERLAY_TTS_TEMP_DIR:temporary}}:{})});
+  let done=false,timedOut=false;
+  const stop=()=>{
+   if(platform==='win32'&&child.pid){const killer=spawnImpl('taskkill.exe',['/PID',String(child.pid),'/T','/F'],{shell:false,windowsHide:true,stdio:'ignore'});killer.once('error',()=>child.kill('SIGKILL'));killer.unref?.();}
+   else child.kill('SIGKILL');
+  };
+  const timer=setTimeout(()=>{timedOut=true;stop();},timeoutMs);
+  const finish=error=>{if(done)return;done=true;clearTimeout(timer);signal?.removeEventListener('abort',stop);
+   const cleanup=temporary?require('node:fs/promises').rm(temporary,{recursive:true,force:true,maxRetries:5,retryDelay:100}).catch(()=>log('[TTS] No se pudo limpiar un archivo de audio temporal.')):Promise.resolve();
+   cleanup.then(()=>error?reject(error):resolve());
+  };
+  signal?.addEventListener('abort',stop,{once:true});
+  let stderr='';child.stderr?.setEncoding('utf8');child.stderr?.on('data',chunk=>{stderr=(stderr+chunk).slice(-4000);});
+  child.stdin.on('error',()=>{});
+  child.once('error',()=>finish(Error('No se pudo iniciar Kokoro.')));
+  child.once('close',code=>{if(stderr.trim())log(stderr.trim());finish(signal?.aborted?null:timedOut?Error('Se agotó el tiempo de Kokoro.'):code===0?null:Error('Falló Kokoro o la salida de audio.'));});
+  child.stdin.end(JSON.stringify({text:String(text),voice:opts.voice,speed:opts.speed,cacheDir:opts.cacheDir}));
+  if(signal?.aborted)stop();
+ });
+}
+function createSpeech(config={}, {env=process.env,platform=process.platform,log=console.log,spawnImpl=spawn}={}){
+ const opts=settings(config,env,platform);
+ return async(text,options={})=>{
+  if(options.signal?.aborted)return;
+  const common={...options,platform,spawnImpl,log};
+  if(opts.provider==='say')return say(text,common);
+  try{await kokoro(text,{...common,...opts});}
+  catch(e){if(options.signal?.aborted)return;if(opts.fallback!=='say')throw e;log('[TTS] Kokoro falló; leyendo este mensaje con say.');await say(text,common);}
+ };
+}
+function speak(text,options={}){return createSpeech(options.config,{env:options.env,platform:options.platform,log:options.log,spawnImpl:options.spawnImpl})(text,options);}
+module.exports={speak,say,kokoro,createSpeech,settings};

package/tts/voice-command.js

@@ -0,0 +1,14 @@
+const fs=require('node:fs'),path=require('node:path');
+const {createSpeech}=require('./speech');
+async function testVoice(text,{dataDir,provider,voice,speed,fallback}={}, {speechFactory=createSpeech,signals=process,env=process.env}={}){
+ if(typeof text!=='string'||!text.trim())throw Error('Indica un texto: wargaming-overlay --test-tts "Hola, esta es una prueba."');
+ let config={};
+ if(dataDir){try{config=JSON.parse(fs.readFileSync(path.join(dataDir,'youtube-tts.json'),'utf8'));}catch(e){if(e.code!=='ENOENT')throw Error('Configuración youtube-tts.json inválida.');}}
+ // CLI overrides environment and file settings, without changing the saved configuration.
+ const overrides={...env};
+ for(const [key,value] of Object.entries({TTS_PROVIDER:provider,KOKORO_VOICE:voice,KOKORO_SPEED:speed,TTS_FALLBACK:fallback}))if(value!==undefined)overrides[key]=String(value);
+ const speech=speechFactory(config,{env:overrides});const controller=new AbortController();
+ const stop=()=>controller.abort();signals.once('SIGINT',stop);signals.once('SIGTERM',stop);
+ try{await speech(text,{signal:controller.signal});}finally{signals.removeListener('SIGINT',stop);signals.removeListener('SIGTERM',stop);}
+}
+module.exports={testVoice};

package/tts/wav.js

@@ -0,0 +1,6 @@
+function wav(samples,sampleRate){
+ const data=Buffer.alloc(44+samples.length*2);data.write('RIFF');data.writeUInt32LE(data.length-8,4);data.write('WAVEfmt ',8);data.writeUInt32LE(16,16);data.writeUInt16LE(1,20);data.writeUInt16LE(1,22);data.writeUInt32LE(sampleRate,24);data.writeUInt32LE(sampleRate*2,28);data.writeUInt16LE(2,32);data.writeUInt16LE(16,34);data.write('data',36);data.writeUInt32LE(samples.length*2,40);
+ for(let i=0;i<samples.length;i++)data.writeInt16LE(Math.round(Math.max(-1,Math.min(1,samples[i]))*32767),44+i*2);
+ return data;
+}
+module.exports={wav};

package/tts/windows-playback.js

@@ -0,0 +1,14 @@
+const fs=require('node:fs/promises'),os=require('node:os'),path=require('node:path');
+const {spawn}=require('node:child_process');const {wav}=require('./wav');
+async function playWindows(samples,sampleRate,{spawnImpl=spawn}={}){
+ const dir=process.env.OVERLAY_TTS_TEMP_DIR||await fs.mkdtemp(path.join(os.tmpdir(),'overlay-tts-'));const file=path.join(dir,'speech.wav');
+ try{
+  await fs.writeFile(file,wav(samples,sampleRate));
+  await new Promise((resolve,reject)=>{
+   const child=spawnImpl('powershell.exe',['-NoProfile','-NonInteractive','-Command',"$ErrorActionPreference='Stop'; $player=New-Object System.Media.SoundPlayer; try { $player.SoundLocation=$env:OVERLAY_TTS_WAV; $player.Load(); $player.PlaySync() } finally { $player.Dispose() }"],{shell:false,windowsHide:true,stdio:'ignore',env:{...process.env,OVERLAY_TTS_WAV:file}});
+   child.once('error',()=>reject(Error('No se pudo abrir el audio integrado de Windows.')));
+   child.once('close',code=>code===0?resolve():reject(Error('Falló el audio integrado de Windows.')));
+  });
+ }finally{await fs.rm(dir,{recursive:true,force:true});}
+}
+module.exports={playWindows};

package/turn-tracker.js

@@ -1,35 +1,47 @@
-// Accessibility snapshots can be partial. Only increases of previously seen
-// values are activity; discovering a mission while scrolling is not activity.
+// Keep the union of observed cards for each player and round across partial snapshots.
+// A first-seen unscored card after the initial reading is a draw heuristic, not proof.
 function inferTurn(previous, incoming, samePlayers) {
- const fresh={firstPlayer:null,activePlayer:null,half:null,highestRound:incoming.round,eligible:incoming.round===1 && incoming.players.every(p=>p.score===0),seen:{},reason:'Esperando actividad para detectar el turno'};
+ // The parser keeps Tabletop Battles player order even when a heading is off-screen.
+ const firstPlayer=incoming.players[0].name;
+ const fresh={firstPlayer,orderSource:'ui-order',detectionSource:'secondary-draws',activePlayer:null,half:null,highestRound:incoming.round,seen:{},reason:'Orden de Tabletop Battles identificado; esperando nuevas secundarias para detectar el turno'};
  let t=samePlayers && previous.turn ? structuredClone(previous.turn) : fresh;
  if(incoming.round<t.highestRound) return {...t,reason:'Ronda histórica: turno sin determinar'};
- if(incoming.round>t.highestRound){t={...t,highestRound:incoming.round,eligible:true,seen:{},activePlayer:null,half:null};}
+ // Old versions learned order from scoring; discard that inference on migration.
+ if(t.orderSource!=='ui-order' || t.firstPlayer!==firstPlayer)t=fresh;
+ if(incoming.round>t.highestRound){t={...t,highestRound:incoming.round,seen:{},cards:{},cardBaselines:{},activePlayer:null,half:null,reason:fresh.reason};}
+ // Preserve card history, but discard halves inferred by the former scoring policy.
+ if(t.detectionSource!=='secondary-draws'){
+  t.detectionSource='secondary-draws';t.activePlayer=null;t.half=null;t.reason=fresh.reason;
+ }
  const events=[];
+ t.cards=t.cards||{};
  for(const p of incoming.players){
-  const old=t.seen[p.name]||{},next={...old};let activity=false;
-  const values={};
-  for(const key of ['primary','secondary']) if(Number.isFinite(p[key]?.score))values[key]=p[key].score;
-  if(Number.isFinite(p.score))values.score=p.score;
-  for(const m of p.secondaries||[])if(Number.isFinite(m.score))values[`mission:${m.name}`]=m.score;
-  for(const m of p.primaryObjectives||[]){
-   if(m.checked!=null)values[`checked:${m.name}`]=Number(m.checked);
-   if(Number.isFinite(m.counter))values[`counter:${m.name}`]=m.counter;
-  }
-  for(const [key,value] of Object.entries(values)){
-   if(Number.isFinite(old[key]) && value>old[key])activity=true;
-   next[key]=value;
+  let activity=false;
+  if(Array.isArray(p.secondaries)){
+   const names=[...new Set(p.secondaries.map(m=>m.name))];
+   const prior=t.cards[p.name];
+   const known=Array.isArray(prior)?prior:[];
+   const added=p.secondaries.filter(m=>m.enabled!==false && !known.includes(m.name));
+   // A complete baseline proves an addition. Otherwise a new zero-point card is
+   // useful evidence, including the first visible BOTTOM card after TOP played.
+   if(t.cardBaselines?.[p.name] && added.length)activity=true;
+   else if(Object.hasOwn(t.seen,p.name) && added.some(m=>m.score===0))activity=true;
+   t.cards[p.name]=[...new Set([...known,...names])];
+   if(p.secondariesComplete){
+    t.cardBaselines=t.cardBaselines||{};
+    t.cardBaselines[p.name]=true;
+   }
   }
-  t.seen[p.name]=next;
+  t.seen[p.name]=true;
   if(activity)events.push(p.name);
  }
  if(events.length===1){
   const name=events[0];
-  if(!t.firstPlayer && t.eligible)t.firstPlayer=name;
-  t.activePlayer=name;
-  // Bottom is terminal for this round: delayed scoring cannot rewind it.
+  // Late card changes by TOP must not rewind a round after BOTTOM began.
+  if(t.half!=='bottom')t.activePlayer=name;
+  // Bottom is terminal for this round.
   if(t.firstPlayer && t.half!=='bottom')t.half=name===t.firstPlayer?'top':'bottom';
-  t.reason=t.half?'Turno inferido por actividad de puntuación':`Actividad de ${name}; esperando conocer el orden de juego`;
+  t.reason='Turno identificado por nuevas secundarias; orden de Tabletop Battles';
  }
  if(events.length>1)t.reason='Cambios en ambos jugadores; se conserva el último turno detectado';
  return t;

package/youtube/auth.js

@@ -0,0 +1,71 @@
+const fs=require('node:fs');
+const path=require('node:path');
+const os=require('node:os');
+const http=require('node:http');
+const crypto=require('node:crypto');
+const {spawn}=require('node:child_process');
+const SCOPE='https://www.googleapis.com/auth/youtube.readonly';
+const credentialDir=()=>path.join(os.homedir(),'.config','wargaming-overlay','youtube');
+function privateWrite(file,value){
+ fs.mkdirSync(path.dirname(file),{recursive:true,mode:0o700});
+ const tmp=file+'.'+crypto.randomBytes(6).toString('hex')+'.tmp';
+ try{fs.writeFileSync(tmp,JSON.stringify(value),{mode:0o600,flag:'wx'});fs.renameSync(tmp,file);}finally{try{fs.unlinkSync(tmp)}catch{}}
+}
+function read(file){try{return JSON.parse(fs.readFileSync(file,'utf8'))}catch(e){if(e.code==='ENOENT')return null;throw Error('No se pueden leer las credenciales locales de YouTube.');}}
+function clientConfig(json){
+ const c=json?.installed;
+ if(!c?.client_id || !c.client_secret)throw Error('Usa el JSON OAuth de tipo Aplicación de escritorio de Google.');
+ return {client_id:c.client_id,client_secret:c.client_secret};
+}
+class Auth {
+ constructor({dir=credentialDir(),fetchImpl=fetch,now=Date.now}={}){this.dir=dir;this.fetch=fetchImpl;this.now=now;this.pending=null;}
+ load(){const c=read(path.join(this.dir,'client.json'));if(!c)throw Error('Configura OAuth: wargaming-overlay youtube-auth --client-secret /ruta/client.json');return c;}
+ async exchange(params,signal){
+  const response=await this.fetch('https://oauth2.googleapis.com/token',{method:'POST',body:new URLSearchParams(params),signal:signal?AbortSignal.any([signal,AbortSignal.timeout(20000)]):AbortSignal.timeout(20000)});
+  const data=await response.json();
+  if(!response.ok || !data.access_token)throw Error(data.error==='invalid_grant'?'Autorización revocada o vencida. Ejecuta youtube-auth de nuevo.':'No se pudo obtener autorización de Google; se reintentará.');
+  return data;
+ }
+ save(data,old={}){
+  const tokens={refresh_token:data.refresh_token||old.refresh_token,access_token:data.access_token,expires_at:this.now()+Number(data.expires_in||3600)*1000,scope:data.scope||old.scope||SCOPE};
+  if(!tokens.refresh_token)throw Error('Google no entregó refresh token. Autoriza de nuevo con youtube-auth.');
+  if(!tokens.scope.split(' ').includes(SCOPE))throw Error('No se concedió el permiso de lectura de YouTube.');
+  privateWrite(path.join(this.dir,'tokens.json'),tokens);return tokens;
+ }
+ async token(signal){
+  const t=read(path.join(this.dir,'tokens.json'));
+  if(!t?.refresh_token)throw Error('YouTube sin autorizar. Ejecuta wargaming-overlay youtube-auth --client-secret /ruta/client.json');
+  if(t.access_token && t.expires_at>this.now()+60000)return t.access_token;
+  if(!this.pending)this.pending=(async()=>{const c=this.load();return this.save(await this.exchange({...c,grant_type:'refresh_token',refresh_token:t.refresh_token},signal),t).access_token;})().finally(()=>{this.pending=null;});
+  return this.pending;
+ }
+ invalidate(){const file=path.join(this.dir,'tokens.json'),t=read(file);if(t)privateWrite(file,{...t,expires_at:0});}
+ async authorize(clientFile,{open=url=>{const child=spawn(process.platform==='darwin'?'open':process.platform==='win32'?'explorer.exe':'xdg-open',[url],{stdio:'ignore',shell:false});child.on('error',()=>{});child.unref();},log=console.log,timeoutMs=180000}={}){
+  const c=clientFile?clientConfig(read(path.resolve(clientFile))):this.load();
+  const state=crypto.randomBytes(24).toString('hex'),verifier=crypto.randomBytes(32).toString('base64url');
+  const challenge=crypto.createHash('sha256').update(verifier).digest('base64url');
+  let resolveCode,rejectCode;
+  const codePromise=new Promise((resolve,reject)=>{resolveCode=resolve;rejectCode=reject;});
+  const server=http.createServer((req,res)=>{
+   const u=new URL(req.url,'http://127.0.0.1');
+   res.setHeader('Content-Type','text/plain; charset=utf-8');res.setHeader('Cache-Control','no-store');
+   if(u.pathname!=='/oauth/callback'){res.writeHead(404);res.end();return;}
+   if(u.searchParams.get('state')!==state){res.writeHead(400);res.end('Solicitud no válida.');return;}
+   if(u.searchParams.get('error')){res.end('Autorización cancelada. Vuelve a la terminal.');rejectCode(Error('Autorización cancelada por el usuario.'));return;}
+   const code=u.searchParams.get('code');if(!code){res.writeHead(400);res.end('Falta autorización.');return;}
+   res.end('Autorización recibida. Puedes cerrar esta ventana y volver a la terminal.');resolveCode(code);
+  });
+  await new Promise((resolve,reject)=>{server.once('error',reject);server.listen(0,'127.0.0.1',resolve);});
+  const timer=setTimeout(()=>rejectCode(Error('Se agotó el tiempo de autorización. Ejecuta youtube-auth de nuevo.')),timeoutMs);
+  const redirect=`http://127.0.0.1:${server.address().port}/oauth/callback`;
+  try{
+   const url=new URL('https://accounts.google.com/o/oauth2/v2/auth');url.search=new URLSearchParams({client_id:c.client_id,redirect_uri:redirect,response_type:'code',scope:SCOPE,access_type:'offline',prompt:'consent',state,code_challenge:challenge,code_challenge_method:'S256'});
+   log('[YouTube] Autoriza el canal en el navegador. Si no se abre: '+url.href);open(url.href);
+   const code=await codePromise;
+   const tokens=await this.exchange({...c,code,redirect_uri:redirect,grant_type:'authorization_code',code_verifier:verifier});
+   this.save(tokens);privateWrite(path.join(this.dir,'client.json'),c);
+   log('[YouTube] Autorización guardada. Ya puedes iniciar el backend con YOUTUBE_CHAT_TTS_ENABLED=true.');
+  }finally{clearTimeout(timer);server.close();server.closeAllConnections();}
+ }
+}
+module.exports={Auth,credentialDir,privateWrite,SCOPE};

package/youtube/chat.proto

@@ -0,0 +1,29 @@
+// Minimal wire-compatible subset of the official YouTube streaming schema.
+// https://developers.google.com/youtube/v3/live/streaming-live-chat
+syntax = "proto2";
+package youtube.api.v3;
+service V3DataLiveChatMessageService {
+ rpc StreamList(LiveChatMessageListRequest) returns (stream LiveChatMessageListResponse) {}
+}
+message LiveChatMessageListRequest {
+ optional string live_chat_id = 1;
+ optional string page_token = 99;
+ repeated string part = 100;
+}
+message LiveChatMessageListResponse {
+ optional string offline_at = 2;
+ optional string next_page_token = 100602;
+ repeated LiveChatMessage items = 1007;
+}
+message LiveChatMessage {
+ optional string id = 101;
+ optional LiveChatMessageSnippet snippet = 2;
+ optional LiveChatMessageAuthorDetails author_details = 3;
+}
+message LiveChatMessageAuthorDetails { optional string display_name = 103; }
+message LiveChatMessageSnippet {
+ optional int32 type = 1;
+ optional string published_at = 4;
+ optional LiveChatTextMessageDetails text_message_details = 19;
+}
+message LiveChatTextMessageDetails { optional string message_text = 1; }

package/youtube/index.js

@@ -0,0 +1,23 @@
+const fs=require('node:fs'),path=require('node:path');
+function configFor(dataDir,env=process.env){
+ let file={};try{file=JSON.parse(fs.readFileSync(path.join(dataDir,'youtube-tts.json'),'utf8'));}catch(e){if(e.code!=='ENOENT')throw Error('Configuración youtube-tts.json inválida.');}
+ const config={enabled:true,maxMessageLength:300,maxQueueLength:10,readUsername:true,filterUrls:true,extraBlockedTerms:[],...file};
+ for(const [key,min,max] of [['maxMessageLength',50,300],['maxQueueLength',1,100]])if(!Number.isInteger(config[key])||config[key]<min||config[key]>max)throw Error(`Configuración ${key} fuera de rango.`);
+ for(const key of ['enabled','readUsername','filterUrls'])if(typeof config[key]!=='boolean')throw Error(`Configuración ${key} debe ser true/false.`);
+ if(!Array.isArray(config.extraBlockedTerms)||config.extraBlockedTerms.some(t=>typeof t!=='string'||t.length>100))throw Error('extraBlockedTerms debe ser una lista de textos cortos.');
+ if(config.httpFallback!==undefined&&typeof config.httpFallback!=='boolean')throw Error('httpFallback debe ser true/false.');
+ if(config.apiKeyFile){if(typeof config.apiKeyFile!=='string')throw Error('apiKeyFile debe ser una ruta.');try{config.apiKey=fs.readFileSync(path.resolve(config.apiKeyFile),'utf8').trim();}catch{throw Error('No se pudo leer apiKeyFile.');}if(!config.apiKey||/\s/.test(config.apiKey))throw Error('El archivo API key debe contener únicamente la clave.');}
+ return config;
+}
+function startYouTube(dataDir,{env=process.env,platform=process.platform,log=console.log}={}){
+ if(env.YOUTUBE_CHAT_TTS_ENABLED!=='true'){log('[YouTube] Chat TTS desactivado. Actívalo con YOUTUBE_CHAT_TTS_ENABLED=true.');return null;}
+ try{
+  if(!['darwin','win32','linux'].includes(platform))throw Error('Sistema no compatible con TTS.');
+  const config=configFor(dataDir,env);if(!config.enabled){log('[YouTube] TTS desactivado en configuración.');return null;}
+  require('../tts/speech').settings(config,env,platform);
+  const {YouTubeService}=require('./service');
+  log('[YouTube] Iniciando chat TTS. Si falta autorización, ejecuta wargaming-overlay youtube-auth --client-secret /ruta/client.json.');
+  return new YouTubeService({config,log,speech:require('../tts/speech').createSpeech(config,{env,platform,log})}).start();
+ }catch(e){log('[YouTube] '+e.message+' El overlay continúa funcionando.');return null;}
+}
+module.exports={startYouTube,configFor};

package/youtube/live-broadcast.js

@@ -0,0 +1,13 @@
+async function findBroadcast(auth,{signal,fetchImpl=fetch}={}){
+ const token=await auth.token(signal);
+ const url=new URL('https://www.googleapis.com/youtube/v3/liveBroadcasts');
+ // API accepts exactly one filter: active, NOT active + mine.
+ url.search=new URLSearchParams({part:'snippet,status',broadcastStatus:'active',broadcastType:'all',maxResults:'50'});
+ const response=await fetchImpl(url,{headers:{Authorization:`Bearer ${token}`},signal:signal?AbortSignal.any([signal,AbortSignal.timeout(20000)]):AbortSignal.timeout(20000)});
+ if(response.status===401){auth.invalidate();throw Error('Autorización vencida; renovando.');}
+ if(!response.ok)throw Error(`Consulta de directos falló (HTTP ${response.status}). Revisa permisos/cuota de YouTube.`);
+ const data=await response.json();
+ const active=(data.items||[]).filter(b=>b.snippet?.liveChatId).sort((a,b)=>String(a.id).localeCompare(String(b.id)));
+ return active[0]?{id:active[0].id,liveChatId:active[0].snippet.liveChatId,title:active[0].snippet.title,multiple:active.length>1}:null;
+}
+module.exports={findBroadcast};

package/youtube/live-chat.js

@@ -0,0 +1,24 @@
+const path=require('node:path');
+function normalize(item){
+ if(item.snippet?.type!==1 || !item.id || typeof item.snippet.textMessageDetails?.messageText!=='string')return null;
+ return {id:item.id,type:'youtube_chat_message',author:item.authorDetails?.displayName||'Usuario',text:item.snippet.textMessageDetails.messageText,timestamp:item.snippet.publishedAt,messageType:'textMessageEvent'};
+}
+async function* streamChat({auth,liveChatId,pageToken,signal,createClient,apiKey}){
+ const grpc=require('@grpc/grpc-js'),loader=require('@grpc/proto-loader');
+ const def=loader.loadSync(path.join(__dirname,'chat.proto'));
+ const Service=grpc.loadPackageDefinition(def).youtube.api.v3.V3DataLiveChatMessageService;
+ const client=createClient?createClient(Service,grpc):new Service('youtube.googleapis.com:443',grpc.credentials.createSsl());
+ let call;
+ const cancel=()=>call?.cancel();
+ try{
+  const meta=new grpc.Metadata();
+  if(apiKey)meta.set('x-goog-api-key',apiKey);
+  else meta.set('authorization',`Bearer ${await auth.token(signal)}`);
+  if(signal?.aborted)return;
+  // Reopen periodically with fresh credentials, retaining the continuation token.
+  call=client.streamList({liveChatId,pageToken,part:['id','snippet','authorDetails']},meta,{deadline:Date.now()+45*60*1000});
+  signal?.addEventListener('abort',cancel,{once:true});
+  for await(const batch of call)yield batch;
+ }finally{signal?.removeEventListener('abort',cancel);call?.cancel();client.close();}
+}
+module.exports={streamChat,normalize};

package/youtube/poll-chat.js

@@ -0,0 +1,15 @@
+const {setTimeout:delay}=require('node:timers/promises');
+async function* pollChat({auth,liveChatId,pageToken,signal,fetchImpl=fetch,sleep=ms=>delay(ms,null,{signal})}){
+ while(!signal?.aborted){
+  const url=new URL('https://www.googleapis.com/youtube/v3/liveChat/messages');
+  url.search=new URLSearchParams({liveChatId,part:'id,snippet,authorDetails',...(pageToken?{pageToken}:{})});
+  const response=await fetchImpl(url,{headers:{Authorization:`Bearer ${await auth.token(signal)}`},signal:signal?AbortSignal.any([signal,AbortSignal.timeout(20000)]):AbortSignal.timeout(20000)});
+  const data=await response.json();
+  if(!response.ok){const reason=data.error?.errors?.[0]?.reason;const code=response.status===401?16:response.status===404?5:['liveChatEnded','liveChatDisabled'].includes(reason)?9:response.status===400?3:response.status===403?7:14;throw Object.assign(Error('No se pudo consultar el chat por HTTP.'),{code});}
+  yield {...data,items:(data.items||[]).map(item=>({...item,snippet:{...item.snippet,type:({textMessageEvent:1,chatEndedEvent:4})[item.snippet?.type]||0}}))};
+  if(data.offlineAt)return;
+  pageToken=data.nextPageToken||pageToken;
+  await sleep(Math.max(15000,Number(data.pollingIntervalMillis)||0));
+ }
+}
+module.exports={pollChat};

package/youtube/service.js

@@ -0,0 +1,73 @@
+const {EventEmitter}=require('node:events');
+const {setTimeout:delay}=require('node:timers/promises');
+const {Auth}=require('./auth');
+const {findBroadcast}=require('./live-broadcast');
+const {streamChat,normalize}=require('./live-chat');
+const {pollChat}=require('./poll-chat');
+const {SpeechQueue}=require('../tts/queue');
+const {sanitize}=require('../tts/sanitizer');
+const backoff=[1000,2000,5000,10000,30000];
+class YouTubeService extends EventEmitter {
+ constructor({config={},auth=new Auth(),discover=findBroadcast,stream=streamChat,poll=pollChat,queue,speech,log=console.log,sleep=(ms,signal)=>delay(ms,null,{signal}),now=Date.now}={}){
+  super();this.config=config;this.auth=auth;this.discover=discover;this.stream=stream;this.poll=poll;this.polling=false;this.log=log;this.sleep=sleep;this.now=now;
+  this.queue=queue||new SpeechQueue({maxQueueLength:config.maxQueueLength||10,speech:speech||require('../tts/speech').createSpeech(config,{log}),log});this.state='DISCONNECTED';this.seen=new Set();this.controller=new AbortController();this.chat=null;this.pageToken=undefined;this.task=null;
+ }
+ status(state,message){if(this.state!==state||this.lastMessage!==message){this.state=state;this.lastMessage=message;this.log('[YouTube] '+message);}}
+ start(){if(!this.task)this.task=this.run().catch(()=>{if(!this.controller.signal.aborted)this.status('DISCONNECTED','Servicio detenido por un error inesperado; el overlay continúa.');});return this;}
+ async stop(){this.controller.abort();await this.queue.stop();await this.task;}
+ endChat(){this.chat=null;this.pageToken=undefined;this.queue.clear();this.status('WAITING_FOR_STREAM','Directo terminado o chat no disponible; buscando otro directo.');}
+ async run(){
+  const signal=this.controller.signal;let failures=0;
+  while(!signal.aborted){
+   try{
+    if(!this.chat){
+     await this.auth.token(signal);this.status('AUTHENTICATED','Autorización cargada.');
+     const broadcast=await this.discover(this.auth,{signal});
+     if(!broadcast){this.status('WAITING_FOR_STREAM','Sin directo activo con chat; volveré a comprobar en 60 segundos.');await this.sleep(60000,signal);continue;}
+     this.chat=broadcast.liveChatId;this.pageToken=undefined;this.startedAt=this.now();
+     this.log(`[YouTube] Directo detectado${broadcast.multiple?' (hay varios; se usa el primero por ID)':''}.`);
+    }
+    let ended=false,received=false,continuation=false;
+    if(this.state!=='CONNECTED_TO_CHAT')this.status('CONNECTING_TO_CHAT',this.polling?'Conectando al chat mediante HTTP (respaldo, cada 15 s)…':'Conectando al chat en vivo mediante streamList…');
+    for await(const batch of (this.polling?this.poll:this.stream)({auth:this.auth,liveChatId:this.chat,pageToken:this.pageToken,signal,apiKey:this.config.apiKey})){
+     if(signal.aborted)break;
+     received=true;continuation=!!batch.nextPageToken;
+     failures=0;this.status('CONNECTED_TO_CHAT','Chat conectado; esperando mensajes nuevos.');
+     if(batch.offlineAt || (batch.items||[]).some(i=>i.snippet?.type===4)){ended=true;break;}
+     for(const item of batch.items||[]){
+      if(!item.id||this.seen.has(item.id))continue;
+      this.seen.add(item.id);if(this.seen.size>1000)this.seen.delete(this.seen.values().next().value);
+      const event=normalize(item);if(!event)continue;
+      // Initial streamList replies include history: never speak pre-connection messages.
+      if(!Number.isFinite(Date.parse(event.timestamp)) || Date.parse(event.timestamp)<this.startedAt)continue;
+      const safe=sanitize(event,this.config);if(!safe)continue;
+      this.log(`[Chat] ${safe.author}: ${safe.text}`);
+      // Future consumers receive the normalized event; listener failures stay isolated.
+      try{this.emit('message',event);}catch{this.log('[YouTube] Falló un consumidor de mensajes.');}
+      this.queue.enqueue(safe);
+     }
+     this.pageToken=batch.nextPageToken||this.pageToken;
+    }
+    if(ended){this.endChat();await this.sleep(60000,signal);continue;}
+    if(!signal.aborted){
+     // Successful EOF with a cursor is a continuation, not an authentication failure.
+     if(received&&continuation){await this.sleep(1000,signal);continue;}
+     throw Object.assign(Error('Chat stream ended without continuation'),{code:14});
+    }
+   }catch(e){
+    if(signal.aborted)break;
+    if(e.code===16){
+     if(!this.config.apiKey||this.polling)this.auth.invalidate();
+     if(!this.polling&&this.config.httpFallback===true){this.polling=true;this.pageToken=undefined;this.status('DISCONNECTED','streamList rechazó las credenciales. Cambiando a HTTP de respaldo (cada 15 s).');continue;}
+    }
+    if([5,9].includes(e.code)){this.endChat();await this.sleep(60000,signal);continue;}
+    if(e.code===3)this.pageToken=undefined;
+    const ms=backoff[Math.min(failures++,backoff.length-1)];
+    // Do not print upstream payloads or request objects: they may contain credentials.
+    this.status('DISCONNECTED',e.code===16?`streamList/YouTube rechazó las credenciales (código 16). Reintento en ${ms/1000}s. Si OAuth funciona por HTTP, configura apiKeyFile para streamList. El respaldo HTTP requiere httpFallback: true.`:`Conexión/autorización no disponible${Number.isInteger(e.code)?' (código '+e.code+')':''}. Reintento en ${ms/1000}s. Si persiste, revisa OAuth, API y cuota.`);
+    await this.sleep(ms,signal);
+   }
+  }
+ }
+}
+module.exports={YouTubeService,backoff};