sshya 0.2.3 → 0.2.4

package/package.json

@@ -2,7 +2,7 @@
   "name": "sshya",
   "module": "index.ts",
   "type": "module",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "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/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/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,7 @@ import chalk from "chalk";
 import Fuse from "fuse.js";
 import inquirer from "inquirer";
 import { getConnections } from "../database";
+import { enableEscapeExit } from "./escExit";
 
 /**
  * Prompt user to choose a connection alias using fuzzy search.
@@ -17,31 +18,36 @@ export async function selectAlias(message: string = "Select a connection"): Prom
     }
 
 
-    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 }));
+    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) => {
+                    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;
-                }
+                    // 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,
-                });
+                    // 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 fuse.search(term).map(r => r.item);
+                },
             },
-        },
-    ]);
-    return alias as string;
+        ]);
+        return alias as string;
+    } finally {
+        cleanup();
+    }
 }