mirror of
https://github.com/LightZirconite/Microsoft-Rewards-Bot.git
synced 2026-01-10 01:06:17 +00:00
549 lines
22 KiB
TypeScript
549 lines
22 KiB
TypeScript
import { BrowserFingerprintWithHeaders } from 'fingerprint-generator'
|
|
import fs from 'fs'
|
|
import path from 'path'
|
|
import { BrowserContext, Cookie } from 'rebrowser-playwright'
|
|
import { Account } from '../interface/Account'
|
|
import { Config, ConfigBrowser, ConfigSaveFingerprint, ConfigScheduling } from '../interface/Config'
|
|
import { Util } from './Utils'
|
|
|
|
const utils = new Util()
|
|
|
|
let configCache: Config
|
|
let configSourcePath = ''
|
|
|
|
// Basic JSON comment stripper (supports // line and /* block */ comments while preserving strings)
|
|
function stripJsonComments(input: string): string {
|
|
let out = ''
|
|
let inString = false
|
|
let stringChar = ''
|
|
let inLine = false
|
|
let inBlock = false
|
|
for (let i = 0; i < input.length; i++) {
|
|
const ch = input[i]!
|
|
const next = input[i + 1]
|
|
if (inLine) {
|
|
if (ch === '\n' || ch === '\r') {
|
|
inLine = false
|
|
out += ch
|
|
}
|
|
continue
|
|
}
|
|
if (inBlock) {
|
|
if (ch === '*' && next === '/') {
|
|
inBlock = false
|
|
i++
|
|
}
|
|
continue
|
|
}
|
|
if (inString) {
|
|
out += ch
|
|
if (ch === '\\') { // escape next char
|
|
i++
|
|
if (i < input.length) out += input[i]
|
|
continue
|
|
}
|
|
if (ch === stringChar) {
|
|
inString = false
|
|
}
|
|
continue
|
|
}
|
|
if (ch === '"' || ch === '\'') {
|
|
inString = true
|
|
stringChar = ch
|
|
out += ch
|
|
continue
|
|
}
|
|
if (ch === '/' && next === '/') {
|
|
inLine = true
|
|
i++
|
|
continue
|
|
}
|
|
if (ch === '/' && next === '*') {
|
|
inBlock = true
|
|
i++
|
|
continue
|
|
}
|
|
out += ch
|
|
}
|
|
return out
|
|
}
|
|
|
|
// Normalize both legacy (flat) and new (nested) config schemas into the flat Config interface
|
|
function normalizeConfig(raw: unknown): Config {
|
|
// TYPE SAFETY: Validate raw input before processing
|
|
// Config files are untrusted JSON that could have any structure
|
|
// We use explicit runtime checks for each property below
|
|
if (!raw || typeof raw !== 'object') {
|
|
throw new Error('Config must be a valid object')
|
|
}
|
|
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
const n = raw as Record<string, any>
|
|
|
|
// Browser settings
|
|
const browserConfig = n.browser ?? {}
|
|
const headless = process.env.FORCE_HEADLESS === '1'
|
|
? true
|
|
: (typeof browserConfig.headless === 'boolean'
|
|
? browserConfig.headless
|
|
: (typeof n.headless === 'boolean' ? n.headless : false)) // Legacy fallback
|
|
|
|
const globalTimeout = browserConfig.globalTimeout ?? n.globalTimeout ?? '30s'
|
|
const browser: ConfigBrowser = {
|
|
headless,
|
|
globalTimeout: utils.stringToMs(globalTimeout)
|
|
}
|
|
|
|
// Execution
|
|
const parallel = n.execution?.parallel ?? n.parallel ?? false
|
|
const runOnZeroPoints = n.execution?.runOnZeroPoints ?? n.runOnZeroPoints ?? false
|
|
const clusters = n.execution?.clusters ?? n.clusters ?? 1
|
|
const passesPerRun = n.execution?.passesPerRun ?? n.passesPerRun
|
|
|
|
// Search
|
|
const useLocalQueries = n.search?.useLocalQueries ?? n.searchOnBingLocalQueries ?? false
|
|
const searchSettingsSrc = n.search?.settings ?? n.searchSettings ?? {}
|
|
const delaySrc = searchSettingsSrc.delay ?? searchSettingsSrc.searchDelay ?? { min: '3min', max: '5min' }
|
|
const searchSettings = {
|
|
useGeoLocaleQueries: !!(searchSettingsSrc.useGeoLocaleQueries ?? false),
|
|
scrollRandomResults: !!(searchSettingsSrc.scrollRandomResults ?? false),
|
|
clickRandomResults: !!(searchSettingsSrc.clickRandomResults ?? false),
|
|
retryMobileSearchAmount: Number(searchSettingsSrc.retryMobileSearchAmount ?? 2),
|
|
searchDelay: {
|
|
min: delaySrc.min ?? '3min',
|
|
max: delaySrc.max ?? '5min'
|
|
},
|
|
localFallbackCount: Number(searchSettingsSrc.localFallbackCount ?? 25),
|
|
extraFallbackRetries: Number(searchSettingsSrc.extraFallbackRetries ?? 1)
|
|
}
|
|
|
|
// Workers
|
|
const workers = n.workers ?? {
|
|
doDailySet: true,
|
|
doMorePromotions: true,
|
|
doPunchCards: true,
|
|
doDesktopSearch: true,
|
|
doMobileSearch: true,
|
|
doDailyCheckIn: true,
|
|
doReadToEarn: true,
|
|
bundleDailySetWithSearch: false
|
|
}
|
|
// Ensure missing flag gets a default
|
|
if (typeof workers.bundleDailySetWithSearch !== 'boolean') workers.bundleDailySetWithSearch = false
|
|
|
|
// Logging
|
|
const logging = n.logging ?? {}
|
|
const logExcludeFunc = Array.isArray(logging.excludeFunc) ? logging.excludeFunc : (n.logExcludeFunc ?? [])
|
|
const webhookLogExcludeFunc = Array.isArray(logging.webhookExcludeFunc) ? logging.webhookExcludeFunc : (n.webhookLogExcludeFunc ?? [])
|
|
|
|
// Notifications
|
|
const notifications = n.notifications ?? {}
|
|
const webhook = notifications.webhook ?? n.webhook ?? { enabled: false, url: '' }
|
|
const conclusionWebhook = notifications.conclusionWebhook ?? n.conclusionWebhook ?? { enabled: false, url: '' }
|
|
const ntfy = notifications.ntfy ?? n.ntfy ?? { enabled: false, url: '', topic: '', authToken: '' }
|
|
|
|
// Fingerprinting
|
|
const saveFingerprint = (n.fingerprinting?.saveFingerprint ?? n.saveFingerprint) ?? { mobile: false, desktop: false }
|
|
|
|
// Humanization defaults (single on/off)
|
|
// FIXED: Always initialize humanization object first to prevent undefined access
|
|
if (!n.humanization) n.humanization = {}
|
|
if (typeof n.humanization.enabled !== 'boolean') n.humanization.enabled = true
|
|
if (typeof n.humanization.stopOnBan !== 'boolean') n.humanization.stopOnBan = false
|
|
if (typeof n.humanization.immediateBanAlert !== 'boolean') n.humanization.immediateBanAlert = true
|
|
if (typeof n.humanization.randomOffDaysPerWeek !== 'number') {
|
|
n.humanization.randomOffDaysPerWeek = 1
|
|
}
|
|
// Strong default gestures when enabled (explicit values still win)
|
|
if (typeof n.humanization.gestureMoveProb !== 'number') {
|
|
n.humanization.gestureMoveProb = !n.humanization.enabled ? 0 : 0.5
|
|
}
|
|
if (typeof n.humanization.gestureScrollProb !== 'number') {
|
|
n.humanization.gestureScrollProb = !n.humanization.enabled ? 0 : 0.25
|
|
}
|
|
|
|
// Vacation mode (monthly contiguous off-days)
|
|
if (!n.vacation) n.vacation = {}
|
|
if (typeof n.vacation.enabled !== 'boolean') n.vacation.enabled = false
|
|
const vMin = Number(n.vacation.minDays)
|
|
const vMax = Number(n.vacation.maxDays)
|
|
n.vacation.minDays = isFinite(vMin) && vMin > 0 ? Math.floor(vMin) : 3
|
|
n.vacation.maxDays = isFinite(vMax) && vMax > 0 ? Math.floor(vMax) : 5
|
|
if (n.vacation.maxDays < n.vacation.minDays) {
|
|
const t = n.vacation.minDays; n.vacation.minDays = n.vacation.maxDays; n.vacation.maxDays = t
|
|
}
|
|
|
|
const riskRaw = (n.riskManagement ?? {}) as Record<string, unknown>
|
|
const hasRiskCfg = Object.keys(riskRaw).length > 0
|
|
const riskManagement = hasRiskCfg ? {
|
|
enabled: riskRaw.enabled === true,
|
|
autoAdjustDelays: riskRaw.autoAdjustDelays !== false,
|
|
stopOnCritical: riskRaw.stopOnCritical === true,
|
|
banPrediction: riskRaw.banPrediction === true,
|
|
riskThreshold: typeof riskRaw.riskThreshold === 'number' ? riskRaw.riskThreshold : undefined
|
|
} : undefined
|
|
|
|
const queryDiversityRaw = (n.queryDiversity ?? {}) as Record<string, unknown>
|
|
const hasQueryCfg = Object.keys(queryDiversityRaw).length > 0
|
|
const queryDiversity = hasQueryCfg ? {
|
|
enabled: queryDiversityRaw.enabled === true,
|
|
sources: Array.isArray(queryDiversityRaw.sources) && queryDiversityRaw.sources.length
|
|
? (queryDiversityRaw.sources.filter((s: unknown) => typeof s === 'string') as Array<'google-trends' | 'reddit' | 'news' | 'wikipedia' | 'local-fallback'>)
|
|
: undefined,
|
|
maxQueriesPerSource: typeof queryDiversityRaw.maxQueriesPerSource === 'number' ? queryDiversityRaw.maxQueriesPerSource : undefined,
|
|
cacheMinutes: typeof queryDiversityRaw.cacheMinutes === 'number' ? queryDiversityRaw.cacheMinutes : undefined
|
|
} : undefined
|
|
|
|
const dryRun = n.dryRun === true
|
|
|
|
const jobStateRaw = (n.jobState ?? {}) as Record<string, unknown>
|
|
const jobState = {
|
|
enabled: jobStateRaw.enabled !== false,
|
|
dir: typeof jobStateRaw.dir === 'string' ? jobStateRaw.dir : undefined,
|
|
skipCompletedAccounts: jobStateRaw.skipCompletedAccounts !== false
|
|
}
|
|
|
|
const dashboardRaw = (n.dashboard ?? {}) as Record<string, unknown>
|
|
const dashboard = {
|
|
enabled: dashboardRaw.enabled === true,
|
|
port: typeof dashboardRaw.port === 'number' ? dashboardRaw.port : 3000,
|
|
host: typeof dashboardRaw.host === 'string' ? dashboardRaw.host : '127.0.0.1'
|
|
}
|
|
|
|
const scheduling = buildSchedulingConfig(n.scheduling)
|
|
|
|
const cfg: Config = {
|
|
baseURL: n.baseURL ?? 'https://rewards.bing.com',
|
|
sessionPath: n.sessionPath ?? 'sessions',
|
|
browser,
|
|
parallel,
|
|
runOnZeroPoints,
|
|
clusters,
|
|
saveFingerprint,
|
|
workers,
|
|
searchOnBingLocalQueries: !!useLocalQueries,
|
|
globalTimeout,
|
|
searchSettings,
|
|
humanization: n.humanization,
|
|
retryPolicy: n.retryPolicy,
|
|
jobState,
|
|
logExcludeFunc,
|
|
webhookLogExcludeFunc,
|
|
logging, // retain full logging object for live webhook usage
|
|
proxy: n.proxy ?? { proxyGoogleTrends: true, proxyBingTerms: true },
|
|
webhook,
|
|
conclusionWebhook,
|
|
ntfy,
|
|
update: n.update,
|
|
passesPerRun: passesPerRun,
|
|
vacation: n.vacation,
|
|
crashRecovery: n.crashRecovery || {},
|
|
riskManagement,
|
|
dryRun,
|
|
queryDiversity,
|
|
dashboard,
|
|
scheduling
|
|
}
|
|
|
|
return cfg
|
|
}
|
|
|
|
// IMPROVED: Generic helper to reduce duplication
|
|
function extractStringField(obj: unknown, key: string): string | undefined {
|
|
if (obj && typeof obj === 'object' && key in obj) {
|
|
const value = (obj as Record<string, unknown>)[key]
|
|
return typeof value === 'string' ? value : undefined
|
|
}
|
|
return undefined
|
|
}
|
|
|
|
function extractBooleanField(obj: unknown, key: string): boolean | undefined {
|
|
if (obj && typeof obj === 'object' && key in obj) {
|
|
const value = (obj as Record<string, unknown>)[key]
|
|
return typeof value === 'boolean' ? value : undefined
|
|
}
|
|
return undefined
|
|
}
|
|
|
|
function buildSchedulingConfig(raw: unknown): ConfigScheduling | undefined {
|
|
if (!raw || typeof raw !== 'object') return undefined
|
|
|
|
const source = raw as Record<string, unknown>
|
|
const scheduling: ConfigScheduling = {
|
|
enabled: source.enabled === true,
|
|
type: typeof source.type === 'string' ? source.type as ConfigScheduling['type'] : undefined
|
|
}
|
|
|
|
const cronRaw = source.cron
|
|
if (cronRaw && typeof cronRaw === 'object') {
|
|
scheduling.cron = {
|
|
schedule: extractStringField(cronRaw, 'schedule'),
|
|
workingDirectory: extractStringField(cronRaw, 'workingDirectory'),
|
|
nodePath: extractStringField(cronRaw, 'nodePath'),
|
|
logFile: extractStringField(cronRaw, 'logFile'),
|
|
user: extractStringField(cronRaw, 'user')
|
|
}
|
|
}
|
|
|
|
const taskRaw = source.taskScheduler
|
|
if (taskRaw && typeof taskRaw === 'object') {
|
|
const taskSource = taskRaw as Record<string, unknown>
|
|
scheduling.taskScheduler = {
|
|
taskName: extractStringField(taskRaw, 'taskName'),
|
|
schedule: extractStringField(taskRaw, 'schedule'),
|
|
frequency: typeof taskSource.frequency === 'string' ? taskSource.frequency as 'daily' | 'weekly' | 'once' : undefined,
|
|
workingDirectory: extractStringField(taskRaw, 'workingDirectory'),
|
|
runAsUser: extractBooleanField(taskRaw, 'runAsUser'),
|
|
highestPrivileges: extractBooleanField(taskRaw, 'highestPrivileges')
|
|
}
|
|
}
|
|
|
|
return scheduling
|
|
}
|
|
|
|
export function loadAccounts(): Account[] {
|
|
try {
|
|
// 1) CLI dev override
|
|
let file = 'accounts.json'
|
|
if (process.argv.includes('-dev')) {
|
|
file = 'accounts.dev.json'
|
|
}
|
|
|
|
// 2) Docker-friendly env overrides
|
|
const envJson = process.env.ACCOUNTS_JSON
|
|
const envFile = process.env.ACCOUNTS_FILE
|
|
|
|
let raw: string | undefined
|
|
if (envJson && envJson.trim().startsWith('[')) {
|
|
raw = envJson
|
|
} else if (envFile && envFile.trim()) {
|
|
const full = path.isAbsolute(envFile) ? envFile : path.join(process.cwd(), envFile)
|
|
if (!fs.existsSync(full)) {
|
|
throw new Error(`ACCOUNTS_FILE not found: ${full}`)
|
|
}
|
|
raw = fs.readFileSync(full, 'utf-8')
|
|
} else {
|
|
// Try multiple locations to support both root mounts and dist mounts
|
|
// Support both .json and .jsonc extensions
|
|
const candidates = [
|
|
path.join(__dirname, '../', file), // root/accounts.json (preferred)
|
|
path.join(__dirname, '../', file + 'c'), // root/accounts.jsonc
|
|
path.join(__dirname, '../src', file), // fallback: file kept inside src/
|
|
path.join(__dirname, '../src', file + 'c'), // src/accounts.jsonc
|
|
path.join(process.cwd(), file), // cwd override
|
|
path.join(process.cwd(), file + 'c'), // cwd/accounts.jsonc
|
|
path.join(process.cwd(), 'src', file), // cwd/src/accounts.json
|
|
path.join(process.cwd(), 'src', file + 'c'), // cwd/src/accounts.jsonc
|
|
path.join(__dirname, file), // dist/accounts.json (legacy)
|
|
path.join(__dirname, file + 'c') // dist/accounts.jsonc
|
|
]
|
|
let chosen: string | null = null
|
|
for (const p of candidates) {
|
|
try {
|
|
if (fs.existsSync(p)) {
|
|
chosen = p
|
|
break
|
|
}
|
|
} catch (e) {
|
|
// Filesystem check failed for this path, try next
|
|
continue
|
|
}
|
|
}
|
|
if (!chosen) throw new Error(`accounts file not found in: ${candidates.join(' | ')}`)
|
|
raw = fs.readFileSync(chosen, 'utf-8')
|
|
}
|
|
|
|
// Support comments in accounts file (same as config)
|
|
const cleaned = stripJsonComments(raw)
|
|
const parsedUnknown = JSON.parse(cleaned)
|
|
// Accept either a root array or an object with an `accounts` array, ignore `_note`
|
|
const parsed = Array.isArray(parsedUnknown) ? parsedUnknown : (parsedUnknown && typeof parsedUnknown === 'object' && Array.isArray((parsedUnknown as { accounts?: unknown }).accounts) ? (parsedUnknown as { accounts: unknown[] }).accounts : null)
|
|
if (!Array.isArray(parsed)) throw new Error('accounts must be an array')
|
|
// TYPE SAFETY: Validate entries BEFORE processing
|
|
for (const entry of parsed) {
|
|
// Pre-validation: Check basic structure
|
|
if (!entry || typeof entry !== 'object') {
|
|
throw new Error('each account entry must be an object')
|
|
}
|
|
|
|
// Use Record<string, any> to access dynamic properties from untrusted JSON
|
|
// Runtime validation below ensures type safety
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
const a = entry as Record<string, any>
|
|
|
|
// Validate required fields with proper type checking
|
|
if (typeof a.email !== 'string' || typeof a.password !== 'string') {
|
|
throw new Error('each account must have email and password strings')
|
|
}
|
|
a.email = String(a.email).trim()
|
|
a.password = String(a.password)
|
|
|
|
// Simplified recovery email logic: if present and non-empty, validate it
|
|
if (typeof a.recoveryEmail === 'string') {
|
|
const trimmed = a.recoveryEmail.trim()
|
|
if (trimmed !== '') {
|
|
if (!/@/.test(trimmed)) {
|
|
throw new Error(`account ${a.email} recoveryEmail must be a valid email address (got: "${trimmed}")`)
|
|
}
|
|
a.recoveryEmail = trimmed
|
|
} else {
|
|
a.recoveryEmail = undefined
|
|
}
|
|
} else {
|
|
a.recoveryEmail = undefined
|
|
}
|
|
|
|
if (!a.proxy || typeof a.proxy !== 'object') {
|
|
a.proxy = { proxyAxios: true, url: '', port: 0, username: '', password: '' }
|
|
} else {
|
|
// Safe proxy property access with runtime validation
|
|
const proxy = a.proxy as Record<string, unknown>
|
|
a.proxy = {
|
|
proxyAxios: proxy.proxyAxios !== false,
|
|
url: typeof proxy.url === 'string' ? proxy.url : '',
|
|
port: typeof proxy.port === 'number' ? proxy.port : 0,
|
|
username: typeof proxy.username === 'string' ? proxy.username : '',
|
|
password: typeof proxy.password === 'string' ? proxy.password : ''
|
|
}
|
|
}
|
|
}
|
|
// Filter out disabled accounts (enabled: false)
|
|
const allAccounts = parsed as Account[]
|
|
const enabledAccounts = allAccounts.filter(acc => acc.enabled !== false)
|
|
return enabledAccounts
|
|
} catch (error) {
|
|
throw new Error(error as string)
|
|
}
|
|
}
|
|
|
|
export function getConfigPath(): string { return configSourcePath }
|
|
|
|
export function loadConfig(): Config {
|
|
try {
|
|
if (configCache) {
|
|
return configCache
|
|
}
|
|
|
|
// Resolve configuration file from common locations (supports .jsonc and .json)
|
|
const names = ['config.jsonc', 'config.json']
|
|
const bases = [
|
|
path.join(__dirname, '../'), // dist root when compiled
|
|
path.join(__dirname, '../src'), // fallback: running dist but config still in src
|
|
process.cwd(), // repo root
|
|
path.join(process.cwd(), 'src'), // repo/src when running ts-node
|
|
__dirname // dist/util
|
|
]
|
|
const candidates: string[] = []
|
|
for (const base of bases) {
|
|
for (const name of names) {
|
|
candidates.push(path.join(base, name))
|
|
}
|
|
}
|
|
|
|
let cfgPath: string | null = null
|
|
for (const p of candidates) {
|
|
try {
|
|
if (fs.existsSync(p)) {
|
|
cfgPath = p
|
|
break
|
|
}
|
|
} catch (e) {
|
|
// Filesystem check failed for this path, try next
|
|
continue
|
|
}
|
|
}
|
|
if (!cfgPath) throw new Error(`config.json not found in: ${candidates.join(' | ')}`)
|
|
const config = fs.readFileSync(cfgPath, 'utf-8')
|
|
const text = config.replace(/^\uFEFF/, '')
|
|
const raw = JSON.parse(stripJsonComments(text))
|
|
const normalized = normalizeConfig(raw)
|
|
configCache = normalized
|
|
configSourcePath = cfgPath
|
|
|
|
return normalized
|
|
} catch (error) {
|
|
throw new Error(error as string)
|
|
}
|
|
}
|
|
|
|
interface SessionData {
|
|
cookies: Cookie[]
|
|
fingerprint?: BrowserFingerprintWithHeaders
|
|
}
|
|
|
|
export async function loadSessionData(sessionPath: string, email: string, isMobile: boolean, saveFingerprint: ConfigSaveFingerprint): Promise<SessionData> {
|
|
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 baseDir = path.join(__dirname, '../browser/', sessionPath, email)
|
|
const fingerprintFile = path.join(baseDir, `${isMobile ? 'mobile_fingerprint' : 'desktop_fingerprint'}.json`)
|
|
|
|
let fingerprint!: BrowserFingerprintWithHeaders
|
|
const shouldLoad = (saveFingerprint.desktop && !isMobile) || (saveFingerprint.mobile && isMobile)
|
|
if (shouldLoad && 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, null, 2)
|
|
)
|
|
|
|
return sessionDir
|
|
} catch (error) {
|
|
throw new Error(error as string)
|
|
}
|
|
}
|
|
|
|
export async function saveFingerprintData(sessionPath: string, email: string, isMobile: boolean, fingerprint: 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 file
|
|
const fingerprintPath = path.join(sessionDir, `${isMobile ? 'mobile_fingerprint' : 'desktop_fingerprint'}.json`)
|
|
const payload = JSON.stringify(fingerprint)
|
|
await fs.promises.writeFile(fingerprintPath, payload)
|
|
|
|
return sessionDir
|
|
} catch (error) {
|
|
throw new Error(error as string)
|
|
}
|
|
} |