webtools-cli 1.2.4__tar.gz → 1.2.6__tar.gz

{webtools_cli-1.2.4 → webtools_cli-1.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webtools-cli
-Version: 1.2.4
+Version: 1.2.6
 Summary: Advanced Web Intelligence & Scraping Toolkit with CLI and Web UI
 Author: Abhinav Adarsh
 License-Expression: MIT
@@ -30,7 +30,7 @@ Requires-Dist: mtranslate
 Requires-Dist: colorama
 Requires-Dist: playwright
 Requires-Dist: pycryptodome
-Requires-Dist: tenacity>=8.2.3
+Requires-Dist: tenacity<9.0.0,>=8.2.3
 Requires-Dist: pyreadline3; platform_system == "Windows"
 Provides-Extra: playwright
 Requires-Dist: playwright; extra == "playwright"
@@ -54,7 +54,7 @@ WebTools CLI is an advanced web intelligence suite for researchers, OSINT enthus
 
 - **🎯 Stealth & Speed**: Smart proxy rotation and Turbo-Fetch logic for evasion and performance.
 - **🧠 AI-Powered**: Automated content summarization, sentiment analysis, and readability scoring.
-- **☁️ Cloud-Native**: Integrated Mega.nz storage for seamless media backups and file management.
+- **☁️ Cloud-Native**: Integrated Mega.nz storage with **Seamless Mono-Installer** (one-click, conflict-free setup).
 - **🔧 Security-Centric**: Built-in honeypot detection, threat leveling, and image forensic analysis.
 - **💻 Terminal-First**: Designed for power users who live in the command line.
 - **🛡️ Cross-Platform**: Works seamlessly on Windows, Linux, and macOS (with auto-download for Windows tunnels).

{webtools_cli-1.2.4 → webtools_cli-1.2.6}/README.md

@@ -16,7 +16,7 @@ WebTools CLI is an advanced web intelligence suite for researchers, OSINT enthus
 
 - **🎯 Stealth & Speed**: Smart proxy rotation and Turbo-Fetch logic for evasion and performance.
 - **🧠 AI-Powered**: Automated content summarization, sentiment analysis, and readability scoring.
-- **☁️ Cloud-Native**: Integrated Mega.nz storage for seamless media backups and file management.
+- **☁️ Cloud-Native**: Integrated Mega.nz storage with **Seamless Mono-Installer** (one-click, conflict-free setup).
 - **🔧 Security-Centric**: Built-in honeypot detection, threat leveling, and image forensic analysis.
 - **💻 Terminal-First**: Designed for power users who live in the command line.
 - **🛡️ Cross-Platform**: Works seamlessly on Windows, Linux, and macOS (with auto-download for Windows tunnels).

{webtools_cli-1.2.4 → webtools_cli-1.2.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "webtools-cli"
-version = "1.2.4"
+version = "1.2.6"
 description = "Advanced Web Intelligence & Scraping Toolkit with CLI and Web UI"
 readme = "README.md"
 license = "MIT"
@@ -37,7 +37,7 @@ dependencies = [
     "colorama",
     "playwright",
     "pycryptodome",
-    "tenacity>=8.2.3",
+    "tenacity>=8.2.3,<9.0.0",
     "pyreadline3; platform_system == 'Windows'",
 ]
 

{webtools_cli-1.2.4 → webtools_cli-1.2.6}/webtools/core.py

@@ -7,59 +7,24 @@ if sys.stdout.encoding and sys.stdout.encoding.lower() != 'utf-8':
         sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')
     except Exception: pass
 
-# --- AUTO-INSTALLER FOR MISSING/BROKEN DEPENDENCIES ---
+# --- AUTO-INSTALLER FOR PLAYWRIGHT BROWSERS ---
 def ensure_dependencies():
-    """Checks and performs a forced clean install of dependencies at runtime"""
-    # Dependencies that must be imported successfully
-    # Format: module_name -> (pip_package_name, min_version_prefix, forced_upgrade)
-    check_deps = {
-        "mega": ("mega.py", None, False),
-        "Crypto": ("pycryptodome", None, True), # Always ensure pycryptodome over pycrypto
-        "tenacity": ("tenacity>=8.2.3", "8", True)
-    }
-    
-    missing_or_broken = []
-    
-    # 1. Clean up "pycrypto" which causes SyntaxError on Python 3
-    # If we catch a SyntaxError from 'from mega import Mega', it's almost certainly pycrypto
+    """Ensures Playwright browsers are installed if the library is present"""
     try:
-        import Crypto.PublicKey.RSA
-    except (SyntaxError, AttributeError, ImportError):
-        # SyntaxError means it's the old pycrypto. We must kill it.
-        missing_or_broken.append("pycryptodome")
-    
-    # 2. Check for missing or outdated modules
-    for module_name, (pkg_name, min_v, forced) in check_deps.items():
-        try:
-            mod = __import__(module_name)
-            if min_v:
-                from importlib.metadata import version as get_v
-                try:
-                    if int(get_v(module_name).split('.')[0]) < int(min_v):
-                        missing_or_broken.append(pkg_name)
-                except:
-                    if forced: missing_or_broken.append(pkg_name)
-        except:
-            missing_or_broken.append(pkg_name)
-
-    if missing_or_broken:
-        print(f"\n[!] Critical dependency issues detected: {', '.join(missing_or_broken)}")
-        print("[*] Running Forced Clean Repair (Python 3.11+ Stability Patch)...")
-        try:
-            # Step A: Uninstall known troublemakers
-            subprocess.call([sys.executable, "-m", "pip", "uninstall", "-y", "pycrypto", "tenacity"], 
-                            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-            
-            # Step B: Install modern core deps
-            subprocess.check_call([sys.executable, "-m", "pip", "install", "--upgrade", "pycryptodome", "tenacity>=8.2.3", "requests"])
-            
-            # Step C: Install mega.py WITHOUT dependencies to avoid downgrading tenacity
-            subprocess.check_call([sys.executable, "-m", "pip", "install", "mega.py", "--no-deps"])
-            
-            print("[+] Environment repaired successfully! Please restart the app if it fails next.\n")
-        except Exception as e:
-            print(f"[-] Auto-repair failed: {e}")
-            print("[!] Please run manually: pip uninstall pycrypto tenacity && pip install pycryptodome tenacity>=8.2.3 mega.py --no-deps")
+        from playwright.sync_api import sync_playwright
+        # Simple check for browser existence
+        with sync_playwright() as p:
+            try:
+                p.chromium.launch(headless=True).close()
+            except:
+                print("\n[*] Playwright found but browsers are missing. Auto-installing...")
+                subprocess.check_call([sys.executable, "-m", "playwright", "install", "chromium"])
+    except ImportError:
+        # pip install handled this, but just in case
+        pass
+    except Exception as e:
+        # Non-critical failure, don't block startup
+        pass
 
 ensure_dependencies()
 
@@ -82,174 +47,12 @@ from collections import Counter
 from flask import Flask, render_template_string, send_from_directory, request, jsonify, send_file, after_this_request
 from PIL import Image,ExifTags,ImageChops,ImageEnhance
 from io import BytesIO
-from mega import Mega
-try:
-    from mega.errors import RequestError
-    from mega.crypto import (
-        base64_to_a32, decrypt_key, base64_url_decode, a32_to_str, 
-        encrypt_key, str_to_a32, mpi_to_int, base64_url_encode
-    )
-    from Crypto.PublicKey import RSA
-    import binascii
-except ImportError:
-    class RequestError(Exception): pass
-
-# --- MONKEY PATCH FOR MEGA.PY (Fixes TypeError in AES calls) ---
-try:
-    from Crypto.Cipher import AES
-    import mega.mega as mega_module
-    _original_aes_new = AES.new
-    
-    def _patched_aes_new(key, *args, **kwargs):
-        # Convert key to bytes if string
-        if isinstance(key, str):
-            key = key.encode('latin-1')
-        
-        # Convert positional arguments (like IV/mode) to bytes if strings
-        new_args = list(args)
-        for i in range(len(new_args)):
-            if isinstance(new_args[i], str):
-                new_args[i] = new_args[i].encode('latin-1')
-            
-        # Convert keyword arguments (IV, nonce, etc.) to bytes if strings
-        for k in kwargs:
-            if isinstance(kwargs[k], str):
-                kwargs[k] = kwargs[k].encode('latin-1')
-                
-        return _original_aes_new(key, *new_args, **kwargs)
-    
-    # Apply patch globally
-    AES.new = _patched_aes_new
-    if hasattr(mega_module, 'AES'):
-        mega_module.AES.new = _patched_aes_new
-except Exception:
-    pass
 
-class RobustMega(Mega):
-    """
-    Patched version of Mega library to handle fragile API responses.
-    The original library crashes if the API returns non-JSON or an empty string.
-    """
-    def _login_process(self, resp, password):
-        """
-        Overridden to fix 'Invalid RSA public exponent' error in newer pycryptodome.
-        The original code passes 0 as the exponent, which is rejected.
-        """
-        encrypted_master_key = base64_to_a32(resp['k'])
-        self.master_key = decrypt_key(encrypted_master_key, password)
-        if 'tsid' in resp:
-            tsid = base64_url_decode(resp['tsid'])
-            key_encrypted = a32_to_str(
-                encrypt_key(str_to_a32(tsid[:16]), self.master_key)
-            )
-            if key_encrypted == tsid[-16:]:
-                self.sid = resp['tsid']
-        elif 'csid' in resp:
-            encrypted_rsa_private_key = base64_to_a32(resp['privk'])
-            rsa_private_key = decrypt_key(
-                encrypted_rsa_private_key, self.master_key
-            )
-
-            private_key_str = a32_to_str(rsa_private_key)
-            self.rsa_private_key = [0, 0, 0, 0]
-            
-            # This loop parses the 4 components: p, q, d, u
-            for i in range(4):
-                l = int(((private_key_str[0]) * 256 + (private_key_str[1]) + 7) / 8) + 2
-                self.rsa_private_key[i] = mpi_to_int(private_key_str[:l])
-                private_key_str = private_key_str[l:]
-
-            encrypted_sid = mpi_to_int(base64_url_decode(resp['csid']))
-            
-            # The Fix: Calculate the real 'e' from p, q, d
-            p = self.rsa_private_key[0]
-            q = self.rsa_private_key[1]
-            d = self.rsa_private_key[2]
-            n = p * q
-            phi = (p - 1) * (q - 1)
-            
-            try:
-                # Calculate real e = d^-1 mod phi
-                e = pow(d, -1, phi)
-                rsa_decrypter = RSA.construct((n, e, d, p, q))
-            except:
-                # Fallback to 65537 if inverse fails (shouldn't happen)
-                e = 65537
-                rsa_decrypter = RSA.construct((n, e, d, p, q), consistency_check=False)
-            
-            # Handle potential library differences in how the key is accessed
-            key_obj = rsa_decrypter.key if hasattr(rsa_decrypter, 'key') else rsa_decrypter
-            
-            # Decrypt sid integer
-            sid_int = key_obj._decrypt(encrypted_sid)
-            
-            # Convert to hex then to bytes, ensuring we handle the 0 padding if any
-            sid_hex = '%x' % sid_int
-            if len(sid_hex) % 2:
-                sid_hex = '0' + sid_hex
-            sid_bytes = binascii.unhexlify(sid_hex)
-            
-            self.sid = base64_url_encode(sid_bytes[:43])
-
-    def _api_request(self, data):
-        params = {'id': self.sequence_num}
-        self.sequence_num += 1
-
-        if self.sid:
-            params.update({'sid': self.sid})
-
-        if not isinstance(data, list):
-            data = [data]
-
-        url = '{0}://g.api.{1}/cs'.format(self.schema, self.domain)
-        headers = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36',
-            'Accept': '*/*',
-            'Accept-Language': 'en-US,en;q=0.9',
-            'Origin': 'https://mega.nz',
-            'Referer': 'https://mega.nz/'
-        }
-        
-        try:
-            req = requests.post(
-                url,
-                params=params,
-                data=json.dumps(data),
-                headers=headers,
-                timeout=self.timeout,
-            )
-            
-            content = req.text.strip() if req.text else ""
-            
-            if not content:
-                if req.status_code == 402:
-                    raise Exception("Mega.nz is temporarily blocking this connection (Status 402). This usually happens due to rate-limiting. Please try again later or use a different network.")
-                raise Exception(f"Mega API returned empty response (Status {req.status_code})")
-                
-            try:
-                json_resp = json.loads(content)
-            except json.JSONDecodeError:
-                # Try to parse as integer error code
-                try:
-                    val = int(content)
-                    raise RequestError(val)
-                except (ValueError, RequestError):
-                    if content.startswith("-") and content[1:].isdigit():
-                         raise RequestError(int(content))
-                    raise Exception(f"Mega API error: {content[:100]}")
-
-            if isinstance(json_resp, int):
-                if json_resp == -3:
-                    time.sleep(0.5)
-                    return self._api_request(data=data)
-                raise RequestError(json_resp)
-            
-            return json_resp[0]
-        except Exception:
-            raise
+# Internal Mega Client (Conflict-free and Python 3.11+ compatible)
+from .install import Mega, RequestError
 
 # Global Mega session state
-mega_engine = RobustMega()
+mega_engine = Mega()
 mega_sessions = {} # Mapping: email -> {'client': MegaClient, 'info': user_info, 'quota': quota}
 active_mega_email = None
 

webtools_cli-1.2.6/webtools/install.py

@@ -0,0 +1,168 @@
+"""Installation and Utility Utilities for WebTools CLI"""
+import os
+import sys
+import json
+import random
+import binascii
+import requests
+import subprocess
+from Crypto.Cipher import AES
+from Crypto.PublicKey import RSA
+from Crypto.Util import Counter
+from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
+
+# --- PLAYWRIGHT SETUP ---
+
+def install_playwright_browsers():
+    """Install Playwright Chromium browser after package installation"""
+    try:
+        print("📦 Installing Playwright Chromium browser...")
+        subprocess.run([sys.executable, "-m", "playwright", "install", "chromium"], check=True)
+        print("✓ Playwright Chromium installed successfully")
+    except subprocess.CalledProcessError:
+        print("⚠️ Failed to install Playwright browsers. Run manually: playwright install chromium")
+    except Exception as e:
+        print(f"⚠️ Playwright browser installation skipped: {e}")
+
+# --- INTERNAL MEGA CLIENT (Conflict-free & Python 3.11+ compatible) ---
+
+class RequestError(Exception):
+    """Exception for Mega API requests"""
+    pass
+
+def base64_url_decode(data):
+    data += '=' * (4 - len(data) % 4)
+    return binascii.a2b_base64(data.replace('-', '+').replace('_', '/'))
+
+def base64_url_encode(data):
+    return binascii.b2a_base64(data).decode('utf-8').strip().replace('+', '-').replace('/', '_').replace('=', '')
+
+def a32_to_str(a):
+    return binascii.unhexlify(''.join(format(i, '08x') for i in a))
+
+def str_to_a32(s):
+    if len(s) % 4:
+        s += b'\0' * (4 - len(s) % 4)
+    return [int(binascii.hexlify(s[i:i + 4]), 16) for i in range(0, len(s), 4)]
+
+def base64_to_a32(s):
+    return str_to_a32(base64_url_decode(s))
+
+def a32_to_base64(a):
+    return base64_url_encode(a32_to_str(a))
+
+def aes_cbc_encrypt(data, key):
+    cipher = AES.new(a32_to_str(key), AES.MODE_CBC, b'\0' * 16)
+    return str_to_a32(cipher.encrypt(a32_to_str(data)))
+
+def aes_cbc_decrypt(data, key):
+    cipher = AES.new(a32_to_str(key), AES.MODE_CBC, b'\0' * 16)
+    return str_to_a32(cipher.decrypt(a32_to_str(data)))
+
+def decrypt_key(a, k):
+    res = []
+    for i in range(0, len(a), 4):
+        res += aes_cbc_decrypt(a[i:i + 4], k)
+    return res
+
+def encrypt_key(a, k):
+    res = []
+    for i in range(0, len(a), 4):
+        res += aes_cbc_encrypt(a[i:i + 4], k)
+    return res
+
+def prepare_key(a):
+    v = [0x93C467E3, 0x7DB0C7A4, 0xD1BE3F81, 0x0152CB56]
+    for _ in range(0x10000):
+        for j in range(0, len(a), 4):
+            key = [0, 0, 0, 0]
+            for k in range(4):
+                if j + k < len(a):
+                    key[k] = a[j + k]
+            v = aes_cbc_encrypt(v, key)
+    return v
+
+def mpi_to_int(s):
+    return int(binascii.hexlify(s[2:]), 16)
+
+class Mega:
+    def __init__(self):
+        self.sid = None
+        self.api_url = "https://g.api.mega.co.nz/cs"
+        self.sequence_num = random.randint(0, 0xFFFFFFFF)
+
+    def login(self, email, password):
+        password_aes = prepare_key(str_to_a32(password.encode('utf-8')))
+        user_hash = self._stringhash(email, password_aes)
+        resp = self._api_request({'a': 'us', 'user': email, 'uh': user_hash})
+        
+        if isinstance(resp, int) and resp < 0:
+            raise RequestError(f"Login failed: {resp}")
+
+        encrypted_key = base64_to_a32(resp['k'])
+        self.master_key = decrypt_key(encrypted_key, password_aes)
+        
+        if 'tsid' in resp:
+            self.sid = resp['tsid']
+        elif 'csid' in resp:
+            encrypted_rsa_private_key = base64_to_a32(resp['privk'])
+            rsa_private_key = decrypt_key(encrypted_rsa_private_key, self.master_key)
+            private_key_str = a32_to_str(rsa_private_key)
+            components = [0, 0, 0, 0]
+            for i in range(4):
+                l = int(((private_key_str[0]) * 256 + (private_key_str[1]) + 7) / 8) + 2
+                components[i] = mpi_to_int(private_key_str[:l])
+                private_key_str = private_key_str[l:]
+            encrypted_sid = mpi_to_int(base64_url_decode(resp['csid']))
+            p, q, d, _ = components
+            n, phi = p * q, (p - 1) * (q - 1)
+            try: e = pow(d, -1, phi)
+            except: e = 65537
+            rsa_decrypter = RSA.construct((n, e, d, p, q))
+            sid_int = rsa_decrypter._decrypt(encrypted_sid)
+            sid_hex = '%x' % sid_int
+            if len(sid_hex) % 2: sid_hex = '0' + sid_hex
+            self.sid = base64_url_encode(binascii.unhexlify(sid_hex)[:43])
+        return self
+
+    def _stringhash(self, email, aes_key):
+        s = email.encode('utf-8')
+        h = [0, 0, 0, 0]
+        for i, b in enumerate(s): h[i % 4] ^= b
+        for _ in range(0x4000): h = aes_cbc_encrypt(h, aes_key)
+        return a32_to_base64([h[0], h[2]])
+
+    @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=10), 
+           retry=retry_if_exception_type(requests.exceptions.RequestException))
+    def _api_request(self, data):
+        url = f"{self.api_url}?id={self.sequence_num}"
+        if self.sid: url += f"&sid={self.sid}"
+        self.sequence_num += 1
+        response = requests.post(url, json=[data], timeout=30)
+        response.raise_for_status()
+        result = response.json()
+        if isinstance(result, list):
+            res = result[0]
+            if isinstance(res, int) and res < 0: raise RequestError(f"API Error {res}")
+            return res
+        return result
+
+    def get_storage_space(self):
+        resp = self._api_request({'a': 'uq', 'strg': 1})
+        return {'total': resp['mstrg'], 'used': resp['cstrg']}
+
+    def upload(self, filename, dest_folder=None):
+        size = os.path.getsize(filename)
+        resp = self._api_request({'a': 'u', 's': size})
+        upload_url = resp['p']
+        with open(filename, 'rb') as f: data = f.read()
+        r = requests.post(upload_url, data=data, timeout=60)
+        upload_token = r.text
+        file_key = [random.randint(0, 0xFFFFFFFF) for _ in range(6)]
+        attribs = {'n': os.path.basename(filename)}
+        encoded_attribs = base64_url_encode(b'MEGA' + json.dumps(attribs).encode('utf-8'))
+        data = {'a': 'p', 't': dest_folder or 'ROOT', 'n': [{'h': upload_token, 't': 0, 'a': encoded_attribs, 'k': a32_to_base64(file_key[:4])}]}
+        return self._api_request(data)
+
+if __name__ == "__main__":
+    install_playwright_browsers()

