webpilot-engine 2.0.6__tar.gz → 2.0.7__tar.gz

{webpilot_engine-2.0.6 → webpilot_engine-2.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webpilot-engine
-Version: 2.0.6
+Version: 2.0.7
 Summary: WebPilot: Enterprise Autonomous Browser Engine, Universal Form Inspector & AI Agent Web Runtime
 Author: Abdulkarim Salih, WebPilot Core Team
 License: MIT

{webpilot_engine-2.0.6 → webpilot_engine-2.0.7}/cli.py

@@ -40,6 +40,11 @@ def get_base_url(args: argparse.Namespace) -> str:
     return f"http://{host}:{port}"
 
 
+def get_supervisor_client(args: argparse.Namespace) -> SupervisorClient:
+    token = getattr(args, "token", None)
+    return SupervisorClient(base_url=get_base_url(args), token=token)
+
+
 def inspect_cmd(args: argparse.Namespace) -> None:
     """Executes the universal inspection workflow."""
     if getattr(args, "standalone", False):
@@ -63,7 +68,7 @@ def inspect_cmd(args: argparse.Namespace) -> None:
         return
 
     # Multi-tier Master Supervisor execution (default)
-    client = SupervisorClient(base_url=get_base_url(args))
+    client = get_supervisor_client(args)
 
     if args.close_session:
         res = client.stop_service()
@@ -159,7 +164,7 @@ def apply_cmd(args: argparse.Namespace) -> None:
         return
 
     # Multi-tier Master Supervisor execution (default)
-    client = SupervisorClient(base_url=get_base_url(args))
+    client = get_supervisor_client(args)
 
     if args.close_session:
         res = client.stop_service()
@@ -211,7 +216,7 @@ def apply_cmd(args: argparse.Namespace) -> None:
 
 def service_cmd(args: argparse.Namespace) -> None:
     """Manages the Master Supervisor daemon (status, restart, stop, start)."""
-    client = SupervisorClient(base_url=get_base_url(args))
+    client = get_supervisor_client(args)
     action = args.service_action.lower()
 
     if action == "status":
@@ -259,7 +264,7 @@ def service_cmd(args: argparse.Namespace) -> None:
 def shell_cmd(args: argparse.Namespace) -> None:
     """Launches the interactive REPL shell."""
     from supervisor.shell import run_interactive_shell
-    run_interactive_shell(host=args.host, port=args.port)
+    run_interactive_shell(host=args.host, port=args.port, token=getattr(args, "token", None))
 
 
 def main():
@@ -267,9 +272,12 @@ def main():
         from supervisor.master_daemon import run_master_daemon
         idx = sys.argv.index("--run-daemon")
         port = 9333
+        token = None
         if len(sys.argv) > idx + 1 and sys.argv[idx + 1].isdigit():
             port = int(sys.argv[idx + 1])
-        run_master_daemon(port=port)
+        if len(sys.argv) > idx + 2:
+            token = sys.argv[idx + 2]
+        run_master_daemon(port=port, token=token)
         return
 
     if "--run-worker" in sys.argv:
@@ -286,6 +294,7 @@ def main():
     parser.add_argument("--env-file", help="Path to custom .env file")
     parser.add_argument("--host", default="127.0.0.1", help="Supervisor host address (default: 127.0.0.1)")
     parser.add_argument("--port", type=int, default=9333, help="Supervisor port (default: 9333)")
+    parser.add_argument("--token", help="Explicit Master Supervisor authentication token")
 
     subparsers = parser.add_subparsers(dest="command", required=True)
 
@@ -305,6 +314,7 @@ def main():
     p_inspect.add_argument("--standalone", action="store_true", help="Run in-process via FlowOrchestrator instead of Master Supervisor")
     p_inspect.add_argument("--host", default="127.0.0.1", help="Supervisor host address")
     p_inspect.add_argument("--port", type=int, default=9333, help="Supervisor port")
+    p_inspect.add_argument("--token", help="Explicit Master Supervisor authentication token")
     p_inspect.add_argument("--config", help="Path to custom settings.json configuration file")
     p_inspect.add_argument("--device-profile", help="Path to custom device_profile.json configuration file")
     p_inspect.add_argument("--env-file", help="Path to custom .env file")
@@ -329,6 +339,7 @@ def main():
     p_apply.add_argument("--standalone", action="store_true", help="Run in-process via FlowOrchestrator instead of Master Supervisor")
     p_apply.add_argument("--host", default="127.0.0.1", help="Supervisor host address")
     p_apply.add_argument("--port", type=int, default=9333, help="Supervisor port")
+    p_apply.add_argument("--token", help="Explicit Master Supervisor authentication token")
     p_apply.add_argument("--config", help="Path to custom settings.json configuration file")
     p_apply.add_argument("--device-profile", help="Path to custom device_profile.json configuration file")
     p_apply.add_argument("--env-file", help="Path to custom .env file")
@@ -337,12 +348,14 @@ def main():
     p_shell = subparsers.add_parser("shell", help="Launch interactive REPL automation shell")
     p_shell.add_argument("--host", default="127.0.0.1", help="Supervisor host address")
     p_shell.add_argument("--port", type=int, default=9333, help="Supervisor port")
+    p_shell.add_argument("--token", help="Explicit Master Supervisor authentication token")
 
     # 4. Supervisor Service Management Subcommand
     p_service = subparsers.add_parser("service", help="Manage Master Supervisor background daemon")
     p_service.add_argument("service_action", choices=["status", "restart", "stop", "start"], help="Action to execute")
     p_service.add_argument("--host", default="127.0.0.1", help="Supervisor host address")
     p_service.add_argument("--port", type=int, default=9333, help="Supervisor port")
+    p_service.add_argument("--token", help="Explicit Master Supervisor authentication token")
 
     # 5. Browser Binaries Installation Subcommand
     p_install = subparsers.add_parser("install", help="Download and configure required Playwright Chromium browser")

{webpilot_engine-2.0.6 → webpilot_engine-2.0.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "webpilot-engine"
-version = "2.0.6"
+version = "2.0.7"
 description = "WebPilot: Enterprise Autonomous Browser Engine, Universal Form Inspector & AI Agent Web Runtime"
 readme = "README.md"
 authors = [

{webpilot_engine-2.0.6 → webpilot_engine-2.0.7}/supervisor/client.py

@@ -86,12 +86,17 @@ class SupervisorClient:
             cwd = PROJECT_ROOT
             cmd = [py_exe, script_path]
 
-        get_process_manager().launch_detached(cmd, cwd=cwd)
+        spawn_env = os.environ.copy()
+        if self.token:
+            spawn_env["WEBPILOT_SUPERVISOR_TOKEN"] = self.token
+
+        get_process_manager().launch_detached(cmd, cwd=cwd, env=spawn_env)
 
         # Wait up to 4 seconds for supervisor to become active
         start = time.time()
         while time.time() - start < 4.0:
-            self.token = load_supervisor_token()
+            if not self.token:
+                self.token = load_supervisor_token()
             if self.is_running():
                 print("[✓] Master Supervisor is ready and active.")
                 return

{webpilot_engine-2.0.6 → webpilot_engine-2.0.7}/supervisor/contracts.py

@@ -49,6 +49,7 @@ class SupervisorActionResponse:
     telemetry: Dict[str, Any] = field(default_factory=dict)
     schema: Optional[Dict[str, Any]] = None
     confirmed_fields: List[Any] = field(default_factory=list)
+    unconfirmed_fields: List[Any] = field(default_factory=list)
     failed_fields: List[Any] = field(default_factory=list)
     validation_errors: List[str] = field(default_factory=list)
     reactive_event: Optional[Dict[str, Any]] = None

{webpilot_engine-2.0.6 → webpilot_engine-2.0.7}/supervisor/master_daemon.py

@@ -88,33 +88,37 @@ class MasterSupervisor:
         self.watchdog_thread = threading.Thread(target=self._watchdog_loop, daemon=True)
         self.watchdog_thread.start()
 
+    def _spawn_worker(self) -> subprocess.Popen:
+        """Spawns Layer 2 Worker subprocess with process group isolation."""
+        if getattr(sys, "frozen", False):
+            worker_cmd = [sys.executable, "--run-worker"]
+            worker_cwd = os.path.dirname(sys.executable)
+        else:
+            worker_cmd = [sys.executable, "-m", "supervisor.worker_process"]
+            worker_cwd = PROJECT_ROOT
+
+        worker_env = os.environ.copy()
+        worker_env["WEBPILOT_SUPERVISOR_TOKEN"] = self.token
+
+        popen_kwargs: Dict[str, Any] = {
+            "stdin": subprocess.PIPE,
+            "stdout": subprocess.PIPE,
+            "stderr": subprocess.PIPE,
+            "text": True,
+            "bufsize": 1,
+            "cwd": worker_cwd,
+            "env": worker_env,
+        }
+        if sys.platform != "win32":
+            popen_kwargs["start_new_session"] = True
+
+        return subprocess.Popen(worker_cmd, **popen_kwargs)
+
     def _ensure_worker(self) -> subprocess.Popen:
         """Spawns Layer 2 Worker subprocess if not currently running."""
         with self.lock:
             if self.worker_process is None or self.worker_process.poll() is not None:
-                if getattr(sys, "frozen", False):
-                    worker_cmd = [sys.executable, "--run-worker"]
-                    worker_cwd = os.path.dirname(sys.executable)
-                else:
-                    worker_cmd = [sys.executable, "-m", "supervisor.worker_process"]
-                    worker_cwd = PROJECT_ROOT
-
-                worker_env = os.environ.copy()
-                worker_env["WEBPILOT_SUPERVISOR_TOKEN"] = self.token
-
-                popen_kwargs: Dict[str, Any] = {
-                    "stdin": subprocess.PIPE,
-                    "stdout": subprocess.PIPE,
-                    "stderr": subprocess.PIPE,
-                    "text": True,
-                    "bufsize": 1,
-                    "cwd": worker_cwd,
-                    "env": worker_env,
-                }
-                if sys.platform != "win32":
-                    popen_kwargs["start_new_session"] = True
-
-                self.worker_process = subprocess.Popen(worker_cmd, **popen_kwargs)
+                self.worker_process = self._spawn_worker()
             return self.worker_process
 
     def execute_action(self, req: SupervisorActionRequest) -> SupervisorActionResponse:
@@ -179,19 +183,8 @@ class MasterSupervisor:
         with self.lock:
             old_pid = self.worker_process.pid if self.worker_process else None
             self.terminate_worker()
-            # Spawn fresh Worker
-            worker_env = os.environ.copy()
-            worker_env["WEBPILOT_SUPERVISOR_TOKEN"] = self.token
-            new_worker = subprocess.Popen(
-                [sys.executable, "-m", "supervisor.worker_process"],
-                stdin=subprocess.PIPE,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                text=True,
-                bufsize=1,
-                cwd=PROJECT_ROOT,
-                env=worker_env,
-            )
+            # Spawn fresh Worker using unified helper with start_new_session on POSIX
+            new_worker = self._spawn_worker()
             self.worker_process = new_worker
             self.last_active_time = time.time()
 
@@ -306,13 +299,13 @@ def create_supervisor_handler(supervisor: MasterSupervisor):
     return SupervisorHTTPHandler
 
 
-def run_master_daemon(port: int = DEFAULT_SUPERVISOR_PORT):
+def run_master_daemon(port: int = DEFAULT_SUPERVISOR_PORT, token: Optional[str] = None):
     """Starts the Master Supervisor HTTP service."""
     sys.stdout = LogWriter(LOG_FILE)
     sys.stderr = LogWriter(LOG_FILE)
     log_daemon(f"run_master_daemon starting on port {port} (PID: {os.getpid()})")
     try:
-        supervisor = MasterSupervisor(port=port)
+        supervisor = MasterSupervisor(port=port, token=token)
         handler_class = create_supervisor_handler(supervisor)
         server = HTTPServer((DEFAULT_SUPERVISOR_HOST, port), handler_class)
         log_daemon(f"Master Supervisor listening on http://{DEFAULT_SUPERVISOR_HOST}:{port}")
@@ -332,6 +325,7 @@ def run_master_daemon(port: int = DEFAULT_SUPERVISOR_PORT):
 
 
 if __name__ == "__main__":
-    port = int(sys.argv[1]) if len(sys.argv) > 1 else DEFAULT_SUPERVISOR_PORT
-    run_master_daemon(port=port)
+    port = int(sys.argv[1]) if len(sys.argv) > 1 and sys.argv[1].isdigit() else DEFAULT_SUPERVISOR_PORT
+    token = sys.argv[2] if len(sys.argv) > 2 else None
+    run_master_daemon(port=port, token=token)
 

{webpilot_engine-2.0.6 → webpilot_engine-2.0.7}/supervisor/shell.py

@@ -8,7 +8,7 @@ from __future__ import annotations
 
 import os
 import sys
-from typing import List
+from typing import List, Optional
 
 PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 if PROJECT_ROOT not in sys.path:
@@ -19,9 +19,9 @@ from supervisor.client import SupervisorClient
 from supervisor.contracts import SupervisorActionRequest, SupervisorActionResponse
 
 
-def run_interactive_shell(host: str = "127.0.0.1", port: int = 9333):
+def run_interactive_shell(host: str = "127.0.0.1", port: int = 9333, token: Optional[str] = None):
     """Runs the interactive REPL session."""
-    client = SupervisorClient(base_url=f"http://{host}:{port}")
+    client = SupervisorClient(base_url=f"http://{host}:{port}", token=token)
     try:
         client.ensure_running()
     except Exception as exc:

{webpilot_engine-2.0.6 → webpilot_engine-2.0.7}/supervisor/worker_process.py

@@ -253,6 +253,7 @@ class OperationalWorker:
 
         field_svc = FieldInteractionService(page)
         confirmed = []
+        unconfirmed = []
         failed = []
 
         if fields_to_set:
@@ -260,12 +261,23 @@ class OperationalWorker:
             for key, val in fields_to_set:
                 success = field_svc.set_field(key, val)
                 if success:
-                    confirmed.append((key, val))
-                    lines.append(f"  [✓] Set '{key}' -> '{val}'")
+                    # Post-fill verification: read back DOM value to confirm it was applied
+                    verified = field_svc.verify_field_value(key, val)
+                    if not verified:
+                        # Fallback retry via direct Playwright interaction
+                        field_svc._playwright_click_fallback(key, val)
+                        verified = field_svc.verify_field_value(key, val)
+
+                    if verified:
+                        confirmed.append((key, val))
+                        lines.append(f"  [✓] Set & Verified '{key}' -> '{val}'")
+                    else:
+                        unconfirmed.append((key, val))
+                        lines.append(f"  [?] Set but unconfirmed '{key}' -> '{val}'")
                 else:
                     failed.append((key, val))
                     lines.append(f"  [~] Unmatched/Failed '{key}' -> '{val}'")
-            lines.append(f"[*] Fields summary: {len(confirmed)} set | {len(failed)} skipped.")
+            lines.append(f"[*] Fields summary: {len(confirmed)} confirmed | {len(unconfirmed)} unconfirmed | {len(failed)} skipped.")
 
         # 4. Handle uploads
         if req.upload_files:
@@ -349,6 +361,7 @@ class OperationalWorker:
             total_tabs=len(ctx.pages) if ctx else 0,
             tabs=coord.adapter.list_open_tabs(),
             confirmed_fields=confirmed,
+            unconfirmed_fields=unconfirmed,
             failed_fields=failed,
             validation_errors=validation_errors,
             schema=schema,

webpilot_engine-2.0.7/tests/test_supervisor.py

@@ -0,0 +1,179 @@
+"""Unit tests for Master Supervisor, Worker Process contracts, and Supervisor Client."""
+
+import json
+import pytest
+from supervisor.contracts import SupervisorActionRequest, SupervisorActionResponse
+from supervisor.client import SupervisorClient, DEFAULT_SUPERVISOR_URL
+
+
+def test_supervisor_action_request_roundtrip():
+    """Verify SupervisorActionRequest serialization and deserialization."""
+    req = SupervisorActionRequest(
+        action="apply",
+        url="https://example.com/login",
+        fill_arguments=["username=testuser", "password=secret"],
+        press_buttons=["Sign In"],
+        submit=True,
+        screenshot_path="screenshot.png",
+        tab_index=1,
+        auto_inspect=False,
+    )
+    data = req.to_dict()
+    assert data["action"] == "apply"
+    assert data["url"] == "https://example.com/login"
+    assert data["fill_arguments"] == ["username=testuser", "password=secret"]
+    assert data["press_buttons"] == ["Sign In"]
+    assert data["submit"] is True
+    assert data["screenshot_path"] == "screenshot.png"
+    assert data["tab_index"] == 1
+    assert data["auto_inspect"] is False
+
+    reconstructed = SupervisorActionRequest.from_dict(data)
+    assert reconstructed == req
+
+
+def test_supervisor_action_response_roundtrip():
+    """Verify SupervisorActionResponse serialization and deserialization."""
+    resp = SupervisorActionResponse(
+        success=True,
+        action="apply",
+        message="Success",
+        browser_pid=1234,
+        worker_pid=5678,
+        active_tab_index=0,
+        active_url="https://example.com/dashboard",
+        active_title="Dashboard",
+        total_tabs=1,
+        tabs=[{"index": 0, "title": "Dashboard", "url": "https://example.com/dashboard", "is_active": True}],
+        confirmed_fields=[("username", "testuser")],
+        failed_fields=[],
+        validation_errors=[],
+        output_lines=["[✓] Form submitted"],
+    )
+    data = resp.to_dict()
+    assert data["success"] is True
+    assert data["browser_pid"] == 1234
+    assert data["worker_pid"] == 5678
+    assert len(data["tabs"]) == 1
+    assert data["output_lines"] == ["[✓] Form submitted"]
+
+    reconstructed = SupervisorActionResponse.from_dict(data)
+    assert reconstructed == resp
+
+
+def test_supervisor_client_default_url():
+    """Verify SupervisorClient initialization with default and custom URLs."""
+    client_default = SupervisorClient()
+    assert client_default.base_url == DEFAULT_SUPERVISOR_URL
+
+    client_custom = SupervisorClient(base_url="http://127.0.0.1:9555/")
+    assert client_custom.base_url == "http://127.0.0.1:9555"
+
+
+def test_supervisor_action_request_defaults():
+    """Verify default values of SupervisorActionRequest."""
+    req = SupervisorActionRequest(action="inspect")
+    assert req.action == "inspect"
+    assert req.url is None
+    assert req.fill_arguments == []
+    assert req.press_buttons == []
+    assert req.upload_files == []
+    assert req.submit is False
+    assert req.auto_inspect is True
+    assert req.timeout_minutes == 30
+
+
+def test_supervisor_spawn_and_restart_worker(monkeypatch):
+    """Verify MasterSupervisor._spawn_worker and restart_worker lifecycle with start_new_session."""
+    from supervisor.master_daemon import MasterSupervisor
+    import subprocess
+    import sys
+
+    sup = MasterSupervisor(port=9777, token="dummy-token")
+    sup._is_running = False  # Stop watchdog thread
+
+    spawn_calls = []
+
+    class DummyProc:
+        def __init__(self, pid):
+            self.pid = pid
+        def poll(self):
+            return None
+
+    def fake_popen(cmd, **kwargs):
+        spawn_calls.append((cmd, kwargs))
+        return DummyProc(pid=1000 + len(spawn_calls))
+
+    monkeypatch.setattr(subprocess, "Popen", fake_popen)
+
+    # Test initial spawn via _ensure_worker
+    proc1 = sup._ensure_worker()
+    assert proc1.pid == 1001
+    assert len(spawn_calls) == 1
+    cmd1, kwargs1 = spawn_calls[0]
+    assert kwargs1["env"]["WEBPILOT_SUPERVISOR_TOKEN"] == "dummy-token"
+    if sys.platform != "win32":
+        assert kwargs1.get("start_new_session") is True
+
+    # Test restart_worker
+    terminated = []
+    monkeypatch.setattr(sup, "terminate_worker", lambda: terminated.append(True))
+    resp = sup.restart_worker()
+
+    assert resp.success is True
+    assert resp.action == "restart_worker"
+    assert resp.worker_pid == 1002
+    assert len(terminated) == 1
+    assert len(spawn_calls) == 2
+    cmd2, kwargs2 = spawn_calls[1]
+    # Verify that restart_worker uses the unified _spawn_worker
+    if sys.platform != "win32":
+        assert kwargs2.get("start_new_session") is True
+    assert kwargs2["env"]["WEBPILOT_SUPERVISOR_TOKEN"] == "dummy-token"
+
+
+def test_worker_process_field_verification(monkeypatch):
+    """Verify worker_process calls verify_field_value and populates confirmed and unconfirmed fields."""
+    from supervisor.worker_process import OperationalWorker
+    from unittest.mock import MagicMock
+
+    worker = OperationalWorker()
+
+    mock_coord = MagicMock()
+    mock_coord.page.url = "https://example.com/form"
+    mock_coord.page.title.return_value = "Test Form"
+    mock_coord.page.is_closed.return_value = False
+    mock_coord.page.locator.return_value.count.return_value = 0
+    mock_coord.context.pages = [mock_coord.page]
+    worker.coordinator = mock_coord
+    monkeypatch.setattr(worker, "_ensure_session", lambda req: mock_coord)
+
+    # Mock FieldInteractionService
+    mock_field_svc = MagicMock()
+    mock_field_svc.set_field.side_effect = lambda k, v: k != "skipped_field"
+    mock_field_svc.verify_field_value.side_effect = lambda k, v: k == "verified_field"
+
+    monkeypatch.setattr("supervisor.worker_process.FieldInteractionService", lambda page: mock_field_svc)
+    monkeypatch.setattr("supervisor.worker_process.AuthNavigationService", lambda p, c: MagicMock())
+    monkeypatch.setattr("supervisor.worker_process.FormValidator", lambda p: MagicMock(get_validation_errors=lambda: []))
+    monkeypatch.setattr("supervisor.worker_process.InspectionService", lambda p: MagicMock())
+
+    req = SupervisorActionRequest(
+        action="apply",
+        url="https://example.com/form",
+        fill_arguments=[
+            "verified_field=value1",
+            "unverified_field=value2",
+            "skipped_field=value3",
+        ],
+        auto_inspect=False,
+    )
+
+    resp = worker._handle_apply(req)
+
+    assert resp.success is True
+    assert resp.confirmed_fields == [("verified_field", "value1")]
+    assert resp.unconfirmed_fields == [("unverified_field", "value2")]
+    assert resp.failed_fields == [("skipped_field", "value3")]
+    assert mock_field_svc.verify_field_value.called
+

{webpilot_engine-2.0.6 → webpilot_engine-2.0.7}/tests/test_supervisor_security.py

@@ -87,3 +87,22 @@ def test_supervisor_http_auth_enforcement():
     finally:
         server.shutdown()
         server.server_close()
+
+
+def test_cli_token_argument_and_client_propagation():
+    """Verify CLI --token flag parsing and propagation to SupervisorClient."""
+    import argparse
+    from cli import get_supervisor_client
+
+    # 1. Custom token provided in args
+    args_with_token = argparse.Namespace(host="127.0.0.1", port=9333, token="my-custom-token-xyz")
+    client = get_supervisor_client(args_with_token)
+    assert client.token == "my-custom-token-xyz"
+    headers = client._get_headers()
+    assert headers["X-Supervisor-Token"] == "my-custom-token-xyz"
+    assert headers["Authorization"] == "Bearer my-custom-token-xyz"
+
+    # 2. No token in args -> falls back to load_supervisor_token
+    args_no_token = argparse.Namespace(host="127.0.0.1", port=9333, token=None)
+    client_default = get_supervisor_client(args_no_token)
+    assert client_default.base_url == "http://127.0.0.1:9333"

{webpilot_engine-2.0.6 → webpilot_engine-2.0.7}/webpilot_engine.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webpilot-engine
-Version: 2.0.6
+Version: 2.0.7
 Summary: WebPilot: Enterprise Autonomous Browser Engine, Universal Form Inspector & AI Agent Web Runtime
 Author: Abdulkarim Salih, WebPilot Core Team
 License: MIT

webpilot_engine-2.0.6/tests/test_supervisor.py

@@ -1,83 +0,0 @@
-"""Unit tests for Master Supervisor, Worker Process contracts, and Supervisor Client."""
-
-import json
-import pytest
-from supervisor.contracts import SupervisorActionRequest, SupervisorActionResponse
-from supervisor.client import SupervisorClient, DEFAULT_SUPERVISOR_URL
-
-
-def test_supervisor_action_request_roundtrip():
-    """Verify SupervisorActionRequest serialization and deserialization."""
-    req = SupervisorActionRequest(
-        action="apply",
-        url="https://example.com/login",
-        fill_arguments=["username=testuser", "password=secret"],
-        press_buttons=["Sign In"],
-        submit=True,
-        screenshot_path="screenshot.png",
-        tab_index=1,
-        auto_inspect=False,
-    )
-    data = req.to_dict()
-    assert data["action"] == "apply"
-    assert data["url"] == "https://example.com/login"
-    assert data["fill_arguments"] == ["username=testuser", "password=secret"]
-    assert data["press_buttons"] == ["Sign In"]
-    assert data["submit"] is True
-    assert data["screenshot_path"] == "screenshot.png"
-    assert data["tab_index"] == 1
-    assert data["auto_inspect"] is False
-
-    reconstructed = SupervisorActionRequest.from_dict(data)
-    assert reconstructed == req
-
-
-def test_supervisor_action_response_roundtrip():
-    """Verify SupervisorActionResponse serialization and deserialization."""
-    resp = SupervisorActionResponse(
-        success=True,
-        action="apply",
-        message="Success",
-        browser_pid=1234,
-        worker_pid=5678,
-        active_tab_index=0,
-        active_url="https://example.com/dashboard",
-        active_title="Dashboard",
-        total_tabs=1,
-        tabs=[{"index": 0, "title": "Dashboard", "url": "https://example.com/dashboard", "is_active": True}],
-        confirmed_fields=[("username", "testuser")],
-        failed_fields=[],
-        validation_errors=[],
-        output_lines=["[✓] Form submitted"],
-    )
-    data = resp.to_dict()
-    assert data["success"] is True
-    assert data["browser_pid"] == 1234
-    assert data["worker_pid"] == 5678
-    assert len(data["tabs"]) == 1
-    assert data["output_lines"] == ["[✓] Form submitted"]
-
-    reconstructed = SupervisorActionResponse.from_dict(data)
-    assert reconstructed == resp
-
-
-def test_supervisor_client_default_url():
-    """Verify SupervisorClient initialization with default and custom URLs."""
-    client_default = SupervisorClient()
-    assert client_default.base_url == DEFAULT_SUPERVISOR_URL
-
-    client_custom = SupervisorClient(base_url="http://127.0.0.1:9555/")
-    assert client_custom.base_url == "http://127.0.0.1:9555"
-
-
-def test_supervisor_action_request_defaults():
-    """Verify default values of SupervisorActionRequest."""
-    req = SupervisorActionRequest(action="inspect")
-    assert req.action == "inspect"
-    assert req.url is None
-    assert req.fill_arguments == []
-    assert req.press_buttons == []
-    assert req.upload_files == []
-    assert req.submit is False
-    assert req.auto_inspect is True
-    assert req.timeout_minutes == 30