qssh 0.1.0__tar.gz

qssh-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

qssh-0.1.0/PKG-INFO

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: qssh
+Version: 0.1.0
+Summary: Quick SSH session manager - save your VM credentials and connect with a single command
+Author-email: joan-code6 <your-email@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/yourusername/qssh
+Project-URL: Repository, https://github.com/yourusername/qssh
+Project-URL: Issues, https://github.com/yourusername/qssh/issues
+Keywords: ssh,session,manager,vm,cli,terminal
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: System :: Networking
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: pyyaml>=6.0
+Dynamic: license-file
+
+# qssh
+
+**Quick SSH session manager** - Save your VM credentials and connect with a single command.
+
+Tired of copy-pasting credentials every time you want to SSH into your VMs? `qssh` lets you save your session configs and connect instantly.
+
+## Installation
+
+```bash
+pip install qssh
+```
+
+## Quick Start
+
+### 1. Add a new session
+
+```bash
+qssh add outcraft
+```
+
+You'll be prompted for:
+- Host (IP address or hostname)
+- Username
+- Port (default: 22)
+- Authentication method (password or key file)
+
+### 2. Connect to your VM
+
+```bash
+qssh outcraft
+```
+
+That's it! You're connected.
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `qssh <session>` | Connect to a saved session |
+| `qssh add <name>` | Add a new session |
+| `qssh list` | List all saved sessions |
+| `qssh remove <name>` | Remove a session |
+| `qssh edit <name>` | Edit an existing session |
+| `qssh show <name>` | Show session details |
+| `qssh config` | Show config file location |
+
+## Examples
+
+```bash
+# Add a session for your OutCraft VM
+qssh add outcraft
+# Host: 192.168.1.100
+# Username: admin
+# Port [22]: 22
+# Auth type (password/key) [password]: password
+# Password: ********
+
+# Now just connect with:
+qssh outcraft
+
+# List all your sessions
+qssh list
+
+# Remove a session
+qssh remove old-server
+
+# Show details of a session
+qssh show outcraft
+```
+
+## Using SSH Keys
+
+For key-based authentication:
+
+```bash
+qssh add myserver
+# Host: example.com
+# Username: deploy
+# Port [22]: 22
+# Auth type (password/key) [password]: key
+# Key file path: ~/.ssh/id_rsa
+```
+
+## Configuration
+
+Sessions are stored in `~/.qssh/sessions.yaml`. Passwords are stored encoded (not plaintext) but for maximum security, consider using SSH keys instead.
+
+## License
+
+MIT License

qssh-0.1.0/README.md

@@ -0,0 +1,90 @@
+# qssh
+
+**Quick SSH session manager** - Save your VM credentials and connect with a single command.
+
+Tired of copy-pasting credentials every time you want to SSH into your VMs? `qssh` lets you save your session configs and connect instantly.
+
+## Installation
+
+```bash
+pip install qssh
+```
+
+## Quick Start
+
+### 1. Add a new session
+
+```bash
+qssh add outcraft
+```
+
+You'll be prompted for:
+- Host (IP address or hostname)
+- Username
+- Port (default: 22)
+- Authentication method (password or key file)
+
+### 2. Connect to your VM
+
+```bash
+qssh outcraft
+```
+
+That's it! You're connected.
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `qssh <session>` | Connect to a saved session |
+| `qssh add <name>` | Add a new session |
+| `qssh list` | List all saved sessions |
+| `qssh remove <name>` | Remove a session |
+| `qssh edit <name>` | Edit an existing session |
+| `qssh show <name>` | Show session details |
+| `qssh config` | Show config file location |
+
+## Examples
+
+```bash
+# Add a session for your OutCraft VM
+qssh add outcraft
+# Host: 192.168.1.100
+# Username: admin
+# Port [22]: 22
+# Auth type (password/key) [password]: password
+# Password: ********
+
+# Now just connect with:
+qssh outcraft
+
+# List all your sessions
+qssh list
+
+# Remove a session
+qssh remove old-server
+
+# Show details of a session
+qssh show outcraft
+```
+
+## Using SSH Keys
+
+For key-based authentication:
+
+```bash
+qssh add myserver
+# Host: example.com
+# Username: deploy
+# Port [22]: 22
+# Auth type (password/key) [password]: key
+# Key file path: ~/.ssh/id_rsa
+```
+
+## Configuration
+
+Sessions are stored in `~/.qssh/sessions.yaml`. Passwords are stored encoded (not plaintext) but for maximum security, consider using SSH keys instead.
+
+## License
+
+MIT License

