perfectclone 0.1.0__py3-none-any.whl

perfectclone/__init__.py

@@ -0,0 +1,2 @@
+"""Clone any website 1:1 with a real browser, then edit it safely."""
+__version__ = "0.1.0"

perfectclone/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

perfectclone/cli.py

@@ -0,0 +1,112 @@
+"""perfectclone command line."""
+import argparse
+import json
+import sys
+from pathlib import Path
+from urllib.parse import urlparse
+
+from . import __version__
+from .edit import localize, rehost, replace
+from .serve import serve
+from .trackers import strip
+from .util import site_dir
+
+
+def cmd_clone(a):
+    # Imported here so the editing commands don't pay for loading Playwright.
+    from .crawl import crawl
+    from .mirror import mirror
+
+    out = Path(a.out)
+    site = out / "site"
+    print(f"Crawling {a.url}")
+    pages, assets, external, skipped = crawl(
+        a.url, max_pages=a.max_pages, respect_robots=not a.ignore_robots,
+        extract_dir=out / "extract" if a.extract else None,
+    )
+    if not pages:
+        sys.exit("No pages could be loaded." + (f" First problem: {skipped[0]}" if skipped else ""))
+    print(f"Mirroring into {site}")
+    saved, fetched, failures = mirror(pages, assets, site)
+    localize(site, a.url)
+    if a.strip_trackers:
+        print("Removing trackers")
+        strip(site)
+    manifest = {
+        "source": a.url, "pages": pages, "assets_fetched": fetched, "failures": failures,
+        "skipped": skipped, "external_hosts": external,
+    }
+    (out / "manifest.json").write_text(json.dumps(manifest, indent=2))
+    print(f"\nDone: {saved} pages, {fetched} assets → {site}")
+    if failures:
+        print(f"  {len(failures)} URLs failed to download (see {out / 'manifest.json'})")
+    if external:
+        print(f"  The original also used these hosts (embeds, CDNs, analytics): {', '.join(external)}")
+    print(f"\nPreview it:  perfectclone serve {out}")
+
+
+def cmd_serve(a):
+    serve(a.site, a.port)
+
+
+def cmd_replace(a):
+    replace(site_dir(a.site), a.old, a.new, variants=not a.exact_case, whole_word=not a.substring)
+
+
+def cmd_rehost(a):
+    rehost(site_dir(a.site), a.old_origin, a.new_origin)
+
+
+def cmd_strip(a):
+    strip(site_dir(a.site))
+
+
+def main(argv=None):
+    p = argparse.ArgumentParser(
+        prog="perfectclone", description="Clone any website 1:1 with a real browser, then edit it safely.")
+    p.add_argument("--version", action="version", version=__version__)
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    c = sub.add_parser("clone", help="crawl a site and save a working local copy")
+    c.add_argument("url")
+    c.add_argument("-o", "--out", default=None, help="output folder (default: the site's hostname)")
+    c.add_argument("--max-pages", type=int, default=200)
+    c.add_argument("--extract", action="store_true", help="also save each page's text, metadata and a full-page screenshot")
+    c.add_argument("--keep-trackers", dest="strip_trackers", action="store_false", help="keep the original analytics/ad pixels")
+    c.add_argument("--ignore-robots", action="store_true", help="crawl pages robots.txt disallows")
+    c.set_defaults(fn=cmd_clone)
+
+    s = sub.add_parser("serve", help="serve a clone locally")
+    s.add_argument("site")
+    s.add_argument("-p", "--port", type=int, default=8000)
+    s.set_defaults(fn=cmd_serve)
+
+    r = sub.add_parser("replace", help="replace text across the clone (skips URLs, Next.js-safe)")
+    r.add_argument("site")
+    r.add_argument("old")
+    r.add_argument("new")
+    r.add_argument("--exact-case", action="store_true", help="don't also replace UPPER/lower/Capitalized variants")
+    r.add_argument("--substring", action="store_true", help="match inside words too")
+    r.set_defaults(fn=cmd_replace)
+
+    h = sub.add_parser("rehost", help="point canonical/og/sitemap URLs at a new origin")
+    h.add_argument("site")
+    h.add_argument("old_origin")
+    h.add_argument("new_origin")
+    h.set_defaults(fn=cmd_rehost)
+
+    t = sub.add_parser("strip-trackers", help="remove analytics and ad pixels")
+    t.add_argument("site")
+    t.set_defaults(fn=cmd_strip)
+
+    a = p.parse_args(argv)
+    if a.cmd == "clone":
+        if "://" not in a.url:
+            a.url = "https://" + a.url
+        if not a.out:
+            a.out = urlparse(a.url).netloc.removeprefix("www.") or "clone"
+    a.fn(a)
+
+
+if __name__ == "__main__":
+    main()

perfectclone/crawl.py

