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

cli_web/chatgpt/README.md

@@ -0,0 +1,87 @@
+# cli-web-chatgpt
+
+CLI for ChatGPT web interface — ask questions, generate images, download images, manage conversations.
+
+## Installation
+
+```bash
+cd chatgpt/agent-harness
+pip install -e ".[auth]"
+playwright install chromium
+```
+
+## Authentication
+
+The CLI uses browser-based authentication. First capture your session:
+
+```bash
+# Option 1: Use playwright-cli to login and save state
+npx @playwright/cli@latest -s=chatgpt open https://chatgpt.com/ --headed --persistent
+# Log in, then:
+npx @playwright/cli@latest -s=chatgpt state-save chatgpt/traffic-capture/fresh-auth.json
+npx @playwright/cli@latest -s=chatgpt close
+
+# Option 2: Extract token from cookies
+# The CLI auto-extracts access tokens from saved browser state
+```
+
+Check auth status:
+```bash
+cli-web-chatgpt auth status --json
+```
+
+## Usage
+
+### Ask a question
+```bash
+cli-web-chatgpt chat ask "What is the capital of France?"
+cli-web-chatgpt chat ask "Explain quantum computing" --model gpt-5-3
+cli-web-chatgpt chat ask "What is 2+2?" --json
+```
+
+### Generate an image
+```bash
+cli-web-chatgpt chat image "A cat wearing a hat"
+cli-web-chatgpt chat image "Sunset over mountains" -o sunset.png
+cli-web-chatgpt chat image "Abstract art" --json
+```
+
+### List conversations
+```bash
+cli-web-chatgpt conversations list
+cli-web-chatgpt conversations list --limit 5
+cli-web-chatgpt conversations list --archived --json
+```
+
+### Browse generated images
+```bash
+cli-web-chatgpt images list
+cli-web-chatgpt images download <file_id> -c <conversation_id> -o image.png
+cli-web-chatgpt images styles
+```
+
+### Account info
+```bash
+cli-web-chatgpt me
+cli-web-chatgpt models
+```
+
+### REPL mode
+```bash
+cli-web-chatgpt          # Enters interactive REPL
+cli-web-chatgpt --json   # REPL with JSON output
+```
+
+## Architecture
+
+- **Read-only endpoints** (conversations, models, me, images): `curl_cffi` with Chrome TLS impersonation
+- **Chat/image generation**: Playwright headless browser (handles Cloudflare + sentinel anti-abuse)
+- **Auth**: Browser cookies + JWT access token from `/api/auth/session`
+
+## JSON Output
+
+All commands support `--json` for structured output:
+```json
+{"success": true, "data": {...}}
+{"error": true, "code": "AUTH_EXPIRED", "message": "..."}
+```

cli_web/chatgpt/__init__.py

@@ -0,0 +1,3 @@
+"""cli-web-chatgpt — CLI for ChatGPT web interface."""
+
+__version__ = "0.1.0"

