ntermqt 0.1.1__py3-none-any.whl → 0.1.4__py3-none-any.whl

nterm/scripting/cli.py

@@ -0,0 +1,305 @@
+"""
+nterm/scripting/cli.py
+
+Command-line interface for nterm scripting API.
+
+Usage:
+    nterm-cli devices
+    nterm-cli search leaf
+    nterm-cli device eng-leaf-1
+    nterm-cli credentials --unlock
+    nterm-cli status
+"""
+
+import sys
+import json
+import getpass
+from typing import Optional
+
+import click
+
+from .api import NTermAPI, DeviceInfo, CredentialInfo
+
+# Shared API instance
+_api: Optional[NTermAPI] = None
+
+
+def get_api() -> NTermAPI:
+    global _api
+    if _api is None:
+        _api = NTermAPI()
+    return _api
+
+
+def format_table(items: list, columns: list[tuple[str, str, int]]) -> str:
+    """
+    Format items as a simple table.
+
+    Args:
+        items: List of objects with attributes
+        columns: List of (attr_name, header, width) tuples
+    """
+    if not items:
+        return "No results."
+
+    # Build header
+    header = ""
+    separator = ""
+    for attr, name, width in columns:
+        header += f"{name:<{width}} "
+        separator += "-" * width + " "
+
+    lines = [header.rstrip(), separator.rstrip()]
+
+    # Build rows
+    for item in items:
+        row = ""
+        for attr, name, width in columns:
+            val = getattr(item, attr, "")
+            if val is None:
+                val = ""
+            val_str = str(val)[:width - 1]  # Truncate if needed
+            row += f"{val_str:<{width}} "
+        lines.append(row.rstrip())
+
+    return "\n".join(lines)
+
+
+@click.group()
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON")
+@click.pass_context
+def cli(ctx, output_json):
+    """nterm command-line interface for device and credential management."""
+    ctx.ensure_object(dict)
+    ctx.obj["json"] = output_json
+
+
+@cli.command("devices")
+@click.option("-p", "--pattern", default=None, help="Filter by glob pattern (e.g., 'eng-*')")
+@click.option("-f", "--folder", default=None, help="Filter by folder name")
+@click.pass_context
+def list_devices(ctx, pattern, folder):
+    """List saved devices/sessions."""
+    api = get_api()
+    devices = api.devices(pattern=pattern, folder=folder)
+
+    if ctx.obj["json"]:
+        click.echo(json.dumps([d.to_dict() for d in devices], indent=2))
+    else:
+        columns = [
+            ("name", "NAME", 25),
+            ("hostname", "HOSTNAME", 20),
+            ("port", "PORT", 6),
+            ("folder", "FOLDER", 15),
+            ("credential", "CREDENTIAL", 20),
+        ]
+        click.echo(format_table(devices, columns))
+        click.echo(f"\n{len(devices)} device(s)")
+
+
+@cli.command("search")
+@click.argument("query")
+@click.pass_context
+def search_devices(ctx, query):
+    """Search devices by name, hostname, or description."""
+    api = get_api()
+    devices = api.search(query)
+
+    if ctx.obj["json"]:
+        click.echo(json.dumps([d.to_dict() for d in devices], indent=2))
+    else:
+        columns = [
+            ("name", "NAME", 25),
+            ("hostname", "HOSTNAME", 20),
+            ("port", "PORT", 6),
+            ("folder", "FOLDER", 15),
+            ("credential", "CREDENTIAL", 20),
+        ]
+        click.echo(format_table(devices, columns))
+        click.echo(f"\n{len(devices)} result(s)")
+
+
+@cli.command("device")
+@click.argument("name")
+@click.pass_context
+def get_device(ctx, name):
+    """Get details for a specific device."""
+    api = get_api()
+    device = api.device(name)
+
+    if not device:
+        click.echo(f"Device '{name}' not found.", err=True)
+        sys.exit(1)
+
+    if ctx.obj["json"]:
+        click.echo(json.dumps(device.to_dict(), indent=2))
+    else:
+        click.echo(f"Name:           {device.name}")
+        click.echo(f"Hostname:       {device.hostname}")
+        click.echo(f"Port:           {device.port}")
+        click.echo(f"Folder:         {device.folder or '(root)'}")
+        click.echo(f"Credential:     {device.credential or '(none)'}")
+        click.echo(f"Last Connected: {device.last_connected or 'never'}")
+        click.echo(f"Connect Count:  {device.connect_count}")
+
+
+@cli.command("folders")
+@click.pass_context
+def list_folders(ctx):
+    """List all folders."""
+    api = get_api()
+    folders = api.folders()
+
+    if ctx.obj["json"]:
+        click.echo(json.dumps(folders, indent=2))
+    else:
+        if folders:
+            for f in folders:
+                click.echo(f"  {f}")
+            click.echo(f"\n{len(folders)} folder(s)")
+        else:
+            click.echo("No folders.")
+
+
+@cli.command("credentials")
+@click.option("-p", "--pattern", default=None, help="Filter by glob pattern")
+@click.option("-u", "--unlock", is_flag=True, help="Prompt for vault password")
+@click.option("--password", default=None, help="Vault password (use --unlock for interactive)")
+@click.pass_context
+def list_credentials(ctx, pattern, unlock, password):
+    """List credentials (requires unlocked vault)."""
+    api = get_api()
+
+    # Handle vault unlock
+    if not api.vault_initialized:
+        click.echo("Vault not initialized. Run nterm to create a vault first.", err=True)
+        sys.exit(1)
+
+    if not api.vault_unlocked:
+        if unlock:
+            password = getpass.getpass("Vault password: ")
+
+        if password:
+            if not api.unlock(password):
+                click.echo("Failed to unlock vault. Wrong password?", err=True)
+                sys.exit(1)
+        else:
+            click.echo("Vault is locked. Use --unlock or --password to unlock.", err=True)
+            sys.exit(1)
+
+    credentials = api.credentials(pattern=pattern)
+
+    if ctx.obj["json"]:
+        click.echo(json.dumps([c.to_dict() for c in credentials], indent=2))
+    else:
+        columns = [
+            ("name", "NAME", 20),
+            ("username", "USERNAME", 15),
+            ("has_password", "PASS", 5),
+            ("has_key", "KEY", 5),
+            ("is_default", "DEFAULT", 8),
+            ("jump_host", "JUMP HOST", 20),
+        ]
+        click.echo(format_table(credentials, columns))
+        click.echo(f"\n{len(credentials)} credential(s)")
+
+
+@cli.command("credential")
+@click.argument("name")
+@click.option("-u", "--unlock", is_flag=True, help="Prompt for vault password")
+@click.option("--password", default=None, help="Vault password")
+@click.pass_context
+def get_credential(ctx, name, unlock, password):
+    """Get details for a specific credential."""
+    api = get_api()
+
+    # Handle vault unlock
+    if not api.vault_unlocked:
+        if unlock:
+            password = getpass.getpass("Vault password: ")
+
+        if password:
+            if not api.unlock(password):
+                click.echo("Failed to unlock vault.", err=True)
+                sys.exit(1)
+        else:
+            click.echo("Vault is locked. Use --unlock or --password.", err=True)
+            sys.exit(1)
+
+    cred = api.credential(name)
+
+    if not cred:
+        click.echo(f"Credential '{name}' not found.", err=True)
+        sys.exit(1)
+
+    if ctx.obj["json"]:
+        click.echo(json.dumps(cred.to_dict(), indent=2))
+    else:
+        click.echo(f"Name:         {cred.name}")
+        click.echo(f"Username:     {cred.username}")
+        click.echo(f"Has Password: {cred.has_password}")
+        click.echo(f"Has Key:      {cred.has_key}")
+        click.echo(f"Is Default:   {cred.is_default}")
+        click.echo(f"Jump Host:    {cred.jump_host or '(none)'}")
+        click.echo(f"Match Hosts:  {', '.join(cred.match_hosts) or '(any)'}")
+        click.echo(f"Match Tags:   {', '.join(cred.match_tags) or '(any)'}")
+
+
+@cli.command("resolve")
+@click.argument("hostname")
+@click.option("-u", "--unlock", is_flag=True, help="Prompt for vault password")
+@click.option("--password", default=None, help="Vault password")
+@click.pass_context
+def resolve_credential(ctx, hostname, unlock, password):
+    """Find which credential would be used for a hostname."""
+    api = get_api()
+
+    # Handle vault unlock
+    if not api.vault_unlocked:
+        if unlock:
+            password = getpass.getpass("Vault password: ")
+
+        if password:
+            if not api.unlock(password):
+                click.echo("Failed to unlock vault.", err=True)
+                sys.exit(1)
+        else:
+            click.echo("Vault is locked. Use --unlock or --password.", err=True)
+            sys.exit(1)
+
+    cred_name = api.resolve_credential(hostname)
+
+    if ctx.obj["json"]:
+        click.echo(json.dumps({"hostname": hostname, "credential": cred_name}))
+    else:
+        if cred_name:
+            click.echo(f"{hostname} -> {cred_name}")
+        else:
+            click.echo(f"No matching credential for {hostname}")
+
+
+@cli.command("status")
+@click.pass_context
+def show_status(ctx):
+    """Show API status summary."""
+    api = get_api()
+    status = api.status()
+
+    if ctx.obj["json"]:
+        click.echo(json.dumps(status, indent=2))
+    else:
+        click.echo(f"Devices:           {status['devices']}")
+        click.echo(f"Folders:           {status['folders']}")
+        click.echo(f"Vault Initialized: {status['vault_initialized']}")
+        click.echo(f"Vault Unlocked:    {status['vault_unlocked']}")
+        if status['vault_unlocked']:
+            click.echo(f"Credentials:       {status['credentials']}")
+
+
+def main():
+    """Entry point for CLI."""
+    cli(obj={})
+
+
+if __name__ == "__main__":
+    main()

