sshya 0.1.2 → 0.2.1

package/AGENTS.md

@@ -0,0 +1,56 @@
+# SSHya CLI - SSH Connection Manager
+
+**Purpose**: CLI tool for managing SSH connections with aliases, interactive prompts, and fzf integration.
+
+## Core Features
+- **Connection Management**: Add, remove, update, list SSH connections with custom aliases
+- **Interactive Interface**: Uses inquirer.js for user-friendly prompts
+- **fzf Integration**: Fast keyboard-driven connection selection via shell snippets
+- **Import/Export**: JSON-based connection backup and restore
+
+## Architecture
+- **Runtime**: Bun (JavaScript runtime)
+- **Language**: TypeScript with ESM modules
+- **Storage**: JSON file at `~/.sshya/sshm.json`
+- **Dependencies**: commander, inquirer, chalk, fuse.js, zod
+
+## Key Components
+
+### Database (`src/database.ts`)
+- `Connection` interface with id, alias, user, host, key_path, port, remote_path
+- Zod schema validation for data integrity
+- Home directory expansion for paths (`~` → `/home/user`)
+- CRUD operations with automatic normalization
+
+### Commands (`index.ts`)
+- `add`/`remove`/`update`/`list`: Manage connections
+- `print [alias]`: Output SSH command for scripting/fzf
+- `import`/`export`: JSON file operations
+- `fzf`/`instructions`: Shell integration setup
+
+### Interactive Features
+- Fuzzy search for connection selection (fuse.js)
+- Real-time validation with Zod schemas
+- Colorized output (chalk)
+- Graceful error handling with process.exit codes
+
+## Usage Patterns
+1. **Direct**: `sshya add` → Interactive prompt flow
+2. **fzf Integration**: Shell function with `sshya print` for fast selection
+3. **Scripting**: `sshya print my-server` → Outputs `ssh -p 2222 -t -i ~/.ssh/key user@host`
+
+## Notable Implementation Details
+- Interactive prompt handling with raw mode TTY for user input
+- Shell-specific argument parsing (zsh vs bash) for fzf integration
+- Automatic path normalization and validation
+- Usage tracking via `lastUsed` timestamps
+- Always includes `-t` flag for proper pseudo-terminal allocation
+- Enhanced error handling and debugging for fzf integration issues
+
+## Build & Installation
+```bash
+bun run build  # Creates bin/sshya binary
+sudo mv bin/sshya /usr/local/bin/s  # Global access
+```
+
+This tool prioritizes developer experience with fast, keyboard-driven workflows while maintaining robust error handling and cross-platform compatibility.

package/README.md

@@ -4,9 +4,9 @@ This project is a command-line interface (CLI) tool named `sshya` for managing S
 
 ## Core Functionality
 - Add, remove, update, and list SSH connection configurations (alias, user, host, port, key path).
-- Connect to saved SSH connections.
+- Generate SSH command strings for saved connections.
 - Import and export connections from/to a JSON file.
-- A key feature is the interactive `ssh` connection, which has been optimized to provide a smooth, responsive typing experience and correct terminal resizing behavior.
+- A key feature is the fzf-based launcher that provides fast, keyboard-driven connection selection and execution using your system's SSH client.
 
 ## Technology Stack
 - **Runtime:** Bun
@@ -19,16 +19,7 @@ This project is a command-line interface (CLI) tool named `sshya` for managing S
     - `zod`: for validating user input and imported data.
 
 ## Implementation Details
-The main application logic is in `index.ts`. It uses `child_process.spawn` to run the `ssh` command. Significant effort was made to fix issues with the interactive SSH session, including:
-- Laggy typing and missing keystrokes.
-- Incorrect terminal behavior on window resizing.
-
-The final solution involves:
-1.  Spawning the `ssh` process with `stdio: 'pipe'`.
-2.  Setting the local terminal to `rawMode` (`process.stdin.setRawMode(true)`).
-3.  Piping `stdin`, `stdout`, and `stderr` between the main process and the child `ssh` process.
-4.  Manually listening for `resize` events on `process.stdout` and forwarding them to the `ssh` child process by sending a `SIGWINCH` signal.
-5.  Using specific `ssh` command-line options (`-tt`, `ServerAliveInterval`, etc.) to ensure a stable and responsive interactive session.
+The main application logic is in `index.ts`. The tool generates SSH command strings that are executed by your system's SSH client, providing a clean separation between connection management and actual SSH execution.
 
 ## fzf-based launcher
 

