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

nterm/scripting/api.py

@@ -19,13 +19,16 @@ from .models import ActiveSession, CommandResult, DeviceInfo, CredentialInfo
 from .platform_data import INTERFACE_DETAIL_FIELD_MAP
 from .platform_utils import (
     detect_platform,
+    detect_platform_from_template,
+    extract_platform_from_template_name,
     normalize_fields,
     get_paging_disable_command,
     get_platform_command,
     extract_version_info,
     extract_neighbor_info,
+    try_disable_paging,
 )
-from .ssh_connection import connect_ssh, send_command
+from .ssh_connection import connect_ssh, send_command, PagingNotDisabledError
 
 # TextFSM parsing - REQUIRED
 try:
@@ -397,10 +400,21 @@ class NTermAPI:
             prompt=prompt,
         )
 
-        # Detect platform
+        # Pre-emptively try to disable paging BEFORE platform detection
+        # This prevents 'show version' from being truncated by --More--
+        # Use the most common command - harmless if it fails on non-Cisco platforms
+        try:
+            send_command(shell, "terminal length 0", prompt, timeout=5)
+            if debug:
+                print(f"[DEBUG] Pre-emptive paging disable: terminal length 0")
+        except Exception as e:
+            if debug:
+                print(f"[DEBUG] Pre-emptive paging disable failed (normal on some platforms): {e}")
+
+        # Detect platform using TextFSM template matching (primary) or regex (fallback)
         try:
             version_output = send_command(shell, "show version", prompt)
-            platform = detect_platform(version_output)
+            platform = detect_platform(version_output, tfsm_engine=self._tfsm_engine)
             session.platform = platform
             if debug:
                 print(f"[DEBUG] Platform detected: {platform}")
@@ -413,9 +427,13 @@ class NTermAPI:
         if paging_cmd:
             try:
                 send_command(shell, paging_cmd, prompt, timeout=5)
+                session._paging_disabled = True
             except Exception as e:
                 if debug:
                     print(f"[DEBUG] Failed to disable paging: {e}")
+        else:
+            # Platform unknown - will try to auto-fix if paging error occurs
+            session._paging_disabled = False
 
         self._active_sessions[device_name] = session
         return session
@@ -472,6 +490,7 @@ class NTermAPI:
         timeout: int = 60,
         parse: bool = True,
         normalize: bool = True,
+        _retry_after_paging_fix: bool = False,
     ) -> CommandResult:
         """
         Send command to a connected session.
@@ -482,6 +501,7 @@ class NTermAPI:
             timeout: Command timeout in seconds
             parse: Whether to attempt TextFSM parsing
             normalize: Whether to normalize field names (requires parse=True)
+            _retry_after_paging_fix: Internal flag to prevent infinite retry loops
 
         Returns:
             CommandResult with raw and parsed output
@@ -495,12 +515,62 @@ class NTermAPI:
             if result.parsed_data:
                 for row in result.parsed_data:
                     print(row)
+
+        Note:
+            If paging is detected (--More-- prompt), the API will automatically
+            try to disable paging and retry the command once.
         """
         if not session.is_connected():
             raise RuntimeError(f"Session {session.device_name} is not connected")
 
         # Execute command using our refactored module