{webtools_cli-1.2.4 → webtools_cli-1.2.6}/webtools_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webtools-cli
-Version: 1.2.4
+Version: 1.2.6
 Summary: Advanced Web Intelligence & Scraping Toolkit with CLI and Web UI
 Author: Abhinav Adarsh
 License-Expression: MIT
@@ -30,7 +30,7 @@ Requires-Dist: mtranslate
 Requires-Dist: colorama
 Requires-Dist: playwright
 Requires-Dist: pycryptodome
-Requires-Dist: tenacity>=8.2.3
+Requires-Dist: tenacity<9.0.0,>=8.2.3
 Requires-Dist: pyreadline3; platform_system == "Windows"
 Provides-Extra: playwright
 Requires-Dist: playwright; extra == "playwright"
@@ -54,7 +54,7 @@ WebTools CLI is an advanced web intelligence suite for researchers, OSINT enthus
 
 - **🎯 Stealth & Speed**: Smart proxy rotation and Turbo-Fetch logic for evasion and performance.
 - **🧠 AI-Powered**: Automated content summarization, sentiment analysis, and readability scoring.
-- **☁️ Cloud-Native**: Integrated Mega.nz storage for seamless media backups and file management.
+- **☁️ Cloud-Native**: Integrated Mega.nz storage with **Seamless Mono-Installer** (one-click, conflict-free setup).
 - **🔧 Security-Centric**: Built-in honeypot detection, threat leveling, and image forensic analysis.
 - **💻 Terminal-First**: Designed for power users who live in the command line.
 - **🛡️ Cross-Platform**: Works seamlessly on Windows, Linux, and macOS (with auto-download for Windows tunnels).

{webtools_cli-1.2.4 → webtools_cli-1.2.6}/webtools_cli.egg-info/requires.txt

@@ -10,7 +10,7 @@ mtranslate
 colorama
 playwright
 pycryptodome
-tenacity>=8.2.3
+tenacity<9.0.0,>=8.2.3
 
 [:platform_system == "Windows"]
 pyreadline3

webtools_cli-1.2.4/webtools/install.py

@@ -1,17 +0,0 @@
-"""Post-install script to setup Playwright browsers"""
-import subprocess
-import sys
-
-def install_playwright_browsers():
-    """Install Playwright Chromium browser after package installation"""
-    try:
-        print("📦 Installing Playwright Chromium browser...")
-        subprocess.run([sys.executable, "-m", "playwright", "install", "chromium"], check=True)
-        print("✓ Playwright Chromium installed successfully")
-    except subprocess.CalledProcessError:
-        print("⚠️ Failed to install Playwright browsers. Run manually: playwright install chromium")
-    except Exception as e:
-        print(f"⚠️ Playwright browser installation skipped: {e}")
-
-if __name__ == "__main__":
-    install_playwright_browsers()