cli-web-reddit 0.1.0__py3-none-any.whl

cli_web/reddit/commands/post.py

@@ -0,0 +1,93 @@
+"""Post commands for cli-web-reddit."""
+
+from __future__ import annotations
+
+import re
+
+import click
+
+from ..core.client import RedditClient
+from ..core.models import format_post_detail
+from ..utils.helpers import handle_errors, print_json, resolve_json_mode
+from ..utils.output import comment_table, post_detail_display
+
+
+@click.group("post")
+def post():
+    """View post details and comments."""
+
+
+def _parse_post_url(url_or_id: str) -> tuple[str, str, str]:
+    """Parse a Reddit post URL or ID into (subreddit, post_id, slug).
+
+    Accepts:
+      - Full URL: https://www.reddit.com/r/python/comments/abc123/my_post/
+      - Short path: r/python/comments/abc123/my_post
+      - Just the post ID: abc123 (subreddit resolved by Reddit API)
+      - Fullname: t3_abc123 (stripped to abc123)
+    """
+    # Full URL or path with /r/sub/comments/id/slug pattern
+    match = re.search(r"r/([^/]+)/comments/([^/]+)(?:/([^/?]+))?", url_or_id)
+    if match:
+        return match.group(1), match.group(2), match.group(3) or ""
+    # Strip t3_ prefix if present
+    post_id = url_or_id.strip("/")
+    if post_id.startswith("t3_"):
+        post_id = post_id[3:]
+    return "", post_id, ""
+
+
+@post.command("get")
+@click.argument("url_or_id")
+@click.option("--sub", default=None, help="Subreddit name (required if passing just a post ID).")
+@click.option(
+    "--comments", "comment_limit", type=int, default=50, help="Number of comments to fetch."
+)
+@click.option("--json", "use_json", is_flag=True, help="Output as JSON.")
+def get(url_or_id, sub, comment_limit, use_json):
+    """Get post details and comments.
+
+    Pass a full Reddit URL or a post ID (with --sub).
+
+    Examples:
+      post get https://www.reddit.com/r/python/comments/abc123/my_post/
+      post get abc123 --sub python
+    """
+    use_json = resolve_json_mode(use_json)
+    with handle_errors(json_mode=use_json):
+        subreddit, post_id, slug = _parse_post_url(url_or_id)
+        if not subreddit and sub:
+            subreddit = sub
+
+        client = RedditClient()
+        data = client.post_detail(
+            subreddit, post_id, slug=slug, comment_limit=comment_limit, depth=50
+        )
+
+        # Reddit returns [post_listing, comments_listing]
+        post_listing = data[0] if len(data) > 0 else {}
+        comments_listing = data[1] if len(data) > 1 else {}
+
+        post_children = post_listing.get("data", {}).get("children", [])
+        post_data = post_children[0] if post_children else {}
+
+        # Extract link_id for fetching collapsed comments
+        link_id = post_data.get("data", {}).get("name", "") or f"t3_{post_id}"
+
+        result = format_post_detail(
+            post_data,
+            comments_listing,
+            more_children_fn=client.more_children,
+            link_id=link_id,
+            thread_fn=client.comment_thread,
+            post_id=post_id,
+        )
+
+        if use_json:
+            print_json(result)
+        else:
+            post_detail_display(result)
+            if result.get("comments"):
+                comment_table(result["comments"][:20], title="Top Comments")
+                if len(result["comments"]) > 20:
+                    click.echo(f"  ... and {len(result['comments']) - 20} more comments")

cli_web/reddit/commands/search.py

