Feature: Protected audience analysis in PSAT

packages/cli/src/e2e-tests/index.ts

@@ -20,8 +20,8 @@ describe('CLI E2E Test', () => {
 
   it('Should run site analysis', () => {
     return coffee
-      .fork(cli, ['-u https://httpstatus.us/200', '-w 1000'])
-      .includes('stdout', '/out/httpstatus-us-200/report_')
+      .fork(cli, ['-u https://domain-aaa.com/', '-w 1000'])
+      .includes('stdout', '/out/domain-aaa-com/report_')
       .end();
   }, 60000);
 });

packages/common/package.json

@@ -42,6 +42,6 @@
     "tldts": "^6.0.14"
   },
   "devDependencies": {
-    "devtools-protocol": "^0.0.1333880"
+    "devtools-protocol": "^0.0.1345247"
   }
 }

packages/common/src/index.ts

@@ -52,3 +52,4 @@ export * from './worker/enums';
 export * from './utils/generateReports';
 export * from './cookies.types';
 export * from './libraryDetection.types';
+export * from './protectedAudience.types';

packages/common/src/protectedAudience.types.ts

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * External dependencies
+ */
+import type { Protocol } from 'devtools-protocol';
+
+export interface singleAuctionEvent {
+  bidCurrency?: string;
+  uniqueAuctionId?: Protocol.Storage.InterestGroupAuctionId;
+  bid?: number;
+  name?: string;
+  ownerOrigin?: string;
+  type: string;
+  formattedTime: string | Date;
+  componentSellerOrigin?: string;
+  time: number;
+  auctionConfig?: object;
+  interestGroupConfig?: Protocol.Storage.InterestGroupAccessedEvent;
+  parentAuctionId?: Protocol.Storage.InterestGroupAuctionId;
+  eventType:
+    | 'interestGroupAuctionEventOccurred'
+    | 'interestGroupAuctionNetworkRequestCompleted'
+    | 'interestGroupAuctionNetworkRequestCreated'
+    | 'interestGroupAccessed';
+}
+
+export interface auctionData {
+  [uniqueAuctionId: Protocol.Storage.InterestGroupAuctionId]: {
+    auctionTime: Protocol.Network.TimeSinceEpoch;
+    auctionConfig?: any;
+    parentAuctionId?: Protocol.Storage.InterestGroupAuctionId;
+  };
+}
+
+export type InterestGroups = singleAuctionEvent & {
+  details: any;
+};
+
+export type MultiSellerAuction = {
+  [parentAuctionId: string]: {
+    [uniqueAuctionId: string]: singleAuctionEvent[];
+  };
+};
+
+export type SingleSellerAuction = {
+  [parentAuctionId: string]: singleAuctionEvent[];
+};
+
+export type NoBidsType = {
+  [auctionId: string]: {
+    ownerOrigin: string;
+    name: string;
+    uniqueAuctionId: string;
+    adUnitCode?: string;
+    mediaContainerSize?: number[][];
+  };
+};
+
+export type AdsAndBiddersType = {
+  [adUnitCode: string]: {
+    adUnitCode: string;
+    bidders: string[];
+    mediaContainerSize: number[][];
+  };
+};
+
+export type ReceivedBids = singleAuctionEvent & {
+  adUnitCode?: string;
+  mediaContainerSize?: number[];
+};
+
+export type AuctionEventsType = SingleSellerAuction | MultiSellerAuction | null;

packages/extension/package.json

@@ -54,7 +54,7 @@
   },
   "devDependencies": {
     "@types/react-copy-to-clipboard": "^5.0.4",
-    "devtools-protocol": "^0.0.1333880",
+    "devtools-protocol": "^0.0.1345247",
     "html-inline-script-webpack-plugin": "^3.2.1"
   }
 }

packages/extension/src/serviceWorker/attachCDP.ts

@@ -17,23 +17,41 @@
  * This function will attach the debugger to the given target.
  * @param {{ [key: string]: number | string }} target The target where debugger needs to be attached.
  */
