sshya 0.1.0 → 0.1.2

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

@@ -1,17 +1,21 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 
 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 { connectInteractive, printConnectionsPrompt } from './src/helpers/connection';
 import { enableEscapeExit } from './src/helpers/escExit';
+import { printFzfInstructions } from './src/helpers/fzf';
 import { handleSshCommand } from './src/sshCommandHandler';
 
-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();
@@ -25,6 +29,11 @@ program
   .description('Connect to an SSH connection by alias')
   .action(connectInteractive);
 
+program
+  .command('print [alias]')
+  .description('Print an SSH connection by alias')
+  .action(printConnectionsPrompt);
+
 program
   .command('add')
   .aliases(['create', 'new'])
@@ -35,7 +44,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 +75,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 +111,39 @@ 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('@')));
+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';
+}
 
-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);
+  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);
 }
+
+// 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.0",
+  "version": "0.1.2",
   "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/list.ts

@@ -1,8 +1,32 @@
 import chalk from "chalk";
 import { getConnections } from "../database";
 
-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) {
+                // Safely single-quote the key path for shells
+                const quotedKey = `'${String(c.key_path).replace(/'/g, "'\\''")}'`;
+                parts.push('-i', quotedKey);
+            }
+            if (c.port) {
+                parts.push('-p', String(c.port));
+            }
+            parts.push(`${c.user}@${c.host}`);
+            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/database.ts

@@ -6,7 +6,7 @@ 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;

package/src/helpers/{connectInteractive.ts → connection.ts}

@@ -1,6 +1,6 @@
 import chalk from "chalk";
 import { getConnectionByAlias } from "../database";
-import { runSSH } from "../ssh";
+import { buildSSHArgs, runSSH } from "../ssh";
 import { selectAlias } from "./selectAlias";
 
 /**
@@ -12,8 +12,20 @@ export async function connectInteractive(alias?: string) {
   }
   const connection = getConnectionByAlias(alias);
   if (connection) {
-    const { user, host, key_path, port } = connection;
-    runSSH(alias, user, host, key_path, port);
+    runSSH(alias, connection);
+  } else {
+    console.error(chalk.red('Alias not found'));
+  }
+}
+
+export async function printConnectionsPrompt(alias?: string) {
+  if (!alias) {
+    alias = await selectAlias('Select a connection');
+  }
+  const connection = getConnectionByAlias(alias);
+  if (connection) {
+    let args = buildSSHArgs(connection);
+    console.log(args.join(' '));
   } else {
     console.error(chalk.red('Alias not found'));
   }

package/src/helpers/fzf.ts

@@ -0,0 +1,47 @@
+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'*}",
+        "  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}",
+        "    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/ssh.ts

@@ -1,4 +1,5 @@
 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
@@ -9,23 +10,17 @@ 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}`);
+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, user: string, host: string, key_path?: string, port?: string) {
+export function runSSH(alias: string, connection: Connection) {
     recordConnectionUsage(alias);
-    const args = buildSSHArgs(user, host, key_path, port);
+    const args = buildSSHArgs(connection);
 
     const sshProcess = spawn('ssh', args, {
         stdio: 'pipe', // Full control over stdio