webtap-tool 0.11.0__py3-none-any.whl

webtap/commands/quicktype.py

@@ -0,0 +1,306 @@
+"""Generate types and schemas from HTTP request/response bodies using quicktype."""
+
+import json
+import shutil
+import subprocess
+from datetime import datetime
+from pathlib import Path
+from webtap.app import app
+from webtap.commands._builders import success_response, error_response
+from webtap.commands._code_generation import (
+    ensure_output_directory,
+    parse_json,
+    extract_json_path,
+    validate_generation_data,
+)
+from webtap.commands._utils import evaluate_expression, fetch_body_content
+from webtap.commands._tips import get_mcp_description
+
+
+mcp_desc = get_mcp_description("quicktype")
+
+# Header template for generated files
+HEADER_TEMPLATE = """Generated by WebTap from request {row_id}
+Source: {url}
+Method: {method}
+Generated: {timestamp}
+
+Do not edit manually."""
+
+# Comment syntax per language
+COMMENT_STYLES = {
+    "TypeScript": "//",
+    "Python": "#",
+    "Go": "//",
+    "Rust": "//",
+    "Java": "//",
+    "Kotlin": "//",
+    "Swift": "//",
+    "C#": "//",
+    "C++": "//",
+    "Dart": "//",
+    "Ruby": "#",
+    "JSON Schema": None,
+}
+
+
+def _run_quicktype(
+    json_data: dict | list,
+    output: str,
+    type_name: str = None,  # pyright: ignore[reportArgumentType]
+    just_types: bool = True,
+    prefer_types: bool = True,
+    options: dict = None,  # pyright: ignore[reportArgumentType]
+) -> tuple[bool, str]:
+    """Run quicktype CLI with given parameters.
+
+    Returns:
+        Tuple of (success: bool, error_message: str)
+    """
+    if not shutil.which("quicktype"):
+        return False, "quicktype CLI not found. Install with: npm install -g quicktype"
+
+    output_path = Path(output)
+    ext = output_path.suffix.lower()
+
+    cmd = ["quicktype", "-o", str(output), "--src-lang", "json", "--top-level", type_name]
+
+    if just_types:
+        cmd.append("--just-types")
+
+    if ext in {".ts", ".tsx"} and prefer_types:
+        cmd.append("--prefer-types")
+
+    for key, val in (options or {}).items():
+        flag = f"--{key.replace('_', '-')}"
+        if val is True:
+            cmd.append(flag)
+        elif val is not False and val is not None:
+            cmd.extend([flag, str(val)])
+
+    try:
+        subprocess.run(
+            cmd,
+            input=json.dumps(json_data, indent=2),
+            capture_output=True,
+            text=True,
+            check=True,
+            timeout=30,
+        )
+        return True, ""
+    except subprocess.CalledProcessError as e:
+        return False, f"quicktype failed: {e.stderr.strip() if e.stderr else str(e)}"
+    except subprocess.TimeoutExpired:
+        return False, "quicktype timed out (>30s)"
+    except Exception as e:
+        return False, f"Unexpected error: {str(e)}"
+
+
+def _insert_header(row_id: int, har_entry: dict, output_path: Path, language: str) -> None:
+    """Insert language-aware header comment into generated file.
+
+    Args:
+        row_id: HAR row ID for reference.
+        har_entry: HAR entry with request metadata.
+        output_path: Path to generated file.
+        language: Target language (e.g., "TypeScript", "Python").
+    """
+    if not HEADER_TEMPLATE or language not in COMMENT_STYLES:
+        return
+
+    comment_prefix = COMMENT_STYLES[language]
+    if not comment_prefix:
+        return
+
+    try:
+        request = har_entry.get("request", {})
+        metadata = {
+            "row_id": row_id,
+            "url": request.get("url", "N/A"),
+            "method": request.get("method", "N/A"),
+            "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        }
+
+        header_text = HEADER_TEMPLATE.format(**metadata)
+        header_lines = [
+            f"{comment_prefix} {line}" if line.strip() else comment_prefix for line in header_text.split("\n")
+        ]
+        header = "\n".join(header_lines)
+
+        content = output_path.read_text()
+        output_path.write_text(header + "\n\n" + content)
+    except Exception:
+        pass
+
+
+@app.command(display="markdown", fastmcp={"type": "tool", "mime_type": "text/markdown", "description": mcp_desc or ""})
+def quicktype(
+    state,
+    id: int,
+    output: str,
+    type_name: str,
+    field: str = "response.content",
+    json_path: str = None,  # pyright: ignore[reportArgumentType]
+    expr: str = None,  # pyright: ignore[reportArgumentType]
+    just_types: bool = True,
+    prefer_types: bool = True,
+    options: dict = None,  # pyright: ignore[reportArgumentType]
+) -> dict:  # pyright: ignore[reportArgumentType]
+    """Generate types/schemas from request or response body using quicktype CLI.
+
+    Args:
+        id: Row ID from network() output
+        output: Output file path (extension determines language: .ts, .py, .go, etc.)
+        type_name: Top-level type name (e.g., "User", "ApiResponse")
+        field: Body to use - "response.content" (default) or "request.postData"
+        json_path: Optional JSON path to extract nested data (e.g., "data[0]")
+        expr: Optional Python expression to transform data (has 'body' variable)
+        just_types: Generate only types, no serializers (default: True)
+        prefer_types: Use 'type' instead of 'interface' for TypeScript (default: True)
+        options: Additional quicktype flags as dict
+
+    Examples:
+        quicktype(5, "types/User.ts", "User")
+        quicktype(5, "models/customer.py", "Customer")
+        quicktype(5, "api.go", "ApiResponse")
+        quicktype(5, "types.ts", "User", json_path="data[0]")
+        quicktype(5, "types/Form.ts", "Form", field="request.postData")
+        quicktype(5, "types.ts", "User", options={"readonly": True})
+
+    Returns:
+        Success message with generation details
+    """
+    # Get HAR entry via RPC - need full entry with request_id for body fetch
+    try:
+        result = state.client.call("request", id=id, fields=["*"])
+        har_entry = result.get("entry")
+    except Exception as e:
+        return error_response(f"Failed to get request: {e}")
+
+    if not har_entry:
+        return error_response(f"Request {id} not found")
+
+    # Fetch body content
+    body_content, err = fetch_body_content(state, har_entry, field)
+    if err or body_content is None:
+        return error_response(
+            err or "Failed to fetch body",
+            suggestions=[
+                f"Field '{field}' could not be fetched",
+                "For response body: field='response.content'",
+                "For POST data: field='request.postData'",
+            ],
+        )
+
+    # Transform via expression or parse as JSON
+    if expr:
+        try:
+            namespace = {"body": body_content}
+            data, _ = evaluate_expression(expr, namespace)
+        except Exception as e:
+            return error_response(
+                f"Expression failed: {e}",
+                suggestions=[
+                    "Variable available: 'body' (str)",
+                    "Example: json.loads(body)['data'][0]",
+                    "Example: dict(urllib.parse.parse_qsl(body))",
+                ],
+            )
+    else:
+        if not body_content.strip():
+            return error_response("Body is empty")
+
+        data, parse_err = parse_json(body_content)
+        if parse_err:
+            return error_response(
+                parse_err,
+                suggestions=[
+                    "Body must be valid JSON, or use expr to transform it",
+                    'For form data: expr="dict(urllib.parse.parse_qsl(body))"',
+                ],
+            )
+
+    # Extract nested path if specified
+    if json_path:
+        data, err = extract_json_path(data, json_path)
+        if err:
+            return error_response(
+                err,
+                suggestions=[
+                    f"Path '{json_path}' not found in body",
+                    'Try a simpler path like "data" or "data[0]"',
+                ],
+            )
+
+    # Validate structure
+    is_valid, validation_err = validate_generation_data(data)
+    if not is_valid:
+        return error_response(
+            validation_err or "Invalid data structure",
+            suggestions=[
+                "Code generation requires dict or list structure",
+                "Use json_path or expr to extract a complex object",
+            ],
+        )
+
+    # Ensure output directory exists
+    output_path = ensure_output_directory(output)
+
+    # Run quicktype
+    success, error_msg = _run_quicktype(
+        json_data=data,
+        output=str(output_path),
+        type_name=type_name,
+        just_types=just_types,
+        prefer_types=prefer_types,
+        options=options,
+    )
+
+    if not success:
+        return error_response(
+            error_msg,
+            suggestions=[
+                "Check that quicktype is installed: npm install -g quicktype",
+                "Verify the JSON structure is valid",
+                "Try simplifying with json_path",
+            ],
+        )
+
+    # Detect language and insert header
+    ext = output_path.suffix.lower()
+    lang_map = {
+        ".ts": "TypeScript",
+        ".tsx": "TypeScript",
+        ".py": "Python",
+        ".go": "Go",
+        ".rs": "Rust",
+        ".java": "Java",
+        ".kt": "Kotlin",
+        ".swift": "Swift",
+        ".cs": "C#",
+        ".cpp": "C++",
+        ".dart": "Dart",
+        ".rb": "Ruby",
+        ".json": "JSON Schema",
+    }
+    language = lang_map.get(ext, "Unknown")
+
+    _insert_header(id, har_entry, output_path, language)
+
+    # Count lines
+    try:
+        file_content = output_path.read_text()
+        line_count = len(file_content.splitlines())
+    except Exception:
+        line_count = "unknown"
+
+    return success_response(
+        "Types generated successfully",
+        details={
+            "Output": str(output_path),
+            "Language": language,
+            "Type Name": type_name,
+            "Lines": line_count,
+            "Size": f"{output_path.stat().st_size} bytes",
+        },
+    )

webtap/commands/request.py

@@ -0,0 +1,93 @@
+"""Request details command with ES-style field selection."""
+
+import json
+
+from webtap.app import app
+from webtap.client import RPCError
+from webtap.commands._builders import error_response
+from webtap.commands._tips import get_mcp_description
+from webtap.commands._utils import evaluate_expression, format_expression_result
+
+_mcp_desc = get_mcp_description("request")
+
+
+@app.command(
+    display="markdown",
+    fastmcp={"type": "tool", "mime_type": "text/markdown", "description": _mcp_desc or ""},
+)
+def request(
+    state,
+    id: int,
+    fields: list = None,  # pyright: ignore[reportArgumentType]
+    expr: str = None,  # pyright: ignore[reportArgumentType]
+) -> dict:
+    """Get HAR request details with field selection.
+
+    Args:
+        id: Row ID from network() output
+        fields: ES-style field patterns (HAR structure)
+            - None: minimal (method, url, status, time, state)
+            - ["*"]: all fields
+            - ["request.*"]: all request fields
+            - ["request.headers.*"]: all request headers
+            - ["request.postData"]: request body
+            - ["response.headers.*"]: all response headers
+            - ["response.content"]: fetch response body on-demand
+        expr: Python expression with 'data' variable containing selected fields
+
+    Examples:
+        request(123)                           # Minimal
+        request(123, ["*"])                    # Everything
+        request(123, ["request.headers.*"])    # Request headers
+        request(123, ["response.content"])     # Fetch response body
+        request(123, ["request.postData", "response.content"])  # Both bodies
+        request(123, ["response.content"], expr="json.loads(data['response']['content']['text'])")
+    """
+    # Get pre-selected HAR entry from daemon via RPC
+    # Field selection (including body fetch) happens server-side
+    try:
+        result = state.client.call("request", id=id, fields=fields)
+        selected = result.get("entry")
+    except RPCError as e:
+        return error_response(e.message)
+    except Exception as e:
+        return error_response(str(e))
+
+    if not selected:
+        return error_response(f"Request {id} not found")
+
+    # If expr provided, evaluate it with data available
+    if expr:
+        try:
+            namespace = {"data": selected}
+            eval_result, output = evaluate_expression(expr, namespace)
+            formatted = format_expression_result(eval_result, output)
+
+            return {
+                "elements": [
+                    {"type": "heading", "content": "Expression Result", "level": 2},
+                    {"type": "code_block", "content": expr, "language": "python"},
+                    {"type": "text", "content": "**Result:**"},
+                    {"type": "code_block", "content": formatted, "language": ""},
+                ]
+            }
+        except Exception as e:
+            return error_response(
+                f"{type(e).__name__}: {e}",
+                suggestions=[
+                    "The selected fields are available as 'data' variable",
+                    "Common libraries are pre-imported: re, json, bs4, jwt, httpx",
+                    "Example: json.loads(data['response']['content']['text'])",
+                ],
+            )
+
+    # Build markdown response
+    elements = [
+        {"type": "heading", "content": f"Request {id}", "level": 2},
+        {"type": "code_block", "content": json.dumps(selected, indent=2, default=str), "language": "json"},
+    ]
+
+    return {"elements": elements}
+
+
+__all__ = ["request"]

webtap/commands/selections.py

@@ -0,0 +1,138 @@
+"""Browser element selection and prompt analysis commands.
+
+PUBLIC API:
+  - browser: Analyze browser element selections with prompt
+"""
+
+from webtap.app import app
+from webtap.client import RPCError
+from webtap.commands._utils import evaluate_expression, format_expression_result
+from webtap.commands._builders import error_response
+from webtap.commands._tips import get_tips
+
+
+@app.command(
+    display="markdown",
+    fastmcp=[{"type": "resource", "mime_type": "text/markdown"}, {"type": "tool", "mime_type": "text/markdown"}],
+)
+def selections(state, expr: str = None) -> dict:  # pyright: ignore[reportArgumentType]
+    """Browser element selections with prompt and analysis.
+
+    As Resource (no parameters):
+        browser             # Returns current prompt and all selections
+
+    As Tool (with parameters):
+        browser(expr="data['prompt']")                          # Get prompt text
+        browser(expr="data['selections']['1']['styles']")       # Get styles for #1
+        browser(expr="len(data['selections'])")                 # Count selections
+        browser(expr="{k: v['selector'] for k, v in data['selections'].items()}")  # All selectors
+
+    Args:
+        expr: Python expression with 'data' variable containing prompt and selections
+
+    Returns:
+        Formatted browser data or expression result
+    """
+    # Fetch browser data from daemon via RPC
+    try:
+        daemon_status = state.client.call("status")
+    except RPCError as e:
+        return error_response(e.message)
+    except Exception as e:
+        return error_response(str(e))
+
+    browser = daemon_status.get("browser", {})
+    if not browser.get("selections"):
+        return error_response(
+            "No browser selections available",
+            suggestions=[
+                "Use the Chrome extension to select elements",
+                "Click 'Start Selection Mode' in the extension side panel",
+                "Select elements on the page",
+            ],
+        )
+
+    data = {"prompt": browser.get("prompt", ""), "selections": browser.get("selections", {})}
+
+    # No expression - RESOURCE MODE: Return formatted view
+    if not expr:
+        return _format_browser_data(data)
+
+    # TOOL MODE: Evaluate expression
+    try:
+        namespace = {"data": data}
+        result, output = evaluate_expression(expr, namespace)
+        formatted_result = format_expression_result(result, output)
+
+        # Build markdown response
+        return {
+            "elements": [
+                {"type": "heading", "content": "Expression Result", "level": 2},
+                {"type": "code_block", "content": expr, "language": "python"},
+                {"type": "text", "content": "**Result:**"},
+                {"type": "code_block", "content": formatted_result, "language": ""},
+            ]
+        }
+    except Exception as e:
+        # Provide helpful suggestions
+        suggestions = [
+            "The data is available as 'data' variable",
+            "Access prompt: data['prompt']",
+            "Access selections: data['selections']",
+            "Access specific element: data['selections']['1']",
+            "Available fields: outerHTML, selector, jsPath, styles, xpath, fullXpath, preview",
+        ]
+
+        if "KeyError" in str(type(e).__name__):
+            suggestions.extend(
+                [
+                    "Check available selection IDs: list(data['selections'].keys())",
+                    "Check available fields: data['selections']['1'].keys()",
+                ]
+            )
+
+        return error_response(f"{type(e).__name__}: {e}", suggestions=suggestions)
+
+
+def _format_browser_data(data: dict) -> dict:
+    """Format browser data as markdown for resource view."""
+    elements = []
+
+    # Show prompt
+    elements.append({"type": "heading", "content": "Browser Prompt", "level": 2})
+    elements.append({"type": "text", "content": data.get("prompt", "")})
+
+    # Show selection count
+    selection_count = len(data.get("selections", {}))
+    elements.append({"type": "text", "content": f"\n**Selected Elements:** {selection_count}"})
+
+    # Show each selection with preview
+    if selection_count > 0:
+        elements.append({"type": "heading", "content": "Element Selections", "level": 3})
+
+        for sel_id in sorted(data["selections"].keys(), key=lambda x: int(x)):
+            sel = data["selections"][sel_id]
+            preview = sel.get("preview", {})
+
+            # Build preview line
+            preview_parts = [f"**#{sel_id}:**", preview.get("tag", "unknown")]
+            if preview.get("id"):
+                preview_parts.append(f"#{preview['id']}")
+            if preview.get("classes"):
+                preview_parts.append(f".{preview['classes'][0]}")
+
+            elements.append({"type": "text", "content": " ".join(preview_parts)})
+
+            # Show selector
+            elements.append({"type": "code_block", "content": sel.get("selector", ""), "language": "css"})
+
+        # Show usage tips from TIPS.md
+        tips = get_tips("selections")
+        if tips:
+            elements.append({"type": "heading", "content": "Next Steps", "level": 3})
+            elements.append({"type": "list", "items": tips})
+
+    return {"elements": elements}
+
+
+__all__ = ["selections"]