navcli 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

navcli/cli/app.py

@@ -54,6 +54,10 @@ class NavCLI(
             self.poutput("  state         Get full page state")
             self.poutput("  url           Get current URL")
             self.poutput("  title         Get page title")
+            self.poutput("  tables        Get all tables with data")
+            self.poutput("  paragraphs    Get large text paragraphs (200+ chars)")
+            self.poutput("  links         Get all links")
+            self.poutput("  forms         Get all forms")
 
             self.poutput("\nExplore Commands:")
             self.poutput("  find <text>        Find element by text")

navcli/cli/client.py

@@ -123,6 +123,18 @@ class NavClient:
         """Get all forms on the page."""
         return await self._request("GET", "/query/forms")
 
+    async def get_tables(self):
+        """Get all tables on the page with their data."""
+        return await self._request("GET", "/query/tables")
+
+    async def get_paragraphs(self, min_length: int = 200):
+        """Get large text paragraphs (200+ chars) from the page.
+
+        Args:
+            min_length: Minimum paragraph length (default: 200)
+        """
+        return await self._request("GET", f"/query/paragraphs?min_length={min_length}")
+
     # Explore commands
     async def find(self, text: str):
         """Find element by text."""
@@ -234,25 +246,39 @@ class NavClient:
 
         return await self._request("POST", "/cmd/cookies/set", json=body)
 
-    async def save_session(self, path: str = ".navcli_session.json"):
+    async def save_session(self, name: str = None, path: str = None):
         """Save session to file.
 
         Args:
-            path: File path to save session
+            name: Session name (saves to ~/.navcli/sessions/<name>.json)
+            path: Full file path (alternative to name)
         """
         import urllib.parse
-        encoded_path = urllib.parse.quote(path)
-        return await self._request("POST", f"/cmd/session/save?path={encoded_path}")
 
-    async def load_session(self, path: str = ".navcli_session.json"):
+        if name:
+            return await self._request("POST", f"/cmd/session/save?name={name}")
+        elif path:
+            encoded_path = urllib.parse.quote(path)
+            return await self._request("POST", f"/cmd/session/save?path={encoded_path}")
+        else:
+            return await self._request("POST", "/cmd/session/save")
+
+    async def load_session(self, name: str = None, path: str = None):
         """Load session from file.
 
         Args:
-            path: File path to load session from
+            name: Session name (loads from ~/.navcli/sessions/<name>.json)
+            path: Full file path (alternative to name)
         """
         import urllib.parse
-        encoded_path = urllib.parse.quote(path)
-        return await self._request("POST", f"/cmd/session/load?path={encoded_path}")
+
+        if name:
+            return await self._request("POST", f"/cmd/session/load?name={name}")
+        elif path:
+            encoded_path = urllib.parse.quote(path)
+            return await self._request("POST", f"/cmd/session/load?path={encoded_path}")
+        else:
+            return await self._request("POST", "/cmd/session/load")
 
 
 async def main():

navcli/cli/commands/control.py

@@ -21,7 +21,7 @@ class ControlCommands(BaseBrowserCommand):
         async def _quit():
             return await self.client.quit()
 
-        result = asyncio.run(self.run_async_client(_quit))
+        result = asyncio.run(self.run_async_client(_quit()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -35,7 +35,7 @@ class ControlCommands(BaseBrowserCommand):
         async def _shutdown():
             return await self.client.shutdown()
 
-        result = asyncio.run(self.run_async_client(_shutdown))
+        result = asyncio.run(self.run_async_client(_shutdown()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -50,41 +50,41 @@ class ControlCommands(BaseBrowserCommand):
     # Session commands
 
     save_parser = cmd2.Cmd2ArgumentParser()
-    save_parser.add_argument("path", nargs="?", default=".navcli_session.json",
-                              help="Path to save session file")
+    save_parser.add_argument("name", nargs="?", default=None,
+                             help="Session name (saves to ~/.navcli/sessions/<name>.json)")
 
     @cmd2.with_argparser(save_parser)
     def do_save_session(self, args):
         """Save session (cookies, storage) to file.
 
-        Usage: save_session [path]
-        Example: save_session my_session.json
+        Usage: save_session [name]
+        Example: save_session jisilu
         """
         import asyncio
 
         async def _save():
-            return await self.client.save_session(args.path)
+            return await self.client.save_session(name=args.name)
 
-        result = asyncio.run(self.run_async_client(_save))
+        result = asyncio.run(self.run_async_client(_save()))
         self.pretty_result(result)
 
     load_parser = cmd2.Cmd2ArgumentParser()
-    load_parser.add_argument("path", nargs="?", default=".navcli_session.json",
-                              help="Path to load session file from")
+    load_parser.add_argument("name", nargs="?", default=None,
+                             help="Session name (loads from ~/.navcli/sessions/<name>.json)")
 
     @cmd2.with_argparser(load_parser)
     def do_load_session(self, args):
         """Load session (cookies, storage) from file.
 
-        Usage: load_session [path]
-        Example: load_session my_session.json
+        Usage: load_session [name]
+        Example: load_session jisilu
         """
         import asyncio
 
         async def _load():
-            return await self.client.load_session(args.path)
+            return await self.client.load_session(name=args.name)
 
-        result = asyncio.run(self.run_async_client(_load))
+        result = asyncio.run(self.run_async_client(_load()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -98,7 +98,7 @@ class ControlCommands(BaseBrowserCommand):
         async def _get():
             return await self.client.get_cookies()
 
-        result = asyncio.run(self.run_async_client(_get))
+        result = asyncio.run(self.run_async_client(_get()))
         if result.get("success"):
             self.poutput("[OK] got cookies")
         else:
@@ -115,5 +115,5 @@ class ControlCommands(BaseBrowserCommand):
         async def _clear():
             return await self.client.clear_cookies()
 
-        result = asyncio.run(self.run_async_client(_clear))
+        result = asyncio.run(self.run_async_client(_clear()))
         self.pretty_result(result)

navcli/cli/commands/explore.py

@@ -22,7 +22,7 @@ class ExploreCommands(BaseBrowserCommand):
         async def _find():
             return await self.client.find(args.text)
 
-        result = asyncio.run(self.run_async_client(_find))
+        result = asyncio.run(self.run_async_client(_find()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -37,7 +37,7 @@ class ExploreCommands(BaseBrowserCommand):
         async def _findall():
             return await self.client.findall(args.text)
 
-        result = asyncio.run(self.run_async_client(_findall))
+        result = asyncio.run(self.run_async_client(_findall()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -52,7 +52,7 @@ class ExploreCommands(BaseBrowserCommand):
         async def _inspect():
             return await self.client.inspect(args.selector)
 
-        result = asyncio.run(self.run_async_client(_inspect))
+        result = asyncio.run(self.run_async_client(_inspect()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -73,7 +73,7 @@ class ExploreCommands(BaseBrowserCommand):
             else:
                 return await self.client.wait()
 
-        result = asyncio.run(self.run_async_client(_wait))
+        result = asyncio.run(self.run_async_client(_wait()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -89,7 +89,7 @@ class ExploreCommands(BaseBrowserCommand):
             timeout = args.timeout if args.timeout else 3.0
             return await self.client.wait_idle(timeout=timeout)
 
-        result = asyncio.run(self.run_async_client(_wait_idle))
+        result = asyncio.run(self.run_async_client(_wait_idle()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -121,5 +121,5 @@ class ExploreCommands(BaseBrowserCommand):
             else:
                 return await self.client.scroll(direction="down")
 
-        result = asyncio.run(self.run_async_client(_scroll))
+        result = asyncio.run(self.run_async_client(_scroll()))
         self.pretty_result(result)

navcli/cli/commands/interaction.py

@@ -33,7 +33,7 @@ class InteractionCommands(BaseBrowserCommand):
         async def _click():
             return await self.client.click(args.selector, force=args.force)
 
-        result = asyncio.run(self.run_async_client(_click))
+        result = asyncio.run(self.run_async_client(_click()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -48,7 +48,7 @@ class InteractionCommands(BaseBrowserCommand):
         async def _type():
             return await self.client.type(args.selector, args.text)
 
-        result = asyncio.run(self.run_async_client(_type))
+        result = asyncio.run(self.run_async_client(_type()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -63,7 +63,7 @@ class InteractionCommands(BaseBrowserCommand):
         async def _dblclick():
             return await self.client.dblclick(args.selector)
 
-        result = asyncio.run(self.run_async_client(_dblclick))
+        result = asyncio.run(self.run_async_client(_dblclick()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -78,7 +78,7 @@ class InteractionCommands(BaseBrowserCommand):
         async def _rightclick():
             return await self.client.rightclick(args.selector)
 
-        result = asyncio.run(self.run_async_client(_rightclick))
+        result = asyncio.run(self.run_async_client(_rightclick()))
         self.pretty_result(result)
 
     # Aliases
@@ -110,7 +110,7 @@ class InteractionCommands(BaseBrowserCommand):
         async def _clear():
             return await self.client.clear(args.selector)
 
-        result = asyncio.run(self.run_async_client(_clear))
+        result = asyncio.run(self.run_async_client(_clear()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -125,5 +125,5 @@ class InteractionCommands(BaseBrowserCommand):
         async def _upload():
             return await self.client.upload(args.selector, args.file_path)
 
-        result = asyncio.run(self.run_async_client(_upload))
+        result = asyncio.run(self.run_async_client(_upload()))
         self.pretty_result(result)

navcli/cli/commands/navigation.py

@@ -17,7 +17,7 @@ class NavigationCommands(BaseBrowserCommand):
 
     @cmd2.with_argparser(_goto_parser)
     def do_goto(self, args):
-        """Navigate to a URL.
+        """Navigate to a URL and show page summary.
 
         Usage: goto <url>
         Example: goto https://example.com
@@ -28,9 +28,17 @@ class NavigationCommands(BaseBrowserCommand):
             url = "https://" + url
 
         async def _goto():
-            return await self.client.goto(url)
-
-        result = asyncio.run(self.run_async_client(_goto))
+            # Navigate first
+            result = await self.client.goto(url)
+            # Then get paragraphs and merge into state
+            para_result = await self.client.get_paragraphs(min_length=200)
+            if para_result.get("success") and result.get("success"):
+                # Extract paragraphs from state and merge
+                para_data = para_result.get("state", {}).get("paragraphs", [])
+                result["state"]["paragraphs"] = para_data
+            return result
+
+        result = asyncio.run(self.run_async_client(_goto()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -44,7 +52,7 @@ class NavigationCommands(BaseBrowserCommand):
         async def _back():
             return await self.client.back()
 
-        result = asyncio.run(self.run_async_client(_back))
+        result = asyncio.run(self.run_async_client(_back()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -58,7 +66,7 @@ class NavigationCommands(BaseBrowserCommand):
         async def _forward():
             return await self.client.forward()
 
-        result = asyncio.run(self.run_async_client(_forward))
+        result = asyncio.run(self.run_async_client(_forward()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -72,7 +80,7 @@ class NavigationCommands(BaseBrowserCommand):
         async def _reload():
             return await self.client.reload()
 
-        result = asyncio.run(self.run_async_client(_reload))
+        result = asyncio.run(self.run_async_client(_reload()))
         self.pretty_result(result)
 
     # Aliases
@@ -80,11 +88,25 @@ class NavigationCommands(BaseBrowserCommand):
     do_f = do_forward  # forward -> f
     do_r = do_reload  # reload -> r
 
-    # goto -> g (requires separate parser)
+    # goto -> g (shortcut with same logic as do_goto)
     @cmd2.with_argparser(_goto_parser)
     def do_g(self, args):
         """Navigate to a URL (shortcut).
 
         Usage: g <url>
         """
-        return self.do_goto(args)
+        import asyncio
+        url = args.url
+        if not url.startswith(("http://", "https://")):
+            url = "https://" + url
+
+        async def _goto():
+            result = await self.client.goto(url)
+            para_result = await self.client.get_paragraphs(min_length=200)
+            if para_result.get("success") and result.get("success"):
+                para_data = para_result.get("state", {}).get("paragraphs", [])
+                result["state"]["paragraphs"] = para_data
+            return result
+
+        result = asyncio.run(self.run_async_client(_goto()))
+        self.pretty_result(result)

navcli/cli/commands/query.py

@@ -27,7 +27,7 @@ class QueryCommands(BaseBrowserCommand):
         async def _elements():
             return await self.client.get_elements()
 
-        result = asyncio.run(self.run_async_client(_elements))
+        result = asyncio.run(self.run_async_client(_elements()))
         self.pretty_result(result)
         if result.get("success"):
             state = result.get("state", {})
@@ -48,7 +48,7 @@ class QueryCommands(BaseBrowserCommand):
         async def _text():
             return await self.client.get_text()
 
-        result = asyncio.run(self.run_async_client(_text))
+        result = asyncio.run(self.run_async_client(_text()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -62,7 +62,7 @@ class QueryCommands(BaseBrowserCommand):
         async def _html():
             return await self.client.get_html()
 
-        result = asyncio.run(self.run_async_client(_html))
+        result = asyncio.run(self.run_async_client(_html()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -79,7 +79,7 @@ class QueryCommands(BaseBrowserCommand):
         async def _screenshot():
             return await self.client.get_screenshot()
 
-        result = asyncio.run(self.run_async_client(_screenshot))
+        result = asyncio.run(self.run_async_client(_screenshot()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -93,7 +93,7 @@ class QueryCommands(BaseBrowserCommand):
         async def _state():
             return await self.client.get_state()
 
-        result = asyncio.run(self.run_async_client(_state))
+        result = asyncio.run(self.run_async_client(_state()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -107,7 +107,7 @@ class QueryCommands(BaseBrowserCommand):
         async def _url():
             return await self.client.get_url()
 
-        result = asyncio.run(self.run_async_client(_url))
+        result = asyncio.run(self.run_async_client(_url()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -121,7 +121,7 @@ class QueryCommands(BaseBrowserCommand):
         async def _title():
             return await self.client.get_title()
 
-        result = asyncio.run(self.run_async_client(_title))
+        result = asyncio.run(self.run_async_client(_title()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(_evaluate_parser)
@@ -137,7 +137,7 @@ class QueryCommands(BaseBrowserCommand):
         async def _evaluate():
             return await self.client.evaluate(args.expression)
 
-        result = asyncio.run(self.run_async_client(_evaluate))
+        result = asyncio.run(self.run_async_client(_evaluate()))
         self.pretty_result(result)
 
     @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
@@ -151,7 +151,7 @@ class QueryCommands(BaseBrowserCommand):
         async def _links():
             return await self.client.get_links()
 
-        result = asyncio.run(self.run_async_client(_links))
+        result = asyncio.run(self.run_async_client(_links()))
         self.pretty_result(result)
         if result.get("success"):
             state = result.get("state", {})
@@ -167,5 +167,49 @@ class QueryCommands(BaseBrowserCommand):
         async def _forms():
             return await self.client.get_forms()
 
-        result = asyncio.run(self.run_async_client(_forms))
+        result = asyncio.run(self.run_async_client(_forms()))
         self.pretty_result(result)
+
+    @cmd2.with_argparser(cmd2.Cmd2ArgumentParser())
+    def do_tables(self, _):
+        """Get all tables on the page with their data.
+
+        Usage: tables
+        """
+        import asyncio
+
+        async def _tables():
+            return await self.client.get_tables()
+
+        result = asyncio.run(self.run_async_client(_tables()))
+        self.pretty_result(result)
+        if result.get("success"):
+            state = result.get("state", {})
+            tables = state.get("tables", [])
+            for t in tables:
+                self.poutput(f"  Table: {t.get('id', 'N/A')} - {t.get('rowCount', 0)} rows")
+
+    _paragraphs_parser = cmd2.Cmd2ArgumentParser()
+    _paragraphs_parser.add_argument("min_length", nargs="?", type=int, default=200,
+                                   help="Minimum paragraph length (default: 200)")
+
+    @cmd2.with_argparser(_paragraphs_parser)
+    def do_paragraphs(self, args):
+        """Get large text paragraphs (200+ chars) from the page.
+
+        Useful for extracting article content, policy documents, etc.
+
+        Usage: paragraphs [min_length]
+        Example: paragraphs
+        Example: paragraphs 500
+        """
+        import asyncio
+
+        async def _paragraphs():
+            return await self.client.get_paragraphs(min_length=args.min_length)
+
+        result = asyncio.run(self.run_async_client(_paragraphs()))
+        self.pretty_result(result)
+        if result.get("success"):
+            state = result.get("state", {})
+            # Paragraphs are included in the feedback.result info

navcli/core/models/__init__.py

@@ -2,7 +2,7 @@
 
 from .element import Element
 from .dom import DOMTree, DOMChange
-from .state import StateSnapshot
+from .state import StateSnapshot, Paragraph
 from .feedback import CommandResult, Feedback
 
 __all__ = [
@@ -10,6 +10,7 @@ __all__ = [
     'DOMTree',
     'DOMChange',
     'StateSnapshot',
+    'Paragraph',
     'CommandResult',
     'Feedback',
 ]

navcli/core/models/state.py

@@ -1,11 +1,20 @@
 """StateSnapshot model for page state."""
 
-from typing import Optional
+from typing import Optional, List, Dict, Any
 from pydantic import BaseModel, Field
 
 from .dom import DOMTree
 
 
+class Paragraph(BaseModel):
+    """Represents a large text paragraph."""
+
+    index: int = 0
+    text: str = ""
+    length: int = 0
+    selector: str = ""
+
+
 class StateSnapshot(BaseModel):
     """Represents the current page state."""
 
@@ -15,5 +24,7 @@ class StateSnapshot(BaseModel):
     variables: dict = Field(default_factory=dict)  # page variables
     loading: bool = False          # is still loading
     network_idle: bool = True      # network is idle
-    dom_stable: bool = True       # DOM is stable
-    pending_requests: int = 0     # pending request count
+    dom_stable: bool = True        # DOM is stable
+    pending_requests: int = 0      # pending request count
+    tables: List[Dict[str, Any]] = Field(default_factory=list)  # extracted tables
+    paragraphs: List[Paragraph] = Field(default_factory=list)  # extracted paragraphs

navcli/server/__init__.py

@@ -1,6 +1,7 @@
 """NavCLI Browser Server."""
 
 import asyncio
+import os
 import signal
 import sys
 from typing import Optional
@@ -13,16 +14,21 @@ from navcli.server.browser import start_browser, close_browser
 
 __version__ = "0.1.0"
 
+# Session directory
+_NAVCLI_HOME = os.path.expanduser("~/.navcli")
+_NAVCLI_SESSIONS_DIR = os.path.join(_NAVCLI_HOME, "sessions")
+
 # Server instance
 _server: Optional[uvicorn.Server] = None
 
 
-async def start_server(host: str = "127.0.0.1", port: int = 8765) -> uvicorn.Server:
+async def start_server(host: str = "127.0.0.1", port: int = 8765, headless: bool = True) -> uvicorn.Server:
     """Start the browser server.
 
     Args:
         host: Host to bind
         port: Port to listen
+        headless: Run browser in headless mode (default: True)
 
     Returns:
         Uvicorn server instance
@@ -30,7 +36,7 @@ async def start_server(host: str = "127.0.0.1", port: int = 8765) -> uvicorn.Ser
     global _server
 
     # Start browser
-    await start_browser()
+    await start_browser(headless=headless)
 
     # Create app
     app = create_app()
@@ -65,17 +71,53 @@ async def shutdown():
 def main():
     """Main entry point for nav-server command."""
     import argparse
+    import os
 
     parser = argparse.ArgumentParser(description="NavCLI Browser Server")
     parser.add_argument("--host", default="127.0.0.1", help="Host to bind")
     parser.add_argument("--port", type=int, default=8765, help="Port to listen")
+    parser.add_argument("--headless", action="store_true", default=True,
+                        help="Run in headless mode (default)")
+    parser.add_argument("--no-headless", dest="headless", action="store_false",
+                        help="Run with GUI (non-headless)")
 
     args = parser.parse_args()
 
     print(f"Starting NavCLI Browser Server on {args.host}:{args.port}...")
+    print(f"Headless: {args.headless}")
+    print("-" * 60)
+
+    if args.headless:
+        # Headless mode: check for saved session
+        session_files = []
+        if os.path.isdir(_NAVCLI_SESSIONS_DIR):
+            session_files = [f[:-5] for f in os.listdir(_NAVCLI_SESSIONS_DIR) if f.endswith('.json')]
+
+        if session_files:
+            print(f"Saved sessions in {_NAVCLI_SESSIONS_DIR}:")
+            for f in session_files:
+                print(f"  - {f}")
+            print("\nTo load a session:")
+            print('  curl -X POST "http://localhost:8765/cmd/session/load?name=<name>"')
+            print('  nav load_session <name>')
+        else:
+            print("No saved sessions found.")
+        print("\nTo save a session after manual login:")
+        print('  curl -X POST "http://localhost:8765/cmd/session/save?name=<name>"')
+        print('  nav save_session <name>')
+    else:
+        # No-headless mode: remind to save session
+        print("Human-in-the-loop mode: browser window will open")
+        print("1. Manually log in to the website")
+        print("\nWARNING: Session will be LOST when browser closes!")
+        print("Before closing, save your session:")
+        print('  curl -X POST "http://localhost:8765/cmd/session/save?name=<name>"')
+        print('  nav save_session <name>')
+
+    print("-" * 60)
 
     try:
-        asyncio.run(start_server(args.host, args.port))
+        asyncio.run(start_server(args.host, args.port, headless=args.headless))
     except KeyboardInterrupt:
         print("\nShutting down...")
         sys.exit(0)

navcli/server/browser.py

@@ -19,20 +19,49 @@ _context: Optional[BrowserContext] = None
 _page: Optional[Page] = None
 _last_html: Optional[str] = None  # 上一次 HTML 用于 diff
 _dom_version: int = 0
-_storage_state_path: str = ".navcli_session.json"  # 默认会话文件路径  # DOM 版本号
+# Default session directory
+_NAVCLI_HOME = os.path.expanduser("~/.navcli")
+_NAVCLI_SESSIONS_DIR = os.path.join(_NAVCLI_HOME, "sessions")
+_storage_state_path: str = os.path.join(_NAVCLI_SESSIONS_DIR, "session.json")  # Default session file
 
 
-async def start_browser():
-    """Start the browser."""
+async def start_browser(headless: bool = True):
+    """Start the browser.
+
+    Args:
+        headless: Whether to run in headless mode (default: True)
+    """
     global _browser, _context, _page
 
     if _browser is not None:
         return
 
     playwright = await async_playwright().start()
-    _browser = await playwright.chromium.launch(headless=True)
-    _context = await _browser.new_context()
-    _page = await _context.new_page()
+
+    # Support custom browser and user data via environment variables
+    executable_path = os.environ.get("PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH")
+    user_data_dir = os.environ.get("NAVCLI_USER_DATA_DIR")
+
+    launch_kwargs = {"headless": headless}
+    if executable_path:
+        launch_kwargs["executable_path"] = executable_path
+
+    if user_data_dir:
+        # Use persistent context with user data directory
+        context_kwargs = {
+            "user_data_dir": user_data_dir,
+            "headless": headless,
+        }
+        if executable_path:
+            context_kwargs["executable_path"] = executable_path
+        context = await playwright.chromium.launch_persistent_context(**context_kwargs)
+        _page = context.pages[0] if context.pages else None
+        _browser = context.browser
+        _context = context
+    else:
+        _browser = await playwright.chromium.launch(**launch_kwargs)
+        _context = await _browser.new_context()
+        _page = await _context.new_page()
 
 
 async def close_browser():
@@ -58,7 +87,7 @@ async def save_session(path: str = None) -> Dict[str, Any]:
     """Save session (cookies, localStorage, sessionStorage) to file.
 
     Args:
-        path: Path to save session file (default: .navcli_session.json)
+        path: Path to save session file (default: ~/.navcli/sessions/session.json)
 
     Returns:
         Session data dict
@@ -70,6 +99,12 @@ async def save_session(path: str = None) -> Dict[str, Any]:
 
     if path:
         _storage_state_path = path
+    else:
+        # Use default path
+        _storage_state_path = os.path.join(_NAVCLI_SESSIONS_DIR, "session.json")
+
+    # Ensure directory exists
+    os.makedirs(os.path.dirname(_storage_state_path), exist_ok=True)
 
     # Get storage state from Playwright
     storage_state = await _context.storage_state()
@@ -202,7 +237,7 @@ async def wait_for_network_idle(timeout: float = 3.0) -> bool:
         return False
 
 
-def extract_interactive_elements(page: Page) -> list[Element]:
+async def extract_interactive_elements(page: Page) -> list[Element]:
     """Extract interactive elements from the page.
 
     Only returns "actionable + meaningful" elements:
@@ -227,19 +262,22 @@ def extract_interactive_elements(page: Page) -> list[Element]:
     for selector in selectors:
         try:
             locators = page.locator(selector)
-            count = locators.count()
+            count = await locators.count()
             for i in range(count):
                 locator = locators.nth(i)
                 try:
+                    tag = selector.split("[")[0].lower()
+                    is_clickable = selector not in ("input", "select", "textarea", "h1", "h2", "h3", "nav", "menu")
+
                     element = Element(
-                        selector=_generate_selector(page, locator),
-                        tag=selector.split("[")[0].lower(),
-                        text=locator.inner_text().strip()[:200],
-                        clickable=selector not in ("input", "select", "textarea", "h1", "h2", "h3", "nav", "menu"),
+                        selector=await _generate_selector(page, locator),
+                        tag=tag,
+                        text=(await locator.inner_text()).strip()[:200],
+                        clickable=is_clickable,
                         input=selector.startswith("input") or selector == "textarea",
-                        type=locator.get_attribute("type") if selector.startswith("input") else None,
-                        href=locator.get_attribute("href") if selector.startswith("a") else None,
-                        alt=locator.get_attribute("alt") if selector.startswith("img") else None,
+                        type=await locator.get_attribute("type") if selector.startswith("input") else None,
+                        href=await locator.get_attribute("href") if selector.startswith("a") else None,
+                        alt=await locator.get_attribute("alt") if selector.startswith("img") else None,
                     )
                     elements.append(element)
                 except Exception:
@@ -250,18 +288,19 @@ def extract_interactive_elements(page: Page) -> list[Element]:
     return elements
 
 
-def _generate_selector(page: Page, locator) -> str:
+async def _generate_selector(page: Page, locator) -> str:
     """Generate a unique selector for an element."""
     try:
         # Try to get id first
-        element_id = locator.get_attribute("id")
+        element_id = await locator.get_attribute("id")
         if element_id:
-            tag = locator.evaluate_handle("el => el.tagName").lower()
+            tag = (await locator.evaluate_handle("el => el.tagName")).lower()
             return f"#{element_id}"
 
         # Try to get nth-child selector
-        tag = locator.evaluate_handle("el => el.tagName").lower()
-        return f"{tag}:nth-child({locator.evaluate_handle('el => {let i=0; let p=el; while(p){i++; p=p.previousElementSibling;} return i;}')})"
+        tag = (await locator.evaluate_handle("el => el.tagName")).lower()
+        nth = await locator.evaluate_handle('el => {let i=0; let p=el; while(p){i++; p=p.previousElementSibling;} return i;}')
+        return f"{tag}:nth-child({nth})"
     except Exception:
         return ""
 
@@ -320,7 +359,7 @@ async def get_current_state(use_diff: bool = True) -> StateSnapshot:
     title = await page.title()
 
     # Extract elements
-    elements = extract_interactive_elements(page)
+    elements = await extract_interactive_elements(page)
 
     # Get HTML
     current_html = await page.content()

navcli/server/routes/explore.py

@@ -9,7 +9,7 @@ from navcli.core.models import CommandResult, Feedback, Element
 from navcli.server.browser import get_page, get_current_state, start_browser, wait_for_network_idle
 from navcli.utils import wait_for_condition
 
-router = APIRouter()
+router = APIRouter(prefix="/explore")
 
 
 class FindRequest(BaseModel):

navcli/server/routes/query.py

@@ -1,14 +1,12 @@
 """Query routes: elements, text, html, screenshot, state."""
 
-from typing import Optional, List
-from fastapi import APIRouter, HTTPException
-from pydantic import BaseModel
+from fastapi import APIRouter
 
-from navcli.core.models import CommandResult, Feedback
+from navcli.core.models import CommandResult, Feedback, Paragraph
 from navcli.server.browser import get_page, get_current_state, start_browser
 from navcli.utils import encode_screenshot
 
-router = APIRouter()
+router = APIRouter(prefix="/query")
 
 
 @router.get("/elements")
@@ -62,8 +60,118 @@ async def get_text() -> CommandResult:
         )
 
 
-class TextRequest(BaseModel):
-    selectors: Optional[List[str]] = None
+@router.get("/paragraphs")
+async def get_paragraphs(min_length: int = 200) -> CommandResult:
+    """Get large text paragraphs (200+ chars) from the page.
+
+    Useful for extracting article content, policy documents, etc.
+
+    Args:
+        min_length: Minimum paragraph length in characters (default: 200)
+
+    Returns:
+        List of paragraphs with their text, length, and CSS selector
+    """
+    try:
+        page = get_page()
+
+        # Extract paragraphs and large text blocks using JavaScript
+        paragraphs_data = await page.evaluate(f"""
+            () => {{
+                const MIN_LENGTH = {min_length};
+                const results = [];
+
+                // Get all paragraph-like elements
+                const selectors = [
+                    'p',
+                    'article',
+                    '[class*="content"]',
+                    '[class*="article"]',
+                    '[class*="text"]',
+                    '[class*="description"]',
+                    '[class*="detail"]',
+                    'div[class]'
+                ];
+
+                let index = 0;
+
+                // Helper to clean text
+                const cleanText = (text) => {{
+                    return text
+                        .replace(/\\s+/g, ' ')
+                        .replace(/[\\n\\r\\t]+/g, ' ')
+                        .trim();
+                }};
+
+                // Process each selector
+                for (const selector of selectors) {{
+                    const elements = document.querySelectorAll(selector);
+                    for (const el of elements) {{
+                        const text = cleanText(el.innerText);
+                        if (text.length >= MIN_LENGTH) {{
+                            // Generate a stable selector
+                            let cssSelector = '';
+                            if (el.id) {{
+                                cssSelector = '#' + el.id;
+                            }} else {{
+                                const path = [];
+                                let current = el;
+                                while (current && current !== document.body) {{
+                                    let part = current.tagName.toLowerCase();
+                                    if (current.className && typeof current.className === 'string') {{
+                                        part += '.' + current.className.split(' ').filter(c => c).join('.');
+                                    }}
+                                    path.unshift(part);
+                                    current = current.parentElement;
+                                }}
+                                cssSelector = path.join(' > ');
+                            }}
+
+                            // Avoid duplicates
+                            const exists = results.some(r => r.text === text);
+                            if (!exists) {{
+                                results.push({{
+                                    index: index++,
+                                    text: text.substring(0, 5000),  // Limit to 5000 chars
+                                    length: text.length,
+                                    selector: cssSelector
+                                }});
+                            }}
+                        }}
+                    }}
+                }}
+
+                // Sort by length descending
+                results.sort((a, b) => b.length - a.length);
+
+                return results;
+            }}
+        """)
+
+        paragraphs = [
+            Paragraph(**p) for p in paragraphs_data[:50]  # Limit to 50 paragraphs
+        ]
+
+        await start_browser()
+        state = await get_current_state()
+        # Add paragraphs to state
+        state.paragraphs = paragraphs
+
+        return CommandResult(
+            success=True,
+            command="paragraphs",
+            state=state,
+            feedback=Feedback(
+                action="got paragraphs",
+                result=f"found {len(paragraphs)} paragraphs (min {min_length} chars)",
+            ),
+        )
+    except Exception as e:
+        return CommandResult(
+            success=False,
+            command="paragraphs",
+            error=str(e),
+        )
 
 
 @router.get("/html")
@@ -301,3 +409,54 @@ async def get_forms() -> CommandResult:
             command="forms",
             error=str(e),
         )
+
+
+@router.get("/tables")
+async def get_tables() -> CommandResult:
+    """Get all tables on the page with their data."""
+    try:
+        await start_browser()
+        page = get_page()
+
+        tables = await page.evaluate("""
+            Array.from(document.querySelectorAll('table')).map(table => {
+                const rows = Array.from(table.querySelectorAll('tr')).map(tr => {
+                    const cells = Array.from(tr.querySelectorAll('td, th'));
+                    return cells.map(cell => cell.innerText.trim());
+                });
+                // Filter out empty rows
+                const dataRows = rows.filter(row => row.some(cell => cell.length > 0));
+                // Get table id and caption
+                const id = table.id || '';
+                const caption = table.querySelector('caption')?.innerText || '';
+                const headers = dataRows[0] || [];
+                return {
+                    id,
+                    caption,
+                    headers,
+                    rows: dataRows.slice(1),
+                    rowCount: dataRows.length - 1
+                };
+            }).filter(t => t.rowCount > 0)
+        """)
+
+        state = await get_current_state()
+        total_rows = sum(t['rowCount'] for t in tables)
+        # Add tables to state
+        state.tables = tables
+
+        return CommandResult(
+            success=True,
+            command="tables",
+            state=state,
+            feedback=Feedback(
+                action="got tables",
+                result=f"found {len(tables)} tables, {total_rows} rows total",
+            ),
+        )
+    except Exception as e:
+        return CommandResult(
+            success=False,
+            command="tables",
+            error=str(e),
+        )

navcli/server/routes/session.py

@@ -1,5 +1,6 @@
 """Session routes: cookies, save_session, load_session."""
 
+import os
 from typing import Optional, List, Dict, Any
 from fastapi import APIRouter, HTTPException, Query
 from pydantic import BaseModel
@@ -13,6 +14,10 @@ from navcli.server.browser import (
     load_session,
 )
 
+# Session directory
+_NAVCLI_HOME = os.path.expanduser("~/.navcli")
+_NAVCLI_SESSIONS_DIR = os.path.join(_NAVCLI_HOME, "sessions")
+
 router = APIRouter()
 
 
@@ -113,16 +118,28 @@ async def clear_cookies_route() -> CommandResult:
 
 
 @router.post("/session/save")
-async def save_session_route(path: str = Query(".navcli_session.json")) -> CommandResult:
+async def save_session_route(
+    path: str = Query(None),
+    name: str = Query(None),
+) -> CommandResult:
     """Save session to file.
 
     Saves cookies, localStorage, and sessionStorage to a JSON file.
 
     Args:
-        path: File path to save session (default: .navcli_session.json)
+        path: Full file path to save session
+        name: Session name (saves to ~/.navcli/sessions/<name>.json)
     """
     try:
-        storage_state = await save_session(path)
+        # Determine save path
+        if name:
+            save_path = os.path.join(_NAVCLI_SESSIONS_DIR, f"{name}.json")
+        elif path:
+            save_path = path
+        else:
+            save_path = os.path.join(_NAVCLI_SESSIONS_DIR, "session.json")
+
+        storage_state = await save_session(save_path)
 
         cookie_count = len(storage_state.get("cookies", []))
         origin_count = len(storage_state.get("origins", []))
@@ -132,7 +149,7 @@ async def save_session_route(path: str = Query(".navcli_session.json")) -> Comma
             command="save_session",
             feedback=Feedback(
                 action="saved session",
-                result=f"saved to {path}: {cookie_count} cookies, {origin_count} origins",
+                result=f"saved to {save_path}: {cookie_count} cookies, {origin_count} origins",
             ),
         )
     except Exception as e:
@@ -144,30 +161,42 @@ async def save_session_route(path: str = Query(".navcli_session.json")) -> Comma
 
 
 @router.post("/session/load")
-async def load_session_route(path: str = Query(".navcli_session.json")) -> CommandResult:
+async def load_session_route(
+    path: str = Query(None),
+    name: str = Query(None),
+) -> CommandResult:
     """Load session from file.
 
     Loads cookies, localStorage, and sessionStorage from a JSON file.
 
     Args:
-        path: File path to load session from (default: .navcli_session.json)
+        path: Full file path to load session from
+        name: Session name (loads from ~/.navcli/sessions/<name>.json)
     """
+    # Determine load path
+    if name:
+        load_path = os.path.join(_NAVCLI_SESSIONS_DIR, f"{name}.json")
+    elif path:
+        load_path = path
+    else:
+        load_path = os.path.join(_NAVCLI_SESSIONS_DIR, "session.json")
+
     try:
-        await load_session(path)
+        await load_session(load_path)
 
         return CommandResult(
             success=True,
             command="load_session",
             feedback=Feedback(
                 action="loaded session",
-                result=f"loaded session from {path}",
+                result=f"loaded session from {load_path}",
             ),
         )
     except FileNotFoundError:
         return CommandResult(
             success=False,
             command="load_session",
-            error=f"Session file not found: {path}",
+            error=f"Session file not found: {load_path}",
         )
     except Exception as e:
         return CommandResult(

navcli-0.2.0.dist-info/METADATA

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: navcli
+Version: 0.2.0
+Summary: 可交互、可探索的浏览器命令行工具，专为 AI Agent 设计
+Author: NavCLI Team
+License: MIT
+Project-URL: Homepage, https://github.com/navcli/navcli
+Project-URL: Repository, https://github.com/navcli/navcli
+Project-URL: Issues, https://github.com/navcli/navcli/issues
+Keywords: browser,cli,automation,ai-agent,playwright
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: playwright>=1.40.0
+Requires-Dist: cmd2>=2.4.0
+Requires-Dist: fastapi>=0.109.0
+Requires-Dist: uvicorn<1.0.0,>=0.25.0
+Requires-Dist: pydantic>=2.5.0
+Requires-Dist: cssify>=1.0.0
+Requires-Dist: aiohttp>=3.9.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: mypy>=1.8.0; extra == "dev"
+
+# NavCLI - Goals & Vision
+
+## Core Goal
+
+**Enable AI Agents to browse the web like humans.**
+
+Existing solutions (HTTP APIs, headless browser scripts, Playwright MCP) have limitations:
+- No support for JS-rendered SPAs
+- No session persistence
+- Lack of interactive exploration
+
+NavCLI's positioning: **An interactive, explorable browser CLI**
+
+## Core Value
+
+| Feature | What NavCLI Solves |
+|---------|-------------------|
+| JS Rendering | Full SPA support |
+| Session Persistence | Cookies, session maintained |
+| Interactive CLI | Agent can explore while operating |
+| Token Optimization | Lightweight elements + on-demand text/html |
+
+## Typical Workflow
+
+```bash
+> g https://example.com          # Navigate
+> elements                       # Observe interactive elements
+> c .btn-login                   # Click login
+> t #email "test@example.com"    # Type email
+> t #password "123456"           # Type password
+> c button[type="submit"]       # Submit
+> text                           # Confirm result
+```
+
+Agent can: **Navigate → Observe → Interact → Feedback → Continue**
+
+## Vision
+
+Become the **standard browser interaction layer** for AI Agents, enabling any Agent to control browsers via command-line interface:
+- Form filling, login authentication
+- Information scraping, content exploration
+- Complex multi-step business processes
+
+## Related Documentation
+
+- [PRD Product Requirements](./NAVCLI_PRD.md)

{navcli-0.1.0.dist-info → navcli-0.2.0.dist-info}/RECORD

@@ -1,30 +1,30 @@
 navcli/cli/__init__.py,sha256=SE3EeeJ5Hku0o_rbXHVG3cPDxZaLkrLVcH57wFJOtXI,117
-navcli/cli/app.py,sha256=wYEVsUjp4BE_MJDu2v75av1bT5x7EvF4_ssdpH2Q2VQ,3072
-navcli/cli/client.py,sha256=qYdMNMLnXlsMq0bkKJgAiXHpxnqTErehjAF0GRRAG7E,9138
+navcli/cli/app.py,sha256=39miSa9ae82UX76ZQYNTdxn6pw7DhJNHmI9XXbkF1hs,3340
+navcli/cli/client.py,sha256=m0AJw2cx7iZb35JJqREoXfu1iamgDWhPnGeGjm80k4E,10173
 navcli/cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 navcli/cli/commands/base.py,sha256=b8hsB43lUaD0b-5nErtunBGPOFPfKq_sdFEMmynjFRE,1596
-navcli/cli/commands/control.py,sha256=JbAUNXgxZFmEO96TbhtS2CHw2jH2HZUk3EOIU_RwUBY,3253
-navcli/cli/commands/explore.py,sha256=p1p4i2Z-GISmFIikdpQ0mEnpPArSKVA3OIo1Xu42Njg,3664
-navcli/cli/commands/interaction.py,sha256=39CSeWW-Sb_z1w3i2kkmvJ515DL7WLdJPGCwUpri4aQ,3701
-navcli/cli/commands/navigation.py,sha256=ksIyoaCFzkF076C4K8qbl4OI-15UWOjhd47Hm7dGAkI,2265
-navcli/cli/commands/query.py,sha256=zWp-tiCr6xGeIlrsaK1ufoBOTk5L5n8CzGtkIkcnRAs,4630
+navcli/cli/commands/control.py,sha256=72aQvPJfnihu15-HsAjKCkXQ1EXSXRDmqbRx_DjqyJQ,3274
+navcli/cli/commands/explore.py,sha256=UTqVk1_X9Jd_XPv7vTcB9upIO8Rl99nU5LeppvHHzcA,3676
+navcli/cli/commands/interaction.py,sha256=GtlCkq0irtJ_8CqGFbY7RXXmcTQonWrjlYgdQbXQlwc,3713
+navcli/cli/commands/navigation.py,sha256=CLHDGwC1_D78jp5vLURWXUtHdYXTCh0bBHFP8sP9_Uw,3341
+navcli/cli/commands/query.py,sha256=vhI8G3NRlNA-jfEnLFNPGxraoHyOTaPMk3akoB67TKM,6200
 navcli/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-navcli/core/models/__init__.py,sha256=-LEFzktT5xBaOMa_UXlNR_c0O9gVTfv5Bp-3IZb43Q4,295
+navcli/core/models/__init__.py,sha256=qcbXwqa5fQTpiYG6EmTTRRIJ28MqG5jueWqSXI-XrXs,323
 navcli/core/models/dom.py,sha256=vZzEpzLEOlCnUJWBWx0-gmHj8WBxorsnPsZJgUW3UOE,1160
 navcli/core/models/element.py,sha256=6L8PnY7h_-_MFweq6NU6gdG1g5_r_AHlW1bYTuUBNoM,747
 navcli/core/models/feedback.py,sha256=K67nc7fCiAAfeYKDppNEnHtM41fSdF-Ai7IMhvAv7PY,689
-navcli/core/models/state.py,sha256=iyn6GvGpONGRP6WwiE0PYird4owJleK03Gk-jWExfGg,657
-navcli/server/__init__.py,sha256=l7As1ZOyGRO_BX5agyhirw8XNm8Jc6qDez0ugAwXFoA,1795
+navcli/core/models/state.py,sha256=6TBh6zMX8uhBcFICNLFgJhPKLRbET47fjZTjvt3n0Hw,1002
+navcli/server/__init__.py,sha256=KUgDIwwAhzq-5UcUV8A2pcXW6AhPFy6mGFvFThTjvjs,3694
 navcli/server/app.py,sha256=zNWYPGRGVWmoyiZX1g9i6LNqSagJirwzEi8eqsYUUqs,1320
-navcli/server/browser.py,sha256=XEqTUFgw7fLQDIjdahYn1dDDu-IlpaggEiUbH5divjk,10604
+navcli/server/browser.py,sha256=LAOQO157dYO1YVQe88hAnFISK0nKkq8MP96N9BRjr3I,12115
 navcli/server/middleware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 navcli/server/routes/__init__.py,sha256=LCd1lCcBCqJmFchr9OTvKJvCTQNLETAljdPaou-fd3I,180
 navcli/server/routes/control.py,sha256=ysoszU2OjhVH4BW3oahJ5-28l3yheQ-vhdqI-I8EVEU,1071
-navcli/server/routes/explore.py,sha256=7leV1LgTLurqDnLIOhDJhA5XEEGBxHkUOV8SgHJxYxc,11862
+navcli/server/routes/explore.py,sha256=562B8DzcQhNCPwuZleOjn9edQ-rowMz7bBFWZYpCWpM,11879
 navcli/server/routes/interaction.py,sha256=Daq-6Rp7FlWjyMK-HHYGKwQLHDBYWzC0GLq1q346Zxw,8562
 navcli/server/routes/navigation.py,sha256=ZDcblrKnOTDn8aeBKwWgZYHQke6Hmrm_NNtTNSC3MQU,3440
-navcli/server/routes/query.py,sha256=Lgp9lA7lUgXsxvI_1G-fymkIkiCwKpTFOW7SB_NWVJk,7699
-navcli/server/routes/session.py,sha256=gzwQKm8CkJTXcm6-5IYfzm44JF50l7Vhk-0SaLAt754,4701
+navcli/server/routes/query.py,sha256=grKvUDnv7cQudwPx_OgQUgkwgABoqLvRVLQrZP7WyI4,13560
+navcli/server/routes/session.py,sha256=vRTwxg19fRu1ajzn4yyIAqbQJsnRIPAYQEMae-pQQ6E,5480
 navcli/utils/__init__.py,sha256=g3CIjq_xybpmanja9A7oyQMtf9emS6qdHJIJ6BJx6t0,521
 navcli/utils/image.py,sha256=e30zNrOd3wi9UWesiQZJ5n62wIOfrGZnJFCMFKnFOD0,681
 navcli/utils/js.py,sha256=-OenTrj4Nh4s-zjUvjJnN3XSncX8b03tNrgY_nhPRxo,334
@@ -32,8 +32,8 @@ navcli/utils/selector.py,sha256=E_8E5bjjL1gDn524l3bH3XzK3egn9IyoYEb7zXsTwTQ,2146
 navcli/utils/text.py,sha256=wCFCKCn6Ibi8GjAeGXBHT5CfS8BCs7X9qVxDq4eR1tE,389
 navcli/utils/time.py,sha256=bAjJ59rp02MkIfoCT1TzmFd_oGaGlOI-5RPiKSqT-kI,1181
 navcli/utils/url.py,sha256=UG71w8ArYJlqjl2XslwAN-Kk9GJOPK3k5fg6CxXE5js,301
-navcli-0.1.0.dist-info/METADATA,sha256=WyNy3vFZJjHwSR5RYa6rQZYbMR5LhYbepmg4rkztBvA,2607
-navcli-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-navcli-0.1.0.dist-info/entry_points.txt,sha256=J26RwbEYUO5UbuhH0aXF_tvQFCOCatAR80blaSn5oWk,72
-navcli-0.1.0.dist-info/top_level.txt,sha256=dwTN5Lw7STNP3zhL2-RDElX3EslzM2sbYYLfuszQSO4,7
-navcli-0.1.0.dist-info/RECORD,,
+navcli-0.2.0.dist-info/METADATA,sha256=F_QRiKsOC_u0wEPncBydWEXfyZ4wnsBmL4lYG6lNsSY,2697
+navcli-0.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+navcli-0.2.0.dist-info/entry_points.txt,sha256=J26RwbEYUO5UbuhH0aXF_tvQFCOCatAR80blaSn5oWk,72
+navcli-0.2.0.dist-info/top_level.txt,sha256=dwTN5Lw7STNP3zhL2-RDElX3EslzM2sbYYLfuszQSO4,7
+navcli-0.2.0.dist-info/RECORD,,

navcli-0.1.0.dist-info/METADATA

@@ -1,79 +0,0 @@
-Metadata-Version: 2.4
-Name: navcli
-Version: 0.1.0
-Summary: 可交互、可探索的浏览器命令行工具，专为 AI Agent 设计
-Author: NavCLI Team
-License: MIT
-Project-URL: Homepage, https://github.com/navcli/navcli
-Project-URL: Repository, https://github.com/navcli/navcli
-Project-URL: Issues, https://github.com/navcli/navcli/issues
-Keywords: browser,cli,automation,ai-agent,playwright
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-Requires-Dist: playwright>=1.40.0
-Requires-Dist: cmd2>=2.4.0
-Requires-Dist: fastapi>=0.109.0
-Requires-Dist: uvicorn<1.0.0,>=0.25.0
-Requires-Dist: pydantic>=2.5.0
-Requires-Dist: cssify>=1.0.0
-Requires-Dist: aiohttp>=3.9.0
-Provides-Extra: dev
-Requires-Dist: pytest>=7.4.0; extra == "dev"
-Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
-Requires-Dist: ruff>=0.1.0; extra == "dev"
-Requires-Dist: mypy>=1.8.0; extra == "dev"
-
-# NavCLI - 目标与愿景
-
-## 核心目标
-
-**让 AI Agent 能够像人类一样浏览网页。**
-
-现有方案（HTTP API、无头浏览器脚本、Playwright MCP）存在局限：
-- 不支持 JS 渲染的 SPA
-- 无会话状态持久化
-- 缺乏交互式探索能力
-
-NavCLI 的定位：**可交互、可探索的浏览器命令行工具**
-
-## 核心价值
-
-| 特性 | NavCLI 解决的问题 |
-|------|------------------|
-| JS 渲染支持 | 完整支持 SPA 应用 |
-| 会话持久化 | cookies、session 保持 |
-| 交互式 CLI | Agent 可边探索边操作 |
-| Token 优化 | 轻量 elements + 按需 text/html |
-
-## 典型工作流
-
-```bash
-> g https://example.com          # 导航
-> elements                       # 查看可操作元素
-> c .btn-login                   # 点击登录
-> t #email "test@example.com"    # 输入邮箱
-> t #password "123456"           # 输入密码
-> c button[type="submit"]        # 提交
-> text                           # 确认结果
-```
-
-Agent 可以：**导航 → 观察 → 交互 → 反馈 → 继续**
-
-## 愿景
-
-成为 AI Agent 的**标准浏览器交互层**，让任何 Agent 都能通过命令式界面控制浏览器，完成：
-- 表单填写、登录认证
-- 信息抓取、内容探索
-- 复杂多步业务流程
-
-## 相关文档
-
-- [PRD 产品需求文档](./NAVCLI_PRD.md)