sshya 0.2.5 → 0.3.0

package/AGENTS.md

@@ -1,6 +1,6 @@
 # SSHya CLI - SSH Connection Manager
 
-**Purpose**: CLI tool for managing SSH connections with aliases, interactive prompts, and fzf integration.
+**Purpose**: CLI tool for managing SSH connections with aliases, interactive prompts, and optional fzf selection.
 
 ## Core Features
 - **Connection Management**: Add, remove, update, list SSH connections with custom aliases
@@ -15,19 +15,21 @@
 ### Database (`src/database.ts`)
 - `Connection` interface with id, alias, user, host, key_path, port, remote_path
 
-### Commands (`index.ts`)
+### Commands (`index.ts` / `s.ts`)
 - `add`/`remove`/`update`/`list`: Manage connections
-- `print [alias]`: Output SSH command for scripting/fzf
+- `print [alias]`: Output SSH command for scripting
 - `import`/`export`: JSON file operations
-- `fzf`/`instructions`: Shell integration setup
+- `fzf`: In-process fzf picker that connects to the selected alias
+- `s`: Shortcut entrypoint that always runs `connect` (interactive picker or alias)
 
 ## 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`
+2. **Fast connect**: `s` or `sshya connect` → built-in fuzzy picker (no shell rc changes)
+3. **fzf**: `sshya fzf` → fzf-based selection, then the same connect flow
+4. **Scripting**: `sshya print my-server` → Outputs `ssh -p 2222 -t -i ~/.ssh/key user@host`
 
 ## Notable Implementation Details
-- Shell-specific argument parsing (zsh vs bash) for fzf integration
+- `package.json` bins: `sshya` → `index.ts`, `s` → `s.ts`
 - Usage tracking via `lastUsed` timestamps
 - Always includes `-t` flag for proper pseudo-terminal allocation
 - **High-performance optimizations**: ~0.2ms processing time for 8 connections with caching and pre-computation

package/README.md

@@ -4,11 +4,11 @@ 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, remote path).
-- Connect to saved connections with `sshya connect` (aliases: `ssh`, `go`).
+- Connect to saved connections with `s` or `sshya connect` (aliases: `ssh`, `go`).
 - Copy files through saved connections with `sshya copy` (aliases: `sc`, `scp`).
 - Generate SSH command strings for scripting with `sshya print`.
 - Import and export connections from/to a JSON file.
-- fzf-based launcher for fast, keyboard-driven connection selection.
+- Optional fzf picker with `sshya fzf`.
 
 ## Technology Stack
 - **Runtime:** Bun
@@ -23,47 +23,25 @@ This project is a command-line interface (CLI) tool named `sshya` for managing S
 ## Implementation Details
 The main application logic is in `index.ts`. SSH arguments are built in-process and passed directly to your system `ssh` binary, avoiding fragile shell string parsing.
 
-## fzf-based launcher
+## Connecting
 
-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 and user@host.
-- After you pick an entry with `fzf`, it runs `sshya connect <alias>`.
-- `sshya connect` builds SSH arguments in-process and spawns your system `ssh` with inherited stdio, so TTY behavior matches typing the command yourself.
-
-### Usage
-
-After adding the snippet to your shell rc and reloading, simply run:
+Install exposes two commands: `sshya` for management, and `s` as a shortcut to connect. No shell rc changes are required.
 
 ```bash
-s
+s                      # interactive picker (type to filter)
+s my-server            # connect by alias
+sshya connect          # same picker
+sshya connect my-server
 ```
 
-This will launch the fzf interface for selecting and connecting to your saved SSH connections.
-
-You can also connect directly without fzf:
+`s` and `sshya connect` use the built-in fuzzy picker. If you prefer fzf:
 
 ```bash
-sshya connect my-server
-sshya connect          # interactive picker
+sshya fzf
 ```
 
+That requires `fzf` on your PATH. After you pick an entry, it runs the same in-process `connect` flow and spawns your system `ssh` with inherited stdio.
+
 ### Copy files
 
 Use stored connections for `scp` uploads and downloads:
