twitter-cli 0.1.0__py3-none-any.whl

twitter_cli/__init__.py

@@ -0,0 +1,3 @@
+"""twitter-cli: A CLI for Twitter/X."""
+
+__version__ = "0.1.0"

twitter_cli/auth.py

@@ -0,0 +1,193 @@
+"""Cookie authentication for Twitter/X.
+
+Supports:
+1. Environment variables: TWITTER_AUTH_TOKEN + TWITTER_CT0
+2. Auto-extract from browser via browser-cookie3 (subprocess)
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import ssl
+import subprocess
+import sys
+import urllib.error
+import urllib.request
+from typing import Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+# Public bearer token (same as in client.py)
+_BEARER_TOKEN = (
+    "AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs"
+    "%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA"
+)
+
+
+def load_from_env() -> Optional[Dict[str, str]]:
+    """Load cookies from environment variables."""
+    auth_token = os.environ.get("TWITTER_AUTH_TOKEN", "")
+    ct0 = os.environ.get("TWITTER_CT0", "")
+    if auth_token and ct0:
+        return {"auth_token": auth_token, "ct0": ct0}
+    return None
+
+
+def verify_cookies(auth_token, ct0):
+    # type: (str, str) -> Dict[str, Any]
+    """Verify cookies by calling a Twitter API endpoint.
+
+    Tries multiple endpoints. Only raises on clear auth failures (401/403).
+    For other errors (404, network), returns empty dict (proceed without verification).
+    """
+    # Endpoints to try, in order of preference
+    urls = [
+        "https://api.x.com/1.1/account/verify_credentials.json",
+        "https://x.com/i/api/1.1/account/settings.json",
+    ]
+
+    headers = {
+        "Authorization": "Bearer %s" % _BEARER_TOKEN,
+        "Cookie": "auth_token=%s; ct0=%s" % (auth_token, ct0),
+        "X-Csrf-Token": ct0,
+        "X-Twitter-Active-User": "yes",
+        "X-Twitter-Auth-Type": "OAuth2Session",
+        "User-Agent": (
+            "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
+            "AppleWebKit/537.36 (KHTML, like Gecko) "
+            "Chrome/131.0.0.0 Safari/537.36"
+        ),
+    }
+
+    for url in urls:
+        req = urllib.request.Request(url)
+        for k, v in headers.items():
+            req.add_header(k, v)
+
+        ctx = ssl.create_default_context()
+        try:
+            with urllib.request.urlopen(req, context=ctx, timeout=3) as resp:
+                data = json.loads(resp.read().decode("utf-8"))
+                return {"screen_name": data.get("screen_name", "")}
+        except urllib.error.HTTPError as e:
+            if e.code in (401, 403):
+                raise RuntimeError(
+                    "Cookie expired or invalid (HTTP %d). Please re-login to x.com in your browser." % e.code
+                )
+            # 404 or other — try next endpoint
+            logger.debug("Verification endpoint %s returned HTTP %d, trying next...", url, e.code)
+            continue
+        except Exception as e:
+            logger.debug("Verification endpoint %s failed: %s", url, e)
+            continue
+
+    # All endpoints failed with non-auth errors — proceed without verification
+    logger.info("Cookie verification skipped (no working endpoint), will verify on first API call")
+    return {}
+
+
+def extract_from_browser() -> Optional[Dict[str, str]]:
+    """Auto-extract cookies from local browser using browser-cookie3.
+
+    Tries browsers in order: Chrome -> Edge -> Firefox -> Brave.
+    Runs in a subprocess to avoid SQLite database lock issues when the
+    browser is running.
+    """
+    extract_script = '''
+import json, sys
+try:
+    import browser_cookie3
+except ImportError:
+    print(json.dumps({"error": "browser-cookie3 not installed"}))
+    sys.exit(1)
+
+browsers = [
+    ("chrome", browser_cookie3.chrome),
+    ("edge", browser_cookie3.edge),
+    ("firefox", browser_cookie3.firefox),
+    ("brave", browser_cookie3.brave),
+]
+
+for name, fn in browsers:
+    try:
+        jar = fn()
+    except Exception:
+        continue
+    result = {}
+    for cookie in jar:
+        domain = cookie.domain or ""
+        if domain.endswith(".x.com") or domain.endswith(".twitter.com") or domain in ("x.com", "twitter.com", ".x.com", ".twitter.com"):
+            if cookie.name == "auth_token":
+                result["auth_token"] = cookie.value
+            elif cookie.name == "ct0":
+                result["ct0"] = cookie.value
+    if "auth_token" in result and "ct0" in result:
+        result["browser"] = name
+        print(json.dumps(result))
+        sys.exit(0)
+
+print(json.dumps({"error": "No Twitter cookies found in any browser. Make sure you are logged into x.com."}))
+sys.exit(1)
+'''
+
+    try:
+        result = subprocess.run(
+            [sys.executable, "-c", extract_script],
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+        output = result.stdout.strip()
+        if not output:
+            stderr = result.stderr.strip()
+            if stderr:
+                logger.debug("Cookie extraction stderr from current env: %s", stderr[:300])
+                # Maybe browser-cookie3 not installed, try with uv.
+                result2 = subprocess.run(
+                    ["uv", "run", "--with", "browser-cookie3", "python3", "-c", extract_script],
+                    capture_output=True,
+                    text=True,
+                    timeout=30,
+                )
+                output = result2.stdout.strip()
+                if not output:
+                    logger.debug("Cookie extraction stderr from uv fallback: %s", result2.stderr.strip()[:300])
+                    return None
+
+        data = json.loads(output)
+        if "error" in data:
+            return None
+        logger.info("Found cookies in %s", data.get("browser", "unknown"))
+        return {"auth_token": data["auth_token"], "ct0": data["ct0"]}
+    except (subprocess.TimeoutExpired, json.JSONDecodeError, KeyError, FileNotFoundError):
+        return None
+
+
+def get_cookies() -> Dict[str, str]:
+    """Get Twitter cookies. Priority: env vars -> browser extraction (Chrome/Edge/Firefox/Brave).
+
+    Raises RuntimeError if no cookies found.
+    """
+    cookies = None  # type: Optional[Dict[str, str]]
+
+    # 1. Try environment variables
+    cookies = load_from_env()
+    if cookies:
+        logger.info("Loaded cookies from environment variables")
+
+    # 2. Try browser extraction (auto-detect)
+    if not cookies:
+        cookies = extract_from_browser()
+
+    if not cookies:
+        raise RuntimeError(
+            "No Twitter cookies found.\n"
+            "Option 1: Set TWITTER_AUTH_TOKEN and TWITTER_CT0 environment variables\n"
+            "Option 2: Make sure you are logged into x.com in your browser (Chrome/Edge/Firefox/Brave)"
+        )
+
+    # Verify only for explicit auth failures; transient endpoint issues are tolerated.
+    verify_cookies(cookies["auth_token"], cookies["ct0"])
+    return cookies

twitter_cli/cli.py

@@ -0,0 +1,245 @@
+"""CLI entry point for twitter-cli.
+
+Usage:
+    twitter feed                      # fetch home timeline (For You)
+    twitter feed -t following         # fetch following feed
+    twitter feed --max 50             # custom fetch count
+    twitter feed --filter             # enable score-based filtering
+    twitter feed --json               # JSON output
+    twitter favorite                  # fetch bookmarks
+    twitter feed --input tweets.json  # load existing data
+    twitter feed --output out.json    # save filtered tweets
+    twitter user elonmusk             # view user profile
+    twitter user-posts elonmusk       # list user tweets
+"""
+
+from __future__ import annotations
+
+import logging
+import sys
+import time
+from pathlib import Path
+
+import click
+from rich.console import Console
+
+from . import __version__
+from .auth import get_cookies
+from .client import TwitterClient
+from .config import load_config
+from .filter import filter_tweets
+from .formatter import print_filter_stats, print_tweet_table, print_user_profile
+from .serialization import tweets_from_json, tweets_to_json
+
+
+console = Console()
+FEED_TYPES = ["for-you", "following"]
+
+
+def _setup_logging(verbose):
+    # type: (bool) -> None
+    level = logging.DEBUG if verbose else logging.WARNING
+    logging.basicConfig(
+        level=level,
+        format="%(levelname)s %(name)s: %(message)s",
+        stream=sys.stderr,
+    )
+
+
+def _load_tweets_from_json(path):
+    # type: (str) -> List[Tweet]
+    """Load tweets from a JSON file (previously exported)."""
+    file_path = Path(path)
+    if not file_path.exists():
+        raise RuntimeError("Input file not found: %s" % path)
+
+    try:
+        raw = file_path.read_text(encoding="utf-8")
+        return tweets_from_json(raw)
+    except (ValueError, OSError) as exc:
+        raise RuntimeError("Invalid tweet JSON file %s: %s" % (path, exc))
+
+
+def _get_client():
+    # type: () -> TwitterClient
+    """Create an authenticated API client."""
+    console.print("\n🔐 Getting Twitter cookies...")
+    try:
+        cookies = get_cookies()
+    except RuntimeError as exc:
+        raise RuntimeError(str(exc))
+    return TwitterClient(cookies["auth_token"], cookies["ct0"])
+
+
+def _resolve_fetch_count(max_count, configured):
+    # type: (Optional[int], int) -> int
+    """Resolve fetch count with bounds checks."""
+    if max_count is not None:
+        if max_count <= 0:
+            raise RuntimeError("--max must be greater than 0")
+        return max_count
+    return max(configured, 1)
+
+
+def _apply_filter(tweets, do_filter, config):
+    # type: (List[Tweet], bool, dict) -> List[Tweet]
+    """Optionally apply tweet filtering."""
+    if not do_filter:
+        return tweets
+    filter_config = config.get("filter", {})
+    original_count = len(tweets)
+    filtered = filter_tweets(tweets, filter_config)
+    print_filter_stats(original_count, filtered, console)
+    console.print()
+    return filtered
+
+
+@click.group()
+@click.option("--verbose", "-v", is_flag=True, help="Enable debug logging.")
+@click.version_option(version=__version__)
+def cli(verbose):
+    # type: (bool) -> None
+    """twitter — Twitter/X CLI tool 🐦"""
+    _setup_logging(verbose)
+
+
+@cli.command()
+@click.option(
+    "--type",
+    "-t",
+    "feed_type",
+    type=click.Choice(FEED_TYPES),
+    default="for-you",
+    help="Feed type: for-you (algorithmic) or following (chronological).",
+)
+@click.option("--max", "-n", "max_count", type=int, default=None, help="Max number of tweets to fetch.")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+@click.option("--input", "-i", "input_file", type=str, default=None, help="Load tweets from JSON file.")
+@click.option("--output", "-o", "output_file", type=str, default=None, help="Save filtered tweets to JSON file.")
+@click.option("--filter", "do_filter", is_flag=True, help="Enable score-based filtering.")
+def feed(feed_type, max_count, as_json, input_file, output_file, do_filter):
+    # type: (str, Optional[int], bool, Optional[str], Optional[str], bool) -> None
+    """Fetch home timeline with optional filtering."""
+    config = load_config()
+    try:
+        if input_file:
+            console.print("📂 Loading tweets from %s..." % input_file)
+            tweets = _load_tweets_from_json(input_file)
+            console.print("   Loaded %d tweets" % len(tweets))
+        else:
+            fetch_count = _resolve_fetch_count(max_count, config.get("fetch", {}).get("count", 50))
+            client = _get_client()
+            label = "following feed" if feed_type == "following" else "home timeline"
+            console.print("📡 Fetching %s (%d tweets)...\n" % (label, fetch_count))
+            start = time.time()
+            if feed_type == "following":
+                tweets = client.fetch_following_feed(fetch_count)
+            else:
+                tweets = client.fetch_home_timeline(fetch_count)
+            elapsed = time.time() - start
+            console.print("✅ Fetched %d tweets in %.1fs\n" % (len(tweets), elapsed))
+    except RuntimeError as exc:
+        console.print("[red]❌ %s[/red]" % exc)
+        sys.exit(1)
+
+    filtered = _apply_filter(tweets, do_filter, config)
+
+    if output_file:
+        Path(output_file).write_text(tweets_to_json(filtered), encoding="utf-8")
+        console.print("💾 Saved filtered tweets to %s\n" % output_file)
+
+    if as_json:
+        click.echo(tweets_to_json(filtered))
+        return
+
+    title = "👥 Following" if feed_type == "following" else "📱 Twitter"
+    title += " — %d tweets" % len(filtered)
+    print_tweet_table(filtered, console, title=title)
+    console.print()
+
+
+@cli.command()
+@click.option("--max", "-n", "max_count", type=int, default=None, help="Max number of tweets to fetch.")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+@click.option("--output", "-o", "output_file", type=str, default=None, help="Save tweets to JSON file.")
+@click.option("--filter", "do_filter", is_flag=True, help="Enable score-based filtering.")
+def favorite(max_count, as_json, output_file, do_filter):
+    # type: (Optional[int], bool, Optional[str], bool) -> None
+    """Fetch bookmarked (favorite) tweets."""
+    config = load_config()
+    try:
+        fetch_count = _resolve_fetch_count(max_count, config.get("fetch", {}).get("count", 50))
+        client = _get_client()
+        console.print("🔖 Fetching favorites (%d tweets)...\n" % fetch_count)
+        start = time.time()
+        tweets = client.fetch_bookmarks(fetch_count)
+        elapsed = time.time() - start
+        console.print("✅ Fetched %d favorites in %.1fs\n" % (len(tweets), elapsed))
+    except RuntimeError as exc:
+        console.print("[red]❌ %s[/red]" % exc)
+        sys.exit(1)
+
+    filtered = _apply_filter(tweets, do_filter, config)
+
+    if output_file:
+        Path(output_file).write_text(tweets_to_json(filtered), encoding="utf-8")
+        console.print("💾 Saved to %s\n" % output_file)
+
+    if as_json:
+        click.echo(tweets_to_json(filtered))
+        return
+
+    print_tweet_table(filtered, console, title="🔖 Favorites — %d tweets" % len(filtered))
+    console.print()
+
+
+@cli.command()
+@click.argument("screen_name")
+def user(screen_name):
+    # type: (str,) -> None
+    """View a user's profile. SCREEN_NAME is the @handle (without @)."""
+    screen_name = screen_name.lstrip("@")
+    try:
+        client = _get_client()
+        console.print("👤 Fetching user @%s..." % screen_name)
+        profile = client.fetch_user(screen_name)
+    except RuntimeError as exc:
+        console.print("[red]❌ %s[/red]" % exc)
+        sys.exit(1)
+
+    console.print()
+    print_user_profile(profile, console)
+
+
+@cli.command("user-posts")
+@click.argument("screen_name")
+@click.option("--max", "-n", "max_count", type=int, default=20, help="Max number of tweets to fetch.")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+def user_posts(screen_name, max_count, as_json):
+    # type: (str, int, bool) -> None
+    """List a user's tweets. SCREEN_NAME is the @handle (without @)."""
+    screen_name = screen_name.lstrip("@")
+    try:
+        fetch_count = _resolve_fetch_count(max_count, 20)
+        client = _get_client()
+        console.print("👤 Fetching @%s's profile..." % screen_name)
+        profile = client.fetch_user(screen_name)
+        console.print("📝 Fetching tweets (%d)...\n" % fetch_count)
+        start = time.time()
+        tweets = client.fetch_user_tweets(profile.id, fetch_count)
+        elapsed = time.time() - start
+        console.print("✅ Fetched %d tweets in %.1fs\n" % (len(tweets), elapsed))
+    except RuntimeError as exc:
+        console.print("[red]❌ %s[/red]" % exc)
+        sys.exit(1)
+
+    if as_json:
+        click.echo(tweets_to_json(tweets))
+        return
+
+    print_tweet_table(tweets, console, title="📝 @%s — %d tweets" % (screen_name, len(tweets)))
+    console.print()
+
+
+if __name__ == "__main__":
+    cli()