-export default async function attachCDP(target: {
-  [key: string]: number | string;
-}) {
-  try {
-    await chrome.debugger.attach(target, '1.3');
-    await chrome.debugger.sendCommand(target, 'Target.setAutoAttach', {
-      // If this is set to true, debugger will be attached to every new target that is added to the current target.
-      autoAttach: true,
-      waitForDebuggerOnStart: false,
-      //Enables "flat" access to the session via specifying sessionId attribute in the commands.
-      // If this is set to true the debugger is also attached to the child targets of that the target it has been attached to.
-      flatten: true,
-    });
-    await chrome.debugger.sendCommand(target, 'Network.enable');
-    await chrome.debugger.sendCommand(target, 'Audits.enable');
-    await chrome.debugger.sendCommand(target, 'Page.enable');
-  } catch (error) {
-    //Fail silently
-  }
+export default function attachCDP(target: { [key: string]: number | string }) {
+  chrome.debugger.attach(target, '1.3', async () => {
+    if (chrome.runtime.lastError) {
+      // eslint-disable-next-line no-console
+      console.warn(chrome.runtime.lastError);
+    }
+    try {
+      await chrome.debugger.sendCommand(target, 'Target.setAutoAttach', {
+        autoAttach: true,
+        flatten: false,
+        waitForDebuggerOnStart: true,
+      });
+
+      await chrome.debugger.sendCommand(
+        target,
+        'Storage.setInterestGroupAuctionTracking',
+        { enable: true }
+      );
+
+      await chrome.debugger.sendCommand(target, 'Audits.enable');
+
+      await chrome.debugger.sendCommand(
+        target,
+        'Storage.setInterestGroupTracking',
+        {
+          enable: true,
+        }
+      );
+
+      await chrome.debugger.sendCommand(target, 'Page.enable');
+
+      await chrome.debugger.sendCommand(target, 'Network.enable');
+    } catch (error) {
+      // eslint-disable-next-line no-console
+      console.warn(error);
+    }
+  });
 }

packages/extension/src/serviceWorker/chromeListeners/beforeSendHeadersListener.ts

@@ -17,7 +17,8 @@
  * Internal dependencies
  */
 import parseHeaders from '../../utils/parseHeaders';
-import synchnorousCookieStore from '../../store/synchnorousCookieStore';
+import dataStore from '../../store/dataStore';
+import cookieStore from '../../store/cookieStore';
 import { getTab } from '../../utils/getTab';
 
 export const onBeforeSendHeadersListener = ({
@@ -27,26 +28,26 @@ export const onBeforeSendHeadersListener = ({
   frameId,
   requestId,
 }: chrome.webRequest.WebRequestHeadersDetails) => {
-  if (synchnorousCookieStore.globalIsUsingCDP) {
+  if (dataStore.globalIsUsingCDP) {
     return;
   }
 
   (async () => {
     const tab = await getTab(tabId);
-    let tabUrl = synchnorousCookieStore?.getTabUrl(tabId);
+    let tabUrl = dataStore?.getTabUrl(tabId);
 
     if (tab && tab.pendingUrl) {
       tabUrl = tab.pendingUrl;
     }
 
     const cookies = await parseHeaders(
-      synchnorousCookieStore.globalIsUsingCDP,
+      dataStore.globalIsUsingCDP,
       'request',
-      synchnorousCookieStore.tabToRead,
-      synchnorousCookieStore.tabMode,
+      dataStore.tabToRead,
+      dataStore.tabMode,
       tabId,
       url,
-      synchnorousCookieStore.cookieDB ?? {},
+      dataStore.cookieDB ?? {},
       tabUrl,
       frameId.toString(),
       requestId,
@@ -58,6 +59,6 @@ export const onBeforeSendHeadersListener = ({
     }
 
     // Adds the cookies from the request headers to the cookies object.
-    synchnorousCookieStore?.update(tabId, cookies);
+    cookieStore?.update(tabId, cookies);
   })();
 };

packages/extension/src/serviceWorker/chromeListeners/onCommittedNavigationListener.ts

@@ -17,7 +17,7 @@
  * Internal dependencies
  */
 import { TABID_STORAGE } from '../../constants';
-import synchnorousCookieStore from '../../store/synchnorousCookieStore';
+import dataStore from '../../store/dataStore';
 import getQueryParams from '../../utils/getQueryParams';
 import attachCDP from '../attachCDP';
 
@@ -36,7 +36,7 @@ export const onCommittedNavigationListener = async ({
     }
 
     const targets = await chrome.debugger.getTargets();
-    const mainFrameId = synchnorousCookieStore?.globalIsUsingCDP
+    const mainFrameId = dataStore?.globalIsUsingCDP
       ? targets.filter((target) => target.tabId && target.tabId === tabId)[0]
           ?.id
       : 0;
@@ -50,19 +50,19 @@ export const onCommittedNavigationListener = async ({
         isUsingCDP: queryParams.psat_cdp === 'on',
       });
 
-      synchnorousCookieStore.globalIsUsingCDP = queryParams.psat_cdp === 'on';
-      synchnorousCookieStore.tabMode =
+      dataStore.globalIsUsingCDP = queryParams.psat_cdp === 'on';
+      dataStore.tabMode =
         queryParams.psat_multitab === 'on' ? 'unlimited' : 'single';
     }
 
-    synchnorousCookieStore?.updateUrl(tabId, url);
+    dataStore?.updateUrl(tabId, url);
 
     if (url && !url.startsWith('chrome://')) {
-      synchnorousCookieStore?.removeCookieData(tabId);
+      dataStore?.removeCookieData(tabId);
 
-      if (synchnorousCookieStore.globalIsUsingCDP) {
-        synchnorousCookieStore.deinitialiseVariablesForTab(tabId.toString());
-        synchnorousCookieStore.initialiseVariablesForNewTab(tabId.toString());
+      if (dataStore.globalIsUsingCDP) {
+        dataStore.deinitialiseVariablesForTab(tabId.toString());
+        dataStore.initialiseVariablesForNewTab(tabId.toString());
 
         await attachCDP({ tabId });
 
@@ -76,11 +76,7 @@ export const onCommittedNavigationListener = async ({
           }
         );
 
-        synchnorousCookieStore.updateParentChildFrameAssociation(
-          tabId,
-          targetId,
-          '0'
-        );
+        dataStore.updateParentChildFrameAssociation(tabId, targetId, '0');
       }
     }
     await chrome.tabs.sendMessage(tabId, {

packages/extension/src/serviceWorker/chromeListeners/onEnabledListener.ts

@@ -16,7 +16,7 @@
 /**
  * Internal dependencies
  */
-import synchnorousCookieStore from '../../store/synchnorousCookieStore';
+import dataStore from '../../store/dataStore';
 import { updateGlobalVariableAndAttachCDP, setupIntervals } from './utils';
 
 export const onEnabledListener = async (
@@ -26,7 +26,7 @@ export const onEnabledListener = async (
     return;
   }
 
-  synchnorousCookieStore?.clear();
+  dataStore?.clear();
 
   setupIntervals();