cdp-toolkit 3.0.3 → 3.2.0
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 +28 -0
- package/CONTRACT.md +2 -2
- package/README.md +122 -1
- package/dist/bidi/mux-daemon.js +675 -130
- package/dist/cli.js +1432 -635
- package/dist/index.js +1110 -116
- package/dist/mcp.js +1474 -658
- package/package.json +3 -1
- package/src/bidi/snapshot.ts +123 -113
- package/src/cdp/driver.ts +55 -41
- package/src/cdp/endpoint.ts +200 -0
- package/src/cdp/session.ts +246 -0
- package/src/cli.ts +17 -4
- package/src/client.ts +140 -16
- package/src/endpoints.ts +428 -0
- package/src/leases-tools.ts +6 -3
- package/src/leases.ts +28 -4
- package/src/manifest.ts +54 -42
- package/src/mcp.ts +52 -8
- package/src/origins.ts +5 -2
- package/src/policy.ts +163 -0
- package/src/reap.ts +14 -0
- package/src/shared-tools.ts +164 -25
- package/src/toolDocs.ts +41 -38
- package/src/tools/browser-session.ts +26 -12
- package/src/tools/dispatch-mouse.ts +2 -1
- package/src/tools/evaluate.ts +3 -3
- package/src/tools/focus-emulation.ts +5 -3
- package/src/tools/lighthouse.ts +4 -2
- package/src/tools/navigation.ts +3 -3
- package/src/tools/network_mock.ts +2 -2
- package/src/tools/performance.ts +5 -5
- package/src/tools/recorder.ts +3 -3
- package/src/tools/screencast.ts +46 -6
- package/src/tools/snapshot.ts +2 -2
- package/src/version.ts +1 -1
package/dist/bidi/mux-daemon.js
CHANGED
|
@@ -10,11 +10,308 @@ var __esm = (fn, res, err) => () => {
|
|
|
10
10
|
return res;
|
|
11
11
|
};
|
|
12
12
|
|
|
13
|
-
// src/
|
|
13
|
+
// src/endpoints.ts
|
|
14
14
|
import { AsyncLocalStorage } from "node:async_hooks";
|
|
15
|
+
import { readFileSync } from "node:fs";
|
|
16
|
+
function checkName(name, where) {
|
|
17
|
+
if (!NAME_RE.test(name)) {
|
|
18
|
+
throw new EndpointConfigError(`${where}: endpoint name '${name}' is invalid; names are letters, digits and '_' only (no '-', '/', ':' or spaces)`);
|
|
19
|
+
}
|
|
20
|
+
}
|
|
21
|
+
function sameBase(a, b) {
|
|
22
|
+
return a.replace(/\/+$/, "") === b.replace(/\/+$/, "");
|
|
23
|
+
}
|
|
24
|
+
function parseBase(raw, where) {
|
|
25
|
+
let url;
|
|
26
|
+
try {
|
|
27
|
+
url = new URL(raw);
|
|
28
|
+
} catch {
|
|
29
|
+
throw new EndpointConfigError(`${where}: '${raw}' is not a valid URL (expected e.g. http://127.0.0.1:9222)`);
|
|
30
|
+
}
|
|
31
|
+
if (url.protocol !== "http:" && url.protocol !== "https:") {
|
|
32
|
+
throw new EndpointConfigError(`${where}: '${raw}' must be an http:// or https:// DevTools origin, not ${url.protocol}`);
|
|
33
|
+
}
|
|
34
|
+
if (url.hash)
|
|
35
|
+
throw new EndpointConfigError(`${where}: '${raw}' must not carry a #fragment`);
|
|
36
|
+
let mode;
|
|
37
|
+
for (const [key, value] of url.searchParams) {
|
|
38
|
+
if (key !== "mode") {
|
|
39
|
+
throw new EndpointConfigError(`${where}: unknown query parameter '${key}' in '${raw}' (only ?mode=read or ?mode=write is understood)`);
|
|
40
|
+
}
|
|
41
|
+
if (value !== "read" && value !== "write") {
|
|
42
|
+
throw new EndpointConfigError(`${where}: unknown mode '${value}' in '${raw}' (use mode=read or mode=write)`);
|
|
43
|
+
}
|
|
44
|
+
mode = value;
|
|
45
|
+
}
|
|
46
|
+
const path = url.pathname.replace(/\/+$/, "");
|
|
47
|
+
return { base: `${url.protocol}//${url.host}${path}`, mode };
|
|
48
|
+
}
|
|
49
|
+
function parseEnvString(spec) {
|
|
50
|
+
const out = [];
|
|
51
|
+
const seen = new Set;
|
|
52
|
+
for (const part of spec.split(",")) {
|
|
53
|
+
const entry = part.trim();
|
|
54
|
+
if (!entry)
|
|
55
|
+
continue;
|
|
56
|
+
const eq = entry.indexOf("=");
|
|
57
|
+
if (eq <= 0) {
|
|
58
|
+
throw new EndpointConfigError(`CDP_ENDPOINTS: entry '${entry}' is not name=url (e.g. teams=http://127.0.0.1:9333)`);
|
|
59
|
+
}
|
|
60
|
+
const name = entry.slice(0, eq).trim();
|
|
61
|
+
checkName(name, "CDP_ENDPOINTS");
|
|
62
|
+
if (seen.has(name))
|
|
63
|
+
throw new EndpointConfigError(`CDP_ENDPOINTS: duplicate endpoint name '${name}'`);
|
|
64
|
+
seen.add(name);
|
|
65
|
+
const { base, mode } = parseBase(entry.slice(eq + 1).trim(), `CDP_ENDPOINTS endpoint '${name}'`);
|
|
66
|
+
out.push({ name, base, readOnly: mode === "read" });
|
|
67
|
+
}
|
|
68
|
+
return out;
|
|
69
|
+
}
|
|
70
|
+
function parseFile(path) {
|
|
71
|
+
let text;
|
|
72
|
+
try {
|
|
73
|
+
text = readFileSync(path, "utf8");
|
|
74
|
+
} catch (err) {
|
|
75
|
+
const code = err.code ?? String(err);
|
|
76
|
+
throw new EndpointConfigError(`CDP_ENDPOINTS_FILE: cannot read '${path}' (${code})`);
|
|
77
|
+
}
|
|
78
|
+
let json;
|
|
79
|
+
try {
|
|
80
|
+
json = JSON.parse(text);
|
|
81
|
+
} catch (err) {
|
|
82
|
+
throw new EndpointConfigError(`CDP_ENDPOINTS_FILE: '${path}' is not valid JSON (${err instanceof Error ? err.message : String(err)})`);
|
|
83
|
+
}
|
|
84
|
+
const where = `CDP_ENDPOINTS_FILE '${path}'`;
|
|
85
|
+
if (!json || typeof json !== "object" || Array.isArray(json)) {
|
|
86
|
+
throw new EndpointConfigError(`${where}: top level must be an object {"default"?, "endpoints": {...}}`);
|
|
87
|
+
}
|
|
88
|
+
const top = json;
|
|
89
|
+
for (const key of Object.keys(top)) {
|
|
90
|
+
if (key !== "default" && key !== "endpoints")
|
|
91
|
+
throw new EndpointConfigError(`${where}: unknown top-level key '${key}'`);
|
|
92
|
+
}
|
|
93
|
+
if (top.default !== undefined && typeof top.default !== "string") {
|
|
94
|
+
throw new EndpointConfigError(`${where}: "default" must be an endpoint name string`);
|
|
95
|
+
}
|
|
96
|
+
const raw = top.endpoints ?? {};
|
|
97
|
+
if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
|
|
98
|
+
throw new EndpointConfigError(`${where}: "endpoints" must be an object keyed by endpoint name`);
|
|
99
|
+
}
|
|
100
|
+
const endpoints = [];
|
|
101
|
+
for (const [name, value] of Object.entries(raw)) {
|
|
102
|
+
checkName(name, where);
|
|
103
|
+
const at = `${where} endpoint '${name}'`;
|
|
104
|
+
if (!value || typeof value !== "object" || Array.isArray(value)) {
|
|
105
|
+
throw new EndpointConfigError(`${at}: must be an object like {"base":"http://127.0.0.1:9333"}`);
|
|
106
|
+
}
|
|
107
|
+
const v = value;
|
|
108
|
+
for (const key of Object.keys(v)) {
|
|
109
|
+
if (key !== "base" && key !== "readOnly" && key !== "mode") {
|
|
110
|
+
throw new EndpointConfigError(`${at}: unknown key '${key}' (known: base, readOnly, mode)`);
|
|
111
|
+
}
|
|
112
|
+
}
|
|
113
|
+
if (typeof v.base !== "string")
|
|
114
|
+
throw new EndpointConfigError(`${at}: "base" is required and must be a URL string`);
|
|
115
|
+
if (v.readOnly !== undefined && typeof v.readOnly !== "boolean")
|
|
116
|
+
throw new EndpointConfigError(`${at}: "readOnly" must be a boolean`);
|
|
117
|
+
if (v.mode !== undefined && v.mode !== "read" && v.mode !== "write") {
|
|
118
|
+
throw new EndpointConfigError(`${at}: unknown mode '${String(v.mode)}' (use "read" or "write")`);
|
|
119
|
+
}
|
|
120
|
+
const parsed = parseBase(v.base, at);
|
|
121
|
+
const votes = [parsed.mode, v.mode, v.readOnly === undefined ? undefined : v.readOnly ? "read" : "write"].filter((x) => x !== undefined);
|
|
122
|
+
if (new Set(votes).size > 1)
|
|
123
|
+
throw new EndpointConfigError(`${at}: readOnly / mode settings contradict each other`);
|
|
124
|
+
endpoints.push({ name, base: parsed.base, readOnly: votes[0] === "read" });
|
|
125
|
+
}
|
|
126
|
+
return { endpoints, defaultName: top.default };
|
|
127
|
+
}
|
|
128
|
+
function loadEndpoints(env = process.env) {
|
|
129
|
+
const fromEnv = env.CDP_ENDPOINTS !== undefined ? parseEnvString(env.CDP_ENDPOINTS) : [];
|
|
130
|
+
const file = env.CDP_ENDPOINTS_FILE ? parseFile(env.CDP_ENDPOINTS_FILE) : { endpoints: [], defaultName: undefined };
|
|
131
|
+
const merged = new Map;
|
|
132
|
+
for (const ep of fromEnv)
|
|
133
|
+
merged.set(ep.name, ep);
|
|
134
|
+
for (const ep of file.endpoints) {
|
|
135
|
+
const prior = merged.get(ep.name);
|
|
136
|
+
if (prior && (prior.base !== ep.base || prior.readOnly !== ep.readOnly)) {
|
|
137
|
+
throw new EndpointConfigError(`endpoint '${ep.name}' is defined differently in CDP_ENDPOINTS (${prior.base}${prior.readOnly ? " read-only" : ""}) and CDP_ENDPOINTS_FILE (${ep.base}${ep.readOnly ? " read-only" : ""})`);
|
|
138
|
+
}
|
|
139
|
+
if (!prior)
|
|
140
|
+
merged.set(ep.name, ep);
|
|
141
|
+
}
|
|
142
|
+
const cdpBase = env.CDP_BASE;
|
|
143
|
+
if (cdpBase !== undefined) {
|
|
144
|
+
const configured = merged.get("default");
|
|
145
|
+
if (configured && !sameBase(configured.base, cdpBase)) {
|
|
146
|
+
throw new EndpointConfigError(`CDP_BASE (${cdpBase}) and the configured endpoint 'default' (${configured.base}) disagree; drop one or make them match`);
|
|
147
|
+
}
|
|
148
|
+
merged.set("default", { name: "default", base: cdpBase, readOnly: configured?.readOnly ?? false });
|
|
149
|
+
}
|
|
150
|
+
const defaultName = file.defaultName ?? "default";
|
|
151
|
+
if (!merged.has(defaultName)) {
|
|
152
|
+
if (file.defaultName !== undefined) {
|
|
153
|
+
throw new EndpointConfigError(`CDP_ENDPOINTS_FILE names default endpoint '${file.defaultName}', which is not defined (known: ${[...merged.keys()].join(", ") || "none"})`);
|
|
154
|
+
}
|
|
155
|
+
merged.set("default", { name: "default", base: DEFAULT_CDP_BASE, readOnly: false });
|
|
156
|
+
}
|
|
157
|
+
const def = merged.get(defaultName);
|
|
158
|
+
const byName = new Map([[def.name, def]]);
|
|
159
|
+
for (const [name, ep] of merged)
|
|
160
|
+
if (name !== def.name)
|
|
161
|
+
byName.set(name, ep);
|
|
162
|
+
return { default: def, byName };
|
|
163
|
+
}
|
|
164
|
+
function signature(env) {
|
|
165
|
+
return JSON.stringify([env.CDP_BASE ?? null, env.CDP_ENDPOINTS ?? null, env.CDP_ENDPOINTS_FILE ?? null]);
|
|
166
|
+
}
|
|
167
|
+
function endpointConfig() {
|
|
168
|
+
const sig = signature(process.env);
|
|
169
|
+
if (cache?.sig === sig)
|
|
170
|
+
return cache.config;
|
|
171
|
+
const config = loadEndpoints(process.env);
|
|
172
|
+
cache = { sig, config };
|
|
173
|
+
return config;
|
|
174
|
+
}
|
|
175
|
+
function defaultEndpoint() {
|
|
176
|
+
return endpointConfig().default;
|
|
177
|
+
}
|
|
178
|
+
function allEndpoints() {
|
|
179
|
+
return [...endpointConfig().byName.values()];
|
|
180
|
+
}
|
|
181
|
+
function getEndpoint(name) {
|
|
182
|
+
const { byName } = endpointConfig();
|
|
183
|
+
const ep = byName.get(name);
|
|
184
|
+
if (!ep) {
|
|
185
|
+
throw new EndpointConfigError(`unknown endpoint '${name}' (known: ${[...byName.keys()].join(", ")}). Configure it with CDP_ENDPOINTS or CDP_ENDPOINTS_FILE.`);
|
|
186
|
+
}
|
|
187
|
+
return ep;
|
|
188
|
+
}
|
|
189
|
+
function leaseNamespace(ep) {
|
|
190
|
+
const { default: def, byName } = endpointConfig();
|
|
191
|
+
if (sameBase(ep.base, def.base))
|
|
192
|
+
return;
|
|
193
|
+
for (const other of byName.values())
|
|
194
|
+
if (sameBase(other.base, ep.base))
|
|
195
|
+
return other.name;
|
|
196
|
+
return ep.name;
|
|
197
|
+
}
|
|
198
|
+
function hasEndpointPrefix(target) {
|
|
199
|
+
return typeof target === "string" && target.startsWith(ENDPOINT_PREFIX);
|
|
200
|
+
}
|
|
201
|
+
function splitEndpointSelector(target) {
|
|
202
|
+
if (!hasEndpointPrefix(target))
|
|
203
|
+
return { endpoint: defaultEndpoint(), rest: target };
|
|
204
|
+
const body = target.slice(ENDPOINT_PREFIX.length);
|
|
205
|
+
const slash = body.indexOf("/");
|
|
206
|
+
const name = slash < 0 ? body : body.slice(0, slash);
|
|
207
|
+
if (!name)
|
|
208
|
+
throw new EndpointConfigError(`selector '${target}' has an empty endpoint name; use endpoint:<name>/<selector>`);
|
|
209
|
+
const rest = slash < 0 ? undefined : body.slice(slash + 1);
|
|
210
|
+
return { endpoint: getEndpoint(name), rest: rest === "" ? undefined : rest };
|
|
211
|
+
}
|
|
212
|
+
function usesEndpointArgs(args) {
|
|
213
|
+
if (!args || typeof args !== "object")
|
|
214
|
+
return false;
|
|
215
|
+
const a = args;
|
|
216
|
+
return SELECTOR_KEYS.some((k) => hasEndpointPrefix(a[k])) || a.endpoint !== undefined || a.allEndpoints === true;
|
|
217
|
+
}
|
|
218
|
+
function stripEndpointArgs(args) {
|
|
219
|
+
if (!args || typeof args !== "object" || Array.isArray(args))
|
|
220
|
+
return { endpoint: defaultEndpoint(), args };
|
|
221
|
+
const a = args;
|
|
222
|
+
const picks = [];
|
|
223
|
+
let out;
|
|
224
|
+
for (const key of SELECTOR_KEYS) {
|
|
225
|
+
const v = a[key];
|
|
226
|
+
if (!hasEndpointPrefix(v))
|
|
227
|
+
continue;
|
|
228
|
+
const { endpoint, rest } = splitEndpointSelector(v);
|
|
229
|
+
picks.push({ from: `${key} '${v}'`, endpoint });
|
|
230
|
+
out ??= { ...a };
|
|
231
|
+
if (rest === undefined)
|
|
232
|
+
delete out[key];
|
|
233
|
+
else
|
|
234
|
+
out[key] = rest;
|
|
235
|
+
}
|
|
236
|
+
if (a.endpoint !== undefined) {
|
|
237
|
+
if (typeof a.endpoint !== "string" || a.endpoint === "") {
|
|
238
|
+
throw new EndpointConfigError("`endpoint` must be a non-empty endpoint name string");
|
|
239
|
+
}
|
|
240
|
+
picks.push({ from: `endpoint '${a.endpoint}'`, endpoint: getEndpoint(a.endpoint) });
|
|
241
|
+
out ??= { ...a };
|
|
242
|
+
delete out.endpoint;
|
|
243
|
+
}
|
|
244
|
+
const token = leaseTokenNamespace(a.lease);
|
|
245
|
+
if (!picks.length) {
|
|
246
|
+
if (token?.ns === undefined)
|
|
247
|
+
return { endpoint: defaultEndpoint(), args };
|
|
248
|
+
return { endpoint: endpointForNamespace(token.ns), args };
|
|
249
|
+
}
|
|
250
|
+
const first = picks[0];
|
|
251
|
+
for (const p of picks.slice(1)) {
|
|
252
|
+
if (p.endpoint.name !== first.endpoint.name) {
|
|
253
|
+
throw new EndpointConfigError(`conflicting endpoints: ${first.from} vs ${p.from}; name one endpoint per call`);
|
|
254
|
+
}
|
|
255
|
+
}
|
|
256
|
+
if (token && leaseNamespace(first.endpoint) !== token.ns) {
|
|
257
|
+
throw new EndpointConfigError(`conflicting endpoints: ${first.from} vs the lease token, which belongs to ${token.ns === undefined ? "the default endpoint" : `endpoint '${token.ns}'`}; name one endpoint per call`);
|
|
258
|
+
}
|
|
259
|
+
return { endpoint: first.endpoint, args: out ?? a };
|
|
260
|
+
}
|
|
261
|
+
function leaseTokenNamespace(lease) {
|
|
262
|
+
if (typeof lease !== "string")
|
|
263
|
+
return null;
|
|
264
|
+
const colon = lease.indexOf(":");
|
|
265
|
+
if (colon <= 0)
|
|
266
|
+
return null;
|
|
267
|
+
const head = lease.slice(0, colon);
|
|
268
|
+
if (head === "chrome")
|
|
269
|
+
return { ns: undefined };
|
|
270
|
+
if (!head.startsWith("chrome@"))
|
|
271
|
+
return null;
|
|
272
|
+
const ns = head.slice("chrome@".length);
|
|
273
|
+
return NAME_RE.test(ns) ? { ns } : null;
|
|
274
|
+
}
|
|
275
|
+
function endpointForNamespace(ns) {
|
|
276
|
+
for (const ep of endpointConfig().byName.values())
|
|
277
|
+
if (leaseNamespace(ep) === ns)
|
|
278
|
+
return ep;
|
|
279
|
+
throw new EndpointConfigError(`the lease token belongs to endpoint '${ns}', which is not configured (known: ${[...endpointConfig().byName.keys()].join(", ")})`);
|
|
280
|
+
}
|
|
281
|
+
function currentEndpoint() {
|
|
282
|
+
return endpointScope.getStore() ?? defaultEndpoint();
|
|
283
|
+
}
|
|
284
|
+
function isDefaultEndpoint(ep) {
|
|
285
|
+
return ep.name === defaultEndpoint().name;
|
|
286
|
+
}
|
|
287
|
+
function withEndpointScope(ep, fn) {
|
|
288
|
+
return endpointScope.run(ep, fn);
|
|
289
|
+
}
|
|
290
|
+
var EndpointConfigError, DEFAULT_CDP_BASE = "http://127.0.0.1:9222", ENDPOINT_PREFIX = "endpoint:", NAME_RE, cache, SELECTOR_KEYS, ENDPOINTS_FIREFOX_MESSAGE = "named CDP endpoints (an 'endpoint:<name>/' selector prefix, the endpoint arg, list_pages allEndpoints) need the Chrome backend; the Firefox BiDi backend has one session and no endpoints", endpointScope;
|
|
291
|
+
var init_endpoints = __esm(() => {
|
|
292
|
+
EndpointConfigError = class EndpointConfigError extends Error {
|
|
293
|
+
constructor(message) {
|
|
294
|
+
super(message);
|
|
295
|
+
this.name = "EndpointConfigError";
|
|
296
|
+
}
|
|
297
|
+
};
|
|
298
|
+
NAME_RE = /^[A-Za-z0-9_]+$/;
|
|
299
|
+
SELECTOR_KEYS = ["target", "targetId"];
|
|
300
|
+
endpointScope = new AsyncLocalStorage;
|
|
301
|
+
});
|
|
302
|
+
|
|
303
|
+
// src/leases.ts
|
|
304
|
+
import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
|
|
15
305
|
import { randomBytes } from "node:crypto";
|
|
16
306
|
import { mkdir, readFile, readdir, unlink, writeFile } from "node:fs/promises";
|
|
17
307
|
import { join } from "node:path";
|
|
308
|
+
function chromeLeaseBackend(ep = currentEndpoint()) {
|
|
309
|
+
const ns = leaseNamespace(ep);
|
|
310
|
+
return ns === undefined ? "chrome" : `chrome@${ns}`;
|
|
311
|
+
}
|
|
312
|
+
function isLeaseBackend(value) {
|
|
313
|
+
return BACKEND_KEY_RE.test(value);
|
|
314
|
+
}
|
|
18
315
|
function leaseDir() {
|
|
19
316
|
return process.env.CDP_ARTIFACT_DIR ?? "/tmp/cdp-toolkit";
|
|
20
317
|
}
|
|
@@ -51,7 +348,7 @@ function tokenParts(token) {
|
|
|
51
348
|
if (first <= 0 || last <= first)
|
|
52
349
|
return;
|
|
53
350
|
const backend = token.slice(0, first);
|
|
54
|
-
if (backend
|
|
351
|
+
if (!isLeaseBackend(backend))
|
|
55
352
|
return;
|
|
56
353
|
const targetId = token.slice(first + 1, last);
|
|
57
354
|
const nonce = token.slice(last + 1);
|
|
@@ -272,8 +569,10 @@ async function listLeases(opts = {}) {
|
|
|
272
569
|
}
|
|
273
570
|
return out;
|
|
274
571
|
}
|
|
275
|
-
var DEFAULT_LEASE_TTL_MS = 900000, longLived = false, LeaseConflictError, leaseScope, LEASE_FILE_RE;
|
|
572
|
+
var BACKEND_KEY_SOURCE = "chrome@[A-Za-z0-9_]+|chrome|firefox", BACKEND_KEY_RE, DEFAULT_LEASE_TTL_MS = 900000, longLived = false, LeaseConflictError, leaseScope, LEASE_FILE_RE;
|
|
276
573
|
var init_leases = __esm(() => {
|
|
574
|
+
init_endpoints();
|
|
575
|
+
BACKEND_KEY_RE = new RegExp(`^(?:${BACKEND_KEY_SOURCE})$`);
|
|
277
576
|
LeaseConflictError = class LeaseConflictError extends Error {
|
|
278
577
|
targetId;
|
|
279
578
|
holder;
|
|
@@ -284,8 +583,8 @@ var init_leases = __esm(() => {
|
|
|
284
583
|
this.name = "LeaseConflictError";
|
|
285
584
|
}
|
|
286
585
|
};
|
|
287
|
-
leaseScope = new
|
|
288
|
-
LEASE_FILE_RE =
|
|
586
|
+
leaseScope = new AsyncLocalStorage2;
|
|
587
|
+
LEASE_FILE_RE = new RegExp(`^lease-(${BACKEND_KEY_SOURCE})-(.+)\\.json$`);
|
|
289
588
|
});
|
|
290
589
|
|
|
291
590
|
// src/bidi/session-lease.ts
|
|
@@ -632,7 +931,7 @@ async function resolveLiveLabel(backend, label, liveIds) {
|
|
|
632
931
|
var ORIGIN_FILE_RE;
|
|
633
932
|
var init_origins = __esm(() => {
|
|
634
933
|
init_leases();
|
|
635
|
-
ORIGIN_FILE_RE =
|
|
934
|
+
ORIGIN_FILE_RE = new RegExp(`^origin-(${BACKEND_KEY_SOURCE})-(.+)\\.json$`);
|
|
636
935
|
});
|
|
637
936
|
|
|
638
937
|
// src/workers.ts
|
|
@@ -1704,119 +2003,7 @@ function buildSnapshotFunctionSource() {
|
|
|
1704
2003
|
return true;
|
|
1705
2004
|
}
|
|
1706
2005
|
|
|
1707
|
-
|
|
1708
|
-
s = s.trim().replace(/\\s+/g, " ");
|
|
1709
|
-
if (s.length > MAX_NAME_LENGTH) return s.slice(0, MAX_NAME_LENGTH - 1) + "\\u2026";
|
|
1710
|
-
return s;
|
|
1711
|
-
}
|
|
1712
|
-
|
|
1713
|
-
function textOf(el) {
|
|
1714
|
-
return el.textContent || "";
|
|
1715
|
-
}
|
|
1716
|
-
|
|
1717
|
-
function idRefsText(doc, ids) {
|
|
1718
|
-
var parts = [];
|
|
1719
|
-
var list = ids.trim().split(/\\s+/);
|
|
1720
|
-
for (var i = 0; i < list.length; i++) {
|
|
1721
|
-
var ref = doc.getElementById(list[i]);
|
|
1722
|
-
if (ref) parts.push(textOf(ref));
|
|
1723
|
-
}
|
|
1724
|
-
return parts.join(" ").trim();
|
|
1725
|
-
}
|
|
1726
|
-
|
|
1727
|
-
// Text of a <label>, minus any nested form control's own content: a
|
|
1728
|
-
// label that WRAPS its control ("<label>Color <select>...</select></label>")
|
|
1729
|
-
// would otherwise include every option's text in the control's own name.
|
|
1730
|
-
function labelOwnText(label) {
|
|
1731
|
-
var clone = label.cloneNode(true);
|
|
1732
|
-
var controls = clone.querySelectorAll("input, select, textarea, button");
|
|
1733
|
-
for (var i = 0; i < controls.length; i++) {
|
|
1734
|
-
controls[i].parentNode.removeChild(controls[i]);
|
|
1735
|
-
}
|
|
1736
|
-
return textOf(clone);
|
|
1737
|
-
}
|
|
1738
|
-
|
|
1739
|
-
// Guard: without this, an <option> inside a labelled <select> would
|
|
1740
|
-
// inherit the select's own label via closest("label"), not its text.
|
|
1741
|
-
var LABELABLE_TAGS = { INPUT: 1, TEXTAREA: 1, SELECT: 1, BUTTON: 1, METER: 1, OUTPUT: 1, PROGRESS: 1 };
|
|
1742
|
-
|
|
1743
|
-
function nativeLabelText(el) {
|
|
1744
|
-
if (!LABELABLE_TAGS[el.tagName]) return "";
|
|
1745
|
-
var doc = el.ownerDocument;
|
|
1746
|
-
if (el.id) {
|
|
1747
|
-
var forLabel = doc.querySelector('label[for="' + el.id + '"]');
|
|
1748
|
-
if (forLabel) return labelOwnText(forLabel);
|
|
1749
|
-
}
|
|
1750
|
-
var ancestor = el.closest ? el.closest("label") : null;
|
|
1751
|
-
if (ancestor) return labelOwnText(ancestor);
|
|
1752
|
-
return "";
|
|
1753
|
-
}
|
|
1754
|
-
|
|
1755
|
-
// Reduced accname: aria-labelledby, then aria-label, then native label,
|
|
1756
|
-
// then alt/title/placeholder, then trimmed own text for content-named
|
|
1757
|
-
// elements. Not the full W3C accname algorithm (no recursive traversal
|
|
1758
|
-
// rules for nested presentational content) but covers the common cases.
|
|
1759
|
-
function accessibleName(el, contentNamed) {
|
|
1760
|
-
var doc = el.ownerDocument;
|
|
1761
|
-
var labelledby = el.getAttribute("aria-labelledby");
|
|
1762
|
-
if (labelledby) {
|
|
1763
|
-
var viaIds = idRefsText(doc, labelledby);
|
|
1764
|
-
if (viaIds) return truncate(viaIds);
|
|
1765
|
-
}
|
|
1766
|
-
var ariaLabel = el.getAttribute("aria-label");
|
|
1767
|
-
if (ariaLabel && ariaLabel.trim()) return truncate(ariaLabel);
|
|
1768
|
-
var native = nativeLabelText(el);
|
|
1769
|
-
if (native && native.trim()) return truncate(native);
|
|
1770
|
-
var alt = el.getAttribute("alt");
|
|
1771
|
-
if (alt && alt.trim()) return truncate(alt);
|
|
1772
|
-
var title = el.getAttribute("title");
|
|
1773
|
-
if (title && title.trim()) return truncate(title);
|
|
1774
|
-
var placeholder = el.getAttribute("placeholder");
|
|
1775
|
-
if (placeholder && placeholder.trim()) return truncate(placeholder);
|
|
1776
|
-
if (contentNamed) {
|
|
1777
|
-
var text = textOf(el);
|
|
1778
|
-
if (text && text.trim()) return truncate(text);
|
|
1779
|
-
}
|
|
1780
|
-
return "";
|
|
1781
|
-
}
|
|
1782
|
-
|
|
1783
|
-
var IMPLICIT_ROLE_BY_TAG = {
|
|
1784
|
-
A: "link", BUTTON: "button", NAV: "navigation", MAIN: "main", FORM: "form", DIALOG: "dialog",
|
|
1785
|
-
UL: "list", OL: "list", LI: "listitem", TABLE: "table", TR: "row", TD: "cell", TH: "columnheader",
|
|
1786
|
-
SELECT: "combobox", OPTION: "option", TEXTAREA: "textbox", IMG: "img",
|
|
1787
|
-
H1: "heading", H2: "heading", H3: "heading", H4: "heading", H5: "heading", H6: "heading",
|
|
1788
|
-
PROGRESS: "progressbar", METER: "meter"
|
|
1789
|
-
};
|
|
1790
|
-
|
|
1791
|
-
var INPUT_TYPE_ROLE = {
|
|
1792
|
-
button: "button", submit: "button", reset: "button", checkbox: "checkbox", radio: "radio",
|
|
1793
|
-
range: "slider", number: "spinbutton", search: "searchbox", email: "textbox", tel: "textbox",
|
|
1794
|
-
url: "textbox", password: "textbox", text: "textbox", image: "button"
|
|
1795
|
-
};
|
|
1796
|
-
|
|
1797
|
-
var CONTENT_NAMED_ROLES = {
|
|
1798
|
-
button: true, link: true, heading: true, option: true, cell: true,
|
|
1799
|
-
columnheader: true, listitem: true, menuitem: true, tab: true
|
|
1800
|
-
};
|
|
1801
|
-
|
|
1802
|
-
function implicitRole(el) {
|
|
1803
|
-
var explicit = el.getAttribute("role");
|
|
1804
|
-
if (explicit) return explicit;
|
|
1805
|
-
var tag = el.tagName;
|
|
1806
|
-
if (tag === "INPUT") {
|
|
1807
|
-
var type = (el.getAttribute("type") || "text").toLowerCase();
|
|
1808
|
-
return INPUT_TYPE_ROLE[type] || "textbox";
|
|
1809
|
-
}
|
|
1810
|
-
if (tag === "A" && !el.getAttribute("href")) return "";
|
|
1811
|
-
if (Object.prototype.hasOwnProperty.call(IMPLICIT_ROLE_BY_TAG, tag)) {
|
|
1812
|
-
return IMPLICIT_ROLE_BY_TAG[tag];
|
|
1813
|
-
}
|
|
1814
|
-
// Deliberate divergence: Chrome's real AX tree says "generic" here,
|
|
1815
|
-
// but "textbox" is the useful signal an agent needs. Chrome is out of
|
|
1816
|
-
// step, do not "fix" this toward parity.
|
|
1817
|
-
if (el.isContentEditable) return "textbox";
|
|
1818
|
-
return "";
|
|
1819
|
-
}
|
|
2006
|
+
${ACCNAME_HELPERS_SOURCE}
|
|
1820
2007
|
|
|
1821
2008
|
function headingLevel(el) {
|
|
1822
2009
|
var m = /^H([1-6])$/.exec(el.tagName);
|
|
@@ -1958,7 +2145,319 @@ function buildSnapshotFunctionSource() {
|
|
|
1958
2145
|
return { snapshot: lines.join("\\n"), nodeCount: nodeCount };
|
|
1959
2146
|
}`;
|
|
1960
2147
|
}
|
|
1961
|
-
var STAMP_ATTR = "data-cdp-uid",
|
|
2148
|
+
var STAMP_ATTR = "data-cdp-uid", ACCNAME_HELPERS_SOURCE = `
|
|
2149
|
+
function truncate(s) {
|
|
2150
|
+
s = s.trim().replace(/\\s+/g, " ");
|
|
2151
|
+
if (s.length > MAX_NAME_LENGTH) return s.slice(0, MAX_NAME_LENGTH - 1) + "\\u2026";
|
|
2152
|
+
return s;
|
|
2153
|
+
}
|
|
2154
|
+
|
|
2155
|
+
function textOf(el) {
|
|
2156
|
+
return el.textContent || "";
|
|
2157
|
+
}
|
|
2158
|
+
|
|
2159
|
+
function idRefsText(doc, ids) {
|
|
2160
|
+
var parts = [];
|
|
2161
|
+
var list = ids.trim().split(/\\s+/);
|
|
2162
|
+
for (var i = 0; i < list.length; i++) {
|
|
2163
|
+
var ref = doc.getElementById(list[i]);
|
|
2164
|
+
if (ref) parts.push(textOf(ref));
|
|
2165
|
+
}
|
|
2166
|
+
return parts.join(" ").trim();
|
|
2167
|
+
}
|
|
2168
|
+
|
|
2169
|
+
// Text of a <label>, minus any nested form control's own content: a
|
|
2170
|
+
// label that WRAPS its control ("<label>Color <select>...</select></label>")
|
|
2171
|
+
// would otherwise include every option's text in the control's own name.
|
|
2172
|
+
function labelOwnText(label) {
|
|
2173
|
+
var clone = label.cloneNode(true);
|
|
2174
|
+
var controls = clone.querySelectorAll("input, select, textarea, button");
|
|
2175
|
+
for (var i = 0; i < controls.length; i++) {
|
|
2176
|
+
controls[i].parentNode.removeChild(controls[i]);
|
|
2177
|
+
}
|
|
2178
|
+
return textOf(clone);
|
|
2179
|
+
}
|
|
2180
|
+
|
|
2181
|
+
// Guard: without this, an <option> inside a labelled <select> would
|
|
2182
|
+
// inherit the select's own label via closest("label"), not its text.
|
|
2183
|
+
var LABELABLE_TAGS = { INPUT: 1, TEXTAREA: 1, SELECT: 1, BUTTON: 1, METER: 1, OUTPUT: 1, PROGRESS: 1 };
|
|
2184
|
+
|
|
2185
|
+
function nativeLabelText(el) {
|
|
2186
|
+
if (!LABELABLE_TAGS[el.tagName]) return "";
|
|
2187
|
+
var doc = el.ownerDocument;
|
|
2188
|
+
if (el.id) {
|
|
2189
|
+
var forLabel = doc.querySelector('label[for="' + el.id + '"]');
|
|
2190
|
+
if (forLabel) return labelOwnText(forLabel);
|
|
2191
|
+
}
|
|
2192
|
+
var ancestor = el.closest ? el.closest("label") : null;
|
|
2193
|
+
if (ancestor) return labelOwnText(ancestor);
|
|
2194
|
+
return "";
|
|
2195
|
+
}
|
|
2196
|
+
|
|
2197
|
+
// Reduced accname: aria-labelledby, then aria-label, then native label,
|
|
2198
|
+
// then alt/title/placeholder, then trimmed own text for content-named
|
|
2199
|
+
// elements. Not the full W3C accname algorithm (no recursive traversal
|
|
2200
|
+
// rules for nested presentational content) but covers the common cases.
|
|
2201
|
+
function accessibleName(el, contentNamed) {
|
|
2202
|
+
var doc = el.ownerDocument;
|
|
2203
|
+
var labelledby = el.getAttribute("aria-labelledby");
|
|
2204
|
+
if (labelledby) {
|
|
2205
|
+
var viaIds = idRefsText(doc, labelledby);
|
|
2206
|
+
if (viaIds) return truncate(viaIds);
|
|
2207
|
+
}
|
|
2208
|
+
var ariaLabel = el.getAttribute("aria-label");
|
|
2209
|
+
if (ariaLabel && ariaLabel.trim()) return truncate(ariaLabel);
|
|
2210
|
+
var native = nativeLabelText(el);
|
|
2211
|
+
if (native && native.trim()) return truncate(native);
|
|
2212
|
+
var alt = el.getAttribute("alt");
|
|
2213
|
+
if (alt && alt.trim()) return truncate(alt);
|
|
2214
|
+
var title = el.getAttribute("title");
|
|
2215
|
+
if (title && title.trim()) return truncate(title);
|
|
2216
|
+
var placeholder = el.getAttribute("placeholder");
|
|
2217
|
+
if (placeholder && placeholder.trim()) return truncate(placeholder);
|
|
2218
|
+
if (contentNamed) {
|
|
2219
|
+
var text = textOf(el);
|
|
2220
|
+
if (text && text.trim()) return truncate(text);
|
|
2221
|
+
}
|
|
2222
|
+
return "";
|
|
2223
|
+
}
|
|
2224
|
+
|
|
2225
|
+
var IMPLICIT_ROLE_BY_TAG = {
|
|
2226
|
+
A: "link", BUTTON: "button", NAV: "navigation", MAIN: "main", FORM: "form", DIALOG: "dialog",
|
|
2227
|
+
UL: "list", OL: "list", LI: "listitem", TABLE: "table", TR: "row", TD: "cell", TH: "columnheader",
|
|
2228
|
+
SELECT: "combobox", OPTION: "option", TEXTAREA: "textbox", IMG: "img",
|
|
2229
|
+
H1: "heading", H2: "heading", H3: "heading", H4: "heading", H5: "heading", H6: "heading",
|
|
2230
|
+
PROGRESS: "progressbar", METER: "meter"
|
|
2231
|
+
};
|
|
2232
|
+
|
|
2233
|
+
var INPUT_TYPE_ROLE = {
|
|
2234
|
+
button: "button", submit: "button", reset: "button", checkbox: "checkbox", radio: "radio",
|
|
2235
|
+
range: "slider", number: "spinbutton", search: "searchbox", email: "textbox", tel: "textbox",
|
|
2236
|
+
url: "textbox", password: "textbox", text: "textbox", image: "button"
|
|
2237
|
+
};
|
|
2238
|
+
|
|
2239
|
+
var CONTENT_NAMED_ROLES = {
|
|
2240
|
+
button: true, link: true, heading: true, option: true, cell: true,
|
|
2241
|
+
columnheader: true, listitem: true, menuitem: true, tab: true
|
|
2242
|
+
};
|
|
2243
|
+
|
|
2244
|
+
function implicitRole(el) {
|
|
2245
|
+
var explicit = el.getAttribute("role");
|
|
2246
|
+
if (explicit) return explicit;
|
|
2247
|
+
var tag = el.tagName;
|
|
2248
|
+
if (tag === "INPUT") {
|
|
2249
|
+
var type = (el.getAttribute("type") || "text").toLowerCase();
|
|
2250
|
+
return INPUT_TYPE_ROLE[type] || "textbox";
|
|
2251
|
+
}
|
|
2252
|
+
if (tag === "A" && !el.getAttribute("href")) return "";
|
|
2253
|
+
if (Object.prototype.hasOwnProperty.call(IMPLICIT_ROLE_BY_TAG, tag)) {
|
|
2254
|
+
return IMPLICIT_ROLE_BY_TAG[tag];
|
|
2255
|
+
}
|
|
2256
|
+
// Deliberate divergence: Chrome's real AX tree says "generic" here,
|
|
2257
|
+
// but "textbox" is the useful signal an agent needs. Chrome is out of
|
|
2258
|
+
// step, do not "fix" this toward parity.
|
|
2259
|
+
if (el.isContentEditable) return "textbox";
|
|
2260
|
+
return "";
|
|
2261
|
+
}
|
|
2262
|
+
`, MAX_NAME_LENGTH = 120;
|
|
2263
|
+
|
|
2264
|
+
// src/cdp/endpoint.ts
|
|
2265
|
+
import { readFile as readFile5 } from "node:fs/promises";
|
|
2266
|
+
import { join as join5 } from "node:path";
|
|
2267
|
+
async function browserWsFromPortFile(dir, base) {
|
|
2268
|
+
const raw = await readFile5(join5(dir, "DevToolsActivePort"), "utf8").catch(() => {
|
|
2269
|
+
return;
|
|
2270
|
+
});
|
|
2271
|
+
if (!raw)
|
|
2272
|
+
return;
|
|
2273
|
+
const [port, path] = raw.split(`
|
|
2274
|
+
`);
|
|
2275
|
+
if (!port?.trim() || !path?.trim())
|
|
2276
|
+
return;
|
|
2277
|
+
const host = new URL(base).hostname;
|
|
2278
|
+
return `ws://${host}:${port.trim()}${path.trim()}`;
|
|
2279
|
+
}
|
|
2280
|
+
async function discoverBrowserWs(base) {
|
|
2281
|
+
const dir = process.env.CDP_USER_DATA_DIR;
|
|
2282
|
+
return dir ? browserWsFromPortFile(dir, base) : undefined;
|
|
2283
|
+
}
|
|
2284
|
+
async function handshake(url, timeoutMs) {
|
|
2285
|
+
const conn = new CdpConnection(url, { timeoutMs });
|
|
2286
|
+
try {
|
|
2287
|
+
await conn.connect();
|
|
2288
|
+
return true;
|
|
2289
|
+
} catch {
|
|
2290
|
+
return false;
|
|
2291
|
+
} finally {
|
|
2292
|
+
conn.close();
|
|
2293
|
+
}
|
|
2294
|
+
}
|
|
2295
|
+
function detectEndpoint() {
|
|
2296
|
+
const endpoint = currentEndpoint();
|
|
2297
|
+
const base = endpoint.base;
|
|
2298
|
+
const isDefault = isDefaultEndpoint(endpoint);
|
|
2299
|
+
const hit = cached.get(base);
|
|
2300
|
+
if (hit)
|
|
2301
|
+
return hit;
|
|
2302
|
+
const detection = (async () => {
|
|
2303
|
+
const forced = isDefault ? process.env.CDP_BROWSER_WS : undefined;
|
|
2304
|
+
if (forced)
|
|
2305
|
+
return { transport: "browser-ws", browserWsUrl: forced };
|
|
2306
|
+
const discovered = isDefault ? await discoverBrowserWs(base) : undefined;
|
|
2307
|
+
if (discovered && await handshake(discovered, 5000)) {
|
|
2308
|
+
return { transport: "browser-ws", browserWsUrl: discovered };
|
|
2309
|
+
}
|
|
2310
|
+
const version = await fetch(`${base}/json/version`, { signal: AbortSignal.timeout(5000) }).then((r) => r.ok ? r.json() : undefined).catch(() => {
|
|
2311
|
+
return;
|
|
2312
|
+
});
|
|
2313
|
+
if (version?.webSocketDebuggerUrl) {
|
|
2314
|
+
return { transport: "http", browserWsUrl: version.webSocketDebuggerUrl };
|
|
2315
|
+
}
|
|
2316
|
+
const dir = isDefault ? process.env.CDP_USER_DATA_DIR : undefined;
|
|
2317
|
+
throw new Error(`no DevTools endpoint at ${base}: GET /json/version did not answer and ` + (dir ? `no live browser socket was named by ${dir}/DevToolsActivePort. ` : `no profile was searched — CDP_USER_DATA_DIR is unset, and no profile is ever scanned unless you name one. `) + `Set CDP_BROWSER_WS to the ws://.../devtools/browser/<uuid> URL, or CDP_USER_DATA_DIR to the profile in use.`);
|
|
2318
|
+
})().then((info) => {
|
|
2319
|
+
if (info.transport === "http")
|
|
2320
|
+
cached.delete(base);
|
|
2321
|
+
return info;
|
|
2322
|
+
}, (error) => {
|
|
2323
|
+
cached.delete(base);
|
|
2324
|
+
throw error;
|
|
2325
|
+
});
|
|
2326
|
+
cached.set(base, detection);
|
|
2327
|
+
return detection;
|
|
2328
|
+
}
|
|
2329
|
+
function forgetEndpoint() {
|
|
2330
|
+
cached.delete(currentEndpoint().base);
|
|
2331
|
+
}
|
|
2332
|
+
var cached;
|
|
2333
|
+
var init_endpoint = __esm(() => {
|
|
2334
|
+
init_endpoints();
|
|
2335
|
+
init_client2();
|
|
2336
|
+
cached = new Map;
|
|
2337
|
+
});
|
|
2338
|
+
|
|
2339
|
+
// src/cdp/session.ts
|
|
2340
|
+
async function acquireBrowserConn() {
|
|
2341
|
+
if (shared) {
|
|
2342
|
+
shared.refs++;
|
|
2343
|
+
return shared.conn;
|
|
2344
|
+
}
|
|
2345
|
+
if (!opening) {
|
|
2346
|
+
opening = (async () => {
|
|
2347
|
+
let { browserWsUrl } = await detectEndpoint();
|
|
2348
|
+
let conn;
|
|
2349
|
+
try {
|
|
2350
|
+
conn = await new CdpConnection(browserWsUrl).connect();
|
|
2351
|
+
} catch (error) {
|
|
2352
|
+
forgetEndpoint();
|
|
2353
|
+
const fresh = (await detectEndpoint().catch(() => {
|
|
2354
|
+
return;
|
|
2355
|
+
}))?.browserWsUrl;
|
|
2356
|
+
if (!fresh || fresh === browserWsUrl)
|
|
2357
|
+
throw error;
|
|
2358
|
+
browserWsUrl = fresh;
|
|
2359
|
+
conn = await new CdpConnection(browserWsUrl).connect();
|
|
2360
|
+
}
|
|
2361
|
+
shared = { conn, refs: 0, url: browserWsUrl };
|
|
2362
|
+
return conn;
|
|
2363
|
+
})().finally(() => {
|
|
2364
|
+
opening = undefined;
|
|
2365
|
+
});
|
|
2366
|
+
}
|
|
2367
|
+
const conn = await opening;
|
|
2368
|
+
shared.refs++;
|
|
2369
|
+
return conn;
|
|
2370
|
+
}
|
|
2371
|
+
function releaseBrowserConn() {
|
|
2372
|
+
if (!shared)
|
|
2373
|
+
return;
|
|
2374
|
+
shared.refs--;
|
|
2375
|
+
if (shared.refs <= 0) {
|
|
2376
|
+
const { conn } = shared;
|
|
2377
|
+
shared = undefined;
|
|
2378
|
+
conn.close();
|
|
2379
|
+
}
|
|
2380
|
+
}
|
|
2381
|
+
async function withBrowserSocket(fn) {
|
|
2382
|
+
const conn = await acquireBrowserConn();
|
|
2383
|
+
try {
|
|
2384
|
+
return await fn(conn);
|
|
2385
|
+
} finally {
|
|
2386
|
+
releaseBrowserConn();
|
|
2387
|
+
}
|
|
2388
|
+
}
|
|
2389
|
+
|
|
2390
|
+
class SessionConnection {
|
|
2391
|
+
browser;
|
|
2392
|
+
sessionId;
|
|
2393
|
+
opts;
|
|
2394
|
+
detached = false;
|
|
2395
|
+
offs = [];
|
|
2396
|
+
constructor(browser, sessionId, opts = {}) {
|
|
2397
|
+
this.browser = browser;
|
|
2398
|
+
this.sessionId = sessionId;
|
|
2399
|
+
this.opts = opts;
|
|
2400
|
+
}
|
|
2401
|
+
send(method, params = {}, opts = {}) {
|
|
2402
|
+
if (this.detached)
|
|
2403
|
+
return Promise.reject(new CdpError("connection not open"));
|
|
2404
|
+
return this.browser.send(method, params, {
|
|
2405
|
+
timeoutMs: opts.timeoutMs ?? this.opts.timeoutMs,
|
|
2406
|
+
sessionId: opts.sessionId ?? this.sessionId
|
|
2407
|
+
});
|
|
2408
|
+
}
|
|
2409
|
+
on(method, handler) {
|
|
2410
|
+
const off = this.browser.on(method, (params, sessionId) => {
|
|
2411
|
+
if (sessionId && sessionId !== this.sessionId)
|
|
2412
|
+
return;
|
|
2413
|
+
handler(params, sessionId);
|
|
2414
|
+
});
|
|
2415
|
+
this.offs.push(off);
|
|
2416
|
+
return off;
|
|
2417
|
+
}
|
|
2418
|
+
waitFor(method, predicate, timeoutMs = this.opts.timeoutMs ?? DEFAULT_TIMEOUT_MS3) {
|
|
2419
|
+
return new Promise((resolve, reject) => {
|
|
2420
|
+
const timer = setTimeout(() => {
|
|
2421
|
+
off();
|
|
2422
|
+
reject(new CdpError(`waitFor('${method}') timed out after ${timeoutMs}ms`));
|
|
2423
|
+
}, timeoutMs);
|
|
2424
|
+
const off = this.on(method, (params) => {
|
|
2425
|
+
if (!predicate || predicate(params)) {
|
|
2426
|
+
clearTimeout(timer);
|
|
2427
|
+
off();
|
|
2428
|
+
resolve(params);
|
|
2429
|
+
}
|
|
2430
|
+
});
|
|
2431
|
+
});
|
|
2432
|
+
}
|
|
2433
|
+
close() {
|
|
2434
|
+
if (this.detached)
|
|
2435
|
+
return;
|
|
2436
|
+
this.detached = true;
|
|
2437
|
+
for (const off of this.offs)
|
|
2438
|
+
off();
|
|
2439
|
+
this.offs.length = 0;
|
|
2440
|
+
this.browser.send("Target.detachFromTarget", { sessionId: this.sessionId }).catch(() => {});
|
|
2441
|
+
releaseBrowserConn();
|
|
2442
|
+
}
|
|
2443
|
+
}
|
|
2444
|
+
async function openSession(targetId, opts = {}) {
|
|
2445
|
+
const browser = await acquireBrowserConn();
|
|
2446
|
+
try {
|
|
2447
|
+
const { sessionId } = await browser.send("Target.attachToTarget", { targetId, flatten: true }, { timeoutMs: opts.timeoutMs });
|
|
2448
|
+
if (!sessionId)
|
|
2449
|
+
throw new CdpError(`Target.attachToTarget returned no sessionId for ${targetId}`);
|
|
2450
|
+
return new SessionConnection(browser, sessionId, opts);
|
|
2451
|
+
} catch (e) {
|
|
2452
|
+
releaseBrowserConn();
|
|
2453
|
+
throw e;
|
|
2454
|
+
}
|
|
2455
|
+
}
|
|
2456
|
+
var shared, opening;
|
|
2457
|
+
var init_session = __esm(() => {
|
|
2458
|
+
init_client2();
|
|
2459
|
+
init_endpoint();
|
|
2460
|
+
});
|
|
1962
2461
|
|
|
1963
2462
|
// src/client.ts
|
|
1964
2463
|
class CdpConnection {
|
|
@@ -2087,24 +2586,59 @@ class CdpConnection {
|
|
|
2087
2586
|
}
|
|
2088
2587
|
}
|
|
2089
2588
|
async function httpJson(path) {
|
|
2090
|
-
const res = await fetch(`${
|
|
2589
|
+
const res = await fetch(`${currentEndpoint().base}${path}`);
|
|
2091
2590
|
if (!res.ok)
|
|
2092
2591
|
throw new CdpError(`${path} -> HTTP ${res.status}`);
|
|
2093
2592
|
return await res.json();
|
|
2094
2593
|
}
|
|
2095
|
-
function
|
|
2096
|
-
|
|
2594
|
+
async function getTargetsOverBrowserWs() {
|
|
2595
|
+
const { targetInfos } = await withBrowserSocket((conn) => conn.send("Target.getTargets", { filter: [{}] }));
|
|
2596
|
+
return targetInfos.map((t) => ({
|
|
2597
|
+
id: t.targetId,
|
|
2598
|
+
type: t.type,
|
|
2599
|
+
title: t.title,
|
|
2600
|
+
url: t.url,
|
|
2601
|
+
webSocketDebuggerUrl: "",
|
|
2602
|
+
...t.openerId ? { parentId: t.openerId } : {}
|
|
2603
|
+
}));
|
|
2604
|
+
}
|
|
2605
|
+
async function listTargets() {
|
|
2606
|
+
const base = currentEndpoint().base;
|
|
2607
|
+
if (knownTransports.get(base) === "browser-ws")
|
|
2608
|
+
return getTargetsOverBrowserWs();
|
|
2609
|
+
try {
|
|
2610
|
+
const listing = await httpJson("/json/list");
|
|
2611
|
+
knownTransports.set(base, "http");
|
|
2612
|
+
return listing;
|
|
2613
|
+
} catch (httpError) {
|
|
2614
|
+
const detected = await detectEndpoint().catch(() => {
|
|
2615
|
+
return;
|
|
2616
|
+
});
|
|
2617
|
+
if (detected?.transport !== "browser-ws")
|
|
2618
|
+
throw httpError;
|
|
2619
|
+
const targets = await getTargetsOverBrowserWs().catch(() => {
|
|
2620
|
+
throw httpError;
|
|
2621
|
+
});
|
|
2622
|
+
knownTransports.set(base, "browser-ws");
|
|
2623
|
+
return targets;
|
|
2624
|
+
}
|
|
2097
2625
|
}
|
|
2098
2626
|
async function browserWsUrl() {
|
|
2099
|
-
|
|
2100
|
-
|
|
2627
|
+
if (knownTransports.get(currentEndpoint().base) !== "browser-ws") {
|
|
2628
|
+
const version = await httpJson("/json/version").catch(() => {
|
|
2629
|
+
return;
|
|
2630
|
+
});
|
|
2631
|
+
if (version?.webSocketDebuggerUrl)
|
|
2632
|
+
return version.webSocketDebuggerUrl;
|
|
2633
|
+
}
|
|
2634
|
+
return (await detectEndpoint()).browserWsUrl;
|
|
2101
2635
|
}
|
|
2102
2636
|
async function resolveTarget(selector, opts = {}) {
|
|
2103
2637
|
const targets = await listTargets();
|
|
2104
2638
|
const hit = await pickTarget(targets, selector);
|
|
2105
2639
|
if (isWorkerTargetType(hit.type))
|
|
2106
2640
|
return hit;
|
|
2107
|
-
await assertLeaseOk(
|
|
2641
|
+
await assertLeaseOk(chromeLeaseBackend(), hit.id, { lease: opts.lease, url: hit.url, title: hit.title });
|
|
2108
2642
|
return hit;
|
|
2109
2643
|
}
|
|
2110
2644
|
async function pickTarget(targets, selector) {
|
|
@@ -2136,7 +2670,7 @@ async function pickTarget(targets, selector) {
|
|
|
2136
2670
|
}
|
|
2137
2671
|
if (selector.startsWith("label:")) {
|
|
2138
2672
|
const label = selector.slice(6);
|
|
2139
|
-
const { matchIds, knownLabels } = await resolveLiveLabel(
|
|
2673
|
+
const { matchIds, knownLabels } = await resolveLiveLabel(chromeLeaseBackend(), label, pages.map((t) => t.id));
|
|
2140
2674
|
if (matchIds.length > 1) {
|
|
2141
2675
|
throw new CdpError(`label 'label:${label}' matches more than one live target: ${matchIds.join(", ")}. Resolve by target id instead.`);
|
|
2142
2676
|
}
|
|
@@ -2179,7 +2713,7 @@ async function openBrowser(opts = {}) {
|
|
|
2179
2713
|
}
|
|
2180
2714
|
async function openPage(selector, opts = {}) {
|
|
2181
2715
|
const target = await resolveTarget(selector, { lease: opts.lease });
|
|
2182
|
-
const conn = await new CdpConnection(target.webSocketDebuggerUrl, opts).connect();
|
|
2716
|
+
const conn = target.webSocketDebuggerUrl ? await new CdpConnection(target.webSocketDebuggerUrl, opts).connect() : await openSession(target.id, opts);
|
|
2183
2717
|
return { conn, target };
|
|
2184
2718
|
}
|
|
2185
2719
|
async function withPage(selector, fn, opts = {}) {
|
|
@@ -2190,13 +2724,23 @@ async function withPage(selector, fn, opts = {}) {
|
|
|
2190
2724
|
conn.close();
|
|
2191
2725
|
}
|
|
2192
2726
|
}
|
|
2193
|
-
var BASE, DEFAULT_TIMEOUT_MS3, CdpError;
|
|
2727
|
+
var BASE, DEFAULT_TIMEOUT_MS3, CdpError, knownTransports;
|
|
2194
2728
|
var init_client2 = __esm(() => {
|
|
2195
2729
|
init_leases();
|
|
2196
2730
|
init_origins();
|
|
2731
|
+
init_endpoints();
|
|
2197
2732
|
init_workers();
|
|
2198
2733
|
init_frames();
|
|
2199
|
-
|
|
2734
|
+
init_endpoint();
|
|
2735
|
+
init_session();
|
|
2736
|
+
init_session();
|
|
2737
|
+
BASE = (() => {
|
|
2738
|
+
try {
|
|
2739
|
+
return defaultEndpoint().base;
|
|
2740
|
+
} catch {
|
|
2741
|
+
return process.env.CDP_BASE ?? DEFAULT_CDP_BASE;
|
|
2742
|
+
}
|
|
2743
|
+
})();
|
|
2200
2744
|
DEFAULT_TIMEOUT_MS3 = Number(process.env.CDP_TIMEOUT_MS ?? 15000);
|
|
2201
2745
|
CdpError = class CdpError extends Error {
|
|
2202
2746
|
code;
|
|
@@ -2208,6 +2752,7 @@ var init_client2 = __esm(() => {
|
|
|
2208
2752
|
this.name = "CdpError";
|
|
2209
2753
|
}
|
|
2210
2754
|
};
|
|
2755
|
+
knownTransports = new Map;
|
|
2211
2756
|
});
|
|
2212
2757
|
|
|
2213
2758
|
// src/tools/network_mock.ts
|