evo-cli 0.1.11__tar.gz → 0.2.0__tar.gz

{evo_cli-0.1.11 → evo_cli-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo_cli
-Version: 0.1.11
+Version: 0.2.0
 Summary: Evolution CLI - a developer toolbox for setting up dev machines
 Author: maycuatroi
 Project-URL: Homepage, https://github.com/maycuatroi/evo-cli

evo_cli-0.2.0/evo_cli/VERSION

@@ -0,0 +1 @@
+0.2.0

{evo_cli-0.1.11 → evo_cli-0.2.0}/evo_cli/cli.py

@@ -3,7 +3,9 @@ import rich_click as click
 from evo_cli import __version__
 from evo_cli.commands.cloudflare import cfssh
 from evo_cli.commands.fix_claude import f_claude
+from evo_cli.commands.gdrive import gdrive
 from evo_cli.commands.miniconda import miniconda
+from evo_cli.commands.site2s import site2s
 from evo_cli.commands.ssh import setupssh
 
 click.rich_click.USE_MARKDOWN = True
@@ -31,6 +33,8 @@ cli.add_command(setupssh)
 cli.add_command(miniconda)
 cli.add_command(cfssh)
 cli.add_command(f_claude)
+cli.add_command(gdrive)
+cli.add_command(site2s)
 
 
 def main():

evo_cli-0.2.0/evo_cli/commands/gdrive.py

@@ -0,0 +1,528 @@
+import base64
+import json
+import mimetypes
+import os
+import re
+import sys
+import tempfile
+import urllib.error
+import urllib.parse
+import urllib.request
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+import rich_click as click
+from rich.text import Text
+
+from evo_cli.console import error, info, step, success, warning
+
+CONFIG_PATH = Path(os.environ.get("OMELET_CONFIG", str(Path.home() / ".omelet.json")))
+TOKEN_URL = "https://oauth2.googleapis.com/token"
+DOCS_API = "https://docs.googleapis.com/v1/documents/{doc_id}"
+DRIVE_FILE_API = "https://www.googleapis.com/drive/v3/files/{file_id}"
+DRIVE_EXPORT_API = "https://www.googleapis.com/drive/v3/files/{file_id}/export"
+
+DOC_ID_RE = re.compile(r"/document/d/([a-zA-Z0-9_-]+)")
+RAW_ID_RE = re.compile(r"^[a-zA-Z0-9_-]{20,}$")
+MD_INLINE_IMAGE_RE = re.compile(r"!\[([^\]]*)\]\((https?://[^)\s]+)\)")
+MD_REF_IMAGE_RE = re.compile(r"!\[([^\]]*)\]\[([^\]]+)\]")
+MD_REF_DEF_RE = re.compile(r"^\[([^\]]+)\]:\s*<?([^>\s]+)>?\s*$", re.MULTILINE)
+DATA_URI_RE = re.compile(r"^data:([^;,]+)(?:;([^,]+))?,(.*)$", re.DOTALL)
+
+EPILOG = Text.from_markup(
+    "[bold]Examples[/bold]\n\n"
+    "  [cyan]evo gdrive doc-read <url>[/cyan]                read doc, write `<title>/doc.md` + `<title>/images/`\n"
+    "  [cyan]evo gdrive doc-read <url> -o ./out[/cyan]      write into ./out instead\n"
+    "  [cyan]evo gdrive doc-read <id> --no-images[/cyan]    skip image download\n"
+    "  [cyan]evo gdrive doc-read <url> --via-docs-api[/cyan] use Docs API (needs Docs API enabled in the OAuth project)\n"
+    "  [cyan]evo gdrive doc-read <url> --raw[/cyan]         also dump the raw API response"
+)
+
+
+def extract_doc_id(value):
+    match = DOC_ID_RE.search(value)
+    if match:
+        return match.group(1)
+    if RAW_ID_RE.match(value):
+        return value
+    return None
+
+
+def read_config():
+    if not CONFIG_PATH.exists():
+        raise click.ClickException(f"config not found: {CONFIG_PATH}")
+    return json.loads(CONFIG_PATH.read_text(encoding="utf-8"))
+
+
+def write_config(data):
+    tmp = tempfile.NamedTemporaryFile("w", delete=False, dir=str(CONFIG_PATH.parent), encoding="utf-8")
+    try:
+        json.dump(data, tmp, indent=2, ensure_ascii=False)
+        tmp.write("\n")
+        tmp.close()
+        os.chmod(tmp.name, 0o600)
+        os.replace(tmp.name, CONFIG_PATH)
+    except Exception:
+        if os.path.exists(tmp.name):
+            os.unlink(tmp.name)
+        raise
+
+
+def token_expired(token_section):
+    expiry = token_section.get("expiry")
+    if not expiry:
+        return True
+    try:
+        when = datetime.fromisoformat(expiry)
+    except ValueError:
+        return True
+    if when.tzinfo is None:
+        when = when.replace(tzinfo=timezone.utc)
+    now = datetime.now(timezone.utc)
+    return (when - now).total_seconds() < 60
+
+
+def refresh_token(data):
+    rclone_section = data.get("rclone", {})
+    token_section = rclone_section.get("token", {})
+    refresh = token_section.get("refresh_token")
+    if not refresh:
+        raise click.ClickException("rclone.token.refresh_token missing in config")
+
+    client_id = os.environ.get("RCLONE_DRIVE_CLIENT_ID") or rclone_section.get("client_id")
+    client_secret = os.environ.get("RCLONE_DRIVE_CLIENT_SECRET") or rclone_section.get("client_secret")
+    if not client_id or not client_secret:
+        raise click.ClickException(
+            "OAuth client credentials required. Set RCLONE_DRIVE_CLIENT_ID + RCLONE_DRIVE_CLIENT_SECRET "
+            "or add rclone.client_id + rclone.client_secret to the config."
+        )
+
+    payload = urllib.parse.urlencode(
+        {
+            "client_id": client_id,
+            "client_secret": client_secret,
+            "refresh_token": refresh,
+            "grant_type": "refresh_token",
+        }
+    ).encode("utf-8")
+    req = urllib.request.Request(TOKEN_URL, data=payload, method="POST")
+    req.add_header("Content-Type", "application/x-www-form-urlencoded")
+
+    try:
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            body = json.loads(resp.read().decode("utf-8"))
+    except urllib.error.HTTPError as exc:
+        err_body = exc.read().decode("utf-8", "replace")
+        raise click.ClickException(f"token refresh failed: HTTP {exc.code} {err_body}") from exc
+
+    access = body.get("access_token")
+    if not access:
+        raise click.ClickException(f"no access_token in refresh response: {body}")
+
+    expires_in = int(body.get("expires_in", 3600))
+    tz = timezone(timedelta(hours=7))
+    expiry = (datetime.now(tz) + timedelta(seconds=expires_in)).isoformat()
+
+    data["rclone"]["token"]["access_token"] = access
+    data["rclone"]["token"]["expiry"] = expiry
+    data["rclone"]["token"]["expires_in"] = expires_in
+    write_config(data)
+    info(f"Refreshed Drive access token (valid until [accent]{expiry}[/accent])")
+    return access
+
+
+def access_token():
+    data = read_config()
+    token_section = data.get("rclone", {}).get("token", {})
+    token = token_section.get("access_token")
+    if not token or token_expired(token_section):
+        info("Access token missing or expired - refreshing.")
+        token = refresh_token(data)
+    return token
+
+
+def http_get(url, token=None, timeout=120):
+    req = urllib.request.Request(url, method="GET")
+    if token:
+        req.add_header("Authorization", f"Bearer {token}")
+    req.add_header("User-Agent", "evo-cli")
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            return resp.read(), dict(resp.headers)
+    except urllib.error.HTTPError as exc:
+        err_body = exc.read().decode("utf-8", "replace")
+        raise click.ClickException(f"GET {url} failed: HTTP {exc.code} {err_body}") from exc
+
+
+def safe_filename(name):
+    cleaned = re.sub(r"[^a-zA-Z0-9._-]+", "_", name).strip("._-")
+    return cleaned or "image"
+
+
+def guess_image_ext(content_type, fallback="png"):
+    if content_type:
+        ext = mimetypes.guess_extension(content_type.split(";")[0].strip()) or ""
+        ext = ext.lstrip(".")
+        if ext == "jpe":
+            ext = "jpg"
+        if ext:
+            return ext
+    return fallback
+
+
+def download_image(url, dest_path, token=None):
+    headers = {"User-Agent": "evo-cli"}
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+    req = urllib.request.Request(url, headers=headers)
+    try:
+        with urllib.request.urlopen(req, timeout=120) as resp:
+            content_type = resp.headers.get("Content-Type", "")
+            body = resp.read()
+    except urllib.error.HTTPError as exc:
+        raise click.ClickException(f"image download failed: HTTP {exc.code} {url}") from exc
+    if not dest_path.suffix:
+        dest_path = dest_path.with_suffix(f".{guess_image_ext(content_type)}")
+    dest_path.write_bytes(body)
+    return dest_path
+
+
+def fetch_file_metadata(file_id, token):
+    url = DRIVE_FILE_API.format(file_id=file_id) + "?" + urllib.parse.urlencode(
+        {"fields": "id,name,mimeType,modifiedTime"}
+    )
+    body, _ = http_get(url, token=token)
+    return json.loads(body.decode("utf-8"))
+
+
+def parse_filename_from_disposition(headers):
+    disp = headers.get("Content-Disposition") or headers.get("content-disposition") or ""
+    match = re.search(r"filename\*=UTF-8''([^;]+)", disp)
+    if match:
+        return urllib.parse.unquote(match.group(1).strip().strip('"'))
+    match = re.search(r'filename="?([^";]+)"?', disp)
+    if match:
+        return match.group(1).strip()
+    return None
+
+
+def drive_export_markdown(file_id, token):
+    url = DRIVE_EXPORT_API.format(file_id=file_id) + "?" + urllib.parse.urlencode({"mimeType": "text/markdown"})
+    body, headers = http_get(url, token=token)
+    return body.decode("utf-8"), parse_filename_from_disposition(headers)
+
+
+def fetch_document(doc_id, token):
+    body, _ = http_get(DOCS_API.format(doc_id=doc_id), token=token)
+    return json.loads(body.decode("utf-8"))
+
+
+def render_text_run(text_run):
+    content = text_run.get("content", "")
+    if not content:
+        return ""
+    style = text_run.get("textStyle") or {}
+    link = (style.get("link") or {}).get("url")
+    trailing_newline = content.endswith("\n")
+    body = content[:-1] if trailing_newline else content
+    if not body.strip():
+        return content
+    if style.get("bold"):
+        body = f"**{body}**"
+    if style.get("italic"):
+        body = f"*{body}*"
+    if style.get("strikethrough"):
+        body = f"~~{body}~~"
+    if style.get("underline") and not link:
+        body = f"<u>{body}</u>"
+    if link:
+        body = f"[{body}]({link})"
+    return body + ("\n" if trailing_newline else "")
+
+
+def heading_prefix(named_style):
+    if not named_style:
+        return ""
+    if named_style == "TITLE":
+        return "# "
+    match = re.match(r"HEADING_(\d)", named_style)
+    if match:
+        level = max(1, min(6, int(match.group(1))))
+        return "#" * level + " "
+    return ""
+
+
+def bullet_prefix(paragraph, list_props_by_id):
+    bullet = paragraph.get("bullet")
+    if not bullet:
+        return None
+    nesting = bullet.get("nestingLevel", 0)
+    indent = "  " * nesting
+    list_props = list_props_by_id.get(bullet.get("listId"), {})
+    nesting_levels = list_props.get("nestingLevels", [])
+    glyph_type = None
+    if 0 <= nesting < len(nesting_levels):
+        glyph_type = nesting_levels[nesting].get("glyphType")
+    if glyph_type and glyph_type != "GLYPH_TYPE_UNSPECIFIED":
+        return f"{indent}1. "
+    return f"{indent}- "
+
+
+def render_paragraph(paragraph, inline_objects, list_props_by_id, image_resolver):
+    elements = paragraph.get("elements") or []
+    style = paragraph.get("paragraphStyle") or {}
+    prefix = heading_prefix(style.get("namedStyleType"))
+    bullet = bullet_prefix(paragraph, list_props_by_id)
+    parts = []
+    for element in elements:
+        if "textRun" in element:
+            parts.append(render_text_run(element["textRun"]))
+        elif "inlineObjectElement" in element:
+            obj_id = element["inlineObjectElement"].get("inlineObjectId")
+            obj = inline_objects.get(obj_id, {})
+            embedded = (obj.get("inlineObjectProperties") or {}).get("embeddedObject") or {}
+            image_props = embedded.get("imageProperties") or {}
+            content_uri = image_props.get("contentUri")
+            alt = embedded.get("title") or embedded.get("description") or obj_id or "image"
+            if content_uri and image_resolver:
+                rel = image_resolver(obj_id, content_uri)
+                if rel:
+                    parts.append(f"![{alt}]({rel})")
+                    continue
+            parts.append(f"![{alt}]()")
+        elif "horizontalRule" in element:
+            parts.append("\n---\n")
+        elif "pageBreak" in element:
+            parts.append("\n\n---\n\n")
+    text = "".join(parts)
+    if bullet is not None:
+        text = bullet + text.lstrip()
+    elif prefix:
+        text = prefix + text.lstrip()
+    return text
+
+
+def render_table(table, inline_objects, list_props_by_id, image_resolver):
+    rows = table.get("tableRows") or []
+    if not rows:
+        return ""
+    rendered_rows = []
+    for row in rows:
+        cells = row.get("tableCells") or []
+        rendered_cells = []
+        for cell in cells:
+            cell_parts = []
+            for element in cell.get("content") or []:
+                if "paragraph" in element:
+                    cell_parts.append(
+                        render_paragraph(
+                            element["paragraph"], inline_objects, list_props_by_id, image_resolver
+                        ).strip()
+                    )
+            rendered_cells.append(" ".join(p for p in cell_parts if p).replace("|", "\\|"))
+        rendered_rows.append("| " + " | ".join(rendered_cells) + " |")
+    if rendered_rows:
+        header_cells = rendered_rows[0].count("|") - 1
+        separator = "| " + " | ".join(["---"] * max(1, header_cells)) + " |"
+        return "\n".join([rendered_rows[0], separator, *rendered_rows[1:]]) + "\n"
+    return ""
+
+
+def document_to_markdown(document, image_resolver):
+    body = document.get("body") or {}
+    content = body.get("content") or []
+    inline_objects = document.get("inlineObjects") or {}
+    list_props_by_id = {
+        lid: lst.get("listProperties") or {} for lid, lst in (document.get("lists") or {}).items()
+    }
+    title = document.get("title") or "Document"
+    out_parts = [f"# {title}\n"]
+    for element in content:
+        if "paragraph" in element:
+            text = render_paragraph(element["paragraph"], inline_objects, list_props_by_id, image_resolver)
+            if text.strip():
+                out_parts.append(text.rstrip() + "\n")
+        elif "table" in element:
+            out_parts.append(render_table(element["table"], inline_objects, list_props_by_id, image_resolver))
+    return "\n".join(part for part in out_parts if part).rstrip() + "\n"
+
+
+def build_image_resolver(inline_objects, out_dir, no_images):
+    if no_images or not inline_objects:
+        return None
+    images_dir = out_dir / "images"
+    images_dir.mkdir(parents=True, exist_ok=True)
+    cache = {}
+
+    def resolver(obj_id, content_uri):
+        if obj_id in cache:
+            return cache[obj_id]
+        dest = images_dir / safe_filename(obj_id)
+        try:
+            written = download_image(content_uri, dest)
+        except click.ClickException as exc:
+            warning(str(exc))
+            cache[obj_id] = None
+            return None
+        rel = f"images/{written.name}"
+        cache[obj_id] = rel
+        info(f"Saved image [accent]{rel}[/accent]")
+        return rel
+
+    return resolver
+
+
+def save_data_uri(data_uri, dest_no_ext):
+    match = DATA_URI_RE.match(data_uri)
+    if not match:
+        return None
+    mime, encoding, payload = match.group(1), match.group(2) or "", match.group(3)
+    if "base64" in encoding.lower():
+        body = base64.b64decode(payload)
+    else:
+        body = urllib.parse.unquote_to_bytes(payload)
+    ext = guess_image_ext(mime)
+    dest = dest_no_ext.with_suffix(f".{ext}")
+    dest.write_bytes(body)
+    return dest
+
+
+def materialize_image(source_url, dest_no_ext, token):
+    if source_url.startswith("data:"):
+        return save_data_uri(source_url, dest_no_ext)
+    use_token = token if "googleapis.com" in source_url else None
+    return download_image(source_url, dest_no_ext, token=use_token)
+
+
+def download_markdown_images(markdown, out_dir, token):
+    images_dir = out_dir / "images"
+    cache = {}
+    index = [0]
+
+    def next_dest():
+        index[0] += 1
+        images_dir.mkdir(parents=True, exist_ok=True)
+        return images_dir / f"image_{index[0]:03d}"
+
+    ref_defs = {}
+    for match in MD_REF_DEF_RE.finditer(markdown):
+        ref_defs[match.group(1)] = match.group(2)
+
+    def resolve(url, alt_for_log):
+        if url in cache:
+            return cache[url]
+        try:
+            written = materialize_image(url, next_dest(), token)
+        except click.ClickException as exc:
+            warning(str(exc))
+            cache[url] = None
+            return None
+        if written is None:
+            warning(f"could not parse data URI for image '{alt_for_log}'")
+            cache[url] = None
+            return None
+        rel = f"images/{written.name}"
+        cache[url] = rel
+        info(f"Saved image [accent]{rel}[/accent]")
+        return rel
+
+    def inline_repl(match):
+        alt = match.group(1)
+        url = match.group(2)
+        rel = resolve(url, alt)
+        return f"![{alt}]({rel})" if rel else match.group(0)
+
+    def ref_repl(match):
+        alt = match.group(1)
+        ref_id = match.group(2)
+        url = ref_defs.get(ref_id)
+        if not url:
+            return match.group(0)
+        rel = resolve(url, alt)
+        return f"![{alt}]({rel})" if rel else f"![{alt}]({url})"
+
+    markdown = MD_INLINE_IMAGE_RE.sub(inline_repl, markdown)
+    markdown = MD_REF_IMAGE_RE.sub(ref_repl, markdown)
+    markdown = MD_REF_DEF_RE.sub("", markdown)
+    markdown = re.sub(r"\n{3,}", "\n\n", markdown).rstrip() + "\n"
+    return markdown
+
+
+def run_doc_read(target, out_dir, no_images, raw, via_docs_api):
+    doc_id = extract_doc_id(target)
+    if not doc_id:
+        raise click.ClickException("could not extract a Google Doc ID from input.")
+    info(f"Document ID: [accent]{doc_id}[/accent]")
+
+    token = access_token()
+
+    if via_docs_api:
+        step("Render via Docs API")
+        document = fetch_document(doc_id, token)
+        title = document.get("title") or doc_id
+        target_dir = Path(out_dir) if out_dir else Path.cwd() / safe_filename(title)
+        target_dir.mkdir(parents=True, exist_ok=True)
+        info(f"Title: [accent]{title}[/accent]")
+        info(f"Output: [accent]{target_dir}[/accent]")
+        if raw:
+            (target_dir / "raw.json").write_text(
+                json.dumps(document, indent=2, ensure_ascii=False), encoding="utf-8"
+            )
+            info(f"Wrote raw API response to [accent]{target_dir / 'raw.json'}[/accent]")
+        resolver = build_image_resolver(document.get("inlineObjects") or {}, target_dir, no_images)
+        markdown = document_to_markdown(document, resolver)
+    else:
+        step("Export via Drive API (text/markdown)")
+        markdown, exported_name = drive_export_markdown(doc_id, token)
+        title = re.sub(r"\.(md|markdown)$", "", exported_name or "") or doc_id
+        target_dir = Path(out_dir) if out_dir else Path.cwd() / safe_filename(title)
+        target_dir.mkdir(parents=True, exist_ok=True)
+        info(f"Title: [accent]{title}[/accent]")
+        info(f"Output: [accent]{target_dir}[/accent]")
+        if raw:
+            (target_dir / "raw.md").write_text(markdown, encoding="utf-8")
+            info(f"Wrote raw export to [accent]{target_dir / 'raw.md'}[/accent]")
+        if not no_images:
+            step("Download referenced images")
+            markdown = download_markdown_images(markdown, target_dir, token)
+
+    md_path = target_dir / "doc.md"
+    md_path.write_text(markdown, encoding="utf-8")
+    success(f"Wrote [accent]{md_path}[/accent] ({len(markdown)} bytes)")
+
+
+@click.group("gdrive")
+def gdrive():
+    """**Google Drive** helpers. Read Google Docs (text + images) from URL or ID."""
+
+
+@gdrive.command("doc-read", epilog=EPILOG)
+@click.argument("target")
+@click.option("-o", "--output", "out_dir", default=None, help="Output directory (default: ./<doc-title>).")
+@click.option("--no-images", is_flag=True, help="Skip image download; keep remote URLs in markdown.")
+@click.option(
+    "--via-docs-api",
+    is_flag=True,
+    help="Use Docs API instead of Drive export (needs Docs API enabled in the OAuth project).",
+)
+@click.option("--raw", is_flag=True, help="Also write the raw API response next to doc.md.")
+def doc_read(target, out_dir, no_images, raw, via_docs_api):
+    """Read a Google Doc and write **doc.md** + downloaded **images/**.
+
+    `TARGET` is either a Google Docs URL (`https://docs.google.com/document/d/<id>/...`)
+    or a raw document ID. Auth uses the Drive OAuth token saved in
+    `~/.omelet.json` under `rclone.token`, refreshing it automatically when expired.
+
+    Default path: Drive API export to `text/markdown`, then any inline image URLs
+    in the markdown are downloaded into `images/` and their references rewritten
+    to local paths. Pass `--via-docs-api` to use the Docs API instead (gives
+    cleaner image references but needs Docs API enabled in the OAuth project).
+    """
+    step("evo gdrive doc-read")
+    try:
+        run_doc_read(target, out_dir, no_images, raw, via_docs_api)
+    except click.ClickException:
+        raise
+    except Exception as exc:
+        error(str(exc))
+        sys.exit(1)

evo_cli-0.2.0/evo_cli/commands/site2s.py

@@ -0,0 +1,289 @@
+import json
+import os
+import re
+import sys
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+
+import rich_click as click
+from rich.text import Text
+
+from evo_cli.console import console, error, info, step, success, warning
+
+BASE32_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"
+GATE_HOSTS = {"site2s.com", "98sub.net", "traffic2s.com", "seo2s.com"}
+GOOGLE_REFERER = "https://www.google.com/"
+CAPTCHA_URL = "https://98sub.net/site2s/captcha.php"
+GETLINK_URL = "https://site2s.com/rest/connect"
+USER_AGENT = (
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36"
+)
+ENCODED_RE = re.compile(r'encodedRedirectUrl\s*=\s*"([A-Z2-7=]+)"')
+TOKEN_RE = re.compile(r'token\s*=\s*"([0-9a-fA-F]{16,})"')
+
+EPILOG = Text.from_markup(
+    "[bold]Examples[/bold]\n\n"
+    "  [cyan]evo site2s https://site2s.com/b8ijsi3b[/cyan]      resolve the final link\n"
+    "  [cyan]evo site2s b8ijsi3b[/cyan]                         alias also works\n"
+    "  [cyan]evo site2s <url> --json[/cyan]                     print machine-readable result\n"
+    "  [cyan]evo site2s <url> --manual[/cyan]                   solve the reCAPTCHA yourself in the window\n"
+    "  [cyan]evo site2s <url> --headless[/cyan]                 no window (use under xvfb-run)\n\n"
+    "[dim]Layer 1 (Base32 redirect) is decoded with no captcha. Task/campaign links\n"
+    "go through the 98sub reCAPTCHA + server countdown before the link is released.[/dim]"
+)
+
+
+def base32_decode(encoded):
+    bits = ""
+    for ch in encoded:
+        if ch == "=":
+            break
+        val = BASE32_ALPHABET.find(ch.upper())
+        if val == -1:
+            raise ValueError(f"invalid base32 char: {ch!r}")
+        bits += format(val, "05b")
+    out = []
+    i = 0
+    while i < len(bits) - 7:
+        out.append(chr(int(bits[i : i + 8], 2)))
+        i += 8
+    return "".join(out)
+
+
+def normalize_url(target):
+    target = target.strip()
+    if re.fullmatch(r"[A-Za-z0-9_-]+", target):
+        return f"https://site2s.com/{target}", target
+    if not target.startswith("http"):
+        target = "https://" + target
+    alias = urllib.parse.urlparse(target).path.strip("/").split("/")[-1]
+    return target, alias
+
+
+def host_of(url):
+    return urllib.parse.urlparse(url).netloc.lower().split(":")[0]
+
+
+def is_gate(url):
+    host = host_of(url)
+    return any(host == g or host.endswith("." + g) for g in GATE_HOSTS)
+
+
+def load_browser():
+    try:
+        from patchright.sync_api import sync_playwright
+    except ImportError as exc:
+        raise click.ClickException(
+            "patchright is required for Cloudflare/reCAPTCHA handling.\n"
+            "  Install it with:  pip install patchright\n"
+            "  It drives the locally installed Google Chrome."
+        ) from exc
+    return sync_playwright
+
+
+def new_context(sync_playwright, headless):
+    p = sync_playwright().start()
+    args = ["--no-sandbox", "--disable-blink-features=AutomationControlled"]
+    ctx = p.chromium.launch_persistent_context(
+        user_data_dir="/tmp/.evo-site2s-profile",
+        channel="chrome",
+        headless=headless,
+        no_viewport=True,
+        args=args,
+    )
+    return p, ctx
+
+
+def wait_past_cloudflare(page, timeout):
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        page.wait_for_timeout(1500)
+        title = (page.title() or "").lower()
+        if "just a moment" not in title and "moment" not in title:
+            return True
+    return False
+
+
+def fetch_redirect_url(page, site_url, timeout):
+    info(f"Loading [accent]{site_url}[/accent] (passing Cloudflare)...")
+    page.goto(site_url, wait_until="domcontentloaded", timeout=60000)
+    if not wait_past_cloudflare(page, timeout):
+        raise click.ClickException("timed out waiting for Cloudflare challenge to clear")
+    html = page.content()
+    match = ENCODED_RE.search(html)
+    if not match:
+        return None
+    decoded = base32_decode(match.group(1))
+    info(f"Layer-1 redirect: [accent]{decoded}[/accent]")
+    return decoded
+
+
+def get_recaptcha_response(page):
+    return page.evaluate(
+        """() => {
+            const ta = document.querySelector('textarea[name="g-recaptcha-response"]');
+            if (ta && ta.value) return ta.value;
+            try { return (typeof grecaptcha !== 'undefined') ? grecaptcha.getResponse() : ''; }
+            catch (e) { return ''; }
+        }"""
+    )
+
+
+def solve_captcha_for_token(ctx, site_url, alias, manual, captcha_wait, timeout):
+    page = ctx.new_page()
+    captcha_page = CAPTCHA_URL + "?" + urllib.parse.urlencode({"w": site_url, "v": "0"})
+    info(f"Opening captcha page for alias [accent]{alias}[/accent]...")
+    page.set_extra_http_headers({"referer": GOOGLE_REFERER})
+    page.goto(captcha_page, wait_until="domcontentloaded", timeout=60000)
+    page.wait_for_timeout(1500)
+
+    try:
+        page.click("#getLinkButton", timeout=5000)
+    except Exception:
+        pass
+    page.wait_for_timeout(1500)
+
+    if manual:
+        wait_for = max(captcha_wait, 240)
+        warning(f"Solve the reCAPTCHA in the browser window (auto-detected, up to {wait_for}s)...")
+    else:
+        wait_for = captcha_wait
+        info("Waiting for reCAPTCHA to validate (checkbox auto-pass)...")
+
+    deadline = time.time() + wait_for
+    while time.time() < deadline:
+        if get_recaptcha_response(page):
+            break
+        page.wait_for_timeout(1500)
+
+    if not get_recaptcha_response(page):
+        raise click.ClickException(
+            "reCAPTCHA not solved. Re-run with --manual to solve it yourself, "
+            "or the IP may be flagged (try a residential IP)."
+        )
+
+    info("reCAPTCHA solved, submitting...")
+    try:
+        page.click('button[type="submit"][name="submit"]', timeout=5000)
+    except Exception:
+        page.evaluate("() => { const f = document.querySelector('form'); if (f) f.submit(); }")
+    page.wait_for_timeout(3000)
+
+    token = None
+    deadline = time.time() + 20
+    while time.time() < deadline:
+        match = TOKEN_RE.search(page.content())
+        if match:
+            token = match.group(1)
+            break
+        page.wait_for_timeout(1500)
+
+    page.close()
+    if not token:
+        raise click.ClickException("captcha accepted but no token was issued (submit may have failed)")
+    info(f"Token issued: [accent]{token}[/accent]")
+    return token
+
+
+def call_getlink(token):
+    url = GETLINK_URL + "?" + urllib.parse.urlencode({"action": "getLink", "token": token})
+    req = urllib.request.Request(url, method="GET")
+    req.add_header("User-Agent", USER_AGENT)
+    req.add_header("X-Requested-With", "XMLHttpRequest")
+    req.add_header("Referer", "https://98sub.net/")
+    try:
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+    except urllib.error.HTTPError as exc:
+        body = exc.read().decode("utf-8", "replace")
+        try:
+            return json.loads(body)
+        except ValueError:
+            raise click.ClickException(f"getLink HTTP {exc.code}: {body}") from exc
+
+
+def poll_getlink(token, timeout):
+    info("Polling getLink (waiting out the server countdown ~70s)...")
+    deadline = time.time() + timeout
+    delay = 5
+    last = {}
+    with console.status("[info]Waiting for the link to be released...[/info]", spinner="dots"):
+        while time.time() < deadline:
+            data = call_getlink(token)
+            last = data
+            if data.get("status") == "success" and data.get("urlrespone"):
+                return data
+            time.sleep(delay)
+    raise click.ClickException(
+        f"link not released within timeout. Last response: {json.dumps(last, ensure_ascii=False)}"
+    )
+
+
+def run(target, headless, manual, timeout, captcha_wait, as_json):
+    site_url, alias = normalize_url(target)
+    sync_playwright = load_browser()
+
+    if not headless and not os.environ.get("DISPLAY"):
+        warning("No DISPLAY found. Headful Chrome needs a display; run under `xvfb-run` or pass --headless.")
+
+    p, ctx = new_context(sync_playwright, headless)
+    try:
+        page = ctx.pages[0] if ctx.pages else ctx.new_page()
+        redirect_url = fetch_redirect_url(page, site_url, timeout)
+
+        if redirect_url and not is_gate(redirect_url):
+            final = redirect_url
+            slug = None
+        else:
+            if redirect_url:
+                info("Layer-1 points to a task gate; running captcha + token flow.")
+            token = solve_captcha_for_token(ctx, site_url, alias, manual, captcha_wait, timeout)
+            data = poll_getlink(token, timeout)
+            final = data.get("urlrespone")
+            slug = data.get("slug")
+    finally:
+        try:
+            ctx.close()
+        finally:
+            p.stop()
+
+    if as_json:
+        console.print_json(json.dumps({"alias": alias, "final_url": final, "slug": slug}))
+    else:
+        success(f"Final link: [accent]{final}[/accent]")
+        if slug:
+            info(f"slug: {slug}")
+    return final
+
+
+@click.command("site2s", epilog=EPILOG)
+@click.argument("target")
+@click.option("--headless", is_flag=True, help="Run Chrome headless (needs xvfb; Cloudflare may flag it).")
+@click.option("--manual", is_flag=True, help="Pause for you to solve the reCAPTCHA in the window.")
+@click.option("--timeout", default=150, show_default=True, help="Overall timeout per stage (seconds).")
+@click.option("--captcha-wait", default=40, show_default=True, help="Seconds to wait for reCAPTCHA auto-pass.")
+@click.option("--json", "as_json", is_flag=True, help="Print result as JSON.")
+def site2s(target, headless, manual, timeout, captcha_wait, as_json):
+    """Resolve a **Site2S** short link to its real destination.
+
+    `TARGET` is a `https://site2s.com/<alias>` URL or just the `<alias>`.
+
+    Site2S hides the destination behind Cloudflare, a fake "search this keyword
+    on Google" task, a reCAPTCHA, and a server-side countdown. This command
+    drives a real Chrome (via patchright) to pass Cloudflare, decodes the
+    Base32 layer-1 redirect, spoofs a Google referrer to skip the keyword task,
+    waits out the countdown, and pulls the final link from the `getLink` API.
+
+    Direct links resolve instantly with no captcha. Task/campaign links need the
+    reCAPTCHA solved - it auto-passes on clean IPs, otherwise use `--manual`.
+    """
+    step("evo site2s")
+    try:
+        run(target, headless, manual, timeout, captcha_wait, as_json)
+    except click.ClickException:
+        raise
+    except Exception as exc:
+        error(str(exc))
+        sys.exit(1)

{evo_cli-0.1.11 → evo_cli-0.2.0}/evo_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo_cli
-Version: 0.1.11
+Version: 0.2.0
 Summary: Evolution CLI - a developer toolbox for setting up dev machines
 Author: maycuatroi
 Project-URL: Homepage, https://github.com/maycuatroi/evo-cli

{evo_cli-0.1.11 → evo_cli-0.2.0}/evo_cli.egg-info/SOURCES.txt

@@ -19,7 +19,9 @@ evo_cli.egg-info/top_level.txt
 evo_cli/commands/__init__.py
 evo_cli/commands/cloudflare.py
 evo_cli/commands/fix_claude.py
+evo_cli/commands/gdrive.py
 evo_cli/commands/miniconda.py
+evo_cli/commands/site2s.py
 evo_cli/commands/ssh.py
 tests/__init__.py
 tests/test_cli.py

evo_cli-0.1.11/evo_cli/VERSION

@@ -1 +0,0 @@
-0.1.11