webtap-tool 0.2.2__py3-none-any.whl → 0.3.0__py3-none-any.whl

webtap/__init__.py

@@ -9,14 +9,9 @@ PUBLIC API:
   - main: Entry point function for CLI
 """
 
-import atexit
 import sys
-import logging
 
 from webtap.app import app
-from webtap.api import start_api_server
-
-logger = logging.getLogger(__name__)
 
 
 def main():
@@ -27,13 +22,9 @@ def main():
     - MCP mode (with --mcp flag) for Model Context Protocol server
     - REPL mode (default) for interactive shell
 
-    In REPL and MCP modes, the API server is started for Chrome extension
-    integration. The API server runs in background to handle extension requests.
+    The API server for Chrome extension communication must be started
+    explicitly using the server('start') command.
     """
-    # Start API server for Chrome extension (except in CLI mode)
-    if "--cli" not in sys.argv:
-        _start_api_server_safely()
-
     if "--mcp" in sys.argv:
         app.mcp.run()
     elif "--cli" in sys.argv:
@@ -45,20 +36,4 @@ def main():
         app.run(title="WebTap - Chrome DevTools Protocol REPL")
 
 
-def _start_api_server_safely():
-    """Start API server with error handling and cleanup registration."""
-    try:
-        thread = start_api_server(app.state)
-        if thread and app.state:
-            app.state.api_thread = thread
-            logger.info("API server started on port 8765")
-
-            # Register cleanup to shut down API server on exit
-            atexit.register(lambda: app.state.cleanup() if app.state else None)
-        else:
-            logger.info("Port 8765 in use by another instance")
-    except Exception as e:
-        logger.warning(f"Failed to start API server: {e}")
-
-
 __all__ = ["app", "main"]

webtap/api.py

@@ -199,21 +199,6 @@ async def disable_all_filters() -> Dict[str, Any]:
     return {"enabled": [], "total": 0}
 
 
-@api.post("/release")
-async def release_port() -> Dict[str, Any]:
-    """Release API port for another WebTap instance."""
-    logger.info("Releasing API port for another instance")
-
-    # Schedule graceful shutdown after response
-    def shutdown():
-        # Just set the flag to stop uvicorn, don't kill the whole process
-        global _shutdown_requested
-        _shutdown_requested = True
-
-    threading.Timer(0.5, shutdown).start()
-    return {"message": "Releasing port 8765"}
-
-
 # Flag to signal shutdown
 _shutdown_requested = False
 

webtap/app.py

@@ -84,6 +84,7 @@ else:
     from webtap.commands import inspect  # noqa: E402, F401
     from webtap.commands import fetch  # noqa: E402, F401
     from webtap.commands import body  # noqa: E402, F401
+    from webtap.commands import server  # noqa: E402, F401
     from webtap.commands import setup  # noqa: E402, F401
     from webtap.commands import launch  # noqa: E402, F401
 

webtap/commands/server.py

