sshya 0.2.4 → 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,10 +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
@@ -22,48 +23,44 @@ 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`.
+Install exposes two commands: `sshya` for management, and `s` as a shortcut to connect. No shell rc changes are required.
 
-### Quick setup
-
-1. Ensure `fzf` is installed.
-2. Print the shell snippet:
-
-   ```bash
-   sshya fzf
-   # or the aliases
-   sshya instructions
-   sshya install
-   ```
+```bash
+s                      # interactive picker (type to filter)
+s my-server            # connect by alias
+sshya connect          # same picker
+sshya connect my-server
+```
 
-3. Copy the printed snippet into your `~/.zshrc` or `~/.bashrc` and reload your shell.
+`s` and `sshya connect` use the built-in fuzzy picker. If you prefer fzf:
 
-### How it works
+```bash
+sshya fzf
+```
 
-- 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.
+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.
 
-### Usage
+### Copy files
 
-After adding the snippet to your shell rc and reloading, simply run:
+Use stored connections for `scp` uploads and downloads:
 
 ```bash
-s
+sshya copy my-server ./local.txt /tmp/remote.txt
+sshya copy ./local.txt /tmp/remote.txt              # interactive connection picker
+sshya copy --download my-server /tmp/remote.txt ./
+sshya copy --recursive my-server ./dist /var/www
 ```
 
-This will launch the fzf interface for selecting and connecting to your saved SSH connections.
-
-You can also connect directly without fzf:
+The `copy` command also works as `sshya sc` or `sshya scp`.
 
-```bash
-sshya connect my-server
-sshya connect          # interactive picker
-```
+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

@@ -3,11 +3,11 @@
 import chalk from 'chalk';
 import { Command } from 'commander';
 import pkg from './package.json' assert { type: "json" };
-import { addConnectionPrompt, connectConnectionPrompt, exportConnectionsPrompt, importConnectionsPrompt, listConnectionsPrompt, removeConnectionPrompt, testConnectionPrompt, updateConnectionPrompt } from './src/connection';
+import { addConnectionPrompt, connectConnectionPrompt, copyConnectionPrompt, exportConnectionsPrompt, importConnectionsPrompt, listConnectionsPrompt, removeConnectionPrompt, testConnectionPrompt, updateConnectionPrompt } from './src/connection';
 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';
@@ -30,6 +30,20 @@ program
   .description('Connect to an SSH connection by alias')
   .action(connectConnectionPrompt);
 
+program
+  .command('copy [alias] [source] [destination]')
+  .aliases(['sc', 'scp'])
+  .description('Copy files using a stored SSH connection')
+  .option('-d, --download', 'Copy from the remote host to a local destination')
+  .option('-r, --recursive', 'Copy directories recursively')
+  .option('-p, --preserve', 'Preserve modification times, access times, and modes')
+  .action((alias?: string, source?: string, destination?: string, options?: { download?: boolean; recursive?: boolean; preserve?: boolean }) => {
+    return copyConnectionPrompt(alias, source, destination, {
+      download: !!options?.download,
+      recursive: !!options?.recursive,
+      preserve: !!options?.preserve,
+    });
+  });
 
 program
   .command('print [alias]')
@@ -79,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.4",
+  "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/connection/connect.ts

@@ -2,14 +2,22 @@ import chalk from 'chalk';
 import { spawn } from 'child_process';
 import { expandHomePath, getConnectionByAlias, recordConnectionUsage } from '../database';
 import { buildRemoteCommand } from '../helpers/shell';
-import { selectAlias } from '../helpers/selectAlias';
+import { findAliasBySearchTerm, selectAlias } from '../helpers/selectAlias';
 
 export async function connectConnectionPrompt(alias?: string): Promise<void> {
     if (!alias) {
         alias = await selectAlias('Select a connection to connect');
     }
 
-    const connection = getConnectionByAlias(alias);
+    let connection = getConnectionByAlias(alias);
+    if (!connection) {
+        const matchedAlias = findAliasBySearchTerm(alias);
+        if (matchedAlias) {
+            alias = matchedAlias;
+            connection = getConnectionByAlias(alias);
+        }
+    }
+
     if (!connection) {
         console.error(chalk.red('Alias not found'));
         process.exit(1);

package/src/connection/copy.ts

@@ -0,0 +1,119 @@
+import chalk from 'chalk';
+import path from 'path';
+import { spawn } from 'child_process';
+import { expandHomePath, getConnectionByAlias, recordConnectionUsage, type Connection } from '../database';
+import { findAliasBySearchTerm, selectAlias } from '../helpers/selectAlias';
+
+interface CopyOptions {
+    download?: boolean;
+    recursive?: boolean;
+    preserve?: boolean;
+}
+
+interface NormalizedCopyArgs {
+    alias?: string;
+    source?: string;
+    destination?: string;
+}
+
+const isAbsoluteRemotePath = (value: string): boolean => {
+    return value.startsWith('/') || value.startsWith('~/') || value === '~';
+};
+
+const resolveRemotePath = (connection: Connection, value: string): string => {
+    const remotePath = value.trim();
+    const remoteBase = connection.remote_path?.trim();
+
+    if (!remoteBase || isAbsoluteRemotePath(remotePath)) {
+        return remotePath;
+    }
+
+    return path.posix.join(remoteBase, remotePath);
+};
+
+const buildRemoteSpec = (connection: Connection, remotePath: string): string => {
+    return `${connection.user}@${connection.host}:${resolveRemotePath(connection, remotePath)}`;
+};
+
+const normalizeCopyArgs = (first?: string, second?: string, third?: string): NormalizedCopyArgs => {
+    if (third) {
+        return { alias: first, source: second, destination: third };
+    }
+
+    if (first && second) {
+        const maybeConnection = getConnectionByAlias(first);
+        if (maybeConnection) {
+            return { alias: first, source: second };
+        }
+
+        return { source: first, destination: second };
+    }
+
+    return { alias: first, source: second, destination: third };
+};
+
+export async function copyConnectionPrompt(
+    first?: string,
+    second?: string,
+    third?: string,
+    options: CopyOptions = {},
+): Promise<void> {
+    const { download = false, recursive = false, preserve = false } = options;
+    let { alias, source, destination } = normalizeCopyArgs(first, second, third);
+
+    if (!source || !destination) {
+        console.error(chalk.red('Source and destination are required'));
+        console.error(chalk.grey('Usage: sshya copy [alias] <source> <destination>'));
+        console.error(chalk.grey('       sshya copy --download [alias] <remote-source> <local-destination>'));
+        process.exit(1);
+    }
+
+    if (!alias) {
+        alias = await selectAlias(download ? 'Select a connection to copy from' : 'Select a connection to copy to');
+    }
+
+    let connection = getConnectionByAlias(alias);
+    if (!connection) {
+        const matchedAlias = findAliasBySearchTerm(alias);
+        if (matchedAlias) {
+            alias = matchedAlias;
+            connection = getConnectionByAlias(alias);
+        }
+    }
+
+    if (!connection) {
+        console.error(chalk.red('Alias not found'));
+        process.exit(1);
+    }
+
+    const args: string[] = [];
+    if (connection.key_path) {
+        args.push('-i', expandHomePath(connection.key_path) ?? connection.key_path);
+    }
+    if (connection.port) {
+        args.push('-P', String(connection.port));
+    }
+    if (recursive) {
+        args.push('-r');
+    }
+    if (preserve) {
+        args.push('-p');
+    }
+
+    if (download) {
+        args.push(buildRemoteSpec(connection, source), destination);
+    } else {
+        args.push(source, buildRemoteSpec(connection, destination));
+    }
+
+    recordConnectionUsage(alias);
+
+    const child = spawn('scp', args, { stdio: 'inherit' });
+    child.on('error', (error) => {
+        console.error(chalk.red(`Failed to start scp: ${error.message}`));
+        process.exit(1);
+    });
+    child.on('close', (code) => {
+        process.exit(code ?? 1);
+    });
+}

package/src/connection/index.ts

@@ -1,5 +1,6 @@
 export * from './add';
 export * from './connect';
+export * from './copy';
 export * from './export';
 export * from './import';
 export * from './list';

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

package/src/helpers/selectAlias.ts

@@ -4,6 +4,30 @@ import inquirer from "inquirer";
 import { getConnections } from "../database";
 import { enableEscapeExit } from "./escExit";
 
+const getAliasChoices = () => {
+    return getConnections()
+        .sort((a, b) => (b.lastUsed ?? 0) - (a.lastUsed ?? 0))
+        .map(c => ({ name: c.alias, value: c.alias }));
+};
+
+const searchAliasChoices = (term: string) => {
+    const choices = getAliasChoices();
+    if (term.trim().length === 0) {
+        return choices;
+    }
+
+    const fuse = new Fuse(choices, {
+        keys: ['name'],
+        threshold: 0.4,
+    });
+
+    return fuse.search(term).map(r => r.item);
+};
+
+export const findAliasBySearchTerm = (term: string): string | undefined => {
+    return searchAliasChoices(term)[0]?.value;
+};
+
 /**
  * Prompt user to choose a connection alias using fuzzy search.
  * Aborts the process if user presses ESC or if no connections are available.
@@ -11,8 +35,7 @@ import { enableEscapeExit } from "./escExit";
  * @returns selected alias as string
  */
 export async function selectAlias(message: string = "Select a connection"): Promise<string> {
-    const connections = getConnections().sort((a, b) => (b.lastUsed ?? 0) - (a.lastUsed ?? 0));
-    if (connections.length === 0) {
+    if (getConnections().length === 0) {
         console.log(chalk.yellow('No connections found. Add one with "sshya add"'));
         process.exit(0);
     }
@@ -29,20 +52,12 @@ export async function selectAlias(message: string = "Select a connection"): Prom
                 // The signature matches the @inquirer/search documentation:
                 //   (term: string | void, { signal }: { signal: AbortSignal }) => Promise<Choice[]>
                 source: async (term: unknown) => {
-                    const allChoices = connections.map(c => ({ name: c.alias, value: c.alias }));
-
                     // When term is undefined or empty, return the full, recently-used-sorted list.
                     if (typeof term !== 'string' || term.trim().length === 0) {
-                        return allChoices;
+                        return searchAliasChoices('');
                     }
 
-                    // Use Fuse.js for fuzzy matching on the `name` field of choice objects.
-                    const fuse = new Fuse(allChoices, {
-                        keys: ['name'],
-                        threshold: 0.4,
-                    });
-
-                    return fuse.search(term).map(r => r.item);
+                    return searchAliasChoices(term);
                 },
             },
         ]);