package/index.ts

@@ -5,10 +5,10 @@ import { Command } from 'commander';
 import pkg from './package.json' assert { type: "json" };
 import { addConnectionPrompt, exportConnectionsPrompt, importConnectionsPrompt, listConnectionsPrompt, removeConnectionPrompt, testConnectionPrompt, updateConnectionPrompt } from './src/connection';
 import { initDB } from './src/database';
-import { connectInteractive, printConnectionsPrompt } from './src/helpers/connection';
+import { printConnectionsPrompt } from './src/helpers/connection';
 import { enableEscapeExit } from './src/helpers/escExit';
 import { printFzfInstructions } from './src/helpers/fzf';
-import { handleSshCommand } from './src/sshCommandHandler';
+// built-in SSH handler removed
 
 const version = pkg?.version ?? '1.0.0';
 
@@ -24,10 +24,7 @@ program
   .version(version)
   .description('A simple CLI to manage your SSH connections');
 
-program
-  .command('connect [alias]')
-  .description('Connect to an SSH connection by alias')
-  .action(connectInteractive);
+// connect command removed – use system ssh via fzf snippet
 
 program
   .command('print [alias]')
@@ -117,27 +114,11 @@ export function normalizeUserArgs(rawArgv: string[]): string[] {
   return looksLikeBunShim ? rawArgv.slice(3) : rawArgv;
 }
 
-export function determineEntryAction(userArgs: string[]): 'ssh' | 'interactive' | 'cli' {
-  const isSsh = userArgs.length > 0 && (userArgs[0] === 'ssh' || userArgs.some(arg => arg.includes('@')));
-  if (isSsh) return 'ssh';
-  if (userArgs.length === 0) return 'interactive';
-  return 'cli';
-}
 
 async function runFromProcess() {
   // Clean Bun compile shim arguments (e.g., "bun run index.ts") when running the compiled binary
   const rawArgs = process.argv.slice(2);
   const userArgs = normalizeUserArgs(rawArgs);
-  const action = determineEntryAction(userArgs);
-
-  if (action === 'ssh') {
-    await handleSshCommand(userArgs);
-    return;
-  }
-  if (action === 'interactive') {
-    await connectInteractive();
-    return;
-  }
   // Reconstruct argv array expected by commander: [node, script, ...userArgs]
   const argvForCommander: string[] = [process.argv[0] ?? '', process.argv[1] ?? '', ...userArgs];
   program.parse(argvForCommander);

package/package.json

@@ -2,7 +2,7 @@
   "name": "sshya",
   "module": "index.ts",
   "type": "module",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "devDependencies": {
     "@types/bun": "latest",
     "@types/chalk": "^2.2.4"

package/src/connection/add.ts

@@ -31,6 +31,11 @@ export async function addConnectionPrompt() {
             name: 'key_path',
             message: 'Path to key (optional):',
         },
+        {
+            type: 'input',
+            name: 'remote_path',
+            message: 'Remote working directory (optional):',
+        },
     ]);
 
     const parsed = connectionSchema.safeParse(answers);
@@ -38,10 +43,10 @@ export async function addConnectionPrompt() {
         console.error(chalk.red('Invalid input:'), parsed.error.errors.map(e => e.message).join(', '));
         return;
     }
