Update URL to fetch queries from v1 branch

.dockerignore

@@ -1,2 +0,0 @@
-dist
-node_modules

.eslintrc.js

@@ -1,28 +1,40 @@
 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'],
-        quotes: ['error', 'single'],
-        semi: ['error', 'never'],
-        '@typescript-eslint/no-explicit-any': [
-            'warn',
-            {
-                fixToUnknown: false
-            }
+    'plugins': [
+        '@typescript-eslint'
+    ],
+    'rules': {
+        'linebreak-style': [
+            'error',
+            'unix'
         ],
+        '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',
-        'no-empty': 'off'
+        'prefer-arrow-callback': 'error'
+        // Add any other rules you want to enforce here
     }
-}
+}

.github/workflows/docker-release.yml

@@ -1,51 +0,0 @@
-name: Build and Push Docker Image on Release
-
-on:
-  release:
-    types: [published]
-  workflow_dispatch:
-
-env:
-  REGISTRY: ghcr.io
-  IMAGE_NAME: ${{ github.repository }}
-
-jobs:
-  build-and-push:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
-      - name: Log in to GitHub Container Registry
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.REGISTRY }}
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Extract metadata
-        id: meta
-        uses: docker/metadata-action@v5
-        with:
-          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
-          tags: |
-            type=semver,pattern={{version}}
-            type=semver,pattern={{major}}.{{minor}}
-            type=raw,value=latest,enable={{is_default_branch}}
-
-      - name: Build and push Docker image
-        uses: docker/build-push-action@v5
-        with:
-          context: .
-          push: true
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
-          cache-from: type=gha
-          cache-to: type=gha,mode=max

.gitignore

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

.prettierrc

@@ -1,11 +0,0 @@
-{
-    "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 patchright install --with-deps --only-shell chromium \
+RUN npx playwright 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 scripts/docker/run_daily.sh ./scripts/docker/run_daily.sh
+COPY --chmod=755 src/run_daily.sh ./src/run_daily.sh
 COPY --chmod=644 src/crontab.template /etc/cron.d/microsoft-rewards-cron.template
-COPY --chmod=755 scripts/docker/entrypoint.sh /usr/local/bin/entrypoint.sh
+COPY --chmod=755 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,9 +2,296 @@
 
 ---
 
-TODO
+## 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)
 
-[For installation see the main (v1) or v2 branch (mostly the same)](https://github.com/TheNetsky/Microsoft-Rewards-Script/tree/main?tab=readme-ov-file#setup)
+---
+
+## 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  
+
+---
 
 ## 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 * * *' # 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,16,20 * * *" # 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

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 scripts/docker/run_daily.sh
+    SKIP_RANDOM_SLEEP=true src/run_daily.sh
     echo "[entrypoint-bg] Initial run completed at $(date)"
   ) &
   echo "[entrypoint] Background process started (PID: $!)"

package.json

@@ -1,59 +1,52 @@
 {
-    "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"
-    }
+  "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"
+  }
 }

scripts/clearSessions.js

@@ -1,104 +0,0 @@
-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.')

src/accounts.example.json

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

src/browser/Browser.ts

@@ -1,13 +1,13 @@
-import rebrowser, { BrowserContext } from 'patchright'
+import playwright, { BrowserContext } from 'rebrowser-playwright'
 
 import { newInjectedContext } from 'fingerprint-injector'
-import { BrowserFingerprintWithHeaders, FingerprintGenerator } from 'fingerprint-generator'
+import { FingerprintGenerator } from 'fingerprint-generator'
 
-import type { MicrosoftRewardsBot } from '../index'
+import { MicrosoftRewardsBot } from '../index'
 import { loadSessionData, saveFingerprintData } from '../util/Load'
-import { UserAgentManager } from './UserAgent'
+import { updateFingerprintUserAgent } from '../util/UserAgent'
 
