WEBVTT

00:00:00.000 --> 00:00:28.480
好,然后我们来讲一下这个Codex Lulers体系构建与代码可控性治理。那这个的话其实也是一套这个细节的一个规范啊。这个就更加的这个细利度了。前面那个我们说的这个规范的话,主要还是指的是整个项目的一些大的一些规范啊。比如说目录啊,结构啊,是吧。它就相当于一个代码地图。

00:00:28.480 --> 00:00:32.000
那这个Lurus的这个规范的话

00:00:32.000 --> 00:00:33.880
它就更加的细了

00:00:33.880 --> 00:00:36.300
这个是用来去控制

00:00:36.300 --> 00:00:39.820
哪些命令可以在沙箱外去做一个执行

00:00:39.820 --> 00:00:41.900
这个就偏执行类的

00:00:41.900 --> 00:00:44.940
也就是说比如说我们在这个

00:00:44.940 --> 00:00:47.180
跑一些代码的时候

00:00:47.180 --> 00:00:48.180
跑一些case的时候

00:00:48.180 --> 00:00:49.860
做一些自动化测试的时候

00:00:49.860 --> 00:00:52.320
那自动化测试的话

00:00:52.320 --> 00:00:54.220
可能涉及到命令就比较多了

00:00:54.220 --> 00:00:55.960
有可能会删除文件

00:00:55.960 --> 00:00:57.760
有可能需要调用工具

00:00:57.760 --> 00:00:59.000
等等的啊

00:00:59.000 --> 00:01:00.400
就个人关系的权限都会有

00:01:00.400 --> 00:01:03.380
所以Codex专门设计了一套

00:01:03.380 --> 00:01:05.520
叫Lulis的一套组件啊

00:01:05.520 --> 00:01:07.460
专门就是用来干这个事情的

00:01:07.460 --> 00:01:09.620
那这个里面的话啊

00:01:09.620 --> 00:01:11.400
很好理解就是什么呢

00:01:11.400 --> 00:01:12.640
那在这个里面

00:01:12.640 --> 00:01:15.180
你可以建一些这个Lulis啊

00:01:15.180 --> 00:01:18.380
比如说我们就直接在这个

00:01:18.380 --> 00:01:19.840
这个里面啊

00:01:19.840 --> 00:01:21.720
我们就找个项目吧

00:01:21.720 --> 00:01:23.060
嗯

00:01:23.060 --> 00:01:29.300
看一下啊

00:01:29.300 --> 00:01:32.760
这个里面的话

00:01:32.760 --> 00:01:34.900
相当于

00:01:34.900 --> 00:01:37.040
我们要可以加一个规则

00:01:37.040 --> 00:01:38.200
做一个什么呢

00:01:38.200 --> 00:01:39.900
就是杀向外运行的话

00:01:39.900 --> 00:01:41.460
需要先提示用户确认

00:01:41.460 --> 00:01:44.940
也就是说我们可能要执行一个

00:01:44.940 --> 00:01:47.980
GHPR的一个命令

00:01:47.980 --> 00:01:49.160
然后这个命令的话

00:01:49.160 --> 00:01:50.540
可能要去干嘛呢

00:01:50.540 --> 00:01:53.520
要去分析一些仓库是吧

00:01:53.520 --> 00:01:55.180
获取一些这个信息

00:01:55.180 --> 00:01:56.920
所以这个里面的话

00:01:56.920 --> 00:01:59.720
当他执行这种命令的时候

00:01:59.720 --> 00:02:03.100
我们需要有用户去做一个确认

00:02:03.100 --> 00:02:05.020
所以这个里面

00:02:05.020 --> 00:02:06.100
事实上

00:02:06.100 --> 00:02:08.380
他就是要做一个什么呢

00:02:08.380 --> 00:02:09.540
授权的一个管理

00:02:09.540 --> 00:02:12.660
那比如说我们现在就是在这个里面去建一下

00:02:12.660 --> 00:02:16.800
然后我们在这个里面

00:02:16.800 --> 00:02:18.000
比如说这个项目下面

00:02:18.000 --> 00:02:20.740
先建文件啊

00:02:20.740 --> 00:02:22.160
比如说我就建一个点lulus

00:02:22.160 --> 00:02:25.240
然后把下面这一堆翻过来啊

00:02:25.240 --> 00:02:26.800
翻过来啊

00:02:26.800 --> 00:02:28.300
然后在这个里面的话

00:02:28.300 --> 00:02:31.840
我们可以看一下

00:02:31.840 --> 00:02:35.440
首先我们进入到洛伊的这个目楼里去

00:02:35.440 --> 00:02:39.240
进入到洛伊

00:02:48.000 --> 00:02:50.900
好到这个里面然后进入到codex

00:02:50.900 --> 00:02:52.300
然后你就直接问他