-        raw_output = send_command(session.shell, command, session.prompt, timeout)
+        try:
+            raw_output = send_command(session.shell, command, session.prompt, timeout)
+        except PagingNotDisabledError as e:
+            # Auto-recovery: try to disable paging and retry
+            if _retry_after_paging_fix:
+                # Already tried once, don't loop forever
+                raise RuntimeError(
+                    f"Paging still not disabled after auto-fix attempt. "
+                    f"Original error: {e}"
+                )
+
+            # Try to disable paging with multiple commands
+            print(f"[AUTO-FIX] Paging detected, attempting to disable...")
+
+            # Send Ctrl+C to break out of --More-- prompt
+            try:
+                session.shell.send('\x03')  # Ctrl+C
+                import time
+                time.sleep(0.5)
+                # Clear any pending output
+                while session.shell.recv_ready():
+                    session.shell.recv(65536)
+            except Exception:
+                pass
+
+            # Try multiple paging disable commands
+            success = try_disable_paging(
+                session.shell,
+                session.prompt,
+                send_command,
+                debug=True,
+            )
+
+            if success:
+                session._paging_disabled = True
+                print(f"[AUTO-FIX] Paging disabled, retrying command...")
+                # Retry the original command
+                return self.send(
+                    session, command, timeout, parse, normalize,
+                    _retry_after_paging_fix=True
+                )
+            else:
+                raise RuntimeError(
+                    f"Failed to auto-disable paging. "
+                    f"Tried multiple commands but none succeeded. "
+                    f"Original error: {e}"
+                )
 
         # Create result object
         result = CommandResult(
@@ -655,16 +725,22 @@ class NTermAPI:
         Disconnect a session.
 
         Args:
-            session: ActiveSession to close
+            session: ActiveSession to disconnect
         """
         if session.device_name in self._active_sessions:
             del self._active_sessions[session.device_name]
 
-        if session.shell:
-            session.shell.close()
+        try:
+            if session.shell:
+                session.shell.close()
+        except Exception:
+            pass
 
-        if session.client:
-            session.client.close()
+        try:
+            if session.client:
+                session.client.close()
+        except Exception:
+            pass
 
     def disconnect_all(self) -> int:
         """
@@ -674,60 +750,48 @@ class NTermAPI:
             Number of sessions disconnected
 
         Example:
-            # Cleanup at end of script
+            # At end of script or in finally block
             count = api.disconnect_all()
             print(f"Disconnected {count} session(s)")
         """
-        count = 0
-        for session_id in list(self._active_sessions.keys()):
+        count = len(self._active_sessions)
+
+        for session in list(self._active_sessions.values()):
             try:
-                session = self._active_sessions[session_id]
                 self.disconnect(session)
-                count += 1
             except Exception:
                 pass
+
+        self._active_sessions.clear()
         return count
 
     def active_sessions(self) -> List[ActiveSession]:
         """
-        Get list of currently active sessions.
+        List all active sessions.
 
         Returns:
             List of ActiveSession objects
         """
-        # Clean up stale sessions
-        active = []
-        stale = []
-
-        for session_id, session in self._active_sessions.items():
-            if session.is_connected():
-                active.append(session)
-            else:
-                stale.append(session_id)
-
-        # Remove stale entries
-        for session_id in stale:
-            del self._active_sessions[session_id]
-
-        return active
+        return list(self._active_sessions.values())
 
     # -------------------------------------------------------------------------
-    # Debug / diagnostic methods
+    # Diagnostics
     # -------------------------------------------------------------------------
 
     def db_info(self) -> Dict[str, Any]:
         """
-        Get detailed information about TextFSM database.
+        Get information about the TextFSM database.
 
         Returns:
-            Dict with database path, existence, and diagnostic info
+            Dict with db_path, db_exists, db_size, db_size_mb, etc.
         """
         info = {
-            "engine_available": self._tfsm_engine is not None,
+            "engine_initialized": self._tfsm_engine is not None,
             "db_path": None,
             "db_exists": False,
+            "db_size": None,
+            "db_size_mb": None,
             "db_absolute_path": None,
-            "current_working_directory": os.getcwd(),
         }
 
         if self._tfsm_engine and hasattr(self._tfsm_engine, 'db_path'):
@@ -816,6 +880,90 @@ class NTermAPI:
 
         return debug_info
 
+    def detect_platform_from_output(
+        self,
+        output: str,
+        min_score: float = 50.0,
+    ) -> Dict[str, Any]:
+        """
+        Detect platform from command output using TextFSM template matching.
+
+        This is the same method used internally during connect() for platform
+        detection. Useful for testing and debugging.
+
+        Args:
+            output: Raw command output (typically from 'show version')
+            min_score: Minimum match score to accept (default 50.0)
+
+        Returns:
+            Dict with:
+            - platform: Detected platform string or None
+            - template: Best matching template name
+            - score: Match confidence score
+            - method: 'textfsm' or 'regex' or 'none'
+            - parsed_data: Parsed data from template if available
+
+        Example:
+            >>> result = api.send(session, "show version", parse=False)
+            >>> api.detect_platform_from_output(result.raw_output)
+            {
+                'platform': 'cisco_ios',
+                'template': 'cisco_ios_show_version',
+                'score': 95.83,
+                'method': 'textfsm',
+                'parsed_data': [{'VERSION': '15.2(4)M11', ...}]
+            }
+        """
+        result = {
+            "platform": None,
+            "template": None,
+            "score": 0.0,
+            "method": "none",
+            "parsed_data": None,
+            "all_scores": None,
+        }
+
+        if not output:
+            result["error"] = "No output provided"
+            return result
+
+        # Try TextFSM template matching first
+        if self._tfsm_engine:
+            try:
+                best_template, parsed_data, best_score, all_scores = self._tfsm_engine.find_best_template(
+                    device_output=output,
+                    filter_string="show_version",
+                )
+
+                result["template"] = best_template
+                result["score"] = best_score
+                result["all_scores"] = all_scores
+                result["parsed_data"] = parsed_data
+
+                if best_template and best_score >= min_score:
+                    platform = extract_platform_from_template_name(best_template)
+                    if platform:
+                        result["platform"] = platform
+                        result["method"] = "textfsm"
+                        return result
+
+            except Exception as e:
+                result["textfsm_error"] = str(e)
+
+        # Fallback to regex
+        from .platform_data import PLATFORM_PATTERNS
+        import re
+
+        for platform, patterns in PLATFORM_PATTERNS.items():
+            for pattern in patterns:
+                if re.search(pattern, output, re.IGNORECASE):
+                    result["platform"] = platform
+                    result["method"] = "regex"
+                    result["regex_pattern"] = pattern
+                    return result
+
+        return result
+
     # -------------------------------------------------------------------------
     # Convenience / REPL helpers
     # -------------------------------------------------------------------------
@@ -912,6 +1060,7 @@ Command Results:
 
 Debugging:
   api.debug_parse(cmd, output, platform)  Debug why parsing failed
+  api.detect_platform_from_output(output) Detect platform from command output
   api.db_info()                    Show TextFSM database path and status
   
 Status:
@@ -919,6 +1068,21 @@ Status:
   api.vault_unlocked               Check vault status
   api._tfsm_engine                 TextFSM parser (required)
 
+Platform Detection:
+  Platform is detected automatically during connect() using:
+  1. TextFSM template matching (primary - more accurate)
+  2. Regex patterns (fallback)
+  
+  The API sends 'terminal length 0' before detection to prevent
+  paging issues. Template names like 'cisco_ios_show_version' 
+  tell us the platform directly.
+
+Auto-Recovery:
+  If paging (--More--) is detected, the API will automatically:
+  1. Send Ctrl+C to break out of the pager
+  2. Try multiple paging disable commands
+  3. Retry the original command
+
 Examples:
   # Connect and execute (manual)
   api.unlock("vault-password")

nterm/scripting/platform_utils.py

@@ -19,16 +19,27 @@ from .platform_data import (
 )
 
 
-def detect_platform(version_output: str) -> Optional[str]:
+def detect_platform(version_output: str, tfsm_engine=None) -> Optional[str]:
     """
     Detect device platform from 'show version' output.
 
+    Uses TextFSM template matching as primary method (more accurate),
+    falls back to regex patterns if no template matches.
+
     Args:
         version_output: Raw output from 'show version' command
+        tfsm_engine: Optional TextFSMAutoEngine instance for template-based detection
 
     Returns:
         Platform string (e.g., 'cisco_ios', 'arista_eos') or None if not detected
     """
+    # Primary method: Use TextFSM template matching
+    if tfsm_engine is not None:
+        platform = detect_platform_from_template(version_output, tfsm_engine)
+        if platform:
+            return platform
+
+    # Fallback: Regex pattern matching
     for platform, patterns in PLATFORM_PATTERNS.items():
         for pattern in patterns:
             if re.search(pattern, version_output, re.IGNORECASE):
@@ -36,6 +47,140 @@ def detect_platform(version_output: str) -> Optional[str]:
     return None
 
 
+def detect_platform_from_template(
+    version_output: str,
+    tfsm_engine,
+    min_score: float = 50.0,
+) -> Optional[str]:
+    """
+    Detect platform by finding the best matching TextFSM template.
+
+    This is more accurate than regex because TextFSM templates are designed
+    to parse specific platform outputs structurally.
+
+    Args:
+        version_output: Raw output from 'show version' or similar command
+        tfsm_engine: TextFSMAutoEngine instance
+        min_score: Minimum match score to accept (default 50.0)
+
+    Returns:
+        Platform string extracted from template name, or None
+
+    Example:
+        Template 'cisco_ios_show_version' → returns 'cisco_ios'
+        Template 'arista_eos_show_version' → returns 'arista_eos'
+    """
+    if not tfsm_engine or not version_output:
+        return None
+
+    try:
+        # Try with show_version filter first
+        best_template, parsed_data, best_score, all_scores = tfsm_engine.find_best_template(
+            device_output=version_output,
+            filter_string="show_version",
+        )
+
+        if best_template and best_score >= min_score:
+            platform = extract_platform_from_template_name(best_template)
+            if platform:
+                return platform
+
+        # If show_version didn't match well, try without filter
+        # This catches show system info, show version detail, etc.
+        if not best_template or best_score < min_score:
+            best_template, parsed_data, best_score, all_scores = tfsm_engine.find_best_template(
+                device_output=version_output,
+                filter_string="",  # No filter - let it find best match
+            )
+
+            if best_template and best_score >= min_score:
+                platform = extract_platform_from_template_name(best_template)
+                if platform:
+                    return platform
+
+    except Exception:
+        pass  # Fall through to return None
+
+    return None
+
+
+def extract_platform_from_template_name(template_name: str) -> Optional[str]:
+    """
+    Extract platform identifier from a TextFSM template name.
+
+    Template names follow the pattern: {platform}_{command}
+    Examples:
+        'cisco_ios_show_version' → 'cisco_ios'
+        'arista_eos_show_interfaces' → 'arista_eos'
+        'juniper_junos_show_version' → 'juniper_junos'
+        'cisco_nxos_show_version' → 'cisco_nxos'
+
+    Args:
+        template_name: Full template name from TextFSM database
+
+    Returns:
+        Platform string or None if pattern not recognized
+    """
+    if not template_name:
+        return None
+
+    # Known platform prefixes (ordered by specificity - longer matches first)
+    known_platforms = [
+        'cisco_iosxr',
+        'cisco_iosxe',
+        'cisco_nxos',
+        'cisco_ios',
+        'cisco_asa',
+        'cisco_wlc',
+        'arista_eos',
+        'juniper_junos',
+        'juniper_screenos',
+        'hp_procurve',
+        'hp_comware',
+        'huawei_vrp',
+        'linux',
+        'paloalto_panos',
+        'fortinet_fortios',
+        'dell_force10',
+        'dell_os10',
+        'extreme_exos',
+        'extreme_nos',
+        'brocade_fastiron',
+        'brocade_netiron',
+        'ubiquiti_edgeswitch',
+        'mikrotik_routeros',
+        'vyos',
+        'alcatel_aos',
+        'alcatel_sros',
+        'checkpoint_gaia',
+        'enterasys',
+        'ruckus_fastiron',
+        'yamaha',
+        'zyxel_os',
+    ]
+
+    template_lower = template_name.lower()
+
+    for platform in known_platforms:
+        if template_lower.startswith(platform + '_'):
+            return platform
+
+    # Fallback: try to extract platform from template name pattern
+    # Assumes format: platform_command or platform_subplatform_command
+    parts = template_name.split('_')
+    if len(parts) >= 2:
+        # Try first two parts (handles cisco_ios, arista_eos, etc.)
+        potential_platform = f"{parts[0]}_{parts[1]}"
+        if potential_platform.lower() in [p.lower() for p in known_platforms]:
+            return potential_platform.lower()
+
+        # Try just first part for single-word platforms (linux, vyos)
+        if parts[0].lower() in [p.lower() for p in known_platforms]:
+            return parts[0].lower()
+
+    return None
+
+
 def get_platform_command(
     platform: Optional[str],
     command_type: str,
@@ -208,8 +353,65 @@ def extract_version_info(
 
     data = parsed_data[0]  # show version typically returns single row
 
-    # Get platform-specific or default field map
-    field_map = VERSION_FIELD_MAP.get(platform, DEFAULT_VERSION_FIELD_MAP) if platform else DEFAULT_VERSION_FIELD_MAP
+    # Platform-specific field mappings
+    # These override the generic mappings in platform_data.py when needed
+    PLATFORM_VERSION_FIELDS = {
+        'arista_eos': {
+            'version': ['IMAGE', 'VERSION', 'SOFTWARE_IMAGE', 'EOS_VERSION'],
+            'hardware': ['MODEL', 'HARDWARE', 'PLATFORM'],
+            'serial': ['SERIAL_NUMBER', 'SERIAL', 'SN'],
+            'uptime': ['UPTIME'],
+            'hostname': ['HOSTNAME'],
+        },
+        'cisco_ios': {
+            'version': ['VERSION', 'SOFTWARE_VERSION', 'ROMMON'],
+            'hardware': ['HARDWARE', 'MODEL', 'PLATFORM'],
+            'serial': ['SERIAL', 'SERIAL_NUMBER'],
+            'uptime': ['UPTIME'],
+            'hostname': ['HOSTNAME'],
+        },
+        'cisco_nxos': {
+            'version': ['OS', 'VERSION', 'NXOS_VERSION', 'KICKSTART_VERSION'],
+            'hardware': ['PLATFORM', 'HARDWARE', 'CHASSIS'],
+            'serial': ['SERIAL', 'SERIAL_NUMBER'],
+            'uptime': ['UPTIME'],
+            'hostname': ['HOSTNAME', 'DEVICE_NAME'],
+        },
+        'cisco_iosxe': {
+            'version': ['VERSION', 'ROMMON'],
+            'hardware': ['HARDWARE', 'MODEL', 'PLATFORM'],
+            'serial': ['SERIAL', 'SERIAL_NUMBER'],
+            'uptime': ['UPTIME'],
+            'hostname': ['HOSTNAME'],
+        },
+        'juniper_junos': {
+            'version': ['JUNOS_VERSION', 'VERSION'],
+            'hardware': ['MODEL', 'HARDWARE'],
+            'serial': ['SERIAL_NUMBER', 'SERIAL'],
+            'uptime': ['UPTIME', 'RE_UPTIME'],
+            'hostname': ['HOSTNAME'],
+        },
+    }
+
+    # Default field mapping (tries common field names)
+    DEFAULT_FIELDS = {
+        'version': ['VERSION', 'IMAGE', 'SOFTWARE_VERSION', 'SOFTWARE_IMAGE', 'OS', 'ROMMON'],
+        'hardware': ['HARDWARE', 'MODEL', 'PLATFORM', 'CHASSIS'],
+        'serial': ['SERIAL', 'SERIAL_NUMBER', 'SN'],
+        'uptime': ['UPTIME'],
+        'hostname': ['HOSTNAME', 'DEVICE_NAME'],
+    }
+
+    # Get platform-specific mapping or fall back to defaults
+    if platform and platform in PLATFORM_VERSION_FIELDS:
+        field_map = PLATFORM_VERSION_FIELDS[platform]
+    else:
+        # Try to load from platform_data if available
+        try:
+            loaded_map = VERSION_FIELD_MAP.get(platform, DEFAULT_VERSION_FIELD_MAP) if platform else DEFAULT_VERSION_FIELD_MAP
+            field_map = loaded_map if loaded_map else DEFAULT_FIELDS
+        except (NameError, TypeError):
+            field_map = DEFAULT_FIELDS
 
     return extract_fields(data, field_map, defaults={
         'version': 'unknown',
@@ -317,6 +519,70 @@ def get_paging_disable_command(platform: Optional[str]) -> Optional[str]:
     return None
 
 
+def get_paging_disable_commands_to_try() -> List[str]:
+    """
+    Get list of paging disable commands to try when platform is unknown.
+
+    Returns a prioritized list of commands that cover most network platforms.
+    Commands are ordered by likelihood of success across vendors.
+
+    Returns:
+        List of paging disable commands to try in order
+    """
+    return [
+        # Cisco IOS/IOS-XE/NX-OS, Arista EOS (most common)
+        "terminal length 0",
+        # Cisco alternative
+        "terminal pager 0",
+        # Juniper JUNOS
+        "set cli screen-length 0",
+        # Some Cisco platforms
+        "screen-length 0",
+        # HP/Aruba
+        "no page",
+        # Huawei
+        "screen-length 0 temporary",
+        # Extreme
+        "disable clipaging",
+        # Dell/Force10
+        "terminal length 0",
+    ]
+
+
+def try_disable_paging(shell, prompt, send_command_func, debug: bool = False) -> bool:
+    """
+    Try multiple commands to disable terminal paging.
+
+    Used for auto-recovery when PagingNotDisabledError is raised.
+
+    Args:
+        shell: Active SSH channel
+        prompt: Device prompt
+        send_command_func: Function to send commands (ssh_connection.send_command)
+        debug: Print debug info
+
+    Returns:
+        True if any command succeeded (didn't raise exception), False if all failed
+    """
+    commands = get_paging_disable_commands_to_try()
+
+    for cmd in commands:
+        try:
+            if debug:
+                print(f"[PAGING] Trying: {cmd}")
+            # Short timeout - these commands should return quickly
+            send_command_func(shell, cmd, prompt, timeout=5)
+            if debug:
+                print(f"[PAGING] Success: {cmd}")
+            return True
+        except Exception as e:
+            if debug:
+                print(f"[PAGING] Failed: {cmd} - {e}")
+            continue
+
+    return False
+
+
 def sanitize_filename(name: str) -> str:
     """
     Make a device name safe for use in filenames.

nterm/scripting/repl.py

@@ -102,6 +102,8 @@ class NTermREPL:
       :folders             List folders
       :connect <device>    Connect to device [--cred name] [--debug]
       :disconnect          Disconnect current session
+      :disconnect_all      Disconnect all sessions
+      :switch <device>     Switch to another active session
       :sessions            List all active sessions
       :policy [mode]       Get/set policy (read_only|ops)
       :mode [raw|parsed]   Get/set output mode
@@ -120,7 +122,7 @@ class NTermREPL:
       :neighbors           Fetch CDP/LLDP neighbors (tries both)
       :bgp                 Fetch BGP summary
       :routes              Fetch routing table
-      :intf <name>         Fetch specific interface details
+      :intf <n>         Fetch specific interface details
 
     Raw Commands:
       (anything else)      Runs as CLI on the connected session
@@ -232,9 +234,26 @@ class NTermREPL:
             if not self.state.api.vault_unlocked:
                 return self._err("Vault is locked. Run :unlock first.")
 
-            # Disconnect existing session if any
-            if self.state.session:
-                self._safe_disconnect()
+            # Check if already connected to this device
+            existing_sessions = self.state.api.active_sessions()
+            for sess in existing_sessions:
+                if sess.device_name == device:
+                    # Already connected - just switch to it
+                    self.state.session = sess
+                    self.state.connected_device = sess.device_name
+                    return self._ok({
+                        "type": "switch",
+                        "device": sess.device_name,
+                        "hostname": sess.hostname,
+                        "port": sess.port,
+                        "platform": sess.platform,
+                        "prompt": sess.prompt,
+                        "message": "Already connected - switched to existing session",
+                    })
+
+            # NOTE: We no longer disconnect the existing session!
+            # Old sessions stay active in the background.
+            # User can switch back with :switch or disconnect with :disconnect
 
             try:
                 sess = self.state.api.connect(device, credential=cred, debug=debug)
@@ -255,8 +274,60 @@ class NTermREPL:
         if cmd == ":disconnect":
             if not self.state.session:
                 return self._ok({"type": "disconnect", "message": "No active session"})
+
+            device_name = self.state.connected_device
             self._safe_disconnect()
-            return self._ok({"type": "disconnect"})
+
+            # Try to switch to another active session if available
+            remaining = self.state.api.active_sessions()
+            if remaining:
+                self.state.session = remaining[0]
+                self.state.connected_device = remaining[0].device_name
+                return self._ok({
+                    "type": "disconnect",
+                    "disconnected": device_name,
+                    "switched_to": self.state.connected_device,
+                    "message": f"Disconnected {device_name}, switched to {self.state.connected_device}",
+                })
+
+            return self._ok({"type": "disconnect", "disconnected": device_name})
+
+        if cmd == ":disconnect_all":
+            count = self.state.api.disconnect_all()
+            self.state.session = None
+            self.state.connected_device = None
+            return self._ok({"type": "disconnect_all", "count": count})
+
+        if cmd == ":switch":
+            if len(parts) < 2:
+                # Show available sessions
+                sessions = self.state.api.active_sessions()
+                if not sessions:
+                    return self._err("No active sessions. Use :connect <device> first.")
+
+                session_names = [s.device_name for s in sessions]
+                return self._err(f"Usage: :switch <device>\nActive sessions: {', '.join(session_names)}")
+
+            target_device = parts[1]
+
+            # Find the session
+            sessions = self.state.api.active_sessions()
+            for sess in sessions:
+                if sess.device_name == target_device:
+                    self.state.session = sess
+                    self.state.connected_device = sess.device_name
+                    return self._ok({
+                        "type": "switch",
+                        "device": sess.device_name,
+                        "hostname": sess.hostname,
+                        "port": sess.port,
+                        "platform": sess.platform,
+                        "prompt": sess.prompt,
+                    })
+
+            # Not found
+            session_names = [s.device_name for s in sessions]
+            return self._err(f"Session '{target_device}' not found.\nActive sessions: {', '.join(session_names)}")
 
         if cmd == ":sessions":
             sessions = self.state.api.active_sessions()
@@ -295,7 +366,7 @@ class NTermREPL:
                 })
             mode = parts[1].lower()
             if mode not in ["raw", "parsed"]:
