diff --git a/.gitignore b/.gitignore
index 66fd13c..2928ec4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -12,4 +12,5 @@
 *.out
 
 # Dependency directories (remove the comment below to include it)
-# vendor/
+vendor/
+.idea/
diff --git a/_example/main.go b/_example/main.go
deleted file mode 100644
index 83b6a6e..0000000
--- a/_example/main.go
+++ /dev/null
@@ -1,19 +0,0 @@
-package main
-
-import (
-  "fmt"
-  "github.com/yylt/gomsf"
-)
-
-func main(){
-
-  cli := gomsf.NewMsf("127.0.0.1:55553",true)
-  token,err:=gomsf.Login(cli,"pass","pass")
-  if err!= nil {
-    fmt.Println(err)
-    return
-  }
-  err = gomsf.Logout(cli,token.Token,token.Token)
-  fmt.Printf("%v\n",err)
-
-}
diff --git a/console.go b/console.go
index 59f9a6a..fe63456 100644
--- a/console.go
+++ b/console.go
@@ -1,5 +1,7 @@
 package gomsf
 
+import "fmt"
+
 const (
 	cslcreate   = "console.create"
 	csllist     = "console.list"
@@ -10,7 +12,7 @@ const (
 	cslsskill   = "console.session_kill"
 	cslssdetach = "console.session_detach"
 )
-//
+
 type ConsoleInfo struct {
 	Id     string `msgpack:"id"`
 	Prompt string `msgpack:"prompt"`
@@ -22,131 +24,109 @@ type ConsoleDataInfo struct {
 	Prompt string `msgpack:"prompt"`
 	Busy   bool   `msgpack:"busy"`
 }
-//
-//func (m *MsfGo) ConsoleCreate() (*ConsoleInfo, error) {
-//	var (
-//		bs    []byte
-//		err   error
-//		token = m.GetToken()
-//	)
-//	if token == "" {
-//		return nil, ErrNotAuth
-//	}
-//	bodys := []string{cslcreate, token}
-//	bs, err = msgpack.Marshal(bodys)
-//	if err != nil {
-//		return nil, err
-//	}
-//	bs, err = m.send(false, bs)
-//	if err != nil {
-//		return nil, err
-//	}
-//	var ct ConsoleInfo
-//	err = msgpack.Unmarshal(bs, &ct)
-//	if err != nil {
-//		return nil, err
-//	}
-//	return &ct, nil
-//}
-//
-//func (m *MsfGo) ConsoleList() ([]*ConsoleInfo, error) {
-//	var (
-//		bs    []byte
-//		err   error
-//		token = m.GetToken()
-//		infos []*ConsoleInfo
-//	)
-//	if token == "" {
-//		return nil, ErrNotAuth
-//	}
-//	bodys := []string{csllist, token}
-//	bs, err = msgpack.Marshal(bodys)
-//	if err != nil {
-//		return nil, err
-//	}
-//	bs, err = m.send(false, bs)
-//	if err != nil {
-//		return nil, err
-//	}
-//	var ct = map[string]*ConsoleInfo{}
-//	err = msgpack.Unmarshal(bs, &ct)
-//	if err != nil {
-//		return nil, err
-//	}
-//	for _, v := range ct {
-//		infos = append(infos, v)
-//	}
-//	return infos, nil
-//}
-//
-//func (m *MsfGo) ConsoleDestroy(id string) error {
-//	var (
-//		bs    []byte
-//		err   error
-//		token = m.GetToken()
-//	)
-//	if token == "" {
-//		return ErrNotAuth
-//	}
-//	bodys := []string{cslrm, token, id}
-//	bs, err = msgpack.Marshal(bodys)
-//	if err != nil {
-//		return err
-//	}
-//	_, err = m.send(true, bs)
-//	return err
-//}
-//
-//func (m *MsfGo) ConsoleWrite(cmd string) error {
-//	var (
-//		bs    []byte
-//		err   error
-//		token = m.GetToken()
-//	)
-//	if token == "" {
-//		return ErrNotAuth
-//	}
-//	cmd = fmt.Sprintf("%s\n", cmd)
-//	length := len(cmd)
-//	bodys := []string{cslwrite, token, cmd}
-//	bs, err = msgpack.Marshal(bodys)
-//	if err != nil {
-//		return err
-//	}
-//	var ct = map[string]int{}
-//	bs, err = m.send(false, bs)
-//	err = msgpack.Unmarshal(bs, &ct)
-//	if err != nil {
-//		return err
-//	}
-//	if v, ok := ct["wrote"]; ok {
-//		if v == length {
-//			return nil
-//		}
-//		return fmt.Errorf("wrong length %d", v)
-//	}
-//	return fmt.Errorf("wrong return-type: %v", ct)
-//}
-//
-//func (m *MsfGo) ConsoleRead(id string) (string, error) {
-//	var (
-//		bs    []byte
-//		err   error
-//		token = m.GetToken()
-//	)
-//	if token == "" {
-//		return "", ErrNotAuth
-//	}
-//	bodys := []string{cslread, token, id}
-//	bs, err = msgpack.Marshal(bodys)
-//	if err != nil {
-//		return "", err
-//	}
-//	var ct ConsoleDataInfo
-//	bs, err = m.send(false, bs)
-//	err = msgpack.Unmarshal(bs, &ct)
-//	if err != nil {
-//		return "", err
-//	}
-//	return strings.TrimSpace(ct.Data), nil
-//}
+
+type ConsoleTabInfo struct {
+	Tabs []string `msgpack:"tabs"`
+}
+
+func ConsoleCreate(cli MsfCli, token string) (*ConsoleInfo, error) {
+	var (
+		retv *ConsoleInfo
+		sts  = []string{cslcreate, token}
+	)
+	err := cli.Send(sts, &retv)
+	if err != nil {
+		return nil, err
+	}
+	return retv, nil
+}
+
+func ConsoleDestory(cli MsfCli, token, consoleId string) (*Generic, error) {
+	var (
+		retv *Generic
+		sts  = []string{cslrm, token, consoleId}
+	)
+	err := cli.Send(sts, &retv)
+	if err != nil {
+		return nil, err
+	}
+	return retv, nil
+}
+
+func ConsoleList(cli MsfCli, token string) ([]*ConsoleInfo, error) {
+	var (
+		retv []*ConsoleInfo
+		sts  = []string{csllist, token}
+	)
+	err := cli.Send(sts, &retv)
+	if err != nil {
+		return nil, err
+	}
+	return retv, nil
+}
+
+func ConsoleWrite(cli MsfCli, token, consoleId string, data []byte) error {
+	var (
+		sts = []string{cslwrite, token, consoleId, string(data)}
+	)
+	var ret struct {
+		Wrote int `msgpack:"wrote"`
+	}
+	var r = &ret
+	err := cli.Send(sts, &r)
+	if err != nil {
+		return err
+	}
+	if ret.Wrote != len(data) {
+		return fmt.Errorf("write %d, but expect %d", ret.Wrote, len(data))
+	}
+	return nil
+}
+
+func ConsoleRead(cli MsfCli, token, consoleId string) (*ConsoleDataInfo, error) {
+	var (
+		retv *ConsoleDataInfo
+		sts  = []string{cslread, token, consoleId}
+	)
+	err := cli.Send(sts, &retv)
+	if err != nil {
+		return nil, err
+	}
+	return retv, nil
+}
+
+func ConsoleSessDetach(cli MsfCli, token, consoleId string) (*Generic, error) {
+	var (
+		retv *Generic
+		sts  = []string{cslssdetach, token, consoleId}
+	)
+	err := cli.Send(sts, &retv)
+	if err != nil {
+		return nil, err
+	}
+	return retv, nil
+}
+
+func ConsoleSessKill(cli MsfCli, token, consoleId string) (*Generic, error) {
+	var (
+		retv *Generic
+		sts  = []string{cslsskill, token, consoleId}
+	)
+	err := cli.Send(sts, &retv)
+	if err != nil {
+		return nil, err
+	}
+	return retv, nil
+}
+
+func ConsoleTabs(cli MsfCli, token, consoleId, input string) (*ConsoleTabInfo, error) {
+	var (
+		retv *ConsoleTabInfo
+		sts  = []string{csltabs, token, consoleId, input}
+	)
+	err := cli.Send(sts, &retv)
+	if err != nil {
+		return nil, err
+	}
+	return retv, nil
+}
diff --git a/core.go b/core.go
index 649741e..2f3b316 100644
--- a/core.go
+++ b/core.go
@@ -1,33 +1,63 @@
 package gomsf
+
 //TODO
 
 const (
 	coreAddModePath = "core.add_module_path"
-	coreModeStat = "core.module_stats"
-	coreReloadMode = "core.reload_modules"
-	coreSave  = "core.save"
-	coreVersion  = "core.version"
-	coreStop  = "core.stop"
+	coreModeStat    = "core.module_stats"
+	coreReloadMode  = "core.reload_modules"
+	coreSave        = "core.save"
+	coreVersion     = "core.version"
+	coreStop        = "core.stop"
 )
 
-
 type ModuleInfo struct {
-	Exploits  string `msgpack:"exploits"`
-	Auxs  string `msgpack:"auxiliary"`
-	Posts  string `msgpack:"post"`
-	Encoders  string `msgpack:"encoders"`
-	Nops  string `msgpack:"nops"`
-	Payloads  string `msgpack:"payloads"`
+	Exploits string `msgpack:"exploits"`
+	Auxs     string `msgpack:"auxiliary"`
+	Posts    string `msgpack:"post"`
+	Encoders string `msgpack:"encoders"`
+	Nops     string `msgpack:"nops"`
+	Payloads string `msgpack:"payloads"`
+}
+
+type VersionInfo struct {
+	Version string `msgpack:"version"`
+	Ruby    string `msgpack:"ruby"`
+	Api     string `msgpack:"api"`
 }
 
 func AddModulePath(cli MsfCli, user, pass string) (*ModuleInfo, error) {
 	var (
 		retv *ModuleInfo
-		sts = []string{coreAddModePath, user, pass}
+		sts  = []string{coreAddModePath, user, pass}
 	)
-	err := cli.Send(sts,&retv)
+	err := cli.Send(sts, &retv)
 	if err != nil {
 		return nil, err
 	}
-	return retv,nil
-}
\ No newline at end of file
+	return retv, nil
+}
+
+func Version(cli MsfCli, token string) (*VersionInfo, error) {
+	var (
+		retv *VersionInfo
+		sts  = []string{coreVersion, token}
+	)
+	err := cli.Send(sts, &retv)
+	if err != nil {
+		return nil, err
+	}
+	return retv, nil
+}
+
+func Stop(cli MsfCli, token string) (*Generic, error) {
+	var (
+		retv *Generic
+		sts  = []string{coreStop, token}
+	)
+	err := cli.Send(sts, &retv)
+	if err != nil {
+		return nil, err
+	}
+	return retv, nil
+}
diff --git a/core_thread.go b/core_thread.go
index f41b53a..afee2e1 100644
--- a/core_thread.go
+++ b/core_thread.go
@@ -7,66 +7,74 @@ import (
 
 const (
 	coreThreadList = "core.thread_list"
-	coreThreadKill   = "core.thread_kill"
+	coreThreadKill = "core.thread_kill"
 
-
-	coreSetg  = "core.setg"
-	coreUnSetg   = "core.unsetg"
+	coreSetg   = "core.setg"
+	coreUnSetg = "core.unsetg"
 )
 
 type ThreadInfo struct {
-	Status string `msgpack:"status"`
-	Critical bool `msgpack:"critical"`
-	Name string `msgpack:"name"`
-	Started time.Time `msgpack:"started"`
+	Status   string    `msgpack:"status"`
+	Critical bool      `msgpack:"critical"`
+	Name     string    `msgpack:"name"`
+	Started  time.Time `msgpack:"started"`
 }
 
-//TODO Should erase had seted?
-func SetOption(cli MsfCli, token string, kvs ...string) (error) {
+//TODO Should remove options when failed?
+func SetOption(cli MsfCli, token string, kvs ...string) error {
 	var (
 		err error
 		sts = []string{coreSetg, token, "", ""}
 	)
-	if len(kvs)==0 || len(kvs) % 2 !=0 {
+	if len(kvs) == 0 || len(kvs)%2 != 0 {
 		return fmt.Errorf("kv list is not odd or nil!")
 	}
-	for i:=0;i<len(kvs);i+=2{
-		sts[2]=kvs[i]
-		sts[3]=kvs[i+1]
-		err = cli.Send(sts,nil)
-		if err!= nil {
+	for i := 0; i < len(kvs); i += 2 {
+		sts[2] = kvs[i]
+		sts[3] = kvs[i+1]
+		err = cli.Send(sts, nil)
+		if err != nil {
 			return err
 		}
 	}
 	return nil
 }
 
-func UnSetOption(cli MsfCli, token string, keys ...string) (error) {
+func UnSetOption(cli MsfCli, token string, keys ...string) error {
 	var (
 		err error
 		sts = []string{coreUnSetg, token, ""}
 	)
-	if len(keys)==0{
+	if len(keys) == 0 {
 		return fmt.Errorf("key list is nil!")
 	}
-	for i:=0;i<len(keys);i++{
-		sts[2]=keys[i]
-		err = cli.Send(sts,nil)
-		if err!= nil {
+	for i := 0; i < len(keys); i++ {
+		sts[2] = keys[i]
+		err = cli.Send(sts, nil)
+		if err != nil {
 			return err
 		}
 	}
 	return nil
 }
 
-
 func ThreadList(cli MsfCli, token string) ([]*ThreadInfo, error) {
 	var (
-		err error
-		sts = []string{coreThreadList, token}
+		err   error
+		sts   = []string{coreThreadList, token}
+		infos []*ThreadInfo
 	)
 
+	err = cli.Send(sts, &infos)
+	return infos, err
+}
+
+func ThreadKill(cli MsfCli, token, id string) (*Generic, error) {
+	var (
+		sts = []string{coreThreadKill, token, id}
+		gen *Generic
+	)
 
-	err = cli.Send(sts,nil)
-	return nil
+	err := cli.Send(sts, &gen)
+	return gen, err
 }
diff --git a/example/auth.go b/example/auth.go
new file mode 100644
index 0000000..55b6734
--- /dev/null
+++ b/example/auth.go
@@ -0,0 +1,31 @@
+package main
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/yylt/gomsf"
+
+	"time"
+)
+
+func main() {
+
+	cli := gomsf.NewMsf("127.0.0.1:55553", true,
+		gomsf.WithDebug(true),
+		gomsf.WithSkipVerify(true),
+		gomsf.WithTimeOut(time.Second*5))
+
+	token, err := gomsf.Login(cli, "pass", "pass")
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+
+	exploits, err := gomsf.ModExploits(cli, token)
+	log.Printf("exploit %v, err %v", exploits, err)
+
+	err = gomsf.Logout(cli, token, token)
+	fmt.Printf("%v\n", err)
+
+}
diff --git a/go.mod b/go.mod
index e76f8b8..33e49b8 100644
--- a/go.mod
+++ b/go.mod
@@ -3,7 +3,6 @@ module github.com/yylt/gomsf
 go 1.13
 
 require (
-	github.com/clipperhouse/slice v0.0.0-20200107170738-a74fc3888fd9 // indirect
 	github.com/imroc/req v0.3.0
 	github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect
 	github.com/vmihailenco/msgpack/v5 v5.0.0-beta.1
diff --git a/go.sum b/go.sum
index 0981710..8d1b909 100644
--- a/go.sum
+++ b/go.sum
@@ -1,7 +1,3 @@
-github.com/clipperhouse/slice v0.0.0-20200107170738-a74fc3888fd9 h1:98FuFIacIB6rKfxodqagVhwLsrKEjve2T8l6O0oYjsM=
-github.com/clipperhouse/slice v0.0.0-20200107170738-a74fc3888fd9/go.mod h1:SYNbTtqlzmDAa8k/IZo8rBZrLHdB19cwOtJ6ySOwQZ4=
-github.com/clipperhouse/typewriter v0.0.0-20200107164453-d21420026310 h1:IC0Ywh01N6qQ+jT87vS4zhVsrE1q3829nVMQwz7PF3o=
-github.com/clipperhouse/typewriter v0.0.0-20200107164453-d21420026310/go.mod h1:GbdR1VEFLckXDXyXO3pn/lERXrQLVOI9j1Fly05g32I=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -28,23 +24,14 @@ github.com/vmihailenco/msgpack/v5 v5.0.0-beta.1/go.mod h1:xlngVLeyQ/Qi05oQxhQ+oT
 github.com/vmihailenco/tagparser v0.1.1 h1:quXMXlA39OCbd2wAdTsGDlK9RkOk6Wuw+x37wVyIuWY=
 github.com/vmihailenco/tagparser v0.1.1/go.mod h1:OeAg3pn3UbLjkWt+rN9oFYB6u/cQgqMEUPoW2WPyhdI=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190603091049-60506f45cf65 h1:+rhAzEzT3f4JtomfC371qB+0Ola2caSKcY69NUBZrRQ=
 golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200301022130-244492dfa37a h1:GuSPYbZzB5/dcLNCwLQLsg3obCJtX9IJhpXkvY7kzk0=
 golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20200107050322-53017a39ae36 h1:+eY+U4SdIdum+uGmzG+Y7oP2YWTOsFRElVIBD6K3Wgo=
-golang.org/x/tools v0.0.0-20200107050322-53017a39ae36/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
 google.golang.org/appengine v1.6.6 h1:lMO5rYAqUxkmaj76jAkRUvt5JZgFymx/+Q5Mzfivuhc=
 google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
diff --git a/gomsf.go b/gomsf.go
index adbfff6..b816200 100644
--- a/gomsf.go
+++ b/gomsf.go
@@ -10,31 +10,30 @@ import (
 	msgpack "github.com/vmihailenco/msgpack/v5"
 )
 
-
 type Generic struct {
 	Restult string `msgpack:"result"`
 }
 
 type MsfGo struct {
-	baseurl  string
+	baseurl string
 
 	headers http.Header
 	httpcli *req.Req
 }
 
 type MsfCli interface {
-	Send([]string, interface{}) (error)
+	Send([]string, interface{}) error
 }
 
 type Opt func(msfGo *MsfGo)
 
-func WithDebug(debug bool) Opt{
+func WithDebug(debug bool) Opt {
 	return func(msfGo *MsfGo) {
-		if debug == true{
-			req.Debug=true
+		if debug == true {
+			req.Debug = true
 			return
 		}
-		req.Debug=false
+		req.Debug = false
 	}
 }
 
@@ -50,7 +49,7 @@ func WithTimeOut(tm time.Duration) Opt {
 	}
 }
 
-func NewMsf(addr string, usessl bool,opts ...Opt) *MsfGo {
+func NewMsf(addr string, usessl bool, opts ...Opt) *MsfGo {
 	var msfdUrl string
 	rq := req.New()
 	if usessl {
@@ -60,21 +59,20 @@ func NewMsf(addr string, usessl bool,opts ...Opt) *MsfGo {
 	}
 
 	msf := &MsfGo{
-		baseurl:    msfdUrl,
+		baseurl: msfdUrl,
 		httpcli: rq,
 		headers: http.Header{
-			"Content-Type":   []string{"binary/message-pack"},
+			"Content-Type": []string{"binary/message-pack"},
 		},
 	}
 
-	for _,v :=range opts {
+	for _, v := range opts {
 		v(msf)
 	}
 	return msf
 }
 
-
-func (m *MsfGo) Send(sts []string, save interface{})  (error) {
+func (m *MsfGo) Send(sts []string, save interface{}) error {
 	var (
 		buf = bufpool.Get().(*bytes.Buffer)
 		err error
@@ -83,7 +81,7 @@ func (m *MsfGo) Send(sts []string, save interface{})  (error) {
 	defer bufpool.Put(buf)
 
 	err = msgpack.NewEncoder(buf).Encode(sts)
-	if err!= nil {
+	if err != nil {
 		return err
 	}
 
diff --git a/gomsf_test.go b/gomsf_test.go
new file mode 100644
index 0000000..e8f3989
--- /dev/null
+++ b/gomsf_test.go
@@ -0,0 +1,28 @@
+package gomsf
+
+import (
+	"time"
+)
+
+var (
+	Cli   *MsfGo
+	Token string
+
+	defaultAddr   = "127.0.0.1:55553"
+	defaultuser   = "user"
+	defaultpasswd = "passwd"
+)
+
+func init() {
+	Cli = NewMsf(defaultAddr, true,
+		WithDebug(true),
+		WithSkipVerify(true),
+		WithTimeOut(time.Second*5))
+
+	token, err := Login(Cli, defaultuser, defaultpasswd)
+	if err != nil {
+		panic(err)
+		return
+	}
+	Token = token
+}
diff --git a/job.go b/job.go
new file mode 100644
index 0000000..6f983df
--- /dev/null
+++ b/job.go
@@ -0,0 +1,68 @@
+package gomsf
+
+import "strconv"
+
+const (
+	jobinfo = "job.info"
+	joblist = "job.list"
+	jobstop = "job.stop"
+)
+
+type Job struct {
+	Id   int
+	Name string
+}
+
+type JobDetail struct {
+	Id        int                    `msgpack:"jid"`
+	Name      string                 `msgpack:"name"`
+	StartT    int64                  `msgpack:"start_time"`
+	Uri       string                 `msgpack:"uripath"`
+	DataStore map[string]interface{} `msgpack:"datastore"`
+}
+
+func JobList(cli MsfCli, token string) ([]*Job, error) {
+	var (
+		sts   = []string{joblist, token}
+		infos []*Job
+	)
+	var retvar map[string]string
+	err := cli.Send(sts, &retvar)
+	if err != nil {
+		return nil, err
+	}
+	for k, v := range retvar {
+		kint, err := strconv.Atoi(k)
+		if err != nil {
+			continue
+		}
+		infos = append(infos, &Job{
+			Id:   kint,
+			Name: v,
+		})
+	}
+	return infos, nil
+}
+
+func JobStop(cli MsfCli, token, jobid string) (*Generic, error) {
+	var (
+		retv *Generic
+		sts  = []string{jobstop, token, jobid}
+	)
+	err := cli.Send(sts, &retv)
+	if err != nil {
+		return nil, err
+	}
+	return retv, nil
+}
+func JobInfo(cli MsfCli, token, jobid string) (*JobDetail, error) {
+	var (
+		retv *JobDetail
+		sts  = []string{jobinfo, token, jobid}
+	)
+	err := cli.Send(sts, &retv)
+	if err != nil {
+		return nil, err
+	}
+	return retv, nil
+}
diff --git a/job_test.go b/job_test.go
new file mode 100644
index 0000000..f3fb832
--- /dev/null
+++ b/job_test.go
@@ -0,0 +1,17 @@
+package gomsf
+
+import (
+	"testing"
+)
+
+func TestJobList(t *testing.T) {
+
+}
+
+func TestJobInfo(t *testing.T) {
+
+}
+
+func TestJobStop(t *testing.T) {
+
+}
diff --git a/login.go b/login.go
index 4d5217e..630b8ae 100644
--- a/login.go
+++ b/login.go
@@ -1,72 +1,78 @@
 package gomsf
 
 const (
-	authlogin = "auth.login"
-	authlogout = "auth.logout"
+	authlogin     = "auth.login"
+	authlogout    = "auth.logout"
 	authTokenlist = "auth.token_list"
 	authTokenadd  = "auth.token_add"
 	authTokengen  = "auth.token_generate"
 	authTokenrm   = "auth.token_remove"
 )
 
-type AuthLogin struct {
+type authLogin struct {
 	Result string `msgpack:"result"`
 	Token  string `msgpack:"token"`
 }
 
-type AuthList struct {
-	Tokens []string `msgpack:"tokens"`
-}
-
 func Login(cli MsfCli, user, pass string) (string, error) {
 	var (
-		retv *AuthLogin
-		sts = []string{authlogin, user, pass}
+		retv *authLogin
+		sts  = []string{authlogin, user, pass}
 	)
-	err := cli.Send(sts,&retv)
+	err := cli.Send(sts, &retv)
 	if err != nil {
 		return "", err
 	}
-	return retv.Token,nil
+	return retv.Token, nil
 }
 
-func Logout(cli MsfCli, token, oldtoken string ) error {
+func Logout(cli MsfCli, token, oldtoken string) error {
 	var (
-		retv *AuthLogin
-		sts = []string{authlogout, token, oldtoken}
+		retv *Generic
+		sts  = []string{authlogout, token, oldtoken}
 	)
-	return cli.Send(sts,&retv)
+	return cli.Send(sts, &retv)
 }
 
-
-func (m *MsfGo) TokenAdd(cli MsfCli, token, newtoken string) error {
+func TokenAdd(cli MsfCli, token, newtoken string) error {
 	var (
-		retv *AuthLogin
-		sts = []string{authTokenadd, token, newtoken}
+		retv *Generic
+		sts  = []string{authTokenadd, token, newtoken}
 	)
-	return cli.Send(sts,&retv)
+	return cli.Send(sts, &retv)
 }
 
-func (m *MsfGo) TokenGen(cli MsfCli, token string) error {
+func TokenGen(cli MsfCli, token string) (string, error) {
 	var (
-		retv *AuthLogin
-		sts = []string{authTokengen, token}
+		retv *authLogin
+		sts  = []string{authTokengen, token}
 	)
-	return cli.Send(sts,&retv)
+	err := cli.Send(sts, &retv)
+	if err != nil {
+		return "", err
+	}
+	return retv.Token, nil
 }
 
-func (m *MsfGo) TokenRm(cli MsfCli, token, rmtoken string) error {
+func TokenRm(cli MsfCli, token, rmtoken string) error {
 	var (
-		retv *AuthLogin
-		sts = []string{authTokenrm, token, rmtoken}
+		retv *Generic
+		sts  = []string{authTokenrm, token, rmtoken}
 	)
-	return cli.Send(sts,&retv)
+	return cli.Send(sts, &retv)
 }
 
-func (m *MsfGo) Tokenlist(cli MsfCli, token string) (*AuthList, error ){
+func Tokenlist(cli MsfCli, token string) ([]string, error) {
 	var (
-		retv *AuthList
+		retv struct {
+			Tokens []string `msgpack:"tokens"`
+		}
 		sts = []string{authTokenlist, token}
 	)
-	return retv, cli.Send(sts,&retv)
+	var r = &retv
+	err := cli.Send(sts, &r)
+	if err != nil {
+		return nil, err
+	}
+	return retv.Tokens, nil
 }
diff --git a/login_test.go b/login_test.go
new file mode 100644
index 0000000..d54875e
--- /dev/null
+++ b/login_test.go
@@ -0,0 +1,49 @@
+package gomsf
+
+import "testing"
+
+func TestLogout(t *testing.T) {
+	newt := "foo"
+	err := TokenAdd(Cli, Token, newt)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	err = Logout(Cli, Token, newt)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	t.Logf("success logout by token: %s", newt)
+}
+
+func TestTokenlist(t *testing.T) {
+	newt, err := TokenGen(Cli, Token)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	err = TokenAdd(Cli, Token, newt)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	tokens, err := Tokenlist(Cli, Token)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	defer func() {
+		for i := range tokens {
+			if tokens[i] != Token {
+				TokenRm(Cli, Token, tokens[i])
+			}
+		}
+	}()
+
+	for i := range tokens {
+		t.Logf("token-%d: %s", i, tokens[i])
+	}
+}
diff --git a/module.go b/module.go
new file mode 100644
index 0000000..428c99f
--- /dev/null
+++ b/module.go
@@ -0,0 +1,216 @@
+package gomsf
+
+import (
+	"fmt"
+	msgpack "github.com/vmihailenco/msgpack/v5"
+)
+
+type ModType string
+
+const (
+	ExploitType ModType = "exploit"
+	AuxType     ModType = "auxiliary"
+	PostType    ModType = "post"
+	PayloadType ModType = "payload"
+	EncoderType ModType = "encoder"
+	NopType     ModType = "nop"
+)
+
+const (
+	modexploit   = "module.exploits"
+	modauxiliary = "module.auxiliary"
+	modpost      = "module.post"
+	modpayloads  = "module.payloads"
+	modencoders  = "module.encoders"
+	modnops      = "module.nops"
+
+	modinfo                = "module.info"
+	modoptions             = "module.options"
+	modcompatible_payloads = "module.compatible_payloads"
+	modcompatible_sessions = "module.compatible_sessions"
+
+	modexecute = "module.execute"
+)
+
+type Modules struct {
+	Module []string `msgpack:"modules"`
+}
+
+type ModuleDetail struct {
+	Type     string   `msgpack:"type"`
+	Desc     string   `msgpack:"description"`
+	Fullname string   `msgpack:"fullname,omitempty"`
+	Filepath string   `msgpack:"filepath"`
+	Version  string   `msgpack:"version,omitempty"`
+	Rank     string   `msgpack:"rank"`
+	Authors  []string `msgpack:"authors"`
+}
+
+type ModOption struct {
+	Name     string      `msgpack:"-"`
+	Type     string      `msgpack:"type"`
+	Required bool        `msgpack:"required"`
+	Advanced bool        `msgpack:"advanced"`
+	Evasion  bool        `msgpack:"evasion"`
+	Desc     string      `msgpack:"desc"`
+	Default  interface{} `msgpack:"default"`
+	Enums    []string    `msgpack:"enums,omitempty"`
+}
+
+func ModExploits(cli MsfCli, token string) (*Modules, error) {
+	var (
+		retv *Modules
+		sts  = []string{modexploit, token}
+	)
+	err := cli.Send(sts, &retv)
+	if err != nil {
+		return nil, err
+	}
+	return retv, nil
+}
+
+func ModAuxiliarys(cli MsfCli, token string) (*Modules, error) {
+	var (
+		retv *Modules
+		sts  = []string{modauxiliary, token}
+	)
+	err := cli.Send(sts, &retv)
+	if err != nil {
+		return nil, err
+	}
+	return retv, nil
+}
+
+func ModPosts(cli MsfCli, token string) (*Modules, error) {
+	var (
+		retv *Modules
+		sts  = []string{modpost, token}
+	)
+	err := cli.Send(sts, &retv)
+	if err != nil {
+		return nil, err
+	}
+	return retv, nil
+}
+
+func ModPayloads(cli MsfCli, token string) (*Modules, error) {
+	var (
+		retv *Modules
+		sts  = []string{modpayloads, token}
+	)
+	err := cli.Send(sts, &retv)
+	if err != nil {
+		return nil, err
+	}
+	return retv, nil
+}
+
+func ModEncoders(cli MsfCli, token string) (*Modules, error) {
+	var (
+		retv *Modules
+		sts  = []string{modencoders, token}
+	)
+	err := cli.Send(sts, &retv)
+	if err != nil {
+		return nil, err
+	}
+	return retv, nil
+}
+
+func ModNops(cli MsfCli, token string) (*Modules, error) {
+	var (
+		retv *Modules
+		sts  = []string{modnops, token}
+	)
+	err := cli.Send(sts, &retv)
+	if err != nil {
+		return nil, err
+	}
+	return retv, nil
+}
+
+func InfoOfMod(cli MsfCli, token string, modtype ModType, modname string) (*ModuleDetail, error) {
+	var (
+		retv *ModuleDetail
+		sts  = []string{modinfo, token, string(modtype), modname}
+	)
+	err := cli.Send(sts, &retv)
+	if err != nil {
+		return nil, err
+	}
+	return retv, nil
+}
+
+func OptionsOfMod(cli MsfCli, token string, modtype ModType, modname string) ([]*ModOption, error) {
+	var (
+		retv    map[string]*ModOption
+		sts     = []string{modoptions, token, string(modtype), modname}
+		options []*ModOption
+	)
+	err := cli.Send(sts, &retv)
+	if err != nil {
+		return nil, err
+	}
+	for mod, value := range retv {
+		value.Name = mod
+		options = append(options, value)
+	}
+	return options, nil
+}
+
+func CompPayloadsMod(cli MsfCli, token string, exploitModName string) ([]string, error) {
+	var (
+		retv struct {
+			Payloads []string `msgpack:"payloads"`
+		}
+		sts = []string{modcompatible_payloads, token, exploitModName}
+	)
+	var r = &retv
+	err := cli.Send(sts, &r)
+	if err != nil {
+		return nil, err
+	}
+	return retv.Payloads, nil
+}
+
+func CompSessionsMod(cli MsfCli, token string, exploitModName string) ([]string, error) {
+	var (
+		retv struct {
+			Sessions []string `msgpack:"sessions"`
+		}
+		sts = []string{modcompatible_sessions, token, exploitModName}
+	)
+	var r = &retv
+	err := cli.Send(sts, &r)
+	if err != nil {
+		return nil, err
+	}
+	return retv.Sessions, nil
+}
+
+func Execute(cli MsfCli, token string, modType ModType, modName string, options map[string]interface{}) (int, error) {
+	var (
+		retv struct {
+			Id int `msgpack:"job_id"`
+		}
+		sts = []string{modexecute, token, string(modType), modName}
+	)
+	switch modType {
+	case ExploitType:
+	case PostType:
+	case AuxType:
+	default:
+		return 0, fmt.Errorf("Not support module type %s on execute operator", string(modType))
+	}
+	opts, err := msgpack.Marshal(options)
+	if err != nil {
+		return 0, err
+	}
+	sts = append(sts, string(opts))
+	var r = &retv
+	err = cli.Send(sts, &r)
+	if err != nil {
+		return 0, err
+	}
+	return retv.Id, nil
+}
diff --git a/module_test.go b/module_test.go
new file mode 100644
index 0000000..5ccf17b
--- /dev/null
+++ b/module_test.go
@@ -0,0 +1,86 @@
+package gomsf
+
+import "testing"
+
+func TestModAuxiliarys(t *testing.T) {
+	_, err := ModAuxiliarys(Cli, Token)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	//t.Logf("auxs: %s",rets)
+}
+
+func TestModExploits(t *testing.T) {
+	_, err := ModExploits(Cli, Token)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	//t.Logf("exploits: %s",rets)
+}
+
+func TestModPayloads(t *testing.T) {
+	_, err := ModPayloads(Cli, Token)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	//t.Logf("payloads: %s",rets)
+}
+
+func TestModNops(t *testing.T) {
+	rets, err := ModNops(Cli, Token)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	t.Logf("nops: %s", rets)
+}
+func TestModPosts(t *testing.T) {
+	_, err := ModPosts(Cli, Token)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	//t.Logf("posts: %s",rets)
+}
+
+func TestModEncoderss(t *testing.T) {
+	rets, err := ModEncoders(Cli, Token)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	t.Logf("encoders: %s", rets)
+}
+
+func TestModOptions(t *testing.T) {
+	rets, err := ModExploits(Cli, Token)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	options, err := OptionsOfMod(Cli, Token, ExploitType, rets.Module[0])
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	for i := range options {
+		t.Logf("module:%s, options %v", rets.Module[0], options[i])
+	}
+}
+
+func TestModinfo(t *testing.T) {
+	rets, err := ModExploits(Cli, Token)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	info, err := InfoOfMod(Cli, Token, ExploitType, rets.Module[0])
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	t.Logf("module:%s, info %v", rets.Module[0], info)
+}
diff --git a/plugin.go b/plugin.go
new file mode 100644
index 0000000..5d99990
--- /dev/null
+++ b/plugin.go
@@ -0,0 +1,3 @@
+package gomsf
+
+//TODO