00:02:52.300 --> 00:02:56.100
当前项目有哪些

00:02:56.100 --> 00:03:01.100
glueless

00:03:01.100 --> 00:03:06.600
你就直接问他有哪些具体的这个规则是吧

00:03:06.600 --> 00:03:19.460
然后他会自动的去分析啊

00:03:19.460 --> 00:03:22.760
他会去找

00:03:22.760 --> 00:03:26.020
所以他优先级的话

00:03:26.020 --> 00:03:29.480
他会去扫Lulis的这个目录吧

00:03:29.480 --> 00:03:30.780
这里还不行

00:03:30.780 --> 00:03:34.520
我们建了这个点Lulis的这个目录文件以外

00:03:34.520 --> 00:03:35.020
我看一下

00:03:35.020 --> 00:03:38.860
还要建一个.lulus的目录

00:03:38.860 --> 00:03:40.520
不然的话加载是有问题的

00:03:41.540 --> 00:03:44.980
所以这个里面我们得加一个

00:03:44.980 --> 00:03:48.520
还得建个目录

00:03:48.520 --> 00:03:51.100
建个文件夹

00:03:51.100 --> 00:03:54.900
然后把这个.lulus给它拖进去

00:03:54.900 --> 00:03:59.680
然后再重启一下

00:04:03.280 --> 00:04:04.340
然后再去问它

00:04:04.340 --> 00:04:25.040
然后这个里面

00:04:25.040 --> 00:04:27.180
他会去加载这个Lulis

00:04:27.180 --> 00:04:34.000
你看他把agency.md的内容

00:04:34.000 --> 00:04:34.840
也输出出来了

00:04:34.840 --> 00:04:37.240
看一下lulis

00:04:37.240 --> 00:04:39.680
嗯

00:04:39.680 --> 00:04:43.360
哎他这个这里个规范没有输出来

00:04:43.360 --> 00:04:46.040
项目生效的lulis

00:04:46.040 --> 00:04:47.480
dd驱动

00:04:47.480 --> 00:04:52.560
他他把这个lulis理解成

00:04:52.560 --> 00:04:53.920
agents.md了

00:04:53.920 --> 00:04:57.080
看一下有没有办法给他调整一下

00:04:57.080 --> 00:04:59.140
嗯

00:04:59.140 --> 00:05:03.980
这里要去激活一下啊

00:05:04.000 --> 00:05:10.100
lulus

00:05:10.100 --> 00:05:15.700
看一下这个目录

00:05:15.700 --> 00:05:17.840
lulus 下面有一个点

00:05:17.840 --> 00:05:18.360
lulus

00:05:18.360 --> 00:05:27.440
然后我们

00:05:27.440 --> 00:05:31.200
执行一下这个命令看一下

00:05:34.000 --> 00:05:41.800
ghprvu

00:05:41.800 --> 00:05:54.700
原因是当前仓库的gitremote没有指向github助期

00:05:54.700 --> 00:05:58.200
那其实我们可以换一个项目

00:05:58.200 --> 00:06:00.700
prodx

00:06:04.000 --> 00:06:10.840
我们找到那个项目

00:06:10.840 --> 00:06:13.240
用这个开源项目来测试一下

00:06:19.000 --> 00:06:21.000
把这个项目导下来啊

00:06:21.000 --> 00:06:34.120
git clone

00:06:34.120 --> 00:06:40.940
首先我把这个项目拉下来

00:06:40.940 --> 00:06:48.100
因为这个里面要用github的项目

00:06:48.100 --> 00:06:50.180
我上面那个是gitty的一个项目

00:06:51.000 --> 00:06:53.400
所以我首先要把它给它导进来

00:06:53.400 --> 00:06:58.680
看这个项目有点大啊

00:06:58.680 --> 00:07:01.740
反正这个规则的意思就是

00:07:01.740 --> 00:07:04.640
大家在执行一些命令的时候

00:07:04.640 --> 00:07:08.740
就是你可以去指定哪一些各个命令

00:07:08.740 --> 00:07:10.720
是需要用户授权的

00:07:10.720 --> 00:07:13.620
因为我们默认的话

00:07:13.620 --> 00:07:15.820
其实有一些命令啊

00:07:15.820 --> 00:07:17.120
它需要授权

00:07:17.120 --> 00:07:18.660
有些是不需要授权的

00:07:18.660 --> 00:07:20.360
那么大家可以去配一下

00:07:20.360 --> 00:07:21.740
就是在某些命令下

00:07:21.740 --> 00:07:23.400
需要去触发授权

00:07:23.400 --> 00:07:25.280
也就是大家可以针对

00:07:25.280 --> 00:07:27.280
我们当前执行的一个命令的话

00:07:27.280 --> 00:07:29.860
做一些细地图的权限管控

00:07:29.860 --> 00:07:31.120
就加一个规则