@@ -0,0 +1,161 @@
+"""Find a site's pages, and every asset they load, by rendering them in Chromium."""
+import json
+import re
+import subprocess
+import sys
+from collections import deque
+from pathlib import Path
+from urllib import robotparser
+from urllib.parse import urldefrag, urljoin, urlparse
+
+from playwright.sync_api import sync_playwright
+
+from .util import UA, host_of
+
+NOT_PAGE = re.compile(
+    r"\.(png|jpe?g|gif|svg|webp|avif|ico|pdf|zip|mp4|webm|mp3|woff2?|ttf|otf|css|js|mjs|json|xml|txt|rss)$", re.I)
+
+EXTRACT_JS = """
+() => {
+  const abs = u => { try { return new URL(u, location.href).href } catch { return u } };
+  const meta = {};
+  document.querySelectorAll('meta').forEach(m => {
+    const k = m.getAttribute('name') || m.getAttribute('property') || m.getAttribute('http-equiv');
+    if (k) meta[k] = m.getAttribute('content');
+  });
+  return {
+    title: document.title,
+    lang: document.documentElement.lang,
+    canonical: document.querySelector('link[rel=canonical]')?.href || null,
+    meta,
+    headings: [...document.querySelectorAll('h1,h2,h3,h4,h5,h6')].map(h => ({tag: h.tagName, text: h.innerText.trim()})),
+    links: [...document.querySelectorAll('a[href]')].map(a => ({text: a.innerText.trim(), href: abs(a.getAttribute('href'))})),
+    images: [...document.querySelectorAll('img')].map(i => ({src: i.currentSrc || abs(i.getAttribute('src') || ''), alt: i.alt})),
+    forms: [...document.querySelectorAll('form')].map(f => ({action: f.action, method: f.method,
+      fields: [...f.querySelectorAll('input,select,textarea')].map(i => ({tag: i.tagName, type: i.type, name: i.name}))})),
+    jsonld: [...document.querySelectorAll('script[type="application/ld+json"]')].map(s => s.textContent),
+    text: document.body ? document.body.innerText : '',
+  };
+}
+"""
+
+# Scrolling triggers lazy-loaded images, chunks and fonts so they show up in the response log.
+SCROLL_JS = """async () => {
+  for (let y = 0; y < document.body.scrollHeight; y += 600) { window.scrollTo(0, y); await new Promise(r => setTimeout(r, 120)); }
+  window.scrollTo(0, 0);
+}"""
+
+
+def page_key(url, host):
+    """Normalized URL if it's a same-site page worth visiting, else None."""
+    url = urldefrag(url)[0]
+    p = urlparse(url)
+    if p.scheme not in ("http", "https") or host_of(url) != host or NOT_PAGE.search(p.path):
+        return None
+    return p._replace(path=p.path.rstrip("/") or "/", query="").geturl()
+
+
+def slug(url):
+    return re.sub(r"[^a-zA-Z0-9]+", "_", urlparse(url).path.strip("/"))[:100] or "index"
+
+
+def launch(pw, log=print):
+    try:
+        return pw.chromium.launch()
+    except Exception as e:
+        if "Executable doesn't exist" not in str(e):
+            raise
+    log("First run: downloading Chromium for Playwright (one time, about 150 MB)...")
+    subprocess.run([sys.executable, "-m", "playwright", "install", "chromium"], check=True)
+    return pw.chromium.launch()
+
+
+def crawl(start, max_pages=200, respect_robots=True, extract_dir=None, log=print):
+    """Visit same-site pages breadth-first. Returns (pages, asset_urls, external_hosts, skipped)."""
+    host = host_of(start)
+    first = page_key(start, host)
+    queue, seen = deque([first]), {first}
+    pages, assets, external, skipped = [], set(), set(), []
+    if extract_dir:
+        Path(extract_dir).mkdir(parents=True, exist_ok=True)
+
+    with sync_playwright() as pw:
+        browser = launch(pw, log)
+        ctx = browser.new_context(viewport={"width": 1440, "height": 900}, user_agent=UA)
+
+        def get(url):
+            try:
+                r = ctx.request.get(url, timeout=20000)
+                return r if r.ok else None
+            except Exception:
+                return None
+
+        robots = robotparser.RobotFileParser()
+        r = get(urljoin(start, "/robots.txt"))
+        robots.parse(r.text().splitlines() if r else [])
+        sitemaps = re.findall(r"(?im)^sitemap:\s*(\S+)", r.text()) if r else []
+        for sm in sitemaps or [urljoin(start, "/sitemap.xml")]:
+            s = get(urljoin(start, sm))
+            if s:
+                for loc in re.findall(r"<loc>\s*(.*?)\s*</loc>", s.text()):
+                    u = page_key(loc, host)
+                    if u and u not in seen:
+                        seen.add(u)
+                        queue.append(u)
+
+        page = ctx.new_page()
+
+        def on_response(resp):
+            u = resp.url
+            if not u.startswith("http"):
+                return
+            if host_of(u) != host:
+                external.add(urlparse(u).netloc)
+            elif resp.request.resource_type != "document":
+                assets.add(u)
+
+        page.on("response", on_response)
+
+        while queue and len(pages) < max_pages:
+            url = queue.popleft()
+            if respect_robots and not robots.can_fetch("perfectclone", url):
+                skipped.append({"url": url, "reason": "robots.txt"})
+                continue
+            log(f"  [{len(pages) + 1}] {url}")
+            try:
+                resp = page.goto(url, wait_until="domcontentloaded", timeout=45000)
+                # A slow third-party image, a video or a polling connection can hold off "load"
+                # and "networkidle" forever, so each gets a bounded wait.
+                for state, ms in (("load", 15000), ("networkidle", 8000)):
+                    try:
+                        page.wait_for_load_state(state, timeout=ms)
+                    except Exception:
+                        pass
+                page.evaluate(SCROLL_JS)
+                page.wait_for_timeout(400)
+                links = page.eval_on_selector_all("a[href]", "as => as.map(a => a.href)")
+            except Exception as e:
+                skipped.append({"url": url, "reason": str(e).splitlines()[0]})
+                continue
+            status = resp.status if resp else None
+            ctype = resp.headers.get("content-type", "") if resp else ""
+            if (status and status >= 400) or "html" not in ctype:
+                skipped.append({"url": url, "reason": f"HTTP {status} {ctype}".strip()})
+                continue
+            pages.append({"url": url, "final_url": page.url, "status": status, "title": page.title()})
+
+            if extract_dir:
+                data = page.evaluate(EXTRACT_JS)
+                name = slug(url)
+                Path(extract_dir, f"{name}.json").write_text(json.dumps(data, indent=2, ensure_ascii=False))
+                Path(extract_dir, f"{name}.txt").write_text(data["text"])
+                page.screenshot(path=str(Path(extract_dir, f"{name}.png")), full_page=True)
+
+            for href in links:
+                u = page_key(href, host)
+                if u and u not in seen:
+                    seen.add(u)
+                    queue.append(u)
+
+        browser.close()
+    return pages, assets, sorted(external), skipped

perfectclone/edit.py

