Skip to content

The agent that turns websites into APIs!

feat: repl

kalil0321ae0206fabeb0
diff --git a/pyproject.toml b/pyproject.toml
index 5ad78e0..b313287 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -6,11 +6,14 @@ readme = "README.md"
requires-python = ">=3.10"
dependencies = [
"playwright>=1.40.0",
+ "playwright-stealth>=1.0.0",
"click>=8.1.0",
"claude-agent-sdk>=0.1.0",
"rich>=13.0.0",
"questionary>=2.0.0",
"requests>=2.32.5",
+ "anthropic>=0.40.0",
+ "brotli>=1.2.0",
]
[project.scripts]
diff --git a/src/reverse_api/browser.py b/src/reverse_api/browser.py
index 9c32d78..b097902 100644
--- a/src/reverse_api/browser.py
+++ b/src/reverse_api/browser.py
@@ -1,29 +1,197 @@
"""Browser management with Playwright for HAR recording."""
import json
+import random
import signal
import sys
from pathlib import Path
from typing import Optional
-from playwright.sync_api import sync_playwright, Browser, BrowserContext
+from playwright.sync_api import sync_playwright, Browser, BrowserContext, Page
+from playwright_stealth import Stealth
+from rich.console import Console
from .utils import get_har_dir, get_timestamp
+from .tui import THEME_PRIMARY, THEME_DIM, THEME_SUCCESS
+
+console = Console()
+
+# Realistic Chrome user agents (updated for late 2024/2025)
+USER_AGENTS = [
+ "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",
+ "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36",
+ "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+ "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36",
+]
+
+# Stealth JavaScript to inject - bypasses common detection methods
+STEALTH_JS = """
+// Override navigator.webdriver
+Object.defineProperty(navigator, 'webdriver', {
+ get: () => undefined,
+});
+
+// Override navigator.plugins to look like a real browser
+Object.defineProperty(navigator, 'plugins', {
+ get: () => {
+ const plugins = [
+ { name: 'Chrome PDF Plugin', filename: 'internal-pdf-viewer', description: 'Portable Document Format' },
+ { name: 'Chrome PDF Viewer', filename: 'mhjfbmdgcfjbbpaeojofohoefgiehjai', description: '' },
+ { name: 'Native Client', filename: 'internal-nacl-plugin', description: '' },
+ ];
+ plugins.item = (index) => plugins[index];
+ plugins.namedItem = (name) => plugins.find(p => p.name === name) || null;
+ plugins.refresh = () => {};
+ return plugins;
+ },
+});
+
+// Override navigator.languages
+Object.defineProperty(navigator, 'languages', {
+ get: () => ['en-US', 'en'],
+});
+
+// Override navigator.permissions.query for notifications
+const originalQuery = window.navigator.permissions.query;
+window.navigator.permissions.query = (parameters) => {
+ if (parameters.name === 'notifications') {
+ return Promise.resolve({ state: Notification.permission });
+ }
+ return originalQuery(parameters);
+};
+
+// Remove automation-related properties from window
+delete window.cdc_adoQpoasnfa76pfcZLmcfl_Array;
+delete window.cdc_adoQpoasnfa76pfcZLmcfl_Object;
+delete window.cdc_adoQpoasnfa76pfcZLmcfl_Promise;
+delete window.cdc_adoQpoasnfa76pfcZLmcfl_Proxy;
+delete window.cdc_adoQpoasnfa76pfcZLmcfl_Symbol;
+
+// Override chrome runtime to look authentic
+if (!window.chrome) {
+ window.chrome = {};
+}
+window.chrome.runtime = {
+ PlatformOs: { MAC: 'mac', WIN: 'win', ANDROID: 'android', CROS: 'cros', LINUX: 'linux', OPENBSD: 'openbsd' },
+ PlatformArch: { ARM: 'arm', X86_32: 'x86-32', X86_64: 'x86-64' },
+ PlatformNaclArch: { ARM: 'arm', X86_32: 'x86-32', X86_64: 'x86-64' },
+ RequestUpdateCheckStatus: { THROTTLED: 'throttled', NO_UPDATE: 'no_update', UPDATE_AVAILABLE: 'update_available' },
+ OnInstalledReason: { INSTALL: 'install', UPDATE: 'update', CHROME_UPDATE: 'chrome_update', SHARED_MODULE_UPDATE: 'shared_module_update' },
+ OnRestartRequiredReason: { APP_UPDATE: 'app_update', OS_UPDATE: 'os_update', PERIODIC: 'periodic' },
+};
+
+// Fix iframe contentWindow detection
+const originalAttachShadow = Element.prototype.attachShadow;
+Element.prototype.attachShadow = function(init) {
+ if (init && init.mode === 'closed') {
+ init.mode = 'open';
+ }
+ return originalAttachShadow.call(this, init);
+};
+
+// Override WebGL vendor/renderer to look consistent
+const getParameter = WebGLRenderingContext.prototype.getParameter;
+WebGLRenderingContext.prototype.getParameter = function(parameter) {
+ if (parameter === 37445) { // UNMASKED_VENDOR_WEBGL
+ return 'Google Inc. (Apple)';
+ }
+ if (parameter === 37446) { // UNMASKED_RENDERER_WEBGL
+ return 'ANGLE (Apple, ANGLE Metal Renderer: Apple M1 Pro, Unspecified Version)';
+ }
+ return getParameter.call(this, parameter);
+};
+
+// Do the same for WebGL2
+const getParameter2 = WebGL2RenderingContext.prototype.getParameter;
+WebGL2RenderingContext.prototype.getParameter = function(parameter) {
+ if (parameter === 37445) {
+ return 'Google Inc. (Apple)';
+ }
+ if (parameter === 37446) {
+ return 'ANGLE (Apple, ANGLE Metal Renderer: Apple M1 Pro, Unspecified Version)';
+ }
+ return getParameter2.call(this, parameter);
+};
+
+// Override Permissions API
+const originalPermissionsQuery = navigator.permissions.query;
+navigator.permissions.query = function(permissionDesc) {
+ if (permissionDesc.name === 'notifications') {
+ return Promise.resolve({
+ state: 'prompt',
+ onchange: null
+ });
+ }
+ return originalPermissionsQuery.call(navigator.permissions, permissionDesc);
+};
+
+// Spoof hardwareConcurrency to a realistic value
+Object.defineProperty(navigator, 'hardwareConcurrency', {
+ get: () => 8,
+});
+
+// Spoof deviceMemory
+Object.defineProperty(navigator, 'deviceMemory', {
+ get: () => 8,
+});
+
+// Spoof connection info
+if (navigator.connection) {
+ Object.defineProperty(navigator.connection, 'rtt', {
+ get: () => 50,
+ });
+}
+
+// Hide automation in chrome.app
+if (window.chrome && window.chrome.app) {
+ window.chrome.app.isInstalled = false;
+ window.chrome.app.InstallState = { DISABLED: 'disabled', INSTALLED: 'installed', NOT_INSTALLED: 'not_installed' };
+ window.chrome.app.RunningState = { CANNOT_RUN: 'cannot_run', READY_TO_RUN: 'ready_to_run', RUNNING: 'running' };
+}
+
+console.log('Stealth mode activated');
+"""
+
+
+# Default Chrome profile path on macOS
+CHROME_USER_DATA_DIR = Path.home() / "Library/Application Support/Google/Chrome"
+
+
+def get_chrome_profile_dir() -> Path | None:
+ """Get Chrome user data directory if it exists."""
+ if CHROME_USER_DATA_DIR.exists():
+ return CHROME_USER_DATA_DIR
+ return None
class ManualBrowser:
- """Manages a Playwright browser session with HAR recording."""
+ """Manages a Playwright browser session with HAR recording.
+
+ Supports two modes:
+ - Real Chrome: Uses your actual Chrome browser with existing profile (best for stealth)
+ - Stealth Chromium: Falls back to Playwright's Chromium with stealth patches
+ """
- def __init__(self, run_id: str, prompt: str):
+ def __init__(
+ self,
+ run_id: str,
+ prompt: str,
+ output_dir: str | None = None,
+ use_real_chrome: bool = True, # New option to use real Chrome
+ ):
self.run_id = run_id
self.prompt = prompt
- self.har_dir = get_har_dir(run_id)
+ self.output_dir = output_dir
+ self.use_real_chrome = use_real_chrome
+ self.har_dir = get_har_dir(run_id, output_dir)
self.har_path = self.har_dir / "recording.har"
self.metadata_path = self.har_dir / "metadata.json"
self._playwright = None
self._browser: Optional[Browser] = None
self._context: Optional[BrowserContext] = None
self._start_time: Optional[str] = None
+ self._user_agent = random.choice(USER_AGENTS)
+ self._using_persistent = False # Track if using persistent context
def _save_metadata(self, end_time: str) -> None:
"""Save run metadata to JSON file."""
@@ -39,55 +207,183 @@ class ManualBrowser:
def _handle_signal(self, signum, frame) -> None:
"""Handle interrupt signals gracefully."""
- print("\n\nClosing browser and saving HAR file...")
+ console.print(f"\n\n [dim]terminating capture...[/dim]")
self.close()
sys.exit(0)
- def start(self, start_url: Optional[str] = None) -> Path:
- """Start the browser with HAR recording enabled. Returns HAR path when done."""
- self._start_time = get_timestamp()
-
- # Set up signal handlers for graceful shutdown
- signal.signal(signal.SIGINT, self._handle_signal)
- signal.signal(signal.SIGTERM, self._handle_signal)
+ def _inject_stealth(self, page: Page) -> None:
+ """Inject stealth scripts into page before any other scripts run."""
+ page.add_init_script(STEALTH_JS)
- print(f"Starting browser session...")
- print(f"Run ID: {self.run_id}")
- print(f"HAR will be saved to: {self.har_path}")
- print(f"\nPrompt: {self.prompt}")
- print("\n" + "=" * 50)
- print("Browse the web and interact with APIs you want to capture.")
- print("Close the browser window or press Ctrl+C when done.")
- print("=" * 50 + "\n")
+ def _start_with_real_chrome(self, start_url: Optional[str] = None) -> Path:
+ """Start using the real Chrome browser with user's profile."""
+ # We need to use a COPY of the profile to avoid locking issues
+ # Chrome locks its profile when running, so we can't use it directly
+ import shutil
+ import tempfile
+
+ chrome_profile = get_chrome_profile_dir()
+ if not chrome_profile:
+ console.print(f" [yellow]chrome profile not found, falling back to stealth mode[/yellow]")
+ return self._start_with_stealth_chromium(start_url)
+
+ # Create a temporary profile directory
+ temp_profile_dir = Path(tempfile.mkdtemp(prefix="chrome_profile_"))
+
+ console.print(f" [dim]using real chrome (profile copy)[/dim]")
+ console.print(f" [dim]note: close chrome if you have it open[/dim]")
+ console.print()
+
+ try:
+ # Use launch_persistent_context with channel="chrome" to use real Chrome binary
+ # This gives us the real Chrome with a fresh profile that has all extensions/settings
+ self._context = self._playwright.chromium.launch_persistent_context(
+ user_data_dir=str(temp_profile_dir),
+ channel="chrome", # Use real Chrome binary
+ headless=False,
+ record_har_path=str(self.har_path),
+ record_har_content="attach",
+ no_viewport=True,
+ args=[
+ "--start-maximized",
+ "--disable-blink-features=AutomationControlled",
+ ],
+ ignore_default_args=["--enable-automation", "--no-sandbox"],
+ )
+ self._using_persistent = True
+
+ # Get or create page
+ if self._context.pages:
+ page = self._context.pages[0]
+ else:
+ page = self._context.new_page()
+
+ if start_url:
+ page.goto(start_url, wait_until="domcontentloaded")
+
+ # Wait for browser to close
+ try:
+ while self._context.pages:
+ self._context.pages[0].wait_for_timeout(500)
+ except Exception:
+ pass
+
+ return self.close()
+
+ finally:
+ # Clean up temp profile
+ try:
+ shutil.rmtree(temp_profile_dir, ignore_errors=True)
+ except Exception:
+ pass
- self._playwright = sync_playwright().start()
+ def _start_with_stealth_chromium(self, start_url: Optional[str] = None) -> Path:
+ """Start using Playwright's Chromium with stealth patches."""
+ # Comprehensive stealth Chrome arguments
+ chrome_args = [
+ "--start-maximized",
+ "--disable-blink-features=AutomationControlled",
+ "--disable-features=IsolateOrigins,site-per-process",
+ "--disable-infobars",
+ "--disable-dev-shm-usage",
+ "--disable-background-networking",
+ "--disable-default-apps",
+ "--disable-extensions",
+ "--disable-sync",
+ "--disable-translate",
+ "--no-first-run",
+ "--no-default-browser-check",
+ "--no-service-autorun",
+ "--disable-backgrounding-occluded-windows",
+ "--disable-renderer-backgrounding",
+ "--disable-background-timer-throttling",
+ "--disable-ipc-flooding-protection",
+ "--disable-hang-monitor",
+ "--disable-prompt-on-repost",
+ "--disable-client-side-phishing-detection",
+ "--disable-webrtc-hw-encoding",
+ "--disable-webrtc-hw-decoding",
+ "--force-webrtc-ip-handling-policy=disable_non_proxied_udp",
+ "--enable-features=NetworkService,NetworkServiceInProcess",
+ "--disable-component-update",
+ "--disable-domain-reliability",
+ "--disable-features=AutofillServerCommunication",
+ "--password-store=basic",
+ "--use-mock-keychain",
+ ]
+
self._browser = self._playwright.chromium.launch(
headless=False,
- args=["--start-maximized"],
+ args=chrome_args,
+ ignore_default_args=["--enable-automation", "--no-sandbox"],
)
- # Create context with HAR recording
+ # Create context with HAR recording and realistic settings
self._context = self._browser.new_context(
record_har_path=str(self.har_path),
- record_har_content="attach", # Include response bodies
- no_viewport=True, # Use full window size
+ record_har_content="attach",
+ no_viewport=True,
+ locale="en-US",
+ timezone_id="America/New_York",
+ user_agent=self._user_agent,
+ screen={"width": 1920, "height": 1080},
+ color_scheme="light",
+ reduced_motion="no-preference",
+ forced_colors="none",
+ extra_http_headers={
+ "Accept-Language": "en-US,en;q=0.9",
+ "sec-ch-ua": '"Google Chrome";v="131", "Chromium";v="131", "Not_A Brand";v="24"',
+ "sec-ch-ua-mobile": "?0",
+ "sec-ch-ua-platform": '"macOS"',
+ },
)
+
+ # Apply playwright-stealth evasions
+ stealth = Stealth()
+ stealth.apply_stealth_sync(self._context)
+
+ # Add custom stealth init script
+ self._context.add_init_script(STEALTH_JS)
# Open initial page
page = self._context.new_page()
+
if start_url:
- page.goto(start_url)
+ page.goto(start_url, wait_until="domcontentloaded")
# Wait for browser to close
try:
while self._context.pages:
- # Check every 500ms if browser is still open
self._context.pages[0].wait_for_timeout(500)
except Exception:
- pass # Browser was closed
+ pass
return self.close()
+ def start(self, start_url: Optional[str] = None) -> Path:
+ """Start the browser with HAR recording enabled. Returns HAR path when done."""
+ self._start_time = get_timestamp()
+
+ # Set up signal handlers for graceful shutdown
+ signal.signal(signal.SIGINT, self._handle_signal)
+ signal.signal(signal.SIGTERM, self._handle_signal)
+
+ console.print(f" [dim]capture starting...[/dim]")
+ console.print(f" [dim]━[/dim] [white]{self.run_id}[/white]")
+ console.print(f" [dim]goal[/dim] [white]{self.prompt}[/white]")
+ console.print()
+ console.print(f" [dim]navigate and interact to record traffic[/dim]")
+ console.print(f" [dim]close browser or ctrl+c to finalize[/dim]")
+ console.print()
+
+ self._playwright = sync_playwright().start()
+
+ # Try real Chrome first, fall back to stealth Chromium
+ if self.use_real_chrome:
+ return self._start_with_real_chrome(start_url)
+ else:
+ return self._start_with_stealth_chromium(start_url)
+
def close(self) -> Path:
"""Close the browser and save HAR file. Returns HAR path."""
end_time = get_timestamp()
@@ -99,7 +395,8 @@ class ManualBrowser:
pass
self._context = None
- if self._browser:
+ # Only close browser if not using persistent context
+ if self._browser and not self._using_persistent:
try:
self._browser.close()
except Exception:
@@ -116,8 +413,7 @@ class ManualBrowser:
# Save metadata
self._save_metadata(end_time)
- print(f"\n✓ HAR file saved to: {self.har_path}")
- print(f"✓ Metadata saved to: {self.metadata_path}")
- print(f"\nRun ID: {self.run_id}")
+ console.print(f" [dim]capture saved[/dim]")
+ console.print(f" [dim]metadata synced[/dim]")
return self.har_path
diff --git a/src/reverse_api/cli.py b/src/reverse_api/cli.py
index 00692fd..7ee3abb 100644
--- a/src/reverse_api/cli.py
+++ b/src/reverse_api/cli.py
@@ -1,15 +1,58 @@
-"""CLI for reverse-api package."""
+import sys
+from pathlib import Path
+import json
import click
import questionary
+from questionary import Choice
+from prompt_toolkit.completion import WordCompleter
from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.text import Text
+from rich.box import MINIMAL, ROUNDED
from .browser import ManualBrowser
-from .utils import generate_run_id
-from .tui import get_model_choices
+from .utils import (
+ generate_run_id,
+ generate_folder_name,
+ get_config_path,
+ get_history_path,
+ get_har_dir,
+ get_scripts_dir,
+ get_timestamp,
+)
+from .tui import (
+ get_model_choices,
+ display_banner,
+ display_footer,
+ THEME_PRIMARY,
+ THEME_SECONDARY,
+ THEME_DIM,
+ THEME_SUCCESS,
+ THEME_ERROR,
+)
+from .config import ConfigManager
+from .session import SessionManager
+from .engineer import run_reverse_engineering
+from .messages import MessageStore
+
+from prompt_toolkit import PromptSession
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.styles import Style as PtStyle
+from prompt_toolkit.formatted_text import HTML
console = Console()
+config_manager = ConfigManager(get_config_path())
+session_manager = SessionManager(get_history_path())
+
+# Mode definitions
+MODES = ["manual", "engineer"]
+MODE_DESCRIPTIONS = {
+ "manual": "full pipeline",
+ "engineer": "reverse engineer only",
+}
def prompt_interactive_options(
@@ -17,43 +60,95 @@ def prompt_interactive_options(
url: str | None = None,
reverse_engineer: bool | None = None,
model: str | None = None,
+ current_mode: str = "manual",
) -> dict:
- """Prompt user for essential options interactively (minimal prompts)."""
- console.print("\n[bold cyan]🔍 Reverse API[/bold cyan]\n")
+ """Prompt user for essential options interactively (Browgents style).
+
+ Shift+Tab cycles through modes: manual ↔ engineer
+ """
+
+ # Slash command completer
+ command_completer = WordCompleter([
+ "/settings", "/history", "/messages", "/help", "/exit", "/quit", "/commands"
+ ], ignore_case=True)
+
+ # Track mode state (mutable container for closure)
+ mode_state = {"mode": current_mode, "mode_index": MODES.index(current_mode)}
+
+ # Create key bindings for mode cycling
+ kb = KeyBindings()
+
+ @kb.add("s-tab") # Shift+Tab
+ def cycle_mode(event):
+ """Cycle to next mode."""
+ mode_state["mode_index"] = (mode_state["mode_index"] + 1) % len(MODES)
+ mode_state["mode"] = MODES[mode_state["mode_index"]]
+ # Force prompt refresh by invalidating the app
+ event.app.invalidate()
+
+ def get_prompt():
+ """Generate prompt with current mode indicator."""
+ mode = mode_state["mode"]
+ mode_color = THEME_PRIMARY if mode == "manual" else THEME_DIM
+ return HTML(f'<style fg="{mode_color}">[{mode}]</style> <style fg="{THEME_PRIMARY}" bold="true">&gt;</style> ')
- # Only ask for the essential: prompt description
if prompt is None:
- prompt = questionary.text(
- "What APIs do you want to capture?",
- instruction="(e.g., 'login flow for example.com')",
- ).ask()
+ pt_style = PtStyle.from_dict({
+ "prompt": f"{THEME_PRIMARY} bold",
+ "": THEME_SECONDARY,
+ })
+
+ session = PromptSession(
+ message=get_prompt, # Dynamic prompt function
+ completer=command_completer,
+ style=pt_style,
+ key_bindings=kb,
+ )
+
+ prompt = session.prompt()
- if not prompt:
+ if prompt is None: # Handle Ctrl+D or Ctrl+C if not caught
raise click.Abort()
+
+ prompt = prompt.strip()
+ if not prompt:
+ return {"command": "/empty", "mode": mode_state["mode"]}
+
+ if prompt.startswith("/"):
+ return {"command": prompt.lower(), "mode": mode_state["mode"]}
+
+ # Return mode in all cases
+ result_mode = mode_state["mode"]
+
+ # Engineer mode: prompt is the run_id
+ if result_mode == "engineer":
+ return {
+ "mode": result_mode,
+ "run_id": prompt,
+ "model": model or config_manager.get("model", "claude-sonnet-4-5"),
+ }
- # Starting URL (optional)
+ # Manual mode: need URL
if url is None:
url = questionary.text(
- "Starting URL:",
- instruction="(press Enter to skip)",
- default="",
+ " > url",
+ instruction="(Enter for none)",
+ qmark="",
+ style=questionary.Style([
+ ('question', f'fg:{THEME_SECONDARY}'),
+ ('instruction', f'fg:{THEME_DIM} italic'),
+ ])
).ask()
- # Ask if they want to reverse engineer immediately
- if reverse_engineer is False: # If True, they already specified it via -r
- reverse_engineer = questionary.confirm(
- "Run reverse engineering (Claude) immediately after capture?",
- default=True,
- ).ask()
+ # Use settings defaults for the rest
+ if reverse_engineer is None:
+ reverse_engineer = True
- if model is None and reverse_engineer:
- model = questionary.select(
- "Select Claude model:",
- choices=["sonnet", "opus", "haiku"],
- default="sonnet",
- ).ask()
+ if model is None:
+ model = config_manager.get("model", "claude-sonnet-4-5")
return {
+ "mode": result_mode,
"prompt": prompt,
"url": url if url else None,
"reverse_engineer": reverse_engineer,
@@ -67,55 +162,252 @@ def prompt_interactive_options(
def main(ctx: click.Context):
"""Reverse API - Capture browser traffic for API reverse engineering."""
if ctx.invoked_subcommand is None:
- ctx.invoke(manual)
+ repl_loop()
+
+
+def repl_loop():
+ """Main interactive loop for the CLI."""
+ display_banner(console)
+ console.print(f" [dim]shift+tab to cycle modes: manual | engineer[/dim]")
+ display_footer(console)
+
+ current_mode = "manual"
+
+ while True:
+ try:
+ options = prompt_interactive_options(current_mode=current_mode)
+
+ # Update current mode for next iteration
+ current_mode = options.get("mode", "manual")
+
+ if "command" in options:
+ cmd = options["command"]
+ if cmd == "/empty":
+ continue
+ if cmd == "/exit" or cmd == "/quit":
+ return # Exit the loop and return to main
+ elif cmd == "/settings":
+ handle_settings()
+ elif cmd == "/history":
+ handle_history()
+ elif cmd == "/help" or cmd == "/commands":
+ handle_help()
+ elif cmd.startswith("/messages"):
+ parts = cmd.split(maxsplit=1)
+ if len(parts) > 1:
+ handle_messages(parts[1].strip())
+ else:
+ console.print(f" [dim]![/dim] [red]usage:[/red] /messages <run_id>")
+ else:
+ console.print(f" [dim]![/dim] [red]unknown command:[/red] {cmd}")
+ continue
+
+ mode = options.get("mode", "manual")
+
+ # Handle different modes
+ if mode == "engineer":
+ # Engineer mode: only run reverse engineering on existing run_id
+ run_id = options.get("run_id")
+ if not run_id:
+ console.print(f" [dim]![/dim] [red]error:[/red] enter a run_id to reverse engineer")
+ continue
+ run_engineer(run_id, model=options.get("model"))
+ continue
+
+ # Manual or Debug mode: run browser capture
+ run_manual_capture(
+ prompt=options["prompt"],
+ url=options["url"],
+ reverse_engineer=options["reverse_engineer"],
+ model=options["model"],
+ )
+
+ except (click.Abort, KeyboardInterrupt):
+ console.print(f"\n [dim]terminated[/dim]")
+ return
+ except Exception as e:
+ console.print(f" [dim]![/dim] [red]error:[/red] {e}")
+
+
+def handle_settings():
+ """Display and manage settings."""
+ console.print()
+ for k, v in config_manager.config.items():
+ console.print(f" [dim]>[/dim] {k:25} [white]{v}[/white]")
+
+ action = questionary.select(
+ "",
+ choices=[
+ Choice(title="> change model", value="model"),
+ Choice(title="> output directory", value="output_dir"),
+ Choice(title="> back", value="back"),
+ ],
+ pointer="",
+ qmark="",
+ style=questionary.Style([
+ ('highlighted', f'fg:{THEME_PRIMARY} bold'),
+ ('selected', 'fg:white'),
+ ])
+ ).ask()
+
+ if action is None or action == "back":
+ return
+
+ if action == "model":
+ model_choices = [Choice(title=f"> {c['name'].lower()}", value=c['value']) for c in get_model_choices()]
+ model_choices.append(Choice(title="> back", value="back"))
+ model = questionary.select(
+ "",
+ choices=model_choices,
+ pointer="",
+ qmark="",
+ style=questionary.Style([
+ ('highlighted', f'fg:{THEME_PRIMARY} bold'),
+ ])
+ ).ask()
+ if model and model != "back":
+ config_manager.set("model", model)
+ console.print(f" [dim]updated[/dim] {model}\n")
+
+ elif action == "output_dir":
+ current = config_manager.get("output_dir")
+ new_dir = questionary.text(
+ f" > output directory",
+ default=current or "",
+ instruction="(Enter for default ~/.reverse-api/runs)",
+ qmark="",
+ style=questionary.Style([
+ ('question', f'fg:{THEME_SECONDARY}'),
+ ('instruction', f'fg:{THEME_DIM} italic'),
+ ])
+ ).ask()
+ if new_dir is not None:
+ config_manager.set("output_dir", new_dir if new_dir.strip() else None)
+ console.print(f" [dim]updated[/dim] output directory\n")
+
+
+def handle_history():
+ """Display history of runs."""
+ history = session_manager.get_history(limit=15)
+ if not history:
+ console.print(f" [dim]> no logs found[/dim]")
+ return
+
+ choices = []
+ for run in history:
+ cost = run.get("usage", {}).get("estimated_cost_usd", 0)
+ cost_str = f"${cost:.3f}" if cost > 0 else "-"
+ title = f"> {run['run_id']:12} {run['prompt'][:40]:40} {cost_str:>8}"
+ choices.append(Choice(title=title, value=run['run_id']))
+
+ choices.append(Choice(title="> back", value="back"))
+
+ run_id = questionary.select(
+ "",
+ choices=choices,
+ pointer="",
+ qmark="",
+ style=questionary.Style([
+ ('highlighted', f'fg:{THEME_PRIMARY} bold'),
+ ('selected', 'fg:white'),
+ ])
+ ).ask()
+
+ if not run_id or run_id == "back":
+ return
+
+ run = session_manager.get_run(run_id)
+ if run:
+ console.print(Panel(json.dumps(run, indent=2), border_style=THEME_DIM))
+ if questionary.confirm(" > recode?").ask():
+ model = run.get("model") or config_manager.get("model", "claude-sonnet-4-5")
+ run_engineer(run_id, model=model)
+ else:
+ console.print(f" [dim]> not found[/dim]")
+
+
+def handle_help():
+ """Show help for slash commands."""
+ console.print()
+ console.print(f" [white]commands[/white]")
+ console.print(f" [dim]>[/dim] /settings [dim]system[/dim]")
+ console.print(f" [dim]>[/dim] /history [dim]logs[/dim]")
+ console.print(f" [dim]>[/dim] /messages [dim]view run messages[/dim]")
+ console.print(f" [dim]>[/dim] /help [dim]help[/dim]")
+ console.print(f" [dim]>[/dim] /exit [dim]quit[/dim]")
+ console.print()
+ console.print(f" [white]modes[/white] [dim](shift+tab to cycle)[/dim]")
+ console.print(f" [dim]>[/dim] manual [dim]full pipeline: browser + reverse engineering[/dim]")
+ console.print(f" [dim]>[/dim] engineer [dim]reverse engineer only (enter run_id)[/dim]")
+ console.print()
+
+
+def handle_messages(run_id: str):
+ """Display messages from a previous run."""
+ store = MessageStore(run_id)
+ messages = store.load()
+
+ if not messages:
+ console.print(f" [dim]>[/dim] [red]no messages found for run:[/red] {run_id}")
+ return
+
+ console.print()
+ console.print(f" [white]messages for {run_id}[/white]")
+ console.print()
+
+ for msg in messages:
+ msg_type = msg.get("type", "unknown")
+ content = msg.get("content", "")
+ timestamp = msg.get("timestamp", "")[:19] # Truncate to datetime
+
+ if msg_type == "prompt":
+ console.print(f" [dim]{timestamp}[/dim] [white]prompt[/white]")
+ # Show first 200 chars of prompt
+ display = str(content)[:200]
+ if len(str(content)) > 200:
+ display += "..."
+ console.print(f" [dim]{display}[/dim]")
+ elif msg_type == "tool_start":
+ name = content.get("name", "tool")
+ console.print(f" [dim]{timestamp}[/dim] [white]{name.lower()}[/white]")
+ elif msg_type == "tool_result":
+ name = content.get("name", "tool")
+ is_error = content.get("is_error", False)
+ status = "[red]error[/red]" if is_error else "[dim]ok[/dim]"
+ console.print(f" [dim]{timestamp}[/dim] {status}")
+ elif msg_type == "thinking":
+ display = str(content)[:100].replace("\\n", " ")
+ if len(str(content)) > 100:
+ display += "..."
+ console.print(f" [dim]{timestamp} .. {display}[/dim]")
+ elif msg_type == "error":
+ console.print(f" [dim]{timestamp}[/dim] [red]error: {content}[/red]")
+ elif msg_type == "result":
+ console.print(f" [dim]{timestamp}[/dim] [white]complete[/white]")
+ if isinstance(content, dict):
+ script_path = content.get("script_path", "")
+ if script_path:
+ console.print(f" [dim]{script_path}[/dim]")
+
+ console.print()
+
@main.command()
- "--prompt", "-p",
- default=None,
- help="Description of what APIs you want to capture. If omitted, enters interactive mode.",
-)
- "--url", "-u",
- default=None,
- help="Optional starting URL to navigate to.",
-)
- "--reverse-engineer", "-r",
- is_flag=True,
- default=False,
- help="Automatically reverse engineer APIs using Claude after capture.",
-)
- "--model", "-m",
- type=click.Choice(["sonnet", "opus", "haiku"]),
- default=None,
- help="Claude model to use for reverse engineering.",
-)
- "--instructions", "-i",
- default=None,
- help="Additional instructions for Claude when reverse engineering.",
-)
-def manual(
- prompt: str | None,
- url: str | None,
- reverse_engineer: bool,
- model: str | None,
- instructions: str | None,
-):
- """Start a manual browser session with HAR recording.
-
- Opens a Chromium browser where you can interact with websites.
- All network traffic is recorded to a HAR file for later analysis.
- Close the browser or press Ctrl+C when done.
-
- If --prompt is omitted, enters interactive mode.
-
- Use -r to auto-generate a Python API client after capture.
- """
- # Interactive mode if no prompt provided
[email protected]("--prompt", "-p", default=None, help="Capture description.")
[email protected]("--url", "-u", default=None, help="Starting URL.")
[email protected]("--reverse-engineer/--no-engineer", "reverse_engineer", default=True, help="Auto-run Claude.")
[email protected]("--model", "-m", type=click.Choice(["claude-sonnet-4-5", "claude-opus-4-5", "claude-haiku-4-5"]), default=None)
[email protected]("--output-dir", "-o", default=None, help="Custom output directory.")
+def manual(prompt, url, reverse_engineer, model, output_dir):
+ """Start a manual browser session."""
+ run_manual_capture(prompt, url, reverse_engineer, model, output_dir)
+
+
+def run_manual_capture(prompt=None, url=None, reverse_engineer=True, model=None, output_dir=None):
+ """Shared logic for manual capture."""
+ output_dir = output_dir or config_manager.get("output_dir")
+
if prompt is None:
options = prompt_interactive_options(
prompt=prompt,
@@ -123,77 +415,115 @@ def manual(
reverse_engineer=reverse_engineer,
model=model,
)
+ if "command" in options:
+ return # Should not happen from here
prompt = options["prompt"]
url = options["url"]
reverse_engineer = options["reverse_engineer"]
model = options["model"]
-
+
run_id = generate_run_id()
- browser = ManualBrowser(run_id=run_id, prompt=prompt)
+ timestamp = get_timestamp()
+
+ # Record initial session
+ session_manager.add_run(
+ run_id=run_id,
+ prompt=prompt,
+ timestamp=timestamp,
+ url=url,
+ model=model,
+ paths={
+ "har_dir": str(get_har_dir(run_id, output_dir))
+ }
+ )
+
+ browser = ManualBrowser(run_id=run_id, prompt=prompt, output_dir=output_dir)
har_path = browser.start(start_url=url)
if reverse_engineer:
- from .engineer import run_reverse_engineering
- script_path = run_reverse_engineering(
+ result = run_engineer(
run_id=run_id,
har_path=har_path,
prompt=prompt,
model=model,
- additional_instructions=instructions,
+ output_dir=output_dir
)
- if script_path:
- console.print(f"\n[green]✓[/green] Generated API script: [cyan]{script_path}[/cyan]")
+ if result:
+ session_manager.update_run(
+ run_id=run_id,
+ usage=result.get("usage", {}),
+ paths={"script_path": result.get("script_path")}
+ )
@main.command()
@click.argument("run_id")
- "--model", "-m",
- type=click.Choice(["sonnet", "opus", "haiku"]),
- default=None,
- help="Claude model to use for reverse engineering.",
-)
- "--instructions", "-i",
- default=None,
- help="Additional instructions for Claude.",
-)
-def engineer(run_id: str, model: str | None, instructions: str | None):
- """Reverse engineer APIs from a previous capture.
-
- Analyzes the HAR file from a previous run and generates
- a Python API client script using Claude.
- """
- import json
- from pathlib import Path
- from .utils import get_har_dir
- from .engineer import run_reverse_engineering
-
- har_dir = get_har_dir(run_id)
- har_path = har_dir / "recording.har"
- metadata_path = har_dir / "metadata.json"
-
- if not har_path.exists():
- console.print(f"[red]Error:[/red] HAR file not found for run ID: {run_id}")
- console.print(f"[dim]Expected path: {har_path}[/dim]")
- return
-
- # Load prompt from metadata if available
- prompt = "Reverse engineer the captured APIs"
- if metadata_path.exists():
- with open(metadata_path) as f:
- metadata = json.load(f)
- prompt = metadata.get("prompt", prompt)
-
- script_path = run_reverse_engineering(
[email protected]("--model", "-m", type=click.Choice(["claude-sonnet-4-5", "claude-opus-4-5", "claude-haiku-4-5"]), default=None)
[email protected]("--output-dir", "-o", default=None, help="Custom output directory.")
+def engineer(run_id, model, output_dir):
+ """Run reverse engineering on a previous run."""
+ run_engineer(run_id, model=model, output_dir=output_dir)
+
+
+def run_engineer(run_id, har_path=None, prompt=None, model=None, output_dir=None):
+ """Shared logic for reverse engineering."""
+ if not har_path or not prompt:
+ # Load from history if possible
+ run_data = session_manager.get_run(run_id)
+ if not run_data:
+ # Fallback to file search if not in history
+ har_dir = get_har_dir(run_id, output_dir)
+ har_path = har_dir / "recording.har"
+ if not har_path.exists():
+ console.print(f" [dim]![/dim] [red]not found:[/red] {run_id}")
+ return None
+ prompt = "Reverse engineer captured APIs" # Default
+ else:
+ prompt = run_data["prompt"]
+ # Detect where it was saved
+ paths = run_data.get("paths", {})
+ har_dir = Path(paths.get("har_dir", get_har_dir(run_id, None)))
+ har_path = har_dir / "recording.har"
+
+ result = run_reverse_engineering(
run_id=run_id,
har_path=har_path,
prompt=prompt,
- model=model,
- additional_instructions=instructions,
+ model=model or config_manager.get("model", "claude-sonnet-4-5"),
+ output_dir=output_dir
)
- if script_path:
- console.print(f"\n[green]✓[/green] Generated API script: [cyan]{script_path}[/cyan]")
+
+ if result:
+ # Automatically copy scripts to current directory with a readable name
+ scripts_dir = Path(result["script_path"]).parent
+ base_name = generate_folder_name(prompt)
+ folder_name = base_name
+ local_dir = Path.cwd() / "scripts" / folder_name
+
+ # Handle existing folder - append suffix if needed
+ counter = 2
+ while local_dir.exists():
+ folder_name = f"{base_name}_{counter}"
+ local_dir = Path.cwd() / "scripts" / folder_name
+ counter += 1
+
+ local_dir.mkdir(parents=True, exist_ok=True)
+
+ import shutil
+ for item in scripts_dir.iterdir():
+ if item.is_file():
+ shutil.copy2(item, local_dir / item.name)
+
+ console.print(f" [dim]>[/dim] [white]decoding complete[/white]")
+ console.print(f" [dim]>[/dim] [white]{result['script_path']}[/white]")
+ console.print(f" [dim]>[/dim] [white]copied to ./scripts/{folder_name}[/white]\n")
+
+ session_manager.update_run(
+ run_id=run_id,
+ usage=result.get("usage", {}),
+ paths={"script_path": result.get("script_path")}
+ )
+ return result
if __name__ == "__main__":
diff --git a/src/reverse_api/config.py b/src/reverse_api/config.py
new file mode 100644
index 0000000..722b6d1
--- /dev/null
+++ b/src/reverse_api/config.py
@@ -0,0 +1,52 @@
+"""Configuration management for reverse-api."""
+
+import json
+from pathlib import Path
+from typing import Any, Dict
+
+DEFAULT_CONFIG = {
+ "model": "claude-sonnet-4-5",
+ "output_dir": None, # None means use ~/.reverse-api/runs
+}
+
+
+class ConfigManager:
+ """Handles user settings and persistence."""
+
+ def __init__(self, config_path: Path):
+ self.config_path = config_path
+ self.config = DEFAULT_CONFIG.copy()
+ self.load()
+
+ def load(self):
+ """Load configuration from disk."""
+ if self.config_path.exists():
+ try:
+ with open(self.config_path, "r") as f:
+ user_config = json.load(f)
+ # Only keep valid keys
+ valid_config = {k: v for k, v in user_config.items() if k in self.config}
+ self.config.update(valid_config)
+ except (json.JSONDecodeError, OSError):
+ # Fallback to defaults if file is corrupted
+ pass
+
+ def save(self):
+ """Save configuration to disk."""
+ self.config_path.parent.mkdir(parents=True, exist_ok=True)
+ with open(self.config_path, "w") as f:
+ json.dump(self.config, f, indent=4)
+
+ def get(self, key: str, default: Any = None) -> Any:
+ """Get a configuration value."""
+ return self.config.get(key, default)
+
+ def set(self, key: str, value: Any):
+ """Set a configuration value and save."""
+ self.config[key] = value
+ self.save()
+
+ def update(self, settings: Dict[str, Any]):
+ """Update multiple settings and save."""
+ self.config.update(settings)
+ self.save()
diff --git a/src/reverse_api/engineer.py b/src/reverse_api/engineer.py
index f3ac014..d54f3f0 100644
--- a/src/reverse_api/engineer.py
+++ b/src/reverse_api/engineer.py
@@ -3,7 +3,7 @@
import asyncio
import json
from pathlib import Path
-from typing import Optional
+from typing import Optional, Dict, Any
from claude_agent_sdk import (
ClaudeSDKClient,
@@ -17,6 +17,7 @@ from claude_agent_sdk import (
from .utils import get_scripts_dir, get_timestamp
from .tui import ClaudeUI
+from .messages import MessageStore
class APIReverseEngineer:
@@ -29,6 +30,7 @@ class APIReverseEngineer:
prompt: str,
model: Optional[str] = None,
additional_instructions: Optional[str] = None,
+ output_dir: Optional[str] = None,
verbose: bool = True,
):
self.run_id = run_id
@@ -36,8 +38,10 @@ class APIReverseEngineer:
self.prompt = prompt
self.model = model
self.additional_instructions = additional_instructions
- self.scripts_dir = get_scripts_dir(run_id)
+ self.scripts_dir = get_scripts_dir(run_id, output_dir)
self.ui = ClaudeUI(verbose=verbose)
+ self.usage_metadata: Dict[str, Any] = {}
+ self.message_store = MessageStore(run_id, output_dir)
def _build_analysis_prompt(self) -> str:
"""Build the prompt for Claude to analyze the HAR file."""
@@ -61,16 +65,23 @@ The Python script should:
Save the generated Python script to: {self.scripts_dir / 'api_client.py'}
Also create a brief README.md in the same folder explaining the APIs discovered.
+Always test your implementation to ensure it works. If it doesn't try again if you think you can fix it. You can go up to 5 attempts.
+Sometimes websites have bot detection and that kind of things so keep in mind.
+If you see you can't achieve with requests, feel free to use playwright with the real user browser with CDP to bypass bot detection.
+No matter which implementation you choose, always try to make it production ready and test it.
"""
if self.additional_instructions:
base_prompt += f"\n\nAdditional instructions:\n{self.additional_instructions}"
return base_prompt
- async def analyze_and_generate(self) -> Optional[str]:
+ async def analyze_and_generate(self) -> Optional[Dict[str, Any]]:
"""Run the reverse engineering analysis with Claude."""
self.ui.header(self.run_id, self.prompt, self.model)
self.ui.start_analysis()
+
+ # Save the prompt to messages
+ self.message_store.save_prompt(self._build_analysis_prompt())
options = ClaudeAgentOptions(
allowed_tools=["Read", "Write", "Bash", "Glob", "Grep", "WebSearch", "WebFetch"],
@@ -85,28 +96,88 @@ Also create a brief README.md in the same folder explaining the APIs discovered.
# Process response and show progress with TUI
async for message in client.receive_response():
+ # Check for usage metadata in message if applicable
+ # (Note: Current SDK might not expose it easily, but we prepare for it)
+ if hasattr(message, 'usage') and isinstance(getattr(message, 'usage'), dict):
+ self.usage_metadata.update(getattr(message, 'usage'))
+
if isinstance(message, AssistantMessage):
+ last_tool_name = None
for block in message.content:
if isinstance(block, ToolUseBlock):
+ last_tool_name = block.name
self.ui.tool_start(block.name, block.input)
+ self.message_store.save_tool_start(block.name, block.input)
elif isinstance(block, ToolResultBlock):
- # Determine tool name from context
is_error = block.is_error if block.is_error else False
- self.ui.tool_result("Tool", is_error)
+
+ # Extract output from ToolResultBlock
+ output = None
+ if hasattr(block, 'content'):
+ output = block.content
+ elif hasattr(block, 'result'):
+ output = block.result
+ elif hasattr(block, 'output'):
+ output = block.output
+
+ tool_name = last_tool_name or "Tool"
+ self.ui.tool_result(tool_name, is_error, output)
+ self.message_store.save_tool_result(tool_name, is_error, str(output) if output else None)
elif isinstance(block, TextBlock):
self.ui.thinking(block.text)
+ self.message_store.save_thinking(block.text)
elif isinstance(message, ResultMessage):
if message.is_error:
self.ui.error(message.result or "Unknown error")
+ self.message_store.save_error(message.result or "Unknown error")
return None
else:
script_path = str(self.scripts_dir / 'api_client.py')
self.ui.success(script_path)
- return script_path
+
+ # Calculate estimated cost if we have usage data
+ if self.usage_metadata:
+ input_tokens = self.usage_metadata.get("input_tokens", 0)
+ output_tokens = self.usage_metadata.get("output_tokens", 0)
+ cache_creation_tokens = self.usage_metadata.get("cache_creation_input_tokens", 0)
+ cache_read_tokens = self.usage_metadata.get("cache_read_input_tokens", 0)
+
+ # Claude Sonnet 4.5 pricing per million tokens:
+ # - Regular input: $3.00
+ # - Cache creation: $3.75
+ # - Cache read: $0.30
+ # - Output: $15.00
+ cost = (
+ (input_tokens / 1_000_000 * 3.0) +
+ (cache_creation_tokens / 1_000_000 * 3.75) +
+ (cache_read_tokens / 1_000_000 * 0.30) +
+ (output_tokens / 1_000_000 * 15.0)
+ )
+ self.usage_metadata["estimated_cost_usd"] = cost
+
+ # Display usage breakdown
+ self.ui.console.print(f" [dim]Usage:[/dim]")
+ if input_tokens > 0:
+ self.ui.console.print(f" [dim] input: {input_tokens:,} tokens[/dim]")
+ if cache_creation_tokens > 0:
+ self.ui.console.print(f" [dim] cache creation: {cache_creation_tokens:,} tokens[/dim]")
+ if cache_read_tokens > 0:
+ self.ui.console.print(f" [dim] cache read: {cache_read_tokens:,} tokens[/dim]")
+ if output_tokens > 0:
+ self.ui.console.print(f" [dim] output: {output_tokens:,} tokens[/dim]")
+ self.ui.console.print(f" [dim] total cost: ${cost:.4f}[/dim]")
+
+ result: Dict[str, Any] = {
+ "script_path": script_path,
+ "usage": self.usage_metadata
+ }
+ self.message_store.save_result(result)
+ return result
except Exception as e:
self.ui.error(str(e))
+ self.message_store.save_error(str(e))
self.ui.console.print(
"\n[dim]Make sure Claude Code CLI is installed: "
"npm install -g @anthropic-ai/claude-code[/dim]"
@@ -122,8 +193,9 @@ def run_reverse_engineering(
prompt: str,
model: Optional[str] = None,
additional_instructions: Optional[str] = None,
+ output_dir: Optional[str] = None,
verbose: bool = True,
-) -> Optional[str]:
+) -> Optional[Dict[str, Any]]:
"""Synchronous wrapper for reverse engineering."""
engineer = APIReverseEngineer(
run_id=run_id,
@@ -131,6 +203,7 @@ def run_reverse_engineering(
prompt=prompt,
model=model,
additional_instructions=additional_instructions,
+ output_dir=output_dir,
verbose=verbose,
)
return asyncio.run(engineer.analyze_and_generate())
diff --git a/src/reverse_api/messages.py b/src/reverse_api/messages.py
new file mode 100644
index 0000000..75c3c4c
--- /dev/null
+++ b/src/reverse_api/messages.py
@@ -0,0 +1,83 @@
+"""Message persistence for engineer runs."""
+
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from .utils import get_messages_path
+
+
+class MessageStore:
+ """Handles saving and loading messages for engineer runs."""
+
+ def __init__(self, run_id: str, output_dir: Optional[str] = None):
+ self.run_id = run_id
+ self.messages_path = get_messages_path(run_id, output_dir)
+ self.messages_path.parent.mkdir(parents=True, exist_ok=True)
+
+ def _get_timestamp(self) -> str:
+ """Get current timestamp in ISO format."""
+ return datetime.now().isoformat()
+
+ def append(self, msg_type: str, content: Any, **kwargs) -> None:
+ """Append a message to the JSONL file."""
+ message = {
+ "timestamp": self._get_timestamp(),
+ "type": msg_type,
+ "content": content,
+ **kwargs,
+ }
+ with open(self.messages_path, "a") as f:
+ f.write(json.dumps(message) + "\n")
+
+ def save_prompt(self, prompt: str) -> None:
+ """Save the initial prompt."""
+ self.append("prompt", prompt)
+
+ def save_tool_start(self, tool_name: str, tool_input: dict) -> None:
+ """Save a tool start event."""
+ self.append("tool_start", {"name": tool_name, "input": tool_input})
+
+ def save_tool_result(
+ self, tool_name: str, is_error: bool = False, output: Optional[str] = None
+ ) -> None:
+ """Save a tool result event."""
+ self.append(
+ "tool_result",
+ {"name": tool_name, "is_error": is_error, "output": output},
+ )
+
+ def save_thinking(self, text: str) -> None:
+ """Save Claude's thinking/response text."""
+ self.append("thinking", text)
+
+ def save_error(self, error: str) -> None:
+ """Save an error event."""
+ self.append("error", error)
+
+ def save_result(self, result: Dict[str, Any]) -> None:
+ """Save the final result."""
+ self.append("result", result)
+
+ def load(self) -> List[Dict[str, Any]]:
+ """Load all messages from the JSONL file."""
+ if not self.messages_path.exists():
+ return []
+ messages = []
+ with open(self.messages_path, "r") as f:
+ for line in f:
+ line = line.strip()
+ if line:
+ try:
+ messages.append(json.loads(line))
+ except json.JSONDecodeError:
+ continue
+ return messages
+
+ @classmethod
+ def exists(cls, run_id: str, output_dir: Optional[str] = None) -> bool:
+ """Check if messages exist for a run."""
+ from .utils import get_messages_path
+
+ return get_messages_path(run_id, output_dir).exists()
diff --git a/src/reverse_api/session.py b/src/reverse_api/session.py
new file mode 100644
index 0000000..b94e21e
--- /dev/null
+++ b/src/reverse_api/session.py
@@ -0,0 +1,71 @@
+"""Session and history management for reverse-api."""
+
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+class SessionManager:
+ """Handles history tracking and persistence of runs."""
+
+ def __init__(self, history_path: Path):
+ self.history_path = history_path
+ self.history: List[Dict[str, Any]] = []
+ self.load()
+
+ def load(self):
+ """Load history from disk."""
+ if self.history_path.exists():
+ try:
+ with open(self.history_path, "r") as f:
+ self.history = json.load(f)
+ except (json.JSONDecodeError, OSError):
+ # Fallback to empty history if file is corrupted
+ self.history = []
+
+ def save(self):
+ """Save history to disk."""
+ self.history_path.parent.mkdir(parents=True, exist_ok=True)
+ with open(self.history_path, "w") as f:
+ json.dump(self.history, f, indent=4)
+
+ def add_run(self, run_id: str, prompt: str, **kwargs):
+ """Add a new run to history."""
+ run_data = {
+ "run_id": run_id,
+ "prompt": prompt,
+ "timestamp": kwargs.get("timestamp"),
+ "url": kwargs.get("url"),
+ "model": kwargs.get("model"),
+ "usage": kwargs.get("usage", {}),
+ "paths": kwargs.get("paths", {}),
+ }
+ # Avoid duplicates if updating existing run
+ self.history = [r for r in self.history if r["run_id"] != run_id]
+ self.history.insert(0, run_data) # Most recent first
+ self.save()
+
+ def update_run(self, run_id: str, **kwargs):
+ """Update an existing run with more data (e.g., usage after engineer)."""
+ for run in self.history:
+ if run["run_id"] == run_id:
+ if "usage" in kwargs:
+ run["usage"].update(kwargs["usage"])
+ if "paths" in kwargs:
+ run["paths"].update(kwargs["paths"])
+ for key, value in kwargs.items():
+ if key not in ("usage", "paths"):
+ run[key] = value
+ break
+ self.save()
+
+ def get_run(self, run_id: str) -> Optional[Dict[str, Any]]:
+ """Get data for a specific run."""
+ for run in self.history:
+ if run["run_id"] == run_id:
+ return run
+ return None
+
+ def get_history(self, limit: int = 10) -> List[Dict[str, Any]]:
+ """Get recent history."""
+ return self.history[:limit]
diff --git a/src/reverse_api/tui.py b/src/reverse_api/tui.py
index f2a6082..cfc07b5 100644
--- a/src/reverse_api/tui.py
+++ b/src/reverse_api/tui.py
@@ -5,36 +5,45 @@ from rich.console import Console, Group
from rich.panel import Panel
from rich.table import Table
from rich.text import Text
-from rich.box import ROUNDED, MINIMAL, HEAVY
+from rich.box import ROUNDED, MINIMAL, HEAVY, DOUBLE_EDGE
from rich.padding import Padding
from rich.rule import Rule
+from rich.align import Align
+from rich.columns import Columns
+# Theme configuration
+THEME_PRIMARY = "#ff5f50" # Coral Red
+THEME_SECONDARY = "white"
+THEME_DIM = "#555555"
+THEME_SUCCESS = "#ff5f50"
+THEME_ERROR = "bold white on #ff5f50"
-# Tool icons for visual clarity
+
+# Tool icons for visual clarity (minimalist text)
TOOL_ICONS = {
- "Read": "📖",
- "Write": "✏️",
- "Edit": "📝",
- "Bash": "💻",
- "Glob": "🔍",
- "Grep": "🔎",
- "WebSearch": "🌐",
- "WebFetch": "🌍",
- "Task": "📋",
- "default": "🔧",
+ "Read": "rd",
+ "Write": "wr",
+ "Edit": "ed",
+ "Bash": "sh",
+ "Glob": "ls",
+ "Grep": "gp",
+ "WebSearch": "ws",
+ "WebFetch": "wf",
+ "Task": "tk",
+ "default": "> ",
}
-# Tool colors
+# Tool colors (minimalist)
TOOL_COLORS = {
- "Read": "blue",
- "Write": "green",
- "Edit": "yellow",
- "Bash": "magenta",
- "Glob": "cyan",
- "Grep": "cyan",
- "WebSearch": "bright_blue",
- "WebFetch": "bright_blue",
- "default": "white",
+ "Read": THEME_DIM,
+ "Write": THEME_DIM,
+ "Edit": THEME_DIM,
+ "Bash": THEME_DIM,
+ "Glob": THEME_DIM,
+ "Grep": THEME_DIM,
+ "WebSearch": THEME_DIM,
+ "WebFetch": THEME_DIM,
+ "default": THEME_DIM,
}
@@ -49,28 +58,16 @@ class ClaudeUI:
def header(self, run_id: str, prompt: str, model: Optional[str] = None) -> None:
"""Display the session header."""
- # Create a clean header table
- table = Table(show_header=False, box=None, padding=(0, 1))
- table.add_column("key", style="dim", width=12)
- table.add_column("value")
-
- table.add_row("Run ID", f"[yellow]{run_id}[/yellow]")
- if model:
- table.add_row("Model", f"[green]{model}[/green]")
- table.add_row("Task", f"[white]{prompt}[/white]")
-
self.console.print()
- self.console.print(Panel(
- table,
- title="[bold cyan]🔍 Reverse API Analysis[/bold cyan]",
- border_style="cyan",
- box=ROUNDED,
- ))
+ self.console.print(f" [white]reverse-api[/white] [dim]v0.1.0[/dim]")
+ self.console.print(f" [dim]━[/dim] [white]{run_id}[/white]")
+ self.console.print(f" [dim]model[/dim] [white]{model or '---'}[/white]")
+ self.console.print(f" [{THEME_PRIMARY}]task[/{THEME_PRIMARY}] [white]{prompt}[/white]")
+ self.console.print()
def start_analysis(self) -> None:
"""Display analysis start message."""
- self.console.print()
- self.console.print(Rule("[bold]Claude is analyzing...[/bold]", style="dim"))
+ self.console.print(f" [dim]decoding starting...[/dim]")
self.console.print()
def tool_start(self, tool_name: str, tool_input: dict) -> None:
@@ -79,20 +76,29 @@ class ClaudeUI:
self._tools_used.append(tool_name)
icon = TOOL_ICONS.get(tool_name, TOOL_ICONS["default"])
- color = TOOL_COLORS.get(tool_name, TOOL_COLORS["default"])
# Build input summary
input_summary = self._summarize_input(tool_name, tool_input)
# Compact single-line format
self.console.print(
- f" [{color}]●[/{color}] {icon} [bold {color}]{tool_name:12}[/bold {color}] {input_summary}"
+ f" [dim]>[/dim] {icon} [white]{tool_name.lower():8}[/white] {input_summary}"
)
- def tool_result(self, tool_name: str, is_error: bool = False) -> None:
- """Display when a tool completes (only show on error)."""
+ def tool_result(self, tool_name: str, is_error: bool = False, output: Optional[str] = None) -> None:
+ """Display when a tool completes."""
if is_error:
- self.console.print(f" [red]✗ {tool_name} failed[/red]")
+ self.console.print(f" [dim]![/dim] [red]{tool_name.lower()} failed[/red]")
+ elif tool_name == "Bash" and output and self.verbose:
+ # Display bash output
+ output_str = str(output).strip()
+ if output_str:
+ output_lines = output_str.split('\n')
+ max_lines = 30
+ for line in output_lines[:max_lines]:
+ self.console.print(f" [dim]│[/dim] [dim]{line}[/dim]")
+ if len(output_lines) > max_lines:
+ self.console.print(f" [dim]│[/dim] [dim]... ({len(output_lines) - max_lines} more lines)[/dim]")
def thinking(self, text: str, max_length: int = 100) -> None:
"""Display Claude's thinking/response text."""
@@ -108,7 +114,7 @@ class ClaudeUI:
if len(text) > max_length:
display_text += "..."
- self.console.print(f" [dim]→ {display_text}[/dim]")
+ self.console.print(f" [dim].. {display_text}[/dim]")
def progress(self, message: str) -> None:
"""Display a progress message."""
@@ -117,24 +123,14 @@ class ClaudeUI:
def success(self, script_path: str) -> None:
"""Display success message with generated script path."""
self.console.print()
- self.console.print(Rule(style="green"))
-
- # Summary
- summary = Text()
- summary.append("✨ ", style="bold")
- summary.append("Analysis Complete\n\n", style="bold green")
- summary.append(f" Tools: ", style="dim")
- summary.append(f"{self._tool_count}\n", style="white")
- summary.append(f" Script: ", style="dim")
- summary.append(f"{script_path}", style="cyan underline")
-
- self.console.print(summary)
+ self.console.print(f" [dim]decoding complete[/dim]")
+ self.console.print(f" [white]{script_path}[/white]")
self.console.print()
def error(self, message: str) -> None:
"""Display error message."""
self.console.print()
- self.console.print(f"[bold red]✗ Error:[/bold red] {message}")
+ self.console.print(f" [dim]![/dim] [red]error:[/red] {message}")
def _summarize_input(self, tool_name: str, tool_input: dict) -> str:
"""Create a brief summary of tool input."""
@@ -172,7 +168,34 @@ class ClaudeUI:
def get_model_choices() -> list[dict]:
"""Get available model choices for questionary."""
return [
- {"name": "Claude Sonnet (default, balanced)", "value": "sonnet"},
- {"name": "Claude Opus (most capable)", "value": "opus"},
- {"name": "Claude Haiku (fastest)", "value": "haiku"},
+ {"name": "Sonnet 4.5 [Balanced]", "value": "claude-sonnet-4-5"},
+ {"name": "Opus 4.5 [Power]", "value": "claude-opus-4-5"},
+ {"name": "Haiku 4.5 [Speed]", "value": "claude-haiku-4-5"},
]
+
+
+def display_banner(console: Console):
+ """Display ultra-minimalist banner."""
+ console.print()
+ console.print(f" [bold white]reverse-api[/bold white]")
+ console.print(f" [bold {THEME_PRIMARY}]━━[/bold {THEME_PRIMARY}]")
+ console.print()
+ console.print(f" [dim white]AI agents for API reverse engineering.[/dim white]")
+ console.print()
+
+
+def display_footer(console: Console):
+ """Display minimalist footer."""
+ from datetime import datetime
+ time_str = datetime.now().strftime("%H:%M")
+
+ footer = Text()
+ footer.append("\n v0.1.0 ", style=THEME_DIM)
+ footer.append(" LOCAL ", style=THEME_DIM)
+ footer.append(f" {time_str} ", style=THEME_DIM)
+ footer.append(" VIA CLI ", style=THEME_DIM)
+ footer.append(" " * 30)
+ footer.append(" OPERATIONAL ", style=f"bold #44bb44")
+
+ console.print(footer)
+ console.print()
diff --git a/src/reverse_api/utils.py b/src/reverse_api/utils.py
index 8bab66a..7827282 100644
--- a/src/reverse_api/utils.py
+++ b/src/reverse_api/utils.py
@@ -1,10 +1,54 @@
"""Utility functions for run ID generation and path management."""
+import re
import uuid
from datetime import datetime
from pathlib import Path
+def generate_folder_name(prompt: str) -> str:
+ """Generate a clean folder name from a prompt using Claude Haiku.
+
+ Uses Anthropic's fastest model to quickly generate a short, descriptive name.
+ Falls back to simple slugification if API call fails.
+ """
+ try:
+ import anthropic
+
+ client = anthropic.Anthropic()
+ response = client.messages.create(
+ model="claude-4-5-haiku-latest",
+ max_tokens=50,
+ messages=[{
+ "role": "user",
+ "content": f"Generate a short folder name (1-3 words, lowercase, underscores) for this task: {prompt}\n\nRespond with ONLY the folder name, nothing else. Example: apple_jobs_api"
+ }]
+ )
+
+ name = response.content[0].text.strip().lower()
+ # Clean up the name to be filesystem-safe
+ name = re.sub(r'[^a-z0-9_]', '_', name)
+ name = re.sub(r'_+', '_', name) # Collapse multiple underscores
+ name = name.strip('_')[:50] # Limit length
+
+ if name:
+ return name
+ except Exception:
+ pass
+
+ # Fallback: simple slugify
+ return _slugify(prompt)
+
+
+def _slugify(text: str) -> str:
+ """Simple slugify fallback - converts text to a filesystem-safe name."""
+ text = text.lower()
+ text = re.sub(r'[^a-z0-9\s]', '', text)
+ text = re.sub(r'\s+', '_', text)
+ words = text.split('_')[:3] # Take first 3 words
+ return '_'.join(words)[:50]
+
+
def generate_run_id() -> str:
"""Generate a unique run ID using a short UUID format."""
return uuid.uuid4().hex[:12]
@@ -15,20 +59,54 @@ def get_project_root() -> Path:
return Path(__file__).parent.parent.parent
-def get_har_dir(run_id: str) -> Path:
+def get_app_dir() -> Path:
+ """Get the central application data directory."""
+ app_dir = Path.home() / ".reverse-api"
+ app_dir.mkdir(parents=True, exist_ok=True)
+ return app_dir
+
+
+def get_config_path() -> Path:
+ """Get the path to the config file."""
+ return get_app_dir() / "config.json"
+
+
+def get_history_path() -> Path:
+ """Get the path to the history file."""
+ return get_app_dir() / "history.json"
+
+
+def get_base_output_dir(output_dir: str | None = None) -> Path:
+ """Get the base directory for outputs (HARs and scripts)."""
+ if output_dir:
+ return Path(output_dir)
+ return get_app_dir() / "runs"
+
+
+def get_har_dir(run_id: str, output_dir: str | None = None) -> Path:
"""Get the HAR directory for a specific run."""
- har_dir = get_project_root() / "har" / run_id
+ base_dir = get_base_output_dir(output_dir)
+ har_dir = base_dir / "har" / run_id
har_dir.mkdir(parents=True, exist_ok=True)
return har_dir
-def get_scripts_dir(run_id: str) -> Path:
+def get_scripts_dir(run_id: str, output_dir: str | None = None) -> Path:
"""Get the scripts directory for a specific run."""
- scripts_dir = get_project_root() / "scripts" / run_id
+ base_dir = get_base_output_dir(output_dir)
+ scripts_dir = base_dir / "scripts" / run_id
scripts_dir.mkdir(parents=True, exist_ok=True)
return scripts_dir
+def get_messages_path(run_id: str, output_dir: str | None = None) -> Path:
+ """Get the messages file path for a specific run."""
+ base_dir = get_base_output_dir(output_dir)
+ messages_dir = base_dir / "messages"
+ messages_dir.mkdir(parents=True, exist_ok=True)
+ return messages_dir / f"{run_id}.jsonl"
+
+
def get_timestamp() -> str:
"""Get current timestamp in ISO format."""
return datetime.now().isoformat()
diff --git a/uv.lock b/uv.lock
index ac5ce42..ed2be4e 100644
--- a/uv.lock
+++ b/uv.lock
@@ -11,6 +11,25 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
]
+[[package]]
+name = "anthropic"
+version = "0.75.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "anyio" },
+ { name = "distro" },
+ { name = "docstring-parser" },
+ { name = "httpx" },
+ { name = "jiter" },
+ { name = "pydantic" },
+ { name = "sniffio" },
+ { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/04/1f/08e95f4b7e2d35205ae5dcbb4ae97e7d477fc521c275c02609e2931ece2d/anthropic-0.75.0.tar.gz", hash = "sha256:e8607422f4ab616db2ea5baacc215dd5f028da99ce2f022e33c7c535b29f3dfb", size = 439565, upload-time = "2025-11-24T20:41:45.28Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/60/1c/1cd02b7ae64302a6e06724bf80a96401d5313708651d277b1458504a1730/anthropic-0.75.0-py3-none-any.whl", hash = "sha256:ea8317271b6c15d80225a9f3c670152746e88805a7a61e14d4a374577164965b", size = 388164, upload-time = "2025-11-24T20:41:43.587Z" },
+]
+
[[package]]
name = "anyio"
version = "4.12.0"
@@ -34,6 +53,64 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/3a/2a/7cc015f5b9f5db42b7d48157e23356022889fc354a2813c15934b7cb5c0e/attrs-25.4.0-py3-none-any.whl", hash = "sha256:adcf7e2a1fb3b36ac48d97835bb6d8ade15b8dcce26aba8bf1d14847b57a3373", size = 67615, upload-time = "2025-10-06T13:54:43.17Z" },
]
+[[package]]
+name = "brotli"
+version = "1.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f7/16/c92ca344d646e71a43b8bb353f0a6490d7f6e06210f8554c8f874e454285/brotli-1.2.0.tar.gz", hash = "sha256:e310f77e41941c13340a95976fe66a8a95b01e783d430eeaf7a2f87e0a57dd0a", size = 7388632, upload-time = "2025-11-05T18:39:42.86Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/64/10/a090475284fc4a71aed40a96f32e44a7fe5bda39687353dd977720b211b6/brotli-1.2.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:3b90b767916ac44e93a8e28ce6adf8d551e43affb512f2377c732d486ac6514e", size = 863089, upload-time = "2025-11-05T18:38:01.181Z" },
+ { url = "https://files.pythonhosted.org/packages/03/41/17416630e46c07ac21e378c3464815dd2e120b441e641bc516ac32cc51d2/brotli-1.2.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6be67c19e0b0c56365c6a76e393b932fb0e78b3b56b711d180dd7013cb1fd984", size = 445442, upload-time = "2025-11-05T18:38:02.434Z" },
+ { url = "https://files.pythonhosted.org/packages/24/31/90cc06584deb5d4fcafc0985e37741fc6b9717926a78674bbb3ce018957e/brotli-1.2.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0bbd5b5ccd157ae7913750476d48099aaf507a79841c0d04a9db4415b14842de", size = 1532658, upload-time = "2025-11-05T18:38:03.588Z" },
+ { url = "https://files.pythonhosted.org/packages/62/17/33bf0c83bcbc96756dfd712201d87342732fad70bb3472c27e833a44a4f9/brotli-1.2.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3f3c908bcc404c90c77d5a073e55271a0a498f4e0756e48127c35d91cf155947", size = 1631241, upload-time = "2025-11-05T18:38:04.582Z" },
+ { url = "https://files.pythonhosted.org/packages/48/10/f47854a1917b62efe29bc98ac18e5d4f71df03f629184575b862ef2e743b/brotli-1.2.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1b557b29782a643420e08d75aea889462a4a8796e9a6cf5621ab05a3f7da8ef2", size = 1424307, upload-time = "2025-11-05T18:38:05.587Z" },
+ { url = "https://files.pythonhosted.org/packages/e4/b7/f88eb461719259c17483484ea8456925ee057897f8e64487d76e24e5e38d/brotli-1.2.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:81da1b229b1889f25adadc929aeb9dbc4e922bd18561b65b08dd9343cfccca84", size = 1488208, upload-time = "2025-11-05T18:38:06.613Z" },
+ { url = "https://files.pythonhosted.org/packages/26/59/41bbcb983a0c48b0b8004203e74706c6b6e99a04f3c7ca6f4f41f364db50/brotli-1.2.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:ff09cd8c5eec3b9d02d2408db41be150d8891c5566addce57513bf546e3d6c6d", size = 1597574, upload-time = "2025-11-05T18:38:07.838Z" },
+ { url = "https://files.pythonhosted.org/packages/8e/e6/8c89c3bdabbe802febb4c5c6ca224a395e97913b5df0dff11b54f23c1788/brotli-1.2.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:a1778532b978d2536e79c05dac2d8cd857f6c55cd0c95ace5b03740824e0e2f1", size = 1492109, upload-time = "2025-11-05T18:38:08.816Z" },
+ { url = "https://files.pythonhosted.org/packages/ed/9a/4b19d4310b2dbd545c0c33f176b0528fa68c3cd0754e34b2f2bcf56548ae/brotli-1.2.0-cp310-cp310-win32.whl", hash = "sha256:b232029d100d393ae3c603c8ffd7e3fe6f798c5e28ddca5feabb8e8fdb732997", size = 334461, upload-time = "2025-11-05T18:38:10.729Z" },
+ { url = "https://files.pythonhosted.org/packages/ac/39/70981d9f47705e3c2b95c0847dfa3e7a37aa3b7c6030aedc4873081ed005/brotli-1.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:ef87b8ab2704da227e83a246356a2b179ef826f550f794b2c52cddb4efbd0196", size = 369035, upload-time = "2025-11-05T18:38:11.827Z" },
+ { url = "https://files.pythonhosted.org/packages/7a/ef/f285668811a9e1ddb47a18cb0b437d5fc2760d537a2fe8a57875ad6f8448/brotli-1.2.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:15b33fe93cedc4caaff8a0bd1eb7e3dab1c61bb22a0bf5bdfdfd97cd7da79744", size = 863110, upload-time = "2025-11-05T18:38:12.978Z" },
+ { url = "https://files.pythonhosted.org/packages/50/62/a3b77593587010c789a9d6eaa527c79e0848b7b860402cc64bc0bc28a86c/brotli-1.2.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:898be2be399c221d2671d29eed26b6b2713a02c2119168ed914e7d00ceadb56f", size = 445438, upload-time = "2025-11-05T18:38:14.208Z" },
+ { url = "https://files.pythonhosted.org/packages/cd/e1/7fadd47f40ce5549dc44493877db40292277db373da5053aff181656e16e/brotli-1.2.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:350c8348f0e76fff0a0fd6c26755d2653863279d086d3aa2c290a6a7251135dd", size = 1534420, upload-time = "2025-11-05T18:38:15.111Z" },
+ { url = "https://files.pythonhosted.org/packages/12/8b/1ed2f64054a5a008a4ccd2f271dbba7a5fb1a3067a99f5ceadedd4c1d5a7/brotli-1.2.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2e1ad3fda65ae0d93fec742a128d72e145c9c7a99ee2fcd667785d99eb25a7fe", size = 1632619, upload-time = "2025-11-05T18:38:16.094Z" },
+ { url = "https://files.pythonhosted.org/packages/89/5a/7071a621eb2d052d64efd5da2ef55ecdac7c3b0c6e4f9d519e9c66d987ef/brotli-1.2.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:40d918bce2b427a0c4ba189df7a006ac0c7277c180aee4617d99e9ccaaf59e6a", size = 1426014, upload-time = "2025-11-05T18:38:17.177Z" },
+ { url = "https://files.pythonhosted.org/packages/26/6d/0971a8ea435af5156acaaccec1a505f981c9c80227633851f2810abd252a/brotli-1.2.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2a7f1d03727130fc875448b65b127a9ec5d06d19d0148e7554384229706f9d1b", size = 1489661, upload-time = "2025-11-05T18:38:18.41Z" },
+ { url = "https://files.pythonhosted.org/packages/f3/75/c1baca8b4ec6c96a03ef8230fab2a785e35297632f402ebb1e78a1e39116/brotli-1.2.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:9c79f57faa25d97900bfb119480806d783fba83cd09ee0b33c17623935b05fa3", size = 1599150, upload-time = "2025-11-05T18:38:19.792Z" },
+ { url = "https://files.pythonhosted.org/packages/0d/1a/23fcfee1c324fd48a63d7ebf4bac3a4115bdb1b00e600f80f727d850b1ae/brotli-1.2.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:844a8ceb8483fefafc412f85c14f2aae2fb69567bf2a0de53cdb88b73e7c43ae", size = 1493505, upload-time = "2025-11-05T18:38:20.913Z" },
+ { url = "https://files.pythonhosted.org/packages/36/e5/12904bbd36afeef53d45a84881a4810ae8810ad7e328a971ebbfd760a0b3/brotli-1.2.0-cp311-cp311-win32.whl", hash = "sha256:aa47441fa3026543513139cb8926a92a8e305ee9c71a6209ef7a97d91640ea03", size = 334451, upload-time = "2025-11-05T18:38:21.94Z" },
+ { url = "https://files.pythonhosted.org/packages/02/8b/ecb5761b989629a4758c394b9301607a5880de61ee2ee5fe104b87149ebc/brotli-1.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:022426c9e99fd65d9475dce5c195526f04bb8be8907607e27e747893f6ee3e24", size = 369035, upload-time = "2025-11-05T18:38:22.941Z" },
+ { url = "https://files.pythonhosted.org/packages/11/ee/b0a11ab2315c69bb9b45a2aaed022499c9c24a205c3a49c3513b541a7967/brotli-1.2.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:35d382625778834a7f3061b15423919aa03e4f5da34ac8e02c074e4b75ab4f84", size = 861543, upload-time = "2025-11-05T18:38:24.183Z" },
+ { url = "https://files.pythonhosted.org/packages/e1/2f/29c1459513cd35828e25531ebfcbf3e92a5e49f560b1777a9af7203eb46e/brotli-1.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7a61c06b334bd99bc5ae84f1eeb36bfe01400264b3c352f968c6e30a10f9d08b", size = 444288, upload-time = "2025-11-05T18:38:25.139Z" },
+ { url = "https://files.pythonhosted.org/packages/3d/6f/feba03130d5fceadfa3a1bb102cb14650798c848b1df2a808356f939bb16/brotli-1.2.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:acec55bb7c90f1dfc476126f9711a8e81c9af7fb617409a9ee2953115343f08d", size = 1528071, upload-time = "2025-11-05T18:38:26.081Z" },
+ { url = "https://files.pythonhosted.org/packages/2b/38/f3abb554eee089bd15471057ba85f47e53a44a462cfce265d9bf7088eb09/brotli-1.2.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:260d3692396e1895c5034f204f0db022c056f9e2ac841593a4cf9426e2a3faca", size = 1626913, upload-time = "2025-11-05T18:38:27.284Z" },
+ { url = "https://files.pythonhosted.org/packages/03/a7/03aa61fbc3c5cbf99b44d158665f9b0dd3d8059be16c460208d9e385c837/brotli-1.2.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:072e7624b1fc4d601036ab3f4f27942ef772887e876beff0301d261210bca97f", size = 1419762, upload-time = "2025-11-05T18:38:28.295Z" },
+ { url = "https://files.pythonhosted.org/packages/21/1b/0374a89ee27d152a5069c356c96b93afd1b94eae83f1e004b57eb6ce2f10/brotli-1.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:adedc4a67e15327dfdd04884873c6d5a01d3e3b6f61406f99b1ed4865a2f6d28", size = 1484494, upload-time = "2025-11-05T18:38:29.29Z" },
+ { url = "https://files.pythonhosted.org/packages/cf/57/69d4fe84a67aef4f524dcd075c6eee868d7850e85bf01d778a857d8dbe0a/brotli-1.2.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:7a47ce5c2288702e09dc22a44d0ee6152f2c7eda97b3c8482d826a1f3cfc7da7", size = 1593302, upload-time = "2025-11-05T18:38:30.639Z" },
+ { url = "https://files.pythonhosted.org/packages/d5/3b/39e13ce78a8e9a621c5df3aeb5fd181fcc8caba8c48a194cd629771f6828/brotli-1.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:af43b8711a8264bb4e7d6d9a6d004c3a2019c04c01127a868709ec29962b6036", size = 1487913, upload-time = "2025-11-05T18:38:31.618Z" },
+ { url = "https://files.pythonhosted.org/packages/62/28/4d00cb9bd76a6357a66fcd54b4b6d70288385584063f4b07884c1e7286ac/brotli-1.2.0-cp312-cp312-win32.whl", hash = "sha256:e99befa0b48f3cd293dafeacdd0d191804d105d279e0b387a32054c1180f3161", size = 334362, upload-time = "2025-11-05T18:38:32.939Z" },
+ { url = "https://files.pythonhosted.org/packages/1c/4e/bc1dcac9498859d5e353c9b153627a3752868a9d5f05ce8dedd81a2354ab/brotli-1.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:b35c13ce241abdd44cb8ca70683f20c0c079728a36a996297adb5334adfc1c44", size = 369115, upload-time = "2025-11-05T18:38:33.765Z" },
+ { url = "https://files.pythonhosted.org/packages/6c/d4/4ad5432ac98c73096159d9ce7ffeb82d151c2ac84adcc6168e476bb54674/brotli-1.2.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:9e5825ba2c9998375530504578fd4d5d1059d09621a02065d1b6bfc41a8e05ab", size = 861523, upload-time = "2025-11-05T18:38:34.67Z" },
+ { url = "https://files.pythonhosted.org/packages/91/9f/9cc5bd03ee68a85dc4bc89114f7067c056a3c14b3d95f171918c088bf88d/brotli-1.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0cf8c3b8ba93d496b2fae778039e2f5ecc7cff99df84df337ca31d8f2252896c", size = 444289, upload-time = "2025-11-05T18:38:35.6Z" },
+ { url = "https://files.pythonhosted.org/packages/2e/b6/fe84227c56a865d16a6614e2c4722864b380cb14b13f3e6bef441e73a85a/brotli-1.2.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c8565e3cdc1808b1a34714b553b262c5de5fbda202285782173ec137fd13709f", size = 1528076, upload-time = "2025-11-05T18:38:36.639Z" },
+ { url = "https://files.pythonhosted.org/packages/55/de/de4ae0aaca06c790371cf6e7ee93a024f6b4bb0568727da8c3de112e726c/brotli-1.2.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:26e8d3ecb0ee458a9804f47f21b74845cc823fd1bb19f02272be70774f56e2a6", size = 1626880, upload-time = "2025-11-05T18:38:37.623Z" },
+ { url = "https://files.pythonhosted.org/packages/5f/16/a1b22cbea436642e071adcaf8d4b350a2ad02f5e0ad0da879a1be16188a0/brotli-1.2.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:67a91c5187e1eec76a61625c77a6c8c785650f5b576ca732bd33ef58b0dff49c", size = 1419737, upload-time = "2025-11-05T18:38:38.729Z" },
+ { url = "https://files.pythonhosted.org/packages/46/63/c968a97cbb3bdbf7f974ef5a6ab467a2879b82afbc5ffb65b8acbb744f95/brotli-1.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4ecdb3b6dc36e6d6e14d3a1bdc6c1057c8cbf80db04031d566eb6080ce283a48", size = 1484440, upload-time = "2025-11-05T18:38:39.916Z" },
+ { url = "https://files.pythonhosted.org/packages/06/9d/102c67ea5c9fc171f423e8399e585dabea29b5bc79b05572891e70013cdd/brotli-1.2.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3e1b35d56856f3ed326b140d3c6d9db91740f22e14b06e840fe4bb1923439a18", size = 1593313, upload-time = "2025-11-05T18:38:41.24Z" },
+ { url = "https://files.pythonhosted.org/packages/9e/4a/9526d14fa6b87bc827ba1755a8440e214ff90de03095cacd78a64abe2b7d/brotli-1.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:54a50a9dad16b32136b2241ddea9e4df159b41247b2ce6aac0b3276a66a8f1e5", size = 1487945, upload-time = "2025-11-05T18:38:42.277Z" },
+ { url = "https://files.pythonhosted.org/packages/5b/e8/3fe1ffed70cbef83c5236166acaed7bb9c766509b157854c80e2f766b38c/brotli-1.2.0-cp313-cp313-win32.whl", hash = "sha256:1b1d6a4efedd53671c793be6dd760fcf2107da3a52331ad9ea429edf0902f27a", size = 334368, upload-time = "2025-11-05T18:38:43.345Z" },
+ { url = "https://files.pythonhosted.org/packages/ff/91/e739587be970a113b37b821eae8097aac5a48e5f0eca438c22e4c7dd8648/brotli-1.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:b63daa43d82f0cdabf98dee215b375b4058cce72871fd07934f179885aad16e8", size = 369116, upload-time = "2025-11-05T18:38:44.609Z" },
+ { url = "https://files.pythonhosted.org/packages/17/e1/298c2ddf786bb7347a1cd71d63a347a79e5712a7c0cba9e3c3458ebd976f/brotli-1.2.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:6c12dad5cd04530323e723787ff762bac749a7b256a5bece32b2243dd5c27b21", size = 863080, upload-time = "2025-11-05T18:38:45.503Z" },
+ { url = "https://files.pythonhosted.org/packages/84/0c/aac98e286ba66868b2b3b50338ffbd85a35c7122e9531a73a37a29763d38/brotli-1.2.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:3219bd9e69868e57183316ee19c84e03e8f8b5a1d1f2667e1aa8c2f91cb061ac", size = 445453, upload-time = "2025-11-05T18:38:46.433Z" },
+ { url = "https://files.pythonhosted.org/packages/ec/f1/0ca1f3f99ae300372635ab3fe2f7a79fa335fee3d874fa7f9e68575e0e62/brotli-1.2.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:963a08f3bebd8b75ac57661045402da15991468a621f014be54e50f53a58d19e", size = 1528168, upload-time = "2025-11-05T18:38:47.371Z" },
+ { url = "https://files.pythonhosted.org/packages/d6/a6/2ebfc8f766d46df8d3e65b880a2e220732395e6d7dc312c1e1244b0f074a/brotli-1.2.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9322b9f8656782414b37e6af884146869d46ab85158201d82bab9abbcb971dc7", size = 1627098, upload-time = "2025-11-05T18:38:48.385Z" },
+ { url = "https://files.pythonhosted.org/packages/f3/2f/0976d5b097ff8a22163b10617f76b2557f15f0f39d6a0fe1f02b1a53e92b/brotli-1.2.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cf9cba6f5b78a2071ec6fb1e7bd39acf35071d90a81231d67e92d637776a6a63", size = 1419861, upload-time = "2025-11-05T18:38:49.372Z" },
+ { url = "https://files.pythonhosted.org/packages/9c/97/d76df7176a2ce7616ff94c1fb72d307c9a30d2189fe877f3dd99af00ea5a/brotli-1.2.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7547369c4392b47d30a3467fe8c3330b4f2e0f7730e45e3103d7d636678a808b", size = 1484594, upload-time = "2025-11-05T18:38:50.655Z" },
+ { url = "https://files.pythonhosted.org/packages/d3/93/14cf0b1216f43df5609f5b272050b0abd219e0b54ea80b47cef9867b45e7/brotli-1.2.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:fc1530af5c3c275b8524f2e24841cbe2599d74462455e9bae5109e9ff42e9361", size = 1593455, upload-time = "2025-11-05T18:38:51.624Z" },
+ { url = "https://files.pythonhosted.org/packages/b3/73/3183c9e41ca755713bdf2cc1d0810df742c09484e2e1ddd693bee53877c1/brotli-1.2.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d2d085ded05278d1c7f65560aae97b3160aeb2ea2c0b3e26204856beccb60888", size = 1488164, upload-time = "2025-11-05T18:38:53.079Z" },
+ { url = "https://files.pythonhosted.org/packages/64/6a/0c78d8f3a582859236482fd9fa86a65a60328a00983006bcf6d83b7b2253/brotli-1.2.0-cp314-cp314-win32.whl", hash = "sha256:832c115a020e463c2f67664560449a7bea26b0c1fdd690352addad6d0a08714d", size = 339280, upload-time = "2025-11-05T18:38:54.02Z" },
+ { url = "https://files.pythonhosted.org/packages/f5/10/56978295c14794b2c12007b07f3e41ba26acda9257457d7085b0bb3bb90c/brotli-1.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:e7c0af964e0b4e3412a0ebf341ea26ec767fa0b4cf81abb5e897c9338b5ad6a3", size = 375639, upload-time = "2025-11-05T18:38:55.67Z" },
+]
+
[[package]]
name = "certifi"
version = "2025.11.12"
@@ -317,6 +394,24 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/0d/c3/e90f4a4feae6410f914f8ebac129b9ae7a8c92eb60a638012dde42030a9d/cryptography-46.0.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:6b5063083824e5509fdba180721d55909ffacccc8adbec85268b48439423d78c", size = 3438528, upload-time = "2025-10-15T23:18:26.227Z" },
]
+[[package]]
+name = "distro"
+version = "1.9.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fc/f8/98eea607f65de6527f8a2e8885fc8015d3e6f5775df186e443e0964a11c3/distro-1.9.0.tar.gz", hash = "sha256:2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed", size = 60722, upload-time = "2023-12-24T09:54:32.31Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2", size = 20277, upload-time = "2023-12-24T09:54:30.421Z" },
+]
+
+[[package]]
+name = "docstring-parser"
+version = "0.17.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b2/9d/c3b43da9515bd270df0f80548d9944e389870713cc1fe2b8fb35fe2bcefd/docstring_parser-0.17.0.tar.gz", hash = "sha256:583de4a309722b3315439bb31d64ba3eebada841f2e2cee23b99df001434c912", size = 27442, upload-time = "2025-07-21T07:35:01.868Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/55/e2/2537ebcff11c1ee1ff17d8d0b6f4db75873e3b0fb32c2d4a2ee31ecb310a/docstring_parser-0.17.0-py3-none-any.whl", hash = "sha256:cf2569abd23dce8099b300f9b4fa8191e9582dda731fd533daf54c4551658708", size = 36896, upload-time = "2025-07-21T07:35:00.684Z" },
+]
+
[[package]]
name = "exceptiongroup"
version = "1.3.1"
@@ -439,6 +534,103 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
]
+[[package]]
+name = "jiter"
+version = "0.12.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/45/9d/e0660989c1370e25848bb4c52d061c71837239738ad937e83edca174c273/jiter-0.12.0.tar.gz", hash = "sha256:64dfcd7d5c168b38d3f9f8bba7fc639edb3418abcc74f22fdbe6b8938293f30b", size = 168294, upload-time = "2025-11-09T20:49:23.302Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/3b/91/13cb9505f7be74a933f37da3af22e029f6ba64f5669416cb8b2774bc9682/jiter-0.12.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:e7acbaba9703d5de82a2c98ae6a0f59ab9770ab5af5fa35e43a303aee962cf65", size = 316652, upload-time = "2025-11-09T20:46:41.021Z" },
+ { url = "https://files.pythonhosted.org/packages/4e/76/4e9185e5d9bb4e482cf6dec6410d5f78dfeb374cfcecbbe9888d07c52daa/jiter-0.12.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:364f1a7294c91281260364222f535bc427f56d4de1d8ffd718162d21fbbd602e", size = 319829, upload-time = "2025-11-09T20:46:43.281Z" },
+ { url = "https://files.pythonhosted.org/packages/86/af/727de50995d3a153138139f259baae2379d8cb0522c0c00419957bc478a6/jiter-0.12.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:85ee4d25805d4fb23f0a5167a962ef8e002dbfb29c0989378488e32cf2744b62", size = 350568, upload-time = "2025-11-09T20:46:45.075Z" },
+ { url = "https://files.pythonhosted.org/packages/6a/c1/d6e9f4b7a3d5ac63bcbdfddeb50b2dcfbdc512c86cffc008584fdc350233/jiter-0.12.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:796f466b7942107eb889c08433b6e31b9a7ed31daceaecf8af1be26fb26c0ca8", size = 369052, upload-time = "2025-11-09T20:46:46.818Z" },
+ { url = "https://files.pythonhosted.org/packages/eb/be/00824cd530f30ed73fa8a4f9f3890a705519e31ccb9e929f1e22062e7c76/jiter-0.12.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:35506cb71f47dba416694e67af996bbdefb8e3608f1f78799c2e1f9058b01ceb", size = 481585, upload-time = "2025-11-09T20:46:48.319Z" },
+ { url = "https://files.pythonhosted.org/packages/74/b6/2ad7990dff9504d4b5052eef64aa9574bd03d722dc7edced97aad0d47be7/jiter-0.12.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:726c764a90c9218ec9e4f99a33d6bf5ec169163f2ca0fc21b654e88c2abc0abc", size = 380541, upload-time = "2025-11-09T20:46:49.643Z" },
+ { url = "https://files.pythonhosted.org/packages/b5/c7/f3c26ecbc1adbf1db0d6bba99192143d8fe8504729d9594542ecc4445784/jiter-0.12.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:baa47810c5565274810b726b0dc86d18dce5fd17b190ebdc3890851d7b2a0e74", size = 364423, upload-time = "2025-11-09T20:46:51.731Z" },
+ { url = "https://files.pythonhosted.org/packages/18/51/eac547bf3a2d7f7e556927278e14c56a0604b8cddae75815d5739f65f81d/jiter-0.12.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f8ec0259d3f26c62aed4d73b198c53e316ae11f0f69c8fbe6682c6dcfa0fcce2", size = 389958, upload-time = "2025-11-09T20:46:53.432Z" },
+ { url = "https://files.pythonhosted.org/packages/2c/1f/9ca592e67175f2db156cff035e0d817d6004e293ee0c1d73692d38fcb596/jiter-0.12.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:79307d74ea83465b0152fa23e5e297149506435535282f979f18b9033c0bb025", size = 522084, upload-time = "2025-11-09T20:46:54.848Z" },
+ { url = "https://files.pythonhosted.org/packages/83/ff/597d9cdc3028f28224f53e1a9d063628e28b7a5601433e3196edda578cdd/jiter-0.12.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:cf6e6dd18927121fec86739f1a8906944703941d000f0639f3eb6281cc601dca", size = 513054, upload-time = "2025-11-09T20:46:56.487Z" },
+ { url = "https://files.pythonhosted.org/packages/24/6d/1970bce1351bd02e3afcc5f49e4f7ef3dabd7fb688f42be7e8091a5b809a/jiter-0.12.0-cp310-cp310-win32.whl", hash = "sha256:b6ae2aec8217327d872cbfb2c1694489057b9433afce447955763e6ab015b4c4", size = 206368, upload-time = "2025-11-09T20:46:58.638Z" },
+ { url = "https://files.pythonhosted.org/packages/e3/6b/eb1eb505b2d86709b59ec06681a2b14a94d0941db091f044b9f0e16badc0/jiter-0.12.0-cp310-cp310-win_amd64.whl", hash = "sha256:c7f49ce90a71e44f7e1aa9e7ec415b9686bbc6a5961e57eab511015e6759bc11", size = 204847, upload-time = "2025-11-09T20:47:00.295Z" },
+ { url = "https://files.pythonhosted.org/packages/32/f9/eaca4633486b527ebe7e681c431f529b63fe2709e7c5242fc0f43f77ce63/jiter-0.12.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:d8f8a7e317190b2c2d60eb2e8aa835270b008139562d70fe732e1c0020ec53c9", size = 316435, upload-time = "2025-11-09T20:47:02.087Z" },
+ { url = "https://files.pythonhosted.org/packages/10/c1/40c9f7c22f5e6ff715f28113ebaba27ab85f9af2660ad6e1dd6425d14c19/jiter-0.12.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2218228a077e784c6c8f1a8e5d6b8cb1dea62ce25811c356364848554b2056cd", size = 320548, upload-time = "2025-11-09T20:47:03.409Z" },
+ { url = "https://files.pythonhosted.org/packages/6b/1b/efbb68fe87e7711b00d2cfd1f26bb4bfc25a10539aefeaa7727329ffb9cb/jiter-0.12.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9354ccaa2982bf2188fd5f57f79f800ef622ec67beb8329903abf6b10da7d423", size = 351915, upload-time = "2025-11-09T20:47:05.171Z" },
+ { url = "https://files.pythonhosted.org/packages/15/2d/c06e659888c128ad1e838123d0638f0efad90cc30860cb5f74dd3f2fc0b3/jiter-0.12.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8f2607185ea89b4af9a604d4c7ec40e45d3ad03ee66998b031134bc510232bb7", size = 368966, upload-time = "2025-11-09T20:47:06.508Z" },
+ { url = "https://files.pythonhosted.org/packages/6b/20/058db4ae5fb07cf6a4ab2e9b9294416f606d8e467fb74c2184b2a1eeacba/jiter-0.12.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3a585a5e42d25f2e71db5f10b171f5e5ea641d3aa44f7df745aa965606111cc2", size = 482047, upload-time = "2025-11-09T20:47:08.382Z" },
+ { url = "https://files.pythonhosted.org/packages/49/bb/dc2b1c122275e1de2eb12905015d61e8316b2f888bdaac34221c301495d6/jiter-0.12.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd9e21d34edff5a663c631f850edcb786719c960ce887a5661e9c828a53a95d9", size = 380835, upload-time = "2025-11-09T20:47:09.81Z" },
+ { url = "https://files.pythonhosted.org/packages/23/7d/38f9cd337575349de16da575ee57ddb2d5a64d425c9367f5ef9e4612e32e/jiter-0.12.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4a612534770470686cd5431478dc5a1b660eceb410abade6b1b74e320ca98de6", size = 364587, upload-time = "2025-11-09T20:47:11.529Z" },
+ { url = "https://files.pythonhosted.org/packages/f0/a3/b13e8e61e70f0bb06085099c4e2462647f53cc2ca97614f7fedcaa2bb9f3/jiter-0.12.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:3985aea37d40a908f887b34d05111e0aae822943796ebf8338877fee2ab67725", size = 390492, upload-time = "2025-11-09T20:47:12.993Z" },
+ { url = "https://files.pythonhosted.org/packages/07/71/e0d11422ed027e21422f7bc1883c61deba2d9752b720538430c1deadfbca/jiter-0.12.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:b1207af186495f48f72529f8d86671903c8c10127cac6381b11dddc4aaa52df6", size = 522046, upload-time = "2025-11-09T20:47:14.6Z" },
+ { url = "https://files.pythonhosted.org/packages/9f/59/b968a9aa7102a8375dbbdfbd2aeebe563c7e5dddf0f47c9ef1588a97e224/jiter-0.12.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:ef2fb241de583934c9915a33120ecc06d94aa3381a134570f59eed784e87001e", size = 513392, upload-time = "2025-11-09T20:47:16.011Z" },
+ { url = "https://files.pythonhosted.org/packages/ca/e4/7df62002499080dbd61b505c5cb351aa09e9959d176cac2aa8da6f93b13b/jiter-0.12.0-cp311-cp311-win32.whl", hash = "sha256:453b6035672fecce8007465896a25b28a6b59cfe8fbc974b2563a92f5a92a67c", size = 206096, upload-time = "2025-11-09T20:47:17.344Z" },
+ { url = "https://files.pythonhosted.org/packages/bb/60/1032b30ae0572196b0de0e87dce3b6c26a1eff71aad5fe43dee3082d32e0/jiter-0.12.0-cp311-cp311-win_amd64.whl", hash = "sha256:ca264b9603973c2ad9435c71a8ec8b49f8f715ab5ba421c85a51cde9887e421f", size = 204899, upload-time = "2025-11-09T20:47:19.365Z" },
+ { url = "https://files.pythonhosted.org/packages/49/d5/c145e526fccdb834063fb45c071df78b0cc426bbaf6de38b0781f45d956f/jiter-0.12.0-cp311-cp311-win_arm64.whl", hash = "sha256:cb00ef392e7d684f2754598c02c409f376ddcef857aae796d559e6cacc2d78a5", size = 188070, upload-time = "2025-11-09T20:47:20.75Z" },
+ { url = "https://files.pythonhosted.org/packages/92/c9/5b9f7b4983f1b542c64e84165075335e8a236fa9e2ea03a0c79780062be8/jiter-0.12.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:305e061fa82f4680607a775b2e8e0bcb071cd2205ac38e6ef48c8dd5ebe1cf37", size = 314449, upload-time = "2025-11-09T20:47:22.999Z" },
+ { url = "https://files.pythonhosted.org/packages/98/6e/e8efa0e78de00db0aee82c0cf9e8b3f2027efd7f8a71f859d8f4be8e98ef/jiter-0.12.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5c1860627048e302a528333c9307c818c547f214d8659b0705d2195e1a94b274", size = 319855, upload-time = "2025-11-09T20:47:24.779Z" },
+ { url = "https://files.pythonhosted.org/packages/20/26/894cd88e60b5d58af53bec5c6759d1292bd0b37a8b5f60f07abf7a63ae5f/jiter-0.12.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:df37577a4f8408f7e0ec3205d2a8f87672af8f17008358063a4d6425b6081ce3", size = 350171, upload-time = "2025-11-09T20:47:26.469Z" },
+ { url = "https://files.pythonhosted.org/packages/f5/27/a7b818b9979ac31b3763d25f3653ec3a954044d5e9f5d87f2f247d679fd1/jiter-0.12.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:75fdd787356c1c13a4f40b43c2156276ef7a71eb487d98472476476d803fb2cf", size = 365590, upload-time = "2025-11-09T20:47:27.918Z" },
+ { url = "https://files.pythonhosted.org/packages/ba/7e/e46195801a97673a83746170b17984aa8ac4a455746354516d02ca5541b4/jiter-0.12.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1eb5db8d9c65b112aacf14fcd0faae9913d07a8afea5ed06ccdd12b724e966a1", size = 479462, upload-time = "2025-11-09T20:47:29.654Z" },
+ { url = "https://files.pythonhosted.org/packages/ca/75/f833bfb009ab4bd11b1c9406d333e3b4357709ed0570bb48c7c06d78c7dd/jiter-0.12.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:73c568cc27c473f82480abc15d1301adf333a7ea4f2e813d6a2c7d8b6ba8d0df", size = 378983, upload-time = "2025-11-09T20:47:31.026Z" },
+ { url = "https://files.pythonhosted.org/packages/71/b3/7a69d77943cc837d30165643db753471aff5df39692d598da880a6e51c24/jiter-0.12.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4321e8a3d868919bcb1abb1db550d41f2b5b326f72df29e53b2df8b006eb9403", size = 361328, upload-time = "2025-11-09T20:47:33.286Z" },
+ { url = "https://files.pythonhosted.org/packages/b0/ac/a78f90caf48d65ba70d8c6efc6f23150bc39dc3389d65bbec2a95c7bc628/jiter-0.12.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:0a51bad79f8cc9cac2b4b705039f814049142e0050f30d91695a2d9a6611f126", size = 386740, upload-time = "2025-11-09T20:47:34.703Z" },
+ { url = "https://files.pythonhosted.org/packages/39/b6/5d31c2cc8e1b6a6bcf3c5721e4ca0a3633d1ab4754b09bc7084f6c4f5327/jiter-0.12.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:2a67b678f6a5f1dd6c36d642d7db83e456bc8b104788262aaefc11a22339f5a9", size = 520875, upload-time = "2025-11-09T20:47:36.058Z" },
+ { url = "https://files.pythonhosted.org/packages/30/b5/4df540fae4e9f68c54b8dab004bd8c943a752f0b00efd6e7d64aa3850339/jiter-0.12.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:efe1a211fe1fd14762adea941e3cfd6c611a136e28da6c39272dbb7a1bbe6a86", size = 511457, upload-time = "2025-11-09T20:47:37.932Z" },
+ { url = "https://files.pythonhosted.org/packages/07/65/86b74010e450a1a77b2c1aabb91d4a91dd3cd5afce99f34d75fd1ac64b19/jiter-0.12.0-cp312-cp312-win32.whl", hash = "sha256:d779d97c834b4278276ec703dc3fc1735fca50af63eb7262f05bdb4e62203d44", size = 204546, upload-time = "2025-11-09T20:47:40.47Z" },
+ { url = "https://files.pythonhosted.org/packages/1c/c7/6659f537f9562d963488e3e55573498a442503ced01f7e169e96a6110383/jiter-0.12.0-cp312-cp312-win_amd64.whl", hash = "sha256:e8269062060212b373316fe69236096aaf4c49022d267c6736eebd66bbbc60bb", size = 205196, upload-time = "2025-11-09T20:47:41.794Z" },
+ { url = "https://files.pythonhosted.org/packages/21/f4/935304f5169edadfec7f9c01eacbce4c90bb9a82035ac1de1f3bd2d40be6/jiter-0.12.0-cp312-cp312-win_arm64.whl", hash = "sha256:06cb970936c65de926d648af0ed3d21857f026b1cf5525cb2947aa5e01e05789", size = 186100, upload-time = "2025-11-09T20:47:43.007Z" },
+ { url = "https://files.pythonhosted.org/packages/3d/a6/97209693b177716e22576ee1161674d1d58029eb178e01866a0422b69224/jiter-0.12.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:6cc49d5130a14b732e0612bc76ae8db3b49898732223ef8b7599aa8d9810683e", size = 313658, upload-time = "2025-11-09T20:47:44.424Z" },
+ { url = "https://files.pythonhosted.org/packages/06/4d/125c5c1537c7d8ee73ad3d530a442d6c619714b95027143f1b61c0b4dfe0/jiter-0.12.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:37f27a32ce36364d2fa4f7fdc507279db604d27d239ea2e044c8f148410defe1", size = 318605, upload-time = "2025-11-09T20:47:45.973Z" },
+ { url = "https://files.pythonhosted.org/packages/99/bf/a840b89847885064c41a5f52de6e312e91fa84a520848ee56c97e4fa0205/jiter-0.12.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bbc0944aa3d4b4773e348cda635252824a78f4ba44328e042ef1ff3f6080d1cf", size = 349803, upload-time = "2025-11-09T20:47:47.535Z" },
+ { url = "https://files.pythonhosted.org/packages/8a/88/e63441c28e0db50e305ae23e19c1d8fae012d78ed55365da392c1f34b09c/jiter-0.12.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:da25c62d4ee1ffbacb97fac6dfe4dcd6759ebdc9015991e92a6eae5816287f44", size = 365120, upload-time = "2025-11-09T20:47:49.284Z" },
+ { url = "https://files.pythonhosted.org/packages/0a/7c/49b02714af4343970eb8aca63396bc1c82fa01197dbb1e9b0d274b550d4e/jiter-0.12.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:048485c654b838140b007390b8182ba9774621103bd4d77c9c3f6f117474ba45", size = 479918, upload-time = "2025-11-09T20:47:50.807Z" },
+ { url = "https://files.pythonhosted.org/packages/69/ba/0a809817fdd5a1db80490b9150645f3aae16afad166960bcd562be194f3b/jiter-0.12.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:635e737fbb7315bef0037c19b88b799143d2d7d3507e61a76751025226b3ac87", size = 379008, upload-time = "2025-11-09T20:47:52.211Z" },
+ { url = "https://files.pythonhosted.org/packages/5f/c3/c9fc0232e736c8877d9e6d83d6eeb0ba4e90c6c073835cc2e8f73fdeef51/jiter-0.12.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4e017c417b1ebda911bd13b1e40612704b1f5420e30695112efdbed8a4b389ed", size = 361785, upload-time = "2025-11-09T20:47:53.512Z" },
+ { url = "https://files.pythonhosted.org/packages/96/61/61f69b7e442e97ca6cd53086ddc1cf59fb830549bc72c0a293713a60c525/jiter-0.12.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:89b0bfb8b2bf2351fba36bb211ef8bfceba73ef58e7f0c68fb67b5a2795ca2f9", size = 386108, upload-time = "2025-11-09T20:47:54.893Z" },
+ { url = "https://files.pythonhosted.org/packages/e9/2e/76bb3332f28550c8f1eba3bf6e5efe211efda0ddbbaf24976bc7078d42a5/jiter-0.12.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:f5aa5427a629a824a543672778c9ce0c5e556550d1569bb6ea28a85015287626", size = 519937, upload-time = "2025-11-09T20:47:56.253Z" },
+ { url = "https://files.pythonhosted.org/packages/84/d6/fa96efa87dc8bff2094fb947f51f66368fa56d8d4fc9e77b25d7fbb23375/jiter-0.12.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:ed53b3d6acbcb0fd0b90f20c7cb3b24c357fe82a3518934d4edfa8c6898e498c", size = 510853, upload-time = "2025-11-09T20:47:58.32Z" },
+ { url = "https://files.pythonhosted.org/packages/8a/28/93f67fdb4d5904a708119a6ab58a8f1ec226ff10a94a282e0215402a8462/jiter-0.12.0-cp313-cp313-win32.whl", hash = "sha256:4747de73d6b8c78f2e253a2787930f4fffc68da7fa319739f57437f95963c4de", size = 204699, upload-time = "2025-11-09T20:47:59.686Z" },
+ { url = "https://files.pythonhosted.org/packages/c4/1f/30b0eb087045a0abe2a5c9c0c0c8da110875a1d3be83afd4a9a4e548be3c/jiter-0.12.0-cp313-cp313-win_amd64.whl", hash = "sha256:e25012eb0c456fcc13354255d0338cd5397cce26c77b2832b3c4e2e255ea5d9a", size = 204258, upload-time = "2025-11-09T20:48:01.01Z" },
+ { url = "https://files.pythonhosted.org/packages/2c/f4/2b4daf99b96bce6fc47971890b14b2a36aef88d7beb9f057fafa032c6141/jiter-0.12.0-cp313-cp313-win_arm64.whl", hash = "sha256:c97b92c54fe6110138c872add030a1f99aea2401ddcdaa21edf74705a646dd60", size = 185503, upload-time = "2025-11-09T20:48:02.35Z" },
+ { url = "https://files.pythonhosted.org/packages/39/ca/67bb15a7061d6fe20b9b2a2fd783e296a1e0f93468252c093481a2f00efa/jiter-0.12.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:53839b35a38f56b8be26a7851a48b89bc47e5d88e900929df10ed93b95fea3d6", size = 317965, upload-time = "2025-11-09T20:48:03.783Z" },
+ { url = "https://files.pythonhosted.org/packages/18/af/1788031cd22e29c3b14bc6ca80b16a39a0b10e611367ffd480c06a259831/jiter-0.12.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:94f669548e55c91ab47fef8bddd9c954dab1938644e715ea49d7e117015110a4", size = 345831, upload-time = "2025-11-09T20:48:05.55Z" },
+ { url = "https://files.pythonhosted.org/packages/05/17/710bf8472d1dff0d3caf4ced6031060091c1320f84ee7d5dcbed1f352417/jiter-0.12.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:351d54f2b09a41600ffea43d081522d792e81dcfb915f6d2d242744c1cc48beb", size = 361272, upload-time = "2025-11-09T20:48:06.951Z" },
+ { url = "https://files.pythonhosted.org/packages/fb/f1/1dcc4618b59761fef92d10bcbb0b038b5160be653b003651566a185f1a5c/jiter-0.12.0-cp313-cp313t-win_amd64.whl", hash = "sha256:2a5e90604620f94bf62264e7c2c038704d38217b7465b863896c6d7c902b06c7", size = 204604, upload-time = "2025-11-09T20:48:08.328Z" },
+ { url = "https://files.pythonhosted.org/packages/d9/32/63cb1d9f1c5c6632a783c0052cde9ef7ba82688f7065e2f0d5f10a7e3edb/jiter-0.12.0-cp313-cp313t-win_arm64.whl", hash = "sha256:88ef757017e78d2860f96250f9393b7b577b06a956ad102c29c8237554380db3", size = 185628, upload-time = "2025-11-09T20:48:09.572Z" },
+ { url = "https://files.pythonhosted.org/packages/a8/99/45c9f0dbe4a1416b2b9a8a6d1236459540f43d7fb8883cff769a8db0612d/jiter-0.12.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:c46d927acd09c67a9fb1416df45c5a04c27e83aae969267e98fba35b74e99525", size = 312478, upload-time = "2025-11-09T20:48:10.898Z" },
+ { url = "https://files.pythonhosted.org/packages/4c/a7/54ae75613ba9e0f55fcb0bc5d1f807823b5167cc944e9333ff322e9f07dd/jiter-0.12.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:774ff60b27a84a85b27b88cd5583899c59940bcc126caca97eb2a9df6aa00c49", size = 318706, upload-time = "2025-11-09T20:48:12.266Z" },
+ { url = "https://files.pythonhosted.org/packages/59/31/2aa241ad2c10774baf6c37f8b8e1f39c07db358f1329f4eb40eba179c2a2/jiter-0.12.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c5433fab222fb072237df3f637d01b81f040a07dcac1cb4a5c75c7aa9ed0bef1", size = 351894, upload-time = "2025-11-09T20:48:13.673Z" },
+ { url = "https://files.pythonhosted.org/packages/54/4f/0f2759522719133a9042781b18cc94e335b6d290f5e2d3e6899d6af933e3/jiter-0.12.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f8c593c6e71c07866ec6bfb790e202a833eeec885022296aff6b9e0b92d6a70e", size = 365714, upload-time = "2025-11-09T20:48:15.083Z" },
+ { url = "https://files.pythonhosted.org/packages/dc/6f/806b895f476582c62a2f52c453151edd8a0fde5411b0497baaa41018e878/jiter-0.12.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:90d32894d4c6877a87ae00c6b915b609406819dce8bc0d4e962e4de2784e567e", size = 478989, upload-time = "2025-11-09T20:48:16.706Z" },
+ { url = "https://files.pythonhosted.org/packages/86/6c/012d894dc6e1033acd8db2b8346add33e413ec1c7c002598915278a37f79/jiter-0.12.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:798e46eed9eb10c3adbbacbd3bdb5ecd4cf7064e453d00dbef08802dae6937ff", size = 378615, upload-time = "2025-11-09T20:48:18.614Z" },
+ { url = "https://files.pythonhosted.org/packages/87/30/d718d599f6700163e28e2c71c0bbaf6dace692e7df2592fd793ac9276717/jiter-0.12.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b3f1368f0a6719ea80013a4eb90ba72e75d7ea67cfc7846db2ca504f3df0169a", size = 364745, upload-time = "2025-11-09T20:48:20.117Z" },
+ { url = "https://files.pythonhosted.org/packages/8f/85/315b45ce4b6ddc7d7fceca24068543b02bdc8782942f4ee49d652e2cc89f/jiter-0.12.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:65f04a9d0b4406f7e51279710b27484af411896246200e461d80d3ba0caa901a", size = 386502, upload-time = "2025-11-09T20:48:21.543Z" },
+ { url = "https://files.pythonhosted.org/packages/74/0b/ce0434fb40c5b24b368fe81b17074d2840748b4952256bab451b72290a49/jiter-0.12.0-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:fd990541982a24281d12b67a335e44f117e4c6cbad3c3b75c7dea68bf4ce3a67", size = 519845, upload-time = "2025-11-09T20:48:22.964Z" },
+ { url = "https://files.pythonhosted.org/packages/e8/a3/7a7a4488ba052767846b9c916d208b3ed114e3eb670ee984e4c565b9cf0d/jiter-0.12.0-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:b111b0e9152fa7df870ecaebb0bd30240d9f7fff1f2003bcb4ed0f519941820b", size = 510701, upload-time = "2025-11-09T20:48:24.483Z" },
+ { url = "https://files.pythonhosted.org/packages/c3/16/052ffbf9d0467b70af24e30f91e0579e13ded0c17bb4a8eb2aed3cb60131/jiter-0.12.0-cp314-cp314-win32.whl", hash = "sha256:a78befb9cc0a45b5a5a0d537b06f8544c2ebb60d19d02c41ff15da28a9e22d42", size = 205029, upload-time = "2025-11-09T20:48:25.749Z" },
+ { url = "https://files.pythonhosted.org/packages/e4/18/3cf1f3f0ccc789f76b9a754bdb7a6977e5d1d671ee97a9e14f7eb728d80e/jiter-0.12.0-cp314-cp314-win_amd64.whl", hash = "sha256:e1fe01c082f6aafbe5c8faf0ff074f38dfb911d53f07ec333ca03f8f6226debf", size = 204960, upload-time = "2025-11-09T20:48:27.415Z" },
+ { url = "https://files.pythonhosted.org/packages/02/68/736821e52ecfdeeb0f024b8ab01b5a229f6b9293bbdb444c27efade50b0f/jiter-0.12.0-cp314-cp314-win_arm64.whl", hash = "sha256:d72f3b5a432a4c546ea4bedc84cce0c3404874f1d1676260b9c7f048a9855451", size = 185529, upload-time = "2025-11-09T20:48:29.125Z" },
+ { url = "https://files.pythonhosted.org/packages/30/61/12ed8ee7a643cce29ac97c2281f9ce3956eb76b037e88d290f4ed0d41480/jiter-0.12.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e6ded41aeba3603f9728ed2b6196e4df875348ab97b28fc8afff115ed42ba7a7", size = 318974, upload-time = "2025-11-09T20:48:30.87Z" },
+ { url = "https://files.pythonhosted.org/packages/2d/c6/f3041ede6d0ed5e0e79ff0de4c8f14f401bbf196f2ef3971cdbe5fd08d1d/jiter-0.12.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a947920902420a6ada6ad51892082521978e9dd44a802663b001436e4b771684", size = 345932, upload-time = "2025-11-09T20:48:32.658Z" },
+ { url = "https://files.pythonhosted.org/packages/d5/5d/4d94835889edd01ad0e2dbfc05f7bdfaed46292e7b504a6ac7839aa00edb/jiter-0.12.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:add5e227e0554d3a52cf390a7635edaffdf4f8fce4fdbcef3cc2055bb396a30c", size = 367243, upload-time = "2025-11-09T20:48:34.093Z" },
+ { url = "https://files.pythonhosted.org/packages/fd/76/0051b0ac2816253a99d27baf3dda198663aff882fa6ea7deeb94046da24e/jiter-0.12.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3f9b1cda8fcb736250d7e8711d4580ebf004a46771432be0ae4796944b5dfa5d", size = 479315, upload-time = "2025-11-09T20:48:35.507Z" },
+ { url = "https://files.pythonhosted.org/packages/70/ae/83f793acd68e5cb24e483f44f482a1a15601848b9b6f199dacb970098f77/jiter-0.12.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:deeb12a2223fe0135c7ff1356a143d57f95bbf1f4a66584f1fc74df21d86b993", size = 380714, upload-time = "2025-11-09T20:48:40.014Z" },
+ { url = "https://files.pythonhosted.org/packages/b1/5e/4808a88338ad2c228b1126b93fcd8ba145e919e886fe910d578230dabe3b/jiter-0.12.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c596cc0f4cb574877550ce4ecd51f8037469146addd676d7c1a30ebe6391923f", size = 365168, upload-time = "2025-11-09T20:48:41.462Z" },
+ { url = "https://files.pythonhosted.org/packages/0c/d4/04619a9e8095b42aef436b5aeb4c0282b4ff1b27d1db1508df9f5dc82750/jiter-0.12.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5ab4c823b216a4aeab3fdbf579c5843165756bd9ad87cc6b1c65919c4715f783", size = 387893, upload-time = "2025-11-09T20:48:42.921Z" },
+ { url = "https://files.pythonhosted.org/packages/17/ea/d3c7e62e4546fdc39197fa4a4315a563a89b95b6d54c0d25373842a59cbe/jiter-0.12.0-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:e427eee51149edf962203ff8db75a7514ab89be5cb623fb9cea1f20b54f1107b", size = 520828, upload-time = "2025-11-09T20:48:44.278Z" },
+ { url = "https://files.pythonhosted.org/packages/cc/0b/c6d3562a03fd767e31cb119d9041ea7958c3c80cb3d753eafb19b3b18349/jiter-0.12.0-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:edb868841f84c111255ba5e80339d386d937ec1fdce419518ce1bd9370fac5b6", size = 511009, upload-time = "2025-11-09T20:48:45.726Z" },
+ { url = "https://files.pythonhosted.org/packages/aa/51/2cb4468b3448a8385ebcd15059d325c9ce67df4e2758d133ab9442b19834/jiter-0.12.0-cp314-cp314t-win32.whl", hash = "sha256:8bbcfe2791dfdb7c5e48baf646d37a6a3dcb5a97a032017741dea9f817dca183", size = 205110, upload-time = "2025-11-09T20:48:47.033Z" },
+ { url = "https://files.pythonhosted.org/packages/b2/c5/ae5ec83dec9c2d1af805fd5fe8f74ebded9c8670c5210ec7820ce0dbeb1e/jiter-0.12.0-cp314-cp314t-win_amd64.whl", hash = "sha256:2fa940963bf02e1d8226027ef461e36af472dea85d36054ff835aeed944dd873", size = 205223, upload-time = "2025-11-09T20:48:49.076Z" },
+ { url = "https://files.pythonhosted.org/packages/97/9a/3c5391907277f0e55195550cf3fa8e293ae9ee0c00fb402fec1e38c0c82f/jiter-0.12.0-cp314-cp314t-win_arm64.whl", hash = "sha256:506c9708dd29b27288f9f8f1140c3cb0e3d8ddb045956d7757b1fa0e0f39a473", size = 185564, upload-time = "2025-11-09T20:48:50.376Z" },
+ { url = "https://files.pythonhosted.org/packages/fe/54/5339ef1ecaa881c6948669956567a64d2670941925f245c434f494ffb0e5/jiter-0.12.0-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:4739a4657179ebf08f85914ce50332495811004cc1747852e8b2041ed2aab9b8", size = 311144, upload-time = "2025-11-09T20:49:10.503Z" },
+ { url = "https://files.pythonhosted.org/packages/27/74/3446c652bffbd5e81ab354e388b1b5fc1d20daac34ee0ed11ff096b1b01a/jiter-0.12.0-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:41da8def934bf7bec16cb24bd33c0ca62126d2d45d81d17b864bd5ad721393c3", size = 305877, upload-time = "2025-11-09T20:49:12.269Z" },
+ { url = "https://files.pythonhosted.org/packages/a1/f4/ed76ef9043450f57aac2d4fbeb27175aa0eb9c38f833be6ef6379b3b9a86/jiter-0.12.0-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9c44ee814f499c082e69872d426b624987dbc5943ab06e9bbaa4f81989fdb79e", size = 340419, upload-time = "2025-11-09T20:49:13.803Z" },
+ { url = "https://files.pythonhosted.org/packages/21/01/857d4608f5edb0664aa791a3d45702e1a5bcfff9934da74035e7b9803846/jiter-0.12.0-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cd2097de91cf03eaa27b3cbdb969addf83f0179c6afc41bbc4513705e013c65d", size = 347212, upload-time = "2025-11-09T20:49:15.643Z" },
+ { url = "https://files.pythonhosted.org/packages/cb/f5/12efb8ada5f5c9edc1d4555fe383c1fb2eac05ac5859258a72d61981d999/jiter-0.12.0-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:e8547883d7b96ef2e5fe22b88f8a4c8725a56e7f4abafff20fd5272d634c7ecb", size = 309974, upload-time = "2025-11-09T20:49:17.187Z" },
+ { url = "https://files.pythonhosted.org/packages/85/15/d6eb3b770f6a0d332675141ab3962fd4a7c270ede3515d9f3583e1d28276/jiter-0.12.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:89163163c0934854a668ed783a2546a0617f71706a2551a4a0666d91ab365d6b", size = 304233, upload-time = "2025-11-09T20:49:18.734Z" },
+ { url = "https://files.pythonhosted.org/packages/8c/3e/e7e06743294eea2cf02ced6aa0ff2ad237367394e37a0e2b4a1108c67a36/jiter-0.12.0-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d96b264ab7d34bbb2312dedc47ce07cd53f06835eacbc16dde3761f47c3a9e7f", size = 338537, upload-time = "2025-11-09T20:49:20.317Z" },
+ { url = "https://files.pythonhosted.org/packages/2f/9c/6753e6522b8d0ef07d3a3d239426669e984fb0eba15a315cdbc1253904e4/jiter-0.12.0-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c24e864cb30ab82311c6425655b0cdab0a98c5d973b065c66a3f020740c2324c", size = 346110, upload-time = "2025-11-09T20:49:21.817Z" },
+]
+
[[package]]
name = "jsonschema"
version = "4.25.1"
@@ -531,6 +723,18 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/6a/60/fe31d7e6b8907789dcb0584f88be741ba388413e4fbce35f1eba4e3073de/playwright-1.57.0-py3-none-win_arm64.whl", hash = "sha256:5f065f5a133dbc15e6e7c71e7bc04f258195755b1c32a432b792e28338c8335e", size = 32837940, upload-time = "2025-12-09T08:06:42.268Z" },
]
+[[package]]
+name = "playwright-stealth"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "playwright" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b0/50/e008cc2d9f01e351d69f0bb0f394882c517611eec0ee3d5f8dd8535ce719/playwright_stealth-2.0.0.tar.gz", hash = "sha256:4f44d416d4226689895a4d1cfb40e8d137216c0c9710ea8f84bae2dbf1186fc5", size = 25723, upload-time = "2025-06-18T03:54:54.528Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/b9/4e/c37ac19cea166a97de3a9690ad5ba340b3f4f4fcd5bf8237cedb2c2c7076/playwright_stealth-2.0.0-py3-none-any.whl", hash = "sha256:9eb3af1fd21619aac9fdd13a4a08141ed67159ac6310a94f7d2f758ba0cbe179", size = 32466, upload-time = "2025-06-18T03:54:53.394Z" },
+]
+
[[package]]
name = "prompt-toolkit"
version = "3.0.52"
@@ -820,9 +1024,12 @@ name = "reverse-api"
version = "0.1.0"
source = { editable = "." }
dependencies = [
+ { name = "anthropic" },
+ { name = "brotli" },
{ name = "claude-agent-sdk" },
{ name = "click" },
{ name = "playwright" },
+ { name = "playwright-stealth" },
{ name = "questionary" },
{ name = "requests" },
{ name = "rich" },
@@ -830,9 +1037,12 @@ dependencies = [
[package.metadata]
requires-dist = [
+ { name = "anthropic", specifier = ">=0.40.0" },
+ { name = "brotli", specifier = ">=1.2.0" },
{ name = "claude-agent-sdk", specifier = ">=0.1.0" },
{ name = "click", specifier = ">=8.1.0" },
{ name = "playwright", specifier = ">=1.40.0" },
+ { name = "playwright-stealth", specifier = ">=1.0.0" },
{ name = "questionary", specifier = ">=2.0.0" },
{ name = "requests", specifier = ">=2.32.5" },
{ name = "rich", specifier = ">=13.0.0" },
@@ -976,6 +1186,15 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/d1/b7/b95708304cd49b7b6f82fdd039f1748b66ec2b21d6a45180910802f1abf1/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:ac37f9f516c51e5753f27dfdef11a88330f04de2d564be3991384b2f3535d02e", size = 562191, upload-time = "2025-11-30T20:24:36.853Z" },
]
+[[package]]
+name = "sniffio"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" },
+]
+
[[package]]
name = "sse-starlette"
version = "3.0.4"