@@ -75,18 +53,14 @@ sshya copy --download my-server /tmp/remote.txt ./
 sshya copy --recursive my-server ./dist /var/www
 ```
 
-The `copy` command also works as `sshya sc` or `sshya scp`. For a short no-fzf wrapper:
-
-```bash
-sc() {
-  sshya copy "$@"
-}
-```
+The `copy` command also works as `sshya sc` or `sshya scp`.
 
 Relative remote paths are resolved from the connection's saved remote working directory when one is configured.
 If an exact alias is not found, `connect` and `copy` use the first fuzzy match from the same search used by the interactive picker.
 
 ### Troubleshooting
 
-- If fzf filtering looks wrong, reload your shell after updating the snippet. The launcher should call `sshya connect`, not parse `sshya print` output.
+- If `s` is not found, reinstall or relink the package so both bins (`sshya` and `s`) are on your PATH.
+- If `s` still opens an old fzf shell function, remove the `s()` snippet from `~/.zshrc` or `~/.bashrc` so the installed binary is used.
+- If `sshya fzf` fails, install `fzf` or use `s` / `sshya connect` instead.
 - If the port or key path is ignored, verify the connection with `sshya test <alias>`.

package/index.ts

@@ -7,7 +7,7 @@ import { addConnectionPrompt, connectConnectionPrompt, copyConnectionPrompt, exp
 import { initDB } from './src/database';
 import { printConnectionsPrompt } from './src/helpers/connection';
 import { enableEscapeExit } from './src/helpers/escExit';
-import { printFzfInstructions } from './src/helpers/fzf';
+import { runFzfLauncher } from './src/helpers/fzf';
 // built-in SSH handler removed
 
 const version = pkg?.version ?? '1.0.0';
@@ -93,11 +93,8 @@ program
 
 program
   .command('fzf')
-  .aliases(['instructions', 'install'])
-  .description('Show instructions to enable fzf-based connection launcher')
-  .action(() => {
-    printFzfInstructions();
-  });
+  .description('Select a connection with fzf and connect')
+  .action(runFzfLauncher);
 
 program
   .command('path')

package/package.json

@@ -2,7 +2,7 @@
   "name": "sshya",
   "module": "index.ts",
   "type": "module",
-  "version": "0.2.5",
+  "version": "0.3.0",
   "description": "CLI for managing SSH connections with aliases, interactive prompts, and fzf integration",
   "devDependencies": {
     "@types/bun": "latest",
@@ -13,7 +13,7 @@
   },
   "scripts": {
     "start": "bun run index.ts",
-    "build": "bun build index.ts --compile --outfile bin/sshya"
+    "build": "bun build index.ts --compile --outfile bin/sshya && bun build s.ts --compile --outfile bin/s"
   },
   "dependencies": {
     "@inquirer/search": "^3.0.17",
@@ -28,6 +28,6 @@
   },
   "bin": {
     "sshya": "index.ts",
-    "s": "index.ts"
+    "s": "s.ts"
   }
 }

package/s.ts

@@ -0,0 +1,24 @@
+#!/usr/bin/env bun
+
+import { connectConnectionPrompt } from './src/connection';
+import { initDB } from './src/database';
+import { enableEscapeExit } from './src/helpers/escExit';
+
+if (process.stdin.isTTY && process.stdout.isTTY) {
+  enableEscapeExit();
+}
+
+initDB();
+
+const rawArgs = process.argv.slice(2);
+const looksLikeBunShim = rawArgs[0] === 'bun' && rawArgs[1] === 'run';
+const userArgs = looksLikeBunShim ? rawArgs.slice(3) : rawArgs;
+const arg = userArgs[0];
+
+if (arg === '-h' || arg === '--help') {
+  console.log('Usage: s [alias]');
+  console.log('Connect to a saved SSH connection. Omit alias to pick interactively.');
+  process.exit(0);
+}
+
+await connectConnectionPrompt(arg);

package/src/helpers/fzf.ts

@@ -1,27 +1,67 @@
 import chalk from 'chalk';
+import { spawn } from 'child_process';
+import { connectConnectionPrompt } from '../connection/connect';
+import { getConnections } from '../database';
 
-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 = [
-        's() {',
-        '  local line alias userhost',
-        '  run_sshya() {',
-        '    stdbuf -oL sshya "$@"',
-        '  }',
-        "  line=$(run_sshya list --oneline --names | fzf --with-nth=1,2 --nth=1,2 --delimiter=$'\\t') || return",
-        "  alias=${line%%$'\\t'*}",
-        "  userhost=${line#*$'\\t'}; userhost=${userhost%%$'\\t'*}",
-        "  echo \"Connecting: $alias ($userhost)\"",
-        "  run_sshya connect \"$alias\"",
-        '}',
-    ].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('- After adding this to your shell rc, reload with: ' + chalk.cyan('source ~/.zshrc') + ' or ' + chalk.cyan('source ~/.bashrc'));
-    console.log('- Then simply run ' + chalk.bold('s') + ' to launch the fzf interface');
-    process.exit(0);
+const FZF_ARGS = [
+    '--with-nth=1,2',
+    '--nth=1,2',
+    '--delimiter=\t',
+];
+
+export async function runFzfLauncher(): Promise<void> {
+    const connections = getConnections()
+        .sort((a, b) => (b.lastUsed ?? 0) - (a.lastUsed ?? 0));
+
+    if (connections.length === 0) {
+        console.log(chalk.yellow('No connections found. Add one with "sshya add"'));
+        process.exit(0);
+    }
+
+    const input = connections
+        .map((c) => `${c.alias}\t${c.user}@${c.host}`)
+        .join('\n');
+
+    const alias = await pickAliasWithFzf(input);
+    if (!alias) {
+        process.exit(0);
+    }
+
+    await connectConnectionPrompt(alias);
 }
 
+function pickAliasWithFzf(input: string): Promise<string | undefined> {
+    return new Promise((resolve) => {
+        const child = spawn('fzf', FZF_ARGS, { stdio: ['pipe', 'pipe', 'inherit'] });
 
+        child.on('error', (error: NodeJS.ErrnoException) => {
+            if (error.code === 'ENOENT') {
+                console.error(chalk.red('fzf is not installed. Use "s" or "sshya connect" instead.'));
+                process.exit(1);
+            }
+            console.error(chalk.red(`Failed to start fzf: ${error.message}`));
+            process.exit(1);
+        });
+
+        let stdout = '';
+        child.stdout.on('data', (chunk: Buffer | string) => {
+            stdout += chunk.toString();
+        });
+
+        child.stdin.on('error', () => {
+            // fzf may close stdin early when the user cancels.
+        });
+        child.stdin.write(input);
+        child.stdin.end();
+
+        child.on('close', (code) => {
+            if (code !== 0) {
+                resolve(undefined);
+                return;
+            }
+
+            const alias = stdout.trim().split('\t')[0];
+            resolve(alias || undefined);
+        });
+    });
+}