qssh-0.1.0/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "qssh"
+version = "0.1.0"
+description = "Quick SSH session manager - save your VM credentials and connect with a single command"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [
+    {name = "joan-code6", email = "your-email@example.com"}
+]
+keywords = ["ssh", "session", "manager", "vm", "cli", "terminal"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Intended Audience :: System Administrators",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: System :: Networking",
+    "Topic :: Utilities",
+]
+requires-python = ">=3.8"
+dependencies = [
+    "click>=8.0.0",
+    "rich>=13.0.0",
+    "pyyaml>=6.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/yourusername/qssh"
+Repository = "https://github.com/yourusername/qssh"
+Issues = "https://github.com/yourusername/qssh/issues"
+
+[project.scripts]
+qssh = "qssh.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+qssh = ["py.typed"]

qssh-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

qssh-0.1.0/src/qssh/__init__.py

@@ -0,0 +1,9 @@
+"""qssh - Quick SSH session manager."""
+
+__version__ = "0.1.0"
+__author__ = "benne"
+
+from .session import SessionManager
+from .connector import SSHConnector
+
+__all__ = ["SessionManager", "SSHConnector", "__version__"]

qssh-0.1.0/src/qssh/cli.py

@@ -0,0 +1,281 @@
+"""Command-line interface for qssh."""
+
+import sys
+import click
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.prompt import Prompt, Confirm
+
+from . import __version__
+from .session import Session, SessionManager
+from .connector import SSHConnector
+
+
+console = Console()
+manager = SessionManager()
+connector = SSHConnector()
+
+
+@click.group(invoke_without_command=True)
+@click.argument("session_name", required=False)
+@click.option("--version", "-v", is_flag=True, help="Show version")
+@click.pass_context
+def main(ctx, session_name: str, version: bool):
+    """qssh - Quick SSH session manager.
+    
+    Connect to a saved session:
+    
+        qssh <session-name>
+    
+    Or use subcommands to manage sessions:
+    
+        qssh add <name>      Add a new session
+        
+        qssh list            List all sessions
+        
+        qssh remove <name>   Remove a session
+    """
+    if version:
+        console.print(f"[bold blue]qssh[/] version [green]{__version__}[/]")
+        return
+    
+    if ctx.invoked_subcommand is None:
+        if session_name:
+            # Try to connect to the session
+            _connect(session_name)
+        else:
+            # Show help
+            click.echo(ctx.get_help())
+
+
+def _connect(name: str) -> None:
+    """Connect to a session by name."""
+    session = manager.get(name)
+    
+    if not session:
+        console.print(f"[red]Session '[bold]{name}[/bold]' not found.[/]")
+        console.print("\nAvailable sessions:")
+        _list_sessions_simple()
+        console.print(f"\n[dim]Use 'qssh add {name}' to create this session.[/]")
+        sys.exit(1)
+    
+    console.print(f"[bold blue]Connecting to[/] [green]{name}[/] ({session.username}@{session.host}:{session.port})")
+    console.print()
+    
+    exit_code = connector.connect(session)
+    sys.exit(exit_code)
+
+
+def _list_sessions_simple() -> None:
+    """List sessions in a simple format."""
+    sessions = manager.list_all()
+    if not sessions:
+        console.print("[dim]  No sessions saved yet.[/]")
+        return
+    
+    for s in sessions:
+        console.print(f"  • [cyan]{s.name}[/] → {s.username}@{s.host}")
+
+
+@main.command("add")
+@click.argument("name")
+def add_session(name: str):
+    """Add a new SSH session."""
+    if manager.exists(name):
+        if not Confirm.ask(f"Session '[bold]{name}[/]' already exists. Overwrite?"):
+            console.print("[yellow]Cancelled.[/]")
+            return
+    
+    console.print(Panel(f"[bold blue]Adding session:[/] [green]{name}[/]", expand=False))
+    
+    # Gather session info
+    host = Prompt.ask("[bold]Host[/] (IP or hostname)")
+    username = Prompt.ask("[bold]Username[/]")
+    port = Prompt.ask("[bold]Port[/]", default="22")
+    
+    try:
+        port = int(port)
+    except ValueError:
+        console.print("[red]Invalid port number. Using 22.[/]")
+        port = 22
+    
+    auth_type = Prompt.ask(
+        "[bold]Auth type[/]",
+        choices=["password", "key"],
+        default="password"
+    )
+    
+    password = None
+    key_file = None
+    
+    if auth_type == "password":
+        password_raw = Prompt.ask("[bold]Password[/]", password=True)
+        if password_raw:
+            password = Session.encode_password(password_raw)
+    else:
+        key_file = Prompt.ask(
+            "[bold]Key file path[/]",
+            default="~/.ssh/id_rsa"
+        )
+    
+    # Create and save session
+    session = Session(
+        name=name,
+        host=host,
+        username=username,
+        port=port,
+        auth_type=auth_type,
+        password=password,
+        key_file=key_file,
+    )
+    
+    manager.add(session)
+    console.print(f"\n[green]✓[/] Session '[bold]{name}[/]' saved!")
+    console.print(f"[dim]Connect with: qssh {name}[/]")
+
+
+@main.command("list")
+def list_sessions():
+    """List all saved sessions."""
+    sessions = manager.list_all()
+    
+    if not sessions:
+        console.print("[yellow]No sessions saved yet.[/]")
+        console.print("[dim]Use 'qssh add <name>' to add one.[/]")
+        return
+    
+    table = Table(title="SSH Sessions", show_header=True, header_style="bold blue")
+    table.add_column("Name", style="cyan", no_wrap=True)
+    table.add_column("Host", style="green")
+    table.add_column("User", style="yellow")
+    table.add_column("Port", justify="right")
+    table.add_column("Auth", style="magenta")
+    
+    for session in sessions:
+        auth_display = "🔑 key" if session.auth_type == "key" else "🔒 pass"
+        table.add_row(
+            session.name,
+            session.host,
+            session.username,
+            str(session.port),
+            auth_display,
+        )
+    
+    console.print(table)
+
+
+@main.command("remove")
+@click.argument("name")
+def remove_session(name: str):
+    """Remove a saved session."""
+    if not manager.exists(name):
+        console.print(f"[red]Session '[bold]{name}[/bold]' not found.[/]")
+        sys.exit(1)
+    
+    if Confirm.ask(f"Remove session '[bold]{name}[/]'?"):
+        manager.remove(name)
+        console.print(f"[green]✓[/] Session '[bold]{name}[/]' removed.")
+    else:
+        console.print("[yellow]Cancelled.[/]")
+
+
+@main.command("edit")
+@click.argument("name")
+def edit_session(name: str):
+    """Edit an existing session."""
+    session = manager.get(name)
+    
+    if not session:
+        console.print(f"[red]Session '[bold]{name}[/bold]' not found.[/]")
+        sys.exit(1)
+    
+    console.print(Panel(f"[bold blue]Editing session:[/] [green]{name}[/]", expand=False))
+    console.print("[dim]Press Enter to keep current value.[/]\n")
+    
+    # Gather updated info
+    host = Prompt.ask("[bold]Host[/]", default=session.host)
+    username = Prompt.ask("[bold]Username[/]", default=session.username)
+    port = Prompt.ask("[bold]Port[/]", default=str(session.port))
+    
+    try:
+        port = int(port)
+    except ValueError:
+        port = session.port
+    
+    auth_type = Prompt.ask(
+        "[bold]Auth type[/]",
+        choices=["password", "key"],
+        default=session.auth_type
+    )
+    
+    password = session.password
+    key_file = session.key_file
+    
+    if auth_type == "password":
+        if Confirm.ask("Update password?", default=False):
+            password_raw = Prompt.ask("[bold]Password[/]", password=True)
+            if password_raw:
+                password = Session.encode_password(password_raw)
+        key_file = None
+    else:
+        key_file = Prompt.ask(
+            "[bold]Key file path[/]",
+            default=session.key_file or "~/.ssh/id_rsa"
+        )
+        password = None
+    
+    # Update session
+    updated = Session(
+        name=name,
+        host=host,
+        username=username,
+        port=port,
+        auth_type=auth_type,
+        password=password,
+        key_file=key_file,
+    )
+    
+    manager.add(updated)
+    console.print(f"\n[green]✓[/] Session '[bold]{name}[/]' updated!")
+
+
+@main.command("show")
+@click.argument("name")
+def show_session(name: str):
+    """Show details of a session."""
+    session = manager.get(name)
+    
+    if not session:
+        console.print(f"[red]Session '[bold]{name}[/bold]' not found.[/]")
+        sys.exit(1)
+    
+    table = Table(show_header=False, box=None, padding=(0, 2))
+    table.add_column("Property", style="bold blue")
+    table.add_column("Value", style="green")
+    
+    table.add_row("Name", session.name)
+    table.add_row("Host", session.host)
+    table.add_row("Username", session.username)
+    table.add_row("Port", str(session.port))
+    table.add_row("Auth Type", session.auth_type)
+    
+    if session.auth_type == "key":
+        table.add_row("Key File", session.key_file or "~/.ssh/id_rsa")
+    else:
+        table.add_row("Password", "••••••••" if session.password else "[dim]not set[/]")
+    
+    console.print(Panel(table, title=f"[bold]Session: {name}[/]", expand=False))
+    console.print(f"\n[dim]Connect with: qssh {name}[/]")
+
+
+@main.command("config")
+def show_config():
+    """Show configuration file location."""
+    config_path = manager.get_config_path()
+    console.print(f"[bold blue]Config directory:[/] [green]{config_path}[/]")
+    console.print(f"[bold blue]Sessions file:[/]   [green]{config_path / 'sessions.yaml'}[/]")
+
+
+if __name__ == "__main__":
+    main()

qssh-0.1.0/src/qssh/connector.py

@@ -0,0 +1,143 @@
+"""SSH connection handler for qssh."""
+
+import os
+import sys
+import subprocess
+import platform
+from typing import Optional
+
+from .session import Session
+
+
+class SSHConnector:
+    """Handles SSH connections to remote hosts."""
+    
+    def __init__(self):
+        """Initialize SSH connector."""
+        self.system = platform.system().lower()
+    
+    def connect(self, session: Session) -> int:
+        """Connect to a session.
+        
+        Args:
+            session: Session to connect to
+            
+        Returns:
+            Exit code from SSH process
+        """
+        if session.auth_type == "key":
+            return self._connect_with_key(session)
+        else:
+            return self._connect_with_password(session)
+    
+    def _connect_with_key(self, session: Session) -> int:
+        """Connect using SSH key authentication.
+        
+        Args:
+            session: Session configuration
+            
+        Returns:
+            Exit code
+        """
+        key_path = os.path.expanduser(session.key_file) if session.key_file else None
+        
+        cmd = [
+            "ssh",
+            "-o", "StrictHostKeyChecking=accept-new",
+            "-p", str(session.port),
+        ]
+        
+        if key_path:
+            cmd.extend(["-i", key_path])
+        
+        cmd.append(f"{session.username}@{session.host}")
+        
+        return self._run_ssh(cmd)
+    
+    def _connect_with_password(self, session: Session) -> int:
+        """Connect using password authentication.
+        
+        Uses sshpass if available, otherwise prompts for password.
+        
+        Args:
+            session: Session configuration
+            
+        Returns:
+            Exit code
+        """
+        password = session.get_password()
+        
+        # Check if sshpass is available for automatic password entry
+        if password and self._has_sshpass():
+            return self._connect_with_sshpass(session, password)
+        
+        # Fall back to regular SSH (will prompt for password if needed)
+        cmd = [
+            "ssh",
+            "-o", "StrictHostKeyChecking=accept-new",
+            "-p", str(session.port),
+            f"{session.username}@{session.host}",
+        ]
+        
+        if password:
+            # If we have a password but no sshpass, inform the user
+            print(f"[qssh] Password stored. Copy it or install 'sshpass' for auto-login.")
+            print(f"[qssh] Password: {password}")
+            print()
+        
+        return self._run_ssh(cmd)
+    
+    def _connect_with_sshpass(self, session: Session, password: str) -> int:
+        """Connect using sshpass for automatic password entry.
+        
+        Args:
+            session: Session configuration
+            password: Decoded password
+            
+        Returns:
+            Exit code
+        """
+        cmd = [
+            "sshpass", "-p", password,
+            "ssh",
+            "-o", "StrictHostKeyChecking=accept-new",
+            "-p", str(session.port),
+            f"{session.username}@{session.host}",
+        ]
+        
+        return self._run_ssh(cmd)
+    
+    def _has_sshpass(self) -> bool:
+        """Check if sshpass is available on the system."""
+        try:
+            subprocess.run(
+                ["sshpass", "-V"],
+                capture_output=True,
+                check=False
+            )
+            return True
+        except FileNotFoundError:
+            return False
+    
+    def _run_ssh(self, cmd: list) -> int:
+        """Run SSH command and return exit code.
+        
+        Args:
+            cmd: Command to run
+            
+        Returns:
+            Exit code
+        """
+        try:
+            # Run SSH interactively
+            result = subprocess.run(cmd)
+            return result.returncode
+        except FileNotFoundError:
+            print("[qssh] Error: SSH client not found.")
+            print("[qssh] Please ensure OpenSSH is installed and in your PATH.")
+            if self.system == "windows":
+                print("[qssh] On Windows, you can enable it in Settings > Apps > Optional Features")
+            return 1
+        except KeyboardInterrupt:
+            print("\n[qssh] Connection interrupted.")
+            return 130

qssh-0.1.0/src/qssh/session.py

@@ -0,0 +1,151 @@
+"""Session management for qssh."""
+
+import os
+import base64
+from pathlib import Path
+from dataclasses import dataclass, asdict
+from typing import Optional, Dict, List
+
+import yaml
+
+
+@dataclass
+class Session:
+    """Represents an SSH session configuration."""
+    
+    name: str
+    host: str
+    username: str
+    port: int = 22
+    auth_type: str = "password"  # "password" or "key"
+    password: Optional[str] = None  # base64 encoded
+    key_file: Optional[str] = None
+    
+    def to_dict(self) -> dict:
+        """Convert session to dictionary for storage."""
+        data = asdict(self)
+        # Don't store None values
+        return {k: v for k, v in data.items() if v is not None}
+    
+    @classmethod
+    def from_dict(cls, data: dict) -> "Session":
+        """Create session from dictionary."""
+        return cls(**data)
+    
+    def get_password(self) -> Optional[str]:
+        """Decode and return the password."""
+        if self.password:
+            try:
+                return base64.b64decode(self.password.encode()).decode()
+            except Exception:
+                return self.password
+        return None
+    
+    @staticmethod
+    def encode_password(password: str) -> str:
+        """Encode password for storage."""
+        return base64.b64encode(password.encode()).decode()
+
+
+class SessionManager:
+    """Manages SSH sessions storage and retrieval."""
+    
+    def __init__(self, config_dir: Optional[Path] = None):
+        """Initialize session manager.
+        
+        Args:
+            config_dir: Custom config directory. Defaults to ~/.qssh
+        """
+        if config_dir is None:
+            config_dir = Path.home() / ".qssh"
+        
+        self.config_dir = config_dir
+        self.sessions_file = config_dir / "sessions.yaml"
+        self._ensure_config_dir()
+    
+    def _ensure_config_dir(self) -> None:
+        """Create config directory if it doesn't exist."""
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Create sessions file if it doesn't exist
+        if not self.sessions_file.exists():
+            self._save_sessions({})
+    
+    def _load_sessions(self) -> Dict[str, dict]:
+        """Load sessions from file."""
+        if not self.sessions_file.exists():
+            return {}
+        
+        with open(self.sessions_file, "r", encoding="utf-8") as f:
+            data = yaml.safe_load(f)
+            return data if data else {}
+    
+    def _save_sessions(self, sessions: Dict[str, dict]) -> None:
+        """Save sessions to file."""
+        with open(self.sessions_file, "w", encoding="utf-8") as f:
+            yaml.dump(sessions, f, default_flow_style=False, sort_keys=False)
+    
+    def add(self, session: Session) -> None:
+        """Add or update a session.
+        
+        Args:
+            session: Session to add
+        """
+        sessions = self._load_sessions()
+        sessions[session.name] = session.to_dict()
+        self._save_sessions(sessions)
+    
+    def get(self, name: str) -> Optional[Session]:
+        """Get a session by name.
+        
+        Args:
+            name: Session name
+            
+        Returns:
+            Session if found, None otherwise
+        """
+        sessions = self._load_sessions()
+        if name in sessions:
+            return Session.from_dict(sessions[name])
+        return None
+    
+    def remove(self, name: str) -> bool:
+        """Remove a session.
+        
+        Args:
+            name: Session name
+            
+        Returns:
+            True if removed, False if not found
+        """
+        sessions = self._load_sessions()
+        if name in sessions:
+            del sessions[name]
+            self._save_sessions(sessions)
+            return True
+        return False
+    
+    def list_all(self) -> List[Session]:
+        """List all sessions.
+        
+        Returns:
+            List of all sessions
+        """
+        sessions = self._load_sessions()
+        return [Session.from_dict(data) for data in sessions.values()]
+    
+    def exists(self, name: str) -> bool:
+        """Check if session exists.
+        
+        Args:
+            name: Session name
+            
+        Returns:
+            True if exists
+        """
+        sessions = self._load_sessions()
+        return name in sessions
+    
+    def get_config_path(self) -> Path:
+        """Get the config directory path."""
+        return self.config_dir

qssh-0.1.0/src/qssh.egg-info/PKG-INFO

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: qssh
+Version: 0.1.0
+Summary: Quick SSH session manager - save your VM credentials and connect with a single command
+Author-email: joan-code6 <your-email@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/yourusername/qssh
+Project-URL: Repository, https://github.com/yourusername/qssh
+Project-URL: Issues, https://github.com/yourusername/qssh/issues
+Keywords: ssh,session,manager,vm,cli,terminal
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: System :: Networking
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: pyyaml>=6.0
+Dynamic: license-file
+
+# qssh
+
+**Quick SSH session manager** - Save your VM credentials and connect with a single command.
+
+Tired of copy-pasting credentials every time you want to SSH into your VMs? `qssh` lets you save your session configs and connect instantly.
+
+## Installation
+
+```bash
+pip install qssh
+```
+
+## Quick Start
+
+### 1. Add a new session
+
+```bash
+qssh add outcraft
+```
+
+You'll be prompted for:
+- Host (IP address or hostname)
+- Username
+- Port (default: 22)
+- Authentication method (password or key file)
+
+### 2. Connect to your VM
+
+```bash
+qssh outcraft
+```
+
+That's it! You're connected.
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `qssh <session>` | Connect to a saved session |
+| `qssh add <name>` | Add a new session |
+| `qssh list` | List all saved sessions |
+| `qssh remove <name>` | Remove a session |
+| `qssh edit <name>` | Edit an existing session |
+| `qssh show <name>` | Show session details |
+| `qssh config` | Show config file location |
+
+## Examples
+
+```bash
+# Add a session for your OutCraft VM
+qssh add outcraft
+# Host: 192.168.1.100
+# Username: admin
+# Port [22]: 22
+# Auth type (password/key) [password]: password
+# Password: ********
+
+# Now just connect with:
+qssh outcraft
+
+# List all your sessions
+qssh list
+
+# Remove a session
+qssh remove old-server
+
+# Show details of a session
+qssh show outcraft
+```
+
+## Using SSH Keys
+
+For key-based authentication:
+
+```bash
+qssh add myserver
+# Host: example.com
+# Username: deploy
+# Port [22]: 22
+# Auth type (password/key) [password]: key
+# Key file path: ~/.ssh/id_rsa
+```
+
+## Configuration
+
+Sessions are stored in `~/.qssh/sessions.yaml`. Passwords are stored encoded (not plaintext) but for maximum security, consider using SSH keys instead.
+
+## License
+
+MIT License

qssh-0.1.0/src/qssh.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+src/qssh/__init__.py
+src/qssh/cli.py
+src/qssh/connector.py
+src/qssh/py.typed
+src/qssh/session.py
+src/qssh.egg-info/PKG-INFO
+src/qssh.egg-info/SOURCES.txt
+src/qssh.egg-info/dependency_links.txt
+src/qssh.egg-info/entry_points.txt
+src/qssh.egg-info/requires.txt
+src/qssh.egg-info/top_level.txt

qssh-0.1.0/src/qssh.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

qssh-0.1.0/src/qssh.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+qssh = qssh.cli:main

qssh-0.1.0/src/qssh.egg-info/requires.txt

@@ -0,0 +1,3 @@
+click>=8.0.0
+rich>=13.0.0
+pyyaml>=6.0

qssh-0.1.0/src/qssh.egg-info/top_level.txt

@@ -0,0 +1 @@
+qssh