sshya 0.1.1 → 0.2.0

package/README.md

@@ -29,3 +29,61 @@ The final solution involves:
 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.
+
+## fzf-based launcher
+
+You can enable a fast, keyboard-driven launcher for your saved connections using `fzf`.
+
+### Quick setup
+
+1. Ensure `fzf` is installed.
+2. Print the shell snippet:
+
+   ```bash
+   sshya fzf
+   # or the aliases
+   sshya instructions
+   sshya install
+   ```
+
+3. Copy the printed snippet into your `~/.zshrc` or `~/.bashrc` and reload your shell.
+
+### How it works
+
+- The function displays your connections via `sshya list --oneline --names`, showing:
+  - alias, user@host (for display), and a third tab-separated column containing ssh-ready arguments.
+- After you pick an entry with `fzf`, it runs `sshya print <alias>` to obtain a single-line command string and then invokes your system `ssh` client.
+- Argument splitting is handled per-shell to avoid issues with flags and quoting:
+  - zsh: `ssh ${(z)command}`
+  - bash: `read -r -a __args <<< "$command"; ssh "${__args[@]}"`
+
+This ensures flags like `-p 2222` and identities like `-i '/path/with spaces/key'` are passed correctly to `ssh`.
+
+### Why system ssh?
+
+When launching from `fzf`, we intentionally use your host `ssh` binary instead of the built-in connect helper to avoid TTY and ZLE interaction problems.
+
+### ZLE/TTY handling (zsh)
+
+The snippet detaches the zsh line editor before starting `ssh` and restores it after:
+
+- Before `ssh`: `zle -I`
+- After `ssh`: `zle -R -c`
+
+It also temporarily disables XON/XOFF flow control during selection (enables Ctrl-S) and restores your previous `stty` settings afterward.
+
+### Keybinding
+
+The snippet includes an example zsh binding:
+
+```bash
+zle -N fzf_sshya
+bindkey '^S' fzf_sshya
+```
+
+For bash, see the printed notes (example: `bind -x` with Ctrl-S), and ensure flow control is disabled (`stty -ixon`).
+
+### Troubleshooting
+
+- If typing doesn't work in the remote session, make sure you've reloaded your shell after updating the snippet (it uses `zle -I`, `zle -R -c`, and restores `stty`).
+- If the port or key path is ignored, ensure you're on the updated snippet which splits args correctly for zsh/bash and make sure `sshya print <alias>` outputs the expected `-p`/`-i` flags.

package/index.ts

@@ -2,16 +2,20 @@
 
 import chalk from 'chalk';
 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 } from './src/helpers/connectInteractive';
+import { printConnectionsPrompt } from './src/helpers/connection';
 import { enableEscapeExit } from './src/helpers/escExit';
-import { handleSshCommand } from './src/sshCommandHandler';
+import { printFzfInstructions } from './src/helpers/fzf';
+// built-in SSH handler removed
 
-import pkg from './package.json' assert { type: "json" };
 const version = pkg?.version ?? '1.0.0';
 
-enableEscapeExit();
+if (process.stdin.isTTY && process.stdout.isTTY) {
+  enableEscapeExit();
+}
+
 initDB();
 
 const program = new Command();
@@ -20,10 +24,12 @@ program
   .version(version)
   .description('A simple CLI to manage your SSH connections');
 
+// connect command removed – use system ssh via fzf snippet
+
 program
-  .command('connect [alias]')
-  .description('Connect to an SSH connection by alias')
-  .action(connectInteractive);
+  .command('print [alias]')
+  .description('Print an SSH connection by alias')
+  .action(printConnectionsPrompt);
 
 program
   .command('add')
@@ -35,7 +41,9 @@ program
   .command('list')
   .aliases(['ps', 'ls'])
   .description('List all SSH connections')
-  .action(listConnectionsPrompt);
+  .option('--oneline', 'Output each connection as ssh args on one line')
+  .option('--names', 'Include alias as first column (tab-separated) with --oneline')
+  .action((options: { oneline?: boolean; names?: boolean }) => listConnectionsPrompt({ oneline: !!options?.oneline, names: !!options?.names }));
 
 program
   .command('remove [alias]')
@@ -64,6 +72,14 @@ program
   .description('Export connections to a JSON file (default: sshm-export.json)')
   .action(exportConnectionsPrompt);
 
+program
+  .command('fzf')
+  .aliases(['instructions', 'install'])
+  .description('Show instructions to enable fzf-based connection launcher')
+  .action(() => {
+    printFzfInstructions();
+  });
+
 program
   .command('path')
   .description('Provides instructions to make the CLI globally accessible')
@@ -92,20 +108,23 @@ program
     process.exit(0);
   });
 
-// Clean Bun compile shim arguments (e.g., "bun run index.ts") when running the compiled binary
-const rawArgs = process.argv.slice(2);
-const looksLikeBunShim = rawArgs[0] === 'bun' && rawArgs[1] === 'run';
-const userArgs = looksLikeBunShim ? rawArgs.slice(3) : rawArgs;
+// Helpers exported for testing primary dispatch logic
+export function normalizeUserArgs(rawArgv: string[]): string[] {
+  const looksLikeBunShim = rawArgv[0] === 'bun' && rawArgv[1] === 'run';
+  return looksLikeBunShim ? rawArgv.slice(3) : rawArgv;
+}
 
-const isSshCommand = userArgs.length > 0 && (userArgs[0] === 'ssh' || userArgs.some(arg => arg.includes('@')));
 