nterm/session/local_terminal.py

@@ -0,0 +1,225 @@
+"""
+Standalone local terminal session.
+Minimal Session-compatible wrapper for local PTY processes.
+"""
+
+import sys
+import os
+import threading
+import time
+import logging
+from typing import Optional, Callable, List
+
+from .pty_transport import create_pty, is_pty_available, PTYTransport
+from .base import SessionState, SessionEvent, DataReceived, StateChanged
+
+logger = logging.getLogger(__name__)
+
+
+# IPython startup code to inject the nterm API
+IPYTHON_STARTUP = '''
+from nterm.scripting import api
+print("\\n\\033[1;36mnterm API loaded.\\033[0m")
+print("  api.devices()      - List saved devices")
+print("  api.search(query)  - Search devices")  
+print("  api.credentials()  - List credentials (after api.unlock())")
+print("  api.help()         - Show all commands")
+print()
+'''
+
+
+class LocalTerminal:
+    """
+    Lightweight local PTY session.
+
+    Implements just enough of Session interface for TerminalWidget.
+    Completely separate from SSH session management.
+
+    Usage:
+        # Default shell
+        session = LocalTerminal()
+
+        # IPython with nterm API pre-loaded
+        session = LocalTerminal.ipython()
+
+        # Python REPL
+        session = LocalTerminal.python()
+
+        # Arbitrary command
+        session = LocalTerminal(['htop'])
+    """
+
+    def __init__(self, command: Optional[List[str]] = None):
+        """
+        Initialize local terminal session.
+
+        Args:
+            command: Command to run. Defaults to user's shell.
+        """
+        self._command = command or self._default_shell()
+        self._pty: Optional[PTYTransport] = None
+        self._state = SessionState.DISCONNECTED
+        self._stop = threading.Event()
+        self._handler: Optional[Callable[[SessionEvent], None]] = None
+        self._cols, self._rows = 120, 40
+
+    @staticmethod
+    def _default_shell() -> List[str]:
+        """Get user's default shell."""
+        if sys.platform == 'win32':
+            return [os.environ.get('COMSPEC', 'cmd.exe')]
+        return [os.environ.get('SHELL', '/bin/bash')]
+
+    @classmethod
+    def ipython(cls, with_api: bool = True) -> 'LocalTerminal':
+        """
+        Create IPython session in current venv.
+
+        Args:
+            with_api: If True, pre-load nterm scripting API into namespace
+
+        Returns:
+            LocalTerminal configured to run IPython
+
+        Raises:
+            RuntimeError: If IPython is not installed
+        """
+        try:
+            import IPython  # noqa: F401
+        except ImportError:
+            raise RuntimeError(
+                "IPython not installed. Install with: pip install ntermqt[scripting]"
+            )
+
+        if with_api:
+            # Use -i with -c to run startup code then go interactive
+            cmd = [
+                sys.executable, '-m', 'IPython',
+                '-i', '-c', IPYTHON_STARTUP
+            ]
+        else:
+            cmd = [sys.executable, '-m', 'IPython']
+        return cls(cmd)
+
+    @classmethod
+    def python(cls) -> 'LocalTerminal':
+        """
+        Create Python REPL session in current venv.
+
+        Returns:
+            LocalTerminal configured to run Python
+        """
+        return cls([sys.executable])
+
+    @classmethod
+    def shell(cls, shell: str = None) -> 'LocalTerminal':
+        """
+        Create shell session.
+
+        Args:
+            shell: Optional shell path. Defaults to user's default shell.
+
+        Returns:
+            LocalTerminal configured to run shell
+        """
+        if shell:
+            return cls([shell])
+        return cls()
+
+    # -------------------------------------------------------------------------
+    # Session interface (minimal subset for TerminalWidget compatibility)
+    # -------------------------------------------------------------------------
+
+    @property
+    def state(self) -> SessionState:
+        """Current session state."""
+        return self._state
+
+    @property
+    def is_connected(self) -> bool:
+        """Check if process is running."""
+        return self._state == SessionState.CONNECTED
+
+    def set_event_handler(self, handler: Callable[[SessionEvent], None]) -> None:
+        """Set callback for session events."""
+        self._handler = handler
+
+    def set_auto_reconnect(self, enabled: bool) -> None:
+        """No-op for local sessions."""
+        pass
+
+    def connect(self) -> None:
+        """Start the local process."""
+        if not is_pty_available():
+            self._set_state(SessionState.FAILED, "PTY unavailable. On Windows, install pywinpty.")
+            return
+        self._stop.clear()
+        threading.Thread(target=self._run, daemon=True).start()
+
+    def write(self, data: bytes) -> None:
+        """Send input to process."""
+        if self._pty:
+            self._pty.write(data)
+
+    def resize(self, cols: int, rows: int) -> None:
+        """Resize terminal."""
+        self._cols, self._rows = cols, rows
+        if self._pty:
+            self._pty.resize(cols, rows)
+
+    def disconnect(self) -> None:
+        """Terminate the process."""
+        self._stop.set()
+        if self._pty:
+            self._pty.close()
+            self._pty = None
+        self._set_state(SessionState.DISCONNECTED, "Closed")
+
+    # -------------------------------------------------------------------------
+    # Internal
+    # -------------------------------------------------------------------------
+
+    def _set_state(self, state: SessionState, msg: str = ""):
+        """Update state and notify handler."""
+        old, self._state = self._state, state
+        logger.debug(f"LocalTerminal: {old.name} -> {state.name} {msg}")
+        if self._handler:
+            try:
+                self._handler(StateChanged(old, state, msg))
+            except Exception as e:
+                logger.exception(f"Event handler error: {e}")
+
+    def _run(self):
+        """Main PTY read loop (runs in thread)."""
+        try:
+            self._set_state(SessionState.CONNECTING)
+
+            logger.info(f"Spawning: {' '.join(self._command)}")
+
+            self._pty = create_pty()
+            self._pty.spawn(self._command, echo=True)  # Local apps need echo
+            self._pty.resize(self._cols, self._rows)
+
+            self._set_state(SessionState.CONNECTED)
+
+            # Read loop
+            while not self._stop.is_set() and self._pty.is_alive:
+                data = self._pty.read(8192)
+                if data and self._handler:
+                    self._handler(DataReceived(data))
+                else:
+                    time.sleep(0.01)
+
+            # Process exited
+            if not self._stop.is_set():
+                exit_code = self._pty.exit_code if self._pty else None
+                msg = f"Process exited (code {exit_code})" if exit_code is not None else "Process exited"
+                self._set_state(SessionState.DISCONNECTED, msg)
+
+        except Exception as e:
+            logger.exception("LocalTerminal failed")
+            self._set_state(SessionState.FAILED, str(e))
+        finally:
+            if self._pty:
+                self._pty.close()
+                self._pty = None