-                return self._err("Mode must be 'raw' or 'parsed'")
+                return self._err("Mode must be raw or parsed")
             self.state.output_mode = mode
             return self._ok({"type": "mode", "mode": mode})
 
@@ -304,113 +375,87 @@ class NTermREPL:
                 return self._ok({"type": "format", "format": self.state.output_format})
             fmt = parts[1].lower()
             if fmt not in ["text", "rich", "json"]:
-                return self._err("Format must be 'text', 'rich', or 'json'")
+                return self._err("Format must be text, rich, or json")
             self.state.output_format = fmt
             return self._ok({"type": "format", "format": fmt})
 
         if cmd == ":set_hint":
             if len(parts) < 2:
                 return self._err("Usage: :set_hint <platform> (e.g., cisco_ios, arista_eos)")
-            platform = parts[1].lower()
-            self.state.platform_hint = platform
-            return self._ok({"type": "set_hint", "platform_hint": platform})
+            self.state.platform_hint = parts[1]
+            return self._ok({"type": "set_hint", "platform_hint": self.state.platform_hint})
 
         if cmd == ":clear_hint":
             self.state.platform_hint = None
             return self._ok({"type": "clear_hint"})
 
         if cmd == ":debug":
-            if len(parts) >= 2:
-                mode = parts[1].lower()
-                if mode in ["on", "true", "1"]:
-                    self.state.debug_mode = True
-                elif mode in ["off", "false", "0"]:
-                    self.state.debug_mode = False
-                else:
-                    return self._err("Debug mode must be on or off")
-            else:
-                self.state.debug_mode = not self.state.debug_mode
+            if len(parts) < 2:
+                return self._ok({"type": "debug", "debug_mode": self.state.debug_mode})
+            val = parts[1].lower()
+            self.state.debug_mode = val in ["on", "true", "1", "yes"]
             return self._ok({"type": "debug", "debug_mode": self.state.debug_mode})
 
         if cmd == ":dbinfo":
