@cydm/pie 2.1.0 → 2.1.1

package/dist/builtin/skills/chrome-devtools-axi/cli-F2VCSVL4.js

@@ -0,0 +1,4424 @@
+import { createRequire as __axiRequire } from "node:module"; const require = __axiRequire(import.meta.url);
+import {
+  VERSION
+} from "./chunk-42SGITKJ.js";
+import {
+  BRIDGE_PORT_IN_USE_EXIT_CODE,
+  PAGE_IDENTITY_CHANGED_ERROR,
+  clearSelectedPageId,
+  getSelectedPageId,
+  overlaySessionSelected,
+  rememberToolRouting,
+  resolveBridgeScript,
+  resolveSessionName,
+  resolveSessionPidFile,
+  resolveSessionPort,
+  resolveSessionStateDir
+} from "./chunk-UPATXALW.js";
+import "./chunk-OJ6N23UZ.js";
+
+// ../../node_modules/chrome-devtools-axi/node_modules/@toon-format/toon/dist/index.mjs
+var NULL_LITERAL = "null";
+var DELIMITERS = {
+  comma: ",",
+  tab: "	",
+  pipe: "|"
+};
+var DEFAULT_DELIMITER = DELIMITERS.comma;
+function escapeString(value) {
+  return value.replace(/\\/g, `\\\\`).replace(/"/g, `\\"`).replace(/\n/g, `\\n`).replace(/\r/g, `\\r`).replace(/\t/g, `\\t`).replace(/[\u0000-\u001F]/g, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, "0")}`);
+}
+function isBooleanOrNullLiteral(token) {
+  return token === "true" || token === "false" || token === "null";
+}
+function setOwnProperty(target, key, value) {
+  if (key === "__proto__") {
+    Object.defineProperty(target, key, {
+      value,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+    return;
+  }
+  target[key] = value;
+}
+function normalizeValue(value) {
+  if (value === null) return null;
+  if (typeof value === "object" && value !== null && "toJSON" in value && typeof value.toJSON === "function") {
+    const next = value.toJSON();
+    if (next !== value) return normalizeValue(next);
+  }
+  if (typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (Object.is(value, -0)) return 0;
+    if (!Number.isFinite(value)) return null;
+    return value;
+  }
+  if (typeof value === "bigint") {
+    if (value >= Number.MIN_SAFE_INTEGER && value <= Number.MAX_SAFE_INTEGER) return Number(value);
+    return value.toString();
+  }
+  if (value instanceof Date) return value.toISOString();
+  if (Array.isArray(value)) return value.map(normalizeValue);
+  if (value instanceof Set) return Array.from(value).map(normalizeValue);
+  if (value instanceof Map) return Object.fromEntries(Array.from(value, ([k, v]) => [String(k), normalizeValue(v)]));
+  if (isPlainObject(value)) {
+    const encodedValues = {};
+    for (const key in value) if (Object.hasOwn(value, key)) setOwnProperty(encodedValues, key, normalizeValue(value[key]));
+    return encodedValues;
+  }
+  return null;
+}
+function isJsonPrimitive(value) {
+  return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function isJsonArray(value) {
+  return Array.isArray(value);
+}
+function isJsonObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isEmptyObject(value) {
+  return Object.keys(value).length === 0;
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === null || prototype === Object.prototype;
+}
+function isArrayOfPrimitives(value) {
+  return value.length === 0 || value.every((item) => isJsonPrimitive(item));
+}
+function isArrayOfArrays(value) {
+  return value.length === 0 || value.every((item) => isJsonArray(item));
+}
+function isArrayOfObjects(value) {
+  return value.length === 0 || value.every((item) => isJsonObject(item));
+}
+var NUMERIC_LIKE_PATTERN = /^-?\d+(?:\.\d+)?(?:e[+-]?\d+)?$/i;
+var LEADING_ZERO_PATTERN = /^0\d+$/;
+function isValidUnquotedKey(key) {
+  return /^[A-Z_][\w.]*$/i.test(key);
+}
+function isIdentifierSegment(key) {
+  return /^[A-Z_]\w*$/i.test(key);
+}
+function isSafeUnquoted(value, delimiter2 = DEFAULT_DELIMITER) {
+  if (!value) return false;
+  if (value !== value.trim()) return false;
+  if (isBooleanOrNullLiteral(value) || isNumericLike(value)) return false;
+  if (value.includes(":")) return false;
+  if (value.includes('"') || value.includes("\\")) return false;
+  if (/[[\]{}]/.test(value)) return false;
+  if (/[\u0000-\u001F]/.test(value)) return false;
+  if (value.includes(delimiter2)) return false;
+  if (value.startsWith("-")) return false;
+  return true;
+}
+function isNumericLike(value) {
+  return NUMERIC_LIKE_PATTERN.test(value) || LEADING_ZERO_PATTERN.test(value);
+}
+function tryFoldKeyChain(key, value, siblings, options, rootLiteralKeys, pathPrefix, flattenDepth) {
+  if (options.keyFolding !== "safe") return;
+  if (!isJsonObject(value)) return;
+  const { segments, tail, leafValue } = collectSingleKeyChain(key, value, flattenDepth ?? options.flattenDepth);
+  if (segments.length < 2) return;
+  if (!segments.every((seg) => isIdentifierSegment(seg))) return;
+  const foldedKey = buildFoldedKey(segments);
+  const absolutePath = pathPrefix ? `${pathPrefix}.${foldedKey}` : foldedKey;
+  if (siblings.includes(foldedKey)) return;
+  if (rootLiteralKeys && rootLiteralKeys.has(absolutePath)) return;
+  return {
+    foldedKey,
+    remainder: tail,
+    leafValue,
+    segmentCount: segments.length
+  };
+}
+function collectSingleKeyChain(startKey, startValue, maxDepth) {
+  const segments = [startKey];
+  let currentValue = startValue;
+  while (segments.length < maxDepth) {
+    if (!isJsonObject(currentValue)) break;
+    const keys = Object.keys(currentValue);
+    if (keys.length !== 1) break;
+    const nextKey = keys[0];
+    const nextValue = currentValue[nextKey];
+    segments.push(nextKey);
+    currentValue = nextValue;
+  }
+  if (!isJsonObject(currentValue) || isEmptyObject(currentValue)) return {
+    segments,
+    tail: void 0,
+    leafValue: currentValue
+  };
+  return {
+    segments,
+    tail: currentValue,
+    leafValue: currentValue
+  };
+}
+function buildFoldedKey(segments) {
+  return segments.join(".");
+}
+function encodePrimitive(value, delimiter2) {
+  if (value === null) return NULL_LITERAL;
+  if (typeof value === "boolean") return String(value);
+  if (typeof value === "number") return String(value);
+  return encodeStringLiteral(value, delimiter2);
+}
+function encodeStringLiteral(value, delimiter2 = DEFAULT_DELIMITER) {
+  if (isSafeUnquoted(value, delimiter2)) return value;
+  return `"${escapeString(value)}"`;
+}
+function encodeKey(key) {
+  if (isValidUnquotedKey(key)) return key;
+  return `"${escapeString(key)}"`;
+}
+function encodeAndJoinPrimitives(values, delimiter2 = DEFAULT_DELIMITER) {
+  return values.map((v) => encodePrimitive(v, delimiter2)).join(delimiter2);
+}
+function formatHeader(length, options) {
+  const key = options?.key;
+  const fields = options?.fields;
+  const delimiter2 = options?.delimiter ?? ",";
+  let header = "";
+  if (key != null) header += encodeKey(key);
+  header += `[${length}${delimiter2 !== DEFAULT_DELIMITER ? delimiter2 : ""}]`;
+  if (fields) {
+    const quotedFields = fields.map((f) => encodeKey(f));
+    header += `{${quotedFields.join(delimiter2)}}`;
+  }
+  header += ":";
+  return header;
+}
+function* encodeJsonValue(value, options, depth) {
+  if (isJsonPrimitive(value)) {
+    const encodedPrimitive = encodePrimitive(value, options.delimiter);
+    if (encodedPrimitive !== "") yield encodedPrimitive;
+    return;
+  }
+  if (isJsonArray(value)) yield* encodeArrayLines(void 0, value, depth, options);
+  else if (isJsonObject(value)) yield* encodeObjectLines(value, depth, options);
+}
+function* encodeObjectLines(value, depth, options, rootLiteralKeys, pathPrefix, remainingDepth) {
+  const keys = Object.keys(value);
+  if (depth === 0 && !rootLiteralKeys) rootLiteralKeys = new Set(keys.filter((k) => k.includes(".")));
+  const effectiveFlattenDepth = remainingDepth ?? options.flattenDepth;
+  for (const [key, val] of Object.entries(value)) yield* encodeKeyValuePairLines(key, val, depth, options, keys, rootLiteralKeys, pathPrefix, effectiveFlattenDepth);
+}
+function* encodeKeyValuePairLines(key, value, depth, options, siblings, rootLiteralKeys, pathPrefix, flattenDepth) {
+  const currentPath = pathPrefix ? `${pathPrefix}.${key}` : key;
+  const effectiveFlattenDepth = flattenDepth ?? options.flattenDepth;
+  if (options.keyFolding === "safe" && siblings) {
+    const foldResult = tryFoldKeyChain(key, value, siblings, options, rootLiteralKeys, pathPrefix, effectiveFlattenDepth);
+    if (foldResult) {
+      const { foldedKey, remainder, leafValue, segmentCount } = foldResult;
+      const encodedFoldedKey = encodeKey(foldedKey);
+      if (remainder === void 0) {
+        if (isJsonPrimitive(leafValue)) {
+          yield indentedLine(depth, `${encodedFoldedKey}: ${encodePrimitive(leafValue, options.delimiter)}`, options.indent);
+          return;
+        } else if (isJsonArray(leafValue)) {
+          yield* encodeArrayLines(foldedKey, leafValue, depth, options);
+          return;
+        } else if (isJsonObject(leafValue) && isEmptyObject(leafValue)) {
+          yield indentedLine(depth, `${encodedFoldedKey}:`, options.indent);
+          return;
+        }
+      }
+      if (isJsonObject(remainder)) {
+        yield indentedLine(depth, `${encodedFoldedKey}:`, options.indent);
+        const remainingDepth = effectiveFlattenDepth - segmentCount;
+        const foldedPath = pathPrefix ? `${pathPrefix}.${foldedKey}` : foldedKey;
+        yield* encodeObjectLines(remainder, depth + 1, options, rootLiteralKeys, foldedPath, remainingDepth);
+        return;
+      }
+    }
+  }
+  const encodedKey = encodeKey(key);
+  if (isJsonPrimitive(value)) yield indentedLine(depth, `${encodedKey}: ${encodePrimitive(value, options.delimiter)}`, options.indent);
+  else if (isJsonArray(value)) yield* encodeArrayLines(key, value, depth, options);
+  else if (isJsonObject(value)) {
+    yield indentedLine(depth, `${encodedKey}:`, options.indent);
+    if (!isEmptyObject(value)) yield* encodeObjectLines(value, depth + 1, options, rootLiteralKeys, currentPath, effectiveFlattenDepth);
+  }
+}
+function* encodeArrayLines(key, value, depth, options) {
+  if (value.length === 0) {
+    yield indentedLine(depth, key != null ? `${encodeKey(key)}: []` : "[]", options.indent);
+    return;
+  }
+  if (isArrayOfPrimitives(value)) {
+    yield indentedLine(depth, encodeInlineArrayLine(value, options.delimiter, key), options.indent);
+    return;
+  }
+  if (isArrayOfArrays(value)) {
+    if (value.every((arr) => isArrayOfPrimitives(arr))) {
+      yield* encodeArrayOfArraysAsListItemsLines(key, value, depth, options);
+      return;
+    }
+  }
+  if (isArrayOfObjects(value)) {
+    const header = extractTabularHeader(value);
+    if (header) yield* encodeArrayOfObjectsAsTabularLines(key, value, header, depth, options);
+    else yield* encodeMixedArrayAsListItemsLines(key, value, depth, options);
+    return;
+  }
+  yield* encodeMixedArrayAsListItemsLines(key, value, depth, options);
+}
+function* encodeArrayOfArraysAsListItemsLines(prefix, values, depth, options) {
+  yield indentedLine(depth, formatHeader(values.length, {
+    key: prefix,
+    delimiter: options.delimiter
+  }), options.indent);
+  for (const arr of values) if (isArrayOfPrimitives(arr)) {
+    const arrayLine = encodeInlineArrayLine(arr, options.delimiter);
+    yield indentedListItem(depth + 1, arrayLine, options.indent);
+  }
+}
+function encodeInlineArrayLine(values, delimiter2, prefix) {
+  const header = formatHeader(values.length, {
+    key: prefix,
+    delimiter: delimiter2
+  });
+  const joinedValue = encodeAndJoinPrimitives(values, delimiter2);
+  if (values.length === 0) return header;
+  return `${header} ${joinedValue}`;
+}
+function* encodeArrayOfObjectsAsTabularLines(prefix, rows, header, depth, options) {
+  yield indentedLine(depth, formatHeader(rows.length, {
+    key: prefix,
+    fields: header,
+    delimiter: options.delimiter
+  }), options.indent);
+  yield* writeTabularRowsLines(rows, header, depth + 1, options);
+}
+function extractTabularHeader(rows) {
+  if (rows.length === 0) return;
+  const firstRow = rows[0];
+  const firstKeys = Object.keys(firstRow);
+  if (firstKeys.length === 0) return;
+  if (isTabularArray(rows, firstKeys)) return firstKeys;
+}
+function isTabularArray(rows, header) {
+  for (const row of rows) {
+    if (Object.keys(row).length !== header.length) return false;
+    for (const key of header) {
+      if (!Object.hasOwn(row, key)) return false;
+      if (!isJsonPrimitive(row[key])) return false;
+    }
+  }
+  return true;
+}
+function* writeTabularRowsLines(rows, header, depth, options) {
+  for (const row of rows) yield indentedLine(depth, encodeAndJoinPrimitives(header.map((key) => row[key]), options.delimiter), options.indent);
+}
+function* encodeMixedArrayAsListItemsLines(prefix, items, depth, options) {
+  yield indentedLine(depth, formatHeader(items.length, {
+    key: prefix,
+    delimiter: options.delimiter
+  }), options.indent);
+  for (const item of items) yield* encodeListItemValueLines(item, depth + 1, options);
+}
+function* encodeObjectAsListItemLines(obj, depth, options) {
+  if (isEmptyObject(obj)) {
+    yield indentedLine(depth, "-", options.indent);
+    return;
+  }
+  const entries = Object.entries(obj);
+  const [firstKey, firstValue] = entries[0];
+  const restEntries = entries.slice(1);
+  if (isJsonArray(firstValue) && isArrayOfObjects(firstValue)) {
+    const header = extractTabularHeader(firstValue);
+    if (header) {
+      yield indentedListItem(depth, formatHeader(firstValue.length, {
+        key: firstKey,
+        fields: header,
+        delimiter: options.delimiter
+      }), options.indent);
+      yield* writeTabularRowsLines(firstValue, header, depth + 2, options);
+      if (restEntries.length > 0) yield* encodeObjectLines(Object.fromEntries(restEntries), depth + 1, options);
+      return;
+    }
+  }
+  const encodedKey = encodeKey(firstKey);
+  if (isJsonPrimitive(firstValue)) yield indentedListItem(depth, `${encodedKey}: ${encodePrimitive(firstValue, options.delimiter)}`, options.indent);
+  else if (isJsonArray(firstValue)) if (firstValue.length === 0) yield indentedListItem(depth, `${encodedKey}: []`, options.indent);
+  else if (isArrayOfPrimitives(firstValue)) yield indentedListItem(depth, `${encodedKey}${encodeInlineArrayLine(firstValue, options.delimiter)}`, options.indent);
+  else {
+    yield indentedListItem(depth, `${encodedKey}${formatHeader(firstValue.length, { delimiter: options.delimiter })}`, options.indent);
+    for (const item of firstValue) yield* encodeListItemValueLines(item, depth + 2, options);
+  }
+  else if (isJsonObject(firstValue)) {
+    yield indentedListItem(depth, `${encodedKey}:`, options.indent);
+    if (!isEmptyObject(firstValue)) yield* encodeObjectLines(firstValue, depth + 2, options);
+  }
+  if (restEntries.length > 0) yield* encodeObjectLines(Object.fromEntries(restEntries), depth + 1, options);
+}
+function* encodeListItemValueLines(value, depth, options) {
+  if (isJsonPrimitive(value)) yield indentedListItem(depth, encodePrimitive(value, options.delimiter), options.indent);
+  else if (isJsonArray(value)) if (isArrayOfPrimitives(value)) yield indentedListItem(depth, encodeInlineArrayLine(value, options.delimiter), options.indent);
+  else {
+    yield indentedListItem(depth, formatHeader(value.length, { delimiter: options.delimiter }), options.indent);
+    for (const item of value) yield* encodeListItemValueLines(item, depth + 1, options);
+  }
+  else if (isJsonObject(value)) yield* encodeObjectAsListItemLines(value, depth, options);
+}
+function indentedLine(depth, content, indentSize) {
+  return " ".repeat(indentSize * depth) + content;
+}
+function indentedListItem(depth, content, indentSize) {
+  return indentedLine(depth, "- " + content, indentSize);
+}
+function applyReplacer(root, replacer) {
+  const replacedRoot = replacer("", root, []);
+  if (replacedRoot === void 0) return transformChildren(root, replacer, []);
+  return transformChildren(normalizeValue(replacedRoot), replacer, []);
+}
+function transformChildren(value, replacer, path) {
+  if (isJsonObject(value)) return transformObject(value, replacer, path);
+  if (isJsonArray(value)) return transformArray(value, replacer, path);
+  return value;
+}
+function transformObject(obj, replacer, path) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const childPath = [...path, key];
+    const replacedValue = replacer(key, value, childPath);
+    if (replacedValue === void 0) continue;
+    setOwnProperty(result, key, transformChildren(normalizeValue(replacedValue), replacer, childPath));
+  }
+  return result;
+}
+function transformArray(arr, replacer, path) {
+  const result = [];
+  for (let i = 0; i < arr.length; i++) {
+    const value = arr[i];
+    const childPath = [...path, i];
+    const replacedValue = replacer(String(i), value, childPath);
+    if (replacedValue === void 0) continue;
+    const normalizedValue = normalizeValue(replacedValue);
+    result.push(transformChildren(normalizedValue, replacer, childPath));
+  }
+  return result;
+}
+function encode(input, options) {
+  return Array.from(encodeLines(input, options)).join("\n");
+}
+function encodeLines(input, options) {
+  const normalizedValue = normalizeValue(input);
+  const resolvedOptions = resolveOptions(options);
+  return encodeJsonValue(resolvedOptions.replacer ? applyReplacer(normalizedValue, resolvedOptions.replacer) : normalizedValue, resolvedOptions, 0);
+}
+function resolveOptions(options) {
+  return {
+    indent: options?.indent ?? 2,
+    delimiter: options?.delimiter ?? DEFAULT_DELIMITER,
+    keyFolding: options?.keyFolding ?? "off",
+    flattenDepth: options?.flattenDepth ?? Number.POSITIVE_INFINITY,
+    replacer: options?.replacer
+  };
+}
+
+// ../../node_modules/axi-sdk-js/dist/cli.js
+import { basename as basename2 } from "node:path";
+
+// ../../node_modules/axi-sdk-js/dist/errors.js
+var AxiError = class extends Error {
+  code;
+  suggestions;
+  constructor(message, code, suggestions = []) {
+    super(message);
+    this.code = code;
+    this.suggestions = suggestions;
+    this.name = "AxiError";
+  }
+};
+function exitCodeForError(error) {
+  if (error instanceof AxiError && error.code === "VALIDATION_ERROR") {
+    return 2;
+  }
+  return 1;
+}
+
+// ../../node_modules/axi-sdk-js/dist/output.js
+import { homedir } from "node:os";
+function collapseHomeDirectory(path, homeDir = homedir()) {
+  if (!path.startsWith(homeDir)) {
+    return path;
+  }
+  return `~${path.slice(homeDir.length)}`;
+}
+function homeHeaderOutput(options) {
+  return {
+    bin: collapseHomeDirectory(options.execPath ?? process.argv[1] ?? "", options.homeDir),
+    description: options.description
+  };
+}
+function errorOutput(message, code, suggestions = []) {
+  const output = {
+    error: message,
+    code
+  };
+  if (suggestions.length > 0) {
+    output.help = suggestions;
+  }
+  return output;
+}
+function renderOutput(output) {
+  if (typeof output === "string") {
+    return output;
+  }
+  return encode(output);
+}
+function renderError(message, code, suggestions = []) {
+  return renderOutput(errorOutput(message, code, suggestions));
+}
+
+// ../../node_modules/axi-sdk-js/dist/update.js
+import { spawn } from "node:child_process";
+import { execFile } from "node:child_process";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+var REGISTRY_BASE = "https://registry.npmjs.org";
+var REGISTRY_FETCH_TIMEOUT_MS = 2e4;
+function parseSemver(version) {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z-.]+))?(?:\+[0-9A-Za-z-.]+)?$/.exec(version.trim());
+  if (!match) {
+    return null;
+  }
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4] ? match[4].split(".") : []
+  };
+}
+function comparePrerelease(a, b) {
+  if (a.length === 0 && b.length === 0)
+    return 0;
+  if (a.length === 0)
+    return 1;
+  if (b.length === 0)
+    return -1;
+  const length = Math.max(a.length, b.length);
+  for (let index = 0; index < length; index += 1) {
+    if (index >= a.length)
+      return -1;
+    if (index >= b.length)
+      return 1;
+    const left = a[index];
+    const right = b[index];
+    const leftNumeric = /^\d+$/.test(left);
+    const rightNumeric = /^\d+$/.test(right);
+    if (leftNumeric && rightNumeric) {
+      const delta = Number(left) - Number(right);
+      if (delta !== 0)
+        return delta < 0 ? -1 : 1;
+    } else if (leftNumeric) {
+      return -1;
+    } else if (rightNumeric) {
+      return 1;
+    } else if (left !== right) {
+      return left < right ? -1 : 1;
+    }
+  }
+  return 0;
+}
+function compareSemver(a, b) {
+  const parsedA = parseSemver(a);
+  const parsedB = parseSemver(b);
+  if (!parsedA || !parsedB) {
+    if (a === b)
+      return 0;
+    return a < b ? -1 : 1;
+  }
+  if (parsedA.major !== parsedB.major) {
+    return parsedA.major < parsedB.major ? -1 : 1;
+  }
+  if (parsedA.minor !== parsedB.minor) {
+    return parsedA.minor < parsedB.minor ? -1 : 1;
+  }
+  if (parsedA.patch !== parsedB.patch) {
+    return parsedA.patch < parsedB.patch ? -1 : 1;
+  }
+  return comparePrerelease(parsedA.prerelease, parsedB.prerelease);
+}
+function isUpdateAvailable(current, latest) {
+  return compareSemver(latest, current) > 0;
+}
+var nodeFs = {
+  existsSync,
+  readFileSync: (path, encoding) => readFileSync(path, encoding)
+};
+function readNearestPackageJson(startPath, fs = nodeFs) {
+  let dir = dirname(startPath);
+  let previous = "";
+  while (dir !== previous) {
+    const packageJsonPath = join(dir, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+      try {
+        const parsed = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+        if (typeof parsed.name === "string" && parsed.name.length > 0) {
+          return {
+            packageName: parsed.name,
+            version: typeof parsed.version === "string" ? parsed.version : void 0,
+            packageJsonPath
+          };
+        }
+      } catch {
+      }
+    }
+    previous = dir;
+    dir = dirname(dir);
+  }
+  return {};
+}
+function detectInstallMethod(options) {
+  const env = options.env ?? process.env;
+  const path = options.entry.replaceAll("\\", "/");
+  if (path.includes("/_npx/") || /\/dlx-[^/]+\//.test(path) || path.includes("/pnpm/dlx/") || path.includes("/bun/install/cache/")) {
+    return { kind: "npx" };
+  }
+  const homebrewFormula = homebrewFormulaFromPath(path, env);
+  if (homebrewFormula) {
+    return { kind: "homebrew", formula: homebrewFormula };
+  }
+  const pnpmHome = normalizePathRoot(env.PNPM_HOME);
+  if (isPathInsideRoot(path, pnpmHome) || isKnownPnpmGlobalStore(path, env)) {
+    return { kind: "pnpm-global" };
+  }
+  if (isKnownNpmGlobalInstall(path, env)) {
+    return { kind: "npm-global" };
+  }
+  return { kind: "unknown" };
+}
+function normalizePathRoot(path) {
+  const normalized = path?.replaceAll("\\", "/").replace(/\/+$/, "");
+  return normalized && normalized.length > 0 ? normalized : void 0;
+}
+function isPathInsideRoot(path, root) {
+  return root !== void 0 && (path === root || path.startsWith(`${root}/`));
+}
+function homebrewFormulaFromPath(path, env) {
+  for (const root of homebrewCellarRoots(env)) {
+    if (!isPathInsideRoot(path, root)) {
+      continue;
+    }
+    const relative = path.slice(root.length).replace(/^\/+/, "");
+    const formula = relative.split("/")[0];
+    if (formula) {
+      return formula;
+    }
+  }
+  return null;
+}
+function homebrewCellarRoots(env) {
+  const roots = [];
+  const explicitCellar = normalizePathRoot(env.HOMEBREW_CELLAR);
+  if (explicitCellar) {
+    roots.push(explicitCellar);
+  }
+  const prefixes = [
+    env.HOMEBREW_PREFIX,
+    "/opt/homebrew",
+    "/usr/local",
+    "/home/linuxbrew/.linuxbrew"
+  ];
+  for (const prefix of prefixes) {
+    const normalized = normalizePathRoot(prefix);
+    if (normalized) {
+      roots.push(`${normalized}/Cellar`);
+    }
+  }
+  return [...new Set(roots)];
+}
+function isKnownPnpmGlobalStore(path, env) {
+  return pnpmGlobalStoreRoots(env).some((root) => {
+    if (!isPathInsideRoot(path, root)) {
+      return false;
+    }
+    const relative = path.slice(root.length).replace(/^\/+/, "");
+    return /^\d+\/\.pnpm\//.test(relative);
+  });
+}
+function pnpmGlobalStoreRoots(env) {
+  const roots = [];
+  const home = normalizePathRoot(env.HOME ?? env.USERPROFILE);
+  if (home) {
+    roots.push(`${home}/Library/pnpm/global`);
+    roots.push(`${home}/.local/share/pnpm/global`);
+    roots.push(`${home}/AppData/Local/pnpm/global`);
+  }
+  const localAppData = normalizePathRoot(env.LOCALAPPDATA);
+  if (localAppData) {
+    roots.push(`${localAppData}/pnpm/global`);
+  }
+  return [...new Set(roots)];
+}
+function isKnownNpmGlobalInstall(path, env) {
+  return npmGlobalNodeModulesRoots(env).some((root) => isPathInsideRoot(path, root)) || isKnownVersionManagerNpmGlobal(path, env);
+}
+function npmGlobalNodeModulesRoots(env) {
+  const roots = [
+    "/usr/local/lib/node_modules",
+    "/usr/lib/node_modules",
+    "/opt/homebrew/lib/node_modules",
+    "/opt/local/lib/node_modules"
+  ];
+  const prefixes = [env.npm_config_prefix, env.NPM_CONFIG_PREFIX];
+  for (const prefix of prefixes) {
+    const normalized = normalizePathRoot(prefix);
+    if (normalized) {
+      roots.push(`${normalized}/lib/node_modules`, `${normalized}/node_modules`);
+    }
+  }
+  const appData = normalizePathRoot(env.APPDATA);
+  if (appData) {
+    roots.push(`${appData}/npm/node_modules`);
+  }
+  const home = normalizePathRoot(env.HOME ?? env.USERPROFILE);
+  if (home) {
+    roots.push(`${home}/.npm-global/lib/node_modules`, `${home}/.npm-packages/lib/node_modules`);
+  }
+  return [...new Set(roots)];
+}
+function isKnownVersionManagerNpmGlobal(path, env) {
+  return versionManagerNodeRoots(env).some((root) => isPathInsideRoot(path, root) && path.includes("/lib/node_modules/"));
+}
+function versionManagerNodeRoots(env) {
+  const roots = [];
+  const home = normalizePathRoot(env.HOME ?? env.USERPROFILE);
+  if (home) {
+    roots.push(`${home}/.nvm/versions/node`, `${home}/.local/share/fnm/node-versions`, `${home}/.asdf/installs/nodejs`, `${home}/.nodenv/versions`, `${home}/.local/share/mise/installs/node`, `${home}/.volta/tools/image/node`);
+  }
+  const nvmDir = normalizePathRoot(env.NVM_DIR);
+  if (nvmDir) {
+    roots.push(`${nvmDir}/versions/node`);
+  }
+  const fnmDir = normalizePathRoot(env.FNM_DIR);
+  if (fnmDir) {
+    roots.push(`${fnmDir}/node-versions`);
+  }
+  return [...new Set(roots)];
+}
+function planUpgrade(method, packageName) {
+  switch (method.kind) {
+    case "npm-global":
+      return {
+        method: method.kind,
+        command: `npm install -g ${packageName}@latest`,
+        argv: ["npm", "install", "-g", `${packageName}@latest`]
+      };
+    case "pnpm-global":
+      return {
+        method: method.kind,
+        command: `pnpm add -g ${packageName}@latest`,
+        argv: ["pnpm", "add", "-g", `${packageName}@latest`]
+      };
+    case "homebrew":
+      if (method.formula) {
+        return {
+          method: method.kind,
+          command: `brew upgrade ${method.formula}`,
+          argv: ["brew", "upgrade", method.formula]
+        };
+      }
+      return {
+        method: method.kind,
+        command: `brew upgrade ${packageName}`,
+        argv: null,
+        note: "Could not determine the Homebrew formula automatically"
+      };
+    case "npx":
+      return {
+        method: method.kind,
+        command: `npx -y ${packageName}@latest`,
+        argv: null,
+        note: "npx always runs the latest published version, so no install is needed"
+      };
+    case "unknown":
+      return {
+        method: method.kind,
+        command: `npm install -g ${packageName}@latest`,
+        argv: null,
+        note: "Could not determine how this tool was installed"
+      };
+  }
+}
+function packageManagerExecutable(command, platform) {
+  if (platform === "win32" && (command === "npm" || command === "pnpm" || command === "npx")) {
+    return `${command}.cmd`;
+  }
+  return command;
+}
+function shouldUseWindowsPackageManagerShell(command, platform) {
+  return platform === "win32" && (command === "npm" || command === "pnpm" || command === "npx");
+}
+async function npmViewVersion(packageName, platform = process.platform) {
+  try {
+    const command = packageManagerExecutable("npm", platform);
+    const { stdout } = await execFileAsync(command, ["view", packageName, "version"], {
+      timeout: 2e4,
+      shell: shouldUseWindowsPackageManagerShell("npm", platform)
+    });
+    const version = stdout.trim();
+    return version.length > 0 ? version : null;
+  } catch {
+    return null;
+  }
+}
+function registryPath(packageName) {
+  return packageName.startsWith("@") ? packageName.replace("/", "%2f") : packageName;
+}
+function notPublishedError(packageName) {
+  return new AxiError(`${packageName} is not published to the npm registry`, "UPDATE_ERROR", [
+    "Confirm the package name is correct",
+    `Run \`npm view ${packageName} version\` to check manually`
+  ]);
+}
+var RegistryNotFoundError = class extends Error {
+};
+async function withRegistryTimeout(timeoutMs, operation) {
+  const controller = new AbortController();
+  let timer;
+  const timeout = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => {
+      controller.abort();
+      reject(new Error(`Registry fetch timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    timer.unref?.();
+  });
+  try {
+    return await Promise.race([operation(controller.signal), timeout]);
+  } finally {
+    if (timer) {
+      clearTimeout(timer);
+    }
+  }
+}
+async function fetchRegistryVersion(fetchImpl, packageName, timeoutMs) {
+  return withRegistryTimeout(timeoutMs, async (signal) => {
+    const response = await fetchImpl(`${REGISTRY_BASE}/${registryPath(packageName)}/latest`, { headers: { accept: "application/json" }, signal });
+    if (response.ok) {
+      const data = await response.json();
+      if (typeof data.version === "string" && data.version.length > 0) {
+        return data.version;
+      }
+    } else if (response.status === 404) {
+      throw new RegistryNotFoundError();
+    }
+    return null;
+  });
+}
+async function fetchLatestVersion(packageName, options = {}) {
+  const fetchImpl = options.fetchImpl === void 0 ? globalThis.fetch : options.fetchImpl ?? void 0;
+  let registryNotFound = false;
+  if (typeof fetchImpl === "function") {
+    try {
+      const version = await fetchRegistryVersion(fetchImpl, packageName, options.fetchTimeoutMs ?? REGISTRY_FETCH_TIMEOUT_MS);
+      if (version) {
+        return version;
+      }
+    } catch (error) {
+      if (error instanceof RegistryNotFoundError) {
+        registryNotFound = true;
+      } else if (error instanceof AxiError) {
+        throw error;
+      }
+    }
+  }
+  const viewed = await (options.npmView ?? ((name) => npmViewVersion(name, options.platform)))(packageName);
+  if (viewed) {
+    return viewed;
+  }
+  if (registryNotFound) {
+    throw notPublishedError(packageName);
+  }
+  throw new AxiError(`Could not reach the npm registry to check for updates to ${packageName}`, "UPDATE_ERROR", [
+    "Check your network connection and try again",
+    `Run \`npm view ${packageName} version\` to check manually`
+  ]);
+}
+async function defaultRunInstall(plan, stdout, context) {
+  const argv = plan.argv;
+  if (!argv || argv.length === 0) {
+    return { ok: false, message: "No runnable upgrade command" };
+  }
+  stdout.write(`running: ${plan.command}
+`);
+  return new Promise((resolve3) => {
+    const [command, ...args] = argv;
+    const child = spawn(packageManagerExecutable(command, context.platform), args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: shouldUseWindowsPackageManagerShell(command, context.platform)
+    });
+    child.stdout?.on("data", (chunk) => {
+      process.stderr.write(chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      process.stderr.write(chunk);
+    });
+    child.on("error", (error) => {
+      resolve3({ ok: false, message: error.message });
+    });
+    child.on("close", (code) => {
+      resolve3(code === 0 ? { ok: true } : { ok: false, message: `${plan.command} exited with code ${code}` });
+    });
+  });
+}
+function binNameFromArgv(invokedAs) {
+  return basename(invokedAs ?? "tool") || "tool";
+}
+function resolveEntry(invokedAs, realpath) {
+  if (!invokedAs) {
+    return void 0;
+  }
+  try {
+    return realpath(invokedAs);
+  } catch {
+    return invokedAs;
+  }
+}
+function resolveInstalledVersion(invokedAs, realpath, fs) {
+  const installedEntry = resolveEntry(invokedAs, realpath);
+  return installedEntry ? readNearestPackageJson(installedEntry, fs).version : void 0;
+}
+function homebrewUpgradeOutput(options) {
+  const update = {
+    package: options.packageName,
+    previous: options.current,
+    latest: options.latest
+  };
+  if (options.installedVersion) {
+    update.installed = options.installedVersion;
+    update.available = isUpdateAvailable(options.installedVersion, options.latest);
+  } else {
+    update.action = "upgrade-command-ran";
+    update.result = "installed version unknown";
+  }
+  return {
+    update,
+    command: options.command
+  };
+}
+function parseUpdateArgs(args, binName) {
+  if (args.length === 0) {
+    return "install";
+  }
+  if (args.length === 1 && (args[0] === "--check" || args[0] === "--dry-run")) {
+    return "check";
+  }
+  const unknown = args.find((arg) => arg !== "--check" && arg !== "--dry-run");
+  throw new AxiError(unknown ? `Unknown update option: ${unknown}` : "Invalid update arguments", "VALIDATION_ERROR", [
+    `Run \`${binName} update --help\``,
+    `Use \`${binName} update --check\` to check without installing`
+  ]);
+}
+async function runUpdate(options) {
+  const invokedAs = options.invokedAs ?? process.argv[1];
+  const binName = binNameFromArgv(invokedAs);
+  const mode = parseUpdateArgs(options.args, binName);
+  const platform = options.platform ?? process.platform;
+  const realpath = options.realpath ?? ((path) => realpathSync(path));
+  const entry = resolveEntry(invokedAs, realpath);
+  const fs = options.fs ?? nodeFs;
+  const fromPackageJson = entry ? readNearestPackageJson(entry, fs) : {};
+  const packageName = options.packageName ?? fromPackageJson.packageName;
+  const current = options.version ?? fromPackageJson.version;
+  if (!packageName) {
+    throw new AxiError("Could not determine the package name to update", "UPDATE_ERROR", [
+      "Reinstall the tool from npm so its package.json is available",
+      "Tool authors can pass `packageName` to runAxiCli()"
+    ]);
+  }
+  if (!current) {
+    throw new AxiError(`Could not determine the current version of ${packageName}`, "UPDATE_ERROR", [
+      "Reinstall the tool from npm so its version is available",
+      "Tool authors can pass `version` to runAxiCli()"
+    ]);
+  }
+  const fetchLatest = options.fetchLatest ?? ((name) => fetchLatestVersion(name, { platform }));
+  const latest = await fetchLatest(packageName);
+  const available = isUpdateAvailable(current, latest);
+  if (mode === "check") {
+    const output = {
+      update: { package: packageName, current, latest, available }
+    };
+    if (available) {
+      output.help = [`Run \`${binName} update\` to upgrade`];
+    }
+    return output;
+  }
+  if (!available) {
+    return {
+      update: `${packageName} is already on the latest version (${current})`
+    };
+  }
+  const method = entry ? detectInstallMethod({ entry, env: options.env }) : { kind: "unknown" };
+  const plan = planUpgrade(method, packageName);
+  if (!plan.argv) {
+    const help = method.kind === "npx" ? `Re-run with \`${plan.command}\` to use the latest version` : `Run \`${plan.command}\` to upgrade`;
+    return {
+      update: {
+        package: packageName,
+        current,
+        latest,
+        available: true,
+        action: "manual",
+        ...plan.note ? { reason: plan.note } : {},
+        run: plan.command
+      },
+      help: [help]
+    };
+  }
+  const runInstall = options.runInstall ?? defaultRunInstall;
+  const result = await runInstall(plan, options.stdout, { platform });
+  if (!result.ok) {
+    throw new AxiError(`Failed to upgrade ${packageName}`, "UPDATE_ERROR", [
+      `Run \`${plan.command}\` manually`,
+      ...result.message ? [result.message] : []
+    ]);
+  }
+  if (method.kind === "homebrew") {
+    return homebrewUpgradeOutput({
+      packageName,
+      current,
+      latest,
+      installedVersion: resolveInstalledVersion(invokedAs, realpath, fs),
+      command: plan.command
+    });
+  }
+  return {
+    update: `${packageName} upgraded ${current} -> ${latest}`,
+    command: plan.command
+  };
+}
+
+// ../../node_modules/axi-sdk-js/dist/cli.js
+var stdoutWithErrorHandler = /* @__PURE__ */ new WeakSet();
+function defaultFormatError(error) {
+  if (error instanceof AxiError) {
+    return {
+      output: `${renderError(error.message, error.code, error.suggestions)}
+`,
+      exitCode: exitCodeForError(error)
+    };
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    output: `${renderError(message, "UNKNOWN")}
+`,
+    exitCode: 1
+  };
+}
+function defaultUnknownCommand(command) {
+  return `${renderError(`Unknown command: ${command}`, "VALIDATION_ERROR", [
+    "Run `--help` to see available commands"
+  ])}
+`;
+}
+async function runAxiCli(options) {
+  const stdout = options.stdout ?? process.stdout;
+  handleStdoutErrors(stdout);
+  try {
+    await options.initialize?.();
+  } catch (error) {
+    writeFormattedError(error, stdout, options);
+    return;
+  }
+  const argv = options.argv ?? process.argv.slice(2);
+  if (argv.length === 1 && argv[0] === "--help") {
+    stdout.write(options.topLevelHelp);
+    if (!options.commands.update) {
+      if (options.topLevelHelp.length > 0 && !options.topLevelHelp.endsWith("\n")) {
+        stdout.write("\n");
+      }
+      stdout.write(builtinCommandsHelp());
+    }
+    return;
+  }
+  if (argv.length === 1 && isVersionFlag(argv[0])) {
+    if (!options.version) {
+      stdout.write(`${renderError("Version is not configured for this tool", "VALIDATION_ERROR")}
+`);
+      process.exitCode = 2;
+      return;
+    }
+    stdout.write(`${options.version}
+`);
+    return;
+  }
+  const command = argv[0];
+  if (!command) {
+    await runHandler(options.home, [], { command: void 0, args: [] }, stdout, options, true);
+    return;
+  }
+  if (command.startsWith("-")) {
+    stdout.write(renderLeadingFlagError(command));
+    process.exitCode = 2;
+    return;
+  }
+  const args = argv.slice(1);
+  if (command === "update" && !options.commands.update) {
+    await runBuiltinUpdate(args, stdout, options);
+    return;
+  }
+  if (args.includes("--help")) {
+    const help = options.getCommandHelp?.(command);
+    if (help) {
+      stdout.write(help);
+      return;
+    }
+  }
+  const handler = options.commands[command];
+  if (!handler) {
+    stdout.write((options.renderUnknownCommand ?? defaultUnknownCommand)(command));
+    process.exitCode = 2;
+    return;
+  }
+  await runHandler(handler, args, { command, args }, stdout, options, false);
+}
+function handleStdoutErrors(stdout) {
+  const errorObservable = stdout;
+  if (typeof errorObservable.on !== "function" || stdoutWithErrorHandler.has(stdout)) {
+    return;
+  }
+  stdoutWithErrorHandler.add(stdout);
+  errorObservable.on("error", (error) => {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "EPIPE") {
+      process.exitCode = 0;
+      return;
+    }
+    throw error;
+  });
+}
+async function runHandler(handler, args, contextInput, stdout, options, isHomeView) {
+  try {
+    const context = await options.resolveContext?.(contextInput);
+    const output = await handler(args, context);
+    stdout.write(`${renderCommandOutput(output, options, isHomeView)}
+`);
+  } catch (error) {
+    writeFormattedError(error, stdout, options);
+  }
+}
+async function runBuiltinUpdate(args, stdout, options) {
+  if (args.length === 1 && args[0] === "--help") {
+    stdout.write(builtinUpdateHelp());
+    return;
+  }
+  try {
+    const output = await runUpdate({
+      args,
+      stdout,
+      packageName: options.packageName,
+      version: options.version
+    });
+    stdout.write(`${renderOutput(output)}
+`);
+  } catch (error) {
+    writeFormattedError(error, stdout, options);
+  }
+}
+function writeFormattedError(error, stdout, options) {
+  const formatted = (options.formatError ?? defaultFormatError)(error);
+  stdout.write(formatted.output);
+  process.exitCode = formatted.exitCode;
+}
+function resolveBinName() {
+  return basename2(process.argv[1] ?? "tool") || "tool";
+}
+function builtinCommandsHelp() {
+  const bin = resolveBinName();
+  return `${renderOutput({
+    "built-in": {
+      update: `Upgrade \`${bin}\` to the latest published version`,
+      "update --check": "Report current vs latest without installing"
+    }
+  })}
+`;
+}
+function builtinUpdateHelp() {
+  const bin = resolveBinName();
+  return `${renderOutput({
+    command: "update",
+    description: `Upgrade \`${bin}\` to the latest published npm version`,
+    flags: {
+      "--check": "Report current vs latest and exit without installing"
+    },
+    examples: [`${bin} update`, `${bin} update --check`]
+  })}
+`;
+}
+function renderLeadingFlagError(flag) {
+  const bin = basename2(process.argv[1] ?? "tool") || "tool";
+  return `${renderError("Flags must come after the command", "VALIDATION_ERROR", [
+    `Run \`${bin} <command> [args] [flags]\``,
+    `Move \`${flag}\` after the command instead of before it`
+  ])}
+`;
+}
+function isVersionFlag(flag) {
+  return flag === "-v" || flag === "-V" || flag === "--version";
+}
+function renderCommandOutput(output, options, isHomeView) {
+  if (!isHomeView) {
+    return renderOutput(output);
+  }
+  const header = homeHeaderOutput({ description: options.description });
+  if (typeof output === "string") {
+    return `${renderOutput(header)}
+${output}`;
+  }
+  return renderOutput(mergeHomeHeader(header, output));
+}
+function mergeHomeHeader(header, output) {
+  const rest = { ...output };
+  delete rest.bin;
+  delete rest.description;
+  return {
+    ...header,
+    ...rest
+  };
+}
+
+// ../../node_modules/axi-sdk-js/dist/hooks.js
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, realpathSync as realpathSync2, rmSync, statSync, writeFileSync } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { basename as basename3, delimiter, dirname as dirname2, join as join2, resolve } from "node:path";
+var OPENCODE_PLUGIN_MANAGED_PREFIX = "axi-sdk-js managed opencode plugin:";
+function isManagedHook(hook, marker) {
+  return typeof hook?.command === "string" && hook.command.includes(marker);
+}
+function computeSessionStartHookUpdate(settings, spec) {
+  const updated = structuredClone(settings);
+  let changed = false;
+  if (!updated.hooks) {
+    updated.hooks = {};
+    changed = true;
+  }
+  if (Array.isArray(updated.hooks.session_start)) {
+    const legacyHooks = updated.hooks.session_start.filter((hook) => !isManagedHook(hook, spec.marker));
+    if (legacyHooks.length !== updated.hooks.session_start.length) {
+      changed = true;
+      if (legacyHooks.length === 0) {
+        delete updated.hooks.session_start;
+      } else {
+        updated.hooks.session_start = legacyHooks;
+      }
+    }
+  }
+  if (!Array.isArray(updated.hooks.SessionStart)) {
+    updated.hooks.SessionStart = [];
+    changed = true;
+  }
+  for (const group of updated.hooks.SessionStart) {
+    if (!Array.isArray(group.hooks)) {
+      continue;
+    }
+    for (const hook of group.hooks) {
+      if (!isManagedHook(hook, spec.marker)) {
+        continue;
+      }
+      const timeout = spec.timeoutSeconds ?? 10;
+      const isCorrect = hook.command === spec.command && hook.type === "command" && hook.timeout === timeout;
+      if (isCorrect && !changed) {
+        return [settings, false];
+      }
+      hook.command = spec.command;
+      hook.type = "command";
+      hook.timeout = timeout;
+      return [updated, true];
+    }
+  }
+  updated.hooks.SessionStart.push({
+    matcher: "",
+    hooks: [
+      {
+        type: "command",
+        command: spec.command,
+        timeout: spec.timeoutSeconds ?? 10
+      }
+    ]
+  });
+  return [updated, true];
+}
+function computeCodexConfigUpdate(content) {
+  const newline = content.includes("\r\n") ? "\r\n" : "\n";
+  const normalized = content.length === 0 ? "" : content;
+  if (normalized.trim().length === 0) {
+    return [`[features]${newline}hooks = true${newline}`, true];
+  }
+  const lines = normalized.split(/\r?\n/);
+  const updated = [...lines];
+  let inFeatures = false;
+  let sawFeatures = false;
+  for (let index = 0; index < updated.length; index++) {
+    const line = updated[index];
+    const section = line.match(/^\s*(\[{1,2})([^\]]+)(\]{1,2})\s*(?:#.*)?$/);
+    if (section) {
+      const isTableHeader = section[1] === "[" && section[3] === "]" || section[1] === "[[" && section[3] === "]]";
+      if (!isTableHeader) {
+        continue;
+      }
+      const sectionName = section[2].trim();
+      if (inFeatures) {
+        updated.splice(index, 0, "hooks = true");
+        return [updated.join(newline), true];
+      }
+      inFeatures = sectionName === "features";
+      sawFeatures ||= inFeatures;
+      continue;
+    }
+    if (!inFeatures) {
+      continue;
+    }
+    const flag = line.match(/^\s*hooks\s*=\s*(true|false)\s*(?:#.*)?$/);
+    if (!flag) {
+      continue;
+    }
+    if (flag[1] === "true") {
+      return [content, false];
+    }
+    updated[index] = line.replace(/false/, "true");
+    return [updated.join(newline), true];
+  }
+  if (sawFeatures) {
+    const suffix = normalized.endsWith(newline) ? "" : newline;
+    return [`${normalized}${suffix}hooks = true${newline}`, true];
+  }
+  const separator = normalized.endsWith(newline) ? newline : `${newline}${newline}`;
+  return [
+    `${normalized}${separator}[features]${newline}hooks = true${newline}`,
+    true
+  ];
+}
+function sanitizeOpenCodePluginFilePart(marker) {
+  return marker.replace(/[^A-Za-z0-9._-]+/g, "_");
+}
+function sanitizeOpenCodeExportName(marker) {
+  const name = marker.split(/[^A-Za-z0-9]+/).filter(Boolean).map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`).join("");
+  return `Axi${name || "Plugin"}AmbientContextPlugin`;
+}
+function buildOpenCodeAmbientPluginSource(marker, command, timeoutSeconds) {
+  const exportName = sanitizeOpenCodeExportName(marker);
+  const managedMarker = `${OPENCODE_PLUGIN_MANAGED_PREFIX} ${marker}`;
+  return `// ${managedMarker}
+// This file is generated by axi-sdk-js. It is safe to edit only if you remove the managed marker above.
+import { spawn } from "node:child_process";
+
+const command = ${JSON.stringify(command)};
+const marker = ${JSON.stringify(marker)};
+const ambientHeader = ${JSON.stringify(`## AXI ambient context: ${marker}`)};
+const timeoutMs = ${JSON.stringify(timeoutSeconds * 1e3)};
+
+function runAxiHomeView(cwd) {
+  return new Promise((resolve) => {
+    const child = spawn(command, [], {
+      cwd: directoryOrFallback(cwd),
+      env: process.env,
+      shell: false,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      child.kill("SIGTERM");
+      resolve("error: " + marker + " ambient context timed out after " + timeoutMs + "ms");
+    }, timeoutMs);
+
+    child.stdout?.setEncoding("utf-8");
+    child.stderr?.setEncoding("utf-8");
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve("error: " + marker + " ambient context failed: " + error.message);
+    });
+    child.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (code === 0) {
+        resolve(stdout.trim());
+        return;
+      }
+      const message = (stderr || stdout || marker + " exited with code " + code).trim();
+      resolve("error: " + marker + " ambient context failed: " + message);
+    });
+  });
+}
+
+function directoryOrFallback(directory) {
+  return typeof directory === "string" && directory.length > 0
+    ? directory
+    : process.cwd();
+}
+
+export const ${exportName} = async ({ directory }) => {
+  const sessionCache = new Map();
+
+  return {
+    "experimental.chat.system.transform": async (input, output) => {
+      const sessionID = input.sessionID ?? "__global__";
+      let homeView = sessionCache.get(sessionID);
+      if (homeView === undefined) {
+        homeView = await runAxiHomeView(directory);
+        sessionCache.set(sessionID, homeView);
+      }
+
+      if (homeView.length === 0) return;
+      output.system.push(ambientHeader + "\\n" + homeView);
+    },
+  };
+};
+`;
+}
+function openCodePluginFileName(marker) {
+  return `axi-${sanitizeOpenCodePluginFilePart(marker)}.js`;
+}
+function openCodePluginDir(scope, home, root) {
+  return scope === "project" ? join2(root, ".opencode", "plugins") : join2(home, ".config", "opencode", "plugins");
+}
+function resolveHookScopeTargets(marker, options) {
+  const home = options.homeDir ?? homedir2();
+  const scope = options.scope ?? "user";
+  const root = scope === "project" ? resolve(options.projectDir ?? process.cwd()) : home;
+  return {
+    scope,
+    home,
+    root,
+    claudeSettingsPath: join2(root, ".claude", "settings.json"),
+    codexHooksPath: join2(root, ".codex", "hooks.json"),
+    codexConfigPath: join2(home, ".codex", "config.toml"),
+    openCodePluginPath: join2(openCodePluginDir(scope, home, root), openCodePluginFileName(marker))
+  };
+}
+function installOpenCodeAmbientPlugin(pluginPath, marker, command, timeoutSeconds, onError) {
+  const managedMarker = `${OPENCODE_PLUGIN_MANAGED_PREFIX} ${marker}`;
+  const next = buildOpenCodeAmbientPluginSource(marker, command, timeoutSeconds);
+  try {
+    mkdirSync(dirname2(pluginPath), { recursive: true });
+    const current = existsSync2(pluginPath) ? readFileSync2(pluginPath, "utf-8") : void 0;
+    if (current !== void 0 && !current.includes(managedMarker)) {
+      onError?.(`${pluginPath}: refusing to overwrite unmanaged OpenCode plugin`);
+      return;
+    }
+    if (current !== next) {
+      writeFileSync(pluginPath, next, "utf-8");
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    onError?.(`${pluginPath}: ${message}`);
+  }
+}
+function resolvePortableHookCommand(execPath, binaryNames, marker, context) {
+  if (binaryNames.length === 0) {
+    return execPath;
+  }
+  const resolvedExec = context.resolveRealPath(execPath);
+  if (!resolvedExec) {
+    return execPath;
+  }
+  for (const name of binaryNames) {
+    if (!name.includes(marker)) {
+      continue;
+    }
+    for (const dir of context.pathEntries) {
+      if (!dir)
+        continue;
+      for (const ext of context.pathExtensions) {
+        const candidate = join2(dir, `${name}${ext}`);
+        const resolvedCandidate = context.resolveRealPath(candidate);
+        if (resolvedCandidate && resolvedCandidate === resolvedExec) {
+          return name;
+        }
+        const shimTarget = context.resolveShimTarget?.(candidate);
+        if (shimTarget && shimTarget === resolvedExec) {
+          return name;
+        }
+      }
+    }
+  }
+  return execPath;
+}
+var NPM_SHIM_SCRIPT_PATTERNS = [
+  // Git Bash / POSIX shim: exec node "$basedir/node_modules/<pkg>/.../cli.js"
+  /"\$basedir\/([^"]+\.[cm]?js)"/,
+  // Windows .cmd shim: "%dp0%\node_modules\<pkg>\...\cli.js"
+  /%~?dp0%?[\\/]([^"\r\n]+\.[cm]?js)/i
+];
+function extractNpmShimScriptPath(content) {
+  for (const pattern of NPM_SHIM_SCRIPT_PATTERNS) {
+    const match = content.match(pattern);
+    if (match?.[1]) {
+      return match[1];
+    }
+  }
+  return void 0;
+}
+function buildDefaultPortableCommandContext() {
+  const rawPath = process.env.PATH ?? process.env.Path ?? "";
+  const pathEntries = rawPath.split(delimiter).filter(Boolean);
+  const pathExtensions = process.platform === "win32" ? (
+    // Git Bash resolves the extensionless shim, which PATHEXT omits.
+    ["", ...(process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";")]
+  ) : [""];
+  return {
+    pathEntries,
+    pathExtensions,
+    resolveRealPath: (absolutePath) => {
+      try {
+        const stat = statSync(absolutePath);
+        if (!stat.isFile()) {
+          return void 0;
+        }
+        return realpathSync2(absolutePath);
+      } catch {
+        return void 0;
+      }
+    },
+    resolveShimTarget: (shimPath) => {
+      try {
+        const relative = extractNpmShimScriptPath(readFileSync2(shimPath, "utf-8"));
+        if (!relative) {
+          return void 0;
+        }
+        return realpathSync2(resolve(dirname2(shimPath), relative));
+      } catch {
+        return void 0;
+      }
+    }
+  };
+}
+function shouldInstallHooksForNodeAxiExecPath(execPath, policy) {
+  const normalized = resolve(execPath).replaceAll("\\", "/");
+  if (!normalized.includes(policy.marker) || normalized.endsWith(".ts")) {
+    return false;
+  }
+  const fileName = basename3(normalized);
+  if (policy.binaryNames?.includes(fileName)) {
+    return true;
+  }
+  return policy.distEntrypoints?.some((entrypoint) => normalized.endsWith(entrypoint.replaceAll("\\", "/"))) ?? false;
+}
+function inferHookOptions(execPath) {
+  if (!execPath) {
+    return void 0;
+  }
+  const normalized = execPath.replaceAll("\\", "/");
+  const match = normalized.match(/(?:^|\/)dist\/bin\/([^/]+)\.js$/);
+  if (match?.[1]) {
+    const marker = match[1];
+    return {
+      execPath,
+      marker,
+      binaryNames: [marker],
+      distEntrypoints: [`dist/bin/${marker}.js`]
+    };
+  }
+  const fileName = normalized.split("/").pop() ?? "";
+  if (!fileName || fileName.includes(".") || fileName === "node") {
+    return void 0;
+  }
+  return {
+    execPath,
+    marker: fileName,
+    binaryNames: [fileName],
+    distEntrypoints: [`dist/bin/${fileName}.js`]
+  };
+}
+function buildInferredHookInstallPolicy(marker, options, inferred) {
+  const binaryNames = options.binaryNames ?? inferred.binaryNames;
+  const distEntrypoints = options.distEntrypoints ?? inferred.distEntrypoints;
+  return (execPath) => shouldInstallHooksForNodeAxiExecPath(execPath, {
+    marker,
+    binaryNames,
+    distEntrypoints
+  });
+}
+function installSessionStartHooks(options = {}) {
+  const inferred = inferHookOptions(options.execPath ?? process.argv[1]);
+  const marker = options.marker ?? inferred?.marker;
+  if (!marker) {
+    return;
+  }
+  const execPath = resolve(options.execPath ?? inferred?.execPath ?? process.argv[1] ?? "");
+  if (!execPath) {
+    return;
+  }
+  const defaultPolicyOptions = inferred ?? {
+    execPath,
+    marker,
+    binaryNames: [marker],
+    distEntrypoints: [`dist/bin/${marker}.js`]
+  };
+  const shouldInstall = options.shouldInstall ?? buildInferredHookInstallPolicy(marker, options, defaultPolicyOptions);
+  if (shouldInstall && !shouldInstall(execPath)) {
+    return;
+  }
+  const binaryNames = options.binaryNames ?? inferred?.binaryNames ?? [];
+  const command = resolvePortableHookCommand(execPath, binaryNames, marker, buildDefaultPortableCommandContext());
+  const targets = resolveHookScopeTargets(marker, options);
+  const jsonTargets = [targets.claudeSettingsPath, targets.codexHooksPath];
+  const codexConfigPath = targets.codexConfigPath;
+  installOpenCodeAmbientPlugin(targets.openCodePluginPath, marker, command, options.timeoutSeconds ?? 10, options.onError);
+  for (const target of jsonTargets) {
+    try {
+      mkdirSync(dirname2(target), { recursive: true });
+      const current = existsSync2(target) ? JSON.parse(readFileSync2(target, "utf-8")) : {};
+      const [updated, changed] = computeSessionStartHookUpdate(current, {
+        marker,
+        command,
+        timeoutSeconds: options.timeoutSeconds
+      });
+      if (changed) {
+        writeFileSync(target, `${JSON.stringify(updated, null, 2)}
+`, "utf-8");
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      options.onError?.(`${target}: ${message}`);
+    }
+  }
+  try {
+    mkdirSync(dirname2(codexConfigPath), { recursive: true });
+    const current = existsSync2(codexConfigPath) ? readFileSync2(codexConfigPath, "utf-8") : "";
+    const [updated, changed] = computeCodexConfigUpdate(current);
+    if (changed) {
+      writeFileSync(codexConfigPath, updated, "utf-8");
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    options.onError?.(`${codexConfigPath}: ${message}`);
+  }
+}
+
+// vendor/chrome-devtools-axi/src/client.ts
+import { execFileSync, spawn as spawn2 } from "node:child_process";
+import { readFileSync as readFileSync3, existsSync as existsSync3 } from "node:fs";
+import { request } from "node:http";
+import { dirname as dirname3 } from "node:path";
+
+// vendor/chrome-devtools-axi/src/pages.ts
+var PAGE_SCOPED_TOOLS = /* @__PURE__ */ new Set([
+  "click",
+  "drag",
+  "emulate",
+  "evaluate_script",
+  "fill",
+  "fill_form",
+  "get_console_message",
+  "get_network_request",
+  "handle_dialog",
+  "hover",
+  "lighthouse_audit",
+  "list_console_messages",
+  "list_network_requests",
+  "navigate_page",
+  "performance_analyze_insight",
+  "performance_start_trace",
+  "performance_stop_trace",
+  "press_key",
+  "resize_page",
+  "take_heapsnapshot",
+  "take_screenshot",
+  "take_snapshot",
+  "type_text",
+  "upload_file",
+  "wait_for"
+]);
+function needsPageId(name, args = {}) {
+  if (typeof args.pageId === "number") return false;
+  if (name === "evaluate_script" && typeof args.serviceWorkerId === "string" && args.serviceWorkerId.length > 0) {
+    return false;
+  }
+  return PAGE_SCOPED_TOOLS.has(name);
+}
+var GENERIC_SCHEME_SLASH_URL = /^[a-z][a-z0-9+.-]*:\/\//i;
+var COLON_ONLY_SCHEME_URL = /^(?:about:|data:|view-source:|blob:)/i;
+function isPageSchemeUrl(label) {
+  return GENERIC_SCHEME_SLASH_URL.test(label) || COLON_ONLY_SCHEME_URL.test(label);
+}
+var MCP_SECTION_HEADER = /^##\s+(Pages|Extension Pages|Extension Service Workers|Third-party developer tools|WebMCP tools)$/;
+var PAGE_ID_LINE = /^\d+:(?:\s+|$)/;
+var OPEN_DIALOG_HEADER = /^# Open dialog$/;
+var HANDLE_DIALOG_FOOTER = /^Call handle_dialog to handle it before continuing\.$/;
+function stripTrailingIsolatedContext(label) {
+  const match = label.match(/^(.*)\s+isolatedContext=.*$/);
+  if (!match) return label;
+  const before = match[1];
+  const withoutSelected = before.replace(/\s*\[selected\]\s*$/, "").trimEnd();
+  if (matchTrailingUrl(withoutSelected) !== null) return before;
+  if (isPageSchemeUrl(withoutSelected)) return before;
+  return label;
+}
+function stripPageSuffixes(rest) {
+  let label = stripTrailingIsolatedContext(rest);
+  if (/(?:^|\s)\[selected\]\s*$/.test(label)) {
+    label = label.replace(/\s*\[selected\]\s*$/, "").trimEnd();
+  }
+  return label;
+}
+function matchTrailingUrl(label) {
+  const trimmed = label.trimEnd();
+  if (!trimmed.endsWith(")")) return null;
+  const close = trimmed.length - 1;
+  let from = close;
+  while (from > 0) {
+    const open = trimmed.lastIndexOf(" (", from - 1);
+    if (open === -1) return null;
+    const url = trimmed.slice(open + 2, close);
+    if (isPageSchemeUrl(url)) {
+      return { title: trimmed.slice(0, open), url };
+    }
+    from = open;
+  }
+  return null;
+}
+function hasSchemeUrl(label) {
+  const rest = stripPageSuffixes(label);
+  return matchTrailingUrl(rest) !== null || isPageSchemeUrl(rest);
+}
+function isCompletePageRow(row) {
+  return hasSchemeUrl(row.replace(/^\d+:\s*/, ""));
+}
+function isTitleContinuationLine(line) {
+  const m = line.match(/^(\d+):\s+(.+)$/);
+  if (!m) return false;
+  const rest = stripPageSuffixes(m[2]);
+  if (matchTrailingUrl(rest) !== null) return false;
+  if (isPageSchemeUrl(rest)) return false;
+  return /(?:^|\s)\[selected\]\s*$/.test(stripTrailingIsolatedContext(m[2]));
+}
+function extractPageUrl(label) {
+  const match = matchTrailingUrl(label);
+  return match ? match.url : label.trim();
+}
+function pageRowRest(row) {
+  return stripPageSuffixes(row.replace(/^\d+:\s*/, ""));
+}
+function stripDialogPreamble(text) {
+  const lines = text.split(/\r?\n/);
+  const kept = [];
+  for (let i = 0; i < lines.length; ) {
+    if (OPEN_DIALOG_HEADER.test(lines[i].trim())) {
+      let end = -1;
+      for (let idx = i + 1; idx < lines.length; idx++) {
+        if (HANDLE_DIALOG_FOOTER.test(lines[idx].trim())) end = idx;
+      }
+      if (end !== -1) {
+        i = end + 1;
+        continue;
+      }
+    }
+    kept.push(lines[i]);
+    i++;
+  }
+  return kept.join("\n");
+}
+function followingLinesCompleteTitle(rawLines, headerIndex, currentRow) {
+  let acc = `${currentRow} ## Pages`;
+  for (let i = headerIndex + 1; i < rawLines.length; i++) {
+    const next = rawLines[i].trim();
+    if (next.length === 0) continue;
+    if (next.match(MCP_SECTION_HEADER) !== null) return false;
+    if (PAGE_ID_LINE.test(next)) {
+      const rest = stripPageSuffixes(next.replace(/^\d+:\s*/, ""));
+      if (isPageSchemeUrl(rest) && matchTrailingUrl(rest) === null) {
+        return false;
+      }
+    }
+    acc += ` ${next}`;
+    if (matchTrailingUrl(pageRowRest(acc)) !== null) return true;
+  }
+  return false;
+}
+function collapsePageRows(text) {
+  const rows = [];
+  let inPageBlock = false;
+  const rawLines = stripDialogPreamble(text).split(/\r?\n/);
+  for (let index = 0; index < rawLines.length; index++) {
+    const line = rawLines[index].trim();
+    if (line.length === 0) continue;
+    const section = line.match(MCP_SECTION_HEADER)?.[1];
+    if (section !== void 0) {
+      const prev = rows[rows.length - 1];
+      if (section === "Pages" && inPageBlock && prev !== void 0 && !isCompletePageRow(prev) && followingLinesCompleteTitle(rawLines, index, prev)) {
+        rows[rows.length - 1] += ` ${line}`;
+        continue;
+      }
+      if (section === "Pages") {
+        rows.length = 0;
+        inPageBlock = true;
+      } else if (section === "Extension Pages") {
+        inPageBlock = true;
+      } else {
+        inPageBlock = false;
+      }
+      continue;
+    }
+    if (!inPageBlock) continue;
+    if (PAGE_ID_LINE.test(line)) {
+      const prev = rows[rows.length - 1];
+      if (prev !== void 0 && (!isCompletePageRow(prev) || isTitleContinuationLine(line))) {
+        rows[rows.length - 1] += ` ${line}`;
+      } else {
+        rows.push(line);
+      }
+      continue;
+    }
+    if (rows.length > 0) {
+      rows[rows.length - 1] += ` ${line}`;
+    }
+  }
+  return rows.map((row) => row.replace(/\s+/g, " "));
+}
+function parsePagesList(text) {
+  const pages = [];
+  for (const line of collapsePageRows(text)) {
+    const m = line.match(/^(\d+):\s+(.+)$/);
+    if (!m) continue;
+    const id = Number.parseInt(m[1], 10);
+    let rest = stripTrailingIsolatedContext(m[2]);
+    const selected = /(?:^|\s)\[selected\]\s*$/.test(rest);
+    if (selected) {
+      rest = rest.replace(/\s*\[selected\]\s*$/, "").trimEnd();
+    }
+    const url = extractPageUrl(rest);
+    pages.push({ id, url, selected });
+  }
+  return pages;
+}
+
+// vendor/chrome-devtools-axi/src/client.ts
+var DEFAULT_BRIDGE_TIMEOUT_MS = 3e4;
+var MIN_BRIDGE_TIMEOUT_MS = 1e3;
+var HEALTH_TIMEOUT_MS = 2e3;
+var DEEP_HEALTH_TIMEOUT_MS = 5e3;
+function resolveBridgeTimeoutMs() {
+  const raw = process.env.CHROME_DEVTOOLS_AXI_BRIDGE_TIMEOUT_MS;
+  if (!raw) return DEFAULT_BRIDGE_TIMEOUT_MS;
+  const parsed = Number.parseInt(raw, 10);
+  if (Number.isNaN(parsed) || parsed <= 0) return DEFAULT_BRIDGE_TIMEOUT_MS;
+  return Math.max(parsed, MIN_BRIDGE_TIMEOUT_MS);
+}
+var CdpError = class extends AxiError {
+  constructor(message, code, suggestions = []) {
+    super(message, code, suggestions);
+    this.code = code;
+    this.suggestions = suggestions;
+    this.name = "CdpError";
+  }
+  code;
+  suggestions;
+};
+function readPidFile(pidFile = resolveSessionPidFile()) {
+  try {
+    if (!existsSync3(pidFile)) return null;
+    const data = JSON.parse(readFileSync3(pidFile, "utf-8"));
+    if (typeof data.pid === "number" && typeof data.port === "number") {
+      return data;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function httpGet(port, path, timeoutMs = 2e3) {
+  return new Promise((resolve3, reject) => {
+    const req = request(
+      { hostname: "127.0.0.1", port, path, method: "GET", timeout: timeoutMs },
+      (res) => {
+        res.setEncoding("utf8");
+        let data = "";
+        res.on("data", (chunk) => data += chunk);
+        res.on("end", () => resolve3(data));
+      }
+    );
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("timeout"));
+    });
+    req.end();
+  });
+}
+function httpPost(port, path, body, timeoutMs = 12e4) {
+  return new Promise((resolve3, reject) => {
+    const payload = JSON.stringify(body);
+    const req = request(
+      {
+        hostname: "127.0.0.1",
+        port,
+        path,
+        method: "POST",
+        timeout: timeoutMs,
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(payload)
+        }
+      },
+      (res) => {
+        res.setEncoding("utf8");
+        let data = "";
+        res.on("data", (chunk) => data += chunk);
+        res.on("end", () => {
+          if (res.statusCode && res.statusCode >= 400) {
+            reject(new Error(data));
+          } else {
+            resolve3(data);
+          }
+        });
+      }
+    );
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("timeout"));
+    });
+    req.write(payload);
+    req.end();
+  });
+}
+async function checkBridgeHealth(port, opts = {}) {
+  try {
+    const path = opts.deep ? "/health?deep=1" : "/health";
+    const timeoutMs = opts.deep ? DEEP_HEALTH_TIMEOUT_MS : HEALTH_TIMEOUT_MS;
+    const resp = await httpGet(port, path, timeoutMs);
+    const data = JSON.parse(resp);
+    if (data.status !== "ok") return false;
+    if (opts.expectedSession !== void 0 && typeof data.session === "string" && data.session !== opts.expectedSession) {
+      return false;
+    }
+    if (opts.deep && opts.notice) {
+      opts.notice.pageIdentityChanged = data.pageIdentityChanged === true;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+async function waitForProcessExit(pid, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!isProcessAlive(pid)) return true;
+    await sleep(50);
+  }
+  return !isProcessAlive(pid);
+}
+function isBridgeProcess(pid) {
+  try {
+    const command = execFileSync("ps", ["-p", String(pid), "-o", "command="], {
+      encoding: "utf-8",
+      timeout: 1e3
+    });
+    return command.includes("chrome-devtools-axi-bridge");
+  } catch {
+    return false;
+  }
+}
+async function terminateBridgeProcess(pid, opts = {}) {
+  if (!isProcessAlive(pid)) return;
+  const killProcessGroup = opts.killProcessGroup === true;
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    return;
+  }
+  if (await waitForProcessExit(pid, 2e3)) {
+    if (killProcessGroup) {
+      try {
+        process.kill(-pid, "SIGKILL");
+      } catch {
+      }
+    }
+    return;
+  }
+  if (killProcessGroup) {
+    try {
+      process.kill(-pid, "SIGKILL");
+    } catch {
+      try {
+        process.kill(pid, "SIGKILL");
+      } catch {
+      }
+    }
+  } else {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+    }
+  }
+  await waitForProcessExit(pid, 1e3);
+}
+function spawnBridgeProcess(port, sessionName) {
+  const bridgeScript = resolveBridgeScript(import.meta.dirname);
+  const script = existsSync3(bridgeScript.replace(/\.js$/, ".ts")) ? bridgeScript.replace(/\.js$/, ".ts") : bridgeScript;
+  const runner = script.endsWith(".ts") ? "tsx" : "node";
+  const child = spawn2(
+    runner === "tsx" ? "npx" : "node",
+    runner === "tsx" ? ["tsx", script] : [script],
+    {
+      stdio: "ignore",
+      env: {
+        ...process.env,
+        CHROME_DEVTOOLS_AXI_PORT: String(port),
+        CHROME_DEVTOOLS_AXI_SESSION: sessionName
+      },
+      detached: true
+    }
+  );
+  child.unref();
+  return child;
+}
+function resolveSharedMcpMode() {
+  const sharedServerUrl = process.env.CHROME_DEVTOOLS_AXI_MCP_SERVER_URL?.trim();
+  if (!sharedServerUrl) return null;
+  return process.env.CHROME_DEVTOOLS_AXI_MCP_PATH?.trim() ? "proxy" : "direct";
+}
+function sharedMcpSuggestions(mode) {
+  if (mode === "direct") {
+    return [
+      "Shared MCP direct mode is enabled by CHROME_DEVTOOLS_AXI_MCP_SERVER_URL; AXI connects directly to that Streamable HTTP endpoint without launching a local MCP process.",
+      "Verify CHROME_DEVTOOLS_AXI_MCP_SERVER_URL is an absolute http(s) MCP endpoint and that the service is running and reachable there."
+    ];
+  }
+  return [
+    "Shared MCP proxy mode is enabled by CHROME_DEVTOOLS_AXI_MCP_SERVER_URL; this mode does not launch Chrome locally.",
+    "Set CHROME_DEVTOOLS_AXI_MCP_PATH to a runnable chrome-devtools-mcp build that advertises --serverUrl in --help.",
+    "Use the proxy-capable MCP build from the companion shared-server change, then restart this AXI session."
+  ];
+}
+function buildBridgeEarlyExitError(sessionName, port, code, signal) {
+  const how = signal != null ? `was killed by ${signal}` : `exited with code ${code ?? "unknown"}`;
+  const message = `Bridge for session "${sessionName}" ${how} before becoming ready on port ${port}`;
+  if (code === BRIDGE_PORT_IN_USE_EXIT_CODE) {
+    return new CdpError(message, "BRIDGE_NOT_READY", [
+      `Port ${port} is already in use. It may be held by another chrome-devtools-axi session's bridge (a hashed-port collision, or a globally-exported CHROME_DEVTOOLS_AXI_PORT forcing every session onto one port), by a stale or crashed bridge that could not be reused, or by an unrelated process.`,
+      "Set a distinct CHROME_DEVTOOLS_AXI_PORT for this session, unset a global CHROME_DEVTOOLS_AXI_PORT so every session derives its own, or free whatever is holding the port."
+    ]);
+  }
+  const sharedMcpMode = resolveSharedMcpMode();
+  if (sharedMcpMode) {
+    return new CdpError(
+      message,
+      "BRIDGE_NOT_READY",
+      sharedMcpSuggestions(sharedMcpMode)
+    );
+  }
+  const suggestions = [
+    "Check that chrome-devtools-mcp can start: npx chrome-devtools-mcp@latest --help"
+  ];
+  if (process.env.CHROME_DEVTOOLS_AXI_MCP_PATH?.trim()) {
+    suggestions.push(
+      "Verify CHROME_DEVTOOLS_AXI_MCP_PATH points to a valid chrome-devtools-mcp build."
+    );
+  } else {
+    suggestions.push(
+      "`npx -y chrome-devtools-mcp@latest` may have failed to resolve/download the package (offline, or a slow cold first run); install it globally and set:",
+      '  export CHROME_DEVTOOLS_AXI_MCP_PATH="$(npm prefix -g)/lib/node_modules/chrome-devtools-mcp/build/src/bin/chrome-devtools-mcp.js"'
+    );
+  }
+  suggestions.push(
+    "Or Chrome failed to launch; confirm a usable Chrome is installed."
+  );
+  return new CdpError(message, "BRIDGE_NOT_READY", suggestions);
+}
+async function ensureBridge(spawnBridge = spawnBridgeProcess, notice) {
+  const sessionName = resolveSessionName();
+  const port = resolveSessionPort(sessionName);
+  const pidFile = resolveSessionPidFile(sessionName);
+  const pidInfo = readPidFile(pidFile);
+  if (pidInfo && isProcessAlive(pidInfo.pid)) {
+    if (await checkBridgeHealth(pidInfo.port, {
+      deep: true,
+      expectedSession: sessionName,
+      notice
+    })) {
+      return pidInfo.port;
+    }
+    await terminateBridgeProcess(pidInfo.pid, {
+      killProcessGroup: isBridgeProcess(pidInfo.pid)
+    });
+  }
+  clearSelectedPageId();
+  const child = spawnBridge(port, sessionName);
+  let childExited = false;
+  let exitCode = null;
+  let exitSignal = null;
+  child.on("exit", (code, signal) => {
+    childExited = true;
+    exitCode = code;
+    exitSignal = signal;
+  });
+  const timeoutMs = resolveBridgeTimeoutMs();
+  const deadline = Date.now() + timeoutMs;
+  let sawShallowReady = false;
+  while (Date.now() < deadline) {
+    if (await checkBridgeHealth(port, {
+      deep: true,
+      expectedSession: sessionName,
+      notice
+    })) {
+      return port;
+    }
+    if (childExited) {
+      if (await checkBridgeHealth(port, {
+        deep: true,
+        expectedSession: sessionName,
+        notice
+      })) {
+        return port;
+      }
+      throw buildBridgeEarlyExitError(sessionName, port, exitCode, exitSignal);
+    }
+    if (!sawShallowReady && await checkBridgeHealth(port, { expectedSession: sessionName })) {
+      sawShallowReady = true;
+    }
+    await sleep(500);
+  }
+  const seconds = Math.round(timeoutMs / 1e3);
+  const sharedMcpMode = resolveSharedMcpMode();
+  if (sawShallowReady) {
+    const suggestions2 = sharedMcpMode ? [
+      ...sharedMcpSuggestions(sharedMcpMode),
+      "The shared MCP service may be reachable while its attached Chrome target is unavailable."
+    ] : [
+      "The Chrome/Electron instance the bridge was attached to may have exited.",
+      "Verify the target is still listening on its remote-debugging port, then re-run the command.",
+      "If the target was restarted, the bridge has already been recycled \u2014 this run will succeed once the target is reachable."
+    ];
+    throw new CdpError(
+      "Bridge is running but the attached CDP target appears to have gone away",
+      "BRIDGE_NOT_READY",
+      suggestions2
+    );
+  }
+  const suggestions = sharedMcpMode === "direct" ? sharedMcpSuggestions("direct") : sharedMcpMode === "proxy" ? sharedMcpSuggestions("proxy") : [
+    "Check that chrome-devtools-mcp is installed: npx chrome-devtools-mcp@latest --help"
+  ];
+  if (!sharedMcpMode && !process.env.CHROME_DEVTOOLS_AXI_MCP_PATH?.trim()) {
+    suggestions.push(
+      "If `npx -y chrome-devtools-mcp@latest` is slow on this machine, install mcp globally and set:",
+      '  export CHROME_DEVTOOLS_AXI_MCP_PATH="$(npm prefix -g)/lib/node_modules/chrome-devtools-mcp/build/src/bin/chrome-devtools-mcp.js"'
+    );
+  }
+  suggestions.push(
+    "Or extend the deadline: export CHROME_DEVTOOLS_AXI_BRIDGE_TIMEOUT_MS=60000"
+  );
+  throw new CdpError(
+    `Bridge failed to start within ${seconds}s`,
+    "BRIDGE_NOT_READY",
+    suggestions
+  );
+}
+function parseCallResponse(resp) {
+  const data = JSON.parse(resp);
+  if (data.error) {
+    throw new Error(data.error);
+  }
+  return data.result ?? "";
+}
+async function postTool(port, name, args, opts = {}) {
+  const body = { name, args };
+  if (opts.roots && opts.roots.length > 0) body.roots = opts.roots;
+  const resp = await httpPost(port, "/call", body, opts.timeoutMs);
+  return parseCallResponse(resp);
+}
+var FILE_OUTPUT_ARGS_BY_TOOL = /* @__PURE__ */ new Map([
+  ["take_screenshot", ["filePath"]],
+  ["get_network_request", ["responseFilePath", "requestFilePath"]],
+  ["performance_start_trace", ["filePath"]],
+  ["performance_stop_trace", ["filePath"]],
+  ["take_heapsnapshot", ["filePath"]]
+]);
+var DIR_OUTPUT_ARGS_BY_TOOL = /* @__PURE__ */ new Map([
+  ["lighthouse_audit", ["outputDirPath"]]
+]);
+function nearestExistingAncestor(path) {
+  let candidate = path;
+  while (!existsSync3(candidate)) {
+    const parent = dirname3(candidate);
+    if (parent === candidate) return candidate;
+    candidate = parent;
+  }
+  return candidate;
+}
+function collectRootDirs(name, args) {
+  const dirs = /* @__PURE__ */ new Set([process.cwd()]);
+  for (const key of FILE_OUTPUT_ARGS_BY_TOOL.get(name) ?? []) {
+    const value = args[key];
+    if (typeof value === "string" && value.length > 0) {
+      dirs.add(nearestExistingAncestor(dirname3(value)));
+    }
+  }
+  for (const key of DIR_OUTPUT_ARGS_BY_TOOL.get(name) ?? []) {
+    const value = args[key];
+    if (typeof value === "string" && value.length > 0) {
+      dirs.add(nearestExistingAncestor(value));
+    }
+  }
+  if (name === "upload_file" && Array.isArray(args.filePaths)) {
+    for (const file of args.filePaths) {
+      if (typeof file === "string") dirs.add(dirname3(file));
+    }
+  }
+  return [...dirs];
+}
+function resolveSelectedPageId(reconnected) {
+  const pageId = getSelectedPageId();
+  if (pageId === null) {
+    if (reconnected) throw pageIdentityClearedError();
+    throw new CdpError("No page is currently selected", "BROWSER_ERROR", [
+      "Run `chrome-devtools-axi open <url>` to open a page",
+      "Run `chrome-devtools-axi pages` to list tabs",
+      "Run `chrome-devtools-axi selectpage <id>` to select a tab"
+    ]);
+  }
+  return pageId;
+}
+function resolveToolArgs(name, args, reconnected) {
+  if (!needsPageId(name, args)) return args;
+  return { ...args, pageId: resolveSelectedPageId(reconnected) };
+}
+async function callTool(name, args = {}) {
+  const notice = { pageIdentityChanged: false };
+  const port = await ensureBridge(void 0, notice);
+  let resolved = args;
+  try {
+    resolved = resolveToolArgs(name, args, notice.pageIdentityChanged);
+    const result = await postTool(port, name, resolved, {
+      roots: collectRootDirs(name, resolved)
+    });
+    rememberToolRouting(name, resolved, result);
+    return result;
+  } catch (err) {
+    if (err instanceof CdpError) throw err;
+    const message = err instanceof Error ? err.message : String(err);
+    if (isMissingPageError(message)) {
+      const pageId = typeof resolved.pageId === "number" ? resolved.pageId : null;
+      if (pageId !== null && getSelectedPageId() === pageId) {
+        clearSelectedPageId();
+      }
+      throw missingPageError(pageId);
+    }
+    throw mapErrorMessage(message);
+  }
+}
+var MCP_MISSING_PAGE_LINE = "No page found";
+var MCP_CLOSED_PAGE_LINE_PREFIX = "The selected page has been closed.";
+function isMissingPageError(message) {
+  const line = lastNonEmptyLine(message).replace(/^Error:\s*/, "");
+  return line === MCP_MISSING_PAGE_LINE || line.startsWith(MCP_CLOSED_PAGE_LINE_PREFIX);
+}
+function lastNonEmptyLine(message) {
+  const lines = message.split(/\r?\n/);
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    const line = lines[i].trim();
+    if (line) return line;
+  }
+  return "";
+}
+function missingPageError(pageId) {
+  return new CdpError(
+    pageId === null ? "The selected page is no longer available" : `Page ${pageId} is no longer available`,
+    "BROWSER_ERROR",
+    [
+      "Run `chrome-devtools-axi pages` to list the remaining tabs",
+      "Run `chrome-devtools-axi selectpage <id>` to select a tab, or `chrome-devtools-axi open <url>` to open one"
+    ]
+  );
+}
+var PAGE_IDENTITY_SUGGESTIONS = [
+  "Run `chrome-devtools-axi pages` to list the current tabs and their new ids",
+  "Run `chrome-devtools-axi selectpage <id>` to re-select a tab after the reconnect, then retry"
+];
+function pageIdentityChangedError() {
+  return new CdpError(
+    PAGE_IDENTITY_CHANGED_ERROR,
+    "BROWSER_ERROR",
+    PAGE_IDENTITY_SUGGESTIONS
+  );
+}
+function pageIdentityClearedError() {
+  return new CdpError(
+    "The browser reconnected and every page id changed, so no page is currently selected",
+    "BROWSER_ERROR",
+    PAGE_IDENTITY_SUGGESTIONS
+  );
+}
+function mapErrorMessage(message) {
+  if (message === PAGE_IDENTITY_CHANGED_ERROR) {
+    return pageIdentityChangedError();
+  }
+  if (isMissingPageError(message)) return missingPageError(null);
+  if (message.includes("ECONNREFUSED") || message.includes("ECONNRESET")) {
+    return new CdpError("Bridge is not running", "BRIDGE_NOT_READY", [
+      "Run `chrome-devtools-axi open <url>` \u2014 the bridge starts automatically"
+    ]);
+  }
+  if ((message.includes("uid") || message.includes("element")) && (message.includes("not found") || message.includes("invalid"))) {
+    return new CdpError(message, "REF_NOT_FOUND", [
+      "Run `chrome-devtools-axi snapshot` to see available elements and their @uid refs"
+    ]);
+  }
+  if (message.includes("timeout") || message.includes("timed out")) {
+    return new CdpError(message, "TIMEOUT", [
+      "Run `chrome-devtools-axi snapshot` to see current page state"
+    ]);
+  }
+  try {
+    const parsed = JSON.parse(message);
+    if (parsed.error) {
+      return new CdpError(parsed.error, "BROWSER_ERROR", [
+        "Run `chrome-devtools-axi snapshot` to see current page state"
+      ]);
+    }
+  } catch {
+  }
+  return new CdpError(message, "UNKNOWN");
+}
+async function getSessionSnapshotIfRunning() {
+  let sessionName;
+  let pidInfo;
+  try {
+    sessionName = resolveSessionName();
+    pidInfo = readPidFile(resolveSessionPidFile(sessionName));
+  } catch {
+    return null;
+  }
+  if (!pidInfo || !isProcessAlive(pidInfo.pid)) {
+    return null;
+  }
+  if (!await checkBridgeHealth(pidInfo.port, { expectedSession: sessionName })) {
+    return null;
+  }
+  try {
+    const pageId = getSelectedPageId();
+    if (pageId === null) return null;
+    return await postTool(
+      pidInfo.port,
+      "take_snapshot",
+      { pageId },
+      { timeoutMs: 5e3 }
+    );
+  } catch {
+    return null;
+  }
+}
+async function stopBridge() {
+  const pidInfo = readPidFile();
+  if (!pidInfo) return false;
+  if (!isProcessAlive(pidInfo.pid)) return false;
+  await terminateBridgeProcess(pidInfo.pid, {
+    killProcessGroup: isBridgeProcess(pidInfo.pid)
+  });
+  clearSelectedPageId();
+  return true;
+}
+
+// vendor/chrome-devtools-axi/src/generation.ts
+import {
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync4,
+  unlinkSync,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { dirname as dirname4, join as join3 } from "node:path";
+function genFile() {
+  return join3(resolveSessionStateDir(), "snapshot-generation");
+}
+function getCurrentGeneration() {
+  const file = genFile();
+  try {
+    if (!existsSync4(file)) return 0;
+    const parsed = Number.parseInt(readFileSync4(file, "utf-8").trim(), 10);
+    return Number.isNaN(parsed) ? 0 : parsed;
+  } catch {
+    return 0;
+  }
+}
+function bumpGeneration() {
+  const next = getCurrentGeneration() + 1;
+  const file = genFile();
+  try {
+    mkdirSync2(dirname4(file), { recursive: true });
+    writeFileSync2(file, String(next));
+  } catch {
+  }
+  return next;
+}
+
+// vendor/chrome-devtools-axi/src/run.ts
+import { mkdtempSync, writeFileSync as writeFileSync3, unlinkSync as unlinkSync2, rmdirSync } from "node:fs";
+import { join as join4 } from "node:path";
+import { tmpdir } from "node:os";
+import { pathToFileURL } from "node:url";
+
+// vendor/chrome-devtools-axi/src/snapshot.ts
+function countRefs(snapshot) {
+  const matches = snapshot.match(/\buid=\S+/g);
+  return matches ? matches.length : 0;
+}
+function extractRefs(snapshot) {
+  const refs = [];
+  for (const line of snapshot.split("\n")) {
+    const m = line.match(/\buid=(\S+)\s+(\w+)\s+"([^"]*)"/);
+    if (!m) continue;
+    refs.push({ ref: m[1], type: m[2], label: m[3] });
+  }
+  return refs;
+}
+function parseStampedUid(arg) {
+  const stripped = arg.startsWith("@") ? arg.slice(1) : arg;
+  const m = stripped.match(/^g(\d+):(.+)$/);
+  if (m) return { uid: m[2], generation: Number.parseInt(m[1], 10) };
+  return { uid: stripped, generation: null };
+}
+function stampSnapshotGeneration(snapshot, generation) {
+  return snapshot.replace(/\buid=(\S+)/g, (match, uid) => {
+    if (/^g\d+:/.test(uid)) return match;
+    return `uid=g${generation}:${uid}`;
+  });
+}
+function checkUidGeneration(arg, currentGeneration) {
+  const { uid, generation } = parseStampedUid(arg);
+  return {
+    uid,
+    stale: generation !== null && generation !== currentGeneration,
+    refGeneration: generation
+  };
+}
+function extractTitle(snapshot) {
+  const rootMatch = snapshot.match(/RootWebArea\s+"([^"]+)"/);
+  if (rootMatch) return rootMatch[1];
+  const headingMatch = snapshot.match(/\bheading\s+"([^"]+)"/);
+  if (headingMatch) return headingMatch[1];
+  return "";
+}
+function truncateSnapshot(snapshot, full, limit = 16e3) {
+  const totalLength = snapshot.length;
+  if (full || totalLength <= limit) {
+    return { text: snapshot, truncated: false, totalLength };
+  }
+  const cut = snapshot.lastIndexOf("\n", limit);
+  const text = cut > 0 ? snapshot.slice(0, cut) : snapshot.slice(0, limit);
+  return { text, truncated: true, totalLength };
+}
+var MARKER_OVERHEAD = 50;
+function truncateText(text, limit = 8e3) {
+  const totalLength = text.length;
+  if (totalLength <= limit) {
+    return { text, truncated: false, totalLength };
+  }
+  if (totalLength <= limit + MARKER_OVERHEAD) {
+    return { text, truncated: false, totalLength };
+  }
+  const headBudget = Math.floor(limit * 0.4);
+  const tailBudget = limit - headBudget;
+  const headCut = text.lastIndexOf("\n", headBudget);
+  const head = headCut > 0 ? text.slice(0, headCut) : text.slice(0, headBudget);
+  const tailStart = text.indexOf("\n", totalLength - tailBudget);
+  const tail = tailStart > 0 && tailStart < totalLength ? text.slice(tailStart + 1) : text.slice(totalLength - tailBudget);
+  const omitted = totalLength - head.length - tail.length;
+  const result = `${head}
+
+... (${omitted} chars omitted, ${totalLength} total) ...
+
+${tail}`;
+  return { text: result, truncated: true, totalLength };
+}
+var INPUT_TYPES = ["textbox", "searchbox", "input", "combobox", "textarea"];
+function isInputType(type) {
+  return INPUT_TYPES.includes(type);
+}
+
+// vendor/chrome-devtools-axi/src/uid-freshness.ts
+var PAGE_GENERATION_KEY = "__chromeDevtoolsAxiSnapshotGeneration";
+async function captureFreshSnapshot(caller, capture) {
+  const first = await captureSnapshot(caller, capture);
+  const fresh = first.state?.generation === first.generation && first.state.mutations > 0 ? await captureSnapshot(caller, capture) : first;
+  return stampSnapshotGeneration(fresh.snapshot, fresh.generation);
+}
+function throwStaleRef(arg, refGeneration, currentGeneration) {
+  const refRaw = arg.startsWith("@") ? arg.slice(1) : arg;
+  const current = currentGeneration ?? "unavailable";
+  throw new CdpError(
+    `Stale ref @${refRaw}: from snapshot generation ${refGeneration}, current is ${current}. Re-snapshot to get fresh refs.`,
+    "STALE_REF",
+    [
+      "Run `chrome-devtools-axi snapshot` to capture current refs, then retry the action"
+    ]
+  );
+}
+async function markPageSnapshotGeneration(generation, caller) {
+  const key = JSON.stringify(PAGE_GENERATION_KEY);
+  try {
+    await caller("evaluate_script", {
+      function: `() => {
+  const key = ${key};
+  const previous = globalThis[key];
+  if (previous && previous.observer) previous.observer.disconnect();
+  const state = { generation: ${generation}, mutations: 0, observer: null };
+  const observer = new MutationObserver(() => { state.mutations += 1; });
+  observer.observe(document.documentElement || document, { childList: true, subtree: true, attributes: true, characterData: true });
+  state.observer = observer;
+  globalThis[key] = state;
+  return state.generation;
+}`
+    });
+  } catch {
+  }
+}
+async function captureSnapshot(caller, capture) {
+  const generation = bumpGeneration();
+  await markPageSnapshotGeneration(generation, caller);
+  const snapshot = await capture();
+  return { generation, snapshot, state: await getPageRefState(caller) };
+}
+async function getPageRefState(caller) {
+  const key = JSON.stringify(PAGE_GENERATION_KEY);
+  try {
+    const output = await caller("evaluate_script", {
+      function: `() => {
+  const state = globalThis[${key}];
+  if (!state || typeof state.generation !== 'number' || typeof state.mutations !== 'number' || !state.observer) return null;
+  return { generation: state.generation, mutations: state.mutations };
+}`
+    });
+    const jsonBlock = output.match(/```json\n([\s\S]*?)\n```/);
+    const raw = jsonBlock?.[1] ?? output.replace(/^Script ran on page and returned:\s*/, "");
+    const parsed = JSON.parse(raw.trim());
+    if (typeof parsed !== "object" || parsed === null || typeof parsed.generation !== "number" || typeof parsed.mutations !== "number") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function parseUidFresh(arg, caller) {
+  const snapshotGeneration = getCurrentGeneration();
+  const check = checkUidGeneration(arg, snapshotGeneration);
+  if (check.stale) {
+    throwStaleRef(arg, check.refGeneration, snapshotGeneration);
+  }
+  const state = await getPageRefState(caller);
+  if (!state || state.generation !== snapshotGeneration || state.mutations !== 0) {
+    throwStaleRef(
+      arg,
+      parseStampedUid(arg).generation ?? snapshotGeneration,
+      state ? state.generation + state.mutations : null
+    );
+  }
+  return check.uid;
+}
+
+// vendor/chrome-devtools-axi/src/run.ts
+function unwrapNoArgIIFE(s) {
+  const candidate = s.endsWith(";") ? s.slice(0, -1).trimEnd() : s;
+  if (candidate.length < 4 || candidate[0] !== "(" || !candidate.endsWith(")")) {
+    return s;
+  }
+  let depth = 0;
+  let inString = null;
+  let escape = false;
+  let closeIdx = -1;
+  for (let i = 0; i < candidate.length; i++) {
+    const c = candidate[i];
+    if (escape) {
+      escape = false;
+      continue;
+    }
+    if (inString) {
+      if (c === "\\") {
+        escape = true;
+        continue;
+      }
+      if (c === inString) inString = null;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === "`") {
+      inString = c;
+      continue;
+    }
+    if (c === "(") depth++;
+    else if (c === ")") {
+      depth--;
+      if (depth === 0) {
+        closeIdx = i;
+        break;
+      }
+    }
+  }
+  if (closeIdx < 0) return s;
+  const rest = candidate.slice(closeIdx + 1).trim();
+  if (rest !== "()") return s;
+  const inner = candidate.slice(1, closeIdx).trim();
+  if (/^(async\s*)?(\(.*?\)\s*=>|[a-zA-Z_$][a-zA-Z0-9_$]*\s*=>|function[\s*(])/.test(
+    inner
+  )) {
+    return inner;
+  }
+  return s;
+}
+function wrapJsExpression(js) {
+  const trimmed = unwrapNoArgIIFE(js.trim());
+  if (/^(async\s*)?(\(.*?\)\s*=>|[a-zA-Z_$][a-zA-Z0-9_$]*\s*=>|function[\s*(])/.test(
+    trimmed
+  )) {
+    return trimmed;
+  }
+  return `() => (${trimmed})`;
+}
+function parseEvalOutput(output) {
+  const jsonBlock = output.match(/```json\n([\s\S]*?)\n```/);
+  if (jsonBlock) {
+    try {
+      return JSON.parse(jsonBlock[1].trim());
+    } catch {
+      return jsonBlock[1].trim();
+    }
+  }
+  const preamble = "Script ran on page and returned:";
+  if (output.includes(preamble)) {
+    const raw = output.slice(output.indexOf(preamble) + preamble.length).trim();
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return raw;
+    }
+  }
+  return output.trim();
+}
+function stripSnapshotHeader(text) {
+  const lines = text.split("\n");
+  const treeStart = lines.findIndex((l) => /\bRootWebArea\b|\buid=/.test(l));
+  if (treeStart > 0) return lines.slice(treeStart).join("\n");
+  return text.replace(/^[\s\S]*?##\s+Latest page snapshot\s*\n/, "");
+}
+function isRecoverableOpenError(error) {
+  if (!(error instanceof CdpError)) return false;
+  if (error.code !== "BROWSER_ERROR") return false;
+  return /not connected|session (?:closed|not found)|no page/i.test(
+    error.message
+  );
+}
+var UID_RE = /^@?(?:\d[\d_]*|g\d+:.+)$/;
+function isUidRef(s) {
+  return UID_RE.test(s);
+}
+var DEFAULT_WAIT_TIMEOUT = 3e4;
+function createPageHelper(callTool2) {
+  function callFunction(code) {
+    return callTool2("evaluate_script", { function: wrapJsExpression(code) });
+  }
+  async function evalJs(code) {
+    return parseEvalOutput(await callFunction(code));
+  }
+  return {
+    async open(url) {
+      if (!url) {
+        throw new CdpError("Missing URL", "VALIDATION_ERROR", [
+          'Start with `await page.open("https://example.com")`'
+        ]);
+      }
+      try {
+        await callTool2("navigate_page", { type: "url", url });
+      } catch (error) {
+        if (!isRecoverableOpenError(error)) throw error;
+        await callTool2("new_page", { url });
+      }
+      const info = await evalJs(
+        `() => ({ url: location.href, status: performance.getEntriesByType('navigation').pop()?.responseStatus ?? null })`
+      );
+      const result = info;
+      return {
+        url: String(result?.url ?? url),
+        status: typeof result?.status === "number" ? result.status : null
+      };
+    },
+    async eval(jsOrFn) {
+      if (typeof jsOrFn === "function") {
+        return parseEvalOutput(
+          await callTool2("evaluate_script", { function: String(jsOrFn) })
+        );
+      }
+      return evalJs(jsOrFn);
+    },
+    async wait(msOrSelector, timeout) {
+      if (typeof msOrSelector === "number") {
+        await callFunction(`new Promise(r => setTimeout(r, ${msOrSelector}))`);
+      } else {
+        const ms = timeout ?? DEFAULT_WAIT_TIMEOUT;
+        const sel = JSON.stringify(msOrSelector);
+        await callFunction(`new Promise((resolve, reject) => {
+  const sel = ${sel};
+  if (document.querySelector(sel)) { resolve(); return; }
+  const observer = new MutationObserver(() => {
+    if (document.querySelector(sel)) {
+      observer.disconnect();
+      clearTimeout(timer);
+      resolve();
+    }
+  });
+  const timer = setTimeout(() => {
+    observer.disconnect();
+    reject(new Error('Timeout waiting for: ' + sel));
+  }, ${ms});
+  observer.observe(document.body, { childList: true, subtree: true, attributes: true });
+})`);
+      }
+    },
+    async snapshot() {
+      return captureFreshSnapshot(
+        callTool2,
+        async () => stripSnapshotHeader(await callTool2("take_snapshot"))
+      );
+    },
+    async click(refOrSelector) {
+      if (isUidRef(refOrSelector)) {
+        await callTool2("click", {
+          uid: await parseUidFresh(refOrSelector, callTool2)
+        });
+      } else {
+        const sel = JSON.stringify(refOrSelector);
+        await callFunction(`() => {
+  const el = document.querySelector(${sel});
+  if (!el) throw new Error('Element not found: ' + ${sel});
+  el.scrollIntoView({ block: 'center' });
+  el.click();
+}`);
+      }
+    },
+    async fill(refOrSelector, text) {
+      if (isUidRef(refOrSelector)) {
+        await callTool2("fill", {
+          uid: await parseUidFresh(refOrSelector, callTool2),
+          value: text
+        });
+      } else {
+        const sel = JSON.stringify(refOrSelector);
+        const val = JSON.stringify(text);
+        await callFunction(`() => {
+  const el = document.querySelector(${sel});
+  if (!el) throw new Error('Element not found: ' + ${sel});
+  el.focus();
+  const proto = el instanceof HTMLTextAreaElement ? HTMLTextAreaElement.prototype
+    : el instanceof HTMLSelectElement ? HTMLSelectElement.prototype
+    : HTMLInputElement.prototype;
+  Object.getOwnPropertyDescriptor(proto, 'value').set.call(el, ${val});
+  el.dispatchEvent(new Event('input', { bubbles: true }));
+  el.dispatchEvent(new Event('change', { bubbles: true }));
+}`);
+      }
+    },
+    async type(text) {
+      await callTool2("type_text", { text });
+    },
+    async press(key) {
+      await callTool2("press_key", { key });
+    },
+    async back() {
+      await callTool2("navigate_page", { type: "back" });
+    }
+  };
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+async function runScript(content, callTool2) {
+  const page = createPageHelper(callTool2);
+  const tmpDir = mkdtempSync(join4(tmpdir(), "cda-run-"));
+  const tmpFile = join4(tmpDir, "script.mjs");
+  writeFileSync3(tmpFile, content, "utf-8");
+  const lines = [];
+  const origLog = console.log;
+  const captureLog = (...args) => {
+    lines.push(args.map(String).join(" "));
+  };
+  const prevPage = globalThis.page;
+  globalThis.page = page;
+  console.log = captureLog;
+  try {
+    const mod = await import(pathToFileURL(tmpFile).href);
+    if (typeof mod.default === "function") {
+      await mod.default();
+    }
+  } finally {
+    console.log = origLog;
+    if (prevPage === void 0) {
+      delete globalThis.page;
+    } else {
+      globalThis.page = prevPage;
+    }
+    try {
+      unlinkSync2(tmpFile);
+      rmdirSync(tmpDir);
+    } catch {
+    }
+  }
+  const stdout = lines.length > 0 ? lines.join("\n") + "\n" : "";
+  return { stdout };
+}
+
+// vendor/chrome-devtools-axi/src/suggestions.ts
+function getSuggestions(ctx) {
+  if (ctx.command === "wait" || ctx.command === "eval") {
+    return ["Run `chrome-devtools-axi snapshot` to see current page state"];
+  }
+  const refs = ctx.snapshot ? extractRefs(ctx.snapshot) : [];
+  const links = refs.filter((r) => r.type === "link");
+  const buttons = refs.filter((r) => r.type === "button");
+  const inputs = refs.filter((r) => isInputType(r.type));
+  const lines = [];
+  if (ctx.command === "fill") {
+    const submitBtn = buttons.find(
+      (r) => /submit|search|go|send|login|sign|ok/i.test(r.label)
+    );
+    if (submitBtn) {
+      lines.push(
+        `Run \`chrome-devtools-axi click @${submitBtn.ref}\` to click "${submitBtn.label}"`
+      );
+    } else {
+      lines.push("Run `chrome-devtools-axi press Enter` to submit the form");
+    }
+  }
+  if (inputs.length > 0 && ctx.command !== "fill") {
+    const inp = inputs[0];
+    const label = inp.label ? `the "${inp.label}" field` : "the input field";
+    lines.push(
+      `Run \`chrome-devtools-axi fill @${inp.ref} "text"\` to fill ${label}`
+    );
+  }
+  if (buttons.length > 0) {
+    const btn = ctx.command === "fill" ? buttons.find(
+      (r) => !/submit|search|go|send|login|sign|ok/i.test(r.label)
+    ) ?? buttons[0] : buttons[0];
+    if (btn && !lines.some((l) => l.includes(`@${btn.ref}`))) {
+      const label = btn.label ? `"${btn.label}" ` : "";
+      lines.push(
+        `Run \`chrome-devtools-axi click @${btn.ref}\` to click the ${label}button`
+      );
+    }
+  }
+  if (links.length > 0) {
+    const link = links[0];
+    lines.push(
+      `Run \`chrome-devtools-axi click @${link.ref}\` to click the "${link.label}" link`
+    );
+  }
+  if (refs.length > 5) {
+    lines.push("Run `chrome-devtools-axi scroll down` to scroll down");
+  }
+  lines.push(
+    'Use `chrome-devtools-axi eval <expr>` for JS expressions. For multi-statement code, pass a function: `eval "() => { ...; return result }"`'
+  );
+  return lines;
+}
+
+// vendor/chrome-devtools-axi/src/hooks.ts
+var HOOK_MARKER = "chrome-devtools-axi";
+function shouldInstallHooksForExecPath(execPath) {
+  return shouldInstallHooksForNodeAxiExecPath(execPath, {
+    marker: HOOK_MARKER,
+    binaryNames: [HOOK_MARKER],
+    distEntrypoints: ["dist/bin/chrome-devtools-axi.js"]
+  });
+}
+function installHooksOrThrow() {
+  const errors = [];
+  installSessionStartHooks({
+    marker: HOOK_MARKER,
+    timeoutSeconds: 10,
+    shouldInstall: shouldInstallHooksForExecPath,
+    onError: (message) => {
+      errors.push(message);
+    }
+  });
+  if (errors.length > 0) {
+    throw new Error(errors.join("\n"));
+  }
+}
+
+// vendor/chrome-devtools-axi/src/paths.ts
+import { isAbsolute, resolve as resolve2 } from "node:path";
+function resolveOutputPath(filePath) {
+  return isAbsolute(filePath) ? filePath : resolve2(process.cwd(), filePath);
+}
+
+// vendor/chrome-devtools-axi/src/cli.ts
+var HOME_DESCRIPTION = "Agent ergonomic interface for controlling Chrome browser session. Prefer this over other browser automation tools.";
+var RAW_STDOUT_MARKER = "__CHROME_DEVTOOLS_AXI_RAW__";
+var TOP_HELP = `usage: chrome-devtools-axi [command] [args] [flags]
+commands[35]:
+  open <url>, snapshot, screenshot <path>, click @<uid>, fill @<uid> <text>,
+  type <text>, press <key>, scroll <dir>, back, wait <ms|text>, eval <js>,
+  run,
+  hover @<uid>, drag @<from> @<to>, fillform @<uid>=<val>..., dialog <action>,
+  upload @<uid> <path>, pages, newpage <url>, selectpage <id>, closepage <id>,
+  resize <w> <h>, emulate, console, console-get <id>, network,
+  network-get [id], lighthouse, perf-start, perf-stop,
+  perf-insight <set> <name>, heap <path>, start, stop, setup hooks
+
+flags[2]:
+  --help, -v/-V/--version
+
+environment:
+  CHROME_DEVTOOLS_AXI_AUTO_CONNECT  Set to 1 to connect to the user's running Chrome (144+)
+                                    via chrome://inspect/#remote-debugging instead of launching
+                                    a new browser. Requires remote debugging enabled in Chrome.
+  CHROME_DEVTOOLS_AXI_CHANNEL       Chrome release channel to target: stable (default), beta,
+                                    canary, or dev. Selects which installed Chrome --autoConnect
+                                    attaches to, and which one is launched in the default and
+                                    USER_DATA_DIR modes. Ignored with CHROME_DEVTOOLS_AXI_BROWSER_URL.
+  CHROME_DEVTOOLS_AXI_HEADED        Set to 1 to run Chrome in headed (visible) mode
+  CHROME_DEVTOOLS_AXI_CHROME_ARGS   Whitespace-separated Chrome flags forwarded to the browser
+                                    (no shell-style quoting; flags with spaces are not supported)
+                                    e.g. "--enable-gpu --ignore-gpu-blocklist"
+  CHROME_DEVTOOLS_AXI_PORT          Bridge server port (default: 9224)
+  CHROME_DEVTOOLS_AXI_SESSION       Named session for concurrent isolation. Each session name gets
+                                    its own bridge process, port (auto-derived from the name, or set
+                                    CHROME_DEVTOOLS_AXI_PORT), and on-disk state, so multiple sessions
+                                    run at once without colliding. Connection mode and profile are
+                                    unchanged. Defaults to "default" (port 9224, legacy state paths).
+                                    e.g. CHROME_DEVTOOLS_AXI_SESSION=worker-1
+  CHROME_DEVTOOLS_AXI_BROWSER_URL   Connect to an existing Chrome instance instead of launching one.
+                                    http(s):// uses --browserUrl (fetches /json/version).
+                                    ws(s):// uses --wsEndpoint (direct WebSocket).
+                                    e.g. "http://127.0.0.1:9222" or "wss://cluster.example/launch"
+  CHROME_DEVTOOLS_AXI_WS_HEADERS    JSON headers for ws(s):// endpoints (only with BROWSER_URL=wss?://)
+                                    e.g. '{"Authorization":"Bearer token"}'
+  CHROME_DEVTOOLS_AXI_USER_DATA_DIR Persistent Chrome profile directory (skips --isolated mode)
+                                    e.g. "/path/to/.chrome-profile"
+  CHROME_DEVTOOLS_AXI_MCP_PATH      Absolute path to a chrome-devtools-mcp script. When set
+                                    without a shared URL, the bridge spawns 'node $MCP_PATH'
+                                    directly instead of 'npx -y chrome-devtools-mcp@latest'.
+                                    With MCP_SERVER_URL also set, selects stdio proxy mode:
+                                    the executable must advertise --serverUrl in --help.
+                                    Local-mode recommendation:
+                                      npm install -g chrome-devtools-mcp
+                                      export CHROME_DEVTOOLS_AXI_MCP_PATH="$(npm prefix -g)/lib/node_modules/chrome-devtools-mcp/build/src/bin/chrome-devtools-mcp.js"
+  CHROME_DEVTOOLS_AXI_MCP_SERVER_URL
+                                    Shared MCP service URL. With MCP_PATH, starts a verified
+                                    stdio proxy and passes --server-url=<URL>. Without
+                                    MCP_PATH, connects directly over Streamable HTTP (no
+                                    local MCP child); use an absolute http(s) MCP endpoint.
+                                    If unset or blank, the bridge uses standalone stdio mode.
+  CHROME_DEVTOOLS_AXI_BRIDGE_TIMEOUT_MS
+                                    Bridge readiness deadline in ms (default: 30000, min: 1000)
+
+gpu:
+  Headless Chrome cannot access hardware GPU on most Linux systems.
+  For GPU-accelerated WebGL, use headed mode with GPU flags:
+    CHROME_DEVTOOLS_AXI_HEADED=1
+    CHROME_DEVTOOLS_AXI_CHROME_ARGS="--enable-gpu --ignore-gpu-blocklist"
+  For WebGPU, Vulkan must also be enabled (required for the Dawn backend):
+    CHROME_DEVTOOLS_AXI_CHROME_ARGS="--enable-gpu --ignore-gpu-blocklist --enable-unsafe-webgpu --enable-features=Vulkan"
+
+tips:
+  Pipe output through grep/head to extract specific data from large pages.
+`;
+var COMMAND_HELP = {
+  open: `usage: chrome-devtools-axi open <url> [--full]
+Navigate to a URL and capture an accessibility snapshot.
+
+args:
+  <url>   URL to navigate to (required)
+
+flags:
+  --full  Show complete snapshot without truncation
+
+examples:
+  chrome-devtools-axi open https://example.com
+  chrome-devtools-axi open https://example.com --full`,
+  screenshot: `usage: chrome-devtools-axi screenshot <path> [--uid @<uid>] [--full-page] [--format png|jpeg|webp]
+Save a screenshot to a file.
+
+args:
+  <path>  File path to save the screenshot (required)
+
+Relative output paths resolve against the directory where you run the CLI.
+Output reports the resolved absolute path.
+
+flags:
+  --uid @<uid>    Capture a specific element instead of the full viewport.
+                  Refs are generation-tagged (e.g. @g3:12) - pass them back
+                  exactly as printed. A stale ref returns STALE_REF.
+  --full-page     Capture the entire scrollable page
+  --format <fmt>  Image format: png (default), jpeg, or webp
+
+examples:
+  chrome-devtools-axi screenshot ./page.png
+  chrome-devtools-axi screenshot ./element.png --uid @g1:3
+  chrome-devtools-axi screenshot ./full.png --full-page --format jpeg`,
+  snapshot: `usage: chrome-devtools-axi snapshot [--full]
+Capture the current page accessibility snapshot.
+
+flags:
+  --full  Show complete snapshot without truncation
+
+examples:
+  chrome-devtools-axi snapshot
+  chrome-devtools-axi snapshot --full`,
+  click: `usage: chrome-devtools-axi click @<uid> [--full]
+Click an interactive element by its ref from the snapshot.
+
+args:
+  @<uid>  Element ref from snapshot (required). Refs are generation-tagged
+          (e.g. @g3:12) - pass them back exactly as printed. A stale ref
+          (older generation) returns a STALE_REF error so you know to re-snapshot.
+
+flags:
+  --full  Show complete snapshot without truncation
+
+examples:
+  chrome-devtools-axi click @g1:1
+  chrome-devtools-axi click @g2:12 --full`,
+  fill: `usage: chrome-devtools-axi fill @<uid> <text> [--full]
+Fill a form field with text.
+
+args:
+  @<uid>  Element ref from snapshot (required). Refs are generation-tagged
+          (e.g. @g3:12) - pass them back exactly as printed. A stale ref
+          returns a STALE_REF error so you know to re-snapshot.
+  <text>  Text to fill (required)
+
+flags:
+  --full  Show complete snapshot without truncation
+
+examples:
+  chrome-devtools-axi fill @g1:3 "hello world"
+  chrome-devtools-axi fill @g2:3 "search query" --full`,
+  type: `usage: chrome-devtools-axi type <text> [--full]
+Type text at the currently focused element.
+
+args:
+  <text>  Text to type (required)
+
+flags:
+  --full  Show complete snapshot without truncation
+
+examples:
+  chrome-devtools-axi type "hello"
+  chrome-devtools-axi type "search query" --full`,
+  press: `usage: chrome-devtools-axi press <key> [--full]
+Press a keyboard key.
+
+args:
+  <key>  Key name, e.g. Enter, Tab, Escape, ArrowDown (required)
+
+flags:
+  --full  Show complete snapshot without truncation
+
+examples:
+  chrome-devtools-axi press Enter
+  chrome-devtools-axi press Tab --full`,
+  scroll: `usage: chrome-devtools-axi scroll <direction> [--full]
+Scroll the page in a direction.
+
+args:
+  <direction>  up, down, top, or bottom (default: down)
+
+flags:
+  --full  Show complete snapshot without truncation
+
+examples:
+  chrome-devtools-axi scroll down
+  chrome-devtools-axi scroll top --full`,
+  back: `usage: chrome-devtools-axi back [--full]
+Navigate back in browser history.
+
+flags:
+  --full  Show complete snapshot without truncation
+
+examples:
+  chrome-devtools-axi back
+  chrome-devtools-axi back --full`,
+  wait: `usage: chrome-devtools-axi wait <ms|text>
+Wait for a duration or for text to appear on the page.
+
+args:
+  <ms>    Milliseconds to wait (numeric)
+  <text>  Text to wait for (string)
+
+examples:
+  chrome-devtools-axi wait 2000
+  chrome-devtools-axi wait "Submit"`,
+  eval: `usage: chrome-devtools-axi eval <js>
+Evaluate a JavaScript expression in the page context and return the result.
+A bare expression is wrapped as () => (<js>); pass a function (arrow or
+function-keyword) for multi-statement logic. No-arg IIFE form (...)() is
+also accepted and unwrapped automatically.
+
+args:
+  <js>  JavaScript expression (required)
+
+examples:
+  chrome-devtools-axi eval "document.title"
+  chrome-devtools-axi eval "document.querySelectorAll('a').length"
+  chrome-devtools-axi eval "() => { const rows = [...document.querySelectorAll('tr')]; return rows.map(r => r.textContent) }"`,
+  run: `usage: chrome-devtools-axi run <<'EOF'
+  ...script...
+  EOF
+
+Execute a JavaScript script from stdin against the current browser session.
+The script gets a global \`page\` object. Only the script's stdout is returned.
+Pipe a script via heredoc or stdin \u2014 no file path needed.
+
+script API (available as global \`page\`):
+  await page.open(url)              Navigate, returns { url, status }
+  await page.eval(jsOrFn)           Evaluate JS in the page, returns the value
+  await page.snapshot()             Get the generation-tagged accessibility tree
+  await page.wait(ms)               Wait by duration
+  await page.wait(selector)         Wait for CSS selector (30s timeout)
+  await page.wait(selector, ms)     Wait for CSS selector with timeout
+  await page.click("@uid")          Click an element by fresh ref
+  await page.click(selector)        Click via CSS selector
+  await page.fill("@uid", text)     Fill a form field by fresh ref
+  await page.fill(selector, text)   Fill via CSS selector, including controlled fields
+  await page.type(text)             Type at the focused element
+  await page.press(key)             Press a keyboard key
+  await page.back()                 Navigate back
+
+click and fill accept either @uid refs (from snapshot) or CSS selectors. UID actions verify that the page has not mutated since the snapshot and fail with STALE_REF when freshness cannot be confirmed, including for legacy untagged refs.
+page.eval accepts functions, arrow functions, and bare expression strings; no-arg IIFE strings are unwrapped automatically.
+
+examples:
+  chrome-devtools-axi run <<'EOF'
+  await page.open("https://example.com");
+  console.log(await page.eval(() => document.title));
+  EOF
+
+  chrome-devtools-axi run <<'EOF'
+  await page.open("https://en.wikipedia.org/wiki/Ada_Lovelace");
+  await page.click("a[href='/wiki/Charles_Babbage']");
+  await page.wait(".mw-page-title-main");
+  console.log(await page.eval(() => document.title));
+  EOF
+
+  chrome-devtools-axi run <<'EOF'
+  const { status } = await page.open("https://httpbin.org/status/404");
+  console.log("status:", status);
+  EOF`,
+  start: `usage: chrome-devtools-axi start
+Start the bridge server (launches headless Chrome).
+
+examples:
+  chrome-devtools-axi start`,
+  stop: `usage: chrome-devtools-axi stop
+Stop the bridge server and close the browser.
+
+examples:
+  chrome-devtools-axi stop`,
+  // Page management
+  pages: `usage: chrome-devtools-axi pages
+List all open pages/tabs in the browser.
+
+examples:
+  chrome-devtools-axi pages`,
+  newpage: `usage: chrome-devtools-axi newpage <url> [--background] [--full]
+Open a new tab and navigate to a URL.
+
+args:
+  <url>  URL to open (required)
+
+flags:
+  --background  Open in background without bringing to front
+  --full        Show complete snapshot without truncation
+
+examples:
+  chrome-devtools-axi newpage https://example.com
+  chrome-devtools-axi newpage https://example.com --background`,
+  selectpage: `usage: chrome-devtools-axi selectpage <id> [--full]
+Switch to a tab by page ID.
+
+args:
+  <id>  Page ID from the pages command (required)
+
+flags:
+  --full  Show complete snapshot without truncation
+
+examples:
+  chrome-devtools-axi selectpage 1`,
+  closepage: `usage: chrome-devtools-axi closepage <id>
+Close a tab by page ID. The last open page cannot be closed.
+
+args:
+  <id>  Page ID from the pages command (required)
+
+examples:
+  chrome-devtools-axi closepage 2`,
+  resize: `usage: chrome-devtools-axi resize <width> <height>
+Resize the browser window; report requested and actual page dimensions.
+For an exact CSS viewport use emulate --viewport "390x844x1".
+
+args:
+  <width>   Width in pixels (required)
+  <height>  Height in pixels (required)
+
+examples:
+  chrome-devtools-axi resize 1280 720
+  chrome-devtools-axi resize 390 844`,
+  // Interaction
+  hover: `usage: chrome-devtools-axi hover @<uid> [--full]
+Hover over an element to trigger hover states.
+
+args:
+  @<uid>  Element ref from snapshot (required). Refs are generation-tagged
+          (e.g. @g3:12) - pass them back exactly as printed. A stale ref
+          returns a STALE_REF error so you know to re-snapshot.
+
+flags:
+  --full  Show complete snapshot without truncation
+
+examples:
+  chrome-devtools-axi hover @g1:5`,
+  drag: `usage: chrome-devtools-axi drag @<from> @<to> [--full]
+Drag an element onto another element.
+
+args:
+  @<from>  Element to drag (required). Use refs from the latest snapshot.
+  @<to>    Element to drop onto (required). Stale refs return STALE_REF.
+
+flags:
+  --full  Show complete snapshot without truncation
+
+examples:
+  chrome-devtools-axi drag @g1:3 @g1:7`,
+  fillform: `usage: chrome-devtools-axi fillform @<uid>=<value>... [--full]
+Fill multiple form fields at once.
+
+args:
+  @<uid>=<value>  One or more field entries from the latest snapshot (required).
+                  Stale refs return STALE_REF.
+
+flags:
+  --full  Show complete snapshot without truncation
+
+examples:
+  chrome-devtools-axi fillform @g1:1="hello" @g1:2="world"
+  chrome-devtools-axi fillform @g2:3="user@email.com" @g2:4="password123"`,
+  dialog: `usage: chrome-devtools-axi dialog <accept|dismiss> [text]
+Handle a browser dialog (alert, confirm, prompt).
+
+args:
+  <action>  accept or dismiss (required)
+  [text]    Optional text to enter into a prompt dialog
+
+examples:
+  chrome-devtools-axi dialog accept
+  chrome-devtools-axi dialog dismiss
+  chrome-devtools-axi dialog accept "confirmed"`,
+  upload: `usage: chrome-devtools-axi upload @<uid> <path> [--full]
+Upload a file through a file input element.
+
+args:
+  @<uid>  File input element ref from snapshot (required). Refs are
+          generation-tagged; stale refs return STALE_REF.
+  <path>  Local file path to upload (required)
+
+flags:
+  --full  Show complete snapshot without truncation
+
+examples:
+  chrome-devtools-axi upload @g1:5 ./photo.jpg`,
+  // Emulation
+  emulate: `usage: chrome-devtools-axi emulate [flags]
+Emulate device features on the selected page.
+
+flags:
+  --viewport <spec>          Viewport like "390x844x3,mobile,touch"
+  --color-scheme <value>     dark | light | auto
+  --network <condition>      Offline | Slow 3G | Fast 3G | Slow 4G | Fast 4G
+  --cpu <rate>               CPU throttling rate 1-20
+  --geolocation <lat>x<lon>  Geolocation like "37.7749x-122.4194"
+  --user-agent <string>      Custom user agent string
+
+examples:
+  chrome-devtools-axi emulate --viewport "390x844x3,mobile" --color-scheme dark
+  chrome-devtools-axi emulate --network "Slow 3G" --cpu 4`,
+  // DevTools debugging
+  console: `usage: chrome-devtools-axi console [--type <type>] [--limit <n>] [--page <n>]
+List console messages for the current page.
+
+flags:
+  --type <type>  Filter by message type. Valid values:
+                   log, debug, info, error, warn, dir, dirxml, table, trace,
+                   clear, startGroup, startGroupCollapsed, endGroup, assert,
+                   profile, profileEnd, count, timeEnd, verbose, issue, all
+                 ("all" or omitted returns every message.)
+  --limit <n>    Maximum messages to return
+  --page <n>     Page number (0-based)
+
+examples:
+  chrome-devtools-axi console
+  chrome-devtools-axi console --type error --limit 50
+  chrome-devtools-axi console --type all`,
+  "console-get": `usage: chrome-devtools-axi console-get <id>
+Get a specific console message by ID.
+
+args:
+  <id>  Message ID from the console command (required)
+
+examples:
+  chrome-devtools-axi console-get 3`,
+  network: `usage: chrome-devtools-axi network [--type <type>] [--limit <n>] [--page <n>]
+List network requests for the current page.
+
+flags:
+  --type <type>  Filter by resource type. Valid values:
+                   document, stylesheet, image, media, font, script, texttrack,
+                   xhr, fetch, prefetch, eventsource, websocket, manifest,
+                   signedexchange, ping, cspviolationreport, preflight, fedcm,
+                   other, all
+                 ("all" or omitted returns every request.)
+  --limit <n>    Maximum requests to return
+  --page <n>     Page number (0-based)
+
+examples:
+  chrome-devtools-axi network
+  chrome-devtools-axi network --type fetch --limit 50
+  chrome-devtools-axi network --type all`,
+  "network-get": `usage: chrome-devtools-axi network-get [id] [--response-file <path>] [--request-file <path>]
+Get a specific network request. If id is omitted, gets the selected request.
+
+args:
+  [id]  Request ID from the network command (optional)
+
+flags:
+  --response-file <path>  Save response body to file
+  --request-file <path>   Save request body to file
+
+Relative output paths resolve against the directory where you run the CLI.
+
+examples:
+  chrome-devtools-axi network-get 42
+  chrome-devtools-axi network-get 42 --response-file ./response.json`,
+  // Performance
+  lighthouse: `usage: chrome-devtools-axi lighthouse [--device <device>] [--mode <mode>] [--output-dir <path>]
+Run a Lighthouse audit for accessibility, SEO, and best practices.
+
+flags:
+  --device <device>      desktop (default) or mobile
+  --mode <mode>          navigation (default) or snapshot
+  --output-dir <path>    Directory for reports
+
+Relative output paths resolve against the directory where you run the CLI.
+
+examples:
+  chrome-devtools-axi lighthouse
+  chrome-devtools-axi lighthouse --device mobile --output-dir ./reports`,
+  "perf-start": `usage: chrome-devtools-axi perf-start [--no-reload] [--no-auto-stop] [--file <path>]
+Start a performance trace recording.
+
+flags:
+  --no-reload     Don't reload the page when starting
+  --no-auto-stop  Don't automatically stop the trace
+  --file <path>   Save raw trace data to file
+
+Relative output paths resolve against the directory where you run the CLI.
+Output reports the resolved absolute path.
+
+examples:
+  chrome-devtools-axi perf-start
+  chrome-devtools-axi perf-start --no-reload --file trace.json.gz`,
+  "perf-stop": `usage: chrome-devtools-axi perf-stop [--file <path>]
+Stop the active performance trace recording.
+
+flags:
+  --file <path>  Save raw trace data to file
+
+Relative output paths resolve against the directory where you run the CLI.
+
+examples:
+  chrome-devtools-axi perf-stop
+  chrome-devtools-axi perf-stop --file trace.json.gz`,
+  "perf-insight": `usage: chrome-devtools-axi perf-insight <set-id> <insight-name>
+Analyze a specific performance insight from a trace.
+
+args:
+  <set-id>        Insight set ID from trace results (required)
+  <insight-name>  Insight name, e.g. "DocumentLatency" (required)
+
+examples:
+  chrome-devtools-axi perf-insight set1 DocumentLatency
+  chrome-devtools-axi perf-insight set1 LCPBreakdown`,
+  heap: `usage: chrome-devtools-axi heap <path>
+Capture a heap snapshot for memory leak debugging.
+
+args:
+  <path>  File path to save the .heapsnapshot file (required)
+
+Relative output paths resolve against the directory where you run the CLI.
+Output reports the resolved absolute path.
+
+examples:
+  chrome-devtools-axi heap ./snapshot.heapsnapshot`,
+  setup: `usage: chrome-devtools-axi setup hooks
+Install or repair agent SessionStart hooks for chrome-devtools-axi ambient context.
+
+examples:
+  chrome-devtools-axi setup hooks`
+};
+function getCommandHelp(command) {
+  return COMMAND_HELP[command] ?? null;
+}
+function parseScreenshotArgs(args) {
+  let filePath = null;
+  let uid;
+  let fullPage = false;
+  let format;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--uid" && i + 1 < args.length) {
+      const raw = args[++i];
+      uid = raw.startsWith("@") ? raw.slice(1) : raw;
+    } else if (a === "--full-page") {
+      fullPage = true;
+    } else if (a === "--format" && i + 1 < args.length) {
+      format = args[++i];
+    } else if (!a.startsWith("--")) {
+      filePath = a;
+    }
+  }
+  return { filePath, uid, fullPage, format };
+}
+function formatScreenshotOutput(filePath) {
+  return encode({ screenshot: filePath });
+}
+function parseScreenshotOutputPath(result) {
+  const match = result.match(/^Saved screenshot to ([^\r\n]+)\.\s*$/m);
+  if (!match) {
+    throw new CdpError(
+      "chrome-devtools-mcp did not report a saved screenshot path",
+      "BROWSER_ERROR"
+    );
+  }
+  return match[1];
+}
+function formatMcpResult(label, text, suggestions) {
+  const blocks = [];
+  const tr = truncateSnapshot(text, false, 2e3);
+  blocks.push(`${label}:
+${tr.text.trimEnd()}`);
+  if (tr.truncated) {
+    blocks[0] += `
+    ... (truncated, ${tr.totalLength} chars total)`;
+  }
+  if (suggestions.length > 0) {
+    blocks.push(renderHelp(suggestions));
+  }
+  return renderOutput2(blocks);
+}
+function parseFillFormArgs(args) {
+  const entries = [];
+  for (const arg of args) {
+    if (arg === "--full") continue;
+    const match = arg.match(/^@([^=]+)=(.+)$/);
+    if (!match) continue;
+    const uid = match[1];
+    let value = match[2];
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    entries.push({ uid, value });
+  }
+  return { entries };
+}
+function parseOptionalInteger(value) {
+  if (value === void 0) return void 0;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+}
+function parseEmulateArgs(args) {
+  const result = {};
+  let i = 0;
+  while (i < args.length) {
+    switch (args[i]) {
+      case "--viewport":
+        result.viewport = args[++i];
+        break;
+      case "--color-scheme":
+        result.colorScheme = args[++i];
+        break;
+      case "--network":
+        result.networkConditions = args[++i];
+        break;
+      case "--cpu": {
+        const cpuThrottlingRate = parseOptionalInteger(args[++i]);
+        if (cpuThrottlingRate !== void 0) {
+          result.cpuThrottlingRate = cpuThrottlingRate;
+        }
+        break;
+      }
+      case "--geolocation":
+        result.geolocation = args[++i];
+        break;
+      case "--user-agent":
+        result.userAgent = args[++i];
+        break;
+    }
+    i++;
+  }
+  return result;
+}
+function parseConsoleArgs(args) {
+  const result = {};
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--type" && i + 1 < args.length) {
+      const value = args[++i];
+      if (value.toLowerCase() === "all") delete result.types;
+      else result.types = [value];
+    } else if (args[i] === "--limit" && i + 1 < args.length) {
+      const pageSize = parseOptionalInteger(args[++i]);
+      if (pageSize !== void 0) result.pageSize = pageSize;
+    } else if (args[i] === "--page" && i + 1 < args.length) {
+      const pageIdx = parseOptionalInteger(args[++i]);
+      if (pageIdx !== void 0) result.pageIdx = pageIdx;
+    }
+  }
+  return result;
+}
+function parseNetworkArgs(args) {
+  const result = {};
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--type" && i + 1 < args.length) {
+      const value = args[++i];
+      if (value.toLowerCase() === "all") delete result.resourceTypes;
+      else result.resourceTypes = [value];
+    } else if (args[i] === "--limit" && i + 1 < args.length) {
+      const pageSize = parseOptionalInteger(args[++i]);
+      if (pageSize !== void 0) result.pageSize = pageSize;
+    } else if (args[i] === "--page" && i + 1 < args.length) {
+      const pageIdx = parseOptionalInteger(args[++i]);
+      if (pageIdx !== void 0) result.pageIdx = pageIdx;
+    }
+  }
+  return result;
+}
+function parseNetworkGetArgs(args) {
+  const result = {};
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--response-file" && i + 1 < args.length) {
+      result.responseFilePath = args[++i];
+    } else if (args[i] === "--request-file" && i + 1 < args.length) {
+      result.requestFilePath = args[++i];
+    } else if (!args[i].startsWith("--")) {
+      const reqid = parseOptionalInteger(args[i]);
+      if (reqid !== void 0) result.reqid = reqid;
+    }
+  }
+  return result;
+}
+function parseLighthouseArgs(args) {
+  const result = {};
+  for (let i = 0; i < args.length; i++) {
+    switch (args[i]) {
+      case "--device":
+        result.device = args[++i];
+        break;
+      case "--mode":
+        result.mode = args[++i];
+        break;
+      case "--output-dir":
+        result.outputDirPath = args[++i];
+        break;
+    }
+  }
+  return result;
+}
+function parsePerfStartArgs(args) {
+  const result = {};
+  for (let i = 0; i < args.length; i++) {
+    switch (args[i]) {
+      case "--no-reload":
+        result.reload = false;
+        break;
+      case "--no-auto-stop":
+        result.autoStop = false;
+        break;
+      case "--file":
+        result.filePath = args[++i];
+        break;
+    }
+  }
+  return result;
+}
+function renderHelp(lines) {
+  if (lines.length === 0) return "";
+  const indented = lines.map((l) => `  ${l}`).join("\n");
+  return `help[${lines.length}]:
+${indented}`;
+}
+function renderError2(message, code, suggestions = []) {
+  const blocks = [encode({ error: message, code })];
+  if (suggestions.length > 0) {
+    blocks.push(renderHelp(suggestions));
+  }
+  return blocks.join("\n");
+}
+function renderOutput2(blocks) {
+  return blocks.filter(Boolean).join("\n");
+}
+function splitFullFlag(args) {
+  return {
+    args: args.filter((arg) => arg !== "--full"),
+    full: args.includes("--full")
+  };
+}
+function trimSingleTrailingNewline(text) {
+  return text.endsWith("\n") ? text.slice(0, -1) : text;
+}
+function wrapsRawStdout(argv) {
+  return (argv ?? process.argv.slice(2))[0] === "run";
+}
+function wrapStdout(stdout, argv) {
+  const target = stdout ?? process.stdout;
+  if (!wrapsRawStdout(argv)) {
+    return stdout;
+  }
+  return {
+    write(chunk) {
+      if (!chunk.startsWith(RAW_STDOUT_MARKER)) {
+        return target.write(chunk);
+      }
+      const raw = chunk.slice(RAW_STDOUT_MARKER.length);
+      if (raw === "\n") {
+        return true;
+      }
+      return target.write(raw);
+    }
+  };
+}
+function renderUnknownCommand(command) {
+  return renderError2(`Unknown command: ${command}`, "VALIDATION_ERROR", [
+    "Run `chrome-devtools-axi --help` to see available commands"
+  ]) + "\n";
+}
+function normalizeMainOptions(options) {
+  if (Array.isArray(options)) {
+    return { argv: options };
+  }
+  return options ?? {};
+}
+function resolveArgv(argv) {
+  return argv ?? process.argv.slice(2);
+}
+function shouldRenderFullHome(argv) {
+  return argv.length === 1 && argv[0] === "--full";
+}
+function formatPageOutput(snapshot, command, url, full = false) {
+  const title = extractTitle(snapshot);
+  const refs = countRefs(snapshot);
+  const blocks = [];
+  const page = {};
+  if (title) page.title = title;
+  if (url) page.url = url;
+  page.refs = refs;
+  blocks.push(encode({ page }));
+  const tr = truncateSnapshot(snapshot, full);
+  let snapshotBlock = `snapshot:
+${tr.text.trimEnd()}`;
+  if (tr.truncated) {
+    snapshotBlock += `
+    ... (truncated, ${tr.totalLength} chars total)`;
+  }
+  blocks.push(snapshotBlock);
+  const suggestions = getSuggestions({ command, url, snapshot });
+  if (tr.truncated) {
+    suggestions.push(
+      `Run \`chrome-devtools-axi ${command}${url ? " " + url : ""} --full\` to see complete snapshot`
+    );
+  }
+  if (suggestions.length > 0) {
+    blocks.push(renderHelp(suggestions));
+  }
+  return renderOutput2(blocks);
+}
+function stripSnapshotHeader2(text) {
+  const lines = text.split("\n");
+  const treeStart = lines.findIndex((l) => /\bRootWebArea\b|\buid=/.test(l));
+  if (treeStart > 0) return lines.slice(treeStart).join("\n");
+  return text.replace(/^[\s\S]*?##\s+Latest page snapshot\s*\n/, "");
+}
+function parseUid(arg) {
+  const current = getCurrentGeneration();
+  const check = checkUidGeneration(arg, current);
+  if (check.stale) {
+    throwStaleRef2(arg, check.refGeneration, current);
+  }
+  return check.uid;
+}
+async function stampFresh() {
+  return captureFreshSnapshot(
+    callTool,
+    async () => stripSnapshotHeader2(await callTool("take_snapshot"))
+  );
+}
+function throwStaleRef2(arg, refGeneration, currentGeneration) {
+  const refRaw = arg.startsWith("@") ? arg.slice(1) : arg;
+  throw new CdpError(
+    `Stale ref @${refRaw}: from snapshot generation ${refGeneration}, current is ${currentGeneration}. Re-snapshot to get fresh refs.`,
+    "STALE_REF",
+    [
+      "Run `chrome-devtools-axi snapshot` to capture current refs, then retry the action"
+    ]
+  );
+}
+async function parseUidFresh2(arg, caller = callTool) {
+  return parseUidFresh(arg, caller);
+}
+function isRecoverableOpenError2(error) {
+  if (!(error instanceof CdpError)) return false;
+  if (error.code !== "BROWSER_ERROR") return false;
+  return /not connected|session (?:closed|not found)|no page/i.test(
+    error.message
+  );
+}
+async function callWithSnapshot(name, args) {
+  const result = await callTool(name, args);
+  if (/^# Open dialog\b/m.test(result)) {
+    throw new CdpError("The action opened a dialog. Do not replay it; handle the dialog first.", "DIALOG_PENDING", [
+      "Run `chrome-devtools-axi dialog accept` or `chrome-devtools-axi dialog dismiss` in the same session"
+    ]);
+  }
+  return stampFresh();
+}
+var SCROLL_FUNCTIONS = {
+  up: "() => window.scrollBy(0, -500)",
+  down: "() => window.scrollBy(0, 500)",
+  top: "() => window.scrollTo(0, 0)",
+  bottom: "() => window.scrollTo(0, document.body.scrollHeight)"
+};
+async function handleOpen(args, full) {
+  const url = args[0];
+  if (!url) {
+    throw new CdpError("Missing URL", "VALIDATION_ERROR", [
+      "Run `chrome-devtools-axi open https://example.com` to navigate to a page"
+    ]);
+  }
+  try {
+    await callTool("navigate_page", { type: "url", url });
+  } catch (error) {
+    if (!isRecoverableOpenError2(error)) {
+      throw error;
+    }
+    await callTool("new_page", { url });
+  }
+  const snapshot = await stampFresh();
+  return formatPageOutput(snapshot, "open", url, full);
+}
+async function handleSnapshot(full) {
+  const snapshot = await stampFresh();
+  return formatPageOutput(snapshot, "snapshot", void 0, full);
+}
+async function handleScreenshot(args) {
+  const parsed = parseScreenshotArgs(args);
+  if (!parsed.filePath) {
+    throw new CdpError("Missing file path", "VALIDATION_ERROR", [
+      "Run `chrome-devtools-axi screenshot ./page.png` to save a screenshot"
+    ]);
+  }
+  const filePath = resolveOutputPath(parsed.filePath);
+  const toolArgs = { filePath };
+  if (parsed.uid) toolArgs.uid = await parseUidFresh2(parsed.uid);
+  if (parsed.fullPage) toolArgs.fullPage = true;
+  if (parsed.format) toolArgs.format = parsed.format;
+  const result = await callTool("take_screenshot", toolArgs);
+  return formatScreenshotOutput(parseScreenshotOutputPath(result));
+}
+async function handleClick(args, full) {
+  const uid = args[0];
+  if (!uid) {
+    throw new CdpError("Missing element ref", "VALIDATION_ERROR", [
+      "Run `chrome-devtools-axi click @<uid>` \u2014 get uid from snapshot"
+    ]);
+  }
+  const snapshot = await callWithSnapshot("click", {
+    uid: await parseUidFresh2(uid)
+  });
+  return formatPageOutput(snapshot, "click", void 0, full);
+}
+async function handleFill(args, full) {
+  const uid = args[0];
+  const value = args.slice(1).join(" ");
+  if (!uid) {
+    throw new CdpError("Missing element ref", "VALIDATION_ERROR", [
+      'Run `chrome-devtools-axi fill @<uid> "text"` \u2014 get uid from snapshot'
+    ]);
+  }
+  if (!value) {
+    throw new CdpError("Missing fill text", "VALIDATION_ERROR", [
+      'Run `chrome-devtools-axi fill @<uid> "text"` to fill the field'
+    ]);
+  }
+  const snapshot = await callWithSnapshot("fill", {
+    uid: await parseUidFresh2(uid),
+    value
+  });
+  return formatPageOutput(snapshot, "fill", void 0, full);
+}
+async function handlePress(args, full) {
+  const key = args[0];
+  if (!key) {
+    throw new CdpError("Missing key name", "VALIDATION_ERROR", [
+      "Run `chrome-devtools-axi press Enter` to press a key"
+    ]);
+  }
+  const snapshot = await callWithSnapshot("press_key", { key });
+  return formatPageOutput(snapshot, "press", void 0, full);
+}
+async function handleType(args, full) {
+  const text = args.join(" ");
+  if (!text) {
+    throw new CdpError("Missing text", "VALIDATION_ERROR", [
+      'Run `chrome-devtools-axi type "hello"` to type text'
+    ]);
+  }
+  await callTool("type_text", { text });
+  const snapshot = await stampFresh();
+  return formatPageOutput(snapshot, "type", void 0, full);
+}
+async function handleScroll(args, full) {
+  const dir = (args[0] ?? "down").toLowerCase();
+  const fn = SCROLL_FUNCTIONS[dir];
+  if (!fn) {
+    throw new CdpError(`Unknown scroll direction: ${dir}`, "VALIDATION_ERROR", [
+      "Run `chrome-devtools-axi scroll down` \u2014 directions: up, down, top, bottom"
+    ]);
+  }
+  await callTool("evaluate_script", { function: fn });
+  const snapshot = await stampFresh();
+  return formatPageOutput(snapshot, "scroll", void 0, full);
+}
+async function handleBack(full) {
+  await callTool("navigate_page", { type: "back" });
+  const snapshot = await stampFresh();
+  return formatPageOutput(snapshot, "back", void 0, full);
+}
+async function handleWait(args) {
+  const target = args[0];
+  if (!target) {
+    throw new CdpError(
+      "Missing wait target (milliseconds or text)",
+      "VALIDATION_ERROR",
+      [
+        "Run `chrome-devtools-axi wait 2000` to wait 2 seconds",
+        'Run `chrome-devtools-axi wait "Submit"` to wait for text to appear'
+      ]
+    );
+  }
+  const isNumeric = /^\d+$/.test(target);
+  if (isNumeric) {
+    await callTool("evaluate_script", {
+      function: wrapJsExpression(`new Promise(r => setTimeout(r, ${target}))`)
+    });
+  } else {
+    await callTool("wait_for", { text: [target] });
+  }
+  const blocks = [];
+  blocks.push(encode({ waited: target }));
+  const suggestions = getSuggestions({ command: "wait" });
+  if (suggestions.length > 0) blocks.push(renderHelp(suggestions));
+  return renderOutput2(blocks);
+}
+function parseEvalResult(output) {
+  const jsonBlock = output.match(/```json\n([\s\S]*?)\n```/);
+  if (jsonBlock) return jsonBlock[1].trim();
+  const preamble = "Script ran on page and returned:";
+  if (output.includes(preamble))
+    return output.slice(output.indexOf(preamble) + preamble.length).trim();
+  return output.trim();
+}
+async function handleEval(args, full) {
+  const js = args.join(" ");
+  if (!js) {
+    throw new CdpError("Missing JavaScript expression", "VALIDATION_ERROR", [
+      'Run `chrome-devtools-axi eval "document.title"` to evaluate JavaScript'
+    ]);
+  }
+  const output = await callTool("evaluate_script", {
+    function: wrapJsExpression(js)
+  });
+  const blocks = [];
+  const raw = parseEvalResult(output);
+  const tr = full ? { text: raw, truncated: false, totalLength: raw.length } : truncateText(raw);
+  blocks.push(encode({ result: tr.text }));
+  const suggestions = getSuggestions({ command: "eval" });
+  if (tr.truncated) {
+    suggestions.push(
+      "Result was truncated \u2014 re-run with --full flag, or use .slice() / filter in your JS expression"
+    );
+  }
+  if (suggestions.length > 0) blocks.push(renderHelp(suggestions));
+  return renderOutput2(blocks);
+}
+async function handleStart() {
+  const port = await ensureBridge();
+  return encode({ status: "ready", port });
+}
+function formatStopOutput(wasStopped) {
+  return encode({ status: wasStopped ? "stopped" : "stopped (no-op)" });
+}
+async function handleStop() {
+  const wasStopped = await stopBridge();
+  return formatStopOutput(wasStopped);
+}
+async function handlePages() {
+  const result = await callTool("list_pages");
+  const pages = overlaySessionSelected(parsePagesList(result));
+  if (pages.length === 0) {
+    return "pages: 0 pages open";
+  }
+  const blocks = [];
+  const header = `pages[${pages.length}]{id,url,selected}:`;
+  const rows = pages.map((p) => `  ${p.id},${p.url},${p.selected}`);
+  blocks.push(`${header}
+${rows.join("\n")}`);
+  blocks.push(
+    renderHelp([
+      "Run `chrome-devtools-axi selectpage <id>` to switch tabs",
+      "Run `chrome-devtools-axi newpage <url>` to open a new tab"
+    ])
+  );
+  return renderOutput2(blocks);
+}
+async function handleNewPage(args, full) {
+  const url = args.filter((a) => !a.startsWith("--"))[0];
+  if (!url) {
+    throw new CdpError("Missing URL", "VALIDATION_ERROR", [
+      "Run `chrome-devtools-axi newpage https://example.com` to open a new tab"
+    ]);
+  }
+  const background = args.includes("--background");
+  const toolArgs = { url };
+  if (background) toolArgs.background = true;
+  await callTool("new_page", toolArgs);
+  const snapshot = await stampFresh();
+  return formatPageOutput(snapshot, "newpage", url, full);
+}
+async function handleSelectPage(args, full) {
+  const id = args[0];
+  if (!id) {
+    throw new CdpError("Missing page ID", "VALIDATION_ERROR", [
+      "Run `chrome-devtools-axi selectpage <id>` \u2014 get ID from `pages` command"
+    ]);
+  }
+  const pageId = parseInt(id, 10);
+  if (isNaN(pageId)) {
+    throw new CdpError(`Invalid page ID: ${id}`, "VALIDATION_ERROR", [
+      "Run `chrome-devtools-axi pages` to list available page IDs"
+    ]);
+  }
+  await callTool("select_page", { pageId });
+  const snapshot = await stampFresh();
+  return formatPageOutput(snapshot, "selectpage", void 0, full);
+}
+async function handleClosePage(args) {
+  const id = args[0];
+  if (!id) {
+    throw new CdpError("Missing page ID", "VALIDATION_ERROR", [
+      "Run `chrome-devtools-axi closepage <id>` \u2014 get ID from `pages` command"
+    ]);
+  }
+  const pageId = parseInt(id, 10);
+  if (isNaN(pageId)) {
+    throw new CdpError(`Invalid page ID: ${id}`, "VALIDATION_ERROR", [
+      "Run `chrome-devtools-axi pages` to list available page IDs"
+    ]);
+  }
+  const beforeResult = await callTool("list_pages");
+  const pagesBefore = parsePagesList(beforeResult);
+  if (pagesBefore.length <= 1) {
+    const blocks = [
+      encode({ status: "cannot close the last open page (no-op)" })
+    ];
+    blocks.push(
+      renderHelp([
+        "Run `chrome-devtools-axi newpage <url>` to open another tab first",
+        "Run `chrome-devtools-axi stop` to shut down the browser entirely"
+      ])
+    );
+    return renderOutput2(blocks);
+  }
+  await callTool("close_page", { pageId });
+  return encode({ status: "closed", pageId });
+}
+async function handleResize(args) {
+  const [widthStr, heightStr] = args;
+  if (!widthStr || !heightStr) {
+    throw new CdpError("Missing width and/or height", "VALIDATION_ERROR", [
+      "Run `chrome-devtools-axi resize 1280 720` to resize the viewport"
+    ]);
+  }
+  const width = parseInt(widthStr, 10);
+  const height = parseInt(heightStr, 10);
+  if (isNaN(width) || isNaN(height)) {
+    throw new CdpError("Width and height must be numbers", "VALIDATION_ERROR", [
+      "Run `chrome-devtools-axi resize 1280 720` to resize the viewport"
+    ]);
+  }
+  await callTool("resize_page", { width, height });
+  const result = await callTool("evaluate_script", {
+    function: "() => ({width: innerWidth, height: innerHeight, devicePixelRatio})"
+  });
+  const match = result.match(/```(?:json)?\s*([\s\S]*?)```/);
+  let actual;
+  try {
+    actual = match ? JSON.parse(match[1]) : void 0;
+  } catch {
+  }
+  return encode({
+    resized: {
+      requested: { width, height },
+      actual: actual ?? null,
+      mode: "window",
+      exact: actual?.width === width && actual?.height === height
+    }
+  });
+}
+async function handleHover(args, full) {
+  const uid = args[0];
+  if (!uid) {
+    throw new CdpError("Missing element ref", "VALIDATION_ERROR", [
+      "Run `chrome-devtools-axi hover @<uid>` \u2014 get uid from snapshot"
+    ]);
+  }
+  const snapshot = await callWithSnapshot("hover", {
+    uid: await parseUidFresh2(uid)
+  });
+  return formatPageOutput(snapshot, "hover", void 0, full);
+}
+async function handleDrag(args, full) {
+  const from = args[0];
+  const to = args[1];
+  if (!from || !to) {
+    throw new CdpError("Missing element refs", "VALIDATION_ERROR", [
+      "Run `chrome-devtools-axi drag @<from> @<to>` \u2014 get uids from snapshot"
+    ]);
+  }
+  const snapshot = await callWithSnapshot("drag", {
+    from_uid: await parseUidFresh2(from),
+    to_uid: await parseUidFresh2(to)
+  });
+  return formatPageOutput(snapshot, "drag", void 0, full);
+}
+async function handleFillForm(args, full) {
+  const { entries } = parseFillFormArgs(args);
+  if (entries.length === 0) {
+    throw new CdpError("No valid field entries", "VALIDATION_ERROR", [
+      'Run `chrome-devtools-axi fillform @g1:1="hello" @g1:2="world"` to fill multiple fields'
+    ]);
+  }
+  const validated = await Promise.all(
+    entries.map(async (e) => ({
+      uid: await parseUidFresh2(e.uid),
+      value: e.value
+    }))
+  );
+  const snapshot = await callWithSnapshot("fill_form", { elements: validated });
+  return formatPageOutput(snapshot, "fillform", void 0, full);
+}
+async function handleDialog(args) {
+  const action = args[0];
+  if (!action || action !== "accept" && action !== "dismiss") {
+    throw new CdpError("Missing or invalid action", "VALIDATION_ERROR", [
+      "Run `chrome-devtools-axi dialog accept` or `chrome-devtools-axi dialog dismiss`"
+    ]);
+  }
+  const params = { action };
+  const promptText = args.slice(1).join(" ");
+  if (promptText) params.promptText = promptText;
+  const snapshot = await callWithSnapshot("handle_dialog", params);
+  return encode({ dialog: action }) + "\n" + formatPageOutput(snapshot, "dialog");
+}
+async function handleUpload(args, full) {
+  const uid = args[0];
+  const filePath = args[1];
+  if (!uid) {
+    throw new CdpError("Missing element ref", "VALIDATION_ERROR", [
+      "Run `chrome-devtools-axi upload @<uid> <path>` \u2014 get uid from snapshot"
+    ]);
+  }
+  if (!filePath) {
+    throw new CdpError("Missing file path", "VALIDATION_ERROR", [
+      "Run `chrome-devtools-axi upload @<uid> /path/to/file` to upload a file"
+    ]);
+  }
+  const snapshot = await callWithSnapshot("upload_file", {
+    uid: await parseUidFresh2(uid),
+    filePaths: [resolveOutputPath(filePath)]
+  });
+  return formatPageOutput(snapshot, "upload", void 0, full);
+}
+async function handleEmulate(args) {
+  const parsed = parseEmulateArgs(args);
+  await callTool("emulate", parsed);
+  return encode({ emulated: parsed });
+}
+async function handleConsole(args) {
+  const parsed = parseConsoleArgs(args);
+  const result = await callTool("list_console_messages", parsed);
+  return formatMcpResult("console", result, [
+    "Run `chrome-devtools-axi console-get <id>` to see a specific message",
+    "Run `chrome-devtools-axi console --type error` to filter by type"
+  ]);
+}
+async function handleConsoleGet(args) {
+  const id = args[0];
+  if (!id) {
+    throw new CdpError("Missing console message id", "VALIDATION_ERROR", [
+      "Run `chrome-devtools-axi console-get <id>` \u2014 get id from `chrome-devtools-axi console`"
+    ]);
+  }
+  const msgid = parseOptionalInteger(id);
+  if (msgid === void 0) {
+    throw new CdpError(
+      `Invalid console message id: ${id}`,
+      "VALIDATION_ERROR",
+      ["Run `chrome-devtools-axi console` to list available message ids"]
+    );
+  }
+  const result = await callTool("get_console_message", { msgid });
+  return formatMcpResult("message", result, []);
+}
+async function handleNetwork(args) {
+  const parsed = parseNetworkArgs(args);
+  const result = await callTool("list_network_requests", parsed);
+  return formatMcpResult("network", result, [
+    "Run `chrome-devtools-axi network-get <id>` to see request details",
+    "Run `chrome-devtools-axi network --type fetch` to filter by type"
+  ]);
+}
+async function handleNetworkGet(args) {
+  const parsed = parseNetworkGetArgs(args);
+  const toolArgs = { ...parsed };
+  if (toolArgs.responseFilePath) {
+    toolArgs.responseFilePath = resolveOutputPath(toolArgs.responseFilePath);
+  }
+  if (toolArgs.requestFilePath) {
+    toolArgs.requestFilePath = resolveOutputPath(toolArgs.requestFilePath);
+  }
+  const result = await callTool("get_network_request", toolArgs);
+  return formatMcpResult("request", result, []);
+}
+async function handleLighthouse(args) {
+  const opts = parseLighthouseArgs(args);
+  if (opts.outputDirPath) {
+    opts.outputDirPath = resolveOutputPath(opts.outputDirPath);
+  }
+  const result = await callTool("lighthouse_audit", opts);
+  return formatMcpResult("lighthouse", result, []);
+}
+async function handlePerfStart(args) {
+  const opts = parsePerfStartArgs(args);
+  if (opts.filePath) opts.filePath = resolveOutputPath(opts.filePath);
+  await callTool("performance_start_trace", opts);
+  return encode({ trace: "started", ...opts });
+}
+async function handlePerfStop(args) {
+  const toolArgs = {};
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--file" && i + 1 < args.length) {
+      toolArgs.filePath = resolveOutputPath(args[++i]);
+    }
+  }
+  const result = await callTool("performance_stop_trace", toolArgs);
+  return formatMcpResult("trace", result, [
+    "Run `chrome-devtools-axi perf-insight <set-id> <insight-name>` to analyze insights"
+  ]);
+}
+async function handlePerfInsight(args) {
+  const [setId, insightName] = args;
+  if (!setId || !insightName) {
+    throw new CdpError("Missing required arguments", "VALIDATION_ERROR", [
+      "Run `chrome-devtools-axi perf-insight <set-id> <insight-name>` to analyze an insight"
+    ]);
+  }
+  const result = await callTool("performance_analyze_insight", {
+    insightSetId: setId,
+    insightName
+  });
+  return formatMcpResult("insight", result, []);
+}
+async function handleHeap(args) {
+  const rawPath = args[0];
+  if (!rawPath) {
+    throw new CdpError("Missing file path", "VALIDATION_ERROR", [
+      "Run `chrome-devtools-axi heap ./snapshot.heapsnapshot` to take a heap snapshot"
+    ]);
+  }
+  const filePath = resolveOutputPath(rawPath);
+  await callTool("take_heapsnapshot", { filePath });
+  return encode({ heap: filePath });
+}
+async function handleRun() {
+  if (process.stdin.isTTY) {
+    throw new CdpError("No script provided on stdin", "VALIDATION_ERROR", [
+      "Pipe a script: chrome-devtools-axi run <<'EOF'\\n...\\nEOF"
+    ]);
+  }
+  const content = await readStdin();
+  if (!content.trim()) {
+    throw new CdpError("Empty script on stdin", "VALIDATION_ERROR", [
+      "Pipe a script: chrome-devtools-axi run <<'EOF'\\n...\\nEOF"
+    ]);
+  }
+  const result = await runScript(content, callTool);
+  return RAW_STDOUT_MARKER + trimSingleTrailingNewline(result.stdout);
+}
+async function handleSetup(args) {
+  if (args.length !== 1 || args[0] !== "hooks") {
+    throw new CdpError("Unknown setup action", "VALIDATION_ERROR", [
+      "Run `chrome-devtools-axi setup hooks`"
+    ]);
+  }
+  installHooksOrThrow();
+  return renderOutput2([
+    "hooks:\n  status: installed\n  integrations: Claude Code, Codex, OpenCode",
+    renderHelp([
+      "Restart your agent session to receive chrome-devtools-axi ambient context"
+    ])
+  ]);
+}
+async function handleHome(_full) {
+  const result = await getSessionSnapshotIfRunning();
+  if (!result) {
+    return renderOutput2([
+      encode({ browser: "no active session" }),
+      renderHelp(["Run `chrome-devtools-axi open <url>` to start browsing"])
+    ]);
+  }
+  const snapshot = stripSnapshotHeader2(result);
+  const title = extractTitle(snapshot);
+  const refs = countRefs(snapshot);
+  const page = {};
+  if (title) page.title = title;
+  page.refs = refs;
+  const help = [
+    "Run `chrome-devtools-axi snapshot` to see page content",
+    "Run `chrome-devtools-axi open <url>` to navigate to a URL",
+    "Run `chrome-devtools-axi --help` to see full command list"
+  ];
+  return renderOutput2([encode({ page }), renderHelp(help)]);
+}
+function withFullFlag(handler) {
+  return (args) => {
+    const parsed = splitFullFlag(args);
+    return handler(parsed.args, parsed.full);
+  };
+}
+function withoutFullFlag(handler) {
+  return (args) => handler(splitFullFlag(args).args);
+}
+function validateCommandFlags(command, args, allowedFlags, valueFlags, dashPositionalSlots, positionalArgsBeforeText = args.length) {
+  let positionalArgs = 0;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (positionalArgs === positionalArgsBeforeText) return;
+    if (arg === "--help" || allowedFlags.includes(arg)) {
+      if (valueFlags.includes(arg)) i += 1;
+      continue;
+    }
+    if (arg !== "-" && arg.startsWith("-") && (arg.startsWith("--") || !dashPositionalSlots.includes(positionalArgs))) {
+      throw new CdpError(
+        `Unknown flag ${arg} for \`${command}\``,
+        "VALIDATION_ERROR",
+        [`Run \`chrome-devtools-axi ${command} --help\` to see valid flags`]
+      );
+    }
+    positionalArgs += 1;
+  }
+}
+var COMMAND_HANDLERS = {
+  open: withFullFlag(handleOpen),
+  snapshot: async (args) => handleSnapshot(splitFullFlag(args).full),
+  screenshot: withoutFullFlag(handleScreenshot),
+  click: withFullFlag(handleClick),
+  fill: withFullFlag(handleFill),
+  type: withFullFlag(handleType),
+  press: withFullFlag(handlePress),
+  scroll: withFullFlag(handleScroll),
+  back: async (args) => handleBack(splitFullFlag(args).full),
+  wait: withoutFullFlag(handleWait),
+  eval: withFullFlag(handleEval),
+  run: async () => handleRun(),
+  hover: withFullFlag(handleHover),
+  drag: withFullFlag(handleDrag),
+  fillform: withFullFlag(handleFillForm),
+  dialog: withoutFullFlag(handleDialog),
+  upload: withFullFlag(handleUpload),
+  pages: async () => handlePages(),
+  newpage: withFullFlag(handleNewPage),
+  selectpage: withFullFlag(handleSelectPage),
+  closepage: withoutFullFlag(handleClosePage),
+  resize: withoutFullFlag(handleResize),
+  emulate: withoutFullFlag(handleEmulate),
+  console: withoutFullFlag(handleConsole),
+  "console-get": withoutFullFlag(handleConsoleGet),
+  network: withoutFullFlag(handleNetwork),
+  "network-get": withoutFullFlag(handleNetworkGet),
+  lighthouse: withoutFullFlag(handleLighthouse),
+  "perf-start": withoutFullFlag(handlePerfStart),
+  "perf-stop": withoutFullFlag(handlePerfStop),
+  "perf-insight": withoutFullFlag(handlePerfInsight),
+  heap: withoutFullFlag(handleHeap),
+  start: async () => handleStart(),
+  stop: async () => handleStop(),
+  setup: withoutFullFlag(handleSetup)
+};
+var COMMAND_FLAGS = {
+  open: ["--full"],
+  screenshot: ["--uid", "--full-page", "--format"],
+  snapshot: ["--full"],
+  click: ["--full"],
+  fill: ["--full"],
+  type: ["--full"],
+  press: ["--full"],
+  scroll: ["--full"],
+  back: ["--full"],
+  wait: [],
+  eval: ["--full"],
+  run: [],
+  hover: ["--full"],
+  drag: ["--full"],
+  fillform: ["--full"],
+  dialog: [],
+  upload: ["--full"],
+  pages: [],
+  newpage: ["--background", "--full"],
+  selectpage: ["--full"],
+  closepage: [],
+  resize: [],
+  emulate: [
+    "--viewport",
+    "--color-scheme",
+    "--network",
+    "--cpu",
+    "--geolocation",
+    "--user-agent"
+  ],
+  console: ["--type", "--limit", "--page"],
+  "console-get": [],
+  network: ["--type", "--limit", "--page"],
+  "network-get": ["--response-file", "--request-file"],
+  lighthouse: ["--device", "--mode", "--output-dir"],
+  "perf-start": ["--no-reload", "--no-auto-stop", "--file"],
+  "perf-stop": ["--file"],
+  "perf-insight": [],
+  heap: [],
+  start: [],
+  stop: [],
+  setup: []
+};
+var COMMAND_VALUE_FLAGS = {
+  screenshot: ["--uid", "--format"],
+  emulate: COMMAND_FLAGS.emulate,
+  console: COMMAND_FLAGS.console,
+  network: COMMAND_FLAGS.network,
+  "network-get": COMMAND_FLAGS["network-get"],
+  lighthouse: COMMAND_FLAGS.lighthouse,
+  "perf-start": ["--file"],
+  "perf-stop": COMMAND_FLAGS["perf-stop"]
+};
+var COMMAND_POSITIONAL_TEXT_START = {
+  fill: 1,
+  type: 0,
+  wait: 0,
+  eval: 0,
+  dialog: 1
+};
+var COMMAND_DASH_POSITIONAL_SLOTS = {
+  heap: [0],
+  upload: [1],
+  screenshot: [0]
+};
+var COMMANDS = Object.fromEntries(
+  Object.entries(COMMAND_HANDLERS).map(([command, handler]) => [
+    command,
+    (args) => {
+      validateCommandFlags(
+        command,
+        args,
+        COMMAND_FLAGS[command] ?? [],
+        COMMAND_VALUE_FLAGS[command] ?? [],
+        COMMAND_DASH_POSITIONAL_SLOTS[command] ?? [],
+        COMMAND_POSITIONAL_TEXT_START[command]
+      );
+      return handler(args);
+    }
+  ])
+);
+async function main(options = {}) {
+  const normalized = normalizeMainOptions(options);
+  const requestedArgv = resolveArgv(normalized.argv);
+  const homeFull = shouldRenderFullHome(requestedArgv);
+  const argv = homeFull ? [] : normalized.argv;
+  const stdout = wrapStdout(normalized.stdout, argv);
+  await runAxiCli({
+    ...argv ? { argv } : {},
+    ...stdout ? { stdout } : {},
+    description: HOME_DESCRIPTION,
+    version: VERSION,
+    topLevelHelp: TOP_HELP,
+    home: async (args) => handleHome(homeFull || splitFullFlag(args).full),
+    commands: COMMANDS,
+    getCommandHelp,
+    renderUnknownCommand
+  });
+}
+export {
+  HOME_DESCRIPTION,
+  TOP_HELP,
+  formatMcpResult,
+  formatScreenshotOutput,
+  formatStopOutput,
+  getCommandHelp,
+  main,
+  parseConsoleArgs,
+  parseEmulateArgs,
+  parseFillFormArgs,
+  parseLighthouseArgs,
+  parseNetworkArgs,
+  parseNetworkGetArgs,
+  parsePagesList,
+  parsePerfStartArgs,
+  parseScreenshotArgs,
+  parseUid,
+  parseUidFresh2 as parseUidFresh,
+  wrapJsExpression
+};