fix: publickey

backend/acl/login.go

@@ -7,11 +7,13 @@ import (
 	"errors"
 	"fmt"
 	"net/http"
+	"strings"
 
 	"github.com/samber/lo"
 	"github.com/veops/oneterm/conf"
 	mysql "github.com/veops/oneterm/db"
 	"github.com/veops/oneterm/logger"
+	"github.com/veops/oneterm/model"
 	"github.com/veops/oneterm/remote"
 	"github.com/veops/oneterm/util"
 	"go.uber.org/zap"
@@ -47,11 +49,12 @@ func LoginByPassword(ctx context.Context, username string, password string) (ses
 }
 
 func LoginByPublicKey(ctx context.Context, username string, pk string) (sess *Session, err error) {
+	pk = strings.TrimSpace(pk)
 	enc := util.EncryptAES(pk)
 	cnt := int64(0)
-	if err = mysql.DB.Where("usernmae = ? AND pk = ?", username, enc).Count(&cnt).Error; err != nil || cnt == 0 {
+	if err = mysql.DB.Model(&model.PublicKey{}).Where("username = ? AND pk = ?", username, enc).Count(&cnt).Error; err != nil || cnt == 0 {
 		err = fmt.Errorf("%w", err)
-		logger.L().Warn("no pk", zap.Error(err))
+		logger.L().Warn("find pk failed", zap.Int64("cnt", cnt), zap.Error(err))
 		return
 	}
 

backend/api/api.go

@@ -32,7 +32,7 @@ func RunApi() error {
 	docs.SwaggerInfo.BasePath = "/api/oneterm/v1"
 	r.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerFiles.Handler))
 
-	v1 := r.Group("/api/oneterm/v1", auth())
+	v1 := r.Group("/api/oneterm/v1", Error2Resp(), auth())
 	{
 		account := v1.Group("account")
 		{
@@ -117,6 +117,12 @@ func RunApi() error {
 			file.GET("/download/:asset_id/:account_id", c.FileDownload)
 		}
 
+		config := v1.Group("config")
+		{
+			config.GET("", c.GetConfig)
+			config.POST("", c.PostConfig)
+		}
+
 		history := v1.Group("history")
 		{
 			history.GET("", c.GetHistories)

backend/api/controller/config.go

@@ -27,7 +27,7 @@ func (c *Controller) PostConfig(ctx *gin.Context) {
 	}
 
 	cfg := &model.Config{}
-	if err := ctx.BindJSON(cfg); err != nil {
+	if err := ctx.ShouldBindBodyWithJSON(cfg); err != nil {
 		ctx.AbortWithError(http.StatusBadRequest, &ApiError{Code: ErrInvalidArgument, Data: map[string]any{"err": err}})
 		return
 	}

backend/api/controller/connect.go

@@ -101,6 +101,8 @@ func HandleSsh(sess *gsession.Session) (err error) {
 		}
 	}()
 	chs := sess.Chans
+	sess.IdleTimout = idleTime()
+	sess.IdleTk = time.NewTicker(sess.IdleTimout)
 	tk, tk1s, tk1m := time.NewTicker(time.Millisecond*100), time.NewTicker(time.Second), time.NewTicker(time.Minute)
 	sess.G.Go(func() error {
 		return read(sess)

backend/api/middleware.go

@@ -1,13 +1,19 @@
 package api
 
 import (
+	"bytes"
+	"encoding/json"
 	"net/http"
+	"strings"
 	"time"
 
 	"github.com/gin-gonic/gin"
+	"github.com/nicksnyder/go-i18n/v2/i18n"
 	"go.uber.org/zap"
 
 	"github.com/veops/oneterm/acl"
+	"github.com/veops/oneterm/api/controller"
+	myi18n "github.com/veops/oneterm/i18n"
 	"github.com/veops/oneterm/logger"
 )
 
@@ -63,3 +69,53 @@ func auth() gin.HandlerFunc {
 		ctx.Next()
 	}
 }
+
+type bodyWriter struct {
+	gin.ResponseWriter
+	body *bytes.Buffer
+}
+
+func (w bodyWriter) Write(b []byte) (int, error) {
+	return w.body.Write(b)
+}
+
+func Error2Resp() gin.HandlerFunc {
+	return func(ctx *gin.Context) {
+		if strings.Contains(ctx.Request.URL.String(), "session/replay") {
+			ctx.Next()
+			return
+		}
+
+		wb := &bodyWriter{
+			body:           &bytes.Buffer{},
+			ResponseWriter: ctx.Writer,
+		}
+		ctx.Writer = wb
+
+		ctx.Next()
+
+		obj := make(map[string]any)
+		json.Unmarshal(wb.body.Bytes(), &obj)
+		if len(ctx.Errors) > 0 {
+			if v, ok := obj["code"]; !ok || v == 0 {
+				obj["code"] = ctx.Writer.Status()
+			}
+
+			if v, ok := obj["message"]; !ok || v == "" {
+				e := ctx.Errors.Last().Err
+				obj["message"] = e.Error()
+
+				ae, ok := e.(*controller.ApiError)
+				if ok {
+					lang := ctx.PostForm("lang")
+					accept := ctx.GetHeader("Accept-Language")
+					localizer := i18n.NewLocalizer(myi18n.Bundle, lang, accept)
+					obj["message"] = ae.Message(localizer)
+
+				}
+			}
+		}
+		bs, _ := json.Marshal(obj)
+		wb.ResponseWriter.Write(bs)
+	}
+}

backend/conf/conf.go

@@ -124,6 +124,7 @@ type Worker struct {
 type SshConfig struct {
 	Host       string `yaml:"host"`
 	Port       int    `yaml:"port"`
+	PrivateKey string `yaml:"privateKey"`
 }
 
 type GuacdConfig struct {

backend/config.example.yaml

@@ -7,6 +7,7 @@ http:
 ssh:
   host: 0.0.0.0
   port: 2222
+  privateKey: --BEGIN PRIVATE KEY-----END PRIVATE KEY-----
 
 guacd:
   host: oneterm-guacd

backend/sshsrv/handler.go

@@ -15,6 +15,7 @@ import (
 	gossh "golang.org/x/crypto/ssh"
 	"golang.org/x/sync/errgroup"
 
+	"github.com/veops/oneterm/conf"
 	"github.com/veops/oneterm/logger"
 	"github.com/veops/oneterm/model"
 )
@@ -39,17 +40,19 @@ func handler(sess ssh.Session) {
 
 	eg, gctx := errgroup.WithContext(sess.Context())
 	r, w := io.Pipe()
-	defer r.Close()
-	defer w.Close()
 	eg.Go(func() error {
 		_, err := io.Copy(w, sess)
 		return err
 	})
 	eg.Go(func() error {
+		defer sess.Close()
 		defer r.Close()
 		defer w.Close()
-		p := tea.NewProgram(initialView(ctx, sess, r, w), tea.WithContext(gctx), tea.WithInput(r), tea.WithOutput(sess))
+		vw := initialView(ctx, sess, r, w)
+		defer vw.RecordHisCmd()
+		p := tea.NewProgram(vw, tea.WithContext(gctx), tea.WithInput(r), tea.WithOutput(sess))
 		_, err := p.Run()
+
 		return err
 	})
 
@@ -59,15 +62,7 @@ func handler(sess ssh.Session) {
 }
 
 func signer() ssh.Signer {
-	str := `-----BEGIN OPENSSH PRIVATE KEY-----
+	s, err := gossh.ParsePrivateKey([]byte(conf.Cfg.Ssh.PrivateKey))
-b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAMwAAAAtzc2gtZW
-QyNTUxOQAAACBg490b4zqumtizCyM4RWtzJnPEsPIInBFugk8+UCb8XgAAAKCc1yKrnNci
-qwAAAAtzc2gtZWQyNTUxOQAAACBg490b4zqumtizCyM4RWtzJnPEsPIInBFugk8+UCb8Xg
-AAAECvd1Yj+bQxyxJtU3PirLK68CD3MWqBv0/shlFKS6wmbWDj3RvjOq6a2LMLIzhFa3Mm
-c8Sw8gicEW6CTz5QJvxeAAAAGnJvb3RAbG9jYWxob3N0LmxvY2FsZG9tYWluAQID
------END OPENSSH PRIVATE KEY-----
-	`
-	s, err := gossh.ParsePrivateKey([]byte(str))
 	if err != nil {
 		logger.L().Fatal("failed parse signer", zap.Error(err))
 	}

backend/sshsrv/sshsrv.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 
 	"github.com/gliderlabs/ssh"
+	gossh "golang.org/x/crypto/ssh"
 
 	"github.com/veops/oneterm/acl"
 	"github.com/veops/oneterm/conf"
@@ -25,7 +26,7 @@ func init() {
 			return err == nil
 		},
 		PublicKeyHandler: func(ctx ssh.Context, key ssh.PublicKey) bool {
-			sess, err := acl.LoginByPublicKey(ctx, ctx.User(), string(key.Marshal()))
+			sess, err := acl.LoginByPublicKey(ctx, ctx.User(), string(gossh.MarshalAuthorizedKey(key)))
 			ctx.SetValue("session", sess)
 			return err == nil
 		},

backend/sshsrv/textinput/input.go

@@ -0,0 +1,904 @@
+package textinput
+
+import (
+	"reflect"
+	"strings"
+	"time"
+	"unicode"
+
+	"github.com/atotto/clipboard"
+	"github.com/charmbracelet/bubbles/cursor"
+	"github.com/charmbracelet/bubbles/key"
+	"github.com/charmbracelet/bubbles/runeutil"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+	rw "github.com/mattn/go-runewidth"
+	"github.com/rivo/uniseg"
+)
+
+// Internal messages for clipboard operations.
+type (
+	pasteMsg    string
+	pasteErrMsg struct{ error }
+)
+
+// EchoMode sets the input behavior of the text input field.
+type EchoMode int
+
+const (
+	// EchoNormal displays text as is. This is the default behavior.
+	EchoNormal EchoMode = iota
+
+	// EchoPassword displays the EchoCharacter mask instead of actual
+	// characters. This is commonly used for password fields.
+	EchoPassword
+
+	// EchoNone displays nothing as characters are entered. This is commonly
+	// seen for password fields on the command line.
+	EchoNone
+)
+
+// ValidateFunc is a function that returns an error if the input is invalid.
+type ValidateFunc func(string) error
+
+// KeyMap is the key bindings for different actions within the textinput.
+type KeyMap struct {
+	CharacterForward        key.Binding
+	CharacterBackward       key.Binding
+	WordForward             key.Binding
+	WordBackward            key.Binding
+	DeleteWordBackward      key.Binding
+	DeleteWordForward       key.Binding
+	DeleteAfterCursor       key.Binding
+	DeleteBeforeCursor      key.Binding
+	DeleteCharacterBackward key.Binding
+	DeleteCharacterForward  key.Binding
+	LineStart               key.Binding
+	LineEnd                 key.Binding
+	Paste                   key.Binding
+	AcceptSuggestion        key.Binding
+}
+
+// DefaultKeyMap is the default set of key bindings for navigating and acting
+// upon the textinput.
+var DefaultKeyMap = KeyMap{
+	CharacterForward:        key.NewBinding(key.WithKeys("right", "ctrl+f")),
+	CharacterBackward:       key.NewBinding(key.WithKeys("left", "ctrl+b")),
+	WordForward:             key.NewBinding(key.WithKeys("alt+right", "ctrl+right", "alt+f")),
+	WordBackward:            key.NewBinding(key.WithKeys("alt+left", "ctrl+left", "alt+b")),
+	DeleteWordBackward:      key.NewBinding(key.WithKeys("alt+backspace", "ctrl+w")),
+	DeleteWordForward:       key.NewBinding(key.WithKeys("alt+delete", "alt+d")),
+	DeleteAfterCursor:       key.NewBinding(key.WithKeys("ctrl+k")),
+	DeleteBeforeCursor:      key.NewBinding(key.WithKeys("ctrl+u")),
+	DeleteCharacterBackward: key.NewBinding(key.WithKeys("backspace", "ctrl+h")),
+	DeleteCharacterForward:  key.NewBinding(key.WithKeys("delete", "ctrl+d")),
+	LineStart:               key.NewBinding(key.WithKeys("home", "ctrl+a")),
+	LineEnd:                 key.NewBinding(key.WithKeys("end", "ctrl+e")),
+	Paste:                   key.NewBinding(key.WithKeys("ctrl+v")),
+	AcceptSuggestion:        key.NewBinding(key.WithKeys("tab")),
+}
+
+// Model is the Bubble Tea model for this text input element.
+type Model struct {
+	Err error
+
+	// General settings.
+	Prompt        string
+	Placeholder   string
+	EchoMode      EchoMode
+	EchoCharacter rune
+	Cursor        cursor.Model
+
+	// Deprecated: use [cursor.BlinkSpeed] instead.
+	BlinkSpeed time.Duration
+
+	// Styles. These will be applied as inline styles.
+	//
+	// For an introduction to styling with Lip Gloss see:
+	// https://github.com/charmbracelet/lipgloss
+	PromptStyle      lipgloss.Style
+	TextStyle        lipgloss.Style
+	PlaceholderStyle lipgloss.Style
+	CompletionStyle  lipgloss.Style
+
+	// Deprecated: use Cursor.Style instead.
+	CursorStyle lipgloss.Style
+
+	// CharLimit is the maximum amount of characters this input element will
+	// accept. If 0 or less, there's no limit.
+	CharLimit int
+
+	// Width is the maximum number of characters that can be displayed at once.
+	// It essentially treats the text field like a horizontally scrolling
+	// viewport. If 0 or less this setting is ignored.
+	Width int
+
+	// KeyMap encodes the keybindings recognized by the widget.
+	KeyMap KeyMap
+
+	// Underlying text value.
+	value []rune
+
+	// focus indicates whether user input focus should be on this input
+	// component. When false, ignore keyboard input and hide the cursor.
+	focus bool
+
+	// Cursor position.
+	pos int
+
+	// Used to emulate a viewport when width is set and the content is
+	// overflowing.
+	offset      int
+	offsetRight int
+
+	// Validate is a function that checks whether or not the text within the
+	// input is valid. If it is not valid, the `Err` field will be set to the
+	// error returned by the function. If the function is not defined, all
+	// input is considered valid.
+	Validate ValidateFunc
+
+	// rune sanitizer for input.
+	rsan runeutil.Sanitizer
+
+	// Should the input suggest to complete
+	ShowSuggestions bool
+
+	// suggestions is a list of suggestions that may be used to complete the
+	// input.
+	suggestions            [][]rune
+	matchedSuggestions     [][]rune
+	currentSuggestionIndex int
+}
+
+// New creates a new model with default settings.
+func New() Model {
+	return Model{
+		Prompt:           "> ",
+		EchoCharacter:    '*',
+		CharLimit:        0,
+		PlaceholderStyle: lipgloss.NewStyle().Foreground(lipgloss.Color("240")),
+		ShowSuggestions:  false,
+		CompletionStyle:  lipgloss.NewStyle().Foreground(lipgloss.Color("240")),
+		Cursor:           cursor.New(),
+		KeyMap:           DefaultKeyMap,
+
+		suggestions: [][]rune{},
+		value:       nil,
+		focus:       false,
+		pos:         0,
+	}
+}
+
+// NewModel creates a new model with default settings.
+//
+// Deprecated: Use [New] instead.
+var NewModel = New
+
+// SetValue sets the value of the text input.
+func (m *Model) SetValue(s string) {
+	// Clean up any special characters in the input provided by the
+	// caller. This avoids bugs due to e.g. tab characters and whatnot.
+	runes := m.san().Sanitize([]rune(s))
+	err := m.validate(runes)
+	m.setValueInternal(runes, err)
+}
+
+func (m *Model) setValueInternal(runes []rune, err error) {
+	m.Err = err
+
+	empty := len(m.value) == 0
+
+	if m.CharLimit > 0 && len(runes) > m.CharLimit {
+		m.value = runes[:m.CharLimit]
+	} else {
+		m.value = runes
+	}
+	if (m.pos == 0 && empty) || m.pos > len(m.value) {
+		m.SetCursor(len(m.value))
+	}
+	m.handleOverflow()
+}
+
+// Value returns the value of the text input.
+func (m Model) Value() string {
+	return string(m.value)
+}
+
+// Position returns the cursor position.
+func (m Model) Position() int {
+	return m.pos
+}
+
+// SetCursor moves the cursor to the given position. If the position is
+// out of bounds the cursor will be moved to the start or end accordingly.
+func (m *Model) SetCursor(pos int) {
+	m.pos = clamp(pos, 0, len(m.value))
+	m.handleOverflow()
+}
+
+// CursorStart moves the cursor to the start of the input field.
+func (m *Model) CursorStart() {
+	m.SetCursor(0)
+}
+
+// CursorEnd moves the cursor to the end of the input field.
+func (m *Model) CursorEnd() {
+	m.SetCursor(len(m.value))
+}
+
+// Focused returns the focus state on the model.
+func (m Model) Focused() bool {
+	return m.focus
+}
+
+// Focus sets the focus state on the model. When the model is in focus it can
+// receive keyboard input and the cursor will be shown.
+func (m *Model) Focus() tea.Cmd {
+	m.focus = true
+	return m.Cursor.Focus()
+}
+
+// Blur removes the focus state on the model.  When the model is blurred it can
+// not receive keyboard input and the cursor will be hidden.
+func (m *Model) Blur() {
+	m.focus = false
+	m.Cursor.Blur()
+}
+
+// Reset sets the input to its default state with no input.
+func (m *Model) Reset() {
+	m.value = nil
+	m.SetCursor(0)
+}
+
+// SetSuggestions sets the suggestions for the input.
+func (m *Model) SetSuggestions(suggestions []string) {
+	m.suggestions = make([][]rune, len(suggestions))
+	for i, s := range suggestions {
+		m.suggestions[i] = []rune(s)
+	}
+
+	m.updateSuggestions()
+}
+
+// rsan initializes or retrieves the rune sanitizer.
+func (m *Model) san() runeutil.Sanitizer {
+	if m.rsan == nil {
+		// Textinput has all its input on a single line so collapse
+		// newlines/tabs to single spaces.
+		m.rsan = runeutil.NewSanitizer(
+			runeutil.ReplaceTabs(" "), runeutil.ReplaceNewlines(" "))
+	}
+	return m.rsan
+}
+
+func (m *Model) insertRunesFromUserInput(v []rune) {
+	// Clean up any special characters in the input provided by the
+	// clipboard. This avoids bugs due to e.g. tab characters and
+	// whatnot.
+	paste := m.san().Sanitize(v)
+
+	var availSpace int
+	if m.CharLimit > 0 {
+		availSpace = m.CharLimit - len(m.value)
+
+		// If the char limit's been reached, cancel.
+		if availSpace <= 0 {
+			return
+		}
+
+		// If there's not enough space to paste the whole thing cut the pasted
+		// runes down so they'll fit.
+		if availSpace < len(paste) {
+			paste = paste[:availSpace]
+		}
+	}
+
+	// Stuff before and after the cursor
+	head := m.value[:m.pos]
+	tailSrc := m.value[m.pos:]
+	tail := make([]rune, len(tailSrc))
+	copy(tail, tailSrc)
+
+	// Insert pasted runes
+	for _, r := range paste {
+		head = append(head, r)
+		m.pos++
+		if m.CharLimit > 0 {
+			availSpace--
+			if availSpace <= 0 {
+				break
+			}
+		}
+	}
+
+	// Put it all back together
+	value := append(head, tail...)
+	inputErr := m.validate(value)
+	m.setValueInternal(value, inputErr)
+}
+
+// If a max width is defined, perform some logic to treat the visible area
+// as a horizontally scrolling viewport.
+func (m *Model) handleOverflow() {
+	if m.Width <= 0 || uniseg.StringWidth(string(m.value)) <= m.Width {
+		m.offset = 0
+		m.offsetRight = len(m.value)
+		return
+	}
+
+	// Correct right offset if we've deleted characters
+	m.offsetRight = min(m.offsetRight, len(m.value))
+
+	if m.pos < m.offset {
+		m.offset = m.pos
+
+		w := 0
+		i := 0
+		runes := m.value[m.offset:]
+
+		for i < len(runes) && w <= m.Width {
+			w += rw.RuneWidth(runes[i])
+			if w <= m.Width+1 {
+				i++
+			}
+		}
+
+		m.offsetRight = m.offset + i
+	} else if m.pos >= m.offsetRight {
+		m.offsetRight = m.pos
+
+		w := 0
+		runes := m.value[:m.offsetRight]
+		i := len(runes) - 1
+
+		for i > 0 && w < m.Width {
+			w += rw.RuneWidth(runes[i])
+			if w <= m.Width {
+				i--
+			}
+		}
+
+		m.offset = m.offsetRight - (len(runes) - 1 - i)
+	}
+}
+
+// deleteBeforeCursor deletes all text before the cursor.
+func (m *Model) deleteBeforeCursor() {
+	m.value = m.value[m.pos:]
+	m.Err = m.validate(m.value)
+	m.offset = 0
+	m.SetCursor(0)
+}
+
+// deleteAfterCursor deletes all text after the cursor. If input is masked
+// delete everything after the cursor so as not to reveal word breaks in the
+// masked input.
+func (m *Model) deleteAfterCursor() {
+	m.value = m.value[:m.pos]
+	m.Err = m.validate(m.value)
+	m.SetCursor(len(m.value))
+}
+
+// deleteWordBackward deletes the word left to the cursor.
+func (m *Model) deleteWordBackward() {
+	if m.pos == 0 || len(m.value) == 0 {
+		return
+	}
+
+	if m.EchoMode != EchoNormal {
+		m.deleteBeforeCursor()
+		return
+	}
+
+	// Linter note: it's critical that we acquire the initial cursor position
+	// here prior to altering it via SetCursor() below. As such, moving this
+	// call into the corresponding if clause does not apply here.
+	oldPos := m.pos //nolint:ifshort
+
+	m.SetCursor(m.pos - 1)
+	for unicode.IsSpace(m.value[m.pos]) {
+		if m.pos <= 0 {
+			break
+		}
+		// ignore series of whitespace before cursor
+		m.SetCursor(m.pos - 1)
+	}
+
+	for m.pos > 0 {
+		if !unicode.IsSpace(m.value[m.pos]) {
+			m.SetCursor(m.pos - 1)
+		} else {
+			if m.pos > 0 {
+				// keep the previous space
+				m.SetCursor(m.pos + 1)
+			}
+			break
+		}
+	}
+
+	if oldPos > len(m.value) {
+		m.value = m.value[:m.pos]
+	} else {
+		m.value = append(m.value[:m.pos], m.value[oldPos:]...)
+	}
+	m.Err = m.validate(m.value)
+}
+
+// deleteWordForward deletes the word right to the cursor. If input is masked
+// delete everything after the cursor so as not to reveal word breaks in the
+// masked input.
+func (m *Model) deleteWordForward() {
+	if m.pos >= len(m.value) || len(m.value) == 0 {
+		return
+	}
+
+	if m.EchoMode != EchoNormal {
+		m.deleteAfterCursor()
+		return
+	}
+
+	oldPos := m.pos
+	m.SetCursor(m.pos + 1)
+	for unicode.IsSpace(m.value[m.pos]) {
+		// ignore series of whitespace after cursor
+		m.SetCursor(m.pos + 1)
+
+		if m.pos >= len(m.value) {
+			break
+		}
+	}
+
+	for m.pos < len(m.value) {
+		if !unicode.IsSpace(m.value[m.pos]) {
+			m.SetCursor(m.pos + 1)
+		} else {
+			break
+		}
+	}
+
+	if m.pos > len(m.value) {
+		m.value = m.value[:oldPos]
+	} else {
+		m.value = append(m.value[:oldPos], m.value[m.pos:]...)
+	}
+	m.Err = m.validate(m.value)
+
+	m.SetCursor(oldPos)
+}
+
+// wordBackward moves the cursor one word to the left. If input is masked, move
+// input to the start so as not to reveal word breaks in the masked input.
+func (m *Model) wordBackward() {
+	if m.pos == 0 || len(m.value) == 0 {
+		return
+	}
+
+	if m.EchoMode != EchoNormal {
+		m.CursorStart()
+		return
+	}
+
+	i := m.pos - 1
+	for i >= 0 {
+		if unicode.IsSpace(m.value[i]) {
+			m.SetCursor(m.pos - 1)
+			i--
+		} else {
+			break
+		}
+	}
+
+	for i >= 0 {
+		if !unicode.IsSpace(m.value[i]) {
+			m.SetCursor(m.pos - 1)
+			i--
+		} else {
+			break
+		}
+	}
+}
+
+// wordForward moves the cursor one word to the right. If the input is masked,
+// move input to the end so as not to reveal word breaks in the masked input.
+func (m *Model) wordForward() {
+	if m.pos >= len(m.value) || len(m.value) == 0 {
+		return
+	}
+
+	if m.EchoMode != EchoNormal {
+		m.CursorEnd()
+		return
+	}
+
+	i := m.pos
+	for i < len(m.value) {
+		if unicode.IsSpace(m.value[i]) {
+			m.SetCursor(m.pos + 1)
+			i++
+		} else {
+			break
+		}
+	}
+
+	for i < len(m.value) {
+		if !unicode.IsSpace(m.value[i]) {
+			m.SetCursor(m.pos + 1)
+			i++
+		} else {
+			break
+		}
+	}
+}
+
+func (m Model) echoTransform(v string) string {
+	switch m.EchoMode {
+	case EchoPassword:
+		return strings.Repeat(string(m.EchoCharacter), uniseg.StringWidth(v))
+	case EchoNone:
+		return ""
+	case EchoNormal:
+		return v
+	default:
+		return v
+	}
+}
+
+// Update is the Bubble Tea update loop.
+func (m Model) Update(msg tea.Msg) (Model, tea.Cmd) {
+	if !m.focus {
+		return m, nil
+	}
+
+	// Need to check for completion before, because key is configurable and might be double assigned
+	keyMsg, ok := msg.(tea.KeyMsg)
+	if ok && key.Matches(keyMsg, m.KeyMap.AcceptSuggestion) {
+		if m.canAcceptSuggestion() {
+			commonPrefix := m.matchedSuggestions[0]
+			for _, s := range m.matchedSuggestions {
+				str := make([]rune, 0)
+				for i := 0; i < min(len(commonPrefix), len(s)); i++ {
+					if commonPrefix[i] != s[i] {
+						break
+					}
+					str = append(str, commonPrefix[i])
+				}
+				commonPrefix = str
+			}
+			m.value = append(m.value, commonPrefix[len(m.value):]...)
+			m.CursorEnd()
+		}
+	}
+
+	// Let's remember where the position of the cursor currently is so that if
+	// the cursor position changes, we can reset the blink.
+	oldPos := m.pos //nolint
+
+	switch msg := msg.(type) {
+	case tea.KeyMsg:
+		switch {
+		case key.Matches(msg, m.KeyMap.DeleteWordBackward):
+			m.deleteWordBackward()
+		case key.Matches(msg, m.KeyMap.DeleteCharacterBackward):
+			m.Err = nil
+			if len(m.value) > 0 {
+				m.value = append(m.value[:max(0, m.pos-1)], m.value[m.pos:]...)
+				m.Err = m.validate(m.value)
+				if m.pos > 0 {
+					m.SetCursor(m.pos - 1)
+				}
+			}
+		case key.Matches(msg, m.KeyMap.WordBackward):
+			m.wordBackward()
+		case key.Matches(msg, m.KeyMap.CharacterBackward):
+			if m.pos > 0 {
+				m.SetCursor(m.pos - 1)
+			}
+		case key.Matches(msg, m.KeyMap.WordForward):
+			m.wordForward()
+		case key.Matches(msg, m.KeyMap.CharacterForward):
+			if m.pos < len(m.value) {
+				m.SetCursor(m.pos + 1)
+			}
+		case key.Matches(msg, m.KeyMap.LineStart):
+			m.CursorStart()
+		case key.Matches(msg, m.KeyMap.DeleteCharacterForward):
+			if len(m.value) > 0 && m.pos < len(m.value) {
+				m.value = append(m.value[:m.pos], m.value[m.pos+1:]...)
+				m.Err = m.validate(m.value)
+			}
+		case key.Matches(msg, m.KeyMap.LineEnd):
+			m.CursorEnd()
+		case key.Matches(msg, m.KeyMap.DeleteAfterCursor):
+			m.deleteAfterCursor()
+		case key.Matches(msg, m.KeyMap.DeleteBeforeCursor):
+			m.deleteBeforeCursor()
+		case key.Matches(msg, m.KeyMap.Paste):
+			return m, Paste
+		case key.Matches(msg, m.KeyMap.DeleteWordForward):
+			m.deleteWordForward()
+		// case key.Matches(msg, m.KeyMap.NextSuggestion):
+		// 	m.nextSuggestion()
+		// case key.Matches(msg, m.KeyMap.PrevSuggestion):
+		// 	m.previousSuggestion()
+		default:
+			// Input one or more regular characters.
+			m.insertRunesFromUserInput(msg.Runes)
+		}
+
+		// Check again if can be completed
+		// because value might be something that does not match the completion prefix
+		m.updateSuggestions()
+
+	case pasteMsg:
+		m.insertRunesFromUserInput([]rune(msg))
+
+	case pasteErrMsg:
+		m.Err = msg
+	}
+
+	var cmds []tea.Cmd
+	var cmd tea.Cmd
+
+	m.Cursor, cmd = m.Cursor.Update(msg)
+	cmds = append(cmds, cmd)
+
+	if oldPos != m.pos && m.Cursor.Mode() == cursor.CursorBlink {
+		m.Cursor.Blink = false
+		cmds = append(cmds, m.Cursor.BlinkCmd())
+	}
+
+	m.handleOverflow()
+	return m, tea.Batch(cmds...)
+}
+
+// View renders the textinput in its current state.
+func (m Model) View() string {
+	// Placeholder text
+	if len(m.value) == 0 && m.Placeholder != "" {
+		return m.placeholderView()
+	}
+
+	styleText := m.TextStyle.Inline(true).Render
+
+	value := m.value[m.offset:m.offsetRight]
+	pos := max(0, m.pos-m.offset)
+	v := styleText(m.echoTransform(string(value[:pos])))
+
+	if pos < len(value) {
+		char := m.echoTransform(string(value[pos]))
+		m.Cursor.SetChar(char)
+		v += m.Cursor.View()                                   // cursor and text under it
+		v += styleText(m.echoTransform(string(value[pos+1:]))) // text after cursor
+		v += m.completionView(0)                               // suggested completion
+	} else {
+		if m.canAcceptSuggestion() {
+			suggestion := m.matchedSuggestions[m.currentSuggestionIndex]
+			if len(value) < len(suggestion) {
+				m.Cursor.TextStyle = m.CompletionStyle
+				m.Cursor.SetChar(m.echoTransform(string(suggestion[pos])))
+				v += m.Cursor.View()
+				v += m.completionView(1)
+			} else {
+				m.Cursor.SetChar(" ")
+				v += m.Cursor.View()
+			}
+		} else {
+			m.Cursor.SetChar(" ")
+			v += m.Cursor.View()
+		}
+	}
+
+	// If a max width and background color were set fill the empty spaces with
+	// the background color.
+	valWidth := uniseg.StringWidth(string(value))
+	if m.Width > 0 && valWidth <= m.Width {
+		padding := max(0, m.Width-valWidth)
+		if valWidth+padding <= m.Width && pos < len(value) {
+			padding++
+		}
+		v += styleText(strings.Repeat(" ", padding))
+	}
+
+	return m.PromptStyle.Render(m.Prompt) + v
+}
+
+// placeholderView returns the prompt and placeholder view, if any.
+func (m Model) placeholderView() string {
+	var (
+		v     string
+		p     = []rune(m.Placeholder)
+		style = m.PlaceholderStyle.Inline(true).Render
+	)
+
+	m.Cursor.TextStyle = m.PlaceholderStyle
+	m.Cursor.SetChar(string(p[:1]))
+	v += m.Cursor.View()
+
+	// If the entire placeholder is already set and no padding is needed, finish
+	if m.Width < 1 && len(p) <= 1 {
+		return m.PromptStyle.Render(m.Prompt) + v
+	}
+
+	// If Width is set then size placeholder accordingly
+	if m.Width > 0 {
+		// available width is width - len + cursor offset of 1
+		minWidth := lipgloss.Width(m.Placeholder)
+		availWidth := m.Width - minWidth + 1
+
+		// if width < len, 'subtract'(add) number to len and dont add padding
+		if availWidth < 0 {
+			minWidth += availWidth
+			availWidth = 0
+		}
+		// append placeholder[len] - cursor, append padding
+		v += style(string(p[1:minWidth]))
+		v += style(strings.Repeat(" ", availWidth))
+	} else {
+		// if there is no width, the placeholder can be any length
+		v += style(string(p[1:]))
+	}
+
+	return m.PromptStyle.Render(m.Prompt) + v
+}
+
+// Blink is a command used to initialize cursor blinking.
+func Blink() tea.Msg {
+	return cursor.Blink()
+}
+
+// Paste is a command for pasting from the clipboard into the text input.
+func Paste() tea.Msg {
+	str, err := clipboard.ReadAll()
+	if err != nil {
+		return pasteErrMsg{err}
+	}
+	return pasteMsg(str)
+}
+
+func clamp(v, low, high int) int {
+	if high < low {
+		low, high = high, low
+	}
+	return min(high, max(low, v))
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+// Deprecated.
+
+// Deprecated: use cursor.Mode.
+type CursorMode int
+
+const (
+	// Deprecated: use cursor.CursorBlink.
+	CursorBlink = CursorMode(cursor.CursorBlink)
+	// Deprecated: use cursor.CursorStatic.
+	CursorStatic = CursorMode(cursor.CursorStatic)
+	// Deprecated: use cursor.CursorHide.
+	CursorHide = CursorMode(cursor.CursorHide)
+)
+
+func (c CursorMode) String() string {
+	return cursor.Mode(c).String()
+}
+
+// Deprecated: use cursor.Mode().
+func (m Model) CursorMode() CursorMode {
+	return CursorMode(m.Cursor.Mode())
+}
+
+// Deprecated: use cursor.SetMode().
+func (m *Model) SetCursorMode(mode CursorMode) tea.Cmd {
+	return m.Cursor.SetMode(cursor.Mode(mode))
+}
+
+func (m Model) completionView(offset int) string {
+	var (
+		value = m.value
+		style = m.PlaceholderStyle.Inline(true).Render
+	)
+
+	if m.canAcceptSuggestion() {
+		suggestion := m.matchedSuggestions[m.currentSuggestionIndex]
+		if len(value) < len(suggestion) {
+			return style(string(suggestion[len(value)+offset:]))
+		}
+	}
+	return ""
+}
+
+// AvailableSuggestions returns the list of available suggestions.
+func (m *Model) AvailableSuggestions() []string {
+	suggestions := make([]string, len(m.suggestions))
+	for i, s := range m.suggestions {
+		suggestions[i] = string(s)
+	}
+
+	return suggestions
+}
+
+func (m *Model) MatchedSuggestions() []string {
+	suggestions := make([]string, len(m.matchedSuggestions))
+	for i, s := range m.matchedSuggestions {
+		suggestions[i] = string(s)
+	}
+
+	return suggestions
+}
+
+// CurrentSuggestion returns the currently selected suggestion.
+func (m *Model) CurrentSuggestion() string {
+	if m.currentSuggestionIndex >= len(m.matchedSuggestions) {
+		return ""
+	}
+
+	return string(m.matchedSuggestions[m.currentSuggestionIndex])
+}
+
+// canAcceptSuggestion returns whether there is an acceptable suggestion to
+// autocomplete the current value.
+func (m *Model) canAcceptSuggestion() bool {
+	return len(m.matchedSuggestions) > 0
+}
+
+// updateSuggestions refreshes the list of matching suggestions.
+func (m *Model) updateSuggestions() {
+	if !m.ShowSuggestions {
+		return
+	}
+
+	if len(m.value) <= 0 || len(m.suggestions) <= 0 {
+		m.matchedSuggestions = [][]rune{}
+		return
+	}
+
+	matches := [][]rune{}
+	for _, s := range m.suggestions {
+		suggestion := string(s)
+
+		if strings.HasPrefix(strings.ToLower(suggestion), strings.ToLower(string(m.value))) {
+			matches = append(matches, []rune(suggestion))
+		}
+	}
+	if !reflect.DeepEqual(matches, m.matchedSuggestions) {
+		m.currentSuggestionIndex = 0
+	}
+
+	m.matchedSuggestions = matches
+}
+
+// nextSuggestion selects the next suggestion.
+func (m *Model) nextSuggestion() {
+	m.currentSuggestionIndex = (m.currentSuggestionIndex + 1)
+	if m.currentSuggestionIndex >= len(m.matchedSuggestions) {
+		m.currentSuggestionIndex = 0
+	}
+}
+
+// previousSuggestion selects the previous suggestion.
+func (m *Model) previousSuggestion() {
+	m.currentSuggestionIndex = (m.currentSuggestionIndex - 1)
+	if m.currentSuggestionIndex < 0 {
+		m.currentSuggestionIndex = len(m.matchedSuggestions) - 1
+	}
+}
+
+func (m Model) validate(v []rune) error {
+	if m.Validate != nil {
+		return m.Validate(string(v))
+	}
+	return nil
+}

backend/sshsrv/view.go

@@ -5,10 +5,10 @@ import (
 	"fmt"
 	"io"
 	"strings"
+	"time"
 
 	"github.com/charmbracelet/bubbles/help"
 	"github.com/charmbracelet/bubbles/key"
-	"github.com/charmbracelet/bubbles/textinput"
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/charmbracelet/lipgloss"
 	"github.com/charmbracelet/lipgloss/table"
@@ -21,17 +21,20 @@ import (
 
 	"github.com/veops/oneterm/acl"
 	"github.com/veops/oneterm/api/controller"
+	redis "github.com/veops/oneterm/cache"
 	"github.com/veops/oneterm/conf"
 	mysql "github.com/veops/oneterm/db"
 	"github.com/veops/oneterm/logger"
 	"github.com/veops/oneterm/model"
 	"github.com/veops/oneterm/session"
+	"github.com/veops/oneterm/sshsrv/textinput"
 )
 
 const (
 	prompt     = "> "
 	hotPink    = lipgloss.Color("#FF06B7")
 	darkGray   = lipgloss.Color("#767676")
+	hisCmdsFmt = "hiscmds-%d"
 )
 
 var (
@@ -52,8 +55,6 @@ func (k keymap) ShortHelp() []key.Binding {
 	return []key.Binding{
 		key.NewBinding(key.WithKeys("up"), key.WithHelp("↑", "up")),
 		key.NewBinding(key.WithKeys("down"), key.WithHelp("↓", "down")),
-		// key.NewBinding(key.WithKeys("left"), key.WithHelp("←", "prev")),
-		// key.NewBinding(key.WithKeys("right"), key.WithHelp("→", "next")),
 		key.NewBinding(key.WithKeys("tab"), key.WithHelp("tab", "complete")),
 		key.NewBinding(key.WithKeys("f5"), key.WithHelp("F5", "refresh")),
 		key.NewBinding(key.WithKeys("esc", "ctrl+c"), key.WithHelp("esc/ctrl+c", "quit")),
@@ -66,6 +67,7 @@ func (k keymap) FullHelp() [][]key.Binding {
 type view struct {
 	Ctx         *gin.Context
 	Sess        ssh.Session
+	currentUser *acl.Session
 	textinput   textinput.Model
 	cmds        []string
 	cmdsIdx     int
@@ -78,6 +80,8 @@ type view struct {
 }
 
 func initialView(ctx *gin.Context, sess ssh.Session, r io.ReadCloser, w io.WriteCloser) *view {
+	currentUser, _ := acl.GetSessionFromCtx(ctx)
+
 	ti := textinput.New()
 	ti.Placeholder = "ssh"
 	ti.Focus()
@@ -88,14 +92,13 @@ func initialView(ctx *gin.Context, sess ssh.Session, r io.ReadCloser, w io.Write
 	v := view{
 		Ctx:         ctx,
 		Sess:        sess,
+		currentUser: currentUser,
 		textinput:   ti,
 		cmds:        []string{},
 		help:        help.New(),
 		r:           r,
 		w:           w,
 	}
-	ti.KeyMap.NextSuggestion = key.NewBinding(key.WithKeys(""))
-	ti.KeyMap.PrevSuggestion = key.NewBinding(key.WithKeys(""))
 	v.refresh()
 
 	return &v
@@ -187,12 +190,9 @@ func (m *view) View() string {
 }
 
 func (m *view) possible() string {
-	cur := m.textinput
+	ss := m.textinput.MatchedSuggestions()
-	ss := lo.Filter(cur.AvailableSuggestions(), func(s string, _ int) bool {
-		return cur.Value() != "" && strings.HasPrefix(strings.ToLower(s), strings.ToLower(cur.Value()))
-	})
 	ln := len(ss)
-	if ln == 0 {
+	if ln <= 0 {
 		return ""
 	}
 	ss = append(ss[:min(ln, 15)], lo.Ternary(ln > 15, fmt.Sprintf("%d more...", ln-15), ""))
@@ -213,8 +213,6 @@ func (m *view) possible() string {
 }
 
 func (m *view) refresh() {
-	currentUser, _ := acl.GetSessionFromCtx(m.Ctx)
-
 	auths := make([]*model.Authorization, 0)
 	assets := make([]*model.Asset, 0)
 	accounts := make([]*model.Account, 0)
@@ -222,8 +220,8 @@ func (m *view) refresh() {
 	dbAsset := mysql.DB.Model(assets)
 	dbAccount := mysql.DB.Model(accounts)
 
-	if !acl.IsAdmin(currentUser) {
+	if !acl.IsAdmin(m.currentUser) {
-		rs, err := acl.GetRoleResources(ctx, currentUser.Acl.Rid, conf.GetResourceTypeName(conf.RESOURCE_AUTHORIZATION))
+		rs, err := acl.GetRoleResources(ctx, m.currentUser.Acl.Rid, conf.GetResourceTypeName(conf.RESOURCE_AUTHORIZATION))
 		if err != nil {
 			logger.L().Error("auths", zap.Error(err))
 			return
@@ -275,6 +273,16 @@ func (m *view) refresh() {
 		}
 	}
 
+	eg.Go(func() error {
+		var err error
+		if len(m.cmds) != 0 {
+			return err
+		}
+		m.cmds, err = redis.RC.LRange(m.Ctx, fmt.Sprintf(hisCmdsFmt, m.currentUser.GetUid()), -100, -1).Result()
+		m.cmdsIdx = len(m.cmds) - 1
+		return err
+	})
+
 	m.textinput.SetSuggestions(lo.Keys(m.combines))
 }
 
@@ -283,6 +291,13 @@ func (m *view) magicn() tea.Msg {
 	return nil
 }
 
+func (m *view) RecordHisCmd() {
+	k := fmt.Sprintf(hisCmdsFmt, m.currentUser.GetUid())
+	redis.RC.RPush(m.Ctx, k, m.cmds)
+	redis.RC.LTrim(m.Ctx, k, -100, -1)
+	redis.RC.Expire(m.Ctx, k, time.Hour*24*30)
+}
+
 type connector struct {
 	Ctx    *gin.Context
 	Sess   ssh.Session