-if (isSshCommand) {
-  await handleSshCommand(userArgs);
-} else if (userArgs.length === 0) {
-  // No user-specified subcommand -> interactive connect
-  await connectInteractive();
-} else {
+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);
   // Reconstruct argv array expected by commander: [node, script, ...userArgs]
   const argvForCommander: string[] = [process.argv[0] ?? '', process.argv[1] ?? '', ...userArgs];
   program.parse(argvForCommander);
 }
+
+// Only execute when this module is the entrypoint (prevents side effects during tests)
+if (import.meta.main) {
+  await runFromProcess();
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "sshya",
   "module": "index.ts",
   "type": "module",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "devDependencies": {
     "@types/bun": "latest",
     "@types/chalk": "^2.2.4"
@@ -12,7 +12,7 @@
   },
   "scripts": {
     "start": "bun run index.ts",
-    "build": "bun build index.ts --compile --outfile bin/s"
+    "build": "bun build index.ts --compile --outfile bin/sshya"
   },
   "dependencies": {
     "@inquirer/search": "^3.0.17",

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,8 +1,43 @@
 import chalk from "chalk";
-import { getConnections } from "../database";
+import { expandHomePath, getConnections } from "../database";
+import { buildRemoteCommand } from "../helpers/shell";
 
-export async function listConnectionsPrompt() {
+export async function listConnectionsPrompt(options?: { oneline?: boolean; names?: boolean }) {
     const connections = getConnections();
+    if (options?.oneline) {
+        // Print each connection as ssh-ready args on a single line
+        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(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
+                console.log(`${c.alias}\t${c.user}@${c.host}\t${args}`);
+            } else {
+                console.log(args);
+            }
+        }
+        process.exit(0);
+    }
+
     if (connections.length === 0) {
         console.log(chalk.yellow('No connections found. Add one with "sshya add"'));
         return;

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

@@ -6,13 +6,14 @@ import { z } from 'zod';
 const dbDir = path.join(os.homedir(), '.sshya');
 const dbFilePath = path.join(dbDir, 'sshm.json');
 
-interface Connection {
+export interface Connection {
   id: number;
   alias: string;
   user: string;
   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

@@ -0,0 +1,35 @@
+import chalk from "chalk";
+import { expandHomePath, getConnectionByAlias } from "../database";
+import { buildRemoteCommand } from "./shell";
+
+export async function printConnectionsPrompt(alias?: string) {
+  if (!alias) {
+    console.error(chalk.red('Alias is required'));
+    process.exit(1);
+  }
+  const connection = getConnectionByAlias(alias);
+  if (!connection) {
+    console.error(chalk.red('Alias not found'));
+    process.exit(1);
+  }
+  const parts: string[] = [];
+  if (connection.key_path) {
+    const expandedKeyPath = expandHomePath(String(connection.key_path));
+    const quotedKey = `'${String(expandedKeyPath).replace(/'/g, "'\\''")}'`;
+    parts.push('-i', quotedKey);
+  }
+  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

@@ -0,0 +1,57 @@
+import chalk from 'chalk';
+
+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() {',
+        '  local line alias userhost command oldstty',
+        '  # Temporarily disable XON/XOFF so Ctrl-S works, then restore',
+        '  oldstty=$(stty -g 2>/dev/null)',
+        '  stty -ixon 2>/dev/null || true',
+        '  run_sshya() {',
+        '    if command -v sshya >/dev/null 2>&1; then',
+        '      stdbuf -oL sshya "$@"',
+        '    else',
+        '      stdbuf -oL bun --silent run start "$@"',
+        '    fi',
+        '  }',
+        "  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",
+        "    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\"",
+        "    ssh \"${__args[@]}\"",
+        "  fi",
+        "  stty \"$oldstty\" 2>/dev/null || true",
+        '}',
+        '# zsh widget binding (recommended):',
+        '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('- 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,76 +1,23 @@
-import { ChildProcess, spawn } from 'child_process';
-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(user: string, host: string, key_path?: string, port?: string) {
-    const args = [
-        '-tt',
-        '-o', 'NumberOfPasswordPrompts=1',
-        '-o', 'ConnectTimeout=10',
-        '-o', 'ServerAliveInterval=15',
-        '-o', 'TCPKeepAlive=yes',
-    ];
-    if (key_path) args.push('-i', key_path);
-    if (port) args.push('-p', port);
-    args.push(`${user}@${host}`);
-    return args;
-}
-
-export function runSSH(alias: string, user: string, host: string, key_path?: string, port?: string) {
-    recordConnectionUsage(alias);
-    const args = buildSSHArgs(user, host, key_path, port);
-
-    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);
+import type { Connection } from './database';
+import { expandHomePath } from './database';
+import { buildRemoteCommand } from './helpers/shell';
+
+export function buildSSHArgs(connection: Connection) {
+    const args: (string | number)[] = [];
+    if (connection.key_path) {
+        const expandedKeyPath = expandHomePath(connection.key_path);
+        args.push('-i', expandedKeyPath ?? connection.key_path);
     }
-
-    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.port) args.push('-p', connection.port);
+    args.push(`${connection.user}@${connection.host}`);
+    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/helpers/connectInteractive.ts

@@ -1,20 +0,0 @@
-import chalk from "chalk";
-import { getConnectionByAlias } from "../database";
-import { runSSH } from "../ssh";
-import { selectAlias } from "./selectAlias";
-
-/**
- * Helper to prompt user to select a connection and then connect
- */
-export async function connectInteractive(alias?: string) {
-  if (!alias) {
-    alias = await selectAlias('Select a connection');
-  }
-  const connection = getConnectionByAlias(alias);
-  if (connection) {
-    const { user, host, key_path, port } = connection;
-    runSSH(alias, user, host, key_path, port);
-  } else {
-    console.error(chalk.red('Alias not found'));
-  }
-}

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