Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

test(media): separate CDP delivery from renderer execution in preview load failures (#10798)

Adam Eivy2137799fb890
diff --git a/server/services/musicVideo/testPreviewLoadDiagnostics.js b/server/services/musicVideo/testPreviewLoadDiagnostics.js
index 6ebb53afd3..89e753c50e 100644
--- a/server/services/musicVideo/testPreviewLoadDiagnostics.js
+++ b/server/services/musicVideo/testPreviewLoadDiagnostics.js
@@ -1,8 +1,107 @@
// Test-only observer: retain phase facts before owned-page cleanup without
// copying document source, URLs, error messages or console arguments.
+import { availableParallelism, loadavg, platform } from 'node:os';
+
const LIMIT = 1000;
+const DOCUMENT_PROBE_MS = 250;
+// Browser-process probe: one CDP round trip plus two CPU samples this far
+// apart, all inside its own deadline. It runs beside the renderer probe, so a
+// failure costs at most PROCESS_PROBE_MS before the caller's owned cleanup.
+const PROCESS_SAMPLE_MS = 250;
+const PROCESS_PROBE_MS = 1000;
+const DEADLINE = Symbol('deadline');
+const SAMPLED_PROCESS_TYPES = new Set(['browser', 'renderer', 'GPU']);
const count = value => Number.isInteger(value) && value >= 0 ? Math.min(value, LIMIT) : 'unavailable';
const flag = value => typeof value === 'boolean' ? value : 'unavailable';
+const percent = value => Number.isFinite(value) ? Math.min(Math.max(Math.round(value), 0), 10 * LIMIT) : 'unavailable';
+
+// Promise.race owns a late rejection after the deadline wins.
+function withDeadline(start, ms) {
+ let timer;
+ return Promise.race([
+ Promise.resolve().then(start),
+ new Promise(resolve => { timer = setTimeout(() => resolve(DEADLINE), ms); }),
+ ]).finally(() => clearTimeout(timer));
+}
+
+// Keep only allowlisted process types and numeric CPU seconds; process ids
+// are compared inside this module and never leave it.
+function cpuByProcess(result) {
+ const cpu = new Map();
+ const processes = Array.isArray(result?.processInfo) ? result.processInfo.slice(0, LIMIT) : [];
+ for (const entry of processes) {
+ if (SAMPLED_PROCESS_TYPES.has(entry?.type) && Number.isFinite(entry.cpuTime)) cpu.set(entry.id, { type: entry.type, cpuTime: entry.cpuTime });
+ }
+ return cpu;
+}
+
+// Distinguishes CDP delivery to the browser process from renderer execution:
+// a fast round trip with a pegged renderer points at page work; an idle
+// renderer and slow/absent round trip point at delivery or host pressure.
+async function sampleBrowserProcesses(browser) {
+ const session = await browser.newBrowserCDPSession();
+ try {
+ const sent = Date.now();
+ // The reply carries version/user-agent strings; only the latency is kept.
+ await session.send('Browser.getVersion');
+ const browserRoundTripMs = Date.now() - sent;
+ const before = cpuByProcess(await session.send('SystemInfo.getProcessInfo'));
+ const windowStart = Date.now();
+ await new Promise(resolve => setTimeout(resolve, PROCESS_SAMPLE_MS));
+ const after = cpuByProcess(await session.send('SystemInfo.getProcessInfo'));
+ const windowMs = Math.max(Date.now() - windowStart, 1);
+ const busiest = { browser: 0, renderer: 0, GPU: 0 };
+ let rendererProcesses = 0;
+ for (const [id, { type, cpuTime }] of after) {
+ if (type === 'renderer') rendererProcesses++;
+ const previous = before.get(id);
+ if (previous?.type !== type) continue;
+ busiest[type] = Math.max(busiest[type], (cpuTime - previous.cpuTime) * 1000 / windowMs * 100);
+ }
+ return { browserRoundTripMs: count(browserRoundTripMs), rendererProcesses: count(rendererProcesses),
+ busiestRendererCpuPct: percent(busiest.renderer), gpuCpuPct: percent(busiest.GPU), browserCpuPct: percent(busiest.browser) };
+ } finally {
+ session.detach().catch(() => {});
+ }
+}
+
+async function probeDocument(page) {
+ const documentFacts = await withDeadline(() => page.evaluate(() => {
+ let moduleCount = 0, externalScriptCount = 0;
+ for (let i = 0; i < Math.min(document.scripts.length, 1000); i++) {
+ const script = document.scripts[i];
+ if (script.type === 'module') moduleCount++;
+ if (script.hasAttribute('src')) externalScriptCount++;
+ }
+ return { readyState: document.readyState,
+ compositionReady: typeof window.portosComposition?.seek === 'function',
+ scriptCount: document.scripts.length, moduleCount, externalScriptCount };
+ }), DOCUMENT_PROBE_MS).catch(() => null);
+ // Treat page evaluation as untrusted even in a synthetic proof. Only
+ // these scalars can leave the page; never stringify the returned object.
+ if (documentFacts === null) return { documentProbe: 'unavailable' };
+ if (documentFacts === DEADLINE) return { documentProbe: 'deadline' };
+ return { documentProbe: 'captured',
+ readyState: ['loading', 'interactive', 'complete'].includes(documentFacts?.readyState) ? documentFacts.readyState : 'unavailable',
+ compositionReady: flag(documentFacts?.compositionReady),
+ scriptCount: count(documentFacts?.scriptCount),
+ moduleCount: count(documentFacts?.moduleCount),
+ externalScriptCount: count(documentFacts?.externalScriptCount) };
+}
+
+async function probeProcesses(page) {
+ const facts = await withDeadline(() => sampleBrowserProcesses(page.context().browser()), PROCESS_PROBE_MS).catch(() => null);
+ if (facts === null) return { processProbe: 'unavailable' };
+ if (facts === DEADLINE) return { processProbe: 'deadline' };
+ return { processProbe: 'captured', ...facts };
+}
+
+function hostLoadPerCpu() {
+ // Windows reports a constant zero load average.
+ if (platform() === 'win32') return 'unavailable';
+ const perCpu = loadavg()[0] / availableParallelism();
+ return Number.isFinite(perCpu) ? Math.min(Math.round(perCpu * 100) / 100, LIMIT) : 'unavailable';
+}
export async function _withTestPreviewLoadDiagnostics(page, load) {
const started = Date.now();
@@ -32,35 +131,10 @@ export async function _withTestPreviewLoadDiagnostics(page, load) {
await load(() => { phase = 'composition-readiness'; });
} catch (error) {
const failure = { phase, elapsedMs: Math.min(Date.now() - started, 3600000), ...facts,
- pageClosed: page.isClosed(), browserConnected: page.context().browser()?.isConnected() ?? false };
- let timer;
- try {
- const documentFacts = await Promise.race([
- Promise.resolve().then(() => page.evaluate(() => {
- let moduleCount = 0, externalScriptCount = 0;
- for (let i = 0; i < Math.min(document.scripts.length, 1000); i++) {
- const script = document.scripts[i];
- if (script.type === 'module') moduleCount++;
- if (script.hasAttribute('src')) externalScriptCount++;
- }
- return { readyState: document.readyState,
- compositionReady: typeof window.portosComposition?.seek === 'function',
- scriptCount: document.scripts.length, moduleCount, externalScriptCount };
- })),
- new Promise(resolve => { timer = setTimeout(() => resolve(null), 250); }),
- ]);
- // Treat page evaluation as untrusted even in a synthetic proof. Only
- // these scalars can leave the page; never stringify the returned object.
- failure.documentProbe = documentFacts ? 'captured' : 'deadline';
- if (documentFacts) Object.assign(failure, {
- readyState: ['loading', 'interactive', 'complete'].includes(documentFacts.readyState) ? documentFacts.readyState : 'unavailable',
- compositionReady: flag(documentFacts.compositionReady),
- scriptCount: count(documentFacts.scriptCount),
- moduleCount: count(documentFacts.moduleCount),
- externalScriptCount: count(documentFacts.externalScriptCount),
- });
- } catch { failure.documentProbe = 'unavailable'; }
- finally { clearTimeout(timer); }
+ pageClosed: page.isClosed(), browserConnected: page.context().browser()?.isConnected() ?? false,
+ hostLoadPerCpu: hostLoadPerCpu() };
+ const [documentFacts, processFacts] = await Promise.all([probeDocument(page), probeProcesses(page)]);
+ Object.assign(failure, documentFacts, processFacts);
// Attach to the original failure so reporters retain these facts even if
// cleanup subsequently fails. No console/error body enters the snapshot.
error.message += `; preview lifecycle: ${JSON.stringify(failure)}`;
diff --git a/server/services/musicVideo/testPreviewLoadDiagnostics.test.js b/server/services/musicVideo/testPreviewLoadDiagnostics.test.js
index 46e650864d..8d302c7cb1 100644
--- a/server/services/musicVideo/testPreviewLoadDiagnostics.test.js
+++ b/server/services/musicVideo/testPreviewLoadDiagnostics.test.js
@@ -3,9 +3,14 @@ import { afterEach, describe, expect, it, vi } from 'vitest';
import { _withTestPreviewLoadDiagnostics } from './testPreviewLoadDiagnostics.js';
function fixture(evaluate = vi.fn().mockResolvedValue({ readyState: 'interactive', compositionReady: false,
- scriptCount: 3, moduleCount: 1, externalScriptCount: 0 })) {
+ scriptCount: 3, moduleCount: 1, externalScriptCount: 0 }), browser = { isConnected: () => true }) {
return Object.assign(new EventEmitter(), { evaluate, isClosed: () => false,
- context: () => ({ browser: () => ({ isConnected: () => true }) }) });
+ context: () => ({ browser: () => browser }) });
+}
+// A browser-target CDP session whose replies the probe must reduce to scalars.
+function browserSession(send) {
+ const session = { send: vi.fn(send), detach: vi.fn().mockResolvedValue() };
+ return { session, browser: { isConnected: () => true, newBrowserCDPSession: async () => session } };
}
const snapshot = error => JSON.parse(error.message.split('; preview lifecycle: ')[1]);
afterEach(() => vi.useRealTimers());
@@ -56,14 +61,54 @@ describe('preview load failure evidence', () => {
page.context = () => ({ browser: () => ({ isConnected: () => false }) });
const failure = new Error('load failed');
await expect(_withTestPreviewLoadDiagnostics(page, async () => { throw failure; })).rejects.toBe(failure);
- expect(snapshot(failure)).toMatchObject({ pageClosed: true, browserConnected: false, documentProbe: 'unavailable' });
+ expect(snapshot(failure)).toMatchObject({ pageClosed: true, browserConnected: false, documentProbe: 'unavailable', processProbe: 'unavailable' });
expect(page.eventNames()).toEqual([]);
});
+ it('separates browser-process delivery from renderer execution with per-process CPU, keeping no version strings or process ids', async () => {
+ vi.useFakeTimers();
+ const samples = [
+ { processInfo: [{ type: 'browser', id: 9001, cpuTime: 1 }, { type: 'renderer', id: 9002, cpuTime: 2 },
+ { type: 'renderer', id: 9003, cpuTime: 3 }, { type: 'GPU', id: 9004, cpuTime: 4 }, { type: 'secret-utility', id: 9005, cpuTime: 0 }] },
+ // 250 ms later: one renderer pegged, GPU at 20%, browser idle; a new renderer has no baseline.
+ { processInfo: [{ type: 'browser', id: 9001, cpuTime: 1 }, { type: 'renderer', id: 9002, cpuTime: 2.25 },
+ { type: 'renderer', id: 9003, cpuTime: 3.01 }, { type: 'GPU', id: 9004, cpuTime: 4.05 },
+ { type: 'renderer', id: 9006, cpuTime: 50 }, { type: 'secret-utility', id: 9005, cpuTime: 99 }] },
+ ];
+ const { session, browser } = browserSession(async method => method === 'Browser.getVersion'
+ ? { product: 'secret-product', userAgent: 'secret-agent' } : samples.shift());
+ const page = fixture(undefined, browser);
+ const failure = new Error('load deadline');
+ const checked = expect(_withTestPreviewLoadDiagnostics(page, async () => { throw failure; })).rejects.toBe(failure);
+ await vi.advanceTimersByTimeAsync(250);
+ await checked;
+ expect(snapshot(failure)).toMatchObject({ documentProbe: 'captured', processProbe: 'captured', browserRoundTripMs: 0,
+ rendererProcesses: 3, busiestRendererCpuPct: 100, gpuCpuPct: 20, browserCpuPct: 0 });
+ expect(failure.message).not.toMatch(/secret|900\d/);
+ expect(session.detach).toHaveBeenCalled();
+ });
+
+ it('bounds a browser session that stops answering and owns its late rejection', async () => {
+ vi.useFakeTimers();
+ let rejectVersion;
+ const { browser } = browserSession(() => new Promise((_, reject) => { rejectVersion = reject; }));
+ const page = fixture(undefined, browser);
+ const failure = new Error('load deadline');
+ const checked = expect(_withTestPreviewLoadDiagnostics(page, async () => { throw failure; })).rejects.toBe(failure);
+ await vi.advanceTimersByTimeAsync(1000);
+ await checked;
+ expect(snapshot(failure)).toMatchObject({ documentProbe: 'captured', processProbe: 'deadline' });
+ rejectVersion(new Error('late private CDP error'));
+ await Promise.resolve();
+ expect(vi.getTimerCount()).toBe(0);
+ });
+
it('does not probe or retain observers after successful load and semantic readiness', async () => {
- const page = fixture();
+ const { session, browser } = browserSession(async () => ({}));
+ const page = fixture(undefined, browser);
await _withTestPreviewLoadDiagnostics(page, async markReadiness => { page.emit('load'); markReadiness(); });
expect(page.evaluate).not.toHaveBeenCalled();
+ expect(session.send).not.toHaveBeenCalled();
expect(page.eventNames()).toEqual([]);
});
});