diff --git a/etc/common.shy b/etc/common.shy
index 4d34dbc0..029decdd 100644
--- a/etc/common.shy
+++ b/etc/common.shy
@@ -1,11 +1,2 @@
 ~aaa
     role root user shy shaoying
-
-# ~mdb
-#     note model favor spirit spirit relate relate
-#     note model money expend expend amount amount
-#     note model state active active elapse elapse
-#     note model event action action target target
-#     note model proxy ctx text cmd text
-#     note model share stuff stuff right right
-#
diff --git a/etc/exit.shy b/etc/exit.shy
index 8167d0bd..f88bbb98 100644
--- a/etc/exit.shy
+++ b/etc/exit.shy
@@ -1,9 +1,6 @@
-~wiki
-    config save var/tmp/wiki.json wiki_visit
-~mdb
-    config save var/tmp/data.json ktv
 ~ssh
-    config save var/tmp/cert.json work flow trust
+    config save var/data/flow.json flow
+    config save var/data/work.json work
 ~aaa
     config save var/tmp/auth.json auth
 ~cli
diff --git a/etc/init.shy b/etc/init.shy
index b2e2417a..f8aec5e9 100644
--- a/etc/init.shy
+++ b/etc/init.shy
@@ -3,11 +3,8 @@
 ~aaa
     config load tmp/auth.json auth
 ~ssh
-    config load tmp/cert.json work flow
-~mdb
-    config load tmp/data.json ktv
-~wiki
-    config load tmp/wiki.json wiki_visit
+    config load var/data/work.json work
+    config load var/data/flow.json flow
 
 ~nfs
     source etc/common.shy