-import type { AccountProxy } from '../interface/Account'
+import { AccountProxy } from '../interface/Account'
 
 /* Test Stuff
 https://abrahamjuliot.github.io/creepjs/
@@ -24,67 +24,50 @@ class Browser {
         this.bot = bot
     }
 
-    async createBrowser(
-        proxy: AccountProxy,
-        email: string
-    ): Promise<{
-        context: BrowserContext
-        fingerprint: BrowserFingerprintWithHeaders
-    }> {
-        let browser: rebrowser.Browser
+    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
         try {
-            browser = await rebrowser.chromium.launch({
+            browser = await playwright.chromium.launch({
+                //channel: 'msedge', // Uses Edge instead of chrome
                 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',
-                    '--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'
+                    '--ignore-ssl-errors'
                 ]
             })
-        } catch (error) {
-            this.bot.logger.error(
-                this.bot.isMobile,
-                'BROWSER',
-                `Launch failed: ${error instanceof Error ? error.message : String(error)}`
-            )
-            throw error
+        } 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
         }
 
-        const sessionData = await loadSessionData(
-            this.bot.config.sessionPath,
-            email,
-            this.bot.config.saveFingerprint,
-            this.bot.isMobile
-        )
+        const sessionData = await loadSessionData(this.bot.config.sessionPath, email, this.bot.isMobile, this.bot.config.saveFingerprint)
 
-        const fingerprint = sessionData.fingerprint
-            ? sessionData.fingerprint
-            : await this.generateFingerprint(this.bot.isMobile)
+        const fingerprint = sessionData.fingerprint ? sessionData.fingerprint : await this.generateFingerprint()
 
         const context = await newInjectedContext(browser as any, { fingerprint: fingerprint })
 
-        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))
+        // Set timeout to preferred amount
+        context.setDefaultTimeout(this.bot.utils.stringToMs(this.bot.config?.globalTimeout ?? 30000))
 
         await context.addCookies(sessionData.cookies)
 
@@ -92,32 +75,22 @@ class Browser {
             await saveFingerprintData(this.bot.config.sessionPath, email, this.bot.isMobile, fingerprint)
         }
 
-        this.bot.logger.info(
-            this.bot.isMobile,
-            'BROWSER',
-            `Created browser with User-Agent: "${fingerprint.fingerprint.navigator.userAgent}"`
-        )
+        this.bot.log(this.bot.isMobile, 'BROWSER', `Created browser with User-Agent: "${fingerprint.fingerprint.navigator.userAgent}"`)
 
-        this.bot.logger.debug(this.bot.isMobile, 'BROWSER-FINGERPRINT', JSON.stringify(fingerprint))
-
-        return {
-            context: context as unknown as BrowserContext,
-            fingerprint: fingerprint
-        }
+        return context as BrowserContext
     }
 
-    async generateFingerprint(isMobile: boolean) {
+    async generateFingerprint() {
         const fingerPrintData = new FingerprintGenerator().getFingerprint({
-            devices: isMobile ? ['mobile'] : ['desktop'],
-            operatingSystems: isMobile ? ['android', 'ios'] : ['windows', 'linux'],
+            devices: this.bot.isMobile ? ['mobile'] : ['desktop'],
+            operatingSystems: this.bot.isMobile ? ['android'] : ['windows'],
             browsers: [{ name: 'edge' }]
         })
 
-        const userAgentManager = new UserAgentManager(this.bot)
-        const updatedFingerPrintData = await userAgentManager.updateFingerprintUserAgent(fingerPrintData, isMobile)
+        const updatedFingerPrintData = await updateFingerprintUserAgent(fingerPrintData, this.bot.isMobile)
 
         return updatedFingerPrintData
     }
 }
 
-export default Browser
+export default Browser

src/browser/BrowserFunc.ts

@@ -1,14 +1,15 @@
-import type { BrowserContext, Cookie } from 'patchright'
-import type { AxiosRequestConfig, AxiosResponse } from 'axios'
+import { BrowserContext, Page } from 'rebrowser-playwright'
+import { CheerioAPI, load } from 'cheerio'
+import { AxiosRequestConfig } from 'axios'
 
-import type { MicrosoftRewardsBot } from '../index'
+import { MicrosoftRewardsBot } from '../index'
 import { saveSessionData } from '../util/Load'
 
-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'
+import { Counters, DashboardData, MorePromotion, PromotionalItem } from './../interface/DashboardData'
+import { QuizData } from './../interface/QuizData'
+import { AppUserData } from '../interface/AppUserData'
+import { EarnablePoints } from '../interface/Points'
+
 
 export default class BrowserFunc {
     private bot: MicrosoftRewardsBot
@@ -17,154 +18,187 @@ export default class BrowserFunc {
         this.bot = bot
     }
 
+
     /**
-     * Fetch user desktop dashboard data
+     * Navigate the provided page to rewards homepage
+     * @param {Page} page Playwright page
+    */
+    async goHome(page: Page) {
+
+        try {
+            const dashboardURL = new URL(this.bot.config.baseURL)
+
+            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)
+            }
+
+        } catch (error) {
+            throw this.bot.log(this.bot.isMobile, 'GO-HOME', 'An error occurred:' + error, 'error')
+        }
+    }
+
+    /**
+     * Fetch user dashboard data
      * @returns {DashboardData} Object of user bing rewards dashboard data
-     */
+    */
     async getDashboardData(): Promise<DashboardData> {
-        try {
-            const cookieHeader = this.bot.cookies.mobile
-                .map((c: { name: string; value: string }) => `${c.name}=${c.value}`)
-                .join('; ')
+        const dashboardURL = new URL(this.bot.config.baseURL)
+        const currentURL = new URL(this.bot.homePage.url())
 
-            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'
+        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 response = await this.bot.axios.request(request)
-            return response.data.dashboard as DashboardData
-        } catch (error) {
-            this.bot.logger.info(
-                this.bot.isMobile,
-                'GET-DASHBOARD-DATA',
-                `Error fetching dashboard data: ${error instanceof Error ? error.message : String(error)}`
-            )
-            throw error
-        }
-    }
+            const scriptContent = await this.bot.homePage.evaluate(() => {
+                const scripts = Array.from(document.querySelectorAll('script'))
+                const targetScript = scripts.find(script => script.innerText.includes('var dashboard'))
 
-    /**
-     * Fetch user app dashboard data
-     * @returns {AppDashboardData} Object of user bing rewards dashboard data
-     */
-    async getAppDashboardData(): Promise<AppDashboardData> {
-        try {
-            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'
-                }
+                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')
             }
 
-            const response = await this.bot.axios.request(request)
-            return response.data as AppDashboardData
-        } catch (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
-        }
-    }
+            // 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)
 
-    /**
-     * 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'
+                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')
             }
 
-            const response = await this.bot.axios.request(request)
-            return response.data as XboxDashboardData
+            return dashboardData
+
         } 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
+            throw this.bot.log(this.bot.isMobile, 'GET-DASHBOARD-DATA', `Error fetching dashboard data: ${error}`, '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
-     */
-    async getBrowserEarnablePoints(): Promise<BrowserEarnablePoints> {
+     * @returns {number} Total earnable points
+    */
+    async getBrowserEarnablePoints(): Promise<EarnablePoints> {
         try {
+            let desktopSearchPoints = 0
+            let mobileSearchPoints = 0
+            let dailySetPoints = 0
+            let morePromotionsPoints = 0
+
             const data = await this.getDashboardData()
 
-            const desktopSearchPoints =
-                data.userStatus.counters.pcSearch?.reduce(
-                    (sum, x) => sum + (x.pointProgressMax - x.pointProgress),
-                    0
-                ) ?? 0
+            // Desktop Search Points
+            if (data.userStatus.counters.pcSearch?.length) {
+                data.userStatus.counters.pcSearch.forEach(x => desktopSearchPoints += (x.pointProgressMax - x.pointProgress))
+            }
 
-            const mobileSearchPoints =
-                data.userStatus.counters.mobileSearch?.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 todayDate = this.bot.utils.getFormattedDate()
-            const dailySetPoints =
-                data.dailySetPromotions[todayDate]?.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 morePromotionsPoints =
-                data.morePromotions?.reduce((sum, x) => {
-                    if (
-                        ['quiz', 'urlreward'].includes(x.promotionType) &&
-                        x.exclusiveLockedFeatureStatus !== 'locked'
-                    ) {
-                        return sum + (x.pointProgressMax - x.pointProgress)
+            // 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)
                     }
-                    return sum
-                }, 0) ?? 0
+                })
+            }
 
             const totalEarnablePoints = desktopSearchPoints + mobileSearchPoints + dailySetPoints + morePromotionsPoints
 
