1.5.3

Fix issue with pop-up dismissal
1.5.2
2026-01-12 03:16:19 +00:00 · 2025-04-30 16:20:56 +02:00 · 2025-04-24 14:50:22 +02:00 · 2025-03-03 10:59:06 +01:00 · 2025-02-28 12:34:47 +01:00 · 2025-02-25 16:14:51 +01:00
43 changed files with 3071 additions and 1154 deletions
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -28,6 +28,10 @@ module.exports = {
            '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'
--- a/.gitattributes
+++ b/.gitattributes
@@ -0,0 +1,2 @@
+*.sh text eol=lf
+*.template text eol=lf
--- a/.gitignore
+++ b/.gitignore
@@ -5,4 +5,5 @@ package-lock.json
 accounts.json
 notes
 accounts.dev.json
-accounts.main.json
+accounts.main.json
+.DS_Store
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -1,20 +0,0 @@
-{
-    // Use IntelliSense to learn about possible attributes.
-    // Hover to view descriptions of existing attributes.
-    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "type": "node",
-            "request": "launch",
-            "name": "Launch Program",
-            "skipFiles": [
-                "<node_internals>/**"
-            ],
-            "program": "${file}",
-            "outFiles": [
-                "${workspaceFolder}/**/*.js"
-            ]
-        }
-    ]
-}
--- a/47
+++ b/47
@@ -0,0 +1,47 @@
+# Use an official Node.js runtime as a base image
+FROM node:18
+
+# Set the working directory in the container
+WORKDIR /usr/src/microsoft-rewards-script
+
+# Install necessary dependencies for Playwright and cron
+RUN apt-get update && apt-get install -y \
+    jq \
+    cron \
+    gettext-base \
+    xvfb \
+    libgbm-dev \
+    libnss3 \
+    libasound2 \
+    libxss1 \
+    libatk-bridge2.0-0 \
+    libgtk-3-0 \
+    tzdata \
+    wget \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy all files to the working directory
+COPY . .
+
+# Install dependencies, set permissions, and build the script
+RUN npm install && \
+    chmod -R 755 /usr/src/microsoft-rewards-script/node_modules && \
+    npm run pre-build && \
+    npm run build
+
+# Copy cron file to cron directory
+COPY src/crontab.template /etc/cron.d/microsoft-rewards-cron.template
+
+# Create the log file to be able to run tail
+RUN touch /var/log/cron.log
+
+# Define the command to run your application with cron optionally
+CMD ["sh", "-c", "echo \"$TZ\" > /etc/timezone && \
+    ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && \
+    dpkg-reconfigure -f noninteractive tzdata && \
+    envsubst < /etc/cron.d/microsoft-rewards-cron.template > /etc/cron.d/microsoft-rewards-cron && \
+    chmod 0644 /etc/cron.d/microsoft-rewards-cron && \
+    crontab /etc/cron.d/microsoft-rewards-cron && \
+    cron -f & \
+    ([ \"$RUN_ON_START\" = \"true\" ] && npm start) && \
+    tail -f /var/log/cron.log"]
--- a/README.md
+++ b/README.md
@@ -1,5 +1,5 @@
 # Microsoft-Rewards-Script
-Automated Microsoft Rewards script, however this time using TypeScript, Cheerio and Puppeteer.
+Automated Microsoft Rewards script, however this time using TypeScript, Cheerio and Playwright.

 Under development, however mainly for personal use!

@@ -11,10 +11,83 @@ Under development, however mainly for personal use!
 5. Run `npm run build` to build the script
 6. Run `npm run start` to start the built script

+## Notes ##
+- If you end the script without closing the browser window first (only with headless as false), you'll be left with hanging chrome instances using resources. Use taskmanager to kill these or use the included `npm run kill-chrome-win` script. (Windows)
+- If you automate this script, set it to run at least 2 times a day to make sure it picked up all tasks, set `"runOnZeroPoints": false` so it doesn't run when no points are found.
+
+## Docker (Experimental) ##
+### **Before Starting**
+
+- If you had previously built and run the script locally, **remove** the `/node_modules` and `/dist` folders from your `Microsoft-Rewards-Script` directory.
+- If you had used Docker with an older version of the script (e.g., 1.4), **remove** any persistently saved `config.json` and session folders. Old `accounts.json` files can be reused.
+
+### **Setup the Source Files**
+
+1. **Download the Source Code**
+
+2. **Update `accounts.json`**
+
+3. **Edit `config.json`,** ensuring the following values are set (other settings are up to your preference):
+
+   ```json
+   "headless": true,
+   "clusters": 1,
+   ```
+
+### **Customize the `compose.yaml` File**
+
+A basic docker `compose.yaml` is provided. Follow these steps to configure and run the container:
+
+1. **Set Your Timezone:** Adjust the `TZ` variable to ensure correct scheduling.
+2. **Configure Persistent Storage:**
+   - Map `config.json` and `accounts.json` to retain settings and accounts.
+   - (Optional) Use a persistent `sessions` folder to save login sessions.
+3. **Customize the Schedule:**
+   - Modify `CRON_SCHEDULE` to set run times. Use [crontab.guru](https://crontab.guru) for help.
+   - **Note:** The container adds 5–50 minutes of random variability to each scheduled start time.
+4. **(Optional) Run on Startup:**
+   - Set `RUN_ON_START=true` to execute the script immediately when the container starts.
+5. **Start the Container:** Run `docker compose up -d` to build and launch.
+6. **Monitor Logs:** Use `docker logs microsoft-rewards-script` to view script execution and to retrieve 'passwordless' login codes.
+
+
+## Config ## 
+| Setting        | Description           | Default  |
+| :------------- |:-------------| :-----|
+|  baseURL    | MS Rewards page | `https://rewards.bing.com` |
+|  sessionPath    | Path to where you want sessions/fingerprints to be stored | `sessions` (In ./browser/sessions) |
+|  headless    | If the browser window should be visible be ran in the background | `false` (Browser is visible) |
+|  parallel    | If you want mobile and desktop tasks to run parallel or sequential| `true` |
+|  runOnZeroPoints    | Run the rest of the script if 0 points can be earned | `false` (Will not run on 0 points) |
+|  clusters    | Amount of instances ran on launch, 1 per account | `1` (Will run 1 account at the time) |
+|  saveFingerprint.mobile    | Re-use the same fingerprint each time | `false` (Will generate a new fingerprint each time) |
+|  saveFingerprint.desktop    | Re-use the same fingerprint each time | `false` (Will generate a new fingerprint each time) |
+|  workers.doDailySet    | Complete daily set items | `true`  |
+|  workers.doMorePromotions    | Complete promotional items | `true`  |
+|  workers.doPunchCards    | Complete punchcards | `true`  |
+|  workers.doDesktopSearch    | Complete daily desktop searches | `true`  |
+|  workers.doMobileSearch    | Complete daily mobile searches | `true`  |
+|  workers.doDailyCheckIn    | Complete daily check-in activity | `true`  |
+|  workers.doReadToEarn    | Complete read to earn activity | `true`  |
+|  searchOnBingLocalQueries    | Complete the activity "search on Bing" using the `queries.json` or fetched from this repo | `false` (Will fetch from this repo)   |
+|  globalTimeout    | The length before the action gets timeout | `30s`   |
+|  searchSettings.useGeoLocaleQueries    | Generate search queries based on your geo-location | `false` (Uses EN-US generated queries)  |
+|  searchSettings.scrollRandomResults    | Scroll randomly in search results | `true`   |
+|  searchSettings.clickRandomResults    | Visit random website from search result| `true`   |
+|  searchSettings.searchDelay    | Minimum and maximum time in milliseconds between search queries | `min: 3min`    `max: 5min` |
+|  searchSettings.retryMobileSearchAmount     | Keep retrying mobile searches for specified amount | `2` |
+|  logExcludeFunc | Functions to exclude out of the logs and webhooks | `SEARCH-CLOSE-TABS` |
+|  webhookLogExcludeFunc | Functions to exclude out of the webhooks log | `SEARCH-CLOSE-TABS` |
+|  proxy.proxyGoogleTrends     | Enable or disable proxying the request via set proxy | `true` (will be proxied) |
+|  proxy.proxyBingTerms     | Enable or disable proxying the request via set proxy | `true` (will be proxied) |
+|  webhook.enabled     | Enable or disable your set webhook | `false` |
+|  webhook.url     | Your Discord webhook URL | `null` |
+
 ## Features ##
 - [x] Multi-Account Support
 - [x] Session Storing
 - [x] 2FA Support
+- [x] Passwordless Support
 - [x] Headless Support
 - [x] Discord Webhook Support
 - [x] Desktop Searches
@@ -31,13 +104,14 @@ Under development, however mainly for personal use!
 - [x] Completing Click Rewards
 - [x] Completing Polls
 - [x] Completing Punchcards
- [ ] Solving This Or That Quiz
- [x] Clicking Promotional Items
+- [x] Solving This Or That Quiz (Random)
 - [x] Solving ABC Quiz
- [ ] Completing Shopping Game
- [ ] Completing Gaming Tab
+- [x] Completing Daily Check In
+- [x] Completing Read To Earn
 - [x] Clustering Support
 - [x] Proxy Support
+- [x] Docker Support (experimental)
+- [x] Automatic scheduling (via Docker)

 ## Disclaimer ##
 Your account may be at risk of getting banned or suspended using this script, you've been warned!
--- a/compose.yaml
+++ b/compose.yaml
@@ -0,0 +1,15 @@
+services:
+  microsoft-rewards-script:
+    build: .
+    container_name: microsoft-rewards-script
+    restart: unless-stopped
+    volumes:
+      ### Replace "/path/to/" with the actual path to where you want to save the files on your local machine.
+      - /path/to/accounts.json:/usr/src/microsoft-rewards-script/dist/accounts.json
+      - /path/to/config.json:/usr/src/microsoft-rewards-script/dist/config.json 
+      - /path/to/sessions:/usr/src/microsoft-rewards-script/dist/browser/sessions # Optional, saves your login session
+    environment:
+      - NODE_ENV=production
+      - CRON_SCHEDULE=0 7,15,20 * * * # Customize your schedule, use crontab.guru for formatting
+      - RUN_ON_START=true # Runs the script on container startup
+      - TZ=America/Toronto # Set your timezone for proper scheduling
--- a/package.json
+++ b/package.json
@@ -1,16 +1,19 @@
 {
  "name": "microsoft-rewards-script",
-  "version": "1.2.1",
+  "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"
+    "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",
@@ -18,23 +21,31 @@
    "Bot",
    "Script",
    "TypeScript",
-    "Puppeteer",
+    "Playwright",
    "Cheerio"
  ],
  "author": "Netsky",
  "license": "ISC",
  "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^6.7.0",
-    "typescript": "^5.2.2"
+    "@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.5.1",
-    "cheerio": "^1.0.0-rc.12",
-    "eslint": "^8.49.0",
-    "eslint-plugin-modules-newline": "^0.0.6",
-    "puppeteer": "^21.2.1",
-    "puppeteer-extra": "^3.3.6",
-    "puppeteer-extra-plugin-stealth": "^2.11.2",
-    "ts-node": "^10.9.1"
+    "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.47.2",
+    "rebrowser-playwright": "1.47.2",
+    "socks-proxy-agent": "^8.0.5",
+    "ts-node": "^10.9.2"
  }