@@ -0,0 +1,109 @@
+"""Edit a cloned site in place without breaking it.
+
+Text replacement leaves URLs alone (renaming "Acme" must not break https://acme.com/logo.png or
+/acme/app.js) and goes through the flight payload on Next.js pages so the server HTML and the
+React payload stay identical.
+"""
+import re
+
+from .flight import edit_flight, has_flight, map_rows, outside_flight
+from .util import text_files
+
+# URLs, root-relative asset paths and mailto/tel targets are never rewritten.
+PROTECTED = re.compile(r"""(https?://[^\s"'\\<>)]+|(?<=["'(=])/[^\s"'\\<>)]*|mailto:[^\s"'\\<>]+)""")
+
+
+def case_variants(old, new):
+    """Acme → Globex also maps ACME → GLOBEX and acme → globex."""
+    pairs = [(old, new)]
+    for f in (str.upper, str.lower, str.capitalize):
+        if f(old) != old and (f(old), f(new)) not in pairs:
+            pairs.append((f(old), f(new)))
+    return pairs
+
+
+def replacer(pairs, whole_word=True):
+    rx = [(re.compile(rf"\b{re.escape(o)}\b" if whole_word else re.escape(o)), n) for o, n in pairs]
+
+    def swap(text):
+        parts = PROTECTED.split(text)
+        for i in range(0, len(parts), 2):                      # odd indices are protected
+            for r, n in rx:
+                parts[i] = r.sub(n, parts[i])
+        return "".join(parts)
+    return swap
+
+
+def apply(site, fn, html_fn=None, log=print):
+    """Run fn over every text file. Flight data (in HTML, or saved .rsc navigation payloads) is
+    edited row by row so length-prefixed rows stay valid; html_fn, if given, is used for the HTML
+    outside the payload instead of fn."""
+    changed = 0
+    for p in text_files(site):
+        text = p.read_text(errors="surrogateescape")
+        suffix = p.suffix.lower()
+        if suffix == ".rsc":
+            new = map_rows(text, fn)
+        elif suffix in (".html", ".htm"):
+            new = outside_flight(edit_flight(text, fn), html_fn or fn) if has_flight(text) else (html_fn or fn)(text)
+        else:
+            new = fn(text)
+        if new != text:
+            p.write_text(new, errors="surrogateescape")
+            changed += 1
+    log(f"  changed {changed} files")
+    return changed
+
+
+def replace(site, old, new, variants=True, whole_word=True, log=print):
+    pairs = case_variants(old, new) if variants else [(old, new)]
+    return apply(site, replacer(pairs, whole_word), log=log)
+
+
+def origin_variants(origin):
+    m = re.match(r"https?://(?:www\.)?([^/]+)", origin.rstrip("/"))
+    host = m.group(1) if m else origin
+    return re.compile(rf"https?://(?:www\.)?{re.escape(host)}(?![\w.-])")
+
+
+def rehost(site, old_origin, new_origin, log=print):
+    """Point absolute URLs at a new origin (canonical, og:url, JSON-LD, sitemap)."""
+    rx = origin_variants(old_origin)
+    new_origin = new_origin.rstrip("/")
+    return apply(site, lambda t: rx.sub(new_origin, t), log=log)
+
+
+ASSET_TAG = re.compile(r"<(?:img|script|source|video|audio|track|link|image|use)\b[^>]*>", re.I)
+# Module scripts need CORS like fonts do, and import maps list them by absolute URL.
+STYLE_BLOCK = re.compile(r"(<style\b[^>]*>|<script\b[^>]*type=[\"']?importmap[^>]*>)(.*?)(</style>|</script>)", re.S | re.I)
+DOC_LINK = re.compile(r"""rel=["']?(?:canonical|alternate|shortlink|prev|next|author|me)\b""", re.I)
+
+
+def localize(site, origin, log=print):
+    """Make the site's own absolute asset URLs root-relative, so the clone loads its local copies.
+
+    Browsers block cross-origin fonts without CORS headers, so a stylesheet or @font-face still
+    pointing at the original domain renders in a fallback font. Page links and metadata keep
+    their absolute URLs; `rehost` is for those.
+    """
+    rx = re.compile(origin_variants(origin).pattern + r"(?=/)")
+
+    def tag(m):
+        t = m.group(0)
+        return t if t[:5].lower() == "<link" and DOC_LINK.search(t) else rx.sub("", t)
+
+    def html(t):
+        t = ASSET_TAG.sub(tag, t)
+        return STYLE_BLOCK.sub(lambda m: m.group(1) + rx.sub("", m.group(2)) + m.group(3), t)
+
+    changed = 0
+    for p in text_files(site):
+        suffix = p.suffix.lower()
+        if suffix not in (".css", ".html", ".htm"):
+            continue
+        text = p.read_text(errors="surrogateescape")
+        new = rx.sub("", text) if suffix == ".css" else outside_flight(text, html)
+        if new != text:
+            p.write_text(new, errors="surrogateescape")
+            changed += 1
+    return changed

perfectclone/flight.py

@@ -0,0 +1,113 @@
+"""Read and rewrite the React Server Components "flight" payload that Next.js inlines in HTML.
+
+An App Router page ships its server-rendered HTML *and* a serialized copy of the same React tree
+in `<script>self.__next_f.push([1,"..."])</script>` chunks. On load React hydrates the HTML
+against that payload. Change the HTML without changing the payload (or the other way round) and
+React throws a hydration error and re-renders from the payload, undoing the edit.
+
+The payload is a stream of rows:
+    <id>:<json>\n              most rows
+    <id>:T<hex byte length>,<text>   long text, length-prefixed in UTF-8 bytes, no newline
+Rows can span push() chunks, and a text row's length must be recomputed after any edit.
+"""
+import json
+import re
+
+PUSH = re.compile(r"<script[^>]*>self\.__next_f\.push\((\[.*?\])\)</script>", re.S)
+TEXT_ROW = re.compile(rb"([0-9a-f]*):T([0-9a-f]+),")
+
+
+def has_flight(page):
+    return "self.__next_f.push(" in page
+
+
+def map_rows(stream, fn):
+    """Apply fn(str) -> str to every row of a decoded flight stream."""
+    b, out, i = stream.encode(), [], 0
+    while i < len(b):
+        m = TEXT_ROW.match(b, i, min(len(b), i + 40))
+        if m:
+            start = m.end()
+            end = start + int(m.group(2), 16)
+            text = fn(b[start:end].decode()).encode()
+            out.append(m.group(1) + b":T" + format(len(text), "x").encode() + b"," + text)
+            i = end
+        else:
+            j = b.find(b"\n", i)
+            j = len(b) if j < 0 else j + 1
+            out.append(fn(b[i:j].decode()).encode())
+            i = j
+    return b"".join(out).decode()
+
+
+def edit_flight(page, fn):
+    """Apply fn row by row to a page's flight payload and write it back.
+
+    The decoded stream is written back as a single push() in place of the first data chunk, so a
+    row that used to straddle two chunks is handled like any other.
+    """
+    chunks = []
+    for m in PUSH.finditer(page):
+        arr = json.loads(m.group(1))
+        if len(arr) > 1 and arr[0] == 1 and isinstance(arr[1], str):
+            chunks.append((m, arr[1]))
+    if not chunks:
+        return page
+    stream = "".join(s for _, s in chunks)
+    new = map_rows(stream, fn)
+    if new == stream:
+        return page
+    enc = json.dumps([1, new], ensure_ascii=False, separators=(",", ":"))
+    # Same escaping Next.js applies so the payload can't close the <script> early.
+    enc = enc.replace("<", "\\u003c").replace("\u2028", "\\u2028").replace("\u2029", "\\u2029")
+    first = chunks[0][0].group(0)
+    tag = first[: first.index(">") + 1]                       # keep any nonce attribute
+    out, last = [], 0
+    for k, (m, _) in enumerate(chunks):
+        out.append(page[last:m.start()])
+        if k == 0:
+            out.append(f"{tag}self.__next_f.push({enc})</script>")
+        last = m.end()
+    out.append(page[last:])
+    return "".join(out)
+
+
+def outside_flight(page, fn):
+    """Apply fn to the parts of the page that are not flight chunks."""
+    out, last = [], 0
+    for m in PUSH.finditer(page):
+        out.append(fn(page[last:m.start()]))
+        out.append(m.group(0))
+        last = m.end()
+    out.append(fn(page[last:]))
+    return "".join(out)
+
+
+def edit_json_rows(page, fn):
+    """Rewrite each JSON row's tree in a page's payload with fn(node) -> node (None drops an element)."""
+    return edit_flight(page, json_row_editor(fn))
+
+
+def json_row_editor(fn):
+    def row(text):
+        m = re.match(r"([0-9a-f]+):(.*?)(\n?)$", text, re.S)
+        if not m or not m.group(2).startswith(("[", "{")):
+            return text
+        try:
+            tree = json.loads(m.group(2))
+        except ValueError:
+            return text
+        new = walk(tree, fn)
+        if new == tree:
+            return text
+        return f"{m.group(1)}:{json.dumps(new, ensure_ascii=False, separators=(',', ':'))}{m.group(3)}"
+    return row
+
+
+def walk(node, fn):
+    node = fn(node)
+    if isinstance(node, list):
+        return [walk(n, fn) for n in node]
+    if isinstance(node, dict):
+        return {k: walk(v, fn) for k, v in node.items()}
+    return node

