sshya 0.2.3 → 0.2.5

package/README.md

@@ -5,6 +5,7 @@ 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`).
+- 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.
@@ -63,6 +64,28 @@ sshya connect my-server
 sshya connect          # interactive picker
 ```
 
+### Copy files
+
+Use stored connections for `scp` uploads and downloads:
+
+```bash
+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
+```
+
+The `copy` command also works as `sshya sc` or `sshya scp`. For a short no-fzf wrapper:
+
+```bash
+sc() {
+  sshya copy "$@"
+}
+```
+
+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.

package/index.ts

@@ -3,7 +3,7 @@
 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';
@@ -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]')

package/package.json

@@ -2,7 +2,7 @@
   "name": "sshya",
   "module": "index.ts",
   "type": "module",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "CLI for managing SSH connections with aliases, interactive prompts, and fzf integration",
   "devDependencies": {
     "@types/bun": "latest",

package/src/connection/add.ts

@@ -1,9 +1,12 @@
 import chalk from "chalk";
 import inquirer from "inquirer";
 import { addConnection, connectionSchema } from "../database";
+import { enableEscapeExit } from "../helpers/escExit";
 import { testConnectionPrompt } from "./test";
 
 export async function addConnectionPrompt() {
+    const cleanup = enableEscapeExit();
+    try {
     const answers = await inquirer.prompt([
         {
             type: 'input',
@@ -64,4 +67,7 @@ export async function addConnectionPrompt() {
     } catch (err: any) {
         console.error(chalk.red(err.message));
     }
+    } finally {
+        cleanup();
+    }
 }

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/import.ts

@@ -2,6 +2,7 @@ import chalk from 'chalk';
 import fs from 'fs';
 import inquirer from 'inquirer';
 import { addConnection, connectionSchema, getConnectionByAlias, updateConnection } from '../database';
+import { enableEscapeExit } from '../helpers/escExit';
 
 export const importConnectionsPrompt = async (file: string) => {
     if (!fs.existsSync(file)) {
@@ -24,6 +25,8 @@ export const importConnectionsPrompt = async (file: string) => {
 
         console.log(`Found ${connectionsToImport.length} connections to import.`);
 
+        const cleanup = enableEscapeExit();
+        try {
         for (const conn of connectionsToImport) {
             const validation = connectionSchema.safeParse(conn);
             if (!validation.success) {
@@ -77,6 +80,9 @@ export const importConnectionsPrompt = async (file: string) => {
         console.log(`- ${importedCount} new connections added.`);
         console.log(`- ${updatedCount} connections overwritten.`);
         console.log(`- ${skippedCount} connections skipped.`);
+        } finally {
+            cleanup();
+        }
     } catch (err: any) {
         console.error(chalk.red(`Error reading or parsing file: ${err instanceof Error ? err.message : String(err)}`));
     }

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/connection/list.ts

@@ -1,12 +1,13 @@
 import chalk from "chalk";
 import os from "os";
-import { expandHomePath, getConnections } from "../database";
+import { getConnections } from "../database";
 import { buildRemoteCommand } from "../helpers/shell";
 
 export async function listConnectionsPrompt(options?: { oneline?: boolean; names?: boolean }) {
     let connections = getConnections();
     if (options?.oneline) {
-        // Sort by lastUsed (most recent first) for fzf - this helps with selection
+        // Sort by lastUsed descending so most recently used is first in the pipe;
+        // fzf's default layout places the first line at the bottom near the cursor.
         if (options?.names) {
             connections = connections.sort((a, b) => (b.lastUsed ?? 0) - (a.lastUsed ?? 0));
         }
@@ -34,54 +35,7 @@ export async function listConnectionsPrompt(options?: { oneline?: boolean; names
             const userHost = userHostCache.get(c.alias)!;
 
             if (options?.names) {
-                // Optimized tab-separated format for fzf
-                let output = c.alias + TAB + userHost + TAB;
-
-                // Build SSH args array more efficiently
-                const args: string[] = [];
-
-                if (c.key_path) {
-                    // Fast path expansion - only expand if it starts with ~
-                    let expandedKeyPath = c.key_path;
-                    if (expandedKeyPath.startsWith('~')) {
-                        if (expandedKeyPath === '~') {
-                            expandedKeyPath = homeDir;
-                        } else if (expandedKeyPath.startsWith('~/')) {
-                            expandedKeyPath = homeDir + expandedKeyPath.slice(1);
-                        }
-                    }
-
-                    // Fast quote escaping - only escape single quotes
-                    const needsEscaping = expandedKeyPath.includes(SINGLE_QUOTE);
-                    const quotedKey = needsEscaping
-                        ? SINGLE_QUOTE + expandedKeyPath.replace(/'/g, ESCAPED_QUOTE) + SINGLE_QUOTE
-                        : SINGLE_QUOTE + expandedKeyPath + SINGLE_QUOTE;
-
-                    args.push(DASH_I, quotedKey);
-                }
-
-                if (c.port) {
-                    args.push(DASH_P, String(c.port));
-                }
-
-                // Always add -t for interactive terminal allocation
-                args.push(DASH_T);
-                args.push(userHost);
-
-                if (c.remote_path) {
-                    // Only build remote command if needed
-                    const remoteCommand = buildRemoteCommand({
-                        remotePath: String(c.remote_path),
-                        postCommand: 'exec "$SHELL" -l',
-                    });
-                    if (remoteCommand) {
-                        args.push(remoteCommand);
-                    }
-                }
-
-                // Join args with spaces (faster than array join for small arrays)
-                output += args.join(SPACE);
-                console.log(output);
+                console.log(c.alias + TAB + userHost);
             } else {
                 // Simple args-only format (even faster)
                 const args: string[] = [];

package/src/connection/update.ts

@@ -1,6 +1,7 @@
 import chalk from "chalk";
 import inquirer from "inquirer";
 import { getConnectionByAlias, updateConnection } from "../database";
+import { enableEscapeExit } from "../helpers/escExit";
 import { selectAlias } from "../helpers/selectAlias";
 import { testConnectionPrompt } from "./test";
 
@@ -12,6 +13,8 @@ export async function updateConnectionPrompt(alias?: string) {
 
     const connection = getConnectionByAlias(alias);
     if (connection) {
+        const cleanup = enableEscapeExit();
+        try {
         const answers = await inquirer.prompt([
             {
                 type: 'input',
@@ -59,6 +62,9 @@ export async function updateConnectionPrompt(alias?: string) {
         if (test) {
             await testConnectionPrompt(alias);
         }
+        } finally {
+            cleanup();
+        }
     } else {
         console.error(chalk.red('Alias not found'));
     }

package/src/helpers/selectAlias.ts

@@ -2,6 +2,31 @@ import chalk from "chalk";
 import Fuse from "fuse.js";
 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.
@@ -10,38 +35,34 @@ import { getConnections } from "../database";
  * @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);
     }
 
 
-    const { alias } = await inquirer.prompt([
-        {
-            type: 'search',
-            name: 'alias',
-            message,
-            // Fuzzy-search the aliases using Fuse.js as the user types.
-            // 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;
-                }
-
-                // 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);
+    const cleanup = enableEscapeExit();
+    try {
+        const { alias } = await inquirer.prompt([
+            {
+                type: 'search',
+                name: 'alias',
+                message,
+                // Fuzzy-search the aliases using Fuse.js as the user types.
+                // The signature matches the @inquirer/search documentation:
+                //   (term: string | void, { signal }: { signal: AbortSignal }) => Promise<Choice[]>
+                source: async (term: unknown) => {
+                    // When term is undefined or empty, return the full, recently-used-sorted list.
+                    if (typeof term !== 'string' || term.trim().length === 0) {
+                        return searchAliasChoices('');
+                    }
+
+                    return searchAliasChoices(term);
+                },
             },
-        },
-    ]);
-    return alias as string;
+        ]);
+        return alias as string;
+    } finally {
+        cleanup();
+    }
 }