opt code

core/chat/header.go

@@ -88,7 +88,7 @@ func init() {
 			switch arg[0] {
 			case "/header":
 				switch kit.Select("", arg, 1) {
-				case AGENT, CHECK:
+				case AGENT, CHECK, aaa.LOGIN:
 					return // 非登录态
 				}
 			}

core/chat/river.go

@@ -109,6 +109,7 @@ func init() {
 				return // 没有授权
 			}
 
+			m.Debug("what %v-------", arg)
 			switch kit.Select("", arg, 1) {
 			case STORM, OCEAN, NODE:
 				m.Option(ice.MSG_RIVER, arg[0])

core/code/autogen.go

@@ -21,16 +21,6 @@ func _defs(m *ice.Message, args ...string) {
 		}
 	}
 }
-func _autogen_script(m *ice.Message, dir string) {
-	buf, _ := kit.Render(`chapter "{{.Option "name"}}"
-
-field "{{.Option "help"}}" {{.Option "key"}}
-`, m)
-	m.Cmd(nfs.DEFS, dir, string(buf))
-}
-func _autogen_source(m *ice.Message, zone, name string) {
-	m.Cmd(nfs.PUSH, ice.SRC_MAIN_SHY, "\n", kit.SSH_SOURCE+` `+path.Join(zone, kit.Keys(name, SHY)), "\n")
-}
 func _autogen_module(m *ice.Message, dir string) {
 	buf, _ := kit.Render(`package {{.Option "zone"}}
 
@@ -74,9 +64,19 @@ func main() { print(ice.Run()) }
 		}
 	})
 
-	m.Cmd(nfs.SAVE, main, strings.Join(list, ice.NL))
+	m.Cmd(nfs.SAVE, main, kit.Join(list, ice.NL))
 	return
 }
+func _autogen_script(m *ice.Message, dir string) {
+	buf, _ := kit.Render(`chapter "{{.Option "name"}}"
+
+field "{{.Option "help"}}" {{.Option "key"}}
+`, m)
+	m.Cmd(nfs.DEFS, dir, string(buf))
+}
+func _autogen_source(m *ice.Message, zone, name string) {
+	m.Cmd(nfs.PUSH, ice.SRC_MAIN_SHY, ice.NL, kit.SSH_SOURCE+ice.SP+path.Join(zone, kit.Keys(name, SHY)), ice.NL)
+}
 func _autogen_mod(m *ice.Message, file string) (mod string) {
 	m.Cmd(nfs.DEFS, ice.GO_MOD, kit.Format(`module %s
 
@@ -85,7 +85,7 @@ go 1.11
 
 	m.Cmd(nfs.CAT, file, func(line string, index int) {
 		if strings.HasPrefix(line, "module") {
-			mod = strings.Split(line, " ")[1]
+			mod = kit.Split(line, ice.SP)[1]
 			m.Logs("module", mod)
 		}
 	})
@@ -127,17 +127,17 @@ func init() {
 		ice.Info.HostName, ice.Info.UserName,
 	))
 
-	m.Cmdy(nfs.DIR, ice.SRC_BINPACK_GO, "time,size,line,path")
+	m.Cmdy(nfs.DIR, ice.SRC_BINPACK_GO)
-	m.Cmdy(nfs.DIR, ice.SRC_VERSION_GO, "time,size,line,path")
+	m.Cmdy(nfs.DIR, ice.SRC_VERSION_GO)
-	m.Cmdy(nfs.DIR, ice.SRC_MAIN_GO, "time,size,line,path")
+	m.Cmdy(nfs.DIR, ice.SRC_MAIN_GO)
 }
 func _autogen_miss(m *ice.Message) {
 	m.Cmd(nfs.DEFS, ice.ETC_MISS_SH, m.Conf(web.DREAM, kit.Keym("miss")))
 	defer m.Cmdy(nfs.CAT, ice.ETC_MISS_SH)
 
-	m.Cmdy(nfs.DIR, ice.ETC_MISS_SH, "time,size,line,path")
+	m.Cmdy(nfs.DIR, ice.ETC_MISS_SH)
-	m.Cmdy(nfs.DIR, ice.GO_MOD, "time,size,line,path")
+	m.Cmdy(nfs.DIR, ice.GO_MOD)
-	m.Cmdy(nfs.DIR, ice.GO_SUM, "time,size,line,path")
+	m.Cmdy(nfs.DIR, ice.GO_SUM)
 }
 
 const AUTOGEN = "autogen"
@@ -145,10 +145,17 @@ const AUTOGEN = "autogen"
 func init() {
 	Index.Merge(&ice.Context{Commands: map[string]*ice.Command{
 		AUTOGEN: {Name: "autogen path auto create binpack script", Help: "生成", Action: map[string]*ice.Action{
+			mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
+				switch arg[0] {
+				case kit.MDB_MAIN:
+					m.Cmdy(nfs.DIR, ice.SRC, "path,size,time", ice.Option{nfs.DIR_REG, `.*\.go`})
+					m.RenameAppend(kit.MDB_PATH, arg[0])
+				}
+			}},
 			mdb.CREATE: {Name: "create main=src/main.go@key key zone type=Zone,Hash,Data name=hi list help", Help: "模块", Hand: func(m *ice.Message, arg ...string) {
-				_defs(m, "zone", m.Option("name"), "help", m.Option("name"))
+				_defs(m, kit.MDB_ZONE, m.Option(kit.MDB_NAME), kit.MDB_HELP, m.Option(kit.MDB_NAME))
-				_defs(m, "key", kit.Keys("web.code", m.Option("zone"), m.Option("name")))
+				_defs(m, kit.MDB_KEY, kit.Keys("web.code", m.Option(kit.MDB_ZONE), m.Option(kit.MDB_NAME)))
-				switch m.Option("type") {
+				switch m.Option(kit.MDB_TYPE) {
 				case "Zone":
 					_defs(m, "list", "list zone id auto insert")
 				case "Hash":
@@ -158,34 +165,26 @@ func init() {
 				}
 				m.Option("tag", kit.Format("`name:\"%s\" help:\"%s\"`", m.Option("list"), m.Option("help")))
 
-				if p := path.Join(ice.SRC, m.Option(kit.MDB_ZONE), kit.Keys(m.Option(kit.MDB_NAME), SHY)); !kit.FileExists(p) {
-					_autogen_script(m, p)
-					_autogen_source(m, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_NAME))
-				}
-
 				if p := path.Join(ice.SRC, m.Option(kit.MDB_ZONE), kit.Keys(m.Option(kit.MDB_NAME), GO)); !kit.FileExists(p) {
 					_autogen_module(m, p)
 					_autogen_import(m, m.Option(kit.MDB_MAIN), m.Option(kit.MDB_ZONE), _autogen_mod(m, ice.GO_MOD))
 				}
-			}},
+
-			mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
+				if p := path.Join(ice.SRC, m.Option(kit.MDB_ZONE), kit.Keys(m.Option(kit.MDB_NAME), SHY)); !kit.FileExists(p) {
-				switch arg[0] {
+					_autogen_script(m, p)
-				case kit.MDB_MAIN:
+					_autogen_source(m, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_NAME))
-					m.Option(nfs.DIR_REG, `.*\.go`)
-					m.Cmdy(nfs.DIR, ice.SRC, "path,size,time")
-					m.RenameAppend(kit.MDB_PATH, arg[0])
 				}
 			}},
+			ssh.SCRIPT: {Name: "script", Help: "脚本：生成 etc/miss.sh", Hand: func(m *ice.Message, arg ...string) {
+				_autogen_miss(m)
+			}},
 			BINPACK: {Name: "binpack", Help: "打包：生成 src/binpack.go", Hand: func(m *ice.Message, arg ...string) {
 				_autogen_version(m)
 				m.Cmd(BINPACK, mdb.CREATE)
 				m.Cmd(cli.SYSTEM, "sh", "-c", `cat src/binpack.go|sed 's/package main/package ice/g' > usr/release/binpack.go`)
 			}},
-			ssh.SCRIPT: {Name: "script", Help: "脚本：生成 etc/miss.sh", Hand: func(m *ice.Message, arg ...string) {
-				_autogen_miss(m)
-			}},
 		}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-			if m.Option(nfs.DIR_ROOT, ice.SRC); len(arg) == 0 || strings.HasSuffix(arg[0], "/") {
+			if m.Option(nfs.DIR_ROOT, ice.SRC); len(arg) == 0 || strings.HasSuffix(arg[0], ice.PS) {
 				m.Cmdy(nfs.DIR, kit.Select("./", arg, 0))
 			} else {
 				m.Cmdy(nfs.CAT, arg[0])

core/code/bench.go

@@ -5,14 +5,11 @@ import (
 	"io/ioutil"
 	"net/http"
 	"os"
-	"path"
 	"strings"
 	"sync/atomic"
 
 	ice "shylinux.com/x/icebergs"
-	"shylinux.com/x/icebergs/base/cli"
 	"shylinux.com/x/icebergs/base/mdb"
-	"shylinux.com/x/icebergs/base/nfs"
 	kit "shylinux.com/x/toolkits"
 	"shylinux.com/x/toolkits/util/bench"
 )
@@ -23,7 +20,7 @@ func _bench_http(m *ice.Message, name, target string, arg ...string) {
 	m.Echo("nconn: %d nreqs: %d\n", nconn, nreqs*nconn)
 
 	list := []*http.Request{}
-	for _, v := range strings.Split(target, ",") {
+	for _, v := range strings.Split(target, ice.SP) {
 		switch ls := kit.Split(v); ls[0] {
 		case http.MethodPost:
 			if f, e := os.Open(ls[2]); m.Assert(e) {
@@ -65,90 +62,27 @@ const (
 const BENCH = "bench"
 
 func init() {
-	Index.Merge(&ice.Context{
+	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
-		Configs: map[string]*ice.Config{
+		BENCH: {Name: BENCH, Help: "性能压测", Value: kit.Data(
-			BENCH: {Name: BENCH, Help: "性能压测", Value: kit.Data(kit.MDB_SHORT, kit.MDB_ZONE)},
+			kit.MDB_SHORT, kit.MDB_ZONE, kit.MDB_FIELD, "time,id,type,name,text,nconn,nreqs",
-		},
+		)},
-		Commands: map[string]*ice.Command{
+	}, Commands: map[string]*ice.Command{
-			"/bench": {Name: "/bench cmd...", Help: "性能压测", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+		"/bench": {Name: "/bench cmd...", Help: "性能压测", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-				m.Cmdy(m.Optionv("cmd"))
+			m.Cmdy(m.Optionv("cmd"))
-			}},
+		}},
-			BENCH: {Name: "bench zone id auto insert", Help: "性能压测", Action: map[string]*ice.Action{
+		BENCH: {Name: "bench zone id auto insert", Help: "性能压测", Action: ice.MergeAction(map[string]*ice.Action{
-				mdb.CREATE: {Name: "create zone", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
+			mdb.INSERT: {Name: "insert zone=some type=http,redis name=demo text nconn=3 nreqs=10", Help: "添加"},
-					m.Cmdy(mdb.INSERT, BENCH, "", mdb.HASH, arg)
+			ice.RUN: {Name: "run", Help: "执行", Hand: func(m *ice.Message, arg ...string) {
-				}},
+				switch m.Option(kit.MDB_TYPE) {
-				mdb.INSERT: {Name: "insert zone=some type=http,redis name=demo text nconn=3 nreqs=10", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
+				case HTTP:
-					m.Cmdy(mdb.INSERT, BENCH, "", mdb.HASH, kit.MDB_ZONE, arg[1])
+					_bench_http(m, m.Option(kit.MDB_NAME), m.Option(kit.MDB_TEXT))
-					m.Cmdy(mdb.INSERT, BENCH, "", mdb.ZONE, m.Option(kit.MDB_ZONE), arg[2:])
+				case REDIS:
-				}},
+					_bench_redis(m, m.Option(kit.MDB_NAME), m.Option(kit.MDB_TEXT))
-				mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
-					m.Cmdy(mdb.MODIFY, BENCH, "", mdb.ZONE, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID), arg)
-				}},
-				mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
-					m.Cmdy(mdb.DELETE, BENCH, "", mdb.HASH, m.OptionSimple(kit.MDB_ZONE))
-				}},
-
-				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))
-					case REDIS:
-						_bench_redis(m, m.Option(kit.MDB_NAME), m.Option(kit.MDB_TEXT))
-					}
-				}},
-			}, 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, ice.RUN, len(arg) > 0))
-			}},
-
-			"test": {Name: "test path func auto run case", Help: "测试用例", Action: map[string]*ice.Action{
-				"run": {Name: "run", Help: "运行", Hand: func(m *ice.Message, arg ...string) {
-					// cli.Follow(m, "run", func() {
-					m.Option(cli.CMD_DIR, kit.Select(path.Dir(arg[0]), arg[0], strings.HasSuffix(arg[0], "/")))
-					m.Cmdy(cli.SYSTEM, "go", "test", "./", "-v", "-run="+arg[1])
-					// })
-				}},
-				"case": {Name: "case", Help: "用例", Hand: func(m *ice.Message, arg ...string) {
-					msg := m.Spawn()
-					if strings.HasSuffix(arg[0], "/") {
-						msg.Option(cli.CMD_DIR, arg[0])
-						msg.Split(msg.Cmdx(cli.SYSTEM, "grep", "-r", "func Test.*(", "./"), "file:line", ":", "\n")
-						msg.Table(func(index int, value map[string]string, head []string) {
-							if strings.HasPrefix(strings.TrimSpace(value["line"]), "//") {
-								return
-							}
-							ls := kit.Split(value["line"], " (", " (", " (")
-							m.Push("file", value["file"])
-							m.Push("func", strings.TrimPrefix(ls[1], "Test"))
-						})
-					} else {
-						for _, line := range kit.Split(m.Cmdx(cli.SYSTEM, "grep", "^func Test.*(", arg[0]), "\n", "\n", "\n") {
-							ls := kit.Split(line, " (", " (", " (")
-							m.Push("func", strings.TrimPrefix(ls[1], "Test"))
-						}
-					}
-				}},
-			}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-				if len(arg) == 0 || arg[0] == "" {
-					m.Cmdy(nfs.DIR, "./")
-					return
 				}
-				if len(arg) == 1 {
-					if strings.HasSuffix(arg[0], "/") {
-						m.Cmdy(nfs.DIR, arg[0])
-					} else {
-						for _, line := range kit.Split(m.Cmdx(cli.SYSTEM, "grep", "^func Test.*(", arg[0]), "\n", "\n", "\n") {
-							ls := kit.Split(line, " (", " (", " (")
-							m.Push("func", strings.TrimPrefix(ls[1], "Test"))
-						}
-					}
-					return
-				}
-
-				m.Option(cli.CMD_DIR, kit.Select(path.Dir(arg[0]), arg[0], strings.HasSuffix(arg[0], "/")))
-				m.Cmdy(cli.SYSTEM, "go", "test", "./", "-v", "-run="+arg[1])
 			}},
-		},
+		}, mdb.ZoneAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-	})
+			mdb.ZoneSelect(m, arg...)
+			m.PushAction(kit.Select(mdb.REMOVE, ice.RUN, len(arg) > 0))
+		}},
+	}})
 }

core/code/binpack.go