perfectclone/mirror.py

@@ -0,0 +1,168 @@
+"""Download crawled pages and assets into a folder that serves as a working copy.
+
+Pages are saved as the server's HTML, not the rendered DOM, because that is what the site's
+JavaScript hydrates. Assets keep their URL paths so root-relative references resolve unchanged.
+"""
+import html
+import re
+from pathlib import Path
+from urllib.parse import parse_qs, unquote, urljoin, urlparse
+
+from playwright.sync_api import sync_playwright
+
+from .flight import has_flight
+from .util import UA, host_of
+
+REF = re.compile(
+    r"""(?:src|poster|data-src)=["']([^"']+)["']"""
+    r"""|url\(\s*["']?([^"')]+?)["']?\s*\)"""
+    r"""|(?:srcset|srcSet|imagesrcset|data-srcset)=["']([^"']+)["']"""
+    r"""|href=["']([^"']+)["']"""
+)
+# Pages link to each other with href too; those are left to the crawler so --max-pages and
+# robots.txt still apply. From an href, only files that are clearly assets are mirrored.
+ASSET_HREF = re.compile(
+    r"\.(css|js|mjs|ico|png|jpe?g|gif|svg|webp|avif|woff2?|ttf|otf|json|webmanifest|xml|pdf|mp4|webm)(\?|$)", re.I)
+# Lazy chunks and other files loaded at runtime appear only as string literals inside scripts.
+# Bundlers leave node_modules source paths in strings too; those aren't served.
+CHUNK = re.compile(
+    r"""["'`](?:\./)?(/?(?!node_modules/)[\w-]+/[^"'`\s?]+?"""
+    r"""\.(?:js|mjs|css|woff2?|ttf|otf|png|jpe?g|webp|avif|svg|gif|mp4|webm|json|wasm|riv|bin|glb|gltf)"""
+    r"""(?:\?[^"'`\s]*)?)["'`]""")
+TEXT_TYPES = (".html", ".css", ".js", ".mjs", ".svg", ".json", ".xml", ".txt", ".webmanifest")
+# Files a site often has that no page references directly (service workers are registered
+# from script, browsers request icons and manifests on their own).
+EXTRAS = ("/sw.js", "/service-worker.js", "/manifest.json", "/site.webmanifest", "/favicon.ico",
+          "/apple-touch-icon.png", "/robots.txt")
+# String literals that look like paths but are templates ("/static/${id}.js") or fragments.
+BAD_URL = re.compile(r"[\s{}<>`$\\^|()*#]|%23")
+
+
+def contained(site, out):
+    """out, if it stays inside site once resolved; percent-encoded ../ must not escape."""
+    out = out.resolve()
+    return out if out.is_relative_to(site.resolve()) else None
+
+
+def page_path(site, url):
+    path = unquote(urlparse(url).path)
+    if Path(path).suffix in (".html", ".htm"):
+        return contained(site, site / path.lstrip("/"))
+    return contained(site, site / path.strip("/") / "index.html")
+
+
+def asset_path(site, url):
+    path = unquote(urlparse(url).path)
+    if path.endswith("/"):
+        path += "index.html"
+    return contained(site, site / path.lstrip("/"))
+
+
+def refs(text, base, host):
+    """Same-site URLs referenced from HTML, CSS or JS."""
+    out = set()
+    for m in REF.finditer(text):
+        val = html.unescape(next(g for g in m.groups() if g)).strip().strip("\"'")
+        if val.startswith("data:"):
+            continue
+        if m.group(4) and not ASSET_HREF.search(urlparse(val).path + ("?" if urlparse(val).query else "")):
+            continue
+        # Only srcset is a comma list; a data: URL or query string may contain commas too.
+        for part in val.split(", ") if m.group(3) else [val]:
+            u = part.strip().split(" ")[0]
+            if u and not u.startswith(("data:", "#", "mailto:", "tel:", "javascript:", "blob:")):
+                out.add(urljoin(base, u))
+    for m in CHUNK.finditer(text):
+        out.add(urljoin(base, "/" + m.group(1).lstrip("/")))
+    # /_next/image responses are keyed by query string and often refused to direct requests, so
+    # mirror the original image instead; `serve` maps the optimizer URL back to it.
+    for u in [u for u in out if urlparse(u).path == "/_next/image"]:
+        out.discard(u)
+        src = parse_qs(urlparse(u).query).get("url", [""])[0]
+        if src.startswith("/"):
+            out.add(urljoin(base, src))
+    return {u for u in out if u.startswith("http") and host_of(u) == host and not BAD_URL.search(u)}
+
+
+def mirror(pages, assets, out_dir, log=print):
+    """Fetch pages and assets into out_dir. Returns (saved_pages, urls_tried, failures)."""
+    site = Path(out_dir)
+    site.mkdir(parents=True, exist_ok=True)
+    host = host_of(pages[0]["url"])
+    page_paths = {urlparse(p["url"]).path.rstrip("/") or "/" for p in pages}
+    todo, done, failures = set(assets), set(), []
+    saved_pages = 0
+
+    with sync_playwright() as pw:
+        req = pw.request.new_context(user_agent=UA)
+
+        def fetch(url, headers=None, quiet=False):
+            try:
+                r = req.get(url, headers=headers, timeout=30000)
+            except Exception as e:
+                if not quiet:
+                    failures.append({"url": url, "error": str(e).splitlines()[0]})
+                return None
+            if not r.ok:
+                if not quiet:
+                    failures.append({"url": url, "status": r.status})
+                return None
+            return r
+
+        for p in pages:
+            r = fetch(p["url"])
+            if r is None:
+                continue
+            body = r.text()
+            out = page_path(site, p["url"])
+            if out is None:
+                failures.append({"url": p["url"], "error": "path escapes the output folder"})
+                continue
+            out.parent.mkdir(parents=True, exist_ok=True)
+            out.write_text(body)
+            saved_pages += 1
+            todo |= refs(body, p["url"], host)
+            if has_flight(body) and out.name == "index.html":
+                # Next.js navigates between pages by fetching this payload (?_rsc=...) instead
+                # of HTML; without it every client-side link 404s and falls back to a reload.
+                rsc = fetch(p["url"], headers={"RSC": "1"}, quiet=True)
+                if rsc and "text/x-component" in rsc.headers.get("content-type", ""):
+                    out.with_name("index.rsc").write_bytes(rsc.body())
+
+        for path in EXTRAS:
+            r = fetch(urljoin(pages[0]["url"], path), quiet=True)
+            out = asset_path(site, urljoin(pages[0]["url"], path))
+            if r and out and not out.exists() and "text/html" not in r.headers.get("content-type", ""):
+                out.parent.mkdir(parents=True, exist_ok=True)
+                out.write_bytes(r.body())
+                done.add(urljoin(pages[0]["url"], path))
+
+        while todo:
+            url = todo.pop()
+            parsed = urlparse(url)
+            key = parsed._replace(fragment="").geturl()
+            if key in done or (parsed.path.rstrip("/") or "/") in page_paths:
+                continue
+            done.add(key)
+            if "/cdn-cgi/" in parsed.path:                    # Cloudflare's own endpoints
+                continue
+            r = fetch(key)
+            if r is None:
+                continue
+            if "text/html" in r.headers.get("content-type", "") and not Path(parsed.path).suffix:
+                continue                                       # a page the crawl didn't reach
+            out = asset_path(site, key)
+            if out is None:
+                failures.append({"url": key, "error": "path escapes the output folder"})
+                continue
+            if out.is_dir():
+                out = out / "index"
+            out.parent.mkdir(parents=True, exist_ok=True)
+            body = r.body()
+            out.write_bytes(body)
+            if out.suffix in TEXT_TYPES:
+                todo |= refs(body.decode("utf-8", "ignore"), key, host) - done
+        req.dispose()
+
+    log(f"  mirrored {saved_pages} pages, {len(done) - len(failures)} assets")
+    return saved_pages, len(done), failures