@@ -0,0 +1,66 @@
+"""Search commands for cli-web-reddit."""
+
+from __future__ import annotations
+
+import click
+
+from ..core.client import RedditClient
+from ..core.models import extract_listing_posts, extract_listing_subreddits
+from ..utils.helpers import handle_errors, print_json, resolve_json_mode
+from ..utils.output import post_table, subreddit_table
+
+SORT_CHOICES = ["relevance", "hot", "top", "new", "comments"]
+TIME_CHOICES = ["hour", "day", "week", "month", "year", "all"]
+
+
+@click.group("search")
+def search():
+    """Search Reddit posts and subreddits."""
+
+
+@search.command("posts")
+@click.argument("query")
+@click.option("--sort", type=click.Choice(SORT_CHOICES), default="relevance", help="Sort order.")
+@click.option(
+    "--time",
+    "time_filter",
+    type=click.Choice(TIME_CHOICES),
+    default=None,
+    help="Time period (for top sort).",
+)
+@click.option("--limit", type=int, default=25, help="Number of results (max 100).")
+@click.option("--after", default=None, help="Pagination cursor.")
+@click.option("--json", "use_json", is_flag=True, help="Output as JSON.")
+def posts(query, sort, time_filter, limit, after, use_json):
+    """Search posts across all of Reddit."""
+    use_json = resolve_json_mode(use_json)
+    with handle_errors(json_mode=use_json):
+        client = RedditClient()
+        data = client.search_posts(query, limit=limit, sort=sort, time=time_filter, after=after)
+        results, next_after = extract_listing_posts(data)
+        if use_json:
+            print_json({"query": query, "posts": results, "after": next_after})
+        else:
+            post_table(results, title=f"Search: {query}")
+            if next_after:
+                click.echo(f'  Next page: search posts "{query}" --after {next_after}')
+
+
+@search.command("subs")
+@click.argument("query")
+@click.option("--limit", type=int, default=25, help="Number of results (max 100).")
+@click.option("--after", default=None, help="Pagination cursor.")
+@click.option("--json", "use_json", is_flag=True, help="Output as JSON.")
+def subs(query, limit, after, use_json):
+    """Search for subreddits by name/description."""
+    use_json = resolve_json_mode(use_json)
+    with handle_errors(json_mode=use_json):
+        client = RedditClient()
+        data = client.search_subreddits(query, limit=limit, after=after)
+        results, next_after = extract_listing_subreddits(data)
+        if use_json:
+            print_json({"query": query, "subreddits": results, "after": next_after})
+        else:
+            subreddit_table(results, title=f"Subreddits: {query}")
+            if next_after:
+                click.echo(f'  Next page: search subs "{query}" --after {next_after}')

cli_web/reddit/commands/subreddit.py

