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

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.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ntermqt
-Version: 0.1.8
+Version: 0.1.10
 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.10.dist-info}/RECORD

@@ -6,10 +6,11 @@ nterm/askpass/__init__.py,sha256=UpJBk0EOm0nkRwMVv7YdIB4v75ZJpSYmNsU_GlgzbUg,495
 nterm/askpass/server.py,sha256=5tvjYryyfu-n8Cw2KbucwaZfWiqYnFk-iBAVBI8FMfw,12873
 nterm/connection/__init__.py,sha256=2qQ9LGxUxmwem8deOD2WZVkeD6rIVlTlx5Zh2cUEmxY,261
 nterm/connection/profile.py,sha256=4RMgnRNKCc-dFGEIpmQc_bob5MtzxO04_PljP-qUGLs,9450
+nterm/examples/basic_terminal.py,sha256=vbDI1xl-Radv6GYZ0yC6QUafQp_tSX2pWIf7tk58W8E,15256
 nterm/manager/__init__.py,sha256=_QIeTap5CTL3jdTS1Q16fAt-PrqcNPUVr9gtJ22f0ng,774
 nterm/manager/connect_dialog.py,sha256=yd8g_gYttT_UdflRxSfyss8OQTfrvKLUOMg4Kj8FPNo,11711
 nterm/manager/editor.py,sha256=Fn2YWHJ1EwPYrhKhsi4GTBYwRfCYsHsqgKkLY-LQ8JI,8469
-nterm/manager/io.py,sha256=R5ksWgpEz0VdVCokcgTN5G3PFgp5QYhjjt40OypSWkY,21687
+nterm/manager/io.py,sha256=59ehTfnS1sAKEEEwMxujHuccV7rYSoRx4vfS1ExDqW4,32572
 nterm/manager/models.py,sha256=cvC2HzCRadNG1EYsnZN4C9YS6uolHGcUGGZtt-wzGF4,12237
 nterm/manager/settings.py,sha256=r6MTw_9r1Wl2UX_ALpXIuPbDvJ0D91Y8wRKq6Bfr_3g,9210
 nterm/manager/tree.py,sha256=I78wSjkSuyM6903II-XNyPug9saMSODUNBCHCDrq4ls,22397
@@ -20,13 +21,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 +67,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.10.dist-info/METADATA,sha256=Pa4Oytg8jq0W5pU0bmmJR9nryjKRwewy54qejJValjM,16041
+ntermqt-0.1.10.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+ntermqt-0.1.10.dist-info/entry_points.txt,sha256=Gunr-_3w-aSpfqoMuGKM2PJSCRo9hZ7K1BksUtp1yd8,130
+ntermqt-0.1.10.dist-info/top_level.txt,sha256=bZdnNLTHNRNqo9jsOQGUWF7h5st0xW_thH0n2QOxWUo,6
+ntermqt-0.1.10.dist-info/RECORD,,

{ntermqt-0.1.8.dist-info → ntermqt-0.1.10.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any