perfectclone/serve.py

@@ -0,0 +1,102 @@
+"""Serve a clone locally the way a static host would."""
+import functools
+import http.server
+import io
+import os
+import re
+from pathlib import Path
+from urllib.parse import parse_qs, unquote, urlparse
+
+from .util import site_dir
+
+RANGE = re.compile(r"bytes=(\d*)-(\d*)$")
+
+
+class Handler(http.server.SimpleHTTPRequestHandler):
+    extensions_map = {**http.server.SimpleHTTPRequestHandler.extensions_map, ".rsc": "text/x-component"}
+
+    def end_headers(self):
+        self.send_header("Accept-Ranges", "bytes")
+        super().end_headers()
+
+    def send_head(self):
+        self.redirect_to = None
+        self.route()
+        if self.redirect_to:
+            self.send_response(302)
+            self.send_header("Location", self.redirect_to)
+            self.end_headers()
+            return None
+        if self.headers.get("Range"):
+            return self.send_range()
+        return super().send_head()
+
+    def send_range(self):
+        # Safari only plays <video> from servers that answer byte-range requests with 206.
+        path = self.translate_path(self.path)
+        m = RANGE.match(self.headers["Range"].strip())
+        if not m or not os.path.isfile(path) or m.group(1) == m.group(2) == "":
+            return super().send_head()
+        size = os.path.getsize(path)
+        if m.group(1):
+            start, end = int(m.group(1)), min(int(m.group(2) or size - 1), size - 1)
+        else:
+            start, end = max(size - int(m.group(2)), 0), size - 1
+        if start > end:
+            self.send_response(416)
+            self.send_header("Content-Range", f"bytes */{size}")
+            self.end_headers()
+            return None
+        with open(path, "rb") as f:
+            f.seek(start)
+            body = f.read(end - start + 1)
+        self.send_response(206)
+        self.send_header("Content-Type", self.guess_type(path))
+        self.send_header("Content-Range", f"bytes {start}-{end}/{size}")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        return io.BytesIO(body)
+
+    def route(self):
+        """Map the request onto a file the way a static host would."""
+        url = urlparse(self.path)
+        if "_rsc" in parse_qs(url.query) or self.headers.get("RSC") == "1":
+            rsc = Path(self.directory) / unquote(url.path).strip("/") / "index.rsc"
+            if rsc.is_file():
+                self.path = url.path.rstrip("/") + "/index.rsc"
+                return
+        if url.path == "/_next/image":
+            # The mirror keeps original images, not optimizer output. Remote originals (a CMS
+            # CDN) were never on the site, so the browser is sent to them.
+            src = parse_qs(url.query).get("url", [""])[0]
+            if src.startswith(("http://", "https://")):
+                self.redirect_to = src
+            elif src.startswith("/"):
+                self.path = src
+        elif not Path(url.path).suffix:
+            local = Path(self.directory) / unquote(url.path).lstrip("/")
+            if (local / "index.html").is_file():
+                self.path = url.path.rstrip("/") + "/index.html"
+
+    def log_message(self, fmt, *args):
+        if args and str(args[1]).startswith(("4", "5")):
+            super().log_message(fmt, *args)
+
+
+def serve(path, port=8000):
+    site = site_dir(path)
+    handler = functools.partial(Handler, directory=str(site.resolve()))
+    for attempt in range(port, port + 20):
+        try:
+            httpd = http.server.ThreadingHTTPServer(("127.0.0.1", attempt), handler)
+            break
+        except OSError:
+            continue
+    else:
+        raise SystemExit(f"No free port between {port} and {port + 19}.")
+    with httpd:
+        print(f"Serving {site} at http://localhost:{attempt}  (Ctrl+C to stop)")
+        try:
+            httpd.serve_forever()
+        except KeyboardInterrupt:
+            pass