@@ -0,0 +1,184 @@
+"""Subreddit commands for cli-web-reddit."""
+
+from __future__ import annotations
+
+import click
+
+from ..core.client import RedditClient
+from ..core.models import extract_listing_posts, format_subreddit_info
+from ..utils.helpers import handle_errors, print_json, resolve_json_mode
+from ..utils.output import post_table, subreddit_detail_display
+
+SORT_CHOICES = ["hot", "new", "top", "rising"]
+TIME_CHOICES = ["hour", "day", "week", "month", "year", "all"]
+SEARCH_SORT_CHOICES = ["relevance", "hot", "top", "new", "comments"]
+
+
+@click.group("sub")
+def sub():
+    """Browse subreddits — posts, info, rules, search."""
+
+
+@sub.command("hot")
+@click.argument("name")
+@click.option("--limit", type=int, default=25, help="Number of posts (max 100).")
+@click.option("--after", default=None, help="Pagination cursor.")
+@click.option("--json", "use_json", is_flag=True, help="Output as JSON.")
+def hot(name, limit, after, use_json):
+    """Hot posts in a subreddit."""
+    use_json = resolve_json_mode(use_json)
+    with handle_errors(json_mode=use_json):
+        client = RedditClient()
+        data = client.sub_posts(name, sort="hot", limit=limit, after=after)
+        posts, next_after = extract_listing_posts(data)
+        if use_json:
+            print_json({"subreddit": name, "posts": posts, "after": next_after})
+        else:
+            post_table(posts, title=f"r/{name} — Hot")
+            if next_after:
+                click.echo(f"  Next page: sub hot {name} --after {next_after}")
+
+
+@sub.command("new")
+@click.argument("name")
+@click.option("--limit", type=int, default=25, help="Number of posts (max 100).")
+@click.option("--after", default=None, help="Pagination cursor.")
+@click.option("--json", "use_json", is_flag=True, help="Output as JSON.")
+def new(name, limit, after, use_json):
+    """Newest posts in a subreddit."""
+    use_json = resolve_json_mode(use_json)
+    with handle_errors(json_mode=use_json):
+        client = RedditClient()
+        data = client.sub_posts(name, sort="new", limit=limit, after=after)
+        posts, next_after = extract_listing_posts(data)
+        if use_json:
+            print_json({"subreddit": name, "posts": posts, "after": next_after})
+        else:
+            post_table(posts, title=f"r/{name} — New")
+            if next_after:
+                click.echo(f"  Next page: sub new {name} --after {next_after}")
+
+
+@sub.command("top")
+@click.argument("name")
+@click.option(
+    "--time", "time_filter", type=click.Choice(TIME_CHOICES), default="day", help="Time period."
+)
+@click.option("--limit", type=int, default=25, help="Number of posts (max 100).")
+@click.option("--after", default=None, help="Pagination cursor.")
+@click.option("--json", "use_json", is_flag=True, help="Output as JSON.")
+def top(name, time_filter, limit, after, use_json):
+    """Top posts in a subreddit by time period."""
+    use_json = resolve_json_mode(use_json)
+    with handle_errors(json_mode=use_json):
+        client = RedditClient()
+        data = client.sub_posts(name, sort="top", limit=limit, after=after, time=time_filter)
+        posts, next_after = extract_listing_posts(data)
+        if use_json:
+            print_json({"subreddit": name, "posts": posts, "after": next_after})
+        else:
+            post_table(posts, title=f"r/{name} — Top ({time_filter})")
+            if next_after:
+                click.echo(f"  Next page: sub top {name} --time {time_filter} --after {next_after}")
+
+
+@sub.command("info")
+@click.argument("name")
+@click.option("--json", "use_json", is_flag=True, help="Output as JSON.")
+def info(name, use_json):
+    """Get subreddit info and stats."""
+    use_json = resolve_json_mode(use_json)
+    with handle_errors(json_mode=use_json):
+        client = RedditClient()
+        data = client.sub_info(name)
+        result = format_subreddit_info(data)
+        if use_json:
+            print_json(result)
+        else:
+            subreddit_detail_display(result)
+
+
+@sub.command("rules")
+@click.argument("name")
+@click.option("--json", "use_json", is_flag=True, help="Output as JSON.")
+def rules(name, use_json):
+    """Get subreddit rules."""
+    use_json = resolve_json_mode(use_json)
+    with handle_errors(json_mode=use_json):
+        client = RedditClient()
+        data = client.sub_rules(name)
+        rule_list = data.get("rules", [])
+        formatted = [
+            {
+                "priority": r.get("priority", i),
+                "name": r.get("short_name", ""),
+                "description": r.get("description", ""),
+                "kind": r.get("kind", ""),
+            }
+            for i, r in enumerate(rule_list)
+        ]
+        if use_json:
+            print_json({"subreddit": name, "rules": formatted})
+        else:
+            click.echo(f"\n  Rules for r/{name}:")
+            for r in formatted:
+                click.echo(f"  {r['priority'] + 1}. {r['name']}")
+                if r["description"]:
+                    desc = r["description"][:150].replace("\n", " ")
+                    click.echo(f"     {desc}")
+            click.echo()
+
+
+@sub.command("search")
+@click.argument("name")
+@click.argument("query")
+@click.option(
+    "--sort", type=click.Choice(SEARCH_SORT_CHOICES), default="relevance", help="Sort order."
+)
+@click.option("--limit", type=int, default=25, help="Number of results (max 100).")
+@click.option("--after", default=None, help="Pagination cursor.")
+@click.option("--json", "use_json", is_flag=True, help="Output as JSON.")
+def search(name, query, sort, limit, after, use_json):
+    """Search posts within a subreddit."""
+    use_json = resolve_json_mode(use_json)
+    with handle_errors(json_mode=use_json):
+        client = RedditClient()
+        data = client.sub_search(name, query, limit=limit, sort=sort, after=after)
+        posts, next_after = extract_listing_posts(data)
+        if use_json:
+            print_json({"subreddit": name, "query": query, "posts": posts, "after": next_after})
+        else:
+            click.echo(f"  Search r/{name} for '{query}':")
+            post_table(posts, title=f"r/{name} Search: {query}")
+            if next_after:
+                click.echo(f'  Next page: sub search {name} "{query}" --after {next_after}')
+
+
+@sub.command("join")
+@click.argument("name")
+@click.option("--json", "use_json", is_flag=True, help="Output as JSON.")
+def join(name, use_json):
+    """Subscribe to a subreddit (requires login)."""
+    use_json = resolve_json_mode(use_json)
+    with handle_errors(json_mode=use_json):
+        client = RedditClient()
+        client.sub_join(name)
+        if use_json:
+            print_json({"success": True, "action": "subscribe", "subreddit": name})
+        else:
+            click.echo(f"  Subscribed to r/{name}")
+
+
+@sub.command("leave")
+@click.argument("name")
+@click.option("--json", "use_json", is_flag=True, help="Output as JSON.")
+def leave(name, use_json):
+    """Unsubscribe from a subreddit (requires login)."""
+    use_json = resolve_json_mode(use_json)
+    with handle_errors(json_mode=use_json):
+        client = RedditClient()
+        client.sub_leave(name)
+        if use_json:
+            print_json({"success": True, "action": "unsubscribe", "subreddit": name})
+        else:
+            click.echo(f"  Unsubscribed from r/{name}")

