Update URL to fetch queries.json from v3 branch

Close #417

.eslintrc.js

@@ -1,40 +1,28 @@
 module.exports = {
-    'env': {
-        'es2021': true,
-        'node': true
+    env: {
+        es2021: true,
+        node: true
     },
-    'extends': [
-        'eslint:recommended',
-        'plugin:@typescript-eslint/recommended'
-    ],
-    'parser': '@typescript-eslint/parser',
-    'parserOptions': {
-        'ecmaVersion': 12,
-        'sourceType': 'module'
+    extends: ['eslint:recommended', 'plugin:@typescript-eslint/recommended'],
+    parser: '@typescript-eslint/parser',
+    parserOptions: {
+        ecmaVersion: 12,
+        sourceType: 'module'
     },
-    'plugins': [
-        '@typescript-eslint'
-    ],
-    'rules': {
-        'linebreak-style': [
-            'error',
-            'unix'
+    plugins: ['@typescript-eslint'],
+    rules: {
+        'linebreak-style': ['error', 'unix'],
+        quotes: ['error', 'single'],
+        semi: ['error', 'never'],
+        '@typescript-eslint/no-explicit-any': [
+            'warn',
+            {
+                fixToUnknown: false
+            }
         ],
-        'quotes': [
-            'error',
-            'single'
-        ],
-        'semi': [
-            'error',
-            'never'
-        ],
-        '@typescript-eslint/no-explicit-any':
-            ['warn', {
-                fixToUnknown: true // This line is optional and only relevant if you are using TypeScript
-            }],
         'comma-dangle': 'off',
         '@typescript-eslint/comma-dangle': 'error',
-        'prefer-arrow-callback': 'error'
-        // Add any other rules you want to enforce here
+        'prefer-arrow-callback': 'error',
+        'no-empty': 'off'
     }
-}
+}

.gitignore

@@ -1,9 +1,13 @@
 sessions/
 dist/
+.dev/
 node_modules/
-accounts.json
-notes
+src/accounts.json
+src/config.json
+/.vscode
+/diagnostics
+note
 accounts.dev.json
 accounts.main.json
 .DS_Store
-.playwright-chromium-installed
+.playwright-chromium-installed

.prettierrc

@@ -0,0 +1,11 @@
+{
+    "semi": false,
+    "singleQuote": true,
+    "trailingComma": "none",
+    "tabWidth": 4,
+    "useTabs": false,
+    "printWidth": 120,
+    "bracketSpacing": true,
+    "arrowParens": "avoid",
+    "endOfLine": "lf"
+}

Dockerfile

@@ -23,7 +23,7 @@ RUN rm -rf node_modules \
     && npm cache clean --force
 
 # Install Chromium Headless Shell, and cleanup
-RUN npx playwright install --with-deps --only-shell chromium \
+RUN npx patchright install --with-deps --only-shell chromium \
     && rm -rf /root/.cache /tmp/* /var/tmp/*
 
 ###############################################################################
@@ -80,9 +80,9 @@ COPY --from=builder /usr/src/microsoft-rewards-script/package*.json ./
 COPY --from=builder /usr/src/microsoft-rewards-script/node_modules ./node_modules
 
 # Copy runtime scripts with proper permissions from the start
-COPY --chmod=755 src/run_daily.sh ./src/run_daily.sh
+COPY --chmod=755 scripts/docker/run_daily.sh ./scripts/docker/run_daily.sh
 COPY --chmod=644 src/crontab.template /etc/cron.d/microsoft-rewards-cron.template
-COPY --chmod=755 entrypoint.sh /usr/local/bin/entrypoint.sh
+COPY --chmod=755 scripts/docker/entrypoint.sh /usr/local/bin/entrypoint.sh
 
 # Entrypoint handles TZ, initial run toggle, cron templating & launch
 ENTRYPOINT ["/usr/local/bin/entrypoint.sh"]

README.md

@@ -2,296 +2,7 @@
 
 ---
 
-## Table of Contents
-- [Setup](#setup)
-  - [1. Clone the Repository](#1-clone-the-repository)
-  - [2. Copy Configuration Files](#2-copy-configuration-files)
-  - [3. Install Dependencies and Prepare the Browser](#3-install-dependencies-and-prepare-the-browser)
-  - [4. Build and Run](#4-build-and-run)
-- [Nix Users](#nix-setup)
-- [Docker Setup](#docker-setup)
-  - [Before Starting](#before-starting)
-  - [Quick Start](#quick-start)
-  - [Example compose.yaml](#example-composeyaml)
-- [Configuration Reference](#configuration-reference)
-- [Account Configuration](#account-configuration)
-- [Features Overview](#features-overview)
-- [Disclaimer](#disclaimer)
-
----
-
-## Setup
-
-**Requirements:** Node.js ≥ 20 and Git  
-Works on Windows, Linux, macOS, and WSL.
-
----
-
-### 1. Clone the Repository
-**All systems:**
-```bash
-git clone https://github.com/TheNetsky/Microsoft-Rewards-Script.git
-cd Microsoft-Rewards-Script
-```
-Or download the latest release ZIP and extract it.
-
----
-
-### 2. Copy Configuration Files
-
-**Windows:**
-Rename manually:
-```
-src/accounts.example.json → src/accounts.json
-```
-
-**Linux / macOS / WSL:**
-```bash
-cp src/accounts.example.json src/accounts.json
-```
-
-Then edit:
-- `src/accounts.json` — fill in your Microsoft account credentials.  
-- `src/config.json` — review or customize options.
-
----
-
-### 3. Install Dependencies and Prepare the Browser
-
-**All systems:**
-```bash
-npm run pre-build
-```
-
-This command:
-- Installs all dependencies  
-- Clears old builds (`dist/`)  
-- Installs Playwright Chromium (required browser)
-
----
-
-### 4. Build and Run
-
-**All systems:**
-```bash
-npm run build
-npm run start
-```
-
----
-
-## Nix Setup
-
-If using Nix:
-
-1. Run the pre-build step first:
-   ```bash
-   npm run pre-build
-   ```
-
-2. Then start the script:
-   ```bash
-   ./run.sh
-   ```
-
-This will launch the script headlessly using `xvfb-run`.
-
----
-
-## Docker Setup
-
-### Before Starting
-- Remove local `/node_modules` and `/dist` if previously built.  
-- Remove old Docker volumes if upgrading from older versions.  
-- You can reuse your existing `accounts.json`.
-
----
-
-### Quick Start
-1. Clone the repository and configure your `accounts.json`.  
-2. Ensure `config.json` has `"headless": true`.  
-3. Edit `compose.yaml`:  
-   - Set your timezone (`TZ`)  
-   - Set the cron schedule (`CRON_SCHEDULE`)  
-   - Optionally enable `RUN_ON_START=true`  
-4. Start the container:
-   ```bash
-   docker compose up -d
-   ```
-5. Monitor logs:
-   ```bash
-   docker logs microsoft-rewards-script
-   ```
-
-The container includes a randomized delay (about 5–50 minutes by default)  
-before each scheduled run to appear more natural. This can be configured or disabled via environment variables.
-
----
-
-### Example compose.yaml
-
-```yaml
-services:
-  microsoft-rewards-script:
-    image: ghcr.io/your-org/microsoft-rewards-script:latest
-    container_name: microsoft-rewards-script
-    restart: unless-stopped
-
-    volumes:
-      - ./src/accounts.json:/usr/src/microsoft-rewards-script/dist/accounts.json:ro
-      - ./src/config.json:/usr/src/microsoft-rewards-script/dist/config.json:ro
-      - ./sessions:/usr/src/microsoft-rewards-script/dist/sessions
-      
-    environment:
-      TZ: "Europe/Amsterdam"
-      NODE_ENV: "production"
-      CRON_SCHEDULE: "0 7,16,20 * * *"
-      RUN_ON_START: "true"
-      # MIN_SLEEP_MINUTES: "5"
-      # MAX_SLEEP_MINUTES: "50"
-      # SKIP_RANDOM: "true"
-
-    deploy:
-      resources:
-        limits:
-          cpus: "1.0"
-          memory: "1g"
-```
-
-#### compose.yaml Notes
-- **volumes**  
-  - `accounts.json` and `config.json` are mounted read-only to prevent accidental edits.  
-  - `sessions` persists login sessions and fingerprints across runs.  
-  - If `jobState.enabled` is used, mount its directory as a volume.
-- **CRON_SCHEDULE**  
-  - Uses standard crontab syntax (e.g., via [crontab.guru](https://crontab.guru/)).  
-  - Schedule is evaluated inside the container using the configured `TZ`.
-- **RUN_ON_START**  
-  - Runs the script once immediately on startup, then continues on schedule.
-- **Randomization**  
-  - Default delay: 5–50 minutes.  
-  - Adjustable via `MIN_SLEEP_MINUTES` and `MAX_SLEEP_MINUTES`, or disable with `SKIP_RANDOM`.
-
----
-
-## Configuration Reference
-
-Edit `src/config.json` to customize behavior.  
-Below is a summary of available options (matches the latest version in the repository).
-
-### Core
-| Setting | Type | Default | Description |
-|----------|------|----------|-------------|
-| `baseURL` | string | `"https://rewards.bing.com"` | Microsoft Rewards base URL |
-| `sessionPath` | string | `"sessions"` | Directory to store browser sessions |
-| `headless` | boolean | `false` | Run browser invisibly |
-| `parallel` | boolean | `false` | Run desktop and mobile simultaneously |
-| `runOnZeroPoints` | boolean | `false` | Run even when no points are available |
-| `clusters` | number | `1` | Number of concurrent account clusters |
-| `globalTimeout` | string | `"30s"` | Timeout for all actions |
-| `searchOnBingLocalQueries` | boolean | `false` | Use local query list |
-
-### Fingerprinting
-| Setting | Type | Default | Description |
-|----------|------|----------|-------------|
-| `saveFingerprint.mobile` | boolean | `false` | Reuse mobile fingerprint |
-| `saveFingerprint.desktop` | boolean | `false` | Reuse desktop fingerprint |
-
-### Workers
-| Setting | Type | Default | Description |
-|----------|------|----------|-------------|
-| `doDailySet` | boolean | `true` | Complete daily set |
-| `doMorePromotions` | boolean | `true` | Complete more promotions |
-| `doPunchCards` | boolean | `true` | Complete punchcards |
-| `doDesktopSearch` | boolean | `true` | Perform desktop searches |
-| `doMobileSearch` | boolean | `true` | Perform mobile searches |
-| `doDailyCheckIn` | boolean | `true` | Complete daily check-in |
-| `doReadToEarn` | boolean | `true` | Complete Read-to-Earn |
-
-### Search
-| Setting | Type | Default | Description |
-|----------|------|----------|-------------|
-| `searchSettings.useGeoLocaleQueries` | boolean | `false` | Use region-based queries |
-| `searchSettings.scrollRandomResults` | boolean | `true` | Scroll randomly on results |
-| `searchSettings.clickRandomResults` | boolean | `true` | Click random links |
-| `searchSettings.searchDelay.min` | string | `"3min"` | Minimum delay between searches |
-| `searchSettings.searchDelay.max` | string | `"5min"` | Maximum delay between searches |
-| `searchSettings.retryMobileSearchAmount` | number | `2` | Retry mobile searches amount |
-
-### Logging
-| Setting | Type | Default | Description |
-|----------|------|----------|-------------|
-| `logExcludeFunc` | string[] | `["SEARCH-CLOSE-TABS"]` | Exclude from console logs |
-| `webhookLogExcludeFunc` | string[] | `["SEARCH-CLOSE-TABS"]` | Exclude from webhook logs |
-
-### Proxy
-| Setting | Type | Default | Description |
-|----------|------|----------|-------------|
-| `proxy.proxyGoogleTrends` | boolean | `true` | Proxy Google Trends requests |
-| `proxy.proxyBingTerms` | boolean | `true` | Proxy Bing term requests |
-
-### Webhooks
-| Setting | Type | Default | Description |
-|----------|------|----------|-------------|
-| `webhook.enabled` | boolean | `false` | Enable Discord webhook |
-| `webhook.url` | string | `""` | Webhook URL |
-| `conclusionWebhook.enabled` | boolean | `false` | Enable summary webhook |
-| `conclusionWebhook.url` | string | `""` | Summary webhook URL |
-
----
-
-## Account Configuration
-
-Edit `src/accounts.json` — the file is an **array** of accounts:
-
-```json
-[
-  {
-    "email": "email_1",
-    "password": "password_1",
-    "proxy": {
-      "proxyAxios": true,
-      "url": "",
-      "port": 0,
-      "username": "",
-      "password": ""
-    }
-  },
-  {
-    "email": "email_2",
-    "password": "password_2",
-    "proxy": {
-      "proxyAxios": true,
-      "url": "",
-      "port": 0,
-      "username": "",
-      "password": ""
-    }
-  }
-]
-```
-
-**Notes**
-- The file is a **flat array** — not `{ "accounts": [ ... ] }`.  
-- Only `email`, `password`, and `proxy` are supported.  
-- `proxyAxios` enables Axios-level proxying for API requests.
-
----
-
-## Features Overview
-
-- Multi-account and session handling  
-- Persistent browser fingerprints  
-- Parallel task execution  
-- Proxy and retry support  
-- Human-like behavior simulation  
-- Full daily set automation  
-- Mobile and desktop search support  
-- Vacation and risk protection  
-- Webhook notifications  
-- Docker scheduling support  
-
----
+TODO
 
 ## Disclaimer
 

compose.yaml

@@ -1,42 +1,42 @@
 services:
-  microsoft-rewards-script:
-    build: .
-    container_name: microsoft-rewards-script
-    restart: unless-stopped
+    microsoft-rewards-script:
+        build: .
+        container_name: microsoft-rewards-script
+        restart: unless-stopped
 
-    # Volume mounts: Specify a location where you want to save the files on your local machine.
-    volumes:
-      - ./src/accounts.json:/usr/src/microsoft-rewards-script/dist/accounts.json:ro
-      - ./src/config.json:/usr/src/microsoft-rewards-script/dist/config.json:ro
-      - ./sessions:/usr/src/microsoft-rewards-script/dist/browser/sessions # Optional, saves your login session
+        # Volume mounts: Specify a location where you want to save the files on your local machine.
+        volumes:
+            - ./src/accounts.json:/usr/src/microsoft-rewards-script/dist/accounts.json:ro
+            - ./src/config.json:/usr/src/microsoft-rewards-script/dist/config.json:ro
+            - ./sessions:/usr/src/microsoft-rewards-script/dist/browser/sessions # Optional, saves your login session
 
-    environment:
-      TZ: "America/Toronto" # Set your timezone for proper scheduling
-      NODE_ENV: "production"
-      CRON_SCHEDULE: "0 7,16,20 * * *" # Customize your schedule, use crontab.guru for formatting
-      RUN_ON_START: "true" # Runs the script immediately on container startup
+        environment:
+            TZ: 'America/Toronto' # Set your timezone for proper scheduling
+            NODE_ENV: 'production'
+            CRON_SCHEDULE: '0 7 * * *' # Customize your schedule, use crontab.guru for formatting
+            RUN_ON_START: 'true' # Runs the script immediately on container startup
 
-      # Add scheduled start-time randomization (uncomment to customize or disable, default: enabled)
-      #MIN_SLEEP_MINUTES: "5"
-      #MAX_SLEEP_MINUTES: "50"
-      SKIP_RANDOM_SLEEP: "false"
+            # Add scheduled start-time randomization (uncomment to customize or disable, default: enabled)
+            #MIN_SLEEP_MINUTES: "5"
+            #MAX_SLEEP_MINUTES: "50"
+            SKIP_RANDOM_SLEEP: 'false'
 
-      # Optionally set how long to wait before killing a stuck script run (prevents blocking future runs, default: 8 hours)
-      #STUCK_PROCESS_TIMEOUT_HOURS: "8"
+            # Optionally set how long to wait before killing a stuck script run (prevents blocking future runs, default: 8 hours)
+            #STUCK_PROCESS_TIMEOUT_HOURS: "8"
 
-    # Optional resource limits for the container
-    mem_limit: 4g
-    cpus: 2
+        # Optional resource limits for the container
+        mem_limit: 4g
+        cpus: 2
 
-    # Health check - monitors if cron daemon is running to ensure scheduled jobs can execute
-    # Container marked unhealthy if cron process dies
-    healthcheck:
-      test: ["CMD", "sh", "-c", "pgrep cron > /dev/null || exit 1"]
-      interval: 60s
-      timeout: 10s
-      retries: 3
-      start_period: 30s
-    
-    # Security hardening
-    security_opt:
-      - no-new-privileges:true
+        # Health check - monitors if cron daemon is running to ensure scheduled jobs can execute
+        # Container marked unhealthy if cron process dies
+        healthcheck:
+            test: ['CMD', 'sh', '-c', 'pgrep cron > /dev/null || exit 1']
+            interval: 60s
+            timeout: 10s
+            retries: 3
+            start_period: 30s
+
+        # Security hardening
+        security_opt:
+            - no-new-privileges:true

package.json

@@ -1,52 +1,59 @@
 {
-  "name": "microsoft-rewards-script",
-  "version": "1.5.3",
-  "description": "Automatically do tasks for Microsoft Rewards but in TS!",
-  "main": "index.js",
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "scripts": {
-    "pre-build": "npm i && rimraf dist && npx playwright install chromium",
-    "build": "tsc",
-    "start": "node ./dist/index.js",
-    "ts-start": "ts-node ./src/index.ts",
-    "dev": "ts-node ./src/index.ts -dev",
-    "kill-chrome-win": "powershell -Command \"Get-Process | Where-Object { $_.MainModule.FileVersionInfo.FileDescription -eq 'Google Chrome for Testing' } | ForEach-Object { Stop-Process -Id $_.Id -Force }\"",
-    "create-docker": "docker build -t microsoft-rewards-script-docker ."
-  },
-  "keywords": [
-    "Bing Rewards",
-    "Microsoft Rewards",
-    "Bot",
-    "Script",
-    "TypeScript",
-    "Playwright",
-    "Cheerio"
-  ],
-  "author": "Netsky",
-  "license": "ISC",
-  "devDependencies": {
-    "@types/node": "^20.14.11",
-    "@types/ms": "^0.7.34",
-    "@typescript-eslint/eslint-plugin": "^7.17.0",
-    "eslint": "^8.57.0",
-    "eslint-plugin-modules-newline": "^0.0.6",
-    "rimraf": "^6.0.1",
-    "typescript": "^5.5.4"
-  },
-  "dependencies": {
-    "axios": "^1.8.4",
-    "chalk": "^4.1.2",
-    "cheerio": "^1.0.0",
-    "fingerprint-generator": "^2.1.66",
-    "fingerprint-injector": "^2.1.66",
-    "http-proxy-agent": "^7.0.2",
-    "https-proxy-agent": "^7.0.6",
-    "ms": "^2.1.3",
-    "playwright": "1.52.0",
-    "rebrowser-playwright": "1.52.0",
-    "socks-proxy-agent": "^8.0.5",
-    "ts-node": "^10.9.2"
-  }
+    "name": "microsoft-rewards-script",
+    "version": "3.0.1",
+    "description": "Automatically do tasks for Microsoft Rewards but in TS!",
+    "author": "Netsky",
+    "license": "GPL-3.0-or-later",
+    "main": "dist/index.js",
+    "engines": {
+        "node": ">=18.0.0"
+    },
+    "scripts": {
+        "pre-build": "npm i && rimraf dist && npx patchright install chromium",
+        "build": "rimraf dist && tsc",
+        "start": "node ./dist/index.js",
+        "ts-start": "ts-node ./src/index.ts",
+        "dev": "ts-node ./src/index.ts -dev",
+        "kill-chrome-win": "powershell -Command \"Get-Process | Where-Object { $_.MainModule.FileVersionInfo.FileDescription -eq 'Google Chrome for Testing' } | ForEach-Object { Stop-Process -Id $_.Id -Force }\"",
+        "create-docker": "docker build -t microsoft-rewards-script-docker .",
+        "format": "prettier --write .",
+        "format:check": "prettier --check .",
+        "clear-sessions": "node ./scripts/clearSessions.js",
+        "clear-diagnostics": "rimraf diagnostics"
+    },
+    "keywords": [
+        "Bing Rewards",
+        "Microsoft Rewards",
+        "Bot",
+        "Script",
+        "TypeScript",
+        "Playwright",
+        "Cheerio"
+    ],
+    "devDependencies": {
+        "@types/ms": "^2.1.0",
+        "@types/node": "^24.10.1",
+        "@typescript-eslint/eslint-plugin": "^8.48.0",
+        "eslint": "^9.39.1",
+        "eslint-plugin-modules-newline": "^0.0.6",
+        "prettier": "^3.7.1",
+        "rimraf": "^6.1.2",
+        "typescript": "^5.9.3"
+    },
+    "dependencies": {
+        "axios": "^1.13.2",
+        "axios-retry": "^4.5.0",
+        "chalk": "^4.1.2",
+        "cheerio": "^1.0.0",
+        "fingerprint-generator": "^2.1.77",
+        "fingerprint-injector": "^2.1.77",
+        "ghost-cursor-playwright-port": "^1.4.3",
+        "http-proxy-agent": "^7.0.2",
+        "https-proxy-agent": "^7.0.6",
+        "ms": "^2.1.3",
+        "otpauth": "^9.4.1",
+        "p-queue": "^9.0.1",
+        "patchright": "^1.57.0",
+        "ts-node": "^10.9.2"
+    }
 }

scripts/clearSessions.js

@@ -0,0 +1,104 @@
+import fs from 'fs'
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+const projectRoot = path.resolve(__dirname, '..')
+
+const possibleConfigPaths = [
+    path.join(projectRoot, 'config.json'),
+    path.join(projectRoot, 'src', 'config.json'),
+    path.join(projectRoot, 'dist', 'config.json')
+]
+
+console.log('[DEBUG] Project root:', projectRoot)
+console.log('[DEBUG] Searching for config.json...')
+
+let configPath = null
+for (const p of possibleConfigPaths) {
+    console.log('[DEBUG] Checking:', p)
+    if (fs.existsSync(p)) {
+        configPath = p
+        console.log('[DEBUG] Found config at:', p)
+        break
+    }
+}
+
+if (!configPath) {
+    console.error('[ERROR] config.json not found in any expected location!')
+    console.error('[ERROR] Searched:', possibleConfigPaths)
+    process.exit(1)
+}
+
+console.log('[INFO] Using config:', configPath)
+const config = JSON.parse(fs.readFileSync(configPath, 'utf8'))
+
+if (!config.sessionPath) {
+    console.error("[ERROR] config.json missing 'sessionPath' key!")
+    process.exit(1)
+}
+
+console.log('[INFO] Session path from config:', config.sessionPath)
+
+const configDir = path.dirname(configPath)
+const possibleSessionDirs = [
+    path.resolve(configDir, config.sessionPath),
+    path.join(projectRoot, 'src/browser', config.sessionPath),
+    path.join(projectRoot, 'dist/browser', config.sessionPath)
+]
+
+console.log('[DEBUG] Searching for session directory...')
+
+let sessionDir = null
+for (const p of possibleSessionDirs) {
+    console.log('[DEBUG] Checking:', p)
+    if (fs.existsSync(p)) {
+        sessionDir = p
+        console.log('[DEBUG] Found session directory at:', p)
+        break
+    }
+}
+
+if (!sessionDir) {
+    sessionDir = path.resolve(configDir, config.sessionPath)
+    console.log('[DEBUG] Using fallback session directory:', sessionDir)
+}
+
+const normalizedSessionDir = path.normalize(sessionDir)
+const normalizedProjectRoot = path.normalize(projectRoot)
+
+if (!normalizedSessionDir.startsWith(normalizedProjectRoot)) {
+    console.error('[ERROR] Session directory is outside project root!')
+    console.error('[ERROR] Project root:', normalizedProjectRoot)
+    console.error('[ERROR] Session directory:', normalizedSessionDir)
+    process.exit(1)
+}
+
+if (normalizedSessionDir === normalizedProjectRoot) {
+    console.error('[ERROR] Session directory cannot be the project root!')
+    process.exit(1)
+}
+
+const pathSegments = normalizedSessionDir.split(path.sep)
+if (pathSegments.length < 3) {
+    console.error('[ERROR] Session path is too shallow (safety check failed)!')
+    console.error('[ERROR] Path:', normalizedSessionDir)
+    process.exit(1)
+}
+
+if (fs.existsSync(sessionDir)) {
+    console.log('[INFO] Removing session folder:', sessionDir)
+    try {
+        fs.rmSync(sessionDir, { recursive: true, force: true })
+        console.log('[SUCCESS] Session folder removed successfully')
+    } catch (error) {
+        console.error('[ERROR] Failed to remove session folder:', error.message)
+        process.exit(1)
+    }
+} else {
+    console.log('[INFO] Session folder does not exist:', sessionDir)
+}
+
+console.log('[INFO] Done.')

scripts/docker/entrypoint.sh

@@ -26,7 +26,7 @@ if [ "${RUN_ON_START:-false}" = "true" ]; then
       exit 1
     }
     # Skip random sleep for initial run, but preserve setting for cron jobs
-    SKIP_RANDOM_SLEEP=true src/run_daily.sh
+    SKIP_RANDOM_SLEEP=true scripts/docker/run_daily.sh
     echo "[entrypoint-bg] Initial run completed at $(date)"
   ) &
   echo "[entrypoint] Background process started (PID: $!)"

scripts/docker/run_daily.sh

@@ -1,7 +1,6 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
-export PATH="/usr/local/bin:/usr/bin:/bin"
 export PLAYWRIGHT_BROWSERS_PATH=0
 export TZ="${TZ:-UTC}"
 

src/accounts.example.json

@@ -2,6 +2,8 @@
     {
         "email": "email_1",
         "password": "password_1",
+        "totp": "",
+        "geoLocale": "auto",
         "proxy": {
             "proxyAxios": true,
             "url": "",
@@ -13,6 +15,8 @@
     {
         "email": "email_2",
         "password": "password_2",
+        "totp": "",
+        "geoLocale": "auto",
         "proxy": {
             "proxyAxios": true,
             "url": "",
@@ -21,4 +25,4 @@
             "password": ""
         }
     }
-]
+]

src/browser/Browser.ts

@@ -1,13 +1,13 @@
-import playwright, { BrowserContext } from 'rebrowser-playwright'
+import rebrowser, { BrowserContext } from 'patchright'
 
 import { newInjectedContext } from 'fingerprint-injector'
-import { FingerprintGenerator } from 'fingerprint-generator'
+import { BrowserFingerprintWithHeaders, FingerprintGenerator } from 'fingerprint-generator'
 
-import { MicrosoftRewardsBot } from '../index'
+import type { MicrosoftRewardsBot } from '../index'
 import { loadSessionData, saveFingerprintData } from '../util/Load'
-import { updateFingerprintUserAgent } from '../util/UserAgent'
+import { UserAgentManager } from './UserAgent'
 
-import { AccountProxy } from '../interface/Account'
+import type { AccountProxy } from '../interface/Account'
 
 /* Test Stuff
 https://abrahamjuliot.github.io/creepjs/
@@ -24,50 +24,67 @@ class Browser {
         this.bot = bot
     }
 
-    async createBrowser(proxy: AccountProxy, email: string): Promise<BrowserContext> {
-        // Optional automatic browser installation (set AUTO_INSTALL_BROWSERS=1)
-        if (process.env.AUTO_INSTALL_BROWSERS === '1') {
-            try {
-                // Dynamically import child_process to avoid overhead otherwise
-                const { execSync } = await import('child_process') as any
-                execSync('npx playwright install chromium', { stdio: 'ignore' })
-            } catch { /* silent */ }
-        }
-
-        let browser: any
+    async createBrowser(
+        proxy: AccountProxy,
+        email: string
+    ): Promise<{
+        context: BrowserContext
+        fingerprint: BrowserFingerprintWithHeaders
+    }> {
+        let browser: rebrowser.Browser
         try {
-            browser = await playwright.chromium.launch({
-                //channel: 'msedge', // Uses Edge instead of chrome
+            browser = await rebrowser.chromium.launch({
                 headless: this.bot.config.headless,
-                ...(proxy.url && { proxy: { username: proxy.username, password: proxy.password, server: `${proxy.url}:${proxy.port}` } }),
+                ...(proxy.url && {
+                    proxy: { username: proxy.username, password: proxy.password, server: `${proxy.url}:${proxy.port}` }
+                }),
                 args: [
                     '--no-sandbox',
                     '--mute-audio',
                     '--disable-setuid-sandbox',
                     '--ignore-certificate-errors',
                     '--ignore-certificate-errors-spki-list',
-                    '--ignore-ssl-errors'
+                    '--ignore-ssl-errors',
+                    '--no-first-run',
+                    '--no-default-browser-check',
+                    '--disable-user-media-security=true',
+                    '--disable-blink-features=Attestation',
+                    '--disable-features=WebAuthentication,PasswordManagerOnboarding,PasswordManager,EnablePasswordsAccountStorage,Passkeys',
+                    '--disable-save-password-bubble'
                 ]
             })
-        } catch (e: any) {
-            const msg = (e instanceof Error ? e.message : String(e))
-            // Common missing browser executable guidance
-            if (/Executable doesn't exist/i.test(msg)) {
-                this.bot.log(this.bot.isMobile, 'BROWSER', 'Chromium not installed for Playwright. Run: "npx playwright install chromium" (or set AUTO_INSTALL_BROWSERS=1 to auto attempt).', 'error')
-            } else {
-                this.bot.log(this.bot.isMobile, 'BROWSER', 'Failed to launch browser: ' + msg, 'error')
-            }
-            throw e
+        } catch (error) {
+            this.bot.logger.error(
+                this.bot.isMobile,
+                'BROWSER',
+                `Launch failed: ${error instanceof Error ? error.message : String(error)}`
+            )
+            throw error
         }
 
-        const sessionData = await loadSessionData(this.bot.config.sessionPath, email, this.bot.isMobile, this.bot.config.saveFingerprint)
+        const sessionData = await loadSessionData(
+            this.bot.config.sessionPath,
+            email,
+            this.bot.config.saveFingerprint,
+            this.bot.isMobile
+        )
 
-        const fingerprint = sessionData.fingerprint ? sessionData.fingerprint : await this.generateFingerprint()
+        const fingerprint = sessionData.fingerprint
+            ? sessionData.fingerprint
+            : await this.generateFingerprint(this.bot.isMobile)
 
         const context = await newInjectedContext(browser as any, { fingerprint: fingerprint })
 
-        // Set timeout to preferred amount
-        context.setDefaultTimeout(this.bot.utils.stringToMs(this.bot.config?.globalTimeout ?? 30000))
+        await context.addInitScript(() => {
+            Object.defineProperty(navigator, 'credentials', {
+                value: {
+                    create: () => Promise.reject(new Error('WebAuthn disabled')),
+                    get: () => Promise.reject(new Error('WebAuthn disabled'))
+                }
+            })
+        })
+
+        context.setDefaultTimeout(this.bot.utils.stringToNumber(this.bot.config?.globalTimeout ?? 30000))
 
         await context.addCookies(sessionData.cookies)
 
@@ -75,22 +92,32 @@ class Browser {
             await saveFingerprintData(this.bot.config.sessionPath, email, this.bot.isMobile, fingerprint)
         }
 
-        this.bot.log(this.bot.isMobile, 'BROWSER', `Created browser with User-Agent: "${fingerprint.fingerprint.navigator.userAgent}"`)
+        this.bot.logger.info(
+            this.bot.isMobile,
+            'BROWSER',
+            `Created browser with User-Agent: "${fingerprint.fingerprint.navigator.userAgent}"`
+        )
 
-        return context as BrowserContext
+        this.bot.logger.debug(this.bot.isMobile, 'BROWSER-FINGERPRINT', JSON.stringify(fingerprint))
+
+        return {
+            context: context as unknown as BrowserContext,
+            fingerprint: fingerprint
+        }
     }
 
-    async generateFingerprint() {
+    async generateFingerprint(isMobile: boolean) {
         const fingerPrintData = new FingerprintGenerator().getFingerprint({
-            devices: this.bot.isMobile ? ['mobile'] : ['desktop'],
-            operatingSystems: this.bot.isMobile ? ['android'] : ['windows'],
+            devices: isMobile ? ['mobile'] : ['desktop'],
+            operatingSystems: isMobile ? ['android', 'ios'] : ['windows', 'linux'],
             browsers: [{ name: 'edge' }]
         })
 
-        const updatedFingerPrintData = await updateFingerprintUserAgent(fingerPrintData, this.bot.isMobile)
+        const userAgentManager = new UserAgentManager(this.bot)
+        const updatedFingerPrintData = await userAgentManager.updateFingerprintUserAgent(fingerPrintData, isMobile)
 
         return updatedFingerPrintData
     }
 }
 
-export default Browser
+export default Browser

src/browser/BrowserFunc.ts

@@ -1,15 +1,14 @@
-import { BrowserContext, Page } from 'rebrowser-playwright'
-import { CheerioAPI, load } from 'cheerio'
-import { AxiosRequestConfig } from 'axios'
+import type { BrowserContext, Cookie } from 'patchright'
+import type { AxiosRequestConfig, AxiosResponse } from 'axios'
 
-import { MicrosoftRewardsBot } from '../index'
+import type { MicrosoftRewardsBot } from '../index'
 import { saveSessionData } from '../util/Load'
 
-import { Counters, DashboardData, MorePromotion, PromotionalItem } from './../interface/DashboardData'
-import { QuizData } from './../interface/QuizData'
-import { AppUserData } from '../interface/AppUserData'
-import { EarnablePoints } from '../interface/Points'
-
+import type { Counters, DashboardData } from './../interface/DashboardData'
+import type { AppUserData } from '../interface/AppUserData'
+import type { XboxDashboardData } from '../interface/XboxDashboardData'
+import type { AppEarnablePoints, BrowserEarnablePoints, MissingSearchPoints } from '../interface/Points'
+import type { AppDashboardData } from '../interface/AppDashBoardData'
 
 export default class BrowserFunc {
     private bot: MicrosoftRewardsBot
@@ -18,187 +17,154 @@ export default class BrowserFunc {
         this.bot = bot
     }
 
-
     /**
-     * Navigate the provided page to rewards homepage
-     * @param {Page} page Playwright page
-    */
-    async goHome(page: Page) {
-
+     * Fetch user desktop dashboard data
+     * @returns {DashboardData} Object of user bing rewards dashboard data
+     */
+    async getDashboardData(): Promise<DashboardData> {
         try {
-            const dashboardURL = new URL(this.bot.config.baseURL)
+            const cookieHeader = this.bot.cookies.mobile
+                .map((c: { name: string; value: string }) => `${c.name}=${c.value}`)
+                .join('; ')
 
-            if (page.url() === dashboardURL.href) {
-                return
-            }
-
-            await page.goto(this.bot.config.baseURL)
-
-            const maxIterations = 5 // Maximum iterations set to 5
-
-            for (let iteration = 1; iteration <= maxIterations; iteration++) {
-                await this.bot.utils.wait(3000)
-                await this.bot.browser.utils.tryDismissAllMessages(page)
-
-                // Check if account is suspended
-                const isSuspended = await page.waitForSelector('#suspendedAccountHeader', { state: 'visible', timeout: 2000 }).then(() => true).catch(() => false)
-                if (isSuspended) {
-                    this.bot.log(this.bot.isMobile, 'GO-HOME', 'This account is suspended!', 'error')
-                    throw new Error('Account has been suspended!')
-                }
-
-                try {
-                    // If activities are found, exit the loop
-                    await page.waitForSelector('#more-activities', { timeout: 1000 })
-                    this.bot.log(this.bot.isMobile, 'GO-HOME', 'Visited homepage successfully')
-                    break
-
-                } catch (error) {
-                    // Continue if element is not found
-                }
-
-                // Below runs if the homepage was unable to be visited
-                const currentURL = new URL(page.url())
-
-                if (currentURL.hostname !== dashboardURL.hostname) {
-                    await this.bot.browser.utils.tryDismissAllMessages(page)
-
-                    await this.bot.utils.wait(2000)
-                    await page.goto(this.bot.config.baseURL)
-                } else {
-                    this.bot.log(this.bot.isMobile, 'GO-HOME', 'Visited homepage successfully')
-                    break
-                }
-
-                await this.bot.utils.wait(5000)
+            const request: AxiosRequestConfig = {
+                url: `https://rewards.bing.com/api/getuserinfo?type=1&X-Requested-With=XMLHttpRequest&_=${Date.now()}`,
+                method: 'GET',
+                headers: {
+                    ...(this.bot.fingerprint?.headers ?? {}),
+                    Cookie: cookieHeader,
+                    Referer: 'https://rewards.bing.com/',
+                    Origin: 'https://rewards.bing.com'
+                }
             }
 
+            const response = await this.bot.axios.request(request)
+            return response.data.dashboard as DashboardData
         } catch (error) {
-            throw this.bot.log(this.bot.isMobile, 'GO-HOME', 'An error occurred:' + error, 'error')
+            this.bot.logger.info(
+                this.bot.isMobile,
+                'GET-DASHBOARD-DATA',
+                `Error fetching dashboard data: ${error instanceof Error ? error.message : String(error)}`
+            )
+            throw error
         }
     }
 
     /**
-     * Fetch user dashboard data
-     * @returns {DashboardData} Object of user bing rewards dashboard data
-    */
-    async getDashboardData(): Promise<DashboardData> {
-        const dashboardURL = new URL(this.bot.config.baseURL)
-        const currentURL = new URL(this.bot.homePage.url())
-
+     * Fetch user app dashboard data
+     * @returns {AppDashboardData} Object of user bing rewards dashboard data
+     */
+    async getAppDashboardData(): Promise<AppDashboardData> {
         try {
-            // Should never happen since tasks are opened in a new tab!
-            if (currentURL.hostname !== dashboardURL.hostname) {
-                this.bot.log(this.bot.isMobile, 'DASHBOARD-DATA', 'Provided page did not equal dashboard page, redirecting to dashboard page')
-                await this.goHome(this.bot.homePage)
-            }
-            let lastError: any = null
-            for (let attempt = 1; attempt <= 2; attempt++) {
-                try {
-                    // Reload the page to get new data
-                    await this.bot.homePage.reload({ waitUntil: 'domcontentloaded' })
-                    lastError = null
-                    break
-                } catch (re) {
-                    lastError = re
-                    const msg = (re instanceof Error ? re.message : String(re))
-                    this.bot.log(this.bot.isMobile, 'GET-DASHBOARD-DATA', `Reload failed attempt ${attempt}: ${msg}`, 'warn')
-                    // If page/context closed => bail early after first retry
-                    if (msg.includes('has been closed')) {
-                        if (attempt === 1) {
-                            this.bot.log(this.bot.isMobile, 'GET-DASHBOARD-DATA', 'Page appears closed; trying one navigation fallback', 'warn')
-                            try {
-                                await this.goHome(this.bot.homePage)
-                            } catch {/* ignore */}
-                        } else {
-                            break
-                        }
-                    }
-                    if (attempt === 2 && lastError) throw lastError
-                    await this.bot.utils.wait(1000)
+            const request: AxiosRequestConfig = {
+                url: 'https://prod.rewardsplatform.microsoft.com/dapi/me?channel=SAIOS&options=613',
+                method: 'GET',
+                headers: {
+                    Authorization: `Bearer ${this.bot.accessToken}`,
+                    'User-Agent':
+                        'Bing/32.5.431027001 (com.microsoft.bing; build:431027001; iOS 17.6.1) Alamofire/5.10.2'
                 }
             }
 
-            const scriptContent = await this.bot.homePage.evaluate(() => {
-                const scripts = Array.from(document.querySelectorAll('script'))
-                const targetScript = scripts.find(script => script.innerText.includes('var dashboard'))
-
-                return targetScript?.innerText ? targetScript.innerText : null
-            })
-
-            if (!scriptContent) {
-                throw this.bot.log(this.bot.isMobile, 'GET-DASHBOARD-DATA', 'Dashboard data not found within script', 'error')
-            }
-
-            // Extract the dashboard object from the script content
-            const dashboardData = await this.bot.homePage.evaluate((scriptContent: string) => {
-                // Extract the dashboard object using regex
-                const regex = /var dashboard = (\{.*?\});/s
-                const match = regex.exec(scriptContent)
-
-                if (match && match[1]) {
-                    return JSON.parse(match[1])
-                }
-
-            }, scriptContent)
-
-            if (!dashboardData) {
-                throw this.bot.log(this.bot.isMobile, 'GET-DASHBOARD-DATA', 'Unable to parse dashboard script', 'error')
-            }
-
-            return dashboardData
-
+            const response = await this.bot.axios.request(request)
+            return response.data as AppDashboardData
         } catch (error) {
-            throw this.bot.log(this.bot.isMobile, 'GET-DASHBOARD-DATA', `Error fetching dashboard data: ${error}`, 'error')
+            this.bot.logger.info(
+                this.bot.isMobile,
+                'GET-APP-DASHBOARD-DATA',
+                `Error fetching dashboard data: ${error instanceof Error ? error.message : String(error)}`
+            )
+            throw error
         }
+    }
 
+    /**
+     * Fetch user xbox dashboard data
+     * @returns {XboxDashboardData} Object of user bing rewards dashboard data
+     */
+    async getXBoxDashboardData(): Promise<XboxDashboardData> {
+        try {
+            const request: AxiosRequestConfig = {
+                url: 'https://prod.rewardsplatform.microsoft.com/dapi/me?channel=xboxapp&options=6',
+                method: 'GET',
+                headers: {
+                    Authorization: `Bearer ${this.bot.accessToken}`,
+                    'User-Agent':
+                        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; Xbox; Xbox One X) AppleWebKit/537.36 (KHTML, like Gecko) Edge/18.19041'
+                }
+            }
+
+            const response = await this.bot.axios.request(request)
+            return response.data as XboxDashboardData
+        } catch (error) {
+            this.bot.logger.info(
+                this.bot.isMobile,
+                'GET-XBOX-DASHBOARD-DATA',
+                `Error fetching dashboard data: ${error instanceof Error ? error.message : String(error)}`
+            )
+            throw error
+        }
     }
 
     /**
      * Get search point counters
-     * @returns {Counters} Object of search counter data
-    */
+     */
     async getSearchPoints(): Promise<Counters> {
         const dashboardData = await this.getDashboardData() // Always fetch newest data
 
         return dashboardData.userStatus.counters
     }
 
+    missingSearchPoints(counters: Counters, isMobile: boolean): MissingSearchPoints {
+        const mobileData = counters.mobileSearch?.[0]
+        const desktopData = counters.pcSearch?.[0]
+        const edgeData = counters.pcSearch?.[1]
+
+        const mobilePoints = mobileData ? Math.max(0, mobileData.pointProgressMax - mobileData.pointProgress) : 0
+        const desktopPoints = desktopData ? Math.max(0, desktopData.pointProgressMax - desktopData.pointProgress) : 0
+        const edgePoints = edgeData ? Math.max(0, edgeData.pointProgressMax - edgeData.pointProgress) : 0
+
+        const totalPoints = isMobile ? mobilePoints : desktopPoints + edgePoints
+
+        return { mobilePoints, desktopPoints, edgePoints, totalPoints }
+    }
+
     /**
      * Get total earnable points with web browser
-     * @returns {number} Total earnable points
-    */
-    async getBrowserEarnablePoints(): Promise<EarnablePoints> {
+     */
+    async getBrowserEarnablePoints(): Promise<BrowserEarnablePoints> {
         try {
-            let desktopSearchPoints = 0
-            let mobileSearchPoints = 0
-            let dailySetPoints = 0
-            let morePromotionsPoints = 0
-
             const data = await this.getDashboardData()
 
-            // Desktop Search Points
-            if (data.userStatus.counters.pcSearch?.length) {
-                data.userStatus.counters.pcSearch.forEach(x => desktopSearchPoints += (x.pointProgressMax - x.pointProgress))
-            }
+            const desktopSearchPoints =
+                data.userStatus.counters.pcSearch?.reduce(
+                    (sum, x) => sum + (x.pointProgressMax - x.pointProgress),
+                    0
+                ) ?? 0
 
-            // Mobile Search Points
-            if (data.userStatus.counters.mobileSearch?.length) {
-                data.userStatus.counters.mobileSearch.forEach(x => mobileSearchPoints += (x.pointProgressMax - x.pointProgress))
-            }
+            const mobileSearchPoints =
+                data.userStatus.counters.mobileSearch?.reduce(
+                    (sum, x) => sum + (x.pointProgressMax - x.pointProgress),
+                    0
+                ) ?? 0
 
-            // Daily Set
-            data.dailySetPromotions[this.bot.utils.getFormattedDate()]?.forEach(x => dailySetPoints += (x.pointProgressMax - x.pointProgress))
+            const todayDate = this.bot.utils.getFormattedDate()
+            const dailySetPoints =
+                data.dailySetPromotions[todayDate]?.reduce(
+                    (sum, x) => sum + (x.pointProgressMax - x.pointProgress),
+                    0
+                ) ?? 0
 
-            // More Promotions
-            if (data.morePromotions?.length) {
-                data.morePromotions.forEach(x => {
-                    // Only count points from supported activities
-                    if (['quiz', 'urlreward'].includes(x.promotionType) && x.exclusiveLockedFeatureStatus !== 'locked') {
-                        morePromotionsPoints += (x.pointProgressMax - x.pointProgress)
+            const morePromotionsPoints =
+                data.morePromotions?.reduce((sum, x) => {
+                    if (
+                        ['quiz', 'urlreward'].includes(x.promotionType) &&
+                        x.exclusiveLockedFeatureStatus !== 'locked'
+                    ) {
+                        return sum + (x.pointProgressMax - x.pointProgress)
                     }
-                })
-            }
+                    return sum
+                }, 0) ?? 0
 
             const totalEarnablePoints = desktopSearchPoints + mobileSearchPoints + dailySetPoints + morePromotionsPoints
 
@@ -210,174 +176,258 @@ export default class BrowserFunc {
                 totalEarnablePoints
             }
         } catch (error) {
-            throw this.bot.log(this.bot.isMobile, 'GET-BROWSER-EARNABLE-POINTS', 'An error occurred:' + error, 'error')
+            this.bot.logger.error(
+                this.bot.isMobile,
+                'GET-BROWSER-EARNABLE-POINTS',
+                `An error occurred: ${error instanceof Error ? error.message : String(error)}`
+            )
+            throw error
         }
     }
 
     /**
      * Get total earnable points with mobile app
-     * @returns {number} Total earnable points
-    */
-    async getAppEarnablePoints(accessToken: string) {
+     */
+    async getAppEarnablePoints(): Promise<AppEarnablePoints> {
         try {
-            const points = {
-                readToEarn: 0,
-                checkIn: 0,
-                totalEarnablePoints: 0
-            }
+            const eligibleOffers = ['ENUS_readarticle3_30points', 'Gamification_Sapphire_DailyCheckIn']
 
-            const eligibleOffers = [
-                'ENUS_readarticle3_30points',
-                'Gamification_Sapphire_DailyCheckIn'
-            ]
-
-            const data = await this.getDashboardData()
-            let geoLocale = data.userProfile.attributes.country
-            geoLocale = (this.bot.config.searchSettings.useGeoLocaleQueries && geoLocale.length === 2) ? geoLocale.toLowerCase() : 'us'
-
-            const userDataRequest: AxiosRequestConfig = {
+            const request: AxiosRequestConfig = {
                 url: 'https://prod.rewardsplatform.microsoft.com/dapi/me?channel=SAAndroid&options=613',
                 method: 'GET',
                 headers: {
-                    'Authorization': `Bearer ${accessToken}`,
-                    'X-Rewards-Country': geoLocale,
-                    'X-Rewards-Language': 'en'
+                    Authorization: `Bearer ${this.bot.accessToken}`,
+                    'X-Rewards-Country': this.bot.userData.geoLocale,
+                    'X-Rewards-Language': 'en',
+                    'X-Rewards-ismobile': 'true'
                 }
             }
 
-            const userDataResponse: AppUserData = (await this.bot.axios.request(userDataRequest)).data
-            const userData = userDataResponse.response
-            const eligibleActivities = userData.promotions.filter((x) => eligibleOffers.includes(x.attributes.offerid ?? ''))
+            const response = await this.bot.axios.request(request)
+            const userData: AppUserData = response.data
+            const eligibleActivities = userData.response.promotions.filter(x =>
+                eligibleOffers.includes(x.attributes.offerid ?? '')
+            )
+
+            let readToEarn = 0
+            let checkIn = 0
 
             for (const item of eligibleActivities) {
-                if (item.attributes.type === 'msnreadearn') {
-                    points.readToEarn = parseInt(item.attributes.pointmax ?? '') - parseInt(item.attributes.pointprogress ?? '')
-                    break
-                } else if (item.attributes.type === 'checkin') {
-                    const checkInDay = parseInt(item.attributes.progress ?? '') % 7
+                const attrs = item.attributes
 
-                    if (checkInDay < 6 && (new Date()).getDate() != (new Date(item.attributes.last_updated ?? '')).getDate()) {
-                        points.checkIn = parseInt(item.attributes['day_' + (checkInDay + 1) + '_points'] ?? '')
+                if (attrs.type === 'msnreadearn') {
+                    const pointMax = parseInt(attrs.pointmax ?? '0')
+                    const pointProgress = parseInt(attrs.pointprogress ?? '0')
+                    readToEarn = Math.max(0, pointMax - pointProgress)
+                } else if (attrs.type === 'checkin') {
+                    const progress = parseInt(attrs.progress ?? '0')
+                    const checkInDay = progress % 7
+                    const lastUpdated = new Date(attrs.last_updated ?? '')
+                    const today = new Date()
+
+                    if (checkInDay < 6 && today.getDate() !== lastUpdated.getDate()) {
+                        checkIn = parseInt(attrs[`day_${checkInDay + 1}_points`] ?? '0')
                     }
-                    break
                 }
             }
 
-            points.totalEarnablePoints = points.readToEarn + points.checkIn
+            const totalEarnablePoints = readToEarn + checkIn
 
-            return points
+            return {
+                readToEarn,
+                checkIn,
+                totalEarnablePoints
+            }
         } catch (error) {
-            throw this.bot.log(this.bot.isMobile, 'GET-APP-EARNABLE-POINTS', 'An error occurred:' + error, 'error')
+            this.bot.logger.error(
+                this.bot.isMobile,
+                'GET-APP-EARNABLE-POINTS',
+                `An error occurred: ${error instanceof Error ? error.message : String(error)}`
+            )
+            throw error
         }
     }
-
     /**
      * Get current point amount
      * @returns {number} Current total point amount
-    */
+     */
     async getCurrentPoints(): Promise<number> {
         try {
             const data = await this.getDashboardData()
 
             return data.userStatus.availablePoints
         } catch (error) {
-            throw this.bot.log(this.bot.isMobile, 'GET-CURRENT-POINTS', 'An error occurred:' + error, 'error')
+            this.bot.logger.error(
+                this.bot.isMobile,
+                'GET-CURRENT-POINTS',
+                `An error occurred: ${error instanceof Error ? error.message : String(error)}`
+            )
+            throw error
         }
     }
 
-    /**
-     * Parse quiz data from provided page
-     * @param {Page} page Playwright page
-     * @returns {QuizData} Quiz data object
-    */
-    async getQuizData(page: Page): Promise<QuizData> {
-        try {
-            const html = await page.content()
-            const $ = load(html)
-
-            const scriptContent = $('script').filter((index: number, element: any) => {
-                return $(element).text().includes('_w.rewardsQuizRenderInfo')
-            }).text()
-
-            if (scriptContent) {
-                const regex = /_w\.rewardsQuizRenderInfo\s*=\s*({.*?});/s
-                const match = regex.exec(scriptContent)
-
-                if (match && match[1]) {
-                    const quizData = JSON.parse(match[1])
-                    return quizData
-                } else {
-                    throw this.bot.log(this.bot.isMobile, 'GET-QUIZ-DATA', 'Quiz data not found within script', 'error')
-                }
-            } else {
-                throw this.bot.log(this.bot.isMobile, 'GET-QUIZ-DATA', 'Script containing quiz data not found', 'error')
-            }
-
-        } catch (error) {
-            throw this.bot.log(this.bot.isMobile, 'GET-QUIZ-DATA', 'An error occurred:' + error, 'error')
-        }
-
-    }
-
-    async waitForQuizRefresh(page: Page): Promise<boolean> {
-        try {
-            await page.waitForSelector('span.rqMCredits', { state: 'visible', timeout: 10000 })
-            await this.bot.utils.wait(2000)
-
-            return true
-        } catch (error) {
-            this.bot.log(this.bot.isMobile, 'QUIZ-REFRESH', 'An error occurred:' + error, 'error')
-            return false
-        }
-    }
-
-    async checkQuizCompleted(page: Page): Promise<boolean> {
-        try {
-            await page.waitForSelector('#quizCompleteContainer', { state: 'visible', timeout: 2000 })
-            await this.bot.utils.wait(2000)
-
-            return true
-        } catch (error) {
-            return false
-        }
-    }
-
-    async loadInCheerio(page: Page): Promise<CheerioAPI> {
-        const html = await page.content()
-        const $ = load(html)
-
-        return $
-    }
-
-    async getPunchCardActivity(page: Page, activity: PromotionalItem | MorePromotion): Promise<string> {
-        let selector = ''
-        try {
-            const html = await page.content()
-            const $ = load(html)
-
-            const element = $('.offer-cta').toArray().find((x: any) => x.attribs.href?.includes(activity.offerId))
-            if (element) {
-                selector = `a[href*="${element.attribs.href}"]`
-            }
-        } catch (error) {
-            this.bot.log(this.bot.isMobile, 'GET-PUNCHCARD-ACTIVITY', 'An error occurred:' + error, 'error')
-        }
-
-        return selector
-    }
-
     async closeBrowser(browser: BrowserContext, email: string) {
         try {
+            const cookies = await browser.cookies()
+
             // Save cookies
-            await saveSessionData(this.bot.config.sessionPath, browser, email, this.bot.isMobile)
+            this.bot.logger.debug(
+                this.bot.isMobile,
+                'CLOSE-BROWSER',
+                `Saving ${cookies.length} cookies to session folder!`
+            )
+            await saveSessionData(this.bot.config.sessionPath, cookies, email, this.bot.isMobile)
 
             await this.bot.utils.wait(2000)
 
             // Close browser
             await browser.close()
-            this.bot.log(this.bot.isMobile, 'CLOSE-BROWSER', 'Browser closed cleanly!')
+            this.bot.logger.info(this.bot.isMobile, 'CLOSE-BROWSER', 'Browser closed cleanly!')
         } catch (error) {
-            throw this.bot.log(this.bot.isMobile, 'CLOSE-BROWSER', 'An error occurred:' + error, 'error')
+            this.bot.logger.error(
+                this.bot.isMobile,
+                'CLOSE-BROWSER',
+                `An error occurred: ${error instanceof Error ? error.message : String(error)}`
+            )
+            throw error
         }
     }
-}
+
+    mergeCookies(response: AxiosResponse, currentCookieHeader: string = '', whitelist?: string[]): string {
+        const cookieMap = new Map<string, string>(
+            currentCookieHeader
+                .split(';')
+                .map(pair => pair.split('=').map(s => s.trim()))
+                .filter(([name, value]) => name && value)
+                .map(([name, value]) => [name, value] as [string, string])
+        )
+
+        const setCookieList = [response.headers['set-cookie']].flat().filter(Boolean) as string[]
+        const cookiesByName = new Map(this.bot.cookies.mobile.map(c => [c.name, c]))
+
+        for (const setCookie of setCookieList) {
+            const [nameValue, ...attributes] = setCookie.split(';').map(s => s.trim())
+            if (!nameValue) continue
+
+            const [name, value] = nameValue.split('=').map(s => s.trim())
+
+            if (!name) continue
+
+            if (whitelist && !whitelist?.includes(name)) {
+                continue
+            }
+
+            const attrs = this.parseAttributes(attributes)
+            const existing = cookiesByName.get(name)
+
+            if (!value) {
+                if (existing) {
+                    cookiesByName.delete(name)
+                    this.bot.cookies.mobile = this.bot.cookies.mobile.filter(c => c.name !== name)
+                }
+                cookieMap.delete(name)
+                continue
+            }
+
+            if (attrs.expires !== undefined && attrs.expires < Date.now() / 1000) {
+                if (existing) {
+                    cookiesByName.delete(name)
+                    this.bot.cookies.mobile = this.bot.cookies.mobile.filter(c => c.name !== name)
+                }
+                cookieMap.delete(name)
+                continue
+            }
+
+            cookieMap.set(name, value)
+
+            if (existing) {
+                this.updateCookie(existing, value, attrs)
+            } else {
+                this.bot.cookies.mobile.push(this.createCookie(name, value, attrs))
+            }
+        }
+
+        return Array.from(cookieMap, ([name, value]) => `${name}=${value}`).join('; ')
+    }
+
+    private parseAttributes(attributes: string[]) {
+        const attrs: {
+            domain?: string
+            path?: string
+            expires?: number
+            httpOnly?: boolean
+            secure?: boolean
+            sameSite?: Cookie['sameSite']
+        } = {}
+
+        for (const attr of attributes) {
+            const [key, val] = attr.split('=').map(s => s?.trim())
+            const lowerKey = key?.toLowerCase()
+
+            switch (lowerKey) {
+                case 'domain':
+                case 'path': {
+                    if (val) attrs[lowerKey] = val
+                    break
+                }
+                case 'expires': {
+                    if (val) {
+                        const ts = Date.parse(val)
+                        if (!isNaN(ts)) attrs.expires = Math.floor(ts / 1000)
+                    }
+                    break
+                }
+                case 'max-age': {
+                    if (val) {
+                        const maxAge = Number(val)
+                        if (!isNaN(maxAge)) attrs.expires = Math.floor(Date.now() / 1000) + maxAge
+                    }
+                    break
+                }
+                case 'httponly': {
+                    attrs.httpOnly = true
+                    break
+                }
+                case 'secure': {
+                    attrs.secure = true
+                    break
+                }
+                case 'samesite': {
+                    const normalized = val?.toLowerCase()
+                    if (normalized && ['lax', 'strict', 'none'].includes(normalized)) {
+                        attrs.sameSite = (normalized.charAt(0).toUpperCase() +
+                            normalized.slice(1)) as Cookie['sameSite']
+                    }
+                    break
+                }
+            }
+        }
+
+        return attrs
+    }
+
+    private updateCookie(cookie: Cookie, value: string, attrs: ReturnType<typeof this.parseAttributes>) {
+        cookie.value = value
+        if (attrs.domain) cookie.domain = attrs.domain
+        if (attrs.path) cookie.path = attrs.path
+        //if (attrs.expires !== undefined) cookie.expires = attrs.expires
+        //if (attrs.httpOnly) cookie.httpOnly = true
+        //if (attrs.secure) cookie.secure = true
+        //if (attrs.sameSite) cookie.sameSite = attrs.sameSite
+    }
+
+    private createCookie(name: string, value: string, attrs: ReturnType<typeof this.parseAttributes>): Cookie {
+        return {
+            name,
+            value,
+            domain: attrs.domain || '.bing.com',
+            path: attrs.path || '/'
+            /*
+            ...(attrs.expires !== undefined && { expires: attrs.expires }),
+            ...(attrs.httpOnly && { httpOnly: true }),
+            ...(attrs.secure && { secure: true }),
+            ...(attrs.sameSite && { sameSite: attrs.sameSite })
+            */
+        } as Cookie
+    }
+}

src/browser/BrowserUtil.ts

@@ -1,132 +0,0 @@
-import { Page } from 'rebrowser-playwright'
-import { load } from 'cheerio'
-
-import { MicrosoftRewardsBot } from '../index'
-
-
-export default class BrowserUtil {
-    private bot: MicrosoftRewardsBot
-
-    constructor(bot: MicrosoftRewardsBot) {
-        this.bot = bot
-    }
-
-    async tryDismissAllMessages(page: Page): Promise<void> {
-        const buttons = [
-            { selector: '#acceptButton', label: 'AcceptButton' },
-            { selector: '.ext-secondary.ext-button', label: '"Skip for now" Button' },
-            { selector: '#iLandingViewAction', label: 'iLandingViewAction' },
-            { selector: '#iShowSkip', label: 'iShowSkip' },
-            { selector: '#iNext', label: 'iNext' },
-            { selector: '#iLooksGood', label: 'iLooksGood' },
-            { selector: '#idSIButton9', label: 'idSIButton9' },
-            { selector: '.ms-Button.ms-Button--primary', label: 'Primary Button' },
-            { selector: '.c-glyph.glyph-cancel', label: 'Mobile Welcome Button' },
-            { selector: '.maybe-later', label: 'Mobile Rewards App Banner' },
-            { selector: '//div[@id="cookieConsentContainer"]//button[contains(text(), "Accept")]', label: 'Accept Cookie Consent Container', isXPath: true },
-            { selector: '#bnp_btn_accept', label: 'Bing Cookie Banner' },
-            { selector: '#reward_pivot_earn', label: 'Reward Coupon Accept' }
-        ]
-
-        for (const button of buttons) {
-            try {
-                const element = button.isXPath ? page.locator(`xpath=${button.selector}`) : page.locator(button.selector)
-                await element.first().click({ timeout: 500 })
-                await page.waitForTimeout(500)
-
-                this.bot.log(this.bot.isMobile, 'DISMISS-ALL-MESSAGES', `Dismissed: ${button.label}`)
-
-            } catch (error) {
-                // Silent fail
-            }
-        }
-
-        // Handle blocking Bing privacy overlay intercepting clicks (#bnp_overlay_wrapper)
-        try {
-            const overlay = await page.locator('#bnp_overlay_wrapper').first()
-            if (await overlay.isVisible({ timeout: 500 }).catch(()=>false)) {
-                // Try common dismiss buttons inside overlay
-                const rejectBtn = await page.locator('#bnp_btn_reject, button[aria-label*="Reject" i]').first()
-                const acceptBtn = await page.locator('#bnp_btn_accept').first()
-                if (await rejectBtn.isVisible().catch(()=>false)) {
-                    await rejectBtn.click({ timeout: 500 }).catch(()=>{})
-                    this.bot.log(this.bot.isMobile, 'DISMISS-ALL-MESSAGES', 'Dismissed: Bing Overlay Reject')
-                } else if (await acceptBtn.isVisible().catch(()=>false)) {
-                    await acceptBtn.click({ timeout: 500 }).catch(()=>{})
-                    this.bot.log(this.bot.isMobile, 'DISMISS-ALL-MESSAGES', 'Dismissed: Bing Overlay Accept (fallback)')
-                }
-                await page.waitForTimeout(300)
-            }
-        } catch { /* ignore */ }
-    }
-
-    async getLatestTab(page: Page): Promise<Page> {
-        try {
-            await this.bot.utils.wait(1000)
-
-            const browser = page.context()
-            const pages = browser.pages()
-            const newTab = pages[pages.length - 1]
-
-            if (newTab) {
-                return newTab
-            }
-
-            throw this.bot.log(this.bot.isMobile, 'GET-NEW-TAB', 'Unable to get latest tab', 'error')
-        } catch (error) {
-            throw this.bot.log(this.bot.isMobile, 'GET-NEW-TAB', 'An error occurred:' + error, 'error')
-        }
-    }
-
-    async getTabs(page: Page) {
-        try {
-            const browser = page.context()
-            const pages = browser.pages()
-
-            const homeTab = pages[1]
-            let homeTabURL: URL
-
-            if (!homeTab) {
-                throw this.bot.log(this.bot.isMobile, 'GET-TABS', 'Home tab could not be found!', 'error')
-
-            } else {
-                homeTabURL = new URL(homeTab.url())
-
-                if (homeTabURL.hostname !== 'rewards.bing.com') {
-                    throw this.bot.log(this.bot.isMobile, 'GET-TABS', 'Reward page hostname is invalid: ' + homeTabURL.host, 'error')
-                }
-            }
-
-            const workerTab = pages[2]
-            if (!workerTab) {
-                throw this.bot.log(this.bot.isMobile, 'GET-TABS', 'Worker tab could not be found!', 'error')
-            }
-
-            return {
-                homeTab: homeTab,
-                workerTab: workerTab
-            }
-
-        } catch (error) {
-            throw this.bot.log(this.bot.isMobile, 'GET-TABS', 'An error occurred:' + error, 'error')
-        }
-    }
-
-    async reloadBadPage(page: Page): Promise<void> {
-        try {
-            const html = await page.content().catch(() => '')
-            const $ = load(html)
-
-            const isNetworkError = $('body.neterror').length
-
-            if (isNetworkError) {
-                this.bot.log(this.bot.isMobile, 'RELOAD-BAD-PAGE', 'Bad page detected, reloading!')
-                await page.reload()
-            }
-
-        } catch (error) {
-            throw this.bot.log(this.bot.isMobile, 'RELOAD-BAD-PAGE', 'An error occurred:' + error, 'error')
-        }
-    }
-
-}

src/browser/BrowserUtils.ts

@@ -0,0 +1,273 @@
+import { type Page, type BrowserContext } from 'patchright'
+import { CheerioAPI, load } from 'cheerio'
+import { ClickOptions, createCursor } from 'ghost-cursor-playwright-port'
+
+import type { MicrosoftRewardsBot } from '../index'
+
+export default class BrowserUtils {
+    private bot: MicrosoftRewardsBot
+
+    constructor(bot: MicrosoftRewardsBot) {
+        this.bot = bot
+    }
+
+    async tryDismissAllMessages(page: Page): Promise<void> {
+        try {
+            const buttons = [
+                { selector: '#acceptButton', label: 'AcceptButton' },
+                { selector: '#wcpConsentBannerCtrl > * > button:first-child', label: 'Bing Cookies Accept' },
+                { selector: '.ext-secondary.ext-button', label: '"Skip for now" Button' },
+                { selector: '#iLandingViewAction', label: 'iLandingViewAction' },
+                { selector: '#iShowSkip', label: 'iShowSkip' },
+                { selector: '#iNext', label: 'iNext' },
+                { selector: '#iLooksGood', label: 'iLooksGood' },
+                { selector: '#idSIButton9', label: 'idSIButton9' },
+                { selector: '.ms-Button.ms-Button--primary', label: 'Primary Button' },
+                { selector: '.c-glyph.glyph-cancel', label: 'Mobile Welcome Button' },
+                { selector: '.maybe-later', label: 'Mobile Rewards App Banner' },
+                { selector: '#bnp_btn_accept', label: 'Bing Cookie Banner' },
+                { selector: '#reward_pivot_earn', label: 'Reward Coupon Accept' }
+            ]
+
+            const checkVisible = await Promise.allSettled(
+                buttons.map(async b => ({
+                    ...b,
+                    isVisible: await page
+                        .locator(b.selector)
+                        .isVisible()
+                        .catch(() => false)
+                }))
+            )
+
+            const visibleButtons = checkVisible
+                .filter(r => r.status === 'fulfilled' && r.value.isVisible)
+                .map(r => (r.status === 'fulfilled' ? r.value : null))
+                .filter(Boolean)
+
+            if (visibleButtons.length > 0) {
+                await Promise.allSettled(
+                    visibleButtons.map(async b => {
+                        if (b) {
+                            const clicked = await this.ghostClick(page, b.selector)
+                            if (clicked) {
+                                this.bot.logger.debug(
+                                    this.bot.isMobile,
+                                    'DISMISS-ALL-MESSAGES',
+                                    `Dismissed: ${b.label}`
+                                )
+                            }
+                        }
+                    })
+                )
+                await this.bot.utils.wait(300)
+            }
+
+            // Overlay
+            const overlay = await page.$('#bnp_overlay_wrapper')
+            if (overlay) {
+                const rejected = await this.ghostClick(page, '#bnp_btn_reject, button[aria-label*="Reject" i]')
+                if (rejected) {
+                    this.bot.logger.debug(this.bot.isMobile, 'DISMISS-ALL-MESSAGES', 'Dismissed: Bing Overlay Reject')
+                } else {
+                    const accepted = await this.ghostClick(page, '#bnp_btn_accept')
+                    if (accepted) {
+                        this.bot.logger.debug(
+                            this.bot.isMobile,
+                            'DISMISS-ALL-MESSAGES',
+                            'Dismissed: Bing Overlay Accept'
+                        )
+                    }
+                }
+                await this.bot.utils.wait(250)
+            }
+        } catch (error) {
+            this.bot.logger.warn(
+                this.bot.isMobile,
+                'DISMISS-ALL-MESSAGES',
+                `Handler error: ${error instanceof Error ? error.message : String(error)}`
+            )
+        }
+    }
+
+    async getLatestTab(page: Page): Promise<Page> {
+        try {
+            const browser: BrowserContext = page.context()
+            const pages = browser.pages()
+
+            const newTab = pages[pages.length - 1]
+            if (!newTab) {
+                throw this.bot.logger.error(this.bot.isMobile, 'GET-NEW-TAB', 'No tabs could be found!')
+            }
+
+            return newTab
+        } catch (error) {
+            this.bot.logger.error(
+                this.bot.isMobile,
+                'GET-NEW-TAB',
+                `Unable to get latest tab: ${error instanceof Error ? error.message : String(error)}`
+            )
+            throw error
+        }
+    }
+
+    async reloadBadPage(page: Page): Promise<boolean> {
+        try {
+            const html = await page.content().catch(() => '')
+            const $ = load(html)
+
+            if ($('body.neterror').length) {
+                this.bot.logger.info(this.bot.isMobile, 'RELOAD-BAD-PAGE', 'Bad page detected, reloading!')
+                try {
+                    await page.reload({ waitUntil: 'load' })
+                } catch {
+                    await page.reload().catch(() => {})
+                }
+                return true
+            } else {
+                return false
+            }
+        } catch (error) {
+            this.bot.logger.error(
+                this.bot.isMobile,
+                'RELOAD-BAD-PAGE',
+                `Reload check failed: ${error instanceof Error ? error.message : String(error)}`
+            )
+            return true
+        }
+    }
+
+    async closeTabs(page: Page, config = { minTabs: 1, maxTabs: 1 }): Promise<Page> {
+        try {
+            const browser = page.context()
+            const tabs = browser.pages()
+
+            this.bot.logger.debug(
+                this.bot.isMobile,
+                'SEARCH-CLOSE-TABS',
+                `Found ${tabs.length} tab(s) open (min: ${config.minTabs}, max: ${config.maxTabs})`
+            )
+
+            // Check if valid
+            if (config.minTabs < 1 || config.maxTabs < config.minTabs) {
+                this.bot.logger.warn(this.bot.isMobile, 'SEARCH-CLOSE-TABS', 'Invalid config, using defaults')
+                config = { minTabs: 1, maxTabs: 1 }
+            }
+
+            // Close if more than max config
+            if (tabs.length > config.maxTabs) {
+                const tabsToClose = tabs.slice(config.maxTabs)
+
+                const closeResults = await Promise.allSettled(tabsToClose.map(tab => tab.close()))
+
+                const closedCount = closeResults.filter(r => r.status === 'fulfilled').length
+                this.bot.logger.debug(
+                    this.bot.isMobile,
+                    'SEARCH-CLOSE-TABS',
+                    `Closed ${closedCount}/${tabsToClose.length} excess tab(s) to reach max of ${config.maxTabs}`
+                )
+
+                // Open more tabs
+            } else if (tabs.length < config.minTabs) {
+                const tabsNeeded = config.minTabs - tabs.length
+                this.bot.logger.debug(
+                    this.bot.isMobile,
+                    'SEARCH-CLOSE-TABS',
+                    `Opening ${tabsNeeded} tab(s) to reach min of ${config.minTabs}`
+                )
+
+                const newTabPromises = Array.from({ length: tabsNeeded }, async () => {
+                    try {
+                        const newPage = await browser.newPage()
+                        await newPage.goto(this.bot.config.baseURL, { waitUntil: 'domcontentloaded', timeout: 15000 })
+                        return newPage
+                    } catch (error) {
+                        this.bot.logger.warn(
+                            this.bot.isMobile,
+                            'SEARCH-CLOSE-TABS',
+                            `Failed to create new tab: ${error instanceof Error ? error.message : String(error)}`
+                        )
+                        return null
+                    }
+                })
+
+                await Promise.allSettled(newTabPromises)
+            }
+
+            const latestTab = await this.getLatestTab(page)
+            return latestTab
+        } catch (error) {
+            this.bot.logger.error(
+                this.bot.isMobile,
+                'SEARCH-CLOSE-TABS',
+                `Error: ${error instanceof Error ? error.message : String(error)}`
+            )
+            return page
+        }
+    }
+
+    async loadInCheerio(data: Page | string): Promise<CheerioAPI> {
+        const html: string = typeof data === 'string' ? data : await data.content()
+        const $ = load(html)
+        return $
+    }
+
+    async ghostClick(page: Page, selector: string, options?: ClickOptions): Promise<boolean> {
+        try {
+            this.bot.logger.debug(
+                this.bot.isMobile,
+                'GHOST-CLICK',
+                `Trying to click selector: ${selector}, options: ${JSON.stringify(options)}`
+            )
+
+            // Wait for selector to exist before clicking
+            await page.waitForSelector(selector, { timeout: 10000 })
+
+            const cursor = createCursor(page as any)
+            await cursor.click(selector, options)
+
+            return true
+        } catch (error) {
+            this.bot.logger.error(
+                this.bot.isMobile,
+                'GHOST-CLICK',
+                `Failed for ${selector}: ${error instanceof Error ? error.message : String(error)}`
+            )
+            return false
+        }
+    }
+
+    async disableFido(page: Page) {
+        const routePattern = '**/GetCredentialType.srf*'
+        await page.route(routePattern, route => {
+            try {
+                const request = route.request()
+                const postData = request.postData()
+
+                const body = postData ? JSON.parse(postData) : {}
+
+                body.isFidoSupported = false
+
+                this.bot.logger.debug(
+                    this.bot.isMobile,
+                    'DISABLE-FIDO',
+                    `Modified request body: isFidoSupported set to ${body.isFidoSupported}`
+                )
+
+                route.continue({
+                    postData: JSON.stringify(body),
+                    headers: {
+                        ...request.headers(),
+                        'Content-Type': 'application/json'
+                    }
+                })
+            } catch (error) {
+                this.bot.logger.debug(
+                    this.bot.isMobile,
+                    'DISABLE-FIDO',
+                    `An error occurred: ${error instanceof Error ? error.message : String(error)}`
+                )
+                route.continue()
+            }
+        })
+    }
+}

src/browser/UserAgent.ts

@@ -0,0 +1,164 @@
+import axios from 'axios'
+import type { BrowserFingerprintWithHeaders } from 'fingerprint-generator'
+
+import type { ChromeVersion, EdgeVersion } from '../interface/UserAgentUtil'
+import type { MicrosoftRewardsBot } from '../index'
+
+export class UserAgentManager {
+    private static readonly NOT_A_BRAND_VERSION = '99'
+
+    constructor(private bot: MicrosoftRewardsBot) {}
+
+    async getUserAgent(isMobile: boolean) {
+        const system = this.getSystemComponents(isMobile)
+        const app = await this.getAppComponents(isMobile)
+
+        const uaTemplate = isMobile
+            ? `Mozilla/5.0 (${system}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${app.chrome_reduced_version} Mobile Safari/537.36 EdgA/${app.edge_version}`
+            : `Mozilla/5.0 (${system}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${app.chrome_reduced_version} Safari/537.36 Edg/${app.edge_version}`
+
+        const platformVersion = `${isMobile ? Math.floor(Math.random() * 5) + 9 : Math.floor(Math.random() * 15) + 1}.0.0`
+
+        const uaMetadata = {
+            isMobile,
+            platform: isMobile ? 'Android' : 'Windows',
+            fullVersionList: [
+                { brand: 'Not/A)Brand', version: `${UserAgentManager.NOT_A_BRAND_VERSION}.0.0.0` },
+                { brand: 'Microsoft Edge', version: app['edge_version'] },
+                { brand: 'Chromium', version: app['chrome_version'] }
+            ],
+            brands: [
+                { brand: 'Not/A)Brand', version: UserAgentManager.NOT_A_BRAND_VERSION },
+                { brand: 'Microsoft Edge', version: app['edge_major_version'] },
+                { brand: 'Chromium', version: app['chrome_major_version'] }
+            ],
+            platformVersion,
+            architecture: isMobile ? '' : 'x86',
+            bitness: isMobile ? '' : '64',
+            model: ''
+        }
+
+        return { userAgent: uaTemplate, userAgentMetadata: uaMetadata }
+    }
+
+    async getChromeVersion(isMobile: boolean): Promise<string> {
+        try {
+            const request = {
+                url: 'https://googlechromelabs.github.io/chrome-for-testing/last-known-good-versions.json',
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            }
+
+            const response = await axios(request)
+            const data: ChromeVersion = response.data
+            return data.channels.Stable.version
+        } catch (error) {
+            this.bot.logger.error(
+                isMobile,
+                'USERAGENT-CHROME-VERSION',
+                `An error occurred: ${error instanceof Error ? error.message : String(error)}`
+            )
+            throw error
+        }
+    }
+
+    async getEdgeVersions(isMobile: boolean) {
+        try {
+            const request = {
+                url: 'https://edgeupdates.microsoft.com/api/products',
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            }
+
+            const response = await axios(request)
+            const data: EdgeVersion[] = response.data
+            const stable = data.find(x => x.Product == 'Stable') as EdgeVersion
+            return {
+                android: stable.Releases.find(x => x.Platform == 'Android')?.ProductVersion,
+                windows: stable.Releases.find(x => x.Platform == 'Windows' && x.Architecture == 'x64')?.ProductVersion
+            }
+        } catch (error) {
+            this.bot.logger.error(
+                isMobile,
+                'USERAGENT-EDGE-VERSION',
+                `An error occurred: ${error instanceof Error ? error.message : String(error)}`
+            )
+            throw error
+        }
+    }
+
+    getSystemComponents(mobile: boolean): string {
+        if (mobile) {
+            const androidVersion = 10 + Math.floor(Math.random() * 5)
+            return `Linux; Android ${androidVersion}; K`
+        }
+
+        return 'Windows NT 10.0; Win64; x64'
+    }
+
+    async getAppComponents(isMobile: boolean) {
+        const versions = await this.getEdgeVersions(isMobile)
+        const edgeVersion = isMobile ? versions.android : (versions.windows as string)
+        const edgeMajorVersion = edgeVersion?.split('.')[0]
+
+        const chromeVersion = await this.getChromeVersion(isMobile)
+        const chromeMajorVersion = chromeVersion?.split('.')[0]
+        const chromeReducedVersion = `${chromeMajorVersion}.0.0.0`
+
+        return {
+            not_a_brand_version: `${UserAgentManager.NOT_A_BRAND_VERSION}.0.0.0`,
+            not_a_brand_major_version: UserAgentManager.NOT_A_BRAND_VERSION,
+            edge_version: edgeVersion as string,
+            edge_major_version: edgeMajorVersion as string,
+            chrome_version: chromeVersion as string,
+            chrome_major_version: chromeMajorVersion as string,
+            chrome_reduced_version: chromeReducedVersion as string
+        }
+    }
+
+    async updateFingerprintUserAgent(
+        fingerprint: BrowserFingerprintWithHeaders,
+        isMobile: boolean
+    ): Promise<BrowserFingerprintWithHeaders> {
+        try {
+            const userAgentData = await this.getUserAgent(isMobile)
+            const componentData = await this.getAppComponents(isMobile)
+
+            //@ts-expect-error Errors due it not exactly matching
+            fingerprint.fingerprint.navigator.userAgentData = userAgentData.userAgentMetadata
+            fingerprint.fingerprint.navigator.userAgent = userAgentData.userAgent
+            fingerprint.fingerprint.navigator.appVersion = userAgentData.userAgent.replace(
+                `${fingerprint.fingerprint.navigator.appCodeName}/`,
+                ''
+            )
+
+            fingerprint.headers['user-agent'] = userAgentData.userAgent
+            fingerprint.headers['sec-ch-ua'] =
+                `"Microsoft Edge";v="${componentData.edge_major_version}", "Not=A?Brand";v="${componentData.not_a_brand_major_version}", "Chromium";v="${componentData.chrome_major_version}"`
+            fingerprint.headers['sec-ch-ua-full-version-list'] =
+                `"Microsoft Edge";v="${componentData.edge_version}", "Not=A?Brand";v="${componentData.not_a_brand_version}", "Chromium";v="${componentData.chrome_version}"`
+
+            /*
+            Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Mobile Safari/537.36 EdgA/129.0.0.0
+            sec-ch-ua-full-version-list: "Microsoft Edge";v="129.0.2792.84", "Not=A?Brand";v="8.0.0.0", "Chromium";v="129.0.6668.90"
+            sec-ch-ua: "Microsoft Edge";v="129", "Not=A?Brand";v="8", "Chromium";v="129"
+    
+            Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36
+            "Google Chrome";v="129.0.6668.90", "Not=A?Brand";v="8.0.0.0", "Chromium";v="129.0.6668.90"
+            */
+
+            return fingerprint
+        } catch (error) {
+            this.bot.logger.error(
+                isMobile,
+                'USER-AGENT-UPDATE',
+                `An error occurred: ${error instanceof Error ? error.message : String(error)}`
+            )
+            throw error
+        }
+    }
+}

src/browser/auth/Login.ts

@@ -0,0 +1,509 @@
+import type { Page } from 'patchright'
+import type { MicrosoftRewardsBot } from '../../index'
+import { saveSessionData } from '../../util/Load'
+
+// Methods
+import { MobileAccessLogin } from './methods/MobileAccessLogin'
+import { EmailLogin } from './methods/EmailLogin'
+import { PasswordlessLogin } from './methods/PasswordlessLogin'
+import { TotpLogin } from './methods/Totp2FALogin'
+
+type LoginState =
+    | 'EMAIL_INPUT'
+    | 'PASSWORD_INPUT'
+    | 'SIGN_IN_ANOTHER_WAY'
+    | 'PASSKEY_ERROR'
+    | 'PASSKEY_VIDEO'
+    | 'KMSI_PROMPT'
+    | 'LOGGED_IN'
+    | 'ACCOUNT_LOCKED'
+    | 'ERROR_ALERT'
+    | '2FA_TOTP'
+    | 'LOGIN_PASSWORDLESS'
+    | 'GET_A_CODE'
+    | 'UNKNOWN'
+    | 'CHROMEWEBDATA_ERROR'
+
+export class Login {
+    emailLogin: EmailLogin
+    passwordlessLogin: PasswordlessLogin
+    totp2FALogin: TotpLogin
+    constructor(private bot: MicrosoftRewardsBot) {
+        this.emailLogin = new EmailLogin(this.bot)
+        this.passwordlessLogin = new PasswordlessLogin(this.bot)
+        this.totp2FALogin = new TotpLogin(this.bot)
+    }
+
+    private readonly primaryButtonSelector = 'button[data-testid="primaryButton"]'
+    private readonly secondaryButtonSelector = 'button[data-testid="secondaryButton"]'
+
+    async login(page: Page, email: string, password: string, totpSecret?: string) {
+        try {
+            this.bot.logger.info(this.bot.isMobile, 'LOGIN', 'Starting login process')
+
+            await page.goto('https://www.bing.com/rewards/dashboard', { waitUntil: 'domcontentloaded' }).catch(() => {})
+            await this.bot.utils.wait(2000)
+            await this.bot.browser.utils.reloadBadPage(page)
+
+            await this.bot.browser.utils.disableFido(page)
+
+            const maxIterations = 25
+            let iteration = 0
+
+            let previousState: LoginState = 'UNKNOWN'
+            let sameStateCount = 0
+
+            while (iteration < maxIterations) {
+                if (page.isClosed()) throw new Error('Page closed unexpectedly')
+
+                iteration++
+                this.bot.logger.debug(this.bot.isMobile, 'LOGIN', `State check iteration ${iteration}/${maxIterations}`)
+
+                const state = await this.detectCurrentState(page)
+                this.bot.logger.debug(this.bot.isMobile, 'LOGIN', `Current state: ${state}`)
+
+                if (state !== previousState && previousState !== 'UNKNOWN') {
+                    this.bot.logger.info(this.bot.isMobile, 'LOGIN', `State transition: ${previousState} → ${state}`)
+                }
+
+                if (state === previousState && state !== 'LOGGED_IN' && state !== 'UNKNOWN') {
+                    sameStateCount++
+                    if (sameStateCount >= 4) {
+                        this.bot.logger.warn(
+                            this.bot.isMobile,
+                            'LOGIN',
+                            `Stuck in state "${state}" for 4 loops. Refreshing page...`
+                        )
+                        await page.reload({ waitUntil: 'domcontentloaded' })
+                        await this.bot.utils.wait(3000)
+                        sameStateCount = 0
+                        previousState = 'UNKNOWN'
+                        continue
+                    }
+                } else {
+                    sameStateCount = 0
+                }
+                previousState = state
+
+                if (state === 'LOGGED_IN') {
+                    this.bot.logger.info(this.bot.isMobile, 'LOGIN', 'Successfully logged in')
+                    break
+                }
+
+                const shouldContinue = await this.handleState(state, page, email, password, totpSecret)
+
+                if (!shouldContinue) {
+                    throw new Error(`Login failed or aborted at state: ${state}`)
+                }
+
+                await this.bot.utils.wait(1000)
+            }
+
+            if (iteration >= maxIterations) {
+                throw new Error('Login timeout: exceeded maximum iterations')
+            }
+
+            await this.finalizeLogin(page, email)
+        } catch (error) {
+            this.bot.logger.error(
+                this.bot.isMobile,
+                'LOGIN',
+                `An error occurred: ${error instanceof Error ? error.message : String(error)}`
+            )
+            throw error
+        }
+    }
+
+    private async detectCurrentState(page: Page): Promise<LoginState> {
+        // Make sure we settled before getting a URL
+        await page.waitForLoadState('networkidle', { timeout: 5000 }).catch(() => {})
+
+        const url = new URL(page.url())
+
+        this.bot.logger.debug(this.bot.isMobile, 'DETECT-CURRENT-STATE', `Current URL: ${url}`)
+
+        if (url.hostname === 'chromewebdata') {
+            this.bot.logger.warn(this.bot.isMobile, 'DETECT-CURRENT-STATE', 'Detected chromewebdata error page')
+            return 'CHROMEWEBDATA_ERROR'
+        }
+
+        const isLocked = await page
+            .waitForSelector('#serviceAbuseLandingTitle', { state: 'visible', timeout: 200 })
+            .then(() => true)
+            .catch(() => false)
+        if (isLocked) {
+            return 'ACCOUNT_LOCKED'
+        }
+
+        // If instantly loading rewards dash, logged in
+        if (url.hostname === 'rewards.bing.com') {
+            return 'LOGGED_IN'
+        }
+
+        // If account dash, logged in
+        if (url.hostname === 'account.microsoft.com') {
+            return 'LOGGED_IN'
+        }
+
+        const check = async (selector: string, state: LoginState): Promise<LoginState | null> => {
+            return page
+                .waitForSelector(selector, { state: 'visible', timeout: 200 })
+                .then(visible => (visible ? state : null))
+                .catch(() => null)
+        }
+
+        const results = await Promise.all([
+            check('div[role="alert"]', 'ERROR_ALERT'),
+            check('[data-testid="passwordEntry"]', 'PASSWORD_INPUT'),
+            check('input#usernameEntry', 'EMAIL_INPUT'),
+            check('[data-testid="kmsiVideo"]', 'KMSI_PROMPT'),
+            check('[data-testid="biometricVideo"]', 'PASSKEY_VIDEO'),
+            check('[data-testid="registrationImg"]', 'PASSKEY_ERROR'),
+            check('[data-testid="tile"]:has(svg path[d*="M11.78 10.22a.75.75"])', 'SIGN_IN_ANOTHER_WAY'),
+            check('[data-testid="deviceShieldCheckmarkVideo"]', 'LOGIN_PASSWORDLESS'),
+            check('input[name="otc"]', '2FA_TOTP'),
+            check('form[name="OneTimeCodeViewForm"]', '2FA_TOTP')
+        ])
+
+        // Get a code
+        const identityBanner = await page
+            .waitForSelector('[data-testid="identityBanner"]', { state: 'visible', timeout: 200 })
+            .then(() => true)
+            .catch(() => false)
+
+        const primaryButton = await page
+            .waitForSelector(this.primaryButtonSelector, { state: 'visible', timeout: 200 })
+            .then(() => true)
+            .catch(() => false)
+
+        const passwordEntry = await page
+            .waitForSelector('[data-testid="passwordEntry"]', { state: 'visible', timeout: 200 })
+            .then(() => true)
+            .catch(() => false)
+
+        if (identityBanner && primaryButton && !passwordEntry && !results.includes('2FA_TOTP')) {
+            results.push('GET_A_CODE') // Lower prio
+        }
+
+        // Final
+        let foundStates = results.filter((s): s is LoginState => s !== null)
+
+        if (foundStates.length === 0) return 'UNKNOWN'
+
+        if (foundStates.includes('ERROR_ALERT')) {
+            if (url.hostname !== 'login.live.com') {
+                // Remove ERROR_ALERT if not on login.live.com
+                foundStates = foundStates.filter(s => s !== 'ERROR_ALERT')
+            }
+            if (foundStates.includes('2FA_TOTP')) {
+                // Don't throw on TOTP if expired code is entered
+                foundStates = foundStates.filter(s => s !== 'ERROR_ALERT')
+            }
+
+            // On login.live.com, keep it
+            return 'ERROR_ALERT'
+        }
+
+        if (foundStates.includes('ERROR_ALERT')) return 'ERROR_ALERT'
+        if (foundStates.includes('ACCOUNT_LOCKED')) return 'ACCOUNT_LOCKED'
+        if (foundStates.includes('PASSKEY_VIDEO')) return 'PASSKEY_VIDEO'
+        if (foundStates.includes('PASSKEY_ERROR')) return 'PASSKEY_ERROR'
+        if (foundStates.includes('KMSI_PROMPT')) return 'KMSI_PROMPT'
+        if (foundStates.includes('PASSWORD_INPUT')) return 'PASSWORD_INPUT'
+        if (foundStates.includes('EMAIL_INPUT')) return 'EMAIL_INPUT'
+        if (foundStates.includes('SIGN_IN_ANOTHER_WAY')) return 'SIGN_IN_ANOTHER_WAY'
+        if (foundStates.includes('LOGIN_PASSWORDLESS')) return 'LOGIN_PASSWORDLESS'
+        if (foundStates.includes('2FA_TOTP')) return '2FA_TOTP'
+
+        const mainState = foundStates[0] as LoginState
+
+        return mainState
+    }
+
+    private async handleState(
+        state: LoginState,
+        page: Page,
+        email: string,
+        password: string,
+        totpSecret?: string
+    ): Promise<boolean> {
+        switch (state) {
+            case 'ACCOUNT_LOCKED': {
+                const msg = 'This account has been locked! Remove from config and restart!'
+                this.bot.logger.error(this.bot.isMobile, 'CHECK-LOCKED', msg)
+                throw new Error(msg)
+            }
+
+            case 'ERROR_ALERT': {
+                const alertEl = page.locator('div[role="alert"]')
+                const errorMsg = await alertEl.innerText().catch(() => 'Unknown Error')
+                this.bot.logger.error(this.bot.isMobile, 'LOGIN', `Account error: ${errorMsg}`)
+                throw new Error(`Microsoft login error message: ${errorMsg}`)
+            }
+
+            case 'LOGGED_IN':
+                return true
+
+            case 'EMAIL_INPUT': {
+                this.bot.logger.info(this.bot.isMobile, 'LOGIN', 'Entering email')
+                await this.emailLogin.enterEmail(page, email)
+                await page.waitForLoadState('networkidle', { timeout: 5000 }).catch(() => {})
+                return true
+            }
+
+            case 'PASSWORD_INPUT': {
+                this.bot.logger.info(this.bot.isMobile, 'LOGIN', 'Entering password')
+                await this.emailLogin.enterPassword(page, password)
+                await page.waitForLoadState('networkidle', { timeout: 5000 }).catch(() => {})
+                return true
+            }
+
+            case 'GET_A_CODE': {
+                this.bot.logger.info(this.bot.isMobile, 'LOGIN', 'Attempting to bypass "Get code"')
+                // Select sign in other way
+                await this.bot.browser.utils.ghostClick(page, '[data-testid="viewFooter"] span[role="button"]')
+                await page.waitForLoadState('networkidle', { timeout: 5000 }).catch(() => {})
+                return true
+            }
+
+            case 'CHROMEWEBDATA_ERROR': {
+                this.bot.logger.warn(
+                    this.bot.isMobile,
+                    'LOGIN',
+                    'chromewebdata error page detected, attempting to recover to Rewards home'
+                )
+                // Try go to Rewards dashboard
+                try {
+                    await page
+                        .goto(this.bot.config.baseURL, {
+                            waitUntil: 'domcontentloaded',
+                            timeout: 10000
+                        })
+                        .catch(() => {})
+
+                    await this.bot.utils.wait(3000)
+                    return true
+                } catch {
+                    // If even that fails, fall back to login.live.com
+                    this.bot.logger.warn(
+                        this.bot.isMobile,
+                        'LOGIN',
+                        'Failed to navigate to baseURL from chromewebdata, retrying login.live.com'
+                    )
+
+                    await page
+                        .goto('https://login.live.com/', {
+                            waitUntil: 'domcontentloaded',
+                            timeout: 10000
+                        })
+                        .catch(() => {})
+
+                    await this.bot.utils.wait(3000)
+                    return true
+                }
+            }
+
+            case '2FA_TOTP': {
+                this.bot.logger.info(this.bot.isMobile, 'LOGIN', 'TOTP 2FA required')
+                await this.totp2FALogin.handle(page, totpSecret)
+                return true
+            }
+
+            case 'SIGN_IN_ANOTHER_WAY': {
+                this.bot.logger.info(this.bot.isMobile, 'LOGIN', 'Selecting "Use my password"')
+                const passwordOption = '[data-testid="tile"]:has(svg path[d*="M11.78 10.22a.75.75"])'
+                await this.bot.browser.utils.ghostClick(page, passwordOption)
+                await page.waitForLoadState('networkidle', { timeout: 5000 }).catch(() => {})
+                return true
+            }
+
+            case 'KMSI_PROMPT': {
+                this.bot.logger.info(this.bot.isMobile, 'LOGIN', 'Accepting KMSI prompt')
+                await this.bot.browser.utils.ghostClick(page, this.primaryButtonSelector)
+                await page.waitForLoadState('networkidle', { timeout: 5000 }).catch(() => {})
+                return true
+            }
+
+            case 'PASSKEY_VIDEO':
+            case 'PASSKEY_ERROR': {
+                this.bot.logger.info(this.bot.isMobile, 'LOGIN', 'Skipping Passkey prompt')
+                await this.bot.browser.utils.ghostClick(page, this.secondaryButtonSelector)
+                await page.waitForLoadState('networkidle', { timeout: 5000 }).catch(() => {})
+                return true
+            }
+
+            case 'LOGIN_PASSWORDLESS': {
+                this.bot.logger.info(this.bot.isMobile, 'LOGIN', 'Handling passwordless authentication')
+                await this.passwordlessLogin.handle(page)
+                await page.waitForLoadState('networkidle', { timeout: 5000 }).catch(() => {})
+                return true
+            }
+
+            case 'UNKNOWN': {
+                const url = new URL(page.url())
+                this.bot.logger.warn(
+                    this.bot.isMobile,
+                    'LOGIN',
+                    `Unknown state at host:${url.hostname} path:${url.pathname}. Waiting...`
+                )
+                return true
+            }
+
+            default:
+                return true
+        }
+    }
+
+    private async finalizeLogin(page: Page, email: string) {
+        this.bot.logger.info(this.bot.isMobile, 'LOGIN', 'Finalizing login')
+
+        await page.goto(this.bot.config.baseURL, { waitUntil: 'networkidle', timeout: 10000 }).catch(() => {})
+
+        const loginRewardsSuccess = new URL(page.url()).hostname === 'rewards.bing.com'
+        if (loginRewardsSuccess) {
+            this.bot.logger.info(this.bot.isMobile, 'LOGIN', 'Logged into Microsoft Rewards successfully')
+        } else {
+            this.bot.logger.warn(
+                this.bot.isMobile,
+                'LOGIN',
+                'Could not verify Rewards Dashboard. Assuming login valid anyway.'
+            )
+        }
+
+        await this.verifyBingSession(page)
+        await this.getRewardsSession(page)
+
+        const browser = page.context()
+        const cookies = await browser.cookies()
+        await saveSessionData(this.bot.config.sessionPath, cookies, email, this.bot.isMobile)
+
+        this.bot.logger.info(this.bot.isMobile, 'LOGIN', 'Login completed! Session saved!')
+    }
+
+    async verifyBingSession(page: Page) {
+        const url =
+            'https://www.bing.com/fd/auth/signin?action=interactive&provider=windows_live_id&return_url=https%3A%2F%2Fwww.bing.com%2F'
+        const loopMax = 5
+
+        this.bot.logger.info(this.bot.isMobile, 'LOGIN-BING', 'Verifying Bing session')
+
+        try {
+            await page.goto(url, { waitUntil: 'networkidle', timeout: 10000 }).catch(() => {})
+
+            for (let i = 0; i < loopMax; i++) {
+                if (page.isClosed()) break
+
+                // Rare error state
+                const state = await this.detectCurrentState(page)
+                if (state === 'PASSKEY_ERROR') {
+                    this.bot.logger.debug(
+                        this.bot.isMobile,
+                        'LOGIN-BING',
+                        'Verification landed on Passkey error state! Trying to dismiss.'
+                    )
+                    await this.bot.browser.utils.ghostClick(page, this.secondaryButtonSelector)
+                }
+
+                const u = new URL(page.url())
+                const atBingHome = u.hostname === 'www.bing.com' && u.pathname === '/'
+
+                if (atBingHome) {
+                    await this.bot.browser.utils.tryDismissAllMessages(page).catch(() => {})
+
+                    const signedIn = await page
+                        .waitForSelector('#id_n', { timeout: 3000 })
+                        .then(() => true)
+                        .catch(() => false)
+
+                    if (signedIn || this.bot.isMobile) {
+                        this.bot.logger.info(this.bot.isMobile, 'LOGIN-BING', 'Bing session established')
+                        return
+                    }
+                }
+
+                await this.bot.utils.wait(1000)
+            }
+
+            this.bot.logger.warn(
+                this.bot.isMobile,
+                'LOGIN-BING',
+                'Could not confirm Bing session after retries; continuing'
+            )
+        } catch (error) {
+            this.bot.logger.warn(
+                this.bot.isMobile,
+                'LOGIN-BING',
+                `Bing verification error: ${error instanceof Error ? error.message : String(error)}`
+            )
+        }
+    }
+
+    private async getRewardsSession(page: Page) {
+        const loopMax = 5
+
+        this.bot.logger.info(this.bot.isMobile, 'GET-REQUEST-TOKEN', 'Fetching request token')
+
+        try {
+            await page
+                .goto(`${this.bot.config.baseURL}?_=${Date.now()}`, { waitUntil: 'networkidle', timeout: 10000 })
+                .catch(() => {})
+
+            for (let i = 0; i < loopMax; i++) {
+                if (page.isClosed()) break
+
+                this.bot.logger.debug(
+                    this.bot.isMobile,
+                    'GET-REWARD-SESSION',
+                    `Loop ${i + 1}/${loopMax} | URL=${page.url()}`
+                )
+
+                const u = new URL(page.url())
+                const atRewardHome = u.hostname === 'rewards.bing.com' && u.pathname === '/'
+
+                if (atRewardHome) {
+                    await this.bot.browser.utils.tryDismissAllMessages(page)
+
+                    const html = await page.content()
+                    const $ = await this.bot.browser.utils.loadInCheerio(html)
+
+                    const token =
+                        $('input[name="__RequestVerificationToken"]').attr('value') ??
+                        $('meta[name="__RequestVerificationToken"]').attr('content') ??
+                        null
+
+                    if (token) {
+                        this.bot.requestToken = token
+                        this.bot.logger.info(this.bot.isMobile, 'GET-REQUEST-TOKEN', 'Request token has been set!')
+
+                        this.bot.logger.debug(
+                            this.bot.isMobile,
+                            'GET-REWARD-SESSION',
+                            `Token extracted: ${token.substring(0, 10)}...`
+                        )
+                        return
+                    }
+
+                    this.bot.logger.debug(this.bot.isMobile, 'GET-REWARD-SESSION', 'Token NOT found on page')
+                }
+
+                await this.bot.utils.wait(1000)
+            }
+
+            this.bot.logger.warn(
+                this.bot.isMobile,
+                'GET-REQUEST-TOKEN',
+                'No RequestVerificationToken found — some activities may not work'
+            )
+        } catch (error) {
+            throw this.bot.logger.error(
+                this.bot.isMobile,
+                'GET-REQUEST-TOKEN',
+                `Reward session error: ${error instanceof Error ? error.message : String(error)}`
+            )
+        }
+    }
+
+    async getAppAccessToken(page: Page, email: string) {
+        return await new MobileAccessLogin(this.bot, page).get(email)
+    }
+}

src/browser/auth/methods/EmailLogin.ts

@@ -0,0 +1,86 @@
+import type { Page } from 'patchright'
+import type { MicrosoftRewardsBot } from '../../../index'
+
+export class EmailLogin {
+    private submitButton = 'button[type="submit"]'
+
+    constructor(private bot: MicrosoftRewardsBot) {}
+
+    async enterEmail(page: Page, email: string): Promise<'ok' | 'error'> {
+        try {
+            const emailInputSelector = 'input[type="email"]'
+            const emailField = await page
+                .waitForSelector(emailInputSelector, { state: 'visible', timeout: 1000 })
+                .catch(() => {})
+            if (!emailField) {
+                this.bot.logger.warn(this.bot.isMobile, 'LOGIN-ENTER-EMAIL', 'Email field not found')
+                return 'error'
+            }
+
+            await this.bot.utils.wait(1000)
+
+            const prefilledEmail = await page
+                .waitForSelector('#userDisplayName', { state: 'visible', timeout: 1000 })
+                .catch(() => {})
+            if (!prefilledEmail) {
+                await page.fill(emailInputSelector, '').catch(() => {})
+                await this.bot.utils.wait(500)
+                await page.fill(emailInputSelector, email).catch(() => {})
+                await this.bot.utils.wait(1000)
+            } else {
+                this.bot.logger.info(this.bot.isMobile, 'LOGIN-ENTER-EMAIL', 'Email prefilled')
+            }
+
+            await page.waitForSelector(this.submitButton, { state: 'visible', timeout: 2000 }).catch(() => {})
+
+            await this.bot.browser.utils.ghostClick(page, this.submitButton)
+            this.bot.logger.info(this.bot.isMobile, 'LOGIN-ENTER-EMAIL', 'Email submitted')
+
+            return 'ok'
+        } catch (error) {
+            this.bot.logger.error(
+                this.bot.isMobile,
+                'LOGIN-ENTER-EMAIL',
+                `An error occurred: ${error instanceof Error ? error.message : String(error)}`
+            )
+            return 'error'
+        }
+    }
+
+    async enterPassword(page: Page, password: string): Promise<'ok' | 'needs-2fa' | 'error'> {
+        try {
+            const passwordInputSelector = 'input[type="password"]'
+            const passwordField = await page
+                .waitForSelector(passwordInputSelector, { state: 'visible', timeout: 1000 })
+                .catch(() => {})
+            if (!passwordField) {
+                this.bot.logger.warn(this.bot.isMobile, 'LOGIN-ENTER-PASSWORD', 'Password field not found')
+                return 'error'
+            }
+
+            await this.bot.utils.wait(1000)
+            await page.fill(passwordInputSelector, '').catch(() => {})
+            await this.bot.utils.wait(500)
+            await page.fill(passwordInputSelector, password).catch(() => {})
+            await this.bot.utils.wait(1000)
+
+            const submitButton = await page
+                .waitForSelector(this.submitButton, { state: 'visible', timeout: 2000 })
+                .catch(() => null)
+
+            if (submitButton) {
+                await this.bot.browser.utils.ghostClick(page, this.submitButton)
+                this.bot.logger.info(this.bot.isMobile, 'LOGIN-ENTER-PASSWORD', 'Password submitted')
+            }
+
+            return 'ok'
+        } catch (error) {
+            this.bot.logger.error(
+                this.bot.isMobile,
+                'LOGIN-ENTER-PASSWORD',
+                `An error occurred: ${error instanceof Error ? error.message : String(error)}`
+            )
+            return 'error'
+        }
+    }
+}

src/browser/auth/methods/MobileAccessLogin.ts

@@ -0,0 +1,88 @@
+import type { Page } from 'patchright'
+import { randomBytes } from 'crypto'
+import { URLSearchParams } from 'url'
+import type { AxiosRequestConfig } from 'axios'
+
+import type { MicrosoftRewardsBot } from '../../../index'
+
+export class MobileAccessLogin {
+    private clientId = '0000000040170455'
+    private authUrl = 'https://login.live.com/oauth20_authorize.srf'
+    private redirectUrl = 'https://login.live.com/oauth20_desktop.srf'
+    private tokenUrl = 'https://login.microsoftonline.com/consumers/oauth2/v2.0/token'
+    private scope = 'service::prod.rewardsplatform.microsoft.com::MBI_SSL'
+    private maxTimeout = 180_000 // 3min
+
+    constructor(
+        private bot: MicrosoftRewardsBot,
+        private page: Page
+    ) {}
+
+    async get(email: string): Promise<string> {
+        try {
+            const authorizeUrl = new URL(this.authUrl)
+            authorizeUrl.searchParams.append('response_type', 'code')
+            authorizeUrl.searchParams.append('client_id', this.clientId)
+            authorizeUrl.searchParams.append('redirect_uri', this.redirectUrl)
+            authorizeUrl.searchParams.append('scope', this.scope)
+            authorizeUrl.searchParams.append('state', randomBytes(16).toString('hex'))
+            authorizeUrl.searchParams.append('access_type', 'offline_access')
+            authorizeUrl.searchParams.append('login_hint', email)
+
+            await this.bot.browser.utils.disableFido(this.page)
+
+            await this.page.goto(authorizeUrl.href).catch(() => {})
+
+            this.bot.logger.info(this.bot.isMobile, 'LOGIN-APP', 'Waiting for mobile OAuth code...')
+            const start = Date.now()
+            let code = ''
+
+            while (Date.now() - start < this.maxTimeout) {
+                const url = new URL(this.page.url())
+                if (url.hostname === 'login.live.com' && url.pathname === '/oauth20_desktop.srf') {
+                    code = url.searchParams.get('code') || ''
+                    if (code) break
+                }
+                await this.bot.utils.wait(1000)
+            }
+
+            if (!code) {
+                this.bot.logger.warn(this.bot.isMobile, 'LOGIN-APP', 'Timed out waiting for OAuth code')
+                return ''
+            }
+
+            const data = new URLSearchParams()
+            data.append('grant_type', 'authorization_code')
+            data.append('client_id', this.clientId)
+            data.append('code', code)
+            data.append('redirect_uri', this.redirectUrl)
+
+            const request: AxiosRequestConfig = {
+                url: this.tokenUrl,
+                method: 'POST',
+                headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+                data: data.toString()
+            }
+
+            const response = await this.bot.axios.request(request)
+            const token = (response?.data?.access_token as string) ?? ''
+
+            if (!token) {
+                this.bot.logger.warn(this.bot.isMobile, 'LOGIN-APP', 'No access_token in token response')
+                return ''
+            }
+
+            this.bot.logger.info(this.bot.isMobile, 'LOGIN-APP', 'Mobile access token received')
+            return token
+        } catch (error) {
+            this.bot.logger.error(
+                this.bot.isMobile,
+                'LOGIN-APP',
+                `MobileAccess error: ${error instanceof Error ? error.message : String(error)}`
+            )
+            return ''
+        } finally {
+            await this.page.goto(this.bot.config.baseURL, { timeout: 10000 }).catch(() => {})
+        }
+    }
+}

src/browser/auth/methods/PasswordlessLogin.ts

@@ -0,0 +1,110 @@
+import type { Page } from 'patchright'
+import type { MicrosoftRewardsBot } from '../../../index'
+
+export class PasswordlessLogin {
+    private readonly maxAttempts = 60
+    private readonly numberDisplaySelector = 'div[data-testid="displaySign"]'
+    private readonly approvalPath = '/ppsecure/post.srf'
+
+    constructor(private bot: MicrosoftRewardsBot) {}
+
+    private async getDisplayedNumber(page: Page): Promise<string | null> {
+        try {
+            const numberElement = await page
+                .waitForSelector(this.numberDisplaySelector, {
+                    timeout: 5000
+                })
+                .catch(() => null)
+
+            if (numberElement) {
+                const number = await numberElement.textContent()
+                return number?.trim() || null
+            }
+        } catch (error) {
+            this.bot.logger.warn(this.bot.isMobile, 'LOGIN-PASSWORDLESS', 'Could not retrieve displayed number')
+        }
+        return null
+    }
+
+    private async waitForApproval(page: Page): Promise<boolean> {
+        try {
+            this.bot.logger.info(
+                this.bot.isMobile,
+                'LOGIN-PASSWORDLESS',
+                `Waiting for approval... (timeout after ${this.maxAttempts} seconds)`
+            )
+
+            for (let attempt = 1; attempt <= this.maxAttempts; attempt++) {
+                const currentUrl = new URL(page.url())
+                if (currentUrl.pathname === this.approvalPath) {
+                    this.bot.logger.info(this.bot.isMobile, 'LOGIN-PASSWORDLESS', 'Approval detected')
+                    return true
+                }
+
+                // Every 5 seconds to show it's still waiting
+                if (attempt % 5 === 0) {
+                    this.bot.logger.info(
+                        this.bot.isMobile,
+                        'LOGIN-PASSWORDLESS',
+                        `Still waiting... (${attempt}/${this.maxAttempts} seconds elapsed)`
+                    )
+                }
+
+                await this.bot.utils.wait(1000)
+            }
+
+            this.bot.logger.warn(
+                this.bot.isMobile,
+                'LOGIN-PASSWORDLESS',
+                `Approval timeout after ${this.maxAttempts} seconds!`
+            )
+            return false
+        } catch (error: any) {
+            this.bot.logger.error(
+                this.bot.isMobile,
+                'LOGIN-PASSWORDLESS',
+                `Approval failed, an error occurred: ${error instanceof Error ? error.message : String(error)}`
+            )
+            throw error
+        }
+    }
+
+    async handle(page: Page): Promise<void> {
+        try {
+            this.bot.logger.info(this.bot.isMobile, 'LOGIN-PASSWORDLESS', 'Passwordless authentication requested')
+
+            const displayedNumber = await this.getDisplayedNumber(page)
+
+            if (displayedNumber) {
+                this.bot.logger.info(
+                    this.bot.isMobile,
+                    'LOGIN-PASSWORDLESS',
+                    `Please approve login and select number: ${displayedNumber}`
+                )
+            } else {
+                this.bot.logger.info(
+                    this.bot.isMobile,
+                    'LOGIN-PASSWORDLESS',
+                    'Please approve login on your authenticator app'
+                )
+            }
+
+            const approved = await this.waitForApproval(page)
+
+            if (approved) {
+                this.bot.logger.info(this.bot.isMobile, 'LOGIN-PASSWORDLESS', 'Login approved successfully')
+                await page.waitForLoadState('networkidle', { timeout: 5000 }).catch(() => {})
+            } else {
+                this.bot.logger.error(this.bot.isMobile, 'LOGIN-PASSWORDLESS', 'Login approval failed or timed out')
+                throw new Error('Passwordless authentication timeout')
+            }
+        } catch (error) {
+            this.bot.logger.error(
+                this.bot.isMobile,
+                'LOGIN-PASSWORDLESS',
+                `An error occurred: ${error instanceof Error ? error.message : String(error)}`
+            )
+            throw error
+        }
+    }
+}

src/browser/auth/methods/Totp2FALogin.ts

@@ -0,0 +1,163 @@
+import type { Page } from 'patchright'
+import * as OTPAuth from 'otpauth'
+import readline from 'readline'
+import type { MicrosoftRewardsBot } from '../../../index'
+
+export class TotpLogin {
+    private readonly textInputSelector =
+        'form[name="OneTimeCodeViewForm"] input[type="text"], input#floatingLabelInput5'
+    private readonly hiddenInputSelector = 'input[id="otc-confirmation-input"], input[name="otc"]'
+    private readonly submitButtonSelector = 'button[type="submit"]'
+    private readonly maxManualSeconds = 60
+    private readonly maxManualAttempts = 5
+
+    constructor(private bot: MicrosoftRewardsBot) {}
+
+    private generateTotpCode(secret: string): string {
+        return new OTPAuth.TOTP({ secret, digits: 6 }).generate()
+    }
+
+    private async promptManualCode(): Promise<string | null> {
+        return await new Promise(resolve => {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout
+            })
+
+            let resolved = false
+
+            const cleanup = (result: string | null) => {
+                if (resolved) return
+                resolved = true
+                clearTimeout(timer)
+                rl.close()
+                resolve(result)
+            }
+
+            const timer = setTimeout(() => cleanup(null), this.maxManualSeconds * 1000)
+
+            rl.question(`Enter the 6-digit TOTP code (waiting ${this.maxManualSeconds}s): `, answer => {
+                cleanup(answer.trim())
+            })
+        })
+    }
+
+    private async fillCode(page: Page, code: string): Promise<boolean> {
+        try {
+            const visibleInput = await page
+                .waitForSelector(this.textInputSelector, { state: 'visible', timeout: 500 })
+                .catch(() => null)
+
+            if (visibleInput) {
+                await visibleInput.fill(code)
+                this.bot.logger.info(this.bot.isMobile, 'LOGIN-TOTP', 'Filled visible TOTP text input')
+                return true
+            }
+
+            const hiddenInput = await page.$(this.hiddenInputSelector)
+
+            if (hiddenInput) {
+                await hiddenInput.fill(code)
+                this.bot.logger.info(this.bot.isMobile, 'LOGIN-TOTP', 'Filled hidden TOTP input')
+                return true
+            }
+
+            this.bot.logger.warn(this.bot.isMobile, 'LOGIN-TOTP', 'No TOTP input field found (visible or hidden)')
+            return false
+        } catch (error) {
+            this.bot.logger.warn(
+                this.bot.isMobile,
+                'LOGIN-TOTP',
+                `Failed to fill TOTP input: ${error instanceof Error ? error.message : String(error)}`
+            )
+            return false
+        }
+    }
+
+    async handle(page: Page, totpSecret?: string): Promise<void> {
+        try {
+            this.bot.logger.info(this.bot.isMobile, 'LOGIN-TOTP', 'TOTP 2FA authentication requested')
+
+            if (totpSecret) {
+                const code = this.generateTotpCode(totpSecret)
+                this.bot.logger.info(this.bot.isMobile, 'LOGIN-TOTP', 'Generated TOTP code from secret')
+
+                const filled = await this.fillCode(page, code)
+
+                if (!filled) {
+                    this.bot.logger.error(this.bot.isMobile, 'LOGIN-TOTP', 'Unable to locate or fill TOTP input field')
+                    throw new Error('TOTP input field not found')
+                }
+
+                await this.bot.utils.wait(500)
+                await this.bot.browser.utils.ghostClick(page, this.submitButtonSelector)
+                await page.waitForLoadState('networkidle', { timeout: 5000 }).catch(() => {})
+
+                this.bot.logger.info(this.bot.isMobile, 'LOGIN-TOTP', 'TOTP authentication completed successfully')
+                return
+            }
+
+            this.bot.logger.info(this.bot.isMobile, 'LOGIN-TOTP', 'No TOTP secret provided, awaiting manual input')
+
+            for (let attempt = 1; attempt <= this.maxManualAttempts; attempt++) {
+                const code = await this.promptManualCode()
+
+                if (!code || !/^\d{6}$/.test(code)) {
+                    this.bot.logger.warn(
+                        this.bot.isMobile,
+                        'LOGIN-TOTP',
+                        `Invalid or missing TOTP code (attempt ${attempt}/${this.maxManualAttempts})`
+                    )
+
+                    if (attempt === this.maxManualAttempts) {
+                        throw new Error('Manual TOTP input failed or timed out')
+                    }
+
+                    this.bot.logger.info(
+                        this.bot.isMobile,
+                        'LOGIN-TOTP',
+                        'Retrying manual TOTP input due to invalid code'
+                    )
+                    continue
+                }
+
+                const filled = await this.fillCode(page, code)
+
+                if (!filled) {
+                    this.bot.logger.error(
+                        this.bot.isMobile,
+                        'LOGIN-TOTP',
+                        `Unable to locate or fill TOTP input field (attempt ${attempt}/${this.maxManualAttempts})`
+                    )
+
+                    if (attempt === this.maxManualAttempts) {
+                        throw new Error('TOTP input field not found')
+                    }
+
+                    this.bot.logger.info(
+                        this.bot.isMobile,
+                        'LOGIN-TOTP',
+                        'Retrying manual TOTP input due to fill failure'
+                    )
+                    continue
+                }
+
+                await this.bot.utils.wait(500)
+                await this.bot.browser.utils.ghostClick(page, this.submitButtonSelector)
+                await page.waitForLoadState('networkidle', { timeout: 5000 }).catch(() => {})
+
+                this.bot.logger.info(this.bot.isMobile, 'LOGIN-TOTP', 'TOTP authentication completed successfully')
+                return
+            }
+
+            throw new Error(`Manual TOTP input failed after ${this.maxManualAttempts} attempts`)
+        } catch (error) {
+            this.bot.logger.error(
+                this.bot.isMobile,
+                'LOGIN-TOTP',
+                `An error occurred: ${error instanceof Error ? error.message : String(error)}`
+            )
+            throw error
+        }
+    }
+}

src/config.example.json

@@ -0,0 +1,71 @@
+{
+    "baseURL": "https://rewards.bing.com",
+    "sessionPath": "sessions",
+    "headless": false,
+    "runOnZeroPoints": false,
+    "clusters": 1,
+    "errorDiagnostics": true,
+    "saveFingerprint": {
+        "mobile": false,
+        "desktop": false
+    },
+    "workers": {
+        "doDailySet": true,
+        "doMorePromotions": true,
+        "doPunchCards": true,
+        "doAppPromotions": true,
+        "doDesktopSearch": true,
+        "doMobileSearch": true,
+        "doDailyCheckIn": true,
+        "doReadToEarn": true
+    },
+    "searchOnBingLocalQueries": false,
+    "globalTimeout": "30sec",
+    "searchSettings": {
+        "scrollRandomResults": false,
+        "clickRandomResults": false,
+        "parallelSearching": true,
+        "searchResultVisitTime": "10sec",
+        "searchDelay": {
+            "min": "30sec",
+            "max": "1min"
+        },
+        "readDelay": {
+            "min": "30sec",
+            "max": "1min"
+        }
+    },
+    "debugLogs": false,
+    "consoleLogFilter": {
+        "enabled": false,
+        "mode": "whitelist",
+        "levels": ["error", "warn"],
+        "keywords": ["starting account"],
+        "regexPatterns": []
+    },
+    "proxy": {
+        "queryEngine": true
+    },
+    "webhook": {
+        "discord": {
+            "enabled": false,
+            "url": ""
+        },
+        "ntfy": {
+            "enabled": false,
+            "url": "",
+            "topic": "",
+            "token": "",
+            "title": "Microsoft-Rewards-Script",
+            "tags": ["bot", "notify"],
+            "priority": 3
+        },
+        "webhookLogFilter": {
+            "enabled": false,
+            "mode": "whitelist",
+            "levels": ["error"],
+            "keywords": ["starting account", "select number", "collected"],
+            "regexPatterns": []
+        }
+    }
+}

src/config.json

@@ -1,51 +0,0 @@
-{
-    "baseURL": "https://rewards.bing.com",
-    "sessionPath": "sessions",
-    "headless": false,
-    "parallel": false,
-    "runOnZeroPoints": false,
-    "clusters": 1,
-    "saveFingerprint": {
-        "mobile": false,
-        "desktop": false
-    },
-    "workers": {
-        "doDailySet": true,
-        "doMorePromotions": true,
-        "doPunchCards": true,
-        "doDesktopSearch": true,
-        "doMobileSearch": true,
-        "doDailyCheckIn": true,
-        "doReadToEarn": true
-    },
-    "searchOnBingLocalQueries": false,
-    "globalTimeout": "30s",
-    "searchSettings": {
-        "useGeoLocaleQueries": false,
-        "scrollRandomResults": true,
-        "clickRandomResults": true,
-        "searchDelay": {
-            "min": "3min",
-            "max": "5min"
-        },
-        "retryMobileSearchAmount": 2
-    },
-    "logExcludeFunc": [
-        "SEARCH-CLOSE-TABS"
-    ],
-    "webhookLogExcludeFunc": [
-        "SEARCH-CLOSE-TABS"
-    ],
-    "proxy": {
-        "proxyGoogleTrends": true,
-        "proxyBingTerms": true
-    },
-    "webhook": {
-        "enabled": false,
-        "url": ""
-    },
-    "conclusionWebhook": {
-        "enabled": false,
-        "url": ""
-    }
-}

src/crontab.template

@@ -1,2 +1,7 @@
+# Set PATH so cron jobs can find node/npm
+PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
+# Set timezone for cron jobs
+TZ=${TZ}
+
 # Run automation according to CRON_SCHEDULE; redirect both stdout & stderr to Docker logs
-${CRON_SCHEDULE} TZ=${TZ} /bin/bash /usr/src/microsoft-rewards-script/src/run_daily.sh >> /proc/1/fd/1 2>&1
+${CRON_SCHEDULE} /bin/bash /usr/src/microsoft-rewards-script/scripts/docker/run_daily.sh >> /proc/1/fd/1 2>&1

src/functions/Activities.ts

@@ -1,19 +1,22 @@
-import { Page } from 'rebrowser-playwright'
+import type { MicrosoftRewardsBot } from '../index'
+import type { Page } from 'patchright'
 
-import { MicrosoftRewardsBot } from '../index'
+// App
+import { DailyCheckIn } from './activities/app/DailyCheckIn'
+import { ReadToEarn } from './activities/app/ReadToEarn'
+import { AppReward } from './activities/app/AppReward'
 
-import { Search } from './activities/Search'
-import { ABC } from './activities/ABC'
-import { Poll } from './activities/Poll'
-import { Quiz } from './activities/Quiz'
-import { ThisOrThat } from './activities/ThisOrThat'
-import { UrlReward } from './activities/UrlReward'
-import { SearchOnBing } from './activities/SearchOnBing'
-import { ReadToEarn } from './activities/ReadToEarn'
-import { DailyCheckIn } from './activities/DailyCheckIn'
+// API
+import { UrlReward } from './activities/api/UrlReward'
+import { Quiz } from './activities/api/Quiz'
+import { FindClippy } from './activities/api/FindClippy'
 
-import { DashboardData, MorePromotion, PromotionalItem } from '../interface/DashboardData'
+// Browser
+import { SearchOnBing } from './activities/browser/SearchOnBing'
+import { Search } from './activities/browser/Search'
 
+import type { BasePromotion, DashboardData, FindClippyPromotion } from '../interface/DashboardData'
+import type { Promotion } from '../interface/AppDashBoardData'
 
 export default class Activities {
     private bot: MicrosoftRewardsBot
@@ -22,49 +25,67 @@ export default class Activities {
         this.bot = bot
     }
 
-    doSearch = async (page: Page, data: DashboardData): Promise<void> => {
+    // Browser Activities
+    doSearch = async (data: DashboardData, page: Page, isMobile: boolean): Promise<number> => {
         const search = new Search(this.bot)
-        await search.doSearch(page, data)
+        return await search.doSearch(data, page, isMobile)
     }
 
+    doSearchOnBing = async (promotion: BasePromotion, page: Page): Promise<void> => {
+        const searchOnBing = new SearchOnBing(this.bot)
+        await searchOnBing.doSearchOnBing(promotion, page)
+    }
+
+    /*
     doABC = async (page: Page): Promise<void> => {
         const abc = new ABC(this.bot)
         await abc.doABC(page)
     }
+    */
 
+    /*
     doPoll = async (page: Page): Promise<void> => {
         const poll = new Poll(this.bot)
         await poll.doPoll(page)
     }
+    */
 
+    /*
     doThisOrThat = async (page: Page): Promise<void> => {
         const thisOrThat = new ThisOrThat(this.bot)
         await thisOrThat.doThisOrThat(page)
     }
+    */
 
-    doQuiz = async (page: Page): Promise<void> => {
-        const quiz = new Quiz(this.bot)
-        await quiz.doQuiz(page)
-    }
-
-    doUrlReward = async (page: Page): Promise<void> => {
+    // API Activities
+    doUrlReward = async (promotion: BasePromotion): Promise<void> => {
         const urlReward = new UrlReward(this.bot)
-        await urlReward.doUrlReward(page)
+        await urlReward.doUrlReward(promotion)
     }
 
-    doSearchOnBing = async (page: Page, activity: MorePromotion | PromotionalItem): Promise<void> => {
-        const searchOnBing = new SearchOnBing(this.bot)
-        await searchOnBing.doSearchOnBing(page, activity)
+    doQuiz = async (promotion: BasePromotion): Promise<void> => {
+        const quiz = new Quiz(this.bot)
+        await quiz.doQuiz(promotion)
     }
 
-    doReadToEarn = async (accessToken: string, data: DashboardData): Promise<void> => {
+    doFindClippy = async (promotions: FindClippyPromotion): Promise<void> => {
+        const urlReward = new FindClippy(this.bot)
+        await urlReward.doFindClippy(promotions)
+    }
+
+    // App Activities
+    doAppReward = async (promotion: Promotion): Promise<void> => {
+        const urlReward = new AppReward(this.bot)
+        await urlReward.doAppReward(promotion)
+    }
+
+    doReadToEarn = async (): Promise<void> => {
         const readToEarn = new ReadToEarn(this.bot)
-        await readToEarn.doReadToEarn(accessToken, data)
+        await readToEarn.doReadToEarn()
     }
 
-    doDailyCheckIn = async (accessToken: string, data: DashboardData): Promise<void> => {
+    doDailyCheckIn = async (): Promise<void> => {
         const dailyCheckIn = new DailyCheckIn(this.bot)
-        await dailyCheckIn.doDailyCheckIn(accessToken, data)
+        await dailyCheckIn.doDailyCheckIn()
     }
-
-}
+}

src/functions/Login.ts

@@ -1,562 +0,0 @@
-import type { Page } from 'playwright'
-import readline from 'readline'
-import * as crypto from 'crypto'
-import { AxiosRequestConfig } from 'axios'
-
-import { MicrosoftRewardsBot } from '../index'
-import { saveSessionData } from '../util/Load'
-
-import { OAuth } from '../interface/OAuth'
-
-
-const rl = readline.createInterface({
-    // Use as any to avoid strict typing issues with our minimal process shim
-    input: (process as any).stdin,
-    output: (process as any).stdout
-})
-
-export class Login {
-    private bot: MicrosoftRewardsBot
-    private clientId: string = '0000000040170455'
-    private authBaseUrl: string = 'https://login.live.com/oauth20_authorize.srf'
-    private redirectUrl: string = 'https://login.live.com/oauth20_desktop.srf'
-    private tokenUrl: string = 'https://login.microsoftonline.com/consumers/oauth2/v2.0/token'
-    private scope: string = 'service::prod.rewardsplatform.microsoft.com::MBI_SSL'
-    // Flag to prevent spamming passkey logs after first handling
-    private passkeyHandled: boolean = false
-
-    constructor(bot: MicrosoftRewardsBot) {
-        this.bot = bot
-    }
-
-    async login(page: Page, email: string, password: string) {
-
-        try {
-            this.bot.log(this.bot.isMobile, 'LOGIN', 'Starting login process!')
-
-            // Navigate to the Bing login page
-            await page.goto('https://www.bing.com/rewards/dashboard')
-
-            // Disable FIDO support in login request
-            await page.route('**/GetCredentialType.srf*', (route: any) => {
-                const body = JSON.parse(route.request().postData() || '{}')
-                body.isFidoSupported = false
-                route.continue({ postData: JSON.stringify(body) })
-            })
-
-            await page.waitForLoadState('domcontentloaded').catch(() => { })
-
-            await this.bot.browser.utils.reloadBadPage(page)
-
-            // Check if account is locked
-            await this.checkAccountLocked(page)
-
-            const isLoggedIn = await page.waitForSelector('html[data-role-name="RewardsPortal"]', { timeout: 10000 }).then(() => true).catch(() => false)
-
-            if (!isLoggedIn) {
-                await this.execLogin(page, email, password)
-                this.bot.log(this.bot.isMobile, 'LOGIN', 'Logged into Microsoft successfully')
-            } else {
-                this.bot.log(this.bot.isMobile, 'LOGIN', 'Already logged in')
-
-                // Check if account is locked
-                await this.checkAccountLocked(page)
-            }
-
-            // Check if logged in to bing
-            await this.checkBingLogin(page)
-
-            // Save session
-            await saveSessionData(this.bot.config.sessionPath, page.context(), email, this.bot.isMobile)
-
-            // We're done logging in
-            this.bot.log(this.bot.isMobile, 'LOGIN', 'Logged in successfully, saved login session!')
-
-        } catch (error) {
-            // Throw and don't continue
-            throw this.bot.log(this.bot.isMobile, 'LOGIN', 'An error occurred:' + error, 'error')
-        }
-    }
-
-    private async execLogin(page: Page, email: string, password: string) {
-        try {
-            await this.enterEmail(page, email)
-            await this.bot.utils.wait(2000)
-            await this.bot.browser.utils.reloadBadPage(page)
-            await this.bot.utils.wait(2000)
-            await this.enterPassword(page, password)
-            await this.bot.utils.wait(2000)
-
-            // Check if account is locked
-            await this.checkAccountLocked(page)
-
-            await this.bot.browser.utils.reloadBadPage(page)
-            await this.checkLoggedIn(page)
-        } catch (error) {
-            this.bot.log(this.bot.isMobile, 'LOGIN', 'An error occurred: ' + error, 'error')
-        }
-    }
-
-    private async enterEmail(page: Page, email: string) {
-        const emailInputSelector = 'input[type="email"]'
-
-        try {
-            // Wait for email field
-            const emailField = await page.waitForSelector(emailInputSelector, { state: 'visible', timeout: 2000 }).catch(() => null)
-            if (!emailField) {
-                this.bot.log(this.bot.isMobile, 'LOGIN', 'Email field not found', 'warn')
-                return
-            }
-
-            await this.bot.utils.wait(1000)
-
-            // Check if email is prefilled
-            const emailPrefilled = await page.waitForSelector('#userDisplayName', { timeout: 5000 }).catch(() => null)
-            if (emailPrefilled) {
-                this.bot.log(this.bot.isMobile, 'LOGIN', 'Email already prefilled by Microsoft')
-            } else {
-                // Else clear and fill email
-                await page.fill(emailInputSelector, '')
-                await this.bot.utils.wait(500)
-                await page.fill(emailInputSelector, email)
-                await this.bot.utils.wait(1000)
-            }
-
-            const nextButton = await page.waitForSelector('button[type="submit"]', { timeout: 2000 }).catch(() => null)
-            if (nextButton) {
-                await nextButton.click()
-                await this.bot.utils.wait(2000)
-                this.bot.log(this.bot.isMobile, 'LOGIN', 'Email entered successfully')
-            } else {
-                this.bot.log(this.bot.isMobile, 'LOGIN', 'Next button not found after email entry', 'warn')
-            }
-
-        } catch (error) {
-            this.bot.log(this.bot.isMobile, 'LOGIN', `Email entry failed: ${error}`, 'error')
-        }
-    }
-
-    private async enterPassword(page: Page, password: string) {
-        const passwordInputSelector = 'input[type="password"]'
-        const skip2FASelector = '#idA_PWD_SwitchToPassword';
-        try {
-            const skip2FAButton = await page.waitForSelector(skip2FASelector, { timeout: 2000 }).catch(() => null)
-            if (skip2FAButton) {
-                await skip2FAButton.click()
-                await this.bot.utils.wait(2000)
-                this.bot.log(this.bot.isMobile, 'LOGIN', 'Skipped 2FA')
-            } else {
-                this.bot.log(this.bot.isMobile, 'LOGIN', 'No 2FA skip button found, proceeding with password entry')
-            }
-            const viewFooter = await page.waitForSelector('#view > div > span:nth-child(6)', { timeout: 2000 }).catch(() => null)
-            const passwordField1 = await page.waitForSelector(passwordInputSelector, { timeout: 5000 }).catch(() => null)
-            if (viewFooter && !passwordField1) {
-                this.bot.log(this.bot.isMobile, 'LOGIN', 'Page "Get a code to sign in" found by "viewFooter"')
-
-                const otherWaysButton = await viewFooter.$('span[role="button"]')
-                if (otherWaysButton) {
-                    await otherWaysButton.click()
-                    await this.bot.utils.wait(5000)
-
-                    const secondListItem = page.locator('[role="listitem"]').nth(1)
-                    if (await secondListItem.isVisible()) {
-                        await secondListItem.click()
-                    }
-                }
-            }
-
-            // Wait for password field
-            const passwordField = await page.waitForSelector(passwordInputSelector, { state: 'visible', timeout: 5000 }).catch(() => null)
-            if (!passwordField) {
-                this.bot.log(this.bot.isMobile, 'LOGIN', 'Password field not found, possibly 2FA required', 'warn')
-                await this.handle2FA(page)
-                return
-            }
-
-            await this.bot.utils.wait(1000)
-
-            // Clear and fill password
-            await page.fill(passwordInputSelector, '')
-            await this.bot.utils.wait(500)
-            await page.fill(passwordInputSelector, password)
-            await this.bot.utils.wait(1000)
-
-            const nextButton = await page.waitForSelector('button[type="submit"]', { timeout: 2000 }).catch(() => null)
-            if (nextButton) {
-                await nextButton.click()
-                await this.bot.utils.wait(2000)
-                this.bot.log(this.bot.isMobile, 'LOGIN', 'Password entered successfully')
-            } else {
-                this.bot.log(this.bot.isMobile, 'LOGIN', 'Next button not found after password entry', 'warn')
-            }
-
-        } catch (error) {
-            this.bot.log(this.bot.isMobile, 'LOGIN', `Password entry failed: ${error}`, 'error')
-            await this.handle2FA(page)
-        }
-    }
-
-    private async handle2FA(page: Page) {
-        try {
-            const numberToPress = await this.get2FACode(page)
-            if (numberToPress) {
-                // Authenticator App verification
-                await this.authAppVerification(page, numberToPress)
-            } else {
-                // SMS verification
-                await this.authSMSVerification(page)
-            }
-        } catch (error) {
-            this.bot.log(this.bot.isMobile, 'LOGIN', `2FA handling failed: ${error}`)
-        }
-    }
-
-    private async get2FACode(page: Page): Promise<string | null> {
-        try {
-            const element = await page.waitForSelector('#displaySign, div[data-testid="displaySign"]>span', { state: 'visible', timeout: 2000 })
-            return await element.textContent()
-        } catch {
-            if (this.bot.config.parallel) {
-                this.bot.log(this.bot.isMobile, 'LOGIN', 'Script running in parallel, can only send 1 2FA request per account at a time!', 'log', 'yellow')
-                this.bot.log(this.bot.isMobile, 'LOGIN', 'Trying again in 60 seconds! Please wait...', 'log', 'yellow')
-
-                // eslint-disable-next-line no-constant-condition
-                while (true) {
-                    const button = await page.waitForSelector('button[aria-describedby="pushNotificationsTitle errorDescription"]', { state: 'visible', timeout: 2000 }).catch(() => null)
-                    if (button) {
-                        await this.bot.utils.wait(60000)
-                        await button.click()
-
-                        continue
-                    } else {
-                        break
-                    }
-                }
-            }
-
-            await page.click('button[aria-describedby="confirmSendTitle"]').catch(() => { })
-            await this.bot.utils.wait(2000)
-            const element = await page.waitForSelector('#displaySign, div[data-testid="displaySign"]>span', { state: 'visible', timeout: 2000 })
-            return await element.textContent()
-        }
-    }
-
-    private async authAppVerification(page: Page, numberToPress: string | null) {
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            try {
-                this.bot.log(this.bot.isMobile, 'LOGIN', `Press the number ${numberToPress} on your Authenticator app to approve the login`)
-                this.bot.log(this.bot.isMobile, 'LOGIN', 'If you press the wrong number or the "DENY" button, try again in 60 seconds')
-
-                await page.waitForSelector('form[name="f1"]', { state: 'detached', timeout: 60000 })
-
-                this.bot.log(this.bot.isMobile, 'LOGIN', 'Login successfully approved!')
-                break
-            } catch {
-                this.bot.log(this.bot.isMobile, 'LOGIN', 'The code is expired. Trying to get a new code...')
-                // await page.click('button[aria-describedby="pushNotificationsTitle errorDescription"]')
-                const primaryButton = await page.waitForSelector('button[data-testid="primaryButton"]', { state: 'visible', timeout: 5000 }).catch(() => null)
-                if (primaryButton) {
-                    await primaryButton.click()
-                }
-                numberToPress = await this.get2FACode(page)
-            }
-        }
-    }
-
-    private async authSMSVerification(page: Page) {
-        this.bot.log(this.bot.isMobile, 'LOGIN', 'SMS 2FA code required. Waiting for user input...')
-
-        const code = await new Promise<string>((resolve) => {
-            rl.question('Enter 2FA code:\n', (input: string) => {
-                rl.close()
-                resolve(input)
-            })
-        })
-
-        await page.fill('input[name="otc"]', code)
-        await page.keyboard.press('Enter')
-        this.bot.log(this.bot.isMobile, 'LOGIN', '2FA code entered successfully')
-    }
-
-    async getMobileAccessToken(page: Page, email: string) {
-        const authorizeUrl = new URL(this.authBaseUrl)
-
-        authorizeUrl.searchParams.append('response_type', 'code')
-        authorizeUrl.searchParams.append('client_id', this.clientId)
-        authorizeUrl.searchParams.append('redirect_uri', this.redirectUrl)
-        authorizeUrl.searchParams.append('scope', this.scope)
-        authorizeUrl.searchParams.append('state', crypto.randomBytes(16).toString('hex'))
-        authorizeUrl.searchParams.append('access_type', 'offline_access')
-        authorizeUrl.searchParams.append('login_hint', email)
-
-        // Disable FIDO for OAuth flow as well (reduces passkey prompts resurfacing)
-        await page.route('**/GetCredentialType.srf*', (route: any) => {
-            const body = JSON.parse(route.request().postData() || '{}')
-            body.isFidoSupported = false
-            route.continue({ postData: JSON.stringify(body) })
-        }).catch(()=>{})
-
-        await page.goto(authorizeUrl.href)
-
-        let currentUrl = new URL(page.url())
-        let code: string
-
-        const authStart = Date.now()
-        this.bot.log(this.bot.isMobile, 'LOGIN-APP', 'Waiting for authorization...')
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            // Attempt to dismiss passkey/passkey-like screens quickly (non-blocking)
-            await this.tryDismissPasskeyPrompt(page)
-            if (currentUrl.hostname === 'login.live.com' && currentUrl.pathname === '/oauth20_desktop.srf') {
-                code = currentUrl.searchParams.get('code')!
-                break
-            }
-
-            currentUrl = new URL(page.url())
-            // Shorter wait to react faster to passkey prompt
-            await this.bot.utils.wait(1000)
-        }
-
-        const body = new URLSearchParams()
-        body.append('grant_type', 'authorization_code')
-        body.append('client_id', this.clientId)
-        body.append('code', code)
-        body.append('redirect_uri', this.redirectUrl)
-
-        const tokenRequest: AxiosRequestConfig = {
-            url: this.tokenUrl,
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/x-www-form-urlencoded'
-            },
-            data: body.toString()
-        }
-
-        const tokenResponse = await this.bot.axios.request(tokenRequest)
-        const tokenData: OAuth = await tokenResponse.data
-
-        const authDuration = Date.now() - authStart
-        this.bot.log(this.bot.isMobile, 'LOGIN-APP', `Successfully authorized in ${Math.round(authDuration/1000)}s`)
-        return tokenData.access_token
-    }
-
-    // Utils
-
-    private async checkLoggedIn(page: Page) {
-        const targetHostname = 'rewards.bing.com'
-        const targetPathname = '/'
-
-        const start = Date.now()
-        const maxWaitMs = Number(process.env.LOGIN_MAX_WAIT_MS || 180000) // default 3 minutes
-        let guidanceLogged = false
-
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-            await this.dismissLoginMessages(page)
-            const currentURL = new URL(page.url())
-            if (currentURL.hostname === targetHostname && currentURL.pathname === targetPathname) {
-                break
-            }
-
-            // If we keep looping without prompts for too long, advise and fail fast
-            const elapsed = Date.now() - start
-            if (elapsed > maxWaitMs) {
-                if (!guidanceLogged) {
-                    this.bot.log(this.bot.isMobile, 'LOGIN-GUIDE', 'Login taking too long without prompts.')
-                    this.bot.log(this.bot.isMobile, 'LOGIN-GUIDE', 'Tip: Enable passwordless sign-in (Microsoft Authenticator "number match") or add a TOTP secret in accounts.json to auto-fill OTP.')
-                    this.bot.log(this.bot.isMobile, 'LOGIN-GUIDE', 'You can also set LOGIN_MAX_WAIT_MS to increase this timeout if needed.')
-                    guidanceLogged = true
-                }
-                throw this.bot.log(this.bot.isMobile, 'LOGIN-TIMEOUT', `Login timed out after ${Math.round(elapsed/1000)}s without completing`, 'error')
-            }
-        }
-
-        // Wait for login to complete
-        await page.waitForSelector('html[data-role-name="RewardsPortal"]', { timeout: 10000 })
-        this.bot.log(this.bot.isMobile, 'LOGIN', 'Successfully logged into the rewards portal')
-    }
-
-    private lastNoPromptLog: number = 0
-    private noPromptIterations: number = 0
-    private async dismissLoginMessages(page: Page) {
-        let didSomething = false
-
-        // PASSKEY / Windows Hello / Sign in faster
-        const passkeyVideo = await page.waitForSelector('[data-testid="biometricVideo"]', { timeout: 1000 }).catch(() => null)
-        if (passkeyVideo) {
-            const skipButton = await page.$('button[data-testid="secondaryButton"]')
-            if (skipButton) {
-                await skipButton.click().catch(()=>{})
-                if (!this.passkeyHandled) {
-                    this.bot.log(this.bot.isMobile, 'LOGIN-PASSKEY', 'Passkey dialog detected (video heuristic) -> clicked "Skip for now"')
-                }
-                this.passkeyHandled = true
-                await page.waitForTimeout(300)
-                didSomething = true
-            }
-        }
-        if (!didSomething) {
-            const titleEl = await page.waitForSelector('[data-testid="title"]', { timeout: 800 }).catch(() => null)
-            const titleText = (titleEl ? (await titleEl.textContent()) : '')?.trim() || ''
-            const looksLikePasskey = /sign in faster|passkey|fingerprint|face|pin/i.test(titleText)
-            const secondaryBtn = await page.waitForSelector('button[data-testid="secondaryButton"]', { timeout: 500 }).catch(() => null)
-            const primaryBtn = await page.waitForSelector('button[data-testid="primaryButton"]', { timeout: 500 }).catch(() => null)
-            if (looksLikePasskey && secondaryBtn) {
-                await secondaryBtn.click().catch(()=>{})
-                if (!this.passkeyHandled) {
-                    this.bot.log(this.bot.isMobile, 'LOGIN-PASSKEY', `Passkey dialog detected (title: "${titleText}") -> clicked secondary`)
-                }
-                this.passkeyHandled = true
-                await page.waitForTimeout(300)
-                didSomething = true
-            } else if (!didSomething && secondaryBtn && primaryBtn) {
-                const secText = (await secondaryBtn.textContent() || '').trim()
-                if (/skip for now/i.test(secText)) {
-                    await secondaryBtn.click().catch(()=>{})
-                    if (!this.passkeyHandled) {
-                        this.bot.log(this.bot.isMobile, 'LOGIN-PASSKEY', 'Passkey dialog (pair heuristic) -> clicked secondary (Skip for now)')
-                    }
-                    this.passkeyHandled = true
-                    await page.waitForTimeout(300)
-                    didSomething = true
-                }
-            }
-            if (!didSomething) {
-                const skipByText = await page.locator('xpath=//button[contains(normalize-space(.), "Skip for now")]').first()
-                if (await skipByText.isVisible().catch(()=>false)) {
-                    await skipByText.click().catch(()=>{})
-                    if (!this.passkeyHandled) {
-                        this.bot.log(this.bot.isMobile, 'LOGIN-PASSKEY', 'Passkey dialog (text fallback) -> clicked "Skip for now"')
-                    }
-                    this.passkeyHandled = true
-                    await page.waitForTimeout(300)
-                    didSomething = true
-                }
-            }
-            if (!didSomething) {
-                const closeBtn = await page.$('#close-button')
-                if (closeBtn) {
-                    await closeBtn.click().catch(()=>{})
-                    if (!this.passkeyHandled) {
-                        this.bot.log(this.bot.isMobile, 'LOGIN-PASSKEY', 'Attempted close button on potential passkey modal')
-                    }
-                    this.passkeyHandled = true
-                    await page.waitForTimeout(300)
-                }
-            }
-        }
-
-        // KMSI (Keep me signed in) prompt
-        const kmsi = await page.waitForSelector('[data-testid="kmsiVideo"]', { timeout: 800 }).catch(()=>null)
-        if (kmsi) {
-            const yesButton = await page.$('button[data-testid="primaryButton"]')
-            if (yesButton) {
-                await yesButton.click().catch(()=>{})
-                this.bot.log(this.bot.isMobile, 'LOGIN-KMSI', 'KMSI dialog detected -> accepted (Yes)')
-                await page.waitForTimeout(300)
-                didSomething = true
-            }
-        }
-
-        if (!didSomething) {
-            this.noPromptIterations++
-            const now = Date.now()
-            if (this.noPromptIterations === 1 || (now - this.lastNoPromptLog) > 10000) {
-                this.lastNoPromptLog = now
-                this.bot.log(this.bot.isMobile, 'LOGIN-NO-PROMPT', `No dialogs (x${this.noPromptIterations})`)
-                // Reset counter if it grows large to keep number meaningful
-                if (this.noPromptIterations > 50) this.noPromptIterations = 0
-            }
-        } else {
-            // Reset counters after an interaction
-            this.noPromptIterations = 0
-        }
-    }
-
-    /** Lightweight passkey prompt dismissal used in mobile OAuth loop */
-    private async tryDismissPasskeyPrompt(page: Page) {
-        try {
-            // Fast existence checks with very small timeouts to avoid slowing the loop
-            const titleEl = await page.waitForSelector('[data-testid="title"]', { timeout: 500 }).catch(() => null)
-            const secondaryBtn = await page.waitForSelector('button[data-testid="secondaryButton"]', { timeout: 500 }).catch(() => null)
-            // Direct text locator fallback (sometimes data-testid changes)
-            const textSkip = secondaryBtn ? null : await page.locator('xpath=//button[contains(normalize-space(.), "Skip for now")]').first().isVisible().catch(()=>false)
-            if (secondaryBtn) {
-                // Heuristic: if title indicates passkey or both primary/secondary exist with typical text
-                let shouldClick = false
-                let titleText = ''
-                if (titleEl) {
-                    titleText = (await titleEl.textContent() || '').trim()
-                    if (/sign in faster|passkey|fingerprint|face|pin/i.test(titleText)) {
-                        shouldClick = true
-                    }
-                }
-                if (!shouldClick && textSkip) {
-                    shouldClick = true
-                }
-                if (!shouldClick) {
-                    // Fallback text probe on the secondary button itself
-                    const btnText = (await secondaryBtn.textContent() || '').trim()
-                    if (/skip for now/i.test(btnText)) {
-                        shouldClick = true
-                    }
-                }
-                if (shouldClick) {
-                    await secondaryBtn.click().catch(() => { })
-                    if (!this.passkeyHandled) {
-                        this.bot.log(this.bot.isMobile, 'LOGIN-PASSKEY', `Passkey prompt (loop) -> clicked skip${titleText ? ` (title: ${titleText})` : ''}`)
-                    }
-                    this.passkeyHandled = true
-                    await this.bot.utils.wait(500)
-                }
-            }
-        } catch { /* ignore minor errors */ }
-    }
-
-    private async checkBingLogin(page: Page): Promise<void> {
-        try {
-            this.bot.log(this.bot.isMobile, 'LOGIN-BING', 'Verifying Bing login')
-            await page.goto('https://www.bing.com/fd/auth/signin?action=interactive&provider=windows_live_id&return_url=https%3A%2F%2Fwww.bing.com%2F')
-
-            const maxIterations = 5
-
-            for (let iteration = 1; iteration <= maxIterations; iteration++) {
-                const currentUrl = new URL(page.url())
-
-                if (currentUrl.hostname === 'www.bing.com' && currentUrl.pathname === '/') {
-                    await this.bot.browser.utils.tryDismissAllMessages(page)
-
-                    const loggedIn = await this.checkBingLoginStatus(page)
-                    // If mobile browser, skip this step
-                    if (loggedIn || this.bot.isMobile) {
-                        this.bot.log(this.bot.isMobile, 'LOGIN-BING', 'Bing login verification passed!')
-                        break
-                    }
-                }
-
-                await this.bot.utils.wait(1000)
-            }
-
-        } catch (error) {
-            this.bot.log(this.bot.isMobile, 'LOGIN-BING', 'An error occurred:' + error, 'error')
-        }
-    }
-
-    private async checkBingLoginStatus(page: Page): Promise<boolean> {
-        try {
-            await page.waitForSelector('#id_n', { timeout: 5000 })
-            return true
-        } catch (error) {
-            return false
-        }
-    }
-
-    private async checkAccountLocked(page: Page) {
-        await this.bot.utils.wait(2000)
-        const isLocked = await page.waitForSelector('#serviceAbuseLandingTitle', { state: 'visible', timeout: 1000 }).then(() => true).catch(() => false)
-        if (isLocked) {
-            throw this.bot.log(this.bot.isMobile, 'CHECK-LOCKED', 'This account has been locked! Remove the account from "accounts.json" and restart!', 'error')
-        }
-    }
-}

src/functions/QueryEngine.ts

@@ -0,0 +1,191 @@
+import type { AxiosRequestConfig } from 'axios'
+import type {
+    BingSuggestionResponse,
+    BingTrendingTopicsResponse,
+    GoogleSearch,
+    GoogleTrendsResponse
+} from '../interface/Search'
+import type { MicrosoftRewardsBot } from '../index'
+
+export class QueryCore {
+    constructor(private bot: MicrosoftRewardsBot) {}
+
+    async getGoogleTrends(geoLocale: string): Promise<string[]> {
+        const queryTerms: GoogleSearch[] = []
+        this.bot.logger.info(
+            this.bot.isMobile,
+            'SEARCH-GOOGLE-TRENDS',
+            `Generating search queries, can take a while! | GeoLocale: ${geoLocale}`
+        )
+
+        try {
+            const request: AxiosRequestConfig = {
+                url: 'https://trends.google.com/_/TrendsUi/data/batchexecute',
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8'
+                },
+                data: `f.req=[[[i0OFE,"[null, null, \\"${geoLocale.toUpperCase()}\\", 0, null, 48]"]]]`
+            }
+
+            const response = await this.bot.axios.request(request, this.bot.config.proxy.queryEngine)
+            const rawData = response.data
+
+            const trendsData = this.extractJsonFromResponse(rawData)
+            if (!trendsData) {
+                throw this.bot.logger.error(
+                    this.bot.isMobile,
+                    'SEARCH-GOOGLE-TRENDS',
+                    'Failed to parse Google Trends response'
+                )
+            }
+
+            const mappedTrendsData = trendsData.map(query => [query[0], query[9]!.slice(1)])
+            if (mappedTrendsData.length < 90) {
+                this.bot.logger.warn(
+                    this.bot.isMobile,
+                    'SEARCH-GOOGLE-TRENDS',
+                    'Insufficient search queries, falling back to US'
+                )
+                return this.getGoogleTrends('US')
+            }
+
+            for (const [topic, relatedQueries] of mappedTrendsData) {
+                queryTerms.push({
+                    topic: topic as string,
+                    related: relatedQueries as string[]
+                })
+            }
+        } catch (error) {
+            this.bot.logger.error(
+                this.bot.isMobile,
+                'SEARCH-GOOGLE-TRENDS',
+                `An error occurred: ${error instanceof Error ? error.message : String(error)}`
+            )
+        }
+
+        const queries = queryTerms.flatMap(x => [x.topic, ...x.related])
+
+        return queries
+    }
+
+    private extractJsonFromResponse(text: string): GoogleTrendsResponse[1] | null {
+        const lines = text.split('\n')
+        for (const line of lines) {
+            const trimmed = line.trim()
+            if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+                try {
+                    return JSON.parse(JSON.parse(trimmed)[0][2])[1]
+                } catch {
+                    continue
+                }
+            }
+        }
+
+        return null
+    }
+
+    async getBingSuggestions(query: string = '', langCode: string = 'en'): Promise<string[]> {
+        this.bot.logger.info(
+            this.bot.isMobile,
+            'SEARCH-BING-SUGGESTIONS',
+            `Generating bing suggestions! | LangCode: ${langCode}`
+        )
+
+        try {
+            const request: AxiosRequestConfig = {
+                url: `https://www.bingapis.com/api/v7/suggestions?q=${encodeURIComponent(query)}&appid=6D0A9B8C5100E9ECC7E11A104ADD76C10219804B&cc=xl&setlang=${langCode}`,
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8'
+                }
+            }
+
+            const response = await this.bot.axios.request(request, this.bot.config.proxy.queryEngine)
+            const rawData: BingSuggestionResponse = response.data
+
+            const searchSuggestions = rawData.suggestionGroups[0]?.searchSuggestions
+
+            if (!searchSuggestions?.length) {
+                this.bot.logger.warn(this.bot.isMobile, 'SEARCH-BING-SUGGESTIONS', 'API returned no results')
+                return []
+            }
+
+            return searchSuggestions.map(x => x.query)
+        } catch (error) {
+            this.bot.logger.error(
+                this.bot.isMobile,
+                'SEARCH-GOOGLE-TRENDS',
+                `An error occurred: ${error instanceof Error ? error.message : String(error)}`
+            )
+        }
+
+        return []
+    }
+
+    async getBingRelatedTerms(term: string): Promise<string[]> {
+        try {
+            const request = {
+                url: `https://api.bing.com/osjson.aspx?query=${term}`,
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            }
+
+            const response = await this.bot.axios.request(request, this.bot.config.proxy.queryEngine)
+            const rawData = response.data
+
+            const relatedTerms = rawData[1]
+
+            if (!relatedTerms?.length) {
+                this.bot.logger.warn(this.bot.isMobile, 'SEARCH-BING-RELATED', 'API returned no results')
+                return []
+            }
+
+            return relatedTerms
+        } catch (error) {
+            this.bot.logger.error(
+                this.bot.isMobile,
+                'SEARCH-BING-RELATED',
+                `An error occurred: ${error instanceof Error ? error.message : String(error)}`
+            )
+        }
+
+        return []
+    }
+
+    async getBingTendingTopics(langCode: string = 'en'): Promise<string[]> {
+        try {
+            const request = {
+                url: `https://www.bing.com/api/v7/news/trendingtopics?appid=91B36E34F9D1B900E54E85A77CF11FB3BE5279E6&cc=xl&setlang=${langCode}`,
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            }
+
+            const response = await this.bot.axios.request(request, this.bot.config.proxy.queryEngine)
+            const rawData: BingTrendingTopicsResponse = response.data
+
+            const trendingTopics = rawData.value
+
+            if (!trendingTopics?.length) {
+                this.bot.logger.warn(this.bot.isMobile, 'SEARCH-BING-TRENDING', 'API returned no results')
+                return []
+            }
+
+            const queries = trendingTopics.map(x => x.query?.text?.trim() || x.name.trim())
+
+            return queries
+        } catch (error) {
+            this.bot.logger.error(
+                this.bot.isMobile,
+                'SEARCH-BING-TRENDING',
+                `An error occurred: ${error instanceof Error ? error.message : String(error)}`
+            )
+        }
+
+        return []
+    }
+}

src/functions/SearchManager.ts

@@ -0,0 +1,618 @@
+import type { BrowserContext } from 'patchright'
+import type { BrowserFingerprintWithHeaders } from 'fingerprint-generator'
+import { MicrosoftRewardsBot, executionContext } from '../index'
+import type { DashboardData } from '../interface/DashboardData'
+import type { Account } from '../interface/Account'
+
+interface BrowserSession {
+    context: BrowserContext
+    fingerprint: BrowserFingerprintWithHeaders
+}
+
+interface MissingSearchPoints {
+    mobilePoints: number
+    desktopPoints: number
+}
+
+interface SearchResults {
+    mobilePoints: number
+    desktopPoints: number
+}
+
+export class SearchManager {
+    constructor(private bot: MicrosoftRewardsBot) {}
+
+    async doSearches(
+        data: DashboardData,
+        missingSearchPoints: MissingSearchPoints,
+        mobileSession: BrowserSession,
+        account: Account,
+        accountEmail: string
+    ): Promise<SearchResults> {
+        this.bot.logger.debug(
+            'main',
+            'SEARCH-MANAGER',
+            `Start | account=${accountEmail} | mobileMissing=${missingSearchPoints.mobilePoints} | desktopMissing=${missingSearchPoints.desktopPoints}`
+        )
+
+        const doMobile = this.bot.config.workers.doMobileSearch && missingSearchPoints.mobilePoints > 0
+        const doDesktop = this.bot.config.workers.doDesktopSearch && missingSearchPoints.desktopPoints > 0
+
+        const mobileStatus = this.bot.config.workers.doMobileSearch
+            ? missingSearchPoints.mobilePoints > 0
+                ? 'run'
+                : 'skip-no-points'
+            : 'skip-disabled'
+        const desktopStatus = this.bot.config.workers.doDesktopSearch
+            ? missingSearchPoints.desktopPoints > 0
+                ? 'run'
+                : 'skip-no-points'
+            : 'skip-disabled'
+
+        this.bot.logger.info(
+            'main',
+            'SEARCH-MANAGER',
+            `Mobile: ${mobileStatus} (enabled=${this.bot.config.workers.doMobileSearch}, missing=${missingSearchPoints.mobilePoints})`
+        )
+        this.bot.logger.info(
+            'main',
+            'SEARCH-MANAGER',
+            `Desktop: ${desktopStatus} (enabled=${this.bot.config.workers.doDesktopSearch}, missing=${missingSearchPoints.desktopPoints})`
+        )
+
+        if (!doMobile && !doDesktop) {
+            const bothWorkersEnabled = this.bot.config.workers.doMobileSearch && this.bot.config.workers.doDesktopSearch
+            const bothNoPoints = missingSearchPoints.mobilePoints <= 0 && missingSearchPoints.desktopPoints <= 0
+
+            if (bothWorkersEnabled && bothNoPoints) {
+                this.bot.logger.info(
+                    'main',
+                    'SEARCH-MANAGER',
+                    'All searches skipped: no mobile or desktop points left.'
+                )
+            } else {
+                this.bot.logger.info('main', 'SEARCH-MANAGER', 'No searches scheduled (disabled or no points).')
+            }
+
+            this.bot.logger.info('main', 'SEARCH-MANAGER', 'Closing mobile session')
+            try {
+                await executionContext.run({ isMobile: true, accountEmail }, async () => {
+                    await this.bot.browser.func.closeBrowser(mobileSession.context, accountEmail)
+                })
+                this.bot.logger.info('main', 'SEARCH-MANAGER', 'Mobile session closed')
+            } catch (error) {
+                this.bot.logger.warn(
+                    'main',
+                    'SEARCH-MANAGER',
+                    `Failed to close mobile session: ${error instanceof Error ? error.message : String(error)}`
+                )
+                if (error instanceof Error && error.stack) {
+                    this.bot.logger.debug('main', 'SEARCH-MANAGER', `Mobile close stack: ${error.stack}`)
+                }
+            }
+            return { mobilePoints: 0, desktopPoints: 0 }
+        }
+
+        const useParallel = this.bot.config.searchSettings.parallelSearching
+        this.bot.logger.info('main', 'SEARCH-MANAGER', `Mode: ${useParallel ? 'parallel' : 'sequential'}`)
+        this.bot.logger.debug('main', 'SEARCH-MANAGER', `parallelSearching=${useParallel} | account=${accountEmail}`)
+
+        if (useParallel) {
+            return await this.doParallelSearches(
+                data,
+                missingSearchPoints,
+                mobileSession,
+                account,
+                accountEmail,
+                executionContext
+            )
+        } else {
+            return await this.doSequentialSearches(
+                data,
+                missingSearchPoints,
+                mobileSession,
+                account,
+                accountEmail,
+                executionContext
+            )
+        }
+    }
+
+    private async doParallelSearches(
+        data: DashboardData,
+        missingSearchPoints: MissingSearchPoints,
+        mobileSession: BrowserSession,
+        account: Account,
+        accountEmail: string,
+        executionContext: any
+    ): Promise<SearchResults> {
+        this.bot.logger.info('main', 'SEARCH-MANAGER', 'Parallel start')
+        this.bot.logger.debug(
+            'main',
+            'SEARCH-MANAGER',
+            `Parallel config | account=${accountEmail} | mobileMissing=${missingSearchPoints.mobilePoints} | desktopMissing=${missingSearchPoints.desktopPoints}`
+        )
+
+        const shouldDoMobile = this.bot.config.workers.doMobileSearch && missingSearchPoints.mobilePoints > 0
+        const shouldDoDesktop = this.bot.config.workers.doDesktopSearch && missingSearchPoints.desktopPoints > 0
+
+        this.bot.logger.debug(
+            'main',
+            'SEARCH-MANAGER',
+            `Parallel flags | mobile=${shouldDoMobile} | desktop=${shouldDoDesktop}`
+        )
+
+        let desktopSession: BrowserSession | null = null
+        let mobileContextClosed = false
+
+        try {
+            const promises: Promise<number>[] = []
+            const searchTypes: string[] = []
+
+            if (shouldDoMobile) {
+                this.bot.logger.debug(
+                    'main',
+                    'SEARCH-MANAGER',
+                    `Schedule mobile | target=${missingSearchPoints.mobilePoints}`
+                )
+                searchTypes.push('Mobile')
+                promises.push(
+                    this.doMobileSearch(data, missingSearchPoints, mobileSession, accountEmail, executionContext).then(
+                        points => {
+                            mobileContextClosed = true
+                            this.bot.logger.info('main', 'SEARCH-MANAGER', `Mobile done | earned=${points}`)
+                            return points
+                        }
+                    )
+                )
+            } else {
+                const reason = !this.bot.config.workers.doMobileSearch ? 'disabled' : 'no-points'
+                this.bot.logger.info('main', 'SEARCH-MANAGER', `Skip mobile (${reason}); closing mobile session`)
+                await this.bot.browser.func.closeBrowser(mobileSession.context, accountEmail)
+                mobileContextClosed = true
+                this.bot.logger.info('main', 'SEARCH-MANAGER', 'Mobile session closed (no mobile search)')
+            }
+
+            if (shouldDoDesktop) {
+                this.bot.logger.info('main', 'SEARCH-MANAGER', 'Desktop login start')
+                this.bot.logger.debug(
+                    'main',
+                    'SEARCH-MANAGER',
+                    `Desktop login | account=${accountEmail} | proxy=${account.proxy ?? 'none'}`
+                )
+                desktopSession = await executionContext.run({ isMobile: false, accountEmail }, async () =>
+                    this.createDesktopSession(account, accountEmail)
+                )
+                this.bot.logger.info('main', 'SEARCH-MANAGER', 'Desktop login done')
+            } else {
+                const reason = !this.bot.config.workers.doDesktopSearch ? 'disabled' : 'no-points'
+                this.bot.logger.info('main', 'SEARCH-MANAGER', `Skip desktop login (${reason})`)
+            }
+
+            if (shouldDoDesktop && desktopSession) {
+                this.bot.logger.debug(
+                    'main',
+                    'SEARCH-MANAGER',
+                    `Schedule desktop | target=${missingSearchPoints.desktopPoints}`
+                )
+                searchTypes.push('Desktop')
+                promises.push(
+                    this.doDesktopSearch(
+                        data,
+                        missingSearchPoints,
+                        desktopSession,
+                        accountEmail,
+                        executionContext
+                    ).then(points => {
+                        this.bot.logger.info('main', 'SEARCH-MANAGER', `Desktop done | earned=${points}`)
+                        return points
+                    })
+                )
+            }
+
+            this.bot.logger.info('main', 'SEARCH-MANAGER', `Running parallel: ${searchTypes.join(' + ') || 'none'}`)
+
+            const results = await Promise.all(promises)
+
+            this.bot.logger.debug(
+                'main',
+                'SEARCH-MANAGER',
+                `Parallel results | account=${accountEmail} | results=${JSON.stringify(results)}`
+            )
+
+            const mobilePoints = shouldDoMobile ? (results[0] ?? 0) : 0
+            const desktopPoints = shouldDoDesktop ? (results[shouldDoMobile ? 1 : 0] ?? 0) : 0
+
+            this.bot.logger.info(
+                'main',
+                'SEARCH-MANAGER',
+                `Parallel summary | mobile=${mobilePoints} | desktop=${desktopPoints} | total=${
+                    mobilePoints + desktopPoints
+                }`
+            )
+
+            return { mobilePoints, desktopPoints }
+        } catch (error) {
+            this.bot.logger.error(
+                'main',
+                'SEARCH-MANAGER',
+                `Parallel failed: ${error instanceof Error ? error.message : String(error)}`
+            )
+            if (error instanceof Error && error.stack) {
+                this.bot.logger.debug('main', 'SEARCH-MANAGER', `Parallel stack: ${error.stack}`)
+            }
+            throw error
+        } finally {
+            if (!mobileContextClosed && mobileSession) {
+                this.bot.logger.info('main', 'SEARCH-MANAGER', 'Cleanup: closing mobile session')
+                this.bot.logger.debug('main', 'SEARCH-MANAGER', `Cleanup mobile | account=${accountEmail}`)
+                try {
+                    await executionContext.run({ isMobile: true, accountEmail }, async () => {
+                        await this.bot.browser.func.closeBrowser(mobileSession.context, accountEmail)
+                    })
+                    this.bot.logger.info('main', 'SEARCH-MANAGER', 'Cleanup: mobile session closed')
+                } catch (error) {
+                    this.bot.logger.warn(
+                        'main',
+                        'SEARCH-MANAGER',
+                        `Cleanup: mobile close failed: ${error instanceof Error ? error.message : String(error)}`
+                    )
+                    if (error instanceof Error && error.stack) {
+                        this.bot.logger.debug('main', 'SEARCH-MANAGER', `Cleanup mobile stack: ${error.stack}`)
+                    }
+                }
+            }
+        }
+    }
+
+    private async doSequentialSearches(
+        data: DashboardData,
+        missingSearchPoints: MissingSearchPoints,
+        mobileSession: BrowserSession,
+        account: Account,
+        accountEmail: string,
+        executionContext: any
+    ): Promise<SearchResults> {
+        this.bot.logger.info('main', 'SEARCH-MANAGER', 'Sequential start')
+        this.bot.logger.debug(
+            'main',
+            'SEARCH-MANAGER',
+            `Sequential config | account=${accountEmail} | mobileMissing=${missingSearchPoints.mobilePoints} | desktopMissing=${missingSearchPoints.desktopPoints}`
+        )
+
+        const shouldDoMobile = this.bot.config.workers.doMobileSearch && missingSearchPoints.mobilePoints > 0
+        const shouldDoDesktop = this.bot.config.workers.doDesktopSearch && missingSearchPoints.desktopPoints > 0
+
+        this.bot.logger.debug(
+            'main',
+            'SEARCH-MANAGER',
+            `Sequential flags | mobile=${shouldDoMobile} | desktop=${shouldDoDesktop}`
+        )
+
+        let mobilePoints = 0
+        let desktopPoints = 0
+
+        if (shouldDoMobile) {
+            this.bot.logger.info('main', 'SEARCH-MANAGER', 'Step 1: mobile')
+            this.bot.logger.debug(
+                'main',
+                'SEARCH-MANAGER',
+                `Sequential mobile | target=${missingSearchPoints.mobilePoints}`
+            )
+            mobilePoints = await this.doMobileSearch(
+                data,
+                missingSearchPoints,
+                mobileSession,
+                accountEmail,
+                executionContext
+            )
+            this.bot.logger.info('main', 'SEARCH-MANAGER', `Step 1: mobile done | earned=${mobilePoints}`)
+        } else {
+            const reason = !this.bot.config.workers.doMobileSearch ? 'disabled' : 'no-points'
+            this.bot.logger.info('main', 'SEARCH-MANAGER', `Step 1: skip mobile (${reason}); closing mobile session`)
+            this.bot.logger.debug('main', 'SEARCH-MANAGER', 'Closing unused mobile context')
+            try {
+                await executionContext.run({ isMobile: true, accountEmail }, async () => {
+                    await this.bot.browser.func.closeBrowser(mobileSession.context, accountEmail)
+                })
+                this.bot.logger.info('main', 'SEARCH-MANAGER', 'Unused mobile session closed')
+            } catch (error) {
+                this.bot.logger.warn(
+                    'main',
+                    'SEARCH-MANAGER',
+                    `Unused mobile close failed: ${error instanceof Error ? error.message : String(error)}`
+                )
+                if (error instanceof Error && error.stack) {
+                    this.bot.logger.debug('main', 'SEARCH-MANAGER', `Unused mobile stack: ${error.stack}`)
+                }
+            }
+        }
+
+        if (shouldDoDesktop) {
+            this.bot.logger.info('main', 'SEARCH-MANAGER', 'Step 2: desktop')
+            this.bot.logger.debug(
+                'main',
+                'SEARCH-MANAGER',
+                `Sequential desktop | target=${missingSearchPoints.desktopPoints}`
+            )
+            desktopPoints = await this.doDesktopSearchSequential(
+                data,
+                missingSearchPoints,
+                account,
+                accountEmail,
+                executionContext
+            )
+            this.bot.logger.info('main', 'SEARCH-MANAGER', `Step 2: desktop done | earned=${desktopPoints}`)
+        } else {
+            const reason = !this.bot.config.workers.doDesktopSearch ? 'disabled' : 'no-points'
+            this.bot.logger.info('main', 'SEARCH-MANAGER', `Step 2: skip desktop (${reason})`)
+        }
+
+        this.bot.logger.info(
+            'main',
+            'SEARCH-MANAGER',
+            `Sequential summary | mobile=${mobilePoints} | desktop=${desktopPoints} | total=${
+                mobilePoints + desktopPoints
+            }`
+        )
+        this.bot.logger.debug('main', 'SEARCH-MANAGER', `Sequential done | account=${accountEmail}`)
+
+        return { mobilePoints, desktopPoints }
+    }
+
+    private async createDesktopSession(account: Account, accountEmail: string): Promise<BrowserSession> {
+        this.bot.logger.info('main', 'SEARCH-DESKTOP-LOGIN', 'Init desktop session')
+        this.bot.logger.debug(
+            'main',
+            'SEARCH-DESKTOP-LOGIN',
+            `Init | account=${accountEmail} | proxy=${account.proxy ?? 'none'}`
+        )
+
+        const session = await this.bot['browserFactory'].createBrowser(account.proxy, accountEmail)
+        this.bot.logger.debug('main', 'SEARCH-DESKTOP-LOGIN', 'Browser created, new page')
+
+        this.bot.mainDesktopPage = await session.context.newPage()
+
+        this.bot.logger.info('main', 'SEARCH-DESKTOP-LOGIN', `Browser ready | account=${accountEmail}`)
+        this.bot.logger.info('main', 'SEARCH-DESKTOP-LOGIN', 'Login start')
+        this.bot.logger.debug('main', 'SEARCH-DESKTOP-LOGIN', 'Calling login handler')
+
+        await this.bot['login'].login(this.bot.mainDesktopPage, accountEmail, account.password, account.totp)
+
+        this.bot.logger.info('main', 'SEARCH-DESKTOP-LOGIN', 'Login passed, verifying')
+        this.bot.logger.debug('main', 'SEARCH-DESKTOP-LOGIN', 'verifyBingSession')
+
+        await this.bot['login'].verifyBingSession(this.bot.mainDesktopPage)
+        this.bot.cookies.desktop = await session.context.cookies()
+
+        this.bot.logger.debug('main', 'SEARCH-DESKTOP-LOGIN', 'Cookies stored')
+        this.bot.logger.info('main', 'SEARCH-DESKTOP-LOGIN', 'Desktop session ready')
+
+        return session
+    }
+
+    private async doMobileSearch(
+        data: DashboardData,
+        missingSearchPoints: MissingSearchPoints,
+        mobileSession: BrowserSession,
+        accountEmail: string,
+        executionContext: any
+    ): Promise<number> {
+        this.bot.logger.debug(
+            'main',
+            'SEARCH-MOBILE-SEARCH',
+            `Start | account=${accountEmail} | target=${missingSearchPoints.mobilePoints}`
+        )
+
+        return await executionContext.run({ isMobile: true, accountEmail }, async () => {
+            try {
+                if (!this.bot.config.workers.doMobileSearch) {
+                    this.bot.logger.info('main', 'SEARCH-MOBILE-SEARCH', 'Skip: worker disabled in config')
+                    return 0
+                }
+
+                if (missingSearchPoints.mobilePoints === 0) {
+                    this.bot.logger.info('main', 'SEARCH-MOBILE-SEARCH', 'Skip: no points left')
+                    return 0
+                }
+
+                this.bot.logger.info(
+                    'main',
+                    'SEARCH-MOBILE-SEARCH',
+                    `Search start | target=${missingSearchPoints.mobilePoints}`
+                )
+                this.bot.logger.debug('main', 'SEARCH-MOBILE-SEARCH', 'activities.doSearch (mobile)')
+
+                const pointsEarned = await this.bot.activities.doSearch(data, this.bot.mainMobilePage, true)
+
+                this.bot.logger.info(
+                    'main',
+                    'SEARCH-MOBILE-SEARCH',
+                    `Search done | earned=${pointsEarned}/${missingSearchPoints.mobilePoints}`
+                )
+                this.bot.logger.debug(
+                    'main',
+                    'SEARCH-MOBILE-SEARCH',
+                    `Result | account=${accountEmail} | earned=${pointsEarned}`
+                )
+
+                return pointsEarned
+            } catch (error) {
+                this.bot.logger.error(
+                    'main',
+                    'SEARCH-MOBILE-SEARCH',
+                    `Failed: ${error instanceof Error ? error.message : String(error)}`
+                )
+                if (error instanceof Error && error.stack) {
+                    this.bot.logger.debug('main', 'SEARCH-MOBILE-SEARCH', `Stack: ${error.stack}`)
+                }
+                return 0
+            } finally {
+                this.bot.logger.info('main', 'SEARCH-MOBILE-SEARCH', 'Closing mobile session')
+                this.bot.logger.debug('main', 'SEARCH-MOBILE-SEARCH', `Closing context | account=${accountEmail}`)
+                try {
+                    await this.bot.browser.func.closeBrowser(mobileSession.context, accountEmail)
+                    this.bot.logger.info('main', 'SEARCH-MOBILE-SEARCH', 'Mobile browser closed')
+                } catch (error) {
+                    this.bot.logger.warn(
+                        'main',
+                        'SEARCH-MOBILE-SEARCH',
+                        `Close failed: ${error instanceof Error ? error.message : String(error)}`
+                    )
+                    if (error instanceof Error && error.stack) {
+                        this.bot.logger.debug('main', 'SEARCH-MOBILE-SEARCH', `Close stack: ${error.stack}`)
+                    }
+                }
+            }
+        })
+    }
+
+    private async doDesktopSearch(
+        data: DashboardData,
+        missingSearchPoints: MissingSearchPoints,
+        desktopSession: BrowserSession,
+        accountEmail: string,
+        executionContext: any
+    ): Promise<number> {
+        this.bot.logger.debug(
+            'main',
+            'SEARCH-DESKTOP-PARALLEL',
+            `Start | account=${accountEmail} | target=${missingSearchPoints.desktopPoints}`
+        )
+
+        return await executionContext.run({ isMobile: false, accountEmail }, async () => {
+            try {
+                this.bot.logger.info(
+                    'main',
+                    'SEARCH-DESKTOP-PARALLEL',
+                    `Search start | target=${missingSearchPoints.desktopPoints}`
+                )
+                const pointsEarned = await this.bot.activities.doSearch(data, this.bot.mainDesktopPage, false)
+
+                this.bot.logger.info(
+                    'main',
+                    'SEARCH-DESKTOP-PARALLEL',
+                    `Search done | earned=${pointsEarned}/${missingSearchPoints.desktopPoints}`
+                )
+                this.bot.logger.debug(
+                    'main',
+                    'SEARCH-DESKTOP-PARALLEL',
+                    `Result | account=${accountEmail} | earned=${pointsEarned}`
+                )
+
+                return pointsEarned
+            } catch (error) {
+                this.bot.logger.error(
+                    'main',
+                    'SEARCH-DESKTOP-PARALLEL',
+                    `Failed: ${error instanceof Error ? error.message : String(error)}`
+                )
+                if (error instanceof Error && error.stack) {
+                    this.bot.logger.debug('main', 'SEARCH-DESKTOP-PARALLEL', `Stack: ${error.stack}`)
+                }
+                return 0
+            } finally {
+                this.bot.logger.info('main', 'SEARCH-DESKTOP-PARALLEL', 'Closing desktop session')
+                this.bot.logger.debug('main', 'SEARCH-DESKTOP-PARALLEL', `Closing context | account=${accountEmail}`)
+                try {
+                    await this.bot.browser.func.closeBrowser(desktopSession.context, accountEmail)
+                    this.bot.logger.info('main', 'SEARCH-DESKTOP-PARALLEL', 'Desktop browser closed')
+                } catch (error) {
+                    this.bot.logger.warn(
+                        'main',
+                        'SEARCH-DESKTOP-PARALLEL',
+                        `Close failed: ${error instanceof Error ? error.message : String(error)}`
+                    )
+                    if (error instanceof Error && error.stack) {
+                        this.bot.logger.debug('main', 'SEARCH-DESKTOP-PARALLEL', `Close stack: ${error.stack}`)
+                    }
+                }
+            }
+        })
+    }
+
+    private async doDesktopSearchSequential(
+        data: DashboardData,
+        missingSearchPoints: MissingSearchPoints,
+        account: Account,
+        accountEmail: string,
+        executionContext: any
+    ): Promise<number> {
+        this.bot.logger.debug(
+            'main',
+            'SEARCH-DESKTOP-SEQUENTIAL',
+            `Start | account=${accountEmail} | target=${missingSearchPoints.desktopPoints}`
+        )
+
+        return await executionContext.run({ isMobile: false, accountEmail }, async () => {
+            if (!this.bot.config.workers.doDesktopSearch) {
+                this.bot.logger.info('main', 'SEARCH-DESKTOP-SEQUENTIAL', 'Skip: worker disabled in config')
+                return 0
+            }
+
+            if (missingSearchPoints.desktopPoints === 0) {
+                this.bot.logger.info('main', 'SEARCH-DESKTOP-SEQUENTIAL', 'Skip: no points left')
+                return 0
+            }
+
+            let desktopSession: BrowserSession | null = null
+            try {
+                this.bot.logger.info('main', 'SEARCH-DESKTOP-SEQUENTIAL', 'Init desktop session')
+                desktopSession = await this.createDesktopSession(account, accountEmail)
+
+                this.bot.logger.info(
+                    'main',
+                    'SEARCH-DESKTOP-SEQUENTIAL',
+                    `Search start | target=${missingSearchPoints.desktopPoints}`
+                )
+
+                const pointsEarned = await this.bot.activities.doSearch(data, this.bot.mainDesktopPage, false)
+
+                this.bot.logger.info(
+                    'main',
+                    'SEARCH-DESKTOP-SEQUENTIAL',
+                    `Search done | earned=${pointsEarned}/${missingSearchPoints.desktopPoints}`
+                )
+                this.bot.logger.debug(
+                    'main',
+                    'SEARCH-DESKTOP-SEQUENTIAL',
+                    `Result | account=${accountEmail} | earned=${pointsEarned}`
+                )
+
+                return pointsEarned
+            } catch (error) {
+                this.bot.logger.error(
+                    'main',
+                    'SEARCH-DESKTOP-SEQUENTIAL',
+                    `Failed: ${error instanceof Error ? error.message : String(error)}`
+                )
+                if (error instanceof Error && error.stack) {
+                    this.bot.logger.debug('main', 'SEARCH-DESKTOP-SEQUENTIAL', `Stack: ${error.stack}`)
+                }
+                return 0
+            } finally {
+                if (desktopSession) {
+                    this.bot.logger.info('main', 'SEARCH-DESKTOP-SEQUENTIAL', 'Closing desktop session')
+                    this.bot.logger.debug(
+                        'main',
+                        'SEARCH-DESKTOP-SEQUENTIAL',
+                        `Closing context | account=${accountEmail}`
+                    )
+                    try {
+                        await this.bot.browser.func.closeBrowser(desktopSession.context, accountEmail)
+                        this.bot.logger.info('main', 'SEARCH-DESKTOP-SEQUENTIAL', 'Desktop browser closed')
+                    } catch (error) {
+                        this.bot.logger.warn(
+                            'main',
+                            'SEARCH-DESKTOP-SEQUENTIAL',
+                            `Close failed: ${error instanceof Error ? error.message : String(error)}`
+                        )
+                        if (error instanceof Error && error.stack) {
+                            this.bot.logger.debug('main', 'SEARCH-DESKTOP-SEQUENTIAL', `Close stack: ${error.stack}`)
+                        }
+                    }
+                }
+            }
+        })
+    }
+}

src/functions/Workers.ts

@@ -1,8 +1,7 @@
-import { Page } from 'rebrowser-playwright'
-
-import { DashboardData, MorePromotion, PromotionalItem, PunchCard } from '../interface/DashboardData'
-
-import { MicrosoftRewardsBot } from '../index'
+import type { Page } from 'patchright'
+import type { MicrosoftRewardsBot } from '../index'
+import type { DashboardData, PunchCard, BasePromotion, FindClippyPromotion } from '../interface/DashboardData'
+import type { AppDashboardData } from '../interface/AppDashBoardData'
 
 export class Workers {
     public bot: MicrosoftRewardsBot
@@ -11,220 +10,190 @@ export class Workers {
         this.bot = bot
     }
 
-    // Daily Set
-    async doDailySet(page: Page, data: DashboardData) {
-        const todayData = data.dailySetPromotions[this.bot.utils.getFormattedDate()]
+    public async doDailySet(data: DashboardData, page: Page) {
+        const todayKey = this.bot.utils.getFormattedDate()
+        const todayData = data.dailySetPromotions[todayKey]
 
         const activitiesUncompleted = todayData?.filter(x => !x.complete && x.pointProgressMax > 0) ?? []
 
         if (!activitiesUncompleted.length) {
-            this.bot.log(this.bot.isMobile, 'DAILY-SET', 'All Daily Set" items have already been completed')
+            this.bot.logger.info(this.bot.isMobile, 'DAILY-SET', 'All "Daily Set" items have already been completed')
             return
         }
 
-        // Solve Activities
-        this.bot.log(this.bot.isMobile, 'DAILY-SET', 'Started solving "Daily Set" items')
+        this.bot.logger.info(this.bot.isMobile, 'DAILY-SET', 'Started solving "Daily Set" items')
 
-        await this.solveActivities(page, activitiesUncompleted)
+        await this.solveActivities(activitiesUncompleted, page)
 
-        page = await this.bot.browser.utils.getLatestTab(page)
-
-        // Always return to the homepage if not already
-        await this.bot.browser.func.goHome(page)
-
-        this.bot.log(this.bot.isMobile, 'DAILY-SET', 'All "Daily Set" items have been completed')
+        this.bot.logger.info(this.bot.isMobile, 'DAILY-SET', 'All "Daily Set" items have been completed')
     }
 
-    // Punch Card
-    async doPunchCard(page: Page, data: DashboardData) {
+    public async doMorePromotions(data: DashboardData, page: Page) {
+        const morePromotions: BasePromotion[] = [
+            ...new Map(
+                [...(data.morePromotions ?? []), ...(data.morePromotionsWithoutPromotionalItems ?? [])]
+                    .filter(Boolean)
+                    .map(p => [p.offerId, p as BasePromotion] as const)
+            ).values()
+        ]
 
-        const punchCardsUncompleted = data.punchCards?.filter(x => x.parentPromotion && !x.parentPromotion.complete) ?? [] // Only return uncompleted punch cards
-
-        if (!punchCardsUncompleted.length) {
-            this.bot.log(this.bot.isMobile, 'PUNCH-CARD', 'All "Punch Cards" have already been completed')
-            return
-        }
-
-        for (const punchCard of punchCardsUncompleted) {
-
-            // Ensure parentPromotion exists before proceeding
-            if (!punchCard.parentPromotion?.title) {
-                this.bot.log(this.bot.isMobile, 'PUNCH-CARD', `Skipped punchcard "${punchCard.name}" | Reason: Parent promotion is missing!`, 'warn')
-                continue
-            }
-
-            // Get latest page for each card
-            page = await this.bot.browser.utils.getLatestTab(page)
-
-            const activitiesUncompleted = punchCard.childPromotions.filter(x => !x.complete) // Only return uncompleted activities
-
-            // Solve Activities
-            this.bot.log(this.bot.isMobile, 'PUNCH-CARD', `Started solving "Punch Card" items for punchcard: "${punchCard.parentPromotion.title}"`)
-
-            // Got to punch card index page in a new tab
-            await page.goto(punchCard.parentPromotion.destinationUrl, { referer: this.bot.config.baseURL })
-
-            // Wait for new page to load, max 10 seconds, however try regardless in case of error
-            await page.waitForLoadState('networkidle', { timeout: 5000 }).catch(() => { })
-
-            await this.solveActivities(page, activitiesUncompleted, punchCard)
-
-            page = await this.bot.browser.utils.getLatestTab(page)
-
-            const pages = page.context().pages()
-
-            if (pages.length > 3) {
-                await page.close()
-            } else {
-                await this.bot.browser.func.goHome(page)
-            }
-
-            this.bot.log(this.bot.isMobile, 'PUNCH-CARD', `All items for punchcard: "${punchCard.parentPromotion.title}" have been completed`)
-        }
-
-        this.bot.log(this.bot.isMobile, 'PUNCH-CARD', 'All "Punch Card" items have been completed')
-    }
-
-    // More Promotions
-    async doMorePromotions(page: Page, data: DashboardData) {
-        const morePromotions = data.morePromotions
-
-        // Check if there is a promotional item
-        if (data.promotionalItem) { // Convert and add the promotional item to the array
-            morePromotions.push(data.promotionalItem as unknown as MorePromotion)
-        }
-
-        const activitiesUncompleted = morePromotions?.filter(x => !x.complete && x.pointProgressMax > 0 && x.exclusiveLockedFeatureStatus !== 'locked') ?? []
+        const activitiesUncompleted: BasePromotion[] =
+            morePromotions?.filter(
+                x =>
+                    !x.complete &&
+                    x.pointProgressMax > 0 &&
+                    x.exclusiveLockedFeatureStatus !== 'locked' &&
+                    x.promotionType
+            ) ?? []
 
         if (!activitiesUncompleted.length) {
-            this.bot.log(this.bot.isMobile, 'MORE-PROMOTIONS', 'All "More Promotion" items have already been completed')
+            this.bot.logger.info(
+                this.bot.isMobile,
+                'MORE-PROMOTIONS',
+                'All "More Promotion" items have already been completed'
+            )
             return
         }
 
-        // Solve Activities
-        this.bot.log(this.bot.isMobile, 'MORE-PROMOTIONS', 'Started solving "More Promotions" items')
+        this.bot.logger.info(
+            this.bot.isMobile,
+            'MORE-PROMOTIONS',
+            `Started solving ${activitiesUncompleted.length} "More Promotions" items`
+        )
 
-        page = await this.bot.browser.utils.getLatestTab(page)
+        await this.solveActivities(activitiesUncompleted, page)
 
-        await this.solveActivities(page, activitiesUncompleted)
-
-        page = await this.bot.browser.utils.getLatestTab(page)
-
-        // Always return to the homepage if not already
-        await this.bot.browser.func.goHome(page)
-
-        this.bot.log(this.bot.isMobile, 'MORE-PROMOTIONS', 'All "More Promotion" items have been completed')
+        this.bot.logger.info(this.bot.isMobile, 'MORE-PROMOTIONS', 'All "More Promotion" items have been completed')
     }
 
-    // Solve all the different types of activities
-    private async solveActivities(activityPage: Page, activities: PromotionalItem[] | MorePromotion[], punchCard?: PunchCard) {
-        const activityInitial = activityPage.url() // Homepage for Daily/More and Index for promotions
+    public async doAppPromotions(data: AppDashboardData) {
+        const appRewards = data.response.promotions.filter(
+            x =>
+                x.attributes['complete']?.toLowerCase() === 'false' &&
+                x.attributes['offerid'] &&
+                x.attributes['type'] &&
+                x.attributes['type'] === 'sapphire'
+        )
 
+        if (!appRewards.length) {
+            this.bot.logger.info(
+                this.bot.isMobile,
+                'APP-PROMOTIONS',
+                'All "App Promotions" items have already been completed'
+            )
+            return
+        }
+
+        for (const reward of appRewards) {
+            await this.bot.activities.doAppReward(reward)
+            // A delay between completing each activity
+            await this.bot.utils.wait(this.bot.utils.randomDelay(5000, 15000))
+        }
+
+        this.bot.logger.info(this.bot.isMobile, 'APP-PROMOTIONS', 'All "App Promotions" items have been completed')
+    }
+
+    private async solveActivities(activities: BasePromotion[], page: Page, punchCard?: PunchCard) {
         for (const activity of activities) {
             try {
-                // Reselect the worker page
-                activityPage = await this.bot.browser.utils.getLatestTab(activityPage)
+                const type = activity.promotionType?.toLowerCase() ?? ''
+                const name = activity.name?.toLowerCase() ?? ''
+                const offerId = (activity as BasePromotion).offerId
+                const destinationUrl = activity.destinationUrl?.toLowerCase() ?? ''
 
-                const pages = activityPage.context().pages()
-                if (pages.length > 3) {
-                    await activityPage.close()
+                this.bot.logger.debug(
+                    this.bot.isMobile,
+                    'ACTIVITY',
+                    `Processing activity | title="${activity.title}" | offerId=${offerId} | type=${type} | punchCard="${punchCard?.parentPromotion?.title ?? 'none'}"`
+                )
 
-                    activityPage = await this.bot.browser.utils.getLatestTab(activityPage)
-                }
+                switch (type) {
+                    // Quiz-like activities (Poll / regular quiz variants)
+                    case 'quiz': {
+                        const basePromotion = activity as BasePromotion
 
-                await this.bot.utils.wait(1000)
+                        // Poll (usually 10 points, pollscenarioid in URL)
+                        if (activity.pointProgressMax === 10 && destinationUrl.includes('pollscenarioid')) {
+                            this.bot.logger.info(
+                                this.bot.isMobile,
+                                'ACTIVITY',
+                                `Found activity type "Poll" | title="${activity.title}" | offerId=${offerId}`
+                            )
 
-                if (activityPage.url() !== activityInitial) {
-                    await activityPage.goto(activityInitial)
-                }
-
-
-                let selector = `[data-bi-id^="${activity.offerId}"] .pointLink:not(.contentContainer .pointLink)`
-
-                if (punchCard) {
-                    selector = await this.bot.browser.func.getPunchCardActivity(activityPage, activity)
-
-                } else if (activity.name.toLowerCase().includes('membercenter') || activity.name.toLowerCase().includes('exploreonbing')) {
-                    selector = `[data-bi-id^="${activity.name}"] .pointLink:not(.contentContainer .pointLink)`
-                }
-
-                // Wait for the new tab to fully load, ignore error.
-                /*
-                Due to common false timeout on this function, we're ignoring the error regardless, if it worked then it's faster,
-                if it didn't then it gave enough time for the page to load.
-                */
-                await activityPage.waitForLoadState('networkidle', { timeout: 10000 }).catch(() => { })
-                await this.bot.utils.wait(2000)
-
-                switch (activity.promotionType) {
-                    // Quiz (Poll, Quiz or ABC)
-                    case 'quiz':
-                        switch (activity.pointProgressMax) {
-                            // Poll or ABC (Usually 10 points)
-                            case 10:
-                                // Normal poll
-                                if (activity.destinationUrl.toLowerCase().includes('pollscenarioid')) {
-                                    this.bot.log(this.bot.isMobile, 'ACTIVITY', `Found activity type: "Poll" title: "${activity.title}"`)
-                                    await activityPage.click(selector)
-                                    activityPage = await this.bot.browser.utils.getLatestTab(activityPage)
-                                    await this.bot.activities.doPoll(activityPage)
-                                } else { // ABC
-                                    this.bot.log(this.bot.isMobile, 'ACTIVITY', `Found activity type: "ABC" title: "${activity.title}"`)
-                                    await activityPage.click(selector)
-                                    activityPage = await this.bot.browser.utils.getLatestTab(activityPage)
-                                    await this.bot.activities.doABC(activityPage)
-                                }
-                                break
-
-                            // This Or That Quiz (Usually 50 points)
-                            case 50:
-                                this.bot.log(this.bot.isMobile, 'ACTIVITY', `Found activity type: "ThisOrThat" title: "${activity.title}"`)
-                                await activityPage.click(selector)
-                                activityPage = await this.bot.browser.utils.getLatestTab(activityPage)
-                                await this.bot.activities.doThisOrThat(activityPage)
-                                break
-
-                            // Quizzes are usually 30-40 points
-                            default:
-                                this.bot.log(this.bot.isMobile, 'ACTIVITY', `Found activity type: "Quiz" title: "${activity.title}"`)
-                                await activityPage.click(selector)
-                                activityPage = await this.bot.browser.utils.getLatestTab(activityPage)
-                                await this.bot.activities.doQuiz(activityPage)
-                                break
+                            //await this.bot.activities.doPoll(basePromotion)
+                            break
                         }
-                        break
 
-                    // UrlReward (Visit)
-                    case 'urlreward':
+                        // All other quizzes handled via Quiz API
+                        this.bot.logger.info(
+                            this.bot.isMobile,
+                            'ACTIVITY',
+                            `Found activity type "Quiz" | title="${activity.title}" | offerId=${offerId}`
+                        )
+
+                        await this.bot.activities.doQuiz(basePromotion)
+                        break
+                    }
+
+                    // UrlReward
+                    case 'urlreward': {
+                        const basePromotion = activity as BasePromotion
+
                         // Search on Bing are subtypes of "urlreward"
-                        if (activity.name.toLowerCase().includes('exploreonbing')) {
-                            this.bot.log(this.bot.isMobile, 'ACTIVITY', `Found activity type: "SearchOnBing" title: "${activity.title}"`)
-                            await activityPage.click(selector)
-                            activityPage = await this.bot.browser.utils.getLatestTab(activityPage)
-                            await this.bot.activities.doSearchOnBing(activityPage, activity)
+                        if (name.includes('exploreonbing')) {
+                            this.bot.logger.info(
+                                this.bot.isMobile,
+                                'ACTIVITY',
+                                `Found activity type "SearchOnBing" | title="${activity.title}" | offerId=${offerId}`
+                            )
 
+                            await this.bot.activities.doSearchOnBing(basePromotion, page)
                         } else {
-                            this.bot.log(this.bot.isMobile, 'ACTIVITY', `Found activity type: "UrlReward" title: "${activity.title}"`)
-                            await activityPage.click(selector)
-                            activityPage = await this.bot.browser.utils.getLatestTab(activityPage)
-                            await this.bot.activities.doUrlReward(activityPage)
+                            this.bot.logger.info(
+                                this.bot.isMobile,
+                                'ACTIVITY',
+                                `Found activity type "UrlReward" | title="${activity.title}" | offerId=${offerId}`
+                            )
+
+                            await this.bot.activities.doUrlReward(basePromotion)
                         }
                         break
+                    }
+
+                    // Find Clippy specific promotion type
+                    case 'findclippy': {
+                        const clippyPromotion = activity as unknown as FindClippyPromotion
+
+                        this.bot.logger.info(
+                            this.bot.isMobile,
+                            'ACTIVITY',
+                            `Found activity type "FindClippy" | title="${activity.title}" | offerId=${offerId}`
+                        )
+
+                        await this.bot.activities.doFindClippy(clippyPromotion)
+                        break
+                    }
 
                     // Unsupported types
-                    default:
-                        this.bot.log(this.bot.isMobile, 'ACTIVITY', `Skipped activity "${activity.title}" | Reason: Unsupported type: "${activity.promotionType}"!`, 'warn')
+                    default: {
+                        this.bot.logger.warn(
+                            this.bot.isMobile,
+                            'ACTIVITY',
+                            `Skipped activity "${activity.title}" | offerId=${offerId} | Reason: Unsupported type "${activity.promotionType}"`
+                        )
                         break
+                    }
                 }
 
                 // Cooldown
-                await this.bot.utils.wait(2000)
-
+                await this.bot.utils.wait(this.bot.utils.randomDelay(5000, 15000))
             } catch (error) {
-                this.bot.log(this.bot.isMobile, 'ACTIVITY', 'An error occurred:' + error, 'error')
+                this.bot.logger.error(
+                    this.bot.isMobile,
+                    'ACTIVITY',
+                    `Error while solving activity "${activity.title}" | message=${error instanceof Error ? error.message : String(error)}`
+                )
             }
-
         }
     }
-
-}
+}

src/functions/activities/ABC.ts

@@ -1,52 +0,0 @@
-import { Page } from 'rebrowser-playwright'
-
-import { Workers } from '../Workers'
-
-
-export class ABC extends Workers {
-
-    async doABC(page: Page) {
-        this.bot.log(this.bot.isMobile, 'ABC', 'Trying to complete poll')
-
-        try {
-            let $ = await this.bot.browser.func.loadInCheerio(page)
-
-            // Don't loop more than 15 in case unable to solve, would lock otherwise
-            const maxIterations = 15
-            let i
-            for (i = 0; i < maxIterations && !$('span.rw_icon').length; i++) {
-                await page.waitForSelector('.wk_OptionClickClass', { state: 'visible', timeout: 10000 })
-
-                const answers = $('.wk_OptionClickClass')
-                const answer = answers[this.bot.utils.randomNumber(0, 2)]?.attribs['id']
-
-                await page.waitForSelector(`#${answer}`, { state: 'visible', timeout: 10000 })
-
-                await this.bot.utils.wait(2000)
-                await page.click(`#${answer}`) // Click answer
-
-                await this.bot.utils.wait(4000)
-                await page.waitForSelector('div.wk_button', { state: 'visible', timeout: 10000 })
-                await page.click('div.wk_button') // Click next question button
-
-                page = await this.bot.browser.utils.getLatestTab(page)
-                $ = await this.bot.browser.func.loadInCheerio(page)
-                await this.bot.utils.wait(1000)
-            }
-
-            await this.bot.utils.wait(4000)
-            await page.close()
-
-            if (i === maxIterations) {
-                this.bot.log(this.bot.isMobile, 'ABC', 'Failed to solve quiz, exceeded max iterations of 15', 'warn')
-            } else {
-                this.bot.log(this.bot.isMobile, 'ABC', 'Completed the ABC successfully')
-            }
-
-        } catch (error) {
-            await page.close()
-            this.bot.log(this.bot.isMobile, 'ABC', 'An error occurred:' + error, 'error')
-        }
-    }
-
-}

src/functions/activities/DailyCheckIn.ts

@@ -1,48 +0,0 @@
-import { randomBytes } from 'crypto'
-import { AxiosRequestConfig } from 'axios'
-
-import { Workers } from '../Workers'
-
-import { DashboardData } from '../../interface/DashboardData'
-
-
-export class DailyCheckIn extends Workers {
-    public async doDailyCheckIn(accessToken: string, data: DashboardData) {
-        this.bot.log(this.bot.isMobile, 'DAILY-CHECK-IN', 'Starting Daily Check In')
-
-        try {
-            let geoLocale = data.userProfile.attributes.country
-            geoLocale = (this.bot.config.searchSettings.useGeoLocaleQueries && geoLocale.length === 2) ? geoLocale.toLowerCase() : 'us'
-
-            const jsonData = {
-                amount: 1,
-                country: geoLocale,
-                id: randomBytes(64).toString('hex'),
-                type: 101,
-                attributes: {
-                    offerid: 'Gamification_Sapphire_DailyCheckIn'
-                }
-            }
-
-            const claimRequest: AxiosRequestConfig = {
-                url: 'https://prod.rewardsplatform.microsoft.com/dapi/me/activities',
-                method: 'POST',
-                headers: {
-                    'Authorization': `Bearer ${accessToken}`,
-                    'Content-Type': 'application/json',
-                    'X-Rewards-Country': geoLocale,
-                    'X-Rewards-Language': 'en'
-                },
-                data: JSON.stringify(jsonData)
-            }
-
-            const claimResponse = await this.bot.axios.request(claimRequest)
-            const claimedPoint = parseInt((await claimResponse.data).response?.activity?.p) ?? 0
-
-            this.bot.log(this.bot.isMobile, 'DAILY-CHECK-IN', claimedPoint > 0 ? `Claimed ${claimedPoint} points` : 'Already claimed today')
-        } catch (error) {
-            this.bot.log(this.bot.isMobile, 'DAILY-CHECK-IN', 'An error occurred:' + error, 'error')
-        }
-    }
-
-}

src/functions/activities/Poll.ts

@@ -1,29 +0,0 @@
-import { Page } from 'rebrowser-playwright'
-
-import { Workers } from '../Workers'
-
-
-export class Poll extends Workers {
-
-    async doPoll(page: Page) {
-        this.bot.log(this.bot.isMobile, 'POLL', 'Trying to complete poll')
-
-        try {
-            const buttonId = `#btoption${Math.floor(this.bot.utils.randomNumber(0, 1))}`
-
-            await page.waitForSelector(buttonId, { state: 'visible', timeout: 10000 }).catch(() => { }) // We're gonna click regardless or not
-            await this.bot.utils.wait(2000)
-
-            await page.click(buttonId)
-
-            await this.bot.utils.wait(4000)
-            await page.close()
-
-            this.bot.log(this.bot.isMobile, 'POLL', 'Completed the poll successfully')
-        } catch (error) {
-            await page.close()
-            this.bot.log(this.bot.isMobile, 'POLL', 'An error occurred:' + error, 'error')
-        }
-    }
-
-}

src/functions/activities/Quiz.ts

@@ -1,92 +0,0 @@
-import { Page } from 'rebrowser-playwright'
-
-import { Workers } from '../Workers'
-
-
-export class Quiz extends Workers {
-
-    async doQuiz(page: Page) {
-        this.bot.log(this.bot.isMobile, 'QUIZ', 'Trying to complete quiz')
-
-        try {
-            // Check if the quiz has been started or not
-            const quizNotStarted = await page.waitForSelector('#rqStartQuiz', { state: 'visible', timeout: 2000 }).then(() => true).catch(() => false)
-            if (quizNotStarted) {
-                await page.click('#rqStartQuiz')
-            } else {
-                this.bot.log(this.bot.isMobile, 'QUIZ', 'Quiz has already been started, trying to finish it')
-            }
-
-            await this.bot.utils.wait(2000)
-
-            let quizData = await this.bot.browser.func.getQuizData(page)
-            const questionsRemaining = quizData.maxQuestions - quizData.CorrectlyAnsweredQuestionCount // Amount of questions remaining
-
-            // All questions
-            for (let question = 0; question < questionsRemaining; question++) {
-
-                if (quizData.numberOfOptions === 8) {
-                    const answers: string[] = []
-
-                    for (let i = 0; i < quizData.numberOfOptions; i++) {
-                        const answerSelector = await page.waitForSelector(`#rqAnswerOption${i}`, { state: 'visible', timeout: 10000 })
-                        const answerAttribute = await answerSelector?.evaluate((el: any) => el.getAttribute('iscorrectoption'))
-
-                        if (answerAttribute && answerAttribute.toLowerCase() === 'true') {
-                            answers.push(`#rqAnswerOption${i}`)
-                        }
-                    }
-
-                    // Click the answers
-                    for (const answer of answers) {
-                        await page.waitForSelector(answer, { state: 'visible', timeout: 2000 })
-
-                        // Click the answer on page
-                        await page.click(answer)
-
-                        const refreshSuccess = await this.bot.browser.func.waitForQuizRefresh(page)
-                        if (!refreshSuccess) {
-                            await page.close()
-                            this.bot.log(this.bot.isMobile, 'QUIZ', 'An error occurred, refresh was unsuccessful', 'error')
-                            return
-                        }
-                    }
-
-                    // Other type quiz, lightspeed
-                } else if ([2, 3, 4].includes(quizData.numberOfOptions)) {
-                    quizData = await this.bot.browser.func.getQuizData(page) // Refresh Quiz Data
-                    const correctOption = quizData.correctAnswer
-
-                    for (let i = 0; i < quizData.numberOfOptions; i++) {
-
-                        const answerSelector = await page.waitForSelector(`#rqAnswerOption${i}`, { state: 'visible', timeout: 10000 })
-                        const dataOption = await answerSelector?.evaluate((el: any) => el.getAttribute('data-option'))
-
-                        if (dataOption === correctOption) {
-                            // Click the answer on page
-                            await page.click(`#rqAnswerOption${i}`)
-
-                            const refreshSuccess = await this.bot.browser.func.waitForQuizRefresh(page)
-                            if (!refreshSuccess) {
-                                await page.close()
-                                this.bot.log(this.bot.isMobile, 'QUIZ', 'An error occurred, refresh was unsuccessful', 'error')
-                                return
-                            }
-                        }
-                    }
-                    await this.bot.utils.wait(2000)
-                }
-            }
-
-            // Done with
-            await this.bot.utils.wait(2000)
-            await page.close()
-
-            this.bot.log(this.bot.isMobile, 'QUIZ', 'Completed the quiz successfully')
-        } catch (error) {
-            await page.close()
-            this.bot.log(this.bot.isMobile, 'QUIZ', 'An error occurred:' + error, 'error')
-        }
-    }
-
-}

src/functions/activities/ReadToEarn.ts

@@ -1,73 +0,0 @@
-import { randomBytes } from 'crypto'
-import { AxiosRequestConfig } from 'axios'
-
-import { Workers } from '../Workers'
-
-import { DashboardData } from '../../interface/DashboardData'
-
-
-export class ReadToEarn extends Workers {
-    public async doReadToEarn(accessToken: string, data: DashboardData) {
-        this.bot.log(this.bot.isMobile, 'READ-TO-EARN', 'Starting Read to Earn')
-
-        try {
-            let geoLocale = data.userProfile.attributes.country
-            geoLocale = (this.bot.config.searchSettings.useGeoLocaleQueries && geoLocale.length === 2) ? geoLocale.toLowerCase() : 'us'
-
-            const userDataRequest: AxiosRequestConfig = {
-                url: 'https://prod.rewardsplatform.microsoft.com/dapi/me',
-                method: 'GET',
-                headers: {
-                    'Authorization': `Bearer ${accessToken}`,
-                    'X-Rewards-Country': geoLocale,
-                    'X-Rewards-Language': 'en'
-                }
-            }
-            const userDataResponse = await this.bot.axios.request(userDataRequest)
-            const userData = (await userDataResponse.data).response
-            let userBalance = userData.balance
-
-            const jsonData = {
-                amount: 1,
-                country: geoLocale,
-                id: '1',
-                type: 101,
-                attributes: {
-                    offerid: 'ENUS_readarticle3_30points'
-                }
-            }
-
-            const articleCount = 10
-            for (let i = 0; i < articleCount; ++i) {
-                jsonData.id = randomBytes(64).toString('hex')
-                const claimRequest = {
-                    url: 'https://prod.rewardsplatform.microsoft.com/dapi/me/activities',
-                    method: 'POST',
-                    headers: {
-                        'Authorization': `Bearer ${accessToken}`,
-                        'Content-Type': 'application/json',
-                        'X-Rewards-Country': geoLocale,
-                        'X-Rewards-Language': 'en'
-                    },
-                    data: JSON.stringify(jsonData)
-                }
-
-                const claimResponse = await this.bot.axios.request(claimRequest)
-                const newBalance = (await claimResponse.data).response.balance
-
-                if (newBalance == userBalance) {
-                    this.bot.log(this.bot.isMobile, 'READ-TO-EARN', 'Read all available articles')
-                    break
-                } else {
-                    this.bot.log(this.bot.isMobile, 'READ-TO-EARN', `Read article ${i + 1} of ${articleCount} max | Gained ${newBalance - userBalance} Points`)
-                    userBalance = newBalance
-                    await this.bot.utils.wait(Math.floor(this.bot.utils.randomNumber(this.bot.utils.stringToMs(this.bot.config.searchSettings.searchDelay.min), this.bot.utils.stringToMs(this.bot.config.searchSettings.searchDelay.max))))
-                }
-            }
-
-            this.bot.log(this.bot.isMobile, 'READ-TO-EARN', 'Completed Read to Earn')
-        } catch (error) {
-            this.bot.log(this.bot.isMobile, 'READ-TO-EARN', 'An error occurred:' + error, 'error')
-        }
-    }
-}

src/functions/activities/Search.ts

@@ -1,400 +0,0 @@
-import { Page } from 'rebrowser-playwright'
-import { platform } from 'os'
-
-import { Workers } from '../Workers'
-
-import { Counters, DashboardData } from '../../interface/DashboardData'
-import { GoogleSearch } from '../../interface/Search'
-import { AxiosRequestConfig } from 'axios'
-
-type GoogleTrendsResponse = [
-    string,
-    [
-        string,
-        ...null[],
-        [string, ...string[]]
-    ][]
-];
-
-export class Search extends Workers {
-    private bingHome = 'https://bing.com'
-    private searchPageURL = ''
-
-    public async doSearch(page: Page, data: DashboardData) {
-        this.bot.log(this.bot.isMobile, 'SEARCH-BING', 'Starting Bing searches')
-
-        page = await this.bot.browser.utils.getLatestTab(page)
-
-        let searchCounters: Counters = await this.bot.browser.func.getSearchPoints()
-        let missingPoints = this.calculatePoints(searchCounters)
-
-        if (missingPoints === 0) {
-            this.bot.log(this.bot.isMobile, 'SEARCH-BING', 'Bing searches have already been completed')
-            return
-        }
-
-        // Generate search queries
-        let googleSearchQueries = await this.getGoogleTrends(this.bot.config.searchSettings.useGeoLocaleQueries ? data.userProfile.attributes.country : 'US')
-        googleSearchQueries = this.bot.utils.shuffleArray(googleSearchQueries)
-
-        // Deduplicate the search terms
-        googleSearchQueries = [...new Set(googleSearchQueries)]
-
-        // Go to bing
-        await page.goto(this.searchPageURL ? this.searchPageURL : this.bingHome)
-
-        await this.bot.utils.wait(2000)
-
-        await this.bot.browser.utils.tryDismissAllMessages(page)
-
-        let maxLoop = 0 // If the loop hits 10 this when not gaining any points, we're assuming it's stuck. If it doesn't continue after 5 more searches with alternative queries, abort search
-
-        const queries: string[] = []
-        // Mobile search doesn't seem to like related queries?
-        googleSearchQueries.forEach(x => { this.bot.isMobile ? queries.push(x.topic) : queries.push(x.topic, ...x.related) })
-
-        // Loop over Google search queries
-        for (let i = 0; i < queries.length; i++) {
-            const query = queries[i] as string
-
-            this.bot.log(this.bot.isMobile, 'SEARCH-BING', `${missingPoints} Points Remaining | Query: ${query}`)
-
-            searchCounters = await this.bingSearch(page, query)
-            const newMissingPoints = this.calculatePoints(searchCounters)
-
-            // If the new point amount is the same as before
-            if (newMissingPoints == missingPoints) {
-                maxLoop++ // Add to max loop
-            } else { // There has been a change in points
-                maxLoop = 0 // Reset the loop
-            }
-
-            missingPoints = newMissingPoints
-
-            if (missingPoints === 0) {
-                break
-            }
-
-            // Only for mobile searches
-            if (maxLoop > 5 && this.bot.isMobile) {
-                this.bot.log(this.bot.isMobile, 'SEARCH-BING', 'Search didn\'t gain point for 5 iterations, likely bad User-Agent', 'warn')
-                break
-            }
-
-            // If we didn't gain points for 10 iterations, assume it's stuck
-            if (maxLoop > 10) {
-                this.bot.log(this.bot.isMobile, 'SEARCH-BING', 'Search didn\'t gain point for 10 iterations aborting searches', 'warn')
-                maxLoop = 0 // Reset to 0 so we can retry with related searches below
-                break
-            }
-        }
-
-        // Only for mobile searches
-        if (missingPoints > 0 && this.bot.isMobile) {
-            return
-        }
-
-        // If we still got remaining search queries, generate extra ones
-        if (missingPoints > 0) {
-            this.bot.log(this.bot.isMobile, 'SEARCH-BING', `Search completed but we're missing ${missingPoints} points, generating extra searches`)
-
-            let i = 0
-            while (missingPoints > 0) {
-                const query = googleSearchQueries[i++] as GoogleSearch
-
-                // Get related search terms to the Google search queries
-                const relatedTerms = await this.getRelatedTerms(query?.topic)
-                if (relatedTerms.length > 3) {
-                    // Search for the first 2 related terms
-                    for (const term of relatedTerms.slice(1, 3)) {
-                        this.bot.log(this.bot.isMobile, 'SEARCH-BING-EXTRA', `${missingPoints} Points Remaining | Query: ${term}`)
-
-                        searchCounters = await this.bingSearch(page, term)
-                        const newMissingPoints = this.calculatePoints(searchCounters)
-
-                        // If the new point amount is the same as before
-                        if (newMissingPoints == missingPoints) {
-                            maxLoop++ // Add to max loop
-                        } else { // There has been a change in points
-                            maxLoop = 0 // Reset the loop
-                        }
-
-                        missingPoints = newMissingPoints
-
-                        // If we satisfied the searches
-                        if (missingPoints === 0) {
-                            break
-                        }
-
-                        // Try 5 more times, then we tried a total of 15 times, fair to say it's stuck
-                        if (maxLoop > 5) {
-                            this.bot.log(this.bot.isMobile, 'SEARCH-BING-EXTRA', 'Search didn\'t gain point for 5 iterations aborting searches', 'warn')
-                            return
-                        }
-                    }
-                }
-            }
-        }
-
-        this.bot.log(this.bot.isMobile, 'SEARCH-BING', 'Completed searches')
-    }
-
-    private async bingSearch(searchPage: Page, query: string) {
-        const platformControlKey = platform() === 'darwin' ? 'Meta' : 'Control'
-
-        // Try a max of 5 times
-        for (let i = 0; i < 5; i++) {
-            try {
-                // This page had already been set to the Bing.com page or the previous search listing, we just need to select it
-                searchPage = await this.bot.browser.utils.getLatestTab(searchPage)
-
-                // Go to top of the page
-                await searchPage.evaluate(() => {
-                    window.scrollTo(0, 0)
-                })
-
-                await this.bot.utils.wait(500)
-
-                const searchBar = '#sb_form_q'
-                await searchPage.waitForSelector(searchBar, { state: 'visible', timeout: 10000 })
-                await searchPage.click(searchBar) // Focus on the textarea
-                await this.bot.utils.wait(500)
-                await searchPage.keyboard.down(platformControlKey)
-                await searchPage.keyboard.press('A')
-                await searchPage.keyboard.press('Backspace')
-                await searchPage.keyboard.up(platformControlKey)
-                await searchPage.keyboard.type(query)
-                await searchPage.keyboard.press('Enter')
-
-                await this.bot.utils.wait(3000)
-
-                // Bing.com in Chrome opens a new tab when searching
-                const resultPage = await this.bot.browser.utils.getLatestTab(searchPage)
-                this.searchPageURL = new URL(resultPage.url()).href // Set the results page
-
-                await this.bot.browser.utils.reloadBadPage(resultPage)
-
-                if (this.bot.config.searchSettings.scrollRandomResults) {
-                    await this.bot.utils.wait(2000)
-                    await this.randomScroll(resultPage)
-                }
-
-                if (this.bot.config.searchSettings.clickRandomResults) {
-                    await this.bot.utils.wait(2000)
-                    await this.clickRandomLink(resultPage)
-                }
-
-                // Delay between searches
-                await this.bot.utils.wait(Math.floor(this.bot.utils.randomNumber(this.bot.utils.stringToMs(this.bot.config.searchSettings.searchDelay.min), this.bot.utils.stringToMs(this.bot.config.searchSettings.searchDelay.max))))
-
-                return await this.bot.browser.func.getSearchPoints()
-
-            } catch (error) {
-                if (i === 5) {
-                    this.bot.log(this.bot.isMobile, 'SEARCH-BING', 'Failed after 5 retries... An error occurred:' + error, 'error')
-                    break
-
-                }
-
-                this.bot.log(this.bot.isMobile, 'SEARCH-BING', 'Search failed, An error occurred:' + error, 'error')
-                this.bot.log(this.bot.isMobile, 'SEARCH-BING', `Retrying search, attempt ${i}/5`, 'warn')
-
-                // Reset the tabs
-                const lastTab = await this.bot.browser.utils.getLatestTab(searchPage)
-                await this.closeTabs(lastTab)
-
-                await this.bot.utils.wait(4000)
-            }
-        }
-
-        this.bot.log(this.bot.isMobile, 'SEARCH-BING', 'Search failed after 5 retries, ending', 'error')
-        return await this.bot.browser.func.getSearchPoints()
-    }
-
-    private async getGoogleTrends(geoLocale: string = 'US'): Promise<GoogleSearch[]> {
-        const queryTerms: GoogleSearch[] = []
-        this.bot.log(this.bot.isMobile, 'SEARCH-GOOGLE-TRENDS', `Generating search queries, can take a while! | GeoLocale: ${geoLocale}`)
-
-        try {
-            const request: AxiosRequestConfig = {
-                url: 'https://trends.google.com/_/TrendsUi/data/batchexecute',
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8'
-                },
-                data: `f.req=[[[i0OFE,"[null, null, \\"${geoLocale.toUpperCase()}\\", 0, null, 48]"]]]`
-            }
-
-            const response = await this.bot.axios.request(request, this.bot.config.proxy.proxyGoogleTrends)
-            const rawText = response.data
-
-            const trendsData = this.extractJsonFromResponse(rawText)
-            if (!trendsData) {
-               throw  this.bot.log(this.bot.isMobile, 'SEARCH-GOOGLE-TRENDS', 'Failed to parse Google Trends response', 'error')
-            }
-
-            const mappedTrendsData = trendsData.map(query => [query[0], query[9]!.slice(1)])
-            if (mappedTrendsData.length < 90) {
-                this.bot.log(this.bot.isMobile, 'SEARCH-GOOGLE-TRENDS', 'Insufficient search queries, falling back to US', 'warn')
-                return this.getGoogleTrends()
-            }
-
-            for (const [topic, relatedQueries] of mappedTrendsData) {
-                queryTerms.push({
-                    topic: topic as string,
-                    related: relatedQueries as string[]
-                })
-            }
-
-        } catch (error) {
-            this.bot.log(this.bot.isMobile, 'SEARCH-GOOGLE-TRENDS', 'An error occurred:' + error, 'error')
-        }
-
-        return queryTerms
-    }
-
-    private extractJsonFromResponse(text: string): GoogleTrendsResponse[1] | null {
-        const lines = text.split('\n')
-        for (const line of lines) {
-            const trimmed = line.trim()
-            if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
-                try {
-                    return JSON.parse(JSON.parse(trimmed)[0][2])[1]
-                } catch {
-                    continue
-                }
-            }
-        }
-
-        return null
-    }
-
-    private async getRelatedTerms(term: string): Promise<string[]> {
-        try {
-            const request = {
-                url: `https://api.bing.com/osjson.aspx?query=${term}`,
-                method: 'GET',
-                headers: {
-                    'Content-Type': 'application/json'
-                }
-            }
-
-            const response = await this.bot.axios.request(request, this.bot.config.proxy.proxyBingTerms)
-
-            return response.data[1] as string[]
-        } catch (error) {
-            this.bot.log(this.bot.isMobile, 'SEARCH-BING-RELATED', 'An error occurred:' + error, 'error')
-        }
-
-        return []
-    }
-
-    private async randomScroll(page: Page) {
-        try {
-            const viewportHeight = await page.evaluate(() => window.innerHeight)
-            const totalHeight = await page.evaluate(() => document.body.scrollHeight)
-            const randomScrollPosition = Math.floor(Math.random() * (totalHeight - viewportHeight))
-
-            await page.evaluate((scrollPos: number) => {
-                window.scrollTo(0, scrollPos)
-            }, randomScrollPosition)
-
-        } catch (error) {
-            this.bot.log(this.bot.isMobile, 'SEARCH-RANDOM-SCROLL', 'An error occurred:' + error, 'error')
-        }
-    }
-
-    private async clickRandomLink(page: Page) {
-        try {
-            await page.click('#b_results .b_algo h2', { timeout: 2000 }).catch(() => { }) // Since we don't really care if it did it or not
-
-            // Only used if the browser is not the edge browser (continue on Edge popup)
-            await this.closeContinuePopup(page)
-
-            // Stay for 10 seconds for page to load and "visit"
-            await this.bot.utils.wait(10000)
-
-            // Will get current tab if no new one is created, this will always be the visited site or the result page if it failed to click
-            let lastTab = await this.bot.browser.utils.getLatestTab(page)
-
-            let lastTabURL = new URL(lastTab.url()) // Get new tab info, this is the website we're visiting
-
-            // Check if the URL is different from the original one, don't loop more than 5 times.
-            let i = 0
-            while (lastTabURL.href !== this.searchPageURL && i < 5) {
-
-                await this.closeTabs(lastTab)
-
-                // End of loop, refresh lastPage
-                lastTab = await this.bot.browser.utils.getLatestTab(page) // Finally update the lastTab var again
-                lastTabURL = new URL(lastTab.url()) // Get new tab info
-                i++
-            }
-
-        } catch (error) {
-            this.bot.log(this.bot.isMobile, 'SEARCH-RANDOM-CLICK', 'An error occurred:' + error, 'error')
-        }
-    }
-
-    private async closeTabs(lastTab: Page) {
-        const browser = lastTab.context()
-        const tabs = browser.pages()
-
-        try {
-            if (tabs.length > 2) {
-                // If more than 2 tabs are open, close the last tab
-
-                await lastTab.close()
-                this.bot.log(this.bot.isMobile, 'SEARCH-CLOSE-TABS', `More than 2 were open, closed the last tab: "${new URL(lastTab.url()).host}"`)
-
-            } else if (tabs.length === 1) {
-                // If only 1 tab is open, open a new one to search in
-
-                const newPage = await browser.newPage()
-                await this.bot.utils.wait(1000)
-
-                await newPage.goto(this.bingHome)
-                await this.bot.utils.wait(3000)
-                this.searchPageURL = newPage.url()
-
-                this.bot.log(this.bot.isMobile, 'SEARCH-CLOSE-TABS', 'There was only 1 tab open, crated a new one')
-            } else {
-                // Else reset the last tab back to the search listing or Bing.com
-
-                lastTab = await this.bot.browser.utils.getLatestTab(lastTab)
-                await lastTab.goto(this.searchPageURL ? this.searchPageURL : this.bingHome)
-            }
-
-        } catch (error) {
-            this.bot.log(this.bot.isMobile, 'SEARCH-CLOSE-TABS', 'An error occurred:' + error, 'error')
-        }
-
-    }
-
-    private calculatePoints(counters: Counters) {
-        const mobileData = counters.mobileSearch?.[0] // Mobile searches
-        const genericData = counters.pcSearch?.[0] // Normal searches
-        const edgeData = counters.pcSearch?.[1] // Edge searches
-
-        const missingPoints = (this.bot.isMobile && mobileData)
-            ? mobileData.pointProgressMax - mobileData.pointProgress
-            : (edgeData ? edgeData.pointProgressMax - edgeData.pointProgress : 0)
-            + (genericData ? genericData.pointProgressMax - genericData.pointProgress : 0)
-
-        return missingPoints
-    }
-
-    private async closeContinuePopup(page: Page) {
-        try {
-            await page.waitForSelector('#sacs_close', { timeout: 1000 })
-            const continueButton = await page.$('#sacs_close')
-
-            if (continueButton) {
-                await continueButton.click()
-            }
-        } catch (error) {
-            // Continue if element is not found or other error occurs
-        }
-    }
-
-}

src/functions/activities/SearchOnBing.ts

@@ -1,91 +0,0 @@
-import type { Page } from 'playwright'
-import * as fs from 'fs'
-import path from 'path'
-
-import { Workers } from '../Workers'
-
-import { MorePromotion, PromotionalItem } from '../../interface/DashboardData'
-
-
-export class SearchOnBing extends Workers {
-
-    async doSearchOnBing(page: Page, activity: MorePromotion | PromotionalItem) {
-        this.bot.log(this.bot.isMobile, 'SEARCH-ON-BING', 'Trying to complete SearchOnBing')
-
-        try {
-            await this.bot.utils.wait(5000)
-
-            await this.bot.browser.utils.tryDismissAllMessages(page)
-
-            const query = await this.getSearchQuery(activity.title)
-
-            const searchBar = '#sb_form_q'
-            await page.waitForSelector(searchBar, { state: 'visible', timeout: 10000 })
-            await this.safeClick(page, searchBar)
-            await this.bot.utils.wait(500)
-            await page.keyboard.type(query)
-            await page.keyboard.press('Enter')
-            await this.bot.utils.wait(3000)
-
-            await page.close()
-
-            this.bot.log(this.bot.isMobile, 'SEARCH-ON-BING', 'Completed the SearchOnBing successfully')
-        } catch (error) {
-            await page.close()
-            this.bot.log(this.bot.isMobile, 'SEARCH-ON-BING', 'An error occurred:' + error, 'error')
-        }
-    }
-
-    private async safeClick(page: Page, selector: string) {
-        try {
-            await page.click(selector, { timeout: 5000 })
-        } catch (e: any) {
-            const msg = (e?.message || '')
-            if (/Timeout.*click/i.test(msg) || /intercepts pointer events/i.test(msg)) {
-                // Try to dismiss overlays then retry once
-                await this.bot.browser.utils.tryDismissAllMessages(page)
-                await this.bot.utils.wait(500)
-                await page.click(selector, { timeout: 5000 })
-            } else {
-                throw e
-            }
-        }
-    }
-
-    private async getSearchQuery(title: string): Promise<string> {
-        interface Queries {
-            title: string;
-            queries: string[]
-        }
-
-        let queries: Queries[] = []
-
-        try {
-            if (this.bot.config.searchOnBingLocalQueries) {
-                const data = fs.readFileSync(path.join(__dirname, '../queries.json'), 'utf8')
-                queries = JSON.parse(data)
-            } else {
-                // Fetch from the repo directly so the user doesn't need to redownload the script for the new activities
-                const response = await this.bot.axios.request({
-                    method: 'GET',
-                    url: 'https://raw.githubusercontent.com/TheNetsky/Microsoft-Rewards-Script/refs/heads/v1/src/functions/queries.json'
-                })
-                queries = response.data
-            }
-
-            const answers = queries.find(x => this.normalizeString(x.title) === this.normalizeString(title))
-            const answer = answers ? this.bot.utils.shuffleArray(answers?.queries)[0] as string : title
-
-            this.bot.log(this.bot.isMobile, 'SEARCH-ON-BING-QUERY', `Fetched answer: ${answer} | question: ${title}`)
-            return answer
-
-        } catch (error) {
-            this.bot.log(this.bot.isMobile, 'SEARCH-ON-BING-QUERY', 'An error occurred:' + error, 'error')
-            return title
-        }
-    }
-
-    private normalizeString(string: string): string {
-        return string.normalize('NFD').trim().toLowerCase().replace(/[^\x20-\x7E]/g, '').replace(/[?!]/g, '')
-    }
-}

src/functions/activities/ThisOrThat.ts

@@ -1,47 +0,0 @@
-import { Page } from 'rebrowser-playwright'
-
-import { Workers } from '../Workers'
-
-
-export class ThisOrThat extends Workers {
-
-    async doThisOrThat(page: Page) {
-        this.bot.log(this.bot.isMobile, 'THIS-OR-THAT', 'Trying to complete ThisOrThat')
-
-
-        try {
-            // Check if the quiz has been started or not
-            const quizNotStarted = await page.waitForSelector('#rqStartQuiz', { state: 'visible', timeout: 2000 }).then(() => true).catch(() => false)
-            if (quizNotStarted) {
-                await page.click('#rqStartQuiz')
-            } else {
-                this.bot.log(this.bot.isMobile, 'THIS-OR-THAT', 'ThisOrThat has already been started, trying to finish it')
-            }
-
-            await this.bot.utils.wait(2000)
-
-            // Solving
-            const quizData = await this.bot.browser.func.getQuizData(page)
-            const questionsRemaining = quizData.maxQuestions - (quizData.currentQuestionNumber - 1) // Amount of questions remaining
-
-            for (let question = 0; question < questionsRemaining; question++) {
-                // Since there's no solving logic yet, randomly guess to complete
-                const buttonId = `#rqAnswerOption${Math.floor(this.bot.utils.randomNumber(0, 1))}`
-                await page.click(buttonId)
-
-                const refreshSuccess = await this.bot.browser.func.waitForQuizRefresh(page)
-                if (!refreshSuccess) {
-                    await page.close()
-                    this.bot.log(this.bot.isMobile, 'QUIZ', 'An error occurred, refresh was unsuccessful', 'error')
-                    return
-                }
-            }
-
-            this.bot.log(this.bot.isMobile, 'THIS-OR-THAT', 'Completed the ThisOrThat successfully')
-        } catch (error) {
-            await page.close()
-            this.bot.log(this.bot.isMobile, 'THIS-OR-THAT', 'An error occurred:' + error, 'error')
-        }
-    }
-
-}

src/functions/activities/UrlReward.ts

@@ -1,23 +0,0 @@
-import { Page } from 'rebrowser-playwright'
-
-import { Workers } from '../Workers'
-
-
-export class UrlReward extends Workers {
-
-    async doUrlReward(page: Page) {
-        this.bot.log(this.bot.isMobile, 'URL-REWARD', 'Trying to complete UrlReward')
-
-        try {
-            this.bot.utils.wait(2000)
-
-            await page.close()
-
-            this.bot.log(this.bot.isMobile, 'URL-REWARD', 'Completed the UrlReward successfully')
-        } catch (error) {
-            await page.close()
-            this.bot.log(this.bot.isMobile, 'URL-REWARD', 'An error occurred:' + error, 'error')
-        }
-    }
-
-}

src/functions/activities/api/FindClippy.ts

@@ -0,0 +1,130 @@
+import type { AxiosRequestConfig } from 'axios'
+import type { FindClippyPromotion } from '../../../interface/DashboardData'
+import { Workers } from '../../Workers'
+
+export class FindClippy extends Workers {
+    private cookieHeader: string = ''
+
+    private fingerprintHeader: { [x: string]: string } = {}
+
+    private gainedPoints: number = 0
+
+    private oldBalance: number = this.bot.userData.currentPoints
+
+    public async doFindClippy(promotion: FindClippyPromotion) {
+        const offerId = promotion.offerId
+        const activityType = promotion.activityType
+
+        try {
+            if (!this.bot.requestToken) {
+                this.bot.logger.warn(
+                    this.bot.isMobile,
+                    'FIND-CLIPPY',
+                    'Skipping: Request token not available, this activity requires it!'
+                )
+                return
+            }
+
+            this.cookieHeader = (this.bot.isMobile ? this.bot.cookies.mobile : this.bot.cookies.desktop)
+                .map((c: { name: string; value: string }) => `${c.name}=${c.value}`)
+                .join('; ')
+
+            const fingerprintHeaders = { ...this.bot.fingerprint.headers }
+            delete fingerprintHeaders['Cookie']
+            delete fingerprintHeaders['cookie']
+            this.fingerprintHeader = fingerprintHeaders
+
+            this.bot.logger.info(
+                this.bot.isMobile,
+                'FIND-CLIPPY',
+                `Starting Find Clippy | offerId=${offerId} | activityType=${activityType} | oldBalance=${this.oldBalance}`
+            )
+
+            this.bot.logger.debug(
+                this.bot.isMobile,
+                'FIND-CLIPPY',
+                `Prepared headers | cookieLength=${this.cookieHeader.length} | fingerprintHeaderKeys=${Object.keys(this.fingerprintHeader).length}`
+            )
+
+            const formData = new URLSearchParams({
+                id: offerId,
+                hash: promotion.hash,
+                timeZone: '60',
+                activityAmount: '1',
+                dbs: '0',
+                form: '',
+                type: activityType,
+                __RequestVerificationToken: this.bot.requestToken
+            })
+
+            this.bot.logger.debug(
+                this.bot.isMobile,
+                'FIND-CLIPPY',
+                `Prepared Find Clippy form data | offerId=${offerId} | hash=${promotion.hash} | timeZone=60 | activityAmount=1 | type=${activityType}`
+            )
+
+            const request: AxiosRequestConfig = {
+                url: 'https://rewards.bing.com/api/reportactivity?X-Requested-With=XMLHttpRequest',
+                method: 'POST',
+                headers: {
+                    ...(this.bot.fingerprint?.headers ?? {}),
+                    Cookie: this.cookieHeader,
+                    Referer: 'https://rewards.bing.com/',
+                    Origin: 'https://rewards.bing.com'
+                },
+                data: formData
+            }
+
+            this.bot.logger.debug(
+                this.bot.isMobile,
+                'FIND-CLIPPY',
+                `Sending Find Clippy request | offerId=${offerId} | url=${request.url}`
+            )
+
+            const response = await this.bot.axios.request(request)
+
+            this.bot.logger.debug(
+                this.bot.isMobile,
+                'FIND-CLIPPY',
+                `Received Find Clippy response | offerId=${offerId} | status=${response.status}`
+            )
+
+            const newBalance = await this.bot.browser.func.getCurrentPoints()
+            this.gainedPoints = newBalance - this.oldBalance
+
+            this.bot.logger.debug(
+                this.bot.isMobile,
+                'FIND-CLIPPY',
+                `Balance delta after Find Clippy | offerId=${offerId} | oldBalance=${this.oldBalance} | newBalance=${newBalance} | gainedPoints=${this.gainedPoints}`
+            )
+
+            if (this.gainedPoints > 0) {
+                this.bot.userData.currentPoints = newBalance
+                this.bot.userData.gainedPoints = (this.bot.userData.gainedPoints ?? 0) + this.gainedPoints
+
+                this.bot.logger.info(
+                    this.bot.isMobile,
+                    'FIND-CLIPPY',
+                    `Found Clippy | offerId=${offerId} | status=${response.status} | gainedPoints=${this.gainedPoints} | newBalance=${newBalance}`,
+                    'green'
+                )
+            } else {
+                this.bot.logger.warn(
+                    this.bot.isMobile,
+                    'FIND-CLIPPY',
+                    `Found Clippy but no points were gained | offerId=${offerId} | status=${response.status} | oldBalance=${this.oldBalance} | newBalance=${newBalance}`
+                )
+            }
+
+            this.bot.logger.debug(this.bot.isMobile, 'FIND-CLIPPY', `Waiting after Find Clippy | offerId=${offerId}`)
+
+            await this.bot.utils.wait(this.bot.utils.randomDelay(5000, 10000))
+        } catch (error) {
+            this.bot.logger.error(
+                this.bot.isMobile,
+                'FIND-CLIPPY',
+                `Error in doFindClippy | offerId=${offerId} | message=${error instanceof Error ? error.message : String(error)}`
+            )
+        }
+    }
+}

src/functions/activities/api/Quiz.ts

@@ -0,0 +1,173 @@
+import type { AxiosRequestConfig } from 'axios'
+import type { BasePromotion } from '../../../interface/DashboardData'
+import { Workers } from '../../Workers'
+
+export class Quiz extends Workers {
+    private cookieHeader: string = ''
+
+    private fingerprintHeader: { [x: string]: string } = {}
+
+    private gainedPoints: number = 0
+
+    private oldBalance: number = this.bot.userData.currentPoints
+
+    async doQuiz(promotion: BasePromotion) {
+        const offerId = promotion.offerId
+        this.oldBalance = Number(this.bot.userData.currentPoints ?? 0)
+        const startBalance = this.oldBalance
+
+        this.bot.logger.info(
+            this.bot.isMobile,
+            'QUIZ',
+            `Starting quiz | offerId=${offerId} | pointProgressMax=${promotion.pointProgressMax} | activityProgressMax=${promotion.activityProgressMax} | currentPoints=${startBalance}`
+        )
+
+        try {
+            this.cookieHeader = (this.bot.isMobile ? this.bot.cookies.mobile : this.bot.cookies.desktop)
+                .map((c: { name: string; value: string }) => `${c.name}=${c.value}`)
+                .join('; ')
+
+            const fingerprintHeaders = { ...this.bot.fingerprint.headers }
+            delete fingerprintHeaders['Cookie']
+            delete fingerprintHeaders['cookie']
+            this.fingerprintHeader = fingerprintHeaders
+
+            this.bot.logger.debug(
+                this.bot.isMobile,
+                'QUIZ',
+                `Prepared quiz headers | offerId=${offerId} | cookieLength=${this.cookieHeader.length} | fingerprintHeaderKeys=${Object.keys(this.fingerprintHeader).length}`
+            )
+
+            // 8-question quiz
+            if (promotion.activityProgressMax === 80) {
+                this.bot.logger.warn(
+                    this.bot.isMobile,
+                    'QUIZ',
+                    `Detected 8-question quiz (activityProgressMax=80), marking as completed | offerId=${offerId}`
+                )
+
+                // Not implemented
+                return
+            }
+
+            //Standard points quizzes (20/30/40/50 max)
+            if ([20, 30, 40, 50].includes(promotion.pointProgressMax)) {
+                let oldBalance = startBalance
+                let gainedPoints = 0
+                const maxAttempts = 20
+                let totalGained = 0
+                let attempts = 0
+
+                this.bot.logger.debug(
+                    this.bot.isMobile,
+                    'QUIZ',
+                    `Starting ReportActivity loop | offerId=${offerId} | maxAttempts=${maxAttempts} | startingBalance=${oldBalance}`
+                )
+
+                for (let i = 0; i < maxAttempts; i++) {
+                    try {
+                        const jsonData = {
+                            UserId: null,
+                            TimeZoneOffset: -60,
+                            OfferId: offerId,
+                            ActivityCount: 1,
+                            QuestionIndex: '-1'
+                        }
+
+                        const request: AxiosRequestConfig = {
+                            url: 'https://www.bing.com/bingqa/ReportActivity?ajaxreq=1',
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
+                                cookie: this.cookieHeader,
+                                ...this.fingerprintHeader
+                            },
+                            data: JSON.stringify(jsonData)
+                        }
+
+                        this.bot.logger.debug(
+                            this.bot.isMobile,
+                            'QUIZ',
+                            `Sending ReportActivity request | attempt=${i + 1}/${maxAttempts} | offerId=${offerId} | url=${request.url}`
+                        )
+
+                        const response = await this.bot.axios.request(request)
+
+                        this.bot.logger.debug(
+                            this.bot.isMobile,
+                            'QUIZ',
+                            `Received ReportActivity response | attempt=${i + 1}/${maxAttempts} | offerId=${offerId} | status=${response.status}`
+                        )
+
+                        const newBalance = await this.bot.browser.func.getCurrentPoints()
+                        gainedPoints = newBalance - oldBalance
+
+                        this.bot.logger.debug(
+                            this.bot.isMobile,
+                            'QUIZ',
+                            `Balance delta after ReportActivity | attempt=${i + 1}/${maxAttempts} | offerId=${offerId} | oldBalance=${oldBalance} | newBalance=${newBalance} | gainedPoints=${gainedPoints}`
+                        )
+
+                        attempts = i + 1
+
+                        if (gainedPoints > 0) {
+                            this.bot.userData.currentPoints = newBalance
+                            this.bot.userData.gainedPoints = (this.bot.userData.gainedPoints ?? 0) + gainedPoints
+
+                            oldBalance = newBalance
+                            totalGained += gainedPoints
+                            this.gainedPoints += gainedPoints
+
+                            this.bot.logger.info(
+                                this.bot.isMobile,
+                                'QUIZ',
+                                `ReportActivity ${i + 1} → ${response.status} | offerId=${offerId} | gainedPoints=${gainedPoints} | newBalance=${newBalance}`,
+                                'green'
+                            )
+                        } else {
+                            this.bot.logger.warn(
+                                this.bot.isMobile,
+                                'QUIZ',
+                                `ReportActivity ${i + 1} | offerId=${offerId} | no more points gained, ending quiz | lastBalance=${newBalance}`
+                            )
+                            break
+                        }
+
+                        this.bot.logger.debug(
+                            this.bot.isMobile,
+                            'QUIZ',
+                            `Waiting between ReportActivity attempts | attempt=${i + 1}/${maxAttempts} | offerId=${offerId}`
+                        )
+
+                        await this.bot.utils.wait(this.bot.utils.randomDelay(5000, 7000))
+                    } catch (error) {
+                        this.bot.logger.error(
+                            this.bot.isMobile,
+                            'QUIZ',
+                            `Error during ReportActivity | attempt=${i + 1}/${maxAttempts} | offerId=${offerId} | message=${error instanceof Error ? error.message : String(error)}`
+                        )
+                        break
+                    }
+                }
+
+                this.bot.logger.info(
+                    this.bot.isMobile,
+                    'QUIZ',
+                    `Completed the quiz successfully | offerId=${offerId} | attempts=${attempts} | totalGained=${totalGained} | startBalance=${startBalance} | finalBalance=${this.bot.userData.currentPoints}`
+                )
+            } else {
+                this.bot.logger.warn(
+                    this.bot.isMobile,
+                    'QUIZ',
+                    `Unsupported quiz configuration | offerId=${offerId} | pointProgressMax=${promotion.pointProgressMax} | activityProgressMax=${promotion.activityProgressMax}`
+                )
+            }
+        } catch (error) {
+            this.bot.logger.error(
+                this.bot.isMobile,
+                'QUIZ',
+                `Error in doQuiz | offerId=${promotion.offerId} | message=${error instanceof Error ? error.message : String(error)}`
+            )
+        }
+    }
+}

src/functions/activities/api/UrlReward.ts

@@ -0,0 +1,129 @@
+import type { AxiosRequestConfig } from 'axios'
+import type { BasePromotion } from '../../../interface/DashboardData'
+import { Workers } from '../../Workers'
+
+export class UrlReward extends Workers {
+    private cookieHeader: string = ''
+
+    private fingerprintHeader: { [x: string]: string } = {}
+
+    private gainedPoints: number = 0
+
+    private oldBalance: number = this.bot.userData.currentPoints
+
+    public async doUrlReward(promotion: BasePromotion) {
+        if (!this.bot.requestToken) {
+            this.bot.logger.warn(
+                this.bot.isMobile,
+                'URL-REWARD',
+                'Skipping: Request token not available, this activity requires it!'
+            )
+            return
+        }
+
+        const offerId = promotion.offerId
+
+        this.bot.logger.info(
+            this.bot.isMobile,
+            'URL-REWARD',
+            `Starting UrlReward | offerId=${offerId} | geo=${this.bot.userData.geoLocale} | oldBalance=${this.oldBalance}`
+        )
+
+        try {
+            this.cookieHeader = (this.bot.isMobile ? this.bot.cookies.mobile : this.bot.cookies.desktop)
+                .map((c: { name: string; value: string }) => `${c.name}=${c.value}`)
+                .join('; ')
+
+            const fingerprintHeaders = { ...this.bot.fingerprint.headers }
+            delete fingerprintHeaders['Cookie']
+            delete fingerprintHeaders['cookie']
+            this.fingerprintHeader = fingerprintHeaders
+
+            this.bot.logger.debug(
+                this.bot.isMobile,
+                'URL-REWARD',
+                `Prepared UrlReward headers | offerId=${offerId} | cookieLength=${this.cookieHeader.length} | fingerprintHeaderKeys=${Object.keys(this.fingerprintHeader).length}`
+            )
+
+            const formData = new URLSearchParams({
+                id: offerId,
+                hash: promotion.hash,
+                timeZone: '60',
+                activityAmount: '1',
+                dbs: '0',
+                form: '',
+                type: '',
+                __RequestVerificationToken: this.bot.requestToken
+            })
+
+            this.bot.logger.debug(
+                this.bot.isMobile,
+                'URL-REWARD',
+                `Prepared UrlReward form data | offerId=${offerId} | hash=${promotion.hash} | timeZone=60 | activityAmount=1`
+            )
+
+            const request: AxiosRequestConfig = {
+                url: 'https://rewards.bing.com/api/reportactivity?X-Requested-With=XMLHttpRequest',
+                method: 'POST',
+                headers: {
+                    ...(this.bot.fingerprint?.headers ?? {}),
+                    Cookie: this.cookieHeader,
+                    Referer: 'https://rewards.bing.com/',
+                    Origin: 'https://rewards.bing.com'
+                },
+                data: formData
+            }
+
+            this.bot.logger.debug(
+                this.bot.isMobile,
+                'URL-REWARD',
+                `Sending UrlReward request | offerId=${offerId} | url=${request.url}`
+            )
+
+            const response = await this.bot.axios.request(request)
+
+            this.bot.logger.debug(
+                this.bot.isMobile,
+                'URL-REWARD',
+                `Received UrlReward response | offerId=${offerId} | status=${response.status}`
+            )
+
+            const newBalance = await this.bot.browser.func.getCurrentPoints()
+            this.gainedPoints = newBalance - this.oldBalance
+
+            this.bot.logger.debug(
+                this.bot.isMobile,
+                'URL-REWARD',
+                `Balance delta after UrlReward | offerId=${offerId} | oldBalance=${this.oldBalance} | newBalance=${newBalance} | gainedPoints=${this.gainedPoints}`
+            )
+
+            if (this.gainedPoints > 0) {
+                this.bot.userData.currentPoints = newBalance
+                this.bot.userData.gainedPoints = (this.bot.userData.gainedPoints ?? 0) + this.gainedPoints
+
+                this.bot.logger.info(
+                    this.bot.isMobile,
+                    'URL-REWARD',
+                    `Completed UrlReward | offerId=${offerId} | status=${response.status} | gainedPoints=${this.gainedPoints} | newBalance=${newBalance}`,
+                    'green'
+                )
+            } else {
+                this.bot.logger.warn(
+                    this.bot.isMobile,
+                    'URL-REWARD',
+                    `Failed UrlReward with no points | offerId=${offerId} | status=${response.status} | oldBalance=${this.oldBalance} | newBalance=${newBalance}`
+                )
+            }
+
+            this.bot.logger.debug(this.bot.isMobile, 'URL-REWARD', `Waiting after UrlReward | offerId=${offerId}`)
+
+            await this.bot.utils.wait(this.bot.utils.randomDelay(5000, 10000))
+        } catch (error) {
+            this.bot.logger.error(
+                this.bot.isMobile,
+                'URL-REWARD',
+                `Error in doUrlReward | offerId=${promotion.offerId} | message=${error instanceof Error ? error.message : String(error)}`
+            )
+        }
+    }
+}

src/functions/activities/app/AppReward.ts

@@ -0,0 +1,119 @@
+import type { AxiosRequestConfig } from 'axios'
+import { randomUUID } from 'crypto'
+import type { Promotion } from '../../../interface/AppDashBoardData'
+import { Workers } from '../../Workers'
+
+export class AppReward extends Workers {
+    private gainedPoints: number = 0
+
+    private oldBalance: number = this.bot.userData.currentPoints
+
+    public async doAppReward(promotion: Promotion) {
+        if (!this.bot.accessToken) {
+            this.bot.logger.warn(
+                this.bot.isMobile,
+                'APP-REWARD',
+                'Skipping: App access token not available, this activity requires it!'
+            )
+            return
+        }
+
+        const offerId = promotion.attributes['offerid']
+
+        this.bot.logger.info(
+            this.bot.isMobile,
+            'APP-REWARD',
+            `Starting AppReward | offerId=${offerId} | country=${this.bot.userData.geoLocale} | oldBalance=${this.oldBalance}`
+        )
+
+        try {
+            const jsonData = {
+                id: randomUUID(),
+                amount: 1,
+                type: 101,
+                attributes: {
+                    offerid: offerId
+                },
+                country: this.bot.userData.geoLocale
+            }
+
+            this.bot.logger.debug(
+                this.bot.isMobile,
+                'APP-REWARD',
+                `Prepared activity payload | offerId=${offerId} | id=${jsonData.id} | amount=${jsonData.amount} | type=${jsonData.type} | country=${jsonData.country}`
+            )
+
+            const request: AxiosRequestConfig = {
+                url: 'https://prod.rewardsplatform.microsoft.com/dapi/me/activities',
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${this.bot.accessToken}`,
+                    'User-Agent':
+                        'Bing/32.5.431027001 (com.microsoft.bing; build:431027001; iOS 17.6.1) Alamofire/5.10.2',
+                    'Content-Type': 'application/json',
+                    'X-Rewards-Country': this.bot.userData.geoLocale,
+                    'X-Rewards-Language': 'en',
+                    'X-Rewards-ismobile': 'true'
+                },
+                data: JSON.stringify(jsonData)
+            }
+
+            this.bot.logger.debug(
+                this.bot.isMobile,
+                'APP-REWARD',
+                `Sending activity request | offerId=${offerId} | url=${request.url}`
+            )
+
+            const response = await this.bot.axios.request(request)
+
+            this.bot.logger.debug(
+                this.bot.isMobile,
+                'APP-REWARD',
+                `Received activity response | offerId=${offerId} | status=${response.status}`
+            )
+
+            const newBalance = Number(response?.data?.response?.balance ?? this.oldBalance)
+            this.gainedPoints = newBalance - this.oldBalance
+
+            this.bot.logger.debug(
+                this.bot.isMobile,
+                'APP-REWARD',
+                `Balance delta after AppReward | offerId=${offerId} | oldBalance=${this.oldBalance} | newBalance=${newBalance} | gainedPoints=${this.gainedPoints}`
+            )
+
+            if (this.gainedPoints > 0) {
+                this.bot.userData.currentPoints = newBalance
+                this.bot.userData.gainedPoints = (this.bot.userData.gainedPoints ?? 0) + this.gainedPoints
+
+                this.bot.logger.info(
+                    this.bot.isMobile,
+                    'APP-REWARD',
+                    `Completed AppReward | offerId=${offerId} | gainedPoints=${this.gainedPoints} | oldBalance=${this.oldBalance} | newBalance=${newBalance}`,
+                    'green'
+                )
+            } else {
+                this.bot.logger.warn(
+                    this.bot.isMobile,
+                    'APP-REWARD',
+                    `Completed AppReward with no points | offerId=${offerId} | oldBalance=${this.oldBalance} | newBalance=${newBalance}`
+                )
+            }
+
+            this.bot.logger.debug(this.bot.isMobile, 'APP-REWARD', `Waiting after AppReward | offerId=${offerId}`)
+
+            await this.bot.utils.wait(this.bot.utils.randomDelay(5000, 10000))
+
+            this.bot.logger.info(
+                this.bot.isMobile,
+                'APP-REWARD',
+                `Finished AppReward | offerId=${offerId} | finalBalance=${this.bot.userData.currentPoints}`
+            )
+        } catch (error) {
+            this.bot.logger.error(
+                this.bot.isMobile,
+                'APP-REWARD',
+                `Error in doAppReward | offerId=${offerId} | message=${error instanceof Error ? error.message : String(error)}`
+            )
+        }
+    }
+}

src/functions/activities/app/DailyCheckIn.ts

@@ -0,0 +1,161 @@
+import type { AxiosRequestConfig } from 'axios'
+import { randomUUID } from 'crypto'
+import { Workers } from '../../Workers'
+
+export class DailyCheckIn extends Workers {
+    private gainedPoints: number = 0
+
+    private oldBalance: number = this.bot.userData.currentPoints
+
+    public async doDailyCheckIn() {
+        if (!this.bot.accessToken) {
+            this.bot.logger.warn(
+                this.bot.isMobile,
+                'DAILY-CHECK-IN',
+                'Skipping: App access token not available, this activity requires it!'
+            )
+            return
+        }
+
+        this.oldBalance = Number(this.bot.userData.currentPoints ?? 0)
+
+        this.bot.logger.info(
+            this.bot.isMobile,
+            'DAILY-CHECK-IN',
+            `Starting Daily Check-In | geo=${this.bot.userData.geoLocale} | currentPoints=${this.oldBalance}`
+        )
+
+        try {
+            // Try type 101 first
+            this.bot.logger.debug(this.bot.isMobile, 'DAILY-CHECK-IN', 'Attempting Daily Check-In | type=101')
+
+            let response = await this.submitDaily(101) // Try using 101 (EU Variant?)
+            this.bot.logger.debug(
+                this.bot.isMobile,
+                'DAILY-CHECK-IN',
+                `Received Daily Check-In response | type=101 | status=${response?.status ?? 'unknown'}`
+            )
+
+            let newBalance = Number(response?.data?.response?.balance ?? this.oldBalance)
+            this.gainedPoints = newBalance - this.oldBalance
+
+            this.bot.logger.debug(
+                this.bot.isMobile,
+                'DAILY-CHECK-IN',
+                `Balance delta after Daily Check-In | type=101 | oldBalance=${this.oldBalance} | newBalance=${newBalance} | gainedPoints=${this.gainedPoints}`
+            )
+
+            if (this.gainedPoints > 0) {
+                this.bot.userData.currentPoints = newBalance
+                this.bot.userData.gainedPoints = (this.bot.userData.gainedPoints ?? 0) + this.gainedPoints
+
+                this.bot.logger.info(
+                    this.bot.isMobile,
+                    'DAILY-CHECK-IN',
+                    `Completed Daily Check-In | type=101 | gainedPoints=${this.gainedPoints} | oldBalance=${this.oldBalance} | newBalance=${newBalance}`,
+                    'green'
+                )
+                return
+            }
+
+            this.bot.logger.debug(
+                this.bot.isMobile,
+                'DAILY-CHECK-IN',
+                `No points gained with type=101 | oldBalance=${this.oldBalance} | newBalance=${newBalance} | retryingWithType=103`
+            )
+
+            // Fallback to type 103
+            this.bot.logger.debug(this.bot.isMobile, 'DAILY-CHECK-IN', 'Attempting Daily Check-In | type=103')
+
+            response = await this.submitDaily(103) // Try using 103 (USA Variant?)
+            this.bot.logger.debug(
+                this.bot.isMobile,
+                'DAILY-CHECK-IN',
+                `Received Daily Check-In response | type=103 | status=${response?.status ?? 'unknown'}`
+            )
+
+            newBalance = Number(response?.data?.response?.balance ?? this.oldBalance)
+            this.gainedPoints = newBalance - this.oldBalance
+
+            this.bot.logger.debug(
+                this.bot.isMobile,
+                'DAILY-CHECK-IN',
+                `Balance delta after Daily Check-In | type=103 | oldBalance=${this.oldBalance} | newBalance=${newBalance} | gainedPoints=${this.gainedPoints}`
+            )
+
+            if (this.gainedPoints > 0) {
+                this.bot.userData.currentPoints = newBalance
+                this.bot.userData.gainedPoints = (this.bot.userData.gainedPoints ?? 0) + this.gainedPoints
+
+                this.bot.logger.info(
+                    this.bot.isMobile,
+                    'DAILY-CHECK-IN',
+                    `Completed Daily Check-In | type=103 | gainedPoints=${this.gainedPoints} | oldBalance=${this.oldBalance} | newBalance=${newBalance}`,
+                    'green'
+                )
+            } else {
+                this.bot.logger.warn(
+                    this.bot.isMobile,
+                    'DAILY-CHECK-IN',
+                    `Daily Check-In completed but no points gained | typesTried=101,103 | oldBalance=${this.oldBalance} | finalBalance=${newBalance}`
+                )
+            }
+        } catch (error) {
+            this.bot.logger.error(
+                this.bot.isMobile,
+                'DAILY-CHECK-IN',
+                `Error during Daily Check-In | message=${error instanceof Error ? error.message : String(error)}`
+            )
+        }
+    }
+
+    private async submitDaily(type: number) {
+        try {
+            const jsonData = {
+                id: randomUUID(),
+                amount: 1,
+                type: type,
+                attributes: {
+                    offerid: 'Gamification_Sapphire_DailyCheckIn'
+                },
+                country: this.bot.userData.geoLocale
+            }
+
+            this.bot.logger.debug(
+                this.bot.isMobile,
+                'DAILY-CHECK-IN',
+                `Preparing Daily Check-In payload | type=${type} | id=${jsonData.id} | amount=${jsonData.amount} | country=${jsonData.country}`
+            )
+
+            const request: AxiosRequestConfig = {
+                url: 'https://prod.rewardsplatform.microsoft.com/dapi/me/activities',
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${this.bot.accessToken}`,
+                    'User-Agent':
+                        'Bing/32.5.431027001 (com.microsoft.bing; build:431027001; iOS 17.6.1) Alamofire/5.10.2',
+                    'Content-Type': 'application/json',
+                    'X-Rewards-Country': this.bot.userData.geoLocale,
+                    'X-Rewards-Language': 'en',
+                    'X-Rewards-ismobile': 'true'
+                },
+                data: JSON.stringify(jsonData)
+            }
+
+            this.bot.logger.debug(
+                this.bot.isMobile,
+                'DAILY-CHECK-IN',
+                `Sending Daily Check-In request | type=${type} | url=${request.url}`
+            )
+
+            return this.bot.axios.request(request)
+        } catch (error) {
+            this.bot.logger.error(
+                this.bot.isMobile,
+                'DAILY-CHECK-IN',
+                `Error in submitDaily | type=${type} | message=${error instanceof Error ? error.message : String(error)}`
+            )
+            throw error
+        }
+    }
+}

src/functions/activities/app/ReadToEarn.ts

@@ -0,0 +1,131 @@
+import type { AxiosRequestConfig } from 'axios'
+import { randomBytes } from 'crypto'
+import { Workers } from '../../Workers'
+
+export class ReadToEarn extends Workers {
+    public async doReadToEarn() {
+        if (!this.bot.accessToken) {
+            this.bot.logger.warn(
+                this.bot.isMobile,
+                'READ-TO-EARN',
+                'Skipping: App access token not available, this activity requires it!'
+            )
+            return
+        }
+
+        const delayMin = this.bot.config.searchSettings.readDelay.min
+        const delayMax = this.bot.config.searchSettings.readDelay.max
+        const startBalance = Number(this.bot.userData.currentPoints ?? 0)
+
+        this.bot.logger.info(
+            this.bot.isMobile,
+            'READ-TO-EARN',
+            `Starting Read to Earn | geo=${this.bot.userData.geoLocale} | delayRange=${delayMin}-${delayMax} | currentPoints=${startBalance}`
+        )
+
+        try {
+            const jsonData = {
+                amount: 1,
+                id: '1',
+                type: 101,
+                attributes: {
+                    offerid: 'ENUS_readarticle3_30points'
+                },
+                country: this.bot.userData.geoLocale
+            }
+
+            const articleCount = 10
+            let totalGained = 0
+            let articlesRead = 0
+            let oldBalance = startBalance
+
+            for (let i = 0; i < articleCount; ++i) {
+                jsonData.id = randomBytes(64).toString('hex')
+
+                this.bot.logger.debug(
+                    this.bot.isMobile,
+                    'READ-TO-EARN',
+                    `Submitting Read to Earn activity | article=${i + 1}/${articleCount} | id=${jsonData.id} | country=${jsonData.country}`
+                )
+
+                const request: AxiosRequestConfig = {
+                    url: 'https://prod.rewardsplatform.microsoft.com/dapi/me/activities',
+                    method: 'POST',
+                    headers: {
+                        Authorization: `Bearer ${this.bot.accessToken}`,
+                        'User-Agent':
+                            'Bing/32.5.431027001 (com.microsoft.bing; build:431027001; iOS 17.6.1) Alamofire/5.10.2',
+                        'Content-Type': 'application/json',
+                        'X-Rewards-Country': this.bot.userData.geoLocale,
+                        'X-Rewards-Language': 'en',
+                        'X-Rewards-ismobile': 'true'
+                    },
+                    data: JSON.stringify(jsonData)
+                }
+
+                const response = await this.bot.axios.request(request)
+
+                this.bot.logger.debug(
+                    this.bot.isMobile,
+                    'READ-TO-EARN',
+                    `Received Read to Earn response | article=${i + 1}/${articleCount} | status=${response?.status ?? 'unknown'}`
+                )
+
+                const newBalance = Number(response?.data?.response?.balance ?? oldBalance)
+                const gainedPoints = newBalance - oldBalance
+
+                this.bot.logger.debug(
+                    this.bot.isMobile,
+                    'READ-TO-EARN',
+                    `Balance delta after article | article=${i + 1}/${articleCount} | oldBalance=${oldBalance} | newBalance=${newBalance} | gainedPoints=${gainedPoints}`
+                )
+
+                if (gainedPoints <= 0) {
+                    this.bot.logger.info(
+                        this.bot.isMobile,
+                        'READ-TO-EARN',
+                        `No points gained, stopping Read to Earn | article=${i + 1}/${articleCount} | status=${response.status} | oldBalance=${oldBalance} | newBalance=${newBalance}`
+                    )
+                    break
+                }
+
+                // Update point tracking
+                this.bot.userData.currentPoints = newBalance
+                this.bot.userData.gainedPoints = (this.bot.userData.gainedPoints ?? 0) + gainedPoints
+                totalGained += gainedPoints
+                articlesRead = i + 1
+                oldBalance = newBalance
+
+                this.bot.logger.info(
+                    this.bot.isMobile,
+                    'READ-TO-EARN',
+                    `Read article ${i + 1}/${articleCount} | status=${response.status} | gainedPoints=${gainedPoints} | newBalance=${newBalance}`,
+                    'green'
+                )
+
+                // Wait random delay between articles
+                this.bot.logger.debug(
+                    this.bot.isMobile,
+                    'READ-TO-EARN',
+                    `Waiting between articles | article=${i + 1}/${articleCount} | delayRange=${delayMin}-${delayMax}`
+                )
+
+                await this.bot.utils.wait(this.bot.utils.randomDelay(delayMin, delayMax))
+            }
+
+            const finalBalance = Number(this.bot.userData.currentPoints ?? startBalance)
+
+            this.bot.logger.info(
+                this.bot.isMobile,
+                'READ-TO-EARN',
+                `Completed Read to Earn | articlesRead=${articlesRead} | totalGained=${totalGained} | startBalance=${startBalance} | finalBalance=${finalBalance}`
+            )
+        } catch (error) {
+            this.bot.logger.error(
+                this.bot.isMobile,
+                'READ-TO-EARN',
+                `Error during Read to Earn | message=${error instanceof Error ? error.message : String(error)}`
+            )
+        }
+    }
+}

src/functions/activities/browser/Search.ts

@@ -0,0 +1,426 @@
+import type { Page } from 'patchright'
+import type { Counters, DashboardData } from '../../../interface/DashboardData'
+
+import { QueryCore } from '../../QueryEngine'
+import { Workers } from '../../Workers'
+
+export class Search extends Workers {
+    private bingHome = 'https://bing.com'
+    private searchPageURL = ''
+    private searchCount = 0
+
+    public async doSearch(data: DashboardData, page: Page, isMobile: boolean): Promise<number> {
+        const startBalance = Number(this.bot.userData.currentPoints ?? 0)
+
+        this.bot.logger.info(isMobile, 'SEARCH-BING', `Starting Bing searches | currentPoints=${startBalance}`)
+
+        let totalGainedPoints = 0
+
+        try {
+            let searchCounters: Counters = await this.bot.browser.func.getSearchPoints()
+            const missingPoints = this.bot.browser.func.missingSearchPoints(searchCounters, isMobile)
+            let missingPointsTotal = missingPoints.totalPoints
+
+            this.bot.logger.debug(
+                isMobile,
+                'SEARCH-BING',
+                `Initial search counters | mobile=${missingPoints.mobilePoints} | desktop=${missingPoints.desktopPoints} | edge=${missingPoints.edgePoints}`
+            )
+
+            this.bot.logger.info(
+                isMobile,
+                'SEARCH-BING',
+                `Search points remaining | Edge=${missingPoints.edgePoints} | Desktop=${missingPoints.desktopPoints} | Mobile=${missingPoints.mobilePoints}`
+            )
+
+            let queries: string[] = []
+
+            const queryCore = new QueryCore(this.bot)
+
+            const locale = this.bot.userData.geoLocale.toUpperCase()
+
+            this.bot.logger.debug(isMobile, 'SEARCH-BING', `Resolving search queries | locale=${locale}`)
+
+            // Set Google search queries
+            queries = await queryCore.getGoogleTrends(locale)
+
+            this.bot.logger.debug(isMobile, 'SEARCH-BING', `Fetched base queries | count=${queries.length}`)
+
+            // Deduplicate queries
+            queries = [...new Set(queries)]
+
+            this.bot.logger.debug(isMobile, 'SEARCH-BING', `Deduplicated queries | count=${queries.length}`)
+
+            // Shuffle
+            queries = this.bot.utils.shuffleArray(queries)
+
+            this.bot.logger.debug(isMobile, 'SEARCH-BING', `Shuffled queries | count=${queries.length}`)
+
+            // Go to bing
+            const targetUrl = this.searchPageURL ? this.searchPageURL : this.bingHome
+            this.bot.logger.debug(isMobile, 'SEARCH-BING', `Navigating to search page | url=${targetUrl}`)
+
+            await page.goto(targetUrl)
+
+            // Wait until page loaded
+            await page.waitForLoadState('networkidle', { timeout: 10000 }).catch(() => {})
+
+            await this.bot.browser.utils.tryDismissAllMessages(page)
+
+            let stagnantLoop = 0
+            const stagnantLoopMax = 10
+
+            for (let i = 0; i < queries.length; i++) {
+                const query = queries[i] as string
+
+                searchCounters = await this.bingSearch(page, query, isMobile)
+                const newMissingPoints = this.bot.browser.func.missingSearchPoints(searchCounters, isMobile)
+                const newMissingPointsTotal = newMissingPoints.totalPoints
+
+                // Points gained for THIS query only
+                const rawGained = missingPointsTotal - newMissingPointsTotal
+                const gainedPoints = Math.max(0, rawGained)
+
+                if (gainedPoints === 0) {
+                    stagnantLoop++
+                    this.bot.logger.info(
+                        isMobile,
+                        'SEARCH-BING',
+                        `No points gained ${stagnantLoop}/${stagnantLoopMax} | query="${query}" | remaining=${newMissingPointsTotal}`
+                    )
+                } else {
+                    stagnantLoop = 0
+
+                    // Update global user data
+                    const newBalance = Number(this.bot.userData.currentPoints ?? 0) + gainedPoints
+                    this.bot.userData.currentPoints = newBalance
+                    this.bot.userData.gainedPoints = (this.bot.userData.gainedPoints ?? 0) + gainedPoints
+
+                    // Track for return value
+                    totalGainedPoints += gainedPoints
+
+                    this.bot.logger.info(
+                        isMobile,
+                        'SEARCH-BING',
+                        `gainedPoints=${gainedPoints} points | query="${query}" | remaining=${newMissingPointsTotal}`,
+                        'green'
+                    )
+                }
+
+                // Update loop state
+                missingPointsTotal = newMissingPointsTotal
+
+                // Completed
+                if (missingPointsTotal === 0) {
+                    this.bot.logger.info(
+                        isMobile,
+                        'SEARCH-BING',
+                        'All required search points earned, stopping main search loop'
+                    )
+                    break
+                }
+
+                // Stuck
+                if (stagnantLoop > stagnantLoopMax) {
+                    this.bot.logger.warn(
+                        isMobile,
+                        'SEARCH-BING',
+                        `Search did not gain points for ${stagnantLoopMax} iterations, aborting main search loop`
+                    )
+                    stagnantLoop = 0
+                    break
+                }
+            }
+
+            if (missingPointsTotal > 0) {
+                this.bot.logger.info(
+                    isMobile,
+                    'SEARCH-BING',
+                    `Search completed but still missing points, generating extra searches | remaining=${missingPointsTotal}`
+                )
+
+                let i = 0
+                let stagnantLoop = 0
+                const stagnantLoopMax = 5
+
+                while (missingPointsTotal > 0) {
+                    const query = queries[i++] as string
+
+                    this.bot.logger.debug(
+                        isMobile,
+                        'SEARCH-BING-EXTRA',
+                        `Fetching related terms for extra searches | baseQuery="${query}"`
+                    )
+
+                    const relatedTerms = await queryCore.getBingRelatedTerms(query)
+                    this.bot.logger.debug(
+                        isMobile,
+                        'SEARCH-BING-EXTRA',
+                        `Related terms resolved | baseQuery="${query}" | count=${relatedTerms.length}`
+                    )
+
+                    if (relatedTerms.length > 3) {
+                        for (const term of relatedTerms.slice(1, 3)) {
+                            this.bot.logger.info(
+                                isMobile,
+                                'SEARCH-BING-EXTRA',
+                                `Extra search | remaining=${missingPointsTotal} | query="${term}"`
+                            )
+
+                            searchCounters = await this.bingSearch(page, term, isMobile)
+                            const newMissingPoints = this.bot.browser.func.missingSearchPoints(searchCounters, isMobile)
+                            const newMissingPointsTotal = newMissingPoints.totalPoints
+
+                            // Points gained for THIS extra query only
+                            const rawGained = missingPointsTotal - newMissingPointsTotal
+                            const gainedPoints = Math.max(0, rawGained)
+
+                            if (gainedPoints === 0) {
+                                stagnantLoop++
+                                this.bot.logger.info(
+                                    isMobile,
+                                    'SEARCH-BING-EXTRA',
+                                    `No points gained for extra query ${stagnantLoop}/${stagnantLoopMax} | query="${term}" | remaining=${newMissingPointsTotal}`
+                                )
+                            } else {
+                                stagnantLoop = 0
+
+                                // Update global user data
+                                const newBalance = Number(this.bot.userData.currentPoints ?? 0) + gainedPoints
+                                this.bot.userData.currentPoints = newBalance
+                                this.bot.userData.gainedPoints = (this.bot.userData.gainedPoints ?? 0) + gainedPoints
+
+                                // Track for return value
+                                totalGainedPoints += gainedPoints
+
+                                this.bot.logger.info(
+                                    isMobile,
+                                    'SEARCH-BING-EXTRA',
+                                    `gainedPoints=${gainedPoints} points | query="${term}" | remaining=${newMissingPointsTotal}`,
+                                    'green'
+                                )
+                            }
+
+                            // Update loop state
+                            missingPointsTotal = newMissingPointsTotal
+
+                            // Completed
+                            if (missingPointsTotal === 0) {
+                                this.bot.logger.info(
+                                    isMobile,
+                                    'SEARCH-BING-EXTRA',
+                                    'All required search points earned during extra searches'
+                                )
+                                break
+                            }
+
+                            // Stuck again
+                            if (stagnantLoop > stagnantLoopMax) {
+                                this.bot.logger.warn(
+                                    isMobile,
+                                    'SEARCH-BING-EXTRA',
+                                    `Search did not gain points for ${stagnantLoopMax} extra iterations, aborting extra searches`
+                                )
+                                const finalBalance = Number(this.bot.userData.currentPoints ?? startBalance)
+                                this.bot.logger.info(
+                                    isMobile,
+                                    'SEARCH-BING',
+                                    `Aborted extra searches | startBalance=${startBalance} | finalBalance=${finalBalance}`
+                                )
+                                return totalGainedPoints
+                            }
+                        }
+                    }
+                }
+            }
+
+            const finalBalance = Number(this.bot.userData.currentPoints ?? startBalance)
+
+            this.bot.logger.info(
+                isMobile,
+                'SEARCH-BING',
+                `Completed Bing searches | startBalance=${startBalance} | newBalance=${finalBalance}`
+            )
+
+            return totalGainedPoints
+        } catch (error) {
+            this.bot.logger.error(
+                isMobile,
+                'SEARCH-BING',
+                `Error in doSearch | message=${error instanceof Error ? error.message : String(error)}`
+            )
+            return totalGainedPoints
+        }
+    }
+
+    private async bingSearch(searchPage: Page, query: string, isMobile: boolean) {
+        const maxAttempts = 5
+        const refreshThreshold = 10 // Page gets sluggish after x searches?
+
+        this.searchCount++
+
+        // Page fill seems to get more sluggish over time
+        if (this.searchCount % refreshThreshold === 0) {
+            this.bot.logger.info(
+                isMobile,
+                'SEARCH-BING',
+                `Returning to home page to clear accumulated page context | count=${this.searchCount} | threshold=${refreshThreshold}`
+            )
+
+            this.bot.logger.debug(isMobile, 'SEARCH-BING', `Returning home to refresh state | url=${this.bingHome}`)
+
+            await searchPage.goto(this.bingHome)
+            await searchPage.waitForLoadState('networkidle', { timeout: 10000 }).catch(() => {})
+            await this.bot.browser.utils.tryDismissAllMessages(searchPage) // Not always the case but possible for new cookie headers
+        }
+
+        this.bot.logger.debug(
+            isMobile,
+            'SEARCH-BING',
+            `Starting bingSearch | query="${query}" | maxAttempts=${maxAttempts} | searchCount=${this.searchCount} | refreshEvery=${refreshThreshold} | scrollRandomResults=${this.bot.config.searchSettings.scrollRandomResults} | clickRandomResults=${this.bot.config.searchSettings.clickRandomResults}`
+        )
+
+        for (let i = 0; i < maxAttempts; i++) {
+            try {
+                const searchBar = '#sb_form_q'
+                const searchBox = searchPage.locator(searchBar)
+
+                await searchPage.evaluate(() => {
+                    window.scrollTo({ left: 0, top: 0, behavior: 'auto' })
+                })
+
+                await searchPage.keyboard.press('Home')
+                await searchBox.waitFor({ state: 'visible', timeout: 15000 })
+
+                await this.bot.utils.wait(1000)
+                await this.bot.browser.utils.ghostClick(searchPage, searchBar, { clickCount: 3 })
+                await searchBox.fill('')
+
+                await searchPage.keyboard.type(query, { delay: 50 })
+                await searchPage.keyboard.press('Enter')
+
+                this.bot.logger.debug(
+                    isMobile,
+                    'SEARCH-BING',
+                    `Submitted query to Bing | attempt=${i + 1}/${maxAttempts} | query="${query}"`
+                )
+
+                await this.bot.utils.wait(3000)
+
+                if (this.bot.config.searchSettings.scrollRandomResults) {
+                    await this.bot.utils.wait(2000)
+                    await this.randomScroll(searchPage, isMobile)
+                }
+
+                if (this.bot.config.searchSettings.clickRandomResults) {
+                    await this.bot.utils.wait(2000)
+                    await this.clickRandomLink(searchPage, isMobile)
+                }
+
+                await this.bot.utils.wait(
+                    this.bot.utils.randomDelay(
+                        this.bot.config.searchSettings.searchDelay.min,
+                        this.bot.config.searchSettings.searchDelay.max
+                    )
+                )
+
+                const counters = await this.bot.browser.func.getSearchPoints()
+
+                this.bot.logger.debug(
+                    isMobile,
+                    'SEARCH-BING',
+                    `Search counters after query | attempt=${i + 1}/${maxAttempts} | query="${query}"`
+                )
+
+                return counters
+            } catch (error) {
+                if (i >= 5) {
+                    this.bot.logger.error(
+                        isMobile,
+                        'SEARCH-BING',
+                        `Failed after 5 retries | query="${query}" | message=${error instanceof Error ? error.message : String(error)}`
+                    )
+                    break
+                }
+
+                this.bot.logger.error(
+                    isMobile,
+                    'SEARCH-BING',
+                    `Search attempt failed | attempt=${i + 1}/${maxAttempts} | query="${query}" | message=${error instanceof Error ? error.message : String(error)}`
+                )
+
+                this.bot.logger.warn(
+                    isMobile,
+                    'SEARCH-BING',
+                    `Retrying search | attempt=${i + 1}/${maxAttempts} | query="${query}"`
+                )
+
+                await this.bot.utils.wait(2000)
+            }
+        }
+
+        this.bot.logger.debug(
+            isMobile,
+            'SEARCH-BING',
+            `Returning current search counters after failed retries | query="${query}"`
+        )
+
+        return await this.bot.browser.func.getSearchPoints()
+    }
+
+    private async randomScroll(page: Page, isMobile: boolean) {
+        try {
+            const viewportHeight = await page.evaluate(() => window.innerHeight)
+            const totalHeight = await page.evaluate(() => document.body.scrollHeight)
+            const randomScrollPosition = Math.floor(Math.random() * (totalHeight - viewportHeight))
+
+            this.bot.logger.debug(
+                isMobile,
+                'SEARCH-RANDOM-SCROLL',
+                `Random scroll | viewportHeight=${viewportHeight} | totalHeight=${totalHeight} | scrollPos=${randomScrollPosition}`
+            )
+
+            await page.evaluate((scrollPos: number) => {
+                window.scrollTo({ left: 0, top: scrollPos, behavior: 'auto' })
+            }, randomScrollPosition)
+        } catch (error) {
+            this.bot.logger.error(
+                isMobile,
+                'SEARCH-RANDOM-SCROLL',
+                `An error occurred during random scroll | message=${error instanceof Error ? error.message : String(error)}`
+            )
+        }
+    }
+
+    private async clickRandomLink(page: Page, isMobile: boolean) {
+        try {
+            this.bot.logger.debug(isMobile, 'SEARCH-RANDOM-CLICK', 'Attempting to click a random search result link')
+
+            const searchPageUrl = page.url()
+
+            await this.bot.browser.utils.ghostClick(page, '#b_results .b_algo h2')
+            await this.bot.utils.wait(this.bot.config.searchSettings.searchResultVisitTime)
+
+            if (isMobile) {
+                // Mobile
+                await page.goto(searchPageUrl)
+                this.bot.logger.debug(isMobile, 'SEARCH-RANDOM-CLICK', 'Navigated back to search page')
+            } else {
+                // Desktop
+                const newTab = await this.bot.browser.utils.getLatestTab(page)
+                const newTabUrl = newTab.url()
+
+                this.bot.logger.debug(isMobile, 'SEARCH-RANDOM-CLICK', `Visited result tab | url=${newTabUrl}`)
+
+                await this.bot.browser.utils.closeTabs(newTab)
+                this.bot.logger.debug(isMobile, 'SEARCH-RANDOM-CLICK', 'Closed result tab')
+            }
+        } catch (error) {
+            this.bot.logger.error(
+                isMobile,
+                'SEARCH-RANDOM-CLICK',
+                `An error occurred during random click | message=${error instanceof Error ? error.message : String(error)}`
+            )
+        }
+    }
+}

src/functions/activities/browser/SearchOnBing.ts

@@ -0,0 +1,330 @@
+import type { AxiosRequestConfig } from 'axios'
+import type { Page } from 'patchright'
+import * as fs from 'fs'
+import path from 'path'
+
+import { Workers } from '../../Workers'
+import { QueryCore } from '../../QueryEngine'
+
+import type { BasePromotion } from '../../../interface/DashboardData'
+
+export class SearchOnBing extends Workers {
+    private bingHome = 'https://bing.com'
+
+    private cookieHeader: string = ''
+
+    private fingerprintHeader: { [x: string]: string } = {}
+
+    private gainedPoints: number = 0
+
+    private success: boolean = false
+
+    private oldBalance: number = this.bot.userData.currentPoints
+
+    public async doSearchOnBing(promotion: BasePromotion, page: Page) {
+        const offerId = promotion.offerId
+        this.oldBalance = Number(this.bot.userData.currentPoints ?? 0)
+
+        this.bot.logger.info(
+            this.bot.isMobile,
+            'SEARCH-ON-BING',
+            `Starting SearchOnBing | offerId=${offerId} | title="${promotion.title}" | currentPoints=${this.oldBalance}`
+        )
+
+        try {
+            this.cookieHeader = (this.bot.isMobile ? this.bot.cookies.mobile : this.bot.cookies.desktop)
+                .map((c: { name: string; value: string }) => `${c.name}=${c.value}`)
+                .join('; ')
+
+            const fingerprintHeaders = { ...this.bot.fingerprint.headers }
+            delete fingerprintHeaders['Cookie']
+            delete fingerprintHeaders['cookie']
+            this.fingerprintHeader = fingerprintHeaders
+
+            this.bot.logger.debug(
+                this.bot.isMobile,
+                'SEARCH-ON-BING',
+                `Prepared headers for SearchOnBing | offerId=${offerId} | cookieLength=${this.cookieHeader.length} | fingerprintHeaderKeys=${Object.keys(this.fingerprintHeader).length}`
+            )
+
+            this.bot.logger.debug(this.bot.isMobile, 'SEARCH-ON-BING', `Activating search task | offerId=${offerId}`)
+
+            const activated = await this.activateSearchTask(promotion)
+            if (!activated) {
+                this.bot.logger.warn(
+                    this.bot.isMobile,
+                    'SEARCH-ON-BING',
+                    `Search activity couldn't be activated, aborting | offerId=${offerId}`
+                )
+                return
+            }
+
+            // Do the bing search here
+            const queries = await this.getSearchQueries(promotion)
+
+            // Run through the queries
+            await this.searchBing(page, queries)
+
+            if (this.success) {
+                this.bot.logger.info(
+                    this.bot.isMobile,
+                    'SEARCH-ON-BING',
+                    `Completed SearchOnBing | offerId=${offerId} | startBalance=${this.oldBalance} | finalBalance=${this.bot.userData.currentPoints}`
+                )
+            } else {
+                this.bot.logger.warn(
+                    this.bot.isMobile,
+                    'SEARCH-ON-BING',
+                    `Failed SearchOnBing | offerId=${offerId} | startBalance=${this.oldBalance} | finalBalance=${this.bot.userData.currentPoints}`
+                )
+            }
+        } catch (error) {
+            this.bot.logger.error(
+                this.bot.isMobile,
+                'SEARCH-ON-BING',
+                `Error in doSearchOnBing | offerId=${promotion.offerId} | message=${error instanceof Error ? error.message : String(error)}`
+            )
+        }
+    }
+
+    private async searchBing(page: Page, queries: string[]) {
+        queries = [...new Set(queries)]
+
+        this.bot.logger.debug(
+            this.bot.isMobile,
+            'SEARCH-ON-BING-SEARCH',
+            `Starting search loop | queriesCount=${queries.length} | oldBalance=${this.oldBalance}`
+        )
+
+        let i = 0
+        for (const query of queries) {
+            try {
+                this.bot.logger.debug(this.bot.isMobile, 'SEARCH-ON-BING-SEARCH', `Processing query | query="${query}"`)
+
+                await this.bot.mainMobilePage.goto(this.bingHome)
+
+                // Wait until page loaded
+                await page.waitForLoadState('networkidle', { timeout: 10000 }).catch(() => {})
+
+                await this.bot.browser.utils.tryDismissAllMessages(page)
+
+                const searchBar = '#sb_form_q'
+
+                const searchBox = page.locator(searchBar)
+                await searchBox.waitFor({ state: 'attached', timeout: 15000 })
+
+                await this.bot.utils.wait(500)
+                await this.bot.browser.utils.ghostClick(page, searchBar, { clickCount: 3 })
+                await searchBox.fill('')
+
+                await page.keyboard.type(query, { delay: 50 })
+                await page.keyboard.press('Enter')
+
+                await this.bot.utils.wait(this.bot.utils.randomDelay(5000, 7000))
+
+                // Check for point updates
+                const newBalance = await this.bot.browser.func.getCurrentPoints()
+                this.gainedPoints = newBalance - this.oldBalance
+
+                this.bot.logger.debug(
+                    this.bot.isMobile,
+                    'SEARCH-ON-BING-SEARCH',
+                    `Balance check after query | query="${query}" | oldBalance=${this.oldBalance} | newBalance=${newBalance} | gainedPoints=${this.gainedPoints}`
+                )
+
+                if (this.gainedPoints > 0) {
+                    this.bot.userData.currentPoints = newBalance
+                    this.bot.userData.gainedPoints = (this.bot.userData.gainedPoints ?? 0) + this.gainedPoints
+
+                    this.bot.logger.info(
+                        this.bot.isMobile,
+                        'SEARCH-ON-BING-SEARCH',
+                        `SearchOnBing query completed | query="${query}" | gainedPoints=${this.gainedPoints} | oldBalance=${this.oldBalance} | newBalance=${newBalance}`,
+                        'green'
+                    )
+
+                    this.success = true
+                    return
+                } else {
+                    this.bot.logger.warn(
+                        this.bot.isMobile,
+                        'SEARCH-ON-BING-SEARCH',
+                        `${++i}/${queries.length} | noPoints=1 | query="${query}"`
+                    )
+                }
+            } catch (error) {
+                this.bot.logger.error(
+                    this.bot.isMobile,
+                    'SEARCH-ON-BING-SEARCH',
+                    `Error during search loop | query="${query}" | message=${error instanceof Error ? error.message : String(error)}`
+                )
+            } finally {
+                await this.bot.utils.wait(this.bot.utils.randomDelay(5000, 15000))
+                await page.goto(this.bot.config.baseURL, { timeout: 5000 }).catch(() => {})
+            }
+        }
+
+        this.bot.logger.warn(
+            this.bot.isMobile,
+            'SEARCH-ON-BING-SEARCH',
+            `Finished all queries with no points gained | queriesTried=${queries.length} | oldBalance=${this.oldBalance} | finalBalance=${this.bot.userData.currentPoints}`
+        )
+    }
+
+    // The task needs to be activated before being able to complete it
+    private async activateSearchTask(promotion: BasePromotion): Promise<boolean> {
+        try {
+            this.bot.logger.debug(
+                this.bot.isMobile,
+                'SEARCH-ON-BING-ACTIVATE',
+                `Preparing activation request | offerId=${promotion.offerId} | hash=${promotion.hash}`
+            )
+
+            const formData = new URLSearchParams({
+                id: promotion.offerId,
+                hash: promotion.hash,
+                timeZone: '60',
+                activityAmount: '1',
+                dbs: '0',
+                form: '',
+                type: '',
+                __RequestVerificationToken: this.bot.requestToken
+            })
+
+            const request: AxiosRequestConfig = {
+                url: 'https://rewards.bing.com/api/reportactivity?X-Requested-With=XMLHttpRequest',
+                method: 'POST',
+                headers: {
+                    ...(this.bot.fingerprint?.headers ?? {}),
+                    Cookie: this.cookieHeader,
+                    Referer: 'https://rewards.bing.com/',
+                    Origin: 'https://rewards.bing.com'
+                },
+                data: formData
+            }
+
+            const response = await this.bot.axios.request(request)
+            this.bot.logger.info(
+                this.bot.isMobile,
+                'SEARCH-ON-BING-ACTIVATE',
+                `Successfully activated activity | status=${response.status} | offerId=${promotion.offerId}`
+            )
+            return true
+        } catch (error) {
+            this.bot.logger.error(
+                this.bot.isMobile,
+                'SEARCH-ON-BING-ACTIVATE',
+                `Activation failed | offerId=${promotion.offerId} | message=${error instanceof Error ? error.message : String(error)}`
+            )
+            return false
+        }
+    }
+
+    private async getSearchQueries(promotion: BasePromotion): Promise<string[]> {
+        interface Queries {
+            title: string
+            queries: string[]
+        }
+
+        let queries: Queries[] = []
+
+        try {
+            if (this.bot.config.searchOnBingLocalQueries) {
+                this.bot.logger.debug(this.bot.isMobile, 'SEARCH-ON-BING-QUERY', 'Using local queries config file')
+
+                const data = fs.readFileSync(path.join(__dirname, '../queries.json'), 'utf8')
+                queries = JSON.parse(data)
+
+                this.bot.logger.debug(
+                    this.bot.isMobile,
+                    'SEARCH-ON-BING-QUERY',
+                    `Loaded queries config | source=local | entries=${queries.length}`
+                )
+            } else {
+                this.bot.logger.debug(
+                    this.bot.isMobile,
+                    'SEARCH-ON-BING-QUERY',
+                    'Fetching queries config from remote repository'
+                )
+
+                // Fetch from the repo directly so the user doesn't need to redownload the script for the new activities
+                const response = await this.bot.axios.request({
+                    method: 'GET',
+                    url: 'https://raw.githubusercontent.com/TheNetsky/Microsoft-Rewards-Script/refs/heads/v3/src/functions/queries.json'
+                })
+                queries = response.data
+
+                this.bot.logger.debug(
+                    this.bot.isMobile,
+                    'SEARCH-ON-BING-QUERY',
+                    `Loaded queries config | source=remote | entries=${queries.length}`
+                )
+            }
+
+            const answers = queries.find(
+                x => this.bot.utils.normalizeString(x.title) === this.bot.utils.normalizeString(promotion.title)
+            )
+
+            if (answers && answers.queries.length > 0) {
+                const answer = this.bot.utils.shuffleArray(answers.queries)
+
+                this.bot.logger.info(
+                    this.bot.isMobile,
+                    'SEARCH-ON-BING-QUERY',
+                    `Found answers for activity title | source=${this.bot.config.searchOnBingLocalQueries ? 'local' : 'remote'} | title="${promotion.title}" | answersCount=${answer.length} | firstQuery="${answer[0]}"`
+                )
+
+                return answer
+            } else {
+                this.bot.logger.info(
+                    this.bot.isMobile,
+                    'SEARCH-ON-BING-QUERY',
+                    `No matching title in queries config | source=${this.bot.config.searchOnBingLocalQueries ? 'local' : 'remote'} | title="${promotion.title}"`
+                )
+
+                const queryCore = new QueryCore(this.bot)
+
+                const promotionDescription = promotion.description.toLowerCase().trim()
+                const queryDescription = promotionDescription.replace('search on bing', '').trim()
+
+                this.bot.logger.debug(
+                    this.bot.isMobile,
+                    'SEARCH-ON-BING-QUERY',
+                    `Requesting Bing suggestions | queryDescription="${queryDescription}"`
+                )
+
+                const bingSuggestions = await queryCore.getBingSuggestions(queryDescription)
+
+                this.bot.logger.debug(
+                    this.bot.isMobile,
+                    'SEARCH-ON-BING-QUERY',
+                    `Bing suggestions result | count=${bingSuggestions.length} | title="${promotion.title}"`
+                )
+
+                // If no suggestions found
+                if (!bingSuggestions.length) {
+                    this.bot.logger.info(
+                        this.bot.isMobile,
+                        'SEARCH-ON-BING-QUERY',
+                        `No suggestions found, falling back to activity title | title="${promotion.title}"`
+                    )
+                    return [promotion.title]
+                } else {
+                    this.bot.logger.info(
+                        this.bot.isMobile,
+                        'SEARCH-ON-BING-QUERY',
+                        `Using Bing suggestions as search queries | count=${bingSuggestions.length} | title="${promotion.title}"`
+                    )
+                    return bingSuggestions
+                }
+            }
+        } catch (error) {
+            this.bot.logger.error(
+                this.bot.isMobile,
+                'SEARCH-ON-BING-QUERY',
+                `Error while resolving search queries | title="${promotion.title}" | message=${error instanceof Error ? error.message : String(error)} | fallback=promotionTitle`
+            )
+            return [promotion.title]
+        }
+    }
+}

src/functions/queries.json

@@ -1,289 +0,0 @@
-[
-    {
-        "title": "Houses near you",
-        "queries": [
-            "Houses near me"
-        ]
-    },
-    {
-        "title": "Feeling symptoms?",
-        "queries": [
-            "Rash on forearm",
-            "Stuffy nose",
-            "Tickling cough"
-        ]
-    },
-    {
-        "title": "Get your shopping done faster",
-        "queries": [
-            "Buy PS5",
-            "Buy Xbox",
-            "Chair deals"
-        ]
-    },
-    {
-        "title": "Translate anything",
-        "queries": [
-            "Translate welcome home to Korean",
-            "Translate welcome home to Japanese",
-            "Translate goodbye to Japanese"
-        ]
-    },
-    {
-        "title": "Search the lyrics of a song",
-        "queries": [
-            "Debarge rhythm of the night lyrics"
-        ]
-    },
-    {
-        "title": "Let's watch that movie again!",
-        "queries": [
-            "Alien movie",
-            "Aliens movie",
-            "Alien 3 movie",
-            "Predator movie"
-        ]
-    },
-    {
-        "title": "Plan a quick getaway",
-        "queries": [
-            "Flights Amsterdam to Tokyo",
-            "Flights New York to Tokyo"
-        ]
-    },
-    {
-        "title": "Discover open job roles",
-        "queries": [
-            "jobs at Microsoft",
-            "Microsoft Job Openings",
-            "Jobs near me",
-            "jobs at Boeing worked"
-        ]
-    },
-    {
-        "title": "You can track your package",
-        "queries": [
-            "USPS tracking"
-        ]
-    },
-    {
-        "title": "Find somewhere new to explore",
-        "queries": [
-            "Directions to Berlin",
-            "Directions to Tokyo",
-            "Directions to New York"
-        ]
-    },
-    {
-        "title": "Too tired to cook tonight?",
-        "queries": [
-            "KFC near me",
-            "Burger King near me",
-            "McDonalds near me"
-        ]
-    },
-    {
-        "title": "Quickly convert your money",
-        "queries": [
-            "convert 250 USD to yen",
-            "convert 500 USD to yen"
-        ]
-    },
-    {
-        "title": "Learn to cook a new recipe",
-        "queries": [
-            "How to cook ratatouille",
-            "How to cook lasagna"
-        ]
-    },
-    {
-        "title": "Find places to stay!",
-        "queries": [
-            "Hotels Berlin Germany",
-            "Hotels Amsterdam Netherlands"
-        ]
-    },
-    {
-        "title": "How's the economy?",
-        "queries": [
-            "sp 500"
-        ]
-    },
-    {
-        "title": "Who won?",
-        "queries": [
-            "braves score"
-        ]
-    },
-    {
-        "title": "Gaming time",
-        "queries": [
-            "Overwatch video game",
-            "Call of duty video game"
-        ]
-    },
-    {
-        "title": "Expand your vocabulary",
-        "queries": [
-            "definition definition"
-        ]
-    },
-    {
-        "title": "What time is it?",
-        "queries": [
-            "Japan time",
-            "New York time"
-        ]
-    },
-
-    {
-        "title": "Maisons près de chez vous",
-        "queries": [
-            "Maisons près de chez moi"
-        ]
-    },
-    {
-        "title": "Vous ressentez des symptômes ?",
-        "queries": [
-            "Éruption cutanée sur l'avant-bras",
-            "Nez bouché",
-            "Toux chatouilleuse"
-        ]
-    },
-    {
-        "title": "Faites vos achats plus vite",
-        "queries": [
-            "Acheter une PS5",
-            "Acheter une Xbox",
-            "Offres sur les chaises"
-        ]
-    },
-    {
-        "title": "Traduisez tout !",
-        "queries": [
-            "Traduction bienvenue à la maison en coréen",
-            "Traduction bienvenue à la maison en japonais",
-            "Traduction au revoir en japonais"
-        ]
-    },
-    {
-        "title": "Rechercher paroles de chanson",
-        "queries": [
-            "Paroles de Debarge rhythm of the night"
-        ]
-    },
-    {
-        "title": "Et si nous regardions ce film une nouvelle fois?",
-        "queries": [
-            "Alien film",
-            "Film Aliens",
-            "Film Alien 3",
-            "Film Predator"
-        ]
-    },
-    {
-        "title": "Planifiez une petite escapade",
-        "queries": [
-            "Vols Amsterdam-Tokyo",
-            "Vols New York-Tokyo"
-        ]
-    },
-    {
-        "title": "Consulter postes à pourvoir",
-        "queries": [
-            "emplois chez Microsoft",
-            "Offres d'emploi Microsoft",
-            "Emplois près de chez moi",
-            "emplois chez Boeing"
-        ]
-    },
-    {
-        "title": "Vous pouvez suivre votre colis",
-        "queries": [
-            "Suivi Chronopost"
-        ]
-    },
-    {
-        "title": "Trouver un endroit à découvrir",
-        "queries": [
-            "Itinéraire vers Berlin",
-            "Itinéraire vers Tokyo",
-            "Itinéraire vers New York"
-        ]
-    },
-    {
-        "title": "Trop fatigué pour cuisiner ce soir ?",
-        "queries": [
-            "KFC près de chez moi",
-            "Burger King près de chez moi",
-            "McDonalds près de chez moi"
-        ]
-    },
-    {
-        "title": "Convertissez rapidement votre argent",
-        "queries": [
-            "convertir 250 EUR en yen",
-            "convertir 500 EUR en yen"
-        ]
-    },
-    {
-        "title": "Apprenez à cuisiner une nouvelle recette",
-        "queries": [
-            "Comment faire cuire la ratatouille",
-            "Comment faire cuire les lasagnes"
-        ]
-    },
-    {
-        "title": "Trouvez des emplacements pour rester!",
-        "queries": [
-            "Hôtels Berlin Allemagne",
-            "Hôtels Amsterdam Pays-Bas"
-        ]
-    },
-    {
-        "title": "Comment se porte l'économie ?",
-        "queries": [
-            "CAC 40"
-        ]
-    },
-    {
-        "title": "Qui a gagné ?",
-        "queries": [
-            "score du Paris Saint-Germain"
-        ]
-    },
-    {
-        "title": "Temps de jeu",
-        "queries": [
-            "Jeu vidéo Overwatch",
-            "Jeu vidéo Call of Duty"
-        ]
-    },
-    {
-        "title": "Enrichissez votre vocabulaire",
-        "queries": [
-            "definition definition"
-        ]
-    },
-    {
-        "title": "Quelle heure est-il ?",
-        "queries": [
-            "Heure du Japon",
-            "Heure de New York"
-        ]
-    },
-    {
-        "title": "Vérifier la météo",
-        "queries": [
-            "Météo de Paris",
-            "Météo de la France"
-        ]
-    },
-    {
-        "title": "Tenez-vous informé des sujets d'actualité",
-        "queries": [
-            "Augmentation Impots",
-            "Mort célébrité"
-        ]
-    }
-]

src/index.ts

@@ -1,548 +1,494 @@
-import cluster from 'cluster'
-// Use Page type from playwright for typings; at runtime rebrowser-playwright extends playwright
-import type { Page } from 'playwright'
+import { AsyncLocalStorage } from 'node:async_hooks'
+import cluster, { Worker } from 'cluster'
+import type { BrowserContext, Cookie, Page } from 'patchright'
+import pkg from '../package.json'
+
+import type { BrowserFingerprintWithHeaders } from 'fingerprint-generator'
 
 import Browser from './browser/Browser'
 import BrowserFunc from './browser/BrowserFunc'
-import BrowserUtil from './browser/BrowserUtil'
+import BrowserUtils from './browser/BrowserUtils'
 
-import { log } from './util/Logger'
-import Util from './util/Utils'
-import { loadAccounts, loadConfig, saveSessionData } from './util/Load'
+import { IpcLog, Logger } from './logging/Logger'
+import Utils from './util/Utils'
+import { loadAccounts, loadConfig } from './util/Load'
 
-import { Login } from './functions/Login'
+import { Login } from './browser/auth/Login'
 import { Workers } from './functions/Workers'
 import Activities from './functions/Activities'
+import { SearchManager } from './functions/SearchManager'
 
-import { Account } from './interface/Account'
-import Axios from './util/Axios'
-import fs from 'fs'
-import path from 'path'
+import type { Account } from './interface/Account'
+import AxiosClient from './util/Axios'
+import { sendDiscord, flushDiscordQueue } from './logging/Discord'
+import { sendNtfy, flushNtfyQueue } from './logging/Ntfy'
+import type { DashboardData } from './interface/DashboardData'
+import type { AppDashboardData } from './interface/AppDashBoardData'
 
+interface ExecutionContext {
+    isMobile: boolean
+    accountEmail: string
+}
 
-// Main bot class
-export class MicrosoftRewardsBot {
-    public log: typeof log
-    public config
-    public utils: Util
-    public activities: Activities = new Activities(this)
-    public browser: {
-        func: BrowserFunc,
-        utils: BrowserUtil
+interface BrowserSession {
+    context: BrowserContext
+    fingerprint: BrowserFingerprintWithHeaders
+}
+
+interface AccountStats {
+    email: string
+    initialPoints: number
+    finalPoints: number
+    collectedPoints: number
+    duration: number
+    success: boolean
+    error?: string
+}
+
+const executionContext = new AsyncLocalStorage<ExecutionContext>()
+
+export function getCurrentContext(): ExecutionContext {
+    const context = executionContext.getStore()
+    if (!context) {
+        return { isMobile: false, accountEmail: 'unknown' }
     }
-    public isMobile: boolean
-    public homePage!: Page
+    return context
+}
 
-    private pointsCanCollect: number = 0
-    private pointsInitial: number = 0
+async function flushAllWebhooks(timeoutMs = 5000): Promise<void> {
+    await Promise.allSettled([flushDiscordQueue(timeoutMs), flushNtfyQueue(timeoutMs)])
+}
+
+interface UserData {
+    userName: string
+    geoLocale: string
+    initialPoints: number
+    currentPoints: number
+    gainedPoints: number
+}
+
+export class MicrosoftRewardsBot {
+    public logger: Logger
+    public config
+    public utils: Utils
+    public activities: Activities = new Activities(this)
+    public browser: { func: BrowserFunc; utils: BrowserUtils }
+
+    public mainMobilePage!: Page
+    public mainDesktopPage!: Page
+
+    public userData: UserData
+
+    public accessToken = ''
+    public requestToken = ''
+    public cookies: { mobile: Cookie[]; desktop: Cookie[] }
+    public fingerprint!: BrowserFingerprintWithHeaders
+
+    private pointsCanCollect = 0
 
     private activeWorkers: number
-    private mobileRetryAttempts: number
     private browserFactory: Browser = new Browser(this)
     private accounts: Account[]
     private workers: Workers
     private login = new Login(this)
-    private accessToken: string = ''
+    private searchManager: SearchManager
 
-    // Summary collection (per process)
-    private accountSummaries: AccountSummary[] = []
-
-    //@ts-expect-error Will be initialized later
-    public axios: Axios
-
-    constructor(isMobile: boolean) {
-        this.isMobile = isMobile
-        this.log = log
+    public axios!: AxiosClient
 
+    constructor() {
+        this.userData = {
+            userName: '',
+            geoLocale: '',
+            initialPoints: 0,
+            currentPoints: 0,
+            gainedPoints: 0
+        }
+        this.logger = new Logger(this)
         this.accounts = []
-        this.utils = new Util()
+        this.cookies = { mobile: [], desktop: [] }
+        this.utils = new Utils()
         this.workers = new Workers(this)
+        this.searchManager = new SearchManager(this)
         this.browser = {
             func: new BrowserFunc(this),
-            utils: new BrowserUtil(this)
+            utils: new BrowserUtils(this)
         }
         this.config = loadConfig()
         this.activeWorkers = this.config.clusters
-        this.mobileRetryAttempts = 0
     }
 
-    async initialize() {
+    get isMobile(): boolean {
+        return getCurrentContext().isMobile
+    }
+
+    async initialize(): Promise<void> {
         this.accounts = loadAccounts()
     }
 
-    async run() {
-        this.printBanner()
-        log('main', 'MAIN', `Bot started with ${this.config.clusters} clusters`)
+    async run(): Promise<void> {
+        const totalAccounts = this.accounts.length
+        const runStartTime = Date.now()
+
+        this.logger.info(
+            'main',
+            'RUN-START',
+            `Starting Microsoft Rewards bot| v${pkg.version} | Accounts: ${totalAccounts} | Clusters: ${this.config.clusters}`
+        )
 
-        // Only cluster when there's more than 1 cluster demanded
         if (this.config.clusters > 1) {
             if (cluster.isPrimary) {
-                this.runMaster()
+                this.runMaster(runStartTime)
             } else {
-                this.runWorker()
+                this.runWorker(runStartTime)
             }
         } else {
-            await this.runTasks(this.accounts)
+            await this.runTasks(this.accounts, runStartTime)
         }
     }
 
-    private printBanner() {
-        // Only print once (primary process or single cluster execution)
-        if (this.config.clusters > 1 && !cluster.isPrimary) return
-        try {
-            const pkgPath = path.join(__dirname, '../', 'package.json')
-            let version = 'unknown'
-            if (fs.existsSync(pkgPath)) {
-                const raw = fs.readFileSync(pkgPath, 'utf-8')
-                const pkg = JSON.parse(raw)
-                version = pkg.version || version
-            }
-            const banner = [
-                '  __  __  _____       _____                            _     ',
-                ' |  \/  |/ ____|     |  __ \\                          | |    ',
-                ' | \  / | (___ ______| |__) |_____      ____ _ _ __ __| |___ ',
-                ' | |\/| |\\___ \\______|  _  // _ \\ \\ /\\ / / _` | \'__/ _` / __|',
-                ' | |  | |____) |     | | \\ \\  __/ \\ V  V / (_| | | | (_| \\__ \\',
-                ' |_|  |_|_____/      |_|  \\_\\___| \\_/\\_/ \\__,_|_|  \\__,_|___/',
-                '',
-                ` Version: v${version}`,
-                ''
-            ].join('\n')
-            console.log(banner)
-        } catch { /* ignore banner errors */ }
-    }
+    private runMaster(runStartTime: number): void {
+        void this.logger.info('main', 'CLUSTER-PRIMARY', `Primary process started | PID: ${process.pid}`)
 
-    // Return summaries (used when clusters==1)
-    public getSummaries() {
-        return this.accountSummaries
-    }
+        const rawChunks = this.utils.chunkArray(this.accounts, this.config.clusters)
+        const accountChunks = rawChunks.filter(c => c && c.length > 0)
+        this.activeWorkers = accountChunks.length
 
-    private runMaster() {
-        log('main', 'MAIN-PRIMARY', 'Primary process started')
+        const allAccountStats: AccountStats[] = []
 
-        const accountChunks = this.utils.chunkArray(this.accounts, this.config.clusters)
-
-        for (let i = 0; i < accountChunks.length; i++) {
+        for (const chunk of accountChunks) {
             const worker = cluster.fork()
-            const chunk = accountChunks[i]
-            ;(worker as any).send?.({ chunk })
-            // Collect summaries from workers
-            worker.on('message', (msg: any) => {
-                if (msg && msg.type === 'summary' && Array.isArray(msg.data)) {
-                    this.accountSummaries.push(...msg.data)
+            worker.send?.({ chunk, runStartTime })
+
+            worker.on('message', (msg: { __ipcLog?: IpcLog; __stats?: AccountStats[] }) => {
+                if (msg.__stats) {
+                    allAccountStats.push(...msg.__stats)
+                }
+
+                const log = msg.__ipcLog
+
+                if (log && typeof log.content === 'string') {
+                    const config = this.config
+                    const webhook = config.webhook
+                    const content = log.content
+                    const level = log.level
+                    if (webhook.discord?.enabled && webhook.discord.url) {
+                        sendDiscord(webhook.discord.url, content, level)
+                    }
+                    if (webhook.ntfy?.enabled && webhook.ntfy.url) {
+                        sendNtfy(webhook.ntfy, content, level)
+                    }
                 }
             })
         }
 
-    cluster.on('exit', (worker: any, code: number) => {
+        const onWorkerDone = async (label: 'exit' | 'disconnect', worker: Worker, code?: number): Promise<void> => {
             this.activeWorkers -= 1
+            this.logger.warn(
+                'main',
+                `CLUSTER-WORKER-${label.toUpperCase()}`,
+                `Worker ${worker.process?.pid ?? '?'} ${label} | Code: ${code ?? 'n/a'} | Active workers: ${this.activeWorkers}`
+            )
+            if (this.activeWorkers <= 0) {
+                const totalCollectedPoints = allAccountStats.reduce((sum, s) => sum + s.collectedPoints, 0)
+                const totalInitialPoints = allAccountStats.reduce((sum, s) => sum + s.initialPoints, 0)
+                const totalFinalPoints = allAccountStats.reduce((sum, s) => sum + s.finalPoints, 0)
+                const totalDurationMinutes = ((Date.now() - runStartTime) / 1000 / 60).toFixed(1)
 
-            log('main', 'MAIN-WORKER', `Worker ${worker.process.pid} destroyed | Code: ${code} | Active workers: ${this.activeWorkers}`, 'warn')
+                this.logger.info(
+                    'main',
+                    'RUN-END',
+                    `Completed all accounts | Accounts processed: ${allAccountStats.length} | Total points collected: +${totalCollectedPoints} | Old total: ${totalInitialPoints} → New total: ${totalFinalPoints} | Total runtime: ${totalDurationMinutes}min`,
+                    'green'
+                )
+                await flushAllWebhooks()
+                process.exit(code ?? 0)
+            }
+        }
 
-            // Check if all workers have exited
-            if (this.activeWorkers === 0) {
-                // All workers done -> send conclusion (if enabled) then exit
-                this.sendConclusion(this.accountSummaries).finally(() => {
-                    log('main', 'MAIN-WORKER', 'All workers destroyed. Exiting main process!', 'warn')
-                    process.exit(0)
-                })
+        cluster.on('exit', (worker, code) => {
+            void onWorkerDone('exit', worker, code)
+        })
+        cluster.on('disconnect', worker => {
+            void onWorkerDone('disconnect', worker, undefined)
+        })
+    }
+
+    private runWorker(runStartTimeFromMaster?: number): void {
+        void this.logger.info('main', 'CLUSTER-WORKER-START', `Worker spawned | PID: ${process.pid}`)
+        process.on('message', async ({ chunk, runStartTime }: { chunk: Account[]; runStartTime: number }) => {
+            void this.logger.info(
+                'main',
+                'CLUSTER-WORKER-TASK',
+                `Worker ${process.pid} received ${chunk.length} accounts.`
+            )
+            try {
+                const stats = await this.runTasks(chunk, runStartTime ?? runStartTimeFromMaster ?? Date.now())
+                if (process.send) {
+                    process.send({ __stats: stats })
+                }
+            } catch (error) {
+                this.logger.error(
+                    'main',
+                    'CLUSTER-WORKER-ERROR',
+                    `Worker task crash: ${error instanceof Error ? error.message : String(error)}`
+                )
+                await flushAllWebhooks()
+                process.exit(1)
             }
         })
     }
 
-    private runWorker() {
-        log('main', 'MAIN-WORKER', `Worker ${process.pid} spawned`)
-        // Receive the chunk of accounts from the master
-    ;(process as any).on('message', async ({ chunk }: { chunk: Account[] }) => {
-            await this.runTasks(chunk)
-        })
-    }
+    private async runTasks(accounts: Account[], runStartTime: number): Promise<AccountStats[]> {
+        const accountStats: AccountStats[] = []
 
-    private async runTasks(accounts: Account[]) {
         for (const account of accounts) {
-            log('main', 'MAIN-WORKER', `Started tasks for account ${account.email}`)
+            const accountStartTime = Date.now()
+            const accountEmail = account.email
+            this.userData.userName = this.utils.getEmailUsername(accountEmail)
 
-            const accountStart = Date.now()
-            let desktopInitial = 0
-            let mobileInitial = 0
-            let desktopCollected = 0
-            let mobileCollected = 0
-            const errors: string[] = []
+            try {
+                this.logger.info(
+                    'main',
+                    'ACCOUNT-START',
+                    `Starting account: ${accountEmail} | geoLocale: ${account.geoLocale}`
+                )
 
-            this.axios = new Axios(account.proxy)
-            const verbose = process.env.DEBUG_REWARDS_VERBOSE === '1'
-            const formatFullErr = (label: string, e: any) => {
-                const base = shortErr(e)
-                if (verbose && e instanceof Error) {
-                    return `${label}:${base} :: ${e.stack?.split('\n').slice(0,4).join(' | ')}`
+                this.axios = new AxiosClient(account.proxy)
+
+                const result: { initialPoints: number; collectedPoints: number } | undefined = await this.Main(
+                    account
+                ).catch(error => {
+                    void this.logger.error(
+                        true,
+                        'FLOW',
+                        `Mobile flow failed for ${accountEmail}: ${error instanceof Error ? error.message : String(error)}`
+                    )
+                    return undefined
+                })
+
+                const durationSeconds = ((Date.now() - accountStartTime) / 1000).toFixed(1)
+
+                if (result) {
+                    const collectedPoints = result.collectedPoints ?? 0
+                    const accountInitialPoints = result.initialPoints ?? 0
+                    const accountFinalPoints = accountInitialPoints + collectedPoints
+
+                    accountStats.push({
+                        email: accountEmail,
+                        initialPoints: accountInitialPoints,
+                        finalPoints: accountFinalPoints,
+                        collectedPoints: collectedPoints,
+                        duration: parseFloat(durationSeconds),
+                        success: true
+                    })
+
+                    this.logger.info(
+                        'main',
+                        'ACCOUNT-END',
+                        `Completed account: ${accountEmail} | Total: +${collectedPoints} | Old: ${accountInitialPoints} → New: ${accountFinalPoints} | Duration: ${durationSeconds}s`,
+                        'green'
+                    )
+                } else {
+                    accountStats.push({
+                        email: accountEmail,
+                        initialPoints: 0,
+                        finalPoints: 0,
+                        collectedPoints: 0,
+                        duration: parseFloat(durationSeconds),
+                        success: false,
+                        error: 'Flow failed'
+                    })
                 }
-                return `${label}:${base}`
+            } catch (error) {
+                const durationSeconds = ((Date.now() - accountStartTime) / 1000).toFixed(1)
+                this.logger.error(
+                    'main',
+                    'ACCOUNT-ERROR',
+                    `${accountEmail}: ${error instanceof Error ? error.message : String(error)}`
+                )
+
+                accountStats.push({
+                    email: accountEmail,
+                    initialPoints: 0,
+                    finalPoints: 0,
+                    collectedPoints: 0,
+                    duration: parseFloat(durationSeconds),
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error)
+                })
             }
+        }
 
-            if (this.config.parallel) {
-                const mobileInstance = new MicrosoftRewardsBot(true)
-                mobileInstance.axios = this.axios
-                // Run both and capture results with detailed logging
-                const desktopPromise = this.Desktop(account).catch(e => {
-                    log(false, 'TASK', `Desktop flow failed early for ${account.email}: ${e instanceof Error ? e.message : e}`,'error')
-                    errors.push(formatFullErr('desktop', e)); return null
-                })
-                const mobilePromise = mobileInstance.Mobile(account).catch(e => {
-                    log(true, 'TASK', `Mobile flow failed early for ${account.email}: ${e instanceof Error ? e.message : e}`,'error')
-                    errors.push(formatFullErr('mobile', e)); return null
-                })
-                const [desktopResult, mobileResult] = await Promise.all([desktopPromise, mobilePromise])
-                if (desktopResult) {
-                    desktopInitial = desktopResult.initialPoints
-                    desktopCollected = desktopResult.collectedPoints
-                }
-                if (mobileResult) {
-                    mobileInitial = mobileResult.initialPoints
-                    mobileCollected = mobileResult.collectedPoints
-                }
-            } else {
-                this.isMobile = false
-                const desktopResult = await this.Desktop(account).catch(e => {
-                    log(false, 'TASK', `Desktop flow failed early for ${account.email}: ${e instanceof Error ? e.message : e}`,'error')
-                    errors.push(formatFullErr('desktop', e)); return null
-                })
-                if (desktopResult) {
-                    desktopInitial = desktopResult.initialPoints
-                    desktopCollected = desktopResult.collectedPoints
+        if (this.config.clusters <= 1 && !cluster.isWorker) {
+            const totalCollectedPoints = accountStats.reduce((sum, s) => sum + s.collectedPoints, 0)
+            const totalInitialPoints = accountStats.reduce((sum, s) => sum + s.initialPoints, 0)
+            const totalFinalPoints = accountStats.reduce((sum, s) => sum + s.finalPoints, 0)
+            const totalDurationMinutes = ((Date.now() - runStartTime) / 1000 / 60).toFixed(1)
+
+            this.logger.info(
+                'main',
+                'RUN-END',
+                `Completed all accounts | Accounts processed: ${accountStats.length} | Total points collected: +${totalCollectedPoints} | Old total: ${totalInitialPoints} → New total: ${totalFinalPoints} | Total runtime: ${totalDurationMinutes}min`,
+                'green'
+            )
+
+            await flushAllWebhooks()
+            process.exit()
+        }
+
+        return accountStats
+    }
+
+    async Main(account: Account): Promise<{ initialPoints: number; collectedPoints: number }> {
+        const accountEmail = account.email
+        this.logger.info('main', 'FLOW', `Starting session for ${accountEmail}`)
+
+        let mobileSession: BrowserSession | null = null
+        let mobileContextClosed = false
+
+        try {
+            return await executionContext.run({ isMobile: true, accountEmail }, async () => {
+                mobileSession = await this.browserFactory.createBrowser(account.proxy, accountEmail)
+                const initialContext: BrowserContext = mobileSession.context
+                this.mainMobilePage = await initialContext.newPage()
+
+                this.logger.info('main', 'BROWSER', `Mobile Browser started | ${accountEmail}`)
+
+                await this.login.login(this.mainMobilePage, accountEmail, account.password, account.totp)
+
+                try {
+                    this.accessToken = await this.login.getAppAccessToken(this.mainMobilePage, accountEmail)
+                } catch (error) {
+                    this.logger.error(
+                        'main',
+                        'FLOW',
+                        `Failed to get mobile access token: ${error instanceof Error ? error.message : String(error)}`
+                    )
                 }
 
-                this.isMobile = true
-                const mobileResult = await this.Mobile(account).catch(e => {
-                    log(true, 'TASK', `Mobile flow failed early for ${account.email}: ${e instanceof Error ? e.message : e}`,'error')
-                    errors.push(formatFullErr('mobile', e)); return null
-                })
-                if (mobileResult) {
-                    mobileInitial = mobileResult.initialPoints
-                    mobileCollected = mobileResult.collectedPoints
-                }
-            }
+                this.cookies.mobile = await initialContext.cookies()
+                this.fingerprint = mobileSession.fingerprint
 
-            const accountEnd = Date.now()
-            const durationMs = accountEnd - accountStart
-            const totalCollected = desktopCollected + mobileCollected
-            const initialTotal = (desktopInitial || 0) + (mobileInitial || 0)
-            this.accountSummaries.push({
-                email: account.email,
-                durationMs,
-                desktopCollected,
-                mobileCollected,
-                totalCollected,
-                initialTotal,
-                endTotal: initialTotal + totalCollected,
-                errors
+                const data: DashboardData = await this.browser.func.getDashboardData()
+                const appData: AppDashboardData = await this.browser.func.getAppDashboardData()
+
+                // Set geo
+                this.userData.geoLocale =
+                    account.geoLocale === 'auto' ? data.userProfile.attributes.country : account.geoLocale.toLowerCase()
+                if (this.userData.geoLocale.length > 2) {
+                    this.logger.warn(
+                        'main',
+                        'GEO-LOCALE',
+                        `The provided geoLocale is longer than 2 (${this.userData.geoLocale} | auto=${account.geoLocale === 'auto'}), this is likely invalid and can cause errors!`
+                    )
+                }
+
+                this.userData.initialPoints = data.userStatus.availablePoints
+                this.userData.currentPoints = data.userStatus.availablePoints
+                const initialPoints = this.userData.initialPoints ?? 0
+
+                const browserEarnable = await this.browser.func.getBrowserEarnablePoints()
+                const appEarnable = await this.browser.func.getAppEarnablePoints()
+
+                this.pointsCanCollect = browserEarnable.mobileSearchPoints + (appEarnable?.totalEarnablePoints ?? 0)
+
+                this.logger.info(
+                    'main',
+                    'POINTS',
+                    `Earnable today | Mobile: ${this.pointsCanCollect} | Browser: ${
+                        browserEarnable.mobileSearchPoints
+                    } | App: ${appEarnable?.totalEarnablePoints ?? 0} | ${accountEmail} | locale: ${this.userData.geoLocale}`
+                )
+
+                if (this.config.workers.doAppPromotions) await this.workers.doAppPromotions(appData)
+                if (this.config.workers.doDailySet) await this.workers.doDailySet(data, this.mainMobilePage)
+                if (this.config.workers.doMorePromotions) await this.workers.doMorePromotions(data, this.mainMobilePage)
+                if (this.config.workers.doDailyCheckIn) await this.activities.doDailyCheckIn()
+                if (this.config.workers.doReadToEarn) await this.activities.doReadToEarn()
+
+                const searchPoints = await this.browser.func.getSearchPoints()
+                const missingSearchPoints = this.browser.func.missingSearchPoints(searchPoints, true)
+
+                this.cookies.mobile = await initialContext.cookies()
+
+                const { mobilePoints, desktopPoints } = await this.searchManager.doSearches(
+                    data,
+                    missingSearchPoints,
+                    mobileSession,
+                    account,
+                    accountEmail
+                )
+
+                mobileContextClosed = true
+
+                this.userData.gainedPoints = mobilePoints + desktopPoints
+
+                const finalPoints = await this.browser.func.getCurrentPoints()
+                const collectedPoints = finalPoints - initialPoints
+
+                this.logger.info(
+                    'main',
+                    'FLOW',
+                    `Collected: +${collectedPoints} | Mobile: +${mobilePoints} | Desktop: +${desktopPoints} | ${accountEmail}`
+                )
+
+                return {
+                    initialPoints,
+                    collectedPoints: collectedPoints || 0
+                }
             })
-
-            log('main', 'MAIN-WORKER', `Completed tasks for account ${account.email}`, 'log', 'green')
-        }
-
-        log(this.isMobile, 'MAIN-PRIMARY', 'Completed tasks for ALL accounts', 'log', 'green')
-        // Extra diagnostic summary when verbose
-        if (process.env.DEBUG_REWARDS_VERBOSE === '1') {
-            for (const summary of this.accountSummaries) {
-                log('main','SUMMARY-DEBUG',`Account ${summary.email} collected D:${summary.desktopCollected} M:${summary.mobileCollected} TOTAL:${summary.totalCollected} ERRORS:${summary.errors.length ? summary.errors.join(';') : 'none'}`)
+        } finally {
+            if (mobileSession && !mobileContextClosed) {
+                try {
+                    await executionContext.run({ isMobile: true, accountEmail }, async () => {
+                        await this.browser.func.closeBrowser(mobileSession!.context, accountEmail)
+                    })
+                } catch {}
             }
         }
-        // If in worker mode (clusters>1) send summaries to primary
-        if (this.config.clusters > 1 && !cluster.isPrimary) {
-            if (process.send) {
-                process.send({ type: 'summary', data: this.accountSummaries })
-            }
-        } else {
-            // Single process mode -> build and send conclusion directly
-            await this.sendConclusion(this.accountSummaries)
-        }
-        process.exit()
-    }
-
-    // Desktop
-    async Desktop(account: Account) {
-        log(false,'FLOW','Desktop() invoked')
-        const browser = await this.browserFactory.createBrowser(account.proxy, account.email)
-        this.homePage = await browser.newPage()
-
-        log(this.isMobile, 'MAIN', 'Starting browser')
-
-        // Login into MS Rewards, then go to rewards homepage
-        await this.login.login(this.homePage, account.email, account.password)
-
-        await this.browser.func.goHome(this.homePage)
-
-        const data = await this.browser.func.getDashboardData()
-
-    this.pointsInitial = data.userStatus.availablePoints
-    const initial = this.pointsInitial
-
-        log(this.isMobile, 'MAIN-POINTS', `Current point count: ${this.pointsInitial}`)
-
-        const browserEnarablePoints = await this.browser.func.getBrowserEarnablePoints()
-
-        // Tally all the desktop points
-        this.pointsCanCollect = browserEnarablePoints.dailySetPoints +
-            browserEnarablePoints.desktopSearchPoints
-            + browserEnarablePoints.morePromotionsPoints
-
-        log(this.isMobile, 'MAIN-POINTS', `You can earn ${this.pointsCanCollect} points today`)
-
-        // If runOnZeroPoints is false and 0 points to earn, don't continue
-        if (!this.config.runOnZeroPoints && this.pointsCanCollect === 0) {
-            log(this.isMobile, 'MAIN', 'No points to earn and "runOnZeroPoints" is set to "false", stopping!', 'log', 'yellow')
-
-            // Close desktop browser
-            await this.browser.func.closeBrowser(browser, account.email)
-            return
-        }
-
-        // Open a new tab to where the tasks are going to be completed
-        const workerPage = await browser.newPage()
-
-        // Go to homepage on worker page
-        await this.browser.func.goHome(workerPage)
-
-        // Complete daily set
-        if (this.config.workers.doDailySet) {
-            await this.workers.doDailySet(workerPage, data)
-        }
-
-        // Complete more promotions
-        if (this.config.workers.doMorePromotions) {
-            await this.workers.doMorePromotions(workerPage, data)
-        }
-
-        // Complete punch cards
-        if (this.config.workers.doPunchCards) {
-            await this.workers.doPunchCard(workerPage, data)
-        }
-
-        // Do desktop searches
-        if (this.config.workers.doDesktopSearch) {
-            await this.activities.doSearch(workerPage, data)
-        }
-
-        // Save cookies
-        await saveSessionData(this.config.sessionPath, browser, account.email, this.isMobile)
-
-        // Fetch points BEFORE closing (avoid page closed reload error)
-        const after = await this.browser.func.getCurrentPoints().catch(()=>initial)
-        // Close desktop browser
-        await this.browser.func.closeBrowser(browser, account.email)
-        return {
-            initialPoints: initial,
-            collectedPoints: (after - initial) || 0
-        }
-    }
-
-    // Mobile
-    async Mobile(account: Account) {
-        log(true,'FLOW','Mobile() invoked')
-        const browser = await this.browserFactory.createBrowser(account.proxy, account.email)
-        this.homePage = await browser.newPage()
-
-        log(this.isMobile, 'MAIN', 'Starting browser')
-
-        // Login into MS Rewards, then go to rewards homepage
-        await this.login.login(this.homePage, account.email, account.password)
-        this.accessToken = await this.login.getMobileAccessToken(this.homePage, account.email)
-
-        await this.browser.func.goHome(this.homePage)
-
-    const data = await this.browser.func.getDashboardData()
-    const initialPoints = data.userStatus.availablePoints || this.pointsInitial || 0
-
-        const browserEnarablePoints = await this.browser.func.getBrowserEarnablePoints()
-        const appEarnablePoints = await this.browser.func.getAppEarnablePoints(this.accessToken)
-
-        this.pointsCanCollect = browserEnarablePoints.mobileSearchPoints + appEarnablePoints.totalEarnablePoints
-
-        log(this.isMobile, 'MAIN-POINTS', `You can earn ${this.pointsCanCollect} points today (Browser: ${browserEnarablePoints.mobileSearchPoints} points, App: ${appEarnablePoints.totalEarnablePoints} points)`)
-
-        // If runOnZeroPoints is false and 0 points to earn, don't continue
-        if (!this.config.runOnZeroPoints && this.pointsCanCollect === 0) {
-            log(this.isMobile, 'MAIN', 'No points to earn and "runOnZeroPoints" is set to "false", stopping!', 'log', 'yellow')
-
-            // Close mobile browser
-            await this.browser.func.closeBrowser(browser, account.email)
-            return {
-                initialPoints: initialPoints,
-                collectedPoints: 0
-            }
-        }
-        // Do daily check in
-        if (this.config.workers.doDailyCheckIn) {
-            await this.activities.doDailyCheckIn(this.accessToken, data)
-        }
-
-        // Do read to earn
-        if (this.config.workers.doReadToEarn) {
-            await this.activities.doReadToEarn(this.accessToken, data)
-        }
-
-        // Do mobile searches
-        if (this.config.workers.doMobileSearch) {
-            // If no mobile searches data found, stop (Does not always exist on new accounts)
-            if (data.userStatus.counters.mobileSearch) {
-                // Open a new tab to where the tasks are going to be completed
-                const workerPage = await browser.newPage()
-
-                // Go to homepage on worker page
-                await this.browser.func.goHome(workerPage)
-
-                await this.activities.doSearch(workerPage, data)
-
-                // Fetch current search points
-                const mobileSearchPoints = (await this.browser.func.getSearchPoints()).mobileSearch?.[0]
-
-                if (mobileSearchPoints && (mobileSearchPoints.pointProgressMax - mobileSearchPoints.pointProgress) > 0) {
-                    // Increment retry count
-                    this.mobileRetryAttempts++
-                }
-
-                // Exit if retries are exhausted
-                if (this.mobileRetryAttempts > this.config.searchSettings.retryMobileSearchAmount) {
-                    log(this.isMobile, 'MAIN', `Max retry limit of ${this.config.searchSettings.retryMobileSearchAmount} reached. Exiting retry loop`, 'warn')
-                } else if (this.mobileRetryAttempts !== 0) {
-                    log(this.isMobile, 'MAIN', `Attempt ${this.mobileRetryAttempts}/${this.config.searchSettings.retryMobileSearchAmount}: Unable to complete mobile searches, bad User-Agent? Increase search delay? Retrying...`, 'log', 'yellow')
-
-                    // Close mobile browser
-                    await this.browser.func.closeBrowser(browser, account.email)
-
-                    // Create a new browser and try
-                    await this.Mobile(account)
-                    return
-                }
-            } else {
-                log(this.isMobile, 'MAIN', 'Unable to fetch search points, your account is most likely too "new" for this! Try again later!', 'warn')
-            }
-        }
-
-        const afterPointAmount = await this.browser.func.getCurrentPoints()
-
-        log(this.isMobile, 'MAIN-POINTS', `The script collected ${afterPointAmount - initialPoints} points today`)
-
-        // Close mobile browser
-        await this.browser.func.closeBrowser(browser, account.email)
-        return {
-            initialPoints: initialPoints,
-            collectedPoints: (afterPointAmount - initialPoints) || 0
-        }
-    }
-
-    private async sendConclusion(summaries: AccountSummary[]) {
-        const { ConclusionWebhook } = await import('./util/ConclusionWebhook')
-        const cfg = this.config
-        if (!cfg.conclusionWebhook || !cfg.conclusionWebhook.enabled) return
-
-        const totalAccounts = summaries.length
-        if (totalAccounts === 0) return
-
-        let totalCollected = 0
-        let totalInitial = 0
-        let totalEnd = 0
-        let totalDuration = 0
-        let accountsWithErrors = 0
-
-        const accountFields: any[] = []
-        for (const s of summaries) {
-            totalCollected += s.totalCollected
-            totalInitial += s.initialTotal
-            totalEnd += s.endTotal
-            totalDuration += s.durationMs
-            if (s.errors.length) accountsWithErrors++
-
-            const statusEmoji = s.errors.length ? '⚠️' : '✅'
-            const diff = s.totalCollected
-            const duration = formatDuration(s.durationMs)
-            const valueLines: string[] = [
-                `Points: ${s.initialTotal} → ${s.endTotal} ( +${diff} )`,
-                `Breakdown: 🖥️ ${s.desktopCollected} | 📱 ${s.mobileCollected}`,
-                `Duration: ⏱️ ${duration}`
-            ]
-            if (s.errors.length) {
-                valueLines.push(`Errors: ${s.errors.slice(0,2).join(' | ')}`)
-            }
-            accountFields.push({
-                name: `${statusEmoji} ${s.email}`.substring(0, 256),
-                value: valueLines.join('\n').substring(0, 1024),
-                inline: false
-            })
-        }
-
-        const avgDuration = totalDuration / totalAccounts
-        const embed = {
-            title: '🎯 Microsoft Rewards Summary',
-            description: `Processed **${totalAccounts}** account(s)${accountsWithErrors ? ` • ${accountsWithErrors} with issues` : ''}`,
-            color: accountsWithErrors ? 0xFFAA00 : 0x32CD32,
-            fields: [
-                {
-                    name: 'Global Totals',
-                    value: [
-                        `Total Points: ${totalInitial} → ${totalEnd} ( +${totalCollected} )`,
-                        `Average Duration: ${formatDuration(avgDuration)}`,
-                        `Cumulative Runtime: ${formatDuration(totalDuration)}`
-                    ].join('\n')
-                },
-                ...accountFields
-            ].slice(0, 25), // Discord max 25 fields
-            timestamp: new Date().toISOString(),
-            footer: {
-                text: 'Script conclusion webhook'
-            }
-        }
-
-        // Fallback plain text (rare) & embed send
-        const fallback = `Microsoft Rewards Summary\nAccounts: ${totalAccounts}\nTotal: ${totalInitial} -> ${totalEnd} (+${totalCollected})\nRuntime: ${formatDuration(totalDuration)}`
-        await ConclusionWebhook(cfg, fallback, { embeds: [embed] })
     }
 }
 
-interface AccountSummary {
-    email: string
-    durationMs: number
-    desktopCollected: number
-    mobileCollected: number
-    totalCollected: number
-    initialTotal: number
-    endTotal: number
-    errors: string[]
-}
+export { executionContext }
 
-function shortErr(e: any): string {
-    if (!e) return 'unknown'
-    if (e instanceof Error) return e.message.substring(0, 120)
-    const s = String(e)
-    return s.substring(0, 120)
-}
+async function main(): Promise<void> {
+    const rewardsBot = new MicrosoftRewardsBot()
 
-function formatDuration(ms: number): string {
-    if (!ms || ms < 1000) return `${ms}ms`
-    const sec = Math.floor(ms / 1000)
-    const h = Math.floor(sec / 3600)
-    const m = Math.floor((sec % 3600) / 60)
-    const s = sec % 60
-    const parts: string[] = []
-    if (h) parts.push(`${h}h`)
-    if (m) parts.push(`${m}m`)
-    if (s) parts.push(`${s}s`)
-    return parts.join(' ') || `${ms}ms`
-}
-
-async function main() {
-    const rewardsBot = new MicrosoftRewardsBot(false)
+    process.on('beforeExit', () => {
+        void flushAllWebhooks()
+    })
+    process.on('SIGINT', async () => {
+        rewardsBot.logger.warn('main', 'PROCESS', 'SIGINT received, flushing and exiting...')
+        await flushAllWebhooks()
+        process.exit(130)
+    })
+    process.on('SIGTERM', async () => {
+        rewardsBot.logger.warn('main', 'PROCESS', 'SIGTERM received, flushing and exiting...')
+        await flushAllWebhooks()
+        process.exit(143)
+    })
+    process.on('uncaughtException', async error => {
+        rewardsBot.logger.error('main', 'UNCAUGHT-EXCEPTION', error)
+        await flushAllWebhooks()
+        process.exit(1)
+    })
+    process.on('unhandledRejection', async reason => {
+        rewardsBot.logger.error('main', 'UNHANDLED-REJECTION', reason as Error)
+        await flushAllWebhooks()
+        process.exit(1)
+    })
 
     try {
         await rewardsBot.initialize()
         await rewardsBot.run()
     } catch (error) {
-        log(false, 'MAIN-ERROR', `Error running desktop bot: ${error}`, 'error')
+        rewardsBot.logger.error('main', 'MAIN-ERROR', error as Error)
     }
 }
 
-// Start the bots
-main().catch(error => {
-    log('main', 'MAIN-ERROR', `Error running bots: ${error}`, 'error')
+main().catch(async error => {
+    const tmpBot = new MicrosoftRewardsBot()
+    tmpBot.logger.error('main', 'MAIN-ERROR', error as Error)
+    await flushAllWebhooks()
     process.exit(1)
-})
+})

src/interface/Account.ts

@@ -1,13 +1,15 @@
 export interface Account {
-    email: string;
-    password: string;
-    proxy: AccountProxy;
+    email: string
+    password: string
+    totp?: string
+    geoLocale: 'auto' | string
+    proxy: AccountProxy
 }
 
 export interface AccountProxy {
-    proxyAxios: boolean;
-    url: string;
-    port: number;
-    password: string;
-    username: string;
-}
+    proxyAxios: boolean
+    url: string
+    port: number
+    password: string
+    username: string
+}

src/interface/AppDashBoardData.ts

@@ -0,0 +1,105 @@
+export interface AppDashboardData {
+    response: Response
+    correlationId: string
+    code: number
+}
+
+export interface Response {
+    profile: Profile
+    balance: number
+    counters: null
+    promotions: Promotion[]
+    catalog: null
+    goal_item: GoalItem
+    activities: null
+    cashback: null
+    orders: unknown[]
+    rebateProfile: null
+    rebatePayouts: null
+    giveProfile: null
+    autoRedeemProfile: null
+    autoRedeemItem: null
+    thirdPartyProfile: null
+    notifications: null
+    waitlist: null
+    autoOpenFlyout: null
+    coupons: null
+    recommendedAffordableCatalog: null
+    generativeAICreditsBalance: null
+    requestCountryCatalog: null
+    donationCatalog: null
+}
+
+export interface GoalItem {
+    name: string
+    provider: string
+    price: number
+    attributes: GoalItemAttributes
+    config: Config
+}
+
+export interface GoalItemAttributes {
+    category: string
+    CategoryDescription: string
+    'desc.group_text': string
+    'desc.legal_text': string
+    'desc.sc_description': string
+    'desc.sc_title': string
+    display_order: string
+    ExtraLargeImage: string
+    group: string
+    group_image: string
+    group_sc_image: string
+    group_title: string
+    hidden: string
+    large_image: string
+    large_sc_image: string
+    medium_image: string
+    MobileImage: string
+    original_price: string
+    points_destination: string
+    points_source: string
+    Remarks: string
+    ShortText: string
+    showcase: string
+    small_image: string
+    title: string
+    cimsid: string
+    user_defined_goal: string
+}
+
+export interface Config {
+    isHidden: string
+}
+
+export interface Profile {
+    ruid: string
+    attributes: ProfileAttributes
+    offline_attributes: OfflineAttributes
+}
+
+export interface ProfileAttributes {
+    ismsaautojoined: string
+    created: Date
+    creative: string
+    publisher: string
+    program: string
+    country: string
+    target: string
+    epuid: string
+    level: string
+    level_upd: Date
+    iris_segmentation: string
+    iris_segmentation_upd: Date
+    waitlistattributes: string
+    waitlistattributes_upd: Date
+}
+
+export interface OfflineAttributes {}
+
+export interface Promotion {
+    name: string
+    priority: number
+    attributes: { [key: string]: string }
+    tags: string[]
+}

src/interface/AppUserData.ts

@@ -1,151 +1,151 @@
 export interface AppUserData {
-    response: Response;
-    correlationId: string;
-    code: number;
+    response: Response
+    correlationId: string
+    code: number
 }
 
 export interface Response {
-    profile: Profile;
-    balance: number;
-    counters: null;
-    promotions: Promotion[];
-    catalog: null;
-    goal_item: GoalItem;
-    activities: null;
-    cashback: null;
-    orders: Order[];
-    rebateProfile: null;
-    rebatePayouts: null;
-    giveProfile: GiveProfile;
-    autoRedeemProfile: null;
-    autoRedeemItem: null;
-    thirdPartyProfile: null;
-    notifications: null;
-    waitlist: null;
-    autoOpenFlyout: null;
-    coupons: null;
-    recommendedAffordableCatalog: null;
+    profile: Profile
+    balance: number
+    counters: null
+    promotions: Promotion[]
+    catalog: null
+    goal_item: GoalItem
+    activities: null
+    cashback: null
+    orders: Order[]
+    rebateProfile: null
+    rebatePayouts: null
+    giveProfile: GiveProfile
+    autoRedeemProfile: null
+    autoRedeemItem: null
+    thirdPartyProfile: null
+    notifications: null
+    waitlist: null
+    autoOpenFlyout: null
+    coupons: null
+    recommendedAffordableCatalog: null
 }
 
 export interface GiveProfile {
-    give_user: string;
-    give_organization: { [key: string]: GiveOrganization | null };
-    first_give_optin: string;
-    last_give_optout: string;
-    give_lifetime_balance: string;
-    give_lifetime_donation_balance: string;
-    give_balance: string;
-    form: null;
+    give_user: string
+    give_organization: { [key: string]: GiveOrganization | null }
+    first_give_optin: string
+    last_give_optout: string
+    give_lifetime_balance: string
+    give_lifetime_donation_balance: string
+    give_balance: string
+    form: null
 }
 
 export interface GiveOrganization {
-    give_organization_donation_points: number;
-    give_organization_donation_point_to_currency_ratio: number;
-    give_organization_donation_currency: number;
+    give_organization_donation_points: number
+    give_organization_donation_point_to_currency_ratio: number
+    give_organization_donation_currency: number
 }
 
 export interface GoalItem {
-    name: string;
-    provider: string;
-    price: number;
-    attributes: GoalItemAttributes;
-    config: GoalItemConfig;
+    name: string
+    provider: string
+    price: number
+    attributes: GoalItemAttributes
+    config: GoalItemConfig
 }
 
 export interface GoalItemAttributes {
-    category: string;
-    CategoryDescription: string;
-    'desc.group_text': string;
-    'desc.legal_text'?: string;
-    'desc.sc_description': string;
-    'desc.sc_title': string;
-    display_order: string;
-    ExtraLargeImage: string;
-    group: string;
-    group_image: string;
-    group_sc_image: string;
-    group_title: string;
-    hidden?: string;
-    large_image: string;
-    large_sc_image: string;
-    medium_image: string;
-    MobileImage: string;
-    original_price: string;
-    Remarks?: string;
-    ShortText?: string;
-    showcase?: string;
-    small_image: string;
-    title: string;
-    cimsid: string;
-    user_defined_goal?: string;
-    disable_bot_redemptions?: string;
-    'desc.large_text'?: string;
-    english_title?: string;
-    etid?: string;
-    sku?: string;
-    coupon_discount?: string;
+    category: string
+    CategoryDescription: string
+    'desc.group_text': string
+    'desc.legal_text'?: string
+    'desc.sc_description': string
+    'desc.sc_title': string
+    display_order: string
+    ExtraLargeImage: string
+    group: string
+    group_image: string
+    group_sc_image: string
+    group_title: string
+    hidden?: string
+    large_image: string
+    large_sc_image: string
+    medium_image: string
+    MobileImage: string
+    original_price: string
+    Remarks?: string
+    ShortText?: string
+    showcase?: string
+    small_image: string
+    title: string
+    cimsid: string
+    user_defined_goal?: string
+    disable_bot_redemptions?: string
+    'desc.large_text'?: string
+    english_title?: string
+    etid?: string
+    sku?: string
+    coupon_discount?: string
 }
 
 export interface GoalItemConfig {
-    amount: string;
-    currencyCode: string;
-    isHidden: string;
-    PointToCurrencyConversionRatio: string;
+    amount: string
+    currencyCode: string
+    isHidden: string
+    PointToCurrencyConversionRatio: string
 }
 
 export interface Order {
-    id: string;
-    t: Date;
-    sku: string;
-    item_snapshot: ItemSnapshot;
-    p: number;
-    s: S;
-    a: A;
-    child_redemption: null;
-    third_party_partner: null;
-    log: Log[];
+    id: string
+    t: Date
+    sku: string
+    item_snapshot: ItemSnapshot
+    p: number
+    s: S
+    a: A
+    child_redemption: null
+    third_party_partner: null
+    log: Log[]
 }
 
 export interface A {
-    form?: string;
-    OrderId: string;
-    CorrelationId: string;
-    Channel: string;
-    Language: string;
-    Country: string;
-    EvaluationId: string;
-    provider?: string;
-    referenceOrderID?: string;
-    externalRefID?: string;
-    denomination?: string;
-    rewardName?: string;
-    sendEmail?: string;
-    status?: string;
-    createdAt?: Date;
-    bal_before_deduct?: string;
-    bal_after_deduct?: string;
+    form?: string
+    OrderId: string
+    CorrelationId: string
+    Channel: string
+    Language: string
+    Country: string
+    EvaluationId: string
+    provider?: string
+    referenceOrderID?: string
+    externalRefID?: string
+    denomination?: string
+    rewardName?: string
+    sendEmail?: string
+    status?: string
+    createdAt?: Date
+    bal_before_deduct?: string
+    bal_after_deduct?: string
 }
 
 export interface ItemSnapshot {
-    name: string;
-    provider: string;
-    price: number;
-    attributes: GoalItemAttributes;
-    config: ItemSnapshotConfig;
+    name: string
+    provider: string
+    price: number
+    attributes: GoalItemAttributes
+    config: ItemSnapshotConfig
 }
 
 export interface ItemSnapshotConfig {
-    amount: string;
-    countryCode: string;
-    currencyCode: string;
-    sku: string;
+    amount: string
+    countryCode: string
+    currencyCode: string
+    sku: string
 }
 
 export interface Log {
-    time: Date;
-    from: From;
-    to: S;
-    reason: string;
+    time: Date
+    from: From
+    to: S
+    reason: string
 }
 
 export enum From {
@@ -162,58 +162,57 @@ export enum S {
 }
 
 export interface Profile {
-    ruid: string;
-    attributes: ProfileAttributes;
-    offline_attributes: OfflineAttributes;
+    ruid: string
+    attributes: ProfileAttributes
+    offline_attributes: OfflineAttributes
 }
 
 export interface ProfileAttributes {
-    publisher: string;
-    publisher_upd: Date;
-    creative: string;
-    creative_upd: Date;
-    program: string;
-    program_upd: Date;
-    country: string;
-    country_upd: Date;
-    referrerhash: string;
-    referrerhash_upd: Date;
-    optout_upd: Date;
-    language: string;
-    language_upd: Date;
-    target: string;
-    target_upd: Date;
-    created: Date;
-    created_upd: Date;
-    epuid: string;
-    epuid_upd: Date;
-    goal: string;
-    goal_upd: Date;
-    waitlistattributes: string;
-    waitlistattributes_upd: Date;
-    serpbotscore_upd: Date;
-    iscashbackeligible: string;
-    cbedc: string;
-    rlscpct_upd: Date;
-    give_user: string;
-    rebcpc_upd: Date;
-    SerpBotScore_upd: Date;
-    AdsBotScore_upd: Date;
-    dbs_upd: Date;
-    rbs: string;
-    rbs_upd: Date;
-    iris_segmentation: string;
-    iris_segmentation_upd: Date;
+    publisher: string
+    publisher_upd: Date
+    creative: string
+    creative_upd: Date
+    program: string
+    program_upd: Date
+    country: string
+    country_upd: Date
+    referrerhash: string
+    referrerhash_upd: Date
+    optout_upd: Date
+    language: string
+    language_upd: Date
+    target: string
+    target_upd: Date
+    created: Date
+    created_upd: Date
+    epuid: string
+    epuid_upd: Date
+    goal: string
+    goal_upd: Date
+    waitlistattributes: string
+    waitlistattributes_upd: Date
+    serpbotscore_upd: Date
+    iscashbackeligible: string
+    cbedc: string
+    rlscpct_upd: Date
+    give_user: string
+    rebcpc_upd: Date
+    SerpBotScore_upd: Date
+    AdsBotScore_upd: Date
+    dbs_upd: Date
+    rbs: string
+    rbs_upd: Date
+    iris_segmentation: string
+    iris_segmentation_upd: Date
 }
 
-export interface OfflineAttributes {
-}
+export interface OfflineAttributes {}
 
 export interface Promotion {
-    name: string;
-    priority: number;
-    attributes: { [key: string]: string };
-    tags: Tag[];
+    name: string
+    priority: number
+    attributes: { [key: string]: string }
+    tags: Tag[]
 }
 
 export enum Tag {

src/interface/Config.ts

@@ -1,56 +1,81 @@
 export interface Config {
-    baseURL: string;
-    sessionPath: string;
-    headless: boolean;
-    parallel: boolean;
-    runOnZeroPoints: boolean;
-    clusters: number;
-    saveFingerprint: ConfigSaveFingerprint;
-    workers: ConfigWorkers;
-    searchOnBingLocalQueries: boolean;
-    globalTimeout: number | string;
-    searchSettings: ConfigSearchSettings;
-    logExcludeFunc: string[];
-    webhookLogExcludeFunc: string[];
-    proxy: ConfigProxy;
-    webhook: ConfigWebhook;
-    conclusionWebhook?: ConfigWebhook; // Optional secondary webhook for final summary
+    baseURL: string
+    sessionPath: string
+    headless: boolean
+    runOnZeroPoints: boolean
+    clusters: number
+    errorDiagnostics: boolean
+    saveFingerprint: ConfigSaveFingerprint
+    workers: ConfigWorkers
+    searchOnBingLocalQueries: boolean
+    globalTimeout: number | string
+    searchSettings: ConfigSearchSettings
+    debugLogs: boolean
+    proxy: ConfigProxy
+    consoleLogFilter: LogFilter
+    webhook: ConfigWebhook
 }
 
 export interface ConfigSaveFingerprint {
-    mobile: boolean;
-    desktop: boolean;
+    mobile: boolean
+    desktop: boolean
 }
 
 export interface ConfigSearchSettings {
-    useGeoLocaleQueries: boolean;
-    scrollRandomResults: boolean;
-    clickRandomResults: boolean;
-    searchDelay: ConfigSearchDelay;
-    retryMobileSearchAmount: number;
+    scrollRandomResults: boolean
+    clickRandomResults: boolean
+    parallelSearching: boolean
+    searchResultVisitTime: number | string
+    searchDelay: ConfigDelay
+    readDelay: ConfigDelay
 }
 
-export interface ConfigSearchDelay {
-    min: number | string;
-    max: number | string;
-}
-
-export interface ConfigWebhook {
-    enabled: boolean;
-    url: string;
+export interface ConfigDelay {
+    min: number | string
+    max: number | string
 }
 
 export interface ConfigProxy {
-    proxyGoogleTrends: boolean;
-    proxyBingTerms: boolean;
+    queryEngine: boolean
 }
 
 export interface ConfigWorkers {
-    doDailySet: boolean;
-    doMorePromotions: boolean;
-    doPunchCards: boolean;
-    doDesktopSearch: boolean;
-    doMobileSearch: boolean;
-    doDailyCheckIn: boolean;
-    doReadToEarn: boolean;
+    doDailySet: boolean
+    doMorePromotions: boolean
+    doPunchCards: boolean
+    doAppPromotions: boolean
+    doDesktopSearch: boolean
+    doMobileSearch: boolean
+    doDailyCheckIn: boolean
+    doReadToEarn: boolean
+}
+
+// Webhooks
+export interface ConfigWebhook {
+    discord?: WebhookDiscordConfig
+    ntfy?: WebhookNtfyConfig
+    webhookLogFilter: LogFilter
+}
+
+export interface LogFilter {
+    enabled: boolean
+    mode: 'whitelist' | 'blacklist'
+    levels?: Array<'debug' | 'info' | 'warn' | 'error'>
+    keywords?: string[]
+    regexPatterns?: string[]
+}
+
+export interface WebhookDiscordConfig {
+    enabled: boolean
+    url: string
+}
+
+export interface WebhookNtfyConfig {
+    enabled?: boolean
+    url: string
+    topic?: string
+    token?: string
+    title?: string
+    tags?: string[]
+    priority?: 1 | 2 | 3 | 4 | 5 // 5 highest (important)
 }

src/interface/GoogleDailyTrends.ts

@@ -1,44 +0,0 @@
-export interface GoogleTrends {
-    default: Default;
-}
-
-export interface Default {
-    trendingSearchesDays: TrendingSearchesDay[];
-    endDateForNextRequest: string;
-    rssFeedPageUrl: string;
-}
-
-export interface TrendingSearchesDay {
-    date: string;
-    formattedDate: string;
-    trendingSearches: TrendingSearch[];
-}
-
-export interface TrendingSearch {
-    title: Title;
-    formattedTraffic: string;
-    relatedQueries: Title[];
-    image: Image;
-    articles: Article[];
-    shareUrl: string;
-}
-
-export interface Article {
-    title: string;
-    timeAgo: string;
-    source: string;
-    image?: Image;
-    url: string;
-    snippet: string;
-}
-
-export interface Image {
-    newsUrl: string;
-    source: string;
-    imageUrl: string;
-}
-
-export interface Title {
-    query: string;
-    exploreLink: string;
-}

src/interface/OAuth.ts

@@ -1,9 +1,9 @@
 export interface OAuth {
-    access_token: string;
-    refresh_token: string;
-    scope: string;
-    expires_in: number;
-    ext_expires_in: number;
-    foci: string;
-    token_type: string;
-}
+    access_token: string
+    refresh_token: string
+    scope: string
+    expires_in: number
+    ext_expires_in: number
+    foci: string
+    token_type: string
+}

src/interface/Points.ts

@@ -1,7 +1,20 @@
-export interface EarnablePoints {
+export interface BrowserEarnablePoints {
     desktopSearchPoints: number
     mobileSearchPoints: number
     dailySetPoints: number
     morePromotionsPoints: number
     totalEarnablePoints: number
-}
+}
+
+export interface AppEarnablePoints {
+    readToEarn: number
+    checkIn: number
+    totalEarnablePoints: number
+}
+
+export interface MissingSearchPoints {
+    mobilePoints: number
+    desktopPoints: number
+    edgePoints: number
+    totalPoints: number
+}

src/interface/QuizData.ts

@@ -1,50 +1,50 @@
 export interface QuizData {
-    offerId: string;
-    quizId: string;
-    quizCategory: string;
-    IsCurrentQuestionCompleted: boolean;
-    quizRenderSummaryPage: boolean;
-    resetQuiz: boolean;
-    userClickedOnHint: boolean;
-    isDemoEnabled: boolean;
-    correctAnswer: string;
-    isMultiChoiceQuizType: boolean;
-    isPutInOrderQuizType: boolean;
-    isListicleQuizType: boolean;
-    isWOTQuizType: boolean;
-    isBugsForRewardsQuizType: boolean;
-    currentQuestionNumber: number;
-    maxQuestions: number;
-    resetTrackingCounters: boolean;
-    showWelcomePanel: boolean;
-    isAjaxCall: boolean;
-    showHint: boolean;
-    numberOfOptions: number;
-    isMobile: boolean;
-    inRewardsMode: boolean;
-    enableDailySetWelcomePane: boolean;
-    enableDailySetNonWelcomePane: boolean;
-    isDailySetUrlOffer: boolean;
-    isDailySetFlightEnabled: boolean;
-    dailySetUrlOfferId: string;
-    earnedCredits: number;
-    maxCredits: number;
-    creditsPerQuestion: number;
-    userAlreadyClickedOptions: number;
-    hasUserClickedOnOption: boolean;
-    recentAnswerChoice: string;
-    sessionTimerSeconds: string;
-    isOverlayMinimized: number;
-    ScreenReaderMsgOnMove: string;
-    ScreenReaderMsgOnDrop: string;
-    IsPartialPointsEnabled: boolean;
-    PrioritizeUrlOverCookies: boolean;
-    UseNewReportActivityAPI: boolean;
-    CorrectlyAnsweredQuestionCount: number;
-    showJoinRewardsPage: boolean;
-    CorrectOptionAnswer_WOT: string;
-    WrongOptionAnswer_WOT: string;
-    enableSlideAnimation: boolean;
-    ariaLoggingEnabled: boolean;
-    UseQuestionIndexInActivityId: boolean;
+    offerId: string
+    quizId: string
+    quizCategory: string
+    IsCurrentQuestionCompleted: boolean
+    quizRenderSummaryPage: boolean
+    resetQuiz: boolean
+    userClickedOnHint: boolean
+    isDemoEnabled: boolean
+    correctAnswer: string
+    isMultiChoiceQuizType: boolean
+    isPutInOrderQuizType: boolean
+    isListicleQuizType: boolean
+    isWOTQuizType: boolean
+    isBugsForRewardsQuizType: boolean
+    currentQuestionNumber: number
+    maxQuestions: number
+    resetTrackingCounters: boolean
+    showWelcomePanel: boolean
+    isAjaxCall: boolean
+    showHint: boolean
+    numberOfOptions: number
+    isMobile: boolean
+    inRewardsMode: boolean
+    enableDailySetWelcomePane: boolean
+    enableDailySetNonWelcomePane: boolean
+    isDailySetUrlOffer: boolean
+    isDailySetFlightEnabled: boolean
+    dailySetUrlOfferId: string
+    earnedCredits: number
+    maxCredits: number
+    creditsPerQuestion: number
+    userAlreadyClickedOptions: number
+    hasUserClickedOnOption: boolean
+    recentAnswerChoice: string
+    sessionTimerSeconds: string
+    isOverlayMinimized: number
+    ScreenReaderMsgOnMove: string
+    ScreenReaderMsgOnDrop: string
+    IsPartialPointsEnabled: boolean
+    PrioritizeUrlOverCookies: boolean
+    UseNewReportActivityAPI: boolean
+    CorrectlyAnsweredQuestionCount: number
+    showJoinRewardsPage: boolean
+    CorrectOptionAnswer_WOT: string
+    WrongOptionAnswer_WOT: string
+    enableSlideAnimation: boolean
+    ariaLoggingEnabled: boolean
+    UseQuestionIndexInActivityId: boolean
 }

src/interface/Search.ts

@@ -1,4 +1,96 @@
+// Google Trends
+export type GoogleTrendsResponse = [string, [string, ...null[], [string, ...string[]]][]]
+
 export interface GoogleSearch {
-    topic: string;
-    related: string[];
-}
+    topic: string
+    related: string[]
+}
+
+// Bing Suggestions
+export interface BingSuggestionResponse {
+    _type: string
+    instrumentation: BingInstrumentation
+    queryContext: BingQueryContext
+    suggestionGroups: BingSuggestionGroup[]
+}
+
+export interface BingInstrumentation {
+    _type: string
+    pingUrlBase: string
+    pageLoadPingUrl: string
+    llmPingUrlBase: string
+    llmLogPingUrlBase: string
+}
+
+export interface BingQueryContext {
+    originalQuery: string
+}
+
+export interface BingSuggestionGroup {
+    name: string
+    searchSuggestions: BingSearchSuggestion[]
+}
+
+export interface BingSearchSuggestion {
+    url: string
+    urlPingSuffix: string
+    displayText: string
+    query: string
+    result?: BingResult[]
+    searchKind?: string
+}
+
+export interface BingResult {
+    id: string
+    readLink: string
+    readLinkPingSuffix: string
+    webSearchUrl: string
+    webSearchUrlPingSuffix: string
+    name: string
+    image: BingSuggestionImage
+    description: string
+    entityPresentationInfo: BingEntityPresentationInfo
+    bingId: string
+}
+
+export interface BingEntityPresentationInfo {
+    entityScenario: string
+    entityTypeDisplayHint: string
+    query: string
+}
+
+export interface BingSuggestionImage {
+    thumbnailUrl: string
+    hostPageUrl: string
+    hostPageUrlPingSuffix: string
+    width: number
+    height: number
+    sourceWidth: number
+    sourceHeight: number
+}
+
+// Bing Tending Topics
+export interface BingTrendingTopicsResponse {
+    _type: string
+    instrumentation: BingInstrumentation
+    value: BingValue[]
+}
+
+export interface BingValue {
+    webSearchUrl: string
+    webSearchUrlPingSuffix: string
+    name: string
+    image: BingTrendingImage
+    isBreakingNews: boolean
+    query: BingTrendingQuery
+    newsSearchUrl: string
+    newsSearchUrlPingSuffix: string
+}
+
+export interface BingTrendingImage {
+    url: string
+}
+
+export interface BingTrendingQuery {
+    text: string
+}

src/interface/UserAgentUtil.ts

@@ -1,37 +1,37 @@
 // Chrome Product Data
 export interface ChromeVersion {
-    timestamp: Date;
-    channels: Channels;
+    timestamp: Date
+    channels: Channels
 }
 
 export interface Channels {
-    Stable: Beta;
-    Beta: Beta;
-    Dev: Beta;
-    Canary: Beta;
+    Stable: Beta
+    Beta: Beta
+    Dev: Beta
+    Canary: Beta
 }
 
 export interface Beta {
-    channel: string;
-    version: string;
-    revision: string;
+    channel: string
+    version: string
+    revision: string
 }
 
 // Edge Product Data
 export interface EdgeVersion {
-    Product: string;
-    Releases: Release[];
+    Product: string
+    Releases: Release[]
 }
 
 export interface Release {
-    ReleaseId: number;
-    Platform: Platform;
-    Architecture: Architecture;
-    CVEs: string[];
-    ProductVersion: string;
-    Artifacts: Artifact[];
-    PublishedTime: Date;
-    ExpectedExpiryDate: Date;
+    ReleaseId: number
+    Platform: Platform
+    Architecture: Architecture
+    CVEs: string[]
+    ProductVersion: string
+    Artifacts: Artifact[]
+    PublishedTime: Date
+    ExpectedExpiryDate: Date
 }
 
 export enum Architecture {
@@ -42,11 +42,11 @@ export enum Architecture {
 }
 
 export interface Artifact {
-    ArtifactName: string;
-    Location: string;
-    Hash: string;
-    HashAlgorithm: HashAlgorithm;
-    SizeInBytes: number;
+    ArtifactName: string
+    Location: string
+    Hash: string
+    HashAlgorithm: HashAlgorithm
+    SizeInBytes: number
 }
 
 export enum HashAlgorithm {
@@ -59,4 +59,4 @@ export enum Platform {
     Linux = 'Linux',
     MACOS = 'MacOS',
     Windows = 'Windows'
-}
+}

src/interface/XboxDashboardData.ts

@@ -0,0 +1,43 @@
+export interface XboxDashboardData {
+    response: Response
+    correlationId: string
+    code: number
+}
+
+export interface Response {
+    profile: null
+    balance: number
+    counters: { [key: string]: string }
+    promotions: Promotion[]
+    catalog: null
+    goal_item: null
+    activities: null
+    cashback: null
+    orders: null
+    rebateProfile: null
+    rebatePayouts: null
+    giveProfile: null
+    autoRedeemProfile: null
+    autoRedeemItem: null
+    thirdPartyProfile: null
+    notifications: null
+    waitlist: null
+    autoOpenFlyout: null
+    coupons: null
+    recommendedAffordableCatalog: null
+    generativeAICreditsBalance: null
+    requestCountryCatalog: null
+    donationCatalog: null
+}
+
+export interface Promotion {
+    name: string
+    priority: number
+    attributes: { [key: string]: string }
+    tags: Tag[]
+}
+
+export enum Tag {
+    ExcludeHidden = 'exclude_hidden',
+    NonGlobalConfig = 'non_global_config'
+}

src/logging/Discord.ts

@@ -0,0 +1,50 @@
+import axios, { AxiosRequestConfig } from 'axios'
+import PQueue from 'p-queue'
+import type { LogLevel } from './Logger'
+
+const DISCORD_LIMIT = 2000
+
+export interface DiscordConfig {
+    enabled?: boolean
+    url: string
+}
+
+const discordQueue = new PQueue({
+    interval: 1000,
+    intervalCap: 2,
+    carryoverConcurrencyCount: true
+})
+
+function truncate(text: string) {
+    return text.length <= DISCORD_LIMIT ? text : text.slice(0, DISCORD_LIMIT - 14) + ' …(truncated)'
+}
+
+export async function sendDiscord(discordUrl: string, content: string, level: LogLevel): Promise<void> {
+    if (!discordUrl) return
+
+    const request: AxiosRequestConfig = {
+        method: 'POST',
+        url: discordUrl,
+        headers: { 'Content-Type': 'application/json' },
+        data: { content: truncate(content), allowed_mentions: { parse: [] } },
+        timeout: 10000
+    }
+
+    await discordQueue.add(async () => {
+        try {
+            await axios(request)
+        } catch (err: any) {
+            const status = err?.response?.status
+            if (status === 429) return
+        }
+    })
+}
+
+export async function flushDiscordQueue(timeoutMs = 5000): Promise<void> {
+    await Promise.race([
+        (async () => {
+            await discordQueue.onIdle()
+        })(),
+        new Promise<void>((_, reject) => setTimeout(() => reject(new Error('discord flush timeout')), timeoutMs))
+    ]).catch(() => {})
+}

src/logging/Logger.ts

@@ -0,0 +1,189 @@
+import chalk from 'chalk'
+import cluster from 'cluster'
+import { sendDiscord } from './Discord'
+import { sendNtfy } from './Ntfy'
+import type { MicrosoftRewardsBot } from '../index'
+import { errorDiagnostic } from '../util/ErrorDiagnostic'
+import type { LogFilter } from '../interface/Config'
+
+export type Platform = boolean | 'main'
+export type LogLevel = 'info' | 'warn' | 'error' | 'debug'
+export type ColorKey = keyof typeof chalk
+export interface IpcLog {
+    content: string
+    level: LogLevel
+}
+
+type ChalkFn = (msg: string) => string
+
+function platformText(platform: Platform): string {
+    return platform === 'main' ? 'MAIN' : platform ? 'MOBILE' : 'DESKTOP'
+}
+
+function platformBadge(platform: Platform): string {
+    return platform === 'main' ? chalk.bgCyan('MAIN') : platform ? chalk.bgBlue('MOBILE') : chalk.bgMagenta('DESKTOP')
+}
+
+function getColorFn(color?: ColorKey): ChalkFn | null {
+    return color && typeof chalk[color] === 'function' ? (chalk[color] as ChalkFn) : null
+}
+
+function consoleOut(level: LogLevel, msg: string, chalkFn: ChalkFn | null): void {
+    const out = chalkFn ? chalkFn(msg) : msg
+    switch (level) {
+        case 'warn':
+            return console.warn(out)
+        case 'error':
+            return console.error(out)
+        default:
+            return console.log(out)
+    }
+}
+
+function formatMessage(message: string | Error): string {
+    return message instanceof Error ? `${message.message}\n${message.stack || ''}` : message
+}
+
+export class Logger {
+    constructor(private bot: MicrosoftRewardsBot) {}
+
+    info(isMobile: Platform, title: string, message: string, color?: ColorKey) {
+        return this.baseLog('info', isMobile, title, message, color)
+    }
+
+    warn(isMobile: Platform, title: string, message: string | Error, color?: ColorKey) {
+        return this.baseLog('warn', isMobile, title, message, color)
+    }
+
+    error(isMobile: Platform, title: string, message: string | Error, color?: ColorKey) {
+        return this.baseLog('error', isMobile, title, message, color)
+    }
+
+    debug(isMobile: Platform, title: string, message: string | Error, color?: ColorKey) {
+        return this.baseLog('debug', isMobile, title, message, color)
+    }
+
+    private baseLog(
+        level: LogLevel,
+        isMobile: Platform,
+        title: string,
+        message: string | Error,
+        color?: ColorKey
+    ): void {
+        const now = new Date().toLocaleString()
+        const formatted = formatMessage(message)
+
+        const levelTag = level.toUpperCase()
+        const cleanMsg = `[${now}] [${this.bot.userData.userName}] [${levelTag}] ${platformText(
+            isMobile
+        )} [${title}] ${formatted}`
+
+        const config = this.bot.config
+
+        if (level === 'debug' && !config.debugLogs && !process.argv.includes('-dev')) {
+            return
+        }
+
+        const badge = platformBadge(isMobile)
+        const consoleStr = `[${now}] [${this.bot.userData.userName}] [${levelTag}] ${badge} [${title}] ${formatted}`
+
+        let logColor: ColorKey | undefined = color
+
+        if (!logColor) {
+            switch (level) {
+                case 'error':
+                    logColor = 'red'
+                    break
+                case 'warn':
+                    logColor = 'yellow'
+                    break
+                case 'debug':
+                    logColor = 'magenta'
+                    break
+                default:
+                    break
+            }
+        }
+
+        if (level === 'error' && config.errorDiagnostics) {
+            const page = this.bot.isMobile ? this.bot.mainMobilePage : this.bot.mainDesktopPage
+            const error = message instanceof Error ? message : new Error(String(message))
+            errorDiagnostic(page, error)
+        }
+
+        const consoleAllowed = this.shouldPassFilter(config.consoleLogFilter, level, cleanMsg)
+        const webhookAllowed = this.shouldPassFilter(config.webhook.webhookLogFilter, level, cleanMsg)
+
+        if (consoleAllowed) {
+            consoleOut(level, consoleStr, getColorFn(logColor))
+        }
+
+        if (!webhookAllowed) {
+            return
+        }
+
+        if (cluster.isPrimary) {
+            if (config.webhook.discord?.enabled && config.webhook.discord.url) {
+                if (level === 'debug') return
+                sendDiscord(config.webhook.discord.url, cleanMsg, level)
+            }
+
+            if (config.webhook.ntfy?.enabled && config.webhook.ntfy.url) {
+                if (level === 'debug') return
+                sendNtfy(config.webhook.ntfy, cleanMsg, level)
+            }
+        } else {
+            process.send?.({ __ipcLog: { content: cleanMsg, level } })
+        }
+    }
+
+    private shouldPassFilter(filter: LogFilter | undefined, level: LogLevel, message: string): boolean {
+        // If disabled or not, let all logs pass
+        if (!filter || !filter.enabled) {
+            return true
+        }
+
+        // Always log error levelo logs, remove these lines to disable this!
+        if (level === 'error') {
+            return true
+        }
+
+        const { mode, levels, keywords, regexPatterns } = filter
+
+        const hasLevelRule = Array.isArray(levels) && levels.length > 0
+        const hasKeywordRule = Array.isArray(keywords) && keywords.length > 0
+        const hasPatternRule = Array.isArray(regexPatterns) && regexPatterns.length > 0
+
+        if (!hasLevelRule && !hasKeywordRule && !hasPatternRule) {
+            return mode === 'blacklist'
+        }
+
+        const lowerMessage = message.toLowerCase()
+        let isMatch = false
+
+        if (hasLevelRule && levels!.includes(level)) {
+            isMatch = true
+        }
+
+        if (!isMatch && hasKeywordRule) {
+            if (keywords!.some(k => lowerMessage.includes(k.toLowerCase()))) {
+                isMatch = true
+            }
+        }
+
+        // Fancy regex filtering if set!
+        if (!isMatch && hasPatternRule) {
+            for (const pattern of regexPatterns!) {
+                try {
+                    const regex = new RegExp(pattern, 'i')
+                    if (regex.test(message)) {
+                        isMatch = true
+                        break
+                    }
+                } catch {}
+            }
+        }
+
+        return mode === 'whitelist' ? isMatch : !isMatch
+    }
+}

src/logging/Ntfy.ts

@@ -0,0 +1,61 @@
+import axios, { AxiosRequestConfig } from 'axios'
+import PQueue from 'p-queue'
+import type { WebhookNtfyConfig } from '../interface/Config'
+import type { LogLevel } from './Logger'
+
+const ntfyQueue = new PQueue({
+    interval: 1000,
+    intervalCap: 2,
+    carryoverConcurrencyCount: true
+})
+
+export async function sendNtfy(config: WebhookNtfyConfig, content: string, level: LogLevel): Promise<void> {
+    if (!config?.url) return
+
+    switch (level) {
+        case 'error':
+            config.priority = 5 // Highest
+            break
+
+        case 'warn':
+            config.priority = 4
+            break
+
+        default:
+            break
+    }
+
+    const headers: Record<string, string> = { 'Content-Type': 'text/plain' }
+    if (config.title) headers['Title'] = config.title
+    if (config.tags?.length) headers['Tags'] = config.tags.join(',')
+    if (config.priority) headers['Priority'] = String(config.priority)
+    if (config.token) headers['Authorization'] = `Bearer ${config.token}`
+
+    const url = config.topic ? `${config.url}/${config.topic}` : config.url
+
+    const request: AxiosRequestConfig = {
+        method: 'POST',
+        url: url,
+        headers,
+        data: content,
+        timeout: 10000
+    }
+
+    await ntfyQueue.add(async () => {
+        try {
+            await axios(request)
+        } catch (err: any) {
+            const status = err?.response?.status
+            if (status === 429) return
+        }
+    })
+}
+
+export async function flushNtfyQueue(timeoutMs = 5000): Promise<void> {
+    await Promise.race([
+        (async () => {
+            await ntfyQueue.onIdle()
+        })(),
+        new Promise<void>((_, reject) => setTimeout(() => reject(new Error('ntfy flush timeout')), timeoutMs))
+    ]).catch(() => {})
+}

src/util/Axios.ts

@@ -1,8 +1,9 @@
 import axios, { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios'
+import axiosRetry from 'axios-retry'
 import { HttpProxyAgent } from 'http-proxy-agent'
 import { HttpsProxyAgent } from 'https-proxy-agent'
-import { SocksProxyAgent } from 'socks-proxy-agent'
-import { AccountProxy } from '../interface/Account'
+import { URL } from 'url'
+import type { AccountProxy } from '../interface/Account'
 
 class AxiosClient {
     private instance: AxiosInstance
@@ -10,35 +11,74 @@ class AxiosClient {
 
     constructor(account: AccountProxy) {
         this.account = account
-        this.instance = axios.create()
 
-        // If a proxy configuration is provided, set up the agent
+        this.instance = axios.create({
+            timeout: 20000
+        })
+
         if (this.account.url && this.account.proxyAxios) {
             const agent = this.getAgentForProxy(this.account)
             this.instance.defaults.httpAgent = agent
             this.instance.defaults.httpsAgent = agent
         }
+
+        axiosRetry(this.instance, {
+            retries: 5,
+            retryDelay: axiosRetry.exponentialDelay,
+            shouldResetTimeout: true,
+            retryCondition: error => {
+                if (axiosRetry.isNetworkError(error)) return true
+                if (!error.response) return true
+
+                const status = error.response.status
+                return status === 429 || (status >= 500 && status <= 599)
+            }
+        })
     }
 
-    private getAgentForProxy(proxyConfig: AccountProxy): HttpProxyAgent<string> | HttpsProxyAgent<string> | SocksProxyAgent {
-        const { url, port } = proxyConfig
+    private getAgentForProxy(proxyConfig: AccountProxy): HttpProxyAgent<string> | HttpsProxyAgent<string> {
+        const { url: baseUrl, port, username, password } = proxyConfig
 
-        switch (true) {
-            case proxyConfig.url.startsWith('http'):
-                return new HttpProxyAgent(`${url}:${port}`)
-            case proxyConfig.url.startsWith('https'):
-                return new HttpsProxyAgent(`${url}:${port}`)
-            case proxyConfig.url.startsWith('socks'):
-                return new SocksProxyAgent(`${url}:${port}`)
+        let urlObj: URL
+        try {
+            urlObj = new URL(baseUrl)
+        } catch (e) {
+            try {
+                urlObj = new URL(`http://${baseUrl}`)
+            } catch (error) {
+                throw new Error(`Invalid proxy URL format: ${baseUrl}`)
+            }
+        }
+
+        const protocol = urlObj.protocol.toLowerCase()
+        let proxyUrl: string
+
+        if (username && password) {
+            urlObj.username = encodeURIComponent(username)
+            urlObj.password = encodeURIComponent(password)
+            urlObj.port = port.toString()
+            proxyUrl = urlObj.toString()
+        } else {
+            proxyUrl = `${protocol}//${urlObj.hostname}:${port}`
+        }
+
+        switch (protocol) {
+            case 'http:':
+                return new HttpProxyAgent(proxyUrl)
+            case 'https:':
+                return new HttpsProxyAgent(proxyUrl)
             default:
-                throw new Error(`Unsupported proxy protocol: ${url}`)
+                throw new Error(`Unsupported proxy protocol: ${protocol}. Only HTTP(S) is supported!`)
         }
     }
 
-    // Generic method to make any Axios request
     public async request(config: AxiosRequestConfig, bypassProxy = false): Promise<AxiosResponse> {
         if (bypassProxy) {
             const bypassInstance = axios.create()
+            axiosRetry(bypassInstance, {
+                retries: 3,
+                retryDelay: axiosRetry.exponentialDelay
+            })
             return bypassInstance.request(config)
         }
 
@@ -46,4 +86,4 @@ class AxiosClient {
     }
 }
 
-export default AxiosClient
+export default AxiosClient

src/util/ConclusionWebhook.ts

@@ -1,32 +0,0 @@
-import axios from 'axios'
-
-import { Config } from '../interface/Config'
-
-interface ConclusionPayload {
-    content?: string
-    embeds?: any[]
-}
-
-/**
- * Send a final structured summary to the dedicated conclusion webhook (if enabled),
- * otherwise do nothing. Does NOT fallback to the normal logging webhook to avoid spam.
- */
-export async function ConclusionWebhook(configData: Config, content: string, embed?: ConclusionPayload) {
-    const webhook = configData.conclusionWebhook
-
-    if (!webhook || !webhook.enabled || webhook.url.length < 10) return
-
-    const body: ConclusionPayload = embed?.embeds ? { embeds: embed.embeds } : { content }
-    if (content && !body.content && !body.embeds) body.content = content
-
-    const request = {
-        method: 'POST',
-        url: webhook.url,
-        headers: {
-            'Content-Type': 'application/json'
-        },
-        data: body
-    }
-
-    await axios(request).catch(() => { })
-}

src/util/ErrorDiagnostic.ts

@@ -0,0 +1,46 @@
+import fs from 'fs/promises'
+import path from 'path'
+import type { Page } from 'patchright'
+
+export async function errorDiagnostic(page: Page, error: Error): Promise<void> {
+    try {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-')
+        const folderName = `error-${timestamp}`
+        const outputDir = path.join(process.cwd(), 'diagnostics', folderName)
+
+        if (!page) {
+            return
+        }
+
+        if (page.isClosed()) {
+            return
+        }
+
+        // Error log content
+        const errorLog = `
+Name: ${error.name}
+Message: ${error.message}
+Timestamp: ${new Date().toISOString()}
+---------------------------------------------------
+Stack Trace:
+${error.stack || 'No stack trace available'}
+        `.trim()
+
+        const [htmlContent, screenshotBuffer] = await Promise.all([
+            page.content(),
+            page.screenshot({ fullPage: true, type: 'png' })
+        ])
+
+        await fs.mkdir(outputDir, { recursive: true })
+
+        await Promise.all([
+            fs.writeFile(path.join(outputDir, 'dump.html'), htmlContent),
+            fs.writeFile(path.join(outputDir, 'screenshot.png'), screenshotBuffer),
+            fs.writeFile(path.join(outputDir, 'error.txt'), errorLog)
+        ])
+
+        console.log(`Diagnostics saved to: ${outputDir}`)
+    } catch (error) {
+        console.error('Unable to create error diagnostics:', error)
+    }
+}

src/util/Load.ts

@@ -1,11 +1,10 @@
-import { BrowserContext, Cookie } from 'rebrowser-playwright'
-import { BrowserFingerprintWithHeaders } from 'fingerprint-generator'
+import type { Cookie } from 'patchright'
+import type { BrowserFingerprintWithHeaders } from 'fingerprint-generator'
 import fs from 'fs'
 import path from 'path'
 
-
-import { Account } from '../interface/Account'
-import { Config, ConfigSaveFingerprint } from '../interface/Config'
+import type { Account } from '../interface/Account'
+import type { Config, ConfigSaveFingerprint } from '../interface/Config'
 
 let configCache: Config
 
@@ -13,7 +12,6 @@ export function loadAccounts(): Account[] {
     try {
         let file = 'accounts.json'
 
-        // If dev mode, use dev account(s)
         if (process.argv.includes('-dev')) {
             file = 'accounts.dev.json'
         }
@@ -37,7 +35,7 @@ export function loadConfig(): Config {
         const config = fs.readFileSync(configDir, 'utf-8')
 
         const configData = JSON.parse(config)
-        configCache = configData // Set as cache
+        configCache = configData
 
         return configData
     } catch (error) {
@@ -45,10 +43,15 @@ export function loadConfig(): Config {
     }
 }
 
-export async function loadSessionData(sessionPath: string, email: string, isMobile: boolean, saveFingerprint: ConfigSaveFingerprint) {
+export async function loadSessionData(
+    sessionPath: string,
+    email: string,
+    saveFingerprint: ConfigSaveFingerprint,
+    isMobile: boolean
+) {
     try {
-        // Fetch cookie file
-        const cookieFile = path.join(__dirname, '../browser/', sessionPath, email, `${isMobile ? 'mobile_cookies' : 'desktop_cookies'}.json`)
+        const cookiesFileName = isMobile ? 'session_mobile.json' : 'session_desktop.json'
+        const cookieFile = path.join(__dirname, '../browser/', sessionPath, email, cookiesFileName)
 
         let cookies: Cookie[] = []
         if (fs.existsSync(cookieFile)) {
@@ -56,11 +59,12 @@ export async function loadSessionData(sessionPath: string, email: string, isMobi
             cookies = JSON.parse(cookiesData)
         }
 
-        // Fetch fingerprint file
-        const fingerprintFile = path.join(__dirname, '../browser/', sessionPath, email, `${isMobile ? 'mobile_fingerpint' : 'desktop_fingerpint'}.json`)
+        const fingerprintFileName = isMobile ? 'session_fingerprint_mobile.json' : 'session_fingerprint_desktop.json'
+        const fingerprintFile = path.join(__dirname, '../browser/', sessionPath, email, fingerprintFileName)
 
         let fingerprint!: BrowserFingerprintWithHeaders
-        if (((saveFingerprint.desktop && !isMobile) || (saveFingerprint.mobile && isMobile)) && fs.existsSync(fingerprintFile)) {
+        const shouldLoadFingerprint = isMobile ? saveFingerprint.mobile : saveFingerprint.desktop
+        if (shouldLoadFingerprint && fs.existsSync(fingerprintFile)) {
             const fingerprintData = await fs.promises.readFile(fingerprintFile, 'utf-8')
             fingerprint = JSON.parse(fingerprintData)
         }
@@ -69,26 +73,26 @@ export async function loadSessionData(sessionPath: string, email: string, isMobi
             cookies: cookies,
             fingerprint: fingerprint
         }
-
     } catch (error) {
         throw new Error(error as string)
     }
 }
 
-export async function saveSessionData(sessionPath: string, browser: BrowserContext, email: string, isMobile: boolean): Promise<string> {
+export async function saveSessionData(
+    sessionPath: string,
+    cookies: Cookie[],
+    email: string,
+    isMobile: boolean
+): Promise<string> {
     try {
-        const cookies = await browser.cookies()
-
-        // Fetch path
         const sessionDir = path.join(__dirname, '../browser/', sessionPath, email)
+        const cookiesFileName = isMobile ? 'session_mobile.json' : 'session_desktop.json'
 
-        // Create session dir
         if (!fs.existsSync(sessionDir)) {
             await fs.promises.mkdir(sessionDir, { recursive: true })
         }
 
-        // Save cookies to a file
-        await fs.promises.writeFile(path.join(sessionDir, `${isMobile ? 'mobile_cookies' : 'desktop_cookies'}.json`), JSON.stringify(cookies))
+        await fs.promises.writeFile(path.join(sessionDir, cookiesFileName), JSON.stringify(cookies))
 
         return sessionDir
     } catch (error) {
@@ -96,21 +100,24 @@ export async function saveSessionData(sessionPath: string, browser: BrowserConte
     }
 }
 
-export async function saveFingerprintData(sessionPath: string, email: string, isMobile: boolean, fingerpint: BrowserFingerprintWithHeaders): Promise<string> {
+export async function saveFingerprintData(
+    sessionPath: string,
+    email: string,
+    isMobile: boolean,
+    fingerpint: BrowserFingerprintWithHeaders
+): Promise<string> {
     try {
-        // Fetch path
         const sessionDir = path.join(__dirname, '../browser/', sessionPath, email)
+        const fingerprintFileName = isMobile ? 'session_fingerprint_mobile.json' : 'session_fingerprint_desktop.json'
 
-        // Create session dir
         if (!fs.existsSync(sessionDir)) {
             await fs.promises.mkdir(sessionDir, { recursive: true })
         }
 
-        // Save fingerprint to a file
-        await fs.promises.writeFile(path.join(sessionDir, `${isMobile ? 'mobile_fingerpint' : 'desktop_fingerpint'}.json`), JSON.stringify(fingerpint))
+        await fs.promises.writeFile(path.join(sessionDir, fingerprintFileName), JSON.stringify(fingerpint))
 
         return sessionDir
     } catch (error) {
         throw new Error(error as string)
     }
-}
+}

src/util/Logger.ts

@@ -1,45 +0,0 @@
-import chalk from 'chalk'
-
-import { Webhook } from './Webhook'
-import { loadConfig } from './Load'
-
-
-export function log(isMobile: boolean | 'main', title: string, message: string, type: 'log' | 'warn' | 'error' = 'log', color?: keyof typeof chalk): void {
-    const configData = loadConfig()
-
-    if (configData.logExcludeFunc.some(x => x.toLowerCase() === title.toLowerCase())) {
-        return
-    }
-
-    const currentTime = new Date().toLocaleString()
-    const platformText = isMobile === 'main' ? 'MAIN' : isMobile ? 'MOBILE' : 'DESKTOP'
-    const chalkedPlatform = isMobile === 'main' ? chalk.bgCyan('MAIN') : isMobile ? chalk.bgBlue('MOBILE') : chalk.bgMagenta('DESKTOP')
-
-    // Clean string for the Webhook (no chalk)
-    const cleanStr = `[${currentTime}] [PID: ${process.pid}] [${type.toUpperCase()}] ${platformText} [${title}] ${message}`
-
-    // Send the clean string to the Webhook
-    if (!configData.webhookLogExcludeFunc.some(x => x.toLowerCase() === title.toLowerCase())) {
-        Webhook(configData, cleanStr)
-    }
-
-    // Formatted string with chalk for terminal logging
-    const str = `[${currentTime}] [PID: ${process.pid}] [${type.toUpperCase()}] ${chalkedPlatform} [${title}] ${message}`
-
-    const applyChalk = color && typeof chalk[color] === 'function' ? chalk[color] as (msg: string) => string : null
-
-    // Log based on the type
-    switch (type) {
-        case 'warn':
-            applyChalk ? console.warn(applyChalk(str)) : console.warn(str)
-            break
-
-        case 'error':
-            applyChalk ? console.error(applyChalk(str)) : console.error(str)
-            break
-
-        default:
-            applyChalk ? console.log(applyChalk(str)) : console.log(str)
-            break
-    }
-}

src/util/UserAgent.ts

@@ -1,143 +0,0 @@
-import axios from 'axios'
-import { BrowserFingerprintWithHeaders } from 'fingerprint-generator'
-
-import { log } from './Logger'
-
-import { ChromeVersion, EdgeVersion } from '../interface/UserAgentUtil'
-
-const NOT_A_BRAND_VERSION = '99'
-
-export async function getUserAgent(isMobile: boolean) {
-    const system = getSystemComponents(isMobile)
-    const app = await getAppComponents(isMobile)
-
-    const uaTemplate = isMobile ?
-        `Mozilla/5.0 (${system}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${app.chrome_reduced_version} Mobile Safari/537.36 EdgA/${app.edge_version}` :
-        `Mozilla/5.0 (${system}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${app.chrome_reduced_version} Safari/537.36 Edg/${app.edge_version}`
-
-    const platformVersion = `${isMobile ? Math.floor(Math.random() * 5) + 9 : Math.floor(Math.random() * 15) + 1}.0.0`
-
-    const uaMetadata = {
-        isMobile,
-        platform: isMobile ? 'Android' : 'Windows',
-        fullVersionList: [
-            { brand: 'Not/A)Brand', version: `${NOT_A_BRAND_VERSION}.0.0.0` },
-            { brand: 'Microsoft Edge', version: app['edge_version'] },
-            { brand: 'Chromium', version: app['chrome_version'] }
-        ],
-        brands: [
-            { brand: 'Not/A)Brand', version: NOT_A_BRAND_VERSION },
-            { brand: 'Microsoft Edge', version: app['edge_major_version'] },
-            { brand: 'Chromium', version: app['chrome_major_version'] }
-        ],
-        platformVersion,
-        architecture: isMobile ? '' : 'x86',
-        bitness: isMobile ? '' : '64',
-        model: ''
-    }
-
-    return { userAgent: uaTemplate, userAgentMetadata: uaMetadata }
-}
-
-export async function getChromeVersion(isMobile: boolean): Promise<string> {
-    try {
-        const request = {
-            url: 'https://googlechromelabs.github.io/chrome-for-testing/last-known-good-versions.json',
-            method: 'GET',
-            headers: {
-                'Content-Type': 'application/json'
-            }
-        }
-
-        const response = await axios(request)
-        const data: ChromeVersion = response.data
-        return data.channels.Stable.version
-
-    } catch (error) {
-        throw log(isMobile, 'USERAGENT-CHROME-VERSION', 'An error occurred:' + error, 'error')
-    }
-}
-
-export async function getEdgeVersions(isMobile: boolean) {
-    try {
-        const request = {
-            url: 'https://edgeupdates.microsoft.com/api/products',
-            method: 'GET',
-            headers: {
-                'Content-Type': 'application/json'
-            }
-        }
-
-        const response = await axios(request)
-        const data: EdgeVersion[] = response.data
-        const stable = data.find(x => x.Product == 'Stable') as EdgeVersion
-        return {
-            android: stable.Releases.find(x => x.Platform == 'Android')?.ProductVersion,
-            windows: stable.Releases.find(x => (x.Platform == 'Windows' && x.Architecture == 'x64'))?.ProductVersion
-        }
-
-
-    } catch (error) {
-        throw log(isMobile, 'USERAGENT-EDGE-VERSION', 'An error occurred:' + error, 'error')
-    }
-}
-
-export function getSystemComponents(mobile: boolean): string {
-    const osId: string = mobile ? 'Linux' : 'Windows NT 10.0'
-    const uaPlatform: string = mobile ? `Android 1${Math.floor(Math.random() * 5)}` : 'Win64; x64'
-
-    if (mobile) {
-        return `${uaPlatform}; ${osId}; K`
-    }
-
-    return `${uaPlatform}; ${osId}`
-}
-
-export async function getAppComponents(isMobile: boolean) {
-    const versions = await getEdgeVersions(isMobile)
-    const edgeVersion = isMobile ? versions.android : versions.windows as string
-    const edgeMajorVersion = edgeVersion?.split('.')[0]
-
-    const chromeVersion = await getChromeVersion(isMobile)
-    const chromeMajorVersion = chromeVersion?.split('.')[0]
-    const chromeReducedVersion = `${chromeMajorVersion}.0.0.0`
-
-    return {
-        not_a_brand_version: `${NOT_A_BRAND_VERSION}.0.0.0`,
-        not_a_brand_major_version: NOT_A_BRAND_VERSION,
-        edge_version: edgeVersion as string,
-        edge_major_version: edgeMajorVersion as string,
-        chrome_version: chromeVersion as string,
-        chrome_major_version: chromeMajorVersion as string,
-        chrome_reduced_version: chromeReducedVersion as string
-    }
-}
-
-export async function updateFingerprintUserAgent(fingerprint: BrowserFingerprintWithHeaders, isMobile: boolean): Promise<BrowserFingerprintWithHeaders> {
-    try {
-        const userAgentData = await getUserAgent(isMobile)
-        const componentData = await getAppComponents(isMobile)
-
-        //@ts-expect-error Errors due it not exactly matching
-        fingerprint.fingerprint.navigator.userAgentData = userAgentData.userAgentMetadata
-        fingerprint.fingerprint.navigator.userAgent = userAgentData.userAgent
-        fingerprint.fingerprint.navigator.appVersion = userAgentData.userAgent.replace(`${fingerprint.fingerprint.navigator.appCodeName}/`, '')
-
-        fingerprint.headers['user-agent'] = userAgentData.userAgent
-        fingerprint.headers['sec-ch-ua'] = `"Microsoft Edge";v="${componentData.edge_major_version}", "Not=A?Brand";v="${componentData.not_a_brand_major_version}", "Chromium";v="${componentData.chrome_major_version}"`
-        fingerprint.headers['sec-ch-ua-full-version-list'] = `"Microsoft Edge";v="${componentData.edge_version}", "Not=A?Brand";v="${componentData.not_a_brand_version}", "Chromium";v="${componentData.chrome_version}"`
-
-        /*
-        Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Mobile Safari/537.36 EdgA/129.0.0.0
-        sec-ch-ua-full-version-list: "Microsoft Edge";v="129.0.2792.84", "Not=A?Brand";v="8.0.0.0", "Chromium";v="129.0.6668.90"
-        sec-ch-ua: "Microsoft Edge";v="129", "Not=A?Brand";v="8", "Chromium";v="129"
-
-        Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36
-        "Google Chrome";v="129.0.6668.90", "Not=A?Brand";v="8.0.0.0", "Chromium";v="129.0.6668.90"
-        */
-
-        return fingerprint
-    } catch (error) {
-        throw log(isMobile, 'USER-AGENT-UPDATE', 'An error occurred:' + error, 'error')
-    }
-}

src/util/Utils.ts

@@ -1,16 +1,19 @@
-import ms from 'ms'
+import ms, { StringValue } from 'ms'
 
 export default class Util {
+    async wait(time: number | string): Promise<void> {
+        if (typeof time === 'string') {
+            time = this.stringToNumber(time)
+        }
 
-    async wait(ms: number): Promise<void> {
-        return new Promise<void>((resolve) => {
-            setTimeout(resolve, ms)
+        return new Promise<void>(resolve => {
+            setTimeout(resolve, time)
         })
     }
 
     getFormattedDate(ms = Date.now()): string {
         const today = new Date(ms)
-        const month = String(today.getMonth() + 1).padStart(2, '0')  // January is 0
+        const month = String(today.getMonth() + 1).padStart(2, '0') // January is 0
         const day = String(today.getDate()).padStart(2, '0')
         const year = today.getFullYear()
 
@@ -18,7 +21,8 @@ export default class Util {
     }
 
     shuffleArray<T>(array: T[]): T[] {
-        return array.map(value => ({ value, sort: Math.random() }))
+        return array
+            .map(value => ({ value, sort: Math.random() }))
             .sort((a, b) => a.sort - b.sort)
             .map(({ value }) => value)
     }
@@ -39,12 +43,39 @@ export default class Util {
         return chunks
     }
 
-    stringToMs(input: string | number): number {
-        const milisec = ms(input.toString())
-        if (!milisec) {
-            throw new Error('The string provided cannot be parsed to a valid time! Use a format like "1 min", "1m" or "1 minutes"')
+    stringToNumber(input: string | number): number {
+        if (typeof input === 'number') {
+            return input
         }
+        const value = input.trim()
+
+        const milisec = ms(value as StringValue)
+
+        if (milisec === undefined) {
+            throw new Error(
+                `The input provided (${input}) cannot be parsed to a valid time! Use a format like "1 min", "1m" or "1 minutes"`
+            )
+        }
+
         return milisec
     }
 
-}
+    normalizeString(string: string): string {
+        return string
+            .normalize('NFD')
+            .trim()
+            .toLowerCase()
+            .replace(/[^\x20-\x7E]/g, '')
+            .replace(/[?!]/g, '')
+    }
+
+    getEmailUsername(email: string): string {
+        return email.split('@')[0] ?? 'Unknown'
+    }
+
+    randomDelay(min: string | number, max: string | number): number {
+        const minMs = typeof min === 'number' ? min : this.stringToNumber(min)
+        const maxMs = typeof max === 'number' ? max : this.stringToNumber(max)
+        return Math.floor(this.randomNumber(minMs, maxMs))
+    }
+}

src/util/Webhook.ts

@@ -1,23 +0,0 @@
-import axios from 'axios'
-
-
-import { Config } from '../interface/Config'
-
-export async function Webhook(configData: Config, content: string) {
-    const webhook = configData.webhook
-
-    if (!webhook.enabled || webhook.url.length < 10) return
-
-    const request = {
-        method: 'POST',
-        url: webhook.url,
-        headers: {
-            'Content-Type': 'application/json'
-        },
-        data: {
-            'content': content
-        }
-    }
-
-    await axios(request).catch(() => { })
-}

tsconfig.json

@@ -2,18 +2,18 @@
     "compilerOptions": {
         /* Visit https://aka.ms/tsconfig.json to read more about this file */
         /* Basic Options */
-        "target": "ES2020", /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', 'ES2021', or 'ESNEXT'. */
-        "module": "commonjs", /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */
+        "target": "ES2020" /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', 'ES2021', or 'ESNEXT'. */,
+        "module": "commonjs" /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */,
         // "lib": [], /* Specify library files to be included in the compilation. */
         // "allowJs": true,                             /* Allow javascript files to be compiled. */
         // "checkJs": true,                             /* Report errors in .js files. */
         // "jsx": "preserve",                           /* Specify JSX code generation: 'preserve', 'react-native', 'react', 'react-jsx' or 'react-jsxdev'. */
-        "declaration": true, /* Generates corresponding '.d.ts' file. */
-        "declarationMap": true, /* Generates a sourcemap for each corresponding '.d.ts' file. */
-        "sourceMap": true, /* Generates corresponding '.map' file. */
+        "declaration": true /* Generates corresponding '.d.ts' file. */,
+        "declarationMap": true /* Generates a sourcemap for each corresponding '.d.ts' file. */,
+        "sourceMap": true /* Generates corresponding '.map' file. */,
         // "outFile": "./",                             /* Concatenate and emit output to single file. */
-        "outDir": "./dist", /* Redirect output structure to the directory. */
-        "rootDir": "./src", /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
+        "outDir": "./dist" /* Redirect output structure to the directory. */,
+        "rootDir": "./src" /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */,
         // "composite": true,                           /* Enable project compilation */
         // "tsBuildInfoFile": "./",                     /* Specify file to store incremental compilation information */
         // "removeComments": true,                      /* Do not emit comments to output. */
@@ -22,34 +22,34 @@
         // "downlevelIteration": true,                  /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
         // "isolatedModules": true,                     /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
         /* Strict Type-Checking Options */
-        "strict": true, /* Enable all strict type-checking options. */
-        "noImplicitAny": true, /* Raise error on expressions and declarations with an implied 'any' type. */
-        "strictNullChecks": true, /* Enable strict null checks. */
-        "strictFunctionTypes": true, /* Enable strict checking of function types. */
+        "strict": true /* Enable all strict type-checking options. */,
+        "noImplicitAny": true /* Raise error on expressions and declarations with an implied 'any' type. */,
+        "strictNullChecks": true /* Enable strict null checks. */,
+        "strictFunctionTypes": true /* Enable strict checking of function types. */,
         // "strictBindCallApply": true,                 /* Enable strict 'bind', 'call', and 'apply' methods on functions. */
         // "strictPropertyInitialization": true,        /* Enable strict checking of property initialization in classes. */
-        "noImplicitThis": true, /* Raise error on 'this' expressions with an implied 'any' type. */
-        "alwaysStrict": true, /* Parse in strict mode and emit "use strict" for each source file. */
+        "noImplicitThis": true /* Raise error on 'this' expressions with an implied 'any' type. */,
+        "alwaysStrict": true /* Parse in strict mode and emit "use strict" for each source file. */,
         /* Additional Checks */
-        "noUnusedLocals": true, /* Report errors on unused locals. */
+        "noUnusedLocals": true /* Report errors on unused locals. */,
         // "noUnusedParameters": true,                  /* Report errors on unused parameters. */
-        "noImplicitReturns": true, /* Report error when not all code paths in function return a value. */
-        "noFallthroughCasesInSwitch": true, /* Report errors for fallthrough cases in switch statement. */
-        "noUncheckedIndexedAccess": true, /* Include 'undefined' in index signature results */
-        "noImplicitOverride": true, /* Ensure overriding members in derived classes are marked with an 'override' modifier. */
+        "noImplicitReturns": true /* Report error when not all code paths in function return a value. */,
+        "noFallthroughCasesInSwitch": true /* Report errors for fallthrough cases in switch statement. */,
+        "noUncheckedIndexedAccess": true /* Include 'undefined' in index signature results */,
+        "noImplicitOverride": true /* Ensure overriding members in derived classes are marked with an 'override' modifier. */,
         // "noPropertyAccessFromIndexSignature": true,  /* Require undeclared properties from index signatures to use element accesses. */
         /* Module Resolution Options */
-    "moduleResolution":"node", /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
-    "types": ["node"],
-    "typeRoots": ["./node_modules/@types"],
-    // Keep explicit typeRoots to ensure resolution in environments that don't auto-detect before full install.
+        "moduleResolution": "node" /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */,
+        "types": ["node"],
+        "typeRoots": ["./node_modules/@types"],
+        // Keep explicit typeRoots to ensure resolution in environments that don't auto-detect before full install.
         // "baseUrl": "./",                             /* Base directory to resolve non-absolute module names. */
         // "paths": {},                                 /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
         // "rootDirs": [],                              /* List of root folders whose combined content represents the structure of the project at runtime. */
         // "typeRoots": [],                             /* List of folders to include type definitions from. */
         // "types": [],                                 /* Type declaration files to be included in compilation. */
         // "allowSyntheticDefaultImports": true,        /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
-        "esModuleInterop": true, /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
+        "esModuleInterop": true /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */,
         // "preserveSymlinks": true,                    /* Do not resolve the real path of symlinks. */
         // "allowUmdGlobalAccess": true,                /* Allow accessing UMD globals from modules. */
         /* Source Map Options */
@@ -61,17 +61,10 @@
         // "experimentalDecorators": true,              /* Enables experimental support for ES7 decorators. */
         // "emitDecoratorMetadata": true,               /* Enables experimental support for emitting type metadata for decorators. */
         /* Advanced Options */
-        "skipLibCheck": true, /* Skip type checking of declaration files. */
-        "forceConsistentCasingInFileNames": true, /* Disallow inconsistently-cased references to the same file. */
+        "skipLibCheck": true /* Skip type checking of declaration files. */,
+        "forceConsistentCasingInFileNames": true /* Disallow inconsistently-cased references to the same file. */,
         "resolveJsonModule": true
     },
-    "include": [
-        "src/**/*.ts",
-        "src/accounts.json",
-        "src/config.json",
-        "src/functions/queries.json"
-    ],
-    "exclude": [
-        "node_modules"
-    ]
-}
+    "include": ["src/**/*.ts", "src/accounts.json", "src/config.json", "src/functions/queries.json"],
+    "exclude": ["node_modules"]
+}