00:07:31.120 --> 00:07:33.880
因为涉及到一些危险动作的时候

00:07:33.880 --> 00:07:36.640
就需要用户来确认

00:07:36.640 --> 00:07:38.580
确认完之后再去做处理

00:07:38.580 --> 00:07:41.020
所以我们在这个点

00:07:41.020 --> 00:07:43.680
Codex里面去加这个规则的话

00:07:43.680 --> 00:07:45.460
就意味着什么呢

00:07:45.460 --> 00:07:48.400
我们可以去做一些权限的一些细节管控

00:07:48.400 --> 00:07:50.320
就是做一个这种审批

00:07:50.320 --> 00:07:53.120
就相当于大家在这做这个

00:07:53.120 --> 00:07:54.840
整个的一个

00:07:54.840 --> 00:07:57.540
各种各样的命令管理的时候

00:07:57.540 --> 00:07:59.780
你可以下一些细流的一些管控

00:07:59.780 --> 00:08:01.000
有一些

00:08:01.000 --> 00:08:03.180
这个命令的话

00:08:18.690 --> 00:08:20.090
给他加一下

00:08:20.090 --> 00:08:20.610
是吧

00:08:20.610 --> 00:08:22.530
加一些权限控制

00:08:22.530 --> 00:08:24.430
然后这个里面啊

00:08:24.430 --> 00:08:25.850
我们可以配置哪些东西呢

00:08:25.850 --> 00:08:27.490
比如说啊

00:08:27.490 --> 00:08:29.390
它是有一套规范

00:08:29.390 --> 00:08:30.870
比如说这个partner

00:08:30.870 --> 00:08:31.790
匹配规则

00:08:31.790 --> 00:08:32.530
比如说pr

00:08:32.530 --> 00:08:34.690
就是你有pr的一些命令

00:08:34.690 --> 00:08:36.430
然后这个decision

00:08:36.430 --> 00:08:38.230
这个是做一些具体的命

00:08:38.230 --> 00:08:39.310
动作的一个执行

00:08:39.310 --> 00:08:40.650
比如说允许

00:08:40.650 --> 00:08:41.650
或者拒绝

00:08:41.650 --> 00:08:42.390
或者怎么样

00:08:42.390 --> 00:08:44.230
一个是不提示

00:08:44.230 --> 00:08:46.610
直接在沙厢环境下面去执行

00:08:46.610 --> 00:08:47.930
然后是提示

00:08:47.930 --> 00:08:50.090
就每次命中都要确认请求

00:08:50.090 --> 00:08:53.870
然后这个forbidden是直接拒绝了

00:08:53.870 --> 00:08:56.130
就这种命令就不允许执行了

00:08:56.130 --> 00:08:59.630
比如说RM跟RF这种删除文件的

00:08:59.630 --> 00:09:01.490
我们就不管它了

00:09:01.490 --> 00:09:02.430
这个完了

00:09:02.430 --> 00:09:05.530
然后我们现在去切换到这个

00:09:05.530 --> 00:09:07.530
看一下

00:09:07.530 --> 00:09:10.870
切换到codex

00:09:10.870 --> 00:09:12.470
这个项目里面去

00:09:12.470 --> 00:09:15.170
然后在这个项目下面的话

00:09:15.170 --> 00:09:16.210
我们建一个

00:09:16.210 --> 00:09:17.870
把那个移动过去

00:09:17.870 --> 00:09:19.870
刚刚有一个lulus

00:09:23.270 --> 00:09:24.870
把这个移到这个下面去

00:09:34.370 --> 00:09:35.510
好现在已经移过来

00:09:35.510 --> 00:09:36.130
移过来之后

00:09:36.130 --> 00:09:37.670
我们再切进去看一下

00:09:39.070 --> 00:09:39.970
codex

00:09:43.210 --> 00:09:43.870
好这里面

00:09:43.870 --> 00:09:46.670
然后我们再去执行刚刚的一个指令

00:09:47.870 --> 00:09:54.070
比如说我们来分析一下

00:09:54.070 --> 00:09:59.770
当前项目的

00:09:59.770 --> 00:10:03.590
Loss有哪些

00:10:17.870 --> 00:10:27.910
他默认读的也是这个agents.md

00:10:27.910 --> 00:10:35.470
他不能夹载内容

00:10:35.470 --> 00:10:39.570
这就这么来就问他

00:10:39.570 --> 00:10:42.650
当前项目的

00:10:42.650 --> 00:10:46.530
有哪些内容

00:10:46.530 --> 00:10:53.810
我看这样来问行不行啊

00:10:53.810 --> 00:10:57.530
他会去找这个文件啊

00:10:57.530 --> 00:11:04.610
他是有一个匹配规则的

00:11:04.610 --> 00:11:08.590
就比如说Codex想在沙箱里面去运行

