drissionpage-cli 0.1.2__tar.gz → 0.1.4__tar.gz

{drissionpage_cli-0.1.2 → drissionpage_cli-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drissionpage-cli
-Version: 0.1.2
+Version: 0.1.4
 Summary: DrissionPage CLI - Token-efficient browser automation for coding agents
 Author: DrissionPage-MCP Contributors
 License: Apache-2.0

{drissionpage_cli-0.1.2 → drissionpage_cli-0.1.4}/drissionpage_cli/__init__.py

@@ -15,7 +15,7 @@ import time
 import traceback
 from pathlib import Path
 
-__version__ = "0.1.2"
+__version__ = "0.1.4"
 
 # Session storage directory
 CLI_DIR = Path(os.environ.get("DRISSIONPAGE_CLI_DIR", ".drissionpage-cli"))
@@ -72,27 +72,45 @@ def _get_page(session_name, create=False, options=None):
     so that multiple named sessions can coexist.
     """
     from DrissionPage import ChromiumPage, ChromiumOptions
+    from DrissionPage._functions.tools import port_is_using
 
     sessions = _load_sessions()
     info = sessions.get(session_name)
 
     if info:
-        # Try to reconnect to existing session
-        co = ChromiumOptions()
-        co.set_address(info["address"])
-        try:
-            page = ChromiumPage(addr_or_opts=co)
-            if not create:
-                return page
-            # create=True but session is alive — close old one first
+        address = info["address"]
+        ip, port_str = address.split(":")
+        if port_is_using(ip, port_str):
+            # Browser is alive — connect to it.
+            # We must restore the headless state that was used when the session was
+            # created.  If we don't, DrissionPage detects a headless/headed mismatch
+            # and calls Browser.close() to kill Chrome before relaunching it —
+            # which then fails for a reconnect-only scenario.
+            co = ChromiumOptions()
+            co.set_address(address)
+            co.headless(info.get("headless", True))
             try:
-                page.quit()
+                page = ChromiumPage(addr_or_opts=co)
+                if not create:
+                    return page
+                # create=True but session is alive — close old one first
+                try:
+                    page.quit()
+                except Exception:
+                    pass
+                _kill_session(sessions, session_name)
+                sessions = _load_sessions()
             except Exception:
-                pass
-            _kill_session(sessions, session_name)
-            sessions = _load_sessions()
-        except Exception:
-            # Browser is dead — clean up stale entry
+                _kill_session(sessions, session_name)
+                sessions = _load_sessions()
+                if not create:
+                    raise RuntimeError(
+                        f"Session '{session_name}' is no longer running. "
+                        f"Use 'open' to start a new one."
+                    )
+        else:
+            # Port not in use — browser is dead, clean up without trying to connect
+            # (avoids DrissionPage launching a phantom Chrome on the stale port).
             _kill_session(sessions, session_name)
             sessions = _load_sessions()
             if not create:
@@ -111,7 +129,9 @@ def _get_page(session_name, create=False, options=None):
 
     use_system_user_path = options and options.get("system_user_path")
     if use_system_user_path:
-        # use_system_user_path is incompatible with auto_port (auto_port creates a temp profile)
+        # auto_port picks a free port; use_system_user_path then causes DrissionPage
+        # to strip the --user-data-dir arg at launch, so Chrome uses the system profile.
+        co.auto_port()
         co.use_system_user_path(True)
     else:
         co.auto_port()  # pick a free port to avoid conflicts with stale browsers
@@ -140,6 +160,7 @@ def _get_page(session_name, create=False, options=None):
         "address": page.address,
         "pid": page.process_id,
         "started": time.time(),
+        "headless": options.get("headless", True) if options else True,
     }
     _save_sessions(sessions)
     return page

drissionpage_cli-0.1.4/drissionpage_cli/__main__.py

@@ -0,0 +1,3 @@
+from drissionpage_cli import main
+
+main()

{drissionpage_cli-0.1.2 → drissionpage_cli-0.1.4}/drissionpage_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drissionpage-cli
-Version: 0.1.2
+Version: 0.1.4
 Summary: DrissionPage CLI - Token-efficient browser automation for coding agents
 Author: DrissionPage-MCP Contributors
 License: Apache-2.0

{drissionpage_cli-0.1.2 → drissionpage_cli-0.1.4}/drissionpage_cli.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ LICENSE
 README.md
 pyproject.toml
 drissionpage_cli/__init__.py
+drissionpage_cli/__main__.py
 drissionpage_cli.egg-info/PKG-INFO
 drissionpage_cli.egg-info/SOURCES.txt
 drissionpage_cli.egg-info/dependency_links.txt

{drissionpage_cli-0.1.2 → drissionpage_cli-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "drissionpage-cli"
-version = "0.1.2"
+version = "0.1.4"
 description = "DrissionPage CLI - Token-efficient browser automation for coding agents"
 readme = "README.md"
 license = {text = "Apache-2.0"}

{drissionpage_cli-0.1.2 → drissionpage_cli-0.1.4}/tests/test_integration.py

@@ -21,7 +21,7 @@ from pathlib import Path
 
 import pytest
 
-CLI_PATH = Path(__file__).resolve().parent.parent / "drissionpage_cli.py"
+CLI_ROOT = Path(__file__).resolve().parent.parent
 
 # Skip all integration tests if no browser or explicitly skipped
 SKIP_INTEGRATION = os.environ.get("SKIP_INTEGRATION", "0") == "1"
@@ -33,10 +33,11 @@ pytestmark = pytest.mark.skipif(
 def run_cli(*args, timeout=60, cwd=None, env_extra=None):
     """Run drissionpage-cli and return (returncode, stdout, stderr)."""
     env = os.environ.copy()
+    env["PYTHONPATH"] = str(CLI_ROOT) + os.pathsep + env.get("PYTHONPATH", "")
     if env_extra:
         env.update(env_extra)
 
-    cmd = [sys.executable, str(CLI_PATH)] + list(args)
+    cmd = [sys.executable, "-m", "drissionpage_cli"] + list(args)
     proc = subprocess.run(
         cmd, capture_output=True, text=True, timeout=timeout, env=env, cwd=cwd
     )
@@ -53,6 +54,15 @@ def isolated_env(tmp_path):
     }
 
 
+@pytest.fixture
+def storage_url(tmp_path):
+    """A file:// URL that supports localStorage and sessionStorage.
+    data: URLs are null-origin in Chrome and block storage access."""
+    html_file = tmp_path / "storage_test.html"
+    html_file.write_text("<p>Storage Test</p>")
+    return html_file.as_uri()
+
+
 @pytest.fixture(autouse=True)
 def cleanup_after_test(isolated_env):
     """Ensure browser is closed after each test."""
@@ -73,7 +83,7 @@ class TestIntegrationBasic:
     def test_version(self):
         rc, stdout, stderr = run_cli("--version")
         assert rc == 0
-        assert "0.1.0" in stdout
+        assert "0.1.4" in stdout
 
     def test_help(self):
         rc, stdout, stderr = run_cli("--help")
@@ -215,10 +225,10 @@ class TestIntegrationBrowser:
         rc, stdout, stderr = run_cli("reload", env_extra=isolated_env)
         assert rc == 0
 
-    def test_localstorage_operations(self, isolated_env):
+    def test_localstorage_operations(self, isolated_env, storage_url):
         """Test localStorage set, get, list, delete, clear."""
-        html = "data:text/html,<p>Storage Test</p>"
-        run_cli("open", html, env_extra=isolated_env)
+        # data: URLs are null-origin and block localStorage; use file:// instead.
+        run_cli("open", storage_url, env_extra=isolated_env)
 
         # Set
         rc, stdout, _ = run_cli(
@@ -250,10 +260,10 @@ class TestIntegrationBrowser:
         rc, stdout, _ = run_cli("localstorage-clear", env_extra=isolated_env)
         assert rc == 0
 
-    def test_sessionstorage_operations(self, isolated_env):
+    def test_sessionstorage_operations(self, isolated_env, storage_url):
         """Test sessionStorage set, get, clear."""
-        html = "data:text/html,<p>Session Storage</p>"
-        run_cli("open", html, env_extra=isolated_env)
+        # data: URLs are null-origin and block sessionStorage; use file:// instead.
+        run_cli("open", storage_url, env_extra=isolated_env)
 
         rc, stdout, _ = run_cli(
             "sessionstorage-set", "step", "5", env_extra=isolated_env
@@ -271,10 +281,10 @@ class TestIntegrationBrowser:
         )
         assert rc == 0
 
-    def test_state_save_and_load(self, isolated_env, tmp_path):
+    def test_state_save_and_load(self, isolated_env, storage_url, tmp_path):
         """Save and load browser state."""
-        html = "data:text/html,<p>State Test</p>"
-        run_cli("open", html, env_extra=isolated_env)
+        # data: URLs are null-origin and block localStorage; use file:// instead.
+        run_cli("open", storage_url, env_extra=isolated_env)
 
         # Set some storage
         run_cli("localstorage-set", "saved_key", "saved_val", env_extra=isolated_env)
@@ -371,14 +381,18 @@ class TestIntegrationBrowser:
         assert "resized" in stdout.lower()
 
     def test_dialog_handling(self, isolated_env):
-        """Test dialog accept/dismiss."""
+        """Test dialog accept/dismiss in a single subprocess to avoid losing dialog state."""
         html = "data:text/html,<button id='a' onclick='alert(\"hi\")'>Alert</button>"
         run_cli("open", html, env_extra=isolated_env)
 
-        # Click to trigger alert, then dismiss
-        run_cli("click", "@id=a", env_extra=isolated_env)
-        rc, stdout, _ = run_cli("dialog-dismiss", env_extra=isolated_env)
-        # This may fail if alert wasn't caught, which is ok for basic test
+        # Click and dismiss must happen in the same subprocess — the alert dialog is
+        # lost between separate CLI invocations because headless Chrome doesn't persist
+        # pending dialog state across CDP reconnections.
+        rc, stdout, _ = run_cli(
+            "run-code",
+            "import time; page.ele('@id=a').click(); time.sleep(0.3); page.handle_alert(accept=False)",
+            env_extra=isolated_env,
+        )
         assert rc == 0
 
     def test_hover(self, isolated_env):

{drissionpage_cli-0.1.2 → drissionpage_cli-0.1.4}/tests/test_unit.py

@@ -26,7 +26,7 @@ import drissionpage_cli as cli
 
 class TestVersionAndHelp:
     def test_version_string(self):
-        assert cli.__version__ == "0.1.2"
+        assert cli.__version__ == "0.1.4"
 
     def test_build_parser(self):
         parser = cli.build_parser()
@@ -473,7 +473,7 @@ class TestCliInvocation:
 
         result = run_cli("--version")
         assert result.exit_code == 0
-        assert "0.1.0" in result.output
+        assert "0.1.4" in result.output
 
     def test_no_command_shows_help(self):
         """No command shows help text."""
@@ -619,11 +619,11 @@ class TestGetPageOptions:
         self._run_get_page({"system_user_path": True}, tmp_path, mock_co, mock_page)
         mock_co.use_system_user_path.assert_called_once_with(True)
 
-    def test_system_user_path_skips_auto_port(self, tmp_path):
+    def test_system_user_path_also_calls_auto_port(self, tmp_path):
         mock_co = self._make_mock_co()
         mock_page = MagicMock()
         self._run_get_page({"system_user_path": True}, tmp_path, mock_co, mock_page)
-        mock_co.auto_port.assert_not_called()
+        mock_co.auto_port.assert_called_once()
 
     def test_no_system_user_path_calls_auto_port(self, tmp_path):
         mock_co = self._make_mock_co()
@@ -639,6 +639,52 @@ class TestGetPageOptions:
         mock_co.use_system_user_path.assert_called_once_with(True)
         mock_co.headless.assert_called_once_with(False)
 
+    def test_stale_session_dead_port_cleaned_without_connect(self, tmp_path):
+        """When session port is not in use, we must clean up WITHOUT calling
+        ChromiumPage (which would launch a phantom Chrome on the stale port)."""
+        sessions_file = tmp_path / "sessions.json"
+        cli_dir_path = tmp_path / ".drissionpage-cli"
+        cli_dir_path.mkdir()
+        sessions_file.write_text(
+            '{"default": {"address": "127.0.0.1:9222", "pid": 99999, "started": 0}}'
+        )
+
+        mock_page = MagicMock()
+        with patch.object(cli, "SESSIONS_FILE", sessions_file), \
+             patch.object(cli, "CLI_DIR", cli_dir_path), \
+             patch("DrissionPage._functions.tools.port_is_using", return_value=False), \
+             patch("DrissionPage.ChromiumPage") as mock_chromium_page:
+            try:
+                cli._get_page("default", create=False, options=None)
+            except RuntimeError:
+                pass
+            # ChromiumPage must NOT be called — no phantom Chrome launch
+            mock_chromium_page.assert_not_called()
+
+    def test_reconnect_restores_headless_state(self, tmp_path):
+        """When reconnecting to a live session, headless state from session info
+        must be passed to ChromiumOptions to prevent DrissionPage restarting Chrome."""
+        sessions_file = tmp_path / "sessions.json"
+        cli_dir_path = tmp_path / ".drissionpage-cli"
+        cli_dir_path.mkdir()
+        sessions_file.write_text(
+            '{"default": {"address": "127.0.0.1:9333", "pid": 111, "started": 0, "headless": true}}'
+        )
+
+        mock_co = MagicMock()
+        mock_page = MagicMock()
+        mock_page.address = "127.0.0.1:9333"
+        mock_page.process_id = 111
+
+        with patch.object(cli, "SESSIONS_FILE", sessions_file), \
+             patch.object(cli, "CLI_DIR", cli_dir_path), \
+             patch("DrissionPage._functions.tools.port_is_using", return_value=True), \
+             patch("DrissionPage.ChromiumOptions", return_value=mock_co), \
+             patch("DrissionPage.ChromiumPage", return_value=mock_page):
+            cli._get_page("default", create=False, options=None)
+
+        mock_co.headless.assert_called_once_with(True)
+
 
 # ---------------------------------------------------------------------------
 # Command handlers (mocked browser)
@@ -942,7 +988,7 @@ class TestCommandHandlersMocked:
             args.session = None
             args.domain = None
             cli.cmd_cookie_list(args)
-        mock_page.cookies.assert_called_once_with(as_dict=False, all_info=True)
+        mock_page.cookies.assert_called_once_with(all_info=True)
 
     def test_cmd_cookie_list_filtered(self, tmp_path):
         mock_page = self._make_mock_page()