0:00.000–0:07.651
zh好,然后我们来讲一下这个Codex Rules体系构建与代码可控性治理。
0:07.651–0:12.327
zh那这个的话其实也是一套这个细节的一个规范啊。
0:12.327–0:15.090
zh这个就更加的这个细粒度了。
0:15.090–0:22.954
zh前面那个我们说的这个规范的话,主要还是指的是整个项目的一些大的一些规范啊。
0:22.954–0:25.930
zh比如说目录啊,结构啊,是吧。
0:25.930–0:28.480
zh它就相当于一个代码地图。
0:28.480–0:32.000
zh那这个Rules的这个规范的话
0:32.000–0:33.880
zh它就更加的细了
0:33.880–0:36.300
zh这个是用来去控制
0:36.300–0:39.820
zh哪些命令可以在沙箱外去做一个执行
0:39.820–0:41.900
zh这个就偏执行类的
0:41.900–0:44.940
zh也就是说比如说我们在这个
0:44.940–0:47.180
zh跑一些代码的时候
0:47.180–0:48.180
zh跑一些case的时候
0:48.180–0:49.860
zh做一些自动化测试的时候
0:49.860–0:52.320
zh那自动化测试的话
0:52.320–0:54.220
zh可能涉及到命令就比较多了
0:54.220–0:55.960
zh有可能会删除文件
0:55.960–0:57.760
zh有可能需要调用工具
0:57.760–0:59.000
zh等等的啊
0:59.000–1:00.400
zh就个人相关的权限都会有
1:00.400–1:03.380
zh所以Codex专门设计了一套
1:03.380–1:05.520
zh叫Rules的一套组件啊
1:05.520–1:07.460
zh专门就是用来干这个事情的
1:07.460–1:09.620
zh那这个里面的话啊
1:09.620–1:11.400
zh很好理解就是什么呢
1:11.400–1:12.640
zh那在这个里面
1:12.640–1:15.180
zh你可以建一些这个Rules啊
1:15.180–1:18.380
zh比如说我们就直接在这个
1:18.380–1:19.840
zh这个里面啊
1:19.840–1:21.720
zh我们就找个项目吧
1:21.720–1:23.060
zh嗯
1:23.060–1:29.300
zh看一下啊
1:29.300–1:32.760
zh这个里面的话
1:32.760–1:34.900
zh相当于
1:34.900–1:37.040
zh我们要可以加一个规则
1:37.040–1:38.200
zh做一个什么呢
1:38.200–1:39.900
zh就是沙箱外运行的话
1:39.900–1:41.460
zh需要先提示用户确认
1:41.460–1:44.940
zh也就是说我们可能要执行一个
1:44.940–1:47.980
zhGHPR的一个命令
1:47.980–1:49.160
zh然后这个命令的话
1:49.160–1:50.540
zh可能要去干嘛呢
1:50.540–1:53.520
zh要去分析一些仓库是吧
1:53.520–1:55.180
zh获取一些这个信息
1:55.180–1:56.920
zh所以这个里面的话
1:56.920–1:59.720
zh当他执行这种命令的时候
1:59.720–2:03.100
zh我们需要有用户去做一个确认
2:03.100–2:05.020
zh所以这个里面
2:05.020–2:06.100
zh事实上
2:06.100–2:08.380
zh他就是要做一个什么呢
2:08.380–2:09.540
zh授权的一个管理
2:09.540–2:12.660
zh那比如说我们现在就是在这个里面去建一下
2:12.660–2:16.800
zh然后我们在这个里面
2:16.800–2:18.000
zh比如说这个项目下面
2:18.000–2:20.740
zh先建文件啊
2:20.740–2:22.160
zh比如说我就建一个.lulus
2:22.160–2:25.240
zh然后把下面这一堆翻过来啊
2:25.240–2:26.800
zh翻过来啊
2:26.800–2:28.300
zh然后在这个里面的话
2:28.300–2:31.840
zh我们可以看一下
2:31.840–2:35.440
zh首先我们进入到root的这个目录里去
2:35.440–2:48.000
zh进入到root
2:48.000–2:50.900
zh好到这个里面然后进入到codex
2:50.900–2:52.300
zh然后你就直接问他
2:52.300–2:56.100
zh当前项目有哪些
2:56.100–3:01.100
enlulus
3:01.100–3:06.600
zh你就直接问他有哪些具体的这个规则是吧
3:06.600–3:19.460
zh然后他会自动的去分析啊
3:19.460–3:22.760
zh他会去找
3:22.760–3:26.020
zh所以他优先级的话
3:26.020–3:29.480
zh他会去扫.lulus的这个目录吧
3:29.480–3:30.780
zh这里还不行
3:30.780–3:34.520
zh我们建了这个.lulus的这个目录文件以外
3:34.520–3:35.020
zh我看一下
3:35.020–3:38.860
zh还要建一个.lulus的目录
3:38.860–3:41.540
zh不然的话加载是有问题的
3:41.540–3:44.980
zh所以这个里面我们得加一个
3:44.980–3:48.520
zh还得建个目录
3:48.520–3:51.100
zh建个文件夹
3:51.100–3:54.900
zh然后把这个.rules给它拖进去
3:54.900–4:03.280
zh然后再重启一下
4:03.280–4:04.340
zh然后再去问它
4:04.340–4:25.040
zh然后这个里面
4:25.040–4:27.180
zh他会去加载这个Rules
4:27.180–4:34.000
zh你看他把agency.md的内容
4:34.000–4:34.840
zh也输出出来了
4:34.840–4:37.240
zh看一下rules
4:37.240–4:39.680
zh嗯
4:39.680–4:43.360
zh哎他这个这里个规范没有输出来
4:43.360–4:46.040
zh项目生效的rules
4:46.040–4:47.480
zhdd驱动
4:47.480–4:52.560
zh他他把这个rules理解成
4:52.560–4:53.920
zhagents.md了
4:53.920–4:57.080
zh看一下有没有办法给他调整一下
4:57.080–4:59.140
zh嗯
4:59.140–5:04.000
zh这里要去激活一下啊
5:04.000–5:10.100
enrules
5:10.100–5:15.700
zh看一下这个目录
5:15.700–5:17.840
zhrules 下面有一个点
5:17.840–5:18.360
enrules
5:18.360–5:27.440
zh然后我们
5:27.440–5:34.000
zh执行一下这个命令看一下
5:34.000–5:41.800
enghprvu
5:41.800–5:54.700
zh原因是当前仓库的git remote没有指向github主机
5:54.700–5:58.200
zh那其实我们可以换一个项目
5:58.200–6:04.000
enprodx
6:04.000–6:10.840
zh我们找到那个项目
6:10.840–6:19.000
zh用这个开源项目来测试一下
6:19.000–6:21.000
zh把这个项目导下来啊
6:21.000–6:34.120
engit clone
6:34.120–6:40.940
zh首先我把这个项目拉下来
6:40.940–6:48.100
zh因为这个里面要用github的项目
6:48.100–6:51.000
zh我上面那个是gitee的一个项目
6:51.000–6:53.400
zh所以我首先要把它给它导进来
6:53.400–6:58.680
zh看这个项目有点大啊
6:58.680–7:01.740
zh反正这个规则的意思就是
7:01.740–7:04.640
zh大家在执行一些命令的时候
7:04.640–7:08.740
zh就是你可以去指定哪一些各个命令
7:08.740–7:10.720
zh是需要用户授权的
7:10.720–7:13.620
zh因为我们默认的话
7:13.620–7:15.820
zh其实有一些命令啊
7:15.820–7:17.120
zh它需要授权
7:17.120–7:18.660
zh有些是不需要授权的
7:18.660–7:20.360
zh那么大家可以去配一下
7:20.360–7:21.740
zh就是在某些命令下
7:21.740–7:23.400
zh需要去触发授权
7:23.400–7:25.280
zh也就是大家可以针对
7:25.280–7:27.280
zh我们当前执行的一个命令的话
7:27.280–7:29.860
zh做一些细粒度的权限管控
7:29.860–7:31.120
zh就加一个规则
7:31.120–7:33.880
zh因为涉及到一些危险动作的时候
7:33.880–7:36.640
zh就需要用户来确认
7:36.640–7:38.580
zh确认完之后再去做处理
7:38.580–7:41.020
zh所以我们在这个点
7:41.020–7:43.680
zhCodex里面去加这个规则的话
7:43.680–7:45.460
zh就意味着什么呢
7:45.460–7:48.400
zh我们可以去做一些权限的一些细节管控
7:48.400–7:50.320
zh就是做一个这种审批
7:50.320–7:53.120
zh就相当于大家在这做这个
7:53.120–7:54.840
zh整个的一个
7:54.840–7:57.540
zh各种各样的命令管理的时候
7:57.540–7:59.780
zh你可以下一些细粒度的一些管控
7:59.780–8:01.000
zh有一些
8:01.000–8:18.690
zh这个命令的话
8:18.690–8:20.090
zh给他加一下
8:20.090–8:20.610
zh是吧
8:20.610–8:22.530
zh加一些权限控制
8:22.530–8:24.430
zh然后这个里面啊
8:24.430–8:25.850
zh我们可以配置哪些东西呢
8:25.850–8:27.490
zh比如说啊
8:27.490–8:29.390
zh它是有一套规范
8:29.390–8:30.870
zh比如说这个 pattern
8:30.870–8:31.790
zh匹配规则
8:31.790–8:32.530
zh比如说pr
8:32.530–8:34.690
zh就是你有pr的一些命令
8:34.690–8:36.430
zh然后这个decision
8:36.430–8:38.230
zh这个是做一些具体的命
8:38.230–8:39.310
zh动作的一个执行
8:39.310–8:40.650
zh比如说允许
8:40.650–8:41.650
zh或者拒绝
8:41.650–8:42.390
zh或者怎么样
8:42.390–8:44.230
zh一个是不提示
8:44.230–8:46.610
zh直接在沙箱环境下面去执行
8:46.610–8:47.930
zh然后是提示
8:47.930–8:50.090
zh就每次命中都要确认请求
8:50.090–8:53.870
zh然后这个forbidden是直接拒绝了
8:53.870–8:56.130
zh就这种命令就不允许执行了
8:56.130–8:59.630
zh比如说RM跟RF这种删除文件的
8:59.630–9:01.490
zh我们就不管它了
9:01.490–9:02.430
zh这个完了
9:02.430–9:05.530
zh然后我们现在去切换到这个
9:05.530–9:07.530
zh看一下
9:07.530–9:10.870
zh切换到codex
9:10.870–9:12.470
zh这个项目里面去
9:12.470–9:15.170
zh然后在这个项目下面的话
9:15.170–9:16.210
zh我们建一个
9:16.210–9:17.870
zh把那个移动过去
9:17.870–9:23.270
zh刚刚有一个rules
9:23.270–9:34.370
zh把这个移到这个下面去
9:34.370–9:35.510
zh好现在已经移过来
9:35.510–9:36.130
zh移过来之后
9:36.130–9:39.070
zh我们再切进去看一下
9:39.070–9:43.210
encodex
9:43.210–9:43.870
zh好这里面
9:43.870–9:47.870
zh然后我们再去执行刚刚的一个指令
9:47.870–9:54.070
zh比如说我们来分析一下
9:54.070–9:59.770
zh当前项目的
9:59.770–10:17.870
zhRules有哪些
10:17.870–10:27.910
zh他默认读的也是这个agents.md
10:27.910–10:35.470
zh他不能加载内容
10:35.470–10:39.570
zh这就这么来就问他
10:39.570–10:42.650
zh当前项目的
10:42.650–10:46.530
zh有哪些内容
10:46.530–10:53.810
zh我看这样来问行不行啊
10:53.810–10:57.530
zh他会去找这个文件啊
10:57.530–11:04.610
zh他是有一个匹配规则的
11:04.610–11:08.590
zh就比如说Codex想在沙箱里面去运行
11:08.590–11:10.250
zhGHVU开头的命令
11:10.250–11:11.950
zh但是需要后续的批准
11:11.950–11:14.250
zh精准匹配啊才可以
11:14.250–11:17.790
zh所以说不匹配
11:17.790–11:22.490
zh比如说我们现在来整这个看一下
11:22.490–11:37.710
zh你看现在是不是需要用户来确认是吧
11:37.710–11:40.950
zh这个是不是我们那个规则生效了
11:40.950–11:44.010
zh这里面是不是就需要用户来确认
11:44.010–11:44.910
zh是吧
11:44.910–11:46.810
zh来确认一下
11:46.810–12:02.290
zh你看这个是以执行
12:02.290–12:14.010
zh然后我们再来执行这个看一下
12:14.010–12:15.690
zh你看用这种命令
12:15.690–12:16.950
zh一旦匹配上了
12:16.950–12:17.670
zh他就要确认
12:17.670–12:19.550
zh然后不匹配的
12:19.550–12:20.890
zh我们来也来确认一下
12:20.890–12:24.010
zh看一下这个是不是就不会授权了
12:24.010–12:31.370
zh这个还是要确认
12:31.370–12:33.250
zh这个也是要确认
12:33.250–12:35.090
zh只是说这里面
12:35.090–12:38.690
zh就是相当于一些一个逻辑
12:38.690–12:41.430
zh要做一些处理
12:41.430–12:46.070
zh但是我们看一下这个上面那个规则
12:46.070–12:55.650
zh因为他网络访问
12:55.650–12:56.990
zh所以还是需要授权
12:56.990–12:59.110
zh其实这个不匹配的话
12:59.110–13:02.030
zh不匹配的话就必须
13:02.030–13:03.410
zh然后再分析一下
13:03.410–13:11.430
zh看一下刚刚那个规则是什么
13:11.430–13:17.930
zh呃
13:17.930–13:21.370
zhGHPRVU会匹配
13:21.370–13:22.730
zhGitRepo不会匹配
13:22.730–13:27.130
zh因为他不是以精准的GHPRVU
13:27.130–13:41.430
zh不匹配会怎么样
13:41.430–13:46.310
zh怎么样
13:46.310–13:48.770
zh我们就看一下
13:48.770–13:50.570
zh他这个规则到底是怎么样的
13:50.570–13:52.990
zh他说是不会命中
13:52.990–13:54.550
zh点Rules这个规则
13:54.550–13:58.770
zh但是我们实际还是看到那个是吧
13:58.770–14:00.490
zh看一下他这个细节
14:00.490–14:07.750
zh他说的是不会命中
14:07.750–14:10.590
zh但是因为还是会涉及到一些网络权限
14:10.590–14:12.550
zh还是会有一些提示的
14:12.550–14:15.390
zh你看啊
14:15.390–14:17.590
zh因为这个命令需要访问GitHub网络
14:17.590–14:19.190
zh所以在当前环境下
14:19.190–14:21.350
zh还是会要求额外授权执行
14:21.350–14:22.430
zh所以正常来说
14:22.430–14:25.310
zh按理说他没有匹配就不需要做授权
14:25.310–14:27.370
zh因为你要访问网络啊
14:27.370–14:31.730
zh所以这个就还是要做授权的
14:31.730–14:40.590
zh那我们这次这个依旧需要授权
14:40.590–14:42.450
zh你看这里面需要确认一下
14:42.450–14:45.510
zh还是需要授权
14:45.510–14:49.410
zh也要涉及到访问网络啊
14:49.410–14:53.070
zh所以这个规则这个里面的逻辑就是
14:53.070–14:55.190
zh啊我们整个
14:55.190–14:58.570
zh他不一定就说严格按照这个来啊
14:58.570–15:00.470
zh他还要根据当前的环境来决定
15:00.470–15:06.090
zh这个里面到底有没有其他的一些权限需要去申请啊
15:06.090–15:08.870
zh所以说你写在这里的话
15:08.870–15:11.090
zh如果说这个里面啊
15:11.090–15:13.770
zh并不需要额外再去申请其他权限的话
15:13.770–15:15.670
zh这个命令执行就执行成功了
15:15.670–15:18.430
zh他不会弹出那个还需要你确认的那个过程
15:18.430–15:21.590
zh所以具体得看一些场景啊
15:21.590–15:24.250
zh这个大家回头也可以去试一下
15:24.250–15:27.170
zh如果他但凡没有涉及到网络访问的话
15:27.170–15:29.870
zh这个我们其实是OK的啊
15:29.870–15:33.130
zh所以整个Codex
15:33.130–15:35.170
zh他的一个处理逻辑的话就是
15:35.170–15:39.770
zh他会先去加载我们整个 Rules 的一个目录
15:39.770–15:40.130
zh是吧
15:40.130–15:42.230
zh那加载完之后的话
15:42.230–15:46.770
zh他会读取到里面的这个 .rules 的一些文件内容
15:46.770–15:47.790
zh然后的话
15:47.790–15:50.270
zh这个里面他也分全局的
15:50.270–15:51.630
zh还有这个项目的
15:51.630–15:53.690
zh就有用户级别的
15:53.690–15:54.910
zh整个全局的
15:54.910–15:56.890
zh也有按照项目来分的
15:56.890–15:58.670
zh在某个项目下面去点Rules
15:58.670–16:01.730
zh这个都是OK的
16:01.730–16:03.890
zh跟我们前面讲的那个
16:03.890–16:19.484
zh嗯
16:19.484–16:20.884
zh就是一个匹配
16:20.884–16:22.884
zh在这个里面
16:22.884–16:25.184
zh比如说我们可以匹配pr命令是吧
16:25.184–16:26.684
zh然后decision
16:26.684–16:28.484
zh就我们前面讲的不提示
16:28.484–16:30.184
zh然后提示
16:30.184–16:33.884
zh然后或者是直接阻止了
16:33.884–16:34.784
zh那比如说大家
16:34.784–16:36.684
zh其实你可以在这个里面去改
16:36.684–16:38.184
zh比如说现在是提示吗
16:38.184–16:40.684
zh你直接改成forbidden
16:40.684–16:42.984
zh然后你再去执行看一下
16:42.984–16:43.784
zh比如说在这个里面
16:43.784–16:45.384
zh我们先退出去
16:45.384–16:46.884
zh再执行codex
16:46.884–16:49.484
zh然后再直接执行这个
16:49.484–16:50.204
zh命令
16:50.204–16:51.344
zh看一下他会怎么样
16:51.344–16:56.824
zh你看
16:56.824–16:58.344
zh当前
16:58.344–17:01.484
zh看一下会不会被拒绝啊
17:01.484–17:03.084
zh啊
17:03.084–17:05.384
zh因为这个是网络访问啊
17:05.384–17:06.944
zh这个是另外一个权限申请啊
17:06.944–17:08.124
zh跟刚刚那个还不一样
17:08.124–17:17.144
zh看一下他最终会不会被拒绝啊
17:17.144–17:19.044
zh你看现在已经在加载那个
17:19.044–17:19.964
zh点Rules了
17:19.964–17:23.264
zh看一下他最终会不会被拒绝掉
17:23.264–17:37.984
zh还是有这个结果
17:37.984–17:41.444
zh这个是前面咱们做了授权
17:41.444–17:43.304
zh一次性给他加进去了吗
17:43.304–17:46.704
zh正常来说应该是给他拒绝了
17:46.704–17:49.704
zh我现在已经有一个forbidden了
17:49.704–17:51.104
zh我再退出去啊
17:51.104–17:51.704
zh再看一下
17:51.704–18:02.704
zh看我切换这个permission看一下
18:02.704–18:05.704
zh然后测试review
18:05.704–18:07.704
zh我切换这种模式看一下
18:07.704–18:10.704
zh然后再执行
18:10.704–18:16.704
zh看一下他需不需要确认
18:16.704–18:24.764
zh他说GH因为网络沙箱受限
18:24.764–18:27.324
zh他会按照他这里提示的权限
18:27.324–18:29.724
zh他那个沙箱是没权限的
18:29.724–18:31.624
zh是直接给他锯掉的
18:31.624–18:34.864
zh但是的话他要重新做一个提权
18:34.864–18:37.704
zh所以这里面他最终还是可以的
18:37.704–18:40.424
zh你看他这个只是查询
18:40.424–18:42.364
zh他没有涉及到修改的风险
18:42.364–18:44.824
zh所以这里面默认给他放行的
18:44.824–18:46.984
zh看一下
18:46.984–18:53.684
zh在这里大家去改的话
18:53.684–18:55.464
zh你其实看不到什么效果
18:55.464–18:58.524
zh他其实沙箱给他阻止了
18:58.524–18:59.984
zh但是的话就是
18:59.984–19:03.344
zh我们还是可以有一个提权的过程
19:03.344–19:05.564
zh这个是他设计的
19:05.564–19:14.824
zh就是这个样子
19:14.824–19:25.024
zh你看他这个是网络网络权限啊
19:25.024–19:27.184
zh然后不要告诉我之前
19:27.184–19:29.664
zh告诉Codex
19:29.664–19:35.004
zh他其实内部是已经拒绝
19:35.004–19:36.784
zh但是这里会有个提权的操作
19:36.784–19:39.844
zh所以大家得看具体的一个情况
19:39.844–19:43.904
zh然后我们还可以加一些不同的一些参数是吧
19:43.904–19:45.444
zh然后去做一些匹配啊等等
19:45.444–19:48.504
zh那这个里面的话就是
19:48.504–19:51.364
zh我们基于这个Codex
19:51.364–19:53.204
zh可以去做一些这个
19:53.204–19:55.784
zh评估一条代运行的命令的时候
19:55.784–19:57.284
zh他会把命令
19:57.284–19:58.384
zh他的一个参数
19:58.384–20:00.784
zh做一个比较啊
20:00.784–20:01.624
zh那在内部的话
20:01.624–20:02.884
zhCodex会把命令
20:02.884–20:04.724
zh看作一个参数列表
20:04.724–20:06.304
zh比如说一些这个
20:06.304–20:09.424
zh不同的这个参数是吧
20:09.424–20:10.064
zh比如说这个
20:10.064–20:13.484
zhEKCVP这种参数的方式
20:13.484–20:15.684
zh然后去做一个这个接收
20:15.684–20:19.144
zh就是他会有这么一个机制
20:19.144–20:20.584
zh好
20:20.584–20:22.224
zh然后是 shell wrapper
20:22.224–20:23.544
zh与复合的一些命令
20:23.544–20:25.524
zh这个是用来干嘛的呢
20:25.524–20:27.464
zh这个就是我们还可以包装一下
20:27.464–20:29.524
zh就是我们在 rules 里面
20:29.524–20:32.704
zh我们可以把整个命令做一个包装
20:32.704–20:34.524
zh什么意思呢
20:34.524–20:36.584
zh就是你现在要执行多个命令是吧
20:36.584–20:39.544
zh那我现在想把这个做个打包
20:39.544–20:41.864
zh比如说提交文件删除
20:41.864–20:43.344
zh整个做一个打包
20:43.344–20:46.044
zh那么在这里面的话
20:46.044–20:46.804
zh就相当于
20:46.804–20:49.444
zh它单次操作的话
20:49.444–20:51.424
zh相当于把整个 mini 做一个执行
20:51.424–20:53.144
zh就这里面我们可以做一个封装
20:53.144–20:55.664
zh然后Codex的话
20:55.664–20:59.644
zh它什么时候可以去拆分一些脚本
20:59.644–21:01.004
zh比如说
21:01.004–21:02.584
zh这个里面
21:02.584–21:05.904
zh一些纯字面量的一些单词
21:05.904–21:08.204
zh不包含变量展开的这种情况
21:08.204–21:10.244
zh或者是一些
21:10.244–21:13.124
zh只通过安全运算服务的一些
21:13.124–21:13.784
zh这个场景
21:13.784–21:15.544
zh或者是一些
21:15.544–21:16.464
zh这个
21:16.464–21:19.524
zh不同情况的
21:19.524–21:20.644
zh比如说下面这个
21:20.644–21:23.304
zh一些有规则的
21:23.304–21:23.604
zh是吧
21:23.604–21:25.544
zh就都是安全的这种场景
21:25.544–21:27.064
zh这个时候的话
21:27.064–21:28.164
zh他就可以去
21:28.164–21:29.644
zh加一些这个
21:29.644–21:30.904
zh一些
21:30.904–21:33.244
zh做一些安全的一些拆分
21:33.244–21:34.804
zh比如说把这些命令
21:34.804–21:35.404
zh做一个拆分
21:35.404–21:38.184
zh所以他会分别用你的 Rules
21:38.184–21:39.524
zh去评估每一条命令
21:39.524–21:41.424
zh并且以最严格的
21:41.424–21:42.624
zh这个结果为准
21:42.624–21:44.944
zh然后这里面的话
21:44.944–21:47.744
zh即使你允许这个partner
21:47.744–21:49.844
zh然后执行这个
21:49.844–21:51.904
zh你写了这个东西的话
21:51.904–21:53.544
zh那他也不会自动放弃
21:53.544–21:56.244
zh因为这个RM和RF
21:56.244–21:57.964
zh是一个非常危险的一个操作
21:57.964–22:01.264
zh因为这个命令比较危险
22:01.264–22:02.484
zh所以他会单独评估
22:02.484–22:05.204
zh所以你写归你写
22:05.204–22:07.484
zh但是Codex他自己也有一套
22:07.484–22:08.764
zh内置的一套规范
22:08.764–22:12.244
zh所以这种危险命令的话
22:12.244–22:13.364
zh你混在一起的话
22:13.364–22:16.544
zh就违背了他的一个安全指令的一个要求
22:16.544–22:18.304
zh所以大家会发现
22:18.304–22:19.824
zh你不是你写所有命令
22:19.824–22:21.564
zh他都会给你放行的
22:21.564–22:22.764
zh他也要去看情况
22:22.764–22:25.304
zh这个是Codex
22:25.304–22:27.744
zh他可以做一些安全脚本的一个拆分
22:27.744–22:29.024
zh然后的话Codex
22:29.024–22:31.284
zh他什么情况下不会去拆分脚本呢
22:31.284–22:34.024
zh比如说我们已经加了一些重定向像的一些东西了
22:34.024–22:35.964
zh加了一些替换的表达式了
22:35.964–22:37.904
zh或者做了一些环境变量的一些复制了
22:37.904–22:39.844
zh或者加了一些通配符了
22:39.844–22:41.964
zh那这个就不会尝试去解析他
22:41.964–22:43.924
zh因为它本身就代表
22:43.924–22:45.684
zh它的执行的一些关键点
22:45.684–22:47.384
zh是一些规范
22:47.384–22:50.264
zh所以它就不会去拆分
22:50.264–22:51.784
zh然后同时的话
22:51.784–22:52.984
zh它就直接把它用过来
22:52.984–22:54.384
zh直接去运行的啊
22:54.384–22:57.484
zh所以它也不是说你写了
22:57.484–22:58.784
zh它就会帮你去拆分
22:58.784–23:00.564
zh那它也要去看情况
23:00.564–23:04.324
zh所以这种处理方式意味着
23:04.324–23:07.184
zh你就是在可以安全拆分的时候
23:07.184–23:08.924
zhCodex会按照单条命令
23:08.924–23:10.144
zh逐项的去评估
23:10.144–23:12.064
zh在不能安全拆分的时候
23:12.064–23:12.844
zh就是按照
23:12.844–23:14.884
zh更加保守的一个方案
23:14.884–23:15.644
zh去做一个评估
23:15.644–23:18.684
zh然后弄完之后的话
23:18.684–23:20.744
zh我们也可以去做一些测试
23:20.744–23:23.304
zh比如说我们把这个命令
23:23.304–23:27.330
zh加到这里来可以看一下
23:27.330–23:33.890
zh就是你可以去看一下这个规则到底有没有生效。
23:33.890–23:38.690
zh比如说我们这个规则,我们可以把它加进去。
23:38.690–23:40.750
zh你看这个里面就找到了啊
23:40.750–23:42.590
zh什么
23:42.590–23:44.450
enCodex
23:44.450–23:45.330
enDefault
23:45.330–23:47.150
enCheck
23:47.150–23:49.890
zh当前的这个用户目标
23:49.890–23:52.690
zh但是我们没有这个规则是吧
23:52.690–23:55.830
zh这个当前用户目标没有建那个规则
23:55.830–23:59.350
zh所以这个里面我们得改一下啊
23:59.350–24:02.250
zh这个就是当前目录的
24:02.250–24:03.330
enRules
24:03.330–24:05.330
zh点Rules
24:05.330–24:08.690
zh这里我们就指定当前步
24:08.690–24:11.650
zh然后来评估一下它的一些变化
24:11.650–24:29.910
zh来看一下
24:29.910–24:32.410
zhPowerShell可以复制执行的一个命令
24:32.410–24:35.670
zh你看他帮我们把命令做了一个优化
24:35.670–24:39.010
zh来我们退出去执行一下
24:39.010–24:45.790
zh这个里面有一个问题
24:45.790–25:02.410
enCodex
25:02.410–25:05.910
zh你看这个是他匹配的一个规则是吧
25:05.910–25:08.250
zh匹配的规则就是我们可以看得出来
25:08.250–25:10.810
zh这个里面的话就相当于不被允许啊
25:10.810–25:13.070
zh这就是他要有这个结论
25:13.070–25:14.670
zh他可以分析出来
25:14.670–25:16.750
zh我们去执行这个命令的时候
25:16.750–25:19.090
zh他给的这个决定就是拒绝了啊
25:19.090–25:20.970
zh这就是测试规则文件
25:20.970–25:22.450
zh到底有没有写的有没有问题
25:22.450–25:25.070
zh他默认的话会帮你输出一个
25:25.070–25:27.610
zhJSON格式的这么一个规则出来啊
25:27.610–25:31.230
zh所以这个是我们做测试用的
25:31.230–25:36.350
zh然后包括一些这些规则的一些语言啊
25:36.350–25:36.690
zh是吧
25:36.690–25:37.610
zh比如说
25:37.610–25:39.590
zh大家可以去看一下
25:39.590–25:42.110
zh专门有一套语法啊
25:42.110–25:45.270
zh叫这个Specific的这么一个语法
25:45.270–25:49.790
zh你看这个是专门的有一套规范啊
25:49.790–25:50.870
zh大家可以去看一下
25:50.870–25:54.070
zh怎么来写这个东西
25:54.070–25:54.770
zh是吧
25:54.770–25:56.830
zh大家可以去看一下
25:56.830–25:58.990
zh他是专门有一套规则语法的
25:58.990–26:00.610
zh他是采用了这种方式
26:00.610–26:02.210
zh去写规则的
26:02.210–26:04.490
zh大家可以去参考一下
26:04.490–26:05.890
zh这是它的一个使用说明
26:05.890–26:08.890
zh它的语法看起来有点像Python
26:08.890–26:10.890
zh但是设计目标的话是安全执行
26:10.890–26:12.650
zh所以 Rules 的一个引擎
26:12.650–26:14.830
zh可以在不产生副作用的前例下
26:14.830–26:16.170
zh去运行它
26:16.170–26:19.110
zh比如说它不会去触碰文件系统的一些逻辑
26:19.110–26:20.630
zh所以这个里面
26:20.630–26:23.830
zh大家可以去看一下它的一个细节点
26:23.830–26:25.690
zh这个我们可以去
0:00.000–0:07.651
好,然后我们来讲一下这个Codex Rules体系构建与代码可控性治理。
0:07.651–0:12.327
那这个的话其实也是一套这个细节的一个规范啊。
0:12.327–0:15.090
这个就更加的这个细粒度了。
0:15.090–0:22.954
前面那个我们说的这个规范的话,主要还是指的是整个项目的一些大的一些规范啊。
0:22.954–0:25.930
比如说目录啊,结构啊,是吧。
0:25.930–0:28.480
它就相当于一个代码地图。
0:28.480–0:32.000
那这个Rules的这个规范的话
0:32.000–0:33.880
它就更加的细了
0:33.880–0:36.300
这个是用来去控制
0:36.300–0:39.820
哪些命令可以在沙箱外去做一个执行
0:39.820–0:41.900
这个就偏执行类的
0:41.900–0:44.940
也就是说比如说我们在这个
0:44.940–0:47.180
跑一些代码的时候
0:47.180–0:48.180
跑一些case的时候
0:48.180–0:49.860
做一些自动化测试的时候
0:49.860–0:52.320
那自动化测试的话
0:52.320–0:54.220
可能涉及到命令就比较多了
0:54.220–0:55.960
有可能会删除文件
0:55.960–0:57.760
有可能需要调用工具
0:57.760–0:59.000
等等的啊
0:59.000–1:00.400
就个人相关的权限都会有
1:00.400–1:03.380
所以Codex专门设计了一套
1:03.380–1:05.520
叫Rules的一套组件啊
1:05.520–1:07.460
专门就是用来干这个事情的
1:07.460–1:09.620
那这个里面的话啊
1:09.620–1:11.400
很好理解就是什么呢
1:11.400–1:12.640
那在这个里面
1:12.640–1:15.180
你可以建一些这个Rules啊
1:15.180–1:18.380
比如说我们就直接在这个
1:18.380–1:19.840
这个里面啊
1:19.840–1:21.720
我们就找个项目吧
1:21.720–1:23.060
嗯
1:23.060–1:29.300
看一下啊
1:29.300–1:32.760
这个里面的话
1:32.760–1:34.900
相当于
1:34.900–1:37.040
我们要可以加一个规则
1:37.040–1:38.200
做一个什么呢
1:38.200–1:39.900
就是沙箱外运行的话
1:39.900–1:41.460
需要先提示用户确认
1:41.460–1:44.940
也就是说我们可能要执行一个
1:44.940–1:47.980
GHPR的一个命令
1:47.980–1:49.160
然后这个命令的话
1:49.160–1:50.540
可能要去干嘛呢
1:50.540–1:53.520
要去分析一些仓库是吧
1:53.520–1:55.180
获取一些这个信息
1:55.180–1:56.920
所以这个里面的话
1:56.920–1:59.720
当他执行这种命令的时候
1:59.720–2:03.100
我们需要有用户去做一个确认
2:03.100–2:05.020
所以这个里面
2:05.020–2:06.100
事实上
2:06.100–2:08.380
他就是要做一个什么呢
2:08.380–2:09.540
授权的一个管理
2:09.540–2:12.660
那比如说我们现在就是在这个里面去建一下
2:12.660–2:16.800
然后我们在这个里面
2:16.800–2:18.000
比如说这个项目下面
2:18.000–2:20.740
先建文件啊
2:20.740–2:22.160
比如说我就建一个.lulus
2:22.160–2:25.240
然后把下面这一堆翻过来啊
2:25.240–2:26.800
翻过来啊
2:26.800–2:28.300
然后在这个里面的话
2:28.300–2:31.840
我们可以看一下
2:31.840–2:35.440
首先我们进入到root的这个目录里去
2:35.440–2:48.000
进入到root
2:48.000–2:50.900
好到这个里面然后进入到codex
2:50.900–2:52.300
然后你就直接问他
2:52.300–2:56.100
当前项目有哪些
2:56.100–3:01.100
lulus
3:01.100–3:06.600
你就直接问他有哪些具体的这个规则是吧
3:06.600–3:19.460
然后他会自动的去分析啊
3:19.460–3:22.760
他会去找
3:22.760–3:26.020
所以他优先级的话
3:26.020–3:29.480
他会去扫.lulus的这个目录吧
3:29.480–3:30.780
这里还不行
3:30.780–3:34.520
我们建了这个.lulus的这个目录文件以外
3:34.520–3:35.020
我看一下
3:35.020–3:38.860
还要建一个.lulus的目录
3:38.860–3:41.540
不然的话加载是有问题的
3:41.540–3:44.980
所以这个里面我们得加一个
3:44.980–3:48.520
还得建个目录
3:48.520–3:51.100
建个文件夹
3:51.100–3:54.900
然后把这个.rules给它拖进去
3:54.900–4:03.280
然后再重启一下
4:03.280–4:04.340
然后再去问它
4:04.340–4:25.040
然后这个里面
4:25.040–4:27.180
他会去加载这个Rules
4:27.180–4:34.000
你看他把agency.md的内容
4:34.000–4:34.840
也输出出来了
4:34.840–4:37.240
看一下rules
4:37.240–4:39.680
嗯
4:39.680–4:43.360
哎他这个这里个规范没有输出来
4:43.360–4:46.040
项目生效的rules
4:46.040–4:47.480
dd驱动
4:47.480–4:52.560
他他把这个rules理解成
4:52.560–4:53.920
agents.md了
4:53.920–4:57.080
看一下有没有办法给他调整一下
4:57.080–4:59.140
嗯
4:59.140–5:04.000
这里要去激活一下啊
5:04.000–5:10.100
rules
5:10.100–5:15.700
看一下这个目录
5:15.700–5:17.840
rules 下面有一个点
5:17.840–5:18.360
rules
5:18.360–5:27.440
然后我们
5:27.440–5:34.000
执行一下这个命令看一下
5:34.000–5:41.800
ghprvu
5:41.800–5:54.700
原因是当前仓库的git remote没有指向github主机
5:54.700–5:58.200
那其实我们可以换一个项目
5:58.200–6:04.000
prodx
6:04.000–6:10.840
我们找到那个项目
6:10.840–6:19.000
用这个开源项目来测试一下
6:19.000–6:21.000
把这个项目导下来啊
6:21.000–6:34.120
git clone
6:34.120–6:40.940
首先我把这个项目拉下来
6:40.940–6:48.100
因为这个里面要用github的项目
6:48.100–6:51.000
我上面那个是gitee的一个项目
6:51.000–6:53.400
所以我首先要把它给它导进来
6:53.400–6:58.680
看这个项目有点大啊
6:58.680–7:01.740
反正这个规则的意思就是
7:01.740–7:04.640
大家在执行一些命令的时候
7:04.640–7:08.740
就是你可以去指定哪一些各个命令
7:08.740–7:10.720
是需要用户授权的
7:10.720–7:13.620
因为我们默认的话
7:13.620–7:15.820
其实有一些命令啊
7:15.820–7:17.120
它需要授权
7:17.120–7:18.660
有些是不需要授权的
7:18.660–7:20.360
那么大家可以去配一下
7:20.360–7:21.740
就是在某些命令下
7:21.740–7:23.400
需要去触发授权
7:23.400–7:25.280
也就是大家可以针对
7:25.280–7:27.280
我们当前执行的一个命令的话
7:27.280–7:29.860
做一些细粒度的权限管控
7:29.860–7:31.120
就加一个规则
7:31.120–7:33.880
因为涉及到一些危险动作的时候
7:33.880–7:36.640
就需要用户来确认
7:36.640–7:38.580
确认完之后再去做处理
7:38.580–7:41.020
所以我们在这个点
7:41.020–7:43.680
Codex里面去加这个规则的话
7:43.680–7:45.460
就意味着什么呢
7:45.460–7:48.400
我们可以去做一些权限的一些细节管控
7:48.400–7:50.320
就是做一个这种审批
7:50.320–7:53.120
就相当于大家在这做这个
7:53.120–7:54.840
整个的一个
7:54.840–7:57.540
各种各样的命令管理的时候
7:57.540–7:59.780
你可以下一些细粒度的一些管控
7:59.780–8:01.000
有一些
8:01.000–8:18.690
这个命令的话
8:18.690–8:20.090
给他加一下
8:20.090–8:20.610
是吧
8:20.610–8:22.530
加一些权限控制
8:22.530–8:24.430
然后这个里面啊
8:24.430–8:25.850
我们可以配置哪些东西呢
8:25.850–8:27.490
比如说啊
8:27.490–8:29.390
它是有一套规范
8:29.390–8:30.870
比如说这个 pattern
8:30.870–8:31.790
匹配规则
8:31.790–8:32.530
比如说pr
8:32.530–8:34.690
就是你有pr的一些命令
8:34.690–8:36.430
然后这个decision
8:36.430–8:38.230
这个是做一些具体的命
8:38.230–8:39.310
动作的一个执行
8:39.310–8:40.650
比如说允许
8:40.650–8:41.650
或者拒绝
8:41.650–8:42.390
或者怎么样
8:42.390–8:44.230
一个是不提示
8:44.230–8:46.610
直接在沙箱环境下面去执行
8:46.610–8:47.930
然后是提示
8:47.930–8:50.090
就每次命中都要确认请求
8:50.090–8:53.870
然后这个forbidden是直接拒绝了
8:53.870–8:56.130
就这种命令就不允许执行了
8:56.130–8:59.630
比如说RM跟RF这种删除文件的
8:59.630–9:01.490
我们就不管它了
9:01.490–9:02.430
这个完了
9:02.430–9:05.530
然后我们现在去切换到这个
9:05.530–9:07.530
看一下
9:07.530–9:10.870
切换到codex
9:10.870–9:12.470
这个项目里面去
9:12.470–9:15.170
然后在这个项目下面的话
9:15.170–9:16.210
我们建一个
9:16.210–9:17.870
把那个移动过去
9:17.870–9:23.270
刚刚有一个rules
9:23.270–9:34.370
把这个移到这个下面去
9:34.370–9:35.510
好现在已经移过来
9:35.510–9:36.130
移过来之后
9:36.130–9:39.070
我们再切进去看一下
9:39.070–9:43.210
codex
9:43.210–9:43.870
好这里面
9:43.870–9:47.870
然后我们再去执行刚刚的一个指令
9:47.870–9:54.070
比如说我们来分析一下
9:54.070–9:59.770
当前项目的
9:59.770–10:17.870
Rules有哪些
10:17.870–10:27.910
他默认读的也是这个agents.md
10:27.910–10:35.470
他不能加载内容
10:35.470–10:39.570
这就这么来就问他
10:39.570–10:42.650
当前项目的
10:42.650–10:46.530
有哪些内容
10:46.530–10:53.810
我看这样来问行不行啊
10:53.810–10:57.530
他会去找这个文件啊
10:57.530–11:04.610
他是有一个匹配规则的
11:04.610–11:08.590
就比如说Codex想在沙箱里面去运行
11:08.590–11:10.250
GHVU开头的命令
11:10.250–11:11.950
但是需要后续的批准
11:11.950–11:14.250
精准匹配啊才可以
11:14.250–11:17.790
所以说不匹配
11:17.790–11:22.490
比如说我们现在来整这个看一下
11:22.490–11:37.710
你看现在是不是需要用户来确认是吧
11:37.710–11:40.950
这个是不是我们那个规则生效了
11:40.950–11:44.010
这里面是不是就需要用户来确认
11:44.010–11:44.910
是吧
11:44.910–11:46.810
来确认一下
11:46.810–12:02.290
你看这个是以执行
12:02.290–12:14.010
然后我们再来执行这个看一下
12:14.010–12:15.690
你看用这种命令
12:15.690–12:16.950
一旦匹配上了
12:16.950–12:17.670
他就要确认
12:17.670–12:19.550
然后不匹配的
12:19.550–12:20.890
我们来也来确认一下
12:20.890–12:24.010
看一下这个是不是就不会授权了
12:24.010–12:31.370
这个还是要确认
12:31.370–12:33.250
这个也是要确认
12:33.250–12:35.090
只是说这里面
12:35.090–12:38.690
就是相当于一些一个逻辑
12:38.690–12:41.430
要做一些处理
12:41.430–12:46.070
但是我们看一下这个上面那个规则
12:46.070–12:55.650
因为他网络访问
12:55.650–12:56.990
所以还是需要授权
12:56.990–12:59.110
其实这个不匹配的话
12:59.110–13:02.030
不匹配的话就必须
13:02.030–13:03.410
然后再分析一下
13:03.410–13:11.430
看一下刚刚那个规则是什么
13:11.430–13:17.930
呃
13:17.930–13:21.370
GHPRVU会匹配
13:21.370–13:22.730
GitRepo不会匹配
13:22.730–13:27.130
因为他不是以精准的GHPRVU
13:27.130–13:41.430
不匹配会怎么样
13:41.430–13:46.310
怎么样
13:46.310–13:48.770
我们就看一下
13:48.770–13:50.570
他这个规则到底是怎么样的
13:50.570–13:52.990
他说是不会命中
13:52.990–13:54.550
点Rules这个规则
13:54.550–13:58.770
但是我们实际还是看到那个是吧
13:58.770–14:00.490
看一下他这个细节
14:00.490–14:07.750
他说的是不会命中
14:07.750–14:10.590
但是因为还是会涉及到一些网络权限
14:10.590–14:12.550
还是会有一些提示的
14:12.550–14:15.390
你看啊
14:15.390–14:17.590
因为这个命令需要访问GitHub网络
14:17.590–14:19.190
所以在当前环境下
14:19.190–14:21.350
还是会要求额外授权执行
14:21.350–14:22.430
所以正常来说
14:22.430–14:25.310
按理说他没有匹配就不需要做授权
14:25.310–14:27.370
因为你要访问网络啊
14:27.370–14:31.730
所以这个就还是要做授权的
14:31.730–14:40.590
那我们这次这个依旧需要授权
14:40.590–14:42.450
你看这里面需要确认一下
14:42.450–14:45.510
还是需要授权
14:45.510–14:49.410
也要涉及到访问网络啊
14:49.410–14:53.070
所以这个规则这个里面的逻辑就是
14:53.070–14:55.190
啊我们整个
14:55.190–14:58.570
他不一定就说严格按照这个来啊
14:58.570–15:00.470
他还要根据当前的环境来决定
15:00.470–15:06.090
这个里面到底有没有其他的一些权限需要去申请啊
15:06.090–15:08.870
所以说你写在这里的话
15:08.870–15:11.090
如果说这个里面啊
15:11.090–15:13.770
并不需要额外再去申请其他权限的话
15:13.770–15:15.670
这个命令执行就执行成功了
15:15.670–15:18.430
他不会弹出那个还需要你确认的那个过程
15:18.430–15:21.590
所以具体得看一些场景啊
15:21.590–15:24.250
这个大家回头也可以去试一下
15:24.250–15:27.170
如果他但凡没有涉及到网络访问的话
15:27.170–15:29.870
这个我们其实是OK的啊
15:29.870–15:33.130
所以整个Codex
15:33.130–15:35.170
他的一个处理逻辑的话就是
15:35.170–15:39.770
他会先去加载我们整个 Rules 的一个目录
15:39.770–15:40.130
是吧
15:40.130–15:42.230
那加载完之后的话
15:42.230–15:46.770
他会读取到里面的这个 .rules 的一些文件内容
15:46.770–15:47.790
然后的话
15:47.790–15:50.270
这个里面他也分全局的
15:50.270–15:51.630
还有这个项目的
15:51.630–15:53.690
就有用户级别的
15:53.690–15:54.910
整个全局的
15:54.910–15:56.890
也有按照项目来分的
15:56.890–15:58.670
在某个项目下面去点Rules
15:58.670–16:01.730
这个都是OK的
16:01.730–16:03.890
跟我们前面讲的那个
16:03.890–16:19.484
嗯
16:19.484–16:20.884
就是一个匹配
16:20.884–16:22.884
在这个里面
16:22.884–16:25.184
比如说我们可以匹配pr命令是吧
16:25.184–16:26.684
然后decision
16:26.684–16:28.484
就我们前面讲的不提示
16:28.484–16:30.184
然后提示
16:30.184–16:33.884
然后或者是直接阻止了
16:33.884–16:34.784
那比如说大家
16:34.784–16:36.684
其实你可以在这个里面去改
16:36.684–16:38.184
比如说现在是提示吗
16:38.184–16:40.684
你直接改成forbidden
16:40.684–16:42.984
然后你再去执行看一下
16:42.984–16:43.784
比如说在这个里面
16:43.784–16:45.384
我们先退出去
16:45.384–16:46.884
再执行codex
16:46.884–16:49.484
然后再直接执行这个
16:49.484–16:50.204
命令
16:50.204–16:51.344
看一下他会怎么样
16:51.344–16:56.824
你看
16:56.824–16:58.344
当前
16:58.344–17:01.484
看一下会不会被拒绝啊
17:01.484–17:03.084
啊
17:03.084–17:05.384
因为这个是网络访问啊
17:05.384–17:06.944
这个是另外一个权限申请啊
17:06.944–17:08.124
跟刚刚那个还不一样
17:08.124–17:17.144
看一下他最终会不会被拒绝啊
17:17.144–17:19.044
你看现在已经在加载那个
17:19.044–17:19.964
点Rules了
17:19.964–17:23.264
看一下他最终会不会被拒绝掉
17:23.264–17:37.984
还是有这个结果
17:37.984–17:41.444
这个是前面咱们做了授权
17:41.444–17:43.304
一次性给他加进去了吗
17:43.304–17:46.704
正常来说应该是给他拒绝了
17:46.704–17:49.704
我现在已经有一个forbidden了
17:49.704–17:51.104
我再退出去啊
17:51.104–17:51.704
再看一下
17:51.704–18:02.704
看我切换这个permission看一下
18:02.704–18:05.704
然后测试review
18:05.704–18:07.704
我切换这种模式看一下
18:07.704–18:10.704
然后再执行
18:10.704–18:16.704
看一下他需不需要确认
18:16.704–18:24.764
他说GH因为网络沙箱受限
18:24.764–18:27.324
他会按照他这里提示的权限
18:27.324–18:29.724
他那个沙箱是没权限的
18:29.724–18:31.624
是直接给他锯掉的
18:31.624–18:34.864
但是的话他要重新做一个提权
18:34.864–18:37.704
所以这里面他最终还是可以的
18:37.704–18:40.424
你看他这个只是查询
18:40.424–18:42.364
他没有涉及到修改的风险
18:42.364–18:44.824
所以这里面默认给他放行的
18:44.824–18:46.984
看一下
18:46.984–18:53.684
在这里大家去改的话
18:53.684–18:55.464
你其实看不到什么效果
18:55.464–18:58.524
他其实沙箱给他阻止了
18:58.524–18:59.984
但是的话就是
18:59.984–19:03.344
我们还是可以有一个提权的过程
19:03.344–19:05.564
这个是他设计的
19:05.564–19:14.824
就是这个样子
19:14.824–19:25.024
你看他这个是网络网络权限啊
19:25.024–19:27.184
然后不要告诉我之前
19:27.184–19:29.664
告诉Codex
19:29.664–19:35.004
他其实内部是已经拒绝
19:35.004–19:36.784
但是这里会有个提权的操作
19:36.784–19:39.844
所以大家得看具体的一个情况
19:39.844–19:43.904
然后我们还可以加一些不同的一些参数是吧
19:43.904–19:45.444
然后去做一些匹配啊等等
19:45.444–19:48.504
那这个里面的话就是
19:48.504–19:51.364
我们基于这个Codex
19:51.364–19:53.204
可以去做一些这个
19:53.204–19:55.784
评估一条代运行的命令的时候
19:55.784–19:57.284
他会把命令
19:57.284–19:58.384
他的一个参数
19:58.384–20:00.784
做一个比较啊
20:00.784–20:01.624
那在内部的话
20:01.624–20:02.884
Codex会把命令
20:02.884–20:04.724
看作一个参数列表
20:04.724–20:06.304
比如说一些这个
20:06.304–20:09.424
不同的这个参数是吧
20:09.424–20:10.064
比如说这个
20:10.064–20:13.484
EKCVP这种参数的方式
20:13.484–20:15.684
然后去做一个这个接收
20:15.684–20:19.144
就是他会有这么一个机制
20:19.144–20:20.584
好
20:20.584–20:22.224
然后是 shell wrapper
20:22.224–20:23.544
与复合的一些命令
20:23.544–20:25.524
这个是用来干嘛的呢
20:25.524–20:27.464
这个就是我们还可以包装一下
20:27.464–20:29.524
就是我们在 rules 里面
20:29.524–20:32.704
我们可以把整个命令做一个包装
20:32.704–20:34.524
什么意思呢
20:34.524–20:36.584
就是你现在要执行多个命令是吧
20:36.584–20:39.544
那我现在想把这个做个打包
20:39.544–20:41.864
比如说提交文件删除
20:41.864–20:43.344
整个做一个打包
20:43.344–20:46.044
那么在这里面的话
20:46.044–20:46.804
就相当于
20:46.804–20:49.444
它单次操作的话
20:49.444–20:51.424
相当于把整个 mini 做一个执行
20:51.424–20:53.144
就这里面我们可以做一个封装
20:53.144–20:55.664
然后Codex的话
20:55.664–20:59.644
它什么时候可以去拆分一些脚本
20:59.644–21:01.004
比如说
21:01.004–21:02.584
这个里面
21:02.584–21:05.904
一些纯字面量的一些单词
21:05.904–21:08.204
不包含变量展开的这种情况
21:08.204–21:10.244
或者是一些
21:10.244–21:13.124
只通过安全运算服务的一些
21:13.124–21:13.784
这个场景
21:13.784–21:15.544
或者是一些
21:15.544–21:16.464
这个
21:16.464–21:19.524
不同情况的
21:19.524–21:20.644
比如说下面这个
21:20.644–21:23.304
一些有规则的
21:23.304–21:23.604
是吧
21:23.604–21:25.544
就都是安全的这种场景
21:25.544–21:27.064
这个时候的话
21:27.064–21:28.164
他就可以去
21:28.164–21:29.644
加一些这个
21:29.644–21:30.904
一些
21:30.904–21:33.244
做一些安全的一些拆分
21:33.244–21:34.804
比如说把这些命令
21:34.804–21:35.404
做一个拆分
21:35.404–21:38.184
所以他会分别用你的 Rules
21:38.184–21:39.524
去评估每一条命令
21:39.524–21:41.424
并且以最严格的
21:41.424–21:42.624
这个结果为准
21:42.624–21:44.944
然后这里面的话
21:44.944–21:47.744
即使你允许这个partner
21:47.744–21:49.844
然后执行这个
21:49.844–21:51.904
你写了这个东西的话
21:51.904–21:53.544
那他也不会自动放弃
21:53.544–21:56.244
因为这个RM和RF
21:56.244–21:57.964
是一个非常危险的一个操作
21:57.964–22:01.264
因为这个命令比较危险
22:01.264–22:02.484
所以他会单独评估
22:02.484–22:05.204
所以你写归你写
22:05.204–22:07.484
但是Codex他自己也有一套
22:07.484–22:08.764
内置的一套规范
22:08.764–22:12.244
所以这种危险命令的话
22:12.244–22:13.364
你混在一起的话
22:13.364–22:16.544
就违背了他的一个安全指令的一个要求
22:16.544–22:18.304
所以大家会发现
22:18.304–22:19.824
你不是你写所有命令
22:19.824–22:21.564
他都会给你放行的
22:21.564–22:22.764
他也要去看情况
22:22.764–22:25.304
这个是Codex
22:25.304–22:27.744
他可以做一些安全脚本的一个拆分
22:27.744–22:29.024
然后的话Codex
22:29.024–22:31.284
他什么情况下不会去拆分脚本呢
22:31.284–22:34.024
比如说我们已经加了一些重定向像的一些东西了
22:34.024–22:35.964
加了一些替换的表达式了
22:35.964–22:37.904
或者做了一些环境变量的一些复制了
22:37.904–22:39.844
或者加了一些通配符了
22:39.844–22:41.964
那这个就不会尝试去解析他
22:41.964–22:43.924
因为它本身就代表
22:43.924–22:45.684
它的执行的一些关键点
22:45.684–22:47.384
是一些规范
22:47.384–22:50.264
所以它就不会去拆分
22:50.264–22:51.784
然后同时的话
22:51.784–22:52.984
它就直接把它用过来
22:52.984–22:54.384
直接去运行的啊
22:54.384–22:57.484
所以它也不是说你写了
22:57.484–22:58.784
它就会帮你去拆分
22:58.784–23:00.564
那它也要去看情况
23:00.564–23:04.324
所以这种处理方式意味着
23:04.324–23:07.184
你就是在可以安全拆分的时候
23:07.184–23:08.924
Codex会按照单条命令
23:08.924–23:10.144
逐项的去评估
23:10.144–23:12.064
在不能安全拆分的时候
23:12.064–23:12.844
就是按照
23:12.844–23:14.884
更加保守的一个方案
23:14.884–23:15.644
去做一个评估
23:15.644–23:18.684
然后弄完之后的话
23:18.684–23:20.744
我们也可以去做一些测试
23:20.744–23:23.304
比如说我们把这个命令
23:23.304–23:27.330
加到这里来可以看一下
23:27.330–23:33.890
就是你可以去看一下这个规则到底有没有生效。
23:33.890–23:38.690
比如说我们这个规则,我们可以把它加进去。
23:38.690–23:40.750
你看这个里面就找到了啊
23:40.750–23:42.590
什么
23:42.590–23:44.450
Codex
23:44.450–23:45.330
Default
23:45.330–23:47.150
Check
23:47.150–23:49.890
当前的这个用户目标
23:49.890–23:52.690
但是我们没有这个规则是吧
23:52.690–23:55.830
这个当前用户目标没有建那个规则
23:55.830–23:59.350
所以这个里面我们得改一下啊
23:59.350–24:02.250
这个就是当前目录的
24:02.250–24:03.330
Rules
24:03.330–24:05.330
点Rules
24:05.330–24:08.690
这里我们就指定当前步
24:08.690–24:11.650
然后来评估一下它的一些变化
24:11.650–24:29.910
来看一下
24:29.910–24:32.410
PowerShell可以复制执行的一个命令
24:32.410–24:35.670
你看他帮我们把命令做了一个优化
24:35.670–24:39.010
来我们退出去执行一下
24:39.010–24:45.790
这个里面有一个问题
24:45.790–25:02.410
Codex
25:02.410–25:05.910
你看这个是他匹配的一个规则是吧
25:05.910–25:08.250
匹配的规则就是我们可以看得出来
25:08.250–25:10.810
这个里面的话就相当于不被允许啊
25:10.810–25:13.070
这就是他要有这个结论
25:13.070–25:14.670
他可以分析出来
25:14.670–25:16.750
我们去执行这个命令的时候
25:16.750–25:19.090
他给的这个决定就是拒绝了啊
25:19.090–25:20.970
这就是测试规则文件
25:20.970–25:22.450
到底有没有写的有没有问题
25:22.450–25:25.070
他默认的话会帮你输出一个
25:25.070–25:27.610
JSON格式的这么一个规则出来啊
25:27.610–25:31.230
所以这个是我们做测试用的
25:31.230–25:36.350
然后包括一些这些规则的一些语言啊
25:36.350–25:36.690
是吧
25:36.690–25:37.610
比如说
25:37.610–25:39.590
大家可以去看一下
25:39.590–25:42.110
专门有一套语法啊
25:42.110–25:45.270
叫这个Specific的这么一个语法
25:45.270–25:49.790
你看这个是专门的有一套规范啊
25:49.790–25:50.870
大家可以去看一下
25:50.870–25:54.070
怎么来写这个东西
25:54.070–25:54.770
是吧
25:54.770–25:56.830
大家可以去看一下
25:56.830–25:58.990
他是专门有一套规则语法的
25:58.990–26:00.610
他是采用了这种方式
26:00.610–26:02.210
去写规则的
26:02.210–26:04.490
大家可以去参考一下
26:04.490–26:05.890
这是它的一个使用说明
26:05.890–26:08.890
它的语法看起来有点像Python
26:08.890–26:10.890
但是设计目标的话是安全执行
26:10.890–26:12.650
所以 Rules 的一个引擎
26:12.650–26:14.830
可以在不产生副作用的前例下
26:14.830–26:16.170
去运行它
26:16.170–26:19.110
比如说它不会去触碰文件系统的一些逻辑
26:19.110–26:20.630
所以这个里面
26:20.630–26:23.830
大家可以去看一下它的一个细节点
26:23.830–26:25.690
这个我们可以去
0:00.000–0:07.651
zh好,然后我们来讲一下这个Codex Rules体系构建与代码可控性治理。
好,然后我们来讲一下这个Codex Rules体系构建与代码可控性治理。
0:07.651–0:12.327
zh那这个的话其实也是一套这个细节的一个规范啊。
那这个的话其实也是一套这个细节的一个规范啊。
0:12.327–0:15.090
zh这个就更加的这个细粒度了。
这个就更加的这个细粒度了。
0:15.090–0:22.954
zh前面那个我们说的这个规范的话,主要还是指的是整个项目的一些大的一些规范啊。
前面那个我们说的这个规范的话,主要还是指的是整个项目的一些大的一些规范啊。
0:22.954–0:25.930
zh比如说目录啊,结构啊,是吧。
比如说目录啊,结构啊,是吧。
0:25.930–0:28.480
zh它就相当于一个代码地图。
它就相当于一个代码地图。
0:28.480–0:32.000
zh那这个Rules的这个规范的话
那这个Rules的这个规范的话
0:32.000–0:33.880
zh它就更加的细了
它就更加的细了
0:33.880–0:36.300
zh这个是用来去控制
这个是用来去控制
0:36.300–0:39.820
zh哪些命令可以在沙箱外去做一个执行
哪些命令可以在沙箱外去做一个执行
0:39.820–0:41.900
zh这个就偏执行类的
这个就偏执行类的
0:41.900–0:44.940
zh也就是说比如说我们在这个
也就是说比如说我们在这个
0:44.940–0:47.180
zh跑一些代码的时候
跑一些代码的时候
0:47.180–0:48.180
zh跑一些case的时候
跑一些case的时候
0:48.180–0:49.860
zh做一些自动化测试的时候
做一些自动化测试的时候
0:49.860–0:52.320
zh那自动化测试的话
那自动化测试的话
0:52.320–0:54.220
zh可能涉及到命令就比较多了
可能涉及到命令就比较多了
0:54.220–0:55.960
zh有可能会删除文件
有可能会删除文件
0:55.960–0:57.760
zh有可能需要调用工具
有可能需要调用工具
0:57.760–0:59.000
zh等等的啊
等等的啊
0:59.000–1:00.400
zh就个人相关的权限都会有
就个人相关的权限都会有
1:00.400–1:03.380
zh所以Codex专门设计了一套
所以Codex专门设计了一套
1:03.380–1:05.520
zh叫Rules的一套组件啊
叫Rules的一套组件啊
1:05.520–1:07.460
zh专门就是用来干这个事情的
专门就是用来干这个事情的
1:07.460–1:09.620
zh那这个里面的话啊
那这个里面的话啊
1:09.620–1:11.400
zh很好理解就是什么呢
很好理解就是什么呢
1:11.400–1:12.640
zh那在这个里面
那在这个里面
1:12.640–1:15.180
zh你可以建一些这个Rules啊
你可以建一些这个Rules啊
1:15.180–1:18.380
zh比如说我们就直接在这个
比如说我们就直接在这个
1:18.380–1:19.840
zh这个里面啊
这个里面啊
1:19.840–1:21.720
zh我们就找个项目吧
我们就找个项目吧
1:21.720–1:23.060
zh嗯
嗯
1:23.060–1:29.300
zh看一下啊
看一下啊
1:29.300–1:32.760
zh这个里面的话
这个里面的话
1:32.760–1:34.900
zh相当于
相当于
1:34.900–1:37.040
zh我们要可以加一个规则
我们要可以加一个规则
1:37.040–1:38.200
zh做一个什么呢
做一个什么呢
1:38.200–1:39.900
zh就是沙箱外运行的话
就是沙箱外运行的话
1:39.900–1:41.460
zh需要先提示用户确认
需要先提示用户确认
1:41.460–1:44.940
zh也就是说我们可能要执行一个
也就是说我们可能要执行一个
1:44.940–1:47.980
zhGHPR的一个命令
GHPR的一个命令
1:47.980–1:49.160
zh然后这个命令的话
然后这个命令的话
1:49.160–1:50.540
zh可能要去干嘛呢
可能要去干嘛呢
1:50.540–1:53.520
zh要去分析一些仓库是吧
要去分析一些仓库是吧
1:53.520–1:55.180
zh获取一些这个信息
获取一些这个信息
1:55.180–1:56.920
zh所以这个里面的话
所以这个里面的话
1:56.920–1:59.720
zh当他执行这种命令的时候
当他执行这种命令的时候
1:59.720–2:03.100
zh我们需要有用户去做一个确认
我们需要有用户去做一个确认
2:03.100–2:05.020
zh所以这个里面
所以这个里面
2:05.020–2:06.100
zh事实上
事实上
2:06.100–2:08.380
zh他就是要做一个什么呢
他就是要做一个什么呢
2:08.380–2:09.540
zh授权的一个管理
授权的一个管理
2:09.540–2:12.660
zh那比如说我们现在就是在这个里面去建一下
那比如说我们现在就是在这个里面去建一下
2:12.660–2:16.800
zh然后我们在这个里面
然后我们在这个里面
2:16.800–2:18.000
zh比如说这个项目下面
比如说这个项目下面
2:18.000–2:20.740
zh先建文件啊
先建文件啊
2:20.740–2:22.160
zh比如说我就建一个.lulus
比如说我就建一个.lulus
2:22.160–2:25.240
zh然后把下面这一堆翻过来啊
然后把下面这一堆翻过来啊
2:25.240–2:26.800
zh翻过来啊
翻过来啊
2:26.800–2:28.300
zh然后在这个里面的话
然后在这个里面的话
2:28.300–2:31.840
zh我们可以看一下
我们可以看一下
2:31.840–2:35.440
zh首先我们进入到root的这个目录里去
首先我们进入到root的这个目录里去
2:35.440–2:48.000
zh进入到root
进入到root
2:48.000–2:50.900
zh好到这个里面然后进入到codex
好到这个里面然后进入到codex
2:50.900–2:52.300
zh然后你就直接问他
然后你就直接问他
2:52.300–2:56.100
zh当前项目有哪些
当前项目有哪些
2:56.100–3:01.100
enlulus
lulus
3:01.100–3:06.600
zh你就直接问他有哪些具体的这个规则是吧
你就直接问他有哪些具体的这个规则是吧
3:06.600–3:19.460
zh然后他会自动的去分析啊
然后他会自动的去分析啊
3:19.460–3:22.760
zh他会去找
他会去找
3:22.760–3:26.020
zh所以他优先级的话
所以他优先级的话
3:26.020–3:29.480
zh他会去扫.lulus的这个目录吧
他会去扫.lulus的这个目录吧
3:29.480–3:30.780
zh这里还不行
这里还不行
3:30.780–3:34.520
zh我们建了这个.lulus的这个目录文件以外
我们建了这个.lulus的这个目录文件以外
3:34.520–3:35.020
zh我看一下
我看一下
3:35.020–3:38.860
zh还要建一个.lulus的目录
还要建一个.lulus的目录
3:38.860–3:41.540
zh不然的话加载是有问题的
不然的话加载是有问题的
3:41.540–3:44.980
zh所以这个里面我们得加一个
所以这个里面我们得加一个
3:44.980–3:48.520
zh还得建个目录
还得建个目录
3:48.520–3:51.100
zh建个文件夹
建个文件夹
3:51.100–3:54.900
zh然后把这个.rules给它拖进去
然后把这个.rules给它拖进去
3:54.900–4:03.280
zh然后再重启一下
然后再重启一下
4:03.280–4:04.340
zh然后再去问它
然后再去问它
4:04.340–4:25.040
zh然后这个里面
然后这个里面
4:25.040–4:27.180
zh他会去加载这个Rules
他会去加载这个Rules
4:27.180–4:34.000
zh你看他把agency.md的内容
你看他把agency.md的内容
4:34.000–4:34.840
zh也输出出来了
也输出出来了
4:34.840–4:37.240
zh看一下rules
看一下rules
4:37.240–4:39.680
zh嗯
嗯
4:39.680–4:43.360
zh哎他这个这里个规范没有输出来
哎他这个这里个规范没有输出来
4:43.360–4:46.040
zh项目生效的rules
项目生效的rules
4:46.040–4:47.480
zhdd驱动
dd驱动
4:47.480–4:52.560
zh他他把这个rules理解成
他他把这个rules理解成
4:52.560–4:53.920
zhagents.md了
agents.md了
4:53.920–4:57.080
zh看一下有没有办法给他调整一下
看一下有没有办法给他调整一下
4:57.080–4:59.140
zh嗯
嗯
4:59.140–5:04.000
zh这里要去激活一下啊
这里要去激活一下啊
5:04.000–5:10.100
enrules
rules
5:10.100–5:15.700
zh看一下这个目录
看一下这个目录
5:15.700–5:17.840
zhrules 下面有一个点
rules 下面有一个点
5:17.840–5:18.360
enrules
rules
5:18.360–5:27.440
zh然后我们
然后我们
5:27.440–5:34.000
zh执行一下这个命令看一下
执行一下这个命令看一下
5:34.000–5:41.800
enghprvu
ghprvu
5:41.800–5:54.700
zh原因是当前仓库的git remote没有指向github主机
原因是当前仓库的git remote没有指向github主机
5:54.700–5:58.200
zh那其实我们可以换一个项目
那其实我们可以换一个项目
5:58.200–6:04.000
enprodx
prodx
6:04.000–6:10.840
zh我们找到那个项目
我们找到那个项目
6:10.840–6:19.000
zh用这个开源项目来测试一下
用这个开源项目来测试一下
6:19.000–6:21.000
zh把这个项目导下来啊
把这个项目导下来啊
6:21.000–6:34.120
engit clone
git clone
6:34.120–6:40.940
zh首先我把这个项目拉下来
首先我把这个项目拉下来
6:40.940–6:48.100
zh因为这个里面要用github的项目
因为这个里面要用github的项目
6:48.100–6:51.000
zh我上面那个是gitee的一个项目
我上面那个是gitee的一个项目
6:51.000–6:53.400
zh所以我首先要把它给它导进来
所以我首先要把它给它导进来
6:53.400–6:58.680
zh看这个项目有点大啊
看这个项目有点大啊
6:58.680–7:01.740
zh反正这个规则的意思就是
反正这个规则的意思就是
7:01.740–7:04.640
zh大家在执行一些命令的时候
大家在执行一些命令的时候
7:04.640–7:08.740
zh就是你可以去指定哪一些各个命令
就是你可以去指定哪一些各个命令
7:08.740–7:10.720
zh是需要用户授权的
是需要用户授权的
7:10.720–7:13.620
zh因为我们默认的话
因为我们默认的话
7:13.620–7:15.820
zh其实有一些命令啊
其实有一些命令啊
7:15.820–7:17.120
zh它需要授权
它需要授权
7:17.120–7:18.660
zh有些是不需要授权的
有些是不需要授权的
7:18.660–7:20.360
zh那么大家可以去配一下
那么大家可以去配一下
7:20.360–7:21.740
zh就是在某些命令下
就是在某些命令下
7:21.740–7:23.400
zh需要去触发授权
需要去触发授权
7:23.400–7:25.280
zh也就是大家可以针对
也就是大家可以针对
7:25.280–7:27.280
zh我们当前执行的一个命令的话
我们当前执行的一个命令的话
7:27.280–7:29.860
zh做一些细粒度的权限管控
做一些细粒度的权限管控
7:29.860–7:31.120
zh就加一个规则
就加一个规则
7:31.120–7:33.880
zh因为涉及到一些危险动作的时候
因为涉及到一些危险动作的时候
7:33.880–7:36.640
zh就需要用户来确认
就需要用户来确认
7:36.640–7:38.580
zh确认完之后再去做处理
确认完之后再去做处理
7:38.580–7:41.020
zh所以我们在这个点
所以我们在这个点
7:41.020–7:43.680
zhCodex里面去加这个规则的话
Codex里面去加这个规则的话
7:43.680–7:45.460
zh就意味着什么呢
就意味着什么呢
7:45.460–7:48.400
zh我们可以去做一些权限的一些细节管控
我们可以去做一些权限的一些细节管控
7:48.400–7:50.320
zh就是做一个这种审批
就是做一个这种审批
7:50.320–7:53.120
zh就相当于大家在这做这个
就相当于大家在这做这个
7:53.120–7:54.840
zh整个的一个
整个的一个
7:54.840–7:57.540
zh各种各样的命令管理的时候
各种各样的命令管理的时候
7:57.540–7:59.780
zh你可以下一些细粒度的一些管控
你可以下一些细粒度的一些管控
7:59.780–8:01.000
zh有一些
有一些
8:01.000–8:18.690
zh这个命令的话
这个命令的话
8:18.690–8:20.090
zh给他加一下
给他加一下
8:20.090–8:20.610
zh是吧
是吧
8:20.610–8:22.530
zh加一些权限控制
加一些权限控制
8:22.530–8:24.430
zh然后这个里面啊
然后这个里面啊
8:24.430–8:25.850
zh我们可以配置哪些东西呢
我们可以配置哪些东西呢
8:25.850–8:27.490
zh比如说啊
比如说啊
8:27.490–8:29.390
zh它是有一套规范
它是有一套规范
8:29.390–8:30.870
zh比如说这个 pattern
比如说这个 pattern
8:30.870–8:31.790
zh匹配规则
匹配规则
8:31.790–8:32.530
zh比如说pr
比如说pr
8:32.530–8:34.690
zh就是你有pr的一些命令
就是你有pr的一些命令
8:34.690–8:36.430
zh然后这个decision
然后这个decision
8:36.430–8:38.230
zh这个是做一些具体的命
这个是做一些具体的命
8:38.230–8:39.310
zh动作的一个执行
动作的一个执行
8:39.310–8:40.650
zh比如说允许
比如说允许
8:40.650–8:41.650
zh或者拒绝
或者拒绝
8:41.650–8:42.390
zh或者怎么样
或者怎么样
8:42.390–8:44.230
zh一个是不提示
一个是不提示
8:44.230–8:46.610
zh直接在沙箱环境下面去执行
直接在沙箱环境下面去执行
8:46.610–8:47.930
zh然后是提示
然后是提示
8:47.930–8:50.090
zh就每次命中都要确认请求
就每次命中都要确认请求
8:50.090–8:53.870
zh然后这个forbidden是直接拒绝了
然后这个forbidden是直接拒绝了
8:53.870–8:56.130
zh就这种命令就不允许执行了
就这种命令就不允许执行了
8:56.130–8:59.630
zh比如说RM跟RF这种删除文件的
比如说RM跟RF这种删除文件的
8:59.630–9:01.490
zh我们就不管它了
我们就不管它了
9:01.490–9:02.430
zh这个完了
这个完了
9:02.430–9:05.530
zh然后我们现在去切换到这个
然后我们现在去切换到这个
9:05.530–9:07.530
zh看一下
看一下
9:07.530–9:10.870
zh切换到codex
切换到codex
9:10.870–9:12.470
zh这个项目里面去
这个项目里面去
9:12.470–9:15.170
zh然后在这个项目下面的话
然后在这个项目下面的话
9:15.170–9:16.210
zh我们建一个
我们建一个
9:16.210–9:17.870
zh把那个移动过去
把那个移动过去
9:17.870–9:23.270
zh刚刚有一个rules
刚刚有一个rules
9:23.270–9:34.370
zh把这个移到这个下面去
把这个移到这个下面去
9:34.370–9:35.510
zh好现在已经移过来
好现在已经移过来
9:35.510–9:36.130
zh移过来之后
移过来之后
9:36.130–9:39.070
zh我们再切进去看一下
我们再切进去看一下
9:39.070–9:43.210
encodex
codex
9:43.210–9:43.870
zh好这里面
好这里面
9:43.870–9:47.870
zh然后我们再去执行刚刚的一个指令
然后我们再去执行刚刚的一个指令
9:47.870–9:54.070
zh比如说我们来分析一下
比如说我们来分析一下
9:54.070–9:59.770
zh当前项目的
当前项目的
9:59.770–10:17.870
zhRules有哪些
Rules有哪些
10:17.870–10:27.910
zh他默认读的也是这个agents.md
他默认读的也是这个agents.md
10:27.910–10:35.470
zh他不能加载内容
他不能加载内容
10:35.470–10:39.570
zh这就这么来就问他
这就这么来就问他
10:39.570–10:42.650
zh当前项目的
当前项目的
10:42.650–10:46.530
zh有哪些内容
有哪些内容
10:46.530–10:53.810
zh我看这样来问行不行啊
我看这样来问行不行啊
10:53.810–10:57.530
zh他会去找这个文件啊
他会去找这个文件啊
10:57.530–11:04.610
zh他是有一个匹配规则的
他是有一个匹配规则的
11:04.610–11:08.590
zh就比如说Codex想在沙箱里面去运行
就比如说Codex想在沙箱里面去运行
11:08.590–11:10.250
zhGHVU开头的命令
GHVU开头的命令
11:10.250–11:11.950
zh但是需要后续的批准
但是需要后续的批准
11:11.950–11:14.250
zh精准匹配啊才可以
精准匹配啊才可以
11:14.250–11:17.790
zh所以说不匹配
所以说不匹配
11:17.790–11:22.490
zh比如说我们现在来整这个看一下
比如说我们现在来整这个看一下
11:22.490–11:37.710
zh你看现在是不是需要用户来确认是吧
你看现在是不是需要用户来确认是吧
11:37.710–11:40.950
zh这个是不是我们那个规则生效了
这个是不是我们那个规则生效了
11:40.950–11:44.010
zh这里面是不是就需要用户来确认
这里面是不是就需要用户来确认
11:44.010–11:44.910
zh是吧
是吧
11:44.910–11:46.810
zh来确认一下
来确认一下
11:46.810–12:02.290
zh你看这个是以执行
你看这个是以执行
12:02.290–12:14.010
zh然后我们再来执行这个看一下
然后我们再来执行这个看一下
12:14.010–12:15.690
zh你看用这种命令
你看用这种命令
12:15.690–12:16.950
zh一旦匹配上了
一旦匹配上了
12:16.950–12:17.670
zh他就要确认
他就要确认
12:17.670–12:19.550
zh然后不匹配的
然后不匹配的
12:19.550–12:20.890
zh我们来也来确认一下
我们来也来确认一下
12:20.890–12:24.010
zh看一下这个是不是就不会授权了
看一下这个是不是就不会授权了
12:24.010–12:31.370
zh这个还是要确认
这个还是要确认
12:31.370–12:33.250
zh这个也是要确认
这个也是要确认
12:33.250–12:35.090
zh只是说这里面
只是说这里面
12:35.090–12:38.690
zh就是相当于一些一个逻辑
就是相当于一些一个逻辑
12:38.690–12:41.430
zh要做一些处理
要做一些处理
12:41.430–12:46.070
zh但是我们看一下这个上面那个规则
但是我们看一下这个上面那个规则
12:46.070–12:55.650
zh因为他网络访问
因为他网络访问
12:55.650–12:56.990
zh所以还是需要授权
所以还是需要授权
12:56.990–12:59.110
zh其实这个不匹配的话
其实这个不匹配的话
12:59.110–13:02.030
zh不匹配的话就必须
不匹配的话就必须
13:02.030–13:03.410
zh然后再分析一下
然后再分析一下
13:03.410–13:11.430
zh看一下刚刚那个规则是什么
看一下刚刚那个规则是什么
13:11.430–13:17.930
zh呃
呃
13:17.930–13:21.370
zhGHPRVU会匹配
GHPRVU会匹配
13:21.370–13:22.730
zhGitRepo不会匹配
GitRepo不会匹配
13:22.730–13:27.130
zh因为他不是以精准的GHPRVU
因为他不是以精准的GHPRVU
13:27.130–13:41.430
zh不匹配会怎么样
不匹配会怎么样
13:41.430–13:46.310
zh怎么样
怎么样
13:46.310–13:48.770
zh我们就看一下
我们就看一下
13:48.770–13:50.570
zh他这个规则到底是怎么样的
他这个规则到底是怎么样的
13:50.570–13:52.990
zh他说是不会命中
他说是不会命中
13:52.990–13:54.550
zh点Rules这个规则
点Rules这个规则
13:54.550–13:58.770
zh但是我们实际还是看到那个是吧
但是我们实际还是看到那个是吧
13:58.770–14:00.490
zh看一下他这个细节
看一下他这个细节
14:00.490–14:07.750
zh他说的是不会命中
他说的是不会命中
14:07.750–14:10.590
zh但是因为还是会涉及到一些网络权限
但是因为还是会涉及到一些网络权限
14:10.590–14:12.550
zh还是会有一些提示的
还是会有一些提示的
14:12.550–14:15.390
zh你看啊
你看啊
14:15.390–14:17.590
zh因为这个命令需要访问GitHub网络
因为这个命令需要访问GitHub网络
14:17.590–14:19.190
zh所以在当前环境下
所以在当前环境下
14:19.190–14:21.350
zh还是会要求额外授权执行
还是会要求额外授权执行
14:21.350–14:22.430
zh所以正常来说
所以正常来说
14:22.430–14:25.310
zh按理说他没有匹配就不需要做授权
按理说他没有匹配就不需要做授权
14:25.310–14:27.370
zh因为你要访问网络啊
因为你要访问网络啊
14:27.370–14:31.730
zh所以这个就还是要做授权的
所以这个就还是要做授权的
14:31.730–14:40.590
zh那我们这次这个依旧需要授权
那我们这次这个依旧需要授权
14:40.590–14:42.450
zh你看这里面需要确认一下
你看这里面需要确认一下
14:42.450–14:45.510
zh还是需要授权
还是需要授权
14:45.510–14:49.410
zh也要涉及到访问网络啊
也要涉及到访问网络啊
14:49.410–14:53.070
zh所以这个规则这个里面的逻辑就是
所以这个规则这个里面的逻辑就是
14:53.070–14:55.190
zh啊我们整个
啊我们整个
14:55.190–14:58.570
zh他不一定就说严格按照这个来啊
他不一定就说严格按照这个来啊
14:58.570–15:00.470
zh他还要根据当前的环境来决定
他还要根据当前的环境来决定
15:00.470–15:06.090
zh这个里面到底有没有其他的一些权限需要去申请啊
这个里面到底有没有其他的一些权限需要去申请啊
15:06.090–15:08.870
zh所以说你写在这里的话
所以说你写在这里的话
15:08.870–15:11.090
zh如果说这个里面啊
如果说这个里面啊
15:11.090–15:13.770
zh并不需要额外再去申请其他权限的话
并不需要额外再去申请其他权限的话
15:13.770–15:15.670
zh这个命令执行就执行成功了
这个命令执行就执行成功了
15:15.670–15:18.430
zh他不会弹出那个还需要你确认的那个过程
他不会弹出那个还需要你确认的那个过程
15:18.430–15:21.590
zh所以具体得看一些场景啊
所以具体得看一些场景啊
15:21.590–15:24.250
zh这个大家回头也可以去试一下
这个大家回头也可以去试一下
15:24.250–15:27.170
zh如果他但凡没有涉及到网络访问的话
如果他但凡没有涉及到网络访问的话
15:27.170–15:29.870
zh这个我们其实是OK的啊
这个我们其实是OK的啊
15:29.870–15:33.130
zh所以整个Codex
所以整个Codex
15:33.130–15:35.170
zh他的一个处理逻辑的话就是
他的一个处理逻辑的话就是
15:35.170–15:39.770
zh他会先去加载我们整个 Rules 的一个目录
他会先去加载我们整个 Rules 的一个目录
15:39.770–15:40.130
zh是吧
是吧
15:40.130–15:42.230
zh那加载完之后的话
那加载完之后的话
15:42.230–15:46.770
zh他会读取到里面的这个 .rules 的一些文件内容
他会读取到里面的这个 .rules 的一些文件内容
15:46.770–15:47.790
zh然后的话
然后的话
15:47.790–15:50.270
zh这个里面他也分全局的
这个里面他也分全局的
15:50.270–15:51.630
zh还有这个项目的
还有这个项目的
15:51.630–15:53.690
zh就有用户级别的
就有用户级别的
15:53.690–15:54.910
zh整个全局的
整个全局的
15:54.910–15:56.890
zh也有按照项目来分的
也有按照项目来分的
15:56.890–15:58.670
zh在某个项目下面去点Rules
在某个项目下面去点Rules
15:58.670–16:01.730
zh这个都是OK的
这个都是OK的
16:01.730–16:03.890
zh跟我们前面讲的那个
跟我们前面讲的那个
16:03.890–16:19.484
zh嗯
嗯
16:19.484–16:20.884
zh就是一个匹配
就是一个匹配
16:20.884–16:22.884
zh在这个里面
在这个里面
16:22.884–16:25.184
zh比如说我们可以匹配pr命令是吧
比如说我们可以匹配pr命令是吧
16:25.184–16:26.684
zh然后decision
然后decision
16:26.684–16:28.484
zh就我们前面讲的不提示
就我们前面讲的不提示
16:28.484–16:30.184
zh然后提示
然后提示
16:30.184–16:33.884
zh然后或者是直接阻止了
然后或者是直接阻止了
16:33.884–16:34.784
zh那比如说大家
那比如说大家
16:34.784–16:36.684
zh其实你可以在这个里面去改
其实你可以在这个里面去改
16:36.684–16:38.184
zh比如说现在是提示吗
比如说现在是提示吗
16:38.184–16:40.684
zh你直接改成forbidden
你直接改成forbidden
16:40.684–16:42.984
zh然后你再去执行看一下
然后你再去执行看一下
16:42.984–16:43.784
zh比如说在这个里面
比如说在这个里面
16:43.784–16:45.384
zh我们先退出去
我们先退出去
16:45.384–16:46.884
zh再执行codex
再执行codex
16:46.884–16:49.484
zh然后再直接执行这个
然后再直接执行这个
16:49.484–16:50.204
zh命令
命令
16:50.204–16:51.344
zh看一下他会怎么样
看一下他会怎么样
16:51.344–16:56.824
zh你看
你看
16:56.824–16:58.344
zh当前
当前
16:58.344–17:01.484
zh看一下会不会被拒绝啊
看一下会不会被拒绝啊
17:01.484–17:03.084
zh啊
啊
17:03.084–17:05.384
zh因为这个是网络访问啊
因为这个是网络访问啊
17:05.384–17:06.944
zh这个是另外一个权限申请啊
这个是另外一个权限申请啊
17:06.944–17:08.124
zh跟刚刚那个还不一样
跟刚刚那个还不一样
17:08.124–17:17.144
zh看一下他最终会不会被拒绝啊
看一下他最终会不会被拒绝啊
17:17.144–17:19.044
zh你看现在已经在加载那个
你看现在已经在加载那个
17:19.044–17:19.964
zh点Rules了
点Rules了
17:19.964–17:23.264
zh看一下他最终会不会被拒绝掉
看一下他最终会不会被拒绝掉
17:23.264–17:37.984
zh还是有这个结果
还是有这个结果
17:37.984–17:41.444
zh这个是前面咱们做了授权
这个是前面咱们做了授权
17:41.444–17:43.304
zh一次性给他加进去了吗
一次性给他加进去了吗
17:43.304–17:46.704
zh正常来说应该是给他拒绝了
正常来说应该是给他拒绝了
17:46.704–17:49.704
zh我现在已经有一个forbidden了
我现在已经有一个forbidden了
17:49.704–17:51.104
zh我再退出去啊
我再退出去啊
17:51.104–17:51.704
zh再看一下
再看一下
17:51.704–18:02.704
zh看我切换这个permission看一下
看我切换这个permission看一下
18:02.704–18:05.704
zh然后测试review
然后测试review
18:05.704–18:07.704
zh我切换这种模式看一下
我切换这种模式看一下
18:07.704–18:10.704
zh然后再执行
然后再执行
18:10.704–18:16.704
zh看一下他需不需要确认
看一下他需不需要确认
18:16.704–18:24.764
zh他说GH因为网络沙箱受限
他说GH因为网络沙箱受限
18:24.764–18:27.324
zh他会按照他这里提示的权限
他会按照他这里提示的权限
18:27.324–18:29.724
zh他那个沙箱是没权限的
他那个沙箱是没权限的
18:29.724–18:31.624
zh是直接给他锯掉的
是直接给他锯掉的
18:31.624–18:34.864
zh但是的话他要重新做一个提权
但是的话他要重新做一个提权
18:34.864–18:37.704
zh所以这里面他最终还是可以的
所以这里面他最终还是可以的
18:37.704–18:40.424
zh你看他这个只是查询
你看他这个只是查询
18:40.424–18:42.364
zh他没有涉及到修改的风险
他没有涉及到修改的风险
18:42.364–18:44.824
zh所以这里面默认给他放行的
所以这里面默认给他放行的
18:44.824–18:46.984
zh看一下
看一下
18:46.984–18:53.684
zh在这里大家去改的话
在这里大家去改的话
18:53.684–18:55.464
zh你其实看不到什么效果
你其实看不到什么效果
18:55.464–18:58.524
zh他其实沙箱给他阻止了
他其实沙箱给他阻止了
18:58.524–18:59.984
zh但是的话就是
但是的话就是
18:59.984–19:03.344
zh我们还是可以有一个提权的过程
我们还是可以有一个提权的过程
19:03.344–19:05.564
zh这个是他设计的
这个是他设计的
19:05.564–19:14.824
zh就是这个样子
就是这个样子
19:14.824–19:25.024
zh你看他这个是网络网络权限啊
你看他这个是网络网络权限啊
19:25.024–19:27.184
zh然后不要告诉我之前
然后不要告诉我之前
19:27.184–19:29.664
zh告诉Codex
告诉Codex
19:29.664–19:35.004
zh他其实内部是已经拒绝
他其实内部是已经拒绝
19:35.004–19:36.784
zh但是这里会有个提权的操作
但是这里会有个提权的操作
19:36.784–19:39.844
zh所以大家得看具体的一个情况
所以大家得看具体的一个情况
19:39.844–19:43.904
zh然后我们还可以加一些不同的一些参数是吧
然后我们还可以加一些不同的一些参数是吧
19:43.904–19:45.444
zh然后去做一些匹配啊等等
然后去做一些匹配啊等等
19:45.444–19:48.504
zh那这个里面的话就是
那这个里面的话就是
19:48.504–19:51.364
zh我们基于这个Codex
我们基于这个Codex
19:51.364–19:53.204
zh可以去做一些这个
可以去做一些这个
19:53.204–19:55.784
zh评估一条代运行的命令的时候
评估一条代运行的命令的时候
19:55.784–19:57.284
zh他会把命令
他会把命令
19:57.284–19:58.384
zh他的一个参数
他的一个参数
19:58.384–20:00.784
zh做一个比较啊
做一个比较啊
20:00.784–20:01.624
zh那在内部的话
那在内部的话
20:01.624–20:02.884
zhCodex会把命令
Codex会把命令
20:02.884–20:04.724
zh看作一个参数列表
看作一个参数列表
20:04.724–20:06.304
zh比如说一些这个
比如说一些这个
20:06.304–20:09.424
zh不同的这个参数是吧
不同的这个参数是吧
20:09.424–20:10.064
zh比如说这个
比如说这个
20:10.064–20:13.484
zhEKCVP这种参数的方式
EKCVP这种参数的方式
20:13.484–20:15.684
zh然后去做一个这个接收
然后去做一个这个接收
20:15.684–20:19.144
zh就是他会有这么一个机制
就是他会有这么一个机制
20:19.144–20:20.584
zh好
好
20:20.584–20:22.224
zh然后是 shell wrapper
然后是 shell wrapper
20:22.224–20:23.544
zh与复合的一些命令
与复合的一些命令
20:23.544–20:25.524
zh这个是用来干嘛的呢
这个是用来干嘛的呢
20:25.524–20:27.464
zh这个就是我们还可以包装一下
这个就是我们还可以包装一下
20:27.464–20:29.524
zh就是我们在 rules 里面
就是我们在 rules 里面
20:29.524–20:32.704
zh我们可以把整个命令做一个包装
我们可以把整个命令做一个包装
20:32.704–20:34.524
zh什么意思呢
什么意思呢
20:34.524–20:36.584
zh就是你现在要执行多个命令是吧
就是你现在要执行多个命令是吧
20:36.584–20:39.544
zh那我现在想把这个做个打包
那我现在想把这个做个打包
20:39.544–20:41.864
zh比如说提交文件删除
比如说提交文件删除
20:41.864–20:43.344
zh整个做一个打包
整个做一个打包
20:43.344–20:46.044
zh那么在这里面的话
那么在这里面的话
20:46.044–20:46.804
zh就相当于
就相当于
20:46.804–20:49.444
zh它单次操作的话
它单次操作的话
20:49.444–20:51.424
zh相当于把整个 mini 做一个执行
相当于把整个 mini 做一个执行
20:51.424–20:53.144
zh就这里面我们可以做一个封装
就这里面我们可以做一个封装
20:53.144–20:55.664
zh然后Codex的话
然后Codex的话
20:55.664–20:59.644
zh它什么时候可以去拆分一些脚本
它什么时候可以去拆分一些脚本
20:59.644–21:01.004
zh比如说
比如说
21:01.004–21:02.584
zh这个里面
这个里面
21:02.584–21:05.904
zh一些纯字面量的一些单词
一些纯字面量的一些单词
21:05.904–21:08.204
zh不包含变量展开的这种情况
不包含变量展开的这种情况
21:08.204–21:10.244
zh或者是一些
或者是一些
21:10.244–21:13.124
zh只通过安全运算服务的一些
只通过安全运算服务的一些
21:13.124–21:13.784
zh这个场景
这个场景
21:13.784–21:15.544
zh或者是一些
或者是一些
21:15.544–21:16.464
zh这个
这个
21:16.464–21:19.524
zh不同情况的
不同情况的
21:19.524–21:20.644
zh比如说下面这个
比如说下面这个
21:20.644–21:23.304
zh一些有规则的
一些有规则的
21:23.304–21:23.604
zh是吧
是吧
21:23.604–21:25.544
zh就都是安全的这种场景
就都是安全的这种场景
21:25.544–21:27.064
zh这个时候的话
这个时候的话
21:27.064–21:28.164
zh他就可以去
他就可以去
21:28.164–21:29.644
zh加一些这个
加一些这个
21:29.644–21:30.904
zh一些
一些
21:30.904–21:33.244
zh做一些安全的一些拆分
做一些安全的一些拆分
21:33.244–21:34.804
zh比如说把这些命令
比如说把这些命令
21:34.804–21:35.404
zh做一个拆分
做一个拆分
21:35.404–21:38.184
zh所以他会分别用你的 Rules
所以他会分别用你的 Rules
21:38.184–21:39.524
zh去评估每一条命令
去评估每一条命令
21:39.524–21:41.424
zh并且以最严格的
并且以最严格的
21:41.424–21:42.624
zh这个结果为准
这个结果为准
21:42.624–21:44.944
zh然后这里面的话
然后这里面的话
21:44.944–21:47.744
zh即使你允许这个partner
即使你允许这个partner
21:47.744–21:49.844
zh然后执行这个
然后执行这个
21:49.844–21:51.904
zh你写了这个东西的话
你写了这个东西的话
21:51.904–21:53.544
zh那他也不会自动放弃
那他也不会自动放弃
21:53.544–21:56.244
zh因为这个RM和RF
因为这个RM和RF
21:56.244–21:57.964
zh是一个非常危险的一个操作
是一个非常危险的一个操作
21:57.964–22:01.264
zh因为这个命令比较危险
因为这个命令比较危险
22:01.264–22:02.484
zh所以他会单独评估
所以他会单独评估
22:02.484–22:05.204
zh所以你写归你写
所以你写归你写
22:05.204–22:07.484
zh但是Codex他自己也有一套
但是Codex他自己也有一套
22:07.484–22:08.764
zh内置的一套规范
内置的一套规范
22:08.764–22:12.244
zh所以这种危险命令的话
所以这种危险命令的话
22:12.244–22:13.364
zh你混在一起的话
你混在一起的话
22:13.364–22:16.544
zh就违背了他的一个安全指令的一个要求
就违背了他的一个安全指令的一个要求
22:16.544–22:18.304
zh所以大家会发现
所以大家会发现
22:18.304–22:19.824
zh你不是你写所有命令
你不是你写所有命令
22:19.824–22:21.564
zh他都会给你放行的
他都会给你放行的
22:21.564–22:22.764
zh他也要去看情况
他也要去看情况
22:22.764–22:25.304
zh这个是Codex
这个是Codex
22:25.304–22:27.744
zh他可以做一些安全脚本的一个拆分
他可以做一些安全脚本的一个拆分
22:27.744–22:29.024
zh然后的话Codex
然后的话Codex
22:29.024–22:31.284
zh他什么情况下不会去拆分脚本呢
他什么情况下不会去拆分脚本呢
22:31.284–22:34.024
zh比如说我们已经加了一些重定向像的一些东西了
比如说我们已经加了一些重定向像的一些东西了
22:34.024–22:35.964
zh加了一些替换的表达式了
加了一些替换的表达式了
22:35.964–22:37.904
zh或者做了一些环境变量的一些复制了
或者做了一些环境变量的一些复制了
22:37.904–22:39.844
zh或者加了一些通配符了
或者加了一些通配符了
22:39.844–22:41.964
zh那这个就不会尝试去解析他
那这个就不会尝试去解析他
22:41.964–22:43.924
zh因为它本身就代表
因为它本身就代表
22:43.924–22:45.684
zh它的执行的一些关键点
它的执行的一些关键点
22:45.684–22:47.384
zh是一些规范
是一些规范
22:47.384–22:50.264
zh所以它就不会去拆分
所以它就不会去拆分
22:50.264–22:51.784
zh然后同时的话
然后同时的话
22:51.784–22:52.984
zh它就直接把它用过来
它就直接把它用过来
22:52.984–22:54.384
zh直接去运行的啊
直接去运行的啊
22:54.384–22:57.484
zh所以它也不是说你写了
所以它也不是说你写了
22:57.484–22:58.784
zh它就会帮你去拆分
它就会帮你去拆分
22:58.784–23:00.564
zh那它也要去看情况
那它也要去看情况
23:00.564–23:04.324
zh所以这种处理方式意味着
所以这种处理方式意味着
23:04.324–23:07.184
zh你就是在可以安全拆分的时候
你就是在可以安全拆分的时候
23:07.184–23:08.924
zhCodex会按照单条命令
Codex会按照单条命令
23:08.924–23:10.144
zh逐项的去评估
逐项的去评估
23:10.144–23:12.064
zh在不能安全拆分的时候
在不能安全拆分的时候
23:12.064–23:12.844
zh就是按照
就是按照
23:12.844–23:14.884
zh更加保守的一个方案
更加保守的一个方案
23:14.884–23:15.644
zh去做一个评估
去做一个评估
23:15.644–23:18.684
zh然后弄完之后的话
然后弄完之后的话
23:18.684–23:20.744
zh我们也可以去做一些测试
我们也可以去做一些测试
23:20.744–23:23.304
zh比如说我们把这个命令
比如说我们把这个命令
23:23.304–23:27.330
zh加到这里来可以看一下
加到这里来可以看一下
23:27.330–23:33.890
zh就是你可以去看一下这个规则到底有没有生效。
就是你可以去看一下这个规则到底有没有生效。
23:33.890–23:38.690
zh比如说我们这个规则,我们可以把它加进去。
比如说我们这个规则,我们可以把它加进去。
23:38.690–23:40.750
zh你看这个里面就找到了啊
你看这个里面就找到了啊
23:40.750–23:42.590
zh什么
什么
23:42.590–23:44.450
enCodex
Codex
23:44.450–23:45.330
enDefault
Default
23:45.330–23:47.150
enCheck
Check
23:47.150–23:49.890
zh当前的这个用户目标
当前的这个用户目标
23:49.890–23:52.690
zh但是我们没有这个规则是吧
但是我们没有这个规则是吧
23:52.690–23:55.830
zh这个当前用户目标没有建那个规则
这个当前用户目标没有建那个规则
23:55.830–23:59.350
zh所以这个里面我们得改一下啊
所以这个里面我们得改一下啊
23:59.350–24:02.250
zh这个就是当前目录的
这个就是当前目录的
24:02.250–24:03.330
enRules
Rules
24:03.330–24:05.330
zh点Rules
点Rules
24:05.330–24:08.690
zh这里我们就指定当前步
这里我们就指定当前步
24:08.690–24:11.650
zh然后来评估一下它的一些变化
然后来评估一下它的一些变化
24:11.650–24:29.910
zh来看一下
来看一下
24:29.910–24:32.410
zhPowerShell可以复制执行的一个命令
PowerShell可以复制执行的一个命令
24:32.410–24:35.670
zh你看他帮我们把命令做了一个优化
你看他帮我们把命令做了一个优化
24:35.670–24:39.010
zh来我们退出去执行一下
来我们退出去执行一下
24:39.010–24:45.790
zh这个里面有一个问题
这个里面有一个问题
24:45.790–25:02.410
enCodex
Codex
25:02.410–25:05.910
zh你看这个是他匹配的一个规则是吧
你看这个是他匹配的一个规则是吧
25:05.910–25:08.250
zh匹配的规则就是我们可以看得出来
匹配的规则就是我们可以看得出来
25:08.250–25:10.810
zh这个里面的话就相当于不被允许啊
这个里面的话就相当于不被允许啊
25:10.810–25:13.070
zh这就是他要有这个结论
这就是他要有这个结论
25:13.070–25:14.670
zh他可以分析出来
他可以分析出来
25:14.670–25:16.750
zh我们去执行这个命令的时候
我们去执行这个命令的时候
25:16.750–25:19.090
zh他给的这个决定就是拒绝了啊
他给的这个决定就是拒绝了啊
25:19.090–25:20.970
zh这就是测试规则文件
这就是测试规则文件
25:20.970–25:22.450
zh到底有没有写的有没有问题
到底有没有写的有没有问题
25:22.450–25:25.070
zh他默认的话会帮你输出一个
他默认的话会帮你输出一个
25:25.070–25:27.610
zhJSON格式的这么一个规则出来啊
JSON格式的这么一个规则出来啊
25:27.610–25:31.230
zh所以这个是我们做测试用的
所以这个是我们做测试用的
25:31.230–25:36.350
zh然后包括一些这些规则的一些语言啊
然后包括一些这些规则的一些语言啊
25:36.350–25:36.690
zh是吧
是吧
25:36.690–25:37.610
zh比如说
比如说
25:37.610–25:39.590
zh大家可以去看一下
大家可以去看一下
25:39.590–25:42.110
zh专门有一套语法啊
专门有一套语法啊
25:42.110–25:45.270
zh叫这个Specific的这么一个语法
叫这个Specific的这么一个语法
25:45.270–25:49.790
zh你看这个是专门的有一套规范啊
你看这个是专门的有一套规范啊
25:49.790–25:50.870
zh大家可以去看一下
大家可以去看一下
25:50.870–25:54.070
zh怎么来写这个东西
怎么来写这个东西
25:54.070–25:54.770
zh是吧
是吧
25:54.770–25:56.830
zh大家可以去看一下
大家可以去看一下
25:56.830–25:58.990
zh他是专门有一套规则语法的
他是专门有一套规则语法的
25:58.990–26:00.610
zh他是采用了这种方式
他是采用了这种方式
26:00.610–26:02.210
zh去写规则的
去写规则的
26:02.210–26:04.490
zh大家可以去参考一下
大家可以去参考一下
26:04.490–26:05.890
zh这是它的一个使用说明
这是它的一个使用说明
26:05.890–26:08.890
zh它的语法看起来有点像Python
它的语法看起来有点像Python
26:08.890–26:10.890
zh但是设计目标的话是安全执行
但是设计目标的话是安全执行
26:10.890–26:12.650
zh所以 Rules 的一个引擎
所以 Rules 的一个引擎
26:12.650–26:14.830
zh可以在不产生副作用的前例下
可以在不产生副作用的前例下
26:14.830–26:16.170
zh去运行它
去运行它
26:16.170–26:19.110
zh比如说它不会去触碰文件系统的一些逻辑
比如说它不会去触碰文件系统的一些逻辑
26:19.110–26:20.630
zh所以这个里面
所以这个里面
26:20.630–26:23.830
zh大家可以去看一下它的一个细节点
大家可以去看一下它的一个细节点
26:23.830–26:25.690
zh这个我们可以去
这个我们可以去
影片筆記:2026版AI+Codex零基础全套视频课程,Codex从入门到大神AI编程开发,涵盖安装配置、代码分析、Bug修复及完整项目实战 p08 7、Codex Rules 体系构建与代码可控性治理
一句話總結
本節課程介紹了 Codex 中的 Lulus 規範體系,旨在通過細粒度的規則配置(如 .lulus 文件),實現對代碼執行權限、命令執行(特別是沙箱外操作)的精確管控與安全治理,並解釋了其命令拆分評估機制與語法規範。
核心重點
- Lulus 規範體系定義:Lulus 是 Codex 內部用於控制「執行類」命令的規範體系,比項目結構規範更細粒度,主要用於管理沙箱外的命令執行權限。
- 配置與加載機制:
- 必須在項目根目錄創建
.lulus 目錄,並在該目錄下創建 .lulus 文件。
- Codex 優先掃描
.lulus 目錄加載規則;若結構錯誤(如僅創建文件未創建目錄),可能導致加載失敗或誤讀 agents.md。
- 權限管控策略:
- 支持三種決策類型:不提示 (No Prompt)、提示 (Prompt)、禁止 (Forbidden)。
- 命中規則後,需根據配置進行用戶確認或直接執行/拒絕。
- 即使設置為禁止,若命令涉及網絡訪問(如 GitHub 操作),仍可能觸發提權或額外授權流程。
- 命令評估與腳本拆分:
- Codex 將命令視為參數列表進行評估。
- 安全腳本拆分:對於純字面量、無變量展開的安全命令,Codex 會將其拆分為單條命令分別評估,並以最嚴格結果為準。
- 保守執行:若命令包含變量展開、環境變量替換、通配符或不安全因素,則不拆分,採取保守方案直接運行。
- 測試與語法:
- 提供測試規則生效的方法,Codex 會輸出 JSON 格式的評估結果。
- Lulus 採用類似 Python 但專為安全執行設計的語法,旨在無副作用下運行。
詳細大綱
一、 Lulus 規範體系概述
- 定位:屬於細節規範,針對「執行類」命令,特別是沙箱外的命令執行。
- 應用場景:
- 運行代碼、運行 Case、自動化測試。
- 涉及刪除文件、調用工具等可能影響權限的操作。
二、 Lulus 的配置與加載
- 文件結構要求:
- 項目根目錄需創建
.lulus 目錄。
- 目錄內需創建
.lulus 文件。
- 若僅創建文件而未創建目錄,加載可能失敗,需確保目錄結構正確並重啟。
- 加載邏輯:
- Codex 優先掃描
.lulus 目錄。
- 支持全局規則與項目級別規則(用戶級別、項目級別)。
- 若配置錯誤,Codex 可能錯誤讀取
agents.md 而非 .lulus 內容。
三、 權限管控與匹配規則
- 匹配機制:
- 基於命令前綴或精確匹配(如
GHPRVU 開頭的命令)。
- 若不匹配規則,但涉及網絡訪問(如訪問 GitHub),仍可能觸發網絡權限申請或提權流程。
- 決策類型 (Decision):
- 不提示 (No Prompt):直接在沙箱環境下執行。
- 提示 (Prompt):每次命中規則時,需用戶確認請求。
- 禁止 (Forbidden):直接拒絕該命令執行。
- 權限互動邏輯:
- 即使設置為
Forbidden,若命令涉及網絡訪問且沙箱受限,Codex 可能會嘗試「提權」或額外授權申請。
- 若命令僅為查詢且不涉及修改風險,默認可能放行。
- 最終執行結果取決於具體場景及環境權限需求。
四、 命令評估與腳本拆分
- 命令解析:
- Codex 將命令看作參數列表(如
EKCVP 參數方式)進行接收和評估。
- 安全腳本拆分 (Safe Script Splitting):
- 拆分條件:純字面量單詞、不包含變量展開、僅通過安全運算服務、有規則的安全場景。
- 拆分邏輯:將複合命令拆分為單條命令,分別用 Lulus 評估,並以最嚴格的結果為準。
- 不拆分條件:包含重令像、替換表達式、環境變量複製、通配符等,代表執行關鍵點為規範,採取保守方案直接運行。
- 危險命令處理:
- 如
RM、RF 等刪除文件命令,即使混在允許的規則中,Codex 也會單獨評估,因其屬於危險操作,可能違背安全指令要求。
五、 測試與語法規範
- 規則測試:
- 可通過特定指令測試規則是否生效,Codex 會輸出 JSON 格式的規則評估結果。
- 用於驗證規則文件編寫是否正確,以及命令是否被拒絕或允許。
- Lulus 語法:
- 採用專門的語法規範(提及
Specific 語法)。
- 設計目標為安全執行,類似 Python 語法風格。
- 引擎設計為在不產生副作用(如不觸碰文件系統邏輯)的前提下運行。
工具 / 模型 / 名詞整理
- Codex:影片討論的主體產品/模型。
- Lulus:Codex 內部的規範體系或組件名稱(逐字稿中多次出現,部分語境下聽似 "Lulis" 或 "Glueless",但核心指代此規範體系)。
- GHPRVU:逐字稿中提到的命令前綴或示例命令。
- GonRepo:逐字稿中提到的另一個命令示例,用於對比匹配規則。
- agents.md:Codex 可能默認讀取的配置文件,若
.lulus 配置錯誤可能被誤讀。
- PowerShell:逐字稿中提到的執行環境或命令類型。
- JSON:規則測試輸出的格式。
- Specific 語法:逐字稿中提到 "專門有一套語法叫這個 Specific 的這麼一個語法"。
操作流程整理
- 創建規範目錄結構:
- 在項目根目錄創建
.lulus 目錄。
- 在
.lulus 目錄下創建 .lulus 文件。
- 配置權限規則:
- 在
.lulus 文件中定義命令匹配規則(如前綴匹配)。
- 設置決策類型:
No Prompt、Prompt 或 Forbidden。
- 驗證配置:
- 確保目錄結構正確,避免 Codex 誤讀
agents.md。
- 重啟 Codex 以加載新規則。
- 測試規則生效:
- 執行特定指令測試規則。
- 檢查 Codex 輸出的 JSON 格式評估結果,確認命令是被拒絕、允許還是需要確認。
- 執行命令:
- Codex 解析命令為參數列表。
- 根據命令內容判斷是否進行「安全腳本拆分」。
- 若拆分,分別評估並取最嚴格結果;若不拆分,直接保守運行。
- 若命中規則,根據配置執行提示確認或直接執行/拒絕。
值得注意的限制或風險
- 配置結構錯誤風險:若僅創建
.lulus 文件而未創建對應目錄,Codex 可能無法正確加載規則,甚至誤讀 agents.md,導致安全策略失效。
- 網絡訪問的權限互動:即使設置了
Forbidden,若命令涉及網絡訪問(如 GitHub 操作),Codex 仍可能嘗試「提權」或額外授權,這可能與預期行為不符。
- 命令拆分的不確定性:對於包含變量展開、環境變量替換、通配符或「重令像」的命令,Codex 採取保守方案不拆分,這可能導致複雜命令的安全評估不夠精細。
- 危險命令的單獨評估:刪除文件等危險命令(如
RM、RF)會被單獨評估,即使它們混在允許的規則中,這可能導致預期外的拒絕行為。
逐字稿辨識疑點
- Codex Lulers / Lulis / Lulus / Glueless:逐字稿中對該規範體系的稱呼不一致,分別出現過 "Codex Lulers"、"Lurus"、"Lulis"、"Glueless"、"Lulus"。根據上下文,核心指代應為 "Lulus" 或 "Lulis",但存在聽寫混亂。
- GHPRVU / GHPR:逐字稿中提到的命令前綴,疑似為
gh (GitHub CLI) 相關命令的聽寫錯誤,但無法確定具體命令,標為疑點。
- GonRepo:逐字稿中提到的命令,疑似為
gh repo 的聽寫錯誤,標為疑點。
- EKCVP:逐字稿中提到的參數方式,疑似為
--key=value 或類似參數格式的聽寫錯誤,標為疑點。
- prodx:逐字稿中提到的測試項目名稱,疑似為
prod 或某個具體開源項目名的聽寫錯誤,標為疑點。
- gitty:逐字稿中提到的項目來源,疑似為
GitHub 的聽寫錯誤,標為疑點。
- Specific 語法:逐字稿中提到 "專門有一套語法叫這個 Specific 的這麼一個語法",需查證是否為特定名稱或聽寫錯誤。
- 殺箱 / 沙箱:逐字稿中交替使用 "殺箱" 和 "沙箱",應為 "沙箱" (Sandbox) 的聽寫錯誤,但保留原文記錄。
- 提權 / 提現 / 收取:逐字稿中描述權限流程時,出現 "提權"、"提現"、"收取",應均指 "提權" (Privilege Escalation/Authorization) 的聽寫錯誤。
- 貧固:逐字稿中提到 "按照更加保守的一個方案去做一個貧固",應為 "保護" 或 "固化" 的聽寫錯誤,標為疑點。
- 通費符:逐字稿中提到 "加了一些通費符了",應為 "通配符" 的聽寫錯誤,標為疑點。
- 重令像:逐字稿中提到 "加了一些重令像的一些東西了",應為 "正則" 或 "變量" 相關詞彙的聽寫錯誤,標為疑點。
可延伸追問
- Lulus 規範體系與 Codex 其他規則(如
agents.md)的優先級和衝突解決機制是什麼?
- 如何具體編寫
.lulus 文件中的語法,以實現精確的命令匹配和權限控制?
- 在什麼具體場景下,Codex 會選擇「安全腳本拆分」,而在什麼情況下會選擇「保守執行」?
- 如何通過 JSON 測試結果來調試和優化 Lulus 規則配置?
尚未產生學習筆記
請在 Telegram 指令最後加上「學習」,例如:videonote 網址 英文 雙語 學習