00:11:08.590 --> 00:11:10.250
GHVU开头的命令

00:11:10.250 --> 00:11:11.950
但是需要后续的批准

00:11:11.950 --> 00:11:14.250
精准匹配啊才可以

00:11:14.250 --> 00:11:17.790
所以说不匹配

00:11:17.790 --> 00:11:22.490
比如说我们现在来整这个看一下

00:11:22.490 --> 00:11:37.710
你看现在是不是需要用户来确认是吧

00:11:37.710 --> 00:11:40.950
这个是不是我们那个规则生效了

00:11:40.950 --> 00:11:44.010
这里面是不是就需要用户来确认

00:11:44.010 --> 00:11:44.910
是吧

00:11:44.910 --> 00:11:46.810
来确认一下

00:11:46.810 --> 00:12:02.290
你看这个是以执行

00:12:02.290 --> 00:12:05.310
然后我们再来执行这个看一下

00:12:14.010 --> 00:12:15.690
你看用这种命令

00:12:15.690 --> 00:12:16.950
一旦匹配上了

00:12:16.950 --> 00:12:17.670
他就要确认

00:12:17.670 --> 00:12:19.550
然后不匹配的

00:12:19.550 --> 00:12:20.890
我们来也来确认一下

00:12:20.890 --> 00:12:24.010
看一下这个是不是就不会授权了

00:12:24.010 --> 00:12:31.370
这个还是要确认

00:12:31.370 --> 00:12:33.250
这个也是要确认

00:12:33.250 --> 00:12:35.090
只是说这里面

00:12:35.090 --> 00:12:38.690
就是相当于一些一个逻辑

00:12:38.690 --> 00:12:41.430
要做一些处理

00:12:41.430 --> 00:12:46.070
但是我们看一下这个上面那个规则

00:12:46.070 --> 00:12:55.650
因为他网络访问

00:12:55.650 --> 00:12:56.990
所以还是需要授权

00:12:56.990 --> 00:12:59.110
其实这个不匹配的话

00:12:59.110 --> 00:13:02.030
不匹配的话就必须

00:13:02.030 --> 00:13:03.410
然后再分析一下

00:13:03.410 --> 00:13:05.150
看一下刚刚那个规则是什么

00:13:11.430 --> 00:13:17.930
呃

00:13:17.930 --> 00:13:21.370
GHPRVU会匹配

00:13:21.370 --> 00:13:22.730
GonRepo不会匹配

00:13:22.730 --> 00:13:25.430
因为他不是以精准的GHPRVU

00:13:27.130 --> 00:13:28.330
不匹配会怎么样

00:13:41.430 --> 00:13:46.310
怎么样

00:13:46.310 --> 00:13:48.770
我们就看一下

00:13:48.770 --> 00:13:50.570
他这个规则到底是怎么样的

00:13:50.570 --> 00:13:52.990
他说是不会命中

00:13:52.990 --> 00:13:54.550
点Lulis这个规则

00:13:54.550 --> 00:13:58.770
但是我们实际还是看到那个是吧

00:13:58.770 --> 00:14:00.490
看一下他这个细节

00:14:00.490 --> 00:14:02.950
他说的是不会命中

00:14:07.750 --> 00:14:10.590
但是因为还是会涉及到一些网络权限

00:14:10.590 --> 00:14:12.550
还是会有一些提示的

00:14:12.550 --> 00:14:15.390
你看啊

00:14:15.390 --> 00:14:17.590
因为这个命令需要访问GitHub网络

00:14:17.590 --> 00:14:19.190
所以在当年黄金下

00:14:19.190 --> 00:14:21.350
还是会要求额外授权之行

00:14:21.350 --> 00:14:22.430
所以正常来说

00:14:22.430 --> 00:14:25.310
按理说他没有匹配就不需要做授权

00:14:25.310 --> 00:14:27.370
因为你要访问网络啊

00:14:27.370 --> 00:14:31.730
所以这个就还是要做授权的

00:14:31.730 --> 00:14:35.610
那我们最近这个依旧需要授权

00:14:40.590 --> 00:14:42.450
你看这里面需要确认一下

00:14:42.450 --> 00:14:45.510
还是需要收取

00:14:45.510 --> 00:14:49.410
也要涉及到访问网络啊

00:14:49.410 --> 00:14:53.070
所以这个规则这个里面的逻辑就是

00:14:53.070 --> 00:14:55.190
啊我们整个

00:14:55.190 --> 00:14:58.570
他不一定就说严格按照这个来啊

00:14:58.570 --> 00:15:00.470
他还要根据当前的环境来决定

00:15:00.470 --> 00:15:06.090
这个里面到底有没有其他的一些权限需要去申请啊

00:15:06.090 --> 00:15:08.870
所以说你写在这里的话

