opt cli&ctx

base/cli/cli.go

@@ -1,104 +1,16 @@
 package cli
 
 import (
-	"os"
-	"os/user"
-	"path"
-	"runtime"
-	"strings"
-
 	ice "shylinux.com/x/icebergs"
-	kit "shylinux.com/x/toolkits"
 )
 
-func _cli_init(m *ice.Message) {
-	// 版本信息
-	kit.Fetch(kit.UnMarshal(kit.Format(ice.Info.Make)), func(key string, value interface{}) {
-		m.Conf(RUNTIME, kit.Keys(MAKE, strings.ToLower(key)), value)
-	})
-
-	// 环境变量
-	for _, k := range []string{CTX_SHY, CTX_DEV, CTX_OPS, CTX_PID, CTX_USER, CTX_SHARE, CTX_RIVER} {
-		m.Conf(RUNTIME, kit.Keys(CONF, k), os.Getenv(k))
-	}
-
-	// 主机信息
-	m.Conf(RUNTIME, kit.Keys(HOST, "GOARCH"), runtime.GOARCH)
-	m.Conf(RUNTIME, kit.Keys(HOST, "GOOS"), runtime.GOOS)
-	m.Conf(RUNTIME, kit.Keys(HOST, "pid"), os.Getpid())
-
-	// 启动信息
-	if name, e := os.Hostname(); e == nil {
-		m.Conf(RUNTIME, kit.Keys(BOOT, HOSTNAME), kit.Select(name, os.Getenv("HOSTNAME")))
-	}
-	if name, e := os.Getwd(); e == nil {
-		name = path.Base(kit.Select(name, os.Getenv("PWD")))
-		ls := strings.Split(name, "/")
-		name = ls[len(ls)-1]
-		ls = strings.Split(name, "\\")
-		name = ls[len(ls)-1]
-		m.Conf(RUNTIME, kit.Keys(BOOT, PATHNAME), name)
-	}
-	if m.Conf(RUNTIME, kit.Keys(BOOT, USERNAME), kit.Select(os.Getenv(USER), os.Getenv(CTX_USER))) == "" {
-		if user, e := user.Current(); e == nil && user.Name != "" {
-			m.Conf(RUNTIME, kit.Keys(BOOT, USERNAME), kit.Select(user.Name, os.Getenv(CTX_USER)))
-		}
-	}
-	ice.Info.HostName = m.Conf(RUNTIME, kit.Keys(BOOT, HOSTNAME))
-	ice.Info.PathName = m.Conf(RUNTIME, kit.Keys(BOOT, PATHNAME))
-	ice.Info.UserName = m.Conf(RUNTIME, kit.Keys(BOOT, USERNAME))
-
-	// 启动次数
-	count := kit.Int(m.Conf(RUNTIME, kit.Keys(BOOT, kit.MDB_COUNT))) + 1
-	m.Conf(RUNTIME, kit.Keys(BOOT, kit.MDB_COUNT), count)
-
-	// 节点信息
-	m.Conf(RUNTIME, kit.Keys(NODE, kit.MDB_TIME), m.Time())
-	NodeInfo(m, "worker", m.Conf(RUNTIME, kit.Keys(BOOT, PATHNAME)))
-
-	runtime.GOMAXPROCS(kit.Int(kit.Select("1", m.Conf(RUNTIME, kit.Keys(HOST, "GOMAXPROCS")))))
-}
-func NodeInfo(m *ice.Message, kind, name string) {
-	name = strings.ReplaceAll(name, ".", "_")
-	m.Conf(RUNTIME, kit.Keys(NODE, kit.MDB_TYPE), kind)
-	m.Conf(RUNTIME, kit.Keys(NODE, kit.MDB_NAME), name)
-	ice.Info.NodeName = name
-	ice.Info.NodeType = kind
-}
-
 const (
-	MAKE = "make"
+	USER = "USER"
-	TEST = "test"
+	HOME = "HOME"
-	CONF = "conf"
+	PATH = "PATH"
-	HOST = "host"
-	BOOT = "boot"
-	NODE = "node"
-)
-const (
-	HOSTNAME = "hostname"
-	PATHNAME = "pathname"
-	USERNAME = "username"
-)
-const (
-	CTX_SHY   = "ctx_shy"
-	CTX_DEV   = "ctx_dev"
-	CTX_OPS   = "ctx_ops"
-	CTX_PID   = "ctx_pid"
-	CTX_LOG   = "ctx_log"
-	CTX_USER  = "ctx_user"
-	CTX_SHARE = "ctx_share"
-	CTX_RIVER = "ctx_river"
 )
 const CLI = "cli"
 
-var Index = &ice.Context{Name: CLI, Help: "命令模块", Commands: map[string]*ice.Command{
+var Index = &ice.Context{Name: CLI, Help: "命令模块"}
-	ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-		m.Load()
-		_cli_init(m)
-	}},
-	ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-		m.Save()
-	}},
-}}
 
 func init() { ice.Index.Register(Index, nil, RUNTIME, SYSTEM, DAEMON, QRCODE) }

base/cli/cli.shy

@@ -1,7 +1,7 @@
 chapter "cli"
 
-field "扫码" qrcode
-field "守护" daemon
-field "命令" system
 field "环境" runtime
+field "命令" system
+field "守护" daemon
+field "扫码" qrcode
 

base/cli/daemon.go

@@ -11,45 +11,34 @@ import (
 	kit "shylinux.com/x/toolkits"
 )
 
