@introspection-ai/recipes 0.25.1 → 0.27.1

package/dist/mcp-chunks/{chunk-EMSNQHZZ.js → chunk-FONFU4G5.js}

@@ -1,6 +1,6 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 
-// node_modules/.pnpm/mcporter@0.13.8/node_modules/mcporter/dist/sdk-stdio-logging.js
+// node_modules/.pnpm/mcporter@0.13.13/node_modules/mcporter/dist/sdk-stdio-logging.js
 var STDIO_LOGS_FORCED = process.env.MCPORTER_STDIO_LOGS === "1";
 var STDIO_TRACE_ENABLED = process.env.MCPORTER_STDIO_TRACE === "1";
 var stdioLogMode = STDIO_LOGS_FORCED ? "always" : "auto";

package/dist/mcp-chunks/{chunk-BWW4XRUC.js → chunk-H4KL74PV.js}

@@ -1,22 +1,13 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
-import {
-  resolveCommandArgument,
-  resolveCommandArguments
-} from "./chunk-I5GI2A2D.js";
 import {
   parseTree
-} from "./chunk-RD7NHCRK.js";
+} from "./chunk-T4MQCFIK.js";
 import {
+  resolveEnvPlaceholders,
   resolveEnvValue
-} from "./chunk-WTMJMM3B.js";
-
-// node_modules/.pnpm/mcporter@0.13.8/node_modules/mcporter/dist/chrome-devtools-relay.js
-import { createHash as createHash3 } from "node:crypto";
-import fs from "node:fs";
-import os from "node:os";
-import path2 from "node:path";
+} from "./chunk-D6SVCPN6.js";
 