@@ -0,0 +1,162 @@
+"""API server management command.
+
+PUBLIC API:
+  - server: Manage API server (status/start/stop/restart)
+"""
+
+import socket
+import time
+import logging
+
+from webtap.app import app
+from webtap.api import start_api_server
+
+logger = logging.getLogger(__name__)
+
+# Fixed port for API server
+API_PORT = 8765
+
+
+def _check_port() -> bool:
+    """Check if API port is in use."""
+    with socket.socket() as s:
+        try:
+            s.bind(("127.0.0.1", API_PORT))
+            return False  # Port is free
+        except OSError:
+            return True  # Port is in use
+
+
+def _stop_server(state) -> tuple[bool, str]:
+    """Stop the server if this instance owns it."""
+    if not state.api_thread or not state.api_thread.is_alive():
+        return False, "Not running"
+
+    import webtap.api
+
+    webtap.api._shutdown_requested = True
+    state.api_thread.join(timeout=2.0)
+    state.api_thread = None
+
+    return True, "Server stopped"
+
+
+def _start_server(state) -> tuple[bool, str]:
+    """Start the server on port 8765."""
+    # Check if already running
+    if state.api_thread and state.api_thread.is_alive():
+        return True, f"Already running on port {API_PORT}"
+
+    # Check if port is in use
+    if _check_port():
+        return False, f"Port {API_PORT} already in use by another process"
+
+    # Start the server
+    thread = start_api_server(state, port=API_PORT)
+    if thread:
+        state.api_thread = thread
+
+        # Register cleanup
+        import atexit
+
+        atexit.register(lambda: state.cleanup() if state else None)
+
+        return True, f"Server started on port {API_PORT}"
+    else:
+        return False, "Failed to start server"
+
+
+@app.command(
+    display="markdown",
+    fastmcp={
+        "type": "prompt",
+        "arg_descriptions": {"action": "Server action: status (default), start, stop, or restart"},
+    },
+)
+def server(state, action: str = None) -> dict:  # pyright: ignore[reportArgumentType]
+    """API server status and management information.
+
+    Returns current server state and available actions.
+    """
+    if action is None:
+        action = "status"
+
+    action = action.lower()
+    owns_server = bool(state.api_thread and state.api_thread.is_alive())
+
+    # Build markdown elements based on action
+    elements = []
+
+    if action == "status" or action not in ["start", "stop", "restart"]:
+        # Status information
+        elements.append({"type": "heading", "content": "API Server Status", "level": 2})
+
+        if owns_server:
+            elements.append({"type": "text", "content": "**Status:** Running"})
+            elements.append({"type": "text", "content": f"**Port:** {API_PORT}"})
+            elements.append({"type": "text", "content": f"**URL:** http://127.0.0.1:{API_PORT}"})
+            elements.append({"type": "text", "content": f"**Health:** http://127.0.0.1:{API_PORT}/health"})
+            elements.append({"type": "text", "content": "**Extension:** Ready to connect"})
+        else:
+            port_in_use = _check_port()
+            if port_in_use:
+                elements.append({"type": "alert", "message": "Port 8765 in use by another process", "level": "warning"})
+                elements.append({"type": "text", "content": "Cannot start server until port is free"})
+            else:
+                elements.append({"type": "text", "content": "**Status:** Not running"})
+                elements.append({"type": "text", "content": f"**Port:** {API_PORT} (available)"})
+                elements.append({"type": "text", "content": "Use `server('start')` to start the API server"})
+
+        # Available actions
+        elements.append({"type": "heading", "content": "Available Actions", "level": 3})
+        actions = [
+            "`server('start')` - Start the API server",
+            "`server('stop')` - Stop the API server",
+            "`server('restart')` - Restart the API server",
+            "`server('status')` or `server()` - Show this status",
+        ]
+        elements.append({"type": "list", "items": actions})
+
+    elif action == "start":
+        if owns_server:
+            elements.append({"type": "alert", "message": f"Server already running on port {API_PORT}", "level": "info"})
+        else:
+            success, message = _start_server(state)
+            if success:
+                elements.append({"type": "alert", "message": message, "level": "success"})
+                elements.append({"type": "text", "content": f"**URL:** http://127.0.0.1:{API_PORT}"})
+                elements.append({"type": "text", "content": f"**Health:** http://127.0.0.1:{API_PORT}/health"})
+                elements.append({"type": "text", "content": "Chrome extension can now connect"})
+            else:
+                elements.append({"type": "alert", "message": message, "level": "error"})
+
+    elif action == "stop":
+        if not owns_server:
+            elements.append({"type": "text", "content": "Server not running"})
+        else:
+            success, message = _stop_server(state)
+            if success:
+                elements.append({"type": "alert", "message": message, "level": "success"})
+            else:
+                elements.append({"type": "alert", "message": message, "level": "error"})
+
+    elif action == "restart":
+        if owns_server:
+            success, msg = _stop_server(state)
+            if not success:
+                elements.append({"type": "alert", "message": f"Failed to stop: {msg}", "level": "error"})
+                return {"elements": elements}
+            time.sleep(0.5)
+
+        success, msg = _start_server(state)
+        if success:
+            elements.append({"type": "alert", "message": "Server restarted", "level": "success"})
+            elements.append({"type": "text", "content": f"**Port:** {API_PORT}"})
+            elements.append({"type": "text", "content": f"**URL:** http://127.0.0.1:{API_PORT}"})
+        else:
+            elements.append({"type": "alert", "message": f"Failed to restart: {msg}", "level": "error"})
+
+    return {"elements": elements}
+
+
+__all__ = ["server"]