perfectclone/trackers.py

@@ -0,0 +1,93 @@
+"""Remove the original owner's analytics and ad pixels, which would otherwise report a clone's
+visitors to their accounts. Next.js next/script trackers exist only in the flight payload.
+"""
+import re
+
+from .flight import edit_json_rows, has_flight, json_row_editor, map_rows, outside_flight
+from .util import text_files
+
+SIGNATURES = re.compile(
+    r"googletagmanager\.com|google-analytics\.com|\bgtag\(|\bga\(['\"]|doubleclick\.net"
+    r"|connect\.facebook\.net|facebook\.com/tr|\bfbq\("
+    r"|_linkedin_partner_id|snap\.licdn\.com|px\.ads\.linkedin\.com"
+    r"|static\.hotjar\.com|\bhj\(|clarity\.ms"
+    r"|cdn\.segment\.com|analytics\.load\("
+    r"|reb2b|ddwl4m2hdecbv\.cloudfront\.net"
+    r"|posthog|plausible\.io|cdn\.mxpnl\.com|mixpanel"
+    r"|js\.hs-scripts\.com|js\.hs-analytics\.net|hs-banner"
+    r"|analytics\.tiktok\.com|\bttq\.|bat\.bing\.com|\buetq\b"
+    r"|static\.ads-twitter\.com|\btwq\(|redditstatic\.com/ads|\brdt\("
+    r"|static\.cloudflareinsights\.com|data-cf-beacon"
+    r"|cdn\.amplitude\.com|heapanalytics|fullstory\.com|\bFS\.identify|cdn\.lr-ingest|logrocket",
+    re.I,
+)
+
+# Script loaders that bundles inject at runtime (e.g. a GoogleTagManager React component).
+# Pointing them at a data: URL holding a JS comment lets the injecting code run untouched
+# while nothing loads. Beacon/collect endpoints are left alone: rewriting those can throw.
+LOADER = re.compile(
+    r"(?:https?:)?//(?:www\.)?(?:googletagmanager\.com/(?:gtm|gtag/js)|connect\.facebook\.net/[\w_]+/fbevents\.js"
+    r"|snap\.licdn\.com/li\.lms-analytics/insight\.min\.js|static\.hotjar\.com/c/hotjar-|www\.clarity\.ms/tag/"
+    r"|cdn\.segment\.com/analytics\.js|js\.hs-scripts\.com/|static\.cloudflareinsights\.com/beacon"
+    r"|ddwl4m2hdecbv\.cloudfront\.net/b/|plausible\.io/js/|cdn\.amplitude\.com/|cdn\.mxpnl\.com/"
+    r"|analytics\.tiktok\.com/i18n/pixel|static\.ads-twitter\.com/uwt\.js|bat\.bing\.com/bat\.js)"
+)
+SCRIPT = re.compile(r"<script\b[^>]*>.*?</script>", re.S | re.I)
+NOSCRIPT = re.compile(r"<noscript\b[^>]*>.*?</noscript>", re.S | re.I)
+HINT = re.compile(r"<link\b[^>]*rel=[\"']?(?:preload|preconnect|dns-prefetch|prefetch)[^>]*>", re.I)
+
+
+def _strip_html(text):
+    def drop(m):
+        tag = m.group(0)
+        if "__next_f" in tag or "application/ld+json" in tag:
+            return tag
+        return "" if SIGNATURES.search(tag) else tag
+
+    def empty(m):
+        # The element may be part of a React tree, so removing it breaks hydration. React never
+        # hydrates noscript children, so emptying it is safe and stops the no-JS pixel.
+        tag = m.group(0)
+        return tag[: tag.index(">") + 1] + "</noscript>" if SIGNATURES.search(tag) else tag
+
+    text = SCRIPT.sub(drop, text)
+    text = NOSCRIPT.sub(empty, text)
+    return HINT.sub(drop, text)
+
+
+def _is_tracker_element(node):
+    """A React element ["$", type, key, props] for a script whose src/id/body is a tracker."""
+    if not (isinstance(node, list) and len(node) == 4 and node[0] == "$" and isinstance(node[3], dict)):
+        return False
+    props = node[3]
+    is_script = node[1] == "script" or "strategy" in props            # next/script carries strategy
+    if not is_script:
+        return False
+    body = " ".join(str(props.get(k, "")) for k in ("src", "id", "children"))
+    body += str((props.get("dangerouslySetInnerHTML") or {}).get("__html", ""))
+    return bool(SIGNATURES.search(body))
+
+
+def _drop(node):
+    return None if _is_tracker_element(node) else node
+
+
+def strip(site, log=print):
+    changed = 0
+    for p in text_files(site):
+        text = p.read_text(errors="surrogateescape")
+        suffix = p.suffix.lower()
+        if suffix in (".js", ".mjs"):
+            new = LOADER.sub(lambda m: "data:text/javascript,//" + m.group(0).split("//", 1)[1], text)
+        elif suffix == ".rsc":
+            new = map_rows(text, json_row_editor(_drop))
+        elif suffix in (".html", ".htm"):
+            new = outside_flight(edit_json_rows(text, _drop), _strip_html) if has_flight(text) else _strip_html(text)
+            changed += new != text
+        else:
+            continue
+        if new != text:
+            p.write_text(new, errors="surrogateescape")
+    if changed:
+        log(f"  removed trackers from {changed} pages")
+    return changed

perfectclone/util.py

@@ -0,0 +1,25 @@
+"""Helpers shared by the crawler, mirror, editors and server."""
+from pathlib import Path
+from urllib.parse import urlparse
+
+UA = ("Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) "
+      "Chrome/130.0 Safari/537.36 perfectclone")
+TEXT_TYPES = {".html", ".htm", ".js", ".mjs", ".css", ".json", ".xml", ".txt", ".svg", ".webmanifest", ".rsc"}
+
+
+def host_of(url):
+    return urlparse(url).netloc.lower().removeprefix("www.")
+
+
+def text_files(site):
+    for p in Path(site).rglob("*"):
+        if p.is_file() and p.suffix.lower() in TEXT_TYPES:
+            yield p
+
+
+def site_dir(path):
+    """Accept a clone folder (with site/ inside) or the site folder itself."""
+    p = Path(path)
+    if not (p / "index.html").exists() and (p / "site" / "index.html").exists():
+        p = p / "site"
+    return p

