Advanced Platoboost bypasser with multiple methods, GUI controls, statistics tracking, and auto-bypass features
Size
62.9 KB
Version
2.0.1
Created
Nov 1, 2025
Updated
13 days ago
1// ==UserScript==
2// @name Platoboost Premium Bypasser Pro
3// @description Advanced Platoboost bypasser with multiple methods, GUI controls, statistics tracking, and auto-bypass features
4// @version 2.0.1
5// @match https://*.auth.platoboost.app/*
6// @icon https://auth.platoboost.app/icon.svg
7// @grant GM.getValue
8// @grant GM.setValue
9// @grant GM.deleteValue
10// @grant GM.listValues
11// @grant GM.xmlhttpRequest
12// @grant GM.openInTab
13// @grant GM.setClipboard
14// @connect platoboost.app
15// @connect auth.platoboost.app
16// @connect *
17// @run-at document-start
18// ==/UserScript==
19(function() {
20 'use strict';
21
22 // ============================================
23 // PLATOBOOST PREMIUM BYPASSER PRO v2.0.0
24 // Advanced bypass system with multiple methods
25 // ============================================
26
27 console.log('%c[Platoboost Bypasser Pro] Initializing...', 'color: #00ff00; font-weight: bold; font-size: 14px;');
28
29 // ============================================
30 // CONFIGURATION & CONSTANTS
31 // ============================================
32 const CONFIG = {
33 VERSION: '2.0.0',
34 AUTO_BYPASS_ENABLED: true,
35 BYPASS_DELAY: 100, // milliseconds
36 MAX_RETRIES: 10,
37 RETRY_DELAY: 500,
38 STEALTH_MODE: true,
39 AGGRESSIVE_MODE: true,
40 STATISTICS_ENABLED: true,
41 GUI_ENABLED: true,
42 NOTIFICATION_ENABLED: true,
43 AUTO_CLOSE_POPUPS: true,
44 SKIP_TIMERS: true,
45 BLOCK_ADS: true,
46 FAST_MODE: true
47 };
48
49 // Storage keys
50 const STORAGE_KEYS = {
51 STATS: 'platoboost_stats',
52 CONFIG: 'platoboost_config',
53 HISTORY: 'platoboost_history',
54 CACHE: 'platoboost_cache'
55 };
56
57 // ============================================
58 // STATE MANAGEMENT
59 // ============================================
60 class StateManager {
61 constructor() {
62 this.state = {
63 bypassInProgress: false,
64 currentStep: 0,
65 totalSteps: 0,
66 startTime: null,
67 retryCount: 0,
68 method: null,
69 logs: [],
70 errors: []
71 };
72 }
73
74 updateState(updates) {
75 this.state = { ...this.state, ...updates };
76 this.notifyListeners();
77 }
78
79 getState() {
80 return { ...this.state };
81 }
82
83 addLog(message, type = 'info') {
84 const log = {
85 timestamp: Date.now(),
86 message,
87 type
88 };
89 this.state.logs.push(log);
90 console.log(`%c[Bypasser ${type.toUpperCase()}] ${message}`, this.getLogColor(type));
91 }
92
93 getLogColor(type) {
94 const colors = {
95 info: 'color: #00bfff',
96 success: 'color: #00ff00; font-weight: bold',
97 warning: 'color: #ffa500',
98 error: 'color: #ff0000; font-weight: bold',
99 debug: 'color: #888888'
100 };
101 return colors[type] || colors.info;
102 }
103
104 notifyListeners() {
105 if (window.bypasserGUI) {
106 window.bypasserGUI.updateDisplay();
107 }
108 }
109 }
110
111 const stateManager = new StateManager();
112
113 // ============================================
114 // STATISTICS TRACKER
115 // ============================================
116 class StatisticsTracker {
117 constructor() {
118 this.stats = null;
119 this.init();
120 }
121
122 async init() {
123 this.stats = await GM.getValue(STORAGE_KEYS.STATS, {
124 totalBypasses: 0,
125 successfulBypasses: 0,
126 failedBypasses: 0,
127 totalTimeSaved: 0,
128 averageBypassTime: 0,
129 methodsUsed: {},
130 lastBypass: null,
131 firstUse: Date.now()
132 });
133 }
134
135 async recordBypass(success, method, timeTaken) {
136 this.stats.totalBypasses++;
137 if (success) {
138 this.stats.successfulBypasses++;
139 this.stats.totalTimeSaved += Math.max(0, 30000 - timeTaken); // Assuming 30s normal wait
140 } else {
141 this.stats.failedBypasses++;
142 }
143
144 this.stats.methodsUsed[method] = (this.stats.methodsUsed[method] || 0) + 1;
145 this.stats.averageBypassTime =
146 (this.stats.averageBypassTime * (this.stats.totalBypasses - 1) + timeTaken) / this.stats.totalBypasses;
147 this.stats.lastBypass = Date.now();
148
149 await GM.setValue(STORAGE_KEYS.STATS, this.stats);
150 stateManager.addLog(`Statistics updated: ${this.stats.successfulBypasses}/${this.stats.totalBypasses} successful`, 'info');
151 }
152
153 async getStats() {
154 return this.stats;
155 }
156
157 async resetStats() {
158 this.stats = {
159 totalBypasses: 0,
160 successfulBypasses: 0,
161 failedBypasses: 0,
162 totalTimeSaved: 0,
163 averageBypassTime: 0,
164 methodsUsed: {},
165 lastBypass: null,
166 firstUse: Date.now()
167 };
168 await GM.setValue(STORAGE_KEYS.STATS, this.stats);
169 stateManager.addLog('Statistics reset', 'info');
170 }
171
172 formatTime(ms) {
173 const seconds = Math.floor(ms / 1000);
174 const minutes = Math.floor(seconds / 60);
175 const hours = Math.floor(minutes / 60);
176
177 if (hours > 0) return `${hours}h ${minutes % 60}m`;
178 if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
179 return `${seconds}s`;
180 }
181 }
182
183 const statsTracker = new StatisticsTracker();
184
185 // ============================================
186 // UTILITY FUNCTIONS
187 // ============================================
188 const Utils = {
189 sleep(ms) {
190 return new Promise(resolve => setTimeout(resolve, ms));
191 },
192
193 waitForElement(selector, timeout = 10000) {
194 return new Promise((resolve, reject) => {
195 const startTime = Date.now();
196
197 const check = () => {
198 const element = document.querySelector(selector);
199 if (element) {
200 resolve(element);
201 } else if (Date.now() - startTime > timeout) {
202 reject(new Error(`Element ${selector} not found within ${timeout}ms`));
203 } else {
204 setTimeout(check, 100);
205 }
206 };
207
208 check();
209 });
210 },
211
212 clickElement(element) {
213 if (!element) return false;
214
215 try {
216 // Multiple click methods for maximum compatibility
217 element.click();
218
219 const clickEvent = new MouseEvent('click', {
220 view: window,
221 bubbles: true,
222 cancelable: true
223 });
224 element.dispatchEvent(clickEvent);
225
226 return true;
227 } catch (error) {
228 stateManager.addLog(`Click error: ${error.message}`, 'error');
229 return false;
230 }
231 },
232
233 extractUrlParameter(param) {
234 const urlParams = new URLSearchParams(window.location.search);
235 return urlParams.get(param);
236 },
237
238 getPageData() {
239 const url = window.location.href;
240 const dataParam = this.extractUrlParameter('d');
241 return { url, dataParam };
242 },
243
244 async makeRequest(url, options = {}) {
245 return new Promise((resolve, reject) => {
246 GM.xmlhttpRequest({
247 method: options.method || 'GET',
248 url: url,
249 headers: options.headers || {},
250 data: options.data,
251 onload: (response) => resolve(response),
252 onerror: (error) => reject(error),
253 ontimeout: () => reject(new Error('Request timeout'))
254 });
255 });
256 },
257
258 debounce(func, wait) {
259 let timeout;
260 return function executedFunction(...args) {
261 const later = () => {
262 clearTimeout(timeout);
263 func(...args);
264 };
265 clearTimeout(timeout);
266 timeout = setTimeout(later, wait);
267 };
268 },
269
270 generateRandomString(length = 10) {
271 const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
272 let result = '';
273 for (let i = 0; i < length; i++) {
274 result += chars.charAt(Math.floor(Math.random() * chars.length));
275 }
276 return result;
277 }
278 };
279
280 // ============================================
281 // BYPASS METHODS
282 // ============================================
283 class BypassMethods {
284 constructor() {
285 this.methods = [
286 { name: 'Direct Button Click', func: this.directButtonClick.bind(this), priority: 1 },
287 { name: 'Timer Skip', func: this.timerSkip.bind(this), priority: 2 },
288 { name: 'DOM Manipulation', func: this.domManipulation.bind(this), priority: 3 },
289 { name: 'API Intercept', func: this.apiIntercept.bind(this), priority: 4 },
290 { name: 'Cookie Manipulation', func: this.cookieManipulation.bind(this), priority: 5 },
291 { name: 'LocalStorage Hack', func: this.localStorageHack.bind(this), priority: 6 },
292 { name: 'Network Bypass', func: this.networkBypass.bind(this), priority: 7 },
293 { name: 'Aggressive Force', func: this.aggressiveForce.bind(this), priority: 8 }
294 ];
295 }
296
297 async directButtonClick() {
298 stateManager.addLog('Attempting direct button click method...', 'info');
299
300 const buttonSelectors = [
301 'button.bg-primary[class*="inline-flex"]',
302 'button.inline-flex.bg-primary',
303 'button[class*="bg-primary"]',
304 'button:not([disabled])'
305 ];
306
307 for (const selector of buttonSelectors) {
308 try {
309 const buttons = document.querySelectorAll(selector);
310 for (const button of buttons) {
311 const buttonText = button.textContent.trim().toLowerCase();
312 if (buttonText.includes('continue') || buttonText.includes('next')) {
313 stateManager.addLog(`Found continue button with text: ${button.textContent.trim()}`, 'success');
314
315 // Try multiple click methods
316 button.disabled = false;
317 button.style.pointerEvents = 'auto';
318
319 // Method 1: Direct click
320 button.click();
321
322 // Method 2: MouseEvent
323 const clickEvent = new MouseEvent('click', {
324 view: window,
325 bubbles: true,
326 cancelable: true,
327 buttons: 1
328 });
329 button.dispatchEvent(clickEvent);
330
331 // Method 3: PointerEvent
332 const pointerDown = new PointerEvent('pointerdown', { bubbles: true, cancelable: true });
333 const pointerUp = new PointerEvent('pointerup', { bubbles: true, cancelable: true });
334 button.dispatchEvent(pointerDown);
335 button.dispatchEvent(pointerUp);
336
337 // Method 4: Touch events for mobile compatibility
338 const touchStart = new TouchEvent('touchstart', { bubbles: true, cancelable: true });
339 const touchEnd = new TouchEvent('touchend', { bubbles: true, cancelable: true });
340 button.dispatchEvent(touchStart);
341 button.dispatchEvent(touchEnd);
342
343 stateManager.addLog('Button clicked with multiple methods', 'success');
344 await Utils.sleep(CONFIG.BYPASS_DELAY);
345 return true;
346 }
347 }
348 } catch (error) {
349 stateManager.addLog(`Selector error: ${error.message}`, 'debug');
350 }
351 }
352
353 return false;
354 }
355
356 async timerSkip() {
357 stateManager.addLog('Attempting timer skip method...', 'info');
358
359 try {
360 // Override setTimeout and setInterval
361 const originalSetTimeout = window.setTimeout;
362 const originalSetInterval = window.setInterval;
363
364 window.setTimeout = function(callback, delay, ...args) {
365 if (delay > 1000) {
366 stateManager.addLog(`Skipping timer: ${delay}ms`, 'success');
367 delay = 0;
368 }
369 return originalSetTimeout(callback, delay, ...args);
370 };
371
372 window.setInterval = function(callback, delay, ...args) {
373 if (delay > 1000) {
374 stateManager.addLog(`Skipping interval: ${delay}ms`, 'success');
375 delay = 100;
376 }
377 return originalSetInterval(callback, delay, ...args);
378 };
379
380 // Find and modify countdown elements
381 const countdownElements = document.querySelectorAll('[class*="countdown"], [class*="timer"], [id*="timer"]');
382 countdownElements.forEach(el => {
383 el.textContent = '0';
384 el.style.display = 'none';
385 });
386
387 return true;
388 } catch (error) {
389 stateManager.addLog(`Timer skip error: ${error.message}`, 'error');
390 return false;
391 }
392 }
393
394 async domManipulation() {
395 stateManager.addLog('Attempting DOM manipulation method...', 'info');
396
397 try {
398 // Remove disabled attributes
399 const disabledElements = document.querySelectorAll('[disabled]');
400 disabledElements.forEach(el => {
401 el.removeAttribute('disabled');
402 el.classList.remove('disabled');
403 stateManager.addLog('Removed disabled attribute', 'debug');
404 });
405
406 // Enable all buttons
407 const buttons = document.querySelectorAll('button');
408 buttons.forEach(btn => {
409 btn.disabled = false;
410 btn.style.pointerEvents = 'auto';
411 btn.style.opacity = '1';
412 });
413
414 // Remove overlays
415 const overlays = document.querySelectorAll('[class*="overlay"], [class*="modal"], [class*="popup"]');
416 overlays.forEach(overlay => {
417 if (overlay.style.zIndex > 1000) {
418 overlay.remove();
419 stateManager.addLog('Removed overlay element', 'debug');
420 }
421 });
422
423 return true;
424 } catch (error) {
425 stateManager.addLog(`DOM manipulation error: ${error.message}`, 'error');
426 return false;
427 }
428 }
429
430 async apiIntercept() {
431 stateManager.addLog('Attempting API intercept method...', 'info');
432
433 try {
434 // Intercept fetch requests
435 const originalFetch = window.fetch;
436 window.fetch = async function(...args) {
437 const response = await originalFetch(...args);
438
439 if (args[0].includes('platoboost')) {
440 stateManager.addLog(`Intercepted API call: ${args[0]}`, 'success');
441
442 // Clone and modify response
443 const clonedResponse = response.clone();
444 try {
445 const data = await clonedResponse.json();
446 stateManager.addLog(`API Response: ${JSON.stringify(data).substring(0, 100)}`, 'debug');
447 } catch (e) {
448 // Not JSON
449 }
450 }
451
452 return response;
453 };
454
455 // Intercept XMLHttpRequest
456 const originalOpen = XMLHttpRequest.prototype.open;
457 XMLHttpRequest.prototype.open = function(method, url, ...rest) {
458 if (url.includes('platoboost')) {
459 stateManager.addLog(`Intercepted XHR: ${method} ${url}`, 'success');
460 }
461 return originalOpen.call(this, method, url, ...rest);
462 };
463
464 return true;
465 } catch (error) {
466 stateManager.addLog(`API intercept error: ${error.message}`, 'error');
467 return false;
468 }
469 }
470
471 async cookieManipulation() {
472 stateManager.addLog('Attempting cookie manipulation method...', 'info');
473
474 try {
475 // Set bypass cookies
476 const bypassCookies = [
477 'platoboost_verified=true',
478 'bypass_complete=1',
479 'verification_done=true',
480 'step_completed=2'
481 ];
482
483 bypassCookies.forEach(cookie => {
484 document.cookie = `${cookie}; path=/; domain=.platoboost.app`;
485 stateManager.addLog(`Set cookie: ${cookie}`, 'debug');
486 });
487
488 return true;
489 } catch (error) {
490 stateManager.addLog(`Cookie manipulation error: ${error.message}`, 'error');
491 return false;
492 }
493 }
494
495 async localStorageHack() {
496 stateManager.addLog('Attempting localStorage hack method...', 'info');
497
498 try {
499 // Set bypass flags in localStorage
500 const bypassData = {
501 verified: true,
502 completed: true,
503 step: 999,
504 timestamp: Date.now(),
505 bypass: true
506 };
507
508 Object.keys(bypassData).forEach(key => {
509 localStorage.setItem(`platoboost_${key}`, JSON.stringify(bypassData[key]));
510 sessionStorage.setItem(`platoboost_${key}`, JSON.stringify(bypassData[key]));
511 stateManager.addLog(`Set storage: platoboost_${key}`, 'debug');
512 });
513
514 return true;
515 } catch (error) {
516 stateManager.addLog(`LocalStorage hack error: ${error.message}`, 'error');
517 return false;
518 }
519 }
520
521 async networkBypass() {
522 stateManager.addLog('Attempting network bypass method...', 'info');
523
524 try {
525 const pageData = Utils.getPageData();
526
527 if (pageData.dataParam) {
528 stateManager.addLog(`Found data parameter: ${pageData.dataParam.substring(0, 20)}...`, 'info');
529
530 // Try to decode and extract destination
531 try {
532 const decoded = atob(pageData.dataParam);
533 stateManager.addLog(`Decoded data: ${decoded.substring(0, 50)}...`, 'debug');
534 } catch (e) {
535 stateManager.addLog('Data parameter is not base64', 'debug');
536 }
537 }
538
539 return true;
540 } catch (error) {
541 stateManager.addLog(`Network bypass error: ${error.message}`, 'error');
542 return false;
543 }
544 }
545
546 async aggressiveForce() {
547 stateManager.addLog('Attempting aggressive force method...', 'warning');
548
549 try {
550 // Click all possible buttons
551 const allButtons = document.querySelectorAll('button, [role="button"], .btn, [class*="button"]');
552 stateManager.addLog(`Found ${allButtons.length} clickable elements`, 'info');
553
554 for (const button of allButtons) {
555 if (button.textContent.toLowerCase().includes('continue') ||
556 button.textContent.toLowerCase().includes('next') ||
557 button.textContent.toLowerCase().includes('proceed')) {
558
559 stateManager.addLog(`Clicking: ${button.textContent.trim()}`, 'success');
560 Utils.clickElement(button);
561 await Utils.sleep(CONFIG.BYPASS_DELAY);
562 }
563 }
564
565 // Force form submissions
566 const forms = document.querySelectorAll('form');
567 forms.forEach(form => {
568 try {
569 form.submit();
570 stateManager.addLog('Submitted form', 'debug');
571 } catch (e) {
572 // Ignore errors
573 }
574 });
575
576 return true;
577 } catch (error) {
578 stateManager.addLog(`Aggressive force error: ${error.message}`, 'error');
579 return false;
580 }
581 }
582
583 async executeAll() {
584 stateManager.addLog('Executing all bypass methods...', 'info');
585
586 // Sort by priority
587 const sortedMethods = [...this.methods].sort((a, b) => a.priority - b.priority);
588
589 for (const method of sortedMethods) {
590 try {
591 stateManager.updateState({ method: method.name });
592 const result = await method.func();
593
594 if (result) {
595 stateManager.addLog(`✓ ${method.name} executed successfully`, 'success');
596 } else {
597 stateManager.addLog(`✗ ${method.name} failed`, 'warning');
598 }
599
600 await Utils.sleep(CONFIG.BYPASS_DELAY);
601 } catch (error) {
602 stateManager.addLog(`✗ ${method.name} error: ${error.message}`, 'error');
603 }
604 }
605
606 // After all methods, check for key
607 await this.checkForKey();
608 }
609
610 async checkForKey() {
611 stateManager.addLog('Checking for key...', 'info');
612
613 // Wait a bit for the page to load the key
614 await Utils.sleep(2000);
615
616 // Look for textarea with key
617 const textarea = document.querySelector('textarea');
618 if (textarea && textarea.value && textarea.value.length > 20) {
619 const key = textarea.value;
620 stateManager.addLog(`✓ KEY FOUND: ${key.substring(0, 30)}...`, 'success');
621
622 // Copy to clipboard
623 try {
624 await GM.setClipboard(key);
625 stateManager.addLog('✓ Key copied to clipboard!', 'success');
626
627 // Show success notification
628 this.showKeyNotification(key);
629
630 return key;
631 } catch (error) {
632 stateManager.addLog(`Clipboard error: ${error.message}`, 'error');
633
634 // Fallback: try native clipboard API
635 try {
636 await navigator.clipboard.writeText(key);
637 stateManager.addLog('✓ Key copied to clipboard (fallback)!', 'success');
638 this.showKeyNotification(key);
639 return key;
640 } catch (e) {
641 stateManager.addLog('Failed to copy key', 'error');
642 }
643 }
644 } else {
645 stateManager.addLog('No key found yet, will retry...', 'warning');
646 }
647
648 return null;
649 }
650
651 showKeyNotification(key) {
652 const notification = document.createElement('div');
653 notification.style.cssText = `
654 position: fixed;
655 top: 50%;
656 left: 50%;
657 transform: translate(-50%, -50%);
658 background: linear-gradient(135deg, #00ff00, #00cc00);
659 color: #000;
660 padding: 30px 40px;
661 border-radius: 15px;
662 box-shadow: 0 10px 50px rgba(0, 255, 0, 0.5);
663 z-index: 9999999;
664 font-family: Arial, sans-serif;
665 font-size: 18px;
666 font-weight: bold;
667 text-align: center;
668 min-width: 400px;
669 animation: scaleIn 0.3s ease-out;
670 `;
671
672 notification.innerHTML = `
673 <div style="font-size: 48px; margin-bottom: 15px;">🎉</div>
674 <div style="font-size: 24px; margin-bottom: 10px;">KEY OBTAINED!</div>
675 <div style="font-size: 14px; background: rgba(0,0,0,0.2); padding: 10px; border-radius: 8px; margin: 15px 0; word-break: break-all; font-family: monospace;">
676 ${key.substring(0, 50)}${key.length > 50 ? '...' : ''}
677 </div>
678 <div style="font-size: 16px; color: #000;">✓ Copied to Clipboard!</div>
679 `;
680
681 // Add animation
682 const style = document.createElement('style');
683 style.textContent = `
684 @keyframes scaleIn {
685 from { transform: translate(-50%, -50%) scale(0.5); opacity: 0; }
686 to { transform: translate(-50%, -50%) scale(1); opacity: 1; }
687 }
688 `;
689 document.head.appendChild(style);
690
691 document.body.appendChild(notification);
692
693 // Auto-remove after 5 seconds
694 setTimeout(() => {
695 notification.style.transition = 'opacity 0.5s';
696 notification.style.opacity = '0';
697 setTimeout(() => notification.remove(), 500);
698 }, 5000);
699 }
700
701 async executeBypass() {
702 stateManager.addLog('Executing bypass sequence...', 'info');
703
704 // Wait for page to load
705 if (document.readyState !== 'complete') {
706 stateManager.addLog('Waiting for page to load...', 'info');
707 await new Promise(resolve => {
708 window.addEventListener('load', resolve);
709 });
710 }
711
712 await Utils.sleep(500);
713
714 // Execute all bypass methods
715 await bypassMethods.executeAll();
716
717 // Check if bypass was successful
718 await Utils.sleep(1000);
719 const success = await this.checkBypassSuccess();
720
721 const timeTaken = Date.now() - stateManager.state.startTime;
722
723 if (success) {
724 stateManager.addLog(`✓ BYPASS SUCCESSFUL in ${timeTaken}ms!`, 'success');
725 await statsTracker.recordBypass(true, 'multi-method', timeTaken);
726 this.showSuccessNotification(timeTaken);
727 } else {
728 stateManager.addLog('Checking for key on current page...', 'info');
729 // Even if not redirected, check for key
730 const key = await bypassMethods.checkForKey();
731 if (key) {
732 stateManager.addLog('✓ Key obtained successfully!', 'success');
733 await statsTracker.recordBypass(true, 'multi-method', timeTaken);
734 } else {
735 stateManager.addLog('Bypass may not be complete, monitoring...', 'warning');
736 await this.retry();
737 }
738 }
739
740 this.running = false;
741 stateManager.updateState({ bypassInProgress: false });
742 }
743
744 async checkBypassSuccess() {
745 // Check if we've moved to a different page
746 const currentUrl = window.location.href;
747
748 // Check for success indicators
749 const successIndicators = [
750 () => !document.querySelector('button.bg-primary'),
751 () => currentUrl !== stateManager.state.startUrl,
752 () => document.body.textContent.includes('success'),
753 () => document.body.textContent.includes('complete')
754 ];
755
756 return successIndicators.some(check => {
757 try {
758 return check();
759 } catch {
760 return false;
761 }
762 });
763 }
764
765 async retry() {
766 if (this.retryCount >= CONFIG.MAX_RETRIES) {
767 stateManager.addLog('Max retries reached', 'error');
768 await statsTracker.recordBypass(false, 'multi-method', Date.now() - stateManager.state.startTime);
769 return;
770 }
771
772 this.retryCount++;
773 stateManager.updateState({ retryCount: this.retryCount });
774 stateManager.addLog(`Retrying... (${this.retryCount}/${CONFIG.MAX_RETRIES})`, 'warning');
775
776 await Utils.sleep(CONFIG.RETRY_DELAY);
777 this.running = false;
778 await this.start();
779 }
780
781 showSuccessNotification(timeTaken) {
782 if (!CONFIG.NOTIFICATION_ENABLED) return;
783
784 const notification = document.createElement('div');
785 notification.style.cssText = `
786 position: fixed;
787 top: 20px;
788 right: 20px;
789 background: linear-gradient(135deg, #00ff00, #00cc00);
790 color: white;
791 padding: 20px 30px;
792 border-radius: 10px;
793 box-shadow: 0 4px 20px rgba(0, 255, 0, 0.3);
794 z-index: 999999;
795 font-family: Arial, sans-serif;
796 font-size: 16px;
797 font-weight: bold;
798 animation: slideIn 0.5s ease-out;
799 `;
800 notification.innerHTML = `
801 ✓ Bypass Complete!<br>
802 <span style="font-size: 12px; font-weight: normal;">Time: ${timeTaken}ms</span>
803 `;
804
805 document.body.appendChild(notification);
806
807 setTimeout(() => {
808 notification.style.animation = 'slideOut 0.5s ease-in';
809 setTimeout(() => notification.remove(), 500);
810 }, 3000);
811 }
812 }
813
814 const bypassMethods = new BypassMethods();
815
816 // ============================================
817 // POPUP BLOCKER
818 // ============================================
819 class PopupBlocker {
820 constructor() {
821 this.init();
822 }
823
824 init() {
825 if (!CONFIG.AUTO_CLOSE_POPUPS) return;
826
827 stateManager.addLog('Popup blocker initialized', 'info');
828
829 // Override window.open
830 window.open = function(...args) {
831 stateManager.addLog(`Blocked popup: ${args[0]}`, 'success');
832 return null;
833 };
834
835 // Block popunder
836 window.addEventListener('beforeunload', (e) => {
837 e.preventDefault();
838 e.returnValue = '';
839 });
840
841 // Monitor for new windows
842 setInterval(() => {
843 if (window.opener) {
844 window.close();
845 }
846 }, 1000);
847 }
848 }
849
850 const popupBlocker = new PopupBlocker();
851
852 // ============================================
853 // AD BLOCKER
854 // ============================================
855 class AdBlocker {
856 constructor() {
857 this.init();
858 }
859
860 init() {
861 if (!CONFIG.BLOCK_ADS) return;
862
863 stateManager.addLog('Ad blocker initialized', 'info');
864
865 const adSelectors = [
866 '[class*="ad-"]',
867 '[id*="ad-"]',
868 '[class*="advertisement"]',
869 'iframe[src*="ads"]',
870 'iframe[src*="doubleclick"]',
871 '.ad',
872 '.ads',
873 '.adsbygoogle'
874 ];
875
876 const removeAds = () => {
877 adSelectors.forEach(selector => {
878 const ads = document.querySelectorAll(selector);
879 ads.forEach(ad => {
880 ad.remove();
881 stateManager.addLog(`Removed ad element: ${selector}`, 'debug');
882 });
883 });
884 };
885
886 // Remove ads on load
887 removeAds();
888
889 // Monitor for new ads
890 const observer = new MutationObserver(Utils.debounce(removeAds, 500));
891 observer.observe(document.body, {
892 childList: true,
893 subtree: true
894 });
895 }
896 }
897
898 const adBlocker = new AdBlocker();
899
900 // ============================================
901 // MAIN BYPASS ENGINE
902 // ============================================
903 class BypassEngine {
904 constructor() {
905 this.running = false;
906 this.retryCount = 0;
907 }
908
909 async start() {
910 if (this.running) {
911 stateManager.addLog('Bypass already in progress', 'warning');
912 return;
913 }
914
915 this.running = true;
916 stateManager.updateState({
917 bypassInProgress: true,
918 startTime: Date.now(),
919 retryCount: 0
920 });
921
922 stateManager.addLog('=== BYPASS ENGINE STARTED ===', 'success');
923 stateManager.addLog(`Version: ${CONFIG.VERSION}`, 'info');
924 stateManager.addLog(`URL: ${window.location.href}`, 'info');
925
926 try {
927 await this.executeBypass();
928 } catch (error) {
929 stateManager.addLog(`Bypass engine error: ${error.message}`, 'error');
930 await this.retry();
931 }
932 }
933
934 async executeBypass() {
935 stateManager.addLog('Executing bypass sequence...', 'info');
936
937 // Wait for page to load
938 if (document.readyState !== 'complete') {
939 stateManager.addLog('Waiting for page to load...', 'info');
940 await new Promise(resolve => {
941 window.addEventListener('load', resolve);
942 });
943 }
944
945 await Utils.sleep(500);
946
947 // Execute all bypass methods
948 await bypassMethods.executeAll();
949
950 // Check if bypass was successful
951 await Utils.sleep(1000);
952 const success = await this.checkBypassSuccess();
953
954 const timeTaken = Date.now() - stateManager.state.startTime;
955
956 if (success) {
957 stateManager.addLog(`✓ BYPASS SUCCESSFUL in ${timeTaken}ms!`, 'success');
958 await statsTracker.recordBypass(true, 'multi-method', timeTaken);
959 this.showSuccessNotification(timeTaken);
960 } else {
961 stateManager.addLog('Checking for key on current page...', 'info');
962 // Even if not redirected, check for key
963 const key = await bypassMethods.checkForKey();
964 if (key) {
965 stateManager.addLog('✓ Key obtained successfully!', 'success');
966 await statsTracker.recordBypass(true, 'multi-method', timeTaken);
967 } else {
968 stateManager.addLog('Bypass may not be complete, monitoring...', 'warning');
969 await this.retry();
970 }
971 }
972
973 this.running = false;
974 stateManager.updateState({ bypassInProgress: false });
975 }
976
977 async checkBypassSuccess() {
978 // Check if we've moved to a different page
979 const currentUrl = window.location.href;
980
981 // Check for success indicators
982 const successIndicators = [
983 () => !document.querySelector('button.bg-primary'),
984 () => currentUrl !== stateManager.state.startUrl,
985 () => document.body.textContent.includes('success'),
986 () => document.body.textContent.includes('complete')
987 ];
988
989 return successIndicators.some(check => {
990 try {
991 return check();
992 } catch {
993 return false;
994 }
995 });
996 }
997
998 async retry() {
999 if (this.retryCount >= CONFIG.MAX_RETRIES) {
1000 stateManager.addLog('Max retries reached', 'error');
1001 await statsTracker.recordBypass(false, 'multi-method', Date.now() - stateManager.state.startTime);
1002 return;
1003 }
1004
1005 this.retryCount++;
1006 stateManager.updateState({ retryCount: this.retryCount });
1007 stateManager.addLog(`Retrying... (${this.retryCount}/${CONFIG.MAX_RETRIES})`, 'warning');
1008
1009 await Utils.sleep(CONFIG.RETRY_DELAY);
1010 this.running = false;
1011 await this.start();
1012 }
1013
1014 showSuccessNotification(timeTaken) {
1015 if (!CONFIG.NOTIFICATION_ENABLED) return;
1016
1017 const notification = document.createElement('div');
1018 notification.style.cssText = `
1019 position: fixed;
1020 top: 20px;
1021 right: 20px;
1022 background: linear-gradient(135deg, #00ff00, #00cc00);
1023 color: white;
1024 padding: 20px 30px;
1025 border-radius: 10px;
1026 box-shadow: 0 4px 20px rgba(0, 255, 0, 0.3);
1027 z-index: 999999;
1028 font-family: Arial, sans-serif;
1029 font-size: 16px;
1030 font-weight: bold;
1031 animation: slideIn 0.5s ease-out;
1032 `;
1033 notification.innerHTML = `
1034 ✓ Bypass Complete!<br>
1035 <span style="font-size: 12px; font-weight: normal;">Time: ${timeTaken}ms</span>
1036 `;
1037
1038 document.body.appendChild(notification);
1039
1040 setTimeout(() => {
1041 notification.style.animation = 'slideOut 0.5s ease-in';
1042 setTimeout(() => notification.remove(), 500);
1043 }, 3000);
1044 }
1045 }
1046
1047 const bypassEngine = new BypassEngine();
1048
1049 // ============================================
1050 // GUI SYSTEM
1051 // ============================================
1052 class BypasserGUI {
1053 constructor() {
1054 this.visible = false;
1055 this.minimized = false;
1056 this.init();
1057 }
1058
1059 init() {
1060 if (!CONFIG.GUI_ENABLED) return;
1061
1062 this.injectStyles();
1063 this.createGUI();
1064 this.attachEventListeners();
1065
1066 stateManager.addLog('GUI initialized', 'info');
1067 }
1068
1069 injectStyles() {
1070 const styles = `
1071 @keyframes slideIn {
1072 from { transform: translateX(400px); opacity: 0; }
1073 to { transform: translateX(0); opacity: 1; }
1074 }
1075
1076 @keyframes slideOut {
1077 from { transform: translateX(0); opacity: 1; }
1078 to { transform: translateX(400px); opacity: 0; }
1079 }
1080
1081 @keyframes pulse {
1082 0%, 100% { transform: scale(1); }
1083 50% { transform: scale(1.05); }
1084 }
1085
1086 .bypasser-gui {
1087 position: fixed;
1088 top: 20px;
1089 right: 20px;
1090 width: 400px;
1091 background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
1092 border: 2px solid #00ff00;
1093 border-radius: 15px;
1094 box-shadow: 0 10px 40px rgba(0, 255, 0, 0.2);
1095 z-index: 999998;
1096 font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
1097 color: #ffffff;
1098 overflow: hidden;
1099 animation: slideIn 0.5s ease-out;
1100 }
1101
1102 .bypasser-gui.minimized {
1103 width: 200px;
1104 height: 60px;
1105 }
1106
1107 .bypasser-header {
1108 background: linear-gradient(135deg, #00ff00 0%, #00cc00 100%);
1109 padding: 15px;
1110 cursor: move;
1111 display: flex;
1112 justify-content: space-between;
1113 align-items: center;
1114 user-select: none;
1115 }
1116
1117 .bypasser-title {
1118 font-size: 16px;
1119 font-weight: bold;
1120 color: #000;
1121 }
1122
1123 .bypasser-controls {
1124 display: flex;
1125 gap: 10px;
1126 }
1127
1128 .bypasser-btn {
1129 background: rgba(0, 0, 0, 0.3);
1130 border: none;
1131 color: #000;
1132 width: 25px;
1133 height: 25px;
1134 border-radius: 5px;
1135 cursor: pointer;
1136 font-weight: bold;
1137 transition: all 0.3s;
1138 }
1139
1140 .bypasser-btn:hover {
1141 background: rgba(0, 0, 0, 0.5);
1142 transform: scale(1.1);
1143 }
1144
1145 .bypasser-btn:active {
1146 transform: translateY(-2px);
1147 }
1148
1149 .bypasser-content {
1150 padding: 20px;
1151 max-height: 600px;
1152 overflow-y: auto;
1153 }
1154
1155 .bypasser-section {
1156 margin-bottom: 20px;
1157 padding: 15px;
1158 background: rgba(255, 255, 255, 0.05);
1159 border-radius: 10px;
1160 border: 1px solid rgba(0, 255, 0, 0.2);
1161 }
1162
1163 .bypasser-section-title {
1164 font-size: 14px;
1165 font-weight: bold;
1166 color: #00ff00;
1167 margin-bottom: 10px;
1168 text-transform: uppercase;
1169 }
1170
1171 .bypasser-stat {
1172 display: flex;
1173 justify-content: space-between;
1174 padding: 8px 0;
1175 border-bottom: 1px solid rgba(255, 255, 255, 0.1);
1176 }
1177
1178 .bypasser-stat:last-child {
1179 border-bottom: none;
1180 }
1181
1182 .bypasser-stat-label {
1183 color: #aaa;
1184 font-size: 13px;
1185 }
1186
1187 .bypasser-stat-value {
1188 color: #00ff00;
1189 font-weight: bold;
1190 font-size: 13px;
1191 }
1192
1193 .bypasser-button {
1194 width: 100%;
1195 padding: 12px;
1196 background: linear-gradient(135deg, #00ff00 0%, #00cc00 100%);
1197 border: none;
1198 border-radius: 8px;
1199 color: #000;
1200 font-weight: bold;
1201 font-size: 14px;
1202 cursor: pointer;
1203 transition: all 0.3s;
1204 margin-bottom: 10px;
1205 }
1206
1207 .bypasser-button:hover {
1208 transform: translateY(-2px);
1209 box-shadow: 0 5px 15px rgba(0, 255, 0, 0.3);
1210 }
1211
1212 .bypasser-button:active {
1213 transform: translateY(0);
1214 }
1215
1216 .bypasser-button.danger {
1217 background: linear-gradient(135deg, #ff0000 0%, #cc0000 100%);
1218 color: #fff;
1219 }
1220
1221 .bypasser-log {
1222 background: rgba(0, 0, 0, 0.3);
1223 border-radius: 8px;
1224 padding: 10px;
1225 max-height: 200px;
1226 overflow-y: auto;
1227 font-size: 11px;
1228 font-family: 'Courier New', monospace;
1229 }
1230
1231 .bypasser-log-entry {
1232 padding: 5px;
1233 border-bottom: 1px solid rgba(255, 255, 255, 0.05);
1234 color: #00bfff;
1235 }
1236
1237 .bypasser-log-entry:last-child {
1238 border-bottom: none;
1239 }
1240
1241 .bypasser-log-entry.success {
1242 color: #00ff00;
1243 }
1244
1245 .bypasser-log-entry.error {
1246 color: #ff0000;
1247 }
1248
1249 .bypasser-log-entry.warning {
1250 color: #ffa500;
1251 }
1252
1253 .bypasser-progress {
1254 width: 100%;
1255 height: 8px;
1256 background: rgba(0, 0, 0, 0.3);
1257 border-radius: 4px;
1258 overflow: hidden;
1259 margin-top: 10px;
1260 }
1261
1262 .bypasser-progress-bar {
1263 height: 100%;
1264 background: linear-gradient(90deg, #00ff00 0%, #00cc00 100%);
1265 transition: width 0.3s;
1266 animation: pulse 2s infinite;
1267 }
1268
1269 .bypasser-toggle {
1270 display: flex;
1271 align-items: center;
1272 justify-content: space-between;
1273 padding: 10px 0;
1274 }
1275
1276 .bypasser-toggle-label {
1277 font-size: 13px;
1278 color: #ccc;
1279 }
1280
1281 .bypasser-toggle-switch {
1282 position: relative;
1283 width: 50px;
1284 height: 25px;
1285 background: rgba(255, 255, 255, 0.1);
1286 border-radius: 15px;
1287 cursor: pointer;
1288 transition: all 0.3s;
1289 }
1290
1291 .bypasser-toggle-switch.active {
1292 background: #00ff00;
1293 }
1294
1295 .bypasser-toggle-slider {
1296 position: absolute;
1297 top: 2px;
1298 left: 2px;
1299 width: 21px;
1300 height: 21px;
1301 background: white;
1302 border-radius: 50%;
1303 transition: all 0.3s;
1304 }
1305
1306 .bypasser-toggle-switch.active .bypasser-toggle-slider {
1307 left: 27px;
1308 }
1309
1310 .bypasser-fab {
1311 position: fixed;
1312 bottom: 30px;
1313 right: 30px;
1314 width: 60px;
1315 height: 60px;
1316 background: linear-gradient(135deg, #00ff00 0%, #00cc00 100%);
1317 border-radius: 50%;
1318 display: flex;
1319 align-items: center;
1320 justify-content: center;
1321 cursor: pointer;
1322 box-shadow: 0 5px 20px rgba(0, 255, 0, 0.4);
1323 z-index: 999997;
1324 transition: all 0.3s;
1325 font-size: 24px;
1326 color: #000;
1327 font-weight: bold;
1328 }
1329
1330 .bypasser-fab:hover {
1331 transform: scale(1.1) rotate(90deg);
1332 box-shadow: 0 8px 30px rgba(0, 255, 0, 0.6);
1333 }
1334 `;
1335
1336 const styleSheet = document.createElement('style');
1337 styleSheet.textContent = styles;
1338 document.head.appendChild(styleSheet);
1339 }
1340
1341 createGUI() {
1342 // Create FAB button
1343 this.fab = document.createElement('div');
1344 this.fab.className = 'bypasser-fab';
1345 this.fab.innerHTML = '⚡';
1346 this.fab.title = 'Toggle Bypasser GUI';
1347 document.body.appendChild(this.fab);
1348
1349 // Create main GUI
1350 this.gui = document.createElement('div');
1351 this.gui.className = 'bypasser-gui';
1352 this.gui.style.display = 'none';
1353
1354 this.gui.innerHTML = `
1355 <div class="bypasser-header">
1356 <div class="bypasser-title">🚀 Bypasser Pro v${CONFIG.VERSION}</div>
1357 <div class="bypasser-controls">
1358 <button class="bypasser-btn" id="minimize-btn">−</button>
1359 <button class="bypasser-btn" id="close-btn">×</button>
1360 </div>
1361 </div>
1362 <div class="bypasser-content">
1363 <div class="bypasser-section">
1364 <div class="bypasser-section-title">⚡ Quick Actions</div>
1365 <button class="bypasser-button" id="start-bypass-btn">Start Bypass</button>
1366 <button class="bypasser-button" id="force-bypass-btn">Force Bypass</button>
1367 <button class="bypasser-button danger" id="stop-bypass-btn">Stop Bypass</button>
1368 </div>
1369
1370 <div class="bypasser-section">
1371 <div class="bypasser-section-title">📊 Statistics</div>
1372 <div class="bypasser-stat">
1373 <span class="bypasser-stat-label">Total Bypasses:</span>
1374 <span class="bypasser-stat-value" id="stat-total">0</span>
1375 </div>
1376 <div class="bypasser-stat">
1377 <span class="bypasser-stat-label">Success Rate:</span>
1378 <span class="bypasser-stat-value" id="stat-success">0%</span>
1379 </div>
1380 <div class="bypasser-stat">
1381 <span class="bypasser-stat-label">Time Saved:</span>
1382 <span class="bypasser-stat-value" id="stat-time">0s</span>
1383 </div>
1384 <div class="bypasser-stat">
1385 <span class="bypasser-stat-label">Avg Speed:</span>
1386 <span class="bypasser-stat-value" id="stat-speed">0ms</span>
1387 </div>
1388 <button class="bypasser-button danger" id="reset-stats-btn" style="margin-top: 10px;">Reset Statistics</button>
1389 </div>
1390
1391 <div class="bypasser-section">
1392 <div class="bypasser-section-title">⚙️ Settings</div>
1393 <div class="bypasser-toggle">
1394 <span class="bypasser-toggle-label">Auto Bypass</span>
1395 <div class="bypasser-toggle-switch active" data-setting="autoBypass">
1396 <div class="bypasser-toggle-slider"></div>
1397 </div>
1398 </div>
1399 <div class="bypasser-toggle">
1400 <span class="bypasser-toggle-label">Block Popups</span>
1401 <div class="bypasser-toggle-switch active" data-setting="blockPopups">
1402 <div class="bypasser-toggle-slider"></div>
1403 </div>
1404 </div>
1405 <div class="bypasser-toggle">
1406 <span class="bypasser-toggle-label">Block Ads</span>
1407 <div class="bypasser-toggle-switch active" data-setting="blockAds">
1408 <div class="bypasser-toggle-slider"></div>
1409 </div>
1410 </div>
1411 <div class="bypasser-toggle">
1412 <span class="bypasser-toggle-label">Stealth Mode</span>
1413 <div class="bypasser-toggle-switch active" data-setting="stealthMode">
1414 <div class="bypasser-toggle-slider"></div>
1415 </div>
1416 </div>
1417 <div class="bypasser-toggle">
1418 <span class="bypasser-toggle-label">Fast Mode</span>
1419 <div class="bypasser-toggle-switch active" data-setting="fastMode">
1420 <div class="bypasser-toggle-slider"></div>
1421 </div>
1422 </div>
1423 </div>
1424
1425 <div class="bypasser-section">
1426 <div class="bypasser-section-title">📝 Activity Log</div>
1427 <div class="bypasser-log" id="activity-log">
1428 <div class="bypasser-log-entry">Bypasser initialized...</div>
1429 </div>
1430 </div>
1431
1432 <div class="bypasser-section">
1433 <div class="bypasser-section-title">ℹ️ Status</div>
1434 <div class="bypasser-stat">
1435 <span class="bypasser-stat-label">Status:</span>
1436 <span class="bypasser-stat-value" id="status-text">Ready</span>
1437 </div>
1438 <div class="bypasser-stat">
1439 <span class="bypasser-stat-label">Method:</span>
1440 <span class="bypasser-stat-value" id="method-text">None</span>
1441 </div>
1442 <div class="bypasser-stat">
1443 <span class="bypasser-stat-label">Retry Count:</span>
1444 <span class="bypasser-stat-value" id="retry-text">0</span>
1445 </div>
1446 <div class="bypasser-progress">
1447 <div class="bypasser-progress-bar" id="progress-bar" style="width: 0%"></div>
1448 </div>
1449 </div>
1450 </div>
1451 `;
1452
1453 document.body.appendChild(this.gui);
1454 window.bypasserGUI = this;
1455 }
1456
1457 attachEventListeners() {
1458 // FAB click
1459 this.fab.addEventListener('click', () => this.toggle());
1460
1461 // Close button
1462 document.getElementById('close-btn').addEventListener('click', () => this.hide());
1463
1464 // Minimize button
1465 document.getElementById('minimize-btn').addEventListener('click', () => this.toggleMinimize());
1466
1467 // Start bypass button
1468 document.getElementById('start-bypass-btn').addEventListener('click', () => {
1469 bypassEngine.start();
1470 });
1471
1472 // Force bypass button
1473 document.getElementById('force-bypass-btn').addEventListener('click', async () => {
1474 stateManager.addLog('Force bypass initiated', 'warning');
1475 await bypassMethods.aggressiveForce();
1476 });
1477
1478 // Stop bypass button
1479 document.getElementById('stop-bypass-btn').addEventListener('click', () => {
1480 bypassEngine.running = false;
1481 stateManager.addLog('Bypass stopped by user', 'warning');
1482 });
1483
1484 // Reset stats button
1485 document.getElementById('reset-stats-btn').addEventListener('click', async () => {
1486 if (confirm('Are you sure you want to reset all statistics?')) {
1487 await statsTracker.resetStats();
1488 this.updateDisplay();
1489 }
1490 });
1491
1492 // Toggle switches
1493 document.querySelectorAll('.bypasser-toggle-switch').forEach(toggle => {
1494 toggle.addEventListener('click', () => {
1495 toggle.classList.toggle('active');
1496 const setting = toggle.dataset.setting;
1497 stateManager.addLog(`Setting ${setting} toggled`, 'info');
1498 });
1499 });
1500
1501 // Make draggable
1502 this.makeDraggable();
1503 }
1504
1505 makeDraggable() {
1506 const header = this.gui.querySelector('.bypasser-header');
1507 let isDragging = false;
1508 let currentX;
1509 let currentY;
1510 let initialX;
1511 let initialY;
1512
1513 header.addEventListener('mousedown', (e) => {
1514 isDragging = true;
1515 initialX = e.clientX - this.gui.offsetLeft;
1516 initialY = e.clientY - this.gui.offsetTop;
1517 });
1518
1519 document.addEventListener('mousemove', (e) => {
1520 if (isDragging) {
1521 e.preventDefault();
1522 currentX = e.clientX - initialX;
1523 currentY = e.clientY - initialY;
1524 this.gui.style.left = currentX + 'px';
1525 this.gui.style.top = currentY + 'px';
1526 this.gui.style.right = 'auto';
1527 }
1528 });
1529
1530 document.addEventListener('mouseup', () => {
1531 isDragging = false;
1532 });
1533 }
1534
1535 toggle() {
1536 if (this.visible) {
1537 this.hide();
1538 } else {
1539 this.show();
1540 }
1541 }
1542
1543 show() {
1544 this.gui.style.display = 'block';
1545 this.visible = true;
1546 this.updateDisplay();
1547 }
1548
1549 hide() {
1550 this.gui.style.display = 'none';
1551 this.visible = false;
1552 }
1553
1554 toggleMinimize() {
1555 this.minimized = !this.minimized;
1556 this.gui.classList.toggle('minimized');
1557
1558 const content = this.gui.querySelector('.bypasser-content');
1559 content.style.display = this.minimized ? 'none' : 'block';
1560 }
1561
1562 async updateDisplay() {
1563 const stats = await statsTracker.getStats();
1564
1565 // Update statistics
1566 document.getElementById('stat-total').textContent = stats.totalBypasses;
1567
1568 const successRate = stats.totalBypasses > 0
1569 ? ((stats.successfulBypasses / stats.totalBypasses) * 100).toFixed(1)
1570 : 0;
1571 document.getElementById('stat-success').textContent = successRate + '%';
1572
1573 document.getElementById('stat-time').textContent =
1574 statsTracker.formatTime(stats.totalTimeSaved);
1575
1576 document.getElementById('stat-speed').textContent =
1577 Math.round(stats.averageBypassTime) + 'ms';
1578
1579 // Update status
1580 const state = stateManager.getState();
1581 document.getElementById('status-text').textContent =
1582 state.bypassInProgress ? 'Running...' : 'Ready';
1583 document.getElementById('method-text').textContent =
1584 state.method || 'None';
1585 document.getElementById('retry-text').textContent =
1586 state.retryCount;
1587
1588 // Update progress bar
1589 const progress = state.totalSteps > 0
1590 ? (state.currentStep / state.totalSteps) * 100
1591 : 0;
1592 document.getElementById('progress-bar').style.width = progress + '%';
1593
1594 // Update activity log
1595 const logContainer = document.getElementById('activity-log');
1596 const recentLogs = state.logs.slice(-10).reverse();
1597
1598 logContainer.innerHTML = recentLogs.map(log =>
1599 `<div class="bypasser-log-entry ${log.type}">${log.message}</div>`
1600 ).join('');
1601 }
1602 }
1603
1604 // ============================================
1605 // INITIALIZATION
1606 // ============================================
1607 async function init() {
1608 console.log('%c[Platoboost Bypasser Pro] Starting initialization...', 'color: #00ff00; font-weight: bold; font-size: 16px;');
1609
1610 // Wait for DOM to be ready
1611 if (document.readyState === 'loading') {
1612 await new Promise(resolve => {
1613 document.addEventListener('DOMContentLoaded', resolve);
1614 });
1615 }
1616
1617 // Initialize GUI
1618 const gui = new BypasserGUI();
1619
1620 // Auto-start bypass if enabled
1621 if (CONFIG.AUTO_BYPASS_ENABLED) {
1622 stateManager.addLog('Auto-bypass enabled, starting in 2 seconds...', 'info');
1623 setTimeout(() => {
1624 bypassEngine.start();
1625 }, 2000);
1626 }
1627
1628 // Monitor for page changes and key appearance
1629 let lastUrl = window.location.href;
1630 const keyMonitor = setInterval(async () => {
1631 const currentUrl = window.location.href;
1632
1633 // Check for URL change
1634 if (currentUrl !== lastUrl) {
1635 lastUrl = currentUrl;
1636 stateManager.addLog('Page changed, restarting bypass...', 'info');
1637 if (CONFIG.AUTO_BYPASS_ENABLED) {
1638 setTimeout(() => bypassEngine.start(), 1000);
1639 }
1640 }
1641
1642 // Check for key on current page
1643 const textarea = document.querySelector('textarea');
1644 if (textarea && textarea.value && textarea.value.length > 20) {
1645 const key = textarea.value;
1646
1647 // Check if we already copied this key
1648 const lastCopiedKey = await GM.getValue('last_copied_key', '');
1649 if (key !== lastCopiedKey) {
1650 stateManager.addLog('Key detected on page!', 'success');
1651
1652 try {
1653 await GM.setClipboard(key);
1654 await GM.setValue('last_copied_key', key);
1655 stateManager.addLog('✓ Key auto-copied to clipboard!', 'success');
1656
1657 // Show notification
1658 bypassMethods.showKeyNotification(key);
1659 } catch (error) {
1660 stateManager.addLog(`Auto-copy error: ${error.message}`, 'error');
1661 }
1662 }
1663 }
1664 }, 1000);
1665
1666 console.log('%c[Platoboost Bypasser Pro] Initialization complete!', 'color: #00ff00; font-weight: bold; font-size: 16px;');
1667 stateManager.addLog('=== BYPASSER PRO READY ===', 'success');
1668 }
1669
1670 // Start the bypasser
1671 init();
1672
1673})();