Integrate SSH Library with Waveshell Installation/Auto-update (#322)

* refactor launch code to integrate install easier

The previous set up of launch was difficult to navigate. This makes it
much clearer which will make the auto install flow easier to manage.

* feat: integrate auto install into new ssh setup

This change makes it possible to auto install using the ssh library
instead of making a call to the ssh cli command. This will auto install
if the installed waveshell version is incorrect or cannot be found.

* chore: clean up some lints for sshclient

There was a context that didn't have it's cancel function deferred and
an error that wasn't being handle. They're fixed now.

* fix: disconnect client if requested or launch fail

A recent commit made it so a client remained part of the MShellProc
after being disconnected. This is undesireable since a manual
disconnection indicates that the user will need to enter their
credentials again if required. Similarly, if the launch fails with an
error, the expectation is that credentials will have to be entered
again.

* fix: use legacy timer for the time being

The legacy timer frustrates me because it adds a lot of state to the
MShellProc struct that is complicated to manage. But it currently works,
so I will be keeping it for the time being.

* fix: change separator between remoteref and name

With the inclusion of the port number in the canonical id, the :
separator between the remoteref and remote name causes problems if the
port is parsed instead. This changes it to a # in order to avoid this
conflict.

* fix: check for null when closing extra files

It is possible for the list of extra files to contain null files. This
change ensures the null files will not be erroneously closed.

* fix: change connecting method to show port once

With port added to the canonicalname, it no longer makes sense to append
the port afterward.

* feat: use user input modal for sudo connection

The sudo connection used to have a unique way of entering a password.
This change provides an alternative method using the user input modal
that the other connection methods use. It does not work perfectly with
this revision, but the basic building blocks are in place. It needs a
few timer updates to be complete.

* fix: remove old timer to prevent conflicts with it

With this change the old timer is no longer needed. It is not fully
removed yet, but it is disabled so as to not get in the way.
Additionally, error handling has been slightly improved.

There is still a bug where an incorrect password prints a new password
prompt after the error message. That needs to be fixed in the future.

go.work.sum

@@ -1,9 +1,7 @@
 github.com/aws/aws-sdk-go-v2/service/s3 v1.27.11 h1:3/gm/JTX9bX8CpzTgIlrtYpB3EVBDxyg/GY/QdcIEZw=
-github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8=
+github.com/google/go-github/v57 v57.0.0 h1:L+Y3UPTY8ALM8x+TV0lg+IEBI+upibemtBD8Q9u7zHs=
 github.com/kevinburke/ssh_config v1.2.0 h1:x584FjTGwHzMwvHx18PXxbBVzfnxogHaAReU4gf13a4=
 github.com/kevinburke/ssh_config v1.2.0/go.mod h1:CT57kijsi8u/K/BOFA39wgDQJ9CxiF4nAY/ojJ6r6mM=
-github.com/wavetermdev/ssh_config v0.0.0-20240109090616-36c8da3d7376 h1:tFhJgTu7lgd+hldLfPSzDCoWUpXI8wHKR3rxq5jTLkQ=
-github.com/wavetermdev/ssh_config v0.0.0-20240109090616-36c8da3d7376/go.mod h1:q2RIzfka+BXARoNexmF9gkxEX7DmvbW9P4hIVx2Kg4M=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
 golang.org/x/sync v0.2.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=

waveshell/pkg/server/server.go

@@ -652,7 +652,7 @@ func (m *MServer) runCommand(runPacket *packet.RunPacketType) {
 		m.Sender.SendErrorResponse(runPacket.ReqId, fmt.Errorf("server run packets require valid ck: %s", err))
 		return
 	}
-	cproc, _, err := shexec.MakeClientProc(context.Background(), shexec.CmdWrap{Cmd: ecmd})
+	cproc, err := shexec.MakeClientProc(context.Background(), shexec.CmdWrap{Cmd: ecmd})
 	if err != nil {
 		m.Sender.SendErrorResponse(runPacket.ReqId, fmt.Errorf("starting mshell client: %s", err))
 		return

waveshell/pkg/shexec/client.go

@@ -57,9 +57,28 @@ func (cw CmdWrap) Parser() (*packet.PacketParser, io.ReadCloser, io.ReadCloser,
 }
 
 func (cw CmdWrap) Start() error {
+	defer func() {
+		for _, extraFile := range cw.Cmd.ExtraFiles {
+			if extraFile != nil {
+				extraFile.Close()
+			}
+		}
+	}()
 	return cw.Cmd.Start()
 }
 
+func (cw CmdWrap) StdinPipe() (io.WriteCloser, error) {
+	return cw.Cmd.StdinPipe()
+}
+
+func (cw CmdWrap) StdoutPipe() (io.ReadCloser, error) {
+	return cw.Cmd.StdoutPipe()
+}
+
+func (cw CmdWrap) StderrPipe() (io.ReadCloser, error) {
+	return cw.Cmd.StderrPipe()
+}
+
 type SessionWrap struct {
 	Session  *ssh.Session
 	StartCmd string
@@ -101,12 +120,35 @@ func (sw SessionWrap) Parser() (*packet.PacketParser, io.ReadCloser, io.ReadClos
 	return packetParser, io.NopCloser(stdoutReader), io.NopCloser(stderrReader), nil
 }
 
+func (sw SessionWrap) StdinPipe() (io.WriteCloser, error) {
+	return sw.Session.StdinPipe()
+}
+
+func (sw SessionWrap) StdoutPipe() (io.ReadCloser, error) {
+	stdoutReader, err := sw.Session.StdoutPipe()
+	if err != nil {
+		return nil, err
+	}
+	return io.NopCloser(stdoutReader), nil
+}
+
+func (sw SessionWrap) StderrPipe() (io.ReadCloser, error) {
+	stderrReader, err := sw.Session.StderrPipe()
+	if err != nil {
+		return nil, err
+	}
+	return io.NopCloser(stderrReader), nil
+}
+
 type ConnInterface interface {
 	Kill()
 	Wait() error
 	Sender() (*packet.PacketSender, io.WriteCloser, error)
 	Parser() (*packet.PacketParser, io.ReadCloser, io.ReadCloser, error)
 	Start() error
+	StdinPipe() (io.WriteCloser, error)
+	StdoutPipe() (io.ReadCloser, error)
+	StderrPipe() (io.ReadCloser, error)
 }
 
 type ClientProc struct {
@@ -120,20 +162,44 @@ type ClientProc struct {
 	Output       *packet.PacketParser
 }
 
+type WaveshellLaunchError struct {
+	InitPk *packet.InitPacketType
+}
+
+func (wle WaveshellLaunchError) Error() string {
+	if wle.InitPk.NotFound {
+		return "waveshell client not found"
+	} else if semver.MajorMinor(wle.InitPk.Version) != semver.MajorMinor(base.MShellVersion) {
+		return fmt.Sprintf("invalid remote waveshell version '%s', must be '=%s'", wle.InitPk.Version, semver.MajorMinor(base.MShellVersion))
+	}
+	return fmt.Sprintf("invalid waveshell: init packet=%v", *wle.InitPk)
+}
+
+type InvalidPacketError struct {
+	InvalidPk *packet.PacketType
+}
+
+func (ipe InvalidPacketError) Error() string {
+	if ipe.InvalidPk == nil {
+		return "no init packet received from waveshell client"
+	}
+	return fmt.Sprintf("invalid packet received from waveshell client: %s", packet.AsString(*ipe.InvalidPk))
+}
+
 // returns (clientproc, initpk, error)
-func MakeClientProc(ctx context.Context, ecmd ConnInterface) (*ClientProc, *packet.InitPacketType, error) {
+func MakeClientProc(ctx context.Context, ecmd ConnInterface) (*ClientProc, error) {
 	startTs := time.Now()
 	sender, inputWriter, err := ecmd.Sender()
 	if err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 	packetParser, stdoutReader, stderrReader, err := ecmd.Parser()
 	if err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 	err = ecmd.Start()
 	if err != nil {
-		return nil, nil, fmt.Errorf("running local client: %w", err)
+		return nil, fmt.Errorf("running local client: %w", err)
 	}
 	cproc := &ClientProc{
 		Cmd:          ecmd,
@@ -150,29 +216,27 @@ func MakeClientProc(ctx context.Context, ecmd ConnInterface) (*ClientProc, *pack
 	case pk = <-packetParser.MainCh:
 	case <-ctx.Done():
 		cproc.Close()
-		return nil, nil, ctx.Err()
+		return nil, ctx.Err()
 	}
-	if pk != nil {
-		if pk.GetType() != packet.InitPacketStr {
-			cproc.Close()
-			return nil, nil, fmt.Errorf("invalid packet received from mshell client: %s", packet.AsString(pk))
-		}
-		initPk := pk.(*packet.InitPacketType)
-		if initPk.NotFound {
-			cproc.Close()
-			return nil, initPk, fmt.Errorf("mshell client not found")
-		}
-		if semver.MajorMinor(initPk.Version) != semver.MajorMinor(base.MShellVersion) {
-			cproc.Close()
-			return nil, initPk, fmt.Errorf("invalid remote mshell version '%s', must be '=%s'", initPk.Version, semver.MajorMinor(base.MShellVersion))
-		}
-		cproc.InitPk = initPk
-	}
-	if cproc.InitPk == nil {
+	if pk == nil {
 		cproc.Close()
-		return nil, nil, fmt.Errorf("no init packet received from mshell client")
+		return nil, InvalidPacketError{}
 	}
-	return cproc, cproc.InitPk, nil
+	if pk.GetType() != packet.InitPacketStr {
+		cproc.Close()
+		return nil, InvalidPacketError{InvalidPk: &pk}
+	}
+	initPk := pk.(*packet.InitPacketType)
+	if initPk.NotFound {
+		cproc.Close()
+		return nil, WaveshellLaunchError{InitPk: initPk}
+	}
+	if semver.MajorMinor(initPk.Version) != semver.MajorMinor(base.MShellVersion) {
+		cproc.Close()
+		return nil, WaveshellLaunchError{InitPk: initPk}
+	}
+	cproc.InitPk = initPk
+	return cproc, nil
 }
 
 func (cproc *ClientProc) Close() {

waveshell/pkg/shexec/shexec.go

@@ -437,6 +437,16 @@ func MakeMShellSingleCmd() (*exec.Cmd, error) {
 	return ecmd, nil
 }
 
+func MakeLocalExecCmd(cmdStr string, sapi shellapi.ShellApi) *exec.Cmd {
+	homeDir, _ := os.UserHomeDir() // ignore error
+	if homeDir == "" {
+		homeDir = "/"
+	}
+	ecmd := exec.Command(sapi.GetLocalShellPath(), "-c", cmdStr)
+	ecmd.Dir = homeDir
+	return ecmd
+}
+
 func (opts SSHOpts) MakeSSHExecCmd(remoteCommand string, sapi shellapi.ShellApi) *exec.Cmd {
 	remoteCommand = strings.TrimSpace(remoteCommand)
 	if opts.SSHHost == "" {
@@ -587,7 +597,7 @@ func sendMShellBinary(input io.WriteCloser, mshellStream io.Reader) {
 	}()
 }
 
-func RunInstallFromCmd(ctx context.Context, ecmd *exec.Cmd, tryDetect bool, mshellStream io.Reader, mshellReaderFn MShellBinaryReaderFn, msgFn func(string)) error {
+func RunInstallFromCmd(ctx context.Context, ecmd ConnInterface, tryDetect bool, mshellStream io.Reader, mshellReaderFn MShellBinaryReaderFn, msgFn func(string)) error {
 	inputWriter, err := ecmd.StdinPipe()
 	if err != nil {
 		return fmt.Errorf("creating stdin pipe: %v", err)

wavesrv/pkg/cmdrunner/resolver.go

@@ -443,7 +443,7 @@ func parseFullRemoteRef(fullRemoteRef string) (string, string, string, error) {
 	if strings.HasPrefix(fullRemoteRef, "[") && strings.HasSuffix(fullRemoteRef, "]") {
 		fullRemoteRef = fullRemoteRef[1 : len(fullRemoteRef)-1]
 	}
-	fields := strings.Split(fullRemoteRef, ":")
+	fields := strings.Split(fullRemoteRef, "#")
 	if len(fields) > 3 {
 		return "", "", "", fmt.Errorf("invalid remote format '%s'", fullRemoteRef)
 	}

wavesrv/pkg/remote/sshclient.go

@@ -110,7 +110,8 @@ func createPublicKeyCallback(sshKeywords *SshKeywords, passphrase string) func()
 			QueryText:    fmt.Sprintf("Enter passphrase for the SSH key: %s", identityFile),
 			Title:        "Publickey Auth + Passphrase",
 		}
-		ctx, _ := context.WithTimeout(context.Background(), 60*time.Second)
+		ctx, cancelFn := context.WithTimeout(context.Background(), 60*time.Second)
+		defer cancelFn()
 		response, err := userinput.GetUserInput(ctx, scbus.MainRpcBus, request)
 		if err != nil {
 			// this is an error where we actually do want to stop
@@ -267,6 +268,10 @@ func writeToKnownHosts(knownHostsFile string, newLine string, getUserVerificatio
 	}
 
 	_, err = f.WriteString(newLine)
+	if err != nil {
+		f.Close()
+		return err
+	}
 	return f.Close()
 }