-}
+}
--- a/src/accounts.example.json
+++ b/src/accounts.example.json
@@ -3,6 +3,7 @@
        "email": "email_1",
        "password": "password_1",
        "proxy": {
+            "proxyAxios": true,
            "url": "",
            "port": 0,
            "username": "",
@@ -13,6 +14,7 @@
        "email": "email_2",
        "password": "password_2",
        "proxy": {
+            "proxyAxios": true,
            "url": "",
            "port": 0,
            "username": "",
--- a/src/browser/Browser.ts
+++ b/src/browser/Browser.ts
@@ -1,34 +1,74 @@
-import puppeteer from 'puppeteer-extra'
-import stealthPlugin from 'puppeteer-extra-plugin-stealth'
+import playwright, { BrowserContext } from 'rebrowser-playwright'

-import { getUserAgent } from '../util/UserAgent'
-import { loadSesion } from './BrowserFunc'
+import { newInjectedContext } from 'fingerprint-injector'
+import { FingerprintGenerator } from 'fingerprint-generator'
+
+import { MicrosoftRewardsBot } from '../index'
+import { loadSessionData, saveFingerprintData } from '../util/Load'
+import { updateFingerprintUserAgent } from '../util/UserAgent'

 import { AccountProxy } from '../interface/Account'

-import { headless } from '../config.json'
-
-puppeteer.use(stealthPlugin())
+/* Test Stuff
+https://abrahamjuliot.github.io/creepjs/
+https://botcheck.luminati.io/
+https://fv.pro/
+https://pixelscan.net/
+https://www.browserscan.net/
+*/

 class Browser {
+    private bot: MicrosoftRewardsBot

-    async createBrowser(email: string, proxy: AccountProxy, isMobile: boolean) {
-        const userAgent = await getUserAgent(isMobile)
+    constructor(bot: MicrosoftRewardsBot) {
+        this.bot = bot
+    }

-        const browser = await puppeteer.launch({
-            headless: headless,
-            userDataDir: await loadSesion(email),
+    async createBrowser(proxy: AccountProxy, email: string): Promise<BrowserContext> {
+        const 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}` } }),
            args: [
                '--no-sandbox',
                '--mute-audio',
                '--disable-setuid-sandbox',
-                `--user-agent=${userAgent.userAgent}`,
-                isMobile ? '--window-size=568,1024' : '',
-                proxy.url ? `--proxy-server=${proxy.url}:${proxy.port}` : ''
+                '--ignore-certificate-errors',
+                '--ignore-certificate-errors-spki-list',
+                '--ignore-ssl-errors'
            ]
        })

-        return browser
+        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()
+
+        const context = await newInjectedContext(browser as any, { fingerprint: fingerprint })
+
+        // Set timeout to preferred amount
+        context.setDefaultTimeout(this.bot.utils.stringToMs(this.bot.config?.globalTimeout ?? 30000))
+
+        await context.addCookies(sessionData.cookies)
+
+        if (this.bot.config.saveFingerprint) {
+            await saveFingerprintData(this.bot.config.sessionPath, email, this.bot.isMobile, fingerprint)
+        }
+
+        this.bot.log(this.bot.isMobile, 'BROWSER', `Created browser with User-Agent: "${fingerprint.fingerprint.navigator.userAgent}"`)
+
+        return context as BrowserContext
+    }
+
+    async generateFingerprint() {
+        const fingerPrintData = new FingerprintGenerator().getFingerprint({
+            devices: this.bot.isMobile ? ['mobile'] : ['desktop'],
+            operatingSystems: this.bot.isMobile ? ['android'] : ['windows'],
+            browsers: [{ name: 'edge' }]
+        })
+
+        const updatedFingerPrintData = await updateFingerprintUserAgent(fingerPrintData, this.bot.isMobile)
+
+        return updatedFingerPrintData
    }
 }

--- a/src/browser/BrowserFunc.ts
+++ b/src/browser/BrowserFunc.ts
@@ -1,248 +1,360 @@
-import { Page } from 'puppeteer'
-import fs from 'fs'
-import path from 'path'
+import { BrowserContext, Page } from 'rebrowser-playwright'
 import { CheerioAPI, load } from 'cheerio'
+import { AxiosRequestConfig } from 'axios'

-import { tryDismissAllMessages, tryDismissCookieBanner } from './BrowserUtil'
-import { getFormattedDate, wait } from './../util/Utils'
-import { log } from './../util/Logger'
+import { MicrosoftRewardsBot } from '../index'
+import { saveSessionData } from '../util/Load'

 import { Counters, DashboardData, MorePromotion, PromotionalItem } from './../interface/DashboardData'
 import { QuizData } from './../interface/QuizData'
+import { AppUserData } from '../interface/AppUserData'
+import { EarnablePoints } from '../interface/Points'

-import { baseURL, sessionPath } from './../config.json'

-export async function goHome(page: Page): Promise<boolean> {
+export default class BrowserFunc {
+    private bot: MicrosoftRewardsBot

-    try {
-        const dashboardURL = new URL(baseURL)
+    constructor(bot: MicrosoftRewardsBot) {
+        this.bot = bot
+    }

-        await page.goto(baseURL)

-        const maxIterations = 5 // Maximum iterations set to 5
+    /**
+     * Navigate the provided page to rewards homepage
+     * @param {Page} page Playwright page
+    */
+    async goHome(page: Page) {

-        for (let iteration = 1; iteration <= maxIterations; iteration++) {
-            await wait(3000)
-            await tryDismissCookieBanner(page)
+        try {
+            const dashboardURL = new URL(this.bot.config.baseURL)

-            // Check if account is suspended
-            const isSuspended = await page.waitForSelector('#suspendedAccountHeader', { visible: true, timeout: 3000 }).then(() => true).catch(() => false)
-            if (isSuspended) {
-                log('GO-HOME', 'This account is suspended!', 'error')
-                throw new Error('Account has been suspended!')
+            if (page.url() === dashboardURL.href) {
+                return
            }

-            try {
-                // If activities are found, exit the loop
-                await page.waitForSelector('#more-activities', { timeout: 1000 })
-                break
+            await page.goto(this.bot.config.baseURL)

-            } catch (error) {
-                // Continue if element is not found
+            const maxIterations = 5 // Maximum iterations set to 5
+
+            for (let iteration = 1; iteration <= maxIterations; iteration++) {
+                await this.bot.utils.wait(3000)
+                await this.bot.browser.utils.tryDismissAllMessages(page)
+
+                // Check if account is suspended
+                const isSuspended = await page.waitForSelector('#suspendedAccountHeader', { state: 'visible', timeout: 2000 }).then(() => true).catch(() => false)
+                if (isSuspended) {
+                    this.bot.log(this.bot.isMobile, 'GO-HOME', 'This account is suspended!', 'error')
+                    throw new Error('Account has been suspended!')
+                }
+
+                try {
+                    // If activities are found, exit the loop
+                    await page.waitForSelector('#more-activities', { timeout: 1000 })
+                    this.bot.log(this.bot.isMobile, 'GO-HOME', 'Visited homepage successfully')
+                    break
+
+                } catch (error) {
+                    // Continue if element is not found
+                }
+
+                // Below runs if the homepage was unable to be visited
+                const currentURL = new URL(page.url())
+
+                if (currentURL.hostname !== dashboardURL.hostname) {
+                    await this.bot.browser.utils.tryDismissAllMessages(page)
+
+                    await this.bot.utils.wait(2000)
+                    await page.goto(this.bot.config.baseURL)
+                } else {
+                    this.bot.log(this.bot.isMobile, 'GO-HOME', 'Visited homepage successfully')
+                    break
+                }
+
+                await this.bot.utils.wait(5000)
            }

-            const currentURL = new URL(page.url())
+        } 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> {
+        const dashboardURL = new URL(this.bot.config.baseURL)
+        const currentURL = new URL(this.bot.homePage.url())
+
+        try {
+            // Should never happen since tasks are opened in a new tab!
            if (currentURL.hostname !== dashboardURL.hostname) {
-                await tryDismissAllMessages(page)
-
-                await wait(2000)
-                await page.goto(baseURL)
+                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)
            }

-            await wait(5000)
-            log('GO-HOME', 'Visited homepage successfully')
+            // Reload the page to get new data
+            await this.bot.homePage.reload({ waitUntil: 'domcontentloaded' })
+
+            const scriptContent = await this.bot.homePage.evaluate(() => {
+                const scripts = Array.from(document.querySelectorAll('script'))
+                const targetScript = scripts.find(script => script.innerText.includes('var dashboard'))
+
+                return targetScript?.innerText ? targetScript.innerText : null
+            })
+
+            if (!scriptContent) {
+                throw this.bot.log(this.bot.isMobile, 'GET-DASHBOARD-DATA', 'Dashboard data not found within script', 'error')
+            }
+
+            // Extract the dashboard object from the script content
+            const dashboardData = await this.bot.homePage.evaluate(scriptContent => {
+                // Extract the dashboard object using regex
+                const regex = /var dashboard = (\{.*?\});/s
+                const match = regex.exec(scriptContent)
+
+                if (match && match[1]) {
+                    return JSON.parse(match[1])
+                }
+
+            }, scriptContent)
+
+            if (!dashboardData) {
+                throw this.bot.log(this.bot.isMobile, 'GET-DASHBOARD-DATA', 'Unable to parse dashboard script', 'error')
+            }
+
+            return dashboardData
+
+        } catch (error) {
+            throw this.bot.log(this.bot.isMobile, 'GET-DASHBOARD-DATA', `Error fetching dashboard data: ${error}`, 'error')
        }

-    } catch (error) {
-        console.error('An error occurred:', error)
-        return false
    }

-    return true
-}
+    /**
+     * Get search point counters
+     * @returns {Counters} Object of search counter data
+    */
+    async getSearchPoints(): Promise<Counters> {
+        const dashboardData = await this.getDashboardData() // Always fetch newest data

-export async function getDashboardData(page: Page): Promise<DashboardData> {
-    const dashboardURL = new URL(baseURL)
-    const currentURL = new URL(page.url())
-
-    // Should never happen since tasks are opened in a new tab!
-    if (currentURL.hostname !== dashboardURL.hostname) {
-        log('DASHBOARD-DATA', 'Provided page did not equal dashboard page, redirecting to dashboard page')
-        await goHome(page)
+        return dashboardData.userStatus.counters
    }

-    // Reload the page to get new data
-    await page.reload({ waitUntil: 'networkidle2' })
+    /**
+     * Get total earnable points with web browser
+     * @returns {number} Total earnable points
+    */
+    async getBrowserEarnablePoints(): Promise<EarnablePoints> {
+        try {
+            let desktopSearchPoints = 0
+            let mobileSearchPoints = 0
+            let dailySetPoints = 0
+            let morePromotionsPoints = 0

-    const scriptContent = await page.evaluate(() => {
-        const scripts = Array.from(document.querySelectorAll('script'))
-        const targetScript = scripts.find(script => script.innerText.includes('var dashboard'))
+            const data = await this.getDashboardData()

-        if (targetScript) {
-            return targetScript.innerText
-        } else {
-            throw log('GET-DASHBOARD-DATA', 'Script containing dashboard data not found', 'error')
+            // Desktop Search Points
+            if (data.userStatus.counters.pcSearch?.length) {
+                data.userStatus.counters.pcSearch.forEach(x => desktopSearchPoints += (x.pointProgressMax - x.pointProgress))
+            }
+
+            // Mobile Search Points
+            if (data.userStatus.counters.mobileSearch?.length) {
+                data.userStatus.counters.mobileSearch.forEach(x => mobileSearchPoints += (x.pointProgressMax - x.pointProgress))
+            }
+
+            // Daily Set
+            data.dailySetPromotions[this.bot.utils.getFormattedDate()]?.forEach(x => dailySetPoints += (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)
+                    }
+                })
+            }
+
+            const totalEarnablePoints = desktopSearchPoints + mobileSearchPoints + dailySetPoints + morePromotionsPoints
+
+            return {
+                dailySetPoints,
+                morePromotionsPoints,
+                desktopSearchPoints,
+                mobileSearchPoints,
+                totalEarnablePoints
+            }
+        } catch (error) {
+            throw this.bot.log(this.bot.isMobile, 'GET-BROWSER-EARNABLE-POINTS', 'An error occurred:' + error, 'error')
        }
-    })
+    }

-    // Extract the dashboard object from the script content
-    const dashboardData = await page.evaluate(scriptContent => {
-        // Extract the dashboard object using regex
-        const regex = /var dashboard = (\{.*?\});/s
-        const match = regex.exec(scriptContent)
+    /**
+     * Get total earnable points with mobile app
+     * @returns {number} Total earnable points
+    */
+    async getAppEarnablePoints(accessToken: string) {
+        try {
+            const points = {
+                readToEarn: 0,
+                checkIn: 0,
+                totalEarnablePoints: 0
+            }

-        if (match && match[1]) {
-            return JSON.parse(match[1])
-        } else {
-            throw log('GET-DASHBOARD-DATA', 'Dashboard data not found within script', 'error')
+            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 ${accessToken}`,
+                    'X-Rewards-Country': geoLocale,
+                    'X-Rewards-Language': 'en'
+                }
+            }
+
+            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) {
+                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 (checkInDay < 6 && (new Date()).getDate() != (new Date(item.attributes.last_updated ?? '')).getDate()) {
+                        points.checkIn = parseInt(item.attributes['day_' + (checkInDay + 1) + '_points'] ?? '')
+                    }
+                    break
+                }
+            }
+
+            points.totalEarnablePoints = points.readToEarn + points.checkIn
+
+            return points
+        } catch (error) {
+            throw this.bot.log(this.bot.isMobile, 'GET-APP-EARNABLE-POINTS', 'An error occurred:' + error, 'error')
        }
-    }, scriptContent)
+    }