@@ -176,258 +210,174 @@ export default class BrowserFunc {
                 totalEarnablePoints
             }
         } catch (error) {
-            this.bot.logger.error(
-                this.bot.isMobile,
-                'GET-BROWSER-EARNABLE-POINTS',
-                `An error occurred: ${error instanceof Error ? error.message : String(error)}`
-            )
-            throw error
+            throw this.bot.log(this.bot.isMobile, 'GET-BROWSER-EARNABLE-POINTS', 'An error occurred:' + error, 'error')
         }
     }
 
     /**
      * Get total earnable points with mobile app
-     */
-    async getAppEarnablePoints(): Promise<AppEarnablePoints> {
+     * @returns {number} Total earnable points
+    */
+    async getAppEarnablePoints(accessToken: string) {
         try {
-            const eligibleOffers = ['ENUS_readarticle3_30points', 'Gamification_Sapphire_DailyCheckIn']
+            const points = {
+                readToEarn: 0,
+                checkIn: 0,
+                totalEarnablePoints: 0
+            }
 
-            const request: AxiosRequestConfig = {
+            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 = {
                 url: 'https://prod.rewardsplatform.microsoft.com/dapi/me?channel=SAAndroid&options=613',
                 method: 'GET',
                 headers: {
-                    Authorization: `Bearer ${this.bot.accessToken}`,
-                    'X-Rewards-Country': this.bot.userData.geoLocale,
-                    'X-Rewards-Language': 'en',
-                    'X-Rewards-ismobile': 'true'
+                    'Authorization': `Bearer ${accessToken}`,
+                    'X-Rewards-Country': geoLocale,
+                    'X-Rewards-Language': 'en'
                 }
             }
 
-            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
+            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 ?? ''))
 
             for (const item of eligibleActivities) {
-                const attrs = item.attributes
+                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
 
-                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')
+                    if (checkInDay < 6 && (new Date()).getDate() != (new Date(item.attributes.last_updated ?? '')).getDate()) {
+                        points.checkIn = parseInt(item.attributes['day_' + (checkInDay + 1) + '_points'] ?? '')
                     }
+                    break
                 }
             }
 
-            const totalEarnablePoints = readToEarn + checkIn
+            points.totalEarnablePoints = points.readToEarn + points.checkIn
 
-            return {
-                readToEarn,
-                checkIn,
-                totalEarnablePoints
-            }
+            return points
         } catch (error) {
-            this.bot.logger.error(
-                this.bot.isMobile,
-                'GET-APP-EARNABLE-POINTS',
-                `An error occurred: ${error instanceof Error ? error.message : String(error)}`
-            )
-            throw error
+            throw this.bot.log(this.bot.isMobile, 'GET-APP-EARNABLE-POINTS', 'An error occurred:' + error, '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) {
-            this.bot.logger.error(
-                this.bot.isMobile,
-                'GET-CURRENT-POINTS',
-                `An error occurred: ${error instanceof Error ? error.message : String(error)}`
-            )
-            throw error
+            throw this.bot.log(this.bot.isMobile, 'GET-CURRENT-POINTS', 'An error occurred:' + error, '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
-            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 saveSessionData(this.bot.config.sessionPath, browser, email, this.bot.isMobile)
 
             await this.bot.utils.wait(2000)
 
             // Close browser
             await browser.close()
-            this.bot.logger.info(this.bot.isMobile, 'CLOSE-BROWSER', 'Browser closed cleanly!')
+            this.bot.log(this.bot.isMobile, 'CLOSE-BROWSER', 'Browser closed cleanly!')
         } catch (error) {
-            this.bot.logger.error(
-                this.bot.isMobile,
-                'CLOSE-BROWSER',
-                `An error occurred: ${error instanceof Error ? error.message : String(error)}`
-            )
-            throw error
+            throw this.bot.log(this.bot.isMobile, 'CLOSE-BROWSER', 'An error occurred:' + error, '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

@@ -0,0 +1,132 @@
+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

@@ -1,273 +0,0 @@
-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

@@ -1,164 +0,0 @@
-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

@@ -1,509 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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

@@ -1,88 +0,0 @@
-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

@@ -1,110 +0,0 @@
-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

@@ -1,163 +0,0 @@
-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

@@ -1,71 +0,0 @@
-{
-    "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

@@ -0,0 +1,51 @@
+{
+    "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,7 +1,2 @@
-# 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} /bin/bash /usr/src/microsoft-rewards-script/scripts/docker/run_daily.sh >> /proc/1/fd/1 2>&1
+${CRON_SCHEDULE} TZ=${TZ} /bin/bash /usr/src/microsoft-rewards-script/src/run_daily.sh >> /proc/1/fd/1 2>&1

src/functions/Activities.ts

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

src/functions/Login.ts

@@ -0,0 +1,562 @@
+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

@@ -1,191 +0,0 @@
-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

@@ -1,618 +0,0 @@
-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,7 +1,8 @@
-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'
+import { Page } from 'rebrowser-playwright'
+
+import { DashboardData, MorePromotion, PromotionalItem, PunchCard } from '../interface/DashboardData'
+
+import { MicrosoftRewardsBot } from '../index'
 
 export class Workers {
     public bot: MicrosoftRewardsBot
@@ -10,190 +11,220 @@ export class Workers {
         this.bot = bot
     }
 
-    public async doDailySet(data: DashboardData, page: Page) {
-        const todayKey = this.bot.utils.getFormattedDate()
-        const todayData = data.dailySetPromotions[todayKey]
+    // Daily Set
+    async doDailySet(page: Page, data: DashboardData) {
+        const todayData = data.dailySetPromotions[this.bot.utils.getFormattedDate()]
 
         const activitiesUncompleted = todayData?.filter(x => !x.complete && x.pointProgressMax > 0) ?? []
 
         if (!activitiesUncompleted.length) {
-            this.bot.logger.info(this.bot.isMobile, 'DAILY-SET', 'All "Daily Set" items have already been completed')
+            this.bot.log(this.bot.isMobile, 'DAILY-SET', 'All Daily Set" items have already been completed')
             return
         }
 
-        this.bot.logger.info(this.bot.isMobile, 'DAILY-SET', 'Started solving "Daily Set" items')
+        // Solve Activities
+        this.bot.log(this.bot.isMobile, 'DAILY-SET', 'Started solving "Daily Set" items')
 
-        await this.solveActivities(activitiesUncompleted, page)
+        await this.solveActivities(page, activitiesUncompleted)
 
-        this.bot.logger.info(this.bot.isMobile, 'DAILY-SET', 'All "Daily Set" items have been completed')
+        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')
     }
 
-    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()
-        ]
+    // Punch Card
+    async doPunchCard(page: Page, data: DashboardData) {
 
-        const activitiesUncompleted: BasePromotion[] =
-            morePromotions?.filter(
-                x =>
-                    !x.complete &&
-                    x.pointProgressMax > 0 &&
-                    x.exclusiveLockedFeatureStatus !== 'locked' &&
-                    x.promotionType
-            ) ?? []
+        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') ?? []
 
         if (!activitiesUncompleted.length) {
-            this.bot.logger.info(
-                this.bot.isMobile,
-                'MORE-PROMOTIONS',
-                'All "More Promotion" items have already been completed'
-            )
+            this.bot.log(this.bot.isMobile, 'MORE-PROMOTIONS', 'All "More Promotion" items have already been completed')
             return
         }
 
-        this.bot.logger.info(
-            this.bot.isMobile,
-            'MORE-PROMOTIONS',
-            `Started solving ${activitiesUncompleted.length} "More Promotions" items`
-        )
+        // Solve Activities
+        this.bot.log(this.bot.isMobile, 'MORE-PROMOTIONS', 'Started solving "More Promotions" items')
 
-        await this.solveActivities(activitiesUncompleted, page)
+        page = await this.bot.browser.utils.getLatestTab(page)
 
-        this.bot.logger.info(this.bot.isMobile, 'MORE-PROMOTIONS', 'All "More Promotion" items have been completed')
+        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')
     }
 
-    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'
-        )
+    // 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
 
-        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 {
-                const type = activity.promotionType?.toLowerCase() ?? ''
-                const name = activity.name?.toLowerCase() ?? ''
-                const offerId = (activity as BasePromotion).offerId
-                const destinationUrl = activity.destinationUrl?.toLowerCase() ?? ''
+                // Reselect the worker page
+                activityPage = await this.bot.browser.utils.getLatestTab(activityPage)
 
-                this.bot.logger.debug(
-                    this.bot.isMobile,
-                    'ACTIVITY',
-                    `Processing activity | title="${activity.title}" | offerId=${offerId} | type=${type} | punchCard="${punchCard?.parentPromotion?.title ?? 'none'}"`
-                )
+                const pages = activityPage.context().pages()
+                if (pages.length > 3) {
+                    await activityPage.close()
 
-                switch (type) {
-                    // Quiz-like activities (Poll / regular quiz variants)
-                    case 'quiz': {
-                        const basePromotion = activity as BasePromotion
+                    activityPage = await this.bot.browser.utils.getLatestTab(activityPage)
+                }
 
-                        // 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}`
-                            )
+                await this.bot.utils.wait(1000)
 
-                            //await this.bot.activities.doPoll(basePromotion)
-                            break
+                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
                         }
-
-                        // 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
 
+                    // UrlReward (Visit)
+                    case 'urlreward':
                         // Search on Bing are subtypes of "urlreward"
-                        if (name.includes('exploreonbing')) {
-                            this.bot.logger.info(
-                                this.bot.isMobile,
-                                'ACTIVITY',
-                                `Found activity type "SearchOnBing" | title="${activity.title}" | offerId=${offerId}`
-                            )
+                        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)
 
-                            await this.bot.activities.doSearchOnBing(basePromotion, page)
                         } else {
-                            this.bot.logger.info(
-                                this.bot.isMobile,
-                                'ACTIVITY',
-                                `Found activity type "UrlReward" | title="${activity.title}" | offerId=${offerId}`
-                            )
-
-                            await this.bot.activities.doUrlReward(basePromotion)
+                            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)
                         }
                         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.logger.warn(
-                            this.bot.isMobile,
-                            'ACTIVITY',
-                            `Skipped activity "${activity.title}" | offerId=${offerId} | Reason: Unsupported type "${activity.promotionType}"`
-                        )
+                    default:
+                        this.bot.log(this.bot.isMobile, 'ACTIVITY', `Skipped activity "${activity.title}" | Reason: Unsupported type: "${activity.promotionType}"!`, 'warn')
                         break
-                    }
                 }
 
                 // Cooldown
-                await this.bot.utils.wait(this.bot.utils.randomDelay(5000, 15000))
+                await this.bot.utils.wait(2000)
+
             } catch (error) {
-                this.bot.logger.error(
-                    this.bot.isMobile,
-                    'ACTIVITY',
-                    `Error while solving activity "${activity.title}" | message=${error instanceof Error ? error.message : String(error)}`
-                )
+                this.bot.log(this.bot.isMobile, 'ACTIVITY', 'An error occurred:' + error, 'error')
             }
+
         }
     }