@@ -2,6 +2,7 @@ package code
 
 import (
 	"fmt"
+	"io"
 	"io/ioutil"
 	"os"
 	"path"
@@ -13,11 +14,11 @@ import (
 	kit "shylinux.com/x/toolkits"
 )
 
-func _pack_write(o *os.File, arg ...string) {
+func _pack_write(o io.Writer, arg ...string) {
 	for _, v := range arg {
-		o.WriteString(v)
+		fmt.Fprint(o, v)
 	}
-	o.WriteString(ice.NL)
+	fmt.Fprintln(o)
 }
 func _pack_file(m *ice.Message, file string) string {
 	list := ""
@@ -29,7 +30,7 @@ func _pack_file(m *ice.Message, file string) string {
 		}
 	}
 
-	if list = strings.ReplaceAll(list, " ", ","); len(list) > 0 {
+	if list = strings.ReplaceAll(list, ice.SP, ","); len(list) > 0 {
 		return fmt.Sprintf(`[]byte{%v}`, list[1:len(list)-1])
 	}
 	return "[]byte{}"
@@ -43,7 +44,7 @@ func _pack_dir(m *ice.Message, pack *os.File, dir string) {
 		if path.Base(value[kit.MDB_PATH]) == "binpack.go" {
 			return
 		}
-		switch strings.Split(value[kit.MDB_PATH], "/")[0] {
+		switch strings.Split(value[kit.MDB_PATH], ice.PS)[0] {
 		case "pluged", "trash":
 			return
 		}
@@ -72,8 +73,8 @@ func _pack_volcanos(m *ice.Message, pack *os.File, dir string) {
 }
 func _pack_ctx(m *ice.Message, pack *os.File) {
 	_pack_dir(m, pack, ice.SRC_HELP)
-	_pack_dir(m, pack, "src")
+	_pack_dir(m, pack, ice.SRC)
-	pack.WriteString(ice.NL)
+	_pack_write(pack)
 }
 
 const BINPACK = "binpack"
@@ -84,27 +85,25 @@ func init() {
 			mdb.CREATE: {Name: "create", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
 				if pack, p, e := kit.Create(ice.SRC_BINPACK_GO); m.Assert(e) {
 					defer pack.Close()
+					defer m.Echo(p)
 
 					_pack_write(pack, `package main`)
-					_pack_write(pack, "")
+					_pack_write(pack)
 					_pack_write(pack, `import (`)
 					_pack_write(pack, `	ice "shylinux.com/x/icebergs"`)
 					_pack_write(pack, `)`)
-					_pack_write(pack, "")
+					_pack_write(pack)
 
 					_pack_write(pack, `func init() {`)
-					_pack_write(pack, `    ice.Info.Pack = map[string][]byte{`)
+					_pack_write(pack, `	ice.Info.Pack = map[string][]byte{`)
 
 					_pack_volcanos(m, pack, ice.USR_VOLCANOS)
 					_pack_dir(m, pack, ice.USR_LEARNING)
-					// _pack_dir(m, pack, ice.USR_ICEBERGS)
-					// _pack_dir(m, pack, ice.USR_TOOLKITS)
 					_pack_dir(m, pack, ice.USR_INTSHELL)
 					_pack_ctx(m, pack)
 
-					_pack_write(pack, `    }`)
+					_pack_write(pack, `	}`)
 					_pack_write(pack, `}`)
-					m.Echo(p)
 				}
 			}},
 			mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
@@ -112,7 +111,7 @@ func init() {
 			}},
 			mdb.EXPORT: {Name: "export", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
 				for key, value := range ice.Info.Pack {
-					if strings.HasPrefix(key, "/") {
+					if strings.HasPrefix(key, ice.PS) {
 						key = ice.USR_VOLCANOS + key
 					}
 					m.Warn(os.MkdirAll(path.Dir(key), ice.MOD_DIR), "mkdir", key)

core/code/c.go

@@ -8,13 +8,12 @@ import (
 	ice "shylinux.com/x/icebergs"
 	"shylinux.com/x/icebergs/base/cli"
 	"shylinux.com/x/icebergs/base/mdb"
-	"shylinux.com/x/icebergs/base/nfs"
 	kit "shylinux.com/x/toolkits"
 )
 
 func _c_tags(m *ice.Message, key string) {
-	if _, e := os.Stat(path.Join(m.Option(cli.CMD_DIR), ".tags")); e != nil {
+	if _, e := os.Stat(path.Join(m.Option(cli.CMD_DIR), _TAGS)); e != nil {
-		m.Cmd(cli.SYSTEM, "ctags", "-R", "-f", ".tags", "./")
+		m.Cmd(cli.SYSTEM, "ctags", "-R", "-f", _TAGS, "./")
 	}
 	_go_tags(m, key)
 }
@@ -40,156 +39,130 @@ func _c_help(m *ice.Message, section, key string) string {
 const (
 	H    = "h"
 	CC   = "cc"
+	MAN  = "man"
 	MAN1 = "man1"
 	MAN2 = "man2"
 	MAN3 = "man3"
 	MAN8 = "man8"
 )
-const (
-	FIND = "find"
-	GREP = "grep"
-	MAN  = "man"
-)
 const C = "c"
 
 func init() {
-	Index.Register(&ice.Context{Name: C, Help: "系统",
+	Index.Merge(&ice.Context{Name: C, Help: "系统", Commands: map[string]*ice.Command{
-		Commands: map[string]*ice.Command{
+		ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-			ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+			for _, cmd := range []string{mdb.PLUGIN, mdb.RENDER, mdb.ENGINE, mdb.SEARCH} {
 				for _, k := range []string{H, C, CC} {
-					for _, cmd := range []string{mdb.PLUGIN, mdb.RENDER, mdb.ENGINE, mdb.SEARCH} {
+					m.Cmd(cmd, mdb.CREATE, k, m.Prefix(C))
-						m.Cmd(cmd, mdb.CREATE, k, m.Prefix(C))
-					}
 				}
+			}
+			for _, cmd := range []string{mdb.PLUGIN, mdb.RENDER, mdb.SEARCH} {
 				for _, k := range []string{MAN1, MAN2, MAN3, MAN8} {
-					for _, cmd := range []string{mdb.PLUGIN, mdb.RENDER, mdb.SEARCH} {
+					m.Cmd(cmd, mdb.CREATE, k, m.Prefix(MAN))
-						m.Cmd(cmd, mdb.CREATE, k, m.Prefix(MAN))
+				}
+			}
+			LoadPlug(m, C)
+			LoadPlug(m, MAN)
+		}},
+		C: {Name: C, Help: "系统", Action: ice.MergeAction(map[string]*ice.Action{
+			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); !cli.IsSuccess(msg) {
+					m.Copy(msg)
+					return
+				}
+				m.Cmdy(cli.SYSTEM, "./"+name)
+			}},
+			mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
+				if arg[0] == kit.MDB_FOREACH {
+					return
+				}
+				m.Option(cli.CMD_DIR, kit.Select(ice.SRC, arg, 2))
+				m.Cmdy(mdb.SEARCH, MAN2, arg[1:])
+				m.Cmdy(mdb.SEARCH, MAN3, arg[1:])
+				_c_tags(m, kit.Select(kit.MDB_MAIN, arg, 1))
+				_go_find(m, kit.Select(kit.MDB_MAIN, arg, 1))
+				_go_grep(m, kit.Select(kit.MDB_MAIN, arg, 1))
+			}},
+		}, PlugAction())},
+		MAN: {Name: MAN, Help: "手册", Action: ice.MergeAction(map[string]*ice.Action{
+			mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) {
+				m.Echo(_c_help(m, strings.TrimPrefix(arg[0], MAN), strings.TrimSuffix(arg[1], ice.PT+arg[0])))
+			}},
+			mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
+				if arg[0] == kit.MDB_FOREACH {
+					return
+				}
+				for _, i := range []string{"1", "2", "3", "8"} {
+					if text := _c_help(m, i, kit.Select(kit.MDB_MAIN, arg, 1)); text != "" {
+						m.PushSearch(ice.CMD, MAN, kit.MDB_FILE, kit.Keys(arg[1], MAN+i), kit.MDB_LINE, 1, kit.MDB_TEXT, text)
 					}
 				}
-				LoadPlug(m, C)
 			}},
-			C: {Name: C, Help: "系统", Action: map[string]*ice.Action{
+		}, PlugAction())},
-				mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) {
+	}, Configs: map[string]*ice.Config{
-					m.Echo(m.Conf(C, kit.Keym(PLUG)))
+		C: {Name: C, Help: "系统", Value: kit.Data(PLUG, kit.Dict(
-				}},
+			SPLIT, kit.Dict("space", " ", "operator", "{[(.,:;!|<>)]}"),
-				mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) {
+			PREFIX, kit.Dict("//", COMMENT, "/*", COMMENT, "*", COMMENT),
-					m.Cmdy(nfs.CAT, path.Join(arg[2], arg[1]))
+			PREPARE, kit.Dict(
-				}},
+				KEYWORD, kit.Simple(
-				mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) {
+					"#include",
-					m.Option(cli.CMD_DIR, arg[2])
+					"#define",
-					name := strings.TrimSuffix(arg[1], path.Ext(arg[1])) + ".bin"
+					"#ifndef",
-					if msg := m.Cmd(cli.SYSTEM, "gcc", arg[1], "-o", name); !cli.IsSuccess(msg) {
+					"#ifdef",
-						m.Copy(msg)
+					"#else",
-						return
+					"#endif",
-					}
-					m.Cmdy(cli.SYSTEM, "./"+name)
-				}},
-				mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
-					if arg[0] == kit.MDB_FOREACH {
-						return
-					}
-					m.Option(cli.CMD_DIR, kit.Select("src", arg, 2))
-					_go_find(m, kit.Select(kit.MDB_MAIN, arg, 1))
-					m.Cmdy(mdb.SEARCH, MAN2, arg[1:])
-					m.Cmdy(mdb.SEARCH, MAN3, arg[1:])
-					_c_tags(m, kit.Select(kit.MDB_MAIN, arg, 1))
-					_go_grep(m, kit.Select(kit.MDB_MAIN, arg, 1))
-				}},
-			}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-			}},
-			MAN: {Name: MAN, Help: "手册", Action: map[string]*ice.Action{
-				mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) {
-					m.Echo(m.Conf(MAN, kit.Keym(PLUG)))
-				}},
-				mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) {
-					m.Echo(_c_help(m, strings.TrimPrefix(arg[0], MAN), strings.TrimSuffix(arg[1], "."+arg[0])))
-				}},
-				mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
-					if arg[0] == kit.MDB_FOREACH {
-						return
-					}
-					for _, i := range []string{"1", "2", "3", "8"} {
-						if text := _c_help(m, i, kit.Select(kit.MDB_MAIN, arg, 1)); text != "" {
-							m.PushSearch(ice.CMD, "c", kit.MDB_FILE, kit.Keys(arg[1], MAN+i), kit.MDB_LINE, 1, kit.MDB_TEXT, text)
-						}
-					}
-				}},
-			}},
-		},
-		Configs: map[string]*ice.Config{
-			C: {Name: C, Help: "系统", Value: kit.Data(
-				PLUG, kit.Dict(
-					SPLIT, kit.Dict(
-						"space", " ",
-						"operator", "{[(.,:;!|<>)]}",
-					),
-					PREFIX, kit.Dict(
-						"//", COMMENT,
-						"/*", COMMENT,
-						"*", COMMENT,
-					),
-					PREPARE, kit.Dict(
-						KEYWORD, kit.Simple(
-							"#include",
-							"#define",
-							"#ifndef",
-							"#ifdef",
-							"#else",
-							"#endif",
 
-							"if",
+					"if",
-							"else",
+					"else",
-							"for",
+					"for",
-							"while",
+					"while",
-							"do",
+					"do",
-							"break",
+					"break",
-							"continue",
+					"continue",
-							"switch",
+					"switch",
-							"case",
+					"case",
-							"default",
+					"default",
-							"return",
+					"return",
 
-							"typedef",
+					"typedef",
-							"sizeof",
+					"sizeof",
-							"extern",
+					"extern",
-							"static",
+					"static",
-							"const",
+					"const",
-						),
-						DATATYPE, kit.Simple(
-							"union",
-							"struct",
-							"unsigned",
-							"double",
-							"void",
-							"long",
-							"char",
-							"int",
-						),
-						FUNCTION, kit.Simple(
-							"assert",
-							"zmalloc",
-						),
-						CONSTANT, kit.Simple(
-							"NULL", "-1", "0", "1", "2",
-						),
-					),
-					KEYWORD, kit.Dict(),
 				),
-			)},
+				DATATYPE, kit.Simple(
-			MAN: {Name: MAN, Help: "手册", Value: kit.Data(
+					"union",
-				PLUG, kit.Dict(
+					"struct",
-					PREFIX, kit.Dict(
+					"unsigned",
-						"NAME", COMMENT,
+					"double",
-						"LIBRARY", COMMENT,
+					"void",
-						"SYNOPSIS", COMMENT,
+					"long",
-						"DESCRIPTION", COMMENT,
+					"char",
-						"STANDARDS", COMMENT,
+					"int",
-						"SEE ALSO", COMMENT,
-						"HISTORY", COMMENT,
-						"BUGS", COMMENT,
-					),
 				),
-			)},
+				FUNCTION, kit.Simple(
-		},
+					"assert",
-	}, nil)
+					"zmalloc",
+				),
+				CONSTANT, kit.Simple(
+					"NULL", "-1", "0", "1", "2",
+				),
+			), KEYWORD, kit.Dict(),
+		))},
+		MAN: {Name: MAN, Help: "手册", Value: kit.Data(PLUG, kit.Dict(
+			PREPARE, kit.Dict(
+				COMMENT, kit.Simple(
+					"NAME",
+					"LIBRARY",
+					"SYNOPSIS",
+					"DESCRIPTION",
+					"STANDARDS",
+					"SEE ALSO",
+					"HISTORY",
+					"BUGS",
+				),
+			), KEYWORD, kit.Dict(),
+		))},
+	}})
 }

core/code/case.go

@@ -1,9 +1,13 @@
 package code
 
 import (
+	"path"
+	"strings"
+
 	ice "shylinux.com/x/icebergs"
 	"shylinux.com/x/icebergs/base/cli"
 	"shylinux.com/x/icebergs/base/mdb"
+	"shylinux.com/x/icebergs/base/nfs"
 	"shylinux.com/x/icebergs/base/web"
 	kit "shylinux.com/x/toolkits"
 )
@@ -78,5 +82,52 @@ func init() {
 			}
 			m.StatusTimeCount()
 		}},
+		"test": {Name: "test path func auto run case", Help: "测试用例", Action: map[string]*ice.Action{
+			"run": {Name: "run", Help: "运行", Hand: func(m *ice.Message, arg ...string) {
+				// cli.Follow(m, "run", func() {
+				m.Option(cli.CMD_DIR, kit.Select(path.Dir(arg[0]), arg[0], strings.HasSuffix(arg[0], "/")))
+				m.Cmdy(cli.SYSTEM, "go", "test", "./", "-v", "-run="+arg[1])
+				// })
+			}},
+			"case": {Name: "case", Help: "用例", Hand: func(m *ice.Message, arg ...string) {
+				msg := m.Spawn()
+				if strings.HasSuffix(arg[0], "/") {
+					msg.Option(cli.CMD_DIR, arg[0])
+					msg.Split(msg.Cmdx(cli.SYSTEM, "grep", "-r", "func Test.*(", "./"), "file:line", ":", "\n")
+					msg.Table(func(index int, value map[string]string, head []string) {
+						if strings.HasPrefix(strings.TrimSpace(value["line"]), "//") {
+							return
+						}
+						ls := kit.Split(value["line"], " (", " (", " (")
+						m.Push("file", value["file"])
+						m.Push("func", strings.TrimPrefix(ls[1], "Test"))
+					})
+				} else {
+					for _, line := range kit.Split(m.Cmdx(cli.SYSTEM, "grep", "^func Test.*(", arg[0]), "\n", "\n", "\n") {
+						ls := kit.Split(line, " (", " (", " (")
+						m.Push("func", strings.TrimPrefix(ls[1], "Test"))
+					}
+				}
+			}},
+		}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+			if len(arg) == 0 || arg[0] == "" {
+				m.Cmdy(nfs.DIR, "./")
+				return
+			}
+			if len(arg) == 1 {
+				if strings.HasSuffix(arg[0], "/") {
+					m.Cmdy(nfs.DIR, arg[0])
+				} else {
+					for _, line := range kit.Split(m.Cmdx(cli.SYSTEM, "grep", "^func Test.*(", arg[0]), "\n", "\n", "\n") {
+						ls := kit.Split(line, " (", " (", " (")
+						m.Push("func", strings.TrimPrefix(ls[1], "Test"))
+					}
+				}
+				return
+			}
+
+			m.Option(cli.CMD_DIR, kit.Select(path.Dir(arg[0]), arg[0], strings.HasSuffix(arg[0], "/")))
+			m.Cmdy(cli.SYSTEM, "go", "test", "./", "-v", "-run="+arg[1])
+		}},
 	}})
 }