-// node_modules/.pnpm/mcporter@0.13.8/node_modules/mcporter/dist/chrome-devtools-command.js
+// node_modules/.pnpm/mcporter@0.13.13/node_modules/mcporter/dist/chrome-devtools-command.js
 var AUTO_CONNECT_FLAGS = /* @__PURE__ */ new Set(["--autoConnect", "--auto-connect"]);
 var NEGATED_AUTO_CONNECT_FLAGS = /* @__PURE__ */ new Set(["--no-autoConnect", "--no-auto-connect"]);
 var CONNECTION_VALUE_FLAGS = /* @__PURE__ */ new Set([
@@ -76,6 +67,19 @@ function isChromeDevtoolsToken(token) {
   const basename = normalized.slice(normalized.lastIndexOf("/") + 1);
   return /^chrome-devtools-mcp(?:@[^/]+)?(?:\.(?:bat|cjs|cmd|exe|js|mjs))?$/u.test(basename) || normalized.includes("/chrome-devtools-mcp/") && /\.(?:bat|cjs|cmd|exe|js|mjs)$/u.test(basename);
 }
+function isExistingChromeDevtoolsCommand(command, args) {
+  if (isAmbiguousChromeDevtoolsAutoConnectCommand(command, args))
+    return true;
+  if (resolveChromeDevtoolsAutoConnectCommand(command, args).enabled)
+    return true;
+  const target = resolveChromeDevtoolsTarget(command, args);
+  if (!target)
+    return true;
+  return target.args.some((arg) => {
+    const option = arg.split("=")[0] ?? arg;
+    return CONNECTION_VALUE_FLAGS.has(option) || /^-[^-]/u.test(option) && [...CONNECTION_VALUE_FLAGS].some((flag) => flag.length === 2 && option.includes(flag.slice(1)));
+  });
+}
 function isAmbiguousChromeDevtoolsAutoConnectCommand(command, args) {
   if (isChromeDevtoolsToken(command))
     return false;
@@ -273,7 +277,94 @@ function booleanLiteral(value) {
   return void 0;
 }
 
-// node_modules/.pnpm/mcporter@0.13.8/node_modules/mcporter/dist/chrome-devtools-relay-proxy.js
+// node_modules/.pnpm/mcporter@0.13.13/node_modules/mcporter/dist/runtime/utils.js
+var ENV_PLACEHOLDER_PATTERN = /\$\{(?:env:[^}]*|[A-Za-z_][A-Za-z0-9_]*(?::-[^}]*)?)\}/;
+var MAX_TIMER_DELAY_MS = 2147483647;
+function resolveCommandArgument(value, env = process.env) {
+  if (!value) {
+    return value;
+  }
+  if (!value.includes("$")) {
+    return value;
+  }
+  const needsInterpolation = value.startsWith("$env:") || ENV_PLACEHOLDER_PATTERN.test(value);
+  if (!needsInterpolation) {
+    return value;
+  }
+  return resolveEnvPlaceholders(value, env);
+}
+function resolveCommandArguments(args, env = process.env) {
+  if (args.length === 0) {
+    return [];
+  }
+  return args.map((arg) => resolveCommandArgument(arg, env));
+}
+function normalizeTimeout(raw) {
+  if (raw == null) {
+    return void 0;
+  }
+  if (!Number.isFinite(raw)) {
+    return void 0;
+  }
+  const coerced = Math.trunc(raw);
+  return coerced > 0 ? Math.min(coerced, MAX_TIMER_DELAY_MS) : void 0;
+}
+function raceWithTimeout(promise, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const delayMs = Number.isFinite(timeoutMs) ? Math.min(Math.max(Math.trunc(timeoutMs), 1), MAX_TIMER_DELAY_MS) : MAX_TIMER_DELAY_MS;
+    const cancelTimeout = scheduleDeadline(() => {
+      reject(new Error("Timeout"));
+    }, delayMs);
+    promise.then((value) => {
+      cancelTimeout();
+      resolve(value);
+    }, (error) => {
+      cancelTimeout();
+      reject(error);
+    });
+  });
+}
+function scheduleDeadline(callback, delayMs) {
+  const deadline = performance.now() + delayMs;
+  let timer;
+  let cancelled = false;
+  const scheduleNext = () => {
+    if (cancelled)
+      return;
+    const remainingMs = deadline - performance.now();
+    if (remainingMs <= 0) {
+      callback();
+    } else if (remainingMs > 864e5) {
+      timer = setTimeout(scheduleNext, 864e5);
+    } else if (remainingMs > 36e5) {
+      timer = setTimeout(scheduleNext, 36e5);
+    } else if (remainingMs > 6e4) {
+      timer = setTimeout(scheduleNext, 6e4);
+    } else if (remainingMs > 1e3) {
+      timer = setTimeout(scheduleNext, 1e3);
+    } else if (remainingMs > 100) {
+      timer = setTimeout(scheduleNext, 100);
+    } else if (remainingMs > 10) {
+      timer = setTimeout(scheduleNext, 10);
+    } else {
+      timer = setTimeout(scheduleNext, 1);
+    }
+  };
+  scheduleNext();
+  return () => {
+    cancelled = true;
+    if (timer)
+      clearTimeout(timer);
+  };
+}
+
+// node_modules/.pnpm/mcporter@0.13.13/node_modules/mcporter/dist/chrome-devtools-relay.js
+import { createHash as createHash3 } from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path2 from "node:path";
+
+// node_modules/.pnpm/mcporter@0.13.13/node_modules/mcporter/dist/chrome-devtools-relay-proxy.js
 import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
 import http, {} from "node:http";
 var WEBSOCKET_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