-}
+
+}

src/functions/activities/ABC.ts

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,92 @@
+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

@@ -0,0 +1,73 @@
+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

@@ -0,0 +1,400 @@
+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

@@ -0,0 +1,91 @@
+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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -1,130 +0,0 @@
-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

@@ -1,173 +0,0 @@
-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

@@ -1,129 +0,0 @@
-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

@@ -1,119 +0,0 @@
-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

@@ -1,161 +0,0 @@
-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

@@ -1,131 +0,0 @@
-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

@@ -1,426 +0,0 @@
-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

@@ -1,330 +0,0 @@
-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

@@ -2,12 +2,7 @@
     {
         "title": "Houses near you",
         "queries": [
-            "Houses near me",
-            "Homes for sale near me",
-            "Apartments near me",
-            "Real estate listings near me",
-            "Zillow homes near me",
-            "houses for rent near me"
+            "Houses near me"
         ]
     },
     {
@@ -15,10 +10,7 @@
         "queries": [
             "Rash on forearm",
             "Stuffy nose",
-            "Tickling cough",
-            "sore throat remedies",
-            "headache and nausea causes",
-            "fever symptoms adults"
+            "Tickling cough"
         ]
     },
     {
@@ -26,12 +18,7 @@
         "queries": [
             "Buy PS5",
             "Buy Xbox",
-            "Chair deals",
-            "wireless mouse deals",
-            "best gaming headset price",
-            "laptop deals",
-            "buy office chair",
-            "SSD deals"
+            "Chair deals"
         ]
     },
     {
@@ -39,21 +26,13 @@
         "queries": [
             "Translate welcome home to Korean",
             "Translate welcome home to Japanese",
-            "Translate goodbye to Japanese",
-            "Translate good morning to Spanish",
-            "Translate thank you to French",
-            "Translate see you later to Italian"
+            "Translate goodbye to Japanese"
         ]
     },
     {
         "title": "Search the lyrics of a song",
         "queries": [
-            "Debarge rhythm of the night lyrics",
-            "bohemian rhapsody lyrics",
-            "hotel california lyrics",
-            "blinding lights lyrics",
-            "lose yourself lyrics",
-            "smells like teen spirit lyrics"
+            "Debarge rhythm of the night lyrics"
         ]
     },
     {
@@ -62,24 +41,14 @@
             "Alien movie",
             "Aliens movie",
             "Alien 3 movie",
-            "Predator movie",
-            "Terminator movie",
-            "John Wick movie",
-            "Interstellar movie",
-            "The Matrix movie"
+            "Predator movie"
         ]
     },
     {
         "title": "Plan a quick getaway",
         "queries": [
             "Flights Amsterdam to Tokyo",
-            "Flights New York to Tokyo",
-            "cheap flights to paris",
-            "flights amsterdam to rome",
-            "last minute flight deals",
-            "direct flights from amsterdam",
-            "weekend getaway europe",
-            "best time to visit tokyo"
+            "Flights New York to Tokyo"
         ]
     },
     {
@@ -88,22 +57,13 @@
             "jobs at Microsoft",
             "Microsoft Job Openings",
             "Jobs near me",
-            "jobs at Boeing worked",
-            "software engineer jobs near me",
-            "remote developer jobs",
-            "IT jobs netherlands",
-            "customer support jobs near me"
+            "jobs at Boeing worked"
         ]
     },
     {
         "title": "You can track your package",
         "queries": [
-            "USPS tracking",
-            "UPS tracking",
-            "DHL tracking",
-            "FedEx tracking",
-            "track my package",
-            "international package tracking"
+            "USPS tracking"
         ]
     },
     {
@@ -111,12 +71,7 @@
         "queries": [
             "Directions to Berlin",
             "Directions to Tokyo",
-            "Directions to New York",
-            "things to do in berlin",
-            "tourist attractions tokyo",
-            "best places to visit in new york",
-            "hidden gems near me",
-            "day trips near me"
+            "Directions to New York"
         ]
     },
     {
@@ -124,174 +79,67 @@
         "queries": [
             "KFC near me",
             "Burger King near me",
-            "McDonalds near me",
-            "pizza delivery near me",
-            "restaurants open now",
-            "best takeout near me",
-            "quick dinner ideas",
-            "easy dinner recipes"
+            "McDonalds near me"
         ]
     },
     {
         "title": "Quickly convert your money",
         "queries": [
             "convert 250 USD to yen",
-            "convert 500 USD to yen",
-            "usd to eur",
-            "gbp to eur",
-            "eur to jpy",
-            "currency converter",
-            "exchange rate today",
-            "1000 yen to euro"
+            "convert 500 USD to yen"
         ]
     },
     {
         "title": "Learn to cook a new recipe",
         "queries": [
             "How to cook ratatouille",
-            "How to cook lasagna",
-            "easy pasta recipe",
-            "how to make pancakes",
-            "how to make fried rice",
-            "simple chicken recipe"
+            "How to cook lasagna"
         ]
     },
     {
         "title": "Find places to stay!",
         "queries": [
             "Hotels Berlin Germany",
-            "Hotels Amsterdam Netherlands",
-            "hotels in paris",
-            "best hotels in tokyo",
-            "cheap hotels london",
-            "places to stay in barcelona",
-            "hotel deals",
-            "booking hotels near me"
+            "Hotels Amsterdam Netherlands"
         ]
     },
     {
         "title": "How's the economy?",
         "queries": [
-            "sp 500",
-            "nasdaq",
-            "dow jones today",
-            "inflation rate europe",
-            "interest rates today",
-            "stock market today",
-            "economic news",
-            "recession forecast"
+            "sp 500"
         ]
     },
     {
         "title": "Who won?",
         "queries": [
-            "braves score",
-            "champions league results",
-            "premier league results",
-            "nba score",
-            "formula 1 winner",
-            "latest football scores",
-            "ucl final winner",
-            "world cup final result"
+            "braves score"
         ]
     },
     {
         "title": "Gaming time",
         "queries": [
             "Overwatch video game",
-            "Call of duty video game",
-            "best games 2025",
-            "top xbox games",
-            "popular steam games",
-            "new pc games",
-            "game reviews",
-            "best co-op games"
+            "Call of duty video game"
         ]
     },
     {
         "title": "Expand your vocabulary",
         "queries": [
-            "definition definition",
-            "meaning of serendipity",
-            "define nostalgia",
-            "synonym for happy",
-            "define eloquent",
-            "what does epiphany mean",
-            "word of the day",
-            "define immaculate"
+            "definition definition"
         ]
     },
     {
         "title": "What time is it?",
         "queries": [
             "Japan time",
-            "New York time",
-            "time in london",
-            "time in tokyo",
-            "current time in amsterdam",
-            "time in los angeles"
-        ]
-    },
-    {
-        "title": "Find deals on Bing",
-        "queries": [
-            "best laptop deals",
-            "tech deals today",
-            "wireless earbuds deals",
-            "gaming chair deals",
-            "discount codes electronics",
-            "best amazon deals today",
-            "smartphone deals",
-            "ssd deals"
-        ]
-    },
-    {
-        "title": "Prepare for the weather",
-        "queries": [
-            "weather tomorrow",
-            "weekly weather forecast",
-            "rain forecast today",
-            "weather in amsterdam",
-            "storm forecast europe",
-            "uv index today",
-            "temperature this weekend",
-            "snow forecast"
-        ]
-    },
-    {
-        "title": "Track your delivery",
-        "queries": [
-            "track my package",
-            "postnl track and trace",
-            "dhl parcel tracking",
-            "ups tracking",
-            "fedex tracking",
-            "usps tracking",
-            "parcel tracking",
-            "international package tracking"
-        ]
-    },
-    {
-        "title": "Explore a new spot today",
-        "queries": [
-            "places to visit near me",
-            "things to do near me",
-            "hidden gems netherlands",
-            "best museums near me",
-            "parks near me",
-            "tourist attractions nearby",
-            "best cafes near me",
-            "day trip ideas"
+            "New York time"
         ]
     },
