Update utils/backup.py

utils/backup.py

@@ -5,39 +5,52 @@ import zipfile
 import requests
 import hashlib
 import time
+import logging
 from io import BytesIO
 from urllib.parse import urljoin, urlparse, unquote
 from bs4 import BeautifulSoup
 from selenium.webdriver.common.by import By
 
+logger = logging.getLogger(__name__)
+
 
 class SiteBackup:
-    """Classe responsável por fazer backup completo de um site aberto no Selenium."""
+    """Backup completo com crawling recursivo de subpáginas."""
 
-    def __init__(self, driver, url):
+    def __init__(self, driver, url, max_depth=3, max_pages=50):
         self.driver = driver
         self.url = url
         self.base_url = self._get_base_url(url)
         self.domain = urlparse(url).netloc
-        self.downloaded_assets = {}  # url -> (local_path, content)
+        self.downloaded_assets = {}
         self.asset_counter = 0
         self.errors = []
-        # Mapeamento: URL absoluta -> caminho local relativo no ZIP
         self.url_to_local = {}
+        self.max_depth = max_depth
+        self.max_pages = max_pages
+        # Páginas já visitadas: url -> local_html_path
+        self.visited_pages = {}
+        # Fila de páginas para visitar: [(url, depth)]
+        self.page_queue = []
+        # Todos os arquivos do ZIP: path -> bytes
+        self.zip_files = {}
 
     def _get_base_url(self, url):
         parsed = urlparse(url)
         return f"{parsed.scheme}://{parsed.netloc}"
 
     def _safe_filename(self, url, extension=None):
-        """Gera um nome de arquivo seguro a partir de uma URL."""
         self.asset_counter += 1
         parsed = urlparse(url)
         path = unquote(parsed.path).strip("/")
+        query = parsed.query
 
         if path:
             name = path.replace("/", "_").replace("\\", "_")
             name = re.sub(r'[<>:"|?*]', '_', name)
+            if query:
+                q_hash = hashlib.md5(query.encode()).hexdigest()[:6]
+                name = f"{name}_{q_hash}"
         else:
             name = f"asset_{self.asset_counter}"
 
@@ -51,20 +64,35 @@ class SiteBackup:
 
         return name
 
+    def _page_filename(self, url):
+        """Gera nome de arquivo HTML para uma subpágina."""
+        if url == self.url:
+            return "index.html"
+        parsed = urlparse(url)
+        path = unquote(parsed.path).strip("/")
+        query = parsed.query
+        if path:
+            name = path.replace("/", "_").replace("\\", "_")
+            name = re.sub(r'[<>:"|?*]', '_', name)
+        else:
+            name = "page"
+        if query:
+            q_hash = hashlib.md5(query.encode()).hexdigest()[:6]
+            name = f"{name}_{q_hash}"
+        if not name.endswith(".html"):
+            name = f"{name}.html"
+        return f"pages/{name}"
+
     def _download_asset(self, url):
-        """Baixa um asset e retorna seus bytes."""
         if url in self.downloaded_assets:
             return self.downloaded_assets[url]
-
         try:
-            # Tenta pegar via Selenium cookies primeiro
             selenium_cookies = {}
             try:
                 for c in self.driver.get_cookies():
                     selenium_cookies[c['name']] = c['value']
             except:
                 pass
-
             headers = {
                 "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                               "AppleWebKit/537.36 (KHTML, like Gecko) "
@@ -82,92 +110,223 @@ class SiteBackup:
                 self.errors.append(f"HTTP {response.status_code} ao baixar {url[:100]}")
         except Exception as e:
             self.errors.append(f"Erro ao baixar {url[:100]}: {str(e)[:80]}")
-
         return None
 
     def _classify_asset(self, url, content_type=None):
-        """Classifica o asset em uma pasta baseado no tipo."""
         url_lower = url.lower().split('?')[0].split('#')[0]
-
         if any(ext in url_lower for ext in ['.css']):
             return "css"
         elif any(ext in url_lower for ext in ['.js', '.mjs']):
             return "js"
         elif any(ext in url_lower for ext in ['.png', '.jpg', '.jpeg', '.gif',
-                                                '.svg', '.webp', '.ico', '.bmp',
-                                                '.avif']):
+                                               '.svg', '.webp', '.ico', '.bmp', '.avif']):
             return "images"
