ntermqt 0.1.5__tar.gz → 0.1.6__tar.gz

{ntermqt-0.1.5/ntermqt.egg-info → ntermqt-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ntermqt
-Version: 0.1.5
+Version: 0.1.6
 Summary: Modern SSH terminal widget for PyQt6 with credential vault and jump host support
 Author: Scott Peterman
 License: GPL-3.0
@@ -29,6 +29,7 @@ Requires-Dist: click>=8.0.0
 Requires-Dist: ipython>=8.0.0
 Requires-Dist: requests>=2.10.0
 Requires-Dist: textfsm>=2.0.0
+Requires-Dist: rich>=14.0.0
 Requires-Dist: pexpect>=4.8.0; sys_platform != "win32"
 Requires-Dist: pywinpty>=2.0.0; sys_platform == "win32"
 Provides-Extra: keyring
@@ -110,6 +111,8 @@ 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)
+
 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.
 
 ```python

{ntermqt-0.1.5 → ntermqt-0.1.6}/README.md

@@ -66,6 +66,8 @@ 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)
+
 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.
 
 ```python

{ntermqt-0.1.5 → ntermqt-0.1.6}/nterm/scripting/__init__.py

@@ -15,11 +15,6 @@ Quick Start (IPython):
     api.credentials()              # List credentials
 
     api.help()                     # Show all commands