-    const { alias, user, host, key_path, port } = parsed.data;
+    const { alias, user, host, key_path, port, remote_path } = parsed.data;
 
     try {
-        addConnection(alias, user, host, key_path, port ? String(port) : undefined);
+        addConnection(alias, user, host, key_path, port ? String(port) : undefined, remote_path);
         console.log(chalk.green('Connection added successfully'));
 
         const { test } = await inquirer.prompt([

package/src/connection/import.ts

@@ -50,11 +50,25 @@ export const importConnectionsPrompt = async (file: string) => {
                 }
 
                 if (action === 'Overwrite') {
-                    updateConnection(parsedConn.alias, parsedConn.user, parsedConn.host, parsedConn.key_path ?? '', parsedConn.port ? String(parsedConn.port) : undefined);
+                    updateConnection(
+                        parsedConn.alias,
+                        parsedConn.user,
+                        parsedConn.host,
+                        parsedConn.key_path ?? '',
+                        parsedConn.port ? String(parsedConn.port) : undefined,
+                        parsedConn.remote_path,
+                    );
                     updatedCount++;
                 }
             } else {
-                addConnection(parsedConn.alias, parsedConn.user, parsedConn.host, parsedConn.key_path, parsedConn.port ? String(parsedConn.port) : undefined);
+                addConnection(
+                    parsedConn.alias,
+                    parsedConn.user,
+                    parsedConn.host,
+                    parsedConn.key_path,
+                    parsedConn.port ? String(parsedConn.port) : undefined,
+                    parsedConn.remote_path,
+                );
                 importedCount++;
             }
         }

package/src/connection/list.ts

@@ -1,5 +1,6 @@
 import chalk from "chalk";
-import { getConnections } from "../database";
+import { expandHomePath, getConnections } from "../database";
+import { buildRemoteCommand } from "../helpers/shell";
 
 export async function listConnectionsPrompt(options?: { oneline?: boolean; names?: boolean }) {
     const connections = getConnections();
@@ -8,14 +9,26 @@ export async function listConnectionsPrompt(options?: { oneline?: boolean; names
         for (const c of connections) {
             const parts: string[] = [];
             if (c.key_path) {
+                const expandedKeyPath = expandHomePath(String(c.key_path));
                 // Safely single-quote the key path for shells
-                const quotedKey = `'${String(c.key_path).replace(/'/g, "'\\''")}'`;
+                const quotedKey = `'${String(expandedKeyPath).replace(/'/g, "'\\''")}'`;
                 parts.push('-i', quotedKey);
             }
             if (c.port) {
                 parts.push('-p', String(c.port));
             }
+            // Always add -t for interactive terminal allocation (required for fzf integration)
+            parts.push('-t');
             parts.push(`${c.user}@${c.host}`);
+            if (c.remote_path) {
+                const remoteCommand = buildRemoteCommand({
+                    remotePath: String(c.remote_path),
+                    postCommand: 'exec "$SHELL" -l',
+                });
+                if (remoteCommand) {
+                    parts.push(remoteCommand);
+                }
+            }
             const args = parts.join(' ');
             if (options?.names) {
                 // Tab-separated: alias<TAB>user@host<TAB>args for easy fzf display and parsing

package/src/connection/test.ts

@@ -1,7 +1,8 @@
 import chalk from 'chalk';
 import { spawn } from 'child_process';
-import { getConnectionByAlias } from '../database';
+import { expandHomePath, getConnectionByAlias } from '../database';
 import { selectAlias } from '../helpers/selectAlias';
+import { buildRemoteCommand } from '../helpers/shell';
 
 export async function testConnectionPrompt(alias?: string): Promise<void> {
 
@@ -15,14 +16,25 @@ export async function testConnectionPrompt(alias?: string): Promise<void> {
         return;
     }
 
-    const { user, host, key_path, port } = connection;
+    const { user, host, key_path, port, remote_path } = connection;
     console.log(`\nTesting connection to ${chalk.blue(alias)}...`);
 
     const testPromise = new Promise<{ code: number | null; stderr: string }>((resolve) => {
         const args = ['-o', 'BatchMode=yes', '-o', 'ConnectTimeout=5'];
-        if (key_path) args.push('-i', key_path);
+        if (key_path) args.push('-i', expandHomePath(key_path) ?? key_path);
         if (port) args.push('-p', String(port));
-        args.push(`${user}@${host}`, 'exit');
+        args.push(`${user}@${host}`);
+        if (remote_path) {
+            const remoteCommand = buildRemoteCommand({
+                remotePath: remote_path,
+                postCommand: 'exit',
+            });
+            if (remoteCommand) {
+                args.push('-t', remoteCommand);
+            }
+        } else {
+            args.push('exit');
+        }
 
         const child = spawn('ssh', args, { stdio: ['ignore', 'ignore', 'pipe'] });
         let stderr = '';

package/src/connection/update.ts

@@ -37,8 +37,14 @@ export async function updateConnectionPrompt(alias?: string) {
                 message: 'Path to key (optional):',
                 default: connection.key_path,
             },
+            {
+                type: 'input',
+                name: 'remote_path',
+                message: 'Remote working directory (optional):',
+                default: connection.remote_path,
+            },
         ]);
-        updateConnection(alias, answers.user, answers.host, answers.key_path, answers.port);
+        updateConnection(alias, answers.user, answers.host, answers.key_path, answers.port, answers.remote_path);
         console.log(chalk.green('Connection updated successfully'));
 
         const { test } = await inquirer.prompt([

package/src/database.ts

@@ -13,6 +13,7 @@ export interface Connection {
   host: string;
   key_path?: string;
   port?: string;
+  remote_path?: string;
   lastUsed?: number;
 }
 
@@ -22,14 +23,53 @@ export const connectionSchema = z.object({
   host: z.string().min(1),
   key_path: z.string().optional(),
   port: z.union([z.string(), z.number()]).optional(),
+  remote_path: z.string().optional(),
 });
 
+const normalizeOptionalString = (value?: string | number | null): string | undefined => {
+  if (value === undefined || value === null) {
+    return undefined;
+  }
+  const trimmed = String(value).trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+};
+
+export const expandHomePath = (input?: string): string | undefined => {
+  if (!input) {
+    return undefined;
+  }
+  if (input === '~') {
+    return os.homedir();
+  }
+  if (input.startsWith('~/')) {
+    return path.join(os.homedir(), input.slice(2));
+  }
+  return input;
+};
+
+const normalizeConnection = (connection: Connection): Connection => {
+  const normalizedKeyPath = expandHomePath(normalizeOptionalString(connection.key_path));
+  const normalizedPort = normalizeOptionalString(connection.port);
+  const normalizedRemotePath = normalizeOptionalString(connection.remote_path);
+
+  return {
+    ...connection,
+    alias: connection.alias.trim(),
+    user: connection.user.trim(),
+    host: connection.host.trim(),
+    key_path: normalizedKeyPath,
+    port: normalizedPort,
+    remote_path: normalizedRemotePath,
+  };
+};
+
 const readDB = (): Connection[] => {
   if (!fs.existsSync(dbFilePath)) {
     return [];
   }
   const data = fs.readFileSync(dbFilePath, 'utf-8');
-  return JSON.parse(data);
+  const parsed: Connection[] = JSON.parse(data);
+  return parsed.map(normalizeConnection);
 };
 
 const writeDB = (data: Connection[]) => {
@@ -49,21 +89,42 @@ export const initDB = () => {
   // Initialize empty database file if it does not exist
   if (!fs.existsSync(dbFilePath)) {
     writeDB([]);
+    return;
   }
+
+  // Normalize any existing data on disk once during init
+  const existingData = readDB();
+  writeDB(existingData);
 };
 
-export const addConnection = (alias: string, user: string, host: string, key_path?: string, port?: string) => {
+export const addConnection = (
+  alias: string,
+  user: string,
+  host: string,
+  key_path?: string,
+  port?: string,
+  remote_path?: string,
+) => {
   const connections = readDB();
-  if (connections.some(c => c.alias === alias)) {
-    throw new Error(`Connection with alias "${alias}" already exists.`);
+  const normalizedAlias = alias.trim();
+  if (connections.some(c => c.alias === normalizedAlias)) {
+    throw new Error(`Connection with alias "${normalizedAlias}" already exists.`);
   }
+
+  const normalizedUser = user.trim();
+  const normalizedHost = host.trim();
+  const normalizedKeyPath = expandHomePath(normalizeOptionalString(key_path));
+  const normalizedPort = normalizeOptionalString(port);
+  const normalizedRemotePath = normalizeOptionalString(remote_path);
+
   const newConnection: Connection = {
     id: connections.length > 0 ? Math.max(...connections.map(c => c.id)) + 1 : 1,
-    alias,
-    user,
-    host,
-    key_path,
-    port,
+    alias: normalizedAlias,
+    user: normalizedUser,
+    host: normalizedHost,
+    key_path: normalizedKeyPath,
+    port: normalizedPort,
+    remote_path: normalizedRemotePath,
   };
   connections.push(newConnection);
   writeDB(connections);
@@ -84,14 +145,22 @@ export const removeConnection = (alias: string) => {
   writeDB(newConnections);
 };
 
-export const updateConnection = (alias: string, newUser: string, newHost: string, newKeyPath: string, newPort?: string) => {
+export const updateConnection = (
+  alias: string,
+  newUser: string,
+  newHost: string,
+  newKeyPath?: string,
+  newPort?: string,
+  newRemotePath?: string,
+) => {
   const connections = readDB();
   const connection = connections.find(c => c.alias === alias);
   if (connection) {
-    connection.user = newUser;
-    connection.host = newHost;
-    connection.key_path = newKeyPath;
-    connection.port = newPort;
+    connection.user = newUser.trim();
+    connection.host = newHost.trim();
+    connection.key_path = expandHomePath(normalizeOptionalString(newKeyPath));
+    connection.port = normalizeOptionalString(newPort);
+    connection.remote_path = normalizeOptionalString(newRemotePath);
     writeDB(connections);
   }
 };

package/src/helpers/connection.ts

@@ -1,32 +1,37 @@
 import chalk from "chalk";
-import { getConnectionByAlias } from "../database";
-import { buildSSHArgs, runSSH } from "../ssh";
-import { selectAlias } from "./selectAlias";
+import { expandHomePath, getConnectionByAlias } from "../database";
+import { buildRemoteCommand } from "./shell";
 
-/**
- * Helper to prompt user to select a connection and then connect
- */
-export async function connectInteractive(alias?: string) {
+export async function printConnectionsPrompt(alias?: string) {
   if (!alias) {
-    alias = await selectAlias('Select a connection');
+    console.error(chalk.red('Alias is required'));
+    process.exit(1);
   }
   const connection = getConnectionByAlias(alias);
-  if (connection) {
-    runSSH(alias, connection);
-  } else {
+  if (!connection) {
     console.error(chalk.red('Alias not found'));
+    process.exit(1);
   }
-}
-
-export async function printConnectionsPrompt(alias?: string) {
-  if (!alias) {
-    alias = await selectAlias('Select a connection');
+  const parts: string[] = [];
+  if (connection.key_path) {
+    const expandedKeyPath = expandHomePath(String(connection.key_path));
+    const quotedKey = `'${String(expandedKeyPath).replace(/'/g, "'\\''")}'`;
+    parts.push('-i', quotedKey);
   }
-  const connection = getConnectionByAlias(alias);
-  if (connection) {
-    let args = buildSSHArgs(connection);
-    console.log(args.join(' '));
-  } else {
-    console.error(chalk.red('Alias not found'));
+  if (connection.port) {
+    parts.push('-p', String(connection.port));
+  }
+  // Always add -t for interactive terminal allocation (required for fzf integration)
+  parts.push('-t');
+  parts.push(`${connection.user}@${connection.host}`);
+  if (connection.remote_path) {
+    const remoteCommand = buildRemoteCommand({
+      remotePath: String(connection.remote_path),
+      postCommand: 'exec "$SHELL" -l',
+    });
+    if (remoteCommand) {
+      parts.push(remoteCommand);
+    }
   }
+  console.log(parts.join(' '));
 }

package/src/helpers/escExit.ts

@@ -1,5 +1,4 @@
 import readline from 'readline';
-import { isSshSessionActive } from '../ssh';
 
 /**
  * Enable global Escape key handler that terminates the CLI gracefully.
@@ -16,12 +15,7 @@ export function enableEscapeExit(): () => void {
     }
 
     const onKeypress = (_: string, key: readline.Key) => {
-        // Handle ESC key – ignored while an SSH session is active so that
-        // pressing Escape inside the remote shell works as expected.
         if (key.name === 'escape') {
-            if (isSshSessionActive()) {
-                return; // let the remote shell receive the key
-            }
             console.log('\nCancelled by user.');
             process.exit(0);
         }
@@ -32,9 +26,6 @@ export function enableEscapeExit(): () => void {
         // their usual shortcut inside the SSH client, so we don’t force-exit
         // the parent app in that case.
         if (key.ctrl && key.name === 'c') {
-            if (isSshSessionActive()) {
-                return; // let ssh handle the interrupt
-            }
             console.log('\nCancelled by user.');
             process.exit(0);
         }

package/src/helpers/fzf.ts

@@ -4,9 +4,9 @@ export function printFzfInstructions() {
     console.log(chalk.yellow('To enable a quick fzf-powered SSH launcher, add this to your shell rc:'));
     console.log('\n' + chalk.bold('~/.bashrc or ~/.zshrc') + '\n');
     const snippet = [
-        'fzf_sshya() {',
+        '_fzf_sshya() {',
         '  local line alias userhost command oldstty',
-        '  # Temporarily disable XON/XOFF so Ctrl-S works, then restore',
+        '  # Disable XON/XOFF for Ctrl-S binding',
         '  oldstty=$(stty -g 2>/dev/null)',
         '  stty -ixon 2>/dev/null || true',
         '  run_sshya() {',
@@ -19,12 +19,11 @@ export function printFzfInstructions() {
         "  line=$(run_sshya list --oneline --names | fzf --tac --with-nth=1,2 --delimiter=$'\\t') || { stty \"$oldstty\" 2>/dev/null || true; return; }",
         "  alias=${line%%$'\\t'*}",
         "  userhost=${line#*$'\\t'}; userhost=${userhost%%$'\\t'*}",
-        "  echo \"Connecting: $alias ($userhost)\"",
-        "  # Ensure ZLE releases the terminal before starting interactive ssh",
-        "  if [ -n \"$ZSH_VERSION\" ]; then zle -I; fi",
         "  command=$(run_sshya print \"$alias\")",
+        "  echo \"Connecting: $alias ($userhost)\"",
         "  if [ -n \"$ZSH_VERSION\" ]; then",
-        "    ssh ${(z)command}",
+        "    local -a _args; _args=(${(zQ)command})",
+        "    ssh \"${_args[@]}\"",
         "    zle -R -c",
         "  else",
         "    read -r -a __args <<< \"$command\"",
@@ -32,14 +31,14 @@ export function printFzfInstructions() {
         "  fi",
         "  stty \"$oldstty\" 2>/dev/null || true",
         '}',
-        '# zsh widget binding (recommended):',
-        'zle -N fzf_sshya',
-        "bindkey '^S' fzf_sshya",
+        '# Zsh widget binding',
+        'zle -N _fzf_sshya',
+        "bindkey '^S' _fzf_sshya",
     ].join('\n');
     console.log(chalk.cyan(snippet));
     console.log('\n' + chalk.green('Notes:'));
     console.log('- This expects ' + chalk.bold('fzf') + ' to be installed.');
-    console.log('- On bash, you can bind with: ' + chalk.cyan("bind -x '" + '\\"\\u0013\\":fzf_sshya' + "'"));
+    console.log('- On bash, you can bind with: ' + chalk.cyan("bind -x '" + '\\"\\u0013\\":_fzf_sshya' + "'"));
     console.log('- If Ctrl-S is flow control, disable with: ' + chalk.cyan('stty -ixon'));
     process.exit(0);
 }

package/src/helpers/shell.ts

@@ -0,0 +1,26 @@
+export const escapeSingleQuotes = (value: string): string => value.replace(/'/g, "'\\''");
+
+export const wrapInSingleQuotes = (value: string): string => `'${escapeSingleQuotes(value)}'`;
+
+interface RemoteCommandOptions {
+    remotePath?: string;
+    postCommand?: string;
+}
+
+export const buildRemoteCommand = ({
+    remotePath,
+    postCommand,
+}: RemoteCommandOptions): string | undefined => {
+    const commands: string[] = [];
+    if (typeof remotePath === 'string' && remotePath.trim().length > 0) {
+        commands.push(`cd ${wrapInSingleQuotes(remotePath.trim())}`);
+    }
+    if (postCommand && postCommand.trim().length > 0) {
+        commands.push(postCommand.trim());
+    }
+    if (commands.length === 0) {
+        return undefined;
+    }
+    return commands.join(' && ');
+};
+

package/src/ssh.ts

@@ -1,71 +0,0 @@
-import { ChildProcess, spawn } from 'child_process';
-import type { Connection } from './database';
-import { recordConnectionUsage } from './database';
-
-// Track the currently running SSH child-process so other parts of the program
-// (e.g. the global key-handler) can know whether we are inside an SSH session.
-let currentSshProcess: ChildProcess | null = null;
-
-export function isSshSessionActive(): boolean {
-    return currentSshProcess !== null;
-}
-
-export function buildSSHArgs(connection: Connection) {
-    const args = [];
-    if (connection.key_path) args.push('-i', connection.key_path);
-    if (connection.port) args.push('-p', connection.port);
-    args.push(`${connection.user}@${connection.host}`);
-    return args;
-}
-
-export function runSSH(alias: string, connection: Connection) {
-    recordConnectionUsage(alias);
-    const args = buildSSHArgs(connection);
-
-    const sshProcess = spawn('ssh', args, {
-        stdio: 'pipe', // Full control over stdio
-    });
-
-    // Mark session active so that other modules can detect we are now inside an
-    // SSH session.
-    currentSshProcess = sshProcess;
-
-    if (process.stdin.isTTY) {
-        process.stdin.setRawMode(true);
-    }
-
-    process.stdin.pipe(sshProcess.stdin);
-    sshProcess.stdout.pipe(process.stdout);
-    sshProcess.stderr.pipe(process.stderr);
-
-    const onResize = () => {
-        if (sshProcess.pid) {
-            try {
-                process.kill(sshProcess.pid, 'SIGWINCH');
-            } catch {
-                /* Process already exited – ignore */
-            }
-        }
-    };
-
-    const cleanup = (code?: number | null) => {
-        if (process.stdout.isTTY) {
-            process.stdout.removeListener('resize', onResize);
-        }
-        if (process.stdin.isTTY) {
-            process.stdin.setRawMode(false);
-        }
-        process.stdin.unpipe(sshProcess.stdin);
-        // Mark session ended
-        currentSshProcess = null;
-        process.exit(code ?? 0);
-    };
-
-    if (process.stdout.isTTY) {
-        process.stdout.on('resize', onResize);
-        onResize();
-    }
-
-    sshProcess.on('exit', cleanup);
-    sshProcess.on('error', () => cleanup(1));
-} 

package/src/sshCommandHandler.ts

@@ -1,93 +0,0 @@
-import chalk from 'chalk';
-import inquirer from 'inquirer';
-import { addConnection, getConnections } from './database';
-import { runSSH } from './ssh';
-
-export interface ParsedSSH {
-    user: string;
-    host: string;
-    key_path?: string;
-    port?: string;
-}
-
-export function parseSshCommand(args: string[]): ParsedSSH | null {
-    if (args[0] === 'ssh') {
-        args = args.slice(1);
-    }
-
-    let user = '';
-    let host = '';
-    let key_path: string | undefined;
-    let port: string | undefined;
-
-    const userHostArg = args.find(arg => arg.includes('@') && !arg.startsWith('-'));
-    if (!userHostArg) return null;
-
-    const parts = userHostArg.split('@');
-    if (parts.length < 2) return null;
-    user = parts[0] ?? '';
-    host = parts[1] ?? '';
-
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (!arg) continue;
-
-        if (arg === '-i' && i + 1 < args.length) {
-            key_path = args[i + 1]!;
-            i++;
-            // Support combined flag and value, e.g. -i/home/key.pem
-        } else if (arg.startsWith('-i') && arg.length > 2) {
-            key_path = arg.slice(2);
-        } else if (arg === '-p' && i + 1 < args.length) {
-            port = args[i + 1]!;
-            i++;
-            // Support combined flag and value, e.g. -p5572
-        } else if (arg.startsWith('-p') && arg.length > 2) {
-            port = arg.slice(2);
-        }
-    }
-
-    return { user, host, key_path, port };
-}
-
-export async function handleSshCommand(args: string[]) {
-    const connectionDetails = parseSshCommand(args);
-    if (!connectionDetails) {
-        console.error(chalk.red('Could not parse SSH command.'));
-        console.log('Expected format: ssh -i <key> user@host -p <port>');
-        return;
-    }
-
-    const { user, host, key_path, port } = connectionDetails;
-
-    const connections = getConnections();
-    const existingConnection = connections.find(c => {
-        const dbPort = c.port ? String(c.port) : undefined;
-        const dbKeyPath = c.key_path || undefined;
-        return c.user === user && c.host === host && dbKeyPath === key_path && dbPort === port;
-    });
-
-    if (existingConnection) {
-        console.log(chalk.green(`Found existing connection with alias "${existingConnection.alias}". Connecting...`));
-        runSSH(existingConnection.alias, user, host, key_path, port);
-        return;
-    }
-
-    console.log('This looks like a new connection.');
-    const { alias } = await inquirer.prompt([
-        {
-            type: 'input',
-            name: 'alias',
-            message: 'Enter an alias to save this connection for future use:',
-            validate: input => (input ? true : 'Alias cannot be empty.'),
-        },
-    ]);
-
-    try {
-        addConnection(alias, user, host, key_path, port ? String(port) : undefined);
-        console.log(chalk.green(`Connection saved as "${alias}". Connecting...`));
-        runSSH(alias, user, host, key_path, port);
-    } catch (err: any) {
-        console.error(chalk.red(err.message));
-    }
-}