-        elif any(ext in url_lower for ext in ['.woff', '.woff2', '.ttf',
-                                                '.eot', '.otf']):
+        elif any(ext in url_lower for ext in ['.woff', '.woff2', '.ttf', '.eot', '.otf']):
             return "fonts"
-        elif any(ext in url_lower for ext in ['.mp4', '.webm', '.ogg',
-                                                '.mp3', '.wav']):
+        elif any(ext in url_lower for ext in ['.mp4', '.webm', '.ogg', '.mp3', '.wav']):
             return "media"
         elif any(ext in url_lower for ext in ['.json', '.xml', '.csv']):
             return "data"
         else:
             return "assets"
 
-    def capture_full_html(self):
-        """Captura o HTML completo renderizado pelo navegador."""
+    def _is_same_site(self, url):
+        """Verifica se a URL pertence ao mesmo domínio."""
         try:
-            html = self.driver.execute_script("return document.documentElement.outerHTML;")
-            return f"<!DOCTYPE html>\n{html}"
-        except Exception as e:
-            self.errors.append(f"Erro ao capturar HTML: {str(e)}")
-            return self.driver.page_source
-
-    def capture_all_stylesheets(self):
-        """Captura todos os CSS externos e inline."""
-        stylesheets = {}
+            parsed = urlparse(url)
+            return parsed.netloc == self.domain or parsed.netloc == ''
+        except:
+            return False
 
+    def _collect_page_links(self):
+        """Coleta todos os links clicáveis da página atual."""
         try:
