Merge pull request #103 from Tensai75/v1.4.5

v1.4.5

Author: Tensai75

src/components/interception/editDomainDialog.vue

@@ -60,7 +60,7 @@ function reset() {
           v-slot="$field"
           :name="i18n.t('settings.interception.domains.domain.title')"
           :initial-value="domain.domain"
-          :resolver="requiredUniqueBaseDomainResolver"
+          :resolver="isAdd ? requiredUniqueBaseDomainResolver : undefined"
           :validate-on-blur="true"
           :validate-on-value-update="true"
           :validate-on-mount="true"
@@ -73,7 +73,7 @@ function reset() {
             size="small"
             autocomplete="off"
             type="text"
-            :disabled="domain.isDefault"
+            :disabled="domain.isDefault || isAdd === false"
           />
           <Message v-if="$field?.invalid" severity="error" size="small" variant="simple" class="flex-auto">{{
             $field.error?.message

src/entrypoints/background/interception/contentScriptRegistrationHandler.ts

@@ -1,34 +1,30 @@
 import { browser } from '#imports'
-import {
-  getSettings as getInterceptionSettings,
-  Settings as InterceptionSettings,
-  watchSettings as watchInterceptionSettings,
-} from '@/services/interception'
+import { getActiveDomains, watchSettings as watchInterceptionSettings } from '@/services/interception'
 import log from '@/services/logger/debugLogger'
 
 const scriptId: string = 'interception-content-script'
 const scriptSource: string = '/content-scripts/interception.js'
 
 export default function (): void {
-  getInterceptionSettings().then((settings) => {
-    registerContentScript(settings)
-  })
-  watchInterceptionSettings((settings) => {
-    log.info('interception settings have changed')
-    registerContentScript(settings)
+  // async setup
+  log.info('Setting up interception content script registration')
+  setupInterceptionContentScriptRegistration()
+  // synchronous listener for settings changes
+  watchInterceptionSettings(() => {
+    log.info('Interception settings have changed, updating interception content script registration')
+    setupInterceptionContentScriptRegistration()
   })
 }
 
-function registerContentScript(settings: InterceptionSettings): void {
-  const domains = getActiveDomainsMatchPatternArray(settings)
-  browser.scripting.getRegisteredContentScripts().then((scripts) => {
-    const isRegistered = scripts.some((script) => script.id === scriptId)
-    if (domains.length === 0) {
-      handleNoDomains(isRegistered)
-    } else {
-      handleDomainsRegistration(isRegistered, domains)
-    }
-  })
+async function setupInterceptionContentScriptRegistration(): Promise<void> {
+  const domains = await getActiveDomainsMatchPatternArray()
+  const scripts = await browser.scripting.getRegisteredContentScripts()
+  const isRegistered = scripts.some((script) => script.id === scriptId)
+  if (domains.length === 0) {
+    handleNoDomains(isRegistered)
+  } else {
+    handleDomainsRegistration(isRegistered, domains)
+  }
 }
 
 function handleNoDomains(isRegistered: boolean): void {
@@ -46,7 +42,7 @@ function handleDomainsRegistration(isRegistered: boolean, domains: Array<string>
     updateContentScript(domains)
   } else {
     log.info('Registering the interception content script')
-    registerNewContentScript(domains)
+    registerContentScript(domains)
   }
 }
 
@@ -64,15 +60,14 @@ function updateContentScript(domains: Array<string>): void {
     .catch((e: Error) => log.error('Error while updating the registration of the interception content script', e))
 }
 
-function registerNewContentScript(domains: Array<string>): void {
+function registerContentScript(domains: Array<string>): void {
   browser.scripting
     .registerContentScripts([{ id: scriptId, js: [scriptSource], matches: domains }])
     .then(() => log.info('Registration of the interception content script completed successfully'))
     .catch((e: Error) => log.error('Error while registering the interception content script', e))
 }
 
-function getActiveDomainsMatchPatternArray(settings: InterceptionSettings): Array<string> {
-  return settings.enabled
-    ? settings.domains.filter((domain) => domain.isActive).map((domain) => `*://*.${domain.domain}/*`)
-    : []
+async function getActiveDomainsMatchPatternArray(): Promise<Array<string>> {
+  const activeDomains = await getActiveDomains()
+  return activeDomains.map((domain) => `*://*.${domain.domain}/*`)
 }

src/entrypoints/background/interception/declarativeNetRequestHandler.ts

@@ -29,7 +29,6 @@ const redirectURLs = [
 // Redirect URL to be used in declarativeNetRequest rule
 const redirectURL: string = 'https://connectivity-check.ubuntu.com/204'
 // In-memory cache for request details
-export const requestCache = new Map<string, RequestDetails>()
 export const tabRelationships = new Map<number, number>() // key: new tab ID, value: opener tab ID
 
 // Request methods for declarativeNetRequest rules
@@ -122,10 +121,6 @@ async function registerInterceptionListener(): Promise<void> {
     log.info('removing onBeforeRequest listener for interception')
     browser.webRequest.onBeforeRequest.removeListener(onBeforeRequestListener)
   }
-  if (browser.webRequest.onHeadersReceived.hasListener(onRedirectHeadersReceivedListener)) {
-    log.info('removing onRedirectHeadersReceived listener for interception')
-    browser.webRequest.onHeadersReceived.removeListener(onRedirectHeadersReceivedListener)
-  }
   if (browser.tabs.onCreated.hasListener(onTabCreatedListener)) {
     log.info('removing onTabCreated listener for interception')
     browser.tabs.onCreated.removeListener(onTabCreatedListener)
@@ -146,14 +141,6 @@ async function registerInterceptionListener(): Promise<void> {
     const error = e instanceof Error ? e : new Error(String(e))
     log.error('failed to register onBeforeRequest listener for interception:', error)
   }
-  try {
-    log.info('registering onRedirectHeadersReceived listener for interception')
-    browser.webRequest.onHeadersReceived.addListener(onRedirectHeadersReceivedListener, { urls: [redirectURL] })
-    log.info('registration of the onRedirectHeadersReceived listener for interception was successful')
-  } catch (e) {
-    const error = e instanceof Error ? e : new Error(String(e))
-    log.error('failed to register onRedirectHeadersReceived listener for interception:', error)
-  }
   try {
     log.info('registering onTabCreated listener for interception')
     browser.tabs.onCreated.addListener(onTabCreatedListener)
@@ -179,60 +166,26 @@ function onBeforeRequestListener(
   details: Browser.webRequest.OnBeforeRequestDetails
 ): Browser.webRequest.BlockingResponse | undefined {
   isURLTracked(details.url).then((isTracked) => {
-    if (!isTracked) return
-    log.info(`request ${details.requestId} to ${details.url} is tracked, caching request details`)
+    // If the tabId is negative, it means the request comes from the background script itself and hence should be ignored
+    if (!isTracked || details.tabId < 0) return
+    log.info(`request ${details.requestId} to ${details.url} is going to be blocked, gathering request details`)
     let bodyData: RequestDetails['body']
     if (details.method !== 'GET' && details.requestBody) {
       if (details.requestBody.formData) {
         bodyData = details.requestBody.formData as RequestDetails['body']
       }
     }
-    requestCache.set(details.requestId, {
+    const requestDeatils = {
       tabId: details.tabId,
       requestId: details.requestId,
       url: details.url,
       method: details.method,
       body: bodyData,
       // @ts-expect-error: Property 'originUrl' does not exist on type 'WebRequestBodyDetails'
       source: details.originUrl ?? details.initiator ?? '',
-    })
-    setTimeout(() => {
-      if (requestCache.delete(details.requestId)) {
-        log.info(`request cache for request ${details.requestId} was cleared after 5 seconds`)
-      }
-    }, 5000)
-  })
-  return undefined
-}
-
-function onRedirectHeadersReceivedListener(
-  details: Browser.webRequest.OnHeadersReceivedDetails
-): Browser.webRequest.BlockingResponse | undefined {
-  ;(async () => {
-    log.info(`interception redirect detected for request ${details.requestId}`)
-    // Wait for the request details to be available in the cache.
-    // This is necessary because onBeforeRedirectRequestListener may be called
-    // before onBeforeRequestListener has finished caching the details.
-    let timeout = false
-    setTimeout(() => {
-      timeout = true
-    }, 1000)
-    while (!requestCache.has(details.requestId)) {
-      log.info(`waiting for cached request details of request ${details.requestId}`)
-      await new Promise((resolve) => setTimeout(resolve, 100))
-      if (timeout) {
-        log.warn(`waiting for request details of request ${details.requestId} timed out, skipping interception`)
-        return
-      }
     }
-    // Once the request details are available or the timeout is reached,
-    // either process the request if found in cache or ignore it
-    if (requestCache.has(details.requestId)) {
-      log.info(`request details of intercepted request ${details.requestId} found in cache`)
-      interceptRequest(requestCache.get(details.requestId)!)
-      requestCache.delete(details.requestId)
-    }
-  })()
+    interceptRequest(requestDeatils)
+  })
   return undefined
 }
 
@@ -249,7 +202,7 @@ function constructRuleSet(activeDomains: DomainSettings[]): Browser.declarativeN
     priority: 1,
     action: { type: 'redirect', redirect: { url: redirectURL } },
     condition: {
-      regexFilter: `${domain.domain}${normalizeRegexStart(domain.pathRegExp)}`,
+      regexFilter: getDomainRegExp(domain),
       resourceTypes,
       requestMethods,
       initiatorDomains: [domain.domain],
@@ -284,10 +237,11 @@ async function createUrlsFilter(): Promise<string[]> {
 }
 
 async function isURLTracked(url: string): Promise<boolean> {
+  if (url.includes('x-nzbdonkey')) return false // avoid intercepting our own requests from the content script
   const activeDomains = await getActiveDomains()
   for (const domain of activeDomains) {
     try {
-      const regex = new RegExp(`${domain.domain}${normalizeRegexStart(domain.pathRegExp)}`, 'i')
+      const regex = new RegExp(getDomainRegExp(domain), 'i')
       if (regex.test(url)) return true
     } catch (e) {
       const error = e instanceof Error ? e : new Error(String(e))
@@ -297,6 +251,7 @@ async function isURLTracked(url: string): Promise<boolean> {
   return false
 }
 
-function normalizeRegexStart(input: string): string {
-  return input.startsWith('^') ? input.slice(1) : '.*?' + input
+function getDomainRegExp(domain: DomainSettings): string {
+  const pathRegExp = domain.pathRegExp.startsWith('^') ? domain.pathRegExp.slice(1) : '.*?' + domain.pathRegExp
+  return `${domain.domain}${pathRegExp}`
 }

src/entrypoints/background/interception/helperFunction.ts

@@ -69,6 +69,6 @@ export function addTimestampToURL(request: Request, ruleId: number): Request {
   const url = new URL(request.url)
   // Use a combination of timestamp and counter for uniqueness
   const uniqueId = `${Date.now()}${ruleId}`
-  url.searchParams.append('nzbdonkey', uniqueId)
+  url.searchParams.append('x-nzbdonkey', uniqueId)
   return new Request(url.toString(), request)
 }

src/services/interception/functions.ts

@@ -41,7 +41,7 @@ export async function extractArchive(blob: Blob, source: string): Promise<NZBFil
 
 export async function getActiveDomains(): Promise<DomainSettings[]> {
   const settings = await getSettings()
-  return settings.domains.filter((domain) => domain.isActive)
+  return settings.enabled ? settings.domains.filter((domain) => domain.isActive) : []
 }
 
 export async function processNzbFiles(nzbFiles: NZBFileObject[], filename: string): Promise<void> {