@browserless.io/browserless 2.34.0 → 2.36.0

package/extensions/ublocklite/js/ruleset-manager.js

@@ -30,13 +30,13 @@ import {
     rulesetConfig,
     saveRulesetConfig,
 } from './config.js';
+import { ubolErr, ubolLog } from './debug.js';
 
 import { dnr } from './ext-compat.js';
 import { fetchJSON } from './fetch.js';
 import { getAdminRulesets } from './admin.js';
 import { hasBroadHostPermissions } from './utils.js';
 import { rulesFromText } from './dnr-parser.js';
-import { ubolErr, ubolLog } from './debug.js';
 
 /******************************************************************************/
 
@@ -131,9 +131,8 @@ pruneInvalidRegexRules.validated = new Map();
 async function updateRegexRules(currentRules, addRules, removeRuleIds) {
     // Remove existing regex-related block rules
     for ( const rule of currentRules ) {
+        if ( rule.id === 0 ) { continue; }
         if ( rule.id >= SPECIAL_RULES_REALM ) { continue; }
-        const { type } = rule.action;
-        if ( type !== 'block' && type !== 'allow' ) { continue; }
         if ( rule.condition.regexFilter === undefined ) { continue; }
         removeRuleIds.push(rule.id);
     }
@@ -167,134 +166,19 @@ async function updateRegexRules(currentRules, addRules, removeRuleIds) {
 
 /******************************************************************************/
 
-async function updateRemoveparamRules(currentRules, addRules, removeRuleIds) {
-    // Remove existing removeparam-related rules
-    for ( const rule of currentRules ) {
-        if ( rule.id >= SPECIAL_RULES_REALM ) { continue; }
-        if ( rule.action.type !== 'redirect' ) { continue; }
-        if ( rule.action.redirect.transform === undefined ) { continue; }
-        removeRuleIds.push(rule.id);
-    }
-
-    const rulesetDetails = await getEnabledRulesetsDetails();
-
-    // Fetch removeparam rules for all enabled rulesets
-    const toFetch = [];
-    for ( const details of rulesetDetails ) {
-        if ( details.rules.removeparam === 0 ) { continue; }
-        toFetch.push(fetchJSON(`/rulesets/removeparam/${details.id}`));
-    }
-    const removeparamRulesets = await Promise.all(toFetch);
-
-    const allRules = [];
-    for ( const rules of removeparamRulesets ) {
-        if ( Array.isArray(rules) === false ) { continue; }
-        for ( const rule of rules ) {
-            allRules.push(rule);
-        }
-    }
-    if ( allRules.length === 0 ) { return; }
-
-    const validRules = await pruneInvalidRegexRules('removeparam', allRules);
-    if ( validRules.length === 0 ) { return; }
-
-    ubolLog(`Add ${validRules.length} DNR removeparam rules`);
-    addRules.push(...validRules);
-}
-
-/******************************************************************************/
-
-async function updateRedirectRules(currentRules, addRules, removeRuleIds) {
-    // Remove existing redirect-related rules
-    for ( const rule of currentRules ) {
-        if ( rule.id >= SPECIAL_RULES_REALM ) { continue; }
-        if ( rule.action.type !== 'redirect' ) { continue; }
-        if ( rule.action.redirect.extensionPath === undefined ) { continue; }
-        removeRuleIds.push(rule.id);
-    }
-
-    const rulesetDetails = await getEnabledRulesetsDetails();
-
-    // Fetch redirect rules for all enabled rulesets
-    const toFetch = [];
-    for ( const details of rulesetDetails ) {
-        if ( details.rules.redirect === 0 ) { continue; }
-        toFetch.push(fetchJSON(`/rulesets/redirect/${details.id}`));
-    }
-    const redirectRulesets = await Promise.all(toFetch);
-
-    const allRules = [];
-    for ( const rules of redirectRulesets ) {
-        if ( Array.isArray(rules) === false ) { continue; }
-        for ( const rule of rules ) {
-            allRules.push(rule);
-        }
-    }
-    if ( allRules.length === 0 ) { return; }
-
-    const validRules = await pruneInvalidRegexRules('redirect', allRules);
-    if ( validRules.length === 0 ) { return; }
-
-    ubolLog(`Add ${validRules.length} DNR redirect rules`);
-    addRules.push(...validRules);
-}
-
-/******************************************************************************/
-
-async function updateModifyHeadersRules(currentRules, addRules, removeRuleIds) {
-    // Remove existing header modification-related rules
-    for ( const rule of currentRules ) {
-        if ( rule.id >= SPECIAL_RULES_REALM ) { continue; }
-        if ( rule.action.type !== 'modifyHeaders' ) { continue; }
-        removeRuleIds.push(rule.id);
-    }
-
-    const rulesetDetails = await getEnabledRulesetsDetails();
-
-    // Fetch modifyHeaders rules for all enabled rulesets
-    const toFetch = [];
-    for ( const details of rulesetDetails ) {
-        if ( details.rules.modifyHeaders === 0 ) { continue; }
-        toFetch.push(fetchJSON(`/rulesets/modify-headers/${details.id}`));
-    }
-    const rulesets = await Promise.all(toFetch);
-
-    const allRules = [];
-    for ( const rules of rulesets ) {
-        if ( Array.isArray(rules) === false ) { continue; }
-        for ( const rule of rules ) {
-            allRules.push(rule);
-        }
-    }
-    if ( allRules.length === 0 ) { return; }
-
-    const validRules = await pruneInvalidRegexRules('modify-headers', allRules);
-    if ( validRules.length === 0 ) { return; }
-
-    ubolLog(`Add ${validRules.length} DNR modify-headers rules`);
-    addRules.push(...validRules);
-}
-
-/******************************************************************************/
-
 async function updateDynamicRules() {
     const currentRules = await dnr.getDynamicRules();
     const addRules = [];
     const removeRuleIds = [];
 
-    // Remove potentially left-over strict-block rules from previous version
+    // Remove potentially left-over rules from previous version
     for ( const rule of currentRules ) {
         if ( rule.id >= SPECIAL_RULES_REALM ) { continue; }
-        if ( isStrictBlockRule(rule) === false ) { continue; }
         removeRuleIds.push(rule.id);
+        rule.id = 0;
     }
 
-    await Promise.all([
-        updateRegexRules(currentRules, addRules, removeRuleIds),
-        updateRemoveparamRules(currentRules, addRules, removeRuleIds),
-        updateRedirectRules(currentRules, addRules, removeRuleIds),
-        updateModifyHeadersRules(currentRules, addRules, removeRuleIds),
-    ]);
+    await updateRegexRules(currentRules, addRules, removeRuleIds);
     if ( addRules.length === 0 && removeRuleIds.length === 0 ) { return; }
 
     dynamicRegexCount = 0;
@@ -318,7 +202,7 @@ async function updateDynamicRules() {
             ubolLog(`Add ${addRules.length} dynamic DNR rules`);
         }
     } catch(reason) {
-        ubolErr(`updateDynamicRules() / ${reason}`);
+        ubolErr(`updateDynamicRules/${reason}`);
         response.error = `${reason}`;
     }
 
@@ -472,7 +356,7 @@ async function updateSessionRules() {
             ubolLog(`Add ${addRules.length} session DNR rules`);
         }
     } catch(reason) {
-        ubolErr(`updateSessionRules() / ${reason}`);
+        ubolErr(`updateSessionRules/${reason}`);
         response.error = `${reason}`;
     }
     return response;
@@ -667,7 +551,7 @@ async function enableRulesets(ids) {
         enableRulesetIds,
         disableRulesetIds,
     }).catch(reason => {
-        ubolErr(reason);
+        ubolErr(`updateEnabledRulesets/${reason}`);
         response.error = `${reason}`;
     });
 
