tricu

check-firefox.mjs (4824B)

---

 // Dependency-free stock Firefox check, using the same page/Worker assertions
 // as Chromium. The localhost harness receives the report; no patched browser,
 // extension, WebDriver or application changes are needed.
 import assert from 'node:assert/strict';
 import {spawn,execFileSync} from 'node:child_process';
 import {createServer} from 'node:http';
 import {readFile,mkdtemp,rm,writeFile} from 'node:fs/promises';
 import {resolve,extname,sep} from 'node:path';
 import {tmpdir} from 'node:os';
 import {createHash,randomBytes} from 'node:crypto';
 import {gzipSync} from 'node:zlib';
 const [directory,output,firefox='firefox']=process.argv.slice(2),root=resolve(directory);
 const token=randomBytes(24).toString('hex');
 let deliver,fail;
 const completion=new Promise((resolve,reject)=>{deliver=resolve;fail=reject;});
 // Register a rejection handler before asynchronous startup steps.
 completion.catch(()=>{});
 const server=createServer(async(req,res)=>{
   try{
     const pathname=decodeURIComponent(new URL(req.url,'http://localhost').pathname);
     if(pathname==='/report/'+token&&req.method==='POST'){
       const chunks=[];let size=0;
       for await(const chunk of req){size+=chunk.length;if(size>2*1024*1024)throw Error('Report too large');chunks.push(chunk);}
       const result=JSON.parse(Buffer.concat(chunks).toString('utf8'));
       res.writeHead(200);res.end('received');
       result.ok?deliver(result.report):fail(Error(result.error));return;
     }
     if(req.method!=='GET')throw Error('Unsupported method');
     res.setHeader('Cache-Control','no-store');
     if(pathname==='/'){
       res.setHeader('Content-Type','text/html');
       res.end(`<!doctype html><meta charset="utf-8"><title>Firefox Haskell WASM check</title><script type="module">
         let sent=false;
         async function finish(result){if(sent)return;sent=true;await fetch('/report/${token}',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(result)});}
         addEventListener('error',e=>finish({ok:false,error:e.message}));
         addEventListener('unhandledrejection',e=>finish({ok:false,error:String(e.reason?.stack||e.reason)}));
         try{await import('./page.mjs');await finish({ok:true,report:await window.runProbe()});}
         catch(e){await finish({ok:false,error:String(e.stack||e)});}
       </script>`);return;
     }
     const module=pathname.match(/^\/_arboricx\/bundle\/hash\/([0-9a-f]{64})$/);
     const file=module?resolve(root,'parity/modules',module[1]+'.arboricx'):resolve(root,'.'+pathname);
     if(!file.startsWith(root+sep))throw Error('Outside root');
     res.setHeader('Content-Type',({'.html':'text/html','.mjs':'text/javascript','.js':'text/javascript','.json':'application/json','.wasm':'application/wasm'})[extname(file)]||'application/octet-stream');
     res.end(await readFile(file));
   }catch(e){res.writeHead(404);res.end();if(req.url.startsWith('/report/'))fail(e);}
 });
 await new Promise(r=>server.listen(0,'127.0.0.1',r));
 const profile=await mkdtemp(resolve(tmpdir(),'haskell-wasm-firefox-'));
 let browser,timer,log='';
 try{
   const version=execFileSync(firefox,['--version'],{encoding:'utf8',timeout:20000}).trim();
   browser=spawn(firefox,['--headless','--no-remote','--new-instance','--profile',profile,`http://127.0.0.1:${server.address().port}/`],
     {stdio:['ignore','pipe','pipe'],detached:true});
   browser.stdout.on('data',b=>{log=(log+b).slice(-16000);});
   browser.stderr.on('data',b=>{log=(log+b).slice(-16000);});
   browser.on('error',fail);
   browser.on('exit',code=>fail(Error('Firefox exited '+code+'\n'+log)));
   timer=setTimeout(()=>fail(Error('Firefox test timeout\n'+log)),120000);
   const report=await completion;
   assert.match(report.userAgent,/Firefox\//);
   report.package=root;report.browser={product:version};
   report.versions=await readFile(resolve(root,'versions.txt'),'utf8');
   report.manifest=JSON.parse(await readFile(resolve(root,'data/manifest.json')));
   const bytes=await readFile(resolve(root,'reactor.wasm'));
   report.artifact={bytes:bytes.length,gzipBytes:gzipSync(bytes).length,sha256:createHash('sha256').update(bytes).digest('hex')};
   await writeFile(output,JSON.stringify(report,null,2)+'\n');
   console.log(JSON.stringify({browser:report.browser,checks:report.checks,parity:report.parity,initialization:report.initialization,termination:report.termination,artifact:report.artifact,memory:report.memory},null,2));
 }finally{
   clearTimeout(timer);
   if(browser?.pid){
     const exited=browser.exitCode===null?new Promise(r=>browser.once('exit',r)):Promise.resolve();
     try{process.kill(-browser.pid,'SIGKILL');}catch(e){if(e.code!=='ESRCH')throw e;}
     await exited;
   }
   server.closeAllConnections();await new Promise(r=>server.close(r));
   await rm(profile,{recursive:true,force:true,maxRetries:5,retryDelay:100});
 }