core/code/code.go

@@ -7,18 +7,11 @@ import (
 
 const CODE = "code"
 
-var Index = &ice.Context{Name: CODE, Help: "编程中心", Commands: map[string]*ice.Command{
+var Index = &ice.Context{Name: CODE, Help: "编程中心"}
-	ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-		m.Load()
-	}},
-	ice.CTX_EXIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-		m.Save()
-	}},
-}}
 
 func init() {
 	web.Index.Register(Index, &web.Frame{},
-		WEBPACK, BINPACK, AUTOGEN, COMPILE, UPGRADE, PUBLISH, INSTALL,
+		AUTOGEN, WEBPACK, BINPACK, COMPILE, PUBLISH, UPGRADE, INSTALL,
 		VIMER, INNER, FAVOR, BENCH, PPROF,
 		C, SH, SHY, GO, JS,
 	)

core/code/code.shy

@@ -20,3 +20,29 @@ field "脚本" web.code.shy
 field "后端" web.code.go
 field "前端" web.code.js
 
+code.go
+code.shy
+
+autogen.go
+webpack.go
+binpack.go
+compile.go
+publish.go
+upgrade.go
+install.go
+
+vimer.go
+inner.go
+favor.go
+bench.go
+pprof.go
+
+c.go
+sh.go
+shy.go
+go.go
+js.go
+
+python.go
+python.shy
+case.go

core/code/compile.go

@@ -31,7 +31,7 @@ func init() {
 			}},
 		}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 			if len(arg) == 0 {
-				m.Cmdy(nfs.DIR, m.Config(nfs.PATH), "time,size,path")
+				m.Cmdy(nfs.DIR, m.Config(nfs.PATH))
 				return
 			}
 
@@ -52,12 +52,12 @@ func init() {
 				}
 			}
 			file := path.Join(kit.Select("", m.Config(nfs.PATH), m.Option(cli.CMD_DIR) == ""),
-				kit.Keys(kit.Select(ice.ICE, kit.TrimExt(main, ".go"), main != ice.SRC_MAIN_GO), goos, arch))
+				kit.Keys(kit.Select(ice.ICE, kit.TrimExt(main), main != ice.SRC_MAIN_GO), goos, arch))
 
 			// 执行编译
 			_autogen_version(m.Spawn())
-			m.Optionv(cli.CMD_ENV, kit.Simple(m.Confv(COMPILE, kit.Keym(cli.ENV)), cli.GOOS, goos, cli.GOARCH, arch))
+			m.Optionv(cli.CMD_ENV, kit.Simple(m.Configv(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) {
+			if msg := m.Cmd(cli.SYSTEM, m.Configv(GO), "-o", file, main, ice.SRC_VERSION_GO, ice.SRC_BINPACK_GO); !cli.IsSuccess(msg) {
 				m.Copy(msg)
 				return
 			}
@@ -65,7 +65,7 @@ func init() {
 			// 编译成功
 			m.Log_EXPORT(cli.SOURCE, main, cli.TARGET, file)
 			m.Cmdy(nfs.DIR, file, "time,path,size,link,action")
-			m.Cmdy(PUBLISH, ice.CONTEXTS, "base")
+			m.Cmdy(PUBLISH, ice.CONTEXTS, ice.BASE)
 			m.StatusTimeCount()
 		}},
 	}})

core/code/favor.go

@@ -9,51 +9,19 @@ import (
 const FAVOR = "favor"
 
 func init() {
-	Index.Merge(&ice.Context{
+	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
-		Configs: map[string]*ice.Config{
+		FAVOR: {Name: FAVOR, Help: "收藏夹", Value: kit.Data(
-			FAVOR: {Name: FAVOR, Help: "收藏夹", Value: kit.Data(
+			kit.MDB_SHORT, kit.MDB_ZONE, kit.MDB_FIELD, "time,id,type,name,text,path,file,line",
-				kit.MDB_SHORT, kit.MDB_ZONE, kit.MDB_FIELD, "time,id,type,name,text,path,file,line",
+		)},
-			)},
+	}, Commands: map[string]*ice.Command{
-		},
+		FAVOR: {Name: "favor zone id auto insert", Help: "收藏夹", Action: ice.MergeAction(map[string]*ice.Action{
-		Commands: map[string]*ice.Command{
+			mdb.INSERT: {Name: "insert zone=数据结构 type=go name=hi text=hello path file line", Help: "添加"},
-			FAVOR: {Name: "favor zone id auto insert export import", Help: "收藏夹", Action: map[string]*ice.Action{
+			INNER: {Name: "inner", Help: "源码", Hand: func(m *ice.Message, arg ...string) {
-				mdb.CREATE: {Name: "create zone", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
+				m.ProcessCommand(INNER, m.OptionSplit("path,file,line"), arg...)
-					m.Cmdy(mdb.INSERT, m.Prefix(FAVOR), "", mdb.HASH, arg)
-				}},
-				mdb.INSERT: {Name: "insert zone=数据结构 type=go name=hi text=hello path file line", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
-					m.Cmdy(mdb.INSERT, m.Prefix(FAVOR), "", mdb.HASH, kit.MDB_ZONE, arg[1])
-					m.Cmdy(mdb.INSERT, m.Prefix(FAVOR), "", mdb.ZONE, m.Option(kit.MDB_ZONE), arg[2:])
-				}},
-				mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
-					m.Cmdy(mdb.MODIFY, m.Prefix(FAVOR), "", mdb.ZONE, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID), arg)
-				}},
-				mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
-					m.Cmdy(mdb.DELETE, m.Prefix(FAVOR), "", mdb.HASH, m.OptionSimple(kit.MDB_ZONE))
-				}},
-				mdb.EXPORT: {Name: "export", Help: "导出", Hand: func(m *ice.Message, arg ...string) {
-					m.OptionFields(kit.MDB_ZONE, m.Conf(FAVOR, kit.META_FIELD))
-					m.Cmdy(mdb.EXPORT, m.Prefix(FAVOR), "", mdb.ZONE)
-				}},
-				mdb.IMPORT: {Name: "import", Help: "导入", Hand: func(m *ice.Message, arg ...string) {
-					m.OptionFields(kit.MDB_ZONE)
-					m.Cmdy(mdb.IMPORT, m.Prefix(FAVOR), "", mdb.ZONE)
-				}},
-				mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
-					switch arg[0] {
-					case kit.MDB_ZONE:
-						m.Cmdy(mdb.INPUTS, m.Prefix(FAVOR), "", mdb.HASH, arg)
-					default:
-						m.Cmdy(mdb.INPUTS, m.Prefix(FAVOR), "", mdb.ZONE, m.Option(kit.MDB_ZONE), arg)
-					}
-				}},
-				INNER: {Name: "inner", Help: "源码", Hand: func(m *ice.Message, arg ...string) {
-					m.ProcessCommand(INNER, m.OptionSplit("path,file,line"), arg...)
-				}},
-			}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-				m.Fields(len(arg), "time,zone,count", m.Conf(FAVOR, kit.META_FIELD))
-				m.Cmdy(mdb.SELECT, m.Prefix(FAVOR), "", mdb.ZONE, arg)
-				m.PushAction(kit.Select(mdb.REMOVE, INNER, len(arg) > 0))
 			}},
-		},
+		}, mdb.ZoneAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-	})
+			mdb.ZoneSelect(m, arg...)
+			m.PushAction(kit.Select(mdb.REMOVE, INNER, len(arg) > 0))
+		}},
+	}})
 }

core/code/go.go

@@ -14,29 +14,21 @@ import (
 	kit "shylinux.com/x/toolkits"
 )
 
-func _go_find(m *ice.Message, key string) {
-	for _, p := range strings.Split(m.Cmdx(cli.SYSTEM, "find", ".", "-name", key), "\n") {
-		if p == "" {
-			continue
-		}
-		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) {
-	if s, e := os.Stat(path.Join(m.Option(cli.CMD_DIR), ".tags")); os.IsNotExist(e) || s.ModTime().Before(time.Now().Add(kit.Duration("-72h"))) {
+	if s, e := os.Stat(path.Join(m.Option(cli.CMD_DIR), _TAGS)); os.IsNotExist(e) || s.ModTime().Before(time.Now().Add(kit.Duration("-72h"))) {
-		m.Cmd(cli.SYSTEM, "gotags", "-R", "-f", ".tags", "./")
+		m.Cmd(cli.SYSTEM, "gotags", "-R", "-f", _TAGS, "./")
 	}
 
-	ls := strings.Split(key, ".")
+	ls := strings.Split(key, ice.PT)
 	key = ls[len(ls)-1]
 
-	for _, l := range strings.Split(m.Cmdx(cli.SYSTEM, "grep", "^"+key+"\\>", ".tags"), "\n") {
+	for _, l := range strings.Split(m.Cmdx(cli.SYSTEM, GREP, "^"+key+"\\>", _TAGS), ice.NL) {
-		ls := strings.SplitN(l, "\t", 2)
+		ls := strings.SplitN(l, ice.TB, 2)
 		if len(ls) < 2 {
 			continue
 		}
 
-		ls = strings.SplitN(ls[1], "\t", 2)
+		ls = strings.SplitN(ls[1], ice.TB, 2)
 		file := ls[0]
 		ls = strings.SplitN(ls[1], ";\"", 2)
 		text := strings.TrimSuffix(strings.TrimPrefix(ls[0], "/^"), "$/")
@@ -54,161 +46,128 @@ 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(ice.CMD, "grep", value) })
-}
 func _go_help(m *ice.Message, key string) {
-	p := m.Cmd(cli.SYSTEM, "go", "doc", key).Append(cli.CMD_OUT)
+	p := m.Cmd(cli.SYSTEM, GO, "doc", key).Append(cli.CMD_OUT)
 	if p == "" {
 		return
 	}
 	m.PushSearch(ice.CMD, "help", kit.MDB_FILE, key+".godoc", kit.MDB_LINE, 1, kit.MDB_TEXT, p)
 }
+func _go_find(m *ice.Message, key string) {
+	for _, p := range strings.Split(m.Cmdx(cli.SYSTEM, FIND, ".", "-name", key), ice.NL) {
+		if p == "" {
+			continue
+		}
+		m.PushSearch(ice.CMD, FIND, kit.MDB_FILE, strings.TrimPrefix(p, "./"), kit.MDB_LINE, 1, kit.MDB_TEXT, "")
+	}
+}
+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, ice.PT).Append(cli.CMD_OUT), "file:line:text", ":", ice.NL)
+	msg.Table(func(index int, value map[string]string, head []string) { m.PushSearch(ice.CMD, GREP, value) })
+}
 
+func PlugAction(fields ...string) map[string]*ice.Action {
+	return ice.SelectAction(map[string]*ice.Action{
+		mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) { m.Echo(m.Config(PLUG)) }},
+		mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) { m.Cmdy(nfs.CAT, path.Join(arg[2], arg[1])) }},
+	}, fields...)
+}
+
+const (
+	_TAGS = ".tags"
+	FIND  = "find"
+	GREP  = "grep"
+)
 const GO = "go"
-const DOC = "godoc"
 const MOD = "mod"
 const SUM = "sum"
 const PROTO = "proto"