-            css_links = self.driver.execute_script("""
-                var links = document.querySelectorAll('link[rel="stylesheet"]');
-                var urls = [];
-                links.forEach(function(link) {
-                    if (link.href) urls.push(link.href);
+            links = self.driver.execute_script("""
+                var results = [];
+                // Links <a>
+                document.querySelectorAll('a[href]').forEach(function(a) {
+                    var href = a.href;
+                    if (href && !href.startsWith('javascript:') && !href.startsWith('mailto:') 
+                        && !href.startsWith('#') && !href.startsWith('tel:')) {
+                        results.push({
+                            url: href,
+                            text: (a.textContent || '').trim().substring(0, 100),
+                            tag: 'a'
+                        });
+                    }
                 });
-                return urls;
+                // Elementos clicáveis com data-href ou onclick que navegam
+                document.querySelectorAll('[data-href], [data-url], [data-link]').forEach(function(el) {
+                    var href = el.dataset.href || el.dataset.url || el.dataset.link;
+                    if (href) results.push({url: href, text: (el.textContent||'').trim().substring(0,100), tag: el.tagName});
+                });
+                return results;
             """)
+            return links or []
+        except Exception as e:
+            self.errors.append(f"Erro ao coletar links: {str(e)[:80]}")
+            return []
 
-            for css_url in css_links:
-                content = self._download_asset(css_url)
-                if content:
-                    filename = self._safe_filename(css_url, ".css")
-                    local_path = f"css/{filename}"
-                    stylesheets[local_path] = content
-                    self.url_to_local[css_url] = local_path
+    def _collect_clickable_cards(self):
+        """Coleta elementos que parecem cards/botões clicáveis (ex: módulos do Kiwify)."""
+        try:
+            cards = self.driver.execute_script("""
+                var results = [];
+                // Cards com cursor pointer que podem ser clicáveis
+                var allElements = document.querySelectorAll('div, article, section, li, button');
+                allElements.forEach(function(el) {
+                    var style = window.getComputedStyle(el);
+                    if (style.cursor === 'pointer' && el.offsetWidth > 50 && el.offsetHeight > 50) {
+                        var link = el.querySelector('a[href]');
+                        if (link && link.href) {
+                            results.push({
+                                url: link.href,
+                                text: (el.textContent || '').trim().substring(0, 100),
+                                tag: 'card'
+                            });
+                        }
+                    }
+                });
+                return results;
+            """)
+            return cards or []
+        except:
+            return []
+
+    def _navigate_and_capture(self, url, depth=0):
+        """Navega para uma URL, captura a página e seus assets."""
+        if url in self.visited_pages:
+            return
+        if len(self.visited_pages) >= self.max_pages:
+            return
+        if depth > self.max_depth:
+            return
+
+        # Normalizar URL
+        url = url.split('#')[0]
+        if not url:
+            return
+
+        logger.info(f"[BACKUP] Visitando (depth={depth}): {url[:80]}... ({len(self.visited_pages)+1}/{self.max_pages})")
 
-                    # Processar URLs dentro do CSS (fontes, imagens de background)
+        try:
+            # Navegar
+            if url != self.driver.current_url:
+                self.driver.get(url)
+                # Esperar carregamento
+                for _ in range(20):
+                    time.sleep(0.5)
                     try:
-                        css_text = content.decode('utf-8', errors='replace')
-                        css_text = self._rewrite_css_urls(css_text, css_url)
-                        stylesheets[local_path] = css_text.encode('utf-8')
+                        ready = self.driver.execute_script("return document.readyState;")
+                        if ready == "complete":
+                            break
                     except:
-                        pass
+                        break
+                time.sleep(1)  # Extra para JS dinâmico
 
-            inline_styles = self.driver.execute_script("""
-                var styles = document.querySelectorAll('style');
-                var contents = [];
-                styles.forEach(function(s, i) {
-                    contents.push(s.textContent || s.innerText || '');
-                });
-                return contents;
-            """)
+            # Capturar HTML
+            html = self.driver.execute_script("return document.documentElement.outerHTML;")
+            html = f"<!DOCTYPE html>\n{html}"
+
+            # Determinar path local
+            if url == self.url:
+                local_path = "index.html"
+            else:
+                local_path = self._page_filename(url)
+
+            self.visited_pages[url] = local_path
 
-            for i, style_content in enumerate(inline_styles):
-                if style_content.strip():
-                    local_path = f"css/inline_style_{i+1}.css"
-                    stylesheets[local_path] = style_content.encode('utf-8')
+            # Capturar assets desta página
+            self._capture_page_assets()
+
+            # Coletar links para subpáginas
+            if depth < self.max_depth:
+                links = self._collect_page_links()
+                cards = self._collect_clickable_cards()
+                all_links = links + cards
+
+                for link in all_links:
+                    link_url = link.get('url', '')
+                    if not link_url:
+                        continue
+                    # Resolver URL relativa
+                    abs_url = urljoin(url, link_url).split('#')[0]
+                    if self._is_same_site(abs_url) and abs_url not in self.visited_pages:
+                        if abs_url not in [q[0] for q in self.page_queue]:
+                            self.page_queue.append((abs_url, depth + 1))
+
+            # Reescrever HTML
+            rewritten_html = self._rewrite_html(html, local_path)
+            self.zip_files[local_path] = rewritten_html.encode('utf-8')
 
         except Exception as e:
-            self.errors.append(f"Erro ao capturar CSS: {str(e)}")
+            self.errors.append(f"Erro ao visitar {url[:80]}: {str(e)[:80]}")
+            self.visited_pages[url] = None
 
-        return stylesheets
+    def _capture_page_assets(self):
+        """Captura CSS, JS, imagens da página atual (sem duplicar)."""
+        try:
+            # CSS
+            css_links = self.driver.execute_script("""
+                var links = document.querySelectorAll('link[rel="stylesheet"]');
+                var urls = []; links.forEach(function(l){ if(l.href) urls.push(l.href); });
+                return urls;
+            """)
+            for css_url in (css_links or []):
+                if css_url not in self.url_to_local:
+                    content = self._download_asset(css_url)
+                    if content:
+                        filename = self._safe_filename(css_url, ".css")
+                        local_path = f"css/{filename}"
+                        self.zip_files[local_path] = content
+                        self.url_to_local[css_url] = local_path
+                        try:
+                            css_text = content.decode('utf-8', errors='replace')
+                            css_text = self._rewrite_css_urls(css_text, css_url)
+                            self.zip_files[local_path] = css_text.encode('utf-8')
+                        except:
+                            pass
+
+            # JS
+            js_urls = self.driver.execute_script("""
+                var s = document.querySelectorAll('script[src]');
+                var urls = []; s.forEach(function(x){ if(x.src) urls.push(x.src); });
+                return urls;
+            """)
+            for js_url in (js_urls or []):
+                if js_url not in self.url_to_local:
+                    content = self._download_asset(js_url)
+                    if content:
+                        filename = self._safe_filename(js_url, ".js")
+                        local_path = f"js/{filename}"
+                        self.zip_files[local_path] = content
+                        self.url_to_local[js_url] = local_path
+
+            # Imagens
+            img_urls = self.driver.execute_script("""
+                var urls = [];
+                document.querySelectorAll('img').forEach(function(img){
+                    if(img.src && !img.src.startsWith('data:')) urls.push(img.src);
+                    if(img.dataset && img.dataset.src) urls.push(img.dataset.src);
+                });
+                return [...new Set(urls)];
+            """)
+            for img_url in (img_urls or []):
+                abs_url = urljoin(self.driver.current_url, img_url)
+                if abs_url not in self.url_to_local:
+                    content = self._download_asset(abs_url)
+                    if content:
+                        filename = self._safe_filename(abs_url)
+                        local_path = f"images/{filename}"
+                        self.zip_files[local_path] = content
+                        self.url_to_local[abs_url] = local_path
+                        if img_url != abs_url:
+                            self.url_to_local[img_url] = local_path
+
+        except Exception as e:
+            self.errors.append(f"Erro ao capturar assets: {str(e)[:80]}")
 
     def _rewrite_css_urls(self, css_text, css_url):
-        """Reescreve URLs dentro de arquivos CSS para caminhos relativos."""
         def replace_url(match):
             original = match.group(1).strip('\'"')
             if original.startswith('data:') or original.startswith('#'):
@@ -179,340 +338,172 @@ class SiteBackup:
                 filename = self._safe_filename(absolute)
                 local_path = f"{folder}/{filename}"
                 self.url_to_local[absolute] = local_path
-                # Caminho relativo de css/ para a pasta do asset
+                self.zip_files[local_path] = content
                 relative = f"../{local_path}"
                 return f"url('{relative}')"
             return match.group(0)
-
         return re.sub(r'url\(([^)]+)\)', replace_url, css_text)
 
-    def capture_all_scripts(self):
-        """Captura todos os JS externos e inline."""
-        scripts = {}
-
-        try:
-            js_urls = self.driver.execute_script("""
-                var scripts = document.querySelectorAll('script[src]');
-                var urls = [];
-                scripts.forEach(function(s) {
-                    if (s.src) urls.push(s.src);
-                });
-                return urls;
-            """)
-
-            for js_url in js_urls:
-                content = self._download_asset(js_url)
-                if content:
-                    filename = self._safe_filename(js_url, ".js")
-                    local_path = f"js/{filename}"
-                    scripts[local_path] = content
-                    self.url_to_local[js_url] = local_path
-
-            inline_scripts = self.driver.execute_script("""
-                var scripts = document.querySelectorAll('script:not([src])');
-                var contents = [];
-                scripts.forEach(function(s, i) {
-                    var text = s.textContent || s.innerText || '';
-                    if (text.trim().length > 0) contents.push(text);
-                });
-                return contents;
-            """)
-
-            for i, script_content in enumerate(inline_scripts):
-                if script_content.strip():
-                    local_path = f"js/inline_script_{i+1}.js"
-                    scripts[local_path] = script_content.encode('utf-8')
-
-        except Exception as e:
-            self.errors.append(f"Erro ao capturar JS: {str(e)}")
-
-        return scripts
-
-    def capture_all_images(self):
-        """Captura todas as imagens do site."""
-        images = {}
-
-        try:
-            img_urls = self.driver.execute_script("""
-                var images = document.querySelectorAll('img');
-                var urls = [];
-                images.forEach(function(img) {
-                    if (img.src && !img.src.startsWith('data:')) urls.push(img.src);
-                    if (img.dataset && img.dataset.src) urls.push(img.dataset.src);
-                });
-                var allElements = document.querySelectorAll('*');
-                allElements.forEach(function(el) {
-                    var bg = window.getComputedStyle(el).backgroundImage;
-                    if (bg && bg !== 'none') {
-                        var match = bg.match(/url\\(['"]?(.+?)['"]?\\)/);
-                        if (match && !match[1].startsWith('data:')) {
-                            urls.push(match[1]);
-                        }
-                    }
-                });
-                return [...new Set(urls)];
-            """)
-
-            for img_url in img_urls:
-                absolute_url = urljoin(self.url, img_url)
-                content = self._download_asset(absolute_url)
-                if content:
-                    filename = self._safe_filename(absolute_url)
-                    local_path = f"images/{filename}"
-                    images[local_path] = content
-                    self.url_to_local[absolute_url] = local_path
-                    # Também mapear a URL original não-absoluta
-                    if img_url != absolute_url:
-                        self.url_to_local[img_url] = local_path
-
-        except Exception as e:
-            self.errors.append(f"Erro ao capturar imagens: {str(e)}")
-
-        return images
-
-    def capture_fonts(self):
-        """Captura todas as fontes usadas no site."""
-        fonts = {}
-
-        try:
-            font_urls = self.driver.execute_script("""
-                var urls = [];
-                for (var i = 0; i < document.styleSheets.length; i++) {
-                    try {
-                        var rules = document.styleSheets[i].cssRules ||
-                                    document.styleSheets[i].rules;
-                        if (!rules) continue;
-                        for (var j = 0; j < rules.length; j++) {
-                            if (rules[j].type === CSSRule.FONT_FACE_RULE) {
-                                var src = rules[j].style.getPropertyValue('src');
-                                var matches = src.match(/url\\(['"]?(.+?)['"]?\\)/g);
-                                if (matches) {
-                                    matches.forEach(function(m) {
-                                        var url = m.replace(/url\\(['"]?/, '')
-                                                    .replace(/['"]?\\)/, '');
-                                        if (!url.startsWith('data:')) urls.push(url);
-                                    });
-                                }
-                            }
-                        }
-                    } catch(e) {}
-                }
-                return [...new Set(urls)];
-            """)
-
-            for font_url in font_urls:
-                absolute_url = urljoin(self.url, font_url)
-                content = self._download_asset(absolute_url)
-                if content:
-                    filename = self._safe_filename(absolute_url)
-                    local_path = f"fonts/{filename}"
-                    fonts[local_path] = content
-                    self.url_to_local[absolute_url] = local_path
-                    if font_url != absolute_url:
-                        self.url_to_local[font_url] = local_path
-
-        except Exception as e:
-            self.errors.append(f"Erro ao capturar fontes: {str(e)}")
-
-        return fonts
+    def _rewrite_html(self, html, page_local_path):
+        """Reescreve o HTML para usar caminhos locais e links entre páginas."""
+        soup = BeautifulSoup(html, 'html.parser')
+
+        # Calcular profundidade para caminhos relativos
+        depth = page_local_path.count('/')
+        prefix = '../' * depth if depth > 0 else ''
+
+        # Reescrever <link href> (CSS)
+        for link in soup.find_all('link', rel='stylesheet'):
+            href = link.get('href')
+            if href:
+                abs_url = urljoin(self.driver.current_url, href)
+                if abs_url in self.url_to_local:
+                    link['href'] = prefix + self.url_to_local[abs_url]
+
+        # Reescrever <script src>
+        for script in soup.find_all('script', src=True):
+            src = script.get('src')
+            if src:
+                abs_url = urljoin(self.driver.current_url, src)
+                if abs_url in self.url_to_local:
+                    script['src'] = prefix + self.url_to_local[abs_url]
+
+        # Reescrever <img src> e data-src
+        for img in soup.find_all('img'):
+            for attr in ['src', 'data-src']:
+                val = img.get(attr)
+                if val and not val.startswith('data:'):
+                    abs_url = urljoin(self.driver.current_url, val)
+                    if abs_url in self.url_to_local:
+                        img[attr] = prefix + self.url_to_local[abs_url]
+
+        # Reescrever links <a href> para apontar para páginas locais
+        for a in soup.find_all('a', href=True):
+            href = a['href']
+            if href.startswith('javascript:') or href.startswith('mailto:') or href.startswith('tel:'):
+                continue
+            abs_url = urljoin(self.driver.current_url, href).split('#')[0]
+            if abs_url in self.visited_pages and self.visited_pages[abs_url]:
+                target_path = self.visited_pages[abs_url]
+                a['href'] = prefix + target_path
+
+        # Remover <base> tags
+        for base in soup.find_all('base'):
+            base.decompose()
+
+        # Remover scripts de tracking/analytics
+        tracking_patterns = ['google-analytics', 'gtag', 'facebook', 'hotjar',
+                           'analytics', 'tracking', 'pixel', 'adsbygoogle']
+        for script in soup.find_all('script'):
+            src = script.get('src', '')
+            text = script.string or ''
+            if any(p in src.lower() or p in text.lower() for p in tracking_patterns):
+                script.decompose()
+
+        # Garantir charset UTF-8
+        head = soup.find('head')
+        if head:
+            existing_charset = head.find('meta', attrs={'charset': True})
+            if not existing_charset:
+                meta = soup.new_tag('meta', charset='UTF-8')
+                head.insert(0, meta)
+
+        return f"<!DOCTYPE html>\n{str(soup)}"
 
     def capture_screenshot(self):
-        """Captura um screenshot da página."""
         try:
             return self.driver.get_screenshot_as_png()
-        except Exception as e:
-            self.errors.append(f"Erro ao capturar screenshot: {str(e)}")
+        except:
             return None
 
-    def _rewrite_html(self, html):
-        """Reescreve o HTML para apontar para os arquivos locais."""
-        try:
-            soup = BeautifulSoup(html, 'html.parser')
-
-            # Reescrever <link rel="stylesheet" href="...">
-            for link in soup.find_all('link', rel='stylesheet'):
-                href = link.get('href')
-                if href:
-                    absolute = urljoin(self.url, href)
-                    if absolute in self.url_to_local:
-                        link['href'] = self.url_to_local[absolute]
-                    elif href in self.url_to_local:
-                        link['href'] = self.url_to_local[href]
-
-            # Reescrever <script src="...">
-            for script in soup.find_all('script', src=True):
-                src = script.get('src')
-                if src:
-                    absolute = urljoin(self.url, src)
-                    if absolute in self.url_to_local:
-                        script['src'] = self.url_to_local[absolute]
-                    elif src in self.url_to_local:
-                        script['src'] = self.url_to_local[src]
-
-            # Reescrever <img src="...">
-            for img in soup.find_all('img'):
-                src = img.get('src')
-                if src and not src.startswith('data:'):
-                    absolute = urljoin(self.url, src)
-                    if absolute in self.url_to_local:
-                        img['src'] = self.url_to_local[absolute]
-                    elif src in self.url_to_local:
-                        img['src'] = self.url_to_local[src]
-                # data-src (lazy loading)
-                data_src = img.get('data-src')
-                if data_src and not data_src.startswith('data:'):
-                    absolute = urljoin(self.url, data_src)
-                    if absolute in self.url_to_local:
-                        img['data-src'] = self.url_to_local[absolute]
-
-            # Reescrever <source src="..."> (video/audio)
-            for source in soup.find_all('source'):
-                src = source.get('src')
-                if src:
-                    absolute = urljoin(self.url, src)
-                    if absolute in self.url_to_local:
-                        source['src'] = self.url_to_local[absolute]
-
-            # Reescrever background-image inline em style="..."
-            for el in soup.find_all(style=True):
-                style = el.get('style', '')
-                if 'url(' in style:
-                    def replace_inline_url(match):
-                        original = match.group(1).strip('\'"')
-                        if original.startswith('data:'):
-                            return match.group(0)
-                        absolute = urljoin(self.url, original)
-                        if absolute in self.url_to_local:
-                            return f"url('{self.url_to_local[absolute]}')"
-                        return match.group(0)
-                    el['style'] = re.sub(r'url\(([^)]+)\)', replace_inline_url, style)
-
-            # Adicionar <base> tag para resolver caminhos restantes
-            # Remover <base> existente para evitar conflitos
-            for base in soup.find_all('base'):
-                base.decompose()
-
-            # Remover scripts que podem causar problemas offline
-            # (ex: service workers, analytics, cookie consent)
-            for script in soup.find_all('script'):
-                src = script.get('src', '')
-                text = script.string or ''
-                src_lower = src.lower()
-                text_lower = text.lower()
-                # Remover analytics/tracking/cookie scripts que quebram offline
-                block_patterns = [
-                    'google-analytics', 'googletagmanager', 'gtag',
-                    'facebook.net', 'fb.net', 'hotjar',
-                    'cookie', 'consent', 'gdpr',
-                    'serviceworker', 'service-worker', 'sw.js'
-                ]
-                if any(p in src_lower or p in text_lower for p in block_patterns):
-                    script.decompose()
-                    continue
-
-            # Adicionar meta charset se não existir
-            head = soup.find('head')
-            if head:
-                if not soup.find('meta', charset=True) and not soup.find('meta', attrs={'http-equiv': 'Content-Type'}):
-                    meta = soup.new_tag('meta', charset='UTF-8')
-                    head.insert(0, meta)
-
-            return f"<!DOCTYPE html>\n{str(soup)}"
+    def generate_backup_zip(self, folder_name="backup"):
+        """Gera o ZIP com crawling recursivo."""
+        logger.info(f"[BACKUP] Iniciando backup recursivo de {self.url}")
 
-        except Exception as e:
-            self.errors.append(f"Erro ao reescrever HTML: {str(e)}")
-            return html
-
-    def generate_backup_zip(self):
-        """Gera o ZIP completo do backup."""
-        zip_buffer = BytesIO()
-
-        with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zf:
-            # 1. Capturar assets PRIMEIRO (para construir url_to_local)
-            stylesheets = self.capture_all_stylesheets()
-            scripts = self.capture_all_scripts()
-            images = self.capture_all_images()
-            fonts = self.capture_fonts()
-
-            # 2. Capturar e REESCREVER HTML com caminhos locais
-            raw_html = self.capture_full_html()
-            rewritten_html = self._rewrite_html(raw_html)
-            zf.writestr("index.html", rewritten_html)
-
-            # 3. Salvar todos os assets
-            for path, content in stylesheets.items():
-                zf.writestr(path, content)
+        # Começar pela página principal
+        self._navigate_and_capture(self.url, depth=0)
 
-            for path, content in scripts.items():
-                zf.writestr(path, content)
+        # Processar fila de subpáginas
+        while self.page_queue and len(self.visited_pages) < self.max_pages:
+            next_url, next_depth = self.page_queue.pop(0)
+            if next_url not in self.visited_pages:
+                self._navigate_and_capture(next_url, next_depth)
 
-            for path, content in images.items():
-                zf.writestr(path, content)
+        # Voltar para a página original
+        try:
+            self.driver.get(self.url)
+            time.sleep(2)
+        except:
+            pass
 
-            for path, content in fonts.items():
-                zf.writestr(path, content)
+        # Screenshot
+        screenshot = self.capture_screenshot()
 
-            # 4. Screenshot
-            screenshot = self.capture_screenshot()
+        # Gerar ZIP
+        zip_buffer = BytesIO()
+        with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zf:
+            # Todas as páginas e assets
+            for file_path, content in self.zip_files.items():
+                full_path = f"{folder_name}/{file_path}"
+                if isinstance(content, str):
+                    zf.writestr(full_path, content.encode('utf-8'))
+                else:
+                    zf.writestr(full_path, content)
+
+            # Screenshot
             if screenshot:
-                zf.writestr("screenshot.png", screenshot)
-
-            # 5. Relatório
-            report = self._generate_report(
-                rewritten_html, stylesheets, scripts, images, fonts
-            )
-            zf.writestr("backup_report.txt", report)
+                zf.writestr(f"{folder_name}/screenshot.png", screenshot)
+
+            # Relatório
+            report = self._generate_report(folder_name)
+            zf.writestr(f"{folder_name}/backup_report.txt", report.encode('utf-8'))
+
+            # Mapa de navegação (JSON)
+            nav_map = {
+                "pages": {url: path for url, path in self.visited_pages.items() if path},
+                "total_pages": len([p for p in self.visited_pages.values() if p]),
+                "total_assets": len(self.url_to_local),
+                "errors": len(self.errors)
+            }
+            zf.writestr(f"{folder_name}/navigation_map.json",
+                        json.dumps(nav_map, indent=2, ensure_ascii=False).encode('utf-8'))
 
-            # 6. Log de erros
+            # Erros
             if self.errors:
-                error_log = "ERROS DURANTE O BACKUP\n"
-                error_log += "=" * 50 + "\n\n"
-                for err in self.errors:
-                    error_log += f"- {err}\n"
-                zf.writestr("backup_errors.txt", error_log)
+                zf.writestr(f"{folder_name}/errors.txt",
+                           "\n".join(self.errors).encode('utf-8'))
 
         zip_buffer.seek(0)
-        return zip_buffer
-
-    def _generate_report(self, html, stylesheets, scripts, images, fonts):
-        """Gera relatório textual do backup."""
-        report = []
-        report.append("=" * 60)
-        report.append("   RELATÓRIO DE BACKUP DO SITE")
-        report.append("=" * 60)
-        report.append(f"\nURL Original: {self.url}")
-        report.append(f"Domínio: {self.domain}")
-        report.append(f"Data do Backup: {time.strftime('%d/%m/%Y %H:%M:%S')}")
-        report.append(f"\n{'─' * 40}")
-        report.append("ARQUIVOS CAPTURADOS:")
-        report.append(f"{'─' * 40}")
-        report.append(f"  HTML:     1 arquivo (caminhos reescritos)")
-        report.append(f"  CSS:      {len(stylesheets)} arquivo(s)")
-        report.append(f"  JS:       {len(scripts)} arquivo(s)")
-        report.append(f"  Imagens:  {len(images)} arquivo(s)")
-        report.append(f"  Fontes:   {len(fonts)} arquivo(s)")
-        report.append(f"  Screenshot: 1 arquivo")
-        total = 1 + len(stylesheets) + len(scripts) + len(images) + len(fonts) + 1
-        report.append(f"\n  TOTAL: {total} arquivos")
-        report.append(f"\n{'─' * 40}")
-        report.append("MAPEAMENTO DE URLS:")
-        report.append(f"{'─' * 40}")
-        for url, local in list(self.url_to_local.items())[:50]:
-            report.append(f"  {url[:80]}")
-            report.append(f"    -> {local}")
-        if len(self.url_to_local) > 50:
-            report.append(f"  ... e mais {len(self.url_to_local) - 50} mapeamentos")
-
-        if self.errors:
-            report.append(f"\n{'─' * 40}")
-            report.append(f"AVISOS ({len(self.errors)}):")
-            report.append(f"{'─' * 40}")
-            for err in self.errors:
-                report.append(f"  ⚠ {err}")
-
-        report.append(f"\n{'=' * 60}")
-        report.append("Backup gerado pelo Site Backup System v1.3.0")
-        report.append("Caminhos reescritos para funcionamento offline")
-        report.append("=" * 60)
-
-        return "\n".join(report)
+        logger.info(f"[BACKUP] Concluido: {len(self.visited_pages)} paginas, "
+                    f"{len(self.url_to_local)} assets, {len(self.errors)} erros")
+        return zip_buffer, len(self.errors)
+
+    def _generate_report(self, folder_name):
+        timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
+        pages_list = "\n".join([
+            f"  {url} -> {path}"
+            for url, path in self.visited_pages.items() if path
+        ])
+        return f"""========================================
+BACKUP REPORT - Site Backup & Error Checker
+========================================
+URL Original: {self.url}
+Dominio: {self.domain}
+Data: {timestamp}
+Pasta: {folder_name}
+
+PAGINAS CAPTURADAS ({len([p for p in self.visited_pages.values() if p])}):
+{pages_list}
+
+ASSETS BAIXADOS ({len(self.url_to_local)}):
+  CSS: {len([p for p in self.url_to_local.values() if p.startswith('css/')])}
+  JS: {len([p for p in self.url_to_local.values() if p.startswith('js/')])}
+  Imagens: {len([p for p in self.url_to_local.values() if p.startswith('images/')])}
+  Fontes: {len([p for p in self.url_to_local.values() if p.startswith('fonts/')])}
+  Media: {len([p for p in self.url_to_local.values() if p.startswith('media/')])}
+  Outros: {len([p for p in self.url_to_local.values() if p.startswith('assets/')])}
+
+ERROS ({len(self.errors)}):
+{chr(10).join(self.errors) if self.errors else '  Nenhum erro.'}
+========================================
+"""