-            try:
-                db_info = self.state.api.db_info()
-                return self._ok({"type": "dbinfo", "db_info": db_info})
-            except Exception as e:
-                return self._err(f"Failed to get DB info: {e}")
+            info = self.state.api.db_info()
+            return self._ok({"type": "dbinfo", "db_info": info})
 
-        # ===== Quick Commands (Platform-Aware) =====
+        # ===== Quick Commands =====
         if cmd == ":config":
-            return self._quick_command('config', parse=False, timeout=120)
+            return self._quick_config()
 
         if cmd == ":version":
             return self._quick_version()
 
         if cmd == ":interfaces":
-            return self._quick_command('interfaces_status', parse=True)
+            return self._quick_interfaces()
 
         if cmd == ":neighbors":
             return self._quick_neighbors()
 
         if cmd == ":bgp":
-            return self._quick_command('bgp_summary', parse=True)
+            return self._quick_bgp()
 
         if cmd == ":routes":
-            return self._quick_command('routing_table', parse=True, timeout=60)
+            return self._quick_routes()
 
         if cmd == ":intf":
             if len(parts) < 2:
-                return self._err("Usage: :intf <interface_name> (e.g., :intf Gi0/1)")
-            intf_name = parts[1]
-            return self._quick_command('interface_detail', parse=True, name=intf_name)
+                return self._err("Usage: :intf <interface> (e.g., :intf Gi0/1)")
+            return self._quick_interface_detail(parts[1])
 
         return self._err(f"Unknown REPL command: {cmd}")
 
     # -----------------------