+const GODOC = "godoc"
 
 func init() {
-	Index.Register(&ice.Context{Name: GO, Help: "后端",
+	Index.Register(&ice.Context{Name: GO, Help: "后端", Commands: map[string]*ice.Command{
-		Commands: map[string]*ice.Command{
+		ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-			ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+			m.Cmd(mdb.SEARCH, mdb.CREATE, GODOC, m.Prefix(GO))
-				m.Cmd(mdb.ENGINE, mdb.CREATE, GO, m.Prefix(GO))
+			m.Cmd(mdb.SEARCH, mdb.CREATE, GO, m.Prefix(GO))
-				m.Cmd(mdb.SEARCH, mdb.CREATE, GO, m.Prefix(GO))
+			m.Cmd(mdb.ENGINE, mdb.CREATE, GO, m.Prefix(GO))
-				m.Cmd(mdb.SEARCH, mdb.CREATE, DOC, m.Prefix(GO))
 
-				for k := range c.Configs {
+			for k := range c.Configs {
-					m.Cmd(mdb.PLUGIN, mdb.CREATE, k, m.Prefix(k))
+				m.Cmd(mdb.PLUGIN, mdb.CREATE, k, m.Prefix(k))
-					m.Cmd(mdb.RENDER, mdb.CREATE, k, m.Prefix(k))
+				m.Cmd(mdb.RENDER, mdb.CREATE, k, m.Prefix(k))
+			}
+			LoadPlug(m, GO)
+		}},
+		GODOC: {Name: GODOC, Help: "文档", Action: ice.MergeAction(map[string]*ice.Action{
+			mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) {
+				m.Option(cli.CMD_DIR, arg[2])
+				m.Echo(m.Cmdx(cli.SYSTEM, GO, "doc", strings.TrimSuffix(arg[1], ice.PT+arg[0])))
+			}},
+		}, PlugAction())},
+		PROTO: {Name: PROTO, Help: "协议", Action: ice.MergeAction(map[string]*ice.Action{}, PlugAction())},
+		SUM:   {Name: SUM, Help: "版本", Action: ice.MergeAction(map[string]*ice.Action{}, PlugAction())},
+		MOD:   {Name: MOD, Help: "模块", Action: ice.MergeAction(map[string]*ice.Action{}, PlugAction())},
+		GO: {Name: GO, Help: "后端", Action: ice.MergeAction(map[string]*ice.Action{
+			mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) {
+				m.Option(cli.CMD_DIR, arg[2])
+				if strings.HasSuffix(arg[1], "test.go") {
+					m.Cmdy(cli.SYSTEM, GO, "test", "-v", "./"+arg[1])
+				} else {
+					m.Cmdy(cli.SYSTEM, GO, "run", "./"+arg[1])
 				}
-				LoadPlug(m, GO)
+				m.Set(ice.MSG_APPEND)
 			}},
-			SUM: {Name: SUM, Help: "版本", Action: map[string]*ice.Action{
+			mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
-				mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) {
+				if arg[0] == kit.MDB_FOREACH {
-					m.Echo(m.Conf(MOD, kit.Keym(PLUG)))
+					return
-				}},
+				}
-				mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) {
+				_go_tags(m, kit.Select(kit.MDB_MAIN, arg, 1))
-					m.Cmdy(nfs.CAT, path.Join(arg[2], arg[1]))
+				_go_help(m, kit.Select(kit.MDB_MAIN, arg, 1))
-				}},
+				_go_find(m, kit.Select(kit.MDB_MAIN, arg, 1))
+				_go_grep(m, kit.Select(kit.MDB_MAIN, arg, 1))
 			}},
-			MOD: {Name: MOD, Help: "模块", Action: map[string]*ice.Action{
+		}, PlugAction())},
-				mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) {
+	}, Configs: map[string]*ice.Config{
-					m.Echo(m.Conf(MOD, kit.Keym(PLUG)))
+		PROTO: {Name: PROTO, Help: "协议", Value: kit.Data(PLUG, kit.Dict(
-				}},
+			PREFIX, kit.Dict("//", COMMENT),
-				mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) {
+			PREPARE, kit.Dict(
-					m.Cmdy(nfs.CAT, path.Join(arg[2], arg[1]))
+				KEYWORD, kit.Simple(
-				}},
+					"syntax", "option", "package", "import", "service", "message",
-			}},
-			PROTO: {Name: PROTO, Help: "协议", Action: map[string]*ice.Action{
-				mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) {
-					m.Echo(m.Conf(PROTO, kit.Keym(PLUG)))
-				}},
-				mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) {
-					m.Cmdy(nfs.CAT, path.Join(arg[2], arg[1]))
-				}},
-			}},
-			DOC: {Name: DOC, Help: "文档", Action: map[string]*ice.Action{
-				mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) {
-					m.Echo(m.Conf(GO, kit.Keym(PLUG)))
-				}},
-				mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) {
-					m.Option(cli.CMD_DIR, arg[2])
-					m.Echo(m.Cmdx(cli.SYSTEM, GO, "doc", strings.TrimSuffix(arg[1], "."+arg[0])))
-				}},
-			}},
-			GO: {Name: GO, Help: "后端", Action: map[string]*ice.Action{
-				mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) {
-					m.Echo(m.Conf(GO, kit.Keym(PLUG)))
-				}},
-				mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) {
-					m.Cmdy(nfs.CAT, path.Join(arg[2], arg[1]))
-				}},
-				mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) {
-					m.Option(cli.CMD_DIR, arg[2])
-					if strings.HasSuffix(arg[1], "test.go") {
-						m.Cmdy(cli.SYSTEM, GO, "test", "-v", "./"+arg[1])
-					} else {
-						m.Cmdy(cli.SYSTEM, GO, "run", "./"+arg[1])
-					}
-					m.Set(ice.MSG_APPEND)
-				}},
-				mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
-					if arg[0] == kit.MDB_FOREACH {
-						return
-					}
-					_go_find(m, kit.Select(kit.MDB_MAIN, arg, 1))
-					_go_help(m, kit.Select(kit.MDB_MAIN, arg, 1))
-					_go_tags(m, kit.Select(kit.MDB_MAIN, arg, 1))
-					_go_grep(m, kit.Select(kit.MDB_MAIN, arg, 1))
-				}},
-			}},
-		},
-		Configs: map[string]*ice.Config{
-			PROTO: {Name: PROTO, Help: "协议", Value: kit.Data(
-				PLUG, kit.Dict(
-					PREFIX, kit.Dict(
-						"//", COMMENT,
-					),
-					PREPARE, kit.Dict(
-						KEYWORD, kit.Simple(
-							"syntax", "option", "package", "import", "service", "message",
-						),
-						DATATYPE, kit.Simple(
-							"string", "int64", "int32",
-						),
-					),
-					KEYWORD, kit.Dict(),
 				),
-			)},
+				DATATYPE, kit.Simple(
-			MOD: {Name: MOD, Help: "模块", Value: kit.Data(
+					"string", "int64", "int32",
-				PLUG, kit.Dict(
-					PREFIX, kit.Dict(
-						"//", COMMENT,
-					),
-					PREPARE, kit.Dict(
-						KEYWORD, kit.Simple(
-							"module", "require", "replace", "=>",
-						),
-					),
-					KEYWORD, kit.Dict(),
 				),
-			)},
+			), KEYWORD, kit.Dict(),
-			GO: {Name: GO, Help: "后端", Value: kit.Data(
+		))},
-				PLUG, kit.Dict(
+		MOD: {Name: MOD, Help: "模块", Value: kit.Data(PLUG, kit.Dict(
-					SPLIT, kit.Dict(
+			PREFIX, kit.Dict("//", COMMENT),
-						"space", "\t ",
+			PREPARE, kit.Dict(
-						"operator", "{[(&.,:;!|<>)]}",
+				KEYWORD, kit.Simple(
-					),
+					"module", "require", "replace", "=>",
-					PREFIX, kit.Dict(
-						"//", COMMENT,
-						"/*", COMMENT,
-						"* ", COMMENT,
-					),
-					PREPARE, kit.Dict(
-						KEYWORD, kit.Simple(
-							"package", "import", "type", "struct", "interface", "const", "var", "func",
-							"if", "else", "for", "range", "break", "continue",
-							"switch", "case", "default", "fallthrough",
-							"go", "select", "defer", "return",
-						),
-						DATATYPE, kit.Simple(
-							"int", "int32", "int64", "float64",
-							"string", "byte", "bool", "error", "chan", "map",
-						),
-						FUNCTION, kit.Simple(
-							"new", "make", "len", "cap", "copy", "append", "delete", "msg", "m",
-						),
-						CONSTANT, kit.Simple(
-							"false", "true", "nil", "-1", "0", "1", "2",
-						),
-					),
-					KEYWORD, kit.Dict(),
 				),
-			)},
+			), KEYWORD, kit.Dict(),
-		},
+		))},
-	}, nil)
+		GO: {Name: GO, Help: "后端", Value: kit.Data(PLUG, kit.Dict(
+			SPLIT, kit.Dict("space", "\t ", "operator", "{[(&.,:;!|<>)]}"),
+			PREFIX, kit.Dict("//", COMMENT, "/*", COMMENT, "* ", COMMENT),
+			PREPARE, kit.Dict(
+				KEYWORD, kit.Simple(
+					"package", "import", "type", "struct", "interface", "const", "var", "func",
+					"if", "else", "for", "range", "break", "continue",
+					"switch", "case", "default", "fallthrough",
+					"go", "select", "defer", "return",
+				),
+				DATATYPE, kit.Simple(
+					"int", "int32", "int64", "float64",
+					"string", "byte", "bool", "error", "chan", "map",
+				),
+				FUNCTION, kit.Simple(
+					"new", "make", "len", "cap", "copy", "append", "delete", "msg", "m",
+				),
+				CONSTANT, kit.Simple(
+					"false", "true", "nil", "-1", "0", "1", "2",
+				),
+			), KEYWORD, kit.Dict(),
+		))},
+	}}, nil)
 }

core/code/inner.go

@@ -9,9 +9,22 @@ import (
 	"shylinux.com/x/icebergs/base/ctx"
 	"shylinux.com/x/icebergs/base/mdb"
 	"shylinux.com/x/icebergs/base/nfs"
+	"shylinux.com/x/icebergs/base/ssh"
 	kit "shylinux.com/x/toolkits"
 )
 
+func _inner_exec(m *ice.Message, ext, file, dir string, arg ...string) {
+	if !m.Right(dir, file) {
+		return // 没有权限
+	}
+	if m.Cmdy(mdb.ENGINE, ext, file, dir, arg); m.Result() != "" {
+		return // 执行成功
+	}
+	if ls := kit.Simple(m.Confv(INNER, kit.Keym(EXEC, ext))); len(ls) > 0 {
+		m.Cmdy(cli.SYSTEM, ls, file, ice.Option{cli.CMD_DIR, dir})
+		m.Set(ice.MSG_APPEND)
+	}
+}
 func _inner_list(m *ice.Message, ext, file, dir string, arg ...string) {
 	if !m.Right(dir, file) {
 		return // 没有权限
@@ -19,24 +32,10 @@ func _inner_list(m *ice.Message, ext, file, dir string, arg ...string) {
 	if m.Cmdy(mdb.RENDER, ext, file, dir, arg); m.Result() != "" {
 		return // 解析成功
 	}
-
+	if m.Config(ssh.SOURCE, ext) == ice.TRUE {
-	if m.Conf(INNER, kit.Keys(kit.META_SOURCE, ext)) == ice.TRUE {
 		m.Cmdy(nfs.CAT, path.Join(dir, file))
 	}
 }
-func _inner_show(m *ice.Message, ext, file, dir string, arg ...string) {
-	if !m.Right(dir, file) {
-		return // 没有权限
-	}
-	if m.Cmdy(mdb.ENGINE, ext, file, dir, arg); m.Result() != "" {
-		return // 执行成功
-	}
-
-	if ls := kit.Simple(m.Confv(INNER, kit.Keym(SHOW, ext))); len(ls) > 0 {
-		m.Cmdy(cli.SYSTEM, ls, file, ice.Option{cli.CMD_DIR, dir})
-		m.Set(ice.MSG_APPEND)
-	}
-}
 
 func LoadPlug(m *ice.Message, language string) {
 	m.Confm(language, kit.Keym(PLUG, PREPARE), func(key string, value interface{}) {
@@ -60,51 +59,41 @@ const (
 )
 const (
 	PLUG = "plug"
-	SHOW = "show"
+	EXEC = "exec"
 )
 const INNER = "inner"
 
 func init() {
 	Index.Merge(&ice.Context{Commands: map[string]*ice.Command{
 		INNER: {Name: "inner path=src/ file=main.go line=1 auto", Help: "源代码", Meta: kit.Dict(
-			ice.Display("/plugin/local/code/inner.js", "editor"),
+			ice.Display("/plugin/local/code/inner.js"),
 		), Action: ice.MergeAction(map[string]*ice.Action{
 			mdb.PLUGIN: {Name: "plugin", Help: "插件", Hand: func(m *ice.Message, arg ...string) {
 				if m.Cmdy(mdb.PLUGIN, arg); m.Result() == "" {
-					m.Echo(kit.Select("{}", m.Conf(INNER, kit.Keym(PLUG, arg[0]))))
+					m.Echo(kit.Select("{}", m.Config(kit.Keys(PLUG, arg[0]))))
 				}
 			}},
-			mdb.ENGINE: {Name: "engine", Help: "运行", Hand: func(m *ice.Message, arg ...string) {
+			mdb.ENGINE: {Name: "engine", Help: "引擎", Hand: func(m *ice.Message, arg ...string) {
-				_inner_show(m, arg[0], arg[1], arg[2])
+				_inner_exec(m, arg[0], arg[1], arg[2])
-			}},
-			mdb.SEARCH: {Name: "search", Help: "搜索", Hand: func(m *ice.Message, arg ...string) {
-				if strings.Contains(arg[1], ";") {
-					ls := strings.Split(arg[1], ";")
-					arg[0] = ls[0]
-					arg[1] = ls[1]
-				}
-				m.Option(cli.CMD_DIR, arg[2])
-				m.Option(nfs.DIR_ROOT, arg[2])
-				m.Cmdy(mdb.SEARCH, arg[:2], "cmd,file,line,text")
 			}},
 			mdb.INPUTS: {Name: "favor inputs", Help: "补全"},
 			FAVOR:      {Name: "favor", Help: "收藏"},
 		}, ctx.CmdAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-			if len(arg) < 2 {
-				nfs.Dir(m, kit.MDB_PATH)
-				return
-			}
 			if !strings.HasSuffix(arg[0], ice.PS) {
 				arg[1] = kit.Slice(strings.Split(arg[0], ice.PS), -1)[0]
 				arg[0] = strings.TrimSuffix(arg[0], arg[1])
-				m.ProcessRewrite("path", arg[0], "file", arg[1])
+				m.ProcessRewrite(nfs.PATH, arg[0], nfs.FILE, arg[1])
+				return
+			}
+			if len(arg) < 2 {
+				nfs.Dir(m, kit.MDB_PATH)
 				return
 			}
 			_inner_list(m, kit.Ext(arg[1]), arg[1], arg[0])
 		}},
 	}, Configs: map[string]*ice.Config{
 		INNER: {Name: "inner", Help: "源代码", Value: kit.Data(
-			cli.SOURCE, kit.Dict(
+			ssh.SOURCE, kit.Dict(
 				"s", ice.TRUE, "S", ice.TRUE,
 				"shy", ice.TRUE, "py", ice.TRUE,
 				"csv", ice.TRUE, "json", ice.TRUE,
@@ -115,6 +104,10 @@ func init() {
 				"md", ice.TRUE, "license", ice.TRUE, "makefile", ice.TRUE, "sql", ice.TRUE,
 				"ini", ice.TRUE, "conf", ice.TRUE, "toml", ice.TRUE, "yaml", ice.TRUE, "yml", ice.TRUE,
 			),
+			EXEC, kit.Dict(
+				"py", []string{"python"},
+				"js", []string{"node"},
+			),
 			PLUG, kit.Dict(
 				"s", kit.Dict(
 					PREFIX, kit.Dict("//", COMMENT),
@@ -163,11 +156,6 @@ func init() {
 					),
 				),
 			),
-			SHOW, kit.Dict(
-				"py", []string{"python"},
-				"js", []string{"node"},
-			),
 		)},
-	},
+	}})
-	})
 }

core/code/install.go

@@ -18,7 +18,7 @@ import (
 func _install_download(m *ice.Message) {
 	link := m.Option(kit.MDB_LINK)
 	name := path.Base(link)
-	file := path.Join(kit.Select(m.Conf(INSTALL, kit.META_PATH), m.Option(kit.MDB_PATH)), name)
+	file := path.Join(kit.Select(m.Config(kit.MDB_PATH), m.Option(kit.MDB_PATH)), name)
 
 	defer m.Cmdy(nfs.DIR, file)
 	if _, e := os.Stat(file); e == nil {
@@ -54,7 +54,7 @@ func _install_download(m *ice.Message) {
 	})
 }
 func _install_build(m *ice.Message, arg ...string) {
-	p := m.Option(cli.CMD_DIR, path.Join(m.Conf(INSTALL, kit.META_PATH), kit.TrimExt(m.Option(kit.MDB_LINK))))
+	p := m.Option(cli.CMD_DIR, path.Join(m.Config(kit.MDB_PATH), kit.TrimExt(m.Option(kit.MDB_LINK))))
 	pp := kit.Path(path.Join(p, "_install"))
 
 	// 推流
@@ -87,8 +87,8 @@ func _install_build(m *ice.Message, arg ...string) {
 	m.ProcessHold()
 }
 func _install_order(m *ice.Message, arg ...string) {
-	m.Cmd(nfs.PUSH, "etc/path", kit.Path(m.Conf(INSTALL, kit.META_PATH), kit.TrimExt(m.Option(kit.MDB_LINK)), m.Option(kit.MDB_PATH)+"\n"))
+	m.Cmd(nfs.PUSH, ice.ETC_PATH, kit.Path(m.Config(kit.MDB_PATH), kit.TrimExt(m.Option(kit.MDB_LINK)), m.Option(kit.MDB_PATH)+ice.NL))
-	m.Cmdy(nfs.CAT, "etc/path")
+	m.Cmdy(nfs.CAT, ice.ETC_PATH)
 }
 func _install_spawn(m *ice.Message, arg ...string) {
 	if kit.Int(m.Option(tcp.PORT)) >= 10000 {
@@ -102,10 +102,10 @@ func _install_spawn(m *ice.Message, arg ...string) {
 	}
 
 	target := path.Join(m.Conf(cli.DAEMON, kit.META_PATH), m.Option(tcp.PORT))
-	source := path.Join(m.Conf(INSTALL, kit.META_PATH), kit.TrimExt(m.Option(kit.MDB_LINK)))
+	source := path.Join(m.Config(kit.MDB_PATH), kit.TrimExt(m.Option(kit.MDB_LINK)))
 
 	m.Cmd(nfs.DIR, path.Join(source, kit.Select("_install", m.Option("install")))).Table(func(index int, value map[string]string, head []string) {
-		m.Cmd(cli.SYSTEM, "cp", "-r", strings.TrimSuffix(value[kit.MDB_PATH], "/"), target)
+		m.Cmd(cli.SYSTEM, "cp", "-r", strings.TrimSuffix(value[kit.MDB_PATH], ice.PS), target)
 	})
 	m.Echo(target)
 }
@@ -168,7 +168,7 @@ func init() {
 				_install_start(m, arg...)
 			}},
 			cli.SOURCE: {Name: "source link path", Help: "源码", Hand: func(m *ice.Message, arg ...string) {
-				m.Option(nfs.DIR_ROOT, path.Join(m.Conf(INSTALL, kit.META_PATH), kit.TrimExt(m.Option(kit.MDB_LINK)), "_install"))
+				m.Option(nfs.DIR_ROOT, path.Join(m.Config(kit.MDB_PATH), kit.TrimExt(m.Option(kit.MDB_LINK)), "_install"))
 				m.Cmdy(nfs.DIR, m.Option(kit.MDB_PATH))
 			}},
 		}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
@@ -184,8 +184,7 @@ func init() {
 				m.Cmdy(nfs.CAT, kit.Select("./", arg, 2))
 			}
 		}},
-	},
+	}})
-	})
 }
 
 func InstallAction(fields ...string) map[string]*ice.Action {

core/code/js.go

@@ -1,12 +1,9 @@
 package code
 
 import (
-	"path"
-
 	ice "shylinux.com/x/icebergs"
 	"shylinux.com/x/icebergs/base/cli"
 	"shylinux.com/x/icebergs/base/mdb"
-	"shylinux.com/x/icebergs/base/nfs"
 	"shylinux.com/x/icebergs/base/web"
 	kit "shylinux.com/x/toolkits"
 )
@@ -18,157 +15,105 @@ const NODE = "node"
 const VUE = "vue"
 
 func init() {
-	Index.Register(&ice.Context{Name: JS, Help: "前端",
+	Index.Register(&ice.Context{Name: JS, Help: "前端", Commands: map[string]*ice.Command{
-		Commands: map[string]*ice.Command{
+		ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-			ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+			for _, cmd := range []string{mdb.PLUGIN, mdb.RENDER, mdb.ENGINE, mdb.SEARCH} {
-				for _, cmd := range []string{mdb.PLUGIN, mdb.RENDER, mdb.ENGINE, mdb.SEARCH} {
+				m.Cmd(cmd, mdb.CREATE, VUE, m.Prefix(JS))
-					m.Cmd(cmd, mdb.CREATE, VUE, m.Prefix(VUE))
+				m.Cmd(cmd, mdb.CREATE, JS, m.Prefix(JS))
-					m.Cmd(cmd, mdb.CREATE, JS, m.Prefix(JS))
+			}
+			LoadPlug(m, JS)
+		}},
+		JS: {Name: JS, Help: "前端", Action: ice.MergeAction(map[string]*ice.Action{
+			mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) {
+				m.Option(cli.CMD_DIR, arg[2])
+				m.Cmdy(cli.SYSTEM, NODE, arg[1])
+				m.Set(ice.MSG_APPEND)
+			}},
+			mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
+				if arg[0] == kit.MDB_FOREACH {
+					return
 				}
-				LoadPlug(m, JS)
+				_go_find(m, kit.Select(kit.MDB_MAIN, arg, 1))
+				_go_grep(m, kit.Select(kit.MDB_MAIN, arg, 1))
 			}},
-			JS: {Name: JS, Help: "前端", Action: map[string]*ice.Action{
+		}, PlugAction())},
-				mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) {
+		NODE: {Name: "node auto download", Help: "前端", Action: map[string]*ice.Action{
-					m.Echo(m.Conf(JS, kit.Keym(PLUG)))
+			web.DOWNLOAD: {Name: "download", Help: "下载", Hand: func(m *ice.Message, arg ...string) {
-				}},
+				m.Cmdy(INSTALL, m.Config(cli.SOURCE))
-				mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) {
-					m.Cmdy(nfs.CAT, path.Join(arg[2], arg[1]))
-				}},
-				mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) {
-					m.Option(cli.CMD_DIR, arg[2])
-					m.Cmdy(cli.SYSTEM, NODE, arg[1])
-					m.Set(ice.MSG_APPEND)
-				}},
-				mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
-					if arg[0] == kit.MDB_FOREACH {
-						return
-					}
-					_go_find(m, kit.Select(kit.MDB_MAIN, arg, 1))
-					_go_grep(m, kit.Select(kit.MDB_MAIN, arg, 1))
-				}},
 			}},