@@ -282,9 +373,33 @@ async function startChromeDevtoolsRelayProxy(options) {
   const clientAuthorization = `Bearer ${randomBytes(32).toString("base64url")}`;
   let downstreamAccepted = false;
   let closed = false;
+  const lifetime = new AbortController();
+  let closing;
   const server = http.createServer((_request, response) => {
     response.writeHead(404, { Connection: "close", "Content-Length": "0" }).end();
   });
+  const binding = Promise.withResolvers();
+  const terminate = (reason) => {
+    if (closing)
+      return closing;
+    closed = true;
+    closing = binding.promise.catch(() => {
+    }).then(() => closeServer(server, sockets));
+    lifetime.abort(reason);
+    closeUpstream(options.upstream.socket);
+    for (const socket of sockets)
+      socket.destroy();
+    return closing;
+  };
+  const onUpstreamError = () => {
+    void terminate("upstream");
+  };
+  const onUpstreamClose = () => {
+    options.upstream.socket.off("error", onUpstreamError);
+    void terminate("upstream");
+  };
+  options.upstream.socket.on("error", onUpstreamError);
+  options.upstream.socket.once("close", onUpstreamClose);
   server.on("connection", (socket) => trackSocket(sockets, socket));
   server.on("upgrade", (request, downstream, head) => {
     if (closed || downstreamAccepted || !isValidDownstreamUpgrade(request, clientAuthorization) || options.upstream.socket.destroyed) {
@@ -310,53 +425,44 @@ async function startChromeDevtoolsRelayProxy(options) {
       downstream.write(options.upstream.head);
     if (head.length > 0)
       options.upstream.socket.write(head);
-    options.upstream.socket.once("error", () => downstream.destroy());
-    options.upstream.socket.once("close", () => downstream.destroy());
-    downstream.once("error", () => options.upstream.socket.destroy());
-    downstream.once("close", () => options.upstream.socket.destroy());
+    downstream.once("error", () => void terminate("downstream"));
+    downstream.once("close", () => void terminate("downstream"));
     downstream.pipe(options.upstream.socket).pipe(downstream);
     server.close();
   });
-  const onUpstreamClose = () => {
-    void closeServer(server, sockets);
-  };
-  options.upstream.socket.once("close", onUpstreamClose);
+  const onBindError = (error) => binding.reject(error);
+  server.once("error", onBindError);
   try {
-    await new Promise((resolve, reject) => {
-      const onError = (error) => reject(error);
-      server.once("error", onError);
-      server.listen(0, "127.0.0.1", () => {
-        server.off("error", onError);
-        resolve();
-      });
+    server.listen(0, "127.0.0.1", () => {
+      server.off("error", onBindError);
+      binding.resolve();
     });
+    await binding.promise;
   } catch (error) {
-    closeUpstream(options.upstream.socket);
+    binding.reject(error);
+    await terminate("owner");
     throw error;
   }
+  if (closed || options.upstream.socket.destroyed) {
+    await terminate("upstream");
+    throw new Error("Chrome relay connection closed before child handoff.");
+  }
   const address = server.address();
   if (!address || address.address !== "127.0.0.1") {
-    closeUpstream(options.upstream.socket);
-    server.close();
+    await terminate("owner");
     throw new Error("Chrome relay proxy failed to bind to IPv4 loopback.");
   }
   let authorizationAvailable = true;
   return {
     endpoint: `ws://127.0.0.1:${address.port}/cdp`,
+    signal: lifetime.signal,
     consumeClientAuthorization() {
       if (!authorizationAvailable)
         throw new Error("Chrome relay authorization handoff already consumed.");
       authorizationAvailable = false;
       return clientAuthorization;
     },
-    async close() {
-      if (closed)
-        return;
-      closed = true;
-      options.upstream.socket.off("close", onUpstreamClose);
-      closeUpstream(options.upstream.socket);
-      await closeServer(server, sockets);
-    }
+    close: () => terminate("owner")
   };
 }
 function isValidDownstreamUpgrade(request, expectedAuthorization) {
@@ -414,7 +520,7 @@ async function closeServer(server, sockets) {
   await new Promise((resolve) => server.close(() => resolve()));
 }
 
-// node_modules/.pnpm/mcporter@0.13.8/node_modules/mcporter/dist/browser-relay-auth-v2.js
+// node_modules/.pnpm/mcporter@0.13.13/node_modules/mcporter/dist/browser-relay-auth-v2.js
 import { createHmac, hash, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
 var BROWSER_RELAY_AUTH_LABEL = "openclaw.browser-relay.auth";
 var BROWSER_RELAY_AUTH_VERSION = 2;
@@ -483,7 +589,7 @@ function isCanonicalBase64Url(value, bytes) {
   return decoded.byteLength === bytes && decoded.toString("base64url") === value;
 }
 
-// node_modules/.pnpm/mcporter@0.13.8/node_modules/mcporter/dist/chrome-devtools-relay-client.js
+// node_modules/.pnpm/mcporter@0.13.13/node_modules/mcporter/dist/chrome-devtools-relay-client.js
 import { createHash as createHash2, randomBytes as randomBytes2 } from "node:crypto";
 import { lookup } from "node:dns/promises";
 import net from "node:net";
@@ -994,7 +1100,7 @@ function isTimeoutError(error) {
   return Boolean(error && typeof error === "object" && error.reason === "timeout");
 }
 
-// node_modules/.pnpm/mcporter@0.13.8/node_modules/mcporter/dist/chrome-devtools-relay-discovery.js
+// node_modules/.pnpm/mcporter@0.13.13/node_modules/mcporter/dist/chrome-devtools-relay-discovery.js
 import { spawn } from "node:child_process";
 import { statSync } from "node:fs";
 import net2 from "node:net";
@@ -1448,16 +1554,13 @@ function openClawDiscoveryEnvironment(env) {
   return filtered;
 }
 
-// node_modules/.pnpm/mcporter@0.13.8/node_modules/mcporter/dist/chrome-devtools-relay.js
-var DEFAULT_RELAY_PROBE_TIMEOUT_MS = 5e3;
+// node_modules/.pnpm/mcporter@0.13.13/node_modules/mcporter/dist/chrome-devtools-relay.js
+var DEFAULT_RELAY_PROBE_TIMEOUT_MS = 2e4;
 var MIN_RELAY_PROBE_TIMEOUT_MS = 100;
 var MAX_RELAY_PROBE_TIMEOUT_MS = 3e4;
-var DEFAULT_RELAY_URL = "http://127.0.0.1:18799";
-var DEFAULT_RELAY_IDENTITY_URL = new URL(DEFAULT_RELAY_URL).toString();
-var RELAY_CWD_SENTINEL = "$MCPORTER_CHROME_RELAY_CWD";
-var RELAY_CREDENTIAL_SENTINEL = "$MCPORTER_CHROME_RELAY_CREDENTIAL:";
+var UNRESOLVED_RELAY_IDENTITY = "undiscovered";
+var RELAY_DEPENDENCY_SENTINEL = "$MCPORTER_CHROME_RELAY_DEPENDENCY:";
 var RELAY_DISCOVERY_SENTINEL = "$MCPORTER_CHROME_RELAY_DISCOVERY:";
-var CHROME_DEVTOOLS_RELAY_RUNTIME_IDENTITY_VERSION = 1;
 var CHROME_DEVTOOLS_RELAY_RUNTIME_ENV_KEYS = [
   "MCPORTER_CHROME_DEVTOOLS_RELAY_POLICY",
   "MCPORTER_DISABLE_CHROME_DEVTOOLS_RELAY",
@@ -1473,6 +1576,29 @@ var ChromeDevtoolsRelayRequiredError = class extends Error {
     this.name = "ChromeDevtoolsRelayRequiredError";
   }
 };
+var ChromeDevtoolsRelayDiscoveryError = class extends Error {
+  code = "relay_discovery_failed";
+  decision;
+  constructor(reason, policy, timeoutMs) {
+    super(`OpenClaw relay discovery failed (discovery-${reason}; timeout budget ${timeoutMs}ms). No relay endpoint was selected; this request was not dispatched. Check the OpenClaw installation and the canonical Chrome definition in the global mcporter config. For slow cold starts, set MCPORTER_CHROME_DEVTOOLS_RELAY_TIMEOUT_MS in that definition\u2019s env map; drain and stop the daemon after changing its configuration.`);
+    this.name = "ChromeDevtoolsRelayDiscoveryError";
+    this.decision = { route: "unavailable", reason: `discovery-${reason}`, policy, endpoint: void 0 };
+  }
+};
+async function discoverRelayBaseUrl(env, keyId, timeoutMs, policy, options) {
+  const discovered = await discoverOpenClawRelayUrl({
+    env,
+    keyId,
+    timeoutMs,
+    run: options.discover,
+    platform: options.discovery?.platform,
+    isFile: options.discovery?.isFile,
+    cwd: options.discovery?.cwd
+  }).catch(() => ({ reason: "unavailable" }));
+  if (discovered.reason === "success" && discovered.url)
+    return discovered.url;
+  throw new ChromeDevtoolsRelayDiscoveryError(discovered.reason === "success" ? "malformed" : discovered.reason, policy, timeoutMs);
+}
 var lastDecisions = /* @__PURE__ */ new Map();
 function recordChromeDevtoolsRelayDecision(server, decision) {
   lastDecisions.set(server, decision);
@@ -1632,22 +1758,25 @@ async function rewriteChromeDevtoolsArgsForRelay(command, args, env = process.en
     return { credential: { key, keyId: deriveBrowserRelayKeyId(key) } };
   })() : defaultReadCredential(relayEnv);
   if (!loaded.credential) {
-    const base = explicitBase.url ?? new URL(DEFAULT_RELAY_URL);
-    const upstreamEndpoint = new URL("/cdp", base);
-    upstreamEndpoint.protocol = "ws:";
-    return unavailableOrLegacy(args, policy, loaded.reason ?? "invalid-credential", upstreamEndpoint.toString(), options);
+    const upstreamEndpoint = explicitBase.url ? new URL("/cdp", explicitBase.url) : void 0;
+    if (upstreamEndpoint)
+      upstreamEndpoint.protocol = "ws:";
+    return unavailableOrLegacy(args, policy, loaded.reason ?? "invalid-credential", upstreamEndpoint?.toString(), options);
   }
   const timeoutMs = resolveChromeDevtoolsRelayProbeTimeoutMs(relayEnv);
   try {
-    const base = explicitBase.url ?? (await discoverOpenClawRelayUrl({
-      env: relayEnv,
-      keyId: loaded.credential.keyId,
-      timeoutMs,
-      run: options.discover,
-      platform: options.discovery?.platform,
-      isFile: options.discovery?.isFile,
-      cwd: options.discovery?.cwd
-    })).url ?? new URL(DEFAULT_RELAY_URL);
+    let base;
+    try {
+      base = explicitBase.url ?? await discoverRelayBaseUrl(relayEnv, loaded.credential.keyId, timeoutMs, policy, options);
+    } catch (error) {
+      if (!(error instanceof ChromeDevtoolsRelayDiscoveryError))
+        throw error;
+      if (policy === "require") {
+        options.onDecision?.(error.decision);
+        throw error;
+      }
+      return unavailableOrLegacy(args, policy, error.decision.reason, void 0, options);
+    }
     const upstreamEndpoint = new URL("/cdp", base);
     upstreamEndpoint.protocol = "ws:";
     const endpoint = upstreamEndpoint.toString();
@@ -1718,7 +1847,7 @@ function sanitizeRelayIdentityEnvironment(env) {
   const selected = selectChromeDevtoolsRelayRuntimeEnvironment(env);
   if (selected.MCPORTER_CHROME_DEVTOOLS_RELAY_URL !== void 0) {
     const explicit = explicitRelayBaseUrl(selected);
-    selected.MCPORTER_CHROME_DEVTOOLS_RELAY_URL = explicit.url?.toString() ?? "invalid-endpoint";
+    selected.MCPORTER_CHROME_DEVTOOLS_RELAY_URL = explicit.explicit ? explicit.url?.toString() ?? "invalid-endpoint" : "";
   }
   return selected;
 }
@@ -1734,96 +1863,40 @@ function chromeDevtoolsRelayEnvironmentKeys(definitions, env = process.env) {
       continue;
     }
     for (const key of commandEnvironmentKeys)
-      keys.add(key);
+      keys.add(`${RELAY_DEPENDENCY_SENTINEL}${key}`);
     const resolvedDefinitionEnv = resolveRelayIdentityEnvOverrides(definition.env, env);
-    for (const pathKey of [
-      "HOME",
-      "USERPROFILE",
-      "OPENCLAW_HOME",
-      "OPENCLAW_STATE_DIR",
-      "OPENCLAW_OAUTH_DIR",
-      "OPENCLAW_CONFIG_PATH"
-    ]) {
-      const override = resolvedDefinitionEnv[pathKey]?.trim();
-      if (override && override !== "~" && !override.startsWith("~/") && !override.startsWith("~\\") && !path2.isAbsolute(override)) {
-        keys.add(RELAY_CWD_SENTINEL);
-      }
-    }
     for (const key of CHROME_DEVTOOLS_RELAY_RUNTIME_ENV_KEYS) {
-      keys.add(key);
       const override = definition.env?.[key];
       if (!override)
         continue;
       for (const referenced of referencedEnvironmentVariables(override))
-        keys.add(referenced);
+        keys.add(`${RELAY_DEPENDENCY_SENTINEL}${referenced}`);
     }
-    const effectiveEnv = { ...env, ...resolvedDefinitionEnv };
     const resolvedCommand = resolveCommandArgument(definition.command.command, env);
     const resolvedArgs = resolveCommandArguments(definition.command.args, env);
-    if (!isChromeDevtoolsAutoConnectCommand(resolvedCommand, resolvedArgs))
+    const eligible = isChromeDevtoolsAutoConnectCommand(resolvedCommand, resolvedArgs);
+    if (!eligible && !isAmbiguousChromeDevtoolsAutoConnectCommand(resolvedCommand, resolvedArgs))
       continue;
-    const credentialPath = path2.join(resolveOpenClawCredentialDir(effectiveEnv), "browser-extension-relay.secret");
-    keys.add(`${RELAY_CREDENTIAL_SENTINEL}${credentialPath}`);
-    const environment = sanitizeRelayIdentityEnvironment(Object.fromEntries(CHROME_DEVTOOLS_RELAY_RUNTIME_ENV_KEYS.flatMap((key) => {
-      const value = resolvedDefinitionEnv[key];
-      return value === void 0 ? [] : [[key, value]];
-    })));
-    keys.add(`${RELAY_DISCOVERY_SENTINEL}${Buffer.from(JSON.stringify({ credentialPath, environment, configuredPolicy: definition.chromeDevtoolsRelay }), "utf8").toString("base64url")}`);
+    const environment = sanitizeRelayIdentityEnvironment(resolvedDefinitionEnv);
+    keys.add(`${RELAY_DISCOVERY_SENTINEL}${Buffer.from(JSON.stringify({
+      server: definition.name,
+      eligible,
+      environment,
+      configuredPolicy: definition.chromeDevtoolsRelay
+    }), "utf8").toString("base64url")}`);
   }
   return [...keys].toSorted();
 }
 async function resolveChromeDevtoolsRelayRuntimeIdentity(keys, env = process.env, options = {}) {
-  const credentialId = createRelayCredentialIdResolver();
-  const environmentValues = relayEnvironmentIdentityValues(keys, env, credentialId);
-  const discoveryValues = [];
-  for (const key of keys) {
-    if (!key.startsWith(RELAY_DISCOVERY_SENTINEL))
-      continue;
-    const payload = parseRelayDiscoveryIdentity(key.slice(RELAY_DISCOVERY_SENTINEL.length));
-    if (!payload) {
-      discoveryValues.push([key, DEFAULT_RELAY_IDENTITY_URL]);
-      continue;
-    }
-    const effectiveEnv = {
-      ...selectChromeDevtoolsRelayRuntimeEnvironment(env),
-      ...payload.environment
-    };
-    const explicit = explicitRelayBaseUrl(effectiveEnv);
-    if (explicit.explicit) {
-      discoveryValues.push([key, explicit.url?.toString() ?? "invalid-endpoint"]);
-      continue;
-    }
-    if (resolveChromeDevtoolsRelayPolicy(payload.configuredPolicy, effectiveEnv) === "off") {
-      discoveryValues.push([key, "disabled"]);
-      continue;
-    }
-    const keyId = credentialId(payload.credentialPath);
-    if (keyId === "missing-credential" || keyId === "invalid-credential") {
-      discoveryValues.push([key, DEFAULT_RELAY_IDENTITY_URL]);
-      continue;
-    }
-    try {
-      const discovered = await discoverOpenClawRelayUrl({
-        env: effectiveEnv,
-        keyId,
-        timeoutMs: resolveChromeDevtoolsRelayProbeTimeoutMs(effectiveEnv),
-        run: options.discover,
-        platform: options.discovery?.platform,
-        isFile: options.discovery?.isFile,
-        cwd: options.discovery?.cwd
-      });
-      discoveryValues.push([key, discovered.url?.toString() ?? DEFAULT_RELAY_IDENTITY_URL]);
-    } catch {
-      discoveryValues.push([key, DEFAULT_RELAY_IDENTITY_URL]);
+  const { values, relays } = relayEnvironmentIdentityValues(keys, env);
+  for (const relay of relays) {
+    let endpoint = relay.endpoint;
+    if (relay.discover && relay.keyId !== "missing-credential" && relay.keyId !== "invalid-credential") {
+      endpoint = (await discoverRelayBaseUrl(relay.env, relay.keyId, relay.timeoutMs, relay.policy, options)).toString();
     }
+    values.push([relay.server, endpoint]);
   }
-  if (discoveryValues.length === 0)
-    return hashRelayIdentityValues(environmentValues);
-  return hashRelayIdentityValues([
-    ...environmentValues,
-    ["$relayRuntimeIdentity", CHROME_DEVTOOLS_RELAY_RUNTIME_IDENTITY_VERSION],
-    ...discoveryValues
-  ]);
+  return hashRelayIdentityValues(values);
 }
 function createRelayCredentialIdResolver() {
   const credentialIds = /* @__PURE__ */ new Map();
@@ -1838,26 +1911,90 @@ function createRelayCredentialIdResolver() {
     return value;
   };
 }
-function relayEnvironmentIdentityValues(keys, env, credentialId) {
-  const values = keys.map((key) => {
-    if (key === RELAY_CWD_SENTINEL)
-      return [key, process.cwd()];
-    if (key.startsWith(RELAY_CREDENTIAL_SENTINEL)) {
-      const credentialPath = key.slice(RELAY_CREDENTIAL_SENTINEL.length);
-      return [key, credentialId(credentialPath)];
+function relayEnvironmentIdentityValues(keys, env) {
+  const credentialId = createRelayCredentialIdResolver();
+  const values = [];
+  const relays = [];
+  for (const key of keys) {
+    if (key.startsWith(RELAY_DEPENDENCY_SENTINEL)) {
+      values.push([key, env[key.slice(RELAY_DEPENDENCY_SENTINEL.length)] ?? null]);
+      continue;
     }
-    if (key.startsWith(RELAY_DISCOVERY_SENTINEL)) {
-      return [key, "async-discovery"];
+    if (!key.startsWith(RELAY_DISCOVERY_SENTINEL)) {
+      values.push([key, relayEnvironmentIdentityValue(key, env)]);
+      continue;
     }
-    return [key, env[key] ?? null];
-  });
-  if (keys.length > 0) {
-    values.push(["$relayAuth", "v2-async-metadata-discovery"]);
+    const payload = parseRelayDiscoveryIdentity(key.slice(RELAY_DISCOVERY_SENTINEL.length));
+    if (!payload)
+      throw new Error("Invalid Chrome DevTools relay identity metadata");
+    const effectiveEnv = { ...selectChromeDevtoolsRelayRuntimeEnvironment(env), ...payload.environment };
+    const policy = resolveChromeDevtoolsRelayPolicy(payload.configuredPolicy, effectiveEnv);
+    const timeoutMs = resolveChromeDevtoolsRelayProbeTimeoutMs(effectiveEnv);
+    const explicit = explicitRelayBaseUrl(effectiveEnv);
+    const credentialDir = resolveOpenClawCredentialDir(effectiveEnv);
+    const keyId = payload.eligible ? credentialId(path2.join(credentialDir, "browser-extension-relay.secret")) : "not-eligible";
+    const server = `$relay:${payload.server}`;
+    values.push([
+      server,
+      JSON.stringify({
+        policy,
+        timeoutMs,
+        eligible: payload.eligible,
+        credentialDir,
+        keyId,
+        // These values also reach the discovery subprocess; retain inputs whose equivalence it does not guarantee.
+        discovery: OPENCLAW_RELAY_DISCOVERY_ENV_KEYS.map((name) => [
+          name,
+          relayEnvironmentIdentityValue(name, effectiveEnv)
+        ]),
+        cwd: relayIdentityDependsOnCwd(effectiveEnv) ? process.cwd() : null
+      })
+    ]);
+    relays.push({
+      server,
+      policy,
+      env: effectiveEnv,
+      timeoutMs,
+      keyId,
+      endpoint: policy === "off" ? "disabled" : explicit.explicit ? explicit.url?.toString() ?? "invalid-endpoint" : UNRESOLVED_RELAY_IDENTITY,
+      discover: payload.eligible && policy !== "off" && !explicit.explicit
+    });
   }
-  return values;
+  if (keys.length > 0)
+    values.push(["$relayAuth", "v2-effective-metadata-discovery"]);
+  return { values, relays };
+}
+function relayEnvironmentIdentityValue(key, env) {
+  switch (key) {
+    case "MCPORTER_CHROME_DEVTOOLS_RELAY_POLICY":
+    case "MCPORTER_DISABLE_CHROME_DEVTOOLS_RELAY":
+      return resolveChromeDevtoolsRelayPolicy(void 0, env);
+    case "MCPORTER_CHROME_DEVTOOLS_RELAY_TIMEOUT_MS":
+      return resolveChromeDevtoolsRelayProbeTimeoutMs(env);
+    case "MCPORTER_CHROME_DEVTOOLS_RELAY_URL": {
+      const explicit = explicitRelayBaseUrl(env);
+      return explicit.explicit ? explicit.url?.toString() ?? "invalid-endpoint" : UNRESOLVED_RELAY_IDENTITY;
+    }
+    case "OPENCLAW_PROFILE":
+      return normalizeOpenClawProfile(env.OPENCLAW_PROFILE) ?? null;
+    default:
+      return env[key] ?? null;
+  }
+}
+function relayIdentityDependsOnCwd(env) {
+  const paths = [
+    env.HOME,
+    env.USERPROFILE,
+    env.OPENCLAW_HOME,
+    env.OPENCLAW_STATE_DIR,
+    env.OPENCLAW_OAUTH_DIR,
+    env.OPENCLAW_CONFIG_PATH,
+    ...(env.PATH ?? env.Path)?.split(path2.delimiter) ?? []
+  ];
+  return paths.some((value) => value !== void 0 && !path2.isAbsolute(value) && !value.startsWith("~"));
 }
 function hashRelayIdentityValues(values) {
-  return createHash3("sha256").update(JSON.stringify(values)).digest("hex").slice(0, 16);
+  return createHash3("sha256").update(JSON.stringify(values.toSorted((a, b) => a[0].localeCompare(b[0]) || JSON.stringify(a[1]).localeCompare(JSON.stringify(b[1]))))).digest("hex").slice(0, 16);
 }
 function parseRelayDiscoveryIdentity(encoded) {
   try {
@@ -1865,21 +2002,19 @@ function parseRelayDiscoveryIdentity(encoded) {
     if (!value || typeof value !== "object" || Array.isArray(value))
       return void 0;
     const candidate = value;
-    if (typeof candidate.credentialPath !== "string" || !candidate.environment || typeof candidate.environment !== "object") {
+    if (typeof candidate.server !== "string" || typeof candidate.eligible !== "boolean" || !candidate.environment || typeof candidate.environment !== "object")
       return void 0;
-    }
-    if (candidate.configuredPolicy !== void 0 && !["off", "prefer", "require"].includes(candidate.configuredPolicy)) {
+    if (candidate.configuredPolicy !== void 0 && !["off", "prefer", "require"].includes(candidate.configuredPolicy))
       return void 0;
-    }
     const environment = {};
     for (const [key, raw] of Object.entries(candidate.environment)) {
-      if (!CHROME_DEVTOOLS_RELAY_RUNTIME_ENV_KEYS.includes(key) || typeof raw !== "string") {
+      if (!CHROME_DEVTOOLS_RELAY_RUNTIME_ENV_KEYS.includes(key) || typeof raw !== "string")
         return void 0;
-      }
       environment[key] = raw;
     }
     return {
-      credentialPath: candidate.credentialPath,
+      server: candidate.server,
+      eligible: candidate.eligible,
       environment,
       configuredPolicy: candidate.configuredPolicy
     };
@@ -1918,12 +2053,19 @@ function isErrno(error, code) {
 }
 
 export {
+  isExistingChromeDevtoolsCommand,
   resolveChromeDevtoolsAutoConnectCommand,
-  CHROME_DEVTOOLS_RELAY_RUNTIME_IDENTITY_VERSION,
+  resolveCommandArgument,
+  resolveCommandArguments,
+  normalizeTimeout,
+  raceWithTimeout,
   ChromeDevtoolsRelayRequiredError,
+  ChromeDevtoolsRelayDiscoveryError,
   recordChromeDevtoolsRelayDecision,
   getChromeDevtoolsRelayDecision,
   formatChromeDevtoolsRelayDecision,
+  resolveChromeDevtoolsRelayProbeTimeoutMs,
+  resolveChromeDevtoolsRelayPolicy,
   rewriteChromeDevtoolsArgsForRelay,
   resolveChromeDevtoolsRelayEnvironment,
   chromeDevtoolsRelayEnvironmentKeys,