rea/scripts/electron-active-hook.cjs

"use strict";

const applyFunction = Reflect.apply;
const applyArguments = Function.prototype.apply;
const bindFunction = Function.prototype.bind;
const callFunction = Function.prototype.call;
const arrayFrom = Array.from;
const arrayIsArray = Array.isArray;
const defineProperty = Object.defineProperty;
const ownPropertyDescriptor = Object.getOwnPropertyDescriptor;
const getPrototypeOf = Object.getPrototypeOf;
const nativeFunctionPrototype = getPrototypeOf(callFunction);
const getProperty = Reflect.get;
const setProperty = Reflect.set;
const SetConstructor = Set;
const ProxyConstructor = Proxy;
const bindBuiltinMethod = (method) =>
  applyFunction(bindFunction, callFunction, [method]);
const forEachMapEntry = bindBuiltinMethod(Map.prototype.forEach);
const sliceArguments = bindBuiltinMethod(Array.prototype.slice);
const weakMapHas = bindBuiltinMethod(WeakMap.prototype.has);
const weakMapGet = bindBuiltinMethod(WeakMap.prototype.get);
const weakMapSet = bindBuiltinMethod(WeakMap.prototype.set);
const weakSetAdd = bindBuiltinMethod(WeakSet.prototype.add);
const weakSetHas = bindBuiltinMethod(WeakSet.prototype.has);
const setHas = bindBuiltinMethod(Set.prototype.has);
const setAdd = bindBuiltinMethod(Set.prototype.add);
const hasOwnProperty = bindBuiltinMethod(Object.prototype.hasOwnProperty);

const { isProxy } = require("node:util").types;
const { EventEmitter: NodeEventEmitter } = require("node:events");
const nodeEventEmitterMethods = Object.create(null);
for (const method of [
  "on",
  "once",
  "off",
  "removeListener",
  "removeAllListeners",
]) {
  const descriptor = ownPropertyDescriptor(NodeEventEmitter.prototype, method);
  nodeEventEmitterMethods[method] =
    descriptor !== undefined && hasOwnProperty(descriptor, "value")
      ? descriptor.value
      : undefined;
}
const {
  createElectronActiveBoundaryPatches,
} = require("./electron-active-hook-boundaries.cjs");

const ipcEventKinds = new SetConstructor([
  "main-handler-invocation",
  "main-event-invocation",
  "utility-process-fork",
  "utility-process-message",
  "ipc-main-to-renderer",
  "ipc-utility-to-main",
  "ipc-renderer-send",
  "ipc-renderer-invoke",
  "ipc-renderer-post-message",
]);
const events = [];
// Budget serialized data and estimated retained object/array storage together.
const retentionBudgetBytes = 16 * 1024 * 1024;
const snapshotEnvelopeReserveBytes = 1024;
let estimatedRetainedBytes = 0;
let serializedBytes = 0;
let observed = 0;
let observedIpc = 0;
let observedRuntime = 0;
let dropped = 0;
let droppedIpc = 0;
let droppedRuntime = 0;
const droppedFamilies = new Map();
const droppedRoles = new Map();
let sequence = 0;
let correlationSequence = 0;

const shape = (value, depth = 0) => {
  if (depth > 2 || value === null) return value === null ? "null" : "nested";
  if (arrayIsArray(value)) return "array";
  switch (typeof value) {
    case "string":
      return "string";
    case "number":
      return "number";
    case "boolean":
      return "boolean";
    case "undefined":
      return "undefined";
    case "function":
      return "function";
    case "object":
      return "object";
    default:
      return "unknown";
  }
};

// Measure JSON strings without allocating an encoded copy of a caller value.
const jsonStringBytes = (value) => {
  let bytes = 2;
  for (let index = 0; index < value.length; index += 1) {
    const code = value.charCodeAt(index);
    if (code === 0x22 || code === 0x5c) bytes += 2;
    else if (
      code === 0x08 ||
      code === 0x09 ||
      code === 0x0a ||
      code === 0x0c ||
      code === 0x0d
    )
      bytes += 2;
    else if (code <= 0x1f) bytes += 6;
    else if (code >= 0xd800 && code <= 0xdbff) {
      const next = value.charCodeAt(index + 1);
      if (next >= 0xdc00 && next <= 0xdfff) {
        bytes += 4;
        index += 1;
      } else bytes += 6;
    } else if (code >= 0xdc00 && code <= 0xdfff) bytes += 6;
    else if (code <= 0x7f) bytes += 1;
    else if (code <= 0x7ff) bytes += 2;
    else bytes += 3;
    if (bytes > retentionBudgetBytes) return bytes;
  }
  return bytes;
};