00:15:08.870 --> 00:15:11.090
如果说这个里面啊

00:15:11.090 --> 00:15:13.770
并不需要额外再去申请其他权限的话

00:15:13.770 --> 00:15:15.670
这个命令执行就执行成功了

00:15:15.670 --> 00:15:18.430
他不会弹出那个还需要你确认的那个过程

00:15:18.430 --> 00:15:21.590
所以具体得看一些场景啊

00:15:21.590 --> 00:15:24.250
这个大家回头也可以去试一下

00:15:24.250 --> 00:15:27.170
如果他但凡没有涉及到网络访问的话

00:15:27.170 --> 00:15:29.870
这个我们其实是OK的啊

00:15:29.870 --> 00:15:33.130
所以整个Codex

00:15:33.130 --> 00:15:35.170
他的一个处理逻辑的话就是

00:15:35.170 --> 00:15:39.770
他会先去加载我们整个Lulis的一个目录

00:15:39.770 --> 00:15:40.130
是吧

00:15:40.130 --> 00:15:42.230
那加载完之后的话

00:15:42.230 --> 00:15:46.770
他会读取到里面的这个点Lulis的一些文件内容

00:15:46.770 --> 00:15:47.790
然后的话

00:15:47.790 --> 00:15:50.270
这个里面他也分全局的

00:15:50.270 --> 00:15:51.630
还有这个项目的

00:15:51.630 --> 00:15:53.690
就有用户级别的

00:15:53.690 --> 00:15:54.910
整个全局的

00:15:54.910 --> 00:15:56.890
也有按照项目来分的

00:15:56.890 --> 00:15:58.670
在某个项目下面去点Lulis

00:15:58.670 --> 00:16:01.730
这个都是OK的

00:16:01.730 --> 00:16:03.890
跟我们前面讲的那个

00:16:03.890 --> 00:16:04.484
嗯

00:16:19.484 --> 00:16:20.884
就是一个匹配

00:16:20.884 --> 00:16:22.884
在这个里面

00:16:22.884 --> 00:16:25.184
比如说我们可以匹配pr命令是吧

00:16:25.184 --> 00:16:26.684
然后decision

00:16:26.684 --> 00:16:28.484
就我们前面讲的不提示

00:16:28.484 --> 00:16:30.184
然后提示

00:16:30.184 --> 00:16:32.684
然后或者是直接阻止了

00:16:33.884 --> 00:16:34.784
那比如说大家

00:16:34.784 --> 00:16:36.684
其实你可以在这个里面去改

00:16:36.684 --> 00:16:38.184
比如说现在是提示吗

00:16:38.184 --> 00:16:40.684
你直接改成forbidden

00:16:40.684 --> 00:16:42.984
然后你再去执行看一下

00:16:42.984 --> 00:16:43.784
比如说在这个里面

00:16:43.784 --> 00:16:45.384
我们先退出去

00:16:45.384 --> 00:16:46.884
再执行codex

00:16:46.884 --> 00:16:49.084
然后再直接执行这个

00:16:49.484 --> 00:16:50.204
命令

00:16:50.204 --> 00:16:51.344
看一下他会怎么样

00:16:51.344 --> 00:16:56.824
你看

00:16:56.824 --> 00:16:58.344
当前

00:16:58.344 --> 00:17:01.484
看一下会不会被拒绝啊

00:17:01.484 --> 00:17:03.084
啊

00:17:03.084 --> 00:17:05.384
因为这个是网络访问啊

00:17:05.384 --> 00:17:06.944
这个是另外一个权限申请啊

00:17:06.944 --> 00:17:08.124
跟刚刚那个还不一样

00:17:08.124 --> 00:17:17.144
看一下他最终会不会被拒绝啊

00:17:17.144 --> 00:17:19.044
你看现在已经在加载那个

00:17:19.044 --> 00:17:19.964
点录了死了

00:17:19.964 --> 00:17:23.264
看一下他最终会不会被拒绝掉

00:17:23.264 --> 00:17:37.984
还是有这个结果

00:17:37.984 --> 00:17:41.444
这个是前面咱们做了授权

00:17:41.444 --> 00:17:43.304
一次性给他加进去了吗

00:17:43.304 --> 00:17:46.704
正常来说应该是给他拒绝了

00:17:46.704 --> 00:17:49.704
我现在已经有一个forbidden了

00:17:49.704 --> 00:17:51.104
我再退出去啊

00:17:51.104 --> 00:17:51.704
再看一下

00:17:51.704 --> 00:18:02.704
看我切换这个premission看一下

00:18:02.704 --> 00:18:05.704
然后测试review

00:18:05.704 --> 00:18:07.704
我切换这种模式看一下

00:18:07.704 --> 00:18:10.704
然后再置信

00:18:10.704 --> 00:18:13.704
看一下他需不需要确认

