test(media): validate codec and recovery boundaries
This commit is contained in:
AAA committed
1 parent
e23f367313
commit
2d3e82e1f1
6 files changed
+548
-33
No files matched your search
@@ -0,0 +1,384 @@
|
||||
import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
|
||||
import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
|
||||
import { createServer, type Server } from "node:http";
|
||||
import { tmpdir } from "node:os";
|
||||
import { join, resolve } from "node:path";
|
||||
|
||||
import { AccessToken, TrackSource } from "livekit-server-sdk";
|
||||
|
||||
import {
|
||||
CdpConnection,
|
||||
cleanupRun,
|
||||
createPage,
|
||||
reservePort,
|
||||
waitForVersion,
|
||||
type PageHandle,
|
||||
} from "./native-one-viewer-gate";
|
||||
|
||||
const WIDTH = 1_920;
|
||||
const HEIGHT = 1_080;
|
||||
const FRAME_RATE = 30;
|
||||
const MAX_BITRATE = 5_000_000;
|
||||
const SETTLE_MS = 5_000;
|
||||
const SAMPLE_MS = 10_000;
|
||||
|
||||
interface RuntimeResult<T> {
|
||||
result: { value?: T };
|
||||
exceptionDetails?: {
|
||||
text?: string;
|
||||
exception?: { description?: string };
|
||||
};
|
||||
}
|
||||
|
||||
interface ProcessInfo {
|
||||
type: string;
|
||||
id: number;
|
||||
cpuTime: number;
|
||||
}
|
||||
|
||||
interface ProcessSnapshot {
|
||||
processInfo: ProcessInfo[];
|
||||
}
|
||||
|
||||
async function evaluate<T>(
|
||||
cdp: CdpConnection,
|
||||
page: PageHandle,
|
||||
expression: string,
|
||||
timeoutMs: number,
|
||||
): Promise<T> {
|
||||
const value = await cdp.call<RuntimeResult<T>>(
|
||||
"Runtime.evaluate",
|
||||
{
|
||||
expression,
|
||||
awaitPromise: true,
|
||||
returnByValue: true,
|
||||
userGesture: true,
|
||||
},
|
||||
page.sessionId,
|
||||
Date.now() + timeoutMs,
|
||||
);
|
||||
if (value.exceptionDetails) {
|
||||
throw new Error(
|
||||
value.exceptionDetails.exception?.description ??
|
||||
value.exceptionDetails.text ??
|
||||
"Browser evaluation failed",
|
||||
);
|
||||
}
|
||||
return value.result.value as T;
|
||||
}
|
||||
|
||||
function sourceHtml(): string {
|
||||
return `<!doctype html><title>Codec Preflight Source</title>
|
||||
<style>html,body{margin:0;overflow:hidden;background:#000}canvas{display:block;width:100vw;height:100vh}</style>
|
||||
<canvas width="${WIDTH}" height="${HEIGHT}"></canvas><script>
|
||||
const c=document.querySelector('canvas'),x=c.getContext('2d',{alpha:false});let f=0;
|
||||
function draw(){f+=1;for(let r=0;r<14;r+=1)for(let q=0;q<24;q+=1){
|
||||
x.fillStyle='hsl('+((f*29+r*71+q*43)%360)+' 80% '+(35+(f+r+q)%30)+'%)';
|
||||
x.fillRect(q*80,r*78,80,78)}x.fillStyle='#fff';x.fillRect(f*13%1920,0,12,1080);
|
||||
x.fillStyle='#000';x.font='60px monospace';x.fillText(String(f).padStart(8,'0'),24,72)}
|
||||
draw();setInterval(draw,1000/${FRAME_RATE});</script>`;
|
||||
}
|
||||
|
||||
async function startServer(port: number): Promise<Server> {
|
||||
const livekitBundle = await readFile(
|
||||
resolve("node_modules/livekit-client/dist/livekit-client.umd.js"),
|
||||
);
|
||||
const server = createServer((request, response) => {
|
||||
const path = new URL(request.url ?? "/", `http://127.0.0.1:${port}`).pathname;
|
||||
if (path === "/livekit.js") {
|
||||
response.setHeader("content-type", "text/javascript; charset=utf-8");
|
||||
response.end(livekitBundle);
|
||||
return;
|
||||
}
|
||||
response.setHeader("content-type", "text/html; charset=utf-8");
|
||||
response.end(path === "/source"
|
||||
? sourceHtml()
|
||||
: "<!doctype html><title>Codec Preflight</title><script src='/livekit.js'></script><video autoplay muted playsinline style='width:960px'></video>");
|
||||
});
|
||||
await new Promise<void>((resolveListen, rejectListen) => {
|
||||
server.once("error", rejectListen);
|
||||
server.listen(port, "127.0.0.1", resolveListen);
|
||||
});
|
||||
return server;
|
||||
}
|
||||
|
||||
function browserProbe(): string {
|
||||
return `(() => {
|
||||
const WIDTH=${WIDTH},HEIGHT=${HEIGHT},FRAME_RATE=${FRAME_RATE},MAX_BITRATE=${MAX_BITRATE};
|
||||
const SETTLE_MS=${SETTLE_MS},SAMPLE_MS=${SAMPLE_MS};let stream=null,track=null;
|
||||
const delay=(ms)=>new Promise((resolve)=>setTimeout(resolve,ms));
|
||||
async function waitFor(predicate,timeout,label){const deadline=performance.now()+timeout;
|
||||
while(performance.now()<deadline){if(await predicate())return;await delay(50)}
|
||||
throw new Error('Timed out waiting for '+label)}
|
||||
function preferences(codec){const all=RTCRtpSender.getCapabilities('video')?.codecs||[];
|
||||
const mime=codec==='h264'?'video/h264':'video/vp8';const primary=all.filter((item)=>item.mimeType.toLowerCase()===mime);
|
||||
if(!primary.length)throw new Error(mime+' unavailable');
|
||||
const repair=new Set(['video/rtx','video/red','video/ulpfec','video/flexfec-03']);
|
||||
return [...primary,...all.filter((item)=>repair.has(item.mimeType.toLowerCase()))]}
|
||||
async function gathered(pc){if(pc.iceGatheringState==='complete')return;
|
||||
await new Promise((resolve)=>{const changed=()=>{if(pc.iceGatheringState!=='complete')return;
|
||||
pc.removeEventListener('icegatheringstatechange',changed);resolve()};pc.addEventListener('icegatheringstatechange',changed)})}
|
||||
async function negotiate(a,b){await a.setLocalDescription(await a.createOffer());await gathered(a);
|
||||
await b.setRemoteDescription(a.localDescription);await b.setLocalDescription(await b.createAnswer());
|
||||
await gathered(b);await a.setRemoteDescription(b.localDescription)}
|
||||
function statsValue(item){if(!item)return null;const keys=['id','timestamp','bytesSent','bytesReceived',
|
||||
'framesEncoded','framesDecoded','framesDropped','framesPerSecond','frameWidth','frameHeight','totalEncodeTime',
|
||||
'totalDecodeTime','qualityLimitationReason','qualityLimitationDurations','encoderImplementation',
|
||||
'decoderImplementation','powerEfficientEncoder','powerEfficientDecoder','frames'];const value={};
|
||||
for(const key of keys)value[key]=item[key]??null;return value}
|
||||
async function snapshot(sender,receiver,rendered){const [sendReport,receiveReport]=await Promise.all([sender.getStats(),receiver.getStats()]);
|
||||
let outbound=null,inbound=null;sendReport.forEach((item)=>{if(item.type==='outbound-rtp'&&item.kind==='video'&&!item.isRemote)outbound=item});
|
||||
receiveReport.forEach((item)=>{if(item.type==='inbound-rtp'&&item.kind==='video'&&!item.isRemote)inbound=item});
|
||||
const sendCodec=outbound?.codecId?sendReport.get(outbound.codecId):null;
|
||||
const receiveCodec=inbound?.codecId?receiveReport.get(inbound.codecId):null;
|
||||
const mediaSource=outbound?.mediaSourceId?sendReport.get(outbound.mediaSourceId):null;
|
||||
const codec=(item)=>item?{mimeType:item.mimeType||null,sdpFmtpLine:item.sdpFmtpLine||null}:null;
|
||||
return {rendered:rendered(),sender:statsValue(outbound),receiver:statsValue(inbound),
|
||||
mediaSource:statsValue(mediaSource),senderCodec:codec(sendCodec),receiverCodec:codec(receiveCodec)}}
|
||||
function delta(after,before,key){const a=after?.[key],b=before?.[key];return Number.isFinite(a)&&Number.isFinite(b)&&a>=b?a-b:null}
|
||||
function summarize(before,after,sampleMs){const encoded=delta(after.sender,before.sender,'framesEncoded');
|
||||
const decoded=delta(after.receiver,before.receiver,'framesDecoded');const bytes=delta(after.sender,before.sender,'bytesSent');
|
||||
const sourceFrames=delta(after.mediaSource,before.mediaSource,'frames');
|
||||
const encodeTime=delta(after.sender,before.sender,'totalEncodeTime');const decodeTime=delta(after.receiver,before.receiver,'totalDecodeTime');
|
||||
return {senderCodec:after.senderCodec,receiverCodec:after.receiverCodec,sender:after.sender,receiver:after.receiver,
|
||||
measured:{sampleMs,encodedFps:encoded===null?null:encoded*1000/sampleMs,
|
||||
decodedFps:decoded===null?null:decoded*1000/sampleMs,bitrateKbps:bytes===null?null:bytes*8/sampleMs,
|
||||
encodeMsPerFrame:encodeTime!==null&&encoded>0?encodeTime*1000/encoded:null,
|
||||
decodeMsPerFrame:decodeTime!==null&&decoded>0?decodeTime*1000/decoded:null,
|
||||
sourceFps:sourceFrames===null?after.mediaSource?.framesPerSecond:sourceFrames*1000/sampleMs,
|
||||
encodedSourceRatio:sourceFrames>0&&encoded!==null?encoded/sourceFrames:null,
|
||||
renderedFrames:delta(after,before,'rendered')}}}
|
||||
async function setup(){stream=await navigator.mediaDevices.getDisplayMedia({video:{
|
||||
width:{ideal:WIDTH,max:WIDTH},height:{ideal:HEIGHT,max:HEIGHT},frameRate:{ideal:FRAME_RATE,max:FRAME_RATE}},audio:false});
|
||||
track=stream.getVideoTracks()[0];if(!track)throw new Error('No display video track');track.contentHint='motion';
|
||||
return {settings:track.getSettings(),constraints:track.getConstraints(),contentHint:track.contentHint,label:track.label}}
|
||||
function capabilities(){const simple=(codec)=>({mimeType:codec.mimeType,sdpFmtpLine:codec.sdpFmtpLine||null});
|
||||
return {sender:(RTCRtpSender.getCapabilities('video')?.codecs||[]).map(simple),
|
||||
receiver:(RTCRtpReceiver.getCapabilities('video')?.codecs||[]).map(simple)}}
|
||||
async function edge(codec,sourceTrack){
|
||||
const sendPc=new RTCPeerConnection({iceServers:[]}),receivePc=new RTCPeerConnection({iceServers:[]});
|
||||
const transceiver=sendPc.addTransceiver(sourceTrack,{direction:'sendonly'});transceiver.setCodecPreferences(preferences(codec));
|
||||
let receiver=null,remoteTrack=null;receivePc.addEventListener('track',(event)=>{receiver=event.receiver;remoteTrack=event.track});
|
||||
await negotiate(sendPc,receivePc);await waitFor(()=>sendPc.connectionState==='connected'&&receivePc.connectionState==='connected',10000,'connection');
|
||||
await waitFor(()=>receiver&&remoteTrack,5000,'remote track');const video=document.createElement('video');let rendered=0;
|
||||
video.autoplay=true;video.muted=true;video.playsInline=true;document.body.append(video);
|
||||
video.srcObject=new MediaStream([remoteTrack]);if(video.requestVideoFrameCallback){const frame=()=>{rendered+=1;video.requestVideoFrameCallback(frame)};video.requestVideoFrameCallback(frame)}
|
||||
await video.play();const parameters=transceiver.sender.getParameters();if(!parameters.encodings.length)parameters.encodings=[{}];
|
||||
parameters.encodings[0].maxBitrate=MAX_BITRATE;parameters.encodings[0].maxFramerate=FRAME_RATE;
|
||||
parameters.encodings[0].scaleResolutionDownBy=1;parameters.degradationPreference='balanced';await transceiver.sender.setParameters(parameters);
|
||||
await waitFor(async()=>{const report=await receiver.getStats();let frames=0;report.forEach((item)=>{if(item.type==='inbound-rtp'&&item.kind==='video')frames=Math.max(frames,item.framesDecoded||0)});return frames>0&&rendered>0},10000,'decoded frame');
|
||||
return {sendPc,receivePc,sender:transceiver.sender,receiver,remoteTrack,rendered:()=>rendered}}
|
||||
async function run(codec,count,topology){if(!track)throw new Error('Capture not initialized');const edges=[];
|
||||
try{edges.push(await edge(codec,track));
|
||||
if(topology==='relay')edges.push(await edge(codec,edges[0].remoteTrack));
|
||||
else for(let index=1;index<count;index+=1)edges.push(await edge(codec,track));await delay(SETTLE_MS);
|
||||
const before=await Promise.all(edges.map((item)=>snapshot(item.sender,item.receiver,item.rendered))),started=performance.now();
|
||||
await delay(SAMPLE_MS);const sampleMs=performance.now()-started;
|
||||
const after=await Promise.all(edges.map((item)=>snapshot(item.sender,item.receiver,item.rendered)));
|
||||
return edges.map((_,index)=>summarize(before[index],after[index],sampleMs))}
|
||||
finally{for(const item of edges){item.sendPc.close();item.receivePc.close()}await delay(300)}}
|
||||
async function runLivekit(codec,url,publisherToken,subscriberToken){if(!track)throw new Error('Capture not initialized');
|
||||
const sdk=globalThis.LivekitClient,publisher=new sdk.Room({dynacast:true}),subscriber=new sdk.Room();let remoteTrack=null,rendered=0;
|
||||
subscriber.on(sdk.RoomEvent.TrackSubscribed,(nextTrack)=>{if(nextTrack.kind==='video')remoteTrack=nextTrack});
|
||||
try{await publisher.connect(url,publisherToken,{autoSubscribe:false,rtcConfig:{iceServers:[]}});
|
||||
await subscriber.connect(url,subscriberToken,{rtcConfig:{iceServers:[]}});
|
||||
const publication=await publisher.localParticipant.publishTrack(track,{source:sdk.Track.Source.ScreenShare,
|
||||
videoCodec:codec,backupCodec:false,screenShareEncoding:{maxBitrate:MAX_BITRATE,maxFramerate:FRAME_RATE},
|
||||
degradationPreference:'balanced'});
|
||||
await waitFor(()=>publication.videoTrack?.sender&&remoteTrack,15000,'LiveKit publication');
|
||||
const video=document.createElement('video');video.autoplay=true;video.muted=true;video.playsInline=true;document.body.append(video);
|
||||
video.srcObject=new MediaStream([remoteTrack.mediaStreamTrack]);if(video.requestVideoFrameCallback){const frame=()=>{rendered+=1;video.requestVideoFrameCallback(frame)};video.requestVideoFrameCallback(frame)}
|
||||
await video.play();const receiver={getStats:async()=>{const report=await remoteTrack.getRTCStatsReport();if(!report)throw new Error('LiveKit receiver stats unavailable');return report}};
|
||||
await waitFor(async()=>{const report=await receiver.getStats();let frames=0;report?.forEach((item)=>{if(item.type==='inbound-rtp'&&item.kind==='video')frames=Math.max(frames,item.framesDecoded||0)});return frames>0&&rendered>0},15000,'LiveKit decoded frame');
|
||||
await delay(SETTLE_MS);const sender=publication.videoTrack.sender;
|
||||
const before=await snapshot(sender,receiver,()=>rendered),started=performance.now();await delay(SAMPLE_MS);
|
||||
const sampleMs=performance.now()-started,after=await snapshot(sender,receiver,()=>rendered);
|
||||
return {...summarize(before,after,sampleMs),senderParameters:sender.getParameters()}}
|
||||
finally{await Promise.allSettled([publisher.disconnect(false),subscriber.disconnect(false)]);await delay(300)}}
|
||||
function stop(){stream?.getTracks().forEach((item)=>item.stop())}
|
||||
Object.defineProperty(globalThis,'__CODEC_PREFLIGHT__',{value:{setup,capabilities,run,runLivekit,stop}});
|
||||
})()`;
|
||||
}
|
||||
|
||||
async function processSnapshot(cdp: CdpConnection): Promise<ProcessSnapshot> {
|
||||
return cdp.call<ProcessSnapshot>(
|
||||
"SystemInfo.getProcessInfo",
|
||||
{},
|
||||
undefined,
|
||||
Date.now() + 5_000,
|
||||
);
|
||||
}
|
||||
|
||||
function processCpu(
|
||||
before: ProcessSnapshot,
|
||||
after: ProcessSnapshot,
|
||||
wallMs: number,
|
||||
): Record<string, unknown> {
|
||||
const baseline = new Map(
|
||||
before.processInfo.map((item) => [`${item.type}:${item.id}`, item.cpuTime]),
|
||||
);
|
||||
let cpuSeconds = 0;
|
||||
let stableProcesses = 0;
|
||||
for (const item of after.processInfo) {
|
||||
const previous = baseline.get(`${item.type}:${item.id}`);
|
||||
if (previous === undefined || item.cpuTime < previous) continue;
|
||||
cpuSeconds += item.cpuTime - previous;
|
||||
stableProcesses += 1;
|
||||
}
|
||||
const wallSeconds = wallMs / 1_000;
|
||||
return {
|
||||
wallSeconds,
|
||||
cpuSeconds,
|
||||
logicalCoreEquivalent: cpuSeconds / wallSeconds,
|
||||
stableProcesses,
|
||||
processIdentityChanged:
|
||||
stableProcesses !== before.processInfo.length ||
|
||||
stableProcesses !== after.processInfo.length,
|
||||
};
|
||||
}
|
||||
|
||||
async function main(): Promise<void> {
|
||||
const chromePath = process.env.CHROME_PATH?.trim();
|
||||
if (!chromePath) throw new Error("CHROME_PATH must point to Chrome");
|
||||
const codec = process.env.CODEC_PREFLIGHT_CODEC?.trim().toLowerCase();
|
||||
if (codec !== "vp8" && codec !== "h264") {
|
||||
throw new Error("CODEC_PREFLIGHT_CODEC must be vp8 or h264");
|
||||
}
|
||||
const edges = Number(process.env.CODEC_PREFLIGHT_EDGES ?? "1");
|
||||
if (edges !== 1 && edges !== 2) {
|
||||
throw new Error("CODEC_PREFLIGHT_EDGES must be 1 or 2");
|
||||
}
|
||||
const topology = process.env.CODEC_PREFLIGHT_TOPOLOGY?.trim() || "direct";
|
||||
if (topology !== "direct" && topology !== "relay" && topology !== "livekit") {
|
||||
throw new Error("CODEC_PREFLIGHT_TOPOLOGY must be direct, relay, or livekit");
|
||||
}
|
||||
const [debugPort, pagePort] = await Promise.all([reservePort(), reservePort()]);
|
||||
const profile = await mkdtemp(join(tmpdir(), "screener-codec-preflight-"));
|
||||
let chrome: ChildProcessWithoutNullStreams | null = null;
|
||||
let cdp: CdpConnection | null = null;
|
||||
let server: Server | null = null;
|
||||
try {
|
||||
server = await startServer(pagePort);
|
||||
chrome = spawn(chromePath, [
|
||||
`--remote-debugging-port=${debugPort}`,
|
||||
`--user-data-dir=${profile}`,
|
||||
"--no-first-run",
|
||||
"--no-default-browser-check",
|
||||
"--disable-extensions",
|
||||
"--disable-background-timer-throttling",
|
||||
"--disable-backgrounding-occluded-windows",
|
||||
"--disable-renderer-backgrounding",
|
||||
"--autoplay-policy=no-user-gesture-required",
|
||||
"--auto-select-tab-capture-source-by-title=Codec Preflight Source",
|
||||
"--window-size=1920,1080",
|
||||
"about:blank",
|
||||
], { stdio: "pipe", windowsHide: true });
|
||||
chrome.stdout.resume();
|
||||
chrome.stderr.resume();
|
||||
const version = await waitForVersion(debugPort, chrome);
|
||||
cdp = await CdpConnection.connect(version.webSocketDebuggerUrl, Date.now() + 5_000);
|
||||
const gpuInfo = await cdp.call<unknown>("SystemInfo.getInfo", {}, undefined, Date.now() + 5_000);
|
||||
await createPage(cdp, `http://127.0.0.1:${pagePort}/source`, undefined, true);
|
||||
const page = await createPage(cdp, `http://127.0.0.1:${pagePort}/test`, undefined, true);
|
||||
await evaluate<void>(cdp, page, browserProbe(), 5_000);
|
||||
const capabilities = await evaluate<unknown>(
|
||||
cdp,
|
||||
page,
|
||||
"globalThis.__CODEC_PREFLIGHT__.capabilities()",
|
||||
5_000,
|
||||
);
|
||||
const capture = await evaluate<unknown>(
|
||||
cdp,
|
||||
page,
|
||||
"globalThis.__CODEC_PREFLIGHT__.setup()",
|
||||
15_000,
|
||||
);
|
||||
const before = await processSnapshot(cdp);
|
||||
const started = performance.now();
|
||||
let media: unknown;
|
||||
if (topology === "livekit") {
|
||||
const livekitUrl = process.env.CODEC_PREFLIGHT_LIVEKIT_URL?.trim();
|
||||
const apiKey = process.env.CODEC_PREFLIGHT_LIVEKIT_KEY?.trim();
|
||||
const apiSecret = process.env.CODEC_PREFLIGHT_LIVEKIT_SECRET?.trim();
|
||||
if (!livekitUrl || !apiKey || !apiSecret) {
|
||||
throw new Error("LiveKit preflight credentials are missing");
|
||||
}
|
||||
const room = `codec-preflight-${Date.now()}`;
|
||||
const token = async (identity: string, publish: boolean) => {
|
||||
const access = new AccessToken(apiKey, apiSecret, { identity, ttl: 60 });
|
||||
access.addGrant({
|
||||
roomJoin: true,
|
||||
room,
|
||||
canPublish: publish,
|
||||
canPublishSources: publish ? [TrackSource.SCREEN_SHARE] : undefined,
|
||||
canSubscribe: !publish,
|
||||
canPublishData: false,
|
||||
});
|
||||
return access.toJwt();
|
||||
};
|
||||
const [publisherToken, subscriberToken] = await Promise.all([
|
||||
token("host", true),
|
||||
token("viewer", false),
|
||||
]);
|
||||
media = await evaluate<unknown>(
|
||||
cdp,
|
||||
page,
|
||||
`globalThis.__CODEC_PREFLIGHT__.runLivekit(${JSON.stringify(codec)}, ${JSON.stringify(livekitUrl)}, ${JSON.stringify(publisherToken)}, ${JSON.stringify(subscriberToken)})`,
|
||||
60_000,
|
||||
);
|
||||
} else {
|
||||
media = await evaluate<unknown>(
|
||||
cdp,
|
||||
page,
|
||||
`globalThis.__CODEC_PREFLIGHT__.run(${JSON.stringify(codec)}, ${edges}, ${JSON.stringify(topology)})`,
|
||||
45_000,
|
||||
);
|
||||
}
|
||||
const wallMs = performance.now() - started;
|
||||
const after = await processSnapshot(cdp);
|
||||
await evaluate<void>(cdp, page, "globalThis.__CODEC_PREFLIGHT__.stop()", 5_000);
|
||||
const report = {
|
||||
schemaVersion: 1,
|
||||
browser: version.Browser,
|
||||
configuration: {
|
||||
width: WIDTH,
|
||||
height: HEIGHT,
|
||||
frameRate: FRAME_RATE,
|
||||
maxBitrate: MAX_BITRATE,
|
||||
contentHint: "motion",
|
||||
settleMs: SETTLE_MS,
|
||||
sampleMs: SAMPLE_MS,
|
||||
edges,
|
||||
topology,
|
||||
},
|
||||
gpuInfo,
|
||||
capabilities,
|
||||
capture,
|
||||
codec,
|
||||
media,
|
||||
cpu: processCpu(before, after, wallMs),
|
||||
};
|
||||
const outputDirectory = resolve("benchmark-results");
|
||||
await mkdir(outputDirectory, { recursive: true });
|
||||
const output = join(
|
||||
outputDirectory,
|
||||
`browser-codec-preflight-${codec}-${topology}-${edges}.json`,
|
||||
);
|
||||
await writeFile(output, `${JSON.stringify(report, null, 2)}\n`, "utf8");
|
||||
console.log(output);
|
||||
} finally {
|
||||
await cleanupRun({
|
||||
cdp,
|
||||
native: null,
|
||||
chrome,
|
||||
server: null,
|
||||
profile,
|
||||
ports: [debugPort],
|
||||
});
|
||||
if (server) {
|
||||
await new Promise<void>((resolveClose) => server!.close(() => resolveClose()));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
await main();
|
||||
Reference in new issue
Block a user