diff --git a/src/README.md b/src/README.md
new file mode 100644
index 00000000..6c233832
--- /dev/null
+++ b/src/README.md
@@ -0,0 +1,930 @@
+## 源码解析
+
+- toolkit  工具类代码
+- contexts 框架类代码
+- examples 应用类代码
+- extend 启动代码
+- plugin 插件代码
+
+## 系统架构
+| |数据流|命令流|权限流|应用流|
+|---|---|---|---|---|
+|应用层|ctx|cli|aaa|web|
+|控制层|lex|yac|gdb|log|
+|数据层|tcp|nfs|ssh|mdb|
+
+### 模块化
+### 命令化
+### 插件化
+
+## 插件开发
+### 前端
+### 后端
+## 应用开发
+### code代码
+### wiki文档
+### chat聊天
+### team办公
+### mall商务
+## 框架开发
+### 通信框架
+### 存储引擎
+### 应用框架
+### 解析引擎
+
+
+
+更新到此....敬请期待
+----------------------------------------------
+
+## 创建群聊
+除了命令行的使用的方式之外，context还有自己的前端框架。
+不仅降低了使用难度，还提供更加场景化、自动化的应用界面。
+
+用户可以访问区域节点或是任意用户节点的网页服务。
+
+http://127.0.0.29:9095
+
+输入用户名与初始密码，即可登录，如果用户与主机上的用户名相同，则是管理员权限，如果不同，则是普通用户，只有最小的功能权限。
+
+所以任意节点都支持多用户共享使用，但只有管理用户有所有权限，进行资源的管理与分配。
+
+打开应用界面，就可以看到context以办公聊天软件的形式提供各种丰富的功能。
+
+左边框是用户群组列表，用户可以选择群聊或是创建新的群聊。
+中间就是聊天记录与输入框，用户可以自由的聊天收发消息。
+
+与其它聊天软件不同的是，context提供了自定义的功能列表。
+右边框中，就是此群组的功能列表。
+每个用户都可以将自己设备上的命令添加到这个群组的功能列表中，分享给本组员使用。
+每个组员都可以根据自己的需求组合这些命令，生成自己的应用界面。
+
+以每个群聊作为场景，进行资源的共享与应用的开发，从而实现更加场景化与个性化应用。
+
+通过这种精细化的应用场景，进行工具化、标准化、流程化。提高各行各业的工作效率。
+
+## 应用开发
+
+网络框架与应用界面，已经实现了标准化与自动化，剩下就是应用的开发了。
+
+开发者，可以在任意机器上开发自己的应用。以模块与函数为单位进行开发与上线。
+一个函数，即使只有几行代码，也是一个独立完整的应用，可以随时上线，被任意用户使用。
+
+用户还可以在任意群聊中转发此应用，更自由的传播出去。
+从而将软件开发的速度提升成千上万倍，将代码的使用效率提升成千上万倍。
+
+### 创建项目
+在任意节点上，执行project命令，指定项目名，即可创建应用目录。
+```
+$ bin/user.sh
+8[13:41:41]nfs> project hello
+time                line hash     path                     
+2019-07-30 14:27:09 35   eba8eda2 src/plugin/hello/index.go 
+2019-07-30 14:27:09 1    b858cb28 src/plugin/hello/index.shy
+2019-07-30 14:27:09 1    b858cb28 src/plugin/hello/local.shy
+2019-07-30 14:27:09 4    407265b6 src/plugin/hello/index.js 
+9[14:27:09]nfs> 
+```
+每个项目，都可以用go语言开发低层应用，用js开发前端交互。
+除此，context有自己的通用语法解析器，开者完全可以随时自定义语法，定制自己的解析器。
+用自己喜欢的语法开发应用。
+
+默认的shy语法，提供了一个完整的前后端应用框架。创建项目时，自动创建的模块如下。
+```
+fun hello world "" "" \
+	public \
+	text "" \
+	button "执行"
+	copy pwd
+end
+```
+
+这个模板就是一个完整的应用，fun关键字开关，end关键字结束。
+前四行就是定义应用界面，剩下代码就是后端脚本。
+public代表，这个应用是公共的，所以有人都可以访问。也可以是private，只有管理用户可以访问。
+
+text与button，就是需要前端展示的控件。用户在前端点击此button，就会将请求发送到后端，执行此脚本。
+然后将执行结果返回给前端界面。
+
+### 加载项目
+切换到cli模块，使用upgrade命令，加载新的项目应用。
+```
+8[13:41:41]nfs> ~cli
+8[13:41:41]cli> upgrade plugin hello
+3[15:55:53]cli> ~
+names    ctx msg  status stream helps   
+ctx          0    start  stdio  模块中心
+cli      ctx 4    begin         管理中心
+hello    cli 5958 start         shy     
+4[15:57:00]cli> 
+```
+
+切换到hello模块，使用command命令，可以查看到hello模块下的命令列表，然后就可以调用hello命令。
+```
+8[13:41:41]cli> ~hello
+6[15:58:42]hello> command
+key   name                                  
+hello hello world   public text  button 执行
+7[20:27:32]nice> hello
+D:\context/var
+```
+
+同时在前端界面上添加功能，即可看到此函数。
+
+context内部实现了很多功能模块，每个模块下有很多命令，每条命令就是一种应用。
+
+context的使用方式有很多种，
+
+- 可以直接调用，像Shell一样，去解析一条命令
+- 可以启动cli服务，像MySQL一样，交互式使用格式化命令
+- 可以启动web服务，像LabView一样，可以自定义各种图形界面
+- 可以自动组网，将任意台设备组合在一起，实现分布式应用
+- 可以自动建群，在群聊场景中，实现多用户、多会话、多任务、多设备的使用
+
+### 命令模式
+如果只是使用一条命令，或是写在脚本文件中，可以使用这种方式。
+
+例如，dir命令就是查看目录，
+```
+$ bin/bench dir
+time                 size  line  filename
+2019-06-16 10:35:18  324   11    common.shy
+2019-06-16 10:35:18  201   9     exit.shy
+2019-06-16 10:35:18  261   13    init.shy
+```
+
+还可以加更多参数，dir_deep递归查询目录，dir_type文件类型过滤，dir_sort输出表排序。
+```
+$ bin/bench dir ../ dir_deep dir_type file dir_sort line int_r
+time                 size      line   filename
+2019-06-16 10:22:52  13256968  91314  bench
+2019-06-16 11:10:16  1535      66     boot.sh
+2019-06-16 11:10:16  613       31     node.sh
+2019-06-16 11:10:16  261       13     init.shy
+2019-06-16 11:10:16  324       11     common.shy
+2019-06-16 11:10:16  201       9      exit.shy
+
+```
+
+### 交互模式
+
+启动服务，可以提供更丰富的命令与环境。
+```
+$ bin/bench
+0[11:35:46]ssh> dir
+time                 size  line  filename
+2019-06-16 11:35:06  160   3     log/
+2019-06-16 11:35:06  96    1     run/
+2019-06-16 11:35:44  192   4     tmp/
+1[11:35:46]ssh>
+```
+
+如果集中管理，命令越多，系统只会越复杂，学习成本越高，使用越低效，开发越困难。
+
+所以通过模块化，分而治之，更高效的管理丰富的命令。
+
+context命令就是用来管理模块，没有参数时，直接查看当前模块的信息。
+
+如下，第二行是当前模块，第一行是当前模块的父模块，其它行都是当前模块的子模块。
+
+```
+1[11:39:01]ssh> context
+names  ctx  msg  status  stream         helps
+ctx         0    start   shy            模块中心
+ssh    ctx  10   begin   ctx.nfs.file3  集群中心
+```
+
+context第一个参数，可以指定当前模块，
+如下，切换到nfs模块，然后查看各种IO模块，
+切换到ctx根模块，查看所有模块。
+```
+2[11:43:57]ssh> context nfs
+
+3[11:43:58]nfs> context
+names  ctx  msg   status  stream  helps
+ctx         0     start   shy     模块中心
+nfs    ctx  9     begin           存储中心
+stdio  nfs  1174  start   stdio   scan stdio
+
+4[11:44:22]ssh> context ctx
+
+5[11:45:17]ctx> context
+names    ctx  msg   status  stream    helps
+ctx           0     start   shy       模块中心
+aaa      ctx  3     begin             认证中心
+cli      ctx  4     begin             管理中心
+gdb      ctx  232   start             调试中心
+lex      ctx  6     begin             词法中心
+log      ctx  31    start   bench     日志中心
+mdb      ctx  8     begin             数据中心
+nfs      ctx  9     begin             存储中心
+ssh      ctx  10    begin             集群中心
+tcp      ctx  11    begin             网络中心
+web      ctx  1094  start   :9094     应用中心
+yac      ctx  13    begin   35,14,23  语法中心
+shy      cli  1171  start   engine    shell
+matrix1  lex  34    start   76,28,2   matrix
+stdio    nfs  1174  start   stdio     scan stdio
+chat     web  14    begin             会议中心
+code     web  15    begin             代码中心
+wiki     web  16    begin             文档中心
+engine   yac  1173  start   stdio     parse
+
+```
+
+command命令，就是用来管理当前模块的命令，
+```
+17[11:52:02]nfs> context nfs
+
+17[11:52:02]nfs> command
+key     name
+_init   _init
+action  action cmd
+copy    copy to from
+dir     dir [path [fields...]]
+export  export filename
+git     git sum
+hash    hash filename
+import  import filename [index]
+json    json str
+load    load file [buf_size [pos]]
+open    open file
+path    path filename
+printf  printf arg
+prompt  prompt arg
+pwd     pwd [all] | [[index] path]
+read    read [buf_size [pos]]
+remote  remote listen|dial args...
+save    save file string...
+scan    scan file name
+send    send [file] args...
+temp    temp data
+term    term action args...
+trash   trash file
+write   write string [pos]
+
+```
+
+help子命令，查看命令帮助信息。
+```
+18[11:59:19]nfs> command help dir
+dir: dir [path [fields...]]
+    查看目录, path: 路径, fields...: 查询字段, time|type|full|path|tree|filename|size|line|hash
+    dir_deep: 递归查询
+    dir_type both|file|dir|all: 文件类型
+    dir_reg reg: 正则表达式
+    dir_sort field order: 排序
+```
+
+
+### 集群模式
+
+context提供自动化集群的功能，可以自动组网、自动认证。从而快速实现多台设备的协同工作。
+
+#### 启动服务节点
+```
+$ bin/boot.sh
+0[11:35:12]ssh>
+```
+
+#### 启动工作节点
+
+新打开一个终端，启动工作节点，执行remote命令，查看上级节点，
+```
+$ bin/boot.sh create app/demo
+0[15:15:30]ssh> remote
+key  type    module         create_time
+mac  master  ctx.nfs.file3  2019-06-16 15:15:23
+```
+
+回到服务节点终端，执行remote命令，可以查看到所有远程节点。
+```
+2[15:15:31]ssh> remote
+key   type    module         create_time
+com   master  ctx.nfs.file4  2019-06-16 14:25:10
+demo  worker  ctx.nfs.file7  2019-06-16 15:15:23
+```
+
+默认配置中，子节点信任父，所以父节点可以调用子节点的命令。还有更复杂的认证机制，可以灵活配置。
+
+远程命令和本地命令一样，没有任何区别。如下调用demo节点的pwd命令。还支持更复杂的多节点命令，可以更快速的同时管理多台设备。
+```
+2[15:15:31]ssh> remote demo pwd
+/Users/shaoying/context/app/demo/var
+```
+
+#### 启动分机节点
+
+在服务节点的终端，查看服务地址
+```
+3[15:49:00]ssh> web.brow
+index  site
+0      http://192.168.199.139:9094
+```
+
+同样，在另一台设备上下载context，然后启动服务节点。
+通过环境变量ctx_dev指定上级节点。
+```
+$ ctx_dev="http://192.168.199.139:9094" bin/boot.sh
+0[15:49:00]ssh> remote
+key  type    module         create_time
+mac  master  ctx.nfs.file3  2019-06-16 15:15:23
+```
+
+回到服务节点终端，执行remote命令，可以查看到新添加了一个服务子节点。
+```
+2[15:15:31]ssh> remote
+key   type    module         create_time
+com   master  ctx.nfs.file4  2019-06-16 14:25:10
+demo  worker  ctx.nfs.file7  2019-06-16 15:15:23
+sub   server  ctx.nfs.file8  2019-06-16 16:15:23
+```
+
+同样可以远程调用命令。
+```
+2[15:15:31]ssh> remote sub pwd
+/Users/shaoying/context/app/sub/var
+```
+
+#### 文件管理
+调用本地命令，查看当前目录下的文件列表，
+```
+0[10:53:25]ssh> ls
+total 0
+drwxr-xr-x  5 shaoying  staff  160 May 10 03:57 bin
+drwxr-xr-x  5 shaoying  staff  160 May 10 03:30 etc
+drwxr-xr-x  2 shaoying  staff   64 May 10 03:30 usr
+drwxr-xr-x  8 shaoying  staff  256 May 10 03:36 var
+```
+
+调用内部命令，查看文件列表，如下dir与ls命令用途相似，但提供了更丰富的功能，如统计文件行数
+```
+5[10:56:24]ssh> dir etc
+time                 size  line  filename
+2019-04-14 21:29:21  316   10    common.shy
+2019-04-29 21:12:28  130   7     exit.shy
+2019-04-29 21:12:12  191   12    init.shy
+```
+
+"%"是一个内部命令，可以对前一步命令结果进行各种处理。如下按字段line排序
+```
+5[10:56:24]ssh> dir etc % order line
+time                 size  line  filename
+2019-04-29 21:12:12  191   12    init.shy
+2019-04-14 21:29:21  316   10    common.shy
+2019-04-29 21:12:28  130   7     exit.shy
+```
+
+如下按字段""聚合，即可得到汇总结果，所有文件的总字节数、总行数、总文件数
+```
+16[11:04:30]ssh> dir etc % group ""
+time                 size  line  filename    count
+2019-04-14 21:29:21  637   29    common.shy  3
+```
+
+#### 时间管理
+查看当前时间戳
+```
+18[11:11:01]ssh> time
+1557457862000
+```
+将时间戳转换成日期
+```
+19[11:11:14]ssh> time 1557457862000
+2019-05-10 11:11:02
+```
+将日期转换成时间戳
+```
+20[11:11:25]ssh> time "2019-05-10 11:11:02"
+1557457862000
+```
+
+#### 网卡管理
+```
+2[10:53:25]ssh> ifconfig
+index  name  ip             mask  hard
+5      en0   192.168.0.106  24    c4:b3:01:cf:0b:51
+```
+
+### 完整版
+命令行模式，只是context最基本的功能。context还提供了一个前端框架，
+让用户可以自由的组合功能列表，满足自己的需求。
+
+使用更丰富的功能，可以直接下载源码，
+```
+$ git clone https://github.com/shylinux/context.git
+```
+下载完源码后，如果安装了golang，就可以对源码直接进行编译，
+如果没有可以去官网下载安装golang（<https://golang.org/dl/>）。
+第一次make时，会自动下载各种依赖库，所以会慢一些。
+```
+$ cd context && make
+```
+
+#### 启动服务
+bin目录下是各种可执行文件，如启动脚本boot.sh与node.sh。
+
+node.sh用来启动单机版context，boot.sh用来启动网络版context。
+
+如下，直接运行脚本，即可启动context。
+
+启动context后，就可以解析执行各种命令，即可是本地的shell命令，也可以是内部模块命令。
+
+```
+$ bin/node.sh
+0[03:58:43]ssh>
+```
+
+#### 网页服务
+
+下载完整版的context，启动的服务节点，就会带有前端网页服务。
+
+#### 知识库
+
+wiki模块提供了知识库管理。
+
+访问：http://localhost:9094/wiki
+
+wiki模块会将usr/wiki目录下的md文件进行解析，生成网页文件，并自动生成目录与索引。
+
+可以创建自己的知识库，如下创建目录与文件。
+
+```
+$ mkdir -p usr/wiki/some
+$ echo "hello world" > usr/wiki/some/hi.md
+```
+
+然后在服务终端上，切换到新建的知识库，
+```
+0[10:53:25]ssh> ~wiki config wiki_level wiki/some
+```
+
+也可以加到启动文件中，
+```
+$ cat etc/local.shy
+~wiki
+    config wiki_level wiki/some
+```
+
+#### 用户界面
+
+chat模块提供了完整的功能系统。
+
+在一台公共的设备上启动服务节点，在etc/local.shy的启动脚本中加入如下两行命令。此设备就可以成为公共服务器。
+```
+~ssh
+    work serve
+```
+
+在任意其它设备上，每个用户都可以启动自己的节点，在启动脚本etc/local.shy，添加如下两行代码，此设备就可以成为用户的主控节点。
+```
+~ssh
+    work create
+```
+
+在启动用户节点时，只要指定服务节点，就可以实现用户注册，自动加入群组。
+```
+    ctx_dev=http://172.0.0.172 bin/boot.sh
+```
+
+然后登录 http://172.0.0.172:9095/chat 或 http://127.0.0.127:9095/chat ，
+输入自己的用户名，与初始密码，就可以登录系统。
+
+然后就可以自由的创建群聊、共享设备、实时聊天。
+
+#### 模块开发
+```
+project hello
+compile hello
+publish hello
+```
+
+### 所有目录
+
+#### 一级目录
+
+- src
+- etc
+- bin
+- var
+- usr
+
+#### 源码目录
+
+- src/toolkit
+- src/context
+- src/example
+- src/plugin
+ 
+#### 配置文件
+
+- etc/init.shy
+- etc/common.shy
+- etc/exit.shy
+
+#### 执行文件
+
+- bin/boot.sh
+- bin/node.sh
+- bin/bench
+ 
+#### 日志文件
+
+- var/log/boot.log
+- var/log/error.log
+- var/log/right.log
+- var/log/bench.log
+- var/log/debug.log
+- var/run/bench.pid
+- var/run/user/cert.pem
+- var/run/user/key.pem
+- var/run/node/cert.pem
+- var/run/node/key.pem
+- var/tmp/runtime.json
+- var/tmp/auth.json
+ 
+#### 应用目录
+
+- usr/template
+- usr/librarys
+- usr/upgrade
+- usr/client
+
+## 应用开发
+- Windows
+- Mac
+- pi
+- mp
+- iOS
+- Android
+
+### 应用接口
+
+context的应用模块都是web的子模块，在web模块启动HTTP服务后，会根据模块名与命令名自动生成路由。
+web模块会将所有的HTTP请求转换成context的命令调用，所以HTTP的应用接口和普通命令，除了名字必须以"/"开头，其它没有太大区别。
+
+当web接收到HTTP请求后，可以调用单个命令如 http://shylinux.com/code/consul 就会调用code模块下的/consul命令
+
+可以调用多个命令如 http://shylinux.com/code/?componet_group=login 就会调用web模块下的/render命令，
+根据code的componet下的login组件，依次调用每个接口的命令，然后将执行结果与参数一起，调用golang的template，渲染生成HTML。
+
+所有命令都解析完成后就可以生成一个完整的网页。当然如果Accept是application/json，则会跳过模块渲染，直接返回多条命令的执行结果。
+所以componet就是接口的集合，统一提供参数配置、权限检查、命令执行、模板渲染，前端展示样式，前端初始化函数，降低内部命令与外部应用的耦合性，但又将前后端完全融合在一起。
+
+如下，是web.code模块的应用接口定义。配置componet下定义了多个组件，每个组件下定义了多个接口。
+
+login就是登录页面，下面定义了三个接口code、login、tail，
+其中code，使用模板head生成网页头，会包括一些配置，如favicon可以指定图标文件，styles指定引用模式表。
+其中tail，使用模板tail生成网页尾，会包括一些配置，如scripts指定引用脚本文件。
+login就是网页组件了，生成一个网页登录的输入表单，并接收表单请求调用aaa模块的auth命令，进行用户身份的验证。
+其中arguments指定了Form表单字段的列表。
+```
+...
+var Index = &ctx.Context{Name: "code", Help: "代码中心",
+	Caches: map[string]*ctx.Cache{},
+	Configs: map[string]*ctx.Config{
+		"skip_login": &ctx.Config{Name: "skip_login", Value: map[string]interface{}{"/consul": "true"}, Help: "免密登录"},
+        "componet": &ctx.Config{Name: "componet", Value: map[string]interface{}{
+            "login": []interface{}{
+                map[string]interface{}{"componet_name": "code", "componet_tmpl": "head", "metas": []interface{}{
+                    map[string]interface{}{"name": "viewport", "content": "width=device-width, initial-scale=0.7, user-scalable=no"},
+                }, "favicon": "favicon.ico", "styles": []interface{}{"example.css", "code.css"}},
+
+                map[string]interface{}{"componet_name": "login", "componet_help": "login", "componet_tmpl": "componet",
+                    "componet_ctx": "aaa", "componet_cmd": "auth", "componet_args": []interface{}{"@sessid", "ship", "username", "@username", "password", "@password"}, "inputs": []interface{}{
+                        map[string]interface{}{"type": "text", "name": "username", "value": "", "label": "username"},
+                        map[string]interface{}{"type": "password", "name": "password", "value": "", "label": "password"},
+                        map[string]interface{}{"type": "button", "value": "login"},
+                    },
+                    "display_append": "", "display_result": "",
+                },
+
+                map[string]interface{}{"componet_name": "tail", "componet_tmpl": "tail",
+                    "scripts": []interface{}{"toolkit.js", "context.js", "example.js", "code.js"},
+                },
+            },
+...
+```
+### 网页开发
+
+#### 模板
+
+usr/template 存放了网页的模板文件，context会调用golang的template接口进行后端渲染，生成html文件。
+不同的应用模块都会有自己的模板目录，也有公共模板库。
+
+- usr/template/common.tmpl 公共模板
+- usr/template/code/ code模块的模板
+- usr/template/wiki/ wiki模块的模板
+- usr/template/chat/ chat模块的模板
+
+#### 样式
+
+所有的css都存放usr/librarys
+
+- example.css
+- code.css
+- wiki.css
+- chat.css
+
+#### 脚本
+
+所有的js都存放usr/librarys
+
+- toolkit.js 工具库，主要是网页相关的操作，如AppendChild
+- context.js 通信库，主要是用来与后端context进行通信
+- example.js 框架库，统一定义了网页的框架，每个应用网页都会继承
+- code.js 工具链应用的网页
+- wiki.js 知识库应用的网页
+- chat.js 信息流应用的网页
+
+### 小程序
+### 开发板
+
+## 接口开发
+### componet
+### python
+### java
+### c
+
+## 模块开发
+### 应用模块
+#### 简单模块
+#### 复杂模块
+#### 脚本模块
+### 插件模块
+#### 独立插件
+#### 扩展插件
+### 核心模块
+#### 模块中心ctx
+#### 命令中心cli
+#### 认证中心aaa
+#### 应用中心web
+#### 网络中心tcp
+#### 存储中心nfs
+#### 集群中心ssh
+#### 数据中心mdb
+
+### 应用框架
+#### 模块
+
+context内部使用模块组织功能，每个模块都可以独立编译，独立运行。
+解除了代码之间的包依赖、库依赖、引用依赖、调用依赖。
+通过map查找模块，通过map查找命令，通过map查找配置，从而实现完全自由的模块。
+
+**模块定义：**
+```
+type Context struct { // src/contexts/ctx/ctx.go
+    Name string
+    Help string
+
+    Caches   map[string]*Cache
+    Configs  map[string]*Config
+    Commands map[string]*Command
+
+    ...
+
+    contexts map[string]*Context
+    context  *Context
+    root     *Context
+
+    ...
+    Server
+}
+
+```
+Name：模块名称，Help：模块帮助。
+模糊搜索搜索时，会根据Name与Help进行匹配。
+
+每个模块会有命令集合Commands，配置集合Configs，缓存集合Caches。通过这种形式提供功能集合。
+
+contexts：所有子模块，context：指向父模块，root：指向根模块。
+从而组成一个模块树，所以可以通过路由查找模块，
+如ctx.web.code，code的父模块是web，web的父模块是ctx，ctx是根模块。
+所以可以通过命令，查看到当前程序所有模块的信息。
+
+**缓存定义：**
+```
+type Cache struct {
+	Value string
+	Name  string
+	Help  string
+	Hand  func(m *Message, x *Cache, arg ...string) string
+}
+```
+Value：存放的数据，Name：变量名称，Help：变量帮助，Hand读写函数。
+
+缓存数量是一种数据接口，用来存放一些状态量，向外部显示程序进行状态，对外部来说一般是只读的。对内部来说可读可写。
+所以可以通过命令，查看到当前程序任意模块的状态数据。
+
+如下，ncontext当前有多少个模块。nserver有多少个模块运行了守护协程。
+
+```
+"nserver":    &Cache{Name: "nserver", Value: "0", Help: "服务数量"},
+"ncontext":   &Cache{Name: "ncontext", Value: "0", Help: "模块数量"},
+```
+
+**缓存读写：**
+```
+func (m *Message) Cap(key string, arg ...interface{}) string {}
+func (m *Message) Capi(key string, arg ...interface{}) int {}
+func (m *Message) Caps(key string, arg ...interface{}) bool {}
+```
+定义了缓存数据的三种读写接口。
+
+m.Cap()只有一个参数时，会从当前模块查询缓存变量，如果查到则返回Value，如果没有，则依次查询父模块。
+如果查找到根模块还没有查到找，变返回空字符串。
+
+m.Cap()有两个参数时，同样会从当前模块依次查询父模块，直到查到变量，然后设置其值。
+
+m.Capi()是对m.Cap()封装了一下，在int与str相互转换，从而实现用str存储int。
+所有转换失败的数据，都会返回0。
+
+m.Caps()，实现了str存储bool。返回false的值有"", "0", "false", "off", "no", "error: "，其它都返回true。
+
+**配置定义：**
+```
+type Config struct {
+	Value interface{}
+	Name  string
+	Help  string
+	Hand  func(m *Message, x *Cache, arg ...string) string
+}
+```
+Value：存放的数据，Name：变量名称，Help：变量帮助，Hand读写函数。
+与Cache相似，只是Value的类型不再是String而是interface{}，所以可以用来存放更复杂的数据。
+
+一般用来存放配置数据，是外部控制内部数据接口。
+所以可以通过命令，实时修改当前程序任意模块的配置数据。
+避免只是修改某个配置变量，就要重启整个进程，从而实现高效灵活的配置。
+把每个进程当成一个生命来对待，不要轻易杀死任何一个进程。有问题可以用微创手术解决。
+
+**配置读写：**
+```
+func (m *Message) Conf(key string, args ...interface{}) string {}
+func (m *Message) Confi(key string, arg ...interface{}) int {}
+func (m *Message) Confs(key string, arg ...interface{}) bool {}
+func (m *Message) Confx(key string, args ...interface{}) string {}
+func (m *Message) Confv(key string, args ...interface{}) interface{} {}
+func (m *Message) Confm(key string, args ...interface{}) map[string]interface{} {}
+```
+与Cache相似，也定义了各种读写的接口。
+
+因为interface{}可以是任意复合类型，所以数据嵌套很深时，查询会涉及各种类型转换，非常麻烦。
+Conf()定义了键值链。内部去处理类型转换与嵌套的深入。 
+如m.Conf("runtime", "user.node")、m.Conf("runtime", []string{"user", "node"})、m.Conf("runtime", []interface{}{"user", "node"})
+都会查询配置runtime下的user下的node的值。
+
+m.Confx()内部进行选择，如果m.Option(key)中取到了值，则直接返回m.Option(key)，否则返回m.Conf(key)。
+把配置当成一个备用的默认值，如果命令参数设置了此参数，则用命令中的参数。
+
+m.Confv()直接读写原始数据。
+m.Confm()则定义了更丰富的接口，m就是map意思，直接返回map[string]interface{}
+m另外一个意思就是magic，可以传入各种回调函数。
+如下配置node类型是map[string]interface{}，m.Confm()会遍历此map，查到value也是map[string]interface{}的键值，调用回调函数。
+```
+    ...
+    m.Confm("node", func(name string, node map[string]interface{}) {
+        if kit.Format(node["type"]) != "master" {
+            ps = append(ps, kit.Format(node["module"]))
+        }
+    })
+    ...
+```
+
+**命令定义：**
+```
+type Command struct {
+	Form map[string]int
+	Name string
+	Help interface{}
+	Auto func(m *Message, c *Context, key string, arg ...string) (ok bool)
+	Hand func(m *Message, c *Context, key string, arg ...string) (e error)
+}
+```
+Name：命令语法，Help：命令帮助。
+
+Hand：命令处理函数，m是调用消息，c是当前模块，key是命令名，arg是命令参数。
+
+在命令解析时，会根据Form将[key value...]形式的参数，取出存放到m.Option中，方便用key直接查找参数。
+所以arg中只剩下序列参数，通过index序号查找参数。
+
+Auto：终端自动补全函数。在使用终端每输入一个单词时，就调用此函数输出提示信息。所以在命令执行前，这个函数会被调用多次。
+
+如下定义了trans命令
+```
+    ...
+    "trans": &Command{Name: "trans option [type|data|json] limit 10 [index...]", Help: "数据转换",
+        Form: map[string]int{"format": 1, "fields": -1},
+        Hand: func(m *Message, c *Context, key string, arg ...string) (e error) {
+            ...
+        }}
+    ...
+```
+
+**命令调用：**
+```
+func (m *Message) Cmd(args ...interface{}) *Message {}
+func (m *Message) Cmdx(args ...interface{}) string {}
+func (m *Message) Cmds(args ...interface{}) bool {}
+func (m *Message) Cmdy(args ...interface{}) *Message {}
+func (m *Message) Cmdm(args ...interface{}) *Message {}
+```
+m.Cmd()根据第一个参数去当前查找命令，如果没有查找到，则去父模块查找。如果没有查找，则不会执行。
+剩下的参数会根据Form定义来解析，存放到m.Option中。
+
+m.Cmds()当返回值转换成bool规则同m.Caps()与m.Confs()。
+m.Cmdx()当返回值转换成str。 m.Cmdy()将结果复制到当前Message。
+
+m.Cmdm()，m同样是magic，会根据当前会话，自动定向到远程某主机某模块，远程调用其命令，当然也可能定向到本机。
+
+#### 协程
+#### 消息
+
+context内部调用都是
+
+
+### 解析引擎
+#### 文件扫描
+#### 词法解析
+#### 语法解析
+#### 执行命令
+### 通信框架
+#### 节点路由
+每个节点在启动时，自动向上级注册，生成一个动态域名，作为本节点的地址。
+如com.mac.led，led的上级节点是mac，mac的上级节点是com。
+其它节点，就可以通过个这个地址查找到此节点。
+
+在调用远程命令时，通信模块根据远程地址的第一个字段，查找子节点，查取成功后，会将剩余的地址与命令发送给查到的子节点。
+子节点收到地址与命令后，继续查找子节点，直到目标节点收到命令，然后将执行结果原路返回。
+
+在查找的过程中，如果没有查找到子节点，则会传给上级节点重新处理。
+
+#### 节点认证
+
+**节点加密**
+每个节点都有证书与密钥。每个节点在发送命令时，都会用自己的密钥签名，目标节点都会用它的证书验签。以此保证命令来源的可靠性。
+
+**节点类型**
+
+- 初始节点，没有归属的节点
+- 主控节点，有用户证书与密钥的节点
+- 从属节点，有用户证书的节点
+
+- 代理节点，主控节点指定的代理节点
+- 共享节点，允许多个用户控制的节点
+- 认证节点，专门用来存放与查询用户证书的节点
+
+用户在某一设备上添加自己的证书与密钥，此节点即为主控节点。 在其它节点上绑定自己的证书，此即为从属节点。
+
+主控节点就可任意控制从属节点，从属节点不能控制主控节点，从属节点之间也不能相互控制。
+
+主控节点可以指定代理节点，代理节点可以代替主控节点控制从属节点。
+
+共享节点，会有多个用户，可能产生冲突，所以需要认证节点协调。
+
+访问共享节点前，需要向认证节点注册，共享节点会从认证节点取出访问用户的信息。
+
+#### 节点权限
+
+***角色***
+
+每个访问用户，都会指定一个角色。
+主控节点的用户默认有root权限。即拥有设备的所有控制权限。
+
+认证节点的用户默认有tech权限。一般是部分功能。
+
+其它节点的用户默认有void权限。即拥有最小集合的权限，一般是只读的命令。
+
+***组件***
+
+组件是功能的集合，远程访问至少要有remote与source组件的权限才可以执行命令。
+
+每个角色下都会有多个组件的权限。
+
+***命令***
+
+命令就节点向外提供功能的最小单元。
+
+每个组件下都会有多条命令。
+
+***规则***
+
+每条命令内部可以用组件与命令的权限机制自定义权限检查。
+
+权限的分配完全由主控节点与从属节点自己配置，其它节点不许配置。
+
+***示例***
+
+如下配置，用户shy的角色是tech，角色tech下有两个组件remote与source，每个组件下都有命令pwd与dir，所以用户shy就可以远程调用命令dir与pwd
+```
+role tech user shy
+role tech componet remote command pwd dir
+role tech componet source command pwd dir
+```
+
+### 存储引擎
+#### 配置
+#### 缓存
+#### 数据
+
+
diff --git a/src/contexts/cli/version.go b/src/contexts/cli/version.go
index dc83ef1a..d70a0cce 100644
--- a/src/contexts/cli/version.go
+++ b/src/contexts/cli/version.go
@@ -4,5 +4,5 @@ var version = struct {
 	host string
 	self int
 }{
-	"2019-09-18 07:48:00", "com", 527,
+	"2019-09-18 11:36:56", "centos", 527,
 }