+
     {
         "title": "Maisons près de chez vous",
         "queries": [
-            "Maisons près de chez moi",
-            "Maisons à vendre près de chez moi",
-            "Appartements près de chez moi",
-            "Annonces immobilières près de chez moi",
-            "Maisons à louer près de chez moi"
+            "Maisons près de chez moi"
         ]
     },
     {
@@ -299,10 +147,7 @@
         "queries": [
             "Éruption cutanée sur l'avant-bras",
             "Nez bouché",
-            "Toux chatouilleuse",
-            "mal de gorge remèdes",
-            "maux de tête causes",
-            "symptômes de la grippe"
+            "Toux chatouilleuse"
         ]
     },
     {
@@ -310,12 +155,7 @@
         "queries": [
             "Acheter une PS5",
             "Acheter une Xbox",
-            "Offres sur les chaises",
-            "offres ordinateur portable",
-            "meilleures offres casque",
-            "acheter souris sans fil",
-            "promotions ssd",
-            "bons plans tech"
+            "Offres sur les chaises"
         ]
     },
     {
@@ -323,21 +163,13 @@
         "queries": [
             "Traduction bienvenue à la maison en coréen",
             "Traduction bienvenue à la maison en japonais",
-            "Traduction au revoir en japonais",
-            "Traduire bonjour en espagnol",
-            "Traduire merci en anglais",
-            "Traduire à plus tard en italien"
+            "Traduction au revoir en japonais"
         ]
     },
     {
         "title": "Rechercher paroles de chanson",
         "queries": [
-            "Paroles de Debarge rhythm of the night",
-            "paroles bohemian rhapsody",
-            "paroles hotel california",
-            "paroles blinding lights",
-            "paroles lose yourself",
-            "paroles smells like teen spirit"
+            "Paroles de Debarge rhythm of the night"
         ]
     },
     {
@@ -346,23 +178,14 @@
             "Alien film",
             "Film Aliens",
             "Film Alien 3",
-            "Film Predator",
-            "Film Terminator",
-            "Film John Wick",
-            "Film Interstellar",
-            "Film Matrix"
+            "Film Predator"
         ]
     },
     {
         "title": "Planifiez une petite escapade",
         "queries": [
             "Vols Amsterdam-Tokyo",
-            "Vols New York-Tokyo",
-            "vols pas chers paris",
-            "vols amsterdam rome",
-            "offres vols dernière minute",
-            "week-end en europe",
-            "vols directs depuis amsterdam"
+            "Vols New York-Tokyo"
         ]
     },
     {
@@ -371,21 +194,13 @@
             "emplois chez Microsoft",
             "Offres d'emploi Microsoft",
             "Emplois près de chez moi",
-            "emplois chez Boeing",
-            "emplois développeur à distance",
-            "emplois informatique pays-bas",
-            "offres d'emploi près de chez moi"
+            "emplois chez Boeing"
         ]
     },
     {
         "title": "Vous pouvez suivre votre colis",
         "queries": [
-            "Suivi Chronopost",
-            "suivi colis",
-            "suivi DHL",
-            "suivi UPS",
-            "suivi FedEx",
-            "suivi international colis"
+            "Suivi Chronopost"
         ]
     },
     {
@@ -393,11 +208,7 @@
         "queries": [
             "Itinéraire vers Berlin",
             "Itinéraire vers Tokyo",
-            "Itinéraire vers New York",
-            "que faire à berlin",
-            "attractions tokyo",
-            "meilleurs endroits à visiter à new york",
-            "endroits à visiter près de chez moi"
+            "Itinéraire vers New York"
         ]
     },
     {
@@ -405,178 +216,74 @@
         "queries": [
             "KFC près de chez moi",
             "Burger King près de chez moi",
-            "McDonalds près de chez moi",
-            "livraison pizza près de chez moi",
-            "restaurants ouverts maintenant",
-            "idées dîner rapide",
-            "quoi manger ce soir"
+            "McDonalds près de chez moi"
         ]
     },
     {
         "title": "Convertissez rapidement votre argent",
         "queries": [
             "convertir 250 EUR en yen",
-            "convertir 500 EUR en yen",
-            "usd en eur",
-            "gbp en eur",
-            "eur en jpy",
-            "convertisseur de devises",
-            "taux de change aujourd'hui",
-            "1000 yen en euro"
+            "convertir 500 EUR en yen"
         ]
     },
     {
         "title": "Apprenez à cuisiner une nouvelle recette",
         "queries": [
             "Comment faire cuire la ratatouille",
-            "Comment faire cuire les lasagnes",
-            "recette pâtes facile",
-            "comment faire des crêpes",
-            "recette riz sauté",
-            "recette poulet simple"
+            "Comment faire cuire les lasagnes"
         ]
     },
     {
         "title": "Trouvez des emplacements pour rester!",
         "queries": [
             "Hôtels Berlin Allemagne",
-            "Hôtels Amsterdam Pays-Bas",
-            "hôtels paris",
-            "meilleurs hôtels tokyo",
-            "hôtels pas chers londres",
-            "hébergement barcelone",
-            "offres hôtels",
-            "hôtels près de chez moi"
+            "Hôtels Amsterdam Pays-Bas"
         ]
     },
     {
         "title": "Comment se porte l'économie ?",
         "queries": [
-            "CAC 40",
-            "indice dax",
-            "dow jones aujourd'hui",
-            "inflation europe",
-            "taux d'intérêt aujourd'hui",
-            "marché boursier aujourd'hui",
-            "actualités économie",
-            "prévisions récession"
+            "CAC 40"
         ]
     },
     {
         "title": "Qui a gagné ?",
         "queries": [
-            "score du Paris Saint-Germain",
-            "résultats ligue des champions",
-            "résultats premier league",
-            "score nba",
-            "vainqueur formule 1",
-            "derniers scores football",
-            "vainqueur finale ldc"
+            "score du Paris Saint-Germain"
         ]
     },
     {
         "title": "Temps de jeu",
         "queries": [
             "Jeu vidéo Overwatch",
-            "Jeu vidéo Call of Duty",
-            "meilleurs jeux 2025",
-            "top jeux xbox",
-            "jeux steam populaires",
-            "nouveaux jeux pc",
-            "avis jeux vidéo",
-            "meilleurs jeux coop"
+            "Jeu vidéo Call of Duty"
         ]
     },
     {
         "title": "Enrichissez votre vocabulaire",
         "queries": [
-            "definition definition",
-            "signification sérendipité",
-            "définir nostalgie",
-            "synonyme heureux",
-            "définir éloquent",
-            "mot du jour",
-            "que veut dire épiphanie"
+            "definition definition"
         ]
     },
     {
         "title": "Quelle heure est-il ?",
         "queries": [
             "Heure du Japon",
-            "Heure de New York",
-            "heure de londres",
-            "heure de tokyo",
-            "heure actuelle amsterdam",
-            "heure de los angeles"
+            "Heure de New York"
         ]
     },
     {
         "title": "Vérifier la météo",
         "queries": [
             "Météo de Paris",
-            "Météo de la France",
-            "météo demain",
-            "prévisions météo semaine",
-            "météo amsterdam",
-            "risque de pluie aujourd'hui"
+            "Météo de la France"
         ]
     },
     {
         "title": "Tenez-vous informé des sujets d'actualité",
         "queries": [
             "Augmentation Impots",
-            "Mort célébrité",
-            "actualités france",
-            "actualité internationale",
-            "dernières nouvelles économie",
-            "news technologie"
-        ]
-    },
-    {
-        "title": "Préparez-vous pour la météo",
-        "queries": [
-            "météo demain",
-            "prévisions météo semaine",
-            "météo amsterdam",
-            "risque de pluie aujourd'hui",
-            "indice uv aujourd'hui",
-            "température ce week-end",
-            "alerte tempête"
-        ]
-    },
-    {
-        "title": "Suivez votre livraison",
-        "queries": [
-            "suivi colis",
-            "postnl suivi colis",
-            "suivi DHL colis",
-            "suivi UPS",
-            "suivi FedEx",
-            "suivi international colis",
-            "suivre ma livraison"
-        ]
-    },
-    {
-        "title": "Trouvez des offres sur Bing",
-        "queries": [
-            "meilleures offres ordinateur portable",
-            "bons plans tech",
-            "promotions écouteurs",
-            "offres chaise gamer",
-            "codes promo électronique",
-            "meilleures offres amazon aujourd'hui"
-        ]
-    },
-    {
-        "title": "Explorez un nouvel endroit aujourd'hui",
-        "queries": [
-            "endroits à visiter près de chez moi",
-            "que faire près de chez moi",
-            "endroits insolites pays-bas",
-            "meilleurs musées près de chez moi",
-            "parcs près de chez moi",
-            "attractions touristiques à proximité",
-            "meilleurs cafés près de chez moi"
+            "Mort célébrité"
         ]
     }
