sshya 0.1.2 → 0.2.0

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.0",
   "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,24 @@ 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));
             }
             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('-t', 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,35 @@
 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));
+  }
+  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('-t', 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,7 +4,7 @@ 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',
         '  oldstty=$(stty -g 2>/dev/null)',
@@ -19,12 +19,22 @@ 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'*}",
+        "  command=$(run_sshya print \"$alias\")",
         "  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\")",
         "  if [ -n \"$ZSH_VERSION\" ]; then",
-        "    ssh ${(z)command}",
+        "    local -a _args",
+        "    local remote_cmd=\"\"",
+        "    # Check if command contains -t for remote command",
+        "    if [[ \"$command\" == *' -t '* ]]; then",
+        "      # Split at -t, parse only SSH args, keep remote command as-is",
+        "      _args=(${(zQ)command%% -t *})",
+        "      remote_cmd=\"${command#* -t }\"",
+        "      ssh \"${_args[@]}\" -t \"$remote_cmd\"",
+        "    else",
+        "      _args=(${(zQ)command})",
+        "      ssh \"${_args[@]}\"",
+        "    fi",
         "    zle -R -c",
         "  else",
         "    read -r -a __args <<< \"$command\"",
@@ -33,13 +43,13 @@ export function printFzfInstructions() {
         "  stty \"$oldstty\" 2>/dev/null || true",
         '}',
         '# zsh widget binding (recommended):',
-        'zle -N fzf_sshya',
-        "bindkey '^S' fzf_sshya",
+        '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 +1,23 @@
-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;
-}
+import { expandHomePath } from './database';
+import { buildRemoteCommand } from './helpers/shell';
 
 export function buildSSHArgs(connection: Connection) {
-    const args = [];
-    if (connection.key_path) args.push('-i', connection.key_path);
+    const args: (string | number)[] = [];
+    if (connection.key_path) {
+        const expandedKeyPath = expandHomePath(connection.key_path);
+        args.push('-i', expandedKeyPath ?? 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 (connection.remote_path) {
+        const remoteCommand = buildRemoteCommand({
+            remotePath: connection.remote_path,
+            postCommand: 'exec "$SHELL" -l',
+        });
+        if (remoteCommand) {
+            args.push('-t', remoteCommand);
         }
-        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));
-} 
+    return args.map(String);
+}

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));
-    }
-}