webtap/services/setup/__init__.py

@@ -10,7 +10,26 @@ from .filters import FilterSetupService
 from .extension import ExtensionSetupService
 from .chrome import ChromeSetupService
 from .desktop import DesktopSetupService
-from .platform import get_platform_info, ensure_directories
+from .platform import get_platform_info, ensure_directories, APP_NAME
+
+# Old installation paths to clean up
+OLD_EXTENSION_PATH = ".config/webtap/extension"
+OLD_WRAPPER_PATH = ".local/bin/wrappers/google-chrome-stable"
+OLD_DESKTOP_PATH = ".local/share/applications/google-chrome.desktop"
+OLD_DEBUG_DIR = ".config/google-chrome-debug"
+
+# Path components
+WRAPPERS_DIR = "wrappers"
+GOOGLE_CHROME_STABLE = "google-chrome-stable"
+
+# Size formatting constants
+KB_SIZE = 1024
+SIZE_FORMAT_KB = "{:.1f} KB"
+SIZE_FORMAT_EMPTY = "empty"
+
+# Mount point command
+MOUNTPOINT_CMD = "mountpoint"
+MOUNTPOINT_CHECK_FLAG = "-q"
 
 
 class SetupService:
@@ -108,11 +127,11 @@ class SetupService:
         result = {}
 
         # Check old extension location
-        old_extension_path = Path.home() / ".config" / "webtap" / "extension"
+        old_extension_path = Path.home() / OLD_EXTENSION_PATH
         if old_extension_path.exists():
             # Calculate size
             size = sum(f.stat().st_size for f in old_extension_path.rglob("*") if f.is_file())
-            size_str = f"{size / 1024:.1f} KB" if size > 0 else "empty"
+            size_str = SIZE_FORMAT_KB.format(size / KB_SIZE) if size > 0 else SIZE_FORMAT_EMPTY
 
             result["old_extension"] = {"path": str(old_extension_path), "size": size_str, "removed": False}
 
@@ -128,7 +147,7 @@ class SetupService:
                     result["old_extension"]["error"] = str(e)
 
         # Check old Chrome wrapper location
-        old_wrapper_path = Path.home() / ".local" / "bin" / "wrappers" / "google-chrome-stable"
+        old_wrapper_path = Path.home() / OLD_WRAPPER_PATH
         if old_wrapper_path.exists():
             result["old_wrapper"] = {"path": str(old_wrapper_path), "removed": False}
 
@@ -144,12 +163,13 @@ class SetupService:
                     result["old_wrapper"]["error"] = str(e)
 
         # Check old desktop entry
-        old_desktop_path = Path.home() / ".local" / "share" / "applications" / "google-chrome.desktop"
+        old_desktop_path = Path.home() / OLD_DESKTOP_PATH
         if old_desktop_path.exists():
             # Check if it's our override (contains reference to wrapper)
             try:
                 content = old_desktop_path.read_text()
-                if "wrappers/google-chrome-stable" in content or "webtap" in content.lower():
+                wrapper_ref = f"{WRAPPERS_DIR}/{GOOGLE_CHROME_STABLE}"
+                if wrapper_ref in content or APP_NAME in content.lower():
                     result["old_desktop"] = {"path": str(old_desktop_path), "removed": False}
 
                     if not dry_run:
@@ -162,11 +182,11 @@ class SetupService:
                 pass  # If we can't read it, skip it
 
         # Check for bindfs mount
-        debug_dir = Path.home() / ".config" / "google-chrome-debug"
+        debug_dir = Path.home() / OLD_DEBUG_DIR
         if debug_dir.exists():
             try:
                 # Check if it's a mount point
-                output = subprocess.run(["mountpoint", "-q", str(debug_dir)], capture_output=True)
+                output = subprocess.run([MOUNTPOINT_CMD, MOUNTPOINT_CHECK_FLAG, str(debug_dir)], capture_output=True)
                 if output.returncode == 0:
                     result["bindfs_mount"] = str(debug_dir)
             except (FileNotFoundError, OSError):