-			NODE: {Name: "node", Help: "前端", Action: map[string]*ice.Action{
+		}},
-				web.DOWNLOAD: {Name: "download", Help: "下载", Hand: func(m *ice.Message, arg ...string) {
+	}, Configs: map[string]*ice.Config{
-					m.Cmdy(INSTALL, m.Conf(NODE, kit.META_SOURCE))
+		NODE: {Name: NODE, Help: "前端", Value: kit.Data(
-				}},
+			cli.SOURCE, "https://nodejs.org/dist/v10.13.0/node-v10.13.0-linux-x64.tar.xz",
-			}},
+		)},
-			VUE: {Name: "vue", Help: "前端", Action: map[string]*ice.Action{
+		JS: {Name: JS, Help: "js", Value: kit.Data(PLUG, kit.Dict(
-				mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) {
+			SPLIT, kit.Dict("space", " \t", "operator", "{[(&.,;!|<>)]}"),
-					m.Echo(m.Conf(VUE, kit.Keym(PLUG)))
+			PREFIX, kit.Dict("//", COMMENT, "/*", COMMENT, "*", COMMENT),
-				}},
+			PREPARE, kit.Dict(
-				mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) {
+				KEYWORD, kit.Simple(
-					m.Cmdy(nfs.CAT, path.Join(arg[2], arg[1]))
+					"import",
-				}},
+					"from",
-				mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) {
+					"export",
-					m.Option(cli.CMD_DIR, arg[2])
+
-					m.Cmdy(cli.SYSTEM, NODE, arg[1])
+					"var",
-					m.Set(ice.MSG_APPEND)
+					"new",
-				}},
+					"delete",
-				mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
+					"typeof",
-					if arg[0] == kit.MDB_FOREACH {
+					"const",
-						return
+					"function",
-					}
+
-					_go_find(m, kit.Select(kit.MDB_MAIN, arg, 1))
+					"if",
-					_go_grep(m, kit.Select(kit.MDB_MAIN, arg, 1))
+					"else",
-				}},
+					"for",
-			}},
+					"while",
-		},
+					"break",
-		Configs: map[string]*ice.Config{
+					"continue",
-			VUE: {Name: VUE, Help: "vue", Value: kit.Data(
+					"switch",
-				PLUG, kit.Dict(
+					"case",
-					SPLIT, kit.Dict(
+					"default",
-						"space", " \t",
+					"return",
-						"operator", "{[(&.,;!|<>)]}",
+					"try",
-					),
+					"throw",
-					PREFIX, kit.Dict(
+					"catch",
-						"//", COMMENT,
+					"finally",
-						"/*", COMMENT,
-						"*", COMMENT,
-					),
 				),
-			)},
+				FUNCTION, kit.Simple(
-			NODE: {Name: NODE, Help: "前端", Value: kit.Data(
+					"window",
-				kit.SSH_SOURCE, "https://nodejs.org/dist/v10.13.0/node-v10.13.0-linux-x64.tar.xz",
+					"console",
-			)},
+					"document",
-			JS: {Name: JS, Help: "js", Value: kit.Data(
+					"arguments",
-				PLUG, kit.Dict(
+					"event",
-					SPLIT, kit.Dict(
+					"Date",
-						"space", " \t",
+					"JSON",
-						"operator", "{[(&.,;!|<>)]}",
-					),
-					PREFIX, kit.Dict(
-						"//", COMMENT,
-						"/*", COMMENT,
-						"*", COMMENT,
-					),
-					PREPARE, kit.Dict(
-						KEYWORD, kit.Simple(
-							"import",
-							"from",
-							"export",
 
-							"var",
+					"__proto__",
-							"new",
+					"setTimeout",
-							"delete",
+					"createElement",
-							"typeof",
+					"appendChild",
-							"const",
+					"removeChild",
-							"function",
+					"parentNode",
+					"childNodes",
 
-							"if",
+					"Volcanos",
-							"else",
+					"request",
-							"for",
+					"require",
-							"while",
-							"break",
-							"continue",
-							"switch",
-							"case",
-							"default",
-							"return",
-							"try",
-							"throw",
-							"catch",
-							"finally",
-						),
-						FUNCTION, kit.Simple(
-							"window",
-							"console",
-							"document",
-							"arguments",
-							"event",
-							"Date",
-							"JSON",
 
-							"__proto__",
+					"cb",
-							"setTimeout",
+					"cbs",
-							"createElement",
+					"shy",
-							"appendChild",
+					"can",
-							"removeChild",
+					"sub",
-							"parentNode",
+					"msg",
-							"childNodes",
+					"res",
-
+					"pane",
-							"Volcanos",
+					"plugin",
-							"request",
-							"require",
-
-							"cb",
-							"cbs",
-							"shy",
-							"can",
-							"sub",
-							"msg",
-							"res",
-							"pane",
-							"plugin",
-						),
-						CONSTANT, kit.Simple(
-							"true", "false",
-							"undefined", "null",
-							"-1", "0", "1", "2", "10",
-						),
-					),
-					KEYWORD, kit.Dict(),
 				),
-			)},
+				CONSTANT, kit.Simple(
-		},
+					"true", "false",
-	}, nil)
+					"undefined", "null",
+					"-1", "0", "1", "2", "10",
+				),
+			), KEYWORD, kit.Dict(),
+		))},
+	}}, nil)
 }

core/code/pprof.go

@@ -24,80 +24,64 @@ const (
 const PPROF = "pprof"
 
 func init() {
-	Index.Merge(&ice.Context{
+	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
-		Configs: map[string]*ice.Config{
+		PPROF: {Name: PPROF, Help: "性能分析", Value: kit.Data(
-			PPROF: {Name: PPROF, Help: "性能分析", Value: kit.Data(kit.MDB_SHORT, kit.MDB_ZONE,
+			kit.MDB_SHORT, kit.MDB_ZONE, kit.MDB_FIELD, "time,id,text,file",
-				PPROF, []string{GO, "tool", PPROF},
+			PPROF, kit.List(GO, "tool", PPROF),
-			)},
+		)},
-		},
+	}, Commands: map[string]*ice.Command{
-		Commands: map[string]*ice.Command{
+		"/pprof/": {Name: "/pprof/", Help: "性能分析", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-			"/pprof/": {Name: "/pprof/", Help: "性能分析", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+			m.R.URL.Path = strings.Replace("/code"+m.R.URL.Path, "code", "debug", 1)
-				m.R.URL.Path = strings.Replace("/code"+m.R.URL.Path, "code", "debug", 1)
+			http.DefaultServeMux.ServeHTTP(m.W, m.R)
-				http.DefaultServeMux.ServeHTTP(m.W, m.R)
+			m.Render(ice.RENDER_VOID)
-				m.Render(ice.RENDER_VOID)
+		}},
+		PPROF: {Name: "pprof zone id auto create", Help: "性能分析", Action: ice.MergeAction(map[string]*ice.Action{
+			mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
+				switch arg[0] {
+				case BINNARY:
+					m.Cmdy(nfs.DIR, "bin/", "path,size,time").RenameAppend(kit.MDB_PATH, BINNARY)
+				case SERVICE:
+					m.Cmd(web.SPIDE).Table(func(index int, value map[string]string, head []string) {
+						m.Push(SERVICE, kit.MergeURL2(value["client.url"], "/debug/pprof/profile"))
+					})
+				}
 			}},
-			PPROF: {Name: "pprof zone id auto create", Help: "性能分析", Action: map[string]*ice.Action{
+			mdb.CREATE: {Name: "create zone=some binnary service seconds=3", Help: "创建"},
-				mdb.CREATE: {Name: "create zone=some binnary service seconds=3", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
+			mdb.INSERT: {Name: "insert zone type name text", Help: "插入"},
-					m.Cmdy(mdb.INSERT, PPROF, "", mdb.HASH, arg)
-				}},
-				mdb.INSERT: {Name: "insert zone type name text", Help: "插入", Hand: func(m *ice.Message, arg ...string) {
-					m.Cmdy(mdb.INSERT, PPROF, "", mdb.HASH, kit.MDB_ZONE, arg[1])
-					m.Cmdy(mdb.INSERT, PPROF, "", mdb.ZONE, m.Option(kit.MDB_ZONE), arg[2:])
-				}},
-				mdb.MODIFY: {Name: "modify", Help: "编辑", Hand: func(m *ice.Message, arg ...string) {
-					m.Cmdy(mdb.MODIFY, PPROF, "", mdb.ZONE, m.Option(kit.MDB_ZONE), m.Option(kit.MDB_ID), arg)
-				}},
-				mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
-					m.Cmdy(mdb.DELETE, PPROF, "", mdb.HASH, m.OptionSimple(kit.MDB_ZONE))
-				}},
-				mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
-					switch arg[0] {
-					case BINNARY:
-						m.Cmd(nfs.DIR, "bin/", "path,size,time").Table(func(index int, value map[string]string, head []string) {
-							m.Push(BINNARY, value["path"])
-							m.Push("", value, []string{"size,time"})
-						})
-					case SERVICE:
-						m.Cmd(web.SPIDE).Table(func(index int, value map[string]string, head []string) {
-							m.Push(SERVICE, kit.MergeURL2(value["client.url"], "/debug/pprof/profile"))
-						})
-					}
-				}},
 
-				ice.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))
+				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))
+				cmd := kit.Simple(m.Confv(PPROF, kit.Keym(PPROF)), "-text", m.Option(BINNARY), msg.Append(kit.MDB_FILE))
-					res := strings.Split(m.Cmdx(cli.SYSTEM, cmd), ice.NL)
+				res := strings.Split(m.Cmdx(cli.SYSTEM, cmd), ice.NL)
-					if len(res) > 20 {
+				if len(res) > 20 {
-						res = res[:20]
+					res = res[:20]
-					}
-
-					m.Cmd(mdb.INSERT, PPROF, "", mdb.ZONE, m.Option(kit.MDB_ZONE),
-						kit.MDB_TEXT, strings.Join(res, ice.NL), kit.MDB_FILE, msg.Append(kit.MDB_FILE))
-					m.Echo(strings.Join(res, ice.NL))
-					m.ProcessInner()
-				}},
-				web.SERVE: {Name: "serve", Help: "展示", Hand: func(m *ice.Message, arg ...string) {
-					u := kit.ParseURL(m.Option(ice.MSG_USERWEB))
-					p := u.Hostname() + ":" + m.Cmdx(tcp.PORT, aaa.RIGHT)
-
-					m.Cmd(cli.DAEMON, m.Confv(PPROF, kit.Keym(PPROF)), "-http="+p, m.Option(BINNARY), m.Option(kit.MDB_FILE))
-					m.Echo("http://%s/ui/top", p)
-					m.ProcessInner()
-				}},
-			}, 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(ice.RUN, mdb.REMOVE)
-					return
 				}
 
-				m.Table(func(index int, value map[string]string, head []string) {
+				m.Cmd(mdb.INSERT, PPROF, "", mdb.ZONE, m.Option(kit.MDB_ZONE),
-					m.PushDownload(kit.MDB_LINK, "pprof.pd.gz", value[kit.MDB_FILE])
+					kit.MDB_TEXT, strings.Join(res, ice.NL), kit.MDB_FILE, msg.Append(kit.MDB_FILE))
-					m.PushButton(web.SERVE)
+				m.Echo(strings.Join(res, ice.NL))
-				})
+				m.ProcessInner()
 			}},