cli_web/reddit/commands/user.py

@@ -0,0 +1,90 @@
+"""User commands for cli-web-reddit."""
+
+from __future__ import annotations
+
+import click
+
+from ..core.client import RedditClient
+from ..core.models import extract_listing_comments, extract_listing_posts, format_user_info
+from ..utils.helpers import handle_errors, print_json, resolve_json_mode
+from ..utils.output import comment_table, post_table, user_detail_display
+
+SORT_CHOICES = ["hot", "new", "top", "controversial"]
+TIME_CHOICES = ["hour", "day", "week", "month", "year", "all"]
+
+
+@click.group("user")
+def user():
+    """View user profiles and activity."""
+
+
+@user.command("info")
+@click.argument("username")
+@click.option("--json", "use_json", is_flag=True, help="Output as JSON.")
+def info(username, use_json):
+    """Get user profile information."""
+    use_json = resolve_json_mode(use_json)
+    with handle_errors(json_mode=use_json):
+        client = RedditClient()
+        data = client.user_about(username)
+        result = format_user_info(data)
+        if use_json:
+            print_json(result)
+        else:
+            user_detail_display(result)
+
+
+@user.command("posts")
+@click.argument("username")
+@click.option("--sort", type=click.Choice(SORT_CHOICES), default="new", help="Sort order.")
+@click.option(
+    "--time",
+    "time_filter",
+    type=click.Choice(TIME_CHOICES),
+    default=None,
+    help="Time period (for top sort).",
+)
+@click.option("--limit", type=int, default=25, help="Number of posts (max 100).")
+@click.option("--after", default=None, help="Pagination cursor.")
+@click.option("--json", "use_json", is_flag=True, help="Output as JSON.")
+def posts(username, sort, time_filter, limit, after, use_json):
+    """View a user's submitted posts."""
+    use_json = resolve_json_mode(use_json)
+    with handle_errors(json_mode=use_json):
+        client = RedditClient()
+        data = client.user_posts(username, limit=limit, after=after, sort=sort, time=time_filter)
+        results, next_after = extract_listing_posts(data)
+        if use_json:
+            print_json({"username": username, "posts": results, "after": next_after})
+        else:
+            post_table(results, title=f"u/{username} — Posts")
+            if next_after:
+                click.echo(f"  Next page: user posts {username} --after {next_after}")
+
+
+@user.command("comments")
+@click.argument("username")
+@click.option("--sort", type=click.Choice(SORT_CHOICES), default="new", help="Sort order.")
+@click.option(
+    "--time",
+    "time_filter",
+    type=click.Choice(TIME_CHOICES),
+    default=None,
+    help="Time period (for top sort).",
+)
+@click.option("--limit", type=int, default=25, help="Number of comments (max 100).")
+@click.option("--after", default=None, help="Pagination cursor.")
+@click.option("--json", "use_json", is_flag=True, help="Output as JSON.")
+def comments(username, sort, time_filter, limit, after, use_json):
+    """View a user's comments."""
+    use_json = resolve_json_mode(use_json)
+    with handle_errors(json_mode=use_json):
+        client = RedditClient()
+        data = client.user_comments(username, limit=limit, after=after, sort=sort, time=time_filter)
+        results, next_after = extract_listing_comments(data)
+        if use_json:
+            print_json({"username": username, "comments": results, "after": next_after})
+        else:
+            comment_table(results, title=f"u/{username} — Comments")
+            if next_after:
+                click.echo(f"  Next page: user comments {username} --after {next_after}")

