tree e4f94e25112d3ae88eaa458b4d30a3876f28ce58
parent b3b919d5c89d43aebfc6f25f147bf41db11950bf
author Gao Hongtao <hanahmily@gmail.com> 1610007857 +0800
committer GitHub <noreply@github.com> 1610007857 +0800
gpgsig -----BEGIN PGP SIGNATURE-----
 
 wsBcBAABCAAQBQJf9sUxCRBK7hj4Ov3rIwAAdHIIAKLy2Zy+UVNjGM9IPzcKS06t
 oVlK2DgLoHaZMfKofpkL3HogO0agWRwK7Dd0jwSXRUHlAALiA+UEFiqTDiYrZwfZ
 YPiUA7TnsMAPCG7qcbCwT82CB34UTYsX8Sc0HkEyB9PlxsOLgkA16mShs8eVDI3A
 7udBDk9BlHRuEBImD71t+LAEovDmDfbeV7TV3JE6bdV+oaCHl4GobBRsCgD5SI1F
 55SPRu1EbNcUcJYmR1JkrautqNhfBBrpYBc81F6zXI88WbzCW0v3zf658KTwqCc9
 xJbxJSBXFXMZS54XYZzNUHyufR9LrCarx4WXdaUSMYQw1k+SpEC9lCExDe7NJOg=
 =L81c
 -----END PGP SIGNATURE-----
 

Add install command and manifest sub command (#84)

* Add install command and manifest sub command

Signed-off-by: Gao Hongtao <hanahmily@gmail.com>

* Update mod

Signed-off-by: Gao Hongtao <hanahmily@gmail.com>

* Polish go.sum

Signed-off-by: Gao Hongtao <hanahmily@gmail.com>

* Increase lint timeout

Signed-off-by: Gao Hongtao <hanahmily@gmail.com>

* Upgrade swck

Signed-off-by: Gao Hongtao <hanahmily@gmail.com>

* Update internal/commands/install/manifest/manifest.go

Co-authored-by: Zhenxu Ke <kezhenxu94@apache.org>

* Fix default template

Signed-off-by: Gao Hongtao <hanahmily@gmail.com>

* Update assets

Signed-off-by: Gao Hongtao <hanahmily@gmail.com>

Co-authored-by: Zhenxu Ke <kezhenxu94@apache.org>