sshya 0.1.0

package/README.md

@@ -0,0 +1,31 @@
+# Project: sshya
+
+This project is a command-line interface (CLI) tool named `sshya` for managing SSH connections.
+
+## Core Functionality
+- Add, remove, update, and list SSH connection configurations (alias, user, host, port, key path).
+- Connect to saved SSH 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.
+
+## Technology Stack
+- **Runtime:** Bun
+- **Language:** TypeScript
+- **Dependencies:**
+    - `commander`: For command-line argument parsing.
+    - `inquirer`: For interactive prompts.
+    - `chalk`: for terminal string styling.
+    - `fuse.js`: for fuzzy searching connections.
+    - `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.

package/bun.lock

@@ -0,0 +1,126 @@
+{
+  "lockfileVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "sshya",
+      "dependencies": {
+        "@inquirer/search": "^3.0.17",
+        "chalk": "^5.4.1",
+        "commander": "^14.0.0",
+        "fuse.js": "^7.0.0",
+        "inquirer": "^12.0.0",
+        "zod": "^3.22.2",
+      },
+      "devDependencies": {
+        "@types/bun": "latest",
+        "@types/chalk": "^2.2.4",
+      },
+      "peerDependencies": {
+        "typescript": "^5.0.0",
+      },
+    },
+  },
+  "packages": {
+    "@inquirer/checkbox": ["@inquirer/checkbox@4.2.0", "", { "dependencies": { "@inquirer/core": "^10.1.15", "@inquirer/figures": "^1.0.13", "@inquirer/type": "^3.0.8", "ansi-escapes": "^4.3.2", "yoctocolors-cjs": "^2.1.2" }, "peerDependencies": { "@types/node": ">=18" }, "optionalPeers": ["@types/node"] }, "sha512-fdSw07FLJEU5vbpOPzXo5c6xmMGDzbZE2+niuDHX5N6mc6V0Ebso/q3xiHra4D73+PMsC8MJmcaZKuAAoaQsSA=="],
+
+    "@inquirer/confirm": ["@inquirer/confirm@5.1.14", "", { "dependencies": { "@inquirer/core": "^10.1.15", "@inquirer/type": "^3.0.8" }, "peerDependencies": { "@types/node": ">=18" }, "optionalPeers": ["@types/node"] }, "sha512-5yR4IBfe0kXe59r1YCTG8WXkUbl7Z35HK87Sw+WUyGD8wNUx7JvY7laahzeytyE1oLn74bQnL7hstctQxisQ8Q=="],
+
+    "@inquirer/core": ["@inquirer/core@10.1.15", "", { "dependencies": { "@inquirer/figures": "^1.0.13", "@inquirer/type": "^3.0.8", "ansi-escapes": "^4.3.2", "cli-width": "^4.1.0", "mute-stream": "^2.0.0", "signal-exit": "^4.1.0", "wrap-ansi": "^6.2.0", "yoctocolors-cjs": "^2.1.2" }, "peerDependencies": { "@types/node": ">=18" }, "optionalPeers": ["@types/node"] }, "sha512-8xrp836RZvKkpNbVvgWUlxjT4CraKk2q+I3Ksy+seI2zkcE+y6wNs1BVhgcv8VyImFecUhdQrYLdW32pAjwBdA=="],
+
+    "@inquirer/editor": ["@inquirer/editor@4.2.15", "", { "dependencies": { "@inquirer/core": "^10.1.15", "@inquirer/type": "^3.0.8", "external-editor": "^3.1.0" }, "peerDependencies": { "@types/node": ">=18" }, "optionalPeers": ["@types/node"] }, "sha512-wst31XT8DnGOSS4nNJDIklGKnf+8shuauVrWzgKegWUe28zfCftcWZ2vktGdzJgcylWSS2SrDnYUb6alZcwnCQ=="],
+
+    "@inquirer/expand": ["@inquirer/expand@4.0.17", "", { "dependencies": { "@inquirer/core": "^10.1.15", "@inquirer/type": "^3.0.8", "yoctocolors-cjs": "^2.1.2" }, "peerDependencies": { "@types/node": ">=18" }, "optionalPeers": ["@types/node"] }, "sha512-PSqy9VmJx/VbE3CT453yOfNa+PykpKg/0SYP7odez1/NWBGuDXgPhp4AeGYYKjhLn5lUUavVS/JbeYMPdH50Mw=="],
+
+    "@inquirer/figures": ["@inquirer/figures@1.0.13", "", {}, "sha512-lGPVU3yO9ZNqA7vTYz26jny41lE7yoQansmqdMLBEfqaGsmdg7V3W9mK9Pvb5IL4EVZ9GnSDGMO/cJXud5dMaw=="],
+
+    "@inquirer/input": ["@inquirer/input@4.2.1", "", { "dependencies": { "@inquirer/core": "^10.1.15", "@inquirer/type": "^3.0.8" }, "peerDependencies": { "@types/node": ">=18" }, "optionalPeers": ["@types/node"] }, "sha512-tVC+O1rBl0lJpoUZv4xY+WGWY8V5b0zxU1XDsMsIHYregdh7bN5X5QnIONNBAl0K765FYlAfNHS2Bhn7SSOVow=="],
+
+    "@inquirer/number": ["@inquirer/number@3.0.17", "", { "dependencies": { "@inquirer/core": "^10.1.15", "@inquirer/type": "^3.0.8" }, "peerDependencies": { "@types/node": ">=18" }, "optionalPeers": ["@types/node"] }, "sha512-GcvGHkyIgfZgVnnimURdOueMk0CztycfC8NZTiIY9arIAkeOgt6zG57G+7vC59Jns3UX27LMkPKnKWAOF5xEYg=="],
+
+    "@inquirer/password": ["@inquirer/password@4.0.17", "", { "dependencies": { "@inquirer/core": "^10.1.15", "@inquirer/type": "^3.0.8", "ansi-escapes": "^4.3.2" }, "peerDependencies": { "@types/node": ">=18" }, "optionalPeers": ["@types/node"] }, "sha512-DJolTnNeZ00E1+1TW+8614F7rOJJCM4y4BAGQ3Gq6kQIG+OJ4zr3GLjIjVVJCbKsk2jmkmv6v2kQuN/vriHdZA=="],
+
+    "@inquirer/prompts": ["@inquirer/prompts@7.7.1", "", { "dependencies": { "@inquirer/checkbox": "^4.2.0", "@inquirer/confirm": "^5.1.14", "@inquirer/editor": "^4.2.15", "@inquirer/expand": "^4.0.17", "@inquirer/input": "^4.2.1", "@inquirer/number": "^3.0.17", "@inquirer/password": "^4.0.17", "@inquirer/rawlist": "^4.1.5", "@inquirer/search": "^3.0.17", "@inquirer/select": "^4.3.1" }, "peerDependencies": { "@types/node": ">=18" }, "optionalPeers": ["@types/node"] }, "sha512-XDxPrEWeWUBy8scAXzXuFY45r/q49R0g72bUzgQXZ1DY/xEFX+ESDMkTQolcb5jRBzaNJX2W8XQl6krMNDTjaA=="],
+
+    "@inquirer/rawlist": ["@inquirer/rawlist@4.1.5", "", { "dependencies": { "@inquirer/core": "^10.1.15", "@inquirer/type": "^3.0.8", "yoctocolors-cjs": "^2.1.2" }, "peerDependencies": { "@types/node": ">=18" }, "optionalPeers": ["@types/node"] }, "sha512-R5qMyGJqtDdi4Ht521iAkNqyB6p2UPuZUbMifakg1sWtu24gc2Z8CJuw8rP081OckNDMgtDCuLe42Q2Kr3BolA=="],
+
+    "@inquirer/search": ["@inquirer/search@3.0.17", "", { "dependencies": { "@inquirer/core": "^10.1.15", "@inquirer/figures": "^1.0.13", "@inquirer/type": "^3.0.8", "yoctocolors-cjs": "^2.1.2" }, "peerDependencies": { "@types/node": ">=18" }, "optionalPeers": ["@types/node"] }, "sha512-CuBU4BAGFqRYors4TNCYzy9X3DpKtgIW4Boi0WNkm4Ei1hvY9acxKdBdyqzqBCEe4YxSdaQQsasJlFlUJNgojw=="],
+
+    "@inquirer/select": ["@inquirer/select@4.3.1", "", { "dependencies": { "@inquirer/core": "^10.1.15", "@inquirer/figures": "^1.0.13", "@inquirer/type": "^3.0.8", "ansi-escapes": "^4.3.2", "yoctocolors-cjs": "^2.1.2" }, "peerDependencies": { "@types/node": ">=18" }, "optionalPeers": ["@types/node"] }, "sha512-Gfl/5sqOF5vS/LIrSndFgOh7jgoe0UXEizDqahFRkq5aJBLegZ6WjuMh/hVEJwlFQjyLq1z9fRtvUMkb7jM1LA=="],
+
+    "@inquirer/type": ["@inquirer/type@3.0.8", "", { "peerDependencies": { "@types/node": ">=18" }, "optionalPeers": ["@types/node"] }, "sha512-lg9Whz8onIHRthWaN1Q9EGLa/0LFJjyM8mEUbL1eTi6yMGvBf8gvyDLtxSXztQsxMvhxxNpJYrwa1YHdq+w4Jw=="],
+
+    "@types/bun": ["@types/bun@1.2.19", "", { "dependencies": { "bun-types": "1.2.19" } }, "sha512-d9ZCmrH3CJ2uYKXQIUuZ/pUnTqIvLDS0SK7pFmbx8ma+ziH/FRMoAq5bYpRG7y+w1gl+HgyNZbtqgMq4W4e2Lg=="],
+
+    "@types/chalk": ["@types/chalk@2.2.4", "", { "dependencies": { "chalk": "*" } }, "sha512-pb/QoGqtCpH2famSp72qEsXkNzcErlVmiXlQ/ww+5AddD8TmmYS7EWg5T20YiNCAiTgs8pMf2G8SJG5h/ER1ZQ=="],
+
+    "@types/node": ["@types/node@24.1.0", "", { "dependencies": { "undici-types": "~7.8.0" } }, "sha512-ut5FthK5moxFKH2T1CUOC6ctR67rQRvvHdFLCD2Ql6KXmMuCrjsSsRI9UsLCm9M18BMwClv4pn327UvB7eeO1w=="],
+
+    "@types/react": ["@types/react@19.1.8", "", { "dependencies": { "csstype": "^3.0.2" } }, "sha512-AwAfQ2Wa5bCx9WP8nZL2uMZWod7J7/JSplxbTmBQ5ms6QpqNYm672H0Vu9ZVKVngQ+ii4R/byguVEUZQyeg44g=="],
+
+    "ansi-escapes": ["ansi-escapes@4.3.2", "", { "dependencies": { "type-fest": "^0.21.3" } }, "sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ=="],
+
+    "ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="],
+
+    "ansi-styles": ["ansi-styles@4.3.0", "", { "dependencies": { "color-convert": "^2.0.1" } }, "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg=="],
+
+    "bun-types": ["bun-types@1.2.19", "", { "dependencies": { "@types/node": "*" }, "peerDependencies": { "@types/react": "^19" } }, "sha512-uAOTaZSPuYsWIXRpj7o56Let0g/wjihKCkeRqUBhlLVM/Bt+Fj9xTo+LhC1OV1XDaGkz4hNC80et5xgy+9KTHQ=="],
+
+    "chalk": ["chalk@5.4.1", "", {}, "sha512-zgVZuo2WcZgfUEmsn6eO3kINexW8RAE4maiQ8QNs8CtpPCSyMiYsULR3HQYkm3w8FIA3SberyMJMSldGsW+U3w=="],
+
+    "chardet": ["chardet@0.7.0", "", {}, "sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA=="],
+
+    "cli-width": ["cli-width@4.1.0", "", {}, "sha512-ouuZd4/dm2Sw5Gmqy6bGyNNNe1qt9RpmxveLSO7KcgsTnU7RXfsw+/bukWGo1abgBiMAic068rclZsO4IWmmxQ=="],
+
+    "color-convert": ["color-convert@2.0.1", "", { "dependencies": { "color-name": "~1.1.4" } }, "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ=="],
+
+    "color-name": ["color-name@1.1.4", "", {}, "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="],
+
+    "commander": ["commander@14.0.0", "", {}, "sha512-2uM9rYjPvyq39NwLRqaiLtWHyDC1FvryJDa2ATTVims5YAS4PupsEQsDvP14FqhFr0P49CYDugi59xaxJlTXRA=="],
+
+    "csstype": ["csstype@3.1.3", "", {}, "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw=="],
+
+    "emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="],
+
+    "external-editor": ["external-editor@3.1.0", "", { "dependencies": { "chardet": "^0.7.0", "iconv-lite": "^0.4.24", "tmp": "^0.0.33" } }, "sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew=="],
+
+    "fuse.js": ["fuse.js@7.1.0", "", {}, "sha512-trLf4SzuuUxfusZADLINj+dE8clK1frKdmqiJNb1Es75fmI5oY6X2mxLVUciLLjxqw/xr72Dhy+lER6dGd02FQ=="],
+
+    "iconv-lite": ["iconv-lite@0.4.24", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3" } }, "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA=="],
+
+    "inquirer": ["inquirer@12.8.2", "", { "dependencies": { "@inquirer/core": "^10.1.15", "@inquirer/prompts": "^7.7.1", "@inquirer/type": "^3.0.8", "ansi-escapes": "^4.3.2", "mute-stream": "^2.0.0", "run-async": "^4.0.5", "rxjs": "^7.8.2" }, "peerDependencies": { "@types/node": ">=18" }, "optionalPeers": ["@types/node"] }, "sha512-oBDL9f4+cDambZVJdfJu2M5JQfvaug9lbo6fKDlFV40i8t3FGA1Db67ov5Hp5DInG4zmXhHWTSnlXBntnJ7GMA=="],
+
+    "is-fullwidth-code-point": ["is-fullwidth-code-point@3.0.0", "", {}, "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg=="],
+
+    "mute-stream": ["mute-stream@2.0.0", "", {}, "sha512-WWdIxpyjEn+FhQJQQv9aQAYlHoNVdzIzUySNV1gHUPDSdZJ3yZn7pAAbQcV7B56Mvu881q9FZV+0Vx2xC44VWA=="],
+
+    "os-tmpdir": ["os-tmpdir@1.0.2", "", {}, "sha512-D2FR03Vir7FIu45XBY20mTb+/ZSWB00sjU9jdQXt83gDrI4Ztz5Fs7/yy74g2N5SVQY4xY1qDr4rNddwYRVX0g=="],
+
+    "run-async": ["run-async@4.0.5", "", {}, "sha512-oN9GTgxUNDBumHTTDmQ8dep6VIJbgj9S3dPP+9XylVLIK4xB9XTXtKWROd5pnhdXR9k0EgO1JRcNh0T+Ny2FsA=="],
+
+    "rxjs": ["rxjs@7.8.2", "", { "dependencies": { "tslib": "^2.1.0" } }, "sha512-dhKf903U/PQZY6boNNtAGdWbG85WAbjT/1xYoZIC7FAY0yWapOBQVsVrDl58W86//e1VpMNBtRV4MaXfdMySFA=="],
+
+    "safer-buffer": ["safer-buffer@2.1.2", "", {}, "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="],
+
+    "signal-exit": ["signal-exit@4.1.0", "", {}, "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw=="],
+
+    "string-width": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="],
+
+    "strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
+
+    "tmp": ["tmp@0.0.33", "", { "dependencies": { "os-tmpdir": "~1.0.2" } }, "sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw=="],
+
+    "tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "type-fest": ["type-fest@0.21.3", "", {}, "sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w=="],
+
+    "typescript": ["typescript@5.8.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ=="],
+
+    "undici-types": ["undici-types@7.8.0", "", {}, "sha512-9UJ2xGDvQ43tYyVMpuHlsgApydB8ZKfVYTsLDhXkFL/6gfkp+U8xTGdh8pMJv1SpZna0zxG1DwsKZsreLbXBxw=="],
+
+    "wrap-ansi": ["wrap-ansi@6.2.0", "", { "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" } }, "sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA=="],
+
+    "yoctocolors-cjs": ["yoctocolors-cjs@2.1.2", "", {}, "sha512-cYVsTjKl8b+FrnidjibDWskAv7UKOfcwaVZdp/it9n1s9fU3IkgDbhdIRKCW4JDsAlECJY0ytoVPT3sK6kideA=="],
+
+    "zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="],
+  }
+}

package/index.ts

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { addConnectionPrompt, exportConnectionsPrompt, importConnectionsPrompt, listConnectionsPrompt, removeConnectionPrompt, testConnectionPrompt, updateConnectionPrompt } from './src/connection';
+import { initDB } from './src/database';
+import { connectInteractive } from './src/helpers/connectInteractive';
+import { enableEscapeExit } from './src/helpers/escExit';
+import { handleSshCommand } from './src/sshCommandHandler';
+
+import pkg from './package.json' assert { type: "json" };
+const version = pkg?.version ?? '1.0.0';
+
+enableEscapeExit();
+initDB();
+
+const program = new Command();
+
+program
+  .version(version)
+  .description('A simple CLI to manage your SSH connections');
+
+program
+  .command('connect [alias]')
+  .description('Connect to an SSH connection by alias')
+  .action(connectInteractive);
+
+program
+  .command('add')
+  .aliases(['create', 'new'])
+  .description('Add a new SSH connection')
+  .action(addConnectionPrompt);
+
+program
+  .command('list')
+  .aliases(['ps', 'ls'])
+  .description('List all SSH connections')
+  .action(listConnectionsPrompt);
+
+program
+  .command('remove [alias]')
+  .aliases(['delete', 'rm'])
+  .description('Remove an SSH connection by alias')
+  .action(removeConnectionPrompt);
+
+program
+  .command('update [alias]')
+  .aliases(['edit'])
+  .description('Update an SSH connection by alias')
+  .action(updateConnectionPrompt);
+
+program
+  .command('test [alias]')
+  .description('Test an SSH connection by alias')
+  .action(testConnectionPrompt);
+
+program
+  .command('import [file]')
+  .description('Import connections from a JSON file')
+  .action(importConnectionsPrompt);
+
+program
+  .command('export [file]')
+  .description('Export connections to a JSON file (default: sshm-export.json)')
+  .action(exportConnectionsPrompt);
+
+program
+  .command('path')
+  .description('Provides instructions to make the CLI globally accessible')
+  .action(() => {
+    console.log(chalk.yellow('To make the ' + chalk.bold('s') + ' command globally accessible:'));
+    console.log('\n' + chalk.bold('Option 1: Permanent Installation (Recommended)') + '\n');
+    console.log('1. Build the executable: ' + chalk.cyan('bun run build'));
+    console.log('2. Move the executable to a PATH directory (e.g., /usr/local/bin):');
+    console.log(chalk.cyan('   sudo mv bin/s /usr/local/bin/s'));
+    console.log('\n' + chalk.green('After these steps, you should be able to run ' + chalk.bold('s') + ' from any directory.'));
+
+    console.log('\n' + chalk.bold('Option 2: Temporary for Current Session') + '\n');
+    console.log('Add the current directory to your PATH for the current terminal session:');
+    console.log(chalk.cyan(`   export PATH="$PATH:${process.cwd()}/bin"`));
+    console.log('\n' + chalk.green('This will allow you to run ' + chalk.bold('s') + ' from this directory until you close the terminal.'));
+    process.exit(0);
+  });
+
+program
+  .command('about')
+  .description('About this CLI')
+  .action(() => {
+    console.log(chalk.bold('SSHya CLI'));
+    console.log(chalk.gray(`Version ${version}`));
+    console.log(chalk.gray('https://github.com/ceneka/sshya'));
+    process.exit(0);
+  });
+
+// Clean Bun compile shim arguments (e.g., "bun run index.ts") when running the compiled binary
+const rawArgs = process.argv.slice(2);
+const looksLikeBunShim = rawArgs[0] === 'bun' && rawArgs[1] === 'run';
+const userArgs = looksLikeBunShim ? rawArgs.slice(3) : rawArgs;
+
+const isSshCommand = userArgs.length > 0 && (userArgs[0] === 'ssh' || userArgs.some(arg => arg.includes('@')));
+
+if (isSshCommand) {
+  await handleSshCommand(userArgs);
+} else if (userArgs.length === 0) {
+  // No user-specified subcommand -> interactive connect
+  await connectInteractive();
+} else {
+  // Reconstruct argv array expected by commander: [node, script, ...userArgs]
+  const argvForCommander: string[] = [process.argv[0] ?? '', process.argv[1] ?? '', ...userArgs];
+  program.parse(argvForCommander);
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "sshya",
+  "module": "index.ts",
+  "type": "module",
+  "version": "0.1.0",
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/chalk": "^2.2.4"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "scripts": {
+    "start": "bun run index.ts",
+    "build": "bun build index.ts --compile --outfile bin/s"
+  },
+  "dependencies": {
+    "@inquirer/search": "^3.0.17",
+    "chalk": "^5.4.1",
+    "commander": "^14.0.0",
+    "fuse.js": "^7.0.0",
+    "inquirer": "^12.0.0",
+    "zod": "^3.22.2"
+  },
+  "engines": {
+    "bun": ">=1.2.0"
+  },
+  "bin": {
+    "sshya": "index.ts",
+    "s": "index.ts"
+  }
+}

package/src/connection/add.ts

@@ -0,0 +1,62 @@
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { addConnection, connectionSchema } from "../database";
+import { testConnectionPrompt } from "./test";
+
+export async function addConnectionPrompt() {
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'alias',
+            message: 'Alias:',
+        },
+        {
+            type: 'input',
+            name: 'user',
+            message: 'User:',
+            default: 'root',
+        },
+        {
+            type: 'input',
+            name: 'host',
+            message: 'Host/IP:',
+        },
+        {
+            type: 'input',
+            name: 'port',
+            message: 'Port (optional):',
+        },
+        {
+            type: 'input',
+            name: 'key_path',
+            message: 'Path to key (optional):',
+        },
+    ]);
+
+    const parsed = connectionSchema.safeParse(answers);
+    if (!parsed.success) {
+        console.error(chalk.red('Invalid input:'), parsed.error.errors.map(e => e.message).join(', '));
+        return;
+    }
+    const { alias, user, host, key_path, port } = parsed.data;
+
+    try {
+        addConnection(alias, user, host, key_path, port ? String(port) : undefined);
+        console.log(chalk.green('Connection added successfully'));
+
+        const { test } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'test',
+                message: 'Do you want to test the new connection now?',
+                default: true,
+            },
+        ]);
+
+        if (test) {
+            await testConnectionPrompt(alias);
+        }
+    } catch (err: any) {
+        console.error(chalk.red(err.message));
+    }
+}

package/src/connection/export.ts

@@ -0,0 +1,14 @@
+import chalk from 'chalk';
+import fs from 'fs';
+import { getConnections } from '../database';
+
+export const exportConnectionsPrompt = (file: string = 'sshm-export.json') => {
+    const connections = getConnections();
+    if (connections.length === 0) {
+        console.log(chalk.yellow('No connections to export.'));
+        process.exit(1);
+    }
+    fs.writeFileSync(file, JSON.stringify(connections, null, 2));
+    console.log(chalk.green(`Successfully exported ${connections.length} connections to ${file}`));
+    process.exit(0);
+};

package/src/connection/import.ts

@@ -0,0 +1,70 @@
+import chalk from 'chalk';
+import fs from 'fs';
+import inquirer from 'inquirer';
+import { addConnection, connectionSchema, getConnectionByAlias, updateConnection } from '../database';
+
+export const importConnectionsPrompt = async (file: string) => {
+    if (!fs.existsSync(file)) {
+        console.error(chalk.red(`File not found: ${file}`));
+        process.exit(1);
+    }
+
+    try {
+        const fileContent = fs.readFileSync(file, 'utf-8');
+        const connectionsToImport = JSON.parse(fileContent);
+
+        if (!Array.isArray(connectionsToImport)) {
+            console.error(chalk.red('Invalid file format. Expected a JSON array of connections.'));
+            process.exit(1);
+        }
+
+        let importedCount = 0;
+        let skippedCount = 0;
+        let updatedCount = 0;
+
+        console.log(`Found ${connectionsToImport.length} connections to import.`);
+
+        for (const conn of connectionsToImport) {
+            const validation = connectionSchema.safeParse(conn);
+            if (!validation.success) {
+                console.log(chalk.yellow(`Skipping invalid connection object: ${JSON.stringify(conn)}`));
+                skippedCount++;
+                continue;
+            }
+            const parsedConn = validation.data;
+
+            const existingConn = getConnectionByAlias(parsedConn.alias);
+            if (existingConn) {
+                const { action } = await inquirer.prompt([
+                    {
+                        type: 'list',
+                        name: 'action',
+                        message: `Connection with alias "${parsedConn.alias}" already exists. What do you want to do?`,
+                        choices: ['Skip', 'Overwrite'],
+                    },
+                ]);
+
+                if (action === 'Skip') {
+                    skippedCount++;
+                    continue;
+                }
+
+                if (action === 'Overwrite') {
+                    updateConnection(parsedConn.alias, parsedConn.user, parsedConn.host, parsedConn.key_path ?? '', parsedConn.port ? String(parsedConn.port) : undefined);
+                    updatedCount++;
+                }
+            } else {
+                addConnection(parsedConn.alias, parsedConn.user, parsedConn.host, parsedConn.key_path, parsedConn.port ? String(parsedConn.port) : undefined);
+                importedCount++;
+            }
+        }
+
+        console.log(chalk.green('\nImport complete!'));
+        console.log(`- ${importedCount} new connections added.`);
+        console.log(`- ${updatedCount} connections overwritten.`);
+        console.log(`- ${skippedCount} connections skipped.`);
+    } catch (err: any) {
+        console.error(chalk.red(`Error reading or parsing file: ${err instanceof Error ? err.message : String(err)}`));
+    }
+    process.exit(0);
+}; 

package/src/connection/index.ts

@@ -0,0 +1,8 @@
+export * from './add';
+export * from './export';
+export * from './import';
+export * from './list';
+export * from './remove';
+export * from './test';
+export * from './update';
+

package/src/connection/list.ts

@@ -0,0 +1,67 @@
+import chalk from "chalk";
+import { getConnections } from "../database";
+
+export async function listConnectionsPrompt() {
+    const connections = getConnections();
+    if (connections.length === 0) {
+        console.log(chalk.yellow('No connections found. Add one with "sshya add"'));
+        return;
+    }
+
+    const maxLengths = {
+        alias: 'Alias'.length,
+        user: 'User'.length,
+        host: 'Host'.length,
+        port: 'Port'.length,
+    };
+
+    for (const c of connections) {
+        if (c.alias.length > maxLengths.alias) {
+            maxLengths.alias = c.alias.length;
+        }
+        if (c.user.length > maxLengths.user) {
+            maxLengths.user = c.user.length;
+        }
+        if (c.host.length > maxLengths.host) {
+            maxLengths.host = c.host.length;
+        }
+        if (c.port && String(c.port).length > maxLengths.port) {
+            maxLengths.port = String(c.port).length;
+        }
+    }
+
+    const header =
+        chalk.bold('Alias'.padEnd(maxLengths.alias)) +
+        '  ' +
+        chalk.bold('User'.padEnd(maxLengths.user)) +
+        '  ' +
+        chalk.bold('Host'.padEnd(maxLengths.host)) +
+        '  ' +
+        chalk.bold('Port'.padEnd(maxLengths.port));
+    console.log(header);
+
+    const separator =
+        '-'.repeat(maxLengths.alias) +
+        '  ' +
+        '-'.repeat(maxLengths.user) +
+        '  ' +
+        '-'.repeat(maxLengths.host) +
+        '  ' +
+        '-'.repeat(maxLengths.port);
+    console.log(separator);
+
+    for (const c of connections) {
+        const port = c.port ? String(c.port) : '';
+        const row =
+            c.alias.padEnd(maxLengths.alias) +
+            '  ' +
+            c.user.padEnd(maxLengths.user) +
+            '  ' +
+            c.host.padEnd(maxLengths.host) +
+            '  ' +
+            port.padEnd(maxLengths.port);
+        console.log(row);
+    }
+
+    process.exit(0);
+}

package/src/connection/remove.ts

@@ -0,0 +1,11 @@
+import chalk from "chalk";
+import { removeConnection } from "../database";
+import { selectAlias } from "../helpers/selectAlias";
+
+export async function removeConnectionPrompt(alias?: string) {
+    if (!alias) {
+        alias = await selectAlias('Select a connection to remove');
+    }
+    removeConnection(alias);
+    console.log(chalk.green('Connection removed successfully'));
+}

package/src/connection/test.ts

@@ -0,0 +1,46 @@
+import chalk from 'chalk';
+import { spawn } from 'child_process';
+import { getConnectionByAlias } from '../database';
+import { selectAlias } from '../helpers/selectAlias';
+
+export async function testConnectionPrompt(alias?: string): Promise<void> {
+
+    if (!alias) {
+        alias = await selectAlias('Select a connection to test');
+    }
+
+    const connection = getConnectionByAlias(alias);
+    if (!connection) {
+        console.error(chalk.red('Alias not found'));
+        return;
+    }
+
+    const { user, host, key_path, port } = connection;
+    console.log(`\nTesting connection to ${chalk.blue(alias)}...`);
+
+    const testPromise = new Promise<{ code: number | null; stderr: string }>((resolve) => {
+        const args = ['-o', 'BatchMode=yes', '-o', 'ConnectTimeout=5'];
+        if (key_path) args.push('-i', key_path);
+        if (port) args.push('-p', String(port));
+        args.push(`${user}@${host}`, 'exit');
+
+        const child = spawn('ssh', args, { stdio: ['ignore', 'ignore', 'pipe'] });
+        let stderr = '';
+        child.stderr.on('data', (data) => (stderr += data.toString()));
+        child.on('close', (code) => resolve({ code, stderr }));
+        child.on('error', (err) => resolve({ code: -1, stderr: err.message }));
+    });
+
+    const { code, stderr } = await testPromise;
+
+    if (code === 0) {
+        console.log(chalk.green('Connection successful!'));
+        return;
+    }
+
+    console.error(chalk.red('Connection failed.'));
+    if (stderr) {
+        console.error(chalk.grey(stderr.trim()));
+    }
+    return;
+} 

package/src/connection/update.ts

@@ -0,0 +1,59 @@
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { getConnectionByAlias, updateConnection } from "../database";
+import { selectAlias } from "../helpers/selectAlias";
+import { testConnectionPrompt } from "./test";
+
+export async function updateConnectionPrompt(alias?: string) {
+    // If alias is not provided, prompt the user to pick one interactively
+    if (!alias) {
+        alias = await selectAlias('Select a connection to edit');
+    }
+
+    const connection = getConnectionByAlias(alias);
+    if (connection) {
+        const answers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'user',
+                message: 'User:',
+                default: connection.user,
+            },
+            {
+                type: 'input',
+                name: 'host',
+                message: 'Host/IP:',
+                default: connection.host,
+            },
+            {
+                type: 'input',
+                name: 'port',
+                message: 'Port (optional):',
+                default: connection.port,
+            },
+            {
+                type: 'input',
+                name: 'key_path',
+                message: 'Path to key (optional):',
+                default: connection.key_path,
+            },
+        ]);
+        updateConnection(alias, answers.user, answers.host, answers.key_path, answers.port);
+        console.log(chalk.green('Connection updated successfully'));
+
+        const { test } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'test',
+                message: 'Do you want to test the updated connection now?',
+                default: true,
+            },
+        ]);
+
+        if (test) {
+            await testConnectionPrompt(alias);
+        }
+    } else {
+        console.error(chalk.red('Alias not found'));
+    }
+}

package/src/database.ts

@@ -0,0 +1,106 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { z } from 'zod';
+
+const dbDir = path.join(os.homedir(), '.sshya');
+const dbFilePath = path.join(dbDir, 'sshm.json');
+
+interface Connection {
+  id: number;
+  alias: string;
+  user: string;
+  host: string;
+  key_path?: string;
+  port?: string;
+  lastUsed?: number;
+}
+
+export const connectionSchema = z.object({
+  alias: z.string().min(1),
+  user: z.string().min(1),
+  host: z.string().min(1),
+  key_path: z.string().optional(),
+  port: z.union([z.string(), z.number()]).optional(),
+});
+
+const readDB = (): Connection[] => {
+  if (!fs.existsSync(dbFilePath)) {
+    return [];
+  }
+  const data = fs.readFileSync(dbFilePath, 'utf-8');
+  return JSON.parse(data);
+};
+
+const writeDB = (data: Connection[]) => {
+  // Ensure the directory exists before writing
+  if (!fs.existsSync(dbDir)) {
+    fs.mkdirSync(dbDir, { recursive: true });
+  }
+  fs.writeFileSync(dbFilePath, JSON.stringify(data, null, 2));
+};
+
+export const initDB = () => {
+  // Create base directory if it doesn't exist
+  if (!fs.existsSync(dbDir)) {
+    fs.mkdirSync(dbDir, { recursive: true });
+  }
+
+  // Initialize empty database file if it does not exist
+  if (!fs.existsSync(dbFilePath)) {
+    writeDB([]);
+  }
+};
+
+export const addConnection = (alias: string, user: string, host: string, key_path?: string, port?: string) => {
+  const connections = readDB();
+  if (connections.some(c => c.alias === alias)) {
+    throw new Error(`Connection with alias "${alias}" already exists.`);
+  }
+  const newConnection: Connection = {
+    id: connections.length > 0 ? Math.max(...connections.map(c => c.id)) + 1 : 1,
+    alias,
+    user,
+    host,
+    key_path,
+    port,
+  };
+  connections.push(newConnection);
+  writeDB(connections);
+};
+
+export const getConnections = () => {
+  return readDB();
+};
+
+export const getConnectionByAlias = (alias: string) => {
+  const connections = readDB();
+  return connections.find(c => c.alias === alias);
+};
+
+export const removeConnection = (alias: string) => {
+  const connections = readDB();
+  const newConnections = connections.filter(c => c.alias !== alias);
+  writeDB(newConnections);
+};
+
+export const updateConnection = (alias: string, newUser: string, newHost: string, newKeyPath: string, newPort?: string) => {
+  const connections = readDB();
+  const connection = connections.find(c => c.alias === alias);
+  if (connection) {
+    connection.user = newUser;
+    connection.host = newHost;
+    connection.key_path = newKeyPath;
+    connection.port = newPort;
+    writeDB(connections);
+  }
+};
+
+export const recordConnectionUsage = (alias: string) => {
+  const connections = readDB();
+  const connection = connections.find(c => c.alias === alias);
+  if (connection) {
+    connection.lastUsed = Date.now();
+    writeDB(connections);
+  }
+};

package/src/helpers/connectInteractive.ts

@@ -0,0 +1,20 @@
+import chalk from "chalk";
+import { getConnectionByAlias } from "../database";
+import { runSSH } from "../ssh";
+import { selectAlias } from "./selectAlias";
+
+/**
+ * Helper to prompt user to select a connection and then connect
+ */
+export async function connectInteractive(alias?: string) {
+  if (!alias) {
+    alias = await selectAlias('Select a connection');
+  }
+  const connection = getConnectionByAlias(alias);
+  if (connection) {
+    const { user, host, key_path, port } = connection;
+    runSSH(alias, user, host, key_path, port);
+  } else {
+    console.error(chalk.red('Alias not found'));
+  }
+}

package/src/helpers/escExit.ts

@@ -0,0 +1,52 @@
+import readline from 'readline';
+import { isSshSessionActive } from '../ssh';
+
+/**
+ * Enable global Escape key handler that terminates the CLI gracefully.
+ * Call the returned cleanup function after finishing the prompt to restore terminal state.
+ */
+export function enableEscapeExit(): () => void {
+    // Ensure keypress events are emitted
+    readline.emitKeypressEvents(process.stdin);
+
+    // If the terminal is interactive, switch to raw mode so we can capture individual keys
+    const shouldRestoreRawMode = process.stdin.isTTY && !process.stdin.isRaw;
+    if (shouldRestoreRawMode) {
+        process.stdin.setRawMode(true);
+    }
+
+    const onKeypress = (_: string, key: readline.Key) => {
+        // Handle ESC key – ignored while an SSH session is active so that
+        // pressing Escape inside the remote shell works as expected.
+        if (key.name === 'escape') {
+            if (isSshSessionActive()) {
+                return; // let the remote shell receive the key
+            }
+            console.log('\nCancelled by user.');
+            process.exit(0);
+        }
+
+        // Handle Ctrl+C. When stdin is in raw mode (which we enable above), the
+        // usual SIGINT event is **not** emitted. However, we still respect a
+        // running SSH session: users can terminate the remote session with
+        // their usual shortcut inside the SSH client, so we don’t force-exit
+        // the parent app in that case.
+        if (key.ctrl && key.name === 'c') {
+            if (isSshSessionActive()) {
+                return; // let ssh handle the interrupt
+            }
+            console.log('\nCancelled by user.');
+            process.exit(0);
+        }
+    };
+
+    process.stdin.on('keypress', onKeypress);
+
+    // Return a cleanup fn to detach listener & restore terminal
+    return () => {
+        process.stdin.off('keypress', onKeypress);
+        if (shouldRestoreRawMode && process.stdin.isTTY) {
+            process.stdin.setRawMode(false);
+        }
+    };
+} 

package/src/helpers/selectAlias.ts

@@ -0,0 +1,47 @@
+import chalk from "chalk";
+import Fuse from "fuse.js";
+import inquirer from "inquirer";
+import { getConnections } from "../database";
+
+/**
+ * Prompt user to choose a connection alias using fuzzy search.
+ * Aborts the process if user presses ESC or if no connections are available.
+ * @param message Prompt message to display
+ * @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) {
+        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);
+            },
+        },
+    ]);
+    return alias as string;
+} 

package/src/ssh.ts

@@ -0,0 +1,76 @@
+import { ChildProcess, spawn } from 'child_process';
+import { recordConnectionUsage } from './database';
+
+// Track the currently running SSH child-process so other parts of the program
+// (e.g. the global key-handler) can know whether we are inside an SSH session.
+let currentSshProcess: ChildProcess | null = null;
+
+export function isSshSessionActive(): boolean {
+    return currentSshProcess !== null;
+}
+
+export function buildSSHArgs(user: string, host: string, key_path?: string, port?: string) {
+    const args = [
+        '-tt',
+        '-o', 'NumberOfPasswordPrompts=1',
+        '-o', 'ConnectTimeout=10',
+        '-o', 'ServerAliveInterval=15',
+        '-o', 'TCPKeepAlive=yes',
+    ];
+    if (key_path) args.push('-i', key_path);
+    if (port) args.push('-p', port);
+    args.push(`${user}@${host}`);
+    return args;
+}
+
+export function runSSH(alias: string, user: string, host: string, key_path?: string, port?: string) {
+    recordConnectionUsage(alias);
+    const args = buildSSHArgs(user, host, key_path, port);
+
+    const sshProcess = spawn('ssh', args, {
+        stdio: 'pipe', // Full control over stdio
+    });
+
+    // Mark session active so that other modules can detect we are now inside an
+    // SSH session.
+    currentSshProcess = sshProcess;
+
+    if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+    }
+
+    process.stdin.pipe(sshProcess.stdin);
+    sshProcess.stdout.pipe(process.stdout);
+    sshProcess.stderr.pipe(process.stderr);
+
+    const onResize = () => {
+        if (sshProcess.pid) {
+            try {
+                process.kill(sshProcess.pid, 'SIGWINCH');
+            } catch {
+                /* Process already exited – ignore */
+            }
+        }
+    };
+
+    const cleanup = (code?: number | null) => {
+        if (process.stdout.isTTY) {
+            process.stdout.removeListener('resize', onResize);
+        }
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(false);
+        }
+        process.stdin.unpipe(sshProcess.stdin);
+        // Mark session ended
+        currentSshProcess = null;
+        process.exit(code ?? 0);
+    };
+
+    if (process.stdout.isTTY) {
+        process.stdout.on('resize', onResize);
+        onResize();
+    }
+
+    sshProcess.on('exit', cleanup);
+    sshProcess.on('error', () => cleanup(1));
+} 

package/src/sshCommandHandler.ts

@@ -0,0 +1,93 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { addConnection, getConnections } from './database';
+import { runSSH } from './ssh';
+
+export interface ParsedSSH {
+    user: string;
+    host: string;
+    key_path?: string;
+    port?: string;
+}
+
+export function parseSshCommand(args: string[]): ParsedSSH | null {
+    if (args[0] === 'ssh') {
+        args = args.slice(1);
+    }
+
+    let user = '';
+    let host = '';
+    let key_path: string | undefined;
+    let port: string | undefined;
+
+    const userHostArg = args.find(arg => arg.includes('@') && !arg.startsWith('-'));
+    if (!userHostArg) return null;
+
+    const parts = userHostArg.split('@');
+    if (parts.length < 2) return null;
+    user = parts[0] ?? '';
+    host = parts[1] ?? '';
+
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (!arg) continue;
+
+        if (arg === '-i' && i + 1 < args.length) {
+            key_path = args[i + 1]!;
+            i++;
+            // Support combined flag and value, e.g. -i/home/key.pem
+        } else if (arg.startsWith('-i') && arg.length > 2) {
+            key_path = arg.slice(2);
+        } else if (arg === '-p' && i + 1 < args.length) {
+            port = args[i + 1]!;
+            i++;
+            // Support combined flag and value, e.g. -p5572
+        } else if (arg.startsWith('-p') && arg.length > 2) {
+            port = arg.slice(2);
+        }
+    }
+
+    return { user, host, key_path, port };
+}
+
+export async function handleSshCommand(args: string[]) {
+    const connectionDetails = parseSshCommand(args);
+    if (!connectionDetails) {
+        console.error(chalk.red('Could not parse SSH command.'));
+        console.log('Expected format: ssh -i <key> user@host -p <port>');
+        return;
+    }
+
+    const { user, host, key_path, port } = connectionDetails;
+
+    const connections = getConnections();
+    const existingConnection = connections.find(c => {
+        const dbPort = c.port ? String(c.port) : undefined;
+        const dbKeyPath = c.key_path || undefined;
+        return c.user === user && c.host === host && dbKeyPath === key_path && dbPort === port;
+    });
+
+    if (existingConnection) {
+        console.log(chalk.green(`Found existing connection with alias "${existingConnection.alias}". Connecting...`));
+        runSSH(existingConnection.alias, user, host, key_path, port);
+        return;
+    }
+
+    console.log('This looks like a new connection.');
+    const { alias } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'alias',
+            message: 'Enter an alias to save this connection for future use:',
+            validate: input => (input ? true : 'Alias cannot be empty.'),
+        },
+    ]);
+
+    try {
+        addConnection(alias, user, host, key_path, port ? String(port) : undefined);
+        console.log(chalk.green(`Connection saved as "${alias}". Connecting...`));
+        runSSH(alias, user, host, key_path, port);
+    } catch (err: any) {
+        console.error(chalk.red(err.message));
+    }
+} 

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}