-		},
+			web.SERVE: {Name: "serve", Help: "展示", Hand: func(m *ice.Message, arg ...string) {
-	})
+				u := kit.ParseURL(m.Option(ice.MSG_USERWEB))
+				p := u.Hostname() + ":" + m.Cmdx(tcp.PORT, aaa.RIGHT)
+
+				m.Cmd(cli.DAEMON, m.Confv(PPROF, kit.Keym(PPROF)), "-http="+p, m.Option(BINNARY), m.Option(kit.MDB_FILE))
+				m.Echo("http://%s/ui/top", p)
+				m.ProcessInner()
+			}},
+		}, mdb.ZoneAction()), Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+			m.Fields(len(arg), "time,zone,count,binnary,service,seconds", m.Config(kit.MDB_FIELD))
+			if mdb.ZoneSelect(m, arg...); len(arg) == 0 {
+				m.PushAction(ice.RUN, mdb.REMOVE)
+				return
+			}
+
+			m.Table(func(index int, value map[string]string, head []string) {
+				m.PushDownload(kit.MDB_LINK, "pprof.pd.gz", value[kit.MDB_FILE])
+				m.PushButton(web.SERVE)
+			})
+		}},
+	}})
 }

core/code/publish.go

@@ -17,141 +17,113 @@ import (
 	kit "shylinux.com/x/toolkits"
 )
 
-func _publish_file(m *ice.Message, file string, arg ...string) string {
+func _bin_list(m *ice.Message, dir string) {
-	if strings.HasSuffix(file, "ice.bin") {
+	p := m.Option(cli.CMD_DIR, dir)
-		// 打包应用
+	for _, ls := range strings.Split(strings.TrimSpace(m.Cmd(cli.SYSTEM, "bash", "-c", "ls |xargs file |grep executable").Append(cli.CMD_OUT)), ice.NL) {
-		arg = append(arg, kit.Keys("ice", runtime.GOOS, runtime.GOARCH))
+		if file := strings.TrimSpace(strings.Split(ls, ":")[0]); file != "" {
-		if _, e := os.Stat(path.Join(m.Conf(PUBLISH, kit.META_PATH), kit.Select(path.Base(file), arg, 0))); e == nil {
+			if s, e := os.Stat(path.Join(p, file)); e == nil {
-			return ""
+				m.Push(kit.MDB_TIME, s.ModTime())
+				m.Push(kit.MDB_SIZE, kit.FmtSize(s.Size()))
+				m.Push(kit.MDB_FILE, file)
+				m.PushDownload(kit.MDB_LINK, file, path.Join(p, file))
+			}
 		}
+	}
+	m.SortTimeR(kit.MDB_TIME)
+}
+
+func _publish_file(m *ice.Message, file string, arg ...string) string {
+	if strings.HasSuffix(file, "ice.bin") { // 打包应用
+		arg = kit.Simple(kit.Keys(ice.ICE, runtime.GOOS, runtime.GOARCH))
 
 	} else if s, e := os.Stat(file); m.Assert(e) && s.IsDir() {
-		// 打包目录
 		p := path.Base(file) + ".tar.gz"
 		m.Cmd(cli.SYSTEM, "tar", "-zcf", p, file)
 		defer func() { os.Remove(p) }()
-		file = p
+		file = p // 打包目录
 	}
 
 	// 发布文件
-	target := path.Join(m.Conf(PUBLISH, kit.META_PATH), kit.Select(path.Base(file), arg, 0))
+	target := path.Join(m.Config(kit.MDB_PATH), kit.Select(path.Base(file), arg, 0))
 	m.Log_EXPORT(PUBLISH, target, kit.MDB_FROM, file)
 	m.Cmd(nfs.LINK, target, file)
 	return target
 }
+func _publish_list(m *ice.Message, arg ...string) {
+	m.Option(nfs.DIR_DEEP, ice.TRUE)
+	m.Option(nfs.DIR_REG, kit.Select("", arg, 0))
+	m.Option(nfs.DIR_ROOT, m.Config(kit.MDB_PATH))
+	m.Cmdy(nfs.DIR, "./", kit.Select("time,size,line,path,link", arg, 1))
+}
 
 const PUBLISH = "publish"
 
 func init() {
-	Index.Merge(&ice.Context{Commands: map[string]*ice.Command{
+	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
-		ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-			m.Cmd(aaa.ROLE, aaa.WHITE, aaa.VOID, m.Prefix(PUBLISH))
-			m.Cmd(aaa.ROLE, aaa.WHITE, aaa.VOID, ice.USR_PUBLISH)
-			m.Conf(PUBLISH, kit.Keym(ice.CONTEXTS), _contexts)
-		}},
-		PUBLISH: {Name: "publish path auto create volcanos icebergs intshell package dream", Help: "发布", Action: map[string]*ice.Action{
-			mdb.CREATE: {Name: "create file", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
-				_publish_file(m, m.Option(kit.MDB_FILE))
-			}},
-			ice.VOLCANOS: {Name: "volcanos", Help: "火山架", Hand: func(m *ice.Message, arg ...string) {
-				defer func() { m.EchoQRCode(m.Option(ice.MSG_USERWEB)) }()
-				defer func() { m.Cmdy(PUBLISH, ice.CONTEXTS, "miss") }()
-				m.Cmd(PUBLISH, mdb.CREATE, kit.MDB_FILE, ice.ETC_MISS_SH)
-				m.Cmd(PUBLISH, mdb.CREATE, kit.MDB_FILE, ice.GO_MOD)
-
-				m.Cmd(nfs.DEFS, path.Join(m.Conf(PUBLISH, kit.META_PATH), ice.ORDER_JS), m.Conf(PUBLISH, kit.Keym(JS)))
-				m.Cmd(nfs.DEFS, path.Join(ice.USR_VOLCANOS, "page/cache.css"), "")
-				m.Cmd(nfs.DEFS, path.Join(ice.USR_VOLCANOS, "page/cache.js"), "")
-
-				m.Option(nfs.DIR_DEEP, ice.TRUE)
-				m.Option(nfs.DIR_REG, `.*\.(html|css|js)$`)
-				m.Option(nfs.DIR_ROOT, m.Conf(PUBLISH, kit.META_PATH))
-				m.Cmdy(nfs.DIR, "./", "time,size,line,path,link")
-			}},
-			ice.ICEBERGS: {Name: "icebergs", Help: "冰山架", Hand: func(m *ice.Message, arg ...string) {
-				defer func() { m.Cmdy(PUBLISH, ice.CONTEXTS, "base") }()
-				m.Cmd(PUBLISH, mdb.CREATE, kit.MDB_FILE, ice.BIN_ICE_SH)
-				m.Cmd(PUBLISH, mdb.CREATE, kit.MDB_FILE, ice.BIN_ICE_BIN)
-
-				p := m.Option(cli.CMD_DIR, m.Conf(PUBLISH, kit.META_PATH))
-				ls := strings.Split(strings.TrimSpace(m.Cmd(cli.SYSTEM, "bash", "-c", "ls |xargs file |grep executable").Append(cli.CMD_OUT)), ice.NL)
-				for _, ls := range ls {
-					if file := strings.TrimSpace(strings.Split(ls, ":")[0]); file != "" {
-						if s, e := os.Stat(path.Join(p, file)); e == nil {
-							m.Push(kit.MDB_TIME, s.ModTime())
-							m.Push(kit.MDB_SIZE, kit.FmtSize(s.Size()))
-							m.Push(kit.MDB_FILE, file)
-							m.PushDownload(kit.MDB_LINK, file, path.Join(p, file))
-						}
-					}
-				}
-				m.SortTimeR(kit.MDB_TIME)
-			}},
-			ice.INTSHELL: {Name: "intshell", Help: "神农架", Hand: func(m *ice.Message, arg ...string) {
-				defer func() { m.Cmdy(PUBLISH, ice.CONTEXTS, "tmux") }()
-				m.Cmd(nfs.DEFS, path.Join(m.Conf(PUBLISH, kit.META_PATH), ice.ORDER_SH), m.Conf(PUBLISH, kit.Keym(SH)))
-
-				m.Option(nfs.DIR_DEEP, ice.TRUE)
-				m.Option(nfs.DIR_REG, ".*\\.(sh|vim|conf)$")
-				m.Option(nfs.DIR_ROOT, m.Conf(PUBLISH, kit.META_PATH))
-				m.Cmdy(nfs.DIR, "./", "time,size,line,path,link")
-			}},
-			ice.CONTEXTS: {Name: "contexts", Help: "环境", Hand: func(m *ice.Message, arg ...string) {
-				u := kit.ParseURL(tcp.ReplaceLocalhost(m, m.Option(ice.MSG_USERWEB)))
-				host := u.Host
-
-				m.Option("httphost", fmt.Sprintf("%s://%s:%s", u.Scheme, strings.Split(host, ":")[0], kit.Select(kit.Select("80", "443", u.Scheme == "https"), strings.Split(host, ":"), 1)))
-				m.Option("hostport", fmt.Sprintf("%s:%s", strings.Split(host, ":")[0], kit.Select(kit.Select("80", "443", u.Scheme == "https"), strings.Split(host, ":"), 1)))
-				m.Option("hostname", strings.Split(host, ":")[0])
-
-				m.Option("userhost", fmt.Sprintf("%s@%s", m.Option(ice.MSG_USERNAME), strings.Split(host, ":")[0]))
-				m.Option("hostpath", kit.Path("./.ish/pluged"))
-
-				if len(arg) == 0 {
-					arg = append(arg, "tmux", "base", "miss", "binary", "source", "project")
-				}
-				for _, k := range arg {
-					if buf, err := kit.Render(m.Conf(PUBLISH, kit.Keym(ice.CONTEXTS, k)), m); m.Assert(err) {
-						m.EchoScript(strings.TrimSpace(string(buf)))
-					}
-				}
-			}},
-			"package": {Name: "package", Help: "依赖", Hand: func(m *ice.Message, arg ...string) {
-				web.PushStream(m)
-				p := kit.Path(ice.USR_PUBLISH)
-				m.Option(cli.CMD_DIR, kit.Path(os.Getenv(cli.HOME)))
-				// m.Cmdy(cli.SYSTEM, "tar", "-zcvf", "go.tar.gz", "go/pkg")
-				// m.Cmdy(cli.SYSTEM, "mv", "go.tar.gz", p)
-				m.Cmdy(cli.SYSTEM, "tar", "-zcvf", "vim.tar.gz", ".vim/plugged")
-				m.Cmdy(cli.SYSTEM, "mv", "vim.tar.gz", p)
-				m.Toast("打包成功")
-				m.ProcessHold()
-			}},
-			nfs.TRASH: {Name: "trash", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
-				p := m.Option(cli.CMD_DIR, m.Config(kit.MDB_PATH))
-				os.Remove(path.Join(p, m.Option(kit.MDB_PATH)))
-			}},
-			mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
-				m.Cmdy(web.DREAM, mdb.INPUTS, arg)
-			}},
-			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),
-					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))
-			m.Cmdy(nfs.DIR, kit.Select("", arg, 0), "time,size,path,action,link")
-		}},
-	}, Configs: map[string]*ice.Config{
 		PUBLISH: {Name: PUBLISH, Help: "发布", Value: kit.Data(
-			kit.MDB_PATH, "usr/publish", ice.CONTEXTS, _contexts,
+			kit.MDB_PATH, ice.USR_PUBLISH, ice.CONTEXTS, _contexts,
 			SH, `#!/bin/bash
 echo "hello world"
 `,
 			JS, `Volcanos("onengine", {})
 `,
 		)},
+	}, Commands: map[string]*ice.Command{
+		PUBLISH: {Name: "publish path auto create volcanos icebergs intshell", Help: "发布", Action: map[string]*ice.Action{
+			ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) {
+				m.Cmd(aaa.ROLE, aaa.WHITE, aaa.VOID, m.Config(kit.MDB_PATH))
+				m.Cmd(aaa.ROLE, aaa.WHITE, aaa.VOID, m.PrefixKey())
+				m.Config(ice.CONTEXTS, _contexts)
+			}},
+			ice.VOLCANOS: {Name: "volcanos", Help: "火山架", Hand: func(m *ice.Message, arg ...string) {
+				defer func() { m.EchoQRCode(m.Option(ice.MSG_USERWEB)) }()
+				defer func() { m.Cmdy(PUBLISH, ice.CONTEXTS, ice.CORE) }()
+				m.Cmd(PUBLISH, mdb.CREATE, kit.MDB_FILE, ice.ETC_MISS_SH)
+				m.Cmd(PUBLISH, mdb.CREATE, kit.MDB_FILE, ice.GO_MOD)
+
+				m.Cmd(nfs.DEFS, path.Join(m.Config(kit.MDB_PATH), ice.ORDER_JS), m.Config(JS))
+				m.Cmd(nfs.DEFS, path.Join(m.Conf(web.SERVE, kit.Keym(ice.VOLCANOS)), PAGE_CACHE_JS), "")
+				m.Cmd(nfs.DEFS, path.Join(m.Conf(web.SERVE, kit.Keym(ice.VOLCANOS)), PAGE_CACHE_CSS), "")
+				_publish_list(m, `.*\.(html|css|js)$`)
+			}},
+			ice.ICEBERGS: {Name: "icebergs", Help: "冰山架", Hand: func(m *ice.Message, arg ...string) {
+				defer func() { m.Cmdy(PUBLISH, ice.CONTEXTS, ice.BASE) }()
+				m.Cmd(PUBLISH, mdb.CREATE, kit.MDB_FILE, ice.BIN_ICE_BIN)
+				m.Cmd(PUBLISH, mdb.CREATE, kit.MDB_FILE, ice.BIN_ICE_SH)
+				_bin_list(m, m.Config(kit.MDB_PATH))
+			}},
+			ice.INTSHELL: {Name: "intshell", Help: "神农架", Hand: func(m *ice.Message, arg ...string) {
+				defer func() { m.Cmdy(PUBLISH, ice.CONTEXTS, ice.MISC) }()
+				m.Cmd(nfs.DEFS, path.Join(m.Config(kit.MDB_PATH), ice.ORDER_SH), m.Config(SH))
+				_publish_list(m, ".*\\.(sh|vim|conf)$")
+			}},
+			ice.CONTEXTS: {Name: "contexts", Help: "环境", Hand: func(m *ice.Message, arg ...string) {
+				u := kit.ParseURL(tcp.ReplaceLocalhost(m, m.Option(ice.MSG_USERWEB)))
+				m.Option("httphost", fmt.Sprintf("%s://%s:%s", u.Scheme, strings.Split(u.Host, ":")[0], kit.Select(kit.Select("80", "443", u.Scheme == "https"), strings.Split(u.Host, ":"), 1)))
+
+				if len(arg) == 0 {
+					arg = append(arg, "misc", "core", "base", "binary", "source", "project")
+				}
+				for _, k := range arg {
+					if buf, err := kit.Render(m.Config(kit.Keys(ice.CONTEXTS, k)), m); m.Assert(err) {
+						m.EchoScript(strings.TrimSpace(string(buf)))
+					}
+				}
+			}},
+			mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
+				m.Cmdy(web.DREAM, mdb.INPUTS, arg)
+			}},
+			mdb.CREATE: {Name: "create file", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
+				_publish_file(m, m.Option(kit.MDB_FILE))
+			}},
+			nfs.TRASH: {Name: "trash", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
+				p := m.Option(cli.CMD_DIR, m.Config(kit.MDB_PATH))
+				os.Remove(path.Join(p, m.Option(kit.MDB_PATH)))
+			}},
+		}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+			m.Option(nfs.DIR_ROOT, m.Config(kit.MDB_PATH))
+			m.Cmdy(nfs.DIR, kit.Select("", arg, 0), "time,size,path,action,link")
+		}},
 	}})
 }
 