-    # Quick Command Helpers
+    # Quick commands
     # -----------------------
 
-    def _quick_command(
-            self,
-            command_type: str,
-            parse: bool = True,
-            timeout: int = 30,
-            **kwargs
-    ) -> Dict[str, Any]:
-        """Execute a platform-aware command."""
+    def _quick_config(self) -> Dict[str, Any]:
+        """Fetch running configuration."""
         if not self.state.session:
             return self._err("Not connected. Use :connect <device>")
 
-        platform = self.state.platform_hint or self.state.session.platform
-        cmd = get_platform_command(platform, command_type, **kwargs)
-
-        if not cmd:
-            return self._err(f"Command '{command_type}' not available for platform '{platform}'")
-
         try:
             started = time.time()
-            result = self.state.api.send(
+            result = self.state.api.send_platform_command(
                 self.state.session,
-                cmd,
-                timeout=timeout,
-                parse=parse,
-                normalize=True,
+                'config',
+                parse=False,  # Config is typically not parsed
+                timeout=60,
             )
             elapsed = time.time() - started
 
+            if not result:
+                return self._err("Config command not available for this platform")
+
             payload = result.to_dict()
             payload["elapsed_seconds"] = round(elapsed, 3)
-            payload["command_type"] = command_type
-
-            # Truncate if needed
-            raw = payload.get("raw_output", "")
-            if len(raw) > self.state.policy.max_output_chars:
-                payload["raw_output"] = raw[:self.state.policy.max_output_chars] + "\n...<truncated>..."
+            payload["command_type"] = "config"
 
-            return self._ok({"type": "result", "result": payload})
+            return self._ok({"type": "config", "result": payload})
 
         except Exception as e:
-            return self._err(f"Command failed: {e}")
+            return self._err(f"Config fetch failed: {e}")
 
     def _quick_version(self) -> Dict[str, Any]:
         """Fetch and extract version info."""
@@ -446,6 +491,33 @@ class NTermREPL:
         except Exception as e:
             return self._err(f"Version command failed: {e}")
 
+    def _quick_interfaces(self) -> Dict[str, Any]:
+        """Fetch interface status."""
+        if not self.state.session:
+            return self._err("Not connected. Use :connect <device>")
+
+        try:
+            started = time.time()
+            result = self.state.api.send_platform_command(
+                self.state.session,
+                'interfaces_status',
+                parse=True,
+                timeout=30,
+            )
+            elapsed = time.time() - started
+
+            if not result:
+                return self._err("Interfaces command not available for this platform")
+
+            payload = result.to_dict()
+            payload["elapsed_seconds"] = round(elapsed, 3)
+            payload["command_type"] = "interfaces"
+
+            return self._ok({"type": "interfaces", "result": payload})
+
+        except Exception as e:
+            return self._err(f"Interfaces command failed: {e}")
+
     def _quick_neighbors(self) -> Dict[str, Any]:
         """Fetch CDP/LLDP neighbors with fallback."""
         if not self.state.session:
@@ -513,6 +585,89 @@ class NTermREPL:
         except Exception as e:
             return self._err(f"Neighbor discovery failed: {e}")
 
+    def _quick_bgp(self) -> Dict[str, Any]:
+        """Fetch BGP summary."""
+        if not self.state.session:
+            return self._err("Not connected. Use :connect <device>")
+
+        try:
+            started = time.time()
+            result = self.state.api.send_platform_command(
+                self.state.session,
+                'bgp_summary',
+                parse=True,
+                timeout=30,
+            )
+            elapsed = time.time() - started
+
+            if not result:
+                return self._err("BGP command not available for this platform")
+
+            payload = result.to_dict()
+            payload["elapsed_seconds"] = round(elapsed, 3)
+            payload["command_type"] = "bgp"
+
+            return self._ok({"type": "bgp", "result": payload})
+
+        except Exception as e:
+            return self._err(f"BGP command failed: {e}")
+
+    def _quick_routes(self) -> Dict[str, Any]:
+        """Fetch routing table."""
+        if not self.state.session:
+            return self._err("Not connected. Use :connect <device>")
+
+        try:
+            started = time.time()
+            result = self.state.api.send_platform_command(
+                self.state.session,
+                'routing_table',
+                parse=True,
+                timeout=30,
+            )
+            elapsed = time.time() - started
+
+            if not result:
+                return self._err("Routing command not available for this platform")
+
+            payload = result.to_dict()
+            payload["elapsed_seconds"] = round(elapsed, 3)
+            payload["command_type"] = "routes"
+
+            return self._ok({"type": "routes", "result": payload})
+
+        except Exception as e:
+            return self._err(f"Routing command failed: {e}")
+
+    def _quick_interface_detail(self, interface: str) -> Dict[str, Any]:
+        """Fetch specific interface details."""
+        if not self.state.session:
+            return self._err("Not connected. Use :connect <device>")
+
+        try:
+            started = time.time()
+            result = self.state.api.send_platform_command(
+                self.state.session,
+                'interface_detail',
+                name=interface,
+                parse=True,
+                timeout=30,
+            )
+            elapsed = time.time() - started
+
+            if not result:
+                return self._err(f"Interface detail command not available for this platform")
+
+            payload = result.to_dict()
+            payload["elapsed_seconds"] = round(elapsed, 3)
+            payload["command_type"] = "interface_detail"
+            payload["interface"] = interface
+
+            return self._ok({"type": "interface_detail", "result": payload})
+
+        except Exception as e:
+            return self._err(f"Interface detail command failed: {e}")
+
     # -----------------------
     # CLI send path
     # -----------------------
@@ -568,6 +723,7 @@ class NTermREPL:
     # -----------------------
 
     def _safe_disconnect(self) -> None:
+        """Disconnect current session only (not all sessions)."""
         if self.state.session:
             try:
                 self.state.api.disconnect(self.state.session)
@@ -601,6 +757,8 @@ Inventory:
 Sessions:
   :connect <device>    Connect to device [--cred name] [--debug]
   :disconnect          Disconnect current session
+  :disconnect_all      Disconnect all sessions
+  :switch <device>     Switch to another active session
   :sessions            List all active sessions
 
 Quick Commands (platform-aware, auto-selects correct syntax):
@@ -610,7 +768,7 @@ Quick Commands (platform-aware, auto-selects correct syntax):
   :neighbors           Fetch CDP/LLDP neighbors (tries both)
   :bgp                 Fetch BGP summary
   :routes              Fetch routing table
-  :intf <name>         Fetch specific interface details
+  :intf <n>            Fetch specific interface details
 
 Settings:
   :policy [mode]       Get/set policy mode (read_only|ops)
@@ -628,15 +786,16 @@ Info:
 Raw Commands:
   (anything else)      Sends as CLI command to connected device
 
-Examples:
-  :unlock
-  :devices *leaf*
-  :connect usa-leaf-1
-  :version
-  :interfaces
-  :neighbors
-  show ip route
-  :disconnect
+Multi-Session Example:
+  :connect spine-1     # Connect to first device
+  show version         # Run command on spine-1
+  :connect spine-2     # Connect to second (spine-1 stays active!)
+  show version         # Run command on spine-2
+  :sessions            # See both sessions
+  :switch spine-1      # Switch back to spine-1
+  show ip route        # Run command on spine-1
+  :disconnect          # Disconnect spine-1, auto-switch to spine-2
+  :disconnect_all      # Disconnect all remaining sessions
   :exit
 """
 

nterm/scripting/repl_interactive.py

@@ -200,9 +200,34 @@ def _display_result(repl: NTermREPL, result: Dict) -> None:
         print(f"  Prompt: {data.get('prompt', '')}")
         return
 
+    if cmd_type == "switch":
+        msg = data.get('message', '')
+        if msg:
+            print(f"✓ {msg}")
+        else:
+            print(f"✓ Switched 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}")
+        disconnected = data.get("disconnected")
+        switched_to = data.get("switched_to")
+        msg = data.get("message")
+
+        if msg:
+            print(f"✓ {msg}")
+        elif disconnected:
+            print(f"✓ Disconnected from {disconnected}")
+            if switched_to:
+                print(f"  Switched to: {switched_to}")
+        else:
+            print("✓ Disconnected")
+        return
+
+    if cmd_type == "disconnect_all":
+        count = data.get("count", 0)
+        print(f"✓ Disconnected {count} session(s)")
         return
 
     if cmd_type == "sessions":

{ntermqt-0.1.8.dist-info → ntermqt-0.1.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ntermqt
-Version: 0.1.8
+Version: 0.1.9
 Summary: Modern SSH terminal widget for PyQt6 with credential vault and jump host support
 Author: Scott Peterman
 License: GPL-3.0
@@ -112,7 +112,7 @@ nterm includes a built-in development console accessible via **Dev → IPython**
 
 ![IPython Console](https://raw.githubusercontent.com/scottpeterman/nterm/main/screenshots/ipython.png)
 
-![IPython Console](https://raw.githubusercontent.com/scottpeterman/nterm/main/screenshots/repl.png)
+![IPython Console](https://raw.githubusercontent.com/scottpeterman/nterm/main/screenshots/repl_dark3.png)
 
 The IPython console runs in the same Python environment as nterm, with the scripting API pre-loaded. Query your device inventory, inspect credentials, and prototype automation workflows without leaving the app.
 

{ntermqt-0.1.8.dist-info → ntermqt-0.1.9.dist-info}/RECORD

@@ -20,13 +20,13 @@ nterm/parser/tfsm_engine.py,sha256=6p4wrNa9tQRuCmWgsR4E3rZTprpLmii5PNjoGpCQBCw,7
 nterm/parser/tfsm_fire.py,sha256=AHbN6p4HlgcYDjLWb67CF9YfMSTk-3aetMswmEZyRVc,9222
 nterm/parser/tfsm_fire_tester.py,sha256=h2CAqTS6ZNHMUr4di2DBRHAWbBGiUTliOvm5jVG4ltI,79146
 nterm/scripting/__init__.py,sha256=vxbODaXR0IPneja3BuDHmjsHzQg03tFWtHO4Rc6vCTk,1099
-nterm/scripting/api.py,sha256=2Q6p07pUVOzye15NHoHUNE0PY4anla4jUsnu87yym0s,32740
+nterm/scripting/api.py,sha256=nWuANeYyT8mI1OsP9g3Z2lZohrrCpAZVss6t9Ba5Avg,39011
 nterm/scripting/cli.py,sha256=W2DK4ZnuutaArye_to7CBchg0ogClURxVbGsMdnj1y0,9187
 nterm/scripting/models.py,sha256=zX90xtFYz0fqIPc0G8mRaoiZ1aRLm0koiHIvklUBflg,6858
 nterm/scripting/platform_data.py,sha256=uCWBDS1HqmOdYNPojNlKBWLYhLiME9eoE0LWL-w6dkQ,10200
-nterm/scripting/platform_utils.py,sha256=7SrvZvrcoQwOFAIjzXVvbFH04bFW6nOXar5JU3YEbr8,9560
-nterm/scripting/repl.py,sha256=BUISW1FX7EDh-1AV5UFpn2DB20CIYq_SdiCHea_6Ku0,22738
-nterm/scripting/repl_interactive.py,sha256=qcHpubo9GBcz-EpUrR_nHbfSIqwIx-gDXdNJP7rZVbU,17045
+nterm/scripting/platform_utils.py,sha256=_vb1tMstlD9pQ4blD2keAkVbs9lkbFlTBEavI5oMd3Q,18478
+nterm/scripting/repl.py,sha256=URcgs-c-bEYsw2JNCewEonNy1oLsGpzsBcq5xpYWseM,29152
+nterm/scripting/repl_interactive.py,sha256=yQ-XjyELBCE5t4Gk3hBnO8eZCbCXquddLBqcQIKPhY8,17870
 nterm/scripting/ssh_connection.py,sha256=p9EGPE3hgbceDVh7UdGz44cSi79Vl7g9Q4fKd-2T314,19270
 nterm/scripting/test_api_repl.py,sha256=deeA_epPnBxgDGYMKcyXEWQOOpIXQNjDZL01FmOpKvs,8762
 nterm/session/__init__.py,sha256=FkgHF1WPz78JBOWHSC7LLynG2NqoR6aanNTRlEzsO6I,1612
@@ -66,8 +66,8 @@ nterm/vault/manager_ui.py,sha256=qle-W40j6L_pOR0AaOCeyU8myizFTRkISNrloCn0H_Y,345
 nterm/vault/profile.py,sha256=qM9TJf68RKdjtxo-sJehO7wS4iTi2G26BKbmlmHLA5M,6246
 nterm/vault/resolver.py,sha256=GWB2YR9H1MH98RGQBKvitIsjWT_-wSMLuddZNz4wbns,7800
 nterm/vault/store.py,sha256=_0Lfe0WKjm3uSAtxgn9qAPlpBOLCuq9SVgzqsE_qaGQ,21199
-ntermqt-0.1.8.dist-info/METADATA,sha256=m9M46bSjV7s_trY8RfJMPodSxNLkAk1EQTY4RqqR2IY,16034
-ntermqt-0.1.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ntermqt-0.1.8.dist-info/entry_points.txt,sha256=Gunr-_3w-aSpfqoMuGKM2PJSCRo9hZ7K1BksUtp1yd8,130
-ntermqt-0.1.8.dist-info/top_level.txt,sha256=bZdnNLTHNRNqo9jsOQGUWF7h5st0xW_thH0n2QOxWUo,6
-ntermqt-0.1.8.dist-info/RECORD,,
+ntermqt-0.1.9.dist-info/METADATA,sha256=ICYH7EjefVJLe_Hp-prpK8GPQE2TTqEaoX7-x2M0cOo,16040
+ntermqt-0.1.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ntermqt-0.1.9.dist-info/entry_points.txt,sha256=Gunr-_3w-aSpfqoMuGKM2PJSCRo9hZ7K1BksUtp1yd8,130
+ntermqt-0.1.9.dist-info/top_level.txt,sha256=bZdnNLTHNRNqo9jsOQGUWF7h5st0xW_thH0n2QOxWUo,6
+ntermqt-0.1.9.dist-info/RECORD,,