fix: better error handling

Author: smorrisj

client/src/connection/ssh/auth.ts

@@ -118,13 +118,12 @@ export class AuthHandler {
    * @param resolve a function that resolves the promise that is waiting for the password
    * @param username the user name to use for the connection
    */
-  passwordAuth = (cb: NextAuthHandler, username: string) => {
-    this._authPresenter.presentPasswordPrompt(username).then((pw) => {
-      cb({
-        type: "password",
-        password: pw,
-        username: username,
-      });
+  passwordAuth = async (cb: NextAuthHandler, username: string) => {
+    const pw = await this._authPresenter.presentPasswordPrompt(username);
+    cb({
+      type: "password",
+      password: pw,
+      username: username,
     });
   };
 
@@ -134,7 +133,7 @@ export class AuthHandler {
    * @param resolve a function that resolves the promise that is waiting for authentication
    * @param username the user name to use for the connection
    */
-  keyboardInteractiveAuth = (cb: NextAuthHandler, username: string) => {
+  keyboardInteractiveAuth = async (cb: NextAuthHandler, username: string) => {
     cb({
       type: "keyboard-interactive",
       username: username,
@@ -172,7 +171,7 @@ export class AuthHandler {
    * @param privateKeyFilePath the path to the private key file defined in the connection profile
    * @param username the user name to use for the connection
    */
-  privateKeyAuth = (
+  privateKeyAuth = async (
     cb: NextAuthHandler,
     privateKeyFilePath: string,
     username: string,
@@ -186,22 +185,23 @@ export class AuthHandler {
         "Encrypted private OpenSSH key detected, but no passphrase given";
     // key is encrypted, prompt for passphrase
     if (passphraseRequired) {
-      this._authPresenter.presentPassphrasePrompt().then((passphrase) => {
-        //parse the keyfile using the passphrase
-        const passphrasedKeyContentsResult = this._keyParser.parseKey(
-          privateKeyFilePath,
-          passphrase,
-        );
-
-        if (passphrasedKeyContentsResult instanceof Error) {
-          throw passphrasedKeyContentsResult;
-        }
-        cb({
-          type: "publickey",
-          key: passphrasedKeyContentsResult,
-          passphrase: passphrase,
-          username: username,
-        });
+      const passphrase = await this._authPresenter.presentPassphrasePrompt();
+
+      //parse the keyfile using the passphrase
+      const passphrasedKeyContentsResult = this._keyParser.parseKey(
+        privateKeyFilePath,
+        passphrase,
+      );
+
+      if (passphrasedKeyContentsResult instanceof Error) {
+        throw passphrasedKeyContentsResult;
+      }
+
+      cb({
+        type: "publickey",
+        key: passphrasedKeyContentsResult,
+        passphrase: passphrase,
+        username: username,
       });
     } else {
       if (hasParseError) {

client/src/connection/ssh/index.ts

@@ -53,6 +53,7 @@ export class SSHSession extends Session {
   private _authHandler: AuthHandler;
   private _workDirectory: string;
   private _workDirectoryParser: LineParser;
+  private _authsLeft: AuthenticationType[];
 
   constructor(c?: Config, client?: Client) {
     super();
@@ -65,6 +66,7 @@ export class SSHSession extends Session {
       WORK_DIR_END_TAG,
       false,
     );
+    this._authsLeft = [];
   }
 
   public sessionId? = (): string => {
@@ -124,20 +126,30 @@ export class SSHSession extends Session {
 
   public close = (): void | Promise<void> => {
     if (!this._stream) {
+      this.disposeResources();
       return;
     }
     this._stream.write("endsas;\n");
     this._stream.close();
   };
 
   private onConnectionClose = () => {
+    if (!this._sessionReady) {
+      this._reject?.(new Error(l10n.t("Could not connect to the SAS server.")));
+    }
+
+    this.disposeResources();
+  };
+
+  private disposeResources = () => {
     this._stream = undefined;
     this._resolve = undefined;
     this._reject = undefined;
     this._html5FileName = "";
     this._workDirectory = undefined;
     this.clearAuthState();
     sessionInstance = undefined;
+    this._authsLeft = [];
   };
 
   private onConnectionError = (err: Error) => {
@@ -297,7 +309,7 @@ export class SSHSession extends Session {
 
   private handleSSHAuthentication: AuthHandlerMiddleware = (
     authsLeft: AuthenticationType[],
-    _partialSuccess: boolean,
+    partialSuccess: boolean,
     nextAuth: NextAuthHandler,
   ) => {
     if (!authsLeft) {
@@ -313,30 +325,47 @@ export class SSHSession extends Session {
       return false; //returning false will stop the authentication process
     }
 
-    const authMethod = authsLeft.shift();
+    if (this._authsLeft.length === 0 || partialSuccess) {
+      this._authsLeft = authsLeft;
+    }
+
+    const authMethod = this._authsLeft.shift();
+
     switch (authMethod) {
       case "publickey": {
         //user set a keyfile path in profile config
         if (this._config.privateKeyFilePath) {
-          this._authHandler.privateKeyAuth(
-            nextAuth,
-            this._config.privateKeyFilePath,
-            this._config.username,
-          );
+          this._authHandler
+            .privateKeyAuth(
+              nextAuth,
+              this._config.privateKeyFilePath,
+              this._config.username,
+            )
+            .catch((e) => {
+              this._reject?.(e);
+              return false;
+            });
         } else if (process.env.SSH_AUTH_SOCK) {
           this._authHandler.sshAgentAuth(nextAuth, this._config.username);
         }
         break;
       }
       case "password": {
-        this._authHandler.passwordAuth(nextAuth, this._config.username);
+        this._authHandler
+          .passwordAuth(nextAuth, this._config.username)
+          .catch((e) => {
+            this._reject?.(e);
+            return false;
+          });
         break;
       }
       case "keyboard-interactive": {
-        this._authHandler.keyboardInteractiveAuth(
-          nextAuth,
-          this._config.username,
-        );
+        this._authHandler
+          .keyboardInteractiveAuth(nextAuth, this._config.username)
+          .catch((e) => {
+            this._reject?.(e);
+            return false;
+          });
         break;
       }
       default: