Lyon
2164 lines
108 KiB
TypeScript
2164 lines
108 KiB
TypeScript
// SPEC: PJ2026-01040111 长程观测 draft-2026-06-20-p0-passive-web-probe-observer.
|
||
// Responsibility: Source string for the pure-client HWLAB web-probe observer runner.
|
||
import { nodeWebObserveRunnerCommandActionsSource } from "./hwlab-node-web-observe-runner-actions-source";
|
||
|
||
export function nodeWebObserveRunnerSource(): string {
|
||
return String.raw`#!/usr/bin/env node
|
||
import { createHash, randomBytes } from "node:crypto";
|
||
import { appendFile, mkdir, readFile, readdir, rename, stat, unlink, writeFile } from "node:fs/promises";
|
||
import path from "node:path";
|
||
import { pathToFileURL } from "node:url";
|
||
|
||
const specRef = "PJ2026-01040111 长程观测 draft-2026-06-20-p0-passive-web-probe-observer";
|
||
const startedAtMs = Date.now();
|
||
const startedAt = new Date(startedAtMs).toISOString();
|
||
const baseUrl = normalizeBaseUrl(process.env.HWLAB_WEB_BASE_URL);
|
||
const username = process.env.HWLAB_WEB_USER || "admin";
|
||
const password = process.env.HWLAB_WEB_PASS || "";
|
||
const stateDir = path.resolve(process.env.UNIDESK_WEB_OBSERVE_STATE_DIR || ".state/web-observe/manual");
|
||
const jobId = safeId(process.env.UNIDESK_WEB_OBSERVE_JOB_ID || "webobs-" + Date.now().toString(36) + "-" + randomBytes(3).toString("hex"));
|
||
const targetPath = process.env.UNIDESK_WEB_OBSERVE_TARGET_PATH || "/workbench";
|
||
const sampleIntervalMs = positiveInteger(process.env.UNIDESK_WEB_OBSERVE_SAMPLE_INTERVAL_MS, 5000);
|
||
const screenshotIntervalMs = positiveInteger(process.env.UNIDESK_WEB_OBSERVE_SCREENSHOT_INTERVAL_MS, 300000);
|
||
const maxSamples = positiveInteger(process.env.UNIDESK_WEB_OBSERVE_MAX_SAMPLES, 0);
|
||
const observerRefreshIntervalMs = positiveInteger(process.env.UNIDESK_WEB_OBSERVE_OBSERVER_REFRESH_INTERVAL_MS, 180000);
|
||
const viewport = parseViewport(process.env.UNIDESK_WEB_OBSERVE_VIEWPORT || "1440x900");
|
||
const browserProxyMode = parseBrowserProxyMode(process.env.UNIDESK_WEB_OBSERVE_BROWSER_PROXY_MODE || "auto");
|
||
const alertThresholds = parseAlertThresholds(process.env.UNIDESK_WEB_OBSERVE_ALERT_THRESHOLDS_JSON);
|
||
const playwrightProxy = proxyConfigFromEnv(baseUrl);
|
||
const chromiumLaunchOptions = chromiumLaunchOptionsForProxy(playwrightProxy);
|
||
const pageId = "control-" + randomBytes(4).toString("hex");
|
||
const observerPageId = "observer-" + randomBytes(4).toString("hex");
|
||
const dirs = {
|
||
commandsPending: path.join(stateDir, "commands", "pending"),
|
||
commandsProcessing: path.join(stateDir, "commands", "processing"),
|
||
commandsDone: path.join(stateDir, "commands", "done"),
|
||
commandsFailed: path.join(stateDir, "commands", "failed"),
|
||
screenshots: path.join(stateDir, "screenshots"),
|
||
analysis: path.join(stateDir, "analysis"),
|
||
archive: path.join(stateDir, "archive"),
|
||
};
|
||
const files = {
|
||
manifest: path.join(stateDir, "manifest.json"),
|
||
heartbeat: path.join(stateDir, "heartbeat.json"),
|
||
control: path.join(stateDir, "control.jsonl"),
|
||
samples: path.join(stateDir, "samples.jsonl"),
|
||
network: path.join(stateDir, "network.jsonl"),
|
||
console: path.join(stateDir, "console.jsonl"),
|
||
errors: path.join(stateDir, "errors.jsonl"),
|
||
artifacts: path.join(stateDir, "artifacts.jsonl"),
|
||
};
|
||
|
||
let browser;
|
||
let context;
|
||
let page;
|
||
let observerPage;
|
||
let lastObserverRefreshAtMs = Date.now();
|
||
let sampleSeq = 0;
|
||
let commandSeq = 0;
|
||
let artifactSeq = 0;
|
||
let activeCommandId = null;
|
||
let stopping = false;
|
||
let terminalStatus = "starting";
|
||
let lastScreenshotAtMs = 0;
|
||
let auth = null;
|
||
let pageLoadSeq = 0;
|
||
let controlPageEpoch = 0;
|
||
let observerPageEpoch = 0;
|
||
let currentPageProvenance = null;
|
||
const jsonlRotation = { stamp: compactFileTimestamp(startedAt), files: [] };
|
||
|
||
try {
|
||
if (!password) throw new Error("missing HWLAB_WEB_PASS");
|
||
await prepareDirs();
|
||
await rotateExistingJsonlArtifacts();
|
||
await writeManifest({ status: "starting" });
|
||
await writeHeartbeat({ status: "starting" });
|
||
if (jsonlRotation.files.length > 0) await appendJsonl(files.control, eventRecord("jsonl-rotated", { stamp: jsonlRotation.stamp, archiveDir: path.relative(stateDir, dirs.archive), files: jsonlRotation.files, valuesRedacted: true }));
|
||
const launcher = await import(pathToFileURL(path.resolve("scripts/src/browser-launcher.mjs")).href);
|
||
const { chromium } = await launcher.importPlaywright();
|
||
browser = await launcher.launchChromium(chromium, chromiumLaunchOptions);
|
||
context = await browser.newContext({ viewport, ...(playwrightProxy === null ? {} : { proxy: playwrightProxy }) });
|
||
page = await context.newPage();
|
||
attachPassiveListeners(page, "control", pageId);
|
||
auth = await runControlCommand({ id: "startup-login", type: "login", createdAt: startedAt, source: "startup" }, async () => authenticate(context, page));
|
||
await runControlCommand({ id: "startup-goto", type: "goto", path: targetPath, createdAt: new Date().toISOString(), source: "startup" }, async () => gotoTarget(targetPath));
|
||
observerPage = await context.newPage();
|
||
attachPassiveListeners(observerPage, "observer", observerPageId);
|
||
await runControlCommand({ id: "startup-observer-goto", type: "observerGoto", path: targetPath, createdAt: new Date().toISOString(), source: "startup" }, async () => {
|
||
const result = await syncObserverPageToControlSession("startup");
|
||
if (!result?.ok) {
|
||
await appendJsonl(files.control, eventRecord("observer-startup-degraded", {
|
||
reason: result?.failureKind || result?.reason || "observer-not-ready",
|
||
result: sanitize(result),
|
||
valuesRedacted: true,
|
||
}));
|
||
}
|
||
return result ?? { ok: false, reason: "observer-not-ready", pageRole: "observer", pageId: observerPageId, valuesRedacted: true };
|
||
});
|
||
terminalStatus = "running";
|
||
await writeManifest({ status: "running", auth: publicAuth(auth) });
|
||
await writeHeartbeat({ status: "running" });
|
||
while (!stopping) {
|
||
await drainOneCommand();
|
||
await samplePage("interval");
|
||
if (maxSamples > 0 && sampleSeq >= maxSamples) {
|
||
await appendJsonl(files.control, controlRecord({ id: "max-samples", type: "stop", source: "sampler" }, "completed", { reason: "max-samples", maxSamples }));
|
||
break;
|
||
}
|
||
await sleep(sampleIntervalMs);
|
||
}
|
||
terminalStatus = "completed";
|
||
await writeHeartbeat({ status: "completed" });
|
||
await writeManifest({ status: "completed", completedAt: new Date().toISOString() });
|
||
process.exitCode = 0;
|
||
} catch (error) {
|
||
terminalStatus = "failed";
|
||
await appendJsonl(files.errors, eventRecord("runner-error", { error: errorSummary(error) })).catch(() => {});
|
||
await writeHeartbeat({ status: "failed", error: errorSummary(error) }).catch(() => {});
|
||
await writeManifest({ status: "failed", error: errorSummary(error) }).catch(() => {});
|
||
process.exitCode = 2;
|
||
} finally {
|
||
if (browser) await browser.close().catch(() => {});
|
||
}
|
||
|
||
async function prepareDirs() {
|
||
await mkdir(stateDir, { recursive: true, mode: 0o700 });
|
||
await Promise.all(Object.values(dirs).map((dir) => mkdir(dir, { recursive: true, mode: 0o700 })));
|
||
}
|
||
|
||
async function rotateExistingJsonlArtifacts() {
|
||
for (const [key, file] of Object.entries(files)) {
|
||
if (!file.endsWith(".jsonl")) continue;
|
||
let meta = null;
|
||
try {
|
||
meta = await stat(file);
|
||
} catch (error) {
|
||
if (error?.code === "ENOENT") continue;
|
||
throw error;
|
||
}
|
||
if (!meta?.isFile()) continue;
|
||
const archiveFile = await uniqueArchiveFile(jsonlRotation.stamp + "-" + path.basename(file));
|
||
await rename(file, archiveFile);
|
||
jsonlRotation.files.push({ key, from: path.relative(stateDir, file), to: path.relative(stateDir, archiveFile), byteCount: meta.size });
|
||
}
|
||
}
|
||
|
||
async function uniqueArchiveFile(name) {
|
||
let candidate = path.join(dirs.archive, name);
|
||
const parsed = path.parse(name);
|
||
for (let index = 1; ; index += 1) {
|
||
try {
|
||
await stat(candidate);
|
||
candidate = path.join(dirs.archive, parsed.name + "-" + index + parsed.ext);
|
||
} catch (error) {
|
||
if (error?.code === "ENOENT") return candidate;
|
||
throw error;
|
||
}
|
||
}
|
||
}
|
||
|
||
function compactFileTimestamp(value) {
|
||
return new Date(value).toISOString().replace(/[-:]/gu, "").replace(/[.]\d{3}Z$/u, "Z");
|
||
}
|
||
|
||
async function writeManifest(extra = {}) {
|
||
const manifest = {
|
||
ok: extra.status !== "failed",
|
||
command: "web-probe-observe",
|
||
specRef,
|
||
jobId,
|
||
pid: process.pid,
|
||
stateDir,
|
||
baseUrl,
|
||
targetPath,
|
||
network: publicNetwork(playwrightProxy),
|
||
pageAuthority: { browser: "chromium", context: "shared-auth", pageMode: "dual-control-observer", controlPageId: pageId, observerPageId, continuityBreaksRecorded: true },
|
||
pageProvenance: compactPageProvenance(currentPageProvenance),
|
||
sampling: { mode: "passive", sampleIntervalMs, screenshotIntervalMs, maxSamples, observerRefreshIntervalMs, observerInitiatedDefault: false, responseBodyReadDefault: false },
|
||
alertThresholds,
|
||
jsonlRotation,
|
||
commandDirs: dirs,
|
||
artifacts: files,
|
||
safety: { pureClient: true, inboundApi: false, database: false, queueConsumer: false, k8sWorkload: false, valuesRedacted: true, secretValuesPrinted: false },
|
||
startedAt,
|
||
...extra,
|
||
};
|
||
await writeFile(files.manifest, JSON.stringify(manifest, null, 2) + "\n", { mode: 0o600 });
|
||
}
|
||
|
||
async function writeHeartbeat(extra = {}) {
|
||
const heartbeat = {
|
||
ok: terminalStatus !== "failed",
|
||
jobId,
|
||
pid: process.pid,
|
||
stateDir,
|
||
status: terminalStatus,
|
||
pageId,
|
||
observerPageId,
|
||
baseUrl,
|
||
currentUrl: currentPageUrl(),
|
||
observerUrl: pageUrl(observerPage),
|
||
observerRefreshIntervalMs,
|
||
lastObserverRefreshAt: Number.isFinite(lastObserverRefreshAtMs) ? new Date(lastObserverRefreshAtMs).toISOString() : null,
|
||
pageProvenance: compactPageProvenance(currentPageProvenance),
|
||
sampleSeq,
|
||
commandSeq,
|
||
activeCommandId,
|
||
updatedAt: new Date().toISOString(),
|
||
uptimeMs: Date.now() - startedAtMs,
|
||
...extra,
|
||
};
|
||
await writeFile(files.heartbeat, JSON.stringify(heartbeat, null, 2) + "\n", { mode: 0o600 });
|
||
}
|
||
|
||
function attachPassiveListeners(targetPage, pageRole = "control", targetPageId = pageId) {
|
||
targetPage.on("request", (request) => {
|
||
void appendJsonl(files.network, eventRecord("request", {
|
||
pageRole,
|
||
pageId: targetPageId,
|
||
observerInitiated: false,
|
||
commandId: activeCommandId,
|
||
method: request.method(),
|
||
url: safeUrl(request.url()),
|
||
resourceType: request.resourceType(),
|
||
frameUrl: safeFrameUrl(request.frame()),
|
||
}));
|
||
});
|
||
targetPage.on("response", (response) => {
|
||
const request = response.request();
|
||
void appendJsonl(files.network, eventRecord("response", {
|
||
pageRole,
|
||
pageId: targetPageId,
|
||
observerInitiated: false,
|
||
commandId: activeCommandId,
|
||
method: request.method(),
|
||
url: safeUrl(response.url()),
|
||
resourceType: request.resourceType(),
|
||
status: response.status(),
|
||
statusText: response.statusText(),
|
||
fromServiceWorker: response.fromServiceWorker(),
|
||
bodyRead: false,
|
||
}));
|
||
});
|
||
targetPage.on("requestfailed", (request) => {
|
||
void appendJsonl(files.network, eventRecord("requestfailed", {
|
||
pageRole,
|
||
pageId: targetPageId,
|
||
observerInitiated: false,
|
||
commandId: activeCommandId,
|
||
method: request.method(),
|
||
url: safeUrl(request.url()),
|
||
resourceType: request.resourceType(),
|
||
failure: request.failure()?.errorText ?? null,
|
||
}));
|
||
});
|
||
targetPage.on("console", (message) => {
|
||
void appendJsonl(files.console, eventRecord("console", { pageRole, pageId: targetPageId, type: message.type(), text: truncate(message.text(), 1000), location: message.location() }));
|
||
});
|
||
targetPage.on("pageerror", (error) => {
|
||
void appendJsonl(files.errors, eventRecord("pageerror", { pageRole, pageId: targetPageId, error: errorSummary(error) }));
|
||
});
|
||
targetPage.on("crash", () => {
|
||
void appendJsonl(files.errors, eventRecord("page-crash", { pageRole, pageId: targetPageId }));
|
||
});
|
||
targetPage.on("close", () => {
|
||
void appendJsonl(files.control, eventRecord("continuity-break", { pageRole, pageId: targetPageId, reason: "page-closed" }));
|
||
});
|
||
}
|
||
|
||
async function drainOneCommand() {
|
||
const entries = (await readdir(dirs.commandsPending).catch(() => [])).filter((name) => name.endsWith(".json")).sort();
|
||
const name = entries[0];
|
||
if (!name) return;
|
||
const pending = path.join(dirs.commandsPending, name);
|
||
const processing = path.join(dirs.commandsProcessing, name);
|
||
await rename(pending, processing).catch(() => null);
|
||
const raw = await readFile(processing, "utf8");
|
||
const command = JSON.parse(raw);
|
||
const id = safeId(command.id || name.replace(/[.]json$/u, ""));
|
||
command.id = id;
|
||
const stopCommandSampler = startCommandActiveSampler(command);
|
||
try {
|
||
const result = await processCommand(command);
|
||
const done = { ok: true, commandId: id, type: command.type, completedAt: new Date().toISOString(), result: sanitize(result) };
|
||
await writeFile(path.join(dirs.commandsDone, id + ".json"), JSON.stringify(done, null, 2) + "\n", { mode: 0o600 });
|
||
await appendJsonl(files.control, controlRecord(command, "completed", done.result));
|
||
await unlink(processing).catch(() => {});
|
||
} catch (error) {
|
||
const failureSample = await samplePage("command-failed", { refreshObserver: false, screenshot: false })
|
||
.then(() => ({ ok: true, sampleSeq, valuesRedacted: true }))
|
||
.catch((sampleError) => ({ ok: false, error: errorSummary(sampleError), valuesRedacted: true }));
|
||
const failed = { ok: false, commandId: id, type: command.type, failedAt: new Date().toISOString(), error: errorSummary(error), failureSample };
|
||
await writeFile(path.join(dirs.commandsFailed, id + ".json"), JSON.stringify(failed, null, 2) + "\n", { mode: 0o600 });
|
||
await appendJsonl(files.control, controlRecord(command, "failed", { error: failed.error, failureSample }));
|
||
await unlink(processing).catch(() => {});
|
||
} finally {
|
||
stopCommandSampler();
|
||
activeCommandId = null;
|
||
await writeHeartbeat({ status: terminalStatus });
|
||
}
|
||
}
|
||
|
||
function startCommandActiveSampler(command) {
|
||
const intervalMs = Math.max(1000, Number(sampleIntervalMs) || 5000);
|
||
let stopped = false;
|
||
let timer = null;
|
||
let inFlight = false;
|
||
const schedule = () => {
|
||
if (stopped) return;
|
||
timer = setTimeout(tick, intervalMs);
|
||
if (timer && typeof timer.unref === "function") timer.unref();
|
||
};
|
||
const tick = () => {
|
||
if (stopped) return;
|
||
if (inFlight) {
|
||
schedule();
|
||
return;
|
||
}
|
||
inFlight = true;
|
||
samplePage("command-active", { refreshObserver: false, screenshot: false })
|
||
.catch((error) => appendJsonl(files.errors, eventRecord("command-active-sample-error", { commandId: command.id, commandType: command.type, error: errorSummary(error) })))
|
||
.finally(() => {
|
||
inFlight = false;
|
||
schedule();
|
||
});
|
||
};
|
||
schedule();
|
||
return () => {
|
||
stopped = true;
|
||
if (timer) clearTimeout(timer);
|
||
};
|
||
}
|
||
|
||
async function processCommand(command) {
|
||
commandSeq += 1;
|
||
activeCommandId = command.id;
|
||
await writeHeartbeat({ status: "running", activeCommandId });
|
||
await appendJsonl(files.control, controlRecord(command, "started", commandInputSummary(command)));
|
||
switch (command.type) {
|
||
case "login": return authenticate(context, page);
|
||
case "preflight": return preflightSummary();
|
||
case "goto": return withObserverSync(await gotoTarget(command.path || command.url || targetPath), "goto");
|
||
case "newSession": return withObserverSync(await createSessionFromUi(), "newSession");
|
||
case "sendPrompt": return withObserverSync(await sendPrompt(String(command.text || "")), "sendPrompt");
|
||
case "steer": return withObserverSync(await sendPrompt(String(command.text || ""), { expectedAction: "steer", responsePath: "/v1/agent/chat/steer", noActiveReason: "steer-no-active-turn" }), "steer");
|
||
case "cancel": return withObserverSync(await cancelRunningTurn(), "cancel");
|
||
case "selectProvider": return withObserverSync(await selectProvider(String(command.provider || command.value || command.text || "")), "selectProvider");
|
||
case "clickSession": return withObserverSync(await clickSession(String(command.sessionId || command.value || "")), "clickSession");
|
||
case "screenshot": return captureScreenshot(command.reason || "manual", command.imageType || "png");
|
||
case "mark": return { mark: truncate(command.label || command.text || "mark", 200), currentUrl: currentPageUrl(), pageId };
|
||
case "stop": stopping = true; return { stopping: true, currentUrl: currentPageUrl(), pageId };
|
||
default: throw new Error("unsupported observer command type: " + command.type);
|
||
}
|
||
}
|
||
|
||
async function withObserverSync(result, reason) {
|
||
return { ...result, observer: await syncObserverPageToControlSession(reason, result?.sessionId ?? null) };
|
||
}
|
||
|
||
async function syncObserverPageToControlSession(reason, explicitSessionId = null, options = {}) {
|
||
if (!observerPage || observerPage.isClosed()) return { ok: false, reason, pageRole: "observer", pageId: observerPageId, failureKind: "observer-page-unavailable" };
|
||
const forceRefresh = options?.forceRefresh === true;
|
||
const snapshot = await workbenchSessionSnapshot();
|
||
const sessionId = explicitSessionId || snapshot?.activeSessionId || snapshot?.routeSessionId || routeSessionIdFromUrl(currentPageUrl());
|
||
const target = sessionId ? "/workbench/sessions/" + encodeURIComponent(sessionId) : targetPath;
|
||
const targetUrl = new URL(target, baseUrl).toString();
|
||
const beforeUrl = pageUrl(observerPage);
|
||
const beforeSessionId = routeSessionIdFromUrl(beforeUrl);
|
||
if (sessionId && beforeSessionId === sessionId && !forceRefresh) return { ok: true, reason, changed: false, observerRoundTrip: false, sessionId, beforeUrl, afterUrl: beforeUrl, pageRole: "observer", pageId: observerPageId, pageEpoch: observerPageEpoch };
|
||
observerPageEpoch += 1;
|
||
let status = null;
|
||
let statusText = null;
|
||
const response = await observerPage.goto(targetUrl, { waitUntil: "domcontentloaded", timeout: 45000 }).catch((error) => ({ observerGotoError: errorSummary(error) }));
|
||
if (response?.observerGotoError) return { ok: false, reason, changed: false, sessionId: sessionId ?? null, targetPath: target, beforeUrl, afterUrl: pageUrl(observerPage), pageRole: "observer", pageId: observerPageId, pageEpoch: observerPageEpoch, error: response.observerGotoError, valuesRedacted: true };
|
||
status = typeof response?.status === "function" ? response.status() : null;
|
||
statusText = typeof response?.statusText === "function" ? response.statusText() : null;
|
||
const readiness = await waitForTargetPageReady(observerPage, targetUrl, { timeoutMs: 15000 });
|
||
if (!readiness.ok) {
|
||
lastObserverRefreshAtMs = Date.now();
|
||
return { ok: false, reason, changed: true, observerRoundTrip: forceRefresh, sessionId: sessionId ?? null, targetPath: target, beforeUrl, afterUrl: pageUrl(observerPage), pageRole: "observer", pageId: observerPageId, pageEpoch: observerPageEpoch, httpStatus: status, statusText, readiness, hydration: null, failureKind: readiness.reason || "observer-target-not-ready", valuesRedacted: true };
|
||
}
|
||
const hydration = await waitForWorkbenchSessionHydrated(observerPage, sessionId, { timeoutMs: 15000 });
|
||
lastObserverRefreshAtMs = Date.now();
|
||
return { ok: hydration.ok === true, reason, changed: true, observerRoundTrip: forceRefresh, sessionId: sessionId ?? null, targetPath: target, beforeUrl, afterUrl: pageUrl(observerPage), pageRole: "observer", pageId: observerPageId, pageEpoch: observerPageEpoch, httpStatus: status, statusText, readiness, hydration, failureKind: hydration.ok === true ? null : hydration.reason || "observer-session-hydration-failed", valuesRedacted: true };
|
||
}
|
||
|
||
async function waitForWorkbenchSessionHydrated(targetPage, sessionId, options = {}) {
|
||
const timeoutMs = Number.isFinite(Number(options.timeoutMs)) ? Number(options.timeoutMs) : 15000;
|
||
const started = Date.now();
|
||
const deadline = started + Math.max(1, timeoutMs);
|
||
let last = null;
|
||
while (Date.now() <= deadline) {
|
||
last = await workbenchSessionSnapshot(targetPage);
|
||
const expected = String(sessionId || "").trim();
|
||
const observedPath = safeUrlPath(last?.url || pageUrl(targetPage));
|
||
const routeOk = expected ? last?.routeSessionId === expected : isWorkbenchPathname(observedPath || "");
|
||
const activeOk = expected ? last?.activeSessionId === expected : isWorkbenchPathname(observedPath || "");
|
||
if (routeOk && activeOk) return { ok: true, durationMs: Date.now() - started, snapshot: last, valuesRedacted: true };
|
||
await targetPage.waitForTimeout(250).catch(() => {});
|
||
}
|
||
return { ok: false, durationMs: Date.now() - started, snapshot: last, reason: "observer-session-hydration-timeout", expectedSessionId: sessionId || null, valuesRedacted: true };
|
||
}
|
||
|
||
async function maybeRefreshObserverPage(reason) {
|
||
if (!observerPage || observerPage.isClosed()) return null;
|
||
if (!observerRefreshIntervalMs || observerRefreshIntervalMs <= 0) return null;
|
||
if (Date.now() - lastObserverRefreshAtMs < observerRefreshIntervalMs) return null;
|
||
const result = await syncObserverPageToControlSession("observer-periodic-refresh", null, { forceRefresh: true });
|
||
await appendJsonl(files.control, eventRecord("observer-periodic-refresh", {
|
||
pageRole: "observer",
|
||
pageId: observerPageId,
|
||
reason,
|
||
intervalMs: observerRefreshIntervalMs,
|
||
result,
|
||
valuesRedacted: true
|
||
}));
|
||
return result;
|
||
}
|
||
|
||
async function runControlCommand(command, fn) {
|
||
activeCommandId = command.id;
|
||
commandSeq += 1;
|
||
const beforeUrl = currentPageUrl();
|
||
const started = Date.now();
|
||
await appendJsonl(files.control, controlRecord(command, "started", { beforeUrl, input: commandInputSummary(command) }));
|
||
try {
|
||
const result = await fn();
|
||
await appendJsonl(files.control, controlRecord(command, "completed", { beforeUrl, afterUrl: currentPageUrl(), durationMs: Date.now() - started, result: sanitize(result) }));
|
||
return result;
|
||
} catch (error) {
|
||
let failurePageProvenance = null;
|
||
let failureScreenshot = null;
|
||
try {
|
||
failurePageProvenance = compactPageProvenance(await refreshPageProvenance("command-failed", null));
|
||
} catch (captureError) {
|
||
await appendJsonl(files.errors, eventRecord("failure-provenance-error", { commandId: command.id, pageRole: "control", pageId, error: errorSummary(captureError) }));
|
||
}
|
||
try {
|
||
failureScreenshot = await captureScreenshot("command-failed", "jpeg");
|
||
} catch (captureError) {
|
||
await appendJsonl(files.errors, eventRecord("failure-screenshot-error", { commandId: command.id, pageRole: "control", pageId, error: errorSummary(captureError) }));
|
||
}
|
||
await appendJsonl(files.control, controlRecord(command, "failed", { beforeUrl, afterUrl: currentPageUrl(), durationMs: Date.now() - started, error: errorSummary(error), failurePageProvenance, failureScreenshot }));
|
||
throw error;
|
||
} finally {
|
||
activeCommandId = null;
|
||
}
|
||
}
|
||
|
||
async function authenticate(browserContext, authPage) {
|
||
const loginUrl = new URL("/auth/login", baseUrl).toString();
|
||
let activeAuthPage = authPage && !authPage.isClosed() ? authPage : null;
|
||
let closeAuthPage = false;
|
||
if (!activeAuthPage) {
|
||
activeAuthPage = await browserContext.newPage();
|
||
closeAuthPage = true;
|
||
}
|
||
const attempts = [];
|
||
const maxAttempts = 5;
|
||
const initialDelayMs = 250;
|
||
const maxDelayMs = 5000;
|
||
try {
|
||
for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
|
||
const retryDelayMs = attempt < maxAttempts ? Math.min(maxDelayMs, initialDelayMs * (2 ** (attempt - 1))) : 0;
|
||
const retryLabel = attempt + "/" + maxAttempts;
|
||
await writeHeartbeat({ status: terminalStatus, auth: { phase: "api-login", retryAttempt: attempt, retryMaxAttempts: maxAttempts, lastRetryLabel: retryLabel, retryDelayMs: 0, retryExhausted: false, valuesRedacted: true } }).catch(() => {});
|
||
try {
|
||
const response = await pageAuthLogin(activeAuthPage, loginUrl);
|
||
const cookieState = await readAuthCookieState(browserContext);
|
||
const retryable = isRetryableAuthStatus(response.status);
|
||
const item = {
|
||
attempt,
|
||
retryAttempt: attempt,
|
||
retryMaxAttempts: maxAttempts,
|
||
retryLabel,
|
||
retryDelayMs: retryable && attempt < maxAttempts ? retryDelayMs : 0,
|
||
method: "api",
|
||
status: response.status,
|
||
statusText: response.statusText,
|
||
retryable,
|
||
cookiePresent: cookieState.cookiePresent,
|
||
cookieNames: cookieState.cookieNames,
|
||
valuesRedacted: true,
|
||
};
|
||
attempts.push(item);
|
||
await writeHeartbeat({ status: terminalStatus, auth: { phase: "api-login", lastRetryLabel: item.retryLabel, retryAttempt: item.retryAttempt, retryMaxAttempts: item.retryMaxAttempts, retryDelayMs: item.retryDelayMs, lastStatus: item.status, lastStatusText: item.statusText, retryable: item.retryable, cookiePresent: item.cookiePresent, retryExhausted: false, valuesRedacted: true } }).catch(() => {});
|
||
if (response.ok && cookieState.cookiePresent) {
|
||
return {
|
||
ok: true,
|
||
method: "api",
|
||
loginPath: new URL(loginUrl).pathname,
|
||
status: response.status,
|
||
statusText: response.statusText,
|
||
cookiePresent: true,
|
||
cookieNames: cookieState.cookieNames,
|
||
attempts,
|
||
retryCount: attempt - 1,
|
||
retryMaxAttempts: maxAttempts,
|
||
lastRetryLabel: attempt + "/" + maxAttempts,
|
||
retryExhausted: false,
|
||
retryable: false,
|
||
valuesRedacted: true,
|
||
};
|
||
}
|
||
if (!retryable) break;
|
||
} catch (error) {
|
||
const retryable = isRetryableAuthError(error);
|
||
attempts.push({
|
||
attempt,
|
||
retryAttempt: attempt,
|
||
retryMaxAttempts: maxAttempts,
|
||
retryLabel,
|
||
retryDelayMs: retryable && attempt < maxAttempts ? retryDelayMs : 0,
|
||
method: "api",
|
||
status: 0,
|
||
statusText: "request-error",
|
||
retryable,
|
||
error: error && error.message ? truncate(error.message, 500) : truncate(String(error), 500),
|
||
cookiePresent: false,
|
||
cookieNames: [],
|
||
valuesRedacted: true,
|
||
});
|
||
const item = attempts[attempts.length - 1] || null;
|
||
await writeHeartbeat({ status: terminalStatus, auth: { phase: "api-login", lastRetryLabel: item?.retryLabel || retryLabel, retryAttempt: attempt, retryMaxAttempts: maxAttempts, retryDelayMs: item?.retryDelayMs ?? 0, lastStatus: item?.status ?? 0, lastStatusText: item?.statusText ?? "request-error", retryable, cookiePresent: false, retryExhausted: false, lastError: item?.error || null, valuesRedacted: true } }).catch(() => {});
|
||
if (!retryable) break;
|
||
}
|
||
if (attempt < maxAttempts && attempts[attempts.length - 1]?.retryable === true) await sleep(retryDelayMs);
|
||
}
|
||
} finally {
|
||
if (closeAuthPage && activeAuthPage && !activeAuthPage.isClosed()) await activeAuthPage.close().catch(() => {});
|
||
}
|
||
const cookieState = await readAuthCookieState(browserContext);
|
||
const last = attempts[attempts.length - 1] || null;
|
||
const retryable = attempts.some((attempt) => attempt && attempt.retryable === true);
|
||
const failure = {
|
||
ok: false,
|
||
method: "api",
|
||
loginPath: new URL(loginUrl).pathname,
|
||
status: typeof last?.status === "number" ? last.status : 0,
|
||
statusText: typeof last?.statusText === "string" ? last.statusText : "api-login-failed",
|
||
cookiePresent: cookieState.cookiePresent,
|
||
cookieNames: cookieState.cookieNames,
|
||
attempts,
|
||
retryCount: Math.max(0, attempts.length - 1),
|
||
retryMaxAttempts: maxAttempts,
|
||
lastRetryLabel: last?.retryLabel || null,
|
||
retryExhausted: retryable && attempts.length >= maxAttempts,
|
||
retryable,
|
||
lastError: last?.error || null,
|
||
valuesRedacted: true,
|
||
};
|
||
await writeHeartbeat({ status: terminalStatus, auth: { phase: "api-login", lastRetryLabel: failure.lastRetryLabel, retryAttempt: attempts.length, retryMaxAttempts: maxAttempts, retryDelayMs: 0, lastStatus: failure.status, lastStatusText: failure.statusText, retryable: failure.retryable, cookiePresent: failure.cookiePresent, retryExhausted: failure.retryExhausted, lastError: failure.lastError, valuesRedacted: true } }).catch(() => {});
|
||
const error = new Error(authFailureMessage(failure));
|
||
error.webProbeAuth = failure;
|
||
throw error;
|
||
}
|
||
|
||
async function pageAuthLogin(authPage, loginUrl) {
|
||
if (!authPage) throw new Error("auth page is not ready");
|
||
await authPage.goto(new URL("/assets/favicon.svg", baseUrl).toString(), { waitUntil: "domcontentloaded", timeout: 12000 });
|
||
return authPage.evaluate(async (input) => {
|
||
const response = await fetch(input.loginUrl, {
|
||
method: "POST",
|
||
headers: { accept: "application/json", "content-type": "application/json" },
|
||
body: JSON.stringify({ username: input.username, password: input.password }),
|
||
credentials: "include",
|
||
});
|
||
await response.text().catch(() => "");
|
||
return {
|
||
ok: response.ok,
|
||
status: response.status,
|
||
statusText: response.statusText || "",
|
||
};
|
||
}, { username, password, loginUrl });
|
||
}
|
||
|
||
function publicAuth(value) {
|
||
if (!value) return null;
|
||
return {
|
||
ok: value.ok === true,
|
||
method: value.method,
|
||
status: value.status,
|
||
cookiePresent: value.cookiePresent === true,
|
||
cookieNames: value.cookieNames || [],
|
||
retryCount: value.retryCount ?? null,
|
||
retryMaxAttempts: value.retryMaxAttempts ?? null,
|
||
lastRetryLabel: value.lastRetryLabel ?? null,
|
||
retryExhausted: value.retryExhausted === true,
|
||
valuesRedacted: true
|
||
};
|
||
}
|
||
|
||
async function readAuthCookieState(browserContext) {
|
||
const cookies = await browserContext.cookies(baseUrl);
|
||
const cookieNames = cookies.map((cookie) => cookie.name).sort();
|
||
return {
|
||
cookiePresent: cookieNames.includes("hwlab_session") || cookieNames.some((name) => /session|auth|token/iu.test(name)),
|
||
cookieNames: cookieNames.filter((name) => /session|auth|token/iu.test(name)),
|
||
};
|
||
}
|
||
|
||
function isRetryableAuthStatus(status) {
|
||
return status === 0 || status === 408 || status === 409 || status === 425 || status === 429 || status >= 500;
|
||
}
|
||
|
||
function isRetryableAuthError(error) {
|
||
const message = error && error.message ? String(error.message) : String(error || "");
|
||
return /AbortError|EAI_AGAIN|ETIMEDOUT|ECONNRESET|ECONNREFUSED|ECONNABORTED|socket hang up|ERR_NETWORK_CHANGED|fetch failed|failed to fetch|network|timeout|aborted/iu.test(message);
|
||
}
|
||
|
||
function authFailureMessage(failure) {
|
||
const last = Array.isArray(failure.attempts) && failure.attempts.length > 0 ? failure.attempts[failure.attempts.length - 1] : null;
|
||
const retry = failure.lastRetryLabel ? " retry=" + failure.lastRetryLabel : "";
|
||
const exhausted = failure.retryExhausted ? " exhausted=true" : "";
|
||
const status = last ? " status=" + (last.status ?? "-") + " " + (last.statusText ?? "") : "";
|
||
const error = last?.error ? " error=" + truncate(last.error, 160) : "";
|
||
return ("auth login failed:" + retry + exhausted + status + error).trim();
|
||
}
|
||
|
||
function proxyConfigFromEnv(targetBaseUrl) {
|
||
if (browserProxyMode === "direct") return null;
|
||
let target;
|
||
try {
|
||
target = new URL(targetBaseUrl);
|
||
} catch {
|
||
return null;
|
||
}
|
||
const noProxy = process.env.NO_PROXY || process.env.no_proxy || "";
|
||
if (noProxyMatches(target.hostname, noProxy)) return null;
|
||
const raw = target.protocol === "https:"
|
||
? process.env.HTTPS_PROXY || process.env.https_proxy || process.env.ALL_PROXY || process.env.all_proxy || process.env.HTTP_PROXY || process.env.http_proxy || ""
|
||
: process.env.HTTP_PROXY || process.env.http_proxy || process.env.ALL_PROXY || process.env.all_proxy || process.env.HTTPS_PROXY || process.env.https_proxy || "";
|
||
if (!raw) return null;
|
||
return { server: raw };
|
||
}
|
||
|
||
function chromiumLaunchOptionsForProxy(proxy) {
|
||
const base = { env: browserProcessEnvWithoutProxy() };
|
||
if (proxy === null) return { ...base, args: ["--no-proxy-server"] };
|
||
return { ...base, proxy };
|
||
}
|
||
|
||
function browserProcessEnvWithoutProxy() {
|
||
const blocked = new Set(["HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY", "NO_PROXY", "http_proxy", "https_proxy", "all_proxy", "no_proxy"]);
|
||
const env = {};
|
||
for (const [key, value] of Object.entries(process.env)) {
|
||
if (!blocked.has(key) && value !== undefined) env[key] = value;
|
||
}
|
||
return env;
|
||
}
|
||
|
||
function noProxyMatches(hostname, rawList) {
|
||
const host = String(hostname || "").toLowerCase();
|
||
if (!host) return false;
|
||
return String(rawList || "").split(",").some((raw) => {
|
||
let item = raw.trim().toLowerCase();
|
||
if (!item) return false;
|
||
if (item === "*") return true;
|
||
item = item.replace(/^\*\./u, ".");
|
||
const portIndex = item.lastIndexOf(":");
|
||
if (portIndex > -1 && !item.includes("]")) item = item.slice(0, portIndex);
|
||
if (item.startsWith(".")) return host === item.slice(1) || host.endsWith(item);
|
||
return host === item;
|
||
});
|
||
}
|
||
|
||
function publicNetwork(proxy) {
|
||
return {
|
||
proxy: proxy === null ? { enabled: false, source: "env", valuesRedacted: true } : {
|
||
enabled: true,
|
||
source: "env",
|
||
server: publicProxyServer(proxy.server),
|
||
valuesRedacted: true,
|
||
},
|
||
browser: {
|
||
proxyMode: proxy === null ? "direct-no-proxy-server" : "explicit-playwright-proxy",
|
||
requestedProxyMode: browserProxyMode,
|
||
proxyEnvCleared: true,
|
||
valuesRedacted: true,
|
||
},
|
||
valuesRedacted: true,
|
||
};
|
||
}
|
||
|
||
function parseBrowserProxyMode(raw) {
|
||
if (raw === "auto" || raw === "direct") return raw;
|
||
return "auto";
|
||
}
|
||
|
||
function publicProxyServer(raw) {
|
||
try {
|
||
const parsed = new URL(String(raw || ""));
|
||
parsed.username = "";
|
||
parsed.password = "";
|
||
const value = parsed.toString();
|
||
if (parsed.pathname === "/" && parsed.search === "" && parsed.hash === "") return value.replace(/\/$/u, "");
|
||
return value;
|
||
} catch {
|
||
return String(raw || "").replace(/\/\/[^/@]+@/u, "//[redacted]@");
|
||
}
|
||
}
|
||
|
||
async function gotoTarget(rawTarget) {
|
||
const target = new URL(String(rawTarget || targetPath), baseUrl).toString();
|
||
const beforeUrl = currentPageUrl();
|
||
const attempts = [];
|
||
for (let attempt = 1; attempt <= 2; attempt += 1) {
|
||
try {
|
||
const response = await page.goto(target, { waitUntil: "domcontentloaded", timeout: 45000 });
|
||
await page.waitForTimeout(1000).catch(() => {});
|
||
const httpStatus = response ? response.status() : null;
|
||
const readiness = await waitForTargetPageReady(page, target, { timeoutMs: 15000 });
|
||
if (!readiness.ok) {
|
||
const pageProvenance = await refreshPageProvenance("goto-degraded", httpStatus).catch(() => null);
|
||
attempts.push({ attempt, ok: false, degraded: true, httpStatus, readiness, failureKind: readiness.reason || "workbench-app-not-ready" });
|
||
return { beforeUrl, afterUrl: currentPageUrl(), httpStatus, pageId, degraded: true, degradedReason: readiness.reason || "workbench-app-not-ready", pageProvenance: compactPageProvenance(pageProvenance), readiness, attempts };
|
||
}
|
||
const pageProvenance = await refreshPageProvenance("goto", httpStatus);
|
||
attempts.push({ attempt, ok: true, httpStatus, readiness });
|
||
return { beforeUrl, afterUrl: currentPageUrl(), httpStatus, pageId, pageProvenance: compactPageProvenance(pageProvenance), readiness, attempts };
|
||
} catch (error) {
|
||
const message = error instanceof Error ? error.message : String(error);
|
||
attempts.push({ attempt, ok: false, failureKind: navigationFailureKind(message), message: redactErrorMessage(message), readiness: error?.navigationReadiness ?? null });
|
||
if (/workbench-app-not-ready/iu.test(message)) {
|
||
const lateReadiness = await waitForTargetPageReady(page, target, { timeoutMs: 5000 }).catch(() => null);
|
||
if (lateReadiness?.ok) {
|
||
const pageProvenance = await refreshPageProvenance("goto-late-ready", null);
|
||
attempts.push({ attempt, ok: true, lateReady: true, httpStatus: null, readiness: lateReadiness });
|
||
return { beforeUrl, afterUrl: currentPageUrl(), httpStatus: null, pageId, pageProvenance: compactPageProvenance(pageProvenance), readiness: lateReadiness, attempts };
|
||
}
|
||
}
|
||
if (attempt >= 2 || !isRetryableNavigationError(message)) {
|
||
throw Object.assign(new Error(message), { attempts, target });
|
||
}
|
||
if (!observerPage) {
|
||
await recreateAuthenticatedContextForNavigation("retryable-navigation-" + navigationFailureKind(message), attempt).catch((resetError) => appendJsonl(files.errors, eventRecord("navigation-context-reset-error", { commandId: activeCommandId, attempt, error: errorSummary(resetError) })));
|
||
} else {
|
||
await recreateControlPageForNavigation("retryable-navigation-" + navigationFailureKind(message), attempt).catch((resetError) => appendJsonl(files.errors, eventRecord("navigation-page-reset-error", { commandId: activeCommandId, attempt, error: errorSummary(resetError) })));
|
||
}
|
||
await page.waitForTimeout(1500 * attempt).catch(() => {});
|
||
}
|
||
}
|
||
return { beforeUrl, afterUrl: currentPageUrl(), httpStatus: null, pageId, attempts };
|
||
}
|
||
|
||
async function recreateControlPageForNavigation(reason, attempt) {
|
||
const before = currentPageUrl();
|
||
if (page && !page.isClosed()) await page.close().catch(() => {});
|
||
page = await context.newPage();
|
||
attachPassiveListeners(page, "control", pageId);
|
||
currentPageProvenance = null;
|
||
await appendJsonl(files.control, eventRecord("page-recreated", { reason, attempt, beforeUrl: before, afterUrl: currentPageUrl(), pageRole: "control", pageId, valuesRedacted: true }));
|
||
}
|
||
|
||
async function recreateAuthenticatedContextForNavigation(reason, attempt) {
|
||
const before = currentPageUrl();
|
||
if (page && !page.isClosed()) await page.close().catch(() => {});
|
||
if (observerPage && !observerPage.isClosed()) await observerPage.close().catch(() => {});
|
||
observerPage = null;
|
||
if (context) await context.close().catch(() => {});
|
||
context = await browser.newContext({ viewport, ...(playwrightProxy === null ? {} : { proxy: playwrightProxy }) });
|
||
auth = await authenticate(context);
|
||
page = await context.newPage();
|
||
attachPassiveListeners(page, "control", pageId);
|
||
currentPageProvenance = null;
|
||
await appendJsonl(files.control, eventRecord("context-recreated", { reason, attempt, beforeUrl: before, afterUrl: currentPageUrl(), pageRole: "control", pageId, auth: publicAuth(auth), valuesRedacted: true }));
|
||
}
|
||
|
||
async function refreshPageProvenance(reason, httpStatus = null) {
|
||
if (!page || page.isClosed()) return currentPageProvenance;
|
||
const observed = await page.evaluate(() => {
|
||
const assetPath = (raw) => {
|
||
if (!raw) return null;
|
||
try {
|
||
const url = new URL(raw, location.href);
|
||
const keys = Array.from(url.searchParams.keys()).sort();
|
||
return url.pathname + (keys.length > 0 ? "?keys=" + keys.join(",") : "");
|
||
} catch {
|
||
return null;
|
||
}
|
||
};
|
||
const meta = Array.from(document.querySelectorAll("meta[name], meta[property]")).map((element) => ({
|
||
key: String(element.getAttribute("name") || element.getAttribute("property") || "").slice(0, 120),
|
||
content: String(element.getAttribute("content") || "").slice(0, 200),
|
||
})).filter((item) => item.key).sort((a, b) => a.key.localeCompare(b.key));
|
||
const navigation = performance.getEntriesByType("navigation")[0] || null;
|
||
return {
|
||
url: location.href,
|
||
path: location.pathname,
|
||
title: document.title,
|
||
readyState: document.readyState,
|
||
timeOrigin: Math.round(performance.timeOrigin || 0),
|
||
navigationStartTime: navigation ? Math.round(navigation.startTime) : null,
|
||
scripts: Array.from(document.scripts).map((element) => assetPath(element.src)).filter(Boolean).sort(),
|
||
stylesheets: Array.from(document.querySelectorAll('link[rel~="stylesheet"][href]')).map((element) => assetPath(element.href)).filter(Boolean).sort(),
|
||
meta,
|
||
};
|
||
}).catch((error) => ({ error: errorSummary(error), url: currentPageUrl(), path: null, scripts: [], stylesheets: [], meta: [] }));
|
||
pageLoadSeq += 1;
|
||
currentPageProvenance = normalizePageProvenance(observed, { reason, httpStatus, pageLoadSeq });
|
||
await appendJsonl(files.control, eventRecord("page-provenance", { reason, httpStatus, pageProvenance: compactPageProvenance(currentPageProvenance) }));
|
||
return currentPageProvenance;
|
||
}
|
||
|
||
function normalizePageProvenance(value, options = {}) {
|
||
const scripts = Array.isArray(value?.scripts) ? value.scripts.map(String).filter(Boolean) : [];
|
||
const stylesheets = Array.isArray(value?.stylesheets) ? value.stylesheets.map(String).filter(Boolean) : [];
|
||
const meta = Array.isArray(value?.meta) ? value.meta.map((item) => ({
|
||
key: String(item?.key || "").slice(0, 120),
|
||
contentHash: sha256Text(String(item?.content || "")),
|
||
})).filter((item) => item.key) : [];
|
||
const fingerprintInput = JSON.stringify({ scripts, stylesheets, meta });
|
||
return {
|
||
pageLoadSeq: options.pageLoadSeq ?? pageLoadSeq,
|
||
reason: options.reason || "sample",
|
||
observedAt: new Date().toISOString(),
|
||
urlPath: safeUrlPath(value?.url || currentPageUrl()),
|
||
documentPath: value?.path || null,
|
||
titleHash: sha256Text(String(value?.title || "")),
|
||
documentReadyState: value?.readyState || null,
|
||
timeOrigin: Number.isFinite(Number(value?.timeOrigin)) ? Number(value.timeOrigin) : null,
|
||
navigationStartTime: Number.isFinite(Number(value?.navigationStartTime)) ? Number(value.navigationStartTime) : null,
|
||
httpStatus: options.httpStatus ?? null,
|
||
assetFingerprint: sha256Text(fingerprintInput),
|
||
scriptCount: scripts.length,
|
||
stylesheetCount: stylesheets.length,
|
||
metaCount: meta.length,
|
||
scripts: scripts.slice(0, 30),
|
||
stylesheets: stylesheets.slice(0, 30),
|
||
meta: meta.slice(0, 30),
|
||
error: value?.error || null,
|
||
valuesRedacted: true,
|
||
};
|
||
}
|
||
|
||
function compactPageProvenance(value) {
|
||
if (!value) return null;
|
||
return {
|
||
pageLoadSeq: value.pageLoadSeq ?? null,
|
||
reason: value.reason || null,
|
||
observedAt: value.observedAt || null,
|
||
urlPath: value.urlPath || null,
|
||
documentReadyState: value.documentReadyState || null,
|
||
timeOrigin: value.timeOrigin ?? null,
|
||
httpStatus: value.httpStatus ?? null,
|
||
assetFingerprint: value.assetFingerprint || null,
|
||
scriptCount: value.scriptCount ?? 0,
|
||
stylesheetCount: value.stylesheetCount ?? 0,
|
||
metaCount: value.metaCount ?? 0,
|
||
scripts: Array.isArray(value.scripts) ? value.scripts.slice(0, 12) : [],
|
||
stylesheets: Array.isArray(value.stylesheets) ? value.stylesheets.slice(0, 12) : [],
|
||
error: value.error || null,
|
||
valuesRedacted: true,
|
||
};
|
||
}
|
||
|
||
function isRetryableNavigationError(message) {
|
||
return /net::ERR_NETWORK_CHANGED|net::ERR_ABORTED|net::ERR_CONNECTION_RESET|Navigation timeout|workbench-app-not-ready/iu.test(String(message || ""));
|
||
}
|
||
|
||
function navigationFailureKind(message) {
|
||
const text = String(message || "");
|
||
if (/net::ERR_NETWORK_CHANGED/iu.test(text)) return "net::ERR_NETWORK_CHANGED";
|
||
if (/net::ERR_ABORTED/iu.test(text)) return "net::ERR_ABORTED";
|
||
if (/net::ERR_CONNECTION_RESET/iu.test(text)) return "net::ERR_CONNECTION_RESET";
|
||
if (/Navigation timeout/iu.test(text)) return "navigation-timeout";
|
||
if (/workbench-app-not-ready/iu.test(text)) return "workbench-app-not-ready";
|
||
return "navigation-error";
|
||
}
|
||
|
||
function redactErrorMessage(message) {
|
||
return String(message || "")
|
||
.replace(/([?&](?:token|key|password|secret|authorization)=)[^&\s]+/giu, "$1[redacted]")
|
||
.replace(/(Bearer\s+)[A-Za-z0-9._~+/=-]+/gu, "$1[redacted]");
|
||
}
|
||
|
||
async function waitForTargetPageReady(targetPage, targetUrl, options = {}) {
|
||
const timeoutMs = Number.isFinite(Number(options.timeoutMs)) ? Math.max(1, Number(options.timeoutMs)) : 15000;
|
||
const targetPathname = safeUrlPath(targetUrl) || "";
|
||
if (!isWorkbenchPathname(targetPathname)) return { ok: true, reason: "not-workbench-route", valuesRedacted: true };
|
||
const started = Date.now();
|
||
await targetPage.waitForFunction(() => {
|
||
const visible = (element) => {
|
||
if (!element) return false;
|
||
const rect = element.getBoundingClientRect();
|
||
const style = window.getComputedStyle(element);
|
||
return rect.width > 0 && rect.height > 0 && style.visibility !== "hidden" && style.display !== "none";
|
||
};
|
||
const workspace = document.querySelector("#workspace, .workbench-route");
|
||
const login = document.querySelector("form.login-card, .login-card, [data-testid='login']");
|
||
return Boolean(visible(workspace) || visible(login));
|
||
}, null, { timeout: timeoutMs }).catch(() => null);
|
||
const snapshot = await workbenchReadinessSnapshot(targetPage);
|
||
const ok = snapshot.workbenchShellVisible === true;
|
||
return {
|
||
ok,
|
||
reason: ok ? "workbench-ready" : snapshot.loginVisible ? "login-visible" : "workbench-app-not-ready",
|
||
durationMs: Date.now() - started,
|
||
snapshot,
|
||
valuesRedacted: true
|
||
};
|
||
}
|
||
|
||
async function workbenchReadinessSnapshot(targetPage) {
|
||
const snapshot = await targetPage.evaluate(() => {
|
||
const visible = (element) => {
|
||
if (!element) return false;
|
||
const rect = element.getBoundingClientRect();
|
||
const style = window.getComputedStyle(element);
|
||
return rect.width > 0 && rect.height > 0 && style.visibility !== "hidden" && style.display !== "none";
|
||
};
|
||
return {
|
||
url: window.location.href,
|
||
path: window.location.pathname,
|
||
readyState: document.readyState,
|
||
workbenchShellVisible: visible(document.querySelector("#workspace, .workbench-route")),
|
||
sessionCreateVisible: visible(document.querySelector("#session-create")),
|
||
commandInputPresent: visible(document.querySelector("#command-input")),
|
||
activeTabPresent: visible(document.querySelector(".session-tab[data-active='true'], .session-tab[aria-selected='true']")),
|
||
warningPresent: visible(document.querySelector(".composer-warning")),
|
||
loginVisible: visible(document.querySelector("form.login-card, .login-card, [data-testid='login']")),
|
||
bodyTextPreview: String(document.body?.innerText || "").slice(0, 2000),
|
||
valuesRedacted: true
|
||
};
|
||
}).catch((error) => ({ error: errorSummary(error), valuesRedacted: true }));
|
||
if (snapshot && typeof snapshot.bodyTextPreview === "string") {
|
||
snapshot.bodyTextHash = sha256Text(snapshot.bodyTextPreview);
|
||
delete snapshot.bodyTextPreview;
|
||
}
|
||
return snapshot;
|
||
}
|
||
|
||
function isWorkbenchPathname(value) {
|
||
const pathname = String(value || "");
|
||
return pathname === "/workbench" || pathname === "/workspace" || pathname.startsWith("/workbench/") || pathname.startsWith("/workspace/");
|
||
}
|
||
|
||
async function createSessionFromUi() {
|
||
const beforeUrl = currentPageUrl();
|
||
const before = await workbenchSessionSnapshot();
|
||
const readinessBeforeClick = await workbenchReadinessSnapshot(page);
|
||
const create = page.locator("#session-create").first();
|
||
await create.waitFor({ state: "visible", timeout: 15000 });
|
||
const createButtonState = await create.evaluate((element) => {
|
||
const rect = element.getBoundingClientRect();
|
||
const style = window.getComputedStyle(element);
|
||
return {
|
||
tag: element.tagName.toLowerCase(),
|
||
id: element.id || null,
|
||
disabled: Boolean(element.disabled),
|
||
ariaDisabled: element.getAttribute("aria-disabled") || null,
|
||
visible: rect.width > 0 && rect.height > 0 && style.visibility !== "hidden" && style.display !== "none",
|
||
rect: { width: Math.round(rect.width), height: Math.round(rect.height) },
|
||
valuesRedacted: true
|
||
};
|
||
}).catch((error) => ({ error: errorSummary(error), valuesRedacted: true }));
|
||
const createResponsePromise = page.waitForResponse((response) => {
|
||
const request = response.request();
|
||
if (request.method().toUpperCase() !== "POST") return false;
|
||
try {
|
||
return new URL(response.url()).pathname === "/v1/agent/sessions";
|
||
} catch {
|
||
return false;
|
||
}
|
||
}, { timeout: 45000 }).catch((error) => ({ waitError: errorSummary(error) }));
|
||
await create.click();
|
||
const createResponse = await createResponsePromise;
|
||
if (createResponse?.waitError) {
|
||
const error = new Error("newSession did not observe POST /v1/agent/sessions response after click: " + (createResponse.waitError.message || createResponse.waitError.name || "timeout"));
|
||
error.details = { beforeUrl, afterUrl: currentPageUrl(), before, readinessBeforeClick, createButtonState, waitError: createResponse.waitError, pageId, valuesRedacted: true };
|
||
throw error;
|
||
}
|
||
const createStatus = createResponse.status();
|
||
let createPayload = null;
|
||
let createPayloadError = null;
|
||
try {
|
||
createPayload = await createResponse.json();
|
||
} catch (error) {
|
||
createPayloadError = errorSummary(error);
|
||
}
|
||
const createdSessionId = sessionIdFromAgentSessionPayload(createPayload);
|
||
if (createStatus < 200 || createStatus >= 300 || !createdSessionId) {
|
||
const error = new Error("newSession did not receive an authoritative session id from POST /v1/agent/sessions");
|
||
error.details = { status: createStatus, statusText: createResponse.statusText(), responseParsed: createPayload !== null, responseParseError: createPayloadError, createdSessionId, valuesRedacted: true };
|
||
throw error;
|
||
}
|
||
await page.waitForFunction((expectedSessionId) => {
|
||
const activeTab = document.querySelector(".session-tab[data-active='true'], .session-tab[aria-selected='true']");
|
||
const sessionId = activeTab?.getAttribute("data-session-id") || "";
|
||
const routeMatch = window.location.pathname.match(/\/workbench\/sessions\/([^/]+)/u) || window.location.pathname.match(/\/workspace\/sessions\/([^/]+)/u);
|
||
const routeSessionId = routeMatch ? decodeURIComponent(routeMatch[1] || "") : "";
|
||
const warning = document.querySelector(".composer-warning")?.textContent?.trim() || "";
|
||
const input = document.querySelector("#command-input");
|
||
return Boolean(activeTab && sessionId === expectedSessionId && routeSessionId === expectedSessionId && input && !input.disabled && !warning);
|
||
}, createdSessionId, { timeout: 45000 }).catch(() => null);
|
||
const after = await workbenchSessionSnapshot();
|
||
const afterSessionId = after?.activeSessionId || after?.routeSessionId || "";
|
||
const ok = Boolean(afterSessionId === createdSessionId && after?.routeSessionId === createdSessionId && after?.composerReady);
|
||
if (!ok) {
|
||
const error = new Error("newSession did not select the authoritative newly created workbench session");
|
||
error.details = { beforeUrl, afterUrl: currentPageUrl(), before, after, createdSessionId, pageId, valuesRedacted: true };
|
||
throw error;
|
||
}
|
||
return {
|
||
beforeUrl,
|
||
afterUrl: currentPageUrl(),
|
||
ok,
|
||
before,
|
||
after,
|
||
sessionId: createdSessionId,
|
||
createSession: { status: createStatus, statusText: createResponse.statusText(), responseParsed: createPayload !== null, responseParseError: createPayloadError, createdSessionId, valuesRedacted: true },
|
||
pageId
|
||
};
|
||
}
|
||
|
||
function sessionIdFromAgentSessionPayload(payload) {
|
||
const direct = payload?.sessionId ?? payload?.id ?? payload?.session?.sessionId ?? payload?.session?.id ?? payload?.data?.sessionId ?? payload?.data?.id ?? payload?.data?.session?.sessionId ?? payload?.data?.session?.id;
|
||
const directText = String(direct || "").trim();
|
||
if (/^ses_[A-Za-z0-9_-]+$/u.test(directText)) return directText;
|
||
const match = JSON.stringify(payload ?? "").match(/\bses_[A-Za-z0-9_-]+\b/u);
|
||
return match ? match[0] : null;
|
||
}
|
||
|
||
async function workbenchSessionSnapshot(targetPage = page) {
|
||
return targetPage.evaluate(() => {
|
||
const activeTab = document.querySelector(".session-tab[data-active='true'], .session-tab[aria-selected='true']");
|
||
const routeMatch = window.location.pathname.match(/\/workbench\/sessions\/([^/]+)/u) || window.location.pathname.match(/\/workspace\/sessions\/([^/]+)/u);
|
||
const input = document.querySelector("#command-input");
|
||
const warning = document.querySelector(".composer-warning")?.textContent?.trim() || null;
|
||
const visible = (element) => {
|
||
const rect = element.getBoundingClientRect();
|
||
const style = window.getComputedStyle(element);
|
||
return rect.width > 0 && rect.height > 0 && style.visibility !== "hidden" && style.display !== "none";
|
||
};
|
||
return {
|
||
url: window.location.href,
|
||
routeSessionId: routeMatch ? decodeURIComponent(routeMatch[1] || "") : null,
|
||
activeSessionId: activeTab?.getAttribute("data-session-id") || null,
|
||
activeConversationId: activeTab?.getAttribute("data-conversation-id") || null,
|
||
activeStatus: activeTab?.getAttribute("data-status") || null,
|
||
tabCount: document.querySelectorAll(".session-tab").length,
|
||
messageCount: Array.from(document.querySelectorAll('article.message-card, .message-card[data-message-id], article[data-message-id]')).filter(visible).length,
|
||
traceRowCount: Array.from(document.querySelectorAll('[data-testid*="trace" i], [class*="trace" i], [data-trace-id], [data-testid*="event" i]')).filter(visible).length,
|
||
loadingCount: Array.from(document.querySelectorAll('[aria-busy="true"], [data-loading="true"], [class*="loading" i], [data-testid*="loading" i]')).filter(visible).length,
|
||
composerReady: Boolean(activeTab && input && !input.disabled && !warning),
|
||
warning
|
||
};
|
||
}).catch(() => null);
|
||
}
|
||
|
||
async function sendPrompt(text, options = {}) {
|
||
if (text.trim().length === 0) throw new Error("sendPrompt requires non-empty text");
|
||
const responsePath = options.responsePath || "/v1/agent/chat";
|
||
const beforeUrl = currentPageUrl();
|
||
const beforeEvidence = await promptSideEffectSnapshot();
|
||
const primaryEditor = page.locator("#command-input").last();
|
||
const editor = await primaryEditor.isVisible().catch(() => false)
|
||
? primaryEditor
|
||
: page.locator('textarea, [role="textbox"], [contenteditable="true"], input[type="text"]').last();
|
||
await editor.waitFor({ state: "visible", timeout: 15000 });
|
||
await fillComposerEditor(editor, text);
|
||
const primarySubmitSelector = '#command-send, #command-submit, [data-testid="command-submit"], [data-testid="composer-submit"], [data-testid="send-command"]';
|
||
const primarySubmit = page.locator(primarySubmitSelector).last();
|
||
const submit = await primarySubmit.isVisible().catch(() => false)
|
||
? primarySubmit
|
||
: page.locator([
|
||
'button[type="submit"]',
|
||
'button:has-text("发送")',
|
||
'button:has-text("Send")',
|
||
'[data-testid*="send" i]',
|
||
'[aria-label*="send" i]',
|
||
'[aria-label*="发送"]'
|
||
].join(", ")).last();
|
||
await submit.waitFor({ state: "visible", timeout: 15000 });
|
||
if (options.expectedAction) {
|
||
await page.waitForFunction(({ selector, expected }) => {
|
||
const element = document.querySelector(selector);
|
||
return element?.getAttribute("data-action") === expected || element?.getAttribute("disabled") !== null;
|
||
}, { selector: primarySubmitSelector, expected: options.expectedAction }, { timeout: 1000 }).catch(() => null);
|
||
const composer = await composerButtonState(submit);
|
||
if (composer.action !== options.expectedAction || composer.disabled === true) {
|
||
await clearComposerEditor(editor).catch(() => {});
|
||
const sideEffect = await waitForPromptSideEffect(beforeEvidence, 200).catch(() => promptSideEffectSnapshot());
|
||
return {
|
||
beforeUrl,
|
||
afterUrl: currentPageUrl(),
|
||
textHash: sha256Text(text),
|
||
textBytes: Buffer.byteLength(text),
|
||
submitted: false,
|
||
blocked: true,
|
||
degradedReason: options.noActiveReason || "composer-action-mismatch",
|
||
composer,
|
||
chatSubmit: {
|
||
status: null,
|
||
statusText: null,
|
||
urlPath: responsePath,
|
||
responseObserved: false,
|
||
sideEffectObserved: sideEffectHasAuthoritativePromptSubmission(sideEffect),
|
||
sideEffect,
|
||
expectedAction: options.expectedAction,
|
||
actualAction: composer.action,
|
||
valuesRedacted: true
|
||
},
|
||
pageId,
|
||
valuesRedacted: true
|
||
};
|
||
}
|
||
}
|
||
const chatResponsePromise = page.waitForResponse((response) => {
|
||
const request = response.request();
|
||
if (request.method().toUpperCase() !== "POST") return false;
|
||
try {
|
||
return new URL(response.url()).pathname === responsePath;
|
||
} catch {
|
||
return false;
|
||
}
|
||
}, { timeout: 45000 }).catch((error) => ({ waitError: errorSummary(error) }));
|
||
await submit.click();
|
||
const chatResponse = await chatResponsePromise;
|
||
await page.waitForTimeout(500);
|
||
if (chatResponse?.waitError) {
|
||
const sideEffect = await waitForPromptSideEffect(beforeEvidence, 5000);
|
||
if (sideEffectHasAuthoritativePromptSubmission(sideEffect)) {
|
||
return {
|
||
beforeUrl,
|
||
afterUrl: currentPageUrl(),
|
||
textHash: sha256Text(text),
|
||
textBytes: Buffer.byteLength(text),
|
||
chatSubmit: { status: null, statusText: null, urlPath: responsePath, waitError: chatResponse.waitError, sideEffectObserved: true, sideEffect },
|
||
pageId
|
||
};
|
||
}
|
||
const error = new Error("sendPrompt did not observe POST " + responsePath + " response or an authoritative new turn after submit: " + (chatResponse.waitError.message || chatResponse.waitError.name || "timeout"));
|
||
error.details = {
|
||
beforeUrl,
|
||
afterUrl: currentPageUrl(),
|
||
textHash: sha256Text(text),
|
||
textBytes: Buffer.byteLength(text),
|
||
chatSubmit: { status: null, statusText: null, urlPath: responsePath, waitError: chatResponse.waitError, sideEffectObserved: false, sideEffect },
|
||
pageId,
|
||
valuesRedacted: true
|
||
};
|
||
throw error;
|
||
}
|
||
const chatStatus = chatResponse.status();
|
||
if (chatStatus < 200 || chatStatus >= 300) {
|
||
throw new Error("sendPrompt observed POST " + responsePath + " HTTP " + chatStatus + " " + chatResponse.statusText());
|
||
}
|
||
let chatPayload = null;
|
||
let chatPayloadError = null;
|
||
try {
|
||
chatPayload = await chatResponse.json();
|
||
} catch (error) {
|
||
chatPayloadError = errorSummary(error);
|
||
}
|
||
let chatUrlPath = responsePath;
|
||
try {
|
||
chatUrlPath = new URL(chatResponse.url()).pathname;
|
||
} catch {
|
||
chatUrlPath = responsePath;
|
||
}
|
||
const payloadText = chatPayload ? JSON.stringify(chatPayload) : "";
|
||
const traceId = payloadText.match(/\btrc_[A-Za-z0-9_-]+\b/u)?.[0] || null;
|
||
const otelTraceId = typeof chatPayload?.otelTrace?.traceId === "string" && /^[0-9a-f]{32}$/u.test(chatPayload.otelTrace.traceId)
|
||
? chatPayload.otelTrace.traceId
|
||
: null;
|
||
return {
|
||
beforeUrl,
|
||
afterUrl: currentPageUrl(),
|
||
textHash: sha256Text(text),
|
||
textBytes: Buffer.byteLength(text),
|
||
chatSubmit: {
|
||
status: chatStatus,
|
||
statusText: chatResponse.statusText(),
|
||
urlPath: chatUrlPath,
|
||
traceId,
|
||
otelTraceId,
|
||
resultUrl: safeUrlPath(chatPayload?.resultUrl),
|
||
turnUrl: safeUrlPath(chatPayload?.turnUrl),
|
||
streamUrl: safeUrlPath(chatPayload?.streamUrl),
|
||
responseParsed: chatPayload !== null,
|
||
responseParseError: chatPayloadError,
|
||
valuesRedacted: true
|
||
},
|
||
pageId
|
||
};
|
||
}
|
||
|
||
async function fillComposerEditor(editor, text) {
|
||
const tag = await editor.evaluate((element) => element.tagName.toLowerCase()).catch(() => "");
|
||
const editable = await editor.evaluate((element) => element.getAttribute("contenteditable") === "true").catch(() => false);
|
||
if (tag === "textarea" || tag === "input") await editor.fill(text);
|
||
else if (editable) {
|
||
await editor.click();
|
||
await page.keyboard.insertText(text);
|
||
} else {
|
||
await editor.click();
|
||
await page.keyboard.insertText(text);
|
||
}
|
||
}
|
||
|
||
async function clearComposerEditor(editor) {
|
||
const tag = await editor.evaluate((element) => element.tagName.toLowerCase()).catch(() => "");
|
||
const editable = await editor.evaluate((element) => element.getAttribute("contenteditable") === "true").catch(() => false);
|
||
if (tag === "textarea" || tag === "input") {
|
||
await editor.fill("");
|
||
return;
|
||
}
|
||
if (editable) {
|
||
await editor.click();
|
||
await page.keyboard.press(process.platform === "darwin" ? "Meta+A" : "Control+A").catch(() => {});
|
||
await page.keyboard.press("Backspace").catch(() => {});
|
||
}
|
||
}
|
||
|
||
async function composerButtonState(button) {
|
||
return button.evaluate((element) => ({
|
||
action: element.getAttribute("data-action") || null,
|
||
disabled: element.hasAttribute("disabled") || element.getAttribute("aria-disabled") === "true",
|
||
text: (element.textContent || "").trim().slice(0, 80),
|
||
title: element.getAttribute("title") || null,
|
||
ariaLabel: element.getAttribute("aria-label") || null,
|
||
testId: element.getAttribute("data-testid") || null,
|
||
})).catch((error) => ({ action: null, disabled: null, error: errorSummary(error), valuesRedacted: true }));
|
||
}
|
||
|
||
function sideEffectHasAuthoritativePromptSubmission(sideEffect) {
|
||
return Boolean(
|
||
(Array.isArray(sideEffect?.newRunIds) && sideEffect.newRunIds.length > 0)
|
||
|| (Array.isArray(sideEffect?.newTraceIds) && sideEffect.newTraceIds.length > 0)
|
||
|| Number(sideEffect?.messageCountDelta || 0) > 0
|
||
);
|
||
}
|
||
|
||
async function waitForPromptSideEffect(beforeEvidence, timeoutMs) {
|
||
await page.waitForFunction((before) => {
|
||
const current = (() => {
|
||
const text = document.body?.innerText || "";
|
||
const runIds = Array.from(new Set(text.match(/run_[A-Za-z0-9_:-]+/gu) || [])).slice(-20);
|
||
const traceIds = Array.from(new Set(text.match(/trc_[A-Za-z0-9_:-]+/gu) || [])).slice(-20);
|
||
const running = /Trace running|最近\s*\d+\s*(?:秒|分钟|分|小时)前|Code Agent\s*耗时/iu.test(text);
|
||
const executionError = /AgentRun error|agentrun:error:|provider-stream-disconnected|provider-unavailable/iu.test(text);
|
||
const visible = (element) => {
|
||
const rect = element.getBoundingClientRect();
|
||
const style = window.getComputedStyle(element);
|
||
return rect.width > 0 && rect.height > 0 && style.visibility !== "hidden" && style.display !== "none";
|
||
};
|
||
const messageCount = Array.from(document.querySelectorAll('article.message-card, .message-card[data-message-id], article[data-message-id]')).filter(visible).length;
|
||
const textBytes = new TextEncoder().encode(text).length;
|
||
return { runIds, traceIds, running, executionError, messageCount, textBytes };
|
||
})();
|
||
const beforeRuns = Array.isArray(before?.runIds) ? before.runIds : [];
|
||
const beforeTraces = Array.isArray(before?.traceIds) ? before.traceIds : [];
|
||
const newRun = current.runIds.some((id) => !beforeRuns.includes(id));
|
||
const newTrace = current.traceIds.some((id) => !beforeTraces.includes(id));
|
||
const newMessage = current.messageCount > Number(before?.messageCount || 0);
|
||
return newRun || newTrace || newMessage;
|
||
}, beforeEvidence || {}, { timeout: timeoutMs }).catch(() => null);
|
||
const after = await promptSideEffectSnapshot();
|
||
const beforeRuns = Array.isArray(beforeEvidence?.runIds) ? beforeEvidence.runIds : [];
|
||
const beforeTraces = Array.isArray(beforeEvidence?.traceIds) ? beforeEvidence.traceIds : [];
|
||
const newRunIds = after.runIds.filter((id) => !beforeRuns.includes(id));
|
||
const newTraceIds = after.traceIds.filter((id) => !beforeTraces.includes(id));
|
||
const messageCountDelta = Math.max(0, Number(after.messageCount || 0) - Number(beforeEvidence?.messageCount || 0));
|
||
return { ...after, newRunIds, newTraceIds, messageCountDelta, submitted: newRunIds.length > 0 || newTraceIds.length > 0 || messageCountDelta > 0, valuesRedacted: true };
|
||
}
|
||
|
||
async function promptSideEffectSnapshot() {
|
||
return page.evaluate(() => {
|
||
const text = document.body?.innerText || "";
|
||
const visible = (element) => {
|
||
const rect = element.getBoundingClientRect();
|
||
const style = window.getComputedStyle(element);
|
||
return rect.width > 0 && rect.height > 0 && style.visibility !== "hidden" && style.display !== "none";
|
||
};
|
||
return {
|
||
runIds: Array.from(new Set(text.match(/run_[A-Za-z0-9_:-]+/gu) || [])).slice(-20),
|
||
traceIds: Array.from(new Set(text.match(/trc_[A-Za-z0-9_:-]+/gu) || [])).slice(-20),
|
||
running: /Trace running|最近\s*\d+\s*(?:秒|分钟|分|小时)前|Code Agent\s*耗时/iu.test(text),
|
||
executionError: /AgentRun error|agentrun:error:|provider-stream-disconnected|provider-unavailable/iu.test(text),
|
||
messageCount: Array.from(document.querySelectorAll('article.message-card, .message-card[data-message-id], article[data-message-id]')).filter(visible).length,
|
||
textBytes: new TextEncoder().encode(text).length,
|
||
valuesRedacted: true
|
||
};
|
||
}).catch(() => ({ runIds: [], traceIds: [], running: false, executionError: false, messageCount: 0, textBytes: 0, valuesRedacted: true }));
|
||
}
|
||
|
||
${nodeWebObserveRunnerCommandActionsSource()}
|
||
|
||
async function selectProvider(provider) {
|
||
const target = String(provider || "").trim();
|
||
if (!target) throw new Error("selectProvider requires provider name");
|
||
const beforeUrl = currentPageUrl();
|
||
const beforePath = safeUrlPath(beforeUrl);
|
||
if (!String(beforePath || "").startsWith("/workbench")) throw new Error("selectProvider requires a Workbench page; currentPath=" + (beforePath || "-") + "; run observe command --type goto --path /workbench or --type newSession first");
|
||
const nativeSelect = await page.evaluate((name) => {
|
||
const normalized = String(name).toLowerCase();
|
||
const visible = (element) => {
|
||
const rect = element.getBoundingClientRect();
|
||
const style = window.getComputedStyle(element);
|
||
return rect.width > 0 && rect.height > 0 && style.visibility !== "hidden" && style.display !== "none";
|
||
};
|
||
for (const select of Array.from(document.querySelectorAll("select")).filter(visible)) {
|
||
const options = Array.from(select.options || []);
|
||
const option = options.find((item) => String(item.value || "").toLowerCase().includes(normalized) || String(item.textContent || "").toLowerCase().includes(normalized));
|
||
if (!option) continue;
|
||
select.value = option.value;
|
||
select.dispatchEvent(new Event("input", { bubbles: true }));
|
||
select.dispatchEvent(new Event("change", { bubbles: true }));
|
||
return { kind: "native-select", value: option.value, text: option.textContent || "" };
|
||
}
|
||
return null;
|
||
}, target).catch(() => null);
|
||
if (nativeSelect) {
|
||
await page.waitForTimeout(500);
|
||
return { beforeUrl, afterUrl: currentPageUrl(), provider: target, selected: nativeSelect, pageId };
|
||
}
|
||
const optionVisible = page.getByText(target, { exact: false }).last();
|
||
if (await optionVisible.isVisible().catch(() => false)) {
|
||
await optionVisible.click();
|
||
await page.waitForTimeout(500);
|
||
return { beforeUrl, afterUrl: currentPageUrl(), provider: target, selected: { kind: "visible-text" }, pageId };
|
||
}
|
||
const control = page.locator([
|
||
'[data-testid*="provider" i]',
|
||
'[data-testid*="model" i]',
|
||
'[aria-label*="provider" i]',
|
||
'[aria-label*="model" i]',
|
||
'[aria-label*="模型"]',
|
||
'[aria-label*="提供"]',
|
||
'[role="combobox"]',
|
||
'[aria-haspopup="listbox"]',
|
||
].join(", "));
|
||
const count = Math.min(await control.count().catch(() => 0), 60);
|
||
const attempts = [];
|
||
for (let index = count - 1; index >= 0; index -= 1) {
|
||
const item = control.nth(index);
|
||
const visible = await item.isVisible().catch(() => false);
|
||
if (!visible) continue;
|
||
const label = await item.evaluate((element) => String(element.getAttribute("aria-label") || element.getAttribute("data-testid") || element.textContent || "").slice(0, 200)).catch(() => "");
|
||
if (isProviderNavigationLabel(label)) continue;
|
||
if (!/provider|profile|model|模型|提供|codex|openai|moon|api/iu.test(label)) continue;
|
||
attempts.push({ index, label });
|
||
await item.click({ timeout: 3000 }).catch(() => null);
|
||
await page.waitForTimeout(300);
|
||
const option = page.getByText(target, { exact: false }).last();
|
||
if (await option.isVisible().catch(() => false)) {
|
||
await option.click();
|
||
await page.waitForTimeout(700);
|
||
return { beforeUrl, afterUrl: currentPageUrl(), provider: target, selected: { kind: "opened-control", controlIndex: index, label }, attempts, pageId };
|
||
}
|
||
await page.keyboard.press("Escape").catch(() => null);
|
||
}
|
||
const providerCandidates = await collectProviderCandidates();
|
||
throw new Error("provider option not found: " + target + "; providerCandidates=" + JSON.stringify(providerCandidates.slice(0, 50)) + "; attempts=" + JSON.stringify(attempts.slice(-10)));
|
||
}
|
||
|
||
async function collectProviderCandidates() {
|
||
return page.evaluate(() => {
|
||
const rows = [];
|
||
const seen = new Set();
|
||
const isNavigationLabel = (value) => {
|
||
const label = String(value || "").replace(/\s+/gu, " ").trim().toLowerCase();
|
||
if (!label) return false;
|
||
if (label === "api keys" || label === "kapi keys" || label === "profiles" || label === "rprofiles") return true;
|
||
return /^(?:api keys|profiles)$/iu.test(label.replace(/^[a-z]\s*/iu, ""));
|
||
};
|
||
const visible = (element) => {
|
||
const rect = element.getBoundingClientRect();
|
||
const style = window.getComputedStyle(element);
|
||
return rect.width > 0 && rect.height > 0 && style.visibility !== "hidden" && style.display !== "none";
|
||
};
|
||
const push = (kind, element, value, text) => {
|
||
const normalizedValue = String(value || "").trim().slice(0, 160);
|
||
const normalizedText = String(text || "").replace(/\s+/gu, " ").trim().slice(0, 220);
|
||
const label = (normalizedValue + " " + normalizedText).trim();
|
||
if (!label) return;
|
||
const key = (kind + ":" + label).toLowerCase();
|
||
if (seen.has(key)) return;
|
||
seen.add(key);
|
||
rows.push({ kind, value: normalizedValue, text: normalizedText, testId: String(element?.getAttribute?.("data-testid") || "").slice(0, 120), ariaLabel: String(element?.getAttribute?.("aria-label") || "").slice(0, 160) });
|
||
};
|
||
for (const select of Array.from(document.querySelectorAll("select")).filter(visible)) {
|
||
for (const option of Array.from(select.options || [])) push("select-option", select, option.value, option.textContent || "");
|
||
}
|
||
const selector = [
|
||
'[role="option"]',
|
||
'[role="menuitem"]',
|
||
'[data-radix-collection-item]',
|
||
'[data-testid*="provider" i]',
|
||
'[data-testid*="profile" i]',
|
||
'[data-testid*="model" i]',
|
||
'[aria-label*="provider" i]',
|
||
'[aria-label*="profile" i]',
|
||
'[aria-label*="model" i]',
|
||
'[aria-label*="模型"]',
|
||
'[aria-label*="提供"]',
|
||
'button'
|
||
].join(", ");
|
||
for (const element of Array.from(document.querySelectorAll(selector)).filter(visible)) {
|
||
const text = String(element.textContent || "").replace(/\s+/gu, " ").trim();
|
||
const ariaLabel = String(element.getAttribute("aria-label") || "");
|
||
const testId = String(element.getAttribute("data-testid") || "");
|
||
const haystack = text + " " + ariaLabel + " " + testId;
|
||
if (isNavigationLabel(haystack)) continue;
|
||
if (!/provider|profile|model|模型|提供|codex|openai|deepseek|gpt|api|flash|spark|claude|gemini|moon/iu.test(haystack)) continue;
|
||
push("visible-control", element, element.getAttribute("value") || "", text || ariaLabel || testId);
|
||
}
|
||
return rows.slice(0, 80);
|
||
}).catch((error) => [{ kind: "candidate-scan-error", value: "", text: String(error?.message || error).slice(0, 240), testId: "", ariaLabel: "" }]);
|
||
}
|
||
|
||
function isProviderNavigationLabel(value) {
|
||
const text = String(value || "").replace(/\s+/gu, " ").trim().toLowerCase();
|
||
if (!text) return false;
|
||
if (text === "api keys" || text === "kapi keys" || text === "profiles" || text === "rprofiles") return true;
|
||
return /^(?:api keys|profiles)$/iu.test(text.replace(/^[a-z]\s*/iu, ""));
|
||
}
|
||
|
||
async function clickSession(sessionId) {
|
||
if (!sessionId) throw new Error("clickSession requires --session-id or --value");
|
||
const beforeUrl = currentPageUrl();
|
||
const escaped = cssEscape(sessionId);
|
||
const candidate = page.locator("[data-session-id=\"" + escaped + "\"], [href*=\"" + escaped + "\"], text=" + sessionId).first();
|
||
await candidate.waitFor({ state: "visible", timeout: 15000 });
|
||
await candidate.click();
|
||
await page.waitForTimeout(1000);
|
||
return { beforeUrl, afterUrl: currentPageUrl(), sessionId, pageId };
|
||
}
|
||
|
||
async function preflightSummary() {
|
||
return { currentUrl: currentPageUrl(), title: await page.title().catch(() => null), pageId, auth: publicAuth(auth) };
|
||
}
|
||
|
||
async function samplePage(reason, options = {}) {
|
||
if (options?.refreshObserver !== false) await maybeRefreshObserverPage(reason);
|
||
const groupSeq = sampleSeq + 1;
|
||
if (page && !page.isClosed()) await sampleOnePage(page, { reason, groupSeq, pageRole: "control", targetPageId: pageId, pageEpoch: controlPageEpoch });
|
||
if (observerPage && !observerPage.isClosed()) {
|
||
await sampleOnePage(observerPage, { reason, groupSeq, pageRole: "observer", targetPageId: observerPageId, pageEpoch: observerPageEpoch }).catch((error) => appendJsonl(files.errors, eventRecord("observer-sample-error", { pageRole: "observer", pageId: observerPageId, pageEpoch: observerPageEpoch, error: errorSummary(error) })));
|
||
}
|
||
if (options?.screenshot !== false && screenshotIntervalMs > 0 && Date.now() - lastScreenshotAtMs >= screenshotIntervalMs) {
|
||
await captureScreenshot("checkpoint", "jpeg").catch((error) => appendJsonl(files.errors, eventRecord("screenshot-error", { pageRole: "control", pageId, error: errorSummary(error) })));
|
||
}
|
||
await writeHeartbeat({ status: terminalStatus });
|
||
}
|
||
|
||
async function sampleOnePage(targetPage, { reason, groupSeq, pageRole, targetPageId, pageEpoch }) {
|
||
sampleSeq += 1;
|
||
const dom = await targetPage.evaluate(() => {
|
||
const trim = (value, limit = 500) => String(value || "").replace(/\s+/g, " ").trim().slice(0, limit);
|
||
const visible = (element) => {
|
||
const rect = element.getBoundingClientRect();
|
||
const style = window.getComputedStyle(element);
|
||
return rect.width > 0 && rect.height > 0 && style.visibility !== "hidden" && style.display !== "none";
|
||
};
|
||
const textHashInput = (element) => trim(element.textContent || "", 800);
|
||
const loadingTextPattern = /加载中|\bLoading\b/iu;
|
||
const loadingUiPattern = /loading-state|loading-spinner|spinner|progress|skeleton|busy|pending/iu;
|
||
const codeLikeSelector = "pre,code,.trace-row-body,.trace-row-markdown,.markdown-body,.message-text,[class*='trace-row' i],[class*='terminal' i],[class*='log' i],[class*='output' i]";
|
||
const elementTextForLoading = (element) => [
|
||
element.textContent || "",
|
||
element.getAttribute("aria-label") || "",
|
||
element.getAttribute("title") || "",
|
||
element.getAttribute("data-testid") || ""
|
||
].map((value) => trim(value, 240)).filter(Boolean).join(" ");
|
||
const elementLooksLikeLoadingUi = (element) => {
|
||
const signal = [
|
||
element.getAttribute("class") || "",
|
||
element.getAttribute("data-testid") || "",
|
||
element.getAttribute("role") || "",
|
||
element.getAttribute("aria-busy") || "",
|
||
element.getAttribute("aria-label") || "",
|
||
element.getAttribute("title") || ""
|
||
].join(" ");
|
||
return element.getAttribute("aria-busy") === "true" || element.getAttribute("role") === "status" || loadingUiPattern.test(signal);
|
||
};
|
||
const elementIsCodeLike = (element) => Boolean(element.closest(codeLikeSelector)) && !elementLooksLikeLoadingUi(element);
|
||
const hasLoadingText = (element) => {
|
||
const text = elementTextForLoading(element);
|
||
if (!loadingTextPattern.test(text)) return false;
|
||
if (elementIsCodeLike(element)) return false;
|
||
return true;
|
||
};
|
||
const elementDescriptor = (element) => {
|
||
if (!element) return null;
|
||
const className = String(element.className || "").replace(/\s+/g, " ").trim().split(" ").slice(0, 6).join(" ");
|
||
const identityDescendant = element.querySelector("[data-trace-id], [data-message-id], [data-session-id]");
|
||
return {
|
||
tag: element.tagName.toLowerCase(),
|
||
testId: element.getAttribute("data-testid") || null,
|
||
role: element.getAttribute("role") || null,
|
||
id: element.getAttribute("id") || null,
|
||
className: className || null,
|
||
status: element.getAttribute("data-status") || element.getAttribute("aria-busy") || null,
|
||
sessionId: element.getAttribute("data-session-id") || identityDescendant?.getAttribute("data-session-id") || null,
|
||
messageId: element.getAttribute("data-message-id") || identityDescendant?.getAttribute("data-message-id") || null,
|
||
traceId: element.getAttribute("data-trace-id") || identityDescendant?.getAttribute("data-trace-id") || null,
|
||
ariaLabel: element.getAttribute("aria-label") || null
|
||
};
|
||
};
|
||
const ownerKindFor = (element) => {
|
||
const value = [
|
||
element.getAttribute("data-testid") || "",
|
||
element.getAttribute("class") || "",
|
||
element.getAttribute("role") || "",
|
||
element.tagName || ""
|
||
].join(" ").toLowerCase();
|
||
if (/message|turn|agent|assistant/.test(value)) return "turn";
|
||
if (/session|rail|sidebar|nav/.test(value)) return "session-nav";
|
||
if (/composer|prompt|input|textarea/.test(value)) return "composer";
|
||
if (/diagnostic|alert|error|warning/.test(value)) return "diagnostic";
|
||
if (/trace|event|terminal|log/.test(value)) return "trace";
|
||
if (/performance|metric|chart|table/.test(value)) return "performance";
|
||
if (/main|workspace|workbench|root/.test(value)) return "workbench";
|
||
return "unknown";
|
||
};
|
||
const ownerLabelFor = (element) => {
|
||
const heading = element.querySelector("h1,h2,h3,h4,[data-testid*='title' i],[class*='title' i],[class*='header' i]");
|
||
return trim(
|
||
element.getAttribute("aria-label")
|
||
|| element.getAttribute("data-testid")
|
||
|| (heading ? heading.textContent || "" : "")
|
||
|| element.getAttribute("class")
|
||
|| element.tagName,
|
||
160
|
||
);
|
||
};
|
||
const ownerKeyFor = (element) => {
|
||
const descriptor = elementDescriptor(element) || {};
|
||
return [
|
||
ownerKindFor(element),
|
||
descriptor.testId || descriptor.id || descriptor.role || descriptor.className || descriptor.tag || "unknown",
|
||
descriptor.sessionId || descriptor.messageId || descriptor.traceId || ""
|
||
].filter(Boolean).join(":").slice(0, 240);
|
||
};
|
||
const collectLoadingNodes = () => {
|
||
const candidates = Array.from(document.querySelectorAll("body *"))
|
||
.filter(visible)
|
||
.filter(hasLoadingText)
|
||
.filter((element) => !Array.from(element.children).some((child) => visible(child) && hasLoadingText(child)))
|
||
.slice(-80);
|
||
return candidates.map((element, index) => {
|
||
const rect = element.getBoundingClientRect();
|
||
const identityOwner = element.closest('[data-message-id], [data-trace-id], [data-session-id]');
|
||
const structuralOwner = element.closest('article.message-card, .message-card, [data-testid*="message" i], [data-testid*="turn" i], [data-testid*="composer" i], [data-testid*="session" i], [class*="composer" i], [class*="session" i], [class*="trace" i], [class*="diagnostic" i], article, section, aside, main, form, [role="status"], [role="alert"], [role="article"], [role="navigation"]');
|
||
const owner = identityOwner || structuralOwner || element;
|
||
const ownerDescriptor = elementDescriptor(owner);
|
||
return {
|
||
index,
|
||
tag: element.tagName.toLowerCase(),
|
||
className: String(element.className || "").slice(0, 180),
|
||
testId: element.getAttribute("data-testid"),
|
||
role: element.getAttribute("role"),
|
||
text: trim(elementTextForLoading(element), 240),
|
||
ownerKind: ownerKindFor(owner),
|
||
ownerKey: ownerKeyFor(owner),
|
||
ownerLabel: ownerLabelFor(owner),
|
||
owner: ownerDescriptor,
|
||
ownerText: trim(owner.textContent || "", 300),
|
||
rect: { x: Math.round(rect.x), y: Math.round(rect.y), width: Math.round(rect.width), height: Math.round(rect.height) },
|
||
};
|
||
});
|
||
};
|
||
const sessionIdForElement = (element) => {
|
||
const direct = element.getAttribute("data-session-id");
|
||
if (direct) return direct;
|
||
const href = element.getAttribute("href") || element.closest("a[href]")?.getAttribute("href") || "";
|
||
if (!href) return null;
|
||
try {
|
||
const parsed = new URL(href, location.href);
|
||
const match = parsed.pathname.match(/\/(?:workbench|workspace)\/sessions\/([^/?#]+)/u);
|
||
return match ? decodeURIComponent(match[1] || "") : null;
|
||
} catch {
|
||
const match = href.match(/\/(?:workbench|workspace)\/sessions\/([^/?#]+)/u);
|
||
return match ? decodeURIComponent(match[1] || "") : null;
|
||
}
|
||
};
|
||
const sessionTitleTextForElement = (element) => {
|
||
const titleNode = element.querySelector("[data-testid*='session-title' i], [data-testid*='session-name' i], [class*='session-title' i], [class*='session-name' i], [data-testid*='title' i], [class*='title' i]");
|
||
return trim(
|
||
(titleNode ? titleNode.textContent || "" : "")
|
||
|| element.getAttribute("aria-label")
|
||
|| element.getAttribute("title")
|
||
|| element.textContent
|
||
|| "",
|
||
240
|
||
);
|
||
};
|
||
const sessionTitleFallbackPattern = /^(?:Session\s+)?ses_[A-Za-z0-9_.-]+/iu;
|
||
const looksLikeSessionTitleFallback = (title, sessionId) => {
|
||
const text = trim(title, 240);
|
||
const id = String(sessionId || "").trim();
|
||
if (!text) return true;
|
||
if (sessionTitleFallbackPattern.test(text)) return true;
|
||
if (!id) return false;
|
||
return text === id || text.startsWith(id) || text.startsWith("Session " + id);
|
||
};
|
||
const collectSessionRailTitles = () => {
|
||
const candidates = Array.from(document.querySelectorAll(".session-tab[data-session-id], [role='tab'][data-session-id], [data-testid*='session' i][data-session-id], a[href*='/workbench/sessions/'], a[href*='/workspace/sessions/']"))
|
||
.filter(visible);
|
||
const seen = new Set();
|
||
const items = [];
|
||
for (const element of candidates) {
|
||
const sessionId = sessionIdForElement(element);
|
||
const titleText = sessionTitleTextForElement(element);
|
||
const key = (sessionId || "") + "|" + titleText;
|
||
if (seen.has(key)) continue;
|
||
seen.add(key);
|
||
const rect = element.getBoundingClientRect();
|
||
const fallbackTitle = looksLikeSessionTitleFallback(titleText, sessionId);
|
||
items.push({
|
||
index: items.length,
|
||
tag: element.tagName.toLowerCase(),
|
||
testId: element.getAttribute("data-testid"),
|
||
role: element.getAttribute("role"),
|
||
active: element.getAttribute("data-active") === "true" || element.getAttribute("aria-selected") === "true",
|
||
sessionId,
|
||
sessionIdPrefix: sessionId ? String(sessionId).slice(0, 12) : null,
|
||
titleText,
|
||
fallbackTitle,
|
||
rect: { x: Math.round(rect.x), y: Math.round(rect.y), width: Math.round(rect.width), height: Math.round(rect.height) },
|
||
});
|
||
}
|
||
const visibleItems = items.slice(0, 120);
|
||
const fallbackItems = visibleItems.filter((item) => item.fallbackTitle);
|
||
const visibleCount = visibleItems.length;
|
||
const fallbackTitleCount = fallbackItems.length;
|
||
return {
|
||
visibleCount,
|
||
fallbackTitleCount,
|
||
fallbackTitleRatio: visibleCount > 0 ? Number((fallbackTitleCount / visibleCount).toFixed(4)) : 0,
|
||
items: visibleItems.slice(0, 60),
|
||
fallbackItems: fallbackItems.slice(0, 12),
|
||
};
|
||
};
|
||
const diagnosticSummaryText = (element) => {
|
||
const summarySelectors = [
|
||
".api-error-diagnostic-summary-text p",
|
||
".api-error-diagnostic-summary-text",
|
||
"[class*='diagnostic-summary-text' i] p",
|
||
"[class*='diagnostic-summary-text' i]",
|
||
"[data-testid*='diagnostic-summary' i]",
|
||
"[data-testid*='error-summary' i]",
|
||
"[role='alert'] p",
|
||
"[role='alert']"
|
||
];
|
||
const parts = [];
|
||
for (const selector of summarySelectors) {
|
||
for (const candidate of Array.from(element.querySelectorAll(selector))) {
|
||
if (!visible(candidate)) continue;
|
||
const text = trim(candidate.textContent || "", 800);
|
||
if (text && !parts.includes(text)) parts.push(text);
|
||
}
|
||
}
|
||
const ownText = textHashInput(element);
|
||
const text = parts.length > 0 ? parts.join(" ") : ownText;
|
||
return text.replace(/\s+(?:!|i诊断|诊断详情)$/u, "").trim();
|
||
};
|
||
const diagnosticToggleOnly = (element, text) => {
|
||
const compact = String(text || "").trim();
|
||
if (!/^(?:!|i诊断|诊断|诊断详情)$/u.test(compact)) return false;
|
||
const tag = element.tagName.toLowerCase();
|
||
const role = element.getAttribute("role");
|
||
const aria = element.getAttribute("aria-label") || "";
|
||
const title = element.getAttribute("title") || "";
|
||
return tag === "button" || role === "button" || /诊断/u.test(aria) || /诊断/u.test(title);
|
||
};
|
||
const stableMessageText = (element) => {
|
||
const bodySelectors = [
|
||
".message-markdown.message-text",
|
||
".message-text",
|
||
"[data-message-body]",
|
||
"[data-testid='message-body']",
|
||
"[data-testid*='message-text' i]",
|
||
"[data-testid*='final-response' i]"
|
||
];
|
||
const parts = [];
|
||
for (const selector of bodySelectors) {
|
||
for (const candidate of Array.from(element.querySelectorAll(selector))) {
|
||
if (!visible(candidate)) continue;
|
||
const text = trim(candidate.textContent || "", 1200);
|
||
if (text && !parts.includes(text)) parts.push(text);
|
||
}
|
||
}
|
||
if (parts.length > 0) return parts.join(" ");
|
||
const clone = element.cloneNode(true);
|
||
for (const selector of [
|
||
".message-duration-meta",
|
||
".message-activity-meta",
|
||
".api-error-diagnostic",
|
||
"[class*='diagnostic' i]",
|
||
"[class*='trace' i]",
|
||
"[data-trace-id]",
|
||
"[data-testid*='trace' i]",
|
||
"[data-testid*='event' i]",
|
||
"[role='status']",
|
||
"[role='alert']",
|
||
"button"
|
||
]) {
|
||
for (const child of Array.from(clone.querySelectorAll(selector))) child.remove();
|
||
}
|
||
return trim(clone.textContent || "", 1200);
|
||
};
|
||
const numericAttr = (element, names) => {
|
||
for (const name of names) {
|
||
const raw = element.getAttribute(name);
|
||
const value = Number(raw);
|
||
if (Number.isFinite(value)) return value;
|
||
}
|
||
return null;
|
||
};
|
||
const textAttr = (element, names) => {
|
||
for (const name of names) {
|
||
const raw = element.getAttribute(name);
|
||
if (raw && String(raw).trim()) return String(raw).trim();
|
||
}
|
||
return null;
|
||
};
|
||
const summarize = (selector, limit) => Array.from(document.querySelectorAll(selector)).filter(visible).slice(-limit).map((element, index) => {
|
||
const rect = element.getBoundingClientRect();
|
||
const owner = element.closest('article.message-card, .message-card[data-message-id], article[data-message-id], [data-trace-id]');
|
||
const timeElement = element.matches("time,[datetime]") ? element : element.querySelector("time,[datetime]");
|
||
return {
|
||
index,
|
||
tag: element.tagName.toLowerCase(),
|
||
testId: element.getAttribute("data-testid"),
|
||
role: element.getAttribute("role"),
|
||
status: element.getAttribute("data-status") || element.getAttribute("aria-busy") || null,
|
||
sessionId: element.getAttribute("data-session-id") || owner?.getAttribute("data-session-id") || null,
|
||
messageId: element.getAttribute("data-message-id") || owner?.getAttribute("data-message-id") || element.getAttribute("id") || null,
|
||
traceId: element.getAttribute("data-trace-id") || owner?.getAttribute("data-trace-id") || null,
|
||
turnId: element.getAttribute("data-turn-id") || owner?.getAttribute("data-turn-id") || null,
|
||
projectedSeq: numericAttr(element, ["data-projected-seq", "data-projectedseq", "data-seq", "data-sequence", "aria-posinset"]),
|
||
sourceSeq: numericAttr(element, ["data-source-seq", "data-sourceseq", "data-source-event-seq"]),
|
||
eventSeq: numericAttr(element, ["data-event-seq", "data-eventseq"]),
|
||
eventTimestamp: textAttr(element, ["data-event-ts", "data-event-time", "data-timestamp", "datetime"]) || (timeElement ? textAttr(timeElement, ["datetime", "data-event-ts", "data-event-time", "data-timestamp"]) : null),
|
||
eventTimeText: timeElement ? trim(timeElement.textContent || "", 80) : null,
|
||
eventKind: textAttr(element, ["data-event-kind", "data-kind", "data-label", "data-status"]) || element.getAttribute("aria-label") || null,
|
||
text: textHashInput(element),
|
||
rect: { x: Math.round(rect.x), y: Math.round(rect.y), width: Math.round(rect.width), height: Math.round(rect.height) },
|
||
};
|
||
});
|
||
const summarizeMessages = (selector, limit) => Array.from(document.querySelectorAll(selector)).filter(visible).slice(-limit).map((element, index) => {
|
||
const rect = element.getBoundingClientRect();
|
||
return {
|
||
index,
|
||
tag: element.tagName.toLowerCase(),
|
||
testId: element.getAttribute("data-testid"),
|
||
role: element.getAttribute("role"),
|
||
dataRole: element.getAttribute("data-role"),
|
||
status: element.getAttribute("data-status") || element.getAttribute("aria-busy") || null,
|
||
sessionId: element.getAttribute("data-session-id") || null,
|
||
messageId: element.getAttribute("data-message-id") || element.getAttribute("id") || null,
|
||
traceId: element.getAttribute("data-trace-id") || null,
|
||
turnId: element.getAttribute("data-turn-id") || null,
|
||
durationText: trim(element.querySelector(".message-duration-meta")?.textContent || "", 120),
|
||
activityText: trim(element.querySelector(".message-activity-meta")?.textContent || "", 120),
|
||
text: stableMessageText(element),
|
||
rect: { x: Math.round(rect.x), y: Math.round(rect.y), width: Math.round(rect.width), height: Math.round(rect.height) },
|
||
};
|
||
});
|
||
const resourceTimingSample = (entry) => ({
|
||
name: entry.name.split(/[?#]/u)[0].slice(0, 240),
|
||
initiatorType: entry.initiatorType,
|
||
startTime: Math.round(entry.startTime),
|
||
duration: Math.round(entry.duration),
|
||
workerStart: Math.round(entry.workerStart || 0),
|
||
redirectStart: Math.round(entry.redirectStart || 0),
|
||
redirectEnd: Math.round(entry.redirectEnd || 0),
|
||
fetchStart: Math.round(entry.fetchStart || 0),
|
||
domainLookupStart: Math.round(entry.domainLookupStart || 0),
|
||
domainLookupEnd: Math.round(entry.domainLookupEnd || 0),
|
||
connectStart: Math.round(entry.connectStart || 0),
|
||
connectEnd: Math.round(entry.connectEnd || 0),
|
||
secureConnectionStart: Math.round(entry.secureConnectionStart || 0),
|
||
requestStart: Math.round(entry.requestStart || 0),
|
||
responseStart: Math.round(entry.responseStart || 0),
|
||
responseEnd: Math.round(entry.responseEnd || 0),
|
||
transferSize: Number.isFinite(Number(entry.transferSize)) ? Number(entry.transferSize) : null,
|
||
encodedBodySize: Number.isFinite(Number(entry.encodedBodySize)) ? Number(entry.encodedBodySize) : null,
|
||
decodedBodySize: Number.isFinite(Number(entry.decodedBodySize)) ? Number(entry.decodedBodySize) : null,
|
||
nextHopProtocol: entry.nextHopProtocol || null,
|
||
responseStatus: Number.isFinite(Number(entry.responseStatus)) ? Number(entry.responseStatus) : null,
|
||
serverTiming: Array.from(entry.serverTiming || []).slice(0, 8).map((item) => ({
|
||
name: String(item.name || "").slice(0, 80),
|
||
duration: Number.isFinite(Number(item.duration)) ? Math.round(Number(item.duration)) : null,
|
||
description: String(item.description || "").slice(0, 120)
|
||
})),
|
||
});
|
||
const url = location.href;
|
||
const routeSessionMatch = url.match(/\/workbench\/sessions\/([^/?#]+)/u);
|
||
const activeSession = document.querySelector('[data-active="true"][data-session-id], [aria-selected="true"][data-session-id], .active[data-session-id]');
|
||
const activeSessionId = activeSession ? activeSession.getAttribute("data-session-id") : null;
|
||
const messageSelector = 'article.message-card, .message-card[data-message-id], article[data-message-id]';
|
||
const traceSelector = '[data-testid*="trace" i], [class*="trace" i], [data-trace-id], [data-testid*="event" i]';
|
||
const diagnosticSelector = '.api-error-diagnostic, [class*="api-error-diagnostic" i], [class*="message-diagnostic" i], [class*="projection-diagnostic" i], [data-testid="api-error-diagnostic" i], [data-testid="error-diagnostic" i], [data-testid*="diagnostic" i], [role="alert"], [aria-live="assertive"]';
|
||
const messages = summarizeMessages(messageSelector, 80);
|
||
const traceRows = summarize(traceSelector, 30);
|
||
const loadings = collectLoadingNodes();
|
||
const sessionRail = collectSessionRailTitles();
|
||
const diagnostics = Array.from(document.querySelectorAll(diagnosticSelector)).filter(visible).slice(-40).map((element, index) => {
|
||
const rect = element.getBoundingClientRect();
|
||
const text = diagnosticSummaryText(element);
|
||
if (!text || diagnosticToggleOnly(element, text)) return null;
|
||
const traceMatch = text.match(/\b(?:trace_id=)?(trc_[A-Za-z0-9_-]+|[a-f0-9]{16,64})\b/iu);
|
||
const httpStatusMatch = text.match(/\bHTTP\s+([1-5][0-9]{2})\b/iu);
|
||
const idleMatch = text.match(/\bidle\s+(\d+)s\b/iu);
|
||
const waitingForMatch = text.match(/\bwaitingFor=([^\s；;，,)]+)/iu);
|
||
const lastEventLabelMatch = text.match(/\blastEventLabel=([^\s；;，,)]+)/iu);
|
||
const diagnosticCode = httpStatusMatch ? "http-" + httpStatusMatch[1] : /turn\s*超过|无新活动/iu.test(text) ? "turn-idle-no-activity" : /Failed to fetch/iu.test(text) ? "failed-to-fetch" : "diagnostic";
|
||
return {
|
||
index,
|
||
tag: element.tagName.toLowerCase(),
|
||
className: String(element.className || "").slice(0, 240),
|
||
testId: element.getAttribute("data-testid"),
|
||
role: element.getAttribute("role"),
|
||
compact: element.getAttribute("data-compact"),
|
||
expanded: element.getAttribute("data-expanded") || element.getAttribute("aria-expanded"),
|
||
title: element.getAttribute("title"),
|
||
diagnosticCode,
|
||
traceId: traceMatch?.[1] || null,
|
||
httpStatus: httpStatusMatch ? Number(httpStatusMatch[1]) : null,
|
||
idleSeconds: idleMatch ? Number(idleMatch[1]) : null,
|
||
waitingFor: waitingForMatch?.[1] || null,
|
||
lastEventLabel: lastEventLabelMatch?.[1] || null,
|
||
text,
|
||
rect: { x: Math.round(rect.x), y: Math.round(rect.y), width: Math.round(rect.width), height: Math.round(rect.height) },
|
||
};
|
||
}).filter(Boolean);
|
||
const turns = Array.from(document.querySelectorAll('article.message-card[data-role="agent"], .message-card[data-role="agent"], article[data-role="agent"]')).filter(visible).map((element, index) => {
|
||
const rect = element.getBoundingClientRect();
|
||
const text = textHashInput(element);
|
||
const traceElement = element.matches("[data-trace-id]") ? element : element.querySelector("[data-trace-id]");
|
||
const traceMatch = text.match(/\btrc_[A-Za-z0-9_-]+\b/u);
|
||
const durationText = trim(element.querySelector(".message-duration-meta")?.textContent || "", 120);
|
||
const activityText = trim(element.querySelector(".message-activity-meta")?.textContent || "", 120);
|
||
const directTraceId = element.getAttribute("data-trace-id") || traceElement?.getAttribute("data-trace-id") || traceMatch?.[0] || null;
|
||
return {
|
||
index,
|
||
role: element.getAttribute("data-role") || "agent",
|
||
status: element.getAttribute("data-status") || null,
|
||
sessionId: element.getAttribute("data-session-id") || null,
|
||
messageId: element.getAttribute("data-message-id") || element.getAttribute("id") || null,
|
||
traceId: directTraceId,
|
||
turnId: element.getAttribute("data-turn-id") || directTraceId,
|
||
durationText,
|
||
activityText,
|
||
text,
|
||
rect: { x: Math.round(rect.x), y: Math.round(rect.y), width: Math.round(rect.width), height: Math.round(rect.height) },
|
||
};
|
||
}).slice(-80);
|
||
const active = document.activeElement;
|
||
return {
|
||
url,
|
||
path: location.pathname,
|
||
routeSessionId: routeSessionMatch ? decodeURIComponent(routeSessionMatch[1]) : null,
|
||
activeSessionId,
|
||
title: document.title,
|
||
focus: active ? { tag: active.tagName.toLowerCase(), testId: active.getAttribute("data-testid"), role: active.getAttribute("role") } : null,
|
||
viewport: { width: window.innerWidth, height: window.innerHeight, devicePixelRatio: window.devicePixelRatio },
|
||
scroll: { x: Math.round(window.scrollX), y: Math.round(window.scrollY), height: Math.round(document.documentElement.scrollHeight), width: Math.round(document.documentElement.scrollWidth) },
|
||
messages,
|
||
traceRows,
|
||
loadings,
|
||
sessionRail,
|
||
diagnostics,
|
||
turns,
|
||
pageProvenance: {
|
||
url: location.href,
|
||
path: location.pathname,
|
||
title: document.title,
|
||
readyState: document.readyState,
|
||
timeOrigin: Math.round(performance.timeOrigin || 0),
|
||
navigationStartTime: (performance.getEntriesByType("navigation")[0] || null)?.startTime ?? null,
|
||
scripts: Array.from(document.scripts).map((element) => {
|
||
if (!element.src) return null;
|
||
try {
|
||
const url = new URL(element.src, location.href);
|
||
const keys = Array.from(url.searchParams.keys()).sort();
|
||
return url.pathname + (keys.length > 0 ? "?keys=" + keys.join(",") : "");
|
||
} catch {
|
||
return null;
|
||
}
|
||
}).filter(Boolean).sort(),
|
||
stylesheets: Array.from(document.querySelectorAll('link[rel~="stylesheet"][href]')).map((element) => {
|
||
try {
|
||
const url = new URL(element.href, location.href);
|
||
const keys = Array.from(url.searchParams.keys()).sort();
|
||
return url.pathname + (keys.length > 0 ? "?keys=" + keys.join(",") : "");
|
||
} catch {
|
||
return null;
|
||
}
|
||
}).filter(Boolean).sort(),
|
||
meta: Array.from(document.querySelectorAll("meta[name], meta[property]")).map((element) => ({
|
||
key: String(element.getAttribute("name") || element.getAttribute("property") || "").slice(0, 120),
|
||
content: String(element.getAttribute("content") || "").slice(0, 200),
|
||
})).filter((item) => item.key).sort((a, b) => a.key.localeCompare(b.key)),
|
||
},
|
||
performance: performance.getEntriesByType("resource").slice(-80).map(resourceTimingSample),
|
||
};
|
||
}).catch((error) => ({ error: errorSummary(error), url: pageUrl(targetPage) }));
|
||
const sample = {
|
||
seq: sampleSeq,
|
||
sampleGroupSeq: groupSeq,
|
||
ts: new Date().toISOString(),
|
||
reason,
|
||
pageRole,
|
||
pageId: targetPageId,
|
||
pageEpoch: Number.isFinite(Number(pageEpoch)) ? Number(pageEpoch) : 0,
|
||
commandId: activeCommandId,
|
||
observerInitiated: false,
|
||
...digestDom(dom, pageRole),
|
||
};
|
||
await appendJsonl(files.samples, sample);
|
||
}
|
||
|
||
function digestDom(dom, pageRole = "control") {
|
||
if (dom && dom.error) return dom;
|
||
const messages = Array.isArray(dom.messages) ? dom.messages.map((item) => ({ ...item, textHash: sha256Text(item.text || ""), textPreview: truncate(item.text || "", 160), textBytes: Buffer.byteLength(item.text || "") })) : [];
|
||
const traceRows = Array.isArray(dom.traceRows) ? dom.traceRows.map((item) => ({ ...item, textHash: sha256Text(item.text || ""), textPreview: truncate(item.text || "", 160), textBytes: Buffer.byteLength(item.text || "") })) : [];
|
||
const loadings = Array.isArray(dom.loadings) ? dom.loadings.map((item) => ({ ...item, textHash: sha256Text(item.text || ""), textPreview: truncate(item.text || "", 160), textBytes: Buffer.byteLength(item.text || ""), ownerTextHash: sha256Text(item.ownerText || ""), ownerTextPreview: truncate(item.ownerText || "", 160) })) : [];
|
||
const sessionRail = digestSessionRail(dom.sessionRail);
|
||
const diagnostics = Array.isArray(dom.diagnostics) ? dom.diagnostics.map((item) => ({ ...item, textHash: sha256Text(item.text || ""), textPreview: truncate(item.text || "", 260), textBytes: Buffer.byteLength(item.text || "") })) : [];
|
||
const turns = Array.isArray(dom.turns) ? dom.turns.map((item) => ({ ...item, textHash: sha256Text(item.text || ""), textPreview: truncate(item.text || "", 200), textBytes: Buffer.byteLength(item.text || "") })) : [];
|
||
const pageProvenance = normalizePageProvenance(dom.pageProvenance, { reason: "sample", pageLoadSeq: currentPageProvenance?.pageLoadSeq ?? pageLoadSeq });
|
||
if (pageRole === "control") currentPageProvenance = pageProvenance;
|
||
return { ...dom, messages, traceRows, loadings, sessionRail, diagnostics, turns, pageProvenance: compactPageProvenance(pageProvenance) };
|
||
}
|
||
|
||
function digestSessionRail(value) {
|
||
if (!value || typeof value !== "object") return null;
|
||
const items = Array.isArray(value.items) ? value.items.map((item) => {
|
||
const titleText = String(item?.titleText || item?.titlePreview || "");
|
||
return {
|
||
index: item?.index ?? null,
|
||
tag: item?.tag ?? null,
|
||
testId: item?.testId ?? null,
|
||
role: item?.role ?? null,
|
||
active: item?.active === true,
|
||
sessionId: item?.sessionId ?? null,
|
||
sessionIdPrefix: item?.sessionIdPrefix ?? (item?.sessionId ? String(item.sessionId).slice(0, 12) : null),
|
||
fallbackTitle: item?.fallbackTitle === true,
|
||
titleHash: sha256Text(titleText),
|
||
titlePreview: truncate(titleText, 160),
|
||
titleBytes: Buffer.byteLength(titleText),
|
||
rect: item?.rect ?? null,
|
||
};
|
||
}) : [];
|
||
const fallbackItems = items.filter((item) => item.fallbackTitle).slice(0, 12);
|
||
const visibleCount = Number(value.visibleCount ?? items.length);
|
||
const fallbackTitleCount = Number(value.fallbackTitleCount ?? fallbackItems.length);
|
||
return {
|
||
visibleCount: Number.isFinite(visibleCount) ? visibleCount : items.length,
|
||
fallbackTitleCount: Number.isFinite(fallbackTitleCount) ? fallbackTitleCount : fallbackItems.length,
|
||
fallbackTitleRatio: Number.isFinite(Number(value.fallbackTitleRatio)) ? Number(value.fallbackTitleRatio) : (items.length > 0 ? Number((fallbackItems.length / items.length).toFixed(4)) : 0),
|
||
items,
|
||
fallbackItems,
|
||
valuesRedacted: true,
|
||
};
|
||
}
|
||
|
||
async function captureScreenshot(reason, imageType = "png") {
|
||
if (!page || page.isClosed()) throw new Error("page is not available for screenshot");
|
||
artifactSeq += 1;
|
||
const safeReason = safeId(String(reason || "manual")).slice(0, 40) || "manual";
|
||
const type = imageType === "jpeg" || imageType === "jpg" ? "jpeg" : "png";
|
||
const ext = type === "jpeg" ? "jpg" : "png";
|
||
const file = path.join(dirs.screenshots, String(sampleSeq).padStart(6, "0") + "_" + String(artifactSeq).padStart(4, "0") + "_" + safeReason + "." + ext);
|
||
const options = type === "jpeg" ? { path: file, type: "jpeg", quality: 70, fullPage: false } : { path: file, type: "png", fullPage: false };
|
||
await page.screenshot(options);
|
||
const meta = await fileMeta(file);
|
||
const artifact = { seq: artifactSeq, sampleSeq, ts: new Date().toISOString(), kind: "screenshot", reason, path: file, type, byteCount: meta.byteCount, sha256: meta.sha256, pageId, currentUrl: currentPageUrl() };
|
||
await appendJsonl(files.artifacts, artifact);
|
||
lastScreenshotAtMs = Date.now();
|
||
return artifact;
|
||
}
|
||
|
||
function eventRecord(type, data) {
|
||
const clean = sanitize(data) || {};
|
||
return { ts: new Date().toISOString(), type, jobId, pageId: clean.pageId ?? pageId, pageRole: clean.pageRole ?? "control", sampleSeq, commandId: activeCommandId, ...clean };
|
||
}
|
||
|
||
function controlRecord(command, phase, detail) {
|
||
return {
|
||
ts: new Date().toISOString(),
|
||
seq: commandSeq,
|
||
phase,
|
||
commandId: command.id,
|
||
type: command.type,
|
||
source: command.source || "file",
|
||
input: commandInputSummary(command),
|
||
beforeUrl: command.beforeUrl || null,
|
||
afterUrl: currentPageUrl(),
|
||
pageId,
|
||
detail: sanitize(detail),
|
||
};
|
||
}
|
||
|
||
function commandInputSummary(command) {
|
||
const text = typeof command.text === "string" ? command.text : null;
|
||
return {
|
||
type: command.type,
|
||
path: command.path || null,
|
||
url: command.url ? safeUrl(command.url) : null,
|
||
sessionId: command.sessionId || command.value || null,
|
||
provider: command.provider || null,
|
||
label: command.label ? truncate(command.label, 200) : null,
|
||
textHash: text === null ? null : sha256Text(text),
|
||
textBytes: text === null ? null : Buffer.byteLength(text),
|
||
textPreview: null,
|
||
valuesRedacted: true,
|
||
};
|
||
}
|
||
|
||
async function appendJsonl(file, value) {
|
||
await appendFile(file, JSON.stringify(sanitize(value)) + "\n", { mode: 0o600 });
|
||
}
|
||
|
||
async function fileMeta(file) {
|
||
const [buffer, stats] = await Promise.all([readFile(file), stat(file)]);
|
||
return { byteCount: stats.size, sha256: "sha256:" + createHash("sha256").update(buffer).digest("hex") };
|
||
}
|
||
|
||
function currentPageUrl() {
|
||
return pageUrl(page);
|
||
}
|
||
|
||
function pageUrl(targetPage) {
|
||
try { return targetPage && !targetPage.isClosed() ? targetPage.url() : null; } catch { return null; }
|
||
}
|
||
|
||
function routeSessionIdFromUrl(value) {
|
||
try {
|
||
const pathname = new URL(String(value || ""), baseUrl).pathname;
|
||
const match = pathname.match(/\/workbench\/sessions\/([^/?#]+)/u);
|
||
return match ? decodeURIComponent(match[1] || "") : null;
|
||
} catch {
|
||
return null;
|
||
}
|
||
}
|
||
|
||
function safeFrameUrl(frame) {
|
||
try { return frame ? safeUrl(frame.url()) : null; } catch { return null; }
|
||
}
|
||
|
||
function safeUrl(value) {
|
||
try {
|
||
const url = new URL(String(value), baseUrl);
|
||
for (const key of Array.from(url.searchParams.keys())) {
|
||
if (/token|key|secret|password|auth|cookie/iu.test(key)) url.searchParams.set(key, "[redacted]");
|
||
}
|
||
return url.toString();
|
||
} catch {
|
||
return truncate(String(value || ""), 300);
|
||
}
|
||
}
|
||
|
||
function safeUrlPath(value) {
|
||
try {
|
||
return new URL(String(value || ""), baseUrl).pathname;
|
||
} catch {
|
||
return null;
|
||
}
|
||
}
|
||
|
||
function normalizeBaseUrl(value) {
|
||
const raw = value || "http://127.0.0.1:3000";
|
||
const url = new URL(raw);
|
||
return url.origin;
|
||
}
|
||
|
||
function parseViewport(value) {
|
||
const match = String(value).match(/^(\d{3,5})x(\d{3,5})$/u);
|
||
return match ? { width: Number(match[1]), height: Number(match[2]) } : { width: 1440, height: 900 };
|
||
}
|
||
|
||
function positiveInteger(value, fallback) {
|
||
const parsed = Number(value);
|
||
return Number.isFinite(parsed) && parsed >= 0 ? Math.floor(parsed) : fallback;
|
||
}
|
||
|
||
function positiveNumber(value, fallback) {
|
||
const parsed = Number(value);
|
||
return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
|
||
}
|
||
|
||
function requiredPositiveThreshold(raw, key) {
|
||
const parsed = Number(raw?.[key]);
|
||
if (!Number.isFinite(parsed) || parsed <= 0) {
|
||
throw new Error("UNIDESK_WEB_OBSERVE_ALERT_THRESHOLDS_JSON requires positive " + key + "; configure config/hwlab-node-lanes.yaml webProbe.alertThresholds");
|
||
}
|
||
return parsed;
|
||
}
|
||
|
||
function parseAlertThresholds(value) {
|
||
if (!value) {
|
||
throw new Error("UNIDESK_WEB_OBSERVE_ALERT_THRESHOLDS_JSON is required; configure config/hwlab-node-lanes.yaml webProbe.alertThresholds for the selected node/lane");
|
||
}
|
||
const raw = (() => {
|
||
try { return JSON.parse(value); } catch (error) { throw new Error("UNIDESK_WEB_OBSERVE_ALERT_THRESHOLDS_JSON is invalid JSON: " + (error instanceof Error ? error.message : String(error))); }
|
||
})();
|
||
const sessionRailFallbackRatio = requiredPositiveThreshold(raw, "sessionRailFallbackRatio");
|
||
if (sessionRailFallbackRatio > 1) {
|
||
throw new Error("UNIDESK_WEB_OBSERVE_ALERT_THRESHOLDS_JSON sessionRailFallbackRatio must be <= 1");
|
||
}
|
||
return {
|
||
sameOriginApiSlowMs: requiredPositiveThreshold(raw, "sameOriginApiSlowMs"),
|
||
partialApiSlowMs: requiredPositiveThreshold(raw, "partialApiSlowMs"),
|
||
longLivedStreamOpenSlowMs: requiredPositiveThreshold(raw, "longLivedStreamOpenSlowMs"),
|
||
visibleLoadingSlowMs: requiredPositiveThreshold(raw, "visibleLoadingSlowMs"),
|
||
turnTimingSampleSlackSeconds: requiredPositiveThreshold(raw, "turnTimingSampleSlackSeconds"),
|
||
uncommandedStateChangeCommandWindowMs: requiredPositiveThreshold(raw, "uncommandedStateChangeCommandWindowMs"),
|
||
scrollJumpCommandWindowMs: requiredPositiveThreshold(raw, "scrollJumpCommandWindowMs"),
|
||
scrollJumpFromY: requiredPositiveThreshold(raw, "scrollJumpFromY"),
|
||
scrollJumpToY: requiredPositiveThreshold(raw, "scrollJumpToY"),
|
||
sessionRailFallbackRatio,
|
||
crossPageProjectionDivergenceRedMs: positiveNumber(raw.crossPageProjectionDivergenceRedMs, requiredPositiveThreshold(raw, "visibleLoadingSlowMs")),
|
||
source: "yaml-env",
|
||
};
|
||
}
|
||
|
||
function sha256Text(value) {
|
||
return "sha256:" + createHash("sha256").update(String(value)).digest("hex");
|
||
}
|
||
|
||
function safeId(value) {
|
||
return String(value || "").replace(/[^A-Za-z0-9_.-]+/gu, "-").replace(/^-+|-+$/gu, "").slice(0, 120) || "item";
|
||
}
|
||
|
||
function cssEscape(value) {
|
||
return String(value).replace(/\\/gu, "\\\\").replace(/"/gu, "\\\"");
|
||
}
|
||
|
||
function truncate(value, limit) {
|
||
const text = String(value || "");
|
||
return text.length > limit ? text.slice(0, limit) + "..." : text;
|
||
}
|
||
|
||
function sanitize(value) {
|
||
if (value === null || value === undefined) return value;
|
||
if (typeof value === "string") return value === password ? "[redacted]" : value.replaceAll(password, "[redacted]");
|
||
if (typeof value === "number" || typeof value === "boolean") return value;
|
||
if (Array.isArray(value)) return value.map(sanitize);
|
||
if (typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, item]) => /password|cookie|authorization|token|secret/iu.test(key) ? [key, "[redacted]"] : [key, sanitize(item)]));
|
||
return String(value);
|
||
}
|
||
|
||
function errorSummary(error) {
|
||
const summary = { name: error && error.name ? error.name : "Error", message: error && error.message ? truncate(error.message, 1000) : truncate(String(error), 1000), stackTail: error && error.stack ? truncate(error.stack, 2000) : null };
|
||
if (error && error.webProbeAuth) summary.auth = sanitize(error.webProbeAuth);
|
||
if (error && Array.isArray(error.attempts)) summary.attempts = sanitize(error.attempts.slice(-5));
|
||
if (error && error.navigationReadiness) summary.navigationReadiness = sanitize(error.navigationReadiness);
|
||
if (error && error.details) summary.details = sanitize(error.details);
|
||
if (error && error.target) summary.target = sanitize(error.target);
|
||
return summary;
|
||
}
|
||
|
||
function sleep(ms) {
|
||
return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
|
||
}
|
||
`;
|
||
}
|