-func _daemon_show(m *ice.Message, cmd *exec.Cmd, out, err string) {
+func _daemon_exec(m *ice.Message, cmd *exec.Cmd) {
-	if w, ok := m.Optionv(CMD_OUTPUT).(io.Writer); ok {
+	if w := _system_out(m, CMD_OUTPUT); w != nil {
 		cmd.Stdout = w
 		cmd.Stderr = w
-	} else if f, p, e := kit.Create(out); m.Assert(e) {
-		m.Log_EXPORT(kit.MDB_META, DAEMON, CMD_OUTPUT, p)
-		m.Optionv(CMD_OUTPUT, f)
-		cmd.Stdout = f
-		cmd.Stderr = f
 	}
-	if w, ok := m.Optionv(CMD_ERRPUT).(io.Writer); ok {
+	if w := _system_out(m, CMD_ERRPUT); w != nil {
 		cmd.Stderr = w
-	} else if f, p, e := kit.Create(err); m.Assert(e) {
-		m.Log_EXPORT(kit.MDB_META, DAEMON, CMD_ERRPUT, p)
-		m.Optionv(CMD_ERRPUT, f)
-		cmd.Stderr = f
 	}
 
 	// 启动进程
-	if e := cmd.Start(); m.Warn(e != nil, cmd.Args, " ", e) {
+	if e := cmd.Start(); m.Warn(e != nil, cmd.Args, ice.SP, e) {
-		return
+		return // 启动失败
 	}
 	m.Echo("%d", cmd.Process.Pid)
 
 	m.Go(func() {
 		h := m.Cmdx(mdb.INSERT, DAEMON, "", mdb.HASH,
-			kit.MDB_STATUS, START, PID, cmd.Process.Pid,
+			kit.MDB_STATUS, START, ice.CMD, kit.Join(cmd.Args, ice.SP),
-			CMD, strings.Join(cmd.Args, " "),
+			PID, cmd.Process.Pid, DIR, cmd.Dir, ENV, kit.Select("", cmd.Env),
-			DIR, cmd.Dir, ENV, kit.Select("", cmd.Env),
+			m.OptionSimple(CMD_OUTPUT, CMD_ERRPUT, mdb.CACHE_CLEAR_ON_EXIT),
-			mdb.CACHE_CLEAR_ON_EXIT, m.Option(mdb.CACHE_CLEAR_ON_EXIT),
-			CMD_OUTPUT, out, CMD_ERRPUT, err,
 		)
 
-		if e := cmd.Wait(); m.Warn(e != nil, cmd.Args, " ", e) {
+		if e := cmd.Wait(); m.Warn(e != nil, cmd.Args, ice.SP, e) {
 			if m.Conf(DAEMON, kit.Keys(kit.MDB_HASH, h, kit.Keym(kit.MDB_STATUS))) == START {
 				m.Cmd(mdb.MODIFY, DAEMON, "", mdb.HASH, kit.MDB_HASH, h, kit.MDB_STATUS, ERROR, ERROR, e)
 			}
 		} else {
-			m.Cost("args", cmd.Args, "code", cmd.ProcessState.ExitCode())
+			m.Cost(kit.MDB_CODE, cmd.ProcessState.ExitCode(), kit.MDB_ARGS, cmd.Args)
 			m.Cmd(mdb.MODIFY, DAEMON, "", mdb.HASH, kit.MDB_HASH, h, kit.MDB_STATUS, STOP)
 		}
 
@@ -62,6 +51,9 @@ func _daemon_show(m *ice.Message, cmd *exec.Cmd, out, err string) {
 			cb()
 		}
 
+		if w, ok := m.Optionv(CMD_INPUT).(io.Closer); ok {
+			w.Close()
+		}
 		if w, ok := m.Optionv(CMD_OUTPUT).(io.Closer); ok {
 			w.Close()
 		}
@@ -73,13 +65,13 @@ func _daemon_show(m *ice.Message, cmd *exec.Cmd, out, err string) {
 
 func Inputs(m *ice.Message, field string) bool {
 	switch strings.TrimPrefix(field, "extra.") {
-	case POD:
+	case ice.POD:
 		m.Cmdy("route")
-	case CTX:
+	case ice.CTX:
 		m.Cmdy(ctx.CONTEXT)
-	case CMD:
+	case ice.CMD:
-		m.Cmdy(ctx.CONTEXT, kit.Select(m.Option(CTX), m.Option(kit.Keys("extra", CTX))), ctx.COMMAND)
+		m.Cmdy(ctx.CONTEXT, kit.Select(m.Option(ice.CTX), m.Option(kit.Keys(kit.MDB_EXTRA, ice.CTX))), ctx.COMMAND)
-	case ARG:
+	case ice.ARG:
 
 	default:
 		return false
@@ -90,18 +82,9 @@ func Inputs(m *ice.Message, field string) bool {
 const (
 	DIR = "dir"
 	ENV = "env"
+	API = "api"
 	PID = "pid"
 	PWD = "pwd"
-
-	POD = "pod"
-	CTX = "ctx"
-	CMD = "cmd"
-	ARG = "arg"
-
-	RUN = "run"
-	API = "api"
-	RES = "res"
-	ERR = "err"
 )
 const (
 	ERROR = "error"
@@ -127,17 +110,19 @@ const DAEMON = "daemon"
 
 func init() {
 	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
-		DAEMON: {Name: DAEMON, Help: "守护进程", Value: kit.Data(kit.MDB_PATH, ice.USR_LOCAL_DAEMON)},
+		DAEMON: {Name: DAEMON, Help: "守护进程", Value: kit.Data(
+			kit.MDB_PATH, ice.USR_LOCAL_DAEMON, kit.MDB_FIELD, "time,hash,status,pid,cmd,dir,env",
+		)},
 	}, Commands: map[string]*ice.Command{
 		ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 			m.Cmd(mdb.PRUNES, DAEMON, "", mdb.HASH, mdb.CACHE_CLEAR_ON_EXIT, ice.TRUE)
 		}},
 
-		DAEMON: {Name: "daemon hash auto start prunes", Help: "守护进程", Action: map[string]*ice.Action{
+		DAEMON: {Name: "daemon hash auto start prunes", Help: "守护进程", Action: ice.MergeAction(map[string]*ice.Action{
 			START: {Name: "start cmd env dir", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
 				m.Option(CMD_DIR, m.Option(DIR))
 				m.Option(CMD_ENV, kit.Split(m.Option(ENV), " ="))
-				m.Cmdy(DAEMON, kit.Split(m.Option(CMD)))
+				m.Cmdy(DAEMON, kit.Split(m.Option(ice.CMD)))
 			}},
 			RESTART: {Name: "restart", Help: "重启", Hand: func(m *ice.Message, arg ...string) {
 				m.Cmd(DAEMON, STOP)
@@ -145,46 +130,32 @@ func init() {
 				m.Cmdy(DAEMON, START)
 			}},
 			STOP: {Name: "stop", Help: "停止", Hand: func(m *ice.Message, arg ...string) {
-				m.Option(mdb.FIELDS, "time,hash,status,pid,cmd,dir,env")
+				m.OptionFields(m.Config(kit.MDB_FIELD))
-				m.Cmd(mdb.SELECT, DAEMON, "", mdb.HASH, kit.MDB_HASH, m.Option(kit.MDB_HASH)).Table(func(index int, value map[string]string, head []string) {
+				m.Cmd(mdb.SELECT, DAEMON, "", mdb.HASH, m.OptionSimple(kit.MDB_HASH)).Table(func(index int, value map[string]string, head []string) {
-					m.Cmd(mdb.MODIFY, DAEMON, "", mdb.HASH, kit.MDB_HASH, m.Option(kit.MDB_HASH), kit.MDB_STATUS, STOP)
+					m.Cmd(mdb.MODIFY, DAEMON, "", mdb.HASH, m.OptionSimple(kit.MDB_HASH), kit.MDB_STATUS, STOP)
 					m.Cmdy(SYSTEM, "kill", "-9", value[PID])
 				})
 			}},
-			mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
-				m.Cmdy(mdb.DELETE, DAEMON, "", mdb.HASH, kit.MDB_HASH, m.Option(kit.MDB_HASH))
-			}},
 			mdb.PRUNES: {Name: "prunes", Help: "清理", Hand: func(m *ice.Message, arg ...string) {
-				m.Option(mdb.FIELDS, "time,hash,status,pid,cmd,dir,env")
+				m.OptionFields(m.Config(kit.MDB_FIELD))
-				m.Cmdy(mdb.PRUNES, DAEMON, "", mdb.HASH, kit.MDB_STATUS, ERROR)
 				m.Cmdy(mdb.PRUNES, DAEMON, "", mdb.HASH, kit.MDB_STATUS, STOP)
+				m.Cmdy(mdb.PRUNES, DAEMON, "", mdb.HASH, kit.MDB_STATUS, ERROR)
 			}},
-		}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+		}, mdb.HashAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-			if len(arg) == 0 { // 进程列表
+			m.Fields(len(arg), m.Config(kit.MDB_FIELD))
-				m.Fields(len(arg), "time,hash,status,pid,cmd,dir,env")
+			m.Cmdy(mdb.SELECT, DAEMON, "", mdb.HASH, kit.MDB_HASH, arg).Table(func(index int, value map[string]string, head []string) {
-				m.Cmdy(mdb.SELECT, DAEMON, "", mdb.HASH).Table(func(index int, value map[string]string, head []string) {
+				switch value[kit.MDB_STATUS] {
-					switch value[kit.MDB_STATUS] {
-					case START:
-						m.PushButton(RESTART, STOP)
-					default:
-						m.PushButton(mdb.REMOVE)
-					}
-				})
-
-			} else if m.Richs(DAEMON, "", arg[0], nil) != nil { // 进程详情
-				m.Option(mdb.FIELDS, mdb.DETAIL)
-				m.Cmdy(mdb.SELECT, DAEMON, "", mdb.HASH, kit.MDB_HASH, arg)
-				switch m.Append(kit.MDB_STATUS) {
 				case START:
 					m.PushButton(RESTART, STOP)
 				default:
 					m.PushButton(mdb.REMOVE)
 				}
+			})
 
-			} else { // 启动进程
+			if len(arg) == 0 || len(m.Appendv(ice.MSG_APPEND)) > 0 {
-				m.Option(CMD_TYPE, DAEMON)
+				return
-				m.Cmdy(SYSTEM, arg)
 			}
+			_daemon_exec(m, _system_cmd(m, arg...))
 		}},
 	}})
 }

base/cli/qrcode.go

@@ -61,7 +61,6 @@ func _trans_cli(str string) string {
 	}
 	return kit.Format(res)
 }
-
 func _qrcode_cli(m *ice.Message, text string) {
 	qr, _ := qrcode.New(text, qrcode.Medium)
 	fg := _trans_cli(m.Option(FG))
@@ -79,7 +78,7 @@ func _qrcode_cli(m *ice.Message, text string) {
 
 			m.Echo("\033[4%sm  \033[0m", kit.Select(bg, fg, col))
 		}
-		m.Echo("\n")
+		m.Echo(ice.NL)
 	}
 	m.Echo(text)
 }
@@ -126,27 +125,24 @@ const (
 const QRCODE = "qrcode"
 
 func init() {
-	Index.Merge(&ice.Context{
+	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
-		Configs: map[string]*ice.Config{
+		QRCODE: {Name: QRCODE, Help: "二维码", Value: kit.Data()},
-			QRCODE: {Name: QRCODE, Help: "二维码", Value: kit.Data()},
+	}, Commands: map[string]*ice.Command{
-		},
+		ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-		Commands: map[string]*ice.Command{
+			ice.AddRender(ice.RENDER_QRCODE, func(m *ice.Message, cmd string, args ...interface{}) string {
-			ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+				return m.Cmd(QRCODE, kit.Simple(args...)).Result()
-				ice.AddRender(ice.RENDER_QRCODE, func(m *ice.Message, cmd string, args ...interface{}) string {
+			})
-					return m.Cmd(QRCODE, kit.Simple(args...)).Result()
+		}},
-				})
+		QRCODE: {Name: "qrcode text fg bg size auto", Help: "二维码", Action: map[string]*ice.Action{}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-			}},
+			m.Option(SIZE, kit.Select("240", arg, 3))
-			QRCODE: {Name: "qrcode text fg bg size auto", Help: "二维码", Action: map[string]*ice.Action{}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+			m.Option(BG, kit.Select(WHITE, arg, 2))
-				m.Option(SIZE, kit.Select("240", arg, 3))
+			m.Option(FG, kit.Select(BLUE, arg, 1))
-				m.Option(BG, kit.Select(WHITE, arg, 2))
-				m.Option(FG, kit.Select(BLUE, arg, 1))
 
-				if m.IsCliUA() {
+			if m.IsCliUA() {
-					_qrcode_cli(m, kit.Select(m.Conf("web.share", kit.Keym(kit.MDB_DOMAIN)), arg, 0))
+				_qrcode_cli(m, kit.Select(m.Conf("web.share", kit.Keym(kit.MDB_DOMAIN)), arg, 0))
-				} else {
+			} else {
-					_qrcode_web(m, kit.Select(m.Option(ice.MSG_USERWEB), arg, 0))
+				_qrcode_web(m, kit.Select(m.Option(ice.MSG_USERWEB), arg, 0))
-				}
+			}
-			}},
+		}},
-		},
+	}})
-	})
 }

base/cli/runtime.go

@@ -4,6 +4,9 @@ import (
 	"bytes"
 	"io/ioutil"
 	"os"
+	"os/user"
+	"path"
+	"runtime"
 	"strings"
 
 	ice "shylinux.com/x/icebergs"
@@ -11,6 +14,53 @@ import (
 	kit "shylinux.com/x/toolkits"
 )
 
+func _runtime_init(m *ice.Message) {
+	// 版本信息
+	kit.Fetch(kit.UnMarshal(kit.Format(ice.Info.Make)), func(key string, value interface{}) {
+		m.Conf(RUNTIME, kit.Keys(MAKE, strings.ToLower(key)), value)
+	})
+
+	// 环境变量
+	for _, k := range []string{CTX_SHY, CTX_DEV, CTX_OPS, CTX_PID, CTX_USER, CTX_SHARE, CTX_RIVER} {
+		m.Conf(RUNTIME, kit.Keys(CONF, k), os.Getenv(k))
+	}
+
+	// 主机信息
+	m.Conf(RUNTIME, kit.Keys(HOST, GOARCH), runtime.GOARCH)
+	m.Conf(RUNTIME, kit.Keys(HOST, GOOS), runtime.GOOS)
+	m.Conf(RUNTIME, kit.Keys(HOST, "pid"), os.Getpid())
+
+	// 启动信息
+	if name, e := os.Hostname(); e == nil {
+		m.Conf(RUNTIME, kit.Keys(BOOT, HOSTNAME), kit.Select(name, os.Getenv("HOSTNAME")))
+	}
+	if name, e := os.Getwd(); e == nil {
+		name = path.Base(kit.Select(name, os.Getenv("PWD")))
+		ls := strings.Split(name, "/")
+		name = ls[len(ls)-1]
+		ls = strings.Split(name, "\\")
+		name = ls[len(ls)-1]
+		m.Conf(RUNTIME, kit.Keys(BOOT, PATHNAME), name)
+	}
+	if m.Conf(RUNTIME, kit.Keys(BOOT, USERNAME), kit.Select(os.Getenv(USER), os.Getenv(CTX_USER))) == "" {
+		if user, e := user.Current(); e == nil && user.Name != "" {
+			m.Conf(RUNTIME, kit.Keys(BOOT, USERNAME), kit.Select(user.Name, os.Getenv(CTX_USER)))
+		}
+	}
+	ice.Info.HostName = m.Conf(RUNTIME, kit.Keys(BOOT, HOSTNAME))
+	ice.Info.PathName = m.Conf(RUNTIME, kit.Keys(BOOT, PATHNAME))
+	ice.Info.UserName = m.Conf(RUNTIME, kit.Keys(BOOT, USERNAME))
+
+	// 启动次数
+	count := kit.Int(m.Conf(RUNTIME, kit.Keys(BOOT, kit.MDB_COUNT))) + 1
+	m.Conf(RUNTIME, kit.Keys(BOOT, kit.MDB_COUNT), count)
+
+	// 节点信息
+	m.Conf(RUNTIME, kit.Keys(NODE, kit.MDB_TIME), m.Time())
+	NodeInfo(m, "worker", m.Conf(RUNTIME, kit.Keys(BOOT, PATHNAME)))
+
+	runtime.GOMAXPROCS(kit.Int(kit.Select("1", m.Conf(RUNTIME, kit.Keys(HOST, "GOMAXPROCS")))))
+}
 func _runtime_hostinfo(m *ice.Message) {
 	if f, e := os.Open("/proc/cpuinfo"); e == nil {
 		defer f.Close()
@@ -21,7 +71,7 @@ func _runtime_hostinfo(m *ice.Message) {
 	if f, e := os.Open("/proc/meminfo"); e == nil {
 		defer f.Close()
 		if b, e := ioutil.ReadAll(f); e == nil {
-			for i, ls := range strings.Split(string(b), "\n") {
+			for i, ls := range strings.Split(string(b), ice.NL) {
 				vs := kit.Split(ls, ": ")
 				m.Push(strings.TrimSpace(vs[0]), kit.FmtSize(kit.Int64(strings.TrimSpace(vs[1]))*1024))
 				if i > 1 {
@@ -33,62 +83,108 @@ func _runtime_hostinfo(m *ice.Message) {
 	m.Push("uptime", kit.Split(m.Cmdx(SYSTEM, "uptime"), ",")[0])
 }
 
+func NodeInfo(m *ice.Message, kind, name string) {
+	name = strings.ReplaceAll(name, ice.PT, "_")
+	m.Conf(RUNTIME, kit.Keys(NODE, kit.MDB_TYPE), kind)
+	m.Conf(RUNTIME, kit.Keys(NODE, kit.MDB_NAME), name)
+	ice.Info.NodeName = name
+	ice.Info.NodeType = kind
+}
+
+const (
+	MAKE = "make"
+	TEST = "test"
+	CONF = "conf"
+	HOST = "host"
+	BOOT = "boot"
+	NODE = "node"
+)
+const (
+	SOURCE = "source"
+	TARGET = "target"
+)
+const (
+	GOARCH  = "GOARCH"
+	GOOS    = "GOOS"
+	LINUX   = "linux"
+	DARWIN  = "darwin"
+	WINDOWS = "windows"
+	AMD64   = "amd64"
+	I386    = "i386"
+	ARM     = "arm"
+)
+const (
+	CTX_SHY = "ctx_shy"
+	CTX_DEV = "ctx_dev"
+	CTX_OPS = "ctx_ops"
+
+	CTX_PID   = "ctx_pid"
+	CTX_LOG   = "ctx_log"
+	CTX_USER  = "ctx_user"
+	CTX_SHARE = "ctx_share"
+	CTX_RIVER = "ctx_river"
+)
+const (
+	HOSTNAME = "hostname"
+	PATHNAME = "pathname"
+	USERNAME = "username"
+)
 const (
-	DISKINFO = "diskinfo"
 	IFCONFIG = "ifconfig"
 	HOSTINFO = "hostinfo"
 	USERINFO = "userinfo"
 	PROCINFO = "procinfo"
 	BOOTINFO = "bootinfo"
+	DISKINFO = "diskinfo"
 )
 const RUNTIME = "runtime"
 
 func init() {
-	Index.Merge(&ice.Context{
+	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
-		Configs: map[string]*ice.Config{
+		RUNTIME: {Name: RUNTIME, Help: "运行环境", Value: kit.Dict()},
-			RUNTIME: {Name: RUNTIME, Help: "运行环境", Value: kit.Dict()},
+	}, Commands: map[string]*ice.Command{
-		},
+		ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-		Commands: map[string]*ice.Command{
+			_runtime_init(m)
-			RUNTIME: {Name: "runtime info=diskinfo,ifconfig,hostname,hostinfo,userinfo,procinfo,bootinfo auto", Help: "运行环境", Action: map[string]*ice.Action{
+		}},
-				DISKINFO: {Name: "diskinfo", Help: "磁盘信息", Hand: func(m *ice.Message, arg ...string) {
+		RUNTIME: {Name: "runtime info=ifconfig,hostinfo,hostname,userinfo,procinfo,bootinfo,diskinfo auto", Help: "运行环境", Action: map[string]*ice.Action{
-					m.Spawn().Split(m.Cmdx(SYSTEM, "df", "-h"), "", " ", "\n").Table(func(index int, value map[string]string, head []string) {
+			IFCONFIG: {Name: "ifconfig", Help: "网卡配置", Hand: func(m *ice.Message, arg ...string) {
-						if strings.HasPrefix(value["Filesystem"], "/dev") {
+				m.Cmdy("tcp.host")
-							m.Push("", value, head)
-						}
-					})
-				}},
-				IFCONFIG: {Name: "ifconfig", Help: "网卡配置", Hand: func(m *ice.Message, arg ...string) {
-					m.Cmdy("tcp.host")
-				}},
-				HOSTNAME: {Name: "hostname", Help: "主机域名", Hand: func(m *ice.Message, arg ...string) {
-					if len(arg) > 0 {
-						m.Conf(RUNTIME, kit.Keys(NODE, kit.MDB_NAME), arg[0])
-						m.Conf(RUNTIME, kit.Keys(BOOT, HOSTNAME), arg[0])
-						ice.Info.HostName = arg[0]
-					}
-					m.Echo(ice.Info.HostName)
-				}},
-				HOSTINFO: {Name: "hostinfo", Help: "主机信息", Hand: func(m *ice.Message, arg ...string) {
-					_runtime_hostinfo(m)
-				}},
-				USERINFO: {Name: "userinfo", Help: "用户信息", Hand: func(m *ice.Message, arg ...string) {
-					m.Split(m.Cmdx(SYSTEM, "who"), "user term time", " ", "\n")
-				}},
-				PROCINFO: {Name: "procinfo", Help: "进程信息", Hand: func(m *ice.Message, arg ...string) {
-					m.Split(m.Cmdx(SYSTEM, "ps", "u"), "", " ", "\n")
-					m.PushAction("kill")
-					m.StatusTimeCount()
-				}},
-				"kill": {Name: "kill", Help: "结束进程", Hand: func(m *ice.Message, arg ...string) {
-					m.Cmdy(SYSTEM, "kill", m.Option("PID"))
-					m.ProcessRefresh("10ms")
-				}},
-			}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-				if len(arg) > 0 && arg[0] == BOOTINFO {
-					arg = arg[1:]
-				}
-				m.Cmdy(ctx.CONFIG, RUNTIME, arg)
 			}},
-		},
+			HOSTINFO: {Name: "hostinfo", Help: "主机信息", Hand: func(m *ice.Message, arg ...string) {
-	})
+				_runtime_hostinfo(m)
+			}},
+			HOSTNAME: {Name: "hostname", Help: "主机域名", Hand: func(m *ice.Message, arg ...string) {
+				if len(arg) > 0 {
+					m.Conf(RUNTIME, kit.Keys(NODE, kit.MDB_NAME), arg[0])
+					m.Conf(RUNTIME, kit.Keys(BOOT, HOSTNAME), arg[0])
+					ice.Info.HostName = arg[0]
+				}
+				m.Echo(ice.Info.HostName)
+			}},
+			USERINFO: {Name: "userinfo", Help: "用户信息", Hand: func(m *ice.Message, arg ...string) {
+				m.Split(m.Cmdx(SYSTEM, "who"), "user term time", ice.SP, ice.NL)
+			}},
+			PROCINFO: {Name: "procinfo", Help: "进程信息", Hand: func(m *ice.Message, arg ...string) {
+				m.Split(m.Cmdx(SYSTEM, "ps", "u"), "", ice.SP, ice.NL)
+				m.PushAction("prockill")
+				m.StatusTimeCount()
+			}},
+			"prockill": {Name: "prockill", Help: "结束进程", Hand: func(m *ice.Message, arg ...string) {
+				m.Cmdy(SYSTEM, "prockill", m.Option("PID"))
+				m.ProcessRefresh30ms()
+			}},
+			DISKINFO: {Name: "diskinfo", Help: "磁盘信息", Hand: func(m *ice.Message, arg ...string) {
+				m.Spawn().Split(m.Cmdx(SYSTEM, "df", "-h"), "", ice.SP, ice.NL).Table(func(index int, value map[string]string, head []string) {
+					if strings.HasPrefix(value["Filesystem"], "/dev") {
+						m.Push("", value, head)
+					}
+				})
+			}},
+		}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+			if len(arg) > 0 && arg[0] == BOOTINFO {
+				arg = arg[1:]
+			}
+			m.Cmdy(ctx.CONFIG, RUNTIME, arg)
+		}},
+	}})
 }

base/cli/system.go

@@ -5,7 +5,6 @@ import (
 	"io"
 	"os"
 	"os/exec"
-	"strings"
 
 	ice "shylinux.com/x/icebergs"
 	"shylinux.com/x/icebergs/base/ctx"
@@ -13,16 +12,49 @@ import (
 	kit "shylinux.com/x/toolkits"
 )
 
-func _system_show(m *ice.Message, cmd *exec.Cmd) {
+func _system_cmd(m *ice.Message, arg ...string) *exec.Cmd {
+	cmd := exec.Command(arg[0], arg[1:]...)
+
+	// 运行目录
+	if cmd.Dir = m.Option(CMD_DIR); len(cmd.Dir) > 0 {
+		m.Log_EXPORT(CMD_DIR, cmd.Dir)
+		if _, e := os.Stat(cmd.Dir); e != nil && os.IsNotExist(e) {
+			os.MkdirAll(cmd.Dir, ice.MOD_DIR)
+		}
+	}
+
+	// 环境变量
+	env := kit.Simple(m.Optionv(CMD_ENV))
+	for i := 0; i < len(env)-1; i += 2 {
+		cmd.Env = append(cmd.Env, kit.Format("%s=%s", env[i], env[i+1]))
+	}
+	if len(cmd.Env) > 0 {
+		m.Log_EXPORT(CMD_ENV, cmd.Env)
+	}
+	return cmd
+}
+func _system_out(m *ice.Message, out string) io.Writer {
+	if w, ok := m.Optionv(out).(io.Writer); ok {
+		return w
+	} else if m.Option(out) == "" {
+		return nil
+	} else if f, p, e := kit.Create(m.Option(out)); m.Assert(e) {
+		m.Log_EXPORT(out, p)
+		m.Optionv(out, f)
+		return f
+	}
+	return nil
+}
+func _system_exec(m *ice.Message, cmd *exec.Cmd) {
 	// 输入流
 	if r, ok := m.Optionv(CMD_INPUT).(io.Reader); ok {
 		cmd.Stdin = r
 	}
 
 	// 输出流
-	if w, ok := m.Optionv(CMD_OUTPUT).(io.Writer); ok {
+	if w := _system_out(m, CMD_OUTPUT); w != nil {
 		cmd.Stdout, cmd.Stderr = w, w
-		if w, ok := m.Optionv(CMD_ERRPUT).(io.Writer); ok {
+		if w := _system_out(m, CMD_ERRPUT); w != nil {
 			cmd.Stderr = w
 		}
 	} else {
@@ -33,107 +65,61 @@ func _system_show(m *ice.Message, cmd *exec.Cmd) {
 			m.Push(CMD_ERR, err.String())
 			m.Echo(kit.Select(out.String(), err.String()))
 		}()
-
 		cmd.Stdout, cmd.Stderr = out, err
 	}
 
 	// 执行命令
-	if e := cmd.Run(); e != nil {
+	if e := cmd.Run(); !m.Warn(e != nil, cmd.Args, ice.SP, e) {
-		m.Warn(e != nil, cmd.Args, " ", e.Error())
+		m.Cost(kit.MDB_CODE, cmd.ProcessState.ExitCode(), kit.MDB_ARGS, cmd.Args)
-	} else {
-		m.Cost("code", cmd.ProcessState.ExitCode(), "args", cmd.Args)
 	}
 
 	m.Push(kit.MDB_TIME, m.Time())
-	m.Push(CMD_CODE, int(cmd.ProcessState.ExitCode()))
+	m.Push(kit.MDB_CODE, int(cmd.ProcessState.ExitCode()))
 }
 func SystemProcess(m *ice.Message, text string, arg ...string) {
-	if len(arg) > 0 && arg[0] == RUN {
+	if len(arg) > 0 && arg[0] == ice.RUN {
 		m.Cmdy(SYSTEM, arg[1:])
 		return
 	}
 
 	m.Cmdy(ctx.COMMAND, SYSTEM)
-	m.ProcessField(SYSTEM, RUN)
+	m.ProcessField(SYSTEM, ice.RUN)
-	m.Push(ARG, kit.Split(text))
+	m.Push(ice.ARG, kit.Split(text))
 }
 func IsSuccess(m *ice.Message) bool {
-	return m.Append(CMD_CODE) == "0"
+	return m.Append(kit.MDB_CODE) == "0"
 }
 
 const (
-	CMD_DIR  = "cmd_dir"
+	CMD_DIR = "cmd_dir"
-	CMD_ENV  = "cmd_env"
+	CMD_ENV = "cmd_env"
-	CMD_TYPE = "cmd_type"
 
 	CMD_INPUT  = "cmd_input"
 	CMD_OUTPUT = "cmd_output"
 	CMD_ERRPUT = "cmd_errput"
 
-	CMD_CODE = "cmd_code"
+	CMD_OUT = "cmd_out"
-	CMD_ERR  = "cmd_err"
+	CMD_ERR = "cmd_err"
-	CMD_OUT  = "cmd_out"
 )
 
-const (
-	GOARCH  = "goarch"
-	GOOS    = "goos"
-	LINUX   = "linux"
-	DARWIN  = "darwin"
-	WINDOWS = "windows"
-	AMD64   = "amd64"
-	I386    = "386"
-	ARM     = "arm"
-
-	SOURCE = "source"
-	TARGET = "target"
-
-	USER = "USER"
-	HOME = "HOME"
-	PATH = "PATH"
-)
 const SYSTEM = "system"
 
 func init() {
 	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
-		SYSTEM: {Name: SYSTEM, Help: "系统命令", Value: kit.Data()},
+		SYSTEM: {Name: SYSTEM, Help: "系统命令", Value: kit.Data(kit.MDB_FIELD, "time,id,cmd")},
 	}, Commands: map[string]*ice.Command{
 		SYSTEM: {Name: "system cmd run:button", Help: "系统命令", Hand: func(m *ice.Message, c *ice.Context, key string, arg ...string) {
 			if len(arg) == 0 {
-				m.Fields(len(arg), "time,id,cmd")
+				m.Fields(len(arg), m.Config(kit.MDB_FIELD))
 				m.Cmdy(mdb.SELECT, SYSTEM, "", mdb.LIST)
 				return
 			}
-			m.Grow(SYSTEM, "", kit.Dict(kit.MDB_TIME, m.Time(), CMD, strings.Join(arg, " ")))
+			m.Grow(SYSTEM, "", kit.Dict(kit.MDB_TIME, m.Time(), ice.CMD, kit.Join(arg, ice.SP)))
 
 			if len(arg) == 1 {
 				arg = kit.Split(arg[0])
 			}
-			cmd := exec.Command(arg[0], arg[1:]...)
+			_system_exec(m, _system_cmd(m, arg...))
-
-			// 运行目录
-			if cmd.Dir = m.Option(CMD_DIR); len(cmd.Dir) > 0 {
-				m.Log_EXPORT(kit.MDB_META, SYSTEM, CMD_DIR, cmd.Dir)
-				if _, e := os.Stat(cmd.Dir); e != nil && os.IsNotExist(e) {
-					os.MkdirAll(cmd.Dir, ice.MOD_DIR)
-				}
-			}
-
-			// 环境变量
-			env := kit.Simple(m.Optionv(CMD_ENV))
-			for i := 0; i < len(env)-1; i += 2 {
-				cmd.Env = append(cmd.Env, kit.Format("%s=%s", env[i], env[i+1]))
-			}
-			if len(cmd.Env) > 0 {
-				m.Log_EXPORT(kit.MDB_META, SYSTEM, CMD_ENV, cmd.Env)
-			}
-
-			switch m.Option(CMD_TYPE) {
-			case DAEMON:
-				_daemon_show(m, cmd, m.Option(CMD_OUTPUT), m.Option(CMD_ERRPUT))
-			default:
-				_system_show(m, cmd)
-			}
 		}},
 	}})
 }

base/ctx/command.go

@@ -41,13 +41,25 @@ func _command_search(m *ice.Message, kind, name, text string) {
 			return
 		}
 
-		m.PushSearch("cmd", COMMAND,
+		m.PushSearch(kit.MDB_TYPE, COMMAND, kit.MDB_NAME, name, kit.MDB_TEXT, help, CONTEXT, s.Cap(ice.CTX_FOLLOW), COMMAND, key)
-			kit.MDB_TYPE, kind, kit.MDB_NAME, key, kit.MDB_TEXT, s.Cap(ice.CTX_FOLLOW),
-			CONTEXT, s.Cap(ice.CTX_FOLLOW), COMMAND, key,
-		)
 	})
 }
 
+func CmdAction(fields ...string) map[string]*ice.Action {
+	return ice.SelectAction(map[string]*ice.Action{
+		COMMAND: {Name: "command", Help: "命令", Hand: func(m *ice.Message, arg ...string) {
+			if !m.PodCmd(COMMAND, arg) {
+				m.Cmdy(COMMAND, arg)
+			}
+		}},
+		ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
+			if !m.PodCmd(arg) {
+				m.Cmdy(arg)
+			}
+		}},
+	}, fields...)
+}
+
 const (
 	ACTION = "action"
 )
@@ -55,6 +67,9 @@ const COMMAND = "command"
 
 func init() {
 	Index.Merge(&ice.Context{Commands: map[string]*ice.Command{
+		ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+			m.Cmd(mdb.SEARCH, mdb.CREATE, COMMAND, m.Prefix(COMMAND))
+		}},
 		COMMAND: {Name: "command key auto", Help: "命令", Action: map[string]*ice.Action{
 			mdb.SEARCH: {Name: "search type name text", Help: "搜索", Hand: func(m *ice.Message, arg ...string) {
 				if arg[0] == COMMAND || arg[1] != "" {

base/ctx/config.go

@@ -94,42 +94,39 @@ const (
 const CONFIG = "config"
 
 func init() {
-	Index.Merge(&ice.Context{
+	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
-		Configs: map[string]*ice.Config{
+		CONFIG: {Name: CONFIG, Help: "配置", Value: kit.Data(kit.MDB_PATH, ice.VAR_CONF)},
-			CONFIG: {Name: CONFIG, Help: "配置", Value: kit.Data(kit.MDB_PATH, ice.VAR_CONF)},
+	}, Commands: map[string]*ice.Command{
-		},
+		CONFIG: {Name: "config key auto", Help: "配置", Action: map[string]*ice.Action{
-		Commands: map[string]*ice.Command{
+			SAVE: {Name: "save", Help: "保存", Hand: func(m *ice.Message, arg ...string) {
-			CONFIG: {Name: "config key auto", Help: "配置", Action: map[string]*ice.Action{
+				_config_save(m, arg[0], arg[1:]...)
-				SAVE: {Name: "save", Help: "保存", Hand: func(m *ice.Message, arg ...string) {
-					_config_save(m, arg[0], arg[1:]...)
-				}},
-				LOAD: {Name: "load", Help: "加载", Hand: func(m *ice.Message, arg ...string) {
-					_config_load(m, arg[0], arg[1:]...)
-				}},
-				RICH: {Name: "rich", Help: "富有", Hand: func(m *ice.Message, arg ...string) {
-					_config_rich(m, arg[0], arg[1], arg[2:]...)
-				}},
-				GROW: {Name: "grow", Help: "成长", Hand: func(m *ice.Message, arg ...string) {
-					_config_grow(m, arg[0], arg[1], arg[2:]...)
-				}},
-				"clear": {Name: "clear", Help: "清空", Hand: func(m *ice.Message, arg ...string) {
-					m.Conf(arg[0], "", "")
-					m.Cmd("exit", 1)
-				}},
-				"list": {Name: "list", Help: "列表", Hand: func(m *ice.Message, arg ...string) {
-					list := []interface{}{}
-					for _, v := range arg[2:] {
-						list = append(list, v)
-					}
-					m.Confv(arg[0], arg[1], kit.List(list...))
-				}},
-			}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-				if len(arg) == 0 {
-					_config_list(m)
-					return
-				}
-				_config_make(m, arg[0], arg[1:]...)
 			}},
-		},
+			LOAD: {Name: "load", Help: "加载", Hand: func(m *ice.Message, arg ...string) {
-	})
+				_config_load(m, arg[0], arg[1:]...)
+			}},
+			RICH: {Name: "rich", Help: "富有", Hand: func(m *ice.Message, arg ...string) {
+				_config_rich(m, arg[0], arg[1], arg[2:]...)
+			}},
+			GROW: {Name: "grow", Help: "成长", Hand: func(m *ice.Message, arg ...string) {
+				_config_grow(m, arg[0], arg[1], arg[2:]...)
+			}},
+			"list": {Name: "list", Help: "列表", Hand: func(m *ice.Message, arg ...string) {
+				list := []interface{}{}
+				for _, v := range arg[2:] {
+					list = append(list, v)
+				}
+				m.Confv(arg[0], arg[1], kit.List(list...))
+			}},
+			"clear": {Name: "clear", Help: "清空", Hand: func(m *ice.Message, arg ...string) {
+				m.Conf(arg[0], "", "")
+				m.Cmd(ice.EXIT, 1)
+			}},
+		}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+			if len(arg) == 0 {
+				_config_list(m)
+				return
+			}
+			_config_make(m, arg[0], arg[1:]...)
+		}},
+	}})
 }

base/ctx/context.go

@@ -19,7 +19,7 @@ const CONTEXT = "context"
 func init() {
 	Index.Merge(&ice.Context{Commands: map[string]*ice.Command{
 		CONTEXT: {Name: "context name=web.chat action=context,command,config key auto", Help: "模块", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-			m.Search(kit.Select("ice", arg, 0)+".", func(p *ice.Context, s *ice.Context, key string) {
+			m.Search(kit.Select(ice.ICE, arg, 0)+ice.PT, func(p *ice.Context, s *ice.Context, key string) {
 				msg := m.Spawn(s)
 				defer m.Copy(msg)
 

base/ctx/ctx.go

@@ -2,40 +2,12 @@ package ctx
 
 import (
 	ice "shylinux.com/x/icebergs"
-	"shylinux.com/x/icebergs/base/mdb"
 )
 
-func selectAction(list map[string]*ice.Action, fields ...string) map[string]*ice.Action {
-	if len(fields) == 0 {
-		return list
-	}
-
-	res := map[string]*ice.Action{}
-	for _, field := range fields {
-		res[field] = list[field]
-	}
-	return res
-}
-func CmdAction(fields ...string) map[string]*ice.Action {
-	return selectAction(map[string]*ice.Action{
-		"command": {Name: "command", Help: "命令", Hand: func(m *ice.Message, arg ...string) {
-			if !m.PodCmd("command", arg) {
-				m.Cmdy("command", arg)
-			}
-		}},
-		"run": {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
-			if !m.PodCmd(arg) {
-				m.Cmdy(arg)
-			}
-		}},
-	}, fields...)
-}
-
 const CTX = "ctx"
 
 var Index = &ice.Context{Name: CTX, Help: "标准模块", Commands: map[string]*ice.Command{
 	ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-		m.Cmd(mdb.SEARCH, mdb.CREATE, COMMAND, m.Prefix(COMMAND))
 	}},
 	ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 	}},

base/ctx/ctx.shy

@@ -3,4 +3,5 @@ chapter "ctx"
 field "模块" context
 field "命令" command
 field "配置" config
+field "消息" message
 

base/gdb/event.go

@@ -2,19 +2,18 @@ package gdb
 
 import (
 	ice "shylinux.com/x/icebergs"
-	"shylinux.com/x/icebergs/base/cli"
 	"shylinux.com/x/icebergs/base/mdb"
 	kit "shylinux.com/x/toolkits"
 )
 
 func _event_listen(m *ice.Message, event string, cmd string) {
 	h := m.Cmdx(mdb.INSERT, EVENT, "", mdb.HASH, EVENT, event)
-	m.Cmdy(mdb.INSERT, EVENT, kit.Keys(kit.MDB_HASH, h), mdb.LIST, cli.CMD, cmd)
+	m.Cmdy(mdb.INSERT, EVENT, kit.Keys(kit.MDB_HASH, h), mdb.LIST, ice.CMD, cmd)
 }
 func _event_action(m *ice.Message, event string, arg ...string) {
 	m.Option(mdb.FIELDS, "time,id,cmd")
 	m.Cmd(mdb.SELECT, EVENT, kit.Keys(kit.MDB_HASH, kit.Hashs(event)), mdb.LIST).Table(func(index int, value map[string]string, head []string) {
-		m.Cmd(kit.Split(value[cli.CMD]), event, arg).Cost(EVENT, event, cli.ARG, arg)
+		m.Cmd(kit.Split(value[ice.CMD]), event, arg).Cost(EVENT, event, ice.ARG, arg)
 	})
 }
 
@@ -28,7 +27,7 @@ func init() {
 		Commands: map[string]*ice.Command{
 			EVENT: {Name: "event event id auto listen", Help: "事件流", Action: map[string]*ice.Action{
 				LISTEN: {Name: "listen event cmd", Help: "监听", Hand: func(m *ice.Message, arg ...string) {
-					_event_listen(m, m.Option(EVENT), m.Option(cli.CMD))
+					_event_listen(m, m.Option(EVENT), m.Option(ice.CMD))
 				}},
 				ACTION: {Name: "action event arg", Help: "触发", Hand: func(m *ice.Message, arg ...string) {
 					_event_action(m, m.Option(EVENT), arg[2:]...)

base/gdb/gdb.go

@@ -52,8 +52,8 @@ var Index = &ice.Context{Name: GDB, Help: "事件模块",
 			m.Cmd(nfs.SAVE, kit.Select(m.Conf(SIGNAL, kit.META_PATH), m.Conf(cli.RUNTIME, kit.Keys(cli.CONF, cli.CTX_PID))),
 				m.Conf(cli.RUNTIME, kit.Keys(cli.HOST, cli.PID)))
 
-			m.Cmd(SIGNAL, LISTEN, SIGNAL, "3", kit.MDB_NAME, "退出", cli.CMD, "exit 0")
+			m.Cmd(SIGNAL, LISTEN, SIGNAL, "3", kit.MDB_NAME, "退出", ice.CMD, "exit 0")
-			m.Cmd(SIGNAL, LISTEN, SIGNAL, "2", kit.MDB_NAME, "重启", cli.CMD, "exit 1")
+			m.Cmd(SIGNAL, LISTEN, SIGNAL, "2", kit.MDB_NAME, "重启", ice.CMD, "exit 1")
 			m.Load()
 		}},
 		ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {

base/gdb/routine.go

@@ -42,12 +42,12 @@ func init() {
 
 				INNER: {Name: "inner", Help: "源码", Hand: func(m *ice.Message, arg ...string) {
 					switch kit.Select("", arg, 0) {
-					case cli.RUN:
+					case ice.RUN:
 						m.Cmdy(INNER, arg[1:])
 					default:
 						ls := kit.Split(m.Option("fileline"), ":")
-						m.ProcessField(INNER, cli.RUN)
+						m.ProcessField(INNER, ice.RUN)
-						m.Option(cli.ARG, kit.Format([]string{path.Dir(ls[0]), path.Base(ls[0]), ls[1]}))
+						m.Option(ice.ARG, kit.Format([]string{path.Dir(ls[0]), path.Base(ls[0]), ls[1]}))
 						m.Cmdy(ctx.COMMAND, INNER)
 					}
 				}},

base/gdb/signal.go

@@ -7,7 +7,6 @@ import (
 	"syscall"
 
 	ice "shylinux.com/x/icebergs"
-	"shylinux.com/x/icebergs/base/cli"
 	"shylinux.com/x/icebergs/base/mdb"
 	kit "shylinux.com/x/toolkits"
 )
@@ -22,7 +21,7 @@ func _signal_action(m *ice.Message, s int) {
 	m.Option(mdb.FIELDS, "time,signal,name,cmd")
 	msg := m.Cmd(mdb.SELECT, SIGNAL, "", mdb.HASH, SIGNAL, s)
 	msg.Table(func(index int, value map[string]string, head []string) {
-		m.Cmdy(kit.Split(value[cli.CMD]))
+		m.Cmdy(kit.Split(value[ice.CMD]))
 	})
 }
 

base/gdb/timer.go

@@ -25,8 +25,8 @@ func _timer_action(m *ice.Message, arg ...string) {
 		if n := kit.Time(kit.Format(value[NEXT])); now > n && order > 0 {
 			m.Logs(TIMER, kit.MDB_KEY, key, ORDER, order)
 
-			msg := m.Cmd(value[cli.CMD])
+			msg := m.Cmd(value[ice.CMD])
-			m.Grow(TIMER, kit.Keys(kit.MDB_HASH, key), kit.Dict(cli.RES, msg.Result()))
+			m.Grow(TIMER, kit.Keys(kit.MDB_HASH, key), kit.Dict(ice.RES, msg.Result()))
 			if value[ORDER] = kit.Format(order - 1); order > 1 {
 				value[NEXT] = msg.Time(value[INTERVAL])
 			}

base/nfs/dir.go

@@ -14,7 +14,6 @@ import (
 
 	ice "shylinux.com/x/icebergs"
 	"shylinux.com/x/icebergs/base/aaa"
-	"shylinux.com/x/icebergs/base/cli"
 	"shylinux.com/x/icebergs/base/ctx"
 	"shylinux.com/x/icebergs/base/mdb"
 	kit "shylinux.com/x/toolkits"
@@ -166,7 +165,7 @@ func _dir_search(m *ice.Message, kind, name string) {
 			value[kit.MDB_TYPE] = kit.Ext(value[kit.MDB_NAME])
 		}
 
-		m.PushSearch(cli.CMD, CAT, value)
+		m.PushSearch(ice.CMD, CAT, value)
 	})
 }
 

base/web/dream.go

@@ -83,7 +83,7 @@ func _dream_show(m *ice.Message, name string) {
 		kit.Path(os.Args[0])
 
 		m.Optionv(cli.CMD_ERRPUT, path.Join(p, m.Conf(DREAM, kit.Keym(cli.ENV, "ctx_log"))))
-		m.Cmd(cli.DAEMON, m.Confv(DREAM, kit.Keym(cli.CMD)), ice.DEV, ice.DEV, kit.MDB_NAME, name, RIVER, m.Option(RIVER))
+		m.Cmd(cli.DAEMON, m.Confv(DREAM, kit.Keym(ice.CMD)), ice.DEV, ice.DEV, kit.MDB_NAME, name, RIVER, m.Option(RIVER))
 		m.Event(DREAM_CREATE, kit.MDB_TYPE, m.Option(kit.MDB_TYPE), kit.MDB_NAME, name)
 		m.Sleep(ice.MOD_TICK)
 	}
@@ -139,7 +139,7 @@ func init() {
 		},
 		Configs: map[string]*ice.Config{
 			DREAM: {Name: DREAM, Help: "梦想家", Value: kit.Data(kit.MDB_PATH, ice.USR_LOCAL_WORK,
-				cli.CMD, []interface{}{"ice.bin", SPACE, tcp.DIAL},
+				ice.CMD, []interface{}{"ice.bin", SPACE, tcp.DIAL},
 				cli.ENV, kit.Dict(cli.CTX_LOG, ice.BIN_BOOT_LOG),
 				"miss", `#!/bin/bash
 if [ "$ISH_CONF_PRE" = "" ]; then

base/web/route.go

@@ -3,7 +3,6 @@ package web
 import (
 	ice "shylinux.com/x/icebergs"
 	"shylinux.com/x/icebergs/base/aaa"
-	"shylinux.com/x/icebergs/base/cli"
 	"shylinux.com/x/icebergs/base/ctx"
 	"shylinux.com/x/icebergs/base/mdb"
 	"shylinux.com/x/icebergs/base/nfs"
@@ -116,7 +115,7 @@ func init() {
 				}},
 				ctx.COMMAND: {Name: "command", Help: "命令", Hand: func(m *ice.Message, arg ...string) {
 					m.Debug(m.Option(ROUTE))
-					m.Cmdy(SPACE, m.Option(ROUTE), kit.Keys(m.Option(cli.CTX), m.Option(cli.CMD)), arg)
+					m.Cmdy(SPACE, m.Option(ROUTE), kit.Keys(m.Option(ice.CTX), m.Option(ice.CMD)), arg)
 				}},
 			}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 				if len(arg) == 0 || arg[0] == "" { // 路由列表
@@ -129,13 +128,13 @@ func init() {
 
 				} else if len(arg) > 1 { // 命令列表
 					m.Cmd(SPACE, arg[0], ctx.CONTEXT, arg[1], ctx.COMMAND).Table(func(index int, value map[string]string, head []string) {
-						m.Push(cli.CMD, value[kit.MDB_KEY])
+						m.Push(ice.CMD, value[kit.MDB_KEY])
 						m.Push("", value, []string{kit.MDB_NAME, kit.MDB_HELP})
 					})
 
 				} else if len(arg) > 0 { // 模块列表
 					m.Cmd(SPACE, arg[0], ctx.CONTEXT).Table(func(index int, value map[string]string, head []string) {
-						m.Push(cli.CTX, kit.Keys(value["ups"], value[kit.MDB_NAME]))
+						m.Push(ice.CTX, kit.Keys(value["ups"], value[kit.MDB_NAME]))
 						m.Push("", value, []string{ice.CTX_STATUS, ice.CTX_STREAM, kit.MDB_HELP})
 					})
 				}

base/web/serve.go

@@ -165,7 +165,7 @@ func _serve_handle(key string, cmd *ice.Command, msg *ice.Message, w http.Respon
 	}
 
 	// 请求命令
-	if msg.Option(ice.MSG_USERPOD, msg.Option(cli.POD)); msg.Optionv(ice.MSG_CMDS) == nil {
+	if msg.Option(ice.MSG_USERPOD, msg.Option(ice.POD)); msg.Optionv(ice.MSG_CMDS) == nil {
 		if p := strings.TrimPrefix(r.URL.Path, key); p != "" {
 			msg.Optionv(ice.MSG_CMDS, strings.Split(p, "/"))
 		}

base/web/share.go

@@ -22,11 +22,11 @@ func _share_link(m *ice.Message, p string, arg ...interface{}) string {
 	return tcp.ReplaceLocalhost(m, kit.MergeURL2(kit.Select(m.Option(ice.MSG_USERWEB), m.Conf(SHARE, kit.Keym(kit.MDB_DOMAIN))), p, arg...))
 }
 func _share_cache(m *ice.Message, arg ...string) {
-	if pod := m.Option(cli.POD); m.PodCmd(CACHE, arg[0]) {
+	if pod := m.Option(ice.POD); m.PodCmd(CACHE, arg[0]) {
 		if m.Append(kit.MDB_FILE) == "" {
 			m.RenderResult(m.Append(kit.MDB_TEXT))
 		} else {
-			m.Option(cli.POD, pod)
+			m.Option(ice.POD, pod)
 			_share_local(m, m.Append(kit.MDB_FILE))
 		}
 		return
@@ -49,16 +49,16 @@ func _share_local(m *ice.Message, arg ...string) {
 		}
 	}
 
-	if m.Option(cli.POD) != "" { // 远程文件
+	if m.Option(ice.POD) != "" { // 远程文件
-		pp := path.Join(ice.VAR_PROXY, m.Option(cli.POD), p)
+		pp := path.Join(ice.VAR_PROXY, m.Option(ice.POD), p)
 		cache := time.Now().Add(-time.Hour * 240000)
 		if s, e := os.Stat(pp); e == nil {
 			cache = s.ModTime()
 		}
 
 		// 上传文件
-		m.Cmdy(SPACE, m.Option(cli.POD), SPIDE, ice.DEV, SPIDE_RAW, kit.MergeURL2(m.Option(ice.MSG_USERWEB), "/share/proxy/"),
+		m.Cmdy(SPACE, m.Option(ice.POD), SPIDE, ice.DEV, SPIDE_RAW, kit.MergeURL2(m.Option(ice.MSG_USERWEB), "/share/proxy/"),
-			SPIDE_PART, m.OptionSimple(cli.POD), kit.MDB_PATH, p, CACHE, cache.Format(ice.MOD_TIME), UPLOAD, "@"+p)
+			SPIDE_PART, m.OptionSimple(ice.POD), kit.MDB_PATH, p, CACHE, cache.Format(ice.MOD_TIME), UPLOAD, "@"+p)
 
 		if s, e := os.Stat(pp); e == nil && !s.IsDir() {
 			p = pp
@@ -73,7 +73,7 @@ func _share_local(m *ice.Message, arg ...string) {
 	m.RenderDownload(p)
 }
 func _share_proxy(m *ice.Message, arg ...string) {
-	switch p := path.Join(ice.VAR_PROXY, m.Option(cli.POD), m.Option(kit.MDB_PATH)); m.R.Method {
+	switch p := path.Join(ice.VAR_PROXY, m.Option(ice.POD), m.Option(kit.MDB_PATH)); m.R.Method {
 	case http.MethodGet: // 下发文件
 		m.RenderDownload(path.Join(p, m.Option(kit.MDB_NAME)))
 
@@ -111,7 +111,7 @@ func init() {
 				ice.AddRender(ice.RENDER_DOWNLOAD, func(m *ice.Message, cmd string, args ...interface{}) string {
 					list := []string{}
 					if m.Option(ice.MSG_USERPOD) != "" {
-						list = append(list, cli.POD, m.Option(ice.MSG_USERPOD))
+						list = append(list, ice.POD, m.Option(ice.MSG_USERPOD))
 					}
 
 					arg := kit.Simple(args...)

base/web/space.go

@@ -205,11 +205,11 @@ func _space_search(m *ice.Message, kind, name, text string, arg ...string) {
 		case CHROME:
 
 		case MASTER:
-			m.PushSearch(cli.CMD, SPACE, kit.MDB_TYPE, value[kit.MDB_TYPE], kit.MDB_NAME, value[kit.MDB_NAME],
+			m.PushSearch(ice.CMD, SPACE, kit.MDB_TYPE, value[kit.MDB_TYPE], kit.MDB_NAME, value[kit.MDB_NAME],
 				kit.MDB_TEXT, m.Cmd(SPIDE, value[kit.MDB_NAME], ice.OptionFields("client.url")).Append("client.url"), value)
 
 		default:
-			m.PushSearch(cli.CMD, SPACE, kit.MDB_TYPE, value[kit.MDB_TYPE], kit.MDB_NAME, value[kit.MDB_NAME],
+			m.PushSearch(ice.CMD, SPACE, kit.MDB_TYPE, value[kit.MDB_TYPE], kit.MDB_NAME, value[kit.MDB_NAME],
 				kit.MDB_TEXT, _space_link(m, kit.Keys(m.Option(ice.MSG_USERPOD), value[kit.MDB_NAME])), value)
 		}
 	})
@@ -220,7 +220,7 @@ func _space_search(m *ice.Message, kind, name, text string, arg ...string) {
 			return
 		}
 		m.Cmd(tcp.HOST).Table(func(index int, value map[string]string, head []string) {
-			m.PushSearch(cli.CMD, SPACE, kit.MDB_TYPE, MYSELF, kit.MDB_NAME, value[kit.MDB_NAME],
+			m.PushSearch(ice.CMD, SPACE, kit.MDB_TYPE, MYSELF, kit.MDB_NAME, value[kit.MDB_NAME],
 				kit.MDB_TEXT, kit.Format("http://%s:%s", value[tcp.IP], port))
 		})
 	}

conf.go

@@ -25,7 +25,10 @@ const (
 	DEV = "dev"
 	OPS = "ops"
 	ICE = "ice"
+
 	RUN = "run"
+	RES = "res"
+	ERR = "err"
 
 	POD = "pod"
 	CTX = "ctx"

core/chat/action.go

@@ -6,7 +6,6 @@ import (
 
 	ice "shylinux.com/x/icebergs"
 	"shylinux.com/x/icebergs/base/aaa"
-	"shylinux.com/x/icebergs/base/cli"
 	"shylinux.com/x/icebergs/base/ctx"
 	"shylinux.com/x/icebergs/base/mdb"
 	"shylinux.com/x/icebergs/base/web"
@@ -59,7 +58,7 @@ func _action_right(m *ice.Message, river string, storm string) (ok bool) {
 func _action_list(m *ice.Message, river, storm string) {
 	m.Option(ice.MSG_RIVER, river)
 	m.Cmdy(TOOL, storm).Table(func(index int, value map[string]string, head []string) {
-		m.Cmdy(m.Space(kit.Select(m.Option(cli.POD), value[cli.POD])), ctx.COMMAND, kit.Keys(value[cli.CTX], value[cli.CMD]))
+		m.Cmdy(m.Space(kit.Select(m.Option(ice.POD), value[ice.POD])), ctx.COMMAND, kit.Keys(value[ice.CTX], value[ice.CMD]))
 	})
 	m.SortInt(kit.MDB_ID)
 }
@@ -70,8 +69,8 @@ func _action_show(m *ice.Message, river, storm, index string, arg ...string) {
 	cmds := []string{index}
 	prefix := kit.Keys(kit.MDB_HASH, river, TOOL, kit.MDB_HASH, storm)
 	if m.Grows(RIVER, prefix, kit.MDB_ID, index, func(index int, value map[string]interface{}) {
-		if cmds = kit.Simple(kit.Keys(value[cli.CTX], value[cli.CMD])); kit.Format(value[cli.POD]) != "" {
+		if cmds = kit.Simple(kit.Keys(value[ice.CTX], value[ice.CMD])); kit.Format(value[ice.POD]) != "" {
-			m.Option(cli.POD, value[cli.POD]) // 远程节点
+			m.Option(ice.POD, value[ice.POD]) // 远程节点
 		}
 	}) == nil && m.Warn(!m.Right(cmds), ice.ErrNotRight) {
 		return // 没有授权

core/chat/cmd.go

@@ -5,7 +5,6 @@ import (
 	"strings"
 
 	ice "shylinux.com/x/icebergs"
-	"shylinux.com/x/icebergs/base/cli"
 	"shylinux.com/x/icebergs/base/ctx"
 	"shylinux.com/x/icebergs/base/nfs"
 	"shylinux.com/x/icebergs/base/web"
@@ -31,7 +30,7 @@ func init() {
 					}
 					m.Cmdy(ctx.COMMAND, arg[0])
 				}},
-				cli.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
+				ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
 					m.Cmdy(arg)
 				}},
 			}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
@@ -52,7 +51,7 @@ func init() {
 				case "go", "mod", "sum":
 					_cmd_render(m, "web.code.inner", path.Dir(p)+"/", path.Base(p))
 				default:
-					if m.Option(cli.POD) != "" {
+					if m.Option(ice.POD) != "" {
 						if m.PodCmd(ctx.COMMAND, arg[0]); m.Append("meta") != "" {
 							_cmd_render(m, arg[0], arg[1:])
 							return // 远程命令

core/chat/files.go

@@ -2,7 +2,6 @@ package chat
 
 import (
 	ice "shylinux.com/x/icebergs"
-	"shylinux.com/x/icebergs/base/cli"
 	"shylinux.com/x/icebergs/base/mdb"
 	"shylinux.com/x/icebergs/base/web"
 	kit "shylinux.com/x/toolkits"
@@ -27,7 +26,7 @@ func init() {
 				m.Fields(len(arg), m.Conf(FILES, kit.META_FIELD))
 				m.Cmdy(mdb.SELECT, m.Prefix(FILES), "", mdb.HASH, kit.MDB_HASH, arg)
 				m.Table(func(index int, value map[string]string, head []string) {
-					link := kit.MergeURL("/share/cache/"+value[kit.MDB_DATA], cli.POD, m.Option(ice.MSG_USERPOD))
+					link := kit.MergeURL("/share/cache/"+value[kit.MDB_DATA], ice.POD, m.Option(ice.MSG_USERPOD))
 					if m.PushDownload(kit.MDB_LINK, value[kit.MDB_NAME], link); len(arg) > 0 && kit.ExtIsImage(value[kit.MDB_NAME]) {
 						m.PushImages(kit.MDB_IMAGE, link)
 					}

core/chat/footer.go

@@ -2,7 +2,6 @@ package chat
 
 import (
 	ice "shylinux.com/x/icebergs"
-	"shylinux.com/x/icebergs/base/cli"
 	"shylinux.com/x/icebergs/base/ctx"
 	kit "shylinux.com/x/toolkits"
 )
@@ -24,7 +23,7 @@ func init() {
 				ctx.COMMAND: {Name: "command", Help: "命令", Hand: func(m *ice.Message, arg ...string) {
 					m.Cmdy(ctx.COMMAND, arg)
 				}},
-				cli.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
+				ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
 					m.Cmdy(arg)
 				}},
 			}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {

core/chat/node.go

@@ -3,7 +3,6 @@ package chat
 import (
 	ice "shylinux.com/x/icebergs"
 	"shylinux.com/x/icebergs/base/aaa"
-	"shylinux.com/x/icebergs/base/cli"
 	"shylinux.com/x/icebergs/base/mdb"
 	"shylinux.com/x/icebergs/base/web"
 	"shylinux.com/x/icebergs/core/code"
@@ -53,7 +52,7 @@ func init() {
 					m.Cmdy(mdb.SELECT, RIVER, kit.Keys(kit.MDB_HASH, m.Option(ice.MSG_RIVER), NODE), mdb.HASH)
 					m.Table(func(index int, value map[string]string, head []string) {
 						m.PushAnchor(value[kit.MDB_NAME], kit.MergeURL2(m.Option(ice.MSG_USERWEB),
-							"/chat/pod/"+kit.Keys(m.Option(cli.POD), value[kit.MDB_NAME])))
+							"/chat/pod/"+kit.Keys(m.Option(ice.POD), value[kit.MDB_NAME])))
 					})
 					m.RenameAppend("name", "pod")
 					m.PushAction(mdb.REMOVE)

core/chat/pod.go

@@ -4,7 +4,6 @@ import (
 	"path"
 
 	ice "shylinux.com/x/icebergs"
-	"shylinux.com/x/icebergs/base/cli"
 	"shylinux.com/x/icebergs/base/ctx"
 	"shylinux.com/x/icebergs/base/web"
 	kit "shylinux.com/x/toolkits"
@@ -26,7 +25,7 @@ func init() {
 						m.Cmdy(ctx.COMMAND, arg[0])
 					}
 				}},
-				cli.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
+				ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
 					if !m.PodCmd(arg) {
 						m.Cmdy(arg)
 					}

core/chat/river.go

@@ -148,7 +148,7 @@ func init() {
 
 						kit.Fetch(value, func(index int, value string) {
 							m.Search(value, func(p *ice.Context, s *ice.Context, key string, cmd *ice.Command) {
-								m.Cmd(TOOL, mdb.INSERT, kit.MDB_HASH, h, cli.CTX, s.Cap(ice.CTX_FOLLOW), cli.CMD, key, kit.MDB_HELP, cmd.Help)
+								m.Cmd(TOOL, mdb.INSERT, kit.MDB_HASH, h, ice.CTX, s.Cap(ice.CTX_FOLLOW), ice.CMD, key, kit.MDB_HELP, cmd.Help)
 							})
 						})
 					})
@@ -184,7 +184,7 @@ func init() {
 					m.Cmd(code.PUBLISH, mdb.CREATE, kit.MDB_FILE, ice.BIN_ICE_BIN)
 				}},
 				cli.START: {Name: "start name=hi repos template", Help: "启动", Hand: func(m *ice.Message, arg ...string) {
-					m.Cmdy(m.Space(m.Option(cli.POD)), web.DREAM, cli.START, arg)
+					m.Cmdy(m.Space(m.Option(ice.POD)), web.DREAM, cli.START, arg)
 				}},
 
 				SHARE: {Name: "share", Help: "共享", Hand: func(m *ice.Message, arg ...string) {

core/chat/search.go

@@ -2,7 +2,6 @@ package chat
 
 import (
 	ice "shylinux.com/x/icebergs"
-	"shylinux.com/x/icebergs/base/cli"
 	"shylinux.com/x/icebergs/base/ctx"
 	"shylinux.com/x/icebergs/base/mdb"
 	kit "shylinux.com/x/toolkits"
@@ -20,17 +19,17 @@ func init() {
 					if value = kit.GetMeta(value); arg[1] != "" && !kit.Contains(value[kit.MDB_NAME], arg[1]) {
 						return
 					}
-					m.PushSearch(cli.CMD, P_SEARCH, value)
+					m.PushSearch(ice.CMD, P_SEARCH, value)
 				})
 			}},
 			mdb.RENDER: {Name: "render", Help: "渲染", Hand: func(m *ice.Message, arg ...string) {
-				m.Cmdy(m.Space(m.Option(cli.POD)), mdb.RENDER, arg[1:])
+				m.Cmdy(m.Space(m.Option(ice.POD)), mdb.RENDER, arg[1:])
 			}},
 		}, ctx.CmdAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 			if kit.Contains(arg[1], ";") {
 				arg = kit.Split(arg[1], ";", ";", ";")
 			}
-			if m.Cmdy(m.Space(m.Option(cli.POD)), mdb.SEARCH, arg); arg[1] == "" {
+			if m.Cmdy(m.Space(m.Option(ice.POD)), mdb.SEARCH, arg); arg[1] == "" {
 				return
 			}
 			m.Cmd(mdb.INSERT, m.Prefix(P_SEARCH), "", mdb.HASH,

core/chat/tool.go

@@ -33,19 +33,19 @@ func init() {
 			mdb.EXPORT: {Name: "export", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
 				if m.Option(kit.MDB_ID) != "" {
 					msg := m.Cmd(TOOL, m.Option(kit.MDB_HASH), m.Option(kit.MDB_ID))
-					cmd := kit.Keys(msg.Append(cli.CTX), msg.Append(cli.CMD))
+					cmd := kit.Keys(msg.Append(ice.CTX), msg.Append(ice.CMD))
 
 					_action_domain(m, cmd, m.Option(kit.MDB_HASH))
-					m.Cmdy(m.Space(msg.Append(cli.POD)), cmd, mdb.EXPORT)
+					m.Cmdy(m.Space(msg.Append(ice.POD)), cmd, mdb.EXPORT)
 				}
 			}},
 			mdb.IMPORT: {Name: "import", Help: "导入", Hand: func(m *ice.Message, arg ...string) {
 				if m.Option(kit.MDB_ID) != "" {
 					msg := m.Cmd(TOOL, m.Option(kit.MDB_HASH), m.Option(kit.MDB_ID))
-					cmd := kit.Keys(msg.Append(cli.CTX), msg.Append(cli.CMD))
+					cmd := kit.Keys(msg.Append(ice.CTX), msg.Append(ice.CMD))
 
 					_action_domain(m, cmd, m.Option(kit.MDB_HASH))
-					m.Cmdy(m.Space(msg.Append(cli.POD)), cmd, mdb.IMPORT)
+					m.Cmdy(m.Space(msg.Append(ice.POD)), cmd, mdb.IMPORT)
 				}
 			}},
 			mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
@@ -69,12 +69,12 @@ func init() {
 
 			m.OptionFields("time,id,pod,ctx,cmd,arg,display,style")
 			msg := m.Cmd(mdb.SELECT, RIVER, _river_key(m, TOOL, kit.MDB_HASH, arg[0]), mdb.LIST, kit.MDB_ID, kit.Select("", arg, 1))
-			if len(msg.Appendv(cli.CMD)) == 0 && len(arg) > 1 {
+			if len(msg.Appendv(ice.CMD)) == 0 && len(arg) > 1 {
-				msg.Push(cli.CMD, arg[1])
+				msg.Push(ice.CMD, arg[1])
 			}
 
-			if len(arg) > 2 && arg[2] == cli.RUN {
+			if len(arg) > 2 && arg[2] == ice.RUN {
-				m.Cmdy(m.Space(msg.Append(cli.POD)), kit.Keys(msg.Append(cli.CTX), msg.Append(cli.CMD)), arg[3:])
+				m.Cmdy(m.Space(msg.Append(ice.POD)), kit.Keys(msg.Append(ice.CTX), msg.Append(ice.CMD)), arg[3:])
 				return // 执行命令
 			}
 
@@ -84,9 +84,9 @@ func init() {
 			}
 
 			// 命令插件
-			m.ProcessField(arg[0], arg[1], cli.RUN)
+			m.ProcessField(arg[0], arg[1], ice.RUN)
 			m.Table(func(index int, value map[string]string, head []string) {
-				m.Cmdy(m.Space(value[cli.POD]), ctx.CONTEXT, value[cli.CTX], ctx.COMMAND, value[cli.CMD])
+				m.Cmdy(m.Space(value[ice.POD]), ctx.CONTEXT, value[ice.CTX], ctx.COMMAND, value[ice.CMD])
 			})
 		}},
 	}})

core/code/bench.go

@@ -88,7 +88,7 @@ func init() {
 					m.Cmdy(mdb.DELETE, BENCH, "", mdb.HASH, m.OptionSimple(kit.MDB_ZONE))
 				}},
 
-				cli.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
+				ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
 					switch m.Option(kit.MDB_TYPE) {
 					case HTTP:
 						_bench_http(m, m.Option(kit.MDB_NAME), m.Option(kit.MDB_TEXT))
@@ -99,7 +99,7 @@ func init() {
 			}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 				m.Fields(len(arg), "time,zone,count", "time,id,type,name,text,nconn,nreqs")
 				m.Cmdy(mdb.SELECT, BENCH, "", mdb.ZONE, arg)
-				m.PushAction(kit.Select(mdb.REMOVE, cli.RUN, len(arg) > 0))
+				m.PushAction(kit.Select(mdb.REMOVE, ice.RUN, len(arg) > 0))
 			}},
 
 			"test": {Name: "test path func auto run case", Help: "测试用例", Action: map[string]*ice.Action{

core/code/c.go

@@ -78,7 +78,7 @@ func init() {
 				mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) {
 					m.Option(cli.CMD_DIR, arg[2])
 					name := strings.TrimSuffix(arg[1], path.Ext(arg[1])) + ".bin"
-					if msg := m.Cmd(cli.SYSTEM, "gcc", arg[1], "-o", name); msg.Append(cli.CMD_CODE) != "0" {
+					if msg := m.Cmd(cli.SYSTEM, "gcc", arg[1], "-o", name); !cli.IsSuccess(msg) {
 						m.Copy(msg)
 						return
 					}
@@ -110,7 +110,7 @@ func init() {
 					}
 					for _, i := range []string{"1", "2", "3", "8"} {
 						if text := _c_help(m, i, kit.Select(kit.MDB_MAIN, arg, 1)); text != "" {
-							m.PushSearch(cli.CMD, "c", kit.MDB_FILE, kit.Keys(arg[1], MAN+i), kit.MDB_LINE, 1, kit.MDB_TEXT, text)
+							m.PushSearch(ice.CMD, "c", kit.MDB_FILE, kit.Keys(arg[1], MAN+i), kit.MDB_LINE, 1, kit.MDB_TEXT, text)
 						}
 					}
 				}},

core/code/case.go

@@ -22,11 +22,11 @@ func init() {
 			}},
 			mdb.INSERT: {Name: "insert zone name=hi cmd=POST,GET api arg:textarea res:textarea", Help: "添加"},
 
-			cli.RUN: {Name: "run", Help: "运行", Hand: func(m *ice.Message, arg ...string) {
+			ice.RUN: {Name: "run", Help: "运行", Hand: func(m *ice.Message, arg ...string) {
 				m.Option(web.SPIDE_HEADER, web.ContentType, web.ContentJSON)
 				m.Echo(kit.Formats(kit.UnMarshal(m.Cmdx(web.SPIDE, m.Option(ice.DEV), web.SPIDE_RAW,
-					m.Option(cli.CMD), m.Option(cli.API), web.SPIDE_DATA, m.Option(cli.ARG)))))
+					m.Option(ice.CMD), m.Option(cli.API), web.SPIDE_DATA, m.Option(ice.ARG)))))
-				m.Info(`curl "` + m.Option(cli.API) + `" -H "Content-Type: application/json"` + ` -d '` + m.Option(cli.ARG) + `'`)
+				m.Info(`curl "` + m.Option(cli.API) + `" -H "Content-Type: application/json"` + ` -d '` + m.Option(ice.ARG) + `'`)
 				m.ProcessDisplay("/plugin/local/wiki/json.js")
 			}},
 			cli.CHECK: {Name: "check", Help: "检查", Hand: func(m *ice.Message, arg ...string) {
@@ -36,22 +36,22 @@ func init() {
 						m.Push(kit.MDB_TIME, m.Time())
 						m.Push(kit.MDB_ID, value[kit.MDB_ID])
 						if err := m.Cmdx(m.PrefixKey(), cli.CHECK, value); err == ice.OK {
-							m.Push(cli.ERR, cli.Color(m, cli.GREEN, err))
+							m.Push(ice.ERR, cli.Color(m, cli.GREEN, err))
 							success++
 						} else {
-							m.Push(cli.ERR, cli.Color(m, cli.RED, err))
+							m.Push(ice.ERR, cli.Color(m, cli.RED, err))
 						}
 						m.Push(cli.API, value[cli.API])
-						m.Push(cli.ARG, value[cli.ARG])
+						m.Push(ice.ARG, value[ice.ARG])
-						m.Push(cli.RES, value[cli.RES])
+						m.Push(ice.RES, value[ice.RES])
 					})
 					m.StatusTimeCount(ice.SUCCESS, success)
 					return
 				}
 
-				res := kit.UnMarshal(m.Cmdx(m.PrefixKey(), cli.RUN))
+				res := kit.UnMarshal(m.Cmdx(m.PrefixKey(), ice.RUN))
-				if m.Option(cli.RES) != "" {
+				if m.Option(ice.RES) != "" {
-					for k, v := range kit.KeyValue(nil, "", kit.UnMarshal(m.Option(cli.RES))) {
+					for k, v := range kit.KeyValue(nil, "", kit.UnMarshal(m.Option(ice.RES))) {
 						if v != kit.Value(res, k) {
 							m.Echo(kit.Formats(res))
 							return
@@ -75,7 +75,7 @@ func init() {
 				m.PushAction(mdb.INSERT, cli.CHECK, mdb.REMOVE)
 			} else {
 				m.Action(mdb.INSERT, cli.CHECK)
-				m.PushAction(cli.RUN, cli.CHECK)
+				m.PushAction(ice.RUN, cli.CHECK)
 			}
 			m.StatusTimeCount()
 		}},

core/code/compile.go

@@ -56,7 +56,7 @@ func init() {
 
 			// 执行编译
 			_autogen_version(m.Spawn())
-			m.Optionv(cli.CMD_ENV, kit.Simple(m.Confv(COMPILE, kit.Keym(cli.ENV)), "GOOS", goos, "GOARCH", arch))
+			m.Optionv(cli.CMD_ENV, kit.Simple(m.Confv(COMPILE, kit.Keym(cli.ENV)), cli.GOOS, goos, cli.GOARCH, arch))
 			if msg := m.Cmd(cli.SYSTEM, m.Confv(COMPILE, kit.Keym(GO)), "-o", file, main, ice.SRC_VERSION_GO, ice.SRC_BINPACK_GO); !cli.IsSuccess(msg) {
 				m.Copy(msg)
 				return

core/code/go.go

@@ -19,7 +19,7 @@ func _go_find(m *ice.Message, key string) {
 		if p == "" {
 			continue
 		}
-		m.PushSearch(cli.CMD, "find", kit.MDB_FILE, strings.TrimPrefix(p, "./"), kit.MDB_LINE, 1, kit.MDB_TEXT, "")
+		m.PushSearch(ice.CMD, "find", kit.MDB_FILE, strings.TrimPrefix(p, "./"), kit.MDB_LINE, 1, kit.MDB_TEXT, "")
 	}
 }
 func _go_tags(m *ice.Message, key string) {
@@ -49,7 +49,7 @@ func _go_tags(m *ice.Message, key string) {
 		bio := bufio.NewScanner(f)
 		for i := 1; bio.Scan(); i++ {
 			if i == line || bio.Text() == text {
-				m.PushSearch(cli.CMD, "tags", kit.MDB_FILE, strings.TrimPrefix(file, "./"), kit.MDB_LINE, kit.Format(i), kit.MDB_TEXT, bio.Text())
+				m.PushSearch(ice.CMD, "tags", kit.MDB_FILE, strings.TrimPrefix(file, "./"), kit.MDB_LINE, kit.Format(i), kit.MDB_TEXT, bio.Text())
 			}
 		}
 	}
@@ -57,14 +57,14 @@ func _go_tags(m *ice.Message, key string) {
 func _go_grep(m *ice.Message, key string) {
 	msg := m.Spawn()
 	msg.Split(m.Cmd(cli.SYSTEM, "grep", "--exclude-dir=.git", "--exclude=.[a-z]*", "-rn", key, ".").Append(cli.CMD_OUT), "file:line:text", ":", "\n")
-	msg.Table(func(index int, value map[string]string, head []string) { m.PushSearch(cli.CMD, "grep", value) })
+	msg.Table(func(index int, value map[string]string, head []string) { m.PushSearch(ice.CMD, "grep", value) })
 }
 func _go_help(m *ice.Message, key string) {
 	p := m.Cmd(cli.SYSTEM, "go", "doc", key).Append(cli.CMD_OUT)
 	if p == "" {
 		return
 	}
-	m.PushSearch(cli.CMD, "help", kit.MDB_FILE, key+".godoc", kit.MDB_LINE, 1, kit.MDB_TEXT, p)
+	m.PushSearch(ice.CMD, "help", kit.MDB_FILE, key+".godoc", kit.MDB_LINE, 1, kit.MDB_TEXT, p)
 }
 
 const GO = "go"

core/code/install.go

@@ -65,20 +65,20 @@ func _install_build(m *ice.Message, arg ...string) {
 	case func(string):
 		cb(p)
 	default:
-		if msg := m.Cmd(cli.SYSTEM, "./configure", "--prefix="+pp, arg[1:]); msg.Append(cli.CMD_CODE) != "0" {
+		if msg := m.Cmd(cli.SYSTEM, "./configure", "--prefix="+pp, arg[1:]); !cli.IsSuccess(msg) {
 			m.Echo(msg.Append(cli.CMD_ERR))
 			return
 		}
 	}
 
 	// 编译
-	if msg := m.Cmd(cli.SYSTEM, "make", "-j8"); msg.Append(cli.CMD_CODE) != "0" {
+	if msg := m.Cmd(cli.SYSTEM, "make", "-j8"); !cli.IsSuccess(msg) {
 		m.Echo(msg.Append(cli.CMD_ERR))
 		return
 	}
 
 	// 安装
-	if msg := m.Cmd(cli.SYSTEM, "make", "PREFIX="+pp, "install"); msg.Append(cli.CMD_CODE) != "0" {
+	if msg := m.Cmd(cli.SYSTEM, "make", "PREFIX="+pp, "install"); !cli.IsSuccess(msg) {
 		m.Echo(msg.Append(cli.CMD_ERR))
 		return
 	}
@@ -120,7 +120,7 @@ func _install_service(m *ice.Message, arg ...string) {
 
 	m.Fields(len(arg[1:]), "time,port,status,pid,cmd,dir")
 	m.Cmd(mdb.SELECT, cli.DAEMON, "", mdb.HASH).Table(func(index int, value map[string]string, head []string) {
-		if strings.Contains(value[cli.CMD], "bin/"+arg[0]) {
+		if strings.Contains(value[ice.CMD], "bin/"+arg[0]) {
 			m.Push("", value, kit.Split(m.Option(mdb.FIELDS)))
 		}
 	})

core/code/pprof.go

@@ -64,7 +64,7 @@ func init() {
 					}
 				}},
 
-				cli.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
+				ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
 					msg := m.Cmd(web.SPIDE, ice.DEV, web.SPIDE_CACHE, web.SPIDE_GET, m.Option(SERVICE), SECONDS, m.Option(SECONDS))
 
 					cmd := kit.Simple(m.Confv(PPROF, kit.Keym(PPROF)), "-text", m.Option(BINNARY), msg.Append(kit.MDB_FILE))
@@ -89,7 +89,7 @@ func init() {
 			}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 				m.Fields(len(arg), "time,zone,count,binnary,service,seconds", "time,id,text,file")
 				if m.Cmdy(mdb.SELECT, PPROF, "", mdb.ZONE, arg); len(arg) == 0 {
-					m.PushAction(cli.RUN, mdb.REMOVE)
+					m.PushAction(ice.RUN, mdb.REMOVE)
 					return
 				}
 

core/code/publish.go

@@ -137,7 +137,7 @@ func init() {
 			web.DREAM: {Name: "dream name=hi repos", Help: "启动", Hand: func(m *ice.Message, arg ...string) {
 				m.Cmdy(web.DREAM, tcp.START, arg)
 				m.Process(ice.PROCESS_OPEN, kit.MergeURL(m.Option(ice.MSG_USERWEB),
-					cli.POD, kit.Keys(m.Option(ice.MSG_USERPOD), m.Option(kit.MDB_NAME))))
+					ice.POD, kit.Keys(m.Option(ice.MSG_USERPOD), m.Option(kit.MDB_NAME))))
 			}},
 		}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 			m.Option(nfs.DIR_ROOT, m.Conf(PUBLISH, kit.META_PATH))

core/code/python.go

@@ -30,7 +30,7 @@ func init() {
 				cli.START: {Name: "start", Help: "启动", Hand: func(m *ice.Message, arg ...string) {
 					m.Cmdy(INSTALL, cli.START, m.Conf(PYTHON, kit.Keym(cli.SOURCE)), "bin/python3")
 				}},
-				cli.RUN: {Name: "run", Help: "运行", Hand: func(m *ice.Message, arg ...string) {
+				ice.RUN: {Name: "run", Help: "运行", Hand: func(m *ice.Message, arg ...string) {
 					m.Cmdy(cli.SYSTEM, m.Conf(PYTHON, kit.Keym(PYTHON)), arg)
 				}},
 				"pip": {Name: "pip", Help: "安装", Hand: func(m *ice.Message, arg ...string) {

core/code/upgrade.go

@@ -2,6 +2,7 @@ package code
 
 import (
 	"os"
+	"runtime"
 
 	ice "shylinux.com/x/icebergs"
 	"shylinux.com/x/icebergs/base/cli"
@@ -30,7 +31,7 @@ func init() {
 			UPGRADE: {Name: "upgrade item=system,source run:button", Help: "升级", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 				m.Grows(cmd, kit.Keys(kit.MDB_HASH, kit.Select(cli.SYSTEM, arg, 0)), "", "", func(index int, value map[string]interface{}) {
 					if value[kit.MDB_PATH] == ice.BIN_ICE_BIN { // 程序文件
-						value[kit.MDB_FILE] = kit.Keys("ice", m.Conf(cli.RUNTIME, "host.GOOS"), m.Conf(cli.RUNTIME, "host.GOARCH"))
+						value[kit.MDB_FILE] = kit.Keys("ice", runtime.GOOS, runtime.GOARCH)
 						m.Option("exit", ice.TRUE)
 					}
 

core/code/vimer.go

@@ -44,7 +44,7 @@ func init() {
 				)
 
 				_autogen_version(m)
-				if m.Cmdy(cli.SYSTEM, "go", "build", "-v", "-o", "bin/ice.bin", "src/main.go", "src/version.go"); m.Append(cli.CMD_CODE) == "0" {
+				if m.Cmdy(cli.SYSTEM, "go", "build", "-v", "-o", "bin/ice.bin", "src/main.go", "src/version.go"); cli.IsSuccess(m) {
 					m.Cmd("exit", "1")
 				}
 				m.ProcessInner()

core/mall/asset.go

@@ -134,7 +134,7 @@ func init() {
 				ctx.COMMAND: {Name: "command", Help: "命令", Hand: func(m *ice.Message, arg ...string) {
 					m.Cmdy(ctx.COMMAND, arg)
 				}},
-				cli.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
+				ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
 					m.Cmdy(arg)
 				}},
 			}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {

core/team/plan.go

@@ -4,7 +4,6 @@ import (
 	"time"
 
 	ice "shylinux.com/x/icebergs"
-	"shylinux.com/x/icebergs/base/cli"
 	"shylinux.com/x/icebergs/base/ctx"
 	"shylinux.com/x/icebergs/base/mdb"
 	kit "shylinux.com/x/toolkits"
@@ -52,7 +51,7 @@ func init() {
 					m.ProcessRefresh30ms()
 				}},
 				ctx.COMMAND: {Name: "command", Help: "命令"},
-				cli.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
+				ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
 					m.Cmdy(arg)
 				}},
 

core/team/task.go

@@ -90,11 +90,11 @@ func _task_search(m *ice.Message, kind, name, text string) {
 			return
 		}
 		if kind == TASK {
-			m.PushSearch(cli.CMD, TASK,
+			m.PushSearch(ice.CMD, TASK,
 				kit.MDB_ZONE, val[kit.MDB_ZONE], kit.MDB_ID, kit.Format(value[kit.MDB_ID]),
 				value)
 		} else {
-			m.PushSearch(cli.CMD, TASK,
+			m.PushSearch(ice.CMD, TASK,
 				kit.MDB_TYPE, val[kit.MDB_ZONE], kit.MDB_NAME, kit.Format(value[kit.MDB_ID]),
 				kit.MDB_TEXT, kit.Format("%v:%v", value[kit.MDB_NAME], value[kit.MDB_TEXT]),
 				value)

core/wiki/field.go

@@ -4,7 +4,6 @@ import (
 	"strings"
 
 	ice "shylinux.com/x/icebergs"
-	"shylinux.com/x/icebergs/base/cli"
 	kit "shylinux.com/x/toolkits"
 )
 
@@ -79,7 +78,7 @@ func init() {
 	Index.Merge(&ice.Context{
 		Commands: map[string]*ice.Command{
 			FIELD: {Name: "field [name] cmd", Help: "插件", Action: map[string]*ice.Action{
-				cli.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
+				ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
 					m.Cmdy(arg)
 				}},
 			}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {

core/wiki/json.go

@@ -4,7 +4,6 @@ import (
 	"encoding/json"
 
 	ice "shylinux.com/x/icebergs"
-	"shylinux.com/x/icebergs/base/cli"
 	"shylinux.com/x/icebergs/base/nfs"
 	kit "shylinux.com/x/toolkits"
 )
@@ -62,7 +61,7 @@ func init() {
 				nfs.SAVE: {Name: "save path text", Help: "保存", Hand: func(m *ice.Message, arg ...string) {
 					_wiki_save(m, JSON, arg[0], arg[1])
 				}},
-				cli.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
+				ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
 					var data interface{}
 					json.Unmarshal([]byte(m.Cmdx(arg)), &data)
 					m.Option("type", "json")

core/wiki/table.go

@@ -4,7 +4,6 @@ import (
 	"strings"
 
 	ice "shylinux.com/x/icebergs"
-	"shylinux.com/x/icebergs/base/cli"
 	kit "shylinux.com/x/toolkits"
 )
 
@@ -64,7 +63,7 @@ func init() {
 	Index.Merge(&ice.Context{
 		Commands: map[string]*ice.Command{
 			TABLE: {Name: "table `[item item\n]...`", Help: "表格", Action: map[string]*ice.Action{
-				cli.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
+				ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
 					_table_run(m, arg...)
 				}},
 			}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {

core/wiki/word.go

@@ -5,7 +5,6 @@ import (
 	"strings"
 
 	ice "shylinux.com/x/icebergs"
-	"shylinux.com/x/icebergs/base/cli"
 	"shylinux.com/x/icebergs/base/ctx"
 	"shylinux.com/x/icebergs/base/nfs"
 	"shylinux.com/x/icebergs/base/ssh"
@@ -68,7 +67,7 @@ func init() {
 		), Action: ice.MergeAction(map[string]*ice.Action{
 			"play": {Name: "play", Help: "演示"},
 			web.STORY: {Name: "story", Help: "运行", Hand: func(m *ice.Message, arg ...string) {
-				m.Cmdy(arg[0], ctx.ACTION, cli.RUN, arg[2:])
+				m.Cmdy(arg[0], ctx.ACTION, ice.RUN, arg[2:])
 			}},
 		}, ctx.CmdAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 			m.Option(nfs.DIR_REG, m.Conf(WORD, kit.Keym(kit.MDB_REGEXP)))
@@ -80,7 +79,7 @@ func init() {
 			ice.Display("/plugin/local/wiki/word.js", WORD),
 		), Action: ice.MergeAction(map[string]*ice.Action{
 			web.STORY: {Name: "story", Help: "运行", Hand: func(m *ice.Message, arg ...string) {
-				m.Cmdy(arg[0], ctx.ACTION, cli.RUN, arg[2:])
+				m.Cmdy(arg[0], ctx.ACTION, ice.RUN, arg[2:])
 			}},
 			ctx.COMMAND: {Name: "command", Help: "命令", Hand: func(m *ice.Message, arg ...string) {
 				m.Cmdy(ctx.COMMAND, "web.wiki.word")

misc/chrome/page.go

@@ -2,7 +2,6 @@ package chrome
 
 import (
 	ice "shylinux.com/x/icebergs"
-	"shylinux.com/x/icebergs/base/cli"
 	"shylinux.com/x/icebergs/base/ctx"
 	kit "shylinux.com/x/toolkits"
 )
@@ -25,7 +24,7 @@ func init() {
 			FIELD: {Name: "field", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
 				m.Cmdy(FIELD, arg)
 			}},
-			cli.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
+			ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
 				m.Cmdy(arg)
 			}},
 		}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {

misc/git/status.go

@@ -21,7 +21,7 @@ func _status_each(m *ice.Message, title string, cmds ...string) {
 		m.Cmd(REPOS, ice.OptionFields("name,path")).Table(func(index int, value map[string]string, head []string) {
 			toast(value[kit.MDB_NAME], count, total)
 
-			if msg := m.Cmd(cmds, ice.Option{cli.CMD_DIR, value[kit.MDB_PATH]}); msg.Append(cli.CMD_CODE) != "0" {
+			if msg := m.Cmd(cmds, ice.Option{cli.CMD_DIR, value[kit.MDB_PATH]}); !cli.IsSuccess(msg) {
 				m.Toast(msg.Append(cli.CMD_ERR), "error: "+value[kit.MDB_NAME], "3s")
 				list = append(list, value[kit.MDB_NAME])
 				m.Sleep("3s")
@@ -57,6 +57,9 @@ func _status_list(m *ice.Message) (files, adds, dels int, last time.Time) {
 		tags := m.Cmdx(cli.SYSTEM, GIT, "describe", "--tags")
 
 		for _, v := range strings.Split(strings.TrimSpace(diff), ice.NL) {
+			if v == "" {
+				continue
+			}
 			vs := strings.SplitN(strings.TrimSpace(v), ice.SP, 2)
 			switch kit.Ext(vs[1]) {
 			case "swp", "swo", "bin":

misc/lark/home.go

@@ -2,7 +2,6 @@ package lark
 
 import (
 	ice "shylinux.com/x/icebergs"
-	"shylinux.com/x/icebergs/base/cli"
 	"shylinux.com/x/icebergs/base/web"
 	"shylinux.com/x/icebergs/core/chat"
 	kit "shylinux.com/x/toolkits"
@@ -24,7 +23,7 @@ func init() {
 				m.Cmd("web.chat./river").Table(func(index int, val map[string]string, head []string) {
 					m.Cmd("web.chat./river", val[kit.MDB_HASH], chat.TOOL).Table(func(index int, value map[string]string, head []string) {
 						list = append(list, kit.Keys(val[kit.MDB_NAME], value[kit.MDB_NAME]),
-							cli.CMD, kit.Format([]string{HOME, val[kit.MDB_HASH], value[kit.MDB_HASH], val[kit.MDB_NAME] + "." + value[kit.MDB_NAME]}))
+							ice.CMD, kit.Format([]string{HOME, val[kit.MDB_HASH], value[kit.MDB_HASH], val[kit.MDB_NAME] + "." + value[kit.MDB_NAME]}))
 					})
 				})
 			} else {
@@ -32,7 +31,7 @@ func init() {
 				m.Option(ice.MSG_STORM, arg[1])
 				link = kit.MergeURL(link, chat.RIVER, arg[0], chat.STORM, arg[1])
 				m.Cmd("web.chat./river", arg[0], chat.TOOL, arg[1]).Table(func(index int, value map[string]string, head []string) {
-					list = append(list, value[cli.CMD], cli.CMD, kit.Keys(value[cli.CTX], value[cli.CMD]))
+					list = append(list, value[ice.CMD], ice.CMD, kit.Keys(value[ice.CTX], value[ice.CMD]))
 				})
 			}
 			m.Cmd(FORM, CHAT_ID, m.Option(OPEN_CHAT_ID), name, text, "打开网页", "url", link, list)

misc/lark/msg.go

@@ -6,7 +6,6 @@ import (
 	"strings"
 
 	ice "shylinux.com/x/icebergs"
-	"shylinux.com/x/icebergs/base/cli"
 	"shylinux.com/x/icebergs/base/web"
 	"shylinux.com/x/icebergs/core/wiki"
 	kit "shylinux.com/x/toolkits"
@@ -89,9 +88,9 @@ func init() {
 			"card": {Name: "", Help: "", Hand: func(m *ice.Message, arg ...string) {
 				data := m.Optionv(ice.MSG_USERDATA)
 				kit.Fetch(kit.Value(data, "action.value"), func(key string, value string) { m.Option(key, value) })
-				m.Cmdy(TALK, kit.Parse(nil, "", kit.Split(m.Option(cli.CMD))...))
+				m.Cmdy(TALK, kit.Parse(nil, "", kit.Split(m.Option(ice.CMD))...))
 				m.Cmd(SEND, m.Option(APP_ID), CHAT_ID, m.Option(OPEN_CHAT_ID),
-					m.Option(wiki.TITLE)+" "+m.Option(cli.CMD), m.Result())
+					m.Option(wiki.TITLE)+" "+m.Option(ice.CMD), m.Result())
 			}},
 		}, Hand: func(m *ice.Message, c *ice.Context, key string, arg ...string) {
 			if m.Options(OPEN_CHAT_ID) {

misc/trash/docker/docker.go

@@ -175,7 +175,7 @@ var Index = &ice.Context{Name: DOCKER, Help: "虚拟机",
 		}},
 		gdb.AUTO: {Name: "auto", Help: "自动化", Action: map[string]*ice.Action{
 			web.DREAM_START: {Hand: func(m *ice.Message, arg ...string) {
-				if m.Cmd(_container, "start", arg[0]).Append(cli.CMD_CODE) == "0" {
+				if cli.IsSuccess(m.Cmd(_container, "start", arg[0])) {
 					// 重启容器
 					return
 				}