sshya 0.2.4 → 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.4",
+  "version": "0.2.5",
   "description": "CLI for managing SSH connections with aliases, interactive prompts, and fzf integration",
   "devDependencies": {
     "@types/bun": "latest",

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/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);
                 },
             },
         ]);