@@ -684,7 +568,7 @@ async function enableRulesets(ids) {
         ubolLog(`Available static rule count: ${count}`);
         response.staticRuleCount = count;
     }).catch(reason => {
-        ubolErr(reason);
+        ubolErr(`getEnabledRulesets/${reason}`);
     });
 
     return response;
@@ -781,7 +665,7 @@ async function updateUserRules() {
         out.added = addRules.length;
         out.removed = removeRuleIds.length;
     } catch(reason) {
-        ubolErr(`updateUserRules() / ${reason}`);
+        ubolErr(`updateUserRules/${reason}`);
         out.errors.push(`${reason}`);
     } finally {
         const userRules = await getEffectiveUserRules();

package/extensions/ublocklite/js/rw-dnr-editor.js

@@ -376,17 +376,21 @@ export class ReadWriteDNREditor extends DNREditor {
             separatorBefore = true;
         }
         const pastedText = newDoc.sliceString(from, to);
-        let prepend;
+        let linesToPrepend;
         let rules = this.rulesFromJSON(pastedText);
         if ( Boolean(rules?.length) === false ) {
             rules = parseFilters(pastedText);
             if ( Boolean(rules?.length) === false ) { return; }
-            prepend = pastedText.trim().split(/\n/).map(a => `# ${a}`).join('\n');
+            const lines = pastedText.trim().split(/\n/);
+            linesToPrepend = lines.slice(0, 10).map(a => `# ${a}`);
+            if ( lines.length > linesToPrepend.length ) {
+                linesToPrepend.push('# ...');
+            }
         }
         let yamlText = textFromRules(rules);
         if ( yamlText === undefined ) { return; }
-        if ( prepend ) {
-            yamlText = yamlText.replace('---\n', `---\n${prepend}\n`);
+        if ( linesToPrepend ) {
+            yamlText = yamlText.replace('---\n', `---\n${linesToPrepend.join('\n')}\n`);
         }
         if ( separatorBefore && yamlText.startsWith('---\n') ) {
             yamlText = yamlText.slice(4);

package/extensions/ublocklite/js/scripting/css-procedural.js

@@ -60,6 +60,8 @@ self.isolatedAPI.forEachHostname(lookupAll, {
 });
 proceduralImports.length = 0;
 
+if ( selectors.length === 0 ) { return; }
+
 const exceptedSelectors = exceptions.length !== 0
     ? selectors.filter(a => exceptions.includes(JSON.stringify(a)) === false)
     : selectors;

package/extensions/ublocklite/js/scripting/css-specific.js

@@ -58,6 +58,8 @@ self.isolatedAPI.forEachHostname(lookupAll, {
 
 specificImports.length = 0;
 
+if ( selectors.length === 0 ) { return; }
+
 const exceptedSelectors = exceptions.length !== 0
     ? selectors.filter(a => exceptions.includes(a) === false)
     : selectors;

package/extensions/ublocklite/js/scripting/tool-overlay.js

@@ -262,6 +262,7 @@ self.ubolOverlay = {
             }
             return this.proceduralFiltererAPI.qsa(selector);
         }
+        selector = selector.replace(/::[^:]+$/, '');
         try {
             const elems = node.querySelectorAll(selector);
             this.qsa.error = undefined;

package/extensions/ublocklite/js/scripting-manager.js

@@ -551,7 +551,7 @@ async function registerInjectables() {
             await browser.scripting.unregisterContentScripts({ ids: toRemove });
             localRemove('$scripting.unregisterContentScripts');
         } catch(reason) {
-            ubolErr(reason);
+            ubolErr(`unregisterContentScripts/${reason}`);
         }
     }
 
@@ -561,7 +561,7 @@ async function registerInjectables() {
             await browser.scripting.registerContentScripts(toAdd);
             localRemove('$scripting.registerContentScripts');
         } catch(reason) {
-            ubolErr(reason);
+            ubolErr(`registerContentScripts/${reason}`);
         }
     }
 

package/extensions/ublocklite/js/settings.js

@@ -242,9 +242,10 @@ sendMessage({
         renderAdminRules();
         renderFilterLists(cachedRulesetData);
         renderWidgets();
-        dom.cl.remove(dom.body, 'loading');
     } catch(reason) {
         console.error(reason);
+    } finally {
+        dom.cl.remove(dom.body, 'loading');
     }
     listen();
 }).catch(reason => {

package/extensions/ublocklite/js/static-filtering-parser.js

@@ -841,6 +841,11 @@ export class AstFilterParser {
         this.netOptionValueParser = new ArglistParser(',');
         this.scriptletArgListParser = new ArglistParser(',');
         this.domainRegexValueParser = new ArglistParser('/');
+        this.reNetOptionTokens = new RegExp(
+            `^~?(${Array.from(netOptionTokenDescriptors.keys())
+                .map(s => escapeForRegex(s))
+                .join('|')})\\b`
+        );
     }
 
     finish() {
@@ -1240,7 +1245,7 @@ export class AstFilterParser {
         let modifierType = 0;
         let requestTypeCount = 0;
         let unredirectableTypeCount = 0;
-        let badfilter = false;
+        let isBadfilter = false;
         for ( let i = 0, n = this.nodeTypeRegisterPtr; i < n; i++ ) {
             const type = this.nodeTypeRegister[i];
             const targetNode = this.nodeTypeLookupTable[type];
@@ -1264,7 +1269,7 @@ export class AstFilterParser {
                 realBad = hasValue;
                 break;
             case NODE_TYPE_NET_OPTION_NAME_BADFILTER:
-                badfilter = true;
+                isBadfilter = true;
                 /* falls through */
             case NODE_TYPE_NET_OPTION_NAME_NOOP:
                 realBad = isNegated || hasValue;
@@ -1418,9 +1423,6 @@ export class AstFilterParser {
                 this.addFlags(AST_FLAG_HAS_ERROR);
             }
         }
-        const requiresTrustedSource = ( ) =>
-            this.options.trustedSource !== true &&
-            isException === false && badfilter === false;
         switch ( modifierType ) {
         case NODE_TYPE_NET_OPTION_NAME_CNAME:
             realBad = abstractTypeCount || behaviorTypeCount || requestTypeCount;
@@ -1448,7 +1450,8 @@ export class AstFilterParser {
         case NODE_TYPE_NET_OPTION_NAME_REPLACE: {
             realBad = abstractTypeCount || behaviorTypeCount || unredirectableTypeCount;
             if ( realBad ) { break; }
-            if ( requiresTrustedSource() ) {
+            if ( isException || isBadfilter ) { break; }
+            if ( this.options.trustedSource !== true ) {
                 this.astError = AST_ERROR_UNTRUSTED_SOURCE;
                 realBad = true;
                 break;
@@ -1463,7 +1466,8 @@ export class AstFilterParser {
         case NODE_TYPE_NET_OPTION_NAME_URLSKIP: {
             realBad = abstractTypeCount || behaviorTypeCount || unredirectableTypeCount;
             if ( realBad ) { break; }
-            if ( requiresTrustedSource() ) {
+            if ( isException || isBadfilter ) { break; }
+            if ( this.options.trustedSource !== true ) {
                 this.astError = AST_ERROR_UNTRUSTED_SOURCE;
                 realBad = true;
                 break;
@@ -1478,7 +1482,8 @@ export class AstFilterParser {
         case NODE_TYPE_NET_OPTION_NAME_URLTRANSFORM: {
             realBad = abstractTypeCount || behaviorTypeCount || unredirectableTypeCount;
             if ( realBad ) { break; }
-            if ( requiresTrustedSource() ) {
+            if ( isException || isBadfilter ) { break; }
+            if ( this.options.trustedSource !== true ) {
                 this.astError = AST_ERROR_UNTRUSTED_SOURCE;
                 realBad = true;
                 break;
@@ -1512,12 +1517,7 @@ export class AstFilterParser {
         for (;;) {
             const before = s.charAt(j-1);
             if ( before === '$' ) { return -1; }
-            const after = s.charAt(j+1);
-            if ( ')/|'.includes(after) === false ) {
-                if ( before === '' || '"\'\\`'.includes(before) === false ) {
-                    return j;
-                }
-            }
+            if ( this.reNetOptionTokens.test(s.slice(j+1)) ) { return j; }
             if ( j === start ) { break; }
             j = s.lastIndexOf('$', j-1);
             if ( j === -1 ) { break; }
@@ -3080,9 +3080,10 @@ export function parseReplaceByRegexValue(s) {
     if ( parser.transform ) {
         pattern = parser.normalizeArg(pattern);
     }
-    if ( pattern === '' ) { return; }
-    pattern = parser.normalizeArg(pattern, '$');
-    pattern = parser.normalizeArg(pattern, ',');
+    if ( pattern !== '' ) {
+        pattern = parser.normalizeArg(pattern, '$');
+        pattern = parser.normalizeArg(pattern, ',');
+    }
     parser.nextArg(s, parser.separatorEnd);
     let replacement = s.slice(parser.argBeg, parser.argEnd);
     if ( parser.separatorEnd === parser.separatorBeg ) { return; }
@@ -3092,6 +3093,9 @@ export function parseReplaceByRegexValue(s) {
     replacement = parser.normalizeArg(replacement, '$');
     replacement = parser.normalizeArg(replacement, ',');
     const flags = s.slice(parser.separatorEnd);
+    if ( pattern === '' ) {
+        return { flags, replacement }
+    }
     try {
         return { re: new RegExp(pattern, flags), replacement };
     } catch {
@@ -3101,7 +3105,10 @@ export function parseReplaceByRegexValue(s) {
 export function parseReplaceValue(s) {
     if ( s.startsWith('/') ) {
         const r = parseReplaceByRegexValue(s);
-        if ( r ) { r.type = 'text'; }
+        if ( r ) {
+            if ( r.re === undefined ) { return; }
+            r.type = 'text';
+        }
         return r;
     }
     const pos = s.indexOf(':');