webtap/services/setup/desktop.py

@@ -168,11 +168,11 @@ class DesktopSetupService:
         # Create launcher script that directly launches Chrome
         # This avoids Rosetta warnings from nested bash scripts
         launcher_path = macos_dir / "Chrome Debug"
-        
+
         # Get Chrome path from platform info
         chrome_path = self.chrome["path"]
         profile_dir = self.paths["data_dir"] / "profiles" / "default"
-        
+
         launcher_content = f"""#!/bin/bash
 # Chrome Debug app launcher - direct Chrome execution
 # Avoids Rosetta warnings by directly launching Chrome

webtap/services/setup/platform.py

@@ -7,6 +7,46 @@ from typing import Optional
 
 import platformdirs
 
+# Application constants
+APP_NAME = "webtap"
+APP_AUTHOR = "webtap"
+
+# Directory names
+BIN_DIR_NAME = ".local/bin"
+WRAPPER_NAME = "chrome-debug"
+TMP_RUNTIME_DIR = "/tmp"
+
+# Chrome executable names for Linux
+CHROME_NAMES_LINUX = [
+    "google-chrome",
+    "google-chrome-stable",
+    "chromium",
+    "chromium-browser",
+]
+
+# Chrome paths for macOS
+CHROME_PATHS_MACOS = [
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    "Applications/Google Chrome.app/Contents/MacOS/Google Chrome",  # Relative to home
+]
+
+# Chrome paths for Linux
+CHROME_PATHS_LINUX = [
+    "/usr/bin/google-chrome",
+    "/usr/bin/google-chrome-stable",
+    "/usr/bin/chromium",
+    "/usr/bin/chromium-browser",
+    "/snap/bin/chromium",
+]
+
+# Platform identifiers
+PLATFORM_DARWIN = "Darwin"
+PLATFORM_LINUX = "Linux"
+
+# Application directories
+MACOS_APPLICATIONS_DIR = "Applications"
+LINUX_APPLICATIONS_DIR = ".local/share/applications"
+
 
 def get_platform_paths() -> dict[str, Path]:
     """Get platform-appropriate paths using platformdirs.
@@ -14,10 +54,7 @@ def get_platform_paths() -> dict[str, Path]:
     Returns:
         Dictionary of paths for config, data, cache, runtime, and state directories.
     """
-    app_name = "webtap"
-    app_author = "webtap"
-
-    dirs = platformdirs.PlatformDirs(app_name, app_author)
+    dirs = platformdirs.PlatformDirs(APP_NAME, APP_AUTHOR)
 
     paths = {
         "config_dir": Path(dirs.user_config_dir),  # ~/.config/webtap or ~/Library/Application Support/webtap
@@ -31,7 +68,7 @@ def get_platform_paths() -> dict[str, Path]:
         paths["runtime_dir"] = Path(dirs.user_runtime_dir)
     except AttributeError:
         # Fallback for platforms without runtime dir
-        paths["runtime_dir"] = Path("/tmp") / app_name
+        paths["runtime_dir"] = Path(TMP_RUNTIME_DIR) / APP_NAME
 
     return paths
 
@@ -44,21 +81,15 @@ def get_chrome_path() -> Optional[Path]:
     """
     system = platform.system()
 
-    if system == "Darwin":
+    if system == PLATFORM_DARWIN:
         # macOS standard locations
         candidates = [
-            Path("/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"),
-            Path.home() / "Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+            Path(CHROME_PATHS_MACOS[0]),
+            Path.home() / CHROME_PATHS_MACOS[1],
         ]
-    elif system == "Linux":
+    elif system == PLATFORM_LINUX:
         # Linux standard locations
-        candidates = [
-            Path("/usr/bin/google-chrome"),
-            Path("/usr/bin/google-chrome-stable"),
-            Path("/usr/bin/chromium"),
-            Path("/usr/bin/chromium-browser"),
-            Path("/snap/bin/chromium"),
-        ]
+        candidates = [Path(p) for p in CHROME_PATHS_LINUX]
     else:
         return None
 