-
-Quick Start (CLI):
-    nterm-cli devices
-    nterm-cli search leaf
-    nterm-cli credentials --unlock
 """
 
 from .api import (
@@ -29,9 +24,14 @@ from .api import (
     get_api,
     reset_api,
 )
+from nterm.scripting.repl import REPLPolicy, NTermREPL
+from nterm.scripting.repl_interactive import add_repl_to_api
 
 # Convenience: pre-instantiated API
-api = get_api()
+api = get_api()  # <-- This FIRST
+
+# Make api.repl() available
+add_repl_to_api(api)  # <-- Then this
 
 __all__ = [
     "NTermAPI",
@@ -40,4 +40,6 @@ __all__ = [
     "get_api",
     "reset_api",
     "api",
+    'REPLPolicy',
+    'NTermREPL'
 ]

ntermqt-0.1.6/nterm/scripting/repl.py

@@ -0,0 +1,406 @@
+# nterm/scripting/repl.py
+#
+# A single "front door" that BOTH humans (GUI REPL) and MCP use.
+# Guardrails live here, not in the agent.
+#
+# - Allow-list commands (or allow-list verbs + deny-list verbs)
+# - Optional read-only mode
+# - Session scoping (one device/session per REPL unless explicitly allowed)
+# - Audit log of everything that ran
+
+from __future__ import annotations
+
+import os
+import json
+import time
+import shlex
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Optional, Dict, Any, List
+
+from .api import NTermAPI, ActiveSession, CommandResult
+
+
+@dataclass
+class REPLPolicy:
+    mode: str = "read_only"  # "read_only" or "ops"
+    max_output_chars: int = 250000
+    max_command_seconds: int = 60
+
+    # Simple and surprisingly effective "don't brick the network" guardrails
+    deny_substrings: List[str] = field(default_factory=list)
+    allow_prefixes: List[str] = field(default_factory=list)
+
+    def is_allowed(self, command: str) -> bool:
+        cmd = command.strip().lower()
+
+        i = 0
+        while i < len(self.deny_substrings):
+            bad = self.deny_substrings[i].lower()
+            if bad in cmd:
+                return False
+            i += 1
+
+        if self.mode == "read_only":
+            # Cheap "write reminder": block common config verbs
+            # (You can tighten to an allow-list only if you want)
+            write_verbs = [
+                "conf t",
+                "configure",
+                "copy ",
+                "write",
+                "wr ",
+                "reload",
+                "commit",
+                "delete",
+                "set ",
+                "unset ",
+                "clear ",
+                "shutdown",
+                "no shutdown",
+                "format",
+                "upgrade",
+                "install",
+            ]
+            j = 0
+            while j < len(write_verbs):
+                if cmd.startswith(write_verbs[j]):
+                    return False
+                j += 1
+
+        # If allow_prefixes provided, require one of them
+        if self.allow_prefixes:
+            ok = False
+            k = 0
+            while k < len(self.allow_prefixes):
+                pref = self.allow_prefixes[k].lower()
+                if cmd.startswith(pref):
+                    ok = True
+                    break
+                k += 1
+            return ok
+
+        return True
+
+
+@dataclass
+class REPLState:
+    api: NTermAPI
+    policy: REPLPolicy
+    vault_unlocked: bool = False
+    session: Optional[ActiveSession] = None
+    connected_device: Optional[str] = None
+    output_mode: str = "parsed"  # "raw" or "parsed"
+    output_format: str = "text"  # "text", "rich", or "json" (for parsed mode only)
+    platform_hint: Optional[str] = None  # Override platform for TextFSM
+    debug_mode: bool = False  # Show full result data
+
+
+class NTermREPL:
+    """
+    A minimal command router. This is the "tool surface".
+    MCP can call `handle_line()`; humans can type into it.
+
+    Commands:
+      :unlock
+      :lock
+      :creds [pattern]
+      :devices [pattern]
+      :connect <device> [--cred name]
+      :disconnect
+      :policy [read_only|ops]
+      :mode [raw|parsed]
+      :format [text|rich|json]
+      :set_hint <platform>
+      :clear_hint
+      :debug [on|off]
+      :dbinfo
+      (anything else runs as CLI on the connected session)
+      :help
+      :exit
+    """
+
+    def __init__(self, api: Optional[NTermAPI] = None, policy: Optional[REPLPolicy] = None):
+        if api is None:
+            api = NTermAPI()
+        if policy is None:
+            policy = REPLPolicy(
+                mode="read_only",
+                deny_substrings=[
+                    "terminal monitor",  # example if you don't want interactive spam
+                ],
+                allow_prefixes=[],
+            )
+
+        self.state = REPLState(api=api, policy=policy)
+
+    def handle_line(self, line: str) -> Dict[str, Any]:
+        line = (line or "").strip()
+        if not line:
+            return self._ok({"type": "noop"})
+
+        if line.startswith(":"):
+            return self._handle_meta(line)
+
+        # Default: treat as CLI to send
+        return self._handle_send(line)
+
+    # -----------------------
+    # Meta / REPL commands
+    # -----------------------
+
+    def _handle_meta(self, line: str) -> Dict[str, Any]:
+        parts = shlex.split(line)
+        cmd = parts[0].lower()
+
+        if cmd == ":help":
+            return self._ok({"type": "help", "text": self._help_text()})
+
+        if cmd == ":exit":
+            if self.state.session:
+                self._safe_disconnect()
+            return self._ok({"type": "exit"})
+
+        if cmd == ":unlock":
+            # Password should be provided separately, not in the command line
+            if len(parts) > 1:
+                return self._err(":unlock takes no arguments. Password will be prompted securely.")
+            return self._ok({"type": "unlock_prompt", "message": "Please provide vault password"})
+
+        if cmd == ":lock":
+            self.state.api.lock()
+            self.state.vault_unlocked = False
+            return self._ok({"type": "lock", "vault_unlocked": False})
+
+        if cmd == ":creds":
+            if not self.state.api.vault_unlocked:
+                return self._err("Vault is locked. Run :unlock <password> first.")
+
+            pattern = None
+            if len(parts) >= 2:
+                pattern = parts[1]
+
+            creds = self.state.api.credentials(pattern=pattern)
+            rows: List[Dict[str, Any]] = []
+            i = 0
+            while i < len(creds):
+                rows.append(creds[i].to_dict())
+                i += 1
+            return self._ok({"type": "credentials", "credentials": rows})
+
+        if cmd == ":devices":
+            pattern = None
+            if len(parts) >= 2:
+                pattern = parts[1]
+            devs = self.state.api.devices(pattern=pattern)
+            # No comprehensions
+            rows: List[Dict[str, Any]] = []
+            i = 0
+            while i < len(devs):
+                rows.append(devs[i].to_dict())
+                i += 1
+            return self._ok({"type": "devices", "devices": rows})
+
+        if cmd == ":connect":
+            if len(parts) < 2:
+                return self._err("Usage: :connect <device> [--cred name]")
+
+            device = parts[1]
+            cred = None
+
+            i = 2
+            while i < len(parts):
+                if parts[i] == "--cred":
+                    if i + 1 < len(parts):
+                        cred = parts[i + 1]
+                        i += 1
+                i += 1
+
+            if not self.state.api.vault_unlocked:
+                return self._err("Vault is locked. Run :unlock <password> first.")
+
+            # Single active session policy by default
+            if self.state.session:
+                self._safe_disconnect()
+
+            try:
+                sess = self.state.api.connect(device, credential=cred)
+                self.state.session = sess
+                self.state.connected_device = sess.device_name
+
+                return self._ok({
+                    "type": "connect",
+                    "device": sess.device_name,
+                    "hostname": sess.hostname,
+                    "port": sess.port,
+                    "platform": sess.platform,
+                    "prompt": sess.prompt,
+                })
+            except Exception as e:
+                return self._err(f"Connection failed: {e}")
+
+        if cmd == ":disconnect":
+            self._safe_disconnect()
+            return self._ok({"type": "disconnect"})
+
+        if cmd == ":policy":
+            if len(parts) < 2:
+                return self._ok({"type": "policy", "mode": self.state.policy.mode})
+            mode = parts[1].lower()
+            if mode not in ["read_only", "ops"]:
+                return self._err("Policy must be read_only or ops")
+            self.state.policy.mode = mode
+            return self._ok({"type": "policy", "mode": mode})
+
+        if cmd == ":mode":
+            if len(parts) < 2:
+                return self._ok({
+                    "type": "mode",
+                    "mode": self.state.output_mode,
+                    "platform_hint": self.state.platform_hint,
+                })
+            mode = parts[1].lower()
+            if mode not in ["raw", "parsed"]:
+                return self._err("Mode must be 'raw' or 'parsed'")
+            self.state.output_mode = mode
+            return self._ok({"type": "mode", "mode": mode})
+
+        if cmd == ":format":
+            if len(parts) < 2:
+                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'")
+            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})
+
+        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:
+                # Toggle
+                self.state.debug_mode = not self.state.debug_mode
+            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}")
+
+        return self._err(f"Unknown REPL command: {cmd}")
+
+    # -----------------------
+    # CLI send path
+    # -----------------------
+
+    def _handle_send(self, cli: str) -> Dict[str, Any]:
+        if not self.state.session:
+            return self._err("Not connected. Use :connect <device>")
+
+        if not self.state.policy.is_allowed(cli):
+            return self._err(f"Blocked by policy ({self.state.policy.mode}): {cli}")
+
+        try:
+            started = time.time()
+            
+            # Determine if we should parse based on output mode
+            should_parse = (self.state.output_mode == "parsed")
+            
+            # Apply platform hint if set (modify session platform temporarily)
+            original_platform = self.state.session.platform
+            if self.state.platform_hint:
+                self.state.session.platform = self.state.platform_hint
+            
+            try:
+                res: CommandResult = self.state.api.send(
+                    self.state.session,
+                    cli,
+                    timeout=self.state.policy.max_command_seconds,
+                    parse=should_parse,
+                    normalize=True,
+                )
+            finally:
+                # Restore original platform
+                if self.state.platform_hint:
+                    self.state.session.platform = original_platform
+                    
+            elapsed = time.time() - started
+
+            # Clip raw output for safety/transport
+            raw = res.raw_output or ""
+            if len(raw) > self.state.policy.max_output_chars:
+                raw = raw[: self.state.policy.max_output_chars] + "\n...<truncated>..."
+
+            payload = res.to_dict()
+            payload["raw_output"] = raw
+            payload["elapsed_seconds"] = round(elapsed, 3)
+
+            return self._ok({"type": "result", "result": payload})
+        except Exception as e:
+            return self._err(f"Command execution failed: {e}")
+
+    def _safe_disconnect(self) -> None:
+        if self.state.session:
+            try:
+                self.state.api.disconnect(self.state.session)
+            finally:
+                self.state.session = None
+                self.connected_device = None
+
+    def do_unlock(self, password: str) -> Dict[str, Any]:
+        """Internal method to perform unlock with password."""
+        try:
+            ok = self.state.api.unlock(password)
+            self.state.vault_unlocked = bool(ok)
+            return self._ok({"type": "unlock", "vault_unlocked": self.state.vault_unlocked})
+        except Exception as e:
+            return self._err(f"Unlock failed: {e}")
+
+    def _help_text(self) -> str:
+        return (
+            "Commands:\n"
+            "  :unlock             (prompts for vault password securely)\n"
+            "  :lock\n"
+            "  :creds [pattern]\n"
+            "  :devices [pattern]\n"
+            "  :connect <device> [--cred name]\n"
+            "  :disconnect\n"
+            "  :policy [read_only|ops]\n"
+            "  :mode [raw|parsed]  (control output format, default: parsed)\n"
+            "  :format [text|rich|json] (parsed mode display format, default: text)\n"
+            "  :set_hint <platform> (override TextFSM platform, e.g., cisco_ios)\n"
+            "  :clear_hint         (use auto-detected platform)\n"
+            "  :debug [on|off]     (show full result data for troubleshooting)\n"
+            "  :dbinfo             (show TextFSM database status)\n"
+            "  (anything else runs as CLI on the connected session)\n"
+            "  :help\n"
+            "  :exit\n"
+        )
+
+    def _ok(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        return {"ok": True, "data": data, "ts": datetime.now().isoformat()}
+
+    def _err(self, message: str) -> Dict[str, Any]:
+        return {"ok": False, "error": message, "ts": datetime.now().isoformat()}

ntermqt-0.1.6/nterm/scripting/repl_interactive.py

@@ -0,0 +1,418 @@
+"""
+nterm Interactive REPL
+
+Launch with: api.repl()
+
+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
+
+
+def start_repl(api: Optional[NTermAPI] = None, policy: Optional[REPLPolicy] = None):
+    """
+    Start interactive REPL in IPython or terminal.
+
+    Args:
+        api: NTermAPI instance (creates default if None)
+        policy: REPLPolicy (uses read_only default if None)
+
+    Examples:
+        # Default read-only mode
+        api.repl()
+
+        # Operations mode (allows config changes)
+        policy = REPLPolicy(mode="ops")
+        api.repl(policy=policy)
+
+        # Custom policy
+        policy = REPLPolicy(
+            mode="read_only",
+            deny_substrings=["reload", "wr"],
+            allow_prefixes=["show", "display"],
+        )
+        api.repl(policy=policy)
+    """
+    if api is None:
+        from nterm.scripting import api as default_api
+        api = default_api
+
+    repl = NTermREPL(api=api, policy=policy)
+
+    print()
+    print("=" * 60)
+    print("nterm REPL - Safe Network Automation Interface")
+    print("=" * 60)
+    print()
+    print(f"Policy: {repl.state.policy.mode}")
+    print(f"Output: {repl.state.output_mode} ({repl.state.output_format})")
+    print(f"Vault: {'unlocked' if api.vault_unlocked else 'locked'}")
+
+    # Check TextFSM database health
+    try:
+        db_info = api.db_info()
+        db_size = db_info.get('db_size', 0)
+        if not db_info.get('db_exists'):
+            print(f"\n⚠️  TextFSM database not found!")
+            print(f"   Parsing will be unavailable. Use :dbinfo for details.")
+        elif db_size == 0:
+            print(f"\n⚠️  TextFSM database is empty (0 bytes)!")
+            print(f"   Parsing will fail. Use :dbinfo for details.")
+        elif db_size < 100000:
+            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()
+    print("Type :help for commands, :exit to quit")
+    print()
+
+    # 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> "
+
+            try:
+                line = input(prompt)
+            except EOFError:
+                # Ctrl+D
+                break
+            except KeyboardInterrupt:
+                # Ctrl+C
+                print()
+                continue
+
+            # Handle command
+            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")
+
+            if cmd_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)
+                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
+            else:
+                # Unknown type, show raw data
+                import json
+                print(json.dumps(data, indent=2))
+
+    finally:
+        # Clean up
+        if repl.state.session:
+            print("\nDisconnecting...")
+            repl._safe_disconnect()
+        print("\nREPL closed")
+
+
+def _print_parsed_data(data, max_rows=20):
+    """Pretty print parsed data (list of dicts) in text format."""
+    if not data:
+        print("(empty)")
+        return
+
+    if not isinstance(data, list):
+        import json
+        print(json.dumps(data, indent=2))
+        return
+
+    # Get all unique keys
+    all_keys = set()
+    for row in data:
+        if isinstance(row, dict):
+            all_keys.update(row.keys())
+
+    keys = sorted(all_keys)
+
+    if not keys:
+        import json
+        print(json.dumps(data, indent=2))
+        return
+
+    # Calculate column widths
+    col_widths = {}
+    for key in keys:
+        col_widths[key] = len(key)
+
+    for row in data[:max_rows]:
+        if isinstance(row, dict):
+            for key in keys:
+                val = str(row.get(key, ""))
+                col_widths[key] = max(col_widths[key], len(val))
+
+    # Cap widths
+    for key in keys:
+        col_widths[key] = min(col_widths[key], 30)
+
+    # Print header
+    header = " | ".join(key[:col_widths[key]].ljust(col_widths[key]) for key in keys)
+    print(header)
+    print("-" * len(header))
+
+    # Print rows
+    shown = 0
+    for row in data:
+        if not isinstance(row, dict):
+            continue
+        if shown >= max_rows:
+            remaining = len(data) - shown
+            print(f"... ({remaining} more rows)")
+            break
+
+        values = []
+        for key in keys:
+            val = str(row.get(key, ""))
+            if len(val) > col_widths[key]:
+                val = val[:col_widths[key] - 3] + "..."
+            values.append(val.ljust(col_widths[key]))
+
+        print(" | ".join(values))
+        shown += 1
+
+
+def _print_parsed_data_rich(data, max_rows=20):
+    """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)
+        return
+
+    if not data:
+        print("(empty)")
+        return
+
+    if not isinstance(data, list):
+        import json
+        print(json.dumps(data, indent=2))
+        return
+
+    # Get all unique keys
+    all_keys = set()
+    for row in data:
+        if isinstance(row, dict):
+            all_keys.update(row.keys())
+
+    keys = sorted(all_keys)
+
+    if not keys:
+        import json
+        print(json.dumps(data, indent=2))
+        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):
+            continue
+        if shown >= max_rows:
+            remaining = len(data) - shown
+            console.print(f"[yellow]... ({remaining} more rows)[/yellow]")
+            break
+
+        values = [str(row.get(key, "")) for key in keys]
+        table.add_row(*values)
+        shown += 1
+
+    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):
+    """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