perfectclone-0.1.0.dist-info/METADATA

@@ -0,0 +1,192 @@
+Metadata-Version: 2.4
+Name: perfectclone
+Version: 0.1.0
+Summary: Clone any website 1:1 with a real browser, then edit it safely.
+Author: Eshaan Gulati
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/eshaangulati123/perfectclone-website-cloner
+Project-URL: Issues, https://github.com/eshaangulati123/perfectclone-website-cloner/issues
+Project-URL: Changelog, https://github.com/eshaangulati123/perfectclone-website-cloner/blob/main/CHANGELOG.md
+Keywords: website cloner,clone website,website copier,website mirror,playwright,nextjs,httrack alternative,web scraping
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Internet :: WWW/HTTP :: Site Management
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: playwright>=1.40
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pillow; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Dynamic: license-file
+
+# perfectclone: website cloner that copies the real site, 1:1
+
+**Pull the real frontend of any public site in ~15 seconds. No AI, no tokens.**
+
+![Clone any website. Get the real files. huly.io cloned with perfectclone: 0.00% pixel difference, 14 seconds, 157 files, 0 LLM calls.](https://raw.githubusercontent.com/eshaangulati123/perfectclone-website-cloner/main/docs/images/huly-live-vs-clone.jpg)
+
+perfectclone clones any website 1:1. It crawls the site with a real browser (Playwright),
+downloads the site's own HTML, JavaScript, CSS, fonts and images, and gives you a folder you can
+serve, edit and deploy. Then it lets you rebrand it, rehost it and strip the original owner's
+trackers without breaking it, including Next.js sites that hydrate on load.
+
+```bash
+pip install perfectclone
+
+perfectclone clone example.com
+perfectclone serve example.com             # → http://localhost:8000
+```
+
+That's it. Chromium is downloaded automatically the first time you clone. Requires Python 3.10+.
+
+Or try it without installing anything, using [uv](https://docs.astral.sh/uv/):
+
+```bash
+uvx perfectclone clone example.com
+```
+
+## Why not an AI cloner?
+
+Most "clone any website" tools today regenerate the site: an AI agent looks at screenshots or
+scraped markup, writes a new React/Next.js app, and compares the result against the original
+with a visual-similarity score until it's close enough. That gets you a lookalike. The code is
+new, the behaviour is approximate, and there are always gaps.
+
+perfectclone doesn't regenerate anything. It mirrors the bytes the site actually serves, so
+the clone *is* the site: same markup, same bundles, same animations, same JavaScript running.
+Sometimes the real solution is the simple one.
+
+|                                         | AI cloners | wget / HTTrack | perfectclone |
+| --------------------------------------- | :--------: | :------------: | :----------: |
+| Copies the site's real files            | ❌         | ✅             | ✅           |
+| Pixel-identical on modern JS sites      | ❌         | ❌             | ✅           |
+| Catches lazy-loaded JS, fonts, images   | —          | ❌             | ✅           |
+| React / Next.js sites still run         | —          | ❌             | ✅           |
+| Rebrand without breaking the site       | ✅         | ⚠️             | ✅           |
+| Strips the original site's trackers     | —          | ❌             | ✅           |
+| Works without an LLM or API key         | ❌         | ✅             | ✅           |
+
+## Tested on real sites
+
+Each card is one site split down the middle: the live site on the left, the clone on the right.
+
+![Live vs clone split view for nextjs.org, astro.build, svelte.dev, vitepress.dev, docusaurus.io and wordpress.org](https://raw.githubusercontent.com/eshaangulati123/perfectclone-website-cloner/main/docs/images/compatibility.jpg)
+
+`scripts/compat.py` clones each site, serves the copy, and compares its home page with the live
+one at 1440×900, with animations and videos paused on the same frame:
+
+| Site | Built with | Pixel match | Hydration errors | Notes |
+| --- | --- | --- | --- | --- |
+| huly.io | Next.js | 100% | 0 | |
+| nextjs.org | Next.js | 100% | 0 | |
+| astro.build | Astro | 100% | 0 | |
+| svelte.dev | SvelteKit | 100% | 0 | |
+| vitepress.dev | VitePress (Vue) | 100% | 0 | |
+| docusaurus.io | Docusaurus (React) | 100% | 0 | |
+| wordpress.org/news | WordPress | 100% | 0 | |
+| paulgraham.com | Hand-written HTML | 100% | 0 | |
+| example.com | Static HTML | 100% | 0 | |
+| framer.com | Framer | 96% | 0 | Cookie banner needs Framer's backend |
+| webflow.com | Webflow | 93% | 0 | Cookie banner won't run on localhost; carousel caught mid-scroll |
+
+Every clone loaded with zero requests to trackers. Run it yourself with
+`python scripts/compat.py`, and please open an issue for any site that doesn't come out right.
+
+## Commands
+
+```bash
+perfectclone clone <url> [-o out] [--max-pages 200] [--extract] [--keep-trackers] [--ignore-robots]
+perfectclone serve <site> [-p 8000]
+perfectclone replace <site> <old> <new> [--exact-case] [--substring]
+perfectclone rehost <site> <old-origin> <new-origin>
+perfectclone strip-trackers <site>
+```
+
+- **clone** writes `out/site/` (the working copy) and `out/manifest.json` (pages, failures,
+  third-party hosts the site uses). `--extract` also saves each page's text, metadata
+  (headings, links, images, forms, JSON-LD) and a full-page screenshot to `out/extract/`.
+  Trackers are stripped by default.
+- **replace** renames text everywhere: HTML, JS, CSS, JSON, SVG. It also handles the UPPER,
+  lower and Capitalized variants, and leaves URLs and asset paths alone so nothing 404s.
+- **rehost** points canonical, Open Graph, JSON-LD and sitemap URLs at your domain.
+- **serve** works like a static host: clean URLs (`/about` → `/about/index.html`), and
+  `/_next/image` requests are served from the mirrored originals.
+
+Rebrand a clone and put it online:
+
+```bash
+perfectclone clone acme.com -o acme
+perfectclone replace acme "Acme" "Globex"
+perfectclone rehost  acme https://acme.com https://globex.com
+npx netlify-cli deploy --dir acme/site --prod      # or any static host
+```
+
+## How it works
+
+1. **Crawl with a real browser.** Each page is rendered in Chromium and scrolled to the bottom,
+   and every response is recorded. That catches what static mirrors miss: code-split JS chunks,
+   fonts requested from CSS, images behind lazy loading. Links are followed breadth-first,
+   seeded from the sitemap. robots.txt is respected unless you pass `--ignore-robots`.
+2. **Mirror the server's bytes.** Pages are saved as the HTML the *server* sends, not the
+   rendered DOM, because that's what the site's JavaScript expects to hydrate. Assets keep
+   their URL paths, and CSS/JS are scanned for further references (`url()`, `srcset`, chunk
+   paths) until nothing new turns up.
+3. **Edit without breaking hydration.** A Next.js App Router page ships its HTML *and* a
+   serialized copy of the React tree in `self.__next_f.push(...)` script chunks. Change one and
+   not the other, and React throws a hydration error and re-renders from the payload, undoing
+   your edit. perfectclone decodes the payload stream, edits it row by row, recomputes the
+   UTF-8 byte lengths of length-prefixed text rows (`<id>:T<hex>,…`), rejoins rows that span
+   chunks, and writes it back next to the matching HTML edit.
+4. **Strip trackers.** Google Analytics/Tag Manager, the Meta pixel, LinkedIn Insight, Hotjar,
+   Clarity, Segment, PostHog, HubSpot, TikTok, Reddit, X, Cloudflare Web Analytics, RB2B and
+   more. They're removed from `<script>`/`<noscript>` tags, from preload hints, and from Next.js
+   `next/script` elements that only exist in the payload.
+
+## Limits
+
+- **No backend.** Forms, logins, search and API calls still go to the original servers (or
+  fail). perfectclone copies the front end.
+- **Next.js client-side navigation** needs each page's RSC payload answered for `?_rsc=`
+  requests. perfectclone mirrors them and `perfectclone serve` routes them. On a plain static
+  host, internal links fall back to full page loads: everything still works, just without the
+  instant transitions.
+- **Chunks that are only requested after a click** (say, a modal's code) are captured if the
+  crawl triggered them or a bundle names them as a string. A bundle can also assemble a chunk
+  URL at runtime, and that one may be missed.
+- **Bot protection** (CAPTCHAs, aggressive Cloudflare rules) can block the crawl. perfectclone
+  does not try to get around it.
+- Embeds (YouTube, Cal.com, maps) and third-party CDNs keep loading from their own hosts.
+
+## Roadmap
+
+**Clone apps behind a login, like dashboards.** Today perfectclone sees what an anonymous visitor
+sees, and data that loads from APIs after the page renders isn't kept. The plan, for apps you
+have an account on:
+
+- **Crawl as you.** Sign in once in a browser window; perfectclone saves the session and
+  crawls with it.
+- **Record API responses.** Keep every JSON response the app fetches during the crawl and have
+  `perfectclone serve` replay them, so charts, tables and lists show real data offline.
+- **Explore by clicking.** Click through navigation, tabs and menus to reach views that only
+  exist in client-side routing.
+
+The result is a clickable snapshot of the UI and its data at capture time. Saving, server-side
+filtering and live updates still need the real backend.
+
+Other ideas: hydration-aware editing for Nuxt, SvelteKit and Remix payloads, and a deploy
+helper that writes `_redirects` / `vercel.json` rules so `?_rsc=` and `/_next/image` work on
+static hosts. Contributions welcome.
+
+## Contributing
+
+perfectclone is open source under the [MIT License](https://github.com/eshaangulati123/perfectclone-website-cloner/blob/main/LICENSE). Issues and pull requests are
+welcome, especially reports of sites that don't clone cleanly. See
+[CONTRIBUTING.md](https://github.com/eshaangulati123/perfectclone-website-cloner/blob/main/CONTRIBUTING.md), and please follow the [Code of Conduct](https://github.com/eshaangulati123/perfectclone-website-cloner/blob/main/CODE_OF_CONDUCT.md).
+Report security issues privately as described in [SECURITY.md](https://github.com/eshaangulati123/perfectclone-website-cloner/blob/main/SECURITY.md).

perfectclone-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+perfectclone/__init__.py,sha256=OzRJ-OIbvZh0GkFQNI-zusuLMG2mQf6pBE4rog5s7VE,92
+perfectclone/__main__.py,sha256=bYt9eEaoRQWdejEHFD8REx9jxVEdZptECFsV7F49Ink,30
+perfectclone/cli.py,sha256=OpeqoM0LiKTggYyDICeAsXvf6RaIrSJ_WUGwnw5UkHc,4076
+perfectclone/crawl.py,sha256=npHfsfXe70W-dBp1_I5ZTyZcNPonfHHRtPSjMnHPkgs,6805
+perfectclone/edit.py,sha256=RGaJhjn3G-lS019XEk3YaHNot5AA5CJA6o2O4EU6VNg,4371
+perfectclone/flight.py,sha256=qkSWXroSA3DYg9Jcssb4VLf1MkEMmF-28pnKfShP_JQ,4090
+perfectclone/mirror.py,sha256=UYysFF989L-8ZGfbuAhCeXcDGe4iMSMbADJa8jNNe1A,7597
+perfectclone/serve.py,sha256=jVd7x-bLA7XWi19pb8-41Gv0UIKPMVXMuHI1hHDYd2M,3858
+perfectclone/trackers.py,sha256=69e5sekSoqPCynq9pWcF1MzV_tGdrtJOCn4nFeCkSyA,4281
+perfectclone/util.py,sha256=fL_ScJrVAyPVzisGgNycUnxQWszd_vY8lk5ynWuv6OA,838
+perfectclone-0.1.0.dist-info/licenses/LICENSE,sha256=j-vFyE02_F_CtlA090nue9I-GFoKFZwRDwOkacWHqSw,1070
+perfectclone-0.1.0.dist-info/METADATA,sha256=m0lurcj9VFN-55UvG0ec9VTQyqFz7pGQPrsO-ip5JMg,10587
+perfectclone-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+perfectclone-0.1.0.dist-info/entry_points.txt,sha256=rmTjd89EiWV2naTFIq54mx27rgSrILo_dZCckMtHung,55
+perfectclone-0.1.0.dist-info/top_level.txt,sha256=Wt4oOBaA8l6KXOom0LmjA9dVJB2mSbHyw061Q-FaoCA,13
+perfectclone-0.1.0.dist-info/RECORD,,

perfectclone-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

perfectclone-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+perfectclone = perfectclone.cli:main

perfectclone-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Eshaan Gulati
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

perfectclone-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+perfectclone