@@ -159,23 +131,22 @@ var _contexts = kit.Dict(
 	"project", `# 创建项目
 ctx_temp=$(mktemp); curl -fsSL https://shylinux.com -o $ctx_temp; source $ctx_temp project
 `,
-	"source", `# 源码安装
+	"source", `# 下载源码
 ctx_temp=$(mktemp); curl -fsSL https://shylinux.com -o $ctx_temp; source $ctx_temp source
 `,
-	"binary", `# 应用安装
+	"binary", `# 安装应用
 ctx_temp=$(mktemp); curl -fsSL https://shylinux.com -o $ctx_temp; source $ctx_temp binary
-`,
-	"miss", `# 开发环境
-export ctx_dev={{.Option "httphost"}}; ctx_temp=$(mktemp); curl -fsSL $ctx_dev -o $ctx_temp; source $ctx_temp dev
 `,
 	"base", `# 生产环境
 export ctx_dev={{.Option "httphost"}}; ctx_temp=$(mktemp); curl -fsSL $ctx_dev -o $ctx_temp; source $ctx_temp app
 `,
-	"tmux", `# 终端环境
+	"core", `# 开发环境
+export ctx_dev={{.Option "httphost"}}; ctx_temp=$(mktemp); curl -fsSL $ctx_dev -o $ctx_temp; source $ctx_temp dev
+`,
+	"misc", `# 终端环境
 export ctx_dev={{.Option "httphost"}}; ctx_temp=$(mktemp); curl -fsSL $ctx_dev -o $ctx_temp; source $ctx_temp
 `,
 	"tool", `# 群组环境
-mkdir contexts; cd contexts
 export ctx_dev={{.Option "httphost"}} ctx_share={{.Option "share"}} ctx_river={{.Option "sess.river"}} ctx_temp=$(mktemp); curl -fsSL $ctx_dev -o $ctx_temp; source $ctx_temp app
 `,
 )

core/code/sh.go

@@ -1,111 +1,88 @@
 package code
 
 import (
-	"path"
-
 	ice "shylinux.com/x/icebergs"
 	"shylinux.com/x/icebergs/base/cli"
 	"shylinux.com/x/icebergs/base/mdb"
-	"shylinux.com/x/icebergs/base/nfs"
 	kit "shylinux.com/x/toolkits"
 )
 
 const SH = "sh"
 
 func init() {
-	Index.Register(&ice.Context{Name: SH, Help: "命令",
+	Index.Register(&ice.Context{Name: SH, Help: "命令", Commands: map[string]*ice.Command{
-		Commands: map[string]*ice.Command{
+		ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-			ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+			for _, cmd := range []string{mdb.PLUGIN, mdb.RENDER, mdb.ENGINE, mdb.SEARCH} {
-				for _, cmd := range []string{mdb.PLUGIN, mdb.RENDER, mdb.ENGINE, mdb.SEARCH} {
+				m.Cmd(cmd, mdb.CREATE, SH, m.Prefix(SH))
-					m.Cmd(cmd, mdb.CREATE, SH, m.Prefix(SH))
+			}
+			LoadPlug(m, SH)
+		}},
+		SH: {Name: SH, Help: "命令", Action: ice.MergeAction(map[string]*ice.Action{
+			mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) {
+				m.Option(cli.CMD_DIR, arg[2])
+				m.Cmdy(cli.SYSTEM, SH, arg[1])
+				m.Set(ice.MSG_APPEND)
+			}},
+			mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
+				if arg[0] == kit.MDB_FOREACH {
+					return
 				}
-				LoadPlug(m, SH)
+				m.Option(cli.CMD_DIR, kit.Select(ice.SRC, arg, 2))
+				m.Cmdy(mdb.SEARCH, MAN1, arg[1:])
+				m.Cmdy(mdb.SEARCH, MAN8, arg[1:])
+				_go_find(m, kit.Select(kit.MDB_MAIN, arg, 1))
+				_go_grep(m, kit.Select(kit.MDB_MAIN, arg, 1))
 			}},
-			SH: {Name: SH, Help: "命令", Action: map[string]*ice.Action{
+			MAN: {Hand: func(m *ice.Message, arg ...string) {
-				mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) {
+				m.Echo(_c_help(m, arg[0], arg[1]))
-					m.Echo(m.Conf(SH, kit.Keym(PLUG)))
-				}},
-				mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) {
-					m.Cmdy(nfs.CAT, path.Join(arg[2], arg[1]))
-				}},
-				mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) {
-					m.Option(cli.CMD_DIR, arg[2])
-					m.Cmdy(cli.SYSTEM, SH, arg[1])
-					m.Set(ice.MSG_APPEND)
-				}},
-				mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
-					if arg[0] == kit.MDB_FOREACH {
-						return
-					}
-					m.Option(cli.CMD_DIR, kit.Select("src", arg, 2))
-					_go_find(m, kit.Select(kit.MDB_MAIN, arg, 1))
-					m.Cmdy(mdb.SEARCH, MAN1, arg[1:])
-					m.Cmdy(mdb.SEARCH, MAN8, arg[1:])
-					_go_grep(m, kit.Select(kit.MDB_MAIN, arg, 1))
-				}},
-
-				MAN: {Hand: func(m *ice.Message, arg ...string) {
-					m.Echo(_c_help(m, arg[0], arg[1]))
-				}},
 			}},
-		},
+		}, PlugAction())},
-		Configs: map[string]*ice.Config{
+	}, Configs: map[string]*ice.Config{
-			SH: {Name: SH, Help: "命令", Value: kit.Data(
+		SH: {Name: SH, Help: "命令", Value: kit.Data(PLUG, kit.Dict(
-				PLUG, kit.Dict(
+			SPLIT, kit.Dict("space", " ", "operator", "{[(.,;!|<>)]}"),
-					SPLIT, kit.Dict(
+			PREFIX, kit.Dict("#", COMMENT),
-						"space", " ",
+			SUFFIX, kit.Dict("{", COMMENT),
-						"operator", "{[(.,;!|<>)]}",
+			PREPARE, kit.Dict(
-					),
+				KEYWORD, kit.Simple(
-					PREFIX, kit.Dict(
+					"export",
-						"#", COMMENT,
+					"source",
-					),
+					"require",
-					SUFFIX, kit.Dict(
-						"{", COMMENT,
-					),
-					PREPARE, kit.Dict(
-						KEYWORD, kit.Simple(
-							"export",
-							"source",
-							"require",
 
-							"if",
+					"if",
-							"then",
+					"then",
-							"else",
+					"else",
-							"fi",
+					"fi",
-							"for",
+					"for",
-							"while",
+					"while",
-							"do",
+					"do",
-							"done",
+					"done",
-							"esac",
+					"esac",
-							"case",
+					"case",
-							"in",
+					"in",
-							"return",
+					"return",
 
-							"shift",
+					"shift",
-							"local",
+					"local",
-							"echo",
+					"echo",
-							"eval",
+					"eval",
-							"kill",
+					"kill",
-							"let",
+					"let",
-							"cd",
+					"cd",
-						),
-						FUNCTION, kit.Simple(
-							"xargs",
-							"date",
-							"find",
-							"grep",
-							"sed",
-							"awk",
-							"pwd",
-							"ps",
-							"ls",
-							"rm",
-							"go",
-						),
-					),
-					KEYWORD, kit.Dict(),
 				),
-			)},
+				FUNCTION, kit.Simple(
-		},
+					"xargs",
-	}, nil)
+					"date",
+					"find",
+					"grep",
+					"sed",
+					"awk",
+					"pwd",
+					"ps",
+					"ls",
+					"rm",
+					"go",
+				),
+			), KEYWORD, kit.Dict(),
+		))},
+	}}, nil)
 }

core/code/shy.go

@@ -5,62 +5,49 @@ import (
 
 	ice "shylinux.com/x/icebergs"
 	"shylinux.com/x/icebergs/base/mdb"
-	"shylinux.com/x/icebergs/base/nfs"
 	kit "shylinux.com/x/toolkits"
 )
 
 const SHY = "shy"
 
 func init() {
-	Index.Register(&ice.Context{Name: SHY, Help: "脚本",
+	Index.Register(&ice.Context{Name: SHY, Help: "脚本", Commands: map[string]*ice.Command{
-		Commands: map[string]*ice.Command{
+		ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-			ice.CTX_INIT: {Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+			for _, cmd := range []string{mdb.PLUGIN, mdb.RENDER, mdb.ENGINE, mdb.SEARCH} {
-				for _, cmd := range []string{mdb.PLUGIN, mdb.RENDER, mdb.ENGINE, mdb.SEARCH} {
+				m.Cmd(cmd, mdb.CREATE, SHY, m.Prefix(SHY))
-					m.Cmd(cmd, mdb.CREATE, SHY, m.Prefix(SHY))
+			}
+			LoadPlug(m, SHY)
+		}},
+		SHY: {Name: SHY, Help: "脚本", Action: ice.MergeAction(map[string]*ice.Action{
+			mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) {
+				m.Cmdy("web.wiki.word", path.Join(arg[2], arg[1]))
+			}},
+			mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
+				if arg[0] == kit.MDB_FOREACH {
+					return
 				}
-				LoadPlug(m, SHY)
+				_go_find(m, kit.Select(kit.MDB_MAIN, arg, 1))
+				_go_grep(m, kit.Select(kit.MDB_MAIN, arg, 1))
 			}},
-			SHY: {Name: SHY, Help: "脚本", Action: map[string]*ice.Action{
+		}, PlugAction())},
-				mdb.PLUGIN: {Hand: func(m *ice.Message, arg ...string) {
+	}, Configs: map[string]*ice.Config{
-					m.Echo(m.Conf(SHY, kit.Keym(PLUG)))
+		SHY: {Name: SHY, Help: "脚本", Value: kit.Data(PLUG, kit.Dict(
-				}},
+			PREFIX, kit.Dict("#", COMMENT),
-				mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) {
+			PREPARE, kit.Dict(
-					m.Cmdy(nfs.CAT, path.Join(arg[2], arg[1]))
+				KEYWORD, kit.Simple(
-				}},
+					"title",
-				mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) {
+					"premenu",
-					m.Cmdy("web.wiki.word", path.Join(arg[2], arg[1]))
+					"chapter",
-				}},
+					"section",
-				mdb.SEARCH: {Hand: func(m *ice.Message, arg ...string) {
+					"source",
-					if arg[0] == kit.MDB_FOREACH {
+					"refer",
-						return
+					"field",
-					}
+					"spark",
-					_go_find(m, kit.Select(kit.MDB_MAIN, arg, 1))
+					"image",
-					_go_grep(m, kit.Select(kit.MDB_MAIN, arg, 1))
+					"label",
-				}},
+					"chain",
-			}},
-		},
-		Configs: map[string]*ice.Config{
-			SHY: {Name: SHY, Help: "脚本", Value: kit.Data(
-				PLUG, kit.Dict(
-					PREFIX, kit.Dict("#", COMMENT),
-					PREPARE, kit.Dict(
-						KEYWORD, kit.Simple(
-							"title",
-							"premenu",
-							"chapter",
-							"section",
-							"source",
-							"refer",
-							"field",
-							"spark",
-							"image",
-							"label",
-							"chain",
-						),
-					),
-					KEYWORD, kit.Dict(),
 				),
-			)},
+			), KEYWORD, kit.Dict(),
-		},
+		))},
-	}, nil)
+	}}, nil)
 }

core/code/upgrade.go

@@ -13,37 +13,34 @@ import (
 const UPGRADE = "upgrade"
 
 func init() {
-	Index.Merge(&ice.Context{
+	Index.Merge(&ice.Context{Configs: map[string]*ice.Config{
-		Configs: map[string]*ice.Config{
+		UPGRADE: {Name: UPGRADE, Help: "升级", Value: kit.Dict(kit.MDB_HASH, kit.Dict(
-			UPGRADE: {Name: UPGRADE, Help: "升级", Value: kit.Dict(kit.MDB_HASH, kit.Dict(
+			cli.SYSTEM, kit.Dict(kit.MDB_LIST, kit.List(
-				cli.SYSTEM, kit.Dict(kit.MDB_LIST, kit.List(
+				kit.MDB_TYPE, "bin", kit.MDB_FILE, "ice.sh", kit.MDB_PATH, ice.BIN_ICE_SH,
-					kit.MDB_TYPE, "bin", kit.MDB_FILE, "ice.sh", kit.MDB_PATH, ice.BIN_ICE_SH,
+				kit.MDB_TYPE, "bin", kit.MDB_FILE, "ice.bin", kit.MDB_PATH, ice.BIN_ICE_BIN,
-					kit.MDB_TYPE, "bin", kit.MDB_FILE, "ice.bin", kit.MDB_PATH, ice.BIN_ICE_BIN,
+			)),
-				)),
+			cli.SOURCE, kit.Dict(kit.MDB_LIST, kit.List(
-				cli.SOURCE, kit.Dict(kit.MDB_LIST, kit.List(
+				kit.MDB_TYPE, "txt", kit.MDB_FILE, "main.go", kit.MDB_PATH, ice.SRC_MAIN_GO,
-					kit.MDB_TYPE, "txt", kit.MDB_FILE, "main.go", kit.MDB_PATH, ice.SRC_MAIN_GO,
+				kit.MDB_TYPE, "txt", kit.MDB_FILE, "miss.sh", kit.MDB_PATH, ice.ETC_MISS_SH,
-					kit.MDB_TYPE, "txt", kit.MDB_FILE, "miss.sh", kit.MDB_PATH, ice.ETC_MISS_SH,
+				kit.MDB_TYPE, "txt", kit.MDB_FILE, "go.mod", kit.MDB_PATH, ice.GO_MOD,
-					kit.MDB_TYPE, "txt", kit.MDB_FILE, "go.mod", kit.MDB_PATH, ice.GO_MOD,
+			)),
-				)),
+		))},
-			))},
+	}, Commands: map[string]*ice.Command{
-		},
+		UPGRADE: {Name: "upgrade item=system,source run:button", Help: "升级", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
-		Commands: map[string]*ice.Command{
+			m.Grows(cmd, kit.Keys(kit.MDB_HASH, kit.Select(cli.SYSTEM, arg, 0)), "", "", func(index int, value map[string]interface{}) {
-			UPGRADE: {Name: "upgrade item=system,source run:button", Help: "升级", Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
+				if value[kit.MDB_PATH] == ice.BIN_ICE_BIN { // 程序文件
-				m.Grows(cmd, kit.Keys(kit.MDB_HASH, kit.Select(cli.SYSTEM, arg, 0)), "", "", func(index int, value map[string]interface{}) {
+					value[kit.MDB_FILE] = kit.Keys(ice.ICE, runtime.GOOS, runtime.GOARCH)
-					if value[kit.MDB_PATH] == ice.BIN_ICE_BIN { // 程序文件
+					m.Option(ice.EXIT, ice.TRUE)
-						value[kit.MDB_FILE] = kit.Keys("ice", runtime.GOOS, runtime.GOARCH)
-						m.Option("exit", ice.TRUE)
-					}
-
-					// 下载文件
-					msg := m.Cmd(web.SPIDE, ice.DEV, web.SPIDE_CACHE, web.SPIDE_GET, "/publish/"+kit.Format(value[kit.MDB_FILE]))
-					m.Cmd(web.STORY, web.WATCH, msg.Append(kit.MDB_FILE), value[kit.MDB_PATH])
-					os.Chmod(kit.Format(value[kit.MDB_PATH]), 0770)
-				})
-				if m.Option("exit") == ice.TRUE {
-					m.Sleep("1s").Go(func() { m.Cmd("exit", 1) })
 				}
-			}},
+
-		},
+				// 下载文件
-	})
+				msg := m.Cmd(web.SPIDE, ice.DEV, web.SPIDE_CACHE, web.SPIDE_GET, "/publish/"+kit.Format(value[kit.MDB_FILE]))
+				m.Cmd(web.STORY, web.WATCH, msg.Append(kit.MDB_FILE), value[kit.MDB_PATH])
+				os.Chmod(kit.Format(value[kit.MDB_PATH]), 0770)
+			})
+			if m.Option(ice.EXIT) == ice.TRUE {
+				m.Sleep("1s").Go(func() { m.Cmd(ice.EXIT, 1) })
+			}
+		}},
+	}})
 }

core/code/vimer.go

@@ -1,9 +1,7 @@
 package code
 
 import (
-	"os"
 	"path"
-	"strings"
 
 	ice "shylinux.com/x/icebergs"
 	"shylinux.com/x/icebergs/base/cli"
@@ -17,48 +15,40 @@ const VIMER = "vimer"
 func init() {
 	Index.Merge(&ice.Context{Commands: map[string]*ice.Command{
 		VIMER: {Name: "vimer path=src/ file=main.go line=1 refresh:button=auto save", Help: "编辑器", Meta: kit.Dict(
-			ice.Display("/plugin/local/code/vimer.js", "inner"),
+			ice.Display("/plugin/local/code/vimer.js", INNER),
 		), Action: map[string]*ice.Action{
+			nfs.SAVE: {Name: "save type file path", Help: "保存", Hand: func(m *ice.Message, arg ...string) {
+				m.Cmdy(nfs.SAVE, path.Join(m.Option(kit.MDB_PATH), m.Option(kit.MDB_FILE)))
+			}},
 			mdb.ENGINE: {Name: "engine", Help: "运行", Hand: func(m *ice.Message, arg ...string) {
-				if m.Cmdy(mdb.ENGINE, arg); len(m.Resultv()) > 0 || len(m.Appendv(ice.MSG_APPEND)) > 0 {
+				if m.Cmdy(mdb.ENGINE, arg); len(m.Resultv()) > 0 || m.Length() > 0 {
 					return
 				}
 
-				if arg = kit.Split(strings.Join(arg, " ")); m.Right(arg) {
+				if arg = kit.Split(kit.Join(arg, ice.SP)); m.Right(arg) {
-					if m.Cmdy(arg); len(m.Appendv(ice.MSG_APPEND)) == 0 && len(m.Resultv()) == 0 {
+					if m.Cmdy(arg); len(m.Resultv()) == 0 && m.Length() == 0 {
 						m.Cmdy(cli.SYSTEM, arg)
 					}
 				}
 			}},
-			nfs.SAVE: {Name: "save type file path", Help: "保存", Hand: func(m *ice.Message, arg ...string) {
+			mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
-				m.Cmdy(nfs.SAVE, path.Join(m.Option(kit.MDB_PATH), m.Option(kit.MDB_FILE)))
+				m.Cmdy(AUTOGEN, mdb.INPUTS, arg)
 			}},
 			AUTOGEN: {Name: "create main=src/main.go@key key zone type=Zone,Hash,Data name=hi list help", Help: "模块", Hand: func(m *ice.Message, arg ...string) {
 				m.Cmdy(AUTOGEN, mdb.CREATE, arg)
 			}},
-			COMPILE: {Name: "compile", Help: "编译", Hand: func(m *ice.Message, arg ...string) {
-				m.Option(cli.CMD_ENV,
-					cli.HOME, os.Getenv(cli.HOME), cli.PATH, os.Getenv(cli.PATH),
-					"CGO_ENABLED", "0", "GOCACHE", os.Getenv("GOCACHE"),
-					"GOPRIVATE", "shylinux.com",
-				)
-
-				_autogen_version(m)
-				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()
-			}},
 			BINPACK: {Name: "binpack", Help: "打包", Hand: func(m *ice.Message, arg ...string) {
 				m.Cmdy(AUTOGEN, BINPACK)
-				p := path.Join("src/release", ice.GO_MOD)
+				m.Cmd(nfs.COPY, ice.GO_MOD, path.Join(ice.SRC_RELEASE, ice.GO_MOD))
-				if _, e := os.Stat(p); e == nil {
-					m.Cmd(nfs.COPY, ice.GO_MOD, p)
-				}
 				m.ProcessInner()
 			}},
-			mdb.INPUTS: {Name: "inputs", Help: "补全", Hand: func(m *ice.Message, arg ...string) {
+			COMPILE: {Name: "compile", Help: "编译", Hand: func(m *ice.Message, arg ...string) {
-				m.Cmdy(AUTOGEN, mdb.INPUTS, arg)
+				m.Cmdy(COMPILE, ice.SRC_MAIN_GO)
+				m.Cmdy(nfs.LINK, ice.BIN_ICE_BIN, m.Append(nfs.PATH))
+				if cli.IsSuccess(m) {
+					m.Cmd(ice.EXIT, "1")
+				}
+				m.ProcessInner()
 			}},
 		}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 			m.Cmdy(INNER, arg)

core/code/webpack.go

@@ -11,26 +11,36 @@ import (
 	kit "shylinux.com/x/toolkits"
 )
 
-func _volcanos(file ...string) string {
+func _volcanos(m *ice.Message, file ...string) string {
-	return path.Join(ice.USR_VOLCANOS, path.Join(file...))
+	return path.Join(m.Conf(web.SERVE, kit.Keym(ice.VOLCANOS, kit.MDB_PATH)), path.Join(file...))
 }
-func _publish(file ...string) string {
+func _publish(m *ice.Message, file ...string) string {
-	return path.Join(ice.USR_PUBLISH, path.Join(file...))
+	return path.Join(m.Conf(PUBLISH, kit.Keym(kit.MDB_PATH)), path.Join(file...))
 }
 
+const (
+	PUBLISH_ORDER_JS = "publish/order.js"
+	PAGE_CACHE_CSS   = "page/cache.css"
+	PAGE_INDEX_CSS   = "page/index.css"
+	PAGE_CACHE_JS    = "page/cache.js"
+	PAGE_INDEX_JS    = "page/index.js"
+	PAGE_CMD_CSS     = "page/cmd.css"
+	PAGE_CMD_JS      = "page/cmd.js"
+)
+
 const DEVPACK = "devpack"
 const WEBPACK = "webpack"
 
 func init() {
 	Index.Merge(&ice.Context{Commands: map[string]*ice.Command{
 		WEBPACK: {Name: "webpack path auto create prunes", Help: "打包", Action: map[string]*ice.Action{
-			mdb.CREATE: {Name: "create name=demo", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
+			mdb.CREATE: {Name: "create name=hi", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
-				dir := m.Conf(web.SERVE, kit.Keym(ice.VOLCANOS, kit.MDB_PATH))
+				dir := _volcanos(m)
-				css, _, e := kit.Create(path.Join(dir, "page/cache.css"))
+				css, _, e := kit.Create(path.Join(dir, PAGE_CACHE_CSS))
 				m.Assert(e)
 				defer css.Close()
 
-				js, _, e := kit.Create(path.Join(dir, "page/cache.js"))
+				js, _, e := kit.Create(path.Join(dir, PAGE_CACHE_JS))
 				m.Assert(e)
 				defer js.Close()
 
@@ -41,7 +51,7 @@ func init() {
 				for _, k := range []string{"lib", "panel", "plugin"} {
 					m.Cmd(nfs.DIR, k).Table(func(index int, value map[string]string, head []string) {
 						if kit.Ext(value[kit.MDB_PATH]) == CSS {
-							js.WriteString(`Volcanos.meta.cache["` + path.Join("/", value[kit.MDB_PATH]) + "\"] = []\n")
+							js.WriteString(`Volcanos.meta.cache["` + path.Join(ice.PS, value[kit.MDB_PATH]) + "\"] = []\n")
 							css.WriteString(m.Cmdx(nfs.CAT, value[kit.MDB_PATH]))
 						}
 					})
