@rezkam/browser-tools 1.1.0 → 1.1.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +12 -0
- package/package.json +1 -1
- package/scripts/browser-control.mjs +15 -8
- package/scripts/cdp-event-capture.mjs +45 -26
- package/scripts/gif-recorder.mjs +51 -46
- package/scripts/har-capture.mjs +75 -35
- package/scripts/pick.mjs +12 -8
- package/scripts/record-cdp.mjs +7 -27
- package/scripts/record-har.mjs +7 -27
- package/scripts/recording-lifecycle.mjs +33 -0
- package/scripts/resource-helper.mjs +8 -10
- package/scripts/serve.mjs +6 -6
- package/scripts/tab-broker.mjs +96 -163
- package/scripts/tab-pool.mjs +195 -0
|
@@ -0,0 +1,195 @@
|
|
|
1
|
+
import { randomUUID } from 'node:crypto';
|
|
2
|
+
|
|
3
|
+
// Transport-independent owner of the service, lazy browser, and individual lease lifecycles.
|
|
4
|
+
// Queued leases hold no slot. Allocating leases keep their slot until late resources are disposed.
|
|
5
|
+
export function createTabPool({ launchChrome, maxTabs, tabSeconds, proxyServer, log }) {
|
|
6
|
+
const waiting = [];
|
|
7
|
+
const held = new Set();
|
|
8
|
+
const allocations = new Set();
|
|
9
|
+
const releases = new Set();
|
|
10
|
+
let service = { phase: 'open' };
|
|
11
|
+
let browser = { phase: 'idle' };
|
|
12
|
+
|
|
13
|
+
function track(set, task) {
|
|
14
|
+
set.add(task);
|
|
15
|
+
task.then(() => set.delete(task), () => set.delete(task));
|
|
16
|
+
return task;
|
|
17
|
+
}
|
|
18
|
+
|
|
19
|
+
function stopBrowser(running) {
|
|
20
|
+
const stopping = { phase: 'stopping', value: running };
|
|
21
|
+
stopping.result = Promise.resolve().then(() => running.close()).then(() => {
|
|
22
|
+
if (browser === stopping) browser = { phase: 'idle' };
|
|
23
|
+
}, (error) => {
|
|
24
|
+
// Retain a live owner for retry, but never resurrect a browser after its verified exit.
|
|
25
|
+
if (browser === stopping) browser = { phase: 'running', value: running };
|
|
26
|
+
throw error;
|
|
27
|
+
});
|
|
28
|
+
browser = stopping;
|
|
29
|
+
return stopping.result;
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
async function ensureChrome() {
|
|
33
|
+
if (service.phase !== 'open') throw new Error('The tab broker is closed');
|
|
34
|
+
if (browser.phase === 'running') {
|
|
35
|
+
const running = browser.value;
|
|
36
|
+
if (running.browser.connected && running.child.exitCode === null && running.child.signalCode === null) return running;
|
|
37
|
+
await stopBrowser(running);
|
|
38
|
+
return ensureChrome();
|
|
39
|
+
}
|
|
40
|
+
if (browser.phase === 'stopping') {
|
|
41
|
+
await browser.result;
|
|
42
|
+
return ensureChrome();
|
|
43
|
+
}
|
|
44
|
+
if (browser.phase === 'idle') {
|
|
45
|
+
const result = Promise.resolve().then(launchChrome).then((running) => {
|
|
46
|
+
browser = { phase: 'running', value: running };
|
|
47
|
+
running.exited.then(({ code, signal }) => {
|
|
48
|
+
if (browser.value === running) browser = { phase: 'idle' };
|
|
49
|
+
for (const lease of [...held]) {
|
|
50
|
+
if (lease.chrome !== running) continue;
|
|
51
|
+
lease.error = `Chrome exited (${signal ?? code})`;
|
|
52
|
+
end(lease, 'error');
|
|
53
|
+
// Verified exit settles failed cleanup, but allocations must still dispose late contexts.
|
|
54
|
+
if (lease.cleanup.phase !== 'pending') release(lease);
|
|
55
|
+
}
|
|
56
|
+
});
|
|
57
|
+
return running;
|
|
58
|
+
}, (error) => {
|
|
59
|
+
browser = { phase: 'idle' };
|
|
60
|
+
throw error;
|
|
61
|
+
});
|
|
62
|
+
browser = { phase: 'starting', result };
|
|
63
|
+
}
|
|
64
|
+
return browser.result;
|
|
65
|
+
}
|
|
66
|
+
|
|
67
|
+
function pump() {
|
|
68
|
+
if (service.phase !== 'open') return;
|
|
69
|
+
for (const lease of held) {
|
|
70
|
+
if (lease.cleanup.phase === 'failed') void dispose(lease);
|
|
71
|
+
}
|
|
72
|
+
while (held.size < maxTabs && waiting.length > 0) {
|
|
73
|
+
const lease = waiting.shift();
|
|
74
|
+
lease.state = { phase: 'allocating' };
|
|
75
|
+
held.add(lease);
|
|
76
|
+
track(allocations, grant(lease));
|
|
77
|
+
}
|
|
78
|
+
}
|
|
79
|
+
|
|
80
|
+
function write(lease, line) {
|
|
81
|
+
if (!lease.response.writableEnded && !lease.response.destroyed) lease.response.write(`${JSON.stringify(line)}\n`);
|
|
82
|
+
}
|
|
83
|
+
|
|
84
|
+
function release(lease) {
|
|
85
|
+
lease.cleanup = { phase: 'disposed' };
|
|
86
|
+
if (held.delete(lease)) pump();
|
|
87
|
+
}
|
|
88
|
+
|
|
89
|
+
function dispose(lease) {
|
|
90
|
+
if (lease.cleanup.phase === 'disposed') return Promise.resolve();
|
|
91
|
+
if (lease.cleanup.phase === 'disposing') return lease.cleanup.result;
|
|
92
|
+
const result = Promise.resolve().then(async () => {
|
|
93
|
+
if (lease.cleanup.phase === 'disposed') return;
|
|
94
|
+
if (lease.context) {
|
|
95
|
+
try {
|
|
96
|
+
await lease.chrome.session.send('Target.disposeBrowserContext', { browserContextId: lease.context });
|
|
97
|
+
} catch {
|
|
98
|
+
if (lease.cleanup.phase === 'disposed') return;
|
|
99
|
+
// An unconfirmed disposal must not free capacity while its browser can still own the tab.
|
|
100
|
+
if (browser.phase === 'running' && browser.value === lease.chrome) await stopBrowser(lease.chrome);
|
|
101
|
+
else if (browser.phase === 'stopping' && browser.value === lease.chrome) await browser.result;
|
|
102
|
+
}
|
|
103
|
+
}
|
|
104
|
+
}).then(() => release(lease), (error) => {
|
|
105
|
+
if (lease.cleanup.phase !== 'disposed') lease.cleanup = { phase: 'failed', error };
|
|
106
|
+
throw error;
|
|
107
|
+
});
|
|
108
|
+
lease.cleanup = { phase: 'disposing', result };
|
|
109
|
+
return track(releases, result);
|
|
110
|
+
}
|
|
111
|
+
|
|
112
|
+
function end(lease, reason) {
|
|
113
|
+
const previous = lease.state.phase;
|
|
114
|
+
if (previous === 'ended') return;
|
|
115
|
+
lease.state = { phase: 'ended', reason };
|
|
116
|
+
clearTimeout(lease.timer);
|
|
117
|
+
const queued = waiting.indexOf(lease);
|
|
118
|
+
if (queued >= 0) waiting.splice(queued, 1);
|
|
119
|
+
log({
|
|
120
|
+
event: 'tab_lease',
|
|
121
|
+
client: lease.client,
|
|
122
|
+
waited_ms: (lease.granted ?? Date.now()) - lease.asked,
|
|
123
|
+
held_ms: lease.granted ? Date.now() - lease.granted : 0,
|
|
124
|
+
ended: reason,
|
|
125
|
+
tabs: [...held].filter((candidate) => candidate.state.phase !== 'ended').length,
|
|
126
|
+
waiting: waiting.length,
|
|
127
|
+
});
|
|
128
|
+
if (reason !== 'released') write(lease, reason === 'error' ? { error: lease.error } : { ended: reason });
|
|
129
|
+
lease.response.end();
|
|
130
|
+
if (previous === 'active') void dispose(lease);
|
|
131
|
+
// An allocating lease is disposed by grant's finally, even if the context arrives after end.
|
|
132
|
+
}
|
|
133
|
+
|
|
134
|
+
async function grant(lease) {
|
|
135
|
+
try {
|
|
136
|
+
const running = await ensureChrome();
|
|
137
|
+
if (lease.state.phase !== 'allocating') return;
|
|
138
|
+
lease.chrome = running;
|
|
139
|
+
const { browserContextId } = await running.session.send('Target.createBrowserContext', {
|
|
140
|
+
disposeOnDetach: false,
|
|
141
|
+
...(proxyServer ? { proxyServer, proxyBypassList: '<-loopback>' } : {}),
|
|
142
|
+
});
|
|
143
|
+
lease.context = browserContextId;
|
|
144
|
+
if (lease.state.phase !== 'allocating') return;
|
|
145
|
+
await running.session.send('Browser.setDownloadBehavior', { behavior: 'deny', browserContextId });
|
|
146
|
+
if (lease.state.phase !== 'allocating') return;
|
|
147
|
+
const tabUrl = `about:blank#${randomUUID()}`;
|
|
148
|
+
const { targetId } = await running.session.send('Target.createTarget', { url: tabUrl, browserContextId });
|
|
149
|
+
if (lease.state.phase !== 'allocating') return;
|
|
150
|
+
lease.state = { phase: 'active' };
|
|
151
|
+
lease.granted = Date.now();
|
|
152
|
+
lease.timer = setTimeout(() => end(lease, 'expired'), tabSeconds * 1000);
|
|
153
|
+
write(lease, { cdp_url: running.cdpUrl, target_id: targetId, tab_url: tabUrl, deadline: lease.granted + tabSeconds * 1000 });
|
|
154
|
+
} catch (error) {
|
|
155
|
+
lease.error = error instanceof Error ? error.message : String(error);
|
|
156
|
+
end(lease, 'error');
|
|
157
|
+
} finally {
|
|
158
|
+
if (lease.state.phase === 'ended') await dispose(lease);
|
|
159
|
+
}
|
|
160
|
+
}
|
|
161
|
+
|
|
162
|
+
function close() {
|
|
163
|
+
if (service.phase === 'closing' || service.phase === 'closed') return service.result;
|
|
164
|
+
// Publish closing before ending responses, whose close handlers can reenter the pool.
|
|
165
|
+
const result = Promise.resolve().then(async () => {
|
|
166
|
+
if (browser.phase === 'starting') await browser.result.catch(() => {});
|
|
167
|
+
// Closing Chrome breaks stalled CDP work. Waiting for allocations first could deadlock.
|
|
168
|
+
if (browser.phase === 'running') await stopBrowser(browser.value);
|
|
169
|
+
else if (browser.phase === 'stopping') await browser.result;
|
|
170
|
+
await Promise.allSettled([...allocations]);
|
|
171
|
+
await Promise.allSettled([...releases]);
|
|
172
|
+
}).then(() => { service = { phase: 'closed', result }; }, (error) => {
|
|
173
|
+
service = { phase: 'close-failed', error };
|
|
174
|
+
throw error;
|
|
175
|
+
});
|
|
176
|
+
service = { phase: 'closing', result };
|
|
177
|
+
for (const lease of [...held, ...waiting]) end(lease, 'closed');
|
|
178
|
+
return result;
|
|
179
|
+
}
|
|
180
|
+
|
|
181
|
+
return {
|
|
182
|
+
get running() { return browser.phase === 'running' ? browser.value : null; },
|
|
183
|
+
get counts() { return { tabs: held.size, waiting: waiting.length }; },
|
|
184
|
+
add(response, client) {
|
|
185
|
+
if (service.phase !== 'open') { response.writeHead(503).end(); return; }
|
|
186
|
+
const lease = { state: { phase: 'queued' }, cleanup: { phase: 'pending' }, client, asked: Date.now(), response };
|
|
187
|
+
response.writeHead(200, { 'content-type': 'application/x-ndjson', 'cache-control': 'no-store' });
|
|
188
|
+
response.flushHeaders();
|
|
189
|
+
response.on('close', () => end(lease, 'released'));
|
|
190
|
+
waiting.push(lease);
|
|
191
|
+
pump();
|
|
192
|
+
},
|
|
193
|
+
close,
|
|
194
|
+
};
|
|
195
|
+
}
|