00:18:16.704 --> 00:18:24.764
他说GH因为网络杀箱受限

00:18:24.764 --> 00:18:27.324
他会按照他这里提升的权限

00:18:27.324 --> 00:18:29.724
他那个杀箱是没权限的

00:18:29.724 --> 00:18:31.624
是直接给他锯掉的

00:18:31.624 --> 00:18:34.864
但是的话他要重新做一个提权

00:18:34.864 --> 00:18:37.704
所以这里面他最终还是可以的

00:18:37.704 --> 00:18:40.424
你看他这个只是查询

00:18:40.424 --> 00:18:42.364
他没有涉及到修改的风险

00:18:42.364 --> 00:18:44.824
所以这里面默认给他放行的

00:18:44.824 --> 00:18:46.984
看一下

00:18:46.984 --> 00:18:53.684
在这里大家去改的话

00:18:53.684 --> 00:18:55.464
你其实看不到什么效果

00:18:55.464 --> 00:18:58.524
他其实杀箱给他阻止了

00:18:58.524 --> 00:18:59.984
但是的话就是

00:18:59.984 --> 00:19:03.344
我们还是可以有一个提权的过程

00:19:03.344 --> 00:19:05.564
这个是他设计的

00:19:05.564 --> 00:19:06.844
就是这个样子

00:19:14.824 --> 00:19:22.184
你看他这个是网络网络权限啊

00:19:25.024 --> 00:19:27.184
然后不要告诉我之前

00:19:27.184 --> 00:19:29.664
告诉Codex

00:19:29.664 --> 00:19:35.004
他其实内部是已经拒绝

00:19:35.004 --> 00:19:36.784
但是这里会有个提权的操作

00:19:36.784 --> 00:19:39.844
所以大家得看距离的一个情况

00:19:39.844 --> 00:19:43.904
然后我们还可以加一些不同的一些参数是吧

00:19:43.904 --> 00:19:45.444
然后去做一些匹配啊等等

00:19:45.444 --> 00:19:48.504
那这个里面的话就是

00:19:48.504 --> 00:19:51.364
我们基于这个Codex

00:19:51.364 --> 00:19:53.204
可以去做一些这个

00:19:53.204 --> 00:19:55.784
评估一条代运行的命令的时候

00:19:55.784 --> 00:19:57.284
他会把命令

00:19:57.284 --> 00:19:58.384
他的一个参数

00:19:58.384 --> 00:20:00.784
做一个比较啊

00:20:00.784 --> 00:20:01.624
那在内部的话

00:20:01.624 --> 00:20:02.884
Codex会把命令

00:20:02.884 --> 00:20:04.724
看作一个参数列表

00:20:04.724 --> 00:20:06.304
比如说一些这个

00:20:06.304 --> 00:20:09.424
不同的这个参数是吧

00:20:09.424 --> 00:20:10.064
比如说这个

00:20:10.064 --> 00:20:13.484
EKCVP这种参数的方式

00:20:13.484 --> 00:20:15.684
然后去做一个这个接收

00:20:15.684 --> 00:20:19.144
就是他会有这么一个机制

00:20:19.144 --> 00:20:20.584
好

00:20:20.584 --> 00:20:22.224
然后是sharewrapple

00:20:22.224 --> 00:20:23.544
与复合的一些命令

00:20:23.544 --> 00:20:25.524
这个是用来干嘛的呢

00:20:25.524 --> 00:20:27.464
这个就是我们还可以包装一下

00:20:27.464 --> 00:20:29.524
就是我们在lulis里面

00:20:29.524 --> 00:20:32.704
我们可以把整个命令做一个包装

00:20:32.704 --> 00:20:34.524
什么意思呢

00:20:34.524 --> 00:20:36.584
就是你现在要执行多个命令是吧

00:20:36.584 --> 00:20:39.544
那我现在想把这个做给打包

00:20:39.544 --> 00:20:41.864
比如说提交文件删除

00:20:41.864 --> 00:20:43.344
整个做一个打包

00:20:43.344 --> 00:20:46.044
那么在这里面的话

00:20:46.044 --> 00:20:46.804
就相当于

00:20:46.804 --> 00:20:49.444
它单次操作的话

00:20:49.444 --> 00:20:51.424
相当于把整个mini做一个执行

00:20:51.424 --> 00:20:53.144
就这里面我们可以做一个封装

00:20:53.144 --> 00:20:55.664
然后Codex的话

00:20:55.664 --> 00:20:59.644
它什么时候可以去拆分一些脚本

00:20:59.644 --> 00:21:01.004
比如说

00:21:01.004 --> 00:21:02.584
这个里面

00:21:02.584 --> 00:21:05.904
一些纯字面量的一些单词

00:21:05.904 --> 00:21:08.204
不包含变量展开的这种情况