const jsonScalarBytes = (value) => {
  if (value === null) return 4;
  if (typeof value === "string") return jsonStringBytes(value);
  if (typeof value === "boolean") return value ? 4 : 5;
  return String(value).length;
};

const eventFamily = (kind, processTypeValue) => {
  if (
    kind === "preload" &&
    (processTypeValue === "main" || processTypeValue === "browser")
  )
    return "preload-configuration";
  if (kind.startsWith("ipc-renderer"))
    return processTypeValue === "renderer" ? "renderer-ipc" : "ipc";
  return setHas(ipcEventKinds, kind) ? "ipc" : kind;
};

const noteDropped = (kind, processTypeValue, isIpc) => {
  dropped += 1;
  if (isIpc) droppedIpc += 1;
  else droppedRuntime += 1;
  const family = eventFamily(kind, processTypeValue);
  droppedFamilies.set(family, (droppedFamilies.get(family) ?? 0) + 1);
  if (typeof processTypeValue === "string")
    droppedRoles.set(
      processTypeValue,
      (droppedRoles.get(processTypeValue) ?? 0) + 1,
    );
  if (kind === "window-lifecycle")
    droppedRoles.set("window", (droppedRoles.get("window") ?? 0) + 1);
  if (kind === "web-contents-lifecycle" || kind === "navigation")
    droppedRoles.set(
      "web_contents",
      (droppedRoles.get("web_contents") ?? 0) + 1,
    );
  if (kind === "preload" && processTypeValue === "preload")
    droppedRoles.set("preload", (droppedRoles.get("preload") ?? 0) + 1);
};

const isAllowedNavigation = (value) => {
  if (typeof value !== "string") return true;
  try {
    const parsed = new URL(value);
    if (["file:", "data:", "about:"].includes(parsed.protocol)) return true;
    return (
      ["http:", "https:"].includes(parsed.protocol) &&
      ["127.0.0.1", "localhost", "[::1]", "::1"].includes(parsed.hostname)
    );
  } catch {
    return false;
  }
};

const processType = () =>
  typeof process.type === "string" && process.type.length > 0
    ? process.type
    : "main";

const identity = (value, prefix) => {
  if (value === null || value === undefined) return null;
  const id = value.id;
  const processId = value.pid;
  return typeof id === "string" || typeof id === "number"
    ? `${prefix}:${String(id)}`
    : typeof processId === "number"
      ? `${prefix}:pid:${String(processId)}`
      : null;
};

const frameIdentity = (event) => {
  const frame = event?.senderFrame ?? event?.frame;
  const id = frame?.frameTreeNodeId ?? frame?.routingId ?? frame?.id;
  return typeof id === "string" || typeof id === "number"
    ? `frame:${String(id)}`
    : null;
};