@@ -67,7 +98,7 @@ def get_chrome_path() -> Optional[Path]:
             return path
 
     # Try to find in PATH
-    for name in ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser"]:
+    for name in CHROME_NAMES_LINUX:
         if found := shutil.which(name):
             return Path(found)
 
@@ -84,31 +115,30 @@ def get_platform_info() -> dict:
     paths = get_platform_paths()
 
     # Unified paths for both platforms
-    paths["bin_dir"] = Path.home() / ".local/bin"  # User space, no sudo needed
-    wrapper_name = "chrome-debug"  # Same name on both platforms
+    paths["bin_dir"] = Path.home() / BIN_DIR_NAME  # User space, no sudo needed
 
     # Platform-specific launcher locations
-    if system == "Darwin":
-        paths["applications_dir"] = Path.home() / "Applications"
+    if system == PLATFORM_DARWIN:
+        paths["applications_dir"] = Path.home() / MACOS_APPLICATIONS_DIR
     else:  # Linux
-        paths["applications_dir"] = Path.home() / ".local/share/applications"
+        paths["applications_dir"] = Path.home() / LINUX_APPLICATIONS_DIR
 
     chrome_path = get_chrome_path()
 
     return {
         "system": system.lower(),
-        "is_macos": system == "Darwin",
-        "is_linux": system == "Linux",
+        "is_macos": system == PLATFORM_DARWIN,
+        "is_linux": system == PLATFORM_LINUX,
         "paths": paths,
         "chrome": {
             "path": chrome_path,
             "found": chrome_path is not None,
-            "wrapper_name": wrapper_name,
+            "wrapper_name": WRAPPER_NAME,
         },
         "capabilities": {
-            "desktop_files": system == "Linux",
-            "app_bundles": system == "Darwin",
-            "bindfs": system == "Linux" and shutil.which("bindfs") is not None,
+            "desktop_files": system == PLATFORM_LINUX,
+            "app_bundles": system == PLATFORM_DARWIN,
+            "bindfs": system == PLATFORM_LINUX and shutil.which("bindfs") is not None,
         },
     }
 