cli_web/chatgpt/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as: python -m cli_web.chatgpt"""
+
+from .chatgpt_cli import main
+
+main()

cli_web/chatgpt/chatgpt_cli.py

@@ -0,0 +1,132 @@
+"""cli-web-chatgpt — CLI for ChatGPT web interface."""
+
+import sys
+
+if sys.stdout and sys.stdout.encoding and sys.stdout.encoding.lower() not in ("utf-8", "utf8"):
+    try:
+        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+    except AttributeError:
+        pass
+if sys.stderr and sys.stderr.encoding and sys.stderr.encoding.lower() not in ("utf-8", "utf8"):
+    try:
+        sys.stderr.reconfigure(encoding="utf-8", errors="replace")
+    except AttributeError:
+        pass
+
+import shlex
+
+import click
+
+from .commands.account import me, models
+from .commands.auth_cmd import auth_group
+from .commands.chat import chat_group
+from .commands.conversations import conversations_group
+from .commands.images import images_group
+from .utils.repl_skin import ReplSkin
+
+_skin = ReplSkin("chatgpt", version="0.1.0")
+
+
+@click.group(invoke_without_command=True)
+@click.version_option("0.1.0", prog_name="cli-web-chatgpt")
+@click.option("--json", "json_mode", is_flag=True, help="Output as JSON.")
+@click.pass_context
+def cli(ctx, json_mode: bool) -> None:
+    """CLI for ChatGPT — ask questions, generate images, manage conversations."""
+    ctx.ensure_object(dict)
+    ctx.obj["json"] = json_mode
+
+    if ctx.invoked_subcommand is None:
+        _run_repl(ctx)
+
+
+# Register command groups and standalone commands
+cli.add_command(chat_group)
+cli.add_command(conversations_group)
+cli.add_command(images_group)
+cli.add_command(auth_group)
+cli.add_command(me)
+cli.add_command(models)
+
+
+def _print_repl_help() -> None:
+    _skin.info("Available commands:")
+    print("  chat ask <question>           Ask ChatGPT a question")
+    print("    --model <slug>              Model (e.g. gpt-5-4-thinking)")
+    print("    --conversation <id>         Continue existing conversation")
+    print("  chat image <prompt>           Generate an image")
+    print("    --style <name>              Apply a style")
+    print("    --output <path>             Save image to file")
+    print("    --conversation <id>         Continue existing conversation")
+    print("  conversations list            List recent conversations")
+    print("    --limit <n>                 Number to show (default: 20)")
+    print("    --archived / --starred      Filter")
+    print("  conversations get <id>        View a conversation")
+    print("  images list                   List recently generated images")
+    print("  images download <file_id>     Download a generated image")
+    print("    --conversation <id>         (required) Conversation containing the image")
+    print("    --output <path>             Output file path")
+    print("  images styles                 List available image styles")
+    print("  models                        List available models")
+    print("  me                            Show current user info")
+    print("  auth login                    Login via browser")
+    print("  auth status                   Check auth status")
+    print("  auth logout                   Remove stored credentials")
+    print()
+    print("  help                          Show this help")
+    print("  exit / quit                   Exit REPL")
+
+
+def _run_repl(ctx) -> None:
+    _skin.print_banner()
+
+    while True:
+        try:
+            line = input(_skin.prompt()).strip()
+        except (EOFError, KeyboardInterrupt):
+            _skin.print_goodbye()
+            break
+
+        if not line:
+            continue
+        if line.lower() in ("exit", "quit", "q"):
+            _skin.print_goodbye()
+            break
+        if line.lower() in ("help", "?"):
+            _print_repl_help()
+            continue
+
+        try:
+            args = shlex.split(line)
+        except ValueError as exc:
+            _skin.error(f"Parse error: {exc}")
+            continue
+
+        repl_args = ["--json"] + args if ctx.obj.get("json") else args
+
+        try:
+            cli.main(args=repl_args, standalone_mode=False)
+        except SystemExit:
+            pass
+        except click.exceptions.UsageError as exc:
+            _skin.error(str(exc))
+        except Exception as exc:
+            _skin.error(f"{type(exc).__name__}: {exc}")
+
+
+def main():
+    cli()
+
+
+# MCP server mode — exposes every command as an MCP tool over stdio.
+# Canonical adapter: cli-web-core/cli_web_core/mcp_server.py (vendored copy).
+from cli_web.chatgpt import __version__ as _pkg_version  # noqa: E402
+from cli_web.chatgpt.utils.doctor import register_doctor_command  # noqa: E402
+from cli_web.chatgpt.utils.mcp_server import register_mcp_command  # noqa: E402
+
+register_mcp_command(cli, app_name="chatgpt", version=_pkg_version)
+register_doctor_command(cli, app_name="chatgpt", pkg="chatgpt")
+
+
+if __name__ == "__main__":
+    main()

cli_web/chatgpt/commands/account.py

@@ -0,0 +1,57 @@
+"""Account and model commands."""
+
+from __future__ import annotations
+
+import click
+
+from ..core.client import ChatGPTClient
+from ..utils.helpers import handle_errors, resolve_json_mode
+from ..utils.output import print_json
+
+
+@click.command("me")
+@click.option("--json", "json_mode", is_flag=True, help="Output as JSON.")
+@click.pass_context
+def me(ctx, json_mode: bool) -> None:
+    """Show current user info."""
+    json_mode = resolve_json_mode(json_mode)
+
+    with handle_errors(json_mode=json_mode):
+        with ChatGPTClient() as client:
+            data = client.get_me()
+
+            if json_mode:
+                print_json({"success": True, "data": data})
+                return
+
+            click.echo(f"Name:  {data.get('name', 'Unknown')}")
+            click.echo(f"Email: {data.get('email', 'Unknown')}")
+            click.echo(f"ID:    {data.get('id', 'Unknown')}")
+            orgs = data.get("orgs", {}).get("data", [])
+            if orgs:
+                org = orgs[0]
+                click.echo(f"Org:   {org.get('title', 'Unknown')}")
+
+
+@click.command("models")
+@click.option("--json", "json_mode", is_flag=True, help="Output as JSON.")
+@click.pass_context
+def models(ctx, json_mode: bool) -> None:
+    """List available models."""
+    json_mode = resolve_json_mode(json_mode)
+
+    with handle_errors(json_mode=json_mode):
+        with ChatGPTClient() as client:
+            model_list = client.get_models()
+
+            if json_mode:
+                print_json({"success": True, "data": model_list})
+                return
+
+            click.echo(f"{'Slug':<30} {'Title':<30} {'Tags'}")
+            click.echo("-" * 80)
+            for m in model_list:
+                slug = m.get("slug", "?")
+                title = m.get("title", "?")
+                tags = ", ".join(m.get("tags", []))
+                click.echo(f"{slug:<30} {title:<30} {tags}")

cli_web/chatgpt/commands/auth_cmd.py

@@ -0,0 +1,89 @@
+"""Auth management commands."""
+
+from __future__ import annotations
+
+import click
+
+from ..core.auth import clear_auth, is_logged_in, load_auth, login_browser
+from ..utils.helpers import handle_errors
+from ..utils.output import print_json
+
+
+@click.group("auth")
+def auth_group():
+    """Manage authentication."""
+
+
+@auth_group.command("login")
+@click.pass_context
+def login(ctx) -> None:
+    """Login to ChatGPT via browser."""
+    json_mode = ctx.obj.get("json", False) if ctx.obj else False
+
+    with handle_errors(json_mode=json_mode):
+        auth_data = login_browser()
+        if json_mode:
+            print_json(
+                {
+                    "success": True,
+                    "data": {"message": "Logged in successfully"},
+                }
+            )
+        else:
+            click.echo("Logged in successfully.")
+            if auth_data.get("device_id"):
+                click.echo(f"Device ID: {auth_data['device_id']}")
+
+
+@auth_group.command("status")
+@click.pass_context
+def status(ctx) -> None:
+    """Check authentication status."""
+    json_mode = ctx.obj.get("json", False) if ctx.obj else False
+
+    with handle_errors(json_mode=json_mode):
+        if not is_logged_in():
+            if json_mode:
+                print_json(
+                    {
+                        "success": True,
+                        "data": {"logged_in": False},
+                    }
+                )
+            else:
+                click.echo("Not logged in. Run: cli-web-chatgpt auth login")
+            return
+
+        auth = load_auth()
+        token_preview = auth["access_token"][:20] + "..."
+        device_id = auth.get("device_id", "unknown")
+
+        if json_mode:
+            print_json(
+                {
+                    "success": True,
+                    "data": {
+                        "logged_in": True,
+                        "device_id": device_id,
+                        "token_preview": token_preview,
+                    },
+                }
+            )
+        else:
+            click.echo("Logged in.")
+            click.echo(f"Device ID: {device_id}")
+            click.echo(f"Token: {token_preview}")
+
+
+@auth_group.command("logout")
+@click.pass_context
+def logout(ctx) -> None:
+    """Remove stored credentials."""
+    json_mode = ctx.obj.get("json", False) if ctx.obj else False
+
+    with handle_errors(json_mode=json_mode):
+        clear_auth()
+        if json_mode:
+            print_json({"success": True, "data": {"message": "Logged out"}})
+        else:
+            click.echo("Logged out. Credentials removed.")

cli_web/chatgpt/commands/chat.py

@@ -0,0 +1,146 @@
+"""Chat commands — ask questions and generate images with ChatGPT."""
+
+from __future__ import annotations
+
+import click
+
+from ..core.client import ChatGPTClient
+from ..utils.helpers import handle_errors, resolve_json_mode
+from ..utils.output import print_json
+
+try:
+    from rich.console import Console
+    from rich.markdown import Markdown
+
+    _RICH = True
+except ImportError:
+    _RICH = False
+
+
+@click.group("chat")
+def chat_group():
+    """Send messages and generate images with ChatGPT."""
+
+
+@chat_group.command("ask")
+@click.argument("question")
+@click.option(
+    "--model",
+    default=None,
+    help="Model slug (e.g. gpt-5-4-thinking). Use 'models' command to list.",
+)
+@click.option("--conversation", default=None, help="Continue an existing conversation by ID.")
+@click.option("--json", "json_mode", is_flag=True, help="Output as JSON.")
+@click.pass_context
+def ask(ctx, question: str, model: str | None, conversation: str | None, json_mode: bool) -> None:
+    """Ask ChatGPT a question."""
+    json_mode = resolve_json_mode(json_mode)
+
+    with handle_errors(json_mode=json_mode):
+        with ChatGPTClient() as client:
+            if _RICH and not json_mode:
+                console = Console(stderr=True)
+                with console.status("Thinking..."):
+                    result = client.send_message(
+                        message=question,
+                        conversation_id=conversation,
+                        model=model,
+                    )
+            else:
+                result = client.send_message(
+                    message=question,
+                    conversation_id=conversation,
+                    model=model,
+                )
+
+            text = result.get("text", "")
+            conv_id = result.get("conversation_id")
+
+            if json_mode:
+                print_json(
+                    {
+                        "success": True,
+                        "data": {
+                            "text": text,
+                            "conversation_id": conv_id,
+                            "model": model or "default",
+                        },
+                    }
+                )
+            else:
+                if _RICH and text:
+                    Console().print(Markdown(text))
+                else:
+                    click.echo(text or "(no response)")
+
+
+@chat_group.command("image")
+@click.argument("prompt")
+@click.option("--style", default=None, help="Image style to prepend to prompt.")
+@click.option("--output", "-o", default=None, type=click.Path(), help="Save image to file.")
+@click.option("--conversation", default=None, help="Continue an existing conversation by ID.")
+@click.option("--json", "json_mode", is_flag=True, help="Output as JSON.")
+@click.pass_context
+def image(
+    ctx,
+    prompt: str,
+    style: str | None,
+    output: str | None,
+    conversation: str | None,
+    json_mode: bool,
+) -> None:
+    """Generate an image with ChatGPT."""
+    json_mode = resolve_json_mode(json_mode)
+    full_prompt = f"{style} style: {prompt}" if style else prompt
+
+    with handle_errors(json_mode=json_mode):
+        with ChatGPTClient() as client:
+            if _RICH and not json_mode:
+                console = Console(stderr=True)
+                with console.status("Generating image..."):
+                    result = client.send_message(
+                        message=full_prompt,
+                        conversation_id=conversation,
+                        image_mode=True,
+                    )
+            else:
+                result = client.send_message(
+                    message=full_prompt,
+                    conversation_id=conversation,
+                    image_mode=True,
+                )
+
+            file_id = result.get("file_id")
+            conv_id = result.get("conversation_id")
+            download_url = result.get("download_url")
+            text = result.get("text", "")
+
+            # Auto-download if output path given
+            if output and download_url:
+                img_bytes = client.download_file(download_url)
+                with open(output, "wb") as f:
+                    f.write(img_bytes)
+                if not json_mode:
+                    click.echo(f"Image saved to {output} ({len(img_bytes)} bytes)")
+
+            if json_mode:
+                data = {
+                    "file_id": file_id,
+                    "conversation_id": conv_id,
+                    "download_url": download_url,
+                    "text": text or None,
+                }
+                if output and download_url:
+                    data["saved_to"] = output
+                print_json({"success": True, "data": data})
+            elif not output:
+                if file_id:
+                    click.echo(f"Image generated: file_id={file_id}")
+                    if download_url:
+                        click.echo(
+                            f"Download: cli-web-chatgpt images download {file_id} -c {conv_id}"
+                        )
+                elif text:
+                    click.echo(text)
+                else:
+                    click.echo("No image was generated.", err=True)

cli_web/chatgpt/commands/conversations.py

@@ -0,0 +1,87 @@
+"""Conversation management commands."""
+
+from __future__ import annotations
+
+import click
+
+from ..core.client import ChatGPTClient
+from ..utils.helpers import handle_errors, resolve_json_mode
+from ..utils.output import print_json, truncate
+
+
+@click.group("conversations")
+def conversations_group():
+    """List and view conversations."""
+
+
+@conversations_group.command("list")
+@click.option("--limit", "-n", default=20, help="Number of conversations to show.")
+@click.option("--archived", is_flag=True, help="Show archived conversations.")
+@click.option("--starred", is_flag=True, help="Show starred conversations only.")
+@click.option("--json", "json_mode", is_flag=True, help="Output as JSON.")
+@click.pass_context
+def list_conversations(ctx, limit: int, archived: bool, starred: bool, json_mode: bool) -> None:
+    """List recent conversations."""
+    json_mode = resolve_json_mode(json_mode)
+
+    with handle_errors(json_mode=json_mode):
+        with ChatGPTClient() as client:
+            data = client.list_conversations(limit=limit, archived=archived, starred=starred)
+
+            if json_mode:
+                print_json({"success": True, "data": data})
+                return
+
+            items = data.get("items", [])
+            if not items:
+                click.echo("No conversations found.")
+                return
+
+            click.echo(f"{'Title':<50} {'Updated':<20} {'ID'}")
+            click.echo("-" * 100)
+            for conv in items:
+                title = truncate(conv.get("title", "Untitled"), 48)
+                updated = (conv.get("update_time") or "")[:19]
+                cid = conv.get("id", "")
+                click.echo(f"{title:<50} {updated:<20} {cid}")
+
+
+@conversations_group.command("get")
+@click.argument("conversation_id")
+@click.option("--json", "json_mode", is_flag=True, help="Output as JSON.")
+@click.pass_context
+def get_conversation(ctx, conversation_id: str, json_mode: bool) -> None:
+    """View a conversation by ID."""
+    json_mode = resolve_json_mode(json_mode)
+
+    with handle_errors(json_mode=json_mode):
+        with ChatGPTClient() as client:
+            data = client.get_conversation(conversation_id)
+
+            if json_mode:
+                print_json({"success": True, "data": data})
+                return
+
+            title = data.get("title", "Untitled")
+            click.echo(f"Conversation: {title}")
+            click.echo(f"ID: {conversation_id}")
+            click.echo(f"Created: {data.get('create_time', 'unknown')}")
+            click.echo(f"Updated: {data.get('update_time', 'unknown')}")
+
+            mapping = data.get("mapping", {})
+            if mapping:
+                click.echo(f"\nMessages ({len(mapping)}):")
+                for _msg_id, node in mapping.items():
+                    msg = node.get("message")
+                    if not msg:
+                        continue
+                    role = msg.get("author", {}).get("role", "?")
+                    content = msg.get("content", {})
+                    parts = content.get("parts", [])
+                    text = ""
+                    for part in parts:
+                        if isinstance(part, str):
+                            text += part
+                    if text:
+                        preview = truncate(text, 80)
+                        click.echo(f"  [{role}] {preview}")