const record = (event) => {
  observed += 1;
  const isIpc = setHas(ipcEventKinds, event.kind);
  if (isIpc) observedIpc += 1;
  else observedRuntime += 1;
  const raw = {
    sequence: ++sequence,
    correlation_id:
      typeof event.correlation_id === "string"
        ? event.correlation_id
        : `capture:${process.pid}:${++correlationSequence}`,
    event: null,
    phase: "observed",
    channel: null,
    direction: null,
    sender: null,
    receiver: null,
    frame: null,
    target: null,
    argument_shapes: [],
    result_shape: null,
    process_type: processType(),
    source: "electron-active-hook",
    capture_method: "api-wrapper",
    artifact_path: null,
    artifact_sha256: null,
    error: false,
    ...event,
  };
  const shapeGroups = arrayIsArray(raw.argument_shape_value_groups)
    ? raw.argument_shape_value_groups
    : arrayIsArray(raw.argument_shape_values)
      ? [raw.argument_shape_values]
      : [];
  const existingShapes = arrayIsArray(raw.argument_shapes)
    ? raw.argument_shapes
    : [];
  const retainedEvent = {
    ...raw,
    correlation_id: raw.correlation_id,
    event: typeof raw.event === "string" ? raw.event : null,
    channel: typeof raw.channel === "string" ? raw.channel : null,
    sender: typeof raw.sender === "string" ? raw.sender : null,
    receiver: typeof raw.receiver === "string" ? raw.receiver : null,
    frame: typeof raw.frame === "string" ? raw.frame : null,
    target: typeof raw.target === "string" ? raw.target : null,
    argument_shapes: [],
    result_shape:
      typeof raw.result_shape === "string" ? raw.result_shape : null,
    process_type:
      typeof raw.process_type === "string" ? raw.process_type : null,
    artifact_path:
      typeof raw.artifact_path === "string" ? raw.artifact_path : null,
    artifact_sha256:
      typeof raw.artifact_sha256 === "string" ? raw.artifact_sha256 : null,
  };
  delete retainedEvent.argument_shape_values;
  delete retainedEvent.argument_shape_value_groups;

  // All event values are JSON scalars except argument_shapes. Measure them
  // incrementally so large channels, paths, or shape lists never require a
  // full JSON.stringify temporary allocation before the budget decision.
  let eventBytes = 2;
  let argumentShapeCount = 0;
  const eventKeys = Object.keys(retainedEvent);
  for (let index = 0; index < eventKeys.length; index += 1) {
    const key = eventKeys[index];
    const value = retainedEvent[key];
    if (index > 0) eventBytes += 1;
    eventBytes += jsonStringBytes(key) + 1;
    if (key === "argument_shapes") {
      eventBytes += 2;
      let shapeOverflow = false;
      const countShape = (argument) => {
        const encodedShapeBytes = jsonStringBytes(shape(argument));
        eventBytes += encodedShapeBytes + (argumentShapeCount === 0 ? 0 : 1);
        argumentShapeCount += 1;
        shapeOverflow =
          eventBytes + estimatedRetainedBytes + snapshotEnvelopeReserveBytes >
          retentionBudgetBytes;
      };
      for (const group of shapeGroups) {
        if (!arrayIsArray(group)) continue;
        for (const argument of group) {
          countShape(argument);
          if (shapeOverflow) break;
        }
      }
      if (shapeOverflow) {
        noteDropped(raw.kind, retainedEvent.process_type, isIpc);
        return null;
      }
      for (const valueShape of existingShapes)
        if (!shapeOverflow) {
          eventBytes +=
            jsonStringBytes(
              typeof valueShape === "string" ? valueShape : "unknown",
            ) + (argumentShapeCount++ === 0 ? 0 : 1);
          shapeOverflow =
            eventBytes + estimatedRetainedBytes + snapshotEnvelopeReserveBytes >
            retentionBudgetBytes;
        }
      if (shapeOverflow) {
        noteDropped(raw.kind, retainedEvent.process_type, isIpc);
        return null;
      }
    } else eventBytes += jsonScalarBytes(value);
    if (
      eventBytes + estimatedRetainedBytes + snapshotEnvelopeReserveBytes >
      retentionBudgetBytes
    ) {
      noteDropped(raw.kind, retainedEvent.process_type, isIpc);
      return null;
    }
  }
  // Reserve room for the only fields mutated after recording: result_shape and
  // error. The shape vocabulary's longest value is "undefined".
  const reservedMutationBytes = retainedEvent.result_shape === null ? 7 : 0;
  // Include one byte for the event-array separator and reserve space for the
  // snapshot's counters and JSON delimiters.
  // One retained event, one defensive snapshot copy, and up to two serialized
  // result views (timeline plus IPC), with per-object and per-array-slot costs.
  const eventEstimateBytes = eventBytes * 3 + 512 + argumentShapeCount * 16;
  const retainedEventBytes = eventEstimateBytes + reservedMutationBytes + 1;
  if (
    estimatedRetainedBytes + retainedEventBytes + snapshotEnvelopeReserveBytes >
    retentionBudgetBytes
  ) {
    noteDropped(raw.kind, retainedEvent.process_type, isIpc);
    return null;
  }
  for (const group of shapeGroups) {
    if (!arrayIsArray(group)) continue;
    for (const argument of group)
      retainedEvent.argument_shapes.push(shape(argument));
  }
  for (const valueShape of existingShapes)
    retainedEvent.argument_shapes.push(
      typeof valueShape === "string" ? valueShape : "unknown",
    );
  events.push(retainedEvent);
  estimatedRetainedBytes += retainedEventBytes;
  serializedBytes += eventBytes + reservedMutationBytes + 1;
  return retainedEvent;
};

const recordRuntime = (kind, event,