inject.js

(function () {
  // --- toString cloaking ---
  const nativeFns = new Map();
  const origToString = Function.prototype.toString;

  Function.prototype.toString = function () {
    return nativeFns.get(this) || origToString.call(this);
  };
  nativeFns.set(Function.prototype.toString, origToString.call(origToString));

  function cloak(patched, original) {
    nativeFns.set(patched, origToString.call(original));
    return patched;
  }

  // --- fake MediaDeviceInfo that passes instanceof ---
  function createDeviceInfo(original, label) {
    const info = Object.create(MediaDeviceInfo.prototype);
    Object.defineProperties(info, {
      deviceId: { value: original.deviceId, enumerable: true },
      kind: { value: original.kind, enumerable: true },
      label: { value: label, enumerable: true },
      groupId: { value: original.groupId, enumerable: true },
    });
    info.toJSON = function () {
      return {
        deviceId: this.deviceId,
        kind: this.kind,
        label: this.label,
        groupId: this.groupId,
      };
    };
    return info;
  }

  // --- spoof MediaStreamTrack.label ---
  const origLabelDesc = Object.getOwnPropertyDescriptor(
    MediaStreamTrack.prototype,
    "label"
  );
  const trackLabelMap = new WeakMap();

  Object.defineProperty(MediaStreamTrack.prototype, "label", {
    get: cloak(function () {
      const spoofed = trackLabelMap.get(this);
      if (spoofed !== undefined) return spoofed;
      return origLabelDesc.get.call(this);
    }, origLabelDesc.get),
    configurable: true,
    enumerable: true,
  });

  // --- config loading ---
  const configPromise = new Promise((resolve) => {
    const existing = document.documentElement.getAttribute("data-cam-spoofer");
    if (existing) {
      try {
        resolve(JSON.parse(existing));
      } catch (_) {
        resolve(null);
      }
      return;
    }

    const observer = new MutationObserver((mutations) => {
      for (const m of mutations) {
        if (m.attributeName === "data-cam-spoofer") {
          observer.disconnect();
          const val =
            document.documentElement.getAttribute("data-cam-spoofer");
          try {
            resolve(JSON.parse(val));
          } catch (_) {
            resolve(null);
          }
          return;
        }
      }
    });
    observer.observe(document.documentElement, { attributes: true });

    setTimeout(() => {
      observer.disconnect();
      resolve(null);
    }, 2000);
  });

  // --- save originals ---
  const origEnumerate =
    navigator.mediaDevices.enumerateDevices.bind(navigator.mediaDevices);
  const origGetUserMedia =
    navigator.mediaDevices.getUserMedia.bind(navigator.mediaDevices);

  async function findSelectedDevice(config) {
    const devices = await origEnumerate();
    return devices.find(
      (d) => d.kind === "videoinput" && d.label === config.selectedLabel
    );
  }

  // --- patch enumerateDevices ---
  navigator.mediaDevices.enumerateDevices = cloak(async function () {
    const config = await configPromise;
    const devices = await origEnumerate();

    if (!config || !config.enabled || !config.selectedLabel) {
      return devices;
    }

    const selectedFound = devices.some(
      (d) => d.kind === "videoinput" && d.label === config.selectedLabel
    );
    if (!selectedFound) {
      return devices;
    }

    return devices
      .map((d) => {
        if (d.kind !== "videoinput") return d;
        if (d.label !== config.selectedLabel) return null;

        if (config.customLabel) {
          return createDeviceInfo(d, config.customLabel);
        }
        return d;
      })
      .filter(Boolean);
  }, navigator.mediaDevices.enumerateDevices);

  // --- patch getUserMedia ---
  navigator.mediaDevices.getUserMedia = cloak(async function (constraints) {
    const config = await configPromise;

    if (!config || !config.enabled || !config.selectedLabel) {
      return origGetUserMedia(constraints);
    }

    if (constraints && constraints.video) {
      const selected = await findSelectedDevice(config);
      if (selected) {
        const video =
          typeof constraints.video === "object"
            ? { ...constraints.video }
            : {};
        video.deviceId = { exact: selected.deviceId };
        constraints = { ...constraints, video };
      }
    }

    const stream = await origGetUserMedia(constraints);

    // Spoof track labels to match custom name
    if (config.customLabel) {
      stream.getVideoTracks().forEach((track) => {
        trackLabelMap.set(track, config.customLabel);
      });
    }

    return stream;
  }, navigator.mediaDevices.getUserMedia);
})();