00:21:08.204 --> 00:21:10.244
或者是一些

00:21:10.244 --> 00:21:13.124
只通过安全运算服务的一些

00:21:13.124 --> 00:21:13.784
这个场景

00:21:13.784 --> 00:21:15.544
或者是一些

00:21:15.544 --> 00:21:16.464
这个

00:21:16.464 --> 00:21:19.524
不同情况的

00:21:19.524 --> 00:21:20.644
比如说下面这个

00:21:20.644 --> 00:21:23.304
一些有规则的

00:21:23.304 --> 00:21:23.604
是吧

00:21:23.604 --> 00:21:25.544
就都是安全的这种场景

00:21:25.544 --> 00:21:27.064
这个时候的话

00:21:27.064 --> 00:21:28.164
他就可以去

00:21:28.164 --> 00:21:29.644
加一些这个

00:21:29.644 --> 00:21:30.904
一些

00:21:30.904 --> 00:21:33.244
做一些安全的一些拆分

00:21:33.244 --> 00:21:34.804
比如说把这些命令

00:21:34.804 --> 00:21:35.404
做一个拆分

00:21:35.404 --> 00:21:38.184
所以他会分别用你的LULUS

00:21:38.184 --> 00:21:39.524
去评估每一条命令

00:21:39.524 --> 00:21:41.424
并且以最严格的

00:21:41.424 --> 00:21:42.624
这个结果为准

00:21:42.624 --> 00:21:44.944
然后这里面的话

00:21:44.944 --> 00:21:47.744
即使你允许这个partner

00:21:47.744 --> 00:21:49.844
然后执行这个

00:21:49.844 --> 00:21:51.904
你写了这个东西的话

00:21:51.904 --> 00:21:53.544
那他也不会自动放弃

00:21:53.544 --> 00:21:56.244
因为这个RM和RF

00:21:56.244 --> 00:21:57.964
是一个非常危险的一个操作

00:21:57.964 --> 00:22:01.264
因为这个命令比较危险

00:22:01.264 --> 00:22:02.484
所以他会单独评估

00:22:02.484 --> 00:22:05.204
所以你写归你写

00:22:05.204 --> 00:22:07.484
但是Codex他自己也有一套

00:22:07.484 --> 00:22:08.764
内置的一套规范

00:22:08.764 --> 00:22:12.244
所以这种危险命令的话

00:22:12.244 --> 00:22:13.364
你混在一起的话

00:22:13.364 --> 00:22:16.544
就违背了他的一个安全指令的一个要求

00:22:16.544 --> 00:22:18.304
所以大家会发现

00:22:18.304 --> 00:22:19.824
你不是你写所有命令

00:22:19.824 --> 00:22:21.564
他都会给你放行的

00:22:21.564 --> 00:22:22.764
他也要去看情况

00:22:22.764 --> 00:22:25.304
这个是Codex

00:22:25.304 --> 00:22:27.744
他可以做一些安全脚本的一个拆分

00:22:27.744 --> 00:22:29.024
然后的话Codex

00:22:29.024 --> 00:22:31.284
他什么情况下不会去拆分脚本呢

00:22:31.284 --> 00:22:34.024
比如说我们已经加了一些重令像的一些东西了

00:22:34.024 --> 00:22:35.964
加了一些替换的表达式了

00:22:35.964 --> 00:22:37.904
或者做了一些环境变量的一些复制了

00:22:37.904 --> 00:22:39.844
或者加了一些通费符了

00:22:39.844 --> 00:22:41.964
那这个就不会尝试去解析他

00:22:41.964 --> 00:22:43.924
因为它本身就代表

00:22:43.924 --> 00:22:45.684
它的执行的一些关键点

00:22:45.684 --> 00:22:47.384
是一些规范

00:22:47.384 --> 00:22:50.264
所以它就不会去拆分

00:22:50.264 --> 00:22:51.784
然后同时的话

00:22:51.784 --> 00:22:52.984
它就直接把它用过来

00:22:52.984 --> 00:22:54.384
直接去运行的啊

00:22:54.384 --> 00:22:57.484
所以它也不是说你写了

00:22:57.484 --> 00:22:58.784
它就会帮你去拆分

00:22:58.784 --> 00:23:00.564
那它也要去看情况

00:23:00.564 --> 00:23:04.324
所以这种处理方式意味着

00:23:04.324 --> 00:23:07.184
你就是在可以安全拆分的时候

00:23:07.184 --> 00:23:08.924
Codex会按照单条命令

00:23:08.924 --> 00:23:10.144
逐项的去评估

00:23:10.144 --> 00:23:12.064
在不能安全拆分的时候

00:23:12.064 --> 00:23:12.844
就是按照

00:23:12.844 --> 00:23:14.884
更加保守的一个方案

00:23:14.884 --> 00:23:15.644
去做一个贫固