{ntermqt-0.1.5 → ntermqt-0.1.6}/nterm/session/local_terminal.py

@@ -20,6 +20,7 @@ logger = logging.getLogger(__name__)
 IPYTHON_STARTUP = '''
 from nterm.scripting import api
 print("\\n\\033[1;36mnterm API loaded.\\033[0m")
+print("  api.repl()         _ Start CLI/repl")
 print("  api.devices()      - List saved devices")
 print("  api.search(query)  - Search devices")  
 print("  api.credentials()  - List credentials (after api.unlock())")

{ntermqt-0.1.5 → ntermqt-0.1.6/ntermqt.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ntermqt
-Version: 0.1.5
+Version: 0.1.6
 Summary: Modern SSH terminal widget for PyQt6 with credential vault and jump host support
 Author: Scott Peterman
 License: GPL-3.0
@@ -29,6 +29,7 @@ Requires-Dist: click>=8.0.0
 Requires-Dist: ipython>=8.0.0
 Requires-Dist: requests>=2.10.0
 Requires-Dist: textfsm>=2.0.0
+Requires-Dist: rich>=14.0.0
 Requires-Dist: pexpect>=4.8.0; sys_platform != "win32"
 Requires-Dist: pywinpty>=2.0.0; sys_platform == "win32"
 Provides-Extra: keyring
@@ -110,6 +111,8 @@ 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)
+
 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.
 
 ```python

{ntermqt-0.1.5 → ntermqt-0.1.6}/ntermqt.egg-info/SOURCES.txt

@@ -25,6 +25,8 @@ nterm/parser/tfsm_fire_tester.py
 nterm/scripting/__init__.py
 nterm/scripting/api.py
 nterm/scripting/cli.py
+nterm/scripting/repl.py
+nterm/scripting/repl_interactive.py
 nterm/session/__init__.py
 nterm/session/askpass_ssh.py
 nterm/session/base.py

{ntermqt-0.1.5 → ntermqt-0.1.6}/ntermqt.egg-info/requires.txt

@@ -7,6 +7,7 @@ click>=8.0.0
 ipython>=8.0.0
 requests>=2.10.0
 textfsm>=2.0.0
+rich>=14.0.0
 
 [:sys_platform != "win32"]
 pexpect>=4.8.0

{ntermqt-0.1.5 → ntermqt-0.1.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ntermqt"
-version = "0.1.5"
+version = "0.1.6"
 description = "Modern SSH terminal widget for PyQt6 with credential vault and jump host support"
 readme = "README.md"
 license = {text = "GPL-3.0"}
@@ -34,6 +34,7 @@ dependencies = [
     "ipython>=8.0.0",
     "requests>=2.10.0",
     "textfsm>=2.0.0",
+    "rich>=14.0.0",
     # Platform-specific PTY support
     "pexpect>=4.8.0; sys_platform != 'win32'",
     "pywinpty>=2.0.0; sys_platform == 'win32'",