ssh-to-code 1.0.0__py3-none-any.whl

ssh_handler.py

@@ -0,0 +1,233 @@
+#!/usr/bin/env python3
+"""
+SSH Connection Handler
+Manages SSH connections and remote command execution
+"""
+
+import paramiko
+import getpass
+import os
+import sys
+from typing import Optional
+
+
+class SSHHandler:
+    """Handle SSH connections and command execution"""
+    
+    def __init__(self, hostname: str, username: str, port: int = 22, 
+                 key_filename: Optional[str] = None, use_password: bool = False,
+                 key_passphrase: Optional[str] = None):
+        self.hostname = hostname
+        self.username = username
+        self.port = port
+        self.key_filename = key_filename
+        self.use_password = use_password
+        self.key_passphrase = key_passphrase
+        self.client: Optional[paramiko.SSHClient] = None
+        self.connected = False
+    
+    def _load_private_key(self, key_path: str, passphrase: Optional[str] = None):
+        """Load and decrypt private key file"""
+        key_path = os.path.expanduser(key_path)
+        
+        if not os.path.exists(key_path):
+            raise FileNotFoundError(f"Key file not found: {key_path}")
+        
+        # Try different key types (DSS removed in Paramiko 3.0+)
+        key_types = [
+            ('RSA', paramiko.RSAKey),
+            ('Ed25519', paramiko.Ed25519Key),
+            ('ECDSA', paramiko.ECDSAKey),
+        ]
+        
+        # Add DSS support if available (Paramiko < 3.0)
+        if hasattr(paramiko, 'DSSKey'):
+            key_types.append(('DSS', paramiko.DSSKey))
+        
+        for key_name, key_class in key_types:
+            try:
+                # Try loading with passphrase if provided
+                if passphrase:
+                    return key_class.from_private_key_file(key_path, password=passphrase)
+                else:
+                    return key_class.from_private_key_file(key_path)
+            except paramiko.ssh_exception.PasswordRequiredException:
+                # Key is encrypted, need passphrase
+                if passphrase is None:
+                    # This is expected for encrypted keys without passphrase
+                    raise
+                # Continue to next key type if passphrase didn't work
+                continue
+            except paramiko.ssh_exception.SSHException:
+                # Not this key type, try next
+                continue
+            except (AttributeError, Exception):
+                # Other error (including missing key class), try next key type
+                continue
+        
+        # If we get here, couldn't load the key
+        raise paramiko.ssh_exception.SSHException(f"Unable to load key from {key_path}")
+    
+    def _try_key_authentication(self, connect_kwargs: dict, key_path: str) -> bool:
+        """Try to authenticate with a key file, handling encrypted keys"""
+        try:
+            # First try without passphrase
+            pkey = self._load_private_key(key_path)
+            connect_kwargs['pkey'] = pkey
+            return True
+        except paramiko.ssh_exception.PasswordRequiredException:
+            # Key is encrypted, prompt for passphrase
+            print(f"\n🔐 Key file is encrypted: {key_path}")
+            
+            # Try up to 3 times
+            for attempt in range(3):
+                try:
+                    passphrase = getpass.getpass(f"Enter passphrase for key (attempt {attempt + 1}/3): ")
+                    
+                    if not passphrase:
+                        print("Passphrase cannot be empty for encrypted keys")
+                        continue
+                    
+                    pkey = self._load_private_key(key_path, passphrase)
+                    connect_kwargs['pkey'] = pkey
+                    print("✓ Key decrypted successfully")
+                    return True
+                    
+                except paramiko.ssh_exception.SSHException:
+                    if attempt < 2:
+                        print("✗ Incorrect passphrase, try again")
+                    else:
+                        print("✗ Failed to decrypt key after 3 attempts")
+                        return False
+            return False
+        except Exception as e:
+            print(f"Warning: Could not load key {key_path}: {str(e)}")
+            return False
+    
+    def connect(self) -> bool:
+        """Establish SSH connection with support for encrypted keys"""
+        try:
+            self.client = paramiko.SSHClient()
+            self.client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+            
+            connect_kwargs = {
+                'hostname': self.hostname,
+                'username': self.username,
+                'port': self.port,
+                'timeout': 10,
+            }
+            
+            key_auth_success = False
+            
+            # Try key-based authentication first
+            if self.key_filename:
+                key_path = os.path.expanduser(self.key_filename)
+                if not os.path.exists(key_path):
+                    print(f"✗ Key file not found: {key_path}")
+                    print("\nOptions:")
+                    print("  1. Check the path to your PEM/key file")
+                    print("  2. Use password authentication with --password flag")
+                    print("  3. Use SSH agent authentication (ssh-add your key)")
+                else:
+                    print(f"🔑 Using key file: {key_path}")
+                    key_auth_success = self._try_key_authentication(connect_kwargs, key_path)
+                    
+                    if not key_auth_success:
+                        print("\n💡 Options:")
+                        print("  1. Try password authentication (will prompt below)")
+                        print("  2. Check if you have the correct passphrase")
+                        print("  3. Add key to SSH agent: ssh-add", key_path)
+            else:
+                # Try default SSH keys
+                default_keys = [
+                    os.path.expanduser('~/.ssh/id_rsa'),
+                    os.path.expanduser('~/.ssh/id_ed25519'),
+                    os.path.expanduser('~/.ssh/id_ecdsa'),
+                ]
+                
+                existing_keys = [k for k in default_keys if os.path.exists(k)]
+                if existing_keys:
+                    print(f"🔍 Trying default SSH keys...")
+                    for key_path in existing_keys:
+                        print(f"  Trying: {key_path}")
+                        if self._try_key_authentication(connect_kwargs, key_path):
+                            key_auth_success = True
+                            break
+                
+                if not key_auth_success:
+                    # Fall back to SSH agent
+                    connect_kwargs['look_for_keys'] = False
+                    connect_kwargs['allow_agent'] = True
+            
+            # Password authentication
+            if self.use_password or (not key_auth_success and not connect_kwargs.get('pkey')):
+                if not self.use_password:
+                    print("\n🔐 Key authentication not available. Trying password authentication...")
+                
+                password = getpass.getpass(f"Password for {self.username}@{self.hostname}: ")
+                connect_kwargs['password'] = password
+                connect_kwargs['look_for_keys'] = False
+                connect_kwargs['allow_agent'] = False
+                # Remove pkey if we're using password
+                connect_kwargs.pop('pkey', None)
+            
+            try:
+                self.client.connect(**connect_kwargs)
+                self.connected = True
+                print("✓ Connected successfully!")
+                return True
+                
+            except paramiko.AuthenticationException as e:
+                print(f"\n✗ Authentication failed: {str(e)}")
+                print("\n🔧 Troubleshooting:")
+                print("  1. Check your username and hostname")
+                print("  2. Verify key file has correct permissions (chmod 600)")
+                print("  3. Ensure your key is authorized on the server")
+                print("  4. Try: ssh -v " + f"{self.username}@{self.hostname}" + " (for debug info)")
+                print("  5. Add key to SSH agent: ssh-add /path/to/key")
+                return False
+                    
+        except paramiko.AuthenticationException as e:
+            print(f"\n✗ Authentication failed: {str(e)}")
+            return False
+        except paramiko.SSHException as e:
+            print(f"\n✗ SSH connection error: {str(e)}")
+            return False
+        except Exception as e:
+            print(f"\n✗ Connection error: {str(e)}")
+            return False
+    
+    def execute_command(self, command: str, timeout: int = 10) -> str:
+        """Execute a command on the remote server and return output"""
+        if not self.connected or not self.client:
+            raise RuntimeError("Not connected to SSH server")
+        
+        try:
+            stdin, stdout, stderr = self.client.exec_command(command, timeout=timeout)
+            exit_code = stdout.channel.recv_exit_status()
+            
+            output = stdout.read().decode('utf-8', errors='ignore')
+            error = stderr.read().decode('utf-8', errors='ignore')
+            
+            if exit_code != 0 and error:
+                raise RuntimeError(f"Command failed: {error}")
+            
+            return output
+            
+        except Exception as e:
+            raise RuntimeError(f"Command execution failed: {str(e)}")
+    
+    def disconnect(self):
+        """Close SSH connection"""
+        if self.client:
+            self.client.close()
+            self.connected = False
+    
+    def __enter__(self):
+        """Context manager entry"""
+        self.connect()
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit"""
+        self.disconnect()

ssh_to_code-1.0.0.dist-info/METADATA

@@ -0,0 +1,384 @@
+Metadata-Version: 2.4
+Name: ssh-to-code
+Version: 1.0.0
+Summary: Terminal-based SSH directory browser with VS Code integration
+Author-email: Rajesh <rajesh-cs18@users.noreply.github.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/rajesh-cs18/ssh-to-code
+Project-URL: Bug Tracker, https://github.com/rajesh-cs18/ssh-to-code/issues
+Project-URL: Repository, https://github.com/rajesh-cs18/ssh-to-code
+Project-URL: Documentation, https://github.com/rajesh-cs18/ssh-to-code#readme
+Keywords: ssh,vscode,terminal,directory-browser,remote-development
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Environment :: Console :: Curses
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+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 :: Systems Administration
+Classifier: Topic :: Utilities
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: paramiko>=3.0.0
+Dynamic: license-file
+
+# SSH Directory Browser
+
+A terminal-based directory browser that lets you SSH into a remote server, navigate through directories interactively, and open selected directories directly in VS Code using the Remote-SSH extension.
+
+![Terminal UI](https://img.shields.io/badge/Terminal-Based-blue)
+![Python](https://img.shields.io/badge/Python-3.7+-green)
+![VS Code](https://img.shields.io/badge/VS%20Code-Remote--SSH-purple)
+
+
+## Features
+
+- 🚀 **Interactive Terminal UI** - Browse remote directories with an intuitive curses-based interface
+- 🔐 **Secure SSH Connection** - Support for key-based and password authentication
+- 📂 **Visual File Browser** - Clear indicators for directories, files, executables, and symlinks
+- 💻 **VS Code Integration** - Open any remote directory directly in VS Code with one keystroke
+- ⚙️ **Configuration Management** - Save frequently used SSH hosts for quick access
+- 🎨 **Keyboard Navigation** - Fast and efficient navigation using arrow keys
+
+## Requirements
+
+- Python 3.7 or higher
+- VS Code with Remote-SSH extension
+- SSH access to remote server
+
+## Installation
+
+### 1. Clone the repository
+
+```bash
+git clone <repository-url>
+cd ssh-to-code
+```
+
+### 2. Install Python dependencies
+
+```bash
+pip install paramiko
+```
+
+Or use the provided requirements file:
+
+```bash
+pip install -r requirements.txt
+```
+
+### 3. Make the script executable
+
+```bash
+chmod +x ssh_dir_browser.py
+```
+
+### 4. (Optional) Add to PATH
+
+For easy access from anywhere:
+
+```bash
+# Add to your ~/.bashrc or ~/.zshrc
+export PATH="$PATH:/path/to/ssh-to-code"
+
+# Or create a symlink
+sudo ln -s /path/to/ssh-to-code/ssh_dir_browser.py /usr/local/bin/ssh-browse
+```
+
+## Quick Start
+
+### Basic Usage
+
+Connect to a remote server and start browsing:
+
+```bash
+# Option 1: Use the wrapper script (automatically activates venv)
+./ssh-browse user@hostname
+
+# Option 2: Activate venv manually
+source venv/bin/activate
+python ssh_dir_browser.py user@hostname
+```
+
+### With Custom Port
+
+```bash
+./ssh-browse user@hostname -p 2222
+```
+
+### With SSH Key
+
+```bash
+./ssh-browse user@hostname -i ~/.ssh/my_key
+```
+
+### Start in Specific Directory
+
+```bash
+./ssh-browse user@hostname --start-path /var/www
+```
+
+### Password Authentication
+
+```bash
+./ssh-browse user@hostname --password
+```
+
+### AWS EC2 Example
+
+```bash
+./ssh-browse ubuntu@ec2-12-34-56-78.compute.amazonaws.com -i ~/Downloads/aws-key.pem
+```
+
+## Usage
+
+### Keyboard Controls
+
+| Key | Action |
+|-----|--------|
+| `↑` / `↓` | Navigate up/down |
+| `Enter` | Open directory |
+| `o` | Open current directory in VS Code |
+| `n` | Create new folder |
+| `h` | Go to home directory |
+| `r` | Refresh directory listing |
+| `q` | Quit |
+
+### Navigation
+
+1. Use arrow keys to move through the directory listing
+2. Press `Enter` to enter a directory
+3. Select `..` to go to parent directory
+4. Press `n` to create a new folder in the current directory
+5. Press `r` to refresh the directory contents
+6. Press `o` when you want to open the current directory in VS Code
+
+### VS Code Integration
+
+When you press `o`, the application will:
+1. Open VS Code
+2. Connect to the remote server via Remote-SSH
+3. Open the selected directory
+4. Exit the browser
+
+Make sure you have:
+- VS Code installed with the `code` command in your PATH
+- Remote-SSH extension installed in VS Code
+- SSH host properly configured (or the app will help configure it)
+
+### Authentication Methods
+
+The tool supports multiple authentication methods:
+
+1. **Unencrypted SSH Keys**: Automatic authentication
+2. **Encrypted SSH Keys**: Will prompt for passphrase (3 attempts)
+3. **Password Authentication**: Use `--password` flag
+4. **SSH Agent**: Automatically uses keys from ssh-agent
+
+**See [AUTH_GUIDE.md](AUTH_GUIDE.md) for detailed authentication instructions**, including:
+- How to handle encrypted PEM files
+- What to do when you don't have the passphrase
+- Using SSH agent for convenience
+- Troubleshooting authentication issues
+- Cloud provider specific examples (AWS, DigitalOcean, etc.)
+
+## Configuration
+
+### Saving SSH Hosts
+
+You can save frequently used SSH connections:
+
+```python
+from config_manager import ConfigManager
+
+config = ConfigManager()
+config.add_host(
+    name="myserver",
+    hostname="example.com",
+    username="myuser",
+    port=22,
+    key_file="~/.ssh/id_rsa",
+    default_path="/var/www"
+)
+```
+
+### Configuration File
+
+The configuration is stored in `~/.ssh-dir-browser.json`:
+
+```json
+{
+  "version": "1.0",
+  "hosts": [
+    {
+      "name": "myserver",
+      "hostname": "example.com",
+      "username": "myuser",
+      "port": 22,
+      "key_file": "~/.ssh/id_rsa",
+      "default_path": "/var/www"
+    }
+  ],
+  "preferences": {
+    "default_start_path": "~",
+    "save_last_path": true
+  }
+}
+```
+
+## Project Structure
+
+```
+ssh-to-code/
+├── ssh_dir_browser.py      # Main application with terminal UI
+├── ssh_handler.py           # SSH connection management
+├── vscode_integration.py    # VS Code Remote-SSH integration
+├── config_manager.py        # Configuration file management
+├── requirements.txt         # Python dependencies
+├── config.json.example      # Example configuration
+└── README.md               # This file
+```
+
+## Examples
+
+### Example 1: Browse and Open Web Server Directory
+
+```bash
+./ssh_dir_browser.py webdev@myserver.com --start-path /var/www/html
+```
+
+Navigate to your project directory and press `o` to open it in VS Code.
+
+### Example 2: Access Development Server with Custom Key
+
+```bash
+./ssh_dir_browser.py dev@staging.example.com -i ~/.ssh/staging_key -p 2222
+```
+
+### Example 3: Quick Access to Home Directory
+
+```bash
+./ssh_dir_browser.py user@server.com
+# Press 'h' in the browser to go to home directory
+# Navigate to desired folder
+# Press 'o' to open in VS Code
+```
+
+## Troubleshooting
+
+### VS Code Command Not Found
+
+Make sure VS Code is installed and the `code` command is in your PATH:
+
+```bash
+# For macOS
+# Open VS Code, press Cmd+Shift+P, type "shell command"
+# Select "Shell Command: Install 'code' command in PATH"
+
+# For Linux
+sudo ln -s /usr/share/code/bin/code /usr/local/bin/code
+
+# Verify installation
+code --version
+```
+
+### Remote-SSH Extension Not Installed
+
+Install it from VS Code:
+1. Open VS Code
+2. Go to Extensions (Cmd+Shift+X)
+3. Search for "Remote - SSH"
+4. Install the extension from Microsoft
+
+### SSH Connection Issues
+
+- Verify SSH key permissions: `chmod 600 ~/.ssh/id_rsa`
+- Test SSH connection manually: `ssh user@hostname`
+- Check if SSH agent is running: `ssh-add -l`
+- Add key to agent: `ssh-add ~/.ssh/id_rsa`
+
+### Python Module Not Found
+
+Install the required dependency:
+
+```bash
+pip install paramiko
+```
+
+## Advanced Features
+
+### Adding Custom SSH Config
+
+The tool can automatically add SSH hosts to your `~/.ssh/config`:
+
+```python
+from vscode_integration import VSCodeRemote
+
+VSCodeRemote.add_ssh_host_to_config(
+    hostname="example.com",
+    username="myuser",
+    port=22,
+    key_file="~/.ssh/id_rsa",
+    alias="myserver"
+)
+```
+
+### Programmatic Usage
+
+You can use the components in your own scripts:
+
+```python
+from ssh_handler import SSHHandler
+from ssh_dir_browser import DirectoryBrowser
+import curses
+
+# Connect to server
+ssh = SSHHandler("example.com", "myuser", port=22)
+ssh.connect()
+
+# Browse directories
+browser = DirectoryBrowser(ssh, start_path="/var/www")
+curses.wrapper(browser.run)
+
+# Cleanup
+ssh.disconnect()
+```
+
+## Contributing
+
+Contributions are welcome! Feel free to:
+- Report bugs
+- Suggest features
+- Submit pull requests
+
+## License
+
+This project is open source and available under the MIT License.
+
+## Author
+
+Created for seamless remote development workflow with VS Code.
+
+## Roadmap
+
+- [ ] Support for bookmarking favorite directories
+- [ ] Search functionality within directories
+- [ ] File preview support
+- [ ] Support for multiple simultaneous SSH connections
+- [ ] Fuzzy search for quick navigation
+- [ ] Integration with other editors (Neovim, Sublime Text, etc.)
+
+## Acknowledgments
+
+- Built with [Paramiko](https://www.paramiko.org/) for SSH connectivity
+- Uses Python's [curses](https://docs.python.org/3/library/curses.html) for terminal UI
+- Integrates with [VS Code Remote-SSH](https://code.visualstudio.com/docs/remote/ssh)

ssh_to_code-1.0.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+config_manager.py,sha256=08461Dnz3uIJfcCp4AzVhQuYRgXQFiB1JEFCsbhIDdg,4572
+host_selector.py,sha256=9egi5YcsWRpB5kDUXLoSmErz2_NVgpqmDx2XTCOfmCk,8520
+save_config.py,sha256=Df0JkSfzPFmmxbCYI8FkybWh8TWXMUhH7FQaQ6-ozEQ,9942
+ssh_dir_browser.py,sha256=0m5xyP5ywQqxtVLiMHrXyGW8Kdic1y3sAvsKGfNRSmw,13120
+ssh_handler.py,sha256=Ed4DeEtj0eJch0h3qhF6Az9ZRkLqiD5PPaYZfL7s1ig,9887
+vscode_integration.py,sha256=jDPijCgFve9u84NQ3gzKg9LpLW8NFwj4Pk8K_POvhzA,6405
+ssh_to_code-1.0.0.dist-info/licenses/LICENSE,sha256=RwgOu8jMeTWzvhl8UyFrjiOH0GMjMglb9TarProBXoQ,1091
+ssh_to_code-1.0.0.dist-info/METADATA,sha256=KhAhVn0mykA-4kqWpzH1PXAdywsgngm7rLlKcfauh3g,9695
+ssh_to_code-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ssh_to_code-1.0.0.dist-info/entry_points.txt,sha256=C8_owh3u-p0Fw_pzBpOZ0oNXwQuDn9d0I9ldamkOy0g,52
+ssh_to_code-1.0.0.dist-info/top_level.txt,sha256=VRSKb_CtNWh0urK8yDuAJpj2gxW0CNi4ZYHA78wHoNA,88
+ssh_to_code-1.0.0.dist-info/RECORD,,

ssh_to_code-1.0.0.dist-info/WHEEL

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

ssh_to_code-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ssh-browse = ssh_dir_browser:main

ssh_to_code-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 SSH Directory Browser Contributors
+
+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.

ssh_to_code-1.0.0.dist-info/top_level.txt

@@ -0,0 +1,6 @@
+config_manager
+host_selector
+save_config
+ssh_dir_browser
+ssh_handler
+vscode_integration