00:23:15.644 --> 00:23:18.684
然后弄完之后的话

00:23:18.684 --> 00:23:20.744
我们也可以去做一些测试

00:23:20.744 --> 00:23:23.304
比如说我们把这个命令

00:23:23.304 --> 00:23:25.344
加到这里来可以看一下

00:23:27.330 --> 00:23:33.890
就是你可以去看一下這個規則到底有沒有生效。

00:23:33.890 --> 00:23:38.690
比如說我們這個規則,我們可以把它加進去。

00:23:38.690 --> 00:23:40.750
你看这个里面就找到了啊

00:23:40.750 --> 00:23:42.590
什么

00:23:42.590 --> 00:23:44.450
Codex

00:23:44.450 --> 00:23:45.330
Default

00:23:45.330 --> 00:23:47.150
Check

00:23:47.150 --> 00:23:49.890
当前的这个用户目标

00:23:49.890 --> 00:23:52.690
但是我们没有这个规则是吧

00:23:52.690 --> 00:23:55.830
这个当前用户目标没有建那个规则

00:23:55.830 --> 00:23:59.350
所以这个里面我们得改一下啊

00:23:59.350 --> 00:24:02.250
这个就是当前目录的

00:24:02.250 --> 00:24:03.330
Lulis

00:24:03.330 --> 00:24:05.330
点Lulis

00:24:05.330 --> 00:24:08.690
这里我们就指定当前步

00:24:08.690 --> 00:24:11.650
然后来评估一下它的一些变化

00:24:11.650 --> 00:24:13.270
来看一下

00:24:29.910 --> 00:24:32.410
PowerShell可以复制执行的一个命令

00:24:32.410 --> 00:24:35.670
你看他帮我们把命令做了一个优化

00:24:35.670 --> 00:24:39.010
来我们退出去执行一下

00:24:39.010 --> 00:24:45.790
这个里面有一个问题

00:24:45.790 --> 00:24:47.090
Codex

00:25:02.410 --> 00:25:05.910
你看这个是他匹配的一个规则是吧

00:25:05.910 --> 00:25:08.250
匹配的规则就是我们可以看得出来

00:25:08.250 --> 00:25:10.810
这个里面的话就相当于不被允许啊

00:25:10.810 --> 00:25:13.070
这就是他要有这个结论

00:25:13.070 --> 00:25:14.670
他可以分析出来

00:25:14.670 --> 00:25:16.750
我们去执行这个命令的时候

00:25:16.750 --> 00:25:19.090
他给的这个决定就是拒绝了啊

00:25:19.090 --> 00:25:20.970
这就是测试规则文件

00:25:20.970 --> 00:25:22.450
到底有没有写的有没有问题

00:25:22.450 --> 00:25:25.070
他默认的话会帮你输出一个

00:25:25.070 --> 00:25:27.610
JSON格式的这么一个规则出来啊

00:25:27.610 --> 00:25:31.230
所以这个是我们做测试用的

00:25:31.230 --> 00:25:36.350
然后包括一些这些规则的一些语言啊

00:25:36.350 --> 00:25:36.690
是吧

00:25:36.690 --> 00:25:37.610
比如说

00:25:37.610 --> 00:25:39.590
大家可以去看一下

00:25:39.590 --> 00:25:42.110
专门有一套语法啊

00:25:42.110 --> 00:25:45.270
叫这个Specific的这么一个语法

00:25:45.270 --> 00:25:49.790
你看这个是专门的有一套规范啊

00:25:49.790 --> 00:25:50.870
大家可以去看一下

00:25:50.870 --> 00:25:54.070
怎么来写这个东西

00:25:54.070 --> 00:25:54.770
是吧

00:25:54.770 --> 00:25:56.830
大家可以去看一下

00:25:56.830 --> 00:25:58.990
他是专门有一套规则语法的

00:25:58.990 --> 00:26:00.610
他是采用了这种方式

00:26:00.610 --> 00:26:02.210
去写规则的

00:26:02.210 --> 00:26:04.490
大家可以去参考一下

00:26:04.490 --> 00:26:05.890
这是它的一个使用说明

00:26:05.890 --> 00:26:08.890
它的语法看起来有点像Python

00:26:08.890 --> 00:26:10.890
但是设计目标的话是安全执行

00:26:10.890 --> 00:26:12.650
所以Lulis的一个引擎

00:26:12.650 --> 00:26:14.830
可以在不产生副作用的前例下

00:26:14.830 --> 00:26:16.170
去运行它

00:26:16.170 --> 00:26:19.110
比如说它不会去触碰文件系统的一些逻辑

00:26:19.110 --> 00:26:20.630
所以这个里面

00:26:20.630 --> 00:26:23.830
大家可以去看一下它的一个细节点

00:26:23.830 --> 00:26:25.690
这个我们可以去