-]
+]

src/index.ts

@@ -1,502 +1,548 @@
-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 cluster from 'cluster'
+// Use Page type from playwright for typings; at runtime rebrowser-playwright extends playwright
+import type { Page } from 'playwright'
 
 import Browser from './browser/Browser'
 import BrowserFunc from './browser/BrowserFunc'
-import BrowserUtils from './browser/BrowserUtils'
+import BrowserUtil from './browser/BrowserUtil'
 
-import { IpcLog, Logger } from './logging/Logger'
-import Utils from './util/Utils'
-import { loadAccounts, loadConfig } from './util/Load'
+import { log } from './util/Logger'
+import Util from './util/Utils'
+import { loadAccounts, loadConfig, saveSessionData } from './util/Load'
 
-import { Login } from './browser/auth/Login'
+import { Login } from './functions/Login'
 import { Workers } from './functions/Workers'
 import Activities from './functions/Activities'
-import { SearchManager } from './functions/SearchManager'
 
-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'
+import { Account } from './interface/Account'
+import Axios from './util/Axios'
+import fs from 'fs'
+import path from 'path'
 
-interface ExecutionContext {
-    isMobile: boolean
-    accountEmail: string
-}
-
-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' }
-    }
-    return context
-}
-
-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
-}
 
+// Main bot class
 export class MicrosoftRewardsBot {
-    public logger: Logger
+    public log: typeof log
     public config
-    public utils: Utils
+    public utils: Util
     public activities: Activities = new Activities(this)
-    public browser: { func: BrowserFunc; utils: BrowserUtils }
+    public browser: {
+        func: BrowserFunc,
+        utils: BrowserUtil
+    }
+    public isMobile: boolean
+    public homePage!: Page
 
-    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 pointsCanCollect: number = 0
+    private pointsInitial: number = 0
 
     private activeWorkers: number
-    private exitedWorkers: number[]
+    private mobileRetryAttempts: number
     private browserFactory: Browser = new Browser(this)
     private accounts: Account[]
     private workers: Workers
     private login = new Login(this)
-    private searchManager: SearchManager
+    private accessToken: string = ''
 
-    public axios!: AxiosClient
+    // 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
 
-    constructor() {
-        this.userData = {
-            userName: '',
-            geoLocale: '',
-            initialPoints: 0,
-            currentPoints: 0,
-            gainedPoints: 0
-        }
-        this.logger = new Logger(this)
         this.accounts = []
-        this.cookies = { mobile: [], desktop: [] }
-        this.utils = new Utils()
+        this.utils = new Util()
         this.workers = new Workers(this)
-        this.searchManager = new SearchManager(this)
         this.browser = {
             func: new BrowserFunc(this),
-            utils: new BrowserUtils(this)
+            utils: new BrowserUtil(this)
         }
         this.config = loadConfig()
         this.activeWorkers = this.config.clusters
-        this.exitedWorkers = []
+        this.mobileRetryAttempts = 0
     }
 
-    get isMobile(): boolean {
-        return getCurrentContext().isMobile
-    }
-
-    async initialize(): Promise<void> {
+    async initialize() {
         this.accounts = loadAccounts()
     }
 
-    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}`
-        )
+    async run() {
+        this.printBanner()
+        log('main', 'MAIN', `Bot started with ${this.config.clusters} clusters`)
 
+        // Only cluster when there's more than 1 cluster demanded
         if (this.config.clusters > 1) {
             if (cluster.isPrimary) {
-                this.runMaster(runStartTime)
+                this.runMaster()
             } else {
-                this.runWorker(runStartTime)
+                this.runWorker()
             }
         } else {
-            await this.runTasks(this.accounts, runStartTime)
+            await this.runTasks(this.accounts)
         }
     }
 
-    private runMaster(runStartTime: number): void {
-        void this.logger.info('main', 'CLUSTER-PRIMARY', `Primary process started | PID: ${process.pid}`)
-
-        const rawChunks = this.utils.chunkArray(this.accounts, this.config.clusters)
-        const accountChunks = rawChunks.filter(c => c && c.length > 0)
-        this.activeWorkers = accountChunks.length
-
-        const allAccountStats: AccountStats[] = []
-
-        for (const chunk of accountChunks) {
-            const worker = cluster.fork()
-            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)
-                    }
-                }
-            })
-        }
-
-        const onWorkerDone = async (label: 'exit' | 'disconnect', worker: Worker, code?: number): Promise<void> => {
-            const { pid } = worker.process
-
-            if (!pid || this.exitedWorkers.includes(pid)) return
-            else this.exitedWorkers.push(pid)
-
-            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)
-
-                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)
-            }
-        }
-
-        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 })
-                }
-                process.disconnect()
-            } 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 async runTasks(accounts: Account[], runStartTime: number): Promise<AccountStats[]> {
-        const accountStats: AccountStats[] = []
-
-        for (const account of accounts) {
-            const accountStartTime = Date.now()
-            const accountEmail = account.email
-            this.userData.userName = this.utils.getEmailUsername(accountEmail)
-
-            try {
-                this.logger.info(
-                    'main',
-                    'ACCOUNT-START',
-                    `Starting account: ${accountEmail} | geoLocale: ${account.geoLocale}`
-                )
-
-                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'
-                    })
-                }
-            } 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.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
-
+    private printBanner() {
+        // Only print once (primary process or single cluster execution)
+        if (this.config.clusters > 1 && !cluster.isPrimary) return
         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()
+            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 */ }
+    }
 
-                this.logger.info('main', 'BROWSER', `Mobile Browser started | ${accountEmail}`)
+    // Return summaries (used when clusters==1)
+    public getSummaries() {
+        return this.accountSummaries
+    }
 
-                await this.login.login(this.mainMobilePage, accountEmail, account.password, account.totp)
+    private runMaster() {
+        log('main', 'MAIN-PRIMARY', 'Primary process started')
 
-                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)}`
-                    )
-                }
+        const accountChunks = this.utils.chunkArray(this.accounts, this.config.clusters)
 
