Free, open-source screen sharing for private live streams with friends. Watch together in a browser or self-host Piik. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。
import { createServer } from 'node:http';
import type { ChildProcessWithoutNullStreams } from 'node:child_process';
import { mkdir, mkdtemp, writeFile } from 'node:fs/promises';
import { createHash } from 'node:crypto';
import { build } from 'esbuild';
import { join, resolve } from 'node:path';
import { tmpdir } from 'node:os';
import { CdpConnection, cleanupRun, createPage, evaluate, launchChrome, reservePort, waitForSample, waitForVersion } from './browser-gate-harness';
import { createPoolShaper } from './browser-pool-shaper.mjs';
import { parseVideoGateSize } from './media-gate-geometry';
const mode = process.argv[2] || 'carrier', args = process.argv.slice(3);
const flags = new Set(['--product', '--1080', '--h264', '--single', '--av', '--late', '--background',
'--native-source', '--lifecycle', '--network', '--auto', '--relay', '--debug', '--short-pulse', '--repeated-pulses', '--textured', '--display', '--quiet-start']);
if (!['ordinary', 'carrier'].includes(mode)) throw Error('Expected ordinary|carrier');
for (const arg of args) if (!flags.has(arg) && !arg.startsWith('--rate=') && !arg.startsWith('--preference=') && !arg.startsWith('--audio-bitrate=') && !arg.startsWith('--size='))
throw Error('Unsupported option: ' + arg);
const codec = args.includes('--h264') ? 'H264' : 'VP8', network = args.includes('--network');
const automatic = args.includes('--auto'), high = args.includes('--1080'), av = args.includes('--av');
const sizeArgument = args.find(arg => arg.startsWith('--size='));
const size = sizeArgument ? parseVideoGateSize(sizeArgument.slice('--size='.length)) : undefined;
const single = args.includes('--single'), late = args.includes('--late'), background = args.includes('--background');
const displaySource = args.includes('--display');
const quietStart = args.includes('--quiet-start');
const nativeSource = background || args.includes('--native-source'), lifecycle = args.includes('--lifecycle');
const relay = args.includes('--relay');
const shortPulse = args.includes('--short-pulse');
const repeatedPulses = args.includes('--repeated-pulses'), textured = args.includes('--textured');
const rate = Number(args.find(arg => arg.startsWith('--rate='))?.split('=')[1] || 120000);
const audioBitrate = Number(args.find(arg => arg.startsWith('--audio-bitrate='))?.split('=')[1] || 128000);
if (!Number.isInteger(audioBitrate) || audioBitrate < 6000 || audioBitrate > 320000) throw Error('Audio bitrate must be 6000..320000 bps');
const preference = args.find(arg => arg.startsWith('--preference='))?.split('=')[1] || (high || size ? 'maintain-resolution' : 'balanced');
if (!['balanced', 'maintain-resolution', 'maintain-framerate'].includes(preference)) throw Error('Unsupported degradation preference');
if (!Number.isInteger(rate) || rate <= 0) throw Error('Rate must be a positive integer in bps');
if (lifecycle && (nativeSource || network || relay)) throw Error('Lifecycle uses direct canvas/display capture without network shaping');
if (single && late) throw Error('Single-viewer control cannot also late-join B');
if (shortPulse && (!network || !automatic)) throw Error('Short pulse requires --network --auto');
if (repeatedPulses && (!network || !automatic || shortPulse)) throw Error('Repeated pulses require --network --auto without --short-pulse');
if (textured && nativeSource) throw Error('Textured source requires canvas/display capture');
if (displaySource && nativeSource) throw Error('Display and fake-device sources are separate probes');
if (quietStart && !displaySource) throw Error('Quiet start requires real display capture');
const root = resolve(import.meta.dirname, '..');
const bundle = await build({ entryPoints: [join(root, 'scripts/browser-local-pool-page.js')],
bundle: true, write: false, format: 'esm', platform: 'browser', logLevel: 'error' });
const body = Buffer.from(bundle.outputFiles[0].contents);
let cdp: CdpConnection | null = null;
let page: Awaited<ReturnType<typeof createPage>> | undefined;
let originalTarget: string | undefined, backgroundTarget: string | undefined;
let shaper: Awaited<ReturnType<typeof createPoolShaper>> | null = null;
let profile: string | null = null;
let chrome: ChildProcessWithoutNullStreams | null = null;
let port = 0, debugPort = 0;
let result: Record<string, unknown> = { mode, codec, product: true, network, automatic, high, av, single, late, shortPulse, repeatedPulses, textured,
background, nativeSource, displaySource, quietStart, lifecycle, relay, shapedRate: rate, preference };
const server = createServer((request, response) => {
const url = new URL(request.url!, 'http://127.0.0.1');
if (url.pathname === '/visibility' && cdp && page) {
void (async () => {
originalTarget ??= (await cdp!.call<{ targetInfo: { targetId: string } }>(
'Target.getTargetInfo', {}, page!.sessionId, Date.now() + 3000)).targetInfo.targetId;
backgroundTarget ??= (await cdp!.call<{ targetId: string }>(
'Target.createTarget', { url: 'about:blank', background: true }, undefined, Date.now() + 3000)).targetId;
await cdp!.call('Target.activateTarget', { targetId: url.searchParams.get('hidden') === '1' ? backgroundTarget : originalTarget },
undefined, Date.now() + 3000);
response.end('{}');
})().catch(() => { response.statusCode = 500; response.end('{}'); });
return;
}
if (url.pathname === '/process' && cdp) {
void cdp.call<{ processInfo: Array<{ cpuTime: number }> }>('SystemInfo.getProcessInfo', {}, undefined, Date.now() + 3000)
.then(info => response.end(JSON.stringify({ cpuSeconds: info.processInfo.reduce((sum, p) => sum + p.cpuTime, 0) })),
() => response.end('{}'));
return;
}
if (url.pathname === '/shaper' && shaper) {
if (url.searchParams.has('left')) shaper.setTargets(Number(url.searchParams.get('left')), Number(url.searchParams.get('right')));
if (url.searchParams.has('rate')) shaper.setRate(Number(url.searchParams.get('rate')));
response.setHeader('Content-Type', 'application/json');
response.end(JSON.stringify({ ports: shaper.ports, stats: shaper.stats() }));
return;
}
response.setHeader('Content-Type', url.pathname === '/probe.js' ? 'text/javascript' : 'text/html');
response.end(url.pathname === '/probe.js' ? body :
'<!doctype html><meta charset=utf-8><title>Browser local pool</title><script type=module src=/probe.js></script>');
});
try {
shaper = network ? await createPoolShaper() : null;
await new Promise<void>((resolve, reject) => { server.once('error', reject); server.listen(0, '127.0.0.1', resolve); });
port = (server.address() as { port: number }).port;
debugPort = await reservePort();
profile = await mkdtemp(join(tmpdir(), 'piik-client-media-'));
chrome = await launchChrome(process.env.CHROME_PATH || 'C:/Program Files/Google/Chrome/Application/chrome.exe', debugPort, profile,
['--headless=new', '--no-first-run', '--autoplay-policy=no-user-gesture-required',
...(displaySource ? [`--window-size=${size?.width ?? 1920},${size?.height ?? 1200}`, '--force-device-scale-factor=1',
'--auto-accept-this-tab-capture', '--auto-select-tab-capture-source-by-title=Browser local pool'] : []),
...(background ? [] : ['--disable-background-timer-throttling', '--disable-renderer-backgrounding']),
...(nativeSource ? ['--use-fake-device-for-media-stream', '--use-fake-ui-for-media-stream'] : [])]);
chrome.stdout.resume(); chrome.stderr.resume();
const version = await waitForVersion(debugPort, chrome);
cdp = await CdpConnection.connect(version.webSocketDebuggerUrl, Date.now() + 5000);
page = await createPage(cdp, 'about:blank');
const query = new URLSearchParams({ mode, codec, rate: String(rate), preference, audioBitrate: String(audioBitrate) });
if (size) {
query.set('width', String(size.width)); query.set('height', String(size.height));
}
if (process.argv.includes('--debug')) query.set('debug', '1');
for (const [key, value] of Object.entries({ network, automatic, high, av, single, late, background, nativeSource, displaySource, quietStart, lifecycle, relay, shortPulse, repeatedPulses, textured }))
query.set(key, value ? '1' : '0');
await cdp.call('Page.navigate', { url: 'http://127.0.0.1:' + port + '/?' + query }, page.sessionId, Date.now() + 5000);
if (displaySource) {
await waitForSample(() => evaluate<boolean>(cdp!, page!, '!!window.acquireDisplay', Date.now() + 1000), Boolean, 5000);
await cdp.call('Runtime.evaluate', { expression: 'void window.acquireDisplay()', userGesture: true }, page.sessionId, Date.now() + 3000);
}
await waitForSample(() => evaluate<boolean>(cdp!, page!, 'window.probeDone===true', Date.now() + 2000),
Boolean, repeatedPulses ? 170000 : automatic || lifecycle ? 110000 : network || background ? 60000 : 25000);
result = await evaluate<Record<string, unknown>>(cdp, page, 'window.probeResult', Date.now() + 3000);
} catch (error) {
result.error = String(error);
if (cdp && page) result.partial = await evaluate(cdp, page, 'window.probeResult || window.probeProgress?.()', Date.now() + 3000).catch(() => null);
} finally {
const clean = await cleanupRun({ cdp, native: null, chrome,
server: { close: () => new Promise<void>((resolve, reject) => {
if (!server.listening) { resolve(); return; }
server.close(e => e ? reject(e) : resolve());
}) },
profile, ports: [port, debugPort].filter(Boolean) });
if (shaper) { result.shaper = shaper.stats(); await shaper.close(); }
result.probeSha256 = createHash('sha256').update(body).digest('hex');
result.cleanup = clean;
await mkdir(join(root, 'build/browser-local-pool'), { recursive: true });
const name = [mode, codec.toLowerCase(), displaySource && 'display', network && 'network', automatic && 'auto', shortPulse && 'pulse', repeatedPulses && 'repeated-pulses', textured && 'textured', high && '1080',
single && 'single', late && 'late', quietStart && 'quiet-start', background && 'background', lifecycle && 'lifecycle', relay && 'relay', Date.now()].filter(Boolean).join('-');
const output = join(root, 'build/browser-local-pool', name + '.json');
await writeFile(output, JSON.stringify(result, null, 2) + '\n');
console.log(JSON.stringify({ mode, codec, network, error: result.error ?? null, output, cleanup: clean }));
if (result.error || (result.errors as string[] | undefined)?.length || Object.values(clean).some(v => !v)) process.exitCode = 1;
}