diff --git a/usr/librarys/chat.js b/usr/librarys/chat.js
index 1af99b15..93868e01 100644
--- a/usr/librarys/chat.js
+++ b/usr/librarys/chat.js
@@ -106,7 +106,7 @@ var page = Page({check: true,
     initOcean: function(page, field, option, output) {
         var table = kit.AppendChild(output, "table")
         var ui = kit.AppendChild(field, [{view: ["create"], list: [
-            {input: ["name", function(event) {
+            {title: "群聊名称", input: ["name", function(event) {
                 page.oninput(event, function(event) {
                     switch (event.key) {
                         case "1":
@@ -126,71 +126,65 @@ var page = Page({check: true,
                         case "0":
                             field.Pane.Action["清空"](event)
                             return true
+
                         case "-":
-                            var pre = ui.list.querySelector("pre")
-                            pre && pre.click()
+                            var tr = ui.list.querySelectorAll("tr")[1]
+                            tr && tr.childNodes[0].click()
                             return true
                         case "=":
                             var td = table.querySelector("tr.normal td")
                             td && td.click()
                             return true
                     }
-                })
-                event.key == "Enter" && this.nextSibling.click()
+                }), event.key == "Enter" && this.nextSibling.click()
 
-            }]}, {button: ["create", function(event) {
+            }]}, {button: ["创建群聊", function(event) {
                 if (!ui.name.value) {ui.name.focus(); return}
 
-                var list = kit.Selector(ui.list, "pre", function(item) {return item.innerText})
+                var list = kit.Selector(ui.list, "tr", function(item) {
+                    return item.dataset.user
+                })
                 if (list.length == 0) {kit.alert("请添加组员"); return}
 
+
                 field.Pane.Create(ui.name.value, list)
 
-            }]}, {name: "list", view: ["list"]},
+            }]}, {name: "list", view: ["list", "table"], list: [{text: ["2. 已选用户列表", "caption"]}]},
         ]}])
         return {
             Append: function(msg) {
+                kit.AppendChilds(table, [{text: ["1. 选择用户节点 ->", "caption"]}])
                 kit.AppendTable(table, ctx.Table(msg), ["key", "user.route"], function(value, key, row, i, tr, event) {
                     tr.className = "hidden"
-                    var uis = kit.AppendChild(ui.list, [{text: [row.key], click: function(event) {
+                    var uis = kit.AppendChild(ui.list, [{row: [row.key, row["user.route"]], dataset: {user: row.key}, click: function(event) {
                         tr.className = "normal", uis.last.parentNode.removeChild(uis.last)
                     }}])
                 })
             },
-            clear: function(name) {
-                table.innerHTML = "", ui.list.innerHTML = "", ui.name.value = name, ui.name.focus()
-            },
             Create: function(name, list) {
                 field.Pane.Run(["spawn", "", name].concat(list), function(msg) {
-                    page.river.Pane.Show()
-                    field.Pane.Show()
+                    field.Pane.Show(), page.river.Pane.Show(name)
                 })
             },
-            Show: function() {var pane = field.Pane
-                pane.Dialog() && (pane.clear("good"), pane.Run([], pane.Append))
+            Show: function(name) {var pane = field.Pane
+                pane.Dialog(), ui.name.focus(), ui.name.value = name||"good", pane.Run([], pane.Append)
             },
             Action: {
-                "取消": function(event) {
-                    field.Pane.Show()
+                "取消": function(event) {field.Pane.Show()},
+                "清空": function(event) {
+                    kit.Selector(ui.list, "tr", function(item) {item.click()})
                 },
                 "全选": function(event) {
-                    table.querySelectorAll("tr.normal").forEach(function(item) {
-                        item.firstChild.click()
-                    })
-                },
-                "清空": function(event) {
-                    ui.list.querySelectorAll("pre").forEach(function(item) {
-                        item.click()
-                    })
+                    kit.Selector(table, "tr.normal", function(item) {item.firstChild.click()})
                 },
             },
-            Button: ["取消", "全选", "清空"],
+            Button: ["取消", "清空", "全选"],
         }
     },
     initRiver: function(page, field, option, output) {
         return {
-            Show: function() {var pane = field.Pane
-                output.innerHTML = "", pane.Update([], "text", ["nick", "count"], "key", ctx.Search("river")||true)
+            Show: function(which) {var pane = field.Pane
+                output.innerHTML = "", pane.Update([], "text", ["nick", "count"], "key", which||ctx.Search("river")||true)
             },
             Action: {
                 "创建": function(event) {
@@ -515,21 +509,12 @@ var page = Page({check: true,
         }
     },
     initSteam: function(page, field, option, output) {
-        var river = ""
         var table = kit.AppendChild(output, "table")
         var device = kit.AppendChild(field, [{"view": ["device", "table"]}]).last
         var ui = kit.AppendChild(field, [{view: ["create"], list: [
-            {data: {title: "应用名称"}, input: ["name", function(event) {
+            {title: "应用名称", input: ["name", function(event) {
                 page.oninput(event, function(event) {
                     switch (event.key) {
-                        case "i":
-                            var prev = table.querySelector("tr.select").previousSibling
-                            prev && prev.childNodes[0].click()
-                            return true
-                        case "o":
-                            var next = table.querySelector("tr.select").nextSibling
-                            next && next.childNodes[0].click()
-                            return true
                         case "1":
                         case "2":
                         case "3":
@@ -547,6 +532,7 @@ var page = Page({check: true,
                         case "0":
                             field.Pane.Action["清空"](event)
                             return true
+
                         case "-":
                             var tr = ui.list.querySelectorAll("tr")[1]
                             tr && tr.childNodes[0].click()
@@ -555,10 +541,19 @@ var page = Page({check: true,
                             var td = device.querySelector("tr.normal td")
                             td && td.click()
                             return true
+
+                        case "i":
+                            var prev = table.querySelector("tr.select").previousSibling
+                            prev && prev.childNodes[0].click()
+                            return true
+                        case "o":
+                            var next = table.querySelector("tr.select").nextSibling
+                            next && next.childNodes[0].click()
+                            return true
                     }
                 }), event.key == "Enter" && this.nextSibling.click()
 
-            }]}, {button: ["创建", function(event) {
+            }]}, {button: ["创建应用", function(event) {
                 if (!ui.name.value) {ui.name.focus(); return}
 
                 var list = []
@@ -568,15 +563,15 @@ var page = Page({check: true,
                     list.push(item.dataset.index)
                     list.push(item.dataset.name)
                 })
-                // if (list.length == 0) {kit.alert("请添加命令"); return}
 
                 field.Pane.Create(ui.name.value, list)
 
-            }]}, {name: "list", view: ["list", "table"], style: {"min-width": "240px"}, list: [{type: "caption", inner: "3. 已选命令列表"}]},
+            }]}, {name: "list", view: ["list", "table"], list: [{text: ["3. 已选命令列表", "caption"]}]},
         ]}])
 
+        var river = ""
         return {
-            Append: function(com, pod) {var pane = field.Pane
+            Select: function(com, pod) {var pane = field.Pane
                 var last = kit.AppendChild(ui.list, [{
                     dataset: {pod: pod.node, group: com.key, index: com.index, name: com.name},
                     row: [com.key, com.index, com.name, com.help],
@@ -584,41 +579,38 @@ var page = Page({check: true,
                 }]).last
             },
             Update: function(list, pod) {var pane = field.Pane
-                kit.AppendChilds(device, [{type: "caption", inner: "2. 选择模块命令 ->"}])
+                kit.AppendChilds(device, [{text: ["2. 选择模块命令 ->", "caption"]}])
                 kit.AppendTable(device, list, ["key", "index", "name", "help"], function(value, key, com, i, tr, event) {
-                    pane.Append(com, pod)
+                    pane.Select(com, pod)
                 })
             },
-            Select: function(list) {var pane = field.Pane
-                kit.AppendChilds(table, [{type: "caption", inner: "1. 选择用户节点 ->"}])
-                kit.AppendTable(table, list, ["user", "node"], function(value, key, pod, i, tr, event) {
-                    var old = table.querySelector("tr.select")
-                    tr.className = "select", old && (old.className = "normal"), pane.Run([river, pod.user, pod.node], function(msg) {
+            Append: function(msg) {var pane = field.Pane
+                kit.AppendChilds(table, [{text: ["1. 选择用户节点 ->", "caption"]}])
+                kit.AppendTable(table, ctx.Table(msg), ["user", "node"], function(value, key, pod, i, tr, event) {
+                    kit.Selector(table, "tr.select", function(item) {item.className = "normal"})
+                    tr.className = "select", pane.Run([river, pod.user, pod.node], function(msg) {
                         pane.Update(ctx.Table(msg), pod)
                     })
                 }), table.querySelector("td").click()
-                ui.name.value = "nice", ui.name.focus()
             },
             Create: function(name, list) {
                 field.Pane.Run([river, "spawn", name].concat(list), function(msg) {
                     field.Pane.Show(), page.storm.Pane.Show(name)
                 })
             },
-            Show: function() {var pane = field.Pane
-                pane.Dialog() && pane.Run([river], function(msg) {
-                    pane.Select(ctx.Table(msg))
-                })
+            Show: function(name) {var pane = field.Pane
+                pane.Dialog(), ui.name.focus(), ui.name.value = name||"nice", pane.Run([river], pane.Append)
             },
             Listen: {
                 river: function(value, old) {river = value},
             },
             Action: {
                 "取消": function(event) {field.Pane.Show()},
-                "清空": function(event) {ui.list.innerHTML = ""},
+                "清空": function(event) {
+                    kit.Selector(ui.list, "tr", function(item) {item.click()})
+                },
                 "全选": function(event) {
-                    ui.list.innerHTML = "", device.querySelectorAll("tr").forEach(function(item) {
-                        item.firstChild.click()
-                    })
+                    kit.Selector(device, "tr.normal", function(item) {item.firstChild.click()})
                 },
             },
             Button: ["取消", "清空", "全选"],
diff --git a/usr/librarys/example.css b/usr/librarys/example.css
index fd3fdbdf..23c22569 100644
--- a/usr/librarys/example.css
+++ b/usr/librarys/example.css
@@ -174,6 +174,9 @@ fieldset.dialog>div.create {
     margin-left:10px;
     float:left;
 }
+fieldset.dialog>div.create table {
+    min-width:240px;
+}
 
 fieldset.Login {
     font-size:28px;
diff --git a/usr/librarys/example.js b/usr/librarys/example.js
index bcd7d315..f107e5c7 100644
--- a/usr/librarys/example.js
+++ b/usr/librarys/example.js
@@ -573,7 +573,7 @@ function Pane(page, field) {
             pane.Runs(cmds, function(line, index, msg) {
                 var ui = pane.Append(type, line, key, which, cb)
                 if (typeof first == "string") {
-                    (line.key == first || line.name == first || line[which] == first) && ui.first.click()
+                    (line.key == first || line.name == first || line[which] == first || line[key[0]] == first) && ui.first.click()
                 } else {
                     first && index == 0 && ui.first.click()
                 }
diff --git a/usr/librarys/toolkit.js b/usr/librarys/toolkit.js
index 9b02ef3b..a5de6b16 100644
--- a/usr/librarys/toolkit.js
+++ b/usr/librarys/toolkit.js
@@ -149,7 +149,7 @@ kit = toolkit = {
             return elm
         }
 
-        // 基本属性: name value inner
+        // 基本属性: name value title inner
         // 基本样式: style className
         // 基本事件: dataset click
         //
@@ -179,6 +179,9 @@ kit = toolkit = {
             if (child.value) {
                 child.data["value"] = child.value
             }
+            if (child.title) {
+                child.data["title"] = child.title
+            }
             if (child.inner) {
                 child.data["innerHTML"] = child.inner
             }
diff --git a/usr/local/wiki/自然/编程/index.md b/usr/local/wiki/自然/编程/index.md
index 5e433cf4..3505e5d8 100644
--- a/usr/local/wiki/自然/编程/index.md
+++ b/usr/local/wiki/自然/编程/index.md
@@ -1,4 +1,4 @@
-## context
+## 应用简介
 
 context是一种新的编程语言与应用框架，通过模块化、集群化、自动化，实现软件的快速开发，快速共享，快速使用。
 
@@ -62,7 +62,7 @@ time                size line path
 4[22:21:20]nfs>
 ```
 - bin目录，就是各种启动脚本与命令
-- etc目录，就是各种配置脚本
+- etc目录，就是各种配置脚本与文件
 - var目录，就是各种输出文件，如日志与缓存文件
 - usr目录，就是各种前端文件与数据，如js、css文件
 
@@ -80,28 +80,110 @@ $
 ```
 *如果需要搭建私有服务，可以直接运行bin/zone.sh，启动根服务节点。*
 
+
 ## 基本功能
 
-除了命令行交互，还可以访问<http://localhost:9095>，用浏览器进行操作。
+除了命令行交互，还可以访问<http://localhost:9095>，通过浏览器使用更丰富的功能。
 context启动后，默认监听9095端口，启动网页服务。
 
-## 快速共享
-点击左上角的标题，会跳转到当面页面的完整链接地址。
-把主机地址替换成别人可以访问的IP，就共享给其它用户。
-其它用户，输入用户与密码即可登录，并加入此群聊中，使用当前功能页面。
+context的应用界面是群聊的形式进行组织，每个群聊下可以创建任意的应用列表。
+所以每个应用都有群聊的上下文，可以获取当前群组的相关信息，也可以把执行结果发送到群聊中。
+另外应用也可以像文本或图片一样发送出去，共享给别的群组，再重新组合成新的应用界面。
+
+如下左图，左边栏是群组列表，右边栏是当前群组下的应用列表。
+中上栏，是当前群组的聊天记录。中下栏是当前应用的界面。
+如下右图，在应用界面的左上角有界面选项，还可以把应用界面切换到不同的大小。
+```
++----------------------------+        +----------------------------+
+|                            |        |                            |
++------+--------------+------+        +---------------------+------+
+|      |              |      |        |                     |      |
+|  群  |              |  应  |        |                     |  应  |
+|  组  |   聊天记录   |  用  |        |                     |  用  |
+|  列  |              |  列  |        |      应用界面       |  列  |
+|  表  +--------------+  表  |        |                     |  表  |
+|      |              |      |        |                     |      |
+|      |   应用界面   |      |        |                     |      |
+|      |              |      |        |                     |      |
++------+--------------+------+        +---------------------+------+
+|                            |        |                            |
++----------------------------+        +----------------------------+
+```
+
+这些应用的服务器，可是群聊中任意组员的设备，所以组员越多设备也越多，应用种类也就越丰富。
+
+任意组员，都可以使用这些共享设备提供的命令，组合成各种应用界面，更加契合当前群组的使用需求。
+所有的应用与数据，都存放在本地设备上，可以被安全的管理与备份。
+
+### 创建群聊
+左边栏的左上角，有创建按钮，点击便可打开群聊创建窗口。
+
+左方框中，就是当前网络中所有的用户节点，点击即可添加到右方框中。
+
+在右方框中，点击用户节点，便可删除选择。
+
+输入群组名称，点击创建，便可用已选中的用户创建新的群聊。
+
+### 创建应用
+右边栏的左上角，有创建按钮，点击便可打开应用创建窗口。
+
+左边方框是当前群组的所有成员，选择某个成员，中间框便显示，此成员设备上的所有命令。
+
+从中间方框中，选中所需要的命令，便可组合成所需的应用。
+
+在右方框中，输入应用名称，便可创建归属当前群组的应用。
+
+### 共享应用
+
+本群组内的应用，除了可以本群组成员一起使用，还可以分享给其它用户。
+
+点击共享按钮，便可以生成共享链接或二维码，其它用户点击登录后，便可加入此群组，使用此应用。
+
+## 应用开发
+
+context提供了插件的机制，可以自由的扩展应用，满足用户更多定制化的需求。
+
+src/plugin目录下，就是各种插件。
+每个插件，都有后端index.go文件、index.shy文件、前端index.js文件、index.css文件。
+
+推荐使用index.shy开发所需应用，shy语言，是context开发的一种新的编程语言，不需要编译，可以在任意设备上自由的使用。
+
+当应用过于复杂或对性能有过高要求时，可以在index.go实现命令。
+
+当有特殊的交互需求时，可以在index.js中实现前端功能。
+
+当有界面美化需求时，可以在index.css加入样式。
+
+context提供了，完整的开发工具链，从插件的创建、编译、发布、加载，简化了所有开发环节。
+
+### 创建插件
+### 编译插件
+### 加载插件
 
 ## 创建集群
-context是一种分布式框架，可以运行在任意设备上，并且实现了自动组网、自动路由、自动认证。
-远程命令与本地命令，无差别的运行，从而实现无限扩容的分布式计算。
+
+context不仅可以单机提供服务，还支持自动化的集群，实现了自动组网、自动路由、自动认证。
+
+在bin目录下，就是各种启动脚本。
+
+- bin/zone.sh 启动区域节点
+- bin/user.sh 启动用户节点
+- bin/node.sh 启动工作节点
+- bin/boot.sh 启动默认节点
+
+在公共服务器上，执行bin/zone.sh脚本，会创建一个独立的工作域，所有的子节点，都会将用户信息注册到此节点。
+每个用户便可在自己的设备上，设置ctx_dev变量，指向区域向区域ip与端口。
+使用bin/user.sh启动自己的节点，便可自动获取动态域名与注册用户信息。
+
+在同一区域下的所有节点，可以自由的相互访问，并可以在任意设备上创建群聊，所有的信息会自动的分发到其它节点。
+
+- 个人使用，可以创建一个区域节点，下挂多个工作节点。
+- 团队使用，需要创建一个区域节点，多个用户节点，每个用户节点下，可以挂多个工作节点。
+- 如果用户节点或工作节点过多，可以创建分机节点，通过增加层级来降低单机负载。
 
 context每个启动的进程都是一个独立的节点，根据网络框架中的功能作用，可以分为区域节点、用户节点、工作节点、分机节点。
 这几种节点，除了网络框架中的作用外，其它的功能模块与命令都完全一样，没有差别。
-
-个人使用，可以创建一个区域节点，下挂多个工作节点。
-
-团队使用，需要创建一个区域节点，多个用户节点，每个用户节点下，可以挂多个工作节点。
-
-如果用户节点或工作节点过多，可以创建分机节点，通过增加层级来降低单机负载。
+远程命令与本地命令，无差别的运行，从而实现无限扩容的分布式计算。
 
 ### 个人使用
 #### 启动区域节点
@@ -217,633 +299,6 @@ context会自动生成新的网络路由。
 $ ctx_dev=http://192.168.88.102:9095 bin/boot.sh
 ```
 
-## 创建群聊
-除了命令行的使用的方式之外，context还有自己的前端框架。
-不仅降低了使用难度，还提供更加场景化、自动化的应用界面。
-
-用户可以访问区域节点或是任意用户节点的网页服务。
-
-http://127.0.0.29:9095
-
-输入用户名与初始密码，即可登录，如果用户与主机上的用户名相同，则是管理员权限，如果不同，则是普通用户，只有最小的功能权限。
-
-所以任意节点都支持多用户共享使用，但只有管理用户有所有权限，进行资源的管理与分配。
-
-打开应用界面，就可以看到context以办公聊天软件的形式提供各种丰富的功能。
-
-左边框是用户群组列表，用户可以选择群聊或是创建新的群聊。
-中间就是聊天记录与输入框，用户可以自由的聊天收发消息。
-
-与其它聊天软件不同的是，context提供了自定义的功能列表。
-右边框中，就是此群组的功能列表。
-每个用户都可以将自己设备上的命令添加到这个群组的功能列表中，分享给本组员使用。
-每个组员都可以根据自己的需求组合这些命令，生成自己的应用界面。
-
-以每个群聊作为场景，进行资源的共享与应用的开发，从而实现更加场景化与个性化应用。
-
-通过这种精细化的应用场景，进行工具化、标准化、流程化。提高各行各业的工作效率。
-
-## 应用开发
-
-网络框架与应用界面，已经实现了标准化与自动化，剩下就是应用的开发了。
-
-开发者，可以在任意机器上开发自己的应用。以模块与函数为单位进行开发与上线。
-一个函数，即使只有几行代码，也是一个独立完整的应用，可以随时上线，被任意用户使用。
-
-用户还可以在任意群聊中转发此应用，更自由的传播出去。
-从而将软件开发的速度提升成千上万倍，将代码的使用效率提升成千上万倍。
-
-### 创建项目
-在任意节点上，执行project命令，指定项目名，即可创建应用目录。
-```
-$ bin/user.sh
-8[13:41:41]nfs> project hello
-time                line hash     path                     
-2019-07-30 14:27:09 35   eba8eda2 src/plugin/hello/index.go 
-2019-07-30 14:27:09 1    b858cb28 src/plugin/hello/index.shy
-2019-07-30 14:27:09 1    b858cb28 src/plugin/hello/local.shy
-2019-07-30 14:27:09 4    407265b6 src/plugin/hello/index.js 
-9[14:27:09]nfs> 
-```
-每个项目，都可以用go语言开发低层应用，用js开发前端交互。
-除此，context有自己的通用语法解析器，开者完全可以随时自定义语法，定制自己的解析器。
-用自己喜欢的语法开发应用。
-
-默认的shy语法，提供了一个完整的前后端应用框架。创建项目时，自动创建的模块如下。
-```
-fun hello world "" "" \
-	public \
-	text "" \
-	button "执行"
-	copy pwd
-end
-```
-
-这个模板就是一个完整的应用，fun关键字开关，end关键字结束。
-前四行就是定义应用界面，剩下代码就是后端脚本。
-public代表，这个应用是公共的，所以有人都可以访问。也可以是private，只有管理用户可以访问。
-
-text与button，就是需要前端展示的控件。用户在前端点击此button，就会将请求发送到后端，执行此脚本。
-然后将执行结果返回给前端界面。
-
-### 加载项目
-切换到cli模块，使用upgrade命令，加载新的项目应用。
-```
-8[13:41:41]nfs> ~cli
-8[13:41:41]cli> upgrade plugin hello
-3[15:55:53]cli> ~
-names    ctx msg  status stream helps   
-ctx          0    start  stdio  模块中心
-cli      ctx 4    begin         管理中心
-hello    cli 5958 start         shy     
-4[15:57:00]cli> 
-```
-
-切换到hello模块，使用command命令，可以查看到hello模块下的命令列表，然后就可以调用hello命令。
-```
-8[13:41:41]cli> ~hello
-6[15:58:42]hello> command
-key   name                                  
-hello hello world   public text  button 执行
-7[20:27:32]nice> hello
-D:\context/var
-```
-
-同时在前端界面上添加功能，即可看到此函数。
-
-context内部实现了很多功能模块，每个模块下有很多命令，每条命令就是一种应用。
-
-context的使用方式有很多种，
-
-- 可以直接调用，像Shell一样，去解析一条命令
-- 可以启动cli服务，像MySQL一样，交互式使用格式化命令
-- 可以启动web服务，像LabView一样，可以自定义各种图形界面
-- 可以自动组网，将任意台设备组合在一起，实现分布式应用
-- 可以自动建群，在群聊场景中，实现多用户、多会话、多任务、多设备的使用
-
-### 命令模式
-如果只是使用一条命令，或是写在脚本文件中，可以使用这种方式。
-
-例如，dir命令就是查看目录，
-```
-$ bin/bench dir
-time                 size  line  filename
-2019-06-16 10:35:18  324   11    common.shy
-2019-06-16 10:35:18  201   9     exit.shy
-2019-06-16 10:35:18  261   13    init.shy
-```
-
-还可以加更多参数，dir_deep递归查询目录，dir_type文件类型过滤，dir_sort输出表排序。
-```
-$ bin/bench dir ../ dir_deep dir_type file dir_sort line int_r
-time                 size      line   filename
-2019-06-16 10:22:52  13256968  91314  bench
-2019-06-16 11:10:16  1535      66     boot.sh
-2019-06-16 11:10:16  613       31     node.sh
-2019-06-16 11:10:16  261       13     init.shy
-2019-06-16 11:10:16  324       11     common.shy
-2019-06-16 11:10:16  201       9      exit.shy
-
-```
-
-### 交互模式
-
-启动服务，可以提供更丰富的命令与环境。
-```
-$ bin/bench
-0[11:35:46]ssh> dir
-time                 size  line  filename
-2019-06-16 11:35:06  160   3     log/
-2019-06-16 11:35:06  96    1     run/
-2019-06-16 11:35:44  192   4     tmp/
-1[11:35:46]ssh>
-```
-
-如果集中管理，命令越多，系统只会越复杂，学习成本越高，使用越低效，开发越困难。
-
-所以通过模块化，分而治之，更高效的管理丰富的命令。
-
-context命令就是用来管理模块，没有参数时，直接查看当前模块的信息。
-
-如下，第二行是当前模块，第一行是当前模块的父模块，其它行都是当前模块的子模块。
-
-```
-1[11:39:01]ssh> context
-names  ctx  msg  status  stream         helps
-ctx         0    start   shy            模块中心
-ssh    ctx  10   begin   ctx.nfs.file3  集群中心
-```
-
-context第一个参数，可以指定当前模块，
-如下，切换到nfs模块，然后查看各种IO模块，
-切换到ctx根模块，查看所有模块。
-```
-2[11:43:57]ssh> context nfs
-
-3[11:43:58]nfs> context
-names  ctx  msg   status  stream  helps
-ctx         0     start   shy     模块中心
-nfs    ctx  9     begin           存储中心
-stdio  nfs  1174  start   stdio   scan stdio
-
-4[11:44:22]ssh> context ctx
-
-5[11:45:17]ctx> context
-names    ctx  msg   status  stream    helps
-ctx           0     start   shy       模块中心
-aaa      ctx  3     begin             认证中心
-cli      ctx  4     begin             管理中心
-gdb      ctx  232   start             调试中心
-lex      ctx  6     begin             词法中心
-log      ctx  31    start   bench     日志中心
-mdb      ctx  8     begin             数据中心
-nfs      ctx  9     begin             存储中心
-ssh      ctx  10    begin             集群中心
-tcp      ctx  11    begin             网络中心
-web      ctx  1094  start   :9094     应用中心
-yac      ctx  13    begin   35,14,23  语法中心
-shy      cli  1171  start   engine    shell
-matrix1  lex  34    start   76,28,2   matrix
-stdio    nfs  1174  start   stdio     scan stdio
-chat     web  14    begin             会议中心
-code     web  15    begin             代码中心
-wiki     web  16    begin             文档中心
-engine   yac  1173  start   stdio     parse
-
-```
-
-command命令，就是用来管理当前模块的命令，
-```
-17[11:52:02]nfs> context nfs
-
-17[11:52:02]nfs> command
-key     name
-_init   _init
-action  action cmd
-copy    copy to from
-dir     dir [path [fields...]]
-export  export filename
-git     git sum
-hash    hash filename
-import  import filename [index]
-json    json str
-load    load file [buf_size [pos]]
-open    open file
-path    path filename
-printf  printf arg
-prompt  prompt arg
-pwd     pwd [all] | [[index] path]
-read    read [buf_size [pos]]
-remote  remote listen|dial args...
-save    save file string...
-scan    scan file name
-send    send [file] args...
-temp    temp data
-term    term action args...
-trash   trash file
-write   write string [pos]
-
-```
-
-help子命令，查看命令帮助信息。
-```
-18[11:59:19]nfs> command help dir
-dir: dir [path [fields...]]
-    查看目录, path: 路径, fields...: 查询字段, time|type|full|path|tree|filename|size|line|hash
-    dir_deep: 递归查询
-    dir_type both|file|dir|all: 文件类型
-    dir_reg reg: 正则表达式
-    dir_sort field order: 排序
-```
-
-
-### 集群模式
-
-context提供自动化集群的功能，可以自动组网、自动认证。从而快速实现多台设备的协同工作。
-
-#### 启动服务节点
-```
-$ bin/boot.sh
-0[11:35:12]ssh>
-```
-
-#### 启动工作节点
-
-新打开一个终端，启动工作节点，执行remote命令，查看上级节点，
-```
-$ bin/boot.sh create app/demo
-0[15:15:30]ssh> remote
-key  type    module         create_time
-mac  master  ctx.nfs.file3  2019-06-16 15:15:23
-```
-
-回到服务节点终端，执行remote命令，可以查看到所有远程节点。
-```
-2[15:15:31]ssh> remote
-key   type    module         create_time
-com   master  ctx.nfs.file4  2019-06-16 14:25:10
-demo  worker  ctx.nfs.file7  2019-06-16 15:15:23
-```
-
-默认配置中，子节点信任父，所以父节点可以调用子节点的命令。还有更复杂的认证机制，可以灵活配置。
-
-远程命令和本地命令一样，没有任何区别。如下调用demo节点的pwd命令。还支持更复杂的多节点命令，可以更快速的同时管理多台设备。
-```
-2[15:15:31]ssh> remote demo pwd
-/Users/shaoying/context/app/demo/var
-```
-
-#### 启动分机节点
-
-在服务节点的终端，查看服务地址
-```
-3[15:49:00]ssh> web.brow
-index  site
-0      http://192.168.199.139:9094
-```
-
-同样，在另一台设备上下载context，然后启动服务节点。
-通过环境变量ctx_dev指定上级节点。
-```
-$ ctx_dev="http://192.168.199.139:9094" bin/boot.sh
-0[15:49:00]ssh> remote
-key  type    module         create_time
-mac  master  ctx.nfs.file3  2019-06-16 15:15:23
-```
-
-回到服务节点终端，执行remote命令，可以查看到新添加了一个服务子节点。
-```
-2[15:15:31]ssh> remote
-key   type    module         create_time
-com   master  ctx.nfs.file4  2019-06-16 14:25:10
-demo  worker  ctx.nfs.file7  2019-06-16 15:15:23
-sub   server  ctx.nfs.file8  2019-06-16 16:15:23
-```
-
-同样可以远程调用命令。
-```
-2[15:15:31]ssh> remote sub pwd
-/Users/shaoying/context/app/sub/var
-```
-
-#### 文件管理
-调用本地命令，查看当前目录下的文件列表，
-```
-0[10:53:25]ssh> ls
-total 0
-drwxr-xr-x  5 shaoying  staff  160 May 10 03:57 bin
-drwxr-xr-x  5 shaoying  staff  160 May 10 03:30 etc
-drwxr-xr-x  2 shaoying  staff   64 May 10 03:30 usr
-drwxr-xr-x  8 shaoying  staff  256 May 10 03:36 var
-```
-
-调用内部命令，查看文件列表，如下dir与ls命令用途相似，但提供了更丰富的功能，如统计文件行数
-```
-5[10:56:24]ssh> dir etc
-time                 size  line  filename
-2019-04-14 21:29:21  316   10    common.shy
-2019-04-29 21:12:28  130   7     exit.shy
-2019-04-29 21:12:12  191   12    init.shy
-```
-
-"%"是一个内部命令，可以对前一步命令结果进行各种处理。如下按字段line排序
-```
-5[10:56:24]ssh> dir etc % order line
-time                 size  line  filename
-2019-04-29 21:12:12  191   12    init.shy
-2019-04-14 21:29:21  316   10    common.shy
-2019-04-29 21:12:28  130   7     exit.shy
-```
-
-如下按字段""聚合，即可得到汇总结果，所有文件的总字节数、总行数、总文件数
-```
-16[11:04:30]ssh> dir etc % group ""
-time                 size  line  filename    count
-2019-04-14 21:29:21  637   29    common.shy  3
-```
-
-#### 时间管理
-查看当前时间戳
-```
-18[11:11:01]ssh> time
-1557457862000
-```
-将时间戳转换成日期
-```
-19[11:11:14]ssh> time 1557457862000
-2019-05-10 11:11:02
-```
-将日期转换成时间戳
-```
-20[11:11:25]ssh> time "2019-05-10 11:11:02"
-1557457862000
-```
-
-#### 网卡管理
-```
-2[10:53:25]ssh> ifconfig
-index  name  ip             mask  hard
-5      en0   192.168.0.106  24    c4:b3:01:cf:0b:51
-```
-
-### 完整版
-命令行模式，只是context最基本的功能。context还提供了一个前端框架，
-让用户可以自由的组合功能列表，满足自己的需求。
-
-使用更丰富的功能，可以直接下载源码，
-```
-$ git clone https://github.com/shylinux/context.git
-```
-下载完源码后，如果安装了golang，就可以对源码直接进行编译，
-如果没有可以去官网下载安装golang（<https://golang.org/dl/>）。
-第一次make时，会自动下载各种依赖库，所以会慢一些。
-```
-$ cd context && make
-```
-
-#### 启动服务
-bin目录下是各种可执行文件，如启动脚本boot.sh与node.sh。
-
-node.sh用来启动单机版context，boot.sh用来启动网络版context。
-
-如下，直接运行脚本，即可启动context。
-
-启动context后，就可以解析执行各种命令，即可是本地的shell命令，也可以是内部模块命令。
-
-```
-$ bin/node.sh
-0[03:58:43]ssh>
-```
-
-#### 网页服务
-
-下载完整版的context，启动的服务节点，就会带有前端网页服务。
-
-#### 知识库
-
-wiki模块提供了知识库管理。
-
-访问：http://localhost:9094/wiki
-
-wiki模块会将usr/wiki目录下的md文件进行解析，生成网页文件，并自动生成目录与索引。
-
-可以创建自己的知识库，如下创建目录与文件。
-
-```
-$ mkdir -p usr/wiki/some
-$ echo "hello world" > usr/wiki/some/hi.md
-```
-
-然后在服务终端上，切换到新建的知识库，
-```
-0[10:53:25]ssh> ~wiki config wiki_level wiki/some
-```
-
-也可以加到启动文件中，
-```
-$ cat etc/local.shy
-~wiki
-    config wiki_level wiki/some
-```
-
-#### 用户界面
-
-chat模块提供了完整的功能系统。
-
-在一台公共的设备上启动服务节点，在etc/local.shy的启动脚本中加入如下两行命令。此设备就可以成为公共服务器。
-```
-~ssh
-    work serve
-```
-
-在任意其它设备上，每个用户都可以启动自己的节点，在启动脚本etc/local.shy，添加如下两行代码，此设备就可以成为用户的主控节点。
-```
-~ssh
-    work create
-```
-
-在启动用户节点时，只要指定服务节点，就可以实现用户注册，自动加入群组。
-```
-    ctx_dev=http://172.0.0.172 bin/boot.sh
-```
-
-然后登录 http://172.0.0.172:9095/chat 或 http://127.0.0.127:9095/chat ，
-输入自己的用户名，与初始密码，就可以登录系统。
-
-然后就可以自由的创建群聊、共享设备、实时聊天。
-
-#### 模块开发
-```
-project hello
-compile hello
-publish hello
-```
-
-### 所有目录
-
-#### 一级目录
-
-- src
-- etc
-- bin
-- var
-- usr
-
-#### 源码目录
-
-- src/toolkit
-- src/context
-- src/example
-- src/plugin
- 
-#### 配置文件
-
-- etc/init.shy
-- etc/common.shy
-- etc/exit.shy
-
-#### 执行文件
-
-- bin/boot.sh
-- bin/node.sh
-- bin/bench
- 
-#### 日志文件
-
-- var/log/boot.log
-- var/log/error.log
-- var/log/right.log
-- var/log/bench.log
-- var/log/debug.log
-- var/run/bench.pid
-- var/run/user/cert.pem
-- var/run/user/key.pem
-- var/run/node/cert.pem
-- var/run/node/key.pem
-- var/tmp/runtime.json
-- var/tmp/auth.json
- 
-#### 应用目录
-
-- usr/template
-- usr/librarys
-- usr/upgrade
-- usr/client
-
-## 应用开发
-- Windows
-- Mac
-- pi
-- mp
-- iOS
-- Android
-
-### 应用接口
-
-context的应用模块都是web的子模块，在web模块启动HTTP服务后，会根据模块名与命令名自动生成路由。
-web模块会将所有的HTTP请求转换成context的命令调用，所以HTTP的应用接口和普通命令，除了名字必须以"/"开头，其它没有太大区别。
-
-当web接收到HTTP请求后，可以调用单个命令如 http://shylinux.com/code/consul 就会调用code模块下的/consul命令
-
-可以调用多个命令如 http://shylinux.com/code/?componet_group=login 就会调用web模块下的/render命令，
-根据code的componet下的login组件，依次调用每个接口的命令，然后将执行结果与参数一起，调用golang的template，渲染生成HTML。
-
-所有命令都解析完成后就可以生成一个完整的网页。当然如果Accept是application/json，则会跳过模块渲染，直接返回多条命令的执行结果。
-所以componet就是接口的集合，统一提供参数配置、权限检查、命令执行、模板渲染，前端展示样式，前端初始化函数，降低内部命令与外部应用的耦合性，但又将前后端完全融合在一起。
-
-如下，是web.code模块的应用接口定义。配置componet下定义了多个组件，每个组件下定义了多个接口。
-
-login就是登录页面，下面定义了三个接口code、login、tail，
-其中code，使用模板head生成网页头，会包括一些配置，如favicon可以指定图标文件，styles指定引用模式表。
-其中tail，使用模板tail生成网页尾，会包括一些配置，如scripts指定引用脚本文件。
-login就是网页组件了，生成一个网页登录的输入表单，并接收表单请求调用aaa模块的auth命令，进行用户身份的验证。
-其中arguments指定了Form表单字段的列表。
-```
-...
-var Index = &ctx.Context{Name: "code", Help: "代码中心",
-	Caches: map[string]*ctx.Cache{},
-	Configs: map[string]*ctx.Config{
-		"skip_login": &ctx.Config{Name: "skip_login", Value: map[string]interface{}{"/consul": "true"}, Help: "免密登录"},
-        "componet": &ctx.Config{Name: "componet", Value: map[string]interface{}{
-            "login": []interface{}{
-                map[string]interface{}{"componet_name": "code", "componet_tmpl": "head", "metas": []interface{}{
-                    map[string]interface{}{"name": "viewport", "content": "width=device-width, initial-scale=0.7, user-scalable=no"},
-                }, "favicon": "favicon.ico", "styles": []interface{}{"example.css", "code.css"}},
-
-                map[string]interface{}{"componet_name": "login", "componet_help": "login", "componet_tmpl": "componet",
-                    "componet_ctx": "aaa", "componet_cmd": "auth", "componet_args": []interface{}{"@sessid", "ship", "username", "@username", "password", "@password"}, "inputs": []interface{}{
-                        map[string]interface{}{"type": "text", "name": "username", "value": "", "label": "username"},
-                        map[string]interface{}{"type": "password", "name": "password", "value": "", "label": "password"},
-                        map[string]interface{}{"type": "button", "value": "login"},
-                    },
-                    "display_append": "", "display_result": "",
-                },
-
-                map[string]interface{}{"componet_name": "tail", "componet_tmpl": "tail",
-                    "scripts": []interface{}{"toolkit.js", "context.js", "example.js", "code.js"},
-                },
-            },
-...
-```
-### 网页开发
-
-#### 模板
-
-usr/template 存放了网页的模板文件，context会调用golang的template接口进行后端渲染，生成html文件。
-不同的应用模块都会有自己的模板目录，也有公共模板库。
-
-- usr/template/common.tmpl 公共模板
-- usr/template/code/ code模块的模板
-- usr/template/wiki/ wiki模块的模板
-- usr/template/chat/ chat模块的模板
-
-#### 样式
-
-所有的css都存放usr/librarys
-
-- example.css
-- code.css
-- wiki.css
-- chat.css
-
-#### 脚本
-
-所有的js都存放usr/librarys
-
-- toolkit.js 工具库，主要是网页相关的操作，如AppendChild
-- context.js 通信库，主要是用来与后端context进行通信
-- example.js 框架库，统一定义了网页的框架，每个应用网页都会继承
-- code.js 工具链应用的网页
-- wiki.js 知识库应用的网页
-- chat.js 信息流应用的网页
-
-### 小程序
-### 开发板
-
-## 接口开发
-### componet
-### python
-### java
-### c
-
-## 模块开发
-### 应用模块
-#### 简单模块
-#### 复杂模块
-#### 脚本模块
-### 插件模块
-#### 独立插件
-#### 扩展插件
-### 核心模块
-#### 模块中心ctx
-#### 命令中心cli
-#### 认证中心aaa
-#### 应用中心web
-#### 网络中心tcp
-#### 存储中心nfs
-#### 集群中心ssh
-#### 数据中心mdb
-
 ## 系统架构
 
 | |数据流|命令流|权限流|应用流|
@@ -852,266 +307,3 @@ usr/template 存放了网页的模板文件，context会调用golang的template
 |控制层|lex|yac|log|gdb|
 |数据层|tcp|nfs|ssh|mdb|
 
-### 应用框架
-#### 模块
-
-context内部使用模块组织功能，每个模块都可以独立编译，独立运行。
-解除了代码之间的包依赖、库依赖、引用依赖、调用依赖。
-通过map查找模块，通过map查找命令，通过map查找配置，从而实现完全自由的模块。
-
-**模块定义：**
-```
-type Context struct { // src/contexts/ctx/ctx.go
-    Name string
-    Help string
-
-    Caches   map[string]*Cache
-    Configs  map[string]*Config
-    Commands map[string]*Command
-
-    ...
-
-    contexts map[string]*Context
-    context  *Context
-    root     *Context
-
-    ...
-    Server
-}
-
-```
-Name：模块名称，Help：模块帮助。
-模糊搜索搜索时，会根据Name与Help进行匹配。
-
-每个模块会有命令集合Commands，配置集合Configs，缓存集合Caches。通过这种形式提供功能集合。
-
-contexts：所有子模块，context：指向父模块，root：指向根模块。
-从而组成一个模块树，所以可以通过路由查找模块，
-如ctx.web.code，code的父模块是web，web的父模块是ctx，ctx是根模块。
-所以可以通过命令，查看到当前程序所有模块的信息。
-
-**缓存定义：**
-```
-type Cache struct {
-	Value string
-	Name  string
-	Help  string
-	Hand  func(m *Message, x *Cache, arg ...string) string
-}
-```
-Value：存放的数据，Name：变量名称，Help：变量帮助，Hand读写函数。
-
-缓存数量是一种数据接口，用来存放一些状态量，向外部显示程序进行状态，对外部来说一般是只读的。对内部来说可读可写。
-所以可以通过命令，查看到当前程序任意模块的状态数据。
-
-如下，ncontext当前有多少个模块。nserver有多少个模块运行了守护协程。
-
-```
-"nserver":    &Cache{Name: "nserver", Value: "0", Help: "服务数量"},
-"ncontext":   &Cache{Name: "ncontext", Value: "0", Help: "模块数量"},
-```
-
-**缓存读写：**
-```
-func (m *Message) Cap(key string, arg ...interface{}) string {}
-func (m *Message) Capi(key string, arg ...interface{}) int {}
-func (m *Message) Caps(key string, arg ...interface{}) bool {}
-```
-定义了缓存数据的三种读写接口。
-
-m.Cap()只有一个参数时，会从当前模块查询缓存变量，如果查到则返回Value，如果没有，则依次查询父模块。
-如果查找到根模块还没有查到找，变返回空字符串。
-
-m.Cap()有两个参数时，同样会从当前模块依次查询父模块，直到查到变量，然后设置其值。
-
-m.Capi()是对m.Cap()封装了一下，在int与str相互转换，从而实现用str存储int。
-所有转换失败的数据，都会返回0。
-
-m.Caps()，实现了str存储bool。返回false的值有"", "0", "false", "off", "no", "error: "，其它都返回true。
-
-**配置定义：**
-```
-type Config struct {
-	Value interface{}
-	Name  string
-	Help  string
-	Hand  func(m *Message, x *Cache, arg ...string) string
-}
-```
-Value：存放的数据，Name：变量名称，Help：变量帮助，Hand读写函数。
-与Cache相似，只是Value的类型不再是String而是interface{}，所以可以用来存放更复杂的数据。
-
-一般用来存放配置数据，是外部控制内部数据接口。
-所以可以通过命令，实时修改当前程序任意模块的配置数据。
-避免只是修改某个配置变量，就要重启整个进程，从而实现高效灵活的配置。
-把每个进程当成一个生命来对待，不要轻易杀死任何一个进程。有问题可以用微创手术解决。
-
-**配置读写：**
-```
-func (m *Message) Conf(key string, args ...interface{}) string {}
-func (m *Message) Confi(key string, arg ...interface{}) int {}
-func (m *Message) Confs(key string, arg ...interface{}) bool {}
-func (m *Message) Confx(key string, args ...interface{}) string {}
-func (m *Message) Confv(key string, args ...interface{}) interface{} {}
-func (m *Message) Confm(key string, args ...interface{}) map[string]interface{} {}
-```
-与Cache相似，也定义了各种读写的接口。
-
-因为interface{}可以是任意复合类型，所以数据嵌套很深时，查询会涉及各种类型转换，非常麻烦。
-Conf()定义了键值链。内部去处理类型转换与嵌套的深入。 
-如m.Conf("runtime", "user.node")、m.Conf("runtime", []string{"user", "node"})、m.Conf("runtime", []interface{}{"user", "node"})
-都会查询配置runtime下的user下的node的值。
-
-m.Confx()内部进行选择，如果m.Option(key)中取到了值，则直接返回m.Option(key)，否则返回m.Conf(key)。
-把配置当成一个备用的默认值，如果命令参数设置了此参数，则用命令中的参数。
-
-m.Confv()直接读写原始数据。
-m.Confm()则定义了更丰富的接口，m就是map意思，直接返回map[string]interface{}
-m另外一个意思就是magic，可以传入各种回调函数。
-如下配置node类型是map[string]interface{}，m.Confm()会遍历此map，查到value也是map[string]interface{}的键值，调用回调函数。
-```
-    ...
-    m.Confm("node", func(name string, node map[string]interface{}) {
-        if kit.Format(node["type"]) != "master" {
-            ps = append(ps, kit.Format(node["module"]))
-        }
-    })
-    ...
-```
-
-**命令定义：**
-```
-type Command struct {
-	Form map[string]int
-	Name string
-	Help interface{}
-	Auto func(m *Message, c *Context, key string, arg ...string) (ok bool)
-	Hand func(m *Message, c *Context, key string, arg ...string) (e error)
-}
-```
-Name：命令语法，Help：命令帮助。
-
-Hand：命令处理函数，m是调用消息，c是当前模块，key是命令名，arg是命令参数。
-
-在命令解析时，会根据Form将[key value...]形式的参数，取出存放到m.Option中，方便用key直接查找参数。
-所以arg中只剩下序列参数，通过index序号查找参数。
-
-Auto：终端自动补全函数。在使用终端每输入一个单词时，就调用此函数输出提示信息。所以在命令执行前，这个函数会被调用多次。
-
-如下定义了trans命令
-```
-    ...
-    "trans": &Command{Name: "trans option [type|data|json] limit 10 [index...]", Help: "数据转换",
-        Form: map[string]int{"format": 1, "fields": -1},
-        Hand: func(m *Message, c *Context, key string, arg ...string) (e error) {
-            ...
-        }}
-    ...
-```
-
-**命令调用：**
-```
-func (m *Message) Cmd(args ...interface{}) *Message {}
-func (m *Message) Cmdx(args ...interface{}) string {}
-func (m *Message) Cmds(args ...interface{}) bool {}
-func (m *Message) Cmdy(args ...interface{}) *Message {}
-func (m *Message) Cmdm(args ...interface{}) *Message {}
-```
-m.Cmd()根据第一个参数去当前查找命令，如果没有查找到，则去父模块查找。如果没有查找，则不会执行。
-剩下的参数会根据Form定义来解析，存放到m.Option中。
-
-m.Cmds()当返回值转换成bool规则同m.Caps()与m.Confs()。
-m.Cmdx()当返回值转换成str。 m.Cmdy()将结果复制到当前Message。
-
-m.Cmdm()，m同样是magic，会根据当前会话，自动定向到远程某主机某模块，远程调用其命令，当然也可能定向到本机。
-
-#### 协程
-#### 消息
-
-context内部调用都是
-
-
-### 解析引擎
-#### 文件扫描
-#### 词法解析
-#### 语法解析
-#### 执行命令
-### 通信框架
-#### 节点路由
-每个节点在启动时，自动向上级注册，生成一个动态域名，作为本节点的地址。
-如com.mac.led，led的上级节点是mac，mac的上级节点是com。
-其它节点，就可以通过个这个地址查找到此节点。
-
-在调用远程命令时，通信模块根据远程地址的第一个字段，查找子节点，查取成功后，会将剩余的地址与命令发送给查到的子节点。
-子节点收到地址与命令后，继续查找子节点，直到目标节点收到命令，然后将执行结果原路返回。
-
-在查找的过程中，如果没有查找到子节点，则会传给上级节点重新处理。
-
-#### 节点认证
-
-**节点加密**
-每个节点都有证书与密钥。每个节点在发送命令时，都会用自己的密钥签名，目标节点都会用它的证书验签。以此保证命令来源的可靠性。
-
-**节点类型**
-
-- 初始节点，没有归属的节点
-- 主控节点，有用户证书与密钥的节点
-- 从属节点，有用户证书的节点
-
-- 代理节点，主控节点指定的代理节点
-- 共享节点，允许多个用户控制的节点
-- 认证节点，专门用来存放与查询用户证书的节点
-
-用户在某一设备上添加自己的证书与密钥，此节点即为主控节点。 在其它节点上绑定自己的证书，此即为从属节点。
-
-主控节点就可任意控制从属节点，从属节点不能控制主控节点，从属节点之间也不能相互控制。
-
-主控节点可以指定代理节点，代理节点可以代替主控节点控制从属节点。
-
-共享节点，会有多个用户，可能产生冲突，所以需要认证节点协调。
-
-访问共享节点前，需要向认证节点注册，共享节点会从认证节点取出访问用户的信息。
-
-#### 节点权限
-
-***角色***
-
-每个访问用户，都会指定一个角色。
-主控节点的用户默认有root权限。即拥有设备的所有控制权限。
-
-认证节点的用户默认有tech权限。一般是部分功能。
-
-其它节点的用户默认有void权限。即拥有最小集合的权限，一般是只读的命令。
-
-***组件***
-
-组件是功能的集合，远程访问至少要有remote与source组件的权限才可以执行命令。
-
-每个角色下都会有多个组件的权限。
-
-***命令***
-
-命令就节点向外提供功能的最小单元。
-
-每个组件下都会有多条命令。
-
-***规则***
-
-每条命令内部可以用组件与命令的权限机制自定义权限检查。
-
-权限的分配完全由主控节点与从属节点自己配置，其它节点不许配置。
-
-***示例***
-
-如下配置，用户shy的角色是tech，角色tech下有两个组件remote与source，每个组件下都有命令pwd与dir，所以用户shy就可以远程调用命令dir与pwd
-```
-role tech user shy
-role tech componet remote command pwd dir
-role tech componet source command pwd dir
-```
-
-### 存储引擎
-#### 配置
-#### 缓存
-#### 数据
-