@@ -50,49 +60,52 @@ func init() {
 				for _, k := range []string{"lib", "panel", "plugin"} {
 					m.Cmd(nfs.DIR, k).Table(func(index int, value map[string]string, head []string) {
 						if kit.Ext(value[kit.MDB_PATH]) == JS {
-							js.WriteString(`_can_name = "` + path.Join("/", value[kit.MDB_PATH]) + "\";\n")
+							js.WriteString(`_can_name = "` + path.Join(ice.PS, value[kit.MDB_PATH]) + "\";\n")
 							js.WriteString(m.Cmdx(nfs.CAT, value[kit.MDB_PATH]))
 						}
 					})
 				}
 
-				for _, k := range []string{"publish/order.js", "frame.js"} {
+				for _, k := range []string{PUBLISH_ORDER_JS, ice.FRAME_JS} {
-					js.WriteString(`_can_name = "` + path.Join("/", k) + "\"\n")
+					js.WriteString(`_can_name = "` + path.Join(ice.PS, k) + "\"\n")
 					js.WriteString(m.Cmdx(nfs.CAT, k))
 				}
 
-				if f, _, e := kit.Create(path.Join(ice.USR_PUBLISH, WEBPACK, kit.Keys(m.Option(kit.MDB_NAME), JS))); m.Assert(e) {
+				if f, _, e := kit.Create(_publish(m, WEBPACK, kit.Keys(m.Option(kit.MDB_NAME), JS))); m.Assert(e) {
 					defer f.Close()
 
 					f.WriteString(ice.NL)
-					f.WriteString(kit.Format(`Volcanos.meta.args = {river: "%s", storm: "%s"}`, m.Option("river"), m.Option("storm")))
+					f.WriteString(kit.Format(`Volcanos.meta.args = {river: "%s", storm: "%s"}`, m.Option(web.RIVER), m.Option(web.STORM)))
 					f.WriteString(ice.NL)
 					f.WriteString(`Volcanos.meta.pack = ` + kit.Formats(kit.UnMarshal(kit.Select("{}", m.Option("content")))))
 				}
 
 				m.Option(nfs.DIR_ROOT, "")
-				if f, p, e := kit.Create(_publish(WEBPACK, kit.Keys(m.Option(kit.MDB_NAME), HTML))); m.Assert(e) {
+				if f, p, e := kit.Create(_publish(m, WEBPACK, kit.Keys(m.Option(kit.MDB_NAME), HTML))); m.Assert(e) {
+					defer f.Close()
+
 					f.WriteString(fmt.Sprintf(_pack,
-						m.Cmdx(nfs.CAT, _volcanos("page/cache.css")),
+						m.Cmdx(nfs.CAT, _volcanos(m, PAGE_CACHE_CSS)),
-						m.Cmdx(nfs.CAT, _volcanos("page/index.css")),
+						m.Cmdx(nfs.CAT, _volcanos(m, PAGE_INDEX_CSS)),
 
-						m.Cmdx(nfs.CAT, _volcanos(ice.PROTO_JS)),
+						m.Cmdx(nfs.CAT, _volcanos(m, ice.PROTO_JS)),
-						m.Cmdx(nfs.CAT, _publish(path.Join(WEBPACK, kit.Keys(m.Option(kit.MDB_NAME), JS)))),
+						m.Cmdx(nfs.CAT, _publish(m, path.Join(WEBPACK, kit.Keys(m.Option(kit.MDB_NAME), JS)))),
 
-						m.Cmdx(nfs.CAT, _volcanos("page/cache.js")),
+						m.Cmdx(nfs.CAT, _volcanos(m, PAGE_CACHE_JS)),
-						m.Cmdx(nfs.CAT, _volcanos("page/index.js")),
+						m.Cmdx(nfs.CAT, _volcanos(m, PAGE_INDEX_JS)),
 					))
 					m.Echo(p)
 				}
 
-				m.Cmd(nfs.COPY, _volcanos("page/cmd.css"), _volcanos("page/index.css"), _volcanos("page/cache.css"))
+				m.Cmd(nfs.COPY, _volcanos(m, PAGE_CMD_CSS), _volcanos(m, PAGE_INDEX_CSS), _volcanos(m, PAGE_CACHE_CSS))
-				m.Cmd(nfs.COPY, _volcanos("page/cmd.js"), _volcanos("proto.js"), _volcanos("frame.js"), _volcanos("page/cache.js"))
+				m.Cmd(nfs.COPY, _volcanos(m, PAGE_CMD_JS), _volcanos(m, ice.PROTO_JS), _volcanos(m, PAGE_CACHE_JS))
 			}},
 			mdb.REMOVE: {Name: "remove", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
-				m.Cmd(nfs.SAVE, _volcanos("page/cache.js"))
+				m.Cmd(nfs.SAVE, _volcanos(m, PAGE_CACHE_JS))
-				m.Cmd(nfs.SAVE, _volcanos("page/cache.css"))
+				m.Cmd(nfs.SAVE, _volcanos(m, PAGE_CACHE_CSS))
-				m.Cmd(nfs.COPY, _volcanos("page/cmd.css"), _volcanos("page/index.css"), _volcanos("page/cache.css"))
+
-				m.Cmd(nfs.COPY, _volcanos("page/cmd.js"), _volcanos("proto.js"), _volcanos("page/cache.js"))
+				m.Cmd(nfs.COPY, _volcanos(m, PAGE_CMD_CSS), _volcanos(m, PAGE_INDEX_CSS), _volcanos(m, PAGE_CACHE_CSS))
+				m.Cmd(nfs.COPY, _volcanos(m, PAGE_CMD_JS), _volcanos(m, ice.PROTO_JS), _volcanos(m, PAGE_CACHE_JS))
 			}},
 		}, Hand: func(m *ice.Message, c *ice.Context, cmd string, arg ...string) {
 			m.Option(nfs.DIR_DEEP, true)
@@ -107,14 +120,7 @@ func init() {
 const _pack = `
 <!DOCTYPE html>
 <head>
-    <link rel="orange-touch-icon-precomposed" href="/publish/app.png"/>
-    <link rel="orange-touch-startup-image" href="/publish/splash.png"/>
-    <meta name="orange-mobile-web-app-capable" content="yes"/>
-    <meta name="orange-mobile-web-app-status-bar-style" content="black-translucent"/>
-
-    <meta name="viewport" content="width=device-width,initial-scale=0.8,user-scalable=no">
     <meta charset="utf-8">
-    <title>volcanos</title>
     <style type="text/css">%s</style>
     <style type="text/css">%s</style>
 </head>

data.go

@@ -23,6 +23,12 @@ func (m *Message) Config(key string, arg ...interface{}) string {
 	}
 	return m.Conf(m.PrefixKey(), kit.Keym(key))
 }
+func (m *Message) Configv(key string, arg ...interface{}) interface{} {
+	if len(arg) > 0 {
+		m.Confv(m.PrefixKey(), kit.Keym(key), arg[0])
+	}
+	return m.Confv(m.PrefixKey(), kit.Keym(key))
+}
 func (m *Message) ConfigSimple(key ...string) (list []string) {
 	for _, k := range kit.Split(kit.Join(key)) {
 		list = append(list, k, m.Config(k))

render.go

@@ -76,7 +76,13 @@ func (m *Message) RenderIndex(serve, repos string, file ...string) *Message {
 func (m *Message) RenderCmd(index string, args ...interface{}) {
 	list := index
 	if index != "" {
-		list = kit.Format(kit.List(kit.Dict("index", index, "args", kit.Simple(args))))
+		msg := m.Cmd("command", index)
+		list = kit.Format(kit.List(kit.Dict(
+			kit.MDB_INDEX, index, kit.MDB_ARGS, kit.Simple(args),
+			msg.AppendSimple(kit.MDB_NAME, kit.MDB_HELP),
+			"feature", kit.UnMarshal(msg.Append("meta")),
+			"inputs", kit.UnMarshal(msg.Append("list")),
+		)))
 	}
 	m.RenderResult(kit.Format(`<!DOCTYPE html>
 <head>