{webtap_tool-0.2.2.dist-info → webtap_tool-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webtap-tool
-Version: 0.2.2
+Version: 0.3.0
 Summary: Terminal-based web page inspector for AI debugging sessions
 Author-email: Fredrik Angelsen <fredrikangelsen@gmail.com>
 Classifier: Development Status :: 3 - Alpha

{webtap_tool-0.2.2.dist-info → webtap_tool-0.3.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
 webtap/VISION.md,sha256=kfoJfEPVc4chOrD9tNMDmYBY9rX9KB-286oZj70ALCE,7681
-webtap/__init__.py,sha256=6sTctXhLKByd8TnKJ99Y4o6xv7AbbPJ37S6YMNsQGBM,1970
-webtap/api.py,sha256=mfAqxQfu2lF91jiI6kHQnpmwtwq0Hh9UtuV8ApENXe0,8504
-webtap/app.py,sha256=M6-tCT6uvR5aMMYYUymYrXhq4PaUlHVYTv7MDN_svdQ,3246
+webtap/__init__.py,sha256=DFWJGmqZfX8_h4csLA5pKPR4SkaHBMlUgU-WQIE96Gw,1092
+webtap/api.py,sha256=QLfwO_21uSyxBCsqei45c5Uyg7OVfaVopmBncx9ZRfw,8018
+webtap/app.py,sha256=OC8-767GtQ_hAOxUNqD6Yu3JYLNB3ZXdzKn-A1S_RJI,3305
 webtap/filters.py,sha256=nphF2bFRbFtS2ue-CbV1uzKpuK3IYBbwjLeLhMDdLEk,11034
 webtap/cdp/README.md,sha256=0TS0V_dRgRAzBqhddpXWD4S0YVi5wI4JgFJSll_KUBE,5660
 webtap/cdp/__init__.py,sha256=c6NFG0XJnAa5GTe9MLr9mDZcLZqoTQN7A1cvvOfLcgY,453
@@ -28,6 +28,7 @@ webtap/commands/javascript.py,sha256=QpQdqqoQwwTyz1lpibZ92XKOL89scu_ndgSjkhaYuDk
 webtap/commands/launch.py,sha256=iZDLundKlxKRLKf3Vz5at42-tp2f-Uj5wZf7fbhBfA0,2202
 webtap/commands/navigation.py,sha256=Mapawp2AZTJQaws2uwlTgMUhqz7HlVTLxiZ06n_MQc0,6071
 webtap/commands/network.py,sha256=hwZshGGdVsJ_9MFjOKJXT07I990JjZInw2LLnKXLQ5Y,2910
+webtap/commands/server.py,sha256=LSs3l3Pb_vwmWRnYH-sA9JUPxBTQtRedjFQ4KvDaZK0,6032
 webtap/commands/setup.py,sha256=dov1LaN50nAEMNIuBLSK7mcnwhfn9rtqdTopBm1-PhA,9648
 webtap/services/README.md,sha256=rala_jtnNgSiQ1lFLM7x_UQ4SJZDceAm7dpkQMRTYaI,2346
 webtap/services/__init__.py,sha256=IjFqu0Ak6D-r18aokcQMtenDV3fbelvfjTCejGv6CZ0,570
@@ -36,13 +37,13 @@ webtap/services/console.py,sha256=XVfSKTvEHyyOdujsg85S3wtj1CdZhzKtWwlx25MvSv8,37
 webtap/services/fetch.py,sha256=nl6bpU2Vnf40kau4-mqAnIkhC-7Lx2vbTJKUglz9KnE,13602
 webtap/services/main.py,sha256=HcXdPuI7hzsxsNvfN0npGhj_M7HObc83Lr3fuy7BMeE,5673
 webtap/services/network.py,sha256=0o_--F6YvmXqqFqrcjL1gc6Vr9V1Ytb_U7r_DSUWupA,3444
-webtap/services/setup/__init__.py,sha256=rCi6HjyWQmtoBu6NwB1Aw3bEklxsC-bt1jPJ8rGeNgA,6635
+webtap/services/setup/__init__.py,sha256=lfoKCAroc-JoE_r7L-KZkF85ZWiB41MBIgrR7ZISSoE,7157
 webtap/services/setup/chrome.py,sha256=zfPWeb6zm_xjIfiS2S_O9lR2BjGKaPXXo06pN_B9lAU,7187
-webtap/services/setup/desktop.py,sha256=P5bBllQeiHsM2ELbVVmvOxE5k9UiooDh1cRQNKbWm6s,8038
+webtap/services/setup/desktop.py,sha256=fXwQa201W-s2mengm_dJZ9BigJopVrO9YFUQcW_TSFQ,8022
 webtap/services/setup/extension.py,sha256=OvTLuSi5u-kBAkqWAzfYt5lTNZrduXoCMZhFCuMisew,3318
 webtap/services/setup/filters.py,sha256=lAPSLMH_KZQO-7bRkmURwzforx7C3SDrKEw2ZogN-Lo,3220
-webtap/services/setup/platform.py,sha256=RQrhvp8mLg5Bssy5Slfl5SPVGo3BlUIn3lxVm-ZmkAM,3987
-webtap_tool-0.2.2.dist-info/METADATA,sha256=ukRef3zrO-0wrxzGksrDieJ7lBpNNgizETkRIApz_Tg,17588
-webtap_tool-0.2.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-webtap_tool-0.2.2.dist-info/entry_points.txt,sha256=iFe575I0CIb1MbfPt0oX2VYyY5gSU_dA551PKVR83TU,39
-webtap_tool-0.2.2.dist-info/RECORD,,
+webtap/services/setup/platform.py,sha256=7yn-7LQFffgerWzWRtOG-yNEsR36ICThYUAu_N2FAso,4532
+webtap_tool-0.3.0.dist-info/METADATA,sha256=jm3l2rpT1TBdGU8AU7NJYV7RgwpfzITuPyjh4Zb1_pk,17588
+webtap_tool-0.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+webtap_tool-0.3.0.dist-info/entry_points.txt,sha256=iFe575I0CIb1MbfPt0oX2VYyY5gSU_dA551PKVR83TU,39
+webtap_tool-0.3.0.dist-info/RECORD,,