-                this.cookies.mobile = await initialContext.cookies()
-                this.fingerprint = mobileSession.fingerprint
-
-                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
+        for (let i = 0; i < accountChunks.length; i++) {
+            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)
                 }
             })
-        } finally {
-            if (mobileSession && !mobileContextClosed) {
-                try {
-                    await executionContext.run({ isMobile: true, accountEmail }, async () => {
-                        await this.browser.func.closeBrowser(mobileSession!.context, accountEmail)
-                    })
-                } catch {}
+        }
+
+    cluster.on('exit', (worker: any, code: number) => {
+            this.activeWorkers -= 1
+
+            log('main', 'MAIN-WORKER', `Worker ${worker.process.pid} destroyed | Code: ${code} | Active workers: ${this.activeWorkers}`, 'warn')
+
+            // 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)
+                })
+            }
+        })
+    }
+
+    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[]) {
+        for (const account of accounts) {
+            log('main', 'MAIN-WORKER', `Started tasks for account ${account.email}`)
+
+            const accountStart = Date.now()
+            let desktopInitial = 0
+            let mobileInitial = 0
+            let desktopCollected = 0
+            let mobileCollected = 0
+            const errors: string[] = []
+
+            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(' | ')}`
+                }
+                return `${label}:${base}`
+            }
+
+            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
+                }
+
+                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
+                }
+            }
+
+            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
+            })
+
+            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'}`)
             }
         }
