ntermqt 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

nterm/scripting/repl_interactive.py

@@ -7,11 +7,13 @@ Provides a safe, policy-controlled interface to network devices.
 Same interface used by both humans (IPython) and MCP tools.
 """
 
-from nterm.scripting.repl import NTermREPL, REPLPolicy
-from .api import NTermAPI
-from typing import Optional
 import sys
 import getpass
+import json
+from typing import Optional, Dict
+
+from .repl import NTermREPL, REPLPolicy
+from .api import NTermAPI
 
 
 def start_repl(api: Optional[NTermAPI] = None, policy: Optional[REPLPolicy] = None):
@@ -39,8 +41,8 @@ def start_repl(api: Optional[NTermAPI] = None, policy: Optional[REPLPolicy] = No
         api.repl(policy=policy)
     """
     if api is None:
-        from nterm.scripting import api as default_api
-        api = default_api
+        from .api import NTermAPI
+        api = NTermAPI()
 
     repl = NTermREPL(api=api, policy=policy)
 
@@ -67,7 +69,6 @@ def start_repl(api: Optional[NTermAPI] = None, policy: Optional[REPLPolicy] = No
             print(f"\n⚠️  TextFSM database seems small ({db_info.get('db_size_mb', 0):.1f} MB)")
             print(f"   Expected ~0.3 MB. Use :dbinfo to check.")
     except Exception:
-        # Don't crash startup if db_info fails
         pass
 
     print()
@@ -77,21 +78,13 @@ def start_repl(api: Optional[NTermAPI] = None, policy: Optional[REPLPolicy] = No
     # Interactive loop
     try:
         while True:
-            # Show prompt with mode indicator
-            if repl.state.connected_device:
-                mode_indicator = "📊" if repl.state.output_mode == "parsed" else "📄"
-                hint = f"[{repl.state.platform_hint}]" if repl.state.platform_hint else ""
-                prompt = f"{mode_indicator} {repl.state.connected_device}{hint}> "
-            else:
-                prompt = "nterm> "
+            prompt = _build_prompt(repl)
 
             try:
                 line = input(prompt)
             except EOFError:
-                # Ctrl+D
                 break
             except KeyboardInterrupt:
-                # Ctrl+C
                 print()
                 continue
 
@@ -99,185 +92,329 @@ def start_repl(api: Optional[NTermAPI] = None, policy: Optional[REPLPolicy] = No
             result = repl.handle_line(line)
 
             # Display result
-            if not result.get("ok"):
-                print(f"Error: {result.get('error')}")
-                continue
-
-            data = result.get("data", {})
-            cmd_type = data.get("type")
+            _display_result(repl, result)
 
-            if cmd_type == "exit":
+            # Check for exit
+            if result.get("ok") and result.get("data", {}).get("type") == "exit":
                 break
-            elif cmd_type == "unlock_prompt":
-                # Securely prompt for password
-                try:
-                    password = getpass.getpass("Enter vault password: ")
-                    unlock_result = repl.do_unlock(password)
-                    if unlock_result.get("ok"):
-                        unlock_data = unlock_result.get("data", {})
-                        if unlock_data.get("vault_unlocked"):
-                            print("Vault unlocked")
-                        else:
-                            print("Unlock failed - incorrect password")
-                    else:
-                        print(f"Error: {unlock_result.get('error')}")
-                except KeyboardInterrupt:
-                    print("\nUnlock cancelled")
-                    continue
-            elif cmd_type == "help":
-                print(data.get("text", ""))
-            elif cmd_type == "unlock":
-                status = "unlocked" if data.get("vault_unlocked") else "failed"
-                print(f"Vault: {status}")
-            elif cmd_type == "lock":
-                print("Vault locked")
-            elif cmd_type == "credentials":
-                creds = data.get("credentials", [])
-                if not creds:
-                    print("No credentials found")
-                else:
-                    print(f"\n{'Name':<20} {'Username':<20} {'Type':<15}")
-                    print("-" * 55)
-                    for cred in creds:
-                        print(f"{cred['name']:<20} {cred.get('username', ''):<20} {cred.get('cred_type', 'ssh'):<15}")
-                    print()
-            elif cmd_type == "devices":
-                devices = data.get("devices", [])
-                if not devices:
-                    print("No devices found")
-                else:
-                    print(f"\n{'Name':<20} {'Hostname':<20} {'Folder':<15}")
-                    print("-" * 55)
-                    for dev in devices:
-                        print(f"{dev['name']:<20} {dev['hostname']:<20} {dev.get('folder', ''):<15}")
-                    print()
-            elif cmd_type == "connect":
-                print(f"Connected to {data['device']} ({data['hostname']}:{data['port']})")
-                print(f"Platform: {data.get('platform', 'unknown')}")
-                print(f"Prompt: {data.get('prompt', '')}")
-            elif cmd_type == "disconnect":
-                print("Disconnected")
-            elif cmd_type == "policy":
-                print(f"Policy mode: {data.get('mode')}")
-            elif cmd_type == "mode":
-                mode = data.get('mode')
-                hint = data.get('platform_hint')
-                if mode:
-                    print(f"Output mode: {mode}")
-                else:
-                    print(f"Current mode: {mode}")
-                    if hint:
-                        print(f"Platform hint: {hint}")
-            elif cmd_type == "format":
-                fmt = data.get('format')
-                print(f"Output format: {fmt}")
-            elif cmd_type == "set_hint":
-                print(f"Platform hint set to: {data.get('platform_hint')}")
-            elif cmd_type == "clear_hint":
-                print("Platform hint cleared (using auto-detection)")
-            elif cmd_type == "debug":
-                status = "ON" if data.get("debug_mode") else "OFF"
-                print(f"Debug mode: {status}")
-            elif cmd_type == "dbinfo":
-                db_info = data.get("db_info", {})
-                print("\nTextFSM Database Info:")
-                print("=" * 60)
-                print(f"Engine Available:  {db_info.get('engine_available', False)}")
-                print(f"Database Path:     {db_info.get('db_path', 'unknown')}")
-                print(f"Database Exists:   {db_info.get('db_exists', False)}")
-
-                if db_info.get('db_exists'):
-                    db_size = db_info.get('db_size', 0)
-                    db_size_mb = db_info.get('db_size_mb', 0.0)
-                    print(f"Database Size:     {db_size:,} bytes ({db_size_mb:.1f} MB)")
-                    print(f"Absolute Path:     {db_info.get('db_absolute_path', 'unknown')}")
-
-                    # Health checks
-                    if db_size == 0:
-                        print("\n⚠️  WARNING: Database file is empty (0 bytes)!")
-                        print("   Parsing will fail until you download templates.")
-                        print("   Run: api.download_templates() or use the templates installer.")
-                    elif db_size < 100000:  # Less than 100KB
-                        print(f"\n⚠️  WARNING: Database seems too small ({db_size_mb:.1f} MB)")
-                        print("   Expected size is ~0.3 MB. May be corrupted or incomplete.")
-                    else:
-                        print("\n✓ Database appears healthy")
-                else:
-                    print("\n❌ ERROR: Database file not found!")
-                    print("   Run: api.download_templates() to create it.")
 
-                print()
-            elif cmd_type == "result":
-                result_data = data.get("result", {})
-
-                # Debug mode: show full result dict
-                if repl.state.debug_mode:
-                    print("\n[DEBUG - Full Result Dict]")
-                    print("-" * 60)
-                    import json
-                    # Don't print raw_output in debug to avoid clutter
-                    debug_data = {k: v for k, v in result_data.items() if k != "raw_output"}
-                    print(json.dumps(debug_data, indent=2))
-                    print("-" * 60)
-
-                # Show parsed data if available
-                parsed = result_data.get("parsed_data")
-                parse_success = result_data.get("parse_success", False)
-                platform = result_data.get("platform", "")
-
-                # Display based on mode and format
-                if repl.state.output_mode == "parsed":
-                    if parsed and parse_success:
-                        print(f"\n[Parsed with {platform} - format: {repl.state.output_format}]")
-                        print("-" * 60)
-                        _display_parsed_result(parsed, repl.state.output_format)
-                        print()
-                    elif parse_success and not parsed:
-                        # Parsing succeeded but returned empty/no data
-                        print(f"\n[Parsed with {platform} - no structured data]")
-                        raw = result_data.get("raw_output", "")
-                        print(raw)
-                    elif parsed is None and not parse_success:
-                        # Parsing failed or wasn't attempted
-                        print(f"\n[Parse failed - showing raw output]")
-                        raw = result_data.get("raw_output", "")
-                        print(raw)
-                    else:
-                        # Fallback
-                        raw = result_data.get("raw_output", "")
-                        print(raw)
+    finally:
+        # Clean up
+        count = repl.state.api.disconnect_all()
+        if count > 0:
+            print(f"\nDisconnected {count} session(s)")
+        print("REPL closed")
+
+
+def _build_prompt(repl: NTermREPL) -> str:
+    """Build the prompt string based on current state."""
+    if repl.state.connected_device:
+        mode_indicator = "📊" if repl.state.output_mode == "parsed" else "📄"
+        hint = f"[{repl.state.platform_hint}]" if repl.state.platform_hint else ""
+        return f"{mode_indicator} {repl.state.connected_device}{hint}> "
+    else:
+        return "nterm> "
+
+
+def _display_result(repl: NTermREPL, result: Dict) -> None:
+    """Display REPL result based on type."""
+    if not result.get("ok"):
+        print(f"Error: {result.get('error')}")
+        return
+
+    data = result.get("data", {})
+    cmd_type = data.get("type")
+
+    # ===== Vault Commands =====
+    if cmd_type == "unlock_prompt":
+        try:
+            password = getpass.getpass("Enter vault password: ")
+            unlock_result = repl.do_unlock(password)
+            if unlock_result.get("ok"):
+                if unlock_result.get("data", {}).get("vault_unlocked"):
+                    print("✓ Vault unlocked")
                 else:
-                    # Raw mode - just show output
-                    raw = result_data.get("raw_output", "")
-                    print(raw)
-
-                # Show timing
-                elapsed = result_data.get("elapsed_seconds", 0)
-                print(f"\n[{elapsed}s]")
-            elif cmd_type == "noop":
-                pass
+                    print("✗ Unlock failed - incorrect password")
             else:
-                # Unknown type, show raw data
-                import json
-                print(json.dumps(data, indent=2))
+                print(f"Error: {unlock_result.get('error')}")
+        except KeyboardInterrupt:
+            print("\nUnlock cancelled")
+        return
+
+    if cmd_type == "unlock":
+        status = "unlocked" if data.get("vault_unlocked") else "failed"
+        print(f"Vault: {status}")
+        return
+
+    if cmd_type == "lock":
+        print("✓ Vault locked")
+        return
+
+    # ===== Inventory Commands =====
+    if cmd_type == "credentials":
+        creds = data.get("credentials", [])
+        if not creds:
+            print("No credentials found")
+        else:
+            print(f"\n{'Name':<20} {'Username':<20} {'Auth':<15} {'Default':<8}")
+            print("-" * 63)
+            for cred in creds:
+                auth_types = []
+                if cred.get('has_password'):
+                    auth_types.append('pass')
+                if cred.get('has_key'):
+                    auth_types.append('key')
+                auth = '+'.join(auth_types) if auth_types else 'none'
+                default = '★' if cred.get('is_default') else ''
+                print(f"{cred['name']:<20} {cred.get('username', ''):<20} {auth:<15} {default:<8}")
+            print()
+        return
+
+    if cmd_type == "devices":
+        devices = data.get("devices", [])
+        if not devices:
+            print("No devices found")
+        else:
+            print(f"\n{'Name':<25} {'Hostname':<20} {'Port':<6} {'Folder':<15}")
+            print("-" * 66)
+            for dev in devices:
+                print(f"{dev['name']:<25} {dev['hostname']:<20} {dev.get('port', 22):<6} {dev.get('folder', ''):<15}")
+            print(f"\n{len(devices)} device(s)")
+        return
+
+    if cmd_type == "folders":
+        folders = data.get("folders", [])
+        if not folders:
+            print("No folders found")
+        else:
+            print("\nFolders:")
+            for f in sorted(folders):
+                print(f"  📁 {f}")
+            print()
+        return
+
+    # ===== Session Commands =====
+    if cmd_type == "connect":
+        print(f"✓ Connected to {data['device']} ({data['hostname']}:{data['port']})")
+        print(f"  Platform: {data.get('platform', 'unknown')}")
+        print(f"  Prompt: {data.get('prompt', '')}")
+        return
+
+    if cmd_type == "disconnect":
+        msg = data.get("message", "Disconnected")
+        print(f"✓ {msg}")
+        return
+
+    if cmd_type == "sessions":
+        sessions = data.get("sessions", [])
+        current = data.get("current")
+        if not sessions:
+            print("No active sessions")
+        else:
+            print(f"\n{'Device':<20} {'Hostname':<20} {'Platform':<15} {'Status':<10}")
+            print("-" * 65)
+            for s in sessions:
+                marker = "→ " if s['device'] == current else "  "
+                status = "connected" if s.get('connected') else "stale"
+                print(f"{marker}{s['device']:<18} {s['hostname']:<20} {s.get('platform', 'unknown'):<15} {status:<10}")
+            print()
+        return
+
+    # ===== Settings Commands =====
+    if cmd_type == "policy":
+        mode = data.get('mode')
+        emoji = "🔒" if mode == "read_only" else "⚡"
+        print(f"Policy mode: {emoji} {mode}")
+        return
+
+    if cmd_type == "mode":
+        mode = data.get('mode')
+        hint = data.get('platform_hint')
+        print(f"Output mode: {mode}")
+        if hint:
+            print(f"Platform hint: {hint}")
+        return
+
+    if cmd_type == "format":
+        print(f"Output format: {data.get('format')}")
+        return
+
+    if cmd_type == "set_hint":
+        print(f"✓ Platform hint set to: {data.get('platform_hint')}")
+        return
+
+    if cmd_type == "clear_hint":
+        print("✓ Platform hint cleared (using auto-detection)")
+        return
+
+    if cmd_type == "debug":
+        status = "ON" if data.get("debug_mode") else "OFF"
+        print(f"Debug mode: {status}")
+        return
+
+    # ===== Info Commands =====
+    if cmd_type == "dbinfo":
+        _display_dbinfo(data.get("db_info", {}))
+        return
+
+    if cmd_type == "help":
+        print(data.get("text", ""))
+        return
+
+    if cmd_type == "exit":
+        count = data.get("disconnected", 0)
+        if count > 0:
+            print(f"Disconnected {count} session(s)")
+        return
+
+    if cmd_type == "noop":
+        return
+
+    # ===== Quick Commands =====
+    if cmd_type == "version":
+        result_data = data.get("result", {})
+        version_info = result_data.get("version_info", {})
+
+        print(f"\n{'─' * 50}")
+        print(f"  Version:  {version_info.get('version', 'unknown')}")
+        print(f"  Hardware: {version_info.get('hardware', 'unknown')}")
+        print(f"  Serial:   {version_info.get('serial', 'unknown')}")
+        print(f"  Uptime:   {version_info.get('uptime', 'unknown')}")
+        print(f"{'─' * 50}")
+
+        elapsed = result_data.get("elapsed_seconds", 0)
+        print(f"[{elapsed}s]")
+        return
+
+    if cmd_type == "neighbors":
+        result_data = data.get("result", {})
+        neighbor_info = result_data.get("neighbor_info", [])
+
+        if not neighbor_info:
+            parsed = result_data.get("parsed_data", [])
+            if parsed:
+                # Fall back to raw parsed data
+                _display_parsed_result(parsed, repl.state.output_format)
+            else:
+                print("No neighbors found")
+        else:
+            print(f"\n{'Local Interface':<20} {'Neighbor':<30} {'Remote Port':<20} {'Platform':<20}")
+            print("-" * 90)
+            for n in neighbor_info:
+                print(f"{n.get('local_interface', 'unknown'):<20} "
+                      f"{n.get('neighbor_device', 'unknown'):<30} "
+                      f"{n.get('neighbor_interface', 'unknown'):<20} "
+                      f"{n.get('platform', '')[:20]:<20}")
+            print(f"\n{len(neighbor_info)} neighbor(s)")
+
+        elapsed = result_data.get("elapsed_seconds", 0)
+        print(f"[{elapsed}s]")
+        return
+
+    # ===== Generic Result =====
+    if cmd_type == "result":
+        result_data = data.get("result", {})
+        _display_command_result(repl, result_data)
+        return
+
+    # Unknown type - dump as JSON
+    print(json.dumps(data, indent=2))
+
+
+def _display_command_result(repl: NTermREPL, result_data: Dict) -> None:
+    """Display a generic command result."""
+    # Debug mode: show full result dict
+    if repl.state.debug_mode:
+        print("\n[DEBUG - Full Result Dict]")
+        print("-" * 60)
+        debug_data = {k: v for k, v in result_data.items() if k != "raw_output"}
+        print(json.dumps(debug_data, indent=2, default=str))
+        print("-" * 60)
+
+    parsed = result_data.get("parsed_data")
+    parse_success = result_data.get("parse_success", False)
+    platform = result_data.get("platform", "")
+    command_type = result_data.get("command_type", "")
+
+    # Display based on mode
+    if repl.state.output_mode == "parsed":
+        if parsed and parse_success:
+            header = f"[Parsed: {platform}"
+            if command_type:
+                header += f" | {command_type}"
+            header += f" | format: {repl.state.output_format}]"
+            print(f"\n{header}")
+            print("-" * 60)
+            _display_parsed_result(parsed, repl.state.output_format)
+            print()
+        elif parse_success and not parsed:
+            print(f"\n[Parsed: {platform} - no structured data]")
+            raw = result_data.get("raw_output", "")
+            print(raw)
+        elif not parse_success:
+            print(f"\n[Parse failed - showing raw output]")
+            raw = result_data.get("raw_output", "")
+            print(raw)
+        else:
+            raw = result_data.get("raw_output", "")
+            print(raw)
+    else:
+        # Raw mode
+        raw = result_data.get("raw_output", "")
+        print(raw)
+
+    # Show timing
+    elapsed = result_data.get("elapsed_seconds", 0)
+    print(f"\n[{elapsed}s]")
+
+
+def _display_dbinfo(db_info: Dict) -> None:
+    """Display TextFSM database info."""
+    print("\nTextFSM Database Info:")
+    print("=" * 60)
+    print(f"Engine Available:  {db_info.get('engine_available', False)}")
+    print(f"Database Path:     {db_info.get('db_path', 'unknown')}")
+    print(f"Database Exists:   {db_info.get('db_exists', False)}")
+
+    if db_info.get('db_exists'):
+        db_size = db_info.get('db_size', 0)
+        db_size_mb = db_info.get('db_size_mb', 0.0)
+        print(f"Database Size:     {db_size:,} bytes ({db_size_mb:.1f} MB)")
+        print(f"Absolute Path:     {db_info.get('db_absolute_path', 'unknown')}")
+
+        if db_size == 0:
+            print("\n⚠️  WARNING: Database file is empty (0 bytes)!")
+            print("   Parsing will fail until you download templates.")
+        elif db_size < 100000:
+            print(f"\n⚠️  WARNING: Database seems too small ({db_size_mb:.1f} MB)")
+            print("   Expected size is ~0.3 MB. May be corrupted or incomplete.")
+        else:
+            print("\n✓ Database appears healthy")
+    else:
+        print("\n✗ ERROR: Database file not found!")
+        print("   Run: api.download_templates() to create it.")
+
+    print()
 
-    finally:
-        # Clean up
-        if repl.state.session:
-            print("\nDisconnecting...")
-            repl._safe_disconnect()
-        print("\nREPL closed")
+
+def _display_parsed_result(data, output_format: str, max_rows: int = 20) -> None:
+    """Display parsed data in the specified format."""
+    if output_format == "json":
+        print(json.dumps(data, indent=2, default=str))
+    elif output_format == "rich":
+        _print_parsed_data_rich(data, max_rows)
+    else:
+        _print_parsed_data_text(data, max_rows)
 
 
-def _print_parsed_data(data, max_rows=20):
-    """Pretty print parsed data (list of dicts) in text format."""
+def _print_parsed_data_text(data, max_rows: int = 20) -> None:
+    """Pretty print parsed data as text table."""
     if not data:
         print("(empty)")
         return
 
     if not isinstance(data, list):
-        import json
-        print(json.dumps(data, indent=2))
+        print(json.dumps(data, indent=2, default=str))
         return
 
     # Get all unique keys
@@ -289,14 +426,11 @@ def _print_parsed_data(data, max_rows=20):
     keys = sorted(all_keys)
 
     if not keys:
-        import json
-        print(json.dumps(data, indent=2))
+        print(json.dumps(data, indent=2, default=str))
         return
 
     # Calculate column widths
-    col_widths = {}
-    for key in keys:
-        col_widths[key] = len(key)
+    col_widths = {key: len(key) for key in keys}
 
     for row in data[:max_rows]:
         if isinstance(row, dict):
@@ -304,7 +438,7 @@ def _print_parsed_data(data, max_rows=20):
                 val = str(row.get(key, ""))
                 col_widths[key] = max(col_widths[key], len(val))
 
-    # Cap widths
+    # Cap widths at 30
     for key in keys:
         col_widths[key] = min(col_widths[key], 30)
 
@@ -334,14 +468,14 @@ def _print_parsed_data(data, max_rows=20):
         shown += 1
 
 
-def _print_parsed_data_rich(data, max_rows=20):
+def _print_parsed_data_rich(data, max_rows: int = 20) -> None:
     """Pretty print parsed data using Rich library."""
     try:
         from rich.console import Console
         from rich.table import Table
     except ImportError:
         print("⚠️  Rich library not available, falling back to text format")
-        _print_parsed_data(data, max_rows)
+        _print_parsed_data_text(data, max_rows)
         return
 
     if not data:
@@ -349,8 +483,7 @@ def _print_parsed_data_rich(data, max_rows=20):
         return
 
     if not isinstance(data, list):
-        import json
-        print(json.dumps(data, indent=2))
+        print(json.dumps(data, indent=2, default=str))
         return
 
     # Get all unique keys
@@ -362,19 +495,16 @@ def _print_parsed_data_rich(data, max_rows=20):
     keys = sorted(all_keys)
 
     if not keys:
-        import json
-        print(json.dumps(data, indent=2))
+        print(json.dumps(data, indent=2, default=str))
         return
 
     # Create rich table
     console = Console()
     table = Table(show_header=True, header_style="bold cyan")
 
-    # Add columns
     for key in keys:
         table.add_column(key, style="white", no_wrap=False, max_width=30)
 
-    # Add rows
     shown = 0
     for row in data:
         if not isinstance(row, dict):
@@ -391,28 +521,16 @@ def _print_parsed_data_rich(data, max_rows=20):
     console.print(table)
 
 
-def _print_parsed_data_json(data):
-    """Print parsed data as JSON."""
-    import json
-    print(json.dumps(data, indent=2))
-
-
-def _display_parsed_result(data, output_format, max_rows=20):
-    """Display parsed data in the specified format."""
-    if output_format == "json":
-        _print_parsed_data_json(data)
-    elif output_format == "rich":
-        _print_parsed_data_rich(data, max_rows)
-    else:  # text or fallback
-        _print_parsed_data(data, max_rows)
-
-
 # Convenience function to add to API
-def add_repl_to_api(api_instance):
+def add_repl_to_api(api_instance: NTermAPI) -> None:
     """Add repl() method to API instance."""
 
     def repl(policy: Optional[REPLPolicy] = None):
         """Start interactive REPL."""
         start_repl(api=api_instance, policy=policy)
 
-    api_instance.repl = repl
+    api_instance.repl = repl
+
+
+# Type hint for display function
+from typing import Dict