The agent that turns websites into APIs!
feat: repl
kalil0321ae0206fabeb0
diff --git a/pyproject.toml b/pyproject.tomlindex 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.pyindex 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 randomimport signalimport sysfrom pathlib import Pathfrom 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 Consolefrom .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 Noneclass 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_idself.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 = Noneself._browser: Optional[Browser] = Noneself._context: Optional[BrowserContext] = Noneself._start_time: Optional[str] = None+ self._user_agent = random.choice(USER_AGENTS)+ self._using_persistent = False # Track if using persistent contextdef _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 settingsself._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 pagepage = self._context.new_page()+if start_url:- page.goto(start_url)+ page.goto(start_url, wait_until="domcontentloaded")# Wait for browser to closetry:while self._context.pages:- # Check every 500ms if browser is still openself._context.pages[0].wait_for_timeout(500)except Exception:- pass # Browser was closed+ passreturn 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:passself._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 metadataself._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_pathdiff --git a/src/reverse_api/cli.py b/src/reverse_api/cli.pyindex 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 jsonimport clickimport questionary+from questionary import Choice+from prompt_toolkit.completion import WordCompleterfrom rich.console import Console+from rich.table import Table+from rich.panel import Panel+from rich.text import Text+from rich.box import MINIMAL, ROUNDEDfrom .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 HTMLconsole = 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">></style> ')- # Only ask for the essential: prompt descriptionif 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 caughtraise 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 URLif 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 hereprompt = 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 resultif __name__ == "__main__":diff --git a/src/reverse_api/config.py b/src/reverse_api/config.pynew file mode 100644index 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.pyindex f3ac014..d54f3f0 100644--- a/src/reverse_api/engineer.py+++ b/src/reverse_api/engineer.py@@ -3,7 +3,7 @@import asyncioimport jsonfrom pathlib import Path-from typing import Optional+from typing import Optional, Dict, Anyfrom claude_agent_sdk import (ClaudeSDKClient,@@ -17,6 +17,7 @@ from claude_agent_sdk import (from .utils import get_scripts_dir, get_timestampfrom .tui import ClaudeUI+from .messages import MessageStoreclass 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 = promptself.model = modelself.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 TUIasync 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 = Nonefor block in message.content:if isinstance(block, ToolUseBlock):+ last_tool_name = block.nameself.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 contextis_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 Noneelse: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 resultexcept 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pyindex f2a6082..cfc07b5 100644--- a/src/reverse_api/tui.py+++ b/src/reverse_api/tui.py@@ -5,36 +5,45 @@ from rich.console import Console, Groupfrom rich.panel import Panelfrom rich.table import Tablefrom rich.text import Text-from rich.box import ROUNDED, MINIMAL, HEAVY+from rich.box import ROUNDED, MINIMAL, HEAVY, DOUBLE_EDGEfrom rich.padding import Paddingfrom 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 summaryinput_summary = self._summarize_input(tool_name, tool_input)# Compact single-line formatself.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.pyindex 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 reimport uuidfrom datetime import datetimefrom 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_idhar_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_idscripts_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.lockindex 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"