保留原生浏览器探针失败阶段与清理证据（09-06-release-gate-integrity）

scripts/qa/browser-environment-probe.mjs

@@ -66,21 +66,119 @@ export async function observeGuestEntry(context, baseURL, timeout = 30000) {
   return observed;
 }
 
-async function observeNativeEngine(engine, name, owner) {
-  const server = await engine.launchServer({ headless: true, host: "127.0.0.1" });
-  let browser;
-  try {
-    const browserNamespace = namespaceFingerprint(server.process().pid);
-    if (browserNamespace !== owner.ownedNamespace) throw new Error("environment_browser_namespace_mismatch");
-    browser = await engine.connect(server.wsEndpoint());
-    const context = await browser.newContext({ serviceWorkers: "block" });
-    const page = await context.newPage();
-    const online = await page.evaluate(() => navigator.onLine);
-    return { name, version: browser.version(), valid: online === true, online, browserNamespace, browserMatchesOwnedChild: true, noNavigatorOverride: true };
-  } finally {
-    await browser?.close().catch(() => {});
-    await server.close();
+// Browser errors may include executable paths, websocket endpoints and process
+// environments. Persist only classifications, never the message or stack.
+function nativeFailure(error, stage) {
+  const message = typeof error?.message === "string" ? error.message : "";
+  const failure = { stage, errorKind: "browser_operation_failed" };
+  if (message === "environment_browser_namespace_mismatch") failure.errorKind = message;
+  else if (error?.name === "TimeoutError" || /Timeout \d+ms exceeded/i.test(message)) failure.errorKind = "probe_timeout";
+  else if (/error while loading shared libraries|cannot open shared object file|host system is missing dependencies/i.test(message)) failure.errorKind = "browser_dependency_missing";
+  else if (/executable doesn.t exist|spawn .* ENOENT/i.test(message)) failure.errorKind = "browser_executable_missing";
+  else if (/permission denied|operation not permitted|EACCES|EPERM/i.test(message)) failure.errorKind = "browser_permission_denied";
+  else if (/Target .*closed|browser.*closed|process did exit/i.test(message)) failure.errorKind = "browser_process_closed";
+  if (["ENOENT", "EACCES", "EPERM", "ECONNREFUSED", "ECONNRESET", "ETIMEDOUT"].includes(error?.code)) failure.systemCode = error.code;
+  const exit = /<process did exit: exitCode=(null|-?\d+), signal=(null|SIG[A-Z0-9]+)>/.exec(message);
+  if (exit) {
+    failure.processExitCode = exit[1] === "null" ? null : Number(exit[1]);
+    // Only standard names; do not echo arbitrary text resembling a signal.
+    if (["null", "SIGABRT", "SIGSEGV", "SIGILL", "SIGBUS", "SIGKILL", "SIGTERM", "SIGTRAP"].includes(exit[2])) failure.processSignal = exit[2] === "null" ? null : exit[2];
   }
+  return failure;
+}
+
+export async function observeNativeEngine(engine, name, owner, { fingerprint = namespaceFingerprint, tracePath, observeSibling } = {}) {
+  const result = { name, version: null, valid: false, online: null, browserNamespace: null, browserMatchesOwnedChild: false, noNavigatorOverride: true, failures: [] };
+  let stage = "launch";
+  let server;
+  let browser;
+  let context;
+  let tracing = false;
+  const fail = failure => {
+    result.valid = false;
+    result.failures.push(failure);
+    result.errorKind ??= failure.errorKind;
+    result.failureStage ??= failure.stage;
+  };
+  try {
+    server = await engine.launchServer({ headless: true, host: "127.0.0.1" });
+    stage = "namespace";
+    result.browserNamespace = fingerprint(server.process().pid);
+    result.browserMatchesOwnedChild = result.browserNamespace === owner.ownedNamespace;
+    if (!result.browserMatchesOwnedChild) throw new Error("environment_browser_namespace_mismatch");
+    stage = "connect";
+    browser = await engine.connect(server.wsEndpoint());
+    stage = "version";
+    result.version = browser.version();
+    stage = "context";
+    context = await browser.newContext({ serviceWorkers: "block" });
+    if (tracePath) {
+      stage = "trace_start";
+      await context.tracing.start({ screenshots: true, snapshots: true, sources: true });
+      tracing = true;
+    }
+    stage = "page";
+    const page = await context.newPage();
+    stage = "online";
+    const observedOnline = await page.evaluate(() => navigator.onLine);
+    result.online = typeof observedOnline === "boolean" ? observedOnline : null;
+    result.valid = result.online === true;
+    if (!result.valid) fail({ stage, errorKind: result.online === false ? "native_online_observed_false" : "native_online_observation_missing" });
+    // Retain the existing successful lifecycle: Chromium is still alive while
+    // WebKit is observed, so diagnostics do not silently change that condition.
+    stage = "sibling";
+    await observeSibling?.();
+  } catch (error) {
+    fail(nativeFailure(error, stage));
+  } finally {
+    for (const [cleanupStage, close] of [
+      ["trace_stop", tracing ? () => context.tracing.stop({ path: tracePath }) : null],
+      ["context_close", context ? () => context.close() : null],
+      ["browser_close", browser ? () => browser.close() : null],
+      ["server_close", server ? () => server.close() : null],
+    ]) {
+      if (!close) continue;
+      try { await close(); }
+      catch (error) {
+        fail(nativeFailure(error, cleanupStage));
+        if (cleanupStage === "server_close") {
+          try { await server.kill(); }
+          catch (killError) { fail(nativeFailure(killError, "server_kill")); }
+        }
+      }
+    }
+  }
+  return result;
+}
+
+export async function observeNativeProbe({ chromium, webkit }, owner, { fingerprint = namespaceFingerprint } = {}) {
+  let webkitResult;
+  const observeWebkit = async () => {
+    webkitResult = await observeNativeEngine(webkit, "webkit", owner, { fingerprint, tracePath: path.join(owner.environmentDir, "native-webkit-trace.zip") });
+  };
+  const chromiumResult = await observeNativeEngine(chromium, "chromium", owner, {
+    fingerprint, tracePath: path.join(owner.environmentDir, "native-trace.zip"), observeSibling: observeWebkit,
+  });
+  if (!webkitResult) await observeWebkit();
+  const engines = [chromiumResult, webkitResult];
+  return {
+    valid: engines.every(engine => engine.valid), scope: "blank-page-native-probe",
+    online: chromiumResult.online, browserNamespace: chromiumResult.browserNamespace,
+    browserMatchesOwnedChild: chromiumResult.browserMatchesOwnedChild, noNavigatorOverride: true,
+    errorKind: engines.every(engine => engine.valid) ? null : "native_engine_probe_failed", engines,
+  };
+}
+
+export async function recordNativeProbe(engines, owner, { verify = verifyManagedEnvironment, write = atomicEnvironmentJson, fingerprint = namespaceFingerprint } = {}) {
+  const result = await observeNativeProbe(engines, owner, { fingerprint });
+  try { verify(); }
+  catch (error) {
+    result.valid = false;
+    result.errorKind ??= "environment_recheck_failed";
+    result.environmentFailure = nativeFailure(error, "environment_recheck");
+  }
+  write(path.join(owner.environmentDir, "native-online.json"), result);
+  return result;
 }
 
 async function main(mode, baseURL) {
@@ -88,6 +186,12 @@ async function main(mode, baseURL) {
   const { context: owner } = verifyManagedEnvironment();
   const require = createRequire(path.join(root, "client/package.json"));
   const { chromium, webkit } = require("@playwright/test");
+  if (mode === "native") {
+    const result = await recordNativeProbe({ chromium, webkit }, owner);
+    console.log(`[environment] native probe ${result.valid ? "PASS" : "FAIL"}`);
+    if (!result.valid) process.exitCode = 1;
+    return;
+  }
   const server = await chromium.launchServer({ headless: true, host: "127.0.0.1" });
   let browser;
   let context;
@@ -102,13 +206,7 @@ async function main(mode, baseURL) {
     context = await browser.newContext({ serviceWorkers: "block" });
     await context.tracing.start({ screenshots: true, snapshots: true, sources: true });
     tracing = true;
-    if (mode === "native") {
-      const page = await context.newPage();
-      const online = await page.evaluate(() => navigator.onLine);
-      result = { valid: online === true, scope: "blank-page-native-probe", online, errorKind: online === true ? null : online === false ? "native_online_observed_false" : "native_online_observation_missing", browserNamespace, browserMatchesOwnedChild, noNavigatorOverride: true };
-      result.engines = [{ name: "chromium", version: browser.version(), valid: online === true, online, browserNamespace, browserMatchesOwnedChild, noNavigatorOverride: true }, await observeNativeEngine(webkit, "webkit", owner)];
-      result.valid = result.engines.every(engine => engine.valid);
-    } else result = { ...await observeGuestEntry(context, baseURL), browserNamespace, browserMatchesOwnedChild, noNavigatorOverride: true };
+    result = { ...await observeGuestEntry(context, baseURL), browserNamespace, browserMatchesOwnedChild, noNavigatorOverride: true };
     verifyManagedEnvironment();
   } catch (error) {
     result.valid = false;