+        // 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] })
     }
 }
 
-export { executionContext }
+interface AccountSummary {
+    email: string
+    durationMs: number
+    desktopCollected: number
+    mobileCollected: number
+    totalCollected: number
+    initialTotal: number
+    endTotal: number
+    errors: string[]
+}
 
-async function main(): Promise<void> {
-    const rewardsBot = new MicrosoftRewardsBot()
+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)
+}
 
-    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)
-    })
+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)
 
     try {
         await rewardsBot.initialize()
         await rewardsBot.run()
     } catch (error) {
-        rewardsBot.logger.error('main', 'MAIN-ERROR', error as Error)
+        log(false, 'MAIN-ERROR', `Error running desktop bot: ${error}`, 'error')
     }
 }
 
-main().catch(async error => {
-    const tmpBot = new MicrosoftRewardsBot()
-    tmpBot.logger.error('main', 'MAIN-ERROR', error as Error)
-    await flushAllWebhooks()
+// Start the bots
+main().catch(error => {
+    log('main', 'MAIN-ERROR', `Error running bots: ${error}`, 'error')
     process.exit(1)
-})
+})

src/interface/Account.ts

@@ -1,15 +1,13 @@
 export interface Account {
-    email: string
-    password: string
-    totp?: string
-    geoLocale: 'auto' | string
-    proxy: AccountProxy
+    email: string;
+    password: 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

@@ -1,105 +0,0 @@
-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,57 +162,58 @@ 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,81 +1,56 @@
 export interface Config {
-    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
+    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
 }
 
 export interface ConfigSaveFingerprint {
-    mobile: boolean
-    desktop: boolean
+    mobile: boolean;
+    desktop: boolean;
 }
 
 export interface ConfigSearchSettings {
-    scrollRandomResults: boolean
-    clickRandomResults: boolean
-    parallelSearching: boolean
-    searchResultVisitTime: number | string
-    searchDelay: ConfigDelay
-    readDelay: ConfigDelay
+    useGeoLocaleQueries: boolean;
+    scrollRandomResults: boolean;
+    clickRandomResults: boolean;
+    searchDelay: ConfigSearchDelay;
+    retryMobileSearchAmount: number;
 }
 
-export interface ConfigDelay {
-    min: number | string
-    max: number | string
+export interface ConfigSearchDelay {
+    min: number | string;
+    max: number | string;
+}
+
+export interface ConfigWebhook {
+    enabled: boolean;
+    url: string;
 }
 
 export interface ConfigProxy {
-    queryEngine: boolean
+    proxyGoogleTrends: boolean;
+    proxyBingTerms: boolean;
 }
 
 export interface ConfigWorkers {
-    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)
+    doDailySet: boolean;
+    doMorePromotions: boolean;
+    doPunchCards: boolean;
+    doDesktopSearch: boolean;
+    doMobileSearch: boolean;
+    doDailyCheckIn: boolean;
+    doReadToEarn: boolean;
 }

src/interface/GoogleDailyTrends.ts

@@ -0,0 +1,44 @@
+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,20 +1,7 @@
-export interface BrowserEarnablePoints {
+export interface EarnablePoints {
     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,96 +1,4 @@
-// Google Trends
-export type GoogleTrendsResponse = [string, [string, ...null[], [string, ...string[]]][]]
-
 export interface GoogleSearch {
-    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
-}
+    topic: string;
+    related: 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

@@ -1,43 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,189 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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/run_daily.sh

@@ -1,6 +1,7 @@
 #!/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/util/Axios.ts

@@ -1,9 +1,8 @@
 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 { URL } from 'url'
-import type { AccountProxy } from '../interface/Account'
+import { SocksProxyAgent } from 'socks-proxy-agent'
+import { AccountProxy } from '../interface/Account'
 
 class AxiosClient {
     private instance: AxiosInstance
@@ -11,74 +10,35 @@ class AxiosClient {
 
     constructor(account: AccountProxy) {
         this.account = account
+        this.instance = axios.create()
 
-        this.instance = axios.create({
-            timeout: 20000
-        })
-
+        // If a proxy configuration is provided, set up the agent
         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> {
-        const { url: baseUrl, port, username, password } = proxyConfig
+    private getAgentForProxy(proxyConfig: AccountProxy): HttpProxyAgent<string> | HttpsProxyAgent<string> | SocksProxyAgent {
+        const { url, port } = proxyConfig
 
-        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)
+        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}`)
             default:
-                throw new Error(`Unsupported proxy protocol: ${protocol}. Only HTTP(S) is supported!`)
+                throw new Error(`Unsupported proxy protocol: ${url}`)
         }
     }
 
+    // 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)
         }
 
@@ -86,4 +46,4 @@ class AxiosClient {
     }
 }
 
-export default AxiosClient
+export default AxiosClient

src/util/ConclusionWebhook.ts

@@ -0,0 +1,32 @@
+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

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

src/util/Logger.ts

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,143 @@
+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,19 +1,16 @@
-import ms, { StringValue } from 'ms'
+import ms from 'ms'
 
 export default class Util {
-    async wait(time: number | string): Promise<void> {
-        if (typeof time === 'string') {
-            time = this.stringToNumber(time)
-        }
 
-        return new Promise<void>(resolve => {
-            setTimeout(resolve, time)
+    async wait(ms: number): Promise<void> {
+        return new Promise<void>((resolve) => {
+            setTimeout(resolve, ms)
         })
     }
 
     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()
 
@@ -21,8 +18,7 @@ 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)
     }
@@ -43,39 +39,12 @@ export default class Util {
         return chunks
     }
 
-    stringToNumber(input: string | number): number {
-        if (typeof input === 'number') {
-            return input
+    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"')
         }
-        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

@@ -0,0 +1,23 @@
+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,10 +61,17 @@
         // "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"
+    ]
+}