@duckduckgo/autoconsent 4.0.0 → 4.1.1

package/.github/ISSUE_TEMPLATE/broken-site-issue.md

@@ -0,0 +1,29 @@
+---
+name: Broken site issue
+about: Report a site where autoconsent is not working
+title: 'Site breakage: [SITE]'
+labels: broken site
+assignees: ''
+
+---
+
+## Description
+
+The popup on [site]
+ - [ ] is not detected
+ - [ ] is not dismissed properly
+ - [ ] other (elaborate below)
+
+**Tested on**
+ - [ ] DuckDuckGo macOS browser
+ - [ ] DuckDuckGo Windows browser
+ - [ ] DuckDuckGo Android browser
+ - [ ] DuckDuckGo iOS browser
+ - [ ] Chrome browser extension
+ - [ ] Firefox browser extension
+
+**Tested from country**: 
+
+**Autoconsent version**:
+
+**Screenshot (optional)**

package/CHANGELOG.md

@@ -1,3 +1,42 @@
+# v4.1.1 (Tue Jan 24 2023)
+
+#### 🐛 Bug Fix
+
+- Add a test cosmetic rule [#91](https://github.com/duckduckgo/autoconsent/pull/91) ([@muodov](https://github.com/muodov))
+
+#### Authors: 1
+
+- Maxim Tsoy ([@muodov](https://github.com/muodov))
+
+---
+
+# v4.1.0 (Tue Jan 17 2023)
+
+#### 🚀 Enhancement
+
+- Cosmetic rules [#67](https://github.com/duckduckgo/autoconsent/pull/67) ([@muodov](https://github.com/muodov))
+- Extension Devtools [#42](https://github.com/duckduckgo/autoconsent/pull/42) ([@sammacbeth](https://github.com/sammacbeth) [@muodov](https://github.com/muodov))
+
+#### 🐛 Bug Fix
+
+- Cleaning up invalid tests [#49](https://github.com/duckduckgo/autoconsent/pull/49) ([@sammacbeth](https://github.com/sammacbeth))
+- Fix type warning on bundle. [#83](https://github.com/duckduckgo/autoconsent/pull/83) ([@sammacbeth](https://github.com/sammacbeth))
+- Add broken site issue template [#69](https://github.com/duckduckgo/autoconsent/pull/69) ([@sammacbeth](https://github.com/sammacbeth))
+
+#### 🔩 Dependency Updates
+
+- Bump @rollup/plugin-json from 5.0.2 to 6.0.0 [#72](https://github.com/duckduckgo/autoconsent/pull/72) ([@dependabot[bot]](https://github.com/dependabot[bot]))
+- Bump @types/chrome from 0.0.204 to 0.0.206 [#85](https://github.com/duckduckgo/autoconsent/pull/85) ([@dependabot[bot]](https://github.com/dependabot[bot]))
+- Bump eslint from 8.29.0 to 8.31.0 [#84](https://github.com/duckduckgo/autoconsent/pull/84) ([@dependabot[bot]](https://github.com/dependabot[bot]))
+
+#### Authors: 3
+
+- [@dependabot[bot]](https://github.com/dependabot[bot])
+- Maxim Tsoy ([@muodov](https://github.com/muodov))
+- Sam Macbeth ([@sammacbeth](https://github.com/sammacbeth))
+
+---
+
 # v4.0.0 (Wed Dec 14 2022)
 
 #### 💥 Breaking Change

package/Jenkinsfile

@@ -3,7 +3,7 @@ def runPlaywrightTests(resultDir, browser, grep) {
         timeout(20) {
             sh 'mkdir -p ./test-results'
             sh """
-                PLAYWRIGHT_JUNIT_OUTPUT_NAME=results.xml npx playwright test --project $browser --reporter=junit --workers 10 --grep "$grep"|| true
+                PLAYWRIGHT_JUNIT_OUTPUT_NAME=results.xml npx playwright test --project $browser --reporter=junit --grep "$grep"|| true
             """
         }
     } finally {
@@ -27,7 +27,7 @@ pipeline {
     agent { label 'autoconsent-crawler' }
     parameters {
         string(name: 'TEST_RESULT_ROOT', defaultValue: '/mnt/efs/users/smacbeth/autoconsent/ci', description: 'Where test results and configuration are stored')
-        choice(name: 'BROWSER', choices: ['webkit', 'iphoneSE', 'chrome', 'firefox'], description: 'Browser')
+        choice(name: 'BROWSER', choices: ['chrome', 'webkit', 'iphoneSE', 'firefox'], description: 'Browser')
         string(name: 'GREP', defaultValue: '', description: 'filter for tests matching a specific string')
     }
     environment {

package/api.md

@@ -77,6 +77,10 @@ sequenceDiagram
         Note right of CS: execute self-test rules
         CS -->>- BG: selfTestResult
     end
+
+    opt periodically
+        CS ->> BG: report
+    end
 ```
 
 ### Asynchronous eval rules
@@ -101,4 +105,9 @@ sequenceDiagram
     deactivate BG
 
     Note over CS: Continue rule execution (or fail with timeout)
-```
+```
+
+### Report messages
+
+The content-script periodically sends `report` messages which give a summary of the status of what has run
+so far in a particular frame. The exact contents of the report messages can be found in [type definitions](/lib/messages.ts).

package/dist/addon-firefox/background.bundle.js

@@ -1 +1,312 @@
-!function(){"use strict";const e=chrome.runtime.getManifest().manifest_version,t={};async function o(o){if(2!==e)return chrome.storage.local.set(o);Object.assign(t,o)}async function a(o){return null===o?2===e?t:await chrome.storage.local.get(null):2===e?t[o]:(await chrome.storage.local.get(o))?.[o]}async function s(o){if(2!==e)return chrome.storage.local.remove(o);delete t[o]}async function n(e,t,o=""){let a="",s="icons/cookie-idle.png";"success"===t?(a=`Opt out successful! (${o})`,s="icons/party.png"):"complete"===t?(a=`Opt out complete! (${o})`,s="icons/tick.png"):"working"===t?(a=`Processing... (${o})`,s="icons/cog.png"):"verified"===t?(a=`Verified (${o})`,s="icons/verified.png"):"idle"===t?(a="Idle",s="icons/cookie-idle.png"):"available"===t&&(a=`Click to opt out (${o})`,s="icons/cookie.png");const n=chrome.action||chrome.pageAction;chrome.pageAction&&chrome.pageAction.show(e),await n.setTitle({tabId:e,title:a}),await n.setIcon({tabId:e,path:s})}async function c(){const e=await fetch("./rules.json");o({rules:await e.json()})}async function i(){console.log("init sw");const e=await a("config");if(console.log("storedConfig",e),!e){console.log("init config");const e={enabled:!0,autoAction:"optOut",disabledCmps:[],enablePrehide:!0,detectRetries:20};await o({config:e})}}chrome.runtime.onInstalled.addListener((()=>{c(),i()})),2===e&&(c(),i()),chrome.tabs.onRemoved.addListener((e=>{s(`detected${e}`)})),chrome.runtime.onMessage.addListener((async(t,c)=>{const i=c.tab.id,r=c.frameId,l=await a("rules"),d=await a("config");switch(t.type){case"init":0===r&&await n(i,"idle"),chrome.tabs.sendMessage(i,{type:"initResp",rules:l,config:d},{frameId:r});break;case"eval":(async function(t,o,a){return 2===e?new Promise((e=>{chrome.tabs.executeScript(t,{frameId:o,code:`!!window.eval(decodeURIComponent("${encodeURIComponent(a)}"))`},(t=>{e([{result:t[0],frameId:o}])}))})):chrome.scripting.executeScript({target:{tabId:t,frameIds:[o]},world:"MAIN",args:[a],func:e=>{try{return window.eval(e)}catch(t){return void console.warn("eval error",e,t)}}})})(i,r,t.code).then((([e])=>{chrome.tabs.sendMessage(i,{id:t.id,type:"evalResp",result:e.result},{frameId:r})}));break;case"popupFound":await n(i,"available",t.cmp),o({[`detected${i}`]:r});break;case"optOutResult":case"optInResult":t.result&&(await n(i,"working",t.cmp),t.scheduleSelfTest&&await o({[`selfTest${i}`]:r}));break;case"selfTestResult":t.result&&await n(i,"verified",t.cmp);break;case"autoconsentDone":{await n(i,"success",t.cmp);const e=`selfTest${i}`,o=(await chrome.storage.local.get(e))?.[e];"number"==typeof o&&(s(e),chrome.tabs.sendMessage(i,{type:"selfTest"},{frameId:o}));break}case"autoconsentError":console.error("Error:",t.details)}})),2===e&&chrome.pageAction.onClicked.addListener((async e=>{const t=e.id,o=`detected${t}`,c=await a(o);"number"==typeof c&&(s(o),await n(t,"working"),chrome.tabs.sendMessage(t,{type:"optOut"},{frameId:c}))}))}();
+(function () {
+    'use strict';
+
+    const manifestVersion = chrome.runtime.getManifest().manifest_version;
+    // Storage abstraction: MV2 keeps everything in memory, MV3 uses chrome.storage
+    const storage = {};
+    async function storageSet(obj) {
+        if (manifestVersion === 2) {
+            Object.assign(storage, obj);
+            return;
+        }
+        return chrome.storage.local.set(obj);
+    }
+    async function storageGet(key) {
+        if (key === null) {
+            if (manifestVersion === 2) {
+                return storage;
+            }
+            return await chrome.storage.local.get(null);
+        }
+        if (manifestVersion === 2) {
+            return storage[key];
+        }
+        return (await chrome.storage.local.get(key))?.[key];
+    }
+    async function storageRemove(key) {
+        if (manifestVersion === 2) {
+            delete storage[key];
+            return;
+        }
+        return chrome.storage.local.remove(key);
+    }
+
+    async function showOptOutStatus(tabId, status, cmp = '') {
+        let title = "";
+        let icon = "icons/cookie-idle.png";
+        if (status === "success") {
+            title = `Opt out successful! (${cmp})`;
+            icon = "icons/party.png";
+        }
+        else if (status === "complete") {
+            title = `Opt out complete! (${cmp})`;
+            icon = "icons/tick.png";
+        }
+        else if (status === "working") {
+            title = `Processing... (${cmp})`;
+            icon = "icons/cog.png";
+        }
+        else if (status === "verified") {
+            title = `Verified (${cmp})`;
+            icon = "icons/verified.png";
+        }
+        else if (status === "idle") {
+            title = "Idle";
+            icon = "icons/cookie-idle.png";
+        }
+        else if (status === "available") {
+            title = `Click to opt out (${cmp})`;
+            icon = "icons/cookie.png";
+        }
+        const action = chrome.action || chrome.pageAction;
+        if (chrome.pageAction) {
+            chrome.pageAction.show(tabId);
+        }
+        await action.setTitle({
+            tabId,
+            title,
+        });
+        await action.setIcon({
+            tabId,
+            path: icon,
+        });
+    }
+
+    /**
+     * Mapping of tabIds to Port connections to open devtools panels.
+     * This is kept in memory, as the values are only relevant while the background service worker is
+     * alive. Once the service worker stops, Ports to devtools will be severed, and the panel will
+     * reestablish the connection.
+     */
+    const openDevToolsPanels = new Map();
+    async function loadRules() {
+        const res = await fetch("./rules.json");
+        storageSet({
+            rules: await res.json(),
+        });
+    }
+    async function initConfig() {
+        console.log('init sw');
+        const storedConfig = await storageGet('config');
+        console.log('storedConfig', storedConfig);
+        if (!storedConfig) {
+            console.log('init config');
+            const defaultConfig = {
+                enabled: true,
+                autoAction: 'optOut',
+                disabledCmps: [],
+                enablePrehide: true,
+                enableCosmeticRules: true,
+                detectRetries: 20,
+            };
+            await storageSet({
+                config: defaultConfig,
+            });
+        }
+        else if (typeof storedConfig.enableCosmeticRules === 'undefined') { // upgrade from old versions
+            storedConfig.enableCosmeticRules = true;
+            await storageSet({
+                config: storedConfig,
+            });
+        }
+    }
+    async function evalInTab(tabId, frameId, code) {
+        if (manifestVersion === 2) {
+            return new Promise((resolve) => {
+                chrome.tabs.executeScript(tabId, {
+                    frameId,
+                    code: `!!window.eval(decodeURIComponent("${encodeURIComponent(code)}"))`
+                }, (resultArr) => {
+                    resolve([{
+                            result: resultArr[0],
+                            frameId,
+                        }]);
+                });
+            });
+        }
+        return chrome.scripting.executeScript({
+            target: {
+                tabId,
+                frameIds: [frameId],
+            },
+            world: "MAIN",
+            args: [code],
+            func: (code) => {
+                try {
+                    return window.eval(code);
+                }
+                catch (e) {
+                    // ignore CSP errors
+                    console.warn('eval error', code, e);
+                    return;
+                }
+            },
+        });
+    }
+    async function getTabReports(tabId) {
+        const storageKey = `reports-${tabId}`;
+        return (await chrome.storage.session.get(storageKey))[storageKey] || {};
+    }
+    async function updateTabReports(tabId, frameId, msg) {
+        const reportsForTab = await getTabReports(tabId);
+        reportsForTab[frameId] = msg;
+        await chrome.storage.session.set({ [`reports-${tabId}`]: reportsForTab });
+    }
+    chrome.runtime.onInstalled.addListener(() => {
+        loadRules();
+        initConfig();
+    });
+    if (manifestVersion === 2) {
+        // always load rules on startup in MV2
+        loadRules();
+        initConfig();
+    }
+    chrome.tabs.onRemoved.addListener((tabId) => {
+        storageRemove(`detected${tabId}`);
+    });
+    chrome.runtime.onMessage.addListener(async (msg, sender) => {
+        const tabId = sender.tab.id;
+        const frameId = sender.frameId;
+        const rules = await storageGet("rules");
+        const autoconsentConfig = await storageGet('config');
+        switch (msg.type) {
+            case "init":
+                if (frameId === 0) {
+                    await showOptOutStatus(tabId, 'idle');
+                }
+                chrome.tabs.sendMessage(tabId, {
+                    type: "initResp",
+                    rules,
+                    config: autoconsentConfig,
+                }, {
+                    frameId,
+                });
+                break;
+            case "eval":
+                evalInTab(tabId, frameId, msg.code).then(([result]) => {
+                    chrome.tabs.sendMessage(tabId, {
+                        id: msg.id,
+                        type: "evalResp",
+                        result: result.result,
+                    }, {
+                        frameId,
+                    });
+                });
+                break;
+            case "popupFound":
+                await showOptOutStatus(tabId, "available", msg.cmp);
+                storageSet({
+                    [`detected${tabId}`]: frameId,
+                });
+                break;
+            case "optOutResult":
+            case "optInResult":
+                if (msg.result) {
+                    await showOptOutStatus(tabId, "working", msg.cmp);
+                    if (msg.scheduleSelfTest) {
+                        await storageSet({
+                            [`selfTest${tabId}`]: frameId,
+                        });
+                    }
+                }
+                break;
+            case "selfTestResult":
+                if (msg.result) {
+                    await showOptOutStatus(tabId, "verified", msg.cmp);
+                }
+                break;
+            case "autoconsentDone": {
+                await showOptOutStatus(tabId, "success", msg.cmp);
+                // sometimes self-test needs to be done in another frame
+                const selfTestKey = `selfTest${tabId}`;
+                const selfTestFrameId = (await chrome.storage.local.get(selfTestKey))?.[selfTestKey];
+                if (typeof selfTestFrameId === 'number') {
+                    storageRemove(selfTestKey);
+                    chrome.tabs.sendMessage(tabId, {
+                        type: "selfTest",
+                    }, {
+                        frameId: selfTestFrameId,
+                    });
+                }
+                break;
+            }
+            case "autoconsentError":
+                console.error('Error:', msg.details);
+                break;
+            case "report":
+                if (sender.tab && openDevToolsPanels.has(sender.tab.id)) {
+                    openDevToolsPanels.get(sender.tab.id).postMessage({
+                        tabId: sender.tab.id,
+                        frameId: sender.frameId,
+                        ...msg,
+                    });
+                }
+                updateTabReports(sender.tab.id, sender.frameId, msg);
+                break;
+        }
+    });
+    if (manifestVersion === 2) { // MV3 handles this inside the popup
+        chrome.pageAction.onClicked.addListener(async (tab) => {
+            const tabId = tab.id;
+            const detectedKey = `detected${tabId}`;
+            const frameId = await storageGet(detectedKey);
+            if (typeof frameId === 'number') {
+                storageRemove(detectedKey);
+                await showOptOutStatus(tabId, "working");
+                chrome.tabs.sendMessage(tabId, {
+                    type: "optOut",
+                }, {
+                    frameId,
+                });
+            }
+        });
+    }
+    // Communicate with devtools panels
+    chrome.runtime.onConnect.addListener(function (devToolsConnection) {
+        if (devToolsConnection.name.startsWith('instance-')) {
+            // connection from an autoconsent instance - used to detect frame destruction
+            const tabId = devToolsConnection.sender?.tab?.id;
+            const instanceId = devToolsConnection.name.slice('instance-'.length);
+            if (tabId && instanceId) {
+                devToolsConnection.onDisconnect.addListener(() => {
+                    if (openDevToolsPanels.has(tabId)) {
+                        openDevToolsPanels.get(tabId).postMessage({
+                            type: 'instanceTerminated',
+                            tabId,
+                            instanceId,
+                        });
+                    }
+                    // remove stored frame data
+                    updateTabReports(tabId, devToolsConnection.sender.frameId, undefined);
+                });
+            }
+        }
+        else if (devToolsConnection.name === 'devtools-panel') {
+            let tabId = -1;
+            // add the listener
+            devToolsConnection.onMessage.addListener(async (message) => {
+                tabId = message.tabId;
+                if (message.type === 'init') {
+                    // save the message channel for this tab
+                    openDevToolsPanels.set(tabId, devToolsConnection);
+                    // dump data cached in bg to the panel
+                    const reportsForTab = await getTabReports(tabId);
+                    Object.keys(reportsForTab || {}).forEach((frameId) => {
+                        devToolsConnection.postMessage({
+                            tabId,
+                            frameId,
+                            ...reportsForTab[parseInt(frameId, 10)]
+                        });
+                    });
+                }
+            });
+            devToolsConnection.onDisconnect.addListener(function () {
+                openDevToolsPanels.delete(tabId);
+            });
+        }
+    });
+    chrome.tabs.onRemoved.addListener((tabId) => {
+        chrome.storage.session.remove(`reports-${tabId}`);
+    });
+
+})();