cli_web/reddit/core/auth.py

@@ -0,0 +1,204 @@
+"""Auth management for cli-web-reddit.
+
+Uses Python playwright for browser-based Reddit login.
+Stores bearer token (token_v2) and cookies at ~/.config/cli-web-reddit/auth.json.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import platform
+import stat
+import sys
+from pathlib import Path
+
+from .exceptions import AuthError
+
+AUTH_DIR = Path.home() / ".config" / "cli-web-reddit"
+AUTH_FILE = AUTH_DIR / "auth.json"
+
+# Environment variable override for CI/CD
+ENV_VAR = "CLI_WEB_REDDIT_AUTH_JSON"
+
+
+def _ensure_dir() -> None:
+    AUTH_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def load_auth() -> dict | None:
+    """Load auth data from env var or file. Returns dict with 'token' and 'cookies' keys."""
+    # Env var override
+    env = os.environ.get(ENV_VAR)
+    if env:
+        try:
+            return json.loads(env)
+        except json.JSONDecodeError:
+            return None
+
+    if not AUTH_FILE.exists():
+        return None
+
+    try:
+        data = json.loads(AUTH_FILE.read_text(encoding="utf-8"))
+        # Handle both formats
+        if isinstance(data, dict) and "token" in data:
+            return data
+        if isinstance(data, list):
+            # Raw cookie list — extract token_v2
+            token = ""
+            cookie_dict = {}
+            for c in data:
+                if isinstance(c, dict):
+                    cookie_dict[c["name"]] = c["value"]
+                    if c["name"] == "token_v2":
+                        token = c["value"]
+            return {"token": token, "cookies": cookie_dict}
+        if isinstance(data, dict):
+            # Plain dict without "token" key — try to find token_v2 in values
+            token = data.get("token_v2", "")
+            return {"token": token, "cookies": data}
+        return None
+    except (json.JSONDecodeError, KeyError):
+        return None
+
+
+def save_auth(token: str, cookies: dict) -> None:
+    """Save auth data to file with restricted permissions."""
+    _ensure_dir()
+    data = {"token": token, "cookies": cookies}
+    AUTH_FILE.write_text(json.dumps(data, indent=2), encoding="utf-8")
+    # chmod 600 on Unix
+    if platform.system() != "Windows":
+        AUTH_FILE.chmod(stat.S_IRUSR | stat.S_IWUSR)
+
+
+def clear_auth() -> None:
+    """Remove auth file."""
+    if AUTH_FILE.exists():
+        AUTH_FILE.unlink()
+
+
+def get_bearer_token() -> str | None:
+    """Get the bearer token for OAuth API calls."""
+    auth = load_auth()
+    if not auth:
+        return None
+    return auth.get("token") or None
+
+
+def get_cookies() -> dict:
+    """Get cookies dict for session warmup."""
+    auth = load_auth()
+    if not auth:
+        return {}
+    return auth.get("cookies", {})
+
+
+def refresh_token() -> str | None:
+    """Silently refresh token_v2 using the persistent browser profile.
+
+    Launches a headless browser with the saved profile, navigates to Reddit
+    (which auto-refreshes the token_v2 cookie), extracts and saves the new token.
+    Returns the new token or None if refresh failed.
+    """
+    profile_dir = AUTH_DIR / "browser-profile"
+    if not profile_dir.exists():
+        return None
+
+    if sys.platform == "win32":
+        asyncio.set_event_loop_policy(asyncio.DefaultEventLoopPolicy())
+
+    try:
+        from playwright.sync_api import sync_playwright
+    except ImportError:
+        return None
+
+    try:
+        with sync_playwright() as p:
+            context = p.chromium.launch_persistent_context(
+                user_data_dir=str(profile_dir),
+                headless=True,
+                args=[
+                    "--disable-blink-features=AutomationControlled",
+                    "--no-first-run",
+                    "--no-default-browser-check",
+                ],
+            )
+
+            page = context.pages[0] if context.pages else context.new_page()
+            page.goto("https://www.reddit.com/", wait_until="domcontentloaded")
+            page.wait_for_timeout(3000)
+
+            cookies = context.cookies()
+            token = ""
+            cookie_dict = {}
+
+            for c in cookies:
+                if "reddit.com" in c.get("domain", ""):
+                    cookie_dict[c["name"]] = c["value"]
+                    if c["name"] == "token_v2":
+                        token = c["value"]
+
+            context.close()
+
+        if token:
+            save_auth(token, cookie_dict)
+            return token
+        return None
+    except Exception:
+        return None
+
+
+def login_browser() -> dict:
+    """Open browser for Reddit login, extract cookies and token.
+
+    Returns dict with 'token' and 'cookies' keys.
+    """
+    # Windows event loop fix
+    if sys.platform == "win32":
+        asyncio.set_event_loop_policy(asyncio.DefaultEventLoopPolicy())
+
+    from playwright.sync_api import sync_playwright
+
+    with sync_playwright() as p:
+        context = p.chromium.launch_persistent_context(
+            user_data_dir=str(AUTH_DIR / "browser-profile"),
+            headless=False,
+            args=[
+                "--disable-blink-features=AutomationControlled",
+                "--no-first-run",
+                "--no-default-browser-check",
+            ],
+        )
+
+        page = context.pages[0] if context.pages else context.new_page()
+        page.goto("https://www.reddit.com/login")
+
+        print("\n  Please log into Reddit in the browser window.")
+        print("  Press Enter here when you're logged in and see the Reddit homepage.\n")
+        input("  Waiting... ")
+
+        # Navigate to homepage to ensure all cookies are set
+        page.goto("https://www.reddit.com/")
+        page.wait_for_timeout(2000)
+
+        # Extract cookies
+        cookies = context.cookies()
+        cookie_dict = {}
+        token = ""
+
+        for c in cookies:
+            if "reddit.com" in c.get("domain", ""):
+                cookie_dict[c["name"]] = c["value"]
+                if c["name"] == "token_v2":
+                    token = c["value"]
+
+        context.close()
+
+    if not token:
+        raise AuthError("Login failed — no token_v2 cookie found. Please try again.")
+
+    save_auth(token, cookie_dict)
+    return {"token": token, "cookies": cookie_dict}