sshya 0.2.0 → 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/package.json

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

package/src/connection/list.ts

@@ -17,6 +17,8 @@ export async function listConnectionsPrompt(options?: { oneline?: boolean; names
             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({
@@ -24,7 +26,7 @@ export async function listConnectionsPrompt(options?: { oneline?: boolean; names
                     postCommand: 'exec "$SHELL" -l',
                 });
                 if (remoteCommand) {
-                    parts.push('-t', remoteCommand);
+                    parts.push(remoteCommand);
                 }
             }
             const args = parts.join(' ');

package/src/helpers/connection.ts

@@ -21,6 +21,8 @@ export async function printConnectionsPrompt(alias?: string) {
   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({
@@ -28,7 +30,7 @@ export async function printConnectionsPrompt(alias?: string) {
       postCommand: 'exec "$SHELL" -l',
     });
     if (remoteCommand) {
-      parts.push('-t', remoteCommand);
+      parts.push(remoteCommand);
     }
   }
   console.log(parts.join(' '));

package/src/helpers/fzf.ts

@@ -6,7 +6,7 @@ export function printFzfInstructions() {
     const snippet = [
         '_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() {',
@@ -21,20 +21,9 @@ export function printFzfInstructions() {
         "  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",
+        "    local -a _args; _args=(${(zQ)command})",
+        "    ssh \"${_args[@]}\"",
         "    zle -R -c",
         "  else",
         "    read -r -a __args <<< \"$command\"",
@@ -42,7 +31,7 @@ export function printFzfInstructions() {
         "  fi",
         "  stty \"$oldstty\" 2>/dev/null || true",
         '}',
-        '# zsh widget binding (recommended):',
+        '# Zsh widget binding',
         'zle -N _fzf_sshya',
         "bindkey '^S' _fzf_sshya",
     ].join('\n');

package/src/ssh.ts

@@ -1,23 +0,0 @@
-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);
-    }
-    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);
-        }
-    }
-    return args.map(String);
-}