-    return dashboardData
-}
+    /**
+     * Get current point amount
+     * @returns {number} Current total point amount
+    */
+    async getCurrentPoints(): Promise<number> {
+        try {
+            const data = await this.getDashboardData()

-export async function getQuizData(page: Page): Promise<QuizData> {
-    try {
-        const html = await page.content()
-        const $ = load(html)
+            return data.userStatus.availablePoints
+        } catch (error) {
+            throw this.bot.log(this.bot.isMobile, 'GET-CURRENT-POINTS', 'An error occurred:' + error, 'error')
+        }
+    }

-        const scriptContent = $('script').filter((index, element) => {
-            return $(element).text().includes('_w.rewardsQuizRenderInfo')
-        }).text()
+    /**
+     * 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)

-        if (scriptContent) {
-            const regex = /_w\.rewardsQuizRenderInfo\s*=\s*({.*?});/s
-            const match = regex.exec(scriptContent)
+            const scriptContent = $('script').filter((index, element) => {
+                return $(element).text().includes('_w.rewardsQuizRenderInfo')
+            }).text()

-            if (match && match[1]) {
-                const quizData = JSON.parse(match[1])
-                return quizData
+            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 log('GET-QUIZ-DATA', 'Quiz data not found within script', 'error')
+                throw this.bot.log(this.bot.isMobile, 'GET-QUIZ-DATA', 'Script containing quiz data not found', 'error')
            }
-        } else {
-            throw log('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')
        }

-    } catch (error) {
-        throw log('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)

-export async function getSearchPoints(page: Page): Promise<Counters> {
-    const dashboardData = await getDashboardData(page) // Always fetch newest data
-
-    return dashboardData.userStatus.counters
-}
-
-export async function getEarnablePoints(data: DashboardData, page: null | Page = null): Promise<number> {
-    try {
-        // Fetch new data if page is provided
-        if (page) {
-            data = await getDashboardData(page)
+            return true
+        } catch (error) {
+            this.bot.log(this.bot.isMobile, 'QUIZ-REFRESH', 'An error occurred:' + error, 'error')
+            return false
        }
+    }

-        // These only include the points from tasks that the script can complete!
-        let totalEarnablePoints = 0
+    async checkQuizCompleted(page: Page): Promise<boolean> {
+        try {
+            await page.waitForSelector('#quizCompleteContainer', { state: 'visible', timeout: 2000 })
+            await this.bot.utils.wait(2000)

-        // Desktop Search Points
-        data.userStatus.counters.pcSearch.forEach(x => totalEarnablePoints += (x.pointProgressMax - x.pointProgress))
-
-        // Mobile Search Points
-        if (data.userStatus.counters.mobileSearch?.length) {
-            data.userStatus.counters.mobileSearch.forEach(x => totalEarnablePoints += (x.pointProgressMax - x.pointProgress))
+            return true
+        } catch (error) {
+            return false
        }
-
-        // Daily Set
-        data.dailySetPromotions[getFormattedDate()]?.forEach(x => totalEarnablePoints += (x.pointProgressMax - x.pointProgress))
-
-        // More Promotions
-        data.morePromotions.forEach(x => {
-            // Only count points from supported activities
-            if (['quiz', 'urlreward'].includes(x.activityType)) {
-                totalEarnablePoints += (x.pointProgressMax - x.pointProgress)
-            }
-        })
-
-        return totalEarnablePoints
-    } catch (error) {
-        throw log('GET-EARNABLE-POINTS', 'An error occurred:' + error, 'error')
    }
-}

-export async function getCurrentPoints(data: DashboardData, page: null | Page = null): Promise<number> {
-    try {
-        // Fetch new data if page is provided
-        if (page) {
-            data = await getDashboardData(page)
-        }
-
-        return data.userStatus.availablePoints
-    } catch (error) {
-        throw log('GET-CURRENT-POINTS', 'An error occurred:' + error, 'error')
-    }
-}
-
-export async function loadSesion(email: string): Promise<string> {
-    const sessionDir = path.join(__dirname, sessionPath, email)
-
-    try {
-        // Create session dir
-        if (!fs.existsSync(sessionDir)) {
-            await fs.promises.mkdir(sessionDir, { recursive: true })
-        }
-
-        return sessionDir
-    } catch (error) {
-        throw new Error(error as string)
-    }
-}
-
-export async function waitForQuizRefresh(page: Page): Promise<boolean> {
-    try {
-        await page.waitForSelector('#rqHeaderCredits', { visible: true, timeout: 5000 })
-        await wait(2000)
-
-        return true
-    } catch (error) {
-        log('QUIZ-REFRESH', 'An error occurred:' + error, 'error')
-        return false
-    }
-}
-
-export async function checkQuizCompleted(page: Page): Promise<boolean> {
-    try {
-        await page.waitForSelector('#quizCompleteContainer', { visible: true, timeout: 1000 })
-        await wait(2000)
-
-        return true
-    } catch (error) {
-        return false
-    }
-}
-
-export async function refreshCheerio(page: Page): Promise<CheerioAPI> {
-    const html = await page.content()
-    const $ = load(html)
-
-    return $
-}
-
-export async function getPunchCardActivity(page: Page, activity: PromotionalItem | MorePromotion): Promise<string> {
-    let selector = ''
-    try {
+    async loadInCheerio(page: Page): Promise<CheerioAPI> {
        const html = await page.content()
        const $ = load(html)

-        const element = $('.offer-cta').toArray().find(x => x.attribs.href?.includes(activity.offerId))
-        if (element) {
-            selector = `a[href*="${element.attribs.href}"]`
-        }
-    } catch (error) {
-        log('GET-PUNCHCARD-ACTIVITY', 'An error occurred:' + error, 'error')
+        return $
    }

-    return selector
+    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 => 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 {
+            // Save cookies
+            await saveSessionData(this.bot.config.sessionPath, browser, email, this.bot.isMobile)
+
+            await this.bot.utils.wait(2000)
+
+            // Close browser
+            await browser.close()
+            this.bot.log(this.bot.isMobile, 'CLOSE-BROWSER', 'Browser closed cleanly!')
+        } catch (error) {
+            throw this.bot.log(this.bot.isMobile, 'CLOSE-BROWSER', 'An error occurred:' + error, 'error')
+        }
+    }
 }
--- a/src/browser/BrowserUtil.ts
+++ b/src/browser/BrowserUtil.ts
@@ -1,81 +1,115 @@
-import { Page } from 'puppeteer'
+import { Page } from 'rebrowser-playwright'
+import { load } from 'cheerio'

-import { wait } from './../util/Utils'
-import { log } from './../util/Logger'
+import { MicrosoftRewardsBot } from '../index'

-export async function tryDismissAllMessages(page: Page): Promise<boolean> {
-    const buttons = [
-        { 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' }
-    ]

-    let result = false
+export default class BrowserUtil {
+    private bot: MicrosoftRewardsBot

-    for (const button of buttons) {
+    constructor(bot: MicrosoftRewardsBot) {
+        this.bot = bot
+    }
+
+    async tryDismissAllMessages(page: Page): Promise<void> {
+        const buttons = [
+            { selector: 'button[type="submit"]', label: 'Submit Button' },
+            { 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
+            }
+        }
+    }
+
+    async getLatestTab(page: Page): Promise<Page> {
        try {
-            const element = await page.waitForSelector(button.selector, { visible: true, timeout: 1000 })
-            if (element) {
-                await element.click()
-                result = true
+            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) {
-            continue
+            throw this.bot.log(this.bot.isMobile, 'GET-TABS', 'An error occurred:' + error, 'error')
        }
    }

-    return result
-}
+    async reloadBadPage(page: Page): Promise<void> {
+        try {
+            const html = await page.content().catch(() => '')
+            const $ = load(html)

-export async function tryDismissCookieBanner(page: Page): Promise<void> {
-    try {
-        await page.waitForSelector('#cookieConsentContainer', { timeout: 1000 })
-        const cookieBanner = await page.$('#cookieConsentContainer')
+            const isNetworkError = $('body.neterror').length

-        if (cookieBanner) {
-            const button = await cookieBanner.$('button')
-            if (button) {
-                await button.click()
-                await wait(2000)
+            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')
        }
-
-    } catch (error) {
-        // Continue if element is not found or other error occurs
    }
-}

-export async function tryDismissBingCookieBanner(page: Page): Promise<void> {
-    try {
-        await page.waitForSelector('#bnp_btn_accept', { timeout: 1000 })
-        const cookieBanner = await page.$('#bnp_btn_accept')
-
-        if (cookieBanner) {
-            await cookieBanner.click()
-        }
-    } catch (error) {
-        // Continue if element is not found or other error occurs
-    }
-}
-
-export async function getLatestTab(page: Page): Promise<Page> {
-    try {
-        await wait(500)
-
-        const browser = page.browser()
-        const pages = await browser.pages()
-        const newTab = pages[pages.length - 1]
-
-        if (newTab) {
-            return newTab
-        }
-
-        throw log('GET-NEW-TAB', 'Unable to get latest tab', 'error')
-    } catch (error) {
-        throw log('GET-NEW-TAB', 'An error occurred:' + error, 'error')
-    }
 }
--- a/src/config.json
+++ b/src/config.json
@@ -2,19 +2,43 @@
    "baseURL": "https://rewards.bing.com",
    "sessionPath": "sessions",
    "headless": false,
-    "runOnZeroPoints": true,
+    "parallel": true,
+    "runOnZeroPoints": false,
    "clusters": 1,
+    "saveFingerprint": {
+        "mobile": false,
+        "desktop": false
+    },
    "workers": {
        "doDailySet": true,
        "doMorePromotions": true,
        "doPunchCards": true,
        "doDesktopSearch": true,
-        "doMobileSearch": true
+        "doMobileSearch": true,
+        "doDailyCheckIn": true,
+        "doReadToEarn": true
    },
+    "searchOnBingLocalQueries": false,
+    "globalTimeout": "30s",
    "searchSettings": {
        "useGeoLocaleQueries": false,
        "scrollRandomResults": true,
-        "clickRandomResults": 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,
--- a/src/crontab.template
+++ b/src/crontab.template
@@ -0,0 +1 @@
+${CRON_SCHEDULE} TZ=${TZ} /bin/bash /usr/src/microsoft-rewards-script/src/run_daily.sh >> /proc/1/fd/1 2>> /proc/1/fd/2
--- a/src/functions/Activities.ts
+++ b/src/functions/Activities.ts
@@ -0,0 +1,70 @@
+import { Page } from 'rebrowser-playwright'
+
+import { MicrosoftRewardsBot } from '../index'
+
+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'
+
+import { DashboardData, MorePromotion, PromotionalItem } from '../interface/DashboardData'
+
+
+export default class Activities {
+    private bot: MicrosoftRewardsBot
+
+    constructor(bot: MicrosoftRewardsBot) {
+        this.bot = bot
+    }
+
+    doSearch = async (page: Page, data: DashboardData): Promise<void> => {
+        const search = new Search(this.bot)
+        await search.doSearch(page, data)
+    }
+
+    doABC = async (page: Page): Promise<void> => {
+        const abc = new ABC(this.bot)
+        await abc.doABC(page)
+    }
+
+    doPoll = async (page: Page): Promise<void> => {
+        const poll = new Poll(this.bot)
+        await poll.doPoll(page)
+    }
+
+    doThisOrThat = async (page: Page): Promise<void> => {
+        const thisOrThat = new ThisOrThat(this.bot)
+        await thisOrThat.doThisOrThat(page)
+    }
+
+    doQuiz = async (page: Page): Promise<void> => {
+        const quiz = new Quiz(this.bot)
+        await quiz.doQuiz(page)
+    }
+
+    doUrlReward = async (page: Page): Promise<void> => {
+        const urlReward = new UrlReward(this.bot)
+        await urlReward.doUrlReward(page)
+    }
+
+    doSearchOnBing = async (page: Page, activity: MorePromotion | PromotionalItem): Promise<void> => {
+        const searchOnBing = new SearchOnBing(this.bot)
+        await searchOnBing.doSearchOnBing(page, activity)
+    }
+
+    doReadToEarn = async (accessToken: string, data: DashboardData): Promise<void> => {
+        const readToEarn = new ReadToEarn(this.bot)
+        await readToEarn.doReadToEarn(accessToken, data)
+    }
+
+    doDailyCheckIn = async (accessToken: string, data: DashboardData): Promise<void> => {
+        const dailyCheckIn = new DailyCheckIn(this.bot)
+        await dailyCheckIn.doDailyCheckIn(accessToken, data)
+    }
+
+}
--- a/src/functions/Login.ts
+++ b/src/functions/Login.ts
@@ -1,65 +1,231 @@
-import { Page } from 'puppeteer'
+import { Page } from 'rebrowser-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({
    input: process.stdin,
    output: process.stdout
 })

-import { tryDismissAllMessages, tryDismissBingCookieBanner } from '../browser/BrowserUtil'
-import { wait } from '../util/Utils'
-import { log } from '../util/Logger'
+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'

-export async function login(page: Page, email: string, password: string) {
+    constructor(bot: MicrosoftRewardsBot) {
+        this.bot = bot
+    }

-    try {
-        // Navigate to the Bing login page
-        await page.goto('https://login.live.com/')
+    async login(page: Page, email: string, password: string) {

-        const isLoggedIn = await page.waitForSelector('html[data-role-name="MeePortal"]', { timeout: 5000 }).then(() => true).catch(() => false)
+        try {
+            // Navigate to the Bing login page
+            await page.goto('https://rewards.bing.com/signin')

-        if (!isLoggedIn) {
-            const isLocked = await page.waitForSelector('.serviceAbusePageContainer', { visible: true, timeout: 5000 }).then(() => true).catch(() => false)
-            if (isLocked) {
-                log('LOGIN', 'This account has been locked!', 'error')
-                throw new Error('Account has been locked!')
+            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)
            }

-            await page.waitForSelector('#loginHeader', { visible: true, timeout: 10_000 })
+            // Check if logged in to bing
+            await this.checkBingLogin(page)

-            await execLogin(page, email, password)
-            log('LOGIN', 'Logged into Microsoft successfully')
-        } else {
-            log('LOGIN', 'Already logged in')
+            // 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')
        }
-
-        // Check if logged in to bing
-        await checkBingLogin(page)
-
-        // We're done logging in
-        log('LOGIN', 'Logged in successfully')
-
-    } catch (error) {
-        // Throw and don't continue
-        throw log('LOGIN', 'An error occurred:' + error, 'error')
    }
-}

-async function execLogin(page: Page, email: string, password: string) {
-    await page.type('#i0116', email)
-    await page.click('#idSIButton9')
+    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)

-    log('LOGIN', 'Email entered successfully')
+            // Check if account is locked
+            await this.checkAccountLocked(page)

-    try {
-        await page.waitForSelector('#i0118', { visible: true, timeout: 2000 })
-        await wait(2000)
+            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')
+        }
+    }

-        await page.type('#i0118', password)
-        await page.click('#idSIButton9')
+    private async enterEmail(page: Page, email: string) {
+        const emailInputSelector = 'input[type="email"]'

-    } catch (error) {
-        log('LOGIN', '2FA code required')
+        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"]'
+
+        try {
+            // 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) {
+                // Authentictor 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', { 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', { 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('#i0281', { 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"]')
+                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) => {
@@ -68,58 +234,122 @@ async function execLogin(page: Page, email: string, password: string) {
            })
        })

-        await page.type('input[name="otc"]', code)
+        await page.fill('input[name="otc"]', code)
        await page.keyboard.press('Enter')
-
-    } finally {
-        log('LOGIN', 'Password entered successfully')
+        this.bot.log(this.bot.isMobile, 'LOGIN', '2FA code entered successfully')
    }

-    const currentURL = new URL(page.url())
+    private async checkLoggedIn(page: Page) {
+        const targetHostname = 'rewards.bing.com'
+        const targetPathname = '/'

-    while (currentURL.pathname !== '/' || currentURL.hostname !== 'account.microsoft.com') {
-        await tryDismissAllMessages(page)
-        currentURL.href = page.url()
-    }
-
-    // Wait for login to complete
-    await page.waitForSelector('html[data-role-name="MeePortal"]', { timeout: 10_000 })
-}
-
-async function checkBingLogin(page: Page): Promise<void> {
-    try {
-        log('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 wait(3000)
-                await tryDismissBingCookieBanner(page)
-
-                const loggedIn = await checkBingLoginStatus(page)
-                if (loggedIn) {
-                    log('LOGIN-BING', 'Bing login verification passed!')
-                    break
-                }
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            await this.bot.browser.utils.tryDismissAllMessages(page)
+            const currentURL = new URL(page.url())
+            if (currentURL.hostname === targetHostname && currentURL.pathname === targetPathname) {
+                break
            }
-
-            await wait(1000)
        }

-    } catch (error) {
-        log('LOGIN-BING', 'An error occurred:' + error, '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')
    }
-}

-async function checkBingLoginStatus(page: Page): Promise<boolean> {
-    try {
-        await page.waitForSelector('#id_n', { timeout: 5000 })
-        return true
-    } catch (error) {
-        return false
+    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
+        }
+    }
+
+    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)
+
+        await page.goto(authorizeUrl.href)
+
+        let currentUrl = new URL(page.url())
+        let code: string
+
+        this.bot.log(this.bot.isMobile, 'LOGIN-APP', 'Waiting for authorization...')
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            if (currentUrl.hostname === 'login.live.com' && currentUrl.pathname === '/oauth20_desktop.srf') {
+                code = currentUrl.searchParams.get('code')!
+                break
+            }
+
+            currentUrl = new URL(page.url())
+            await this.bot.utils.wait(5000)
+        }
+
+        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
+
+        this.bot.log(this.bot.isMobile, 'LOGIN-APP', 'Successfully authorized')
+        return tokenData.access_token
+    }
+
+    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')
+        }
    }
 }
--- a/src/functions/Workers.ts
+++ b/src/functions/Workers.ts
@@ -1,173 +1,230 @@
-import { Page } from 'puppeteer'
-
-import { doPoll } from './activities/Poll'
-import { doQuiz } from './activities/Quiz'
-import { doUrlReward } from './activities/UrlReward'
-import { doThisOrThat } from './activities/ThisOrThat'
-import { doABC } from './activities/ABC'
-
-import { getPunchCardActivity } from '../browser/BrowserFunc'
-import { getLatestTab } from '../browser/BrowserUtil'
-
-import { getFormattedDate, wait } from '../util/Utils'
-import { log } from '../util/Logger'
+import { Page } from 'rebrowser-playwright'

 import { DashboardData, MorePromotion, PromotionalItem, PunchCard } from '../interface/DashboardData'

-import { baseURL } from '../config.json'
+import { MicrosoftRewardsBot } from '../index'

-// Daily Set
-export async function doDailySet(page: Page, data: DashboardData) {
+export class Workers {
+    public bot: MicrosoftRewardsBot

-    const todayData = data.dailySetPromotions[getFormattedDate()]
-
-    const activitiesUncompleted = todayData?.filter(x => !x.complete && x.pointProgressMax > 0) ?? []
-
-    if (!activitiesUncompleted.length) {
-        log('DAILY-SET', 'All Daily Set" items have already been completed')
-        return
+    constructor(bot: MicrosoftRewardsBot) {
+        this.bot = bot
    }

-    // Solve Activities
-    log('DAILY-SET', 'Started solving "Daily Set" items')
+    // Daily Set
+    async doDailySet(page: Page, data: DashboardData) {
+        const todayData = data.dailySetPromotions[this.bot.utils.getFormattedDate()]

-    await solveActivities(page, activitiesUncompleted)
+        const activitiesUncompleted = todayData?.filter(x => !x.complete && x.pointProgressMax > 0) ?? []

-    log('DAILY-SET', 'All "Daily Set" items have been completed')
-}
-
-// Punch Card
-export async function doPunchCard(page: Page, data: DashboardData) {
-
-    const punchCardsUncompleted = data.punchCards?.filter(x => !x.parentPromotion.complete) ?? [] // Only return uncompleted punch cards
-
-    if (!punchCardsUncompleted.length) {
-        log('PUNCH-CARD', 'All "Punch Cards" have already been completed')
-        return
-    }
-
-    for (const punchCard of punchCardsUncompleted) {
-        const activitiesUncompleted = punchCard.childPromotions.filter(x => !x.complete) // Only return uncompleted activities
+        if (!activitiesUncompleted.length) {
+            this.bot.log(this.bot.isMobile, 'DAILY-SET', 'All Daily Set" items have already been completed')
+            return
+        }

        // Solve Activities
-        log('PUNCH-CARD', `Started solving "Punch Card" items for punchcard: "${punchCard.parentPromotion.title}"`)
+        this.bot.log(this.bot.isMobile, 'DAILY-SET', 'Started solving "Daily Set" items')

-        const browser = page.browser()
-        page = await browser.newPage()
+        await this.solveActivities(page, activitiesUncompleted)

-        // Got to punch card index page in a new tab
-        await page.goto(punchCard.parentPromotion.destinationUrl, { referer: baseURL })
+        page = await this.bot.browser.utils.getLatestTab(page)

-        await solveActivities(page, activitiesUncompleted, punchCard)
+        // Always return to the homepage if not already
+        await this.bot.browser.func.goHome(page)

-        // Close the punch card index page
-        await page.close()
-
-        log('PUNCH-CARD', `All items for punchcard: "${punchCard.parentPromotion.title}" have been completed`)
+        this.bot.log(this.bot.isMobile, 'DAILY-SET', 'All "Daily Set" items have been completed')
    }

-    log('PUNCH-CARD', 'All "Punch Card" items have been completed')
-}
+    // Punch Card
+    async doPunchCard(page: Page, data: DashboardData) {

-// More Promotions
-export async function doMorePromotions(page: Page, data: DashboardData) {
-    const morePromotions = data.morePromotions
+        const punchCardsUncompleted = data.punchCards?.filter(x => x.parentPromotion && !x.parentPromotion.complete) ?? [] // Only return uncompleted punch cards

-    // 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)
+        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')
    }

-    const activitiesUncompleted = morePromotions?.filter(x => !x.complete && x.pointProgressMax > 0) ?? []
+    // More Promotions
+    async doMorePromotions(page: Page, data: DashboardData) {
+        const morePromotions = data.morePromotions

-    if (!activitiesUncompleted.length) {
-        log('MORE-PROMOTIONS', 'All "More Promotion" items have already been completed')
-        return
+        // 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.log(this.bot.isMobile, 'MORE-PROMOTIONS', 'All "More Promotion" items have already been completed')
+            return
+        }
+
+        // Solve Activities
+        this.bot.log(this.bot.isMobile, 'MORE-PROMOTIONS', 'Started solving "More Promotions" items')
+
+        page = await this.bot.browser.utils.getLatestTab(page)
+
+        await this.solveActivities(page, activitiesUncompleted)
+
+        page = await this.bot.browser.utils.getLatestTab(page)
+
+        // Always return to the homepage if not already
+        await this.bot.browser.func.goHome(page)
+
+        this.bot.log(this.bot.isMobile, 'MORE-PROMOTIONS', 'All "More Promotion" items have been completed')
    }

-    // Solve Activities
-    log('MORE-PROMOTIONS', 'Started solving "More Promotions" item')
+    // 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

-    await solveActivities(page, activitiesUncompleted)
+        for (const activity of activities) {
+            try {
+                // Reselect the worker page
+                activityPage = await this.bot.browser.utils.getLatestTab(activityPage)

-    log('MORE-PROMOTIONS', 'All "More Promotion" items have been completed')
-}
+                const pages = activityPage.context().pages()
+                if (pages.length > 3) {
+                    await activityPage.close()

-// Solve all the different types of activities
-async function solveActivities(page: Page, activities: PromotionalItem[] | MorePromotion[], punchCard?: PunchCard) {
-    for (const activity of activities) {
-        try {
-
-            let selector = `[data-bi-id="${activity.offerId}"]`
-
-            if (punchCard) {
-                selector = await getPunchCardActivity(page, activity)
-
-            } else if (activity.name.toLowerCase().includes('membercenter')) {
-
-                // Promotion
-                if (activity.priority === 1) {
-                    selector = '#promo-item'
-                } else {
-                    selector = `[data-bi-id="${activity.name}"]`
+                    activityPage = await this.bot.browser.utils.getLatestTab(activityPage)
                }
+
+                await this.bot.utils.wait(1000)
+
+                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
+                        }
+                        break
+
+                    // UrlReward (Visit)
+                    case 'urlreward':
+                        // Search on Bing are subtypes of "urlreward"
+                        if (activity.name.toLowerCase().includes('exploreonbing')) {
+                            this.bot.log(this.bot.isMobile, 'ACTIVITY', `Found activity type: "SearchOnBing" title: "${activity.title}"`)
+                            await activityPage.click(selector)
+                            activityPage = await this.bot.browser.utils.getLatestTab(activityPage)
+                            await this.bot.activities.doSearchOnBing(activityPage, activity)
+
+                        } else {
+                            this.bot.log(this.bot.isMobile, 'ACTIVITY', `Found activity type: "UrlReward" title: "${activity.title}"`)
+                            await activityPage.click(selector)
+                            activityPage = await this.bot.browser.utils.getLatestTab(activityPage)
+                            await this.bot.activities.doUrlReward(activityPage)
+                        }
+                        break
+
+                    // Unsupported types
+                    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(2000)
+
+            } catch (error) {
+                this.bot.log(this.bot.isMobile, 'ACTIVITY', 'An error occurred:' + error, 'error')
            }

-            // Wait for element to load
-            await page.waitForSelector(selector, { timeout: 5000 })
-            // Click element, it will be opened in a new tab
-            await page.click(selector)
-
-            // Select the new activity page
-            const activityPage = await getLatestTab(page)
-
-            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')) {
-                                log('ACTIVITY', `Found activity type: "Poll" title: "${activity.title}"`)
-                                await doPoll(activityPage)
-                            } else { // ABC
-                                log('ACTIVITY', `Found activity type: "ABC" title: "${activity.title}"`)
-                                await doABC(activityPage)
-                            }
-                            break
-
-                        // This Or That Quiz (Usually 50 points)
-                        case 50:
-                            log('ACTIVITY', `Found activity type: "ThisOrThat" title: "${activity.title}"`)
-                            await doThisOrThat(activityPage)
-                            break
-
-                        // Quizzes are usually 30-40 points
-                        default:
-                            log('ACTIVITY', `Found activity type: "Quiz" title: "${activity.title}"`)
-                            await doQuiz(activityPage)
-                            break
-                    }
-                    break
-
-                // UrlReward (Visit)
-                case 'urlreward':
-                    log('ACTIVITY', `Found activity type: "UrlReward" title: "${activity.title}"`)
-                    await doUrlReward(activityPage)
-                    break
-
-                // Misc, Usually UrlReward Type
-                default:
-                    log('ACTIVITY', `Found activity type: "Misc" title: "${activity.title}"`)
-                    await doUrlReward(activityPage)
-                    break
-            }
-
-            // Cooldown
-            await wait(1500)
-        } catch (error) {
-            log('ACTIVITY', 'An error occurred:' + error, 'error')
        }
    }
+
 }
--- a/src/functions/activities/ABC.ts
+++ b/src/functions/activities/ABC.ts
@@ -1,52 +1,52 @@
-import { Page } from 'puppeteer'
+import { Page } from 'rebrowser-playwright'

-import { refreshCheerio } from '../../browser/BrowserFunc'
-import { getLatestTab } from '../../browser/BrowserUtil'
-import { log } from '../../util/Logger'
-import { randomNumber, wait } from '../../util/Utils'
+import { Workers } from '../Workers'

-export async function doABC(page: Page) {
-    log('ABC', 'Trying to complete poll')

-    try {
-        await wait(2000)
-        let $ = await refreshCheerio(page)
+export class ABC extends Workers {

-        // 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', { visible: true, timeout: 5000 })
+    async doABC(page: Page) {
+        this.bot.log(this.bot.isMobile, 'ABC', 'Trying to complete poll')

-            const answers = $('.wk_OptionClickClass')
-            const answer = answers[randomNumber(0, 2)]?.attribs['id']
+        try {
+            let $ = await this.bot.browser.func.loadInCheerio(page)

-            await page.waitForSelector(`#${answer}`, { visible: true, timeout: 5000 })
+            // 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 })

-            await wait(2000)
-            await page.click(`#${answer}`) // Click answer
+                const answers = $('.wk_OptionClickClass')
+                const answer = answers[this.bot.utils.randomNumber(0, 2)]?.attribs['id']

-            await wait(4000)
-            await page.waitForSelector('div.wk_button', { visible: true, timeout: 5000 })
-            await page.click('div.wk_button') // Click next question button
+                await page.waitForSelector(`#${answer}`, { state: 'visible', timeout: 10000 })

-            page = await getLatestTab(page)
-            $ = await refreshCheerio(page)
-            await wait(1000)
+                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')
        }
-
-        await wait(4000)
-        await page.close()
-
-        if (i === maxIterations) {
-            log('ABC', 'Failed to solve quiz, exceeded max iterations of 15', 'warn')
-        } else {
-            log('ABC', 'Completed the ABC successfully')
-        }
-
-    } catch (error) {
-        await page.close()
-        log('ABC', 'An error occurred:' + error, 'error')
    }
-}

+}
--- a/src/functions/activities/DailyCheckIn.ts
+++ b/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')
+        }
+    }
+
+}
--- a/src/functions/activities/Poll.ts
+++ b/src/functions/activities/Poll.ts
@@ -1,26 +1,29 @@
-import { Page } from 'puppeteer'
+import { Page } from 'rebrowser-playwright'

-import { log } from '../../util/Logger'
-import { randomNumber, wait } from '../../util/Utils'
+import { Workers } from '../Workers'

-export async function doPoll(page: Page) {
-    log('POLL', 'Trying to complete poll')

-    try {
-        const buttonId = `#btoption${Math.floor(randomNumber(0, 1))}`
+export class Poll extends Workers {

-        await page.waitForNetworkIdle({ timeout: 5000 })
-        await page.waitForSelector(buttonId, { visible: true, timeout: 5000 })
-        await wait(2000)
+    async doPoll(page: Page) {
+        this.bot.log(this.bot.isMobile, 'POLL', 'Trying to complete poll')

-        await page.click(buttonId)
+        try {
+            const buttonId = `#btoption${Math.floor(this.bot.utils.randomNumber(0, 1))}`

-        await wait(4000)
-        await page.close()
+            await page.waitForSelector(buttonId, { state: 'visible', timeout: 10000 }).catch(() => { }) // We're gonna click regardless or not
+            await this.bot.utils.wait(2000)

-        log('POLL', 'Completed the poll successfully')
-    } catch (error) {
-        await page.close()
-        log('POLL', 'An error occurred:' + error, 'error')
+            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')
+        }
    }
+
 }
--- a/src/functions/activities/Quiz.ts
+++ b/src/functions/activities/Quiz.ts
@@ -1,94 +1,92 @@
-import { Page } from 'puppeteer'
+import { Page } from 'rebrowser-playwright'

-import { getQuizData, waitForQuizRefresh } from '../../browser/BrowserFunc'
-import { wait } from '../../util/Utils'
-import { log } from '../../util/Logger'
+import { Workers } from '../Workers'

-export async function doQuiz(page: Page) {
-    log('QUIZ', 'Trying to complete quiz')

-    try {
-        await page.waitForNetworkIdle({ timeout: 5000 })
-        await wait(2000)
+export class Quiz extends Workers {

-        // Check if the quiz has been started or not
-        const quizNotStarted = await page.waitForSelector('#rqStartQuiz', { visible: true, timeout: 3000 }).then(() => true).catch(() => false)
-        if (quizNotStarted) {
-            await page.click('#rqStartQuiz')
-        } else {
-            log('QUIZ', 'Quiz has already been started, trying to finish it')
-        }
+    async doQuiz(page: Page) {
+        this.bot.log(this.bot.isMobile, 'QUIZ', 'Trying to complete quiz')

-        await wait(2000)
+        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')
+            }

-        let quizData = await getQuizData(page)
-        const questionsRemaining = quizData.maxQuestions - quizData.CorrectlyAnsweredQuestionCount // Amount of questions remaining
+            await this.bot.utils.wait(2000)

-        // All questions
-        for (let question = 0; question < questionsRemaining; question++) {
+            let quizData = await this.bot.browser.func.getQuizData(page)
+            const questionsRemaining = quizData.maxQuestions - quizData.CorrectlyAnsweredQuestionCount // Amount of questions remaining

-            if (quizData.numberOfOptions === 8) {
-                const answers: string[] = []
+            // All questions
+            for (let question = 0; question < questionsRemaining; question++) {

-                for (let i = 0; i < quizData.numberOfOptions; i++) {
-                    const answerSelector = await page.waitForSelector(`#rqAnswerOption${i}`, { visible: true, timeout: 5000 })
-                    const answerAttribute = await answerSelector?.evaluate(el => el.getAttribute('iscorrectoption'))
+                if (quizData.numberOfOptions === 8) {
+                    const answers: string[] = []

-                    if (answerAttribute && answerAttribute.toLowerCase() === 'true') {
-                        answers.push(`#rqAnswerOption${i}`)
+                    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 => el.getAttribute('iscorrectoption'))
+
+                        if (answerAttribute && answerAttribute.toLowerCase() === 'true') {
+                            answers.push(`#rqAnswerOption${i}`)
+                        }
                    }
-                }

-                // Click the answers
-                for (const answer of answers) {
-                    await page.waitForSelector(answer, { visible: true, timeout: 2000 })
+                    // 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 waitForQuizRefresh(page)
-                    if (!refreshSuccess) {
-                        await page.close()
-                        log('QUIZ', 'An error occurred, refresh was unsuccessful', 'error')
-                        return
-                    }
-                }
-
-                // Other type quiz
-            } else if ([2, 3, 4].includes(quizData.numberOfOptions)) {
-                quizData = await getQuizData(page) // Refresh Quiz Data
-                const correctOption = quizData.correctAnswer
-
-                for (let i = 0; i < quizData.numberOfOptions; i++) {
-
-                    const answerSelector = await page.waitForSelector(`#rqAnswerOption${i}`, { visible: true, timeout: 5000 })
-                    const dataOption = await answerSelector?.evaluate(el => el.getAttribute('data-option'))
-
-                    if (dataOption === correctOption) {
                        // Click the answer on page
-                        await page.click(`#rqAnswerOption${i}`)
+                        await page.click(answer)

-                        const refreshSuccess = await waitForQuizRefresh(page)
+                        const refreshSuccess = await this.bot.browser.func.waitForQuizRefresh(page)
                        if (!refreshSuccess) {
                            await page.close()
-                            log('QUIZ', 'An error occurred, refresh was unsuccessful', 'error')
+                            this.bot.log(this.bot.isMobile, 'QUIZ', 'An error occurred, refresh was unsuccessful', 'error')
                            return
                        }
                    }
-                }
-                await wait(2000)

+                    // 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 => 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()

-        // Done with
-        await wait(2000)
-        await page.close()
-        log('QUIZ', 'Completed the quiz successfully')
-    } catch (error) {
-        await page.close()
-        log('QUIZ', 'An error occurred:' + error, 'error')
+            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')
+        }
    }

 }
--- a/src/functions/activities/ReadToEarn.ts
+++ b/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')
+        }
+    }
+}
--- a/src/functions/activities/Search.ts
+++ b/src/functions/activities/Search.ts
@@ -1,331 +1,400 @@
-import { Page } from 'puppeteer'
-import axios from 'axios'
+import { Page } from 'rebrowser-playwright'
+import { platform } from 'os'

-import { getLatestTab } from '../../browser/BrowserUtil'
-import { getSearchPoints } from '../../browser/BrowserFunc'
-import { log } from '../../util/Logger'
-import { randomNumber, shuffleArray, wait } from '../../util/Utils'
+import { Workers } from '../Workers'

-import { searchSettings } from '../../config.json'
-
-import { DashboardData, DashboardImpression } from '../../interface/DashboardData'
-import { GoogleTrends } from '../../interface/GoogleDailyTrends'
+import { Counters, DashboardData } from '../../interface/DashboardData'
 import { GoogleSearch } from '../../interface/Search'
+import { AxiosRequestConfig } from 'axios'

-export async function doSearch(page: Page, data: DashboardData, mobile: boolean) {
-    log('SEARCH-BING', 'Starting bing searches')
+type GoogleTrendsResponse = [
+    string,
+    [
+        string,
+        ...null[],
+        [string, ...string[]]
+    ][]
+];

-    const mobileData = data.userStatus.counters?.mobileSearch ? data.userStatus.counters.mobileSearch[0] : null // Mobile searches
-    const edgeData = data.userStatus.counters.pcSearch[1] as DashboardImpression // Edge searches
-    const genericData = data.userStatus.counters.pcSearch[0] as DashboardImpression  // Normal searches
+export class Search extends Workers {
+    private bingHome = 'https://bing.com'
+    private searchPageURL = ''

-    let missingPoints = (mobile && mobileData) ?
-        (mobileData.pointProgressMax - mobileData.pointProgress) :
-        (edgeData.pointProgressMax - edgeData.pointProgress) + (genericData.pointProgressMax - genericData.pointProgress)
+    public async doSearch(page: Page, data: DashboardData) {
+        this.bot.log(this.bot.isMobile, 'SEARCH-BING', 'Starting Bing searches')

-    if (missingPoints == 0) {
-        log('SEARCH-BING', `Bing searches for ${mobile ? 'MOBILE' : 'DESKTOP'} have already been completed`)
-        return
-    }
+        page = await this.bot.browser.utils.getLatestTab(page)

-    // Generate search queries
-    let googleSearchQueries = await getGoogleTrends(data.userProfile.attributes.country, missingPoints)
-    googleSearchQueries = shuffleArray(googleSearchQueries)
+        let searchCounters: Counters = await this.bot.browser.func.getSearchPoints()
+        let missingPoints = this.calculatePoints(searchCounters)

-    // Deduplicate the search terms
-    googleSearchQueries = [...new Set(googleSearchQueries)]
-
-    // Open a new tab
-    const browser = page.browser()
-    const searchPage = await browser.newPage()
-
-    // Go to bing
-    await searchPage.goto('https://bing.com')
-
-    let maxLoop = 0 // If the loop hits 10 this when not gaining any points, we're assuming it's stuck. If it ddoesn't continue after 5 more searches with alternative queries, abort search
-
-    const queries: string[] = []
-    googleSearchQueries.forEach(x => 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
-
-        log('SEARCH-BING', `${missingPoints} Points Remaining | Query: ${query} | Mobile: ${mobile}`)
-
-        const newData = await bingSearch(page, searchPage, query)
-
-        const newMobileData = newData.mobileSearch ? newData.mobileSearch[0] : null // Mobile searches
-        const newEdgeData = newData.pcSearch[1] as DashboardImpression // Edge searches
-        const newGenericData = newData.pcSearch[0] as DashboardImpression  // Normal searches
-
-        const newMissingPoints = (mobile && newMobileData) ?
-            (newMobileData.pointProgressMax - newMobileData.pointProgress) :
-            (newEdgeData.pointProgressMax - newEdgeData.pointProgress) + (newGenericData.pointProgressMax - newGenericData.pointProgress)
-
-        // 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
+        if (missingPoints === 0) {
+            this.bot.log(this.bot.isMobile, 'SEARCH-BING', 'Bing searches have already been completed')
+            return
        }

-        missingPoints = newMissingPoints
+        // Generate search queries
+        let googleSearchQueries = await this.getGoogleTrends(this.bot.config.searchSettings.useGeoLocaleQueries ? data.userProfile.attributes.country : 'US')
+        googleSearchQueries = this.bot.utils.shuffleArray(googleSearchQueries)

-        if (missingPoints == 0) {
-            break
+        // 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
+            }
        }

-        // If we didn't gain points for 10 iterations, assume it's stuck
-        if (maxLoop > 10) {
-            log('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) {
-        log('SEARCH-BING', `Search completed but we're missing ${missingPoints} points, generating extra searches`)
+        // 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
+            let i = 0
+            while (missingPoints > 0) {
+                const query = googleSearchQueries[i++] as GoogleSearch

-            // Get related search terms to the Google search queries
-            const relatedTerms = await getRelatedTerms(query?.topic)
-            if (relatedTerms.length > 3) {
-                // Search for the first 2 related terms
-                for (const term of relatedTerms.slice(1, 3)) {
-                    log('SEARCH-BING-EXTRA', `${missingPoints} Points Remaining | Query: ${term} | Mobile: ${mobile}`)
-                    const newData = await bingSearch(page, searchPage, query.topic)
+                // 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}`)

-                    const newMobileData = newData.mobileSearch ? newData.mobileSearch[0] : null // Mobile searches
-                    const newEdgeData = newData.pcSearch[1] as DashboardImpression // Edge searches
-                    const newGenericData = newData.pcSearch[0] as DashboardImpression  // Normal searches
+                        searchCounters = await this.bingSearch(page, term)
+                        const newMissingPoints = this.calculatePoints(searchCounters)

-                    const newMissingPoints = (mobile && newMobileData) ?
-                        (newMobileData.pointProgressMax - newMobileData.pointProgress) :
-                        (newEdgeData.pointProgressMax - newEdgeData.pointProgress) + (newGenericData.pointProgressMax - newGenericData.pointProgress)
+                        // 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
+                        }

-                    // 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

-                    missingPoints = newMissingPoints
+                        // If we satisfied the searches
+                        if (missingPoints === 0) {
+                            break
+                        }

-                    // 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) {
-                        log('SEARCH-BING-EXTRA', 'Search didn\'t gain point for 5 iterations aborting searches', 'warn')
-                        return
+                        // 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')
    }

-    log('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}`)

-async function bingSearch(page: Page, searchPage: Page, query: string) {
-    // Try a max of 5 times
-    for (let i = 0; i < 5; i++) {
        try {
-            const searchBar = '#sb_form_q'
-            await searchPage.waitForSelector(searchBar, { visible: true, timeout: 10_000 })
-            await searchPage.click(searchBar) // Focus on the textarea
-            await wait(500)
-            await searchPage.keyboard.down('Control')
-            await searchPage.keyboard.press('A')
-            await searchPage.keyboard.press('Backspace')
-            await searchPage.keyboard.up('Control')
-            await searchPage.keyboard.type(query)
-            await searchPage.keyboard.press('Enter')
-
-            if (searchSettings.scrollRandomResults) {
-                await wait(2000)
-                await randomScroll(searchPage)
+            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]"]]]`
            }

-            if (searchSettings.clickRandomResults) {
-                await wait(2000)
-                await clickRandomLink(searchPage)
+            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')
            }

-            await wait(Math.floor(randomNumber(10_000, 20_000)))
+            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()
+            }

-            return await getSearchPoints(page)
+            for (const [topic, relatedQueries] of mappedTrendsData) {
+                queryTerms.push({
+                    topic: topic as string,
+                    related: relatedQueries as string[]
+                })
+            }

        } catch (error) {
-            if (i === 5) {
-                log('SEARCH-BING', 'Failed after 5 retries... An error occurred:' + error, 'error')
-                break
-
-            }
-            log('SEARCH-BING', 'Search failed, An error occurred:' + error, 'error')
-            log('SEARCH-BING', `Retrying search, attempt ${i}/5`, 'warn')
-
-            await wait(4000)
+            this.bot.log(this.bot.isMobile, 'SEARCH-GOOGLE-TRENDS', 'An error occurred:' + error, 'error')
        }
+
+        return queryTerms
    }

-    log('SEARCH-BING', 'Search failed after 5 retries, ending', 'error')
-    return await getSearchPoints(page)
-}
+    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
+                }
+            }
+        }

-async function getGoogleTrends(geoLocale: string, queryCount: number): Promise<GoogleSearch[]> {
-    const queryTerms: GoogleSearch[] = []
-    let i = 0
-
-    geoLocale = (searchSettings.useGeoLocaleQueries && geoLocale.length === 2) ? geoLocale.toUpperCase() : 'US'
-
-    log('SEARCH-GOOGLE-TRENDS', `Generating search queries, can take a while! | GeoLocale: ${geoLocale}`)
-
-    while (queryCount > queryTerms.length) {
-        i += 1
-        const date = new Date()
-        date.setDate(date.getDate() - i)
-        const formattedDate = formatDate(date)
+        return null
+    }

+    private async getRelatedTerms(term: string): Promise<string[]> {
        try {
            const request = {
-                url: `https://trends.google.com/trends/api/dailytrends?geo=${geoLocale}&hl=en&ed=${formattedDate}&ns=15`,
+                url: `https://api.bing.com/osjson.aspx?query=${term}`,
                method: 'GET',
                headers: {
                    'Content-Type': 'application/json'
                }
            }

-            const response = await axios(request)
+            const response = await this.bot.axios.request(request, this.bot.config.proxy.proxyBingTerms)

-            const data: GoogleTrends = JSON.parse((await response.data).slice(5))
+            return response.data[1] as string[]
+        } catch (error) {
+            this.bot.log(this.bot.isMobile, 'SEARCH-BING-RELATED', 'An error occurred:' + error, 'error')
+        }

-            for (const topic of data.default.trendingSearchesDays[0]?.trendingSearches ?? []) {
-                queryTerms.push({
-                    topic: topic.title.query.toLowerCase(),
-                    related: topic.relatedQueries.map(x => x.query.toLocaleLowerCase())
-                })
-            }
+        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) => {
+                window.scrollTo(0, scrollPos)
+            }, randomScrollPosition)

        } catch (error) {
-            log('SEARCH-GOOGLE-TRENDS', 'An error occurred:' + error, 'error')
+            this.bot.log(this.bot.isMobile, 'SEARCH-RANDOM-SCROLL', 'An error occurred:' + error, 'error')
        }
    }

-    return queryTerms
-}
+    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

-async function getRelatedTerms(term: string): Promise<string[]> {
-    try {
-        const request = {
-            url: `https://api.bing.com/osjson.aspx?query=${term}`,
-            method: 'GET',
-            headers: {
-                'Content-Type': 'application/json'
-            }
-        }
+            // Only used if the browser is not the edge browser (continue on Edge popup)
+            await this.closeContinuePopup(page)

-        const response = await axios(request)
+            // Stay for 10 seconds for page to load and "visit"
+            await this.bot.utils.wait(10000)

-        return response.data[1] as string[]
-    } catch (error) {
-        log('SEARCH-BING-RELTATED', 'An error occurred:' + error, 'error')
-    }
-    return []
-}
+            // 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)

-function formatDate(date: Date): string {
-    const year = date.getFullYear()
-    const month = String(date.getMonth() + 1).padStart(2, '0')
-    const day = String(date.getDate()).padStart(2, '0')
-
-    return `${year}${month}${day}`
-}
-
-async function randomScroll(page: Page) {
-    try {
-        // Press the arrow down key to scroll
-        for (let i = 0; i < randomNumber(5, 100); i++) {
-            await page.keyboard.press('ArrowDown')
-        }
-    } catch (error) {
-        log('SEARCH-RANDOM-SCROLL', 'An error occurred:' + error, 'error')
-    }
-}
-
-async function clickRandomLink(page: Page) {
-    try {
-        const searchListingURL = new URL(page.url()) // Get searchPage info before clicking
-
-        await page.click('#b_results .b_algo h2').catch(() => { }) // Since we don't really care if it did it or not
-
-        // Wait for website to load
-        await wait(3000)
-
-        // Will get current tab if no new one is created
-        let lastTab = await getLatestTab(page)
-
-        // Wait for the body of the new page to be loaded
-        await lastTab.waitForSelector('body', { timeout: 10_000 }).catch(() => { })
-
-        // Check if the tab is closed or not
-        if (!lastTab.isClosed()) {
-            let lastTabURL = new URL(lastTab.url()) // Get new tab info
+            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 !== searchListingURL.href && i < 5) {
-                // If hostname is still bing, (Bing images/news etc)
-                if (lastTabURL.hostname == searchListingURL.hostname) {
-                    await lastTab.goBack()
+            while (lastTabURL.href !== this.searchPageURL && i < 5) {

-                    lastTab = await getLatestTab(page) // Get last opened tab
+                await this.closeTabs(lastTab)

-                    // If "goBack" didn't return to search listing (due to redirects)
-                    if (lastTabURL.hostname !== searchListingURL.hostname) {
-                        await lastTab.goto(searchListingURL.href)
-                    }
-
-                } else { // No longer on bing, likely opened a new tab, close this tab
-                    lastTab = await getLatestTab(page) // Get last opened tab
-                    lastTabURL = new URL(lastTab.url())
-
-                    const tabs = await (page.browser()).pages() // Get all tabs open
-
-                    // If the browser has more than 3 tabs open, it has opened a new one, we need to close this one.
-                    if (tabs.length > 3) {
-                        // Make sure the page is still open!
-                        if (!lastTab.isClosed()) {
-                            await lastTab.close()
-                        }
-
-                    } else if (lastTabURL.href !== searchListingURL.href) {
-
-                        await lastTab.goBack()
-
-                        lastTab = await getLatestTab(page) // Get last opened tab
-                        lastTabURL = new URL(lastTab.url())
-
-                        // If "goBack" didn't return to search listing (due to redirects)
-                        if (lastTabURL.hostname !== searchListingURL.hostname) {
-                            await lastTab.goto(searchListingURL.href)
-                        }
-                    }
-                }
+                // 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++
            }

-            lastTab = await getLatestTab(page) // Finally update the lastTab var again
-            i++
+        } catch (error) {
+            this.bot.log(this.bot.isMobile, 'SEARCH-RANDOM-CLICK', 'An error occurred:' + error, 'error')
        }
-    } catch (error) {
-        log('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
+        }
+    }
+
 }
--- a/src/functions/activities/SearchOnBing.ts
+++ b/src/functions/activities/SearchOnBing.ts
@@ -0,0 +1,75 @@
+import { Page } from 'rebrowser-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 page.click(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 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/main/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, '')
+    }
+}
--- a/src/functions/activities/ThisOrThat.ts
+++ b/src/functions/activities/ThisOrThat.ts
@@ -1,34 +1,47 @@
-import { Page } from 'puppeteer'
+import { Page } from 'rebrowser-playwright'

-import { wait } from '../../util/Utils'
-import { log } from '../../util/Logger'
-import { getQuizData } from '../../browser/BrowserFunc'
+import { Workers } from '../Workers'

-export async function doThisOrThat(page: Page) {
-    log('THIS-OR-THAT', 'Trying to complete ThisOrThat')

-    try {
-        await page.waitForNetworkIdle({ timeout: 5000 })
-        await wait(2000)
+export class ThisOrThat extends Workers {

-        // Check if the quiz has been started or not
-        const quizNotStarted = await page.waitForSelector('#rqStartQuiz', { visible: true, timeout: 3000 }).then(() => true).catch(() => false)
-        if (quizNotStarted) {
-            await page.click('#rqStartQuiz')
-        } else {
-            log('THIS-OR-THAT', 'ThisOrThat has already been started, trying to finish it')
+    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')
        }
-
-        await wait(2000)
-
-        // Solving
-        const quizData = await getQuizData(page)
-        quizData // correctAnswer property is always null?
-        
-        log('THIS-OR-THAT', 'Completed the ThisOrthat successfully')
-    } catch (error) {
-        await page.close()
-        log('THIS-OR-THAT', 'An error occurred:' + error, 'error')
    }

 }
--- a/src/functions/activities/UrlReward.ts
+++ b/src/functions/activities/UrlReward.ts
@@ -1,21 +1,23 @@
-import { Page } from 'puppeteer'
+import { Page } from 'rebrowser-playwright'

-import { wait } from '../../util/Utils'
-import { log } from '../../util/Logger'
+import { Workers } from '../Workers'

-export async function doUrlReward(page: Page) {
-    log('URL-REWARD', 'Trying to complete UrlReward')

-    try {
-        // After waiting, close the page
-        await page.waitForNetworkIdle({ timeout: 10_000 })
-        await wait(2000)
-        await page.close()
+export class UrlReward extends Workers {

-        log('URL-REWARD', 'Completed the UrlReward successfully')
-    } catch (error) {
-        await page.close()
-        log('URL-REWARD', 'An error occurred:' + error, 'error')
+    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')
+        }
    }

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

 import Browser from './browser/Browser'
-import { getDashboardData, getEarnablePoints, goHome } from './browser/BrowserFunc'
+import BrowserFunc from './browser/BrowserFunc'
+import BrowserUtil from './browser/BrowserUtil'

 import { log } from './util/Logger'
-import { loadAccounts } from './util/Account'
-import { chunkArray } from './util/Utils'
+import Util from './util/Utils'
+import { loadAccounts, loadConfig, saveSessionData } from './util/Load'

-import { login } from './functions/Login'
-import { doDailySet, doMorePromotions, doPunchCard } from './functions/Workers'
-import { doSearch } from './functions/activities/Search'
+import { Login } from './functions/Login'
+import { Workers } from './functions/Workers'
+import Activities from './functions/Activities'

 import { Account } from './interface/Account'
+import Axios from './util/Axios'

-import { runOnZeroPoints, workers, clusters } from './config.json'

 // Main bot class
-class MicrosoftRewardsBot {
-    private activeWorkers: number = clusters
-    private collectedPoints: number = 0
-    private browserFactory: Browser = new Browser()
-    private accounts: Account[]
+export class MicrosoftRewardsBot {
+    public log: typeof log
+    public config
+    public utils: Util
+    public activities: Activities = new Activities(this)
+    public browser: {
+        func: BrowserFunc,
+        utils: BrowserUtil
+    }
+    public isMobile: boolean
+    public homePage!: Page
+
+    private pointsCanCollect: number = 0
+    private pointsInitial: number = 0
+
+    private activeWorkers: number
+    private mobileRetryAttempts: number
+    private browserFactory: Browser = new Browser(this)
+    private accounts: Account[]
+    private workers: Workers
+    private login = new Login(this)
+    private accessToken: string = ''
+
+    //@ts-expect-error Will be initialized later
+    public axios: Axios
+
+    constructor(isMobile: boolean) {
+        this.isMobile = isMobile
+        this.log = log

-    constructor() {
        this.accounts = []
+        this.utils = new Util()
+        this.workers = new Workers(this)
+        this.browser = {
+            func: new BrowserFunc(this),
+            utils: new BrowserUtil(this)
+        }
+        this.config = loadConfig()
+        this.activeWorkers = this.config.clusters
+        this.mobileRetryAttempts = 0
    }

    async initialize() {
-        this.accounts = await loadAccounts()
+        this.accounts = loadAccounts()
    }

    async run() {
-        log('MAIN', `Bot started with ${clusters} clusters`)
+        log('main', 'MAIN', `Bot started with ${this.config.clusters} clusters`)

        // Only cluster when there's more than 1 cluster demanded
-        if (clusters > 1) {
+        if (this.config.clusters > 1) {
            if (cluster.isPrimary) {
                this.runMaster()
            } else {
                this.runWorker()
            }
        } else {
-            this.runTasks(this.accounts)
+            await this.runTasks(this.accounts)
        }
    }

    private runMaster() {
-        log('MAIN-PRIMARY', 'Primary process started')
+        log('main', 'MAIN-PRIMARY', 'Primary process started')

-        const accountChunks = chunkArray(this.accounts, clusters)
+        const accountChunks = this.utils.chunkArray(this.accounts, this.config.clusters)

        for (let i = 0; i < accountChunks.length; i++) {
            const worker = cluster.fork()
@@ -59,19 +93,18 @@ class MicrosoftRewardsBot {
        cluster.on('exit', (worker, code) => {
            this.activeWorkers -= 1

-            log('MAIN-WORKER', `Worker ${worker.process.pid} destroyed | Code: ${code} | Active workers: ${this.activeWorkers}`, 'warn')
+            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) {
-                log('MAIN-WORKER', 'All workers destroyed. Exiting main process!', 'warn')
+                log('main', 'MAIN-WORKER', 'All workers destroyed. Exiting main process!', 'warn')
                process.exit(0)
            }
        })
    }

    private runWorker() {
-        log('MAIN-WORKER', `Worker ${process.pid} spawned`)
-
+        log('main', 'MAIN-WORKER', `Worker ${process.pid} spawned`)
        // Receive the chunk of accounts from the master
        process.on('message', async ({ chunk }) => {
            await this.runTasks(chunk)
@@ -80,142 +113,207 @@ class MicrosoftRewardsBot {

    private async runTasks(accounts: Account[]) {
        for (const account of accounts) {
-            log('MAIN-WORKER', `Started tasks for account ${account.email}`)
+            log('main', 'MAIN-WORKER', `Started tasks for account ${account.email}`)

-            // Desktop Searches, DailySet and More Promotions
-            await this.Desktop(account)
+            this.axios = new Axios(account.proxy)
+            if (this.config.parallel) {
+                await Promise.all([
+                    this.Desktop(account),
+                    (() => {
+                        const mobileInstance = new MicrosoftRewardsBot(true)
+                        mobileInstance.axios = this.axios

-            // If runOnZeroPoints is false and 0 points to earn, stop and try the next account
-            if (!runOnZeroPoints && this.collectedPoints === 0) {
-                continue
+                        return mobileInstance.Mobile(account)
+                    })()
+                ])
+            } else {
+                this.isMobile = false
+                await this.Desktop(account)
+
+                this.isMobile = true
+                await this.Mobile(account)
            }

-            // Mobile Searches
-            await this.Mobile(account)
-
-            log('MAIN-WORKER', `Completed tasks for account ${account.email}`)
+            log('main', 'MAIN-WORKER', `Completed tasks for account ${account.email}`, 'log', 'green')
        }

-        log('MAIN-PRIMARY', 'Completed tasks for ALL accounts')
-        log('MAIN-PRIMARY', 'All workers destroyed!')
-        process.exit(0)
+        log(this.isMobile, 'MAIN-PRIMARY', 'Completed tasks for ALL accounts', 'log', 'green')
+        process.exit()
    }

    // Desktop
    async Desktop(account: Account) {
-        const browser = await this.browserFactory.createBrowser(account.email, account.proxy, false)
-        const page = await browser.newPage()
-        let pages = await browser.pages()
+        const browser = await this.browserFactory.createBrowser(account.proxy, account.email)
+        this.homePage = await browser.newPage()

-        // If for some reason the browser initializes with more than 2 pages, close these
-        while (pages.length > 2) {
-            await pages[0]?.close()
-            pages = await browser.pages()
-        }
+        log(this.isMobile, 'MAIN', 'Starting browser')

-        // Log into proxy
-        await page.authenticate({ username: account.proxy.username, password: account.proxy.password })
+        // Login into MS Rewards, then go to rewards homepage
+        await this.login.login(this.homePage, account.email, account.password)

-        log('MAIN', 'Starting DESKTOP browser')
+        await this.browser.func.goHome(this.homePage)

-        // Login into MS Rewards
-        await login(page, account.email, account.password)
+        const data = await this.browser.func.getDashboardData()

-        const wentHome = await goHome(page)
-        if (!wentHome) {
-            throw log('MAIN', 'Unable to get dashboard page', 'error')
-        }
+        this.pointsInitial = data.userStatus.availablePoints

-        const data = await getDashboardData(page)
-        log('MAIN-POINTS', `Current point count: ${data.userStatus.availablePoints}`)
+        log(this.isMobile, 'MAIN-POINTS', `Current point count: ${this.pointsInitial}`)

-        const earnablePoints = await getEarnablePoints(data)
-        this.collectedPoints = earnablePoints
-        log('MAIN-POINTS', `You can earn ${earnablePoints} points today`)
+        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 (!runOnZeroPoints && this.collectedPoints === 0) {
-            log('MAIN', 'No points to earn and "runOnZeroPoints" is set to "false", stopping')
+        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
-            return await browser.close()
+            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 (workers.doDailySet) {
-            await doDailySet(page, data)
+        if (this.config.workers.doDailySet) {
+            await this.workers.doDailySet(workerPage, data)
        }

        // Complete more promotions
-        if (workers.doMorePromotions) {
-            await doMorePromotions(page, data)
+        if (this.config.workers.doMorePromotions) {
+            await this.workers.doMorePromotions(workerPage, data)
        }

        // Complete punch cards
-        if (workers.doPunchCards) {
-            await doPunchCard(page, data)
+        if (this.config.workers.doPunchCards) {
+            await this.workers.doPunchCard(workerPage, data)
        }

        // Do desktop searches
-        if (workers.doDesktopSearch) {
-            await doSearch(page, data, false)
+        if (this.config.workers.doDesktopSearch) {
+            await this.activities.doSearch(workerPage, data)
        }

+        // Save cookies
+        await saveSessionData(this.config.sessionPath, browser, account.email, this.isMobile)
+
        // Close desktop browser
-        await browser.close()
+        await this.browser.func.closeBrowser(browser, account.email)
+        return
    }

    // Mobile
    async Mobile(account: Account) {
-        const browser = await this.browserFactory.createBrowser(account.email, account.proxy, true)
-        const page = await browser.newPage()
-        let pages = await browser.pages()
+        const browser = await this.browserFactory.createBrowser(account.proxy, account.email)
+        this.homePage = await browser.newPage()

-        // If for some reason the browser initializes with more than 2 pages, close these
-        while (pages.length > 2) {
-            await pages[0]?.close()
-            pages = await browser.pages()
-        }
-        // Log into proxy
-        await page.authenticate({ username: account.proxy.username, password: account.proxy.password })
+        log(this.isMobile, 'MAIN', 'Starting browser')

-        log('MAIN', 'Starting MOBILE 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)

-        // Login into MS Rewards
-        await login(page, account.email, account.password)
+        await this.browser.func.goHome(this.homePage)

-        await goHome(page)
+        const data = await this.browser.func.getDashboardData()

-        const data = await getDashboardData(page)
+        const browserEnarablePoints = await this.browser.func.getBrowserEarnablePoints()
+        const appEarnablePoints = await this.browser.func.getAppEarnablePoints(this.accessToken)

-        // If no mobile searches data found, stop (Does not exist on new accounts)
-        if (!data.userStatus.counters.mobileSearch) {
-            log('MAIN', 'No mobile searches found, stopping')
+        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
-            return await browser.close()
+            await this.browser.func.closeBrowser(browser, account.email)
+            return
+        }
+
+        // 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 (workers.doMobileSearch) {
-            await doSearch(page, data, true)
+        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')
+            }
        }

-        // Fetch new points
-        const earnablePoints = await getEarnablePoints(data, page)
+        const afterPointAmount = await this.browser.func.getCurrentPoints()

-        // If the new earnable is 0, means we got all the points, else retract
-        this.collectedPoints = earnablePoints === 0 ? this.collectedPoints : (this.collectedPoints - earnablePoints)
-        log('MAIN-POINTS', `The script collected ${this.collectedPoints} points today`)
+        log(this.isMobile, 'MAIN-POINTS', `The script collected ${afterPointAmount - this.pointsInitial} points today`)

        // Close mobile browser
-        await browser.close()
+        await this.browser.func.closeBrowser(browser, account.email)
+        return
+    }
+
+}
+
+async function main() {
+    const rewardsBot = new MicrosoftRewardsBot(false)
+
+    try {
+        await rewardsBot.initialize()
+        await rewardsBot.run()
+    } catch (error) {
+        log(false, 'MAIN-ERROR', `Error running desktop bot: ${error}`, 'error')
    }
 }

-const bot = new MicrosoftRewardsBot()
-
-// Initialize accounts first and then start the bot
-bot.initialize().then(() => {
-    bot.run()
+// Start the bots
+main().catch(error => {
+    log('main', 'MAIN-ERROR', `Error running bots: ${error}`, 'error')
+    process.exit(1)
 })
--- a/src/interface/Account.ts
+++ b/src/interface/Account.ts
@@ -5,6 +5,7 @@ export interface Account {
 }

 export interface AccountProxy {
+    proxyAxios: boolean;
    url: string;
    port: number;
    password: string;
--- a/src/interface/AppUserData.ts
+++ b/src/interface/AppUserData.ts
@@ -0,0 +1,226 @@
+export interface AppUserData {
+    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;
+}
+
+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;
+}
+
+export interface GiveOrganization {
+    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;
+}
+
+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;
+}
+
+export interface GoalItemConfig {
+    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[];
+}
+
+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;
+}
+
+export interface ItemSnapshot {
+    name: string;
+    provider: string;
+    price: number;
+    attributes: GoalItemAttributes;
+    config: ItemSnapshotConfig;
+}
+
+export interface ItemSnapshotConfig {
+    amount: string;
+    countryCode: string;
+    currencyCode: string;
+    sku: string;
+}
+
+export interface Log {
+    time: Date;
+    from: From;
+    to: S;
+    reason: string;
+}
+
+export enum From {
+    Created = 'Created',
+    RiskApproved = 'RiskApproved',
+    RiskReview = 'RiskReview'
+}
+
+export enum S {
+    Cancelled = 'Cancelled',
+    RiskApproved = 'RiskApproved',
+    RiskReview = 'RiskReview',
+    Shipped = 'Shipped'
+}
+
+export interface Profile {
+    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;
+}
+
+export interface OfflineAttributes {
+}
+
+export interface Promotion {
+    name: string;
+    priority: number;
+    attributes: { [key: string]: string };
+    tags: Tag[];
+}
+
+export enum Tag {
+    AllowTrialUser = 'allow_trial_user',
+    ExcludeGivePcparent = 'exclude_give_pcparent',
+    ExcludeGlobalConfig = 'exclude_global_config',
+    ExcludeHidden = 'exclude_hidden',
+    LOCString = 'locString',
+    NonGlobalConfig = 'non_global_config'
+}
--- a/src/interface/Config.ts
+++ b/src/interface/Config.ts
@@ -0,0 +1,55 @@
+export interface Config {
+    baseURL: string;
+    sessionPath: string;
+    headless: boolean;
+    parallel: boolean;
+    runOnZeroPoints: boolean;
+    clusters: number;
+    saveFingerprint: ConfigSaveFingerprint;
+    workers: ConfigWorkers;
+    searchOnBingLocalQueries: boolean;
+    globalTimeout: number | string;
+    searchSettings: ConfigSearchSettings;
+    logExcludeFunc: string[];
+    webhookLogExcludeFunc: string[];
+    proxy: ConfigProxy;
+    webhook: ConfigWebhook;
+}
+
+export interface ConfigSaveFingerprint {
+    mobile: boolean;
+    desktop: boolean;
+}
+
+export interface ConfigSearchSettings {
+    useGeoLocaleQueries: boolean;
+    scrollRandomResults: boolean;
+    clickRandomResults: boolean;
+    searchDelay: ConfigSearchDelay;
+    retryMobileSearchAmount: number;
+}
+
+export interface ConfigSearchDelay {
+    min: number | string;
+    max: number | string;
+}
+
+export interface ConfigWebhook {
+    enabled: boolean;
+    url: string;
+}
+
+export interface ConfigProxy {
+    proxyGoogleTrends: boolean;
+    proxyBingTerms: boolean;
+}
+
+export interface ConfigWorkers {
+    doDailySet: boolean;
+    doMorePromotions: boolean;
+    doPunchCards: boolean;
+    doDesktopSearch: boolean;
+    doMobileSearch: boolean;
+    doDailyCheckIn: boolean;
+    doReadToEarn: boolean;
+}
--- a/src/interface/DashboardData.ts
+++ b/src/interface/DashboardData.ts
@@ -351,11 +351,13 @@ export interface MorePromotion {
    legalText: string;
    legalLinkText: string;
    deviceType: string;
+    exclusiveLockedFeatureType: string;
+    exclusiveLockedFeatureStatus: string;
 }

 export interface PunchCard {
    name: string;
-    parentPromotion: PromotionalItem;
+    parentPromotion?: PromotionalItem;
    childPromotions: PromotionalItem[];
 }

--- a/src/interface/OAuth.ts
+++ b/src/interface/OAuth.ts
@@ -0,0 +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;
+}
--- a/src/interface/Points.ts
+++ b/src/interface/Points.ts
@@ -0,0 +1,7 @@
+export interface EarnablePoints {
+    desktopSearchPoints: number
+    mobileSearchPoints: number
+    dailySetPoints: number
+    morePromotionsPoints: number
+    totalEarnablePoints: number
+}
--- a/src/run_daily.sh
+++ b/src/run_daily.sh
@@ -0,0 +1,32 @@
+#!/bin/bash
+
+# Set up environment variables
+export PATH=$PATH:/usr/local/bin:/usr/bin:/bin:/usr/local/sbin:/usr/sbin:/sbin
+
+# Ensure TZ is set
+export TZ=${TZ}
+
+# Change directory to the application directory
+cd /usr/src/microsoft-rewards-script
+
+# Define the minimum and maximum wait times in seconds
+MINWAIT=$((5*60))  # 5 minutes
+MAXWAIT=$((50*60)) # 50 minutes
+
+# Calculate a random sleep time within the specified range
+SLEEPTIME=$((MINWAIT + RANDOM % (MAXWAIT - MINWAIT)))
+
+# Convert the sleep time to minutes for logging
+SLEEP_MINUTES=$((SLEEPTIME / 60))
+
+# Log the sleep duration
+echo "Sleeping for $SLEEP_MINUTES minutes ($SLEEPTIME seconds)..."
+
+# Sleep for the calculated time
+sleep $SLEEPTIME
+
+# Log the start of the script
+echo "Starting script..."
+
+# Execute the Node.js script directly
+npm run start
--- a/src/util/Account.ts
+++ b/src/util/Account.ts
@@ -1,22 +0,0 @@
-import * as fs from 'fs'
-import path from 'path'
-
-import { Account } from '../interface/Account'
-
-export async function loadAccounts(): Promise<Account[]> {
-    try {
-        let file = 'accounts.json'
-
-        // If dev mode, use dev account(s)
-        if (process.argv.includes('-dev')) {
-            file = 'accounts.dev.json'
-        }
-
-        const accountDir = path.join(__dirname, '../', file)
-        const accounts = fs.readFileSync(accountDir, 'utf-8')
-
-        return JSON.parse(accounts)
-    } catch (error) {
-        throw new Error(error as string)
-    }
-}
--- a/src/util/Axios.ts
+++ b/src/util/Axios.ts
@@ -0,0 +1,49 @@
+import axios, { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios'
+import { HttpProxyAgent } from 'http-proxy-agent'
+import { HttpsProxyAgent } from 'https-proxy-agent'
+import { SocksProxyAgent } from 'socks-proxy-agent'
+import { AccountProxy } from '../interface/Account'
+
+class AxiosClient {
+    private instance: AxiosInstance
+    private account: AccountProxy
+
+    constructor(account: AccountProxy) {
+        this.account = account
+        this.instance = axios.create()
+
+        // 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
+        }
+    }
+
+    private getAgentForProxy(proxyConfig: AccountProxy): HttpProxyAgent<string> | HttpsProxyAgent<string> | SocksProxyAgent {
+        const { url, port } = proxyConfig
+
+        switch (true) {
+            case proxyConfig.url.startsWith('http'):
+                return new HttpProxyAgent(`${url}:${port}`)
+            case proxyConfig.url.startsWith('https'):
+                return new HttpsProxyAgent(`${url}:${port}`)
+            case proxyConfig.url.startsWith('socks'):
+                return new SocksProxyAgent(`${url}:${port}`)
+            default:
+                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()
+            return bypassInstance.request(config)
+        }
+
+        return this.instance.request(config)
+    }
+}
+
+export default AxiosClient
--- a/src/util/Load.ts
+++ b/src/util/Load.ts
@@ -0,0 +1,116 @@
+import { BrowserContext, Cookie } from 'rebrowser-playwright'
+import { BrowserFingerprintWithHeaders } from 'fingerprint-generator'
+import fs from 'fs'
+import path from 'path'
+
+
+import { Account } from '../interface/Account'
+import { Config, ConfigSaveFingerprint } from '../interface/Config'
+
+let configCache: Config
+
+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'
+        }
+
+        const accountDir = path.join(__dirname, '../', file)
+        const accounts = fs.readFileSync(accountDir, 'utf-8')
+
+        return JSON.parse(accounts)
+    } catch (error) {
+        throw new Error(error as string)
+    }
+}
+
+export function loadConfig(): Config {
+    try {
+        if (configCache) {
+            return configCache
+        }
+
+        const configDir = path.join(__dirname, '../', 'config.json')
+        const config = fs.readFileSync(configDir, 'utf-8')
+
+        const configData = JSON.parse(config)
+        configCache = configData // Set as cache
+
+        return configData
+    } catch (error) {
+        throw new Error(error as string)
+    }
+}
+
+export async function loadSessionData(sessionPath: string, email: string, isMobile: boolean, saveFingerprint: ConfigSaveFingerprint) {
+    try {
+        // Fetch cookie file
+        const cookieFile = path.join(__dirname, '../browser/', sessionPath, email, `${isMobile ? 'mobile_cookies' : 'desktop_cookies'}.json`)
+
+        let cookies: Cookie[] = []
+        if (fs.existsSync(cookieFile)) {
+            const cookiesData = await fs.promises.readFile(cookieFile, 'utf-8')
+            cookies = JSON.parse(cookiesData)
+        }
+
+        // Fetch fingerprint file
+        const fingerprintFile = path.join(__dirname, '../browser/', sessionPath, email, `${isMobile ? 'mobile_fingerpint' : 'desktop_fingerpint'}.json`)
+
+        let fingerprint!: BrowserFingerprintWithHeaders
+        if (((saveFingerprint.desktop && !isMobile) || (saveFingerprint.mobile && isMobile)) && fs.existsSync(fingerprintFile)) {
+            const fingerprintData = await fs.promises.readFile(fingerprintFile, 'utf-8')
+            fingerprint = JSON.parse(fingerprintData)
+        }
+
+        return {
+            cookies: cookies,
+            fingerprint: fingerprint
+        }
+
+    } catch (error) {
+        throw new Error(error as string)
+    }
+}
+
+export async function saveSessionData(sessionPath: string, browser: BrowserContext, email: string, isMobile: boolean): Promise<string> {
+    try {
+        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 })
+        }
+
+        // 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) {
+        throw new Error(error as 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)
+
+        // Create session dir
+        if (!fs.existsSync(sessionDir)) {
+            await fs.promises.mkdir(sessionDir, { recursive: true })
+        }
+
+        // Save fingerprint to a file
+        await fs.promises.writeFile(path.join(sessionDir, `${isMobile ? 'mobile_fingerpint' : 'desktop_fingerpint'}.json`), JSON.stringify(fingerpint))
+
+        return sessionDir
+    } catch (error) {
+        throw new Error(error as string)
+    }
+}
--- a/src/util/Logger.ts
+++ b/src/util/Logger.ts
@@ -1,26 +1,45 @@
+import chalk from 'chalk'
+
 import { Webhook } from './Webhook'
+import { loadConfig } from './Load'

-export function log(title: string, message: string, type?: 'log' | 'warn' | 'error') {
-    const currentTime = new Date().toISOString()

-    let str = ''
+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':
-            str = `[${currentTime}] [PID: ${process.pid}] [WARN] [${title}] ${message}`
-            console.warn(str)
+            applyChalk ? console.warn(applyChalk(str)) : console.warn(str)
            break

        case 'error':
-            str = `[${currentTime}] [PID: ${process.pid}] [ERROR] [${title}] ${message}`
-            console.error(str)
+            applyChalk ? console.error(applyChalk(str)) : console.error(str)
            break

        default:
-            str = `[${currentTime}] [PID: ${process.pid}] [LOG] [${title}] ${message}`
-            console.log(str)
+            applyChalk ? console.log(applyChalk(str)) : console.log(str)
            break
    }
-
-    if (str) Webhook(str)
-}
+}
--- a/src/util/UserAgent.ts
+++ b/src/util/UserAgent.ts
@@ -1,42 +1,45 @@
 import axios from 'axios'
+import { BrowserFingerprintWithHeaders } from 'fingerprint-generator'

 import { log } from './Logger'

 import { ChromeVersion, EdgeVersion } from '../interface/UserAgentUtil'

-export async function getUserAgent(mobile: boolean) {
-    const system = getSystemComponents(mobile)
-    const app = await getAppComponents(mobile)
+const NOT_A_BRAND_VERSION = '99'

-    const uaTemplate = mobile ?
+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 = `${mobile ? Math.floor(Math.random() * 5) + 9 : Math.floor(Math.random() * 15) + 1}.0.0`
+    const platformVersion = `${isMobile ? Math.floor(Math.random() * 5) + 9 : Math.floor(Math.random() * 15) + 1}.0.0`

    const uaMetadata = {
-        mobile,
-        platform: mobile ? 'Android' : 'Windows',
+        isMobile,
+        platform: isMobile ? 'Android' : 'Windows',
        fullVersionList: [
-            { brand: 'Not/A)Brand', version: '99.0.0.0' },
+            { 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: '99' },
+            { 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: mobile ? '' : 'x86',
-        bitness: mobile ? '' : '64',
+        architecture: isMobile ? '' : 'x86',
+        bitness: isMobile ? '' : '64',
        model: ''
    }

    return { userAgent: uaTemplate, userAgentMetadata: uaMetadata }
 }

-export async function getChromeVersion(): Promise<string> {
+export async function getChromeVersion(isMobile: boolean): Promise<string> {
    try {
        const request = {
            url: 'https://googlechromelabs.github.io/chrome-for-testing/last-known-good-versions.json',
@@ -51,11 +54,11 @@ export async function getChromeVersion(): Promise<string> {
        return data.channels.Stable.version

    } catch (error) {
-        throw log('USERAGENT-CHROME-VERSION', 'An error occurred:' + error, 'error')
+        throw log(isMobile, 'USERAGENT-CHROME-VERSION', 'An error occurred:' + error, 'error')
    }
 }

-export async function getEdgeVersions() {
+export async function getEdgeVersions(isMobile: boolean) {
    try {
        const request = {
            url: 'https://edgeupdates.microsoft.com/api/products',
@@ -75,13 +78,13 @@ export async function getEdgeVersions() {


    } catch (error) {
-        throw log('USERAGENT-EDGE-VERSION', 'An error occurred:' + error, '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 13' : 'Win64; x64'
+    const uaPlatform: string = mobile ? `Android 1${Math.floor(Math.random() * 5)}` : 'Win64; x64'

    if (mobile) {
        return `${uaPlatform}; ${osId}; K`
@@ -90,20 +93,51 @@ export function getSystemComponents(mobile: boolean): string {
    return `${uaPlatform}; ${osId}`
 }

-export async function getAppComponents(mobile: boolean) {
-    const versions = await getEdgeVersions()
-    const edgeVersion = mobile ? versions.android : versions.windows as string
+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()
+    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')
+    }
 }
--- a/src/util/Utils.ts
+++ b/src/util/Utils.ts
@@ -1,38 +1,50 @@
-export async function wait(ms: number): Promise<void> {
-    return new Promise<void>((resolve) => {
-        setTimeout(resolve, ms)
-    })
-}
+import ms from 'ms'

-export function getFormattedDate(ms = Date.now()): string {
-    const today = new Date(ms)
-    const month = String(today.getMonth() + 1).padStart(2, '0')  // January is 0
-    const day = String(today.getDate()).padStart(2, '0')
-    const year = today.getFullYear()
+export default class Util {

-    return `${month}/${day}/${year}`
-}
-
-export function shuffleArray<T>(array: T[]): T[] {
-    const shuffledArray = array.slice()
-
-    shuffledArray.sort(() => Math.random() - 0.5)
-
-    return shuffledArray
-}
-
-export function randomNumber(min: number, max: number): number {
-    return Math.floor(Math.random() * (max - min + 1)) + min
-}
-
-export function chunkArray<T>(arr: T[], numChunks: number): T[][] {
-    const chunkSize = Math.ceil(arr.length / numChunks)
-    const chunks: T[][] = []
-
-    for (let i = 0; i < arr.length; i += chunkSize) {
-        const chunk = arr.slice(i, i + chunkSize)
-        chunks.push(chunk)
+    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 day = String(today.getDate()).padStart(2, '0')
+        const year = today.getFullYear()
+
+        return `${month}/${day}/${year}`
+    }
+
+    shuffleArray<T>(array: T[]): T[] {
+        return array.map(value => ({ value, sort: Math.random() }))
+            .sort((a, b) => a.sort - b.sort)
+            .map(({ value }) => value)
+    }
+
+    randomNumber(min: number, max: number): number {
+        return Math.floor(Math.random() * (max - min + 1)) + min
+    }
+
+    chunkArray<T>(arr: T[], numChunks: number): T[][] {
+        const chunkSize = Math.ceil(arr.length / numChunks)
+        const chunks: T[][] = []
+
+        for (let i = 0; i < arr.length; i += chunkSize) {
+            const chunk = arr.slice(i, i + chunkSize)
+            chunks.push(chunk)
+        }
+
+        return chunks
+    }
+
+    stringToMs(input: string | number): number {
+        const milisec = ms(input.toString())
+        if (!milisec) {
+            throw new Error('The string provided cannot be parsed to a valid time! Use a format like "1 min", "1m" or "1 minutes"')
+        }
+        return milisec
    }

-    return chunks
 }
--- a/src/util/Webhook.ts
+++ b/src/util/Webhook.ts
@@ -1,10 +1,13 @@
 import axios from 'axios'

-import { webhook } from '../config.json'

-export async function Webhook(content: string) {
+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,
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -64,7 +64,9 @@
    },
    "include": [
        "src/**/*.ts",
-        "src/accounts.json"
+        "src/accounts.json",
+        "src/config.json",
+        "src/functions/queries.json"
    ],
    "exclude": [
        "node_modules"
Author	SHA1	Message	Date
TheNetsky	d5fd06d229	1.5.3 Fix issue with pop-up dismissal	2025-04-30 16:20:56 +02:00
TheNetsky	0ddc964878	1.5.2 - Updated packages - Cleanup - Improved message dismissal - Improved login functionality With help from @LightZirconite	2025-04-24 14:50:22 +02:00
CNOCM	325bf65b30	Update README (#264 ) * Update Search.ts * Update README.md	2025-03-03 10:59:06 +01:00
HMCDAT	6f19bd4b0e	Update Dockerfile (#262 )	2025-02-28 12:34:47 +01:00
AariaX	caf6a42a38	Make shuffleArray more random? (#254 )	2025-02-25 16:14:51 +01:00
TheNetsky	352d47229b	Merge branch 'main' of https://github.com/TheNetsky/Microsoft-Rewards-Script	2025-02-24 17:59:28 +01:00
TheNetsky	9a12ee1ec8	Fix geoLocale not being uppercase	2025-02-24 17:59:20 +01:00
Netsky	b630c3ddda	Update README.md	2025-02-24 15:52:53 +01:00
Netsky	287e3897da	Update README.md	2025-02-24 15:51:08 +01:00
Netsky	fcf6aba446	Bump version	2025-02-24 15:49:45 +01:00
AariaX	1102f2ca94	Google API Update (1.5.1) (#247 ) * switch to google internal api * A bit of tidying up * A bit more of tidying up * A bit more of tidying up * Pre 1.5.1 - Add proxy exclusions - Update ReadMe - Update config Interface --------- Co-authored-by: TheNetsky <56271887+TheNetsky@users.noreply.github.com>	2025-02-24 15:49:19 +01:00
1OSA	82a896e83f	added webhooklogexcludefunc (#240 )	2025-02-20 23:21:46 +01:00
Netsky	b0bd1f52c4	Update queries.json	2025-02-19 19:32:45 +01:00
Netsky	7e4121e01b	Update run_daily.sh	2025-02-19 15:29:51 +01:00
Netsky	849406c44f	1.5 inital (#234 ) * 1.4.12 * Update README.md * Update package.json * Update package.json * 1.5 initial - Added parallel mode (experimental, likely no Docker supported) - Added chalk for clearer logging - Added support for "SearchOnBing" Activities - Added more configurable options for certain things - Redone some of the popup/banner clicking for searching (Redo the entire "popup" clicking, so they're more specifically targeted) - Axios proxy is now optional in the config - Fingerprint saving is now optional for desktop and mobile There needs to be many changes for Docker support, including parallel, the new config settings and general testing! This is still highly experimental, if you use Docker or want something more stable, use the version before this commit! * Add queries.json to build * fix(Login): update URL within authorization loop to reflect current page (#210) * Many changes - Updated Packages - Fixed mobile searches erroring out for dashboard data - Reworked "bad page" detection - Catching more errors - Reworked the search and "close tabs" - More fixes to the login - Fixed to paralell and clustering, thanks to @AariaX * Docker 1.5 preliminary support (#211) * Basic docker functionality for 1.5 Preliminary docker support for 1.5. Requires headless=true, clusters=1 * Tidy up timezone, add TZ to compose file Minor changes that should improve timezone handling, and (hopefully) improve scheduling function * updated readme to simplify and clarify docker instructions also removed env vars from table * Fix syntax for cron * Fix scheduling, add .gitattributes to normalize line endings fixed line endings caused by Windows in crontab.template and run_daily.sh, which were breaking cron and script execution in the Docker container. * Removed unnecessary scheduling key from config.json This key isn't necessary for docker or the base script. * Basic docker functionality for 1.5 Preliminary docker support for 1.5. Requires headless=true, clusters=1 Tidied up timezone, add TZ to compose file Minor changes that should improve timezone handling, and (hopefully) improve scheduling function updated readme to simplify and clarify docker instructions also removed env vars from table Fixed syntax for cron Fixed scheduling, add .gitattributes to normalize line endings Fixed line endings caused by Windows in crontab.template and run_daily.sh, which were breaking cron and script execution in the Docker container. Removed unnecessary scheduling key from config.json This key isn't necessary for docker or the base script. * Improve scheduling handling, show logs in console Fixes scheduling when RUN_ON_START=true, and fixes scheduled runs not appearing in docker logs. * Update compose.yaml revert service and container name, revert volumes for better generalization, add tips to environment to set scheduling, timezone and whether to run on container start * Update README.md proper container name Co-authored-by: AariaX <196196201+AariaX@users.noreply.github.com> --------- Co-authored-by: AariaX <196196201+AariaX@users.noreply.github.com> * Fixes - Reworked some of the point counting - Reverted back to the "playwright" package - Fixed error throw for emailPrefill * Update config.json * Add pre-build script * Update package.json * Handle 2FA in parallel mode (#219) * catch error in reloadBadPage (#220) * Use pre-build and simplify dockerfile (#218) This uses the new pre-build script included in package.json to handle deps greatly simplifying the dockerfile. * Small improvements * Small fixes - Fixed log spam for "Waiting for authorization" - Increased wait from 2 to 5 seconds - Increased search to "safer" values for default * Experimenting with selectors Seeing #223 I want to try if this is a good new addition, since for most user this SHOULD work just as good as clicking the entire box. * More stuff - Added ability to exclude logs by their function name - Now caching config settings * fix: don't retry on 0 (#228) * Improvements - Check if searches for mobile are enabled before creating the new page in the browser - Return message if mobile search data cannot be found - Added more selectors for coupons * Improve Popup Dismissal - Now executes in Parallel - Respects a timeout of 1 second --------- Co-authored-by: AariaX <196196201+AariaX@users.noreply.github.com> Co-authored-by: mgrimace <55518507+mgrimace@users.noreply.github.com>	2025-02-15 16:14:47 +01:00
Netsky	d1f4364e18	Change queries format	2024-10-29 15:14:07 +01:00
Netsky	cf79467a4e	Update queries.json	2024-10-29 14:03:22 +01:00
Netsky	ae554a0639	Update Queries	2024-10-29 13:56:00 +01:00
Netsky	1a6f9f4ac3	Update queries Testing stuff	2024-10-28 14:32:36 +01:00
Netsky	45083ed41f	Queries for "Search on Bing" activity	2024-10-27 18:02:29 +01:00
mgrimace	8b489d50f7	Dockerfile refactoring (#167 ) * Docker updates and maintenance - Update run_daily.sh to use compose.yaml env var overrides if present on scheduled jobs, not just first run. Defaults back to config.json values if no override specified. - update sample compose.yaml with volume mapping to keep config.json, accounts.json, and sessions folder persistent on local machine (e.g., to keep data persistent through updates). * Refactored dockerfile Combining various steps to reduce layers. Should improve build time and image size.	2024-10-17 21:46:54 +02:00
mgrimace	7151f2351a	Docker updates and maintenance (#164 ) - Update run_daily.sh to use compose.yaml env var overrides if present on scheduled jobs, not just first run. Defaults back to config.json values if no override specified. - update sample compose.yaml with volume mapping to keep config.json, accounts.json, and sessions folder persistent on local machine (e.g., to keep data persistent through updates).	2024-10-14 15:21:36 +02:00
Netsky	5afd8cbe1d	Update package.json	2024-10-03 15:01:32 +02:00
Netsky	f015649d16	Fix typo	2024-10-02 18:42:01 +02:00
Netsky	034359019c	Update README.md	2024-10-02 18:41:06 +02:00
HMCDAT	09ddbee45a	1.4.11 (#146 ) * fix misspelling * fix: avoid skipping eligible items in "More Promotion" * remove unnecessary output * Fix Formatting * replace checking variable * decrease id length * revert previous commit * change condition for eligible promo * Other fixes --------- Co-authored-by: TheNetsky <56271887+TheNetsky@users.noreply.github.com>	2024-10-02 18:37:06 +02:00
MuhammaD Usama	7939196e88	Update Dockerfile (#152 ) Update Dockerfile for build	2024-09-22 19:46:10 +02:00
TheNetsky	5bc66c5fc9	1.4.10 - Fixed searches for some users	2024-09-02 12:13:38 +02:00
Netsky	c70d6f9cb1	1.4.9	2024-08-30 13:54:35 +02:00
HMCDAT	a47b86e74d	Support new quest to get points (#138 ) * support passwordless auth (using Authenticator app) * update readme * feat: added mobile app tasks (daily check in + read to earn) * fix some stuff * make ReadToEarn use the delay config * fix daily reward search per week * reorder mobile tasks * fix message * Search fixes, reformatting and types --------- Co-authored-by: TheNetsky <56271887+TheNetsky@users.noreply.github.com>	2024-08-30 13:26:52 +02:00
TheNetsky	ce2a72ee36	1.4.8	2024-08-18 15:06:44 +02:00
CNOCM	755237caa1	Skip locked Promotions (#132 )	2024-08-18 14:37:56 +02:00
HMCDAT	2b4cd505c0	Support passwordless auth (#129 ) * support passwordless auth (using Authenticator app) * update readme	2024-07-24 15:01:45 +02:00
Nworm	a39a861dab	Update Search.ts (#127 )	2024-07-11 14:43:26 +02:00
mgrimace	8d19129906	Docker: improved env var handling (#113 ) * Improve env var handling, clarify instructions updateConfig.js will update dist/config.json with any values specified in the docker compose file as environmental variables (env vars). If not specified it will use the default values in src/config.json (the 'usual' place where folks can customize their config). A user can make changes to an env var (e.g., disabling Scroll Random Results), then docker compose up -d to quickly restart the container with the change. * minor update to env vars in table Make sure to change your compose so the updated flattened values work. * TZ handling for cron runs of the script docker logs netsky should now show the proper time zone for script runs that were initiated via cron schedule.	2024-06-01 14:50:29 +02:00
TheNetsky	c6ab80fe54	Delete start.bat oops	2024-05-28 11:39:34 +02:00
TheNetsky	9b1eed526f	1.4.7 - Updated packages - Added timeout after scrolling back to top - Some Docker improvement thanks to @mgrimace	2024-05-28 11:38:49 +02:00
mgrimace	9a144b2e60	Docker with env var support and containerized cron scheduling (#107 ) * Script will run on container start, and continue to run daily at 5:00 am. The goal of this update was to add in-built cronjob support so that the script runs immediately on container start, then will schedule the script to run the daily at 5:00 am without requiring the user to manually create a cronjob. After starting the container and completing the first run, the container should remain active (running) but idle until the next scheduled run. Ideally, the next step will be to include support for environmental variables that will allow the user to customize when the script scheduled runs occur within the docker compose.yaml. * added --build to docker compose command instructions building/rebuilding the image (and the script) may reduce problems if folks make changes to their configs * Updated the crontab default to run twice daily by default, 5am and 11am * Update crontab Newline needed * Environmental variable support, custom scheduling This is a massive update that includes docker environmental variable support for all config options. If specified, the custom env var value will supersede the default values in the config.json. You do not need to change the values in the config.json if you set a custom env var. For example, if you have headless=false in the config.json, but set it as true in the compose.yaml, it will run as HEADLESS=true. If you do not specify a particular env var, the script will automatically use the default value. Please test and contribute wherever possible! * Fix scheduled runs, tidied up readme * timezone support Minor adjustment to attempt to fix timezone env var support * Run on start, npm script env Hopefully two fixes here, the container should again, by default, run on start, then continue per schedule. This defaults to true; however, can be optionally over-ridden in the compose.yaml with the env var RUN_ON_START=false. If set to false, the script should only run on the specified cron schedule. I also passed the TZ write into the npm start command, rather than just the container overall so it should show the proper time. * Keep docker running after run_on_start to wait for cron Accidentally set it up like a run_once, this should keep the container active after run_on_start to wait for the next schedule. * improve order of cmd This should (1) set time zone for script, (2) run once if set, then (3) idle for scheduled cron job. It was a little hacky before, this should be tidier. * updated compose to auto-restart container Noticed the container was exited this am, likely after automated updated to system, adding restart: unless-stopped to compose should keep container running in such circumstances. * Update env vars in readme	2024-05-16 19:28:55 +02:00
Netsky	28b1881642	Update README.md	2024-05-09 12:38:49 +02:00
TheNetsky	ef6ad569ff	1.4.6	2024-05-09 10:04:11 +02:00
Netsky	da9ba91c5c	Merge pull request #98 from jordyamc/main Bug when detecting earnable points from more promotions	2024-05-07 15:12:10 +02:00
Jordy Mendoza	deb2d58b1b	- Fix bug where the script was using `x.activityType` instead of `x.promotionType` this was causing that the script wasn't detecting earnable points from more promotions	2024-04-21 23:50:33 -06:00
Netsky	66a82c2584	Merge pull request #89 from mgrimace/docker Clarify docker instructions, add basic compose.yaml support	2024-04-04 16:43:57 +02:00
mgrimace	8a022d5983	Clarify docker instructions, add basic compose.yaml support This should help folks get started with docker and hopefully make it easier for testing	2024-04-03 17:59:16 -04:00
TheNetsky	64048e35d7	1.4.5 - Fix login not working - Sessions are now saved after logging in - Check if promotions, and searches are available before counting total point amount	2024-03-01 12:19:48 +01:00
TheNetsky	cf7f7ac790	Merge branch 'main' of https://github.com/TheNetsky/Microsoft-Rewards-Script	2024-02-05 11:47:50 +01:00
TheNetsky	f7aa5039f9	1.4.4 - Fixed login getting stuck - Updated packages - Fixed some errors not throwing	2024-02-05 11:47:48 +01:00
Netsky	e082fb03f0	Merge pull request #56 from Omniphantasm/patch-1 Update README.md	2024-01-26 18:55:10 +01:00
Omniphantasm	0303b8c605	Update README.md Script is kill-chrome-win, changed readme to reflect that.	2024-01-26 12:35:30 -05:00
TheNetsky	2fea17c415	1.4.3 - Fixed browser generating mobile browser after the first account - Hopefully fixed script erroring after not finding parent promotions - Added support for MacOS (Thanks @alecm858) - Made some changes to search result scrolling	2024-01-20 12:11:02 +01:00
Netsky	c5beccb54b	Update README.md	2024-01-17 22:23:55 +01:00
TheNetsky	b566ccaece	1.4.2 - Scroll back to top before searching	2024-01-17 18:50:43 +01:00
TheNetsky	15b2b827eb	1.4.1 - Fixed typos - Added Dockerfile (experimental) - Increased scroll amount	2024-01-14 14:09:57 +01:00
Netsky	02518ee4ba	Update README.md	2024-01-07 17:00:23 +01:00
Netsky	69819b5631	Add config explaination	2024-01-07 16:59:15 +01:00
Netsky	b389b87792	Set runOnZeroPoints to false by default	2024-01-07 16:38:47 +01:00
TheNetsky	9ea7f5c452	1.4.0 - Switched from Puppeteer to Playwright - Fixed mobile searches not working - Added fingerprint saving in config - Added mobile search retry in config	2024-01-07 16:33:48 +01:00
TheNetsky	f3fb641ecd	1.3.2 - Better generation of mobile user agents	2023-12-27 11:38:52 +01:00
TheNetsky	bca1e7c896	1.3.1 - Poll clicking will be attempted regardless of the selector being found - Fix tabs sticking upon search error - Updated dependencies	2023-12-20 13:03:08 +01:00
Netsky	fd7c8e36d4	Update README.md	2023-12-01 12:12:26 +01:00
Netsky	dcb0c25d46	Remove the feature of Promo Items	2023-12-01 12:02:17 +01:00
TheNetsky	a8cb5482d4	1.3.0	2023-12-01 11:49:14 +01:00
TheNetsky	28286ff9fe	Pre 1.3.0	2023-11-23 14:38:58 +01:00
TheNetsky	1d6167aeca	Missing await	2023-11-04 16:24:25 +01:00
TheNetsky	3b15fe19a7	1.2.5	2023-11-04 16:21:56 +01:00
TheNetsky	66dcdd4a7a	1.2.4 Disable "This or That" quiz.	2023-10-30 21:10:47 +01:00
TheNetsky	40f32af67f	1.2.3	2023-10-30 20:37:40 +01:00
TheNetsky	c2b68faa74	1.2.2	2023-10-26 15:31:35 +02:00
				`@@ -0,0 +1 @@`
				`${CRON_SCHEDULE} TZ=${TZ} /bin/bash /usr/src/microsoft-rewards-script/src/run_daily.sh >> /proc/1/fd/1 2>> /proc/1/fd/2`