@memnexus-ai/mx-agent-cli 0.1.269 → 0.1.270
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/__tests__/codex-deploy-config.test.d.ts +2 -0
- package/dist/__tests__/codex-deploy-config.test.d.ts.map +1 -0
- package/dist/__tests__/codex-deploy-config.test.js +1170 -0
- package/dist/__tests__/codex-deploy-config.test.js.map +1 -0
- package/dist/__tests__/codex-trust-keys.test.d.ts +2 -0
- package/dist/__tests__/codex-trust-keys.test.d.ts.map +1 -0
- package/dist/__tests__/codex-trust-keys.test.js +731 -0
- package/dist/__tests__/codex-trust-keys.test.js.map +1 -0
- package/dist/__tests__/codex-write-race.test.d.ts +2 -0
- package/dist/__tests__/codex-write-race.test.d.ts.map +1 -0
- package/dist/__tests__/codex-write-race.test.js +372 -0
- package/dist/__tests__/codex-write-race.test.js.map +1 -0
- package/dist/__tests__/runtime-codex-guard-proof.test.js +75 -0
- package/dist/__tests__/runtime-codex-guard-proof.test.js.map +1 -1
- package/dist/commands/codex-deploy-config.d.ts +111 -0
- package/dist/commands/codex-deploy-config.d.ts.map +1 -0
- package/dist/commands/codex-deploy-config.js +400 -0
- package/dist/commands/codex-deploy-config.js.map +1 -0
- package/dist/commands/codex-prove-guards.d.ts +20 -0
- package/dist/commands/codex-prove-guards.d.ts.map +1 -1
- package/dist/commands/codex-prove-guards.js +54 -1
- package/dist/commands/codex-prove-guards.js.map +1 -1
- package/dist/commands/codex-trust-keys.d.ts +12 -0
- package/dist/commands/codex-trust-keys.d.ts.map +1 -0
- package/dist/commands/codex-trust-keys.js +169 -0
- package/dist/commands/codex-trust-keys.js.map +1 -0
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +65 -0
- package/dist/index.js.map +1 -1
- package/dist/lib/runtime/codex-adapter.d.ts.map +1 -1
- package/dist/lib/runtime/codex-adapter.js +15 -15
- package/dist/lib/runtime/codex-adapter.js.map +1 -1
- package/dist/lib/runtime/codex-config.d.ts +211 -0
- package/dist/lib/runtime/codex-config.d.ts.map +1 -1
- package/dist/lib/runtime/codex-config.js +769 -40
- package/dist/lib/runtime/codex-config.js.map +1 -1
- package/dist/lib/runtime/codex-hooks-list.d.ts +91 -0
- package/dist/lib/runtime/codex-hooks-list.d.ts.map +1 -0
- package/dist/lib/runtime/codex-hooks-list.js +418 -0
- package/dist/lib/runtime/codex-hooks-list.js.map +1 -0
- package/dist/lib/runtime/codex-trust-keys.d.ts +95 -0
- package/dist/lib/runtime/codex-trust-keys.d.ts.map +1 -0
- package/dist/lib/runtime/codex-trust-keys.js +279 -0
- package/dist/lib/runtime/codex-trust-keys.js.map +1 -0
- package/package.json +1 -1
|
@@ -0,0 +1,731 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Hook-trust key enumeration and REAL hash verification (#4876, closes
|
|
3
|
+
* KI-CODEX-TRUST-HASH-NOT-VERIFIED).
|
|
4
|
+
*
|
|
5
|
+
* ─── THE TWO DEFECTS UNDER TEST ───────────────────────────────────────────────
|
|
6
|
+
* 1. A STALE GRANT READ AS TRUST. `codexHookTrustPreconditions` accepted any non-empty
|
|
7
|
+
* `trusted_hash`. Codex does not run an entry whose hash stopped matching, and it
|
|
8
|
+
* says nothing when it declines — so the guards went inert while every check we own
|
|
9
|
+
* reported green. The test named "a stale hash is NOT trust" is the mutation canary:
|
|
10
|
+
* remove the comparison and it fails.
|
|
11
|
+
* 2. THE DOUBLE PREFIX. `hooks/list` returns `currentHash` ALREADY carrying `sha256:`.
|
|
12
|
+
* A record written as `sha256:sha256:<hex>` is never matched, and the failure is
|
|
13
|
+
* silent in the same direction. The pasteable block is asserted to reproduce the
|
|
14
|
+
* observed value verbatim and to contain no doubled prefix.
|
|
15
|
+
*
|
|
16
|
+
* The `hooks/list` payload in these tests is the SHAPE OBSERVED LIVE on codex-cli
|
|
17
|
+
* 0.145.0 (2026-08-02): `result.data[].hooks[]` with key, currentHash, trustStatus,
|
|
18
|
+
* sourcePath, enabled — and, per OpenAI bug #27133, every `sourcePath` is the MAIN
|
|
19
|
+
* repo's file even when the query names a worktree cwd.
|
|
20
|
+
*/
|
|
21
|
+
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
|
|
22
|
+
import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'fs';
|
|
23
|
+
import { createHash } from 'crypto';
|
|
24
|
+
import { join } from 'path';
|
|
25
|
+
import { tmpdir } from 'os';
|
|
26
|
+
import { fileURLToPath } from 'url';
|
|
27
|
+
import { CODEX_HOOKS_FILENAME, buildCodexHooksJson, codexHookTrustKeysForDoc, codexHookTrustPreconditions, readCodexTrustState, readDeployedHooksDoc, } from '../lib/runtime/codex-config.js';
|
|
28
|
+
import { carryOverHashes, observedHashesByKey, parseHooksListResponse, queryCodexHooksList, splitTrustKey, } from '../lib/runtime/codex-hooks-list.js';
|
|
29
|
+
import { CODEX_HASH_SHAPE, buildTrustKeyReport, shaCodexHooksFiles, trustGrantToml, } from '../lib/runtime/codex-trust-keys.js';
|
|
30
|
+
import { renderTrustKeyReport } from '../commands/codex-trust-keys.js';
|
|
31
|
+
let mainRepo;
|
|
32
|
+
let worktree;
|
|
33
|
+
let codexHome;
|
|
34
|
+
/** A real 71-character Codex hash shape: `sha256:` + 64 hex. */
|
|
35
|
+
const HASH = (seed) => `sha256:${createHash('sha256').update(seed).digest('hex')}`;
|
|
36
|
+
function deployHooks(dir) {
|
|
37
|
+
mkdirSync(join(dir, '.codex'), { recursive: true });
|
|
38
|
+
writeFileSync(join(dir, CODEX_HOOKS_FILENAME), buildCodexHooksJson({ worktreePath: dir }));
|
|
39
|
+
}
|
|
40
|
+
function keysFor(dir) {
|
|
41
|
+
return codexHookTrustKeysForDoc(join(dir, CODEX_HOOKS_FILENAME), readDeployedHooksDoc(dir));
|
|
42
|
+
}
|
|
43
|
+
/** `hooks/list` entries as Codex reports them: main-repo sourcePath only (#27133). */
|
|
44
|
+
function liveEntries(over = {}) {
|
|
45
|
+
return keysFor(mainRepo).map((key) => ({
|
|
46
|
+
key,
|
|
47
|
+
currentHash: over[key] ?? HASH(key.split(':').slice(-3).join(':')),
|
|
48
|
+
trustStatus: 'trusted',
|
|
49
|
+
sourcePath: join(mainRepo, CODEX_HOOKS_FILENAME),
|
|
50
|
+
enabled: true,
|
|
51
|
+
}));
|
|
52
|
+
}
|
|
53
|
+
function writeConfig(sections) {
|
|
54
|
+
mkdirSync(codexHome, { recursive: true });
|
|
55
|
+
writeFileSync(join(codexHome, 'config.toml'), sections);
|
|
56
|
+
}
|
|
57
|
+
/** Grant every key of both files, with the hashes `hooks/list` would report. */
|
|
58
|
+
function grantAll(over = {}) {
|
|
59
|
+
const observed = new Map(liveEntries().map((e) => [e.key, e.currentHash]));
|
|
60
|
+
const carried = carryOverHashes(observed, join(mainRepo, CODEX_HOOKS_FILENAME), join(worktree, CODEX_HOOKS_FILENAME));
|
|
61
|
+
const all = new Map([...observed, ...carried]);
|
|
62
|
+
writeConfig(`[projects."${mainRepo}"]\ntrust_level = "trusted"\n\n` +
|
|
63
|
+
`[projects."${worktree}"]\ntrust_level = "trusted"\n\n` +
|
|
64
|
+
[...all]
|
|
65
|
+
.map(([k, h]) => `[hooks.state."${k}"]\nenabled = true\ntrusted_hash = "${over[k] ?? h}"\n`)
|
|
66
|
+
.join('\n'));
|
|
67
|
+
}
|
|
68
|
+
const report = (entries) => buildTrustKeyReport({
|
|
69
|
+
worktreePath: worktree,
|
|
70
|
+
mainRepoPath: mainRepo,
|
|
71
|
+
codexHome,
|
|
72
|
+
hooksList: { ok: true, entries: entries ?? liveEntries() },
|
|
73
|
+
});
|
|
74
|
+
beforeEach(() => {
|
|
75
|
+
mainRepo = mkdtempSync(join(tmpdir(), 'mx-tk-main-'));
|
|
76
|
+
worktree = mkdtempSync(join(tmpdir(), 'mx-tk-wt-'));
|
|
77
|
+
codexHome = mkdtempSync(join(tmpdir(), 'mx-tk-home-'));
|
|
78
|
+
deployHooks(mainRepo);
|
|
79
|
+
deployHooks(worktree);
|
|
80
|
+
});
|
|
81
|
+
afterEach(() => {
|
|
82
|
+
for (const d of [mainRepo, worktree, codexHome])
|
|
83
|
+
rmSync(d, { recursive: true, force: true });
|
|
84
|
+
});
|
|
85
|
+
describe('hooks/list parsing — fail closed on every shape it cannot read', () => {
|
|
86
|
+
const envelope = (hooks) => [
|
|
87
|
+
'{"jsonrpc":"2.0","id":1,"result":{}}',
|
|
88
|
+
'not json at all',
|
|
89
|
+
JSON.stringify({ jsonrpc: '2.0', id: 2, result: { data: [{ cwd: '/x', hooks }] } }),
|
|
90
|
+
].join('\n');
|
|
91
|
+
it('reads key, currentHash, trustStatus and sourcePath from the live shape', () => {
|
|
92
|
+
const result = parseHooksListResponse(envelope([
|
|
93
|
+
{
|
|
94
|
+
key: '/workspace/.codex/hooks.json:pre_tool_use:0:0',
|
|
95
|
+
currentHash: HASH('a'),
|
|
96
|
+
trustStatus: 'trusted',
|
|
97
|
+
sourcePath: '/workspace/.codex/hooks.json',
|
|
98
|
+
enabled: true,
|
|
99
|
+
},
|
|
100
|
+
]));
|
|
101
|
+
expect(result.ok).toBe(true);
|
|
102
|
+
if (!result.ok)
|
|
103
|
+
return;
|
|
104
|
+
expect(result.entries[0]?.key).toBe('/workspace/.codex/hooks.json:pre_tool_use:0:0');
|
|
105
|
+
expect(result.entries[0]?.currentHash).toMatch(CODEX_HASH_SHAPE);
|
|
106
|
+
expect(result.entries[0]?.sourcePath).toBe('/workspace/.codex/hooks.json');
|
|
107
|
+
});
|
|
108
|
+
/**
|
|
109
|
+
* An empty `data` array is what Codex returns for an UNTRUSTED project. Reading it as
|
|
110
|
+
* "no hooks, nothing to check" would turn the single most important negative result
|
|
111
|
+
* into a green one.
|
|
112
|
+
*/
|
|
113
|
+
it('an empty result set is an ERROR naming project trust, not an empty success', () => {
|
|
114
|
+
const result = parseHooksListResponse('{"jsonrpc":"2.0","id":2,"result":{"data":[]}}');
|
|
115
|
+
expect(result.ok).toBe(false);
|
|
116
|
+
expect(result.ok === false && result.error).toMatch(/UNTRUSTED project/);
|
|
117
|
+
});
|
|
118
|
+
it('no response, a JSON-RPC error, and a missing currentHash are all refusals', () => {
|
|
119
|
+
expect(parseHooksListResponse('').ok).toBe(false);
|
|
120
|
+
const rpcError = parseHooksListResponse('{"jsonrpc":"2.0","id":2,"error":{"code":-1,"message":"nope"}}');
|
|
121
|
+
expect(rpcError.ok === false && rpcError.error).toMatch(/JSON-RPC error/);
|
|
122
|
+
const noHash = parseHooksListResponse(envelope([{ key: 'k:pre_tool_use:0:0' }]));
|
|
123
|
+
expect(noHash.ok).toBe(false);
|
|
124
|
+
expect(noHash.ok === false && noHash.error).toMatch(/do not hand-write a hash/);
|
|
125
|
+
});
|
|
126
|
+
it('splitTrustKey separates the file path from the event/group/hook suffix', () => {
|
|
127
|
+
expect(splitTrustKey('/a/b/.codex/hooks.json:pre_tool_use:2:0')).toEqual({
|
|
128
|
+
hooksPath: '/a/b/.codex/hooks.json',
|
|
129
|
+
suffix: 'pre_tool_use:2:0',
|
|
130
|
+
});
|
|
131
|
+
expect(splitTrustKey('nonsense')).toBeNull();
|
|
132
|
+
});
|
|
133
|
+
/**
|
|
134
|
+
* SF-1. `data:[null]` and `data:[42]` reached `.hooks` on a non-object and threw a
|
|
135
|
+
* TypeError, uncaught, through `queryCodexHooksList`, `buildTrustKeyReport` and both
|
|
136
|
+
* commands — so the operator got a stack trace where `prove-guards` should have
|
|
137
|
+
* printed its refusal. Nothing from another process throws out of this parser.
|
|
138
|
+
*/
|
|
139
|
+
it('a malformed data array is a refusal, never a thrown TypeError', () => {
|
|
140
|
+
for (const payload of ['{"id":2,"result":{"data":[null]}}', '{"id":2,"result":{"data":[42]}}']) {
|
|
141
|
+
let result;
|
|
142
|
+
expect(() => {
|
|
143
|
+
result = parseHooksListResponse(payload);
|
|
144
|
+
}).not.toThrow();
|
|
145
|
+
expect(result.ok).toBe(false);
|
|
146
|
+
}
|
|
147
|
+
});
|
|
148
|
+
/**
|
|
149
|
+
* The try/catch is around the WHOLE parse, not one field, so a shape nobody
|
|
150
|
+
* anticipated still returns a refusal. These are the shapes a fuzzed or
|
|
151
|
+
* version-shifted response can take; none may escape as an exception.
|
|
152
|
+
*/
|
|
153
|
+
it('every odd top-level shape returns a refusal rather than throwing', () => {
|
|
154
|
+
for (const payload of [
|
|
155
|
+
'{"id":2,"result":{"data":[[]]}}',
|
|
156
|
+
'{"id":2,"result":{"data":[{"hooks":[null]}]}}',
|
|
157
|
+
'{"id":2,"result":{"data":[{"hooks":"not an array"}]}}',
|
|
158
|
+
'{"id":2,"result":{"data":{"not":"an array"}}}',
|
|
159
|
+
'{"id":2,"result":null}',
|
|
160
|
+
'{"id":2}',
|
|
161
|
+
]) {
|
|
162
|
+
let result;
|
|
163
|
+
expect(() => {
|
|
164
|
+
result = parseHooksListResponse(payload);
|
|
165
|
+
}, payload).not.toThrow();
|
|
166
|
+
expect(result?.ok, payload).toBe(false);
|
|
167
|
+
}
|
|
168
|
+
});
|
|
169
|
+
/**
|
|
170
|
+
* SF-2. `observedHashesByKey` builds a Map, so a later duplicate silently replaced an
|
|
171
|
+
* earlier one — a second entry for a key could shadow the real hash and turn a
|
|
172
|
+
* `stale-hash` verdict into `granted`. Two answers to one JSON-RPC id had the same
|
|
173
|
+
* last-wins shape at the response level.
|
|
174
|
+
*/
|
|
175
|
+
it('refuses a duplicate key whose hash DIFFERS, and tolerates an identical repeat', () => {
|
|
176
|
+
const dup = (hashB) => JSON.stringify({
|
|
177
|
+
id: 2,
|
|
178
|
+
result: {
|
|
179
|
+
data: [
|
|
180
|
+
{
|
|
181
|
+
hooks: [
|
|
182
|
+
{ key: '/w/.codex/hooks.json:pre_tool_use:0:0', currentHash: HASH('a'), sourcePath: '/w/.codex/hooks.json' },
|
|
183
|
+
{ key: '/w/.codex/hooks.json:pre_tool_use:0:0', currentHash: hashB, sourcePath: '/w/.codex/hooks.json' },
|
|
184
|
+
],
|
|
185
|
+
},
|
|
186
|
+
],
|
|
187
|
+
},
|
|
188
|
+
});
|
|
189
|
+
const conflicting = parseHooksListResponse(dup(HASH('b')));
|
|
190
|
+
expect(conflicting.ok).toBe(false);
|
|
191
|
+
expect(conflicting.ok === false && conflicting.error).toMatch(/two DIFFERENT hashes for the same key/);
|
|
192
|
+
const identical = parseHooksListResponse(dup(HASH('a')));
|
|
193
|
+
expect(identical.ok).toBe(true);
|
|
194
|
+
expect(identical.ok === true && identical.entries).toHaveLength(1);
|
|
195
|
+
});
|
|
196
|
+
it('refuses a stream carrying two responses to the same request id', () => {
|
|
197
|
+
const one = (hash) => JSON.stringify({
|
|
198
|
+
id: 2,
|
|
199
|
+
result: { data: [{ hooks: [{ key: '/w/.codex/hooks.json:pre_tool_use:0:0', currentHash: hash, sourcePath: '/w/.codex/hooks.json' }] }] },
|
|
200
|
+
});
|
|
201
|
+
const result = parseHooksListResponse(`${one(HASH('a'))}\n${one(HASH('b'))}`);
|
|
202
|
+
expect(result.ok).toBe(false);
|
|
203
|
+
expect(result.ok === false && result.error).toMatch(/more than one response to hooks\/list/);
|
|
204
|
+
});
|
|
205
|
+
/**
|
|
206
|
+
* SF-3. `sourcePath` was captured and never compared to the key it arrived with, so an
|
|
207
|
+
* entry claiming a foreign source file was recorded as a direct observation of the key
|
|
208
|
+
* it names. It is also this module's evidence for #27133 — the claim about WHICH file
|
|
209
|
+
* Codex resolved — which the check restores.
|
|
210
|
+
*/
|
|
211
|
+
it('refuses an entry whose sourcePath is not the key\'s own file', () => {
|
|
212
|
+
const result = parseHooksListResponse(JSON.stringify({
|
|
213
|
+
id: 2,
|
|
214
|
+
result: {
|
|
215
|
+
data: [
|
|
216
|
+
{
|
|
217
|
+
hooks: [
|
|
218
|
+
{
|
|
219
|
+
key: '/w/.codex/hooks.json:pre_tool_use:0:0',
|
|
220
|
+
currentHash: HASH('a'),
|
|
221
|
+
sourcePath: '/somewhere/else/.codex/hooks.json',
|
|
222
|
+
},
|
|
223
|
+
],
|
|
224
|
+
},
|
|
225
|
+
],
|
|
226
|
+
},
|
|
227
|
+
}));
|
|
228
|
+
expect(result.ok).toBe(false);
|
|
229
|
+
expect(result.ok === false && result.error).toMatch(/keyed on .* but sourced from/);
|
|
230
|
+
});
|
|
231
|
+
/**
|
|
232
|
+
* MUST FIX 3 (security review, executed). An ABSENT or non-string `sourcePath` skipped
|
|
233
|
+
* the provenance check entirely and the entry was recorded as a DIRECT observation.
|
|
234
|
+
* That is fail-open in the one direction that matters: `buildTrustKeyReport` treats any
|
|
235
|
+
* direct observation of a file as proof Codex saw that file, which switches off the
|
|
236
|
+
* byte-identity precondition on the carry-over — so an entry with no provenance at all
|
|
237
|
+
* could grade `granted`. Codex reports `sourcePath` on every entry (verified live on
|
|
238
|
+
* 0.145.0), so its absence is a shape we have never seen from Codex.
|
|
239
|
+
*/
|
|
240
|
+
it('refuses an entry with NO sourcePath — absent provenance is not provenance', () => {
|
|
241
|
+
for (const sourcePath of [undefined, null, 99]) {
|
|
242
|
+
const result = parseHooksListResponse(JSON.stringify({
|
|
243
|
+
id: 2,
|
|
244
|
+
result: {
|
|
245
|
+
data: [
|
|
246
|
+
{
|
|
247
|
+
hooks: [
|
|
248
|
+
{
|
|
249
|
+
key: '/w/.codex/hooks.json:pre_tool_use:0:0',
|
|
250
|
+
currentHash: HASH('a'),
|
|
251
|
+
...(sourcePath === undefined ? {} : { sourcePath }),
|
|
252
|
+
},
|
|
253
|
+
],
|
|
254
|
+
},
|
|
255
|
+
],
|
|
256
|
+
},
|
|
257
|
+
}));
|
|
258
|
+
expect(result.ok, `sourcePath ${String(sourcePath)}`).toBe(false);
|
|
259
|
+
expect(result.ok === false && result.error).toMatch(/with NO sourcePath/);
|
|
260
|
+
}
|
|
261
|
+
});
|
|
262
|
+
/**
|
|
263
|
+
* The same fail-open reached the report: an unprovenanced entry keyed on the WORKTREE
|
|
264
|
+
* file made `hasDirect` true there, so the byte-identity check that gates the
|
|
265
|
+
* carry-over never ran, and the row graded `granted` off a hash nothing corroborated.
|
|
266
|
+
* The refusal above is what stops it — and this asserts the outcome, not the mechanism.
|
|
267
|
+
*/
|
|
268
|
+
it('an unprovenanced entry keyed on the worktree file cannot grade granted', () => {
|
|
269
|
+
const wtHooks = join(worktree, CODEX_HOOKS_FILENAME);
|
|
270
|
+
const key = `${wtHooks}:pre_tool_use:0:0`;
|
|
271
|
+
const hooksList = parseHooksListResponse(JSON.stringify({ id: 2, result: { data: [{ hooks: [{ key, currentHash: HASH('a') }] }] } }));
|
|
272
|
+
expect(hooksList.ok).toBe(false);
|
|
273
|
+
writeConfig(`[hooks.state."${key}"]\nenabled = true\ntrusted_hash = "${HASH('a')}"\n`);
|
|
274
|
+
const built = buildTrustKeyReport({
|
|
275
|
+
worktreePath: worktree,
|
|
276
|
+
mainRepoPath: mainRepo,
|
|
277
|
+
codexHome,
|
|
278
|
+
hooksList,
|
|
279
|
+
});
|
|
280
|
+
expect(built.ok).toBe(false);
|
|
281
|
+
expect(built.sets.flatMap((s) => s.rows).some((r) => r.status === 'granted')).toBe(false);
|
|
282
|
+
});
|
|
283
|
+
/**
|
|
284
|
+
* MUST FIX 2, layer one (security review, CVSS 8.2, executed). Trust keys are written
|
|
285
|
+
* into TOML table headers in the block an operator is told to paste into
|
|
286
|
+
* `~/.codex/config.toml`. A key carrying `"` and a newline closes that header and opens
|
|
287
|
+
* one of its own; the reviewer's payload produced `[projects."/workspace"]
|
|
288
|
+
* trust_level = "trusted"`. A key of that shape is not something to render carefully —
|
|
289
|
+
* it is not a fact about our configuration, and it never enters `entries`.
|
|
290
|
+
*/
|
|
291
|
+
it('refuses a key that is not <path>:<event>:<group>:<index>, quote or newline included', () => {
|
|
292
|
+
const evil = '/w/.codex/hooks.json:p:0:0"\nenabled = true\n\n[projects."/workspace"]\ntrust_level = "trusted"\n\n[hooks.state."x';
|
|
293
|
+
for (const key of [
|
|
294
|
+
evil,
|
|
295
|
+
'/w/.codex/hooks.json:PreToolUse:0:0',
|
|
296
|
+
'/w/.codex/hooks.json:pre_tool_use:0',
|
|
297
|
+
'/w/.codex/hooks.json:pre_tool_use:0:x',
|
|
298
|
+
'abc',
|
|
299
|
+
]) {
|
|
300
|
+
const result = parseHooksListResponse(JSON.stringify({
|
|
301
|
+
id: 2,
|
|
302
|
+
result: {
|
|
303
|
+
data: [
|
|
304
|
+
{ hooks: [{ key, currentHash: HASH('a'), sourcePath: '/w/.codex/hooks.json' }] },
|
|
305
|
+
],
|
|
306
|
+
},
|
|
307
|
+
}));
|
|
308
|
+
expect(result.ok, key).toBe(false);
|
|
309
|
+
expect(result.ok === false && result.error).toMatch(/not of the form|quote, backslash/);
|
|
310
|
+
}
|
|
311
|
+
});
|
|
312
|
+
/**
|
|
313
|
+
* SF-5. `r.status` was never inspected and stderr was captured and dropped, so a
|
|
314
|
+
* non-zero exit with parseable stdout was accepted as an answer, and the commonest
|
|
315
|
+
* failure of all — no `codex` on PATH — surfaced as "produced no response to
|
|
316
|
+
* hooks/list", which sends an operator to check project trust instead of their install.
|
|
317
|
+
*/
|
|
318
|
+
it('refuses a non-zero exit even when stdout parses, and carries stderr', () => {
|
|
319
|
+
const good = JSON.stringify({
|
|
320
|
+
id: 2,
|
|
321
|
+
result: { data: [{ hooks: [{ key: '/w/.codex/hooks.json:pre_tool_use:0:0', currentHash: HASH('a') }] }] },
|
|
322
|
+
});
|
|
323
|
+
const result = queryCodexHooksList({
|
|
324
|
+
cwd: '/w',
|
|
325
|
+
exec: () => ({ stdout: good, status: 1, stderr: 'panicked at codex\nbacktrace' }),
|
|
326
|
+
});
|
|
327
|
+
expect(result.ok).toBe(false);
|
|
328
|
+
expect(result.ok === false && result.error).toMatch(/exited 1/);
|
|
329
|
+
expect(result.ok === false && result.error).toContain('backtrace');
|
|
330
|
+
});
|
|
331
|
+
it('names a missing codex binary as a missing install, not as an empty answer', () => {
|
|
332
|
+
const result = queryCodexHooksList({
|
|
333
|
+
cwd: '/w',
|
|
334
|
+
exec: () => ({ stdout: '', status: 127, stderr: 'bash: line 1: codex: command not found' }),
|
|
335
|
+
});
|
|
336
|
+
expect(result.ok).toBe(false);
|
|
337
|
+
expect(result.ok === false && result.error).toMatch(/not found on PATH/);
|
|
338
|
+
expect(result.ok === false && result.error).not.toMatch(/UNTRUSTED project/);
|
|
339
|
+
});
|
|
340
|
+
it('reports a timeout kill and a signal kill distinctly', () => {
|
|
341
|
+
const timedOut = queryCodexHooksList({ cwd: '/w', exec: () => ({ stdout: '', status: 124, stderr: '' }) });
|
|
342
|
+
expect(timedOut.ok === false && timedOut.error).toMatch(/timed out/);
|
|
343
|
+
const signalled = queryCodexHooksList({ cwd: '/w', exec: () => ({ stdout: '', status: null, stderr: '' }) });
|
|
344
|
+
expect(signalled.ok === false && signalled.error).toMatch(/killed by a signal/);
|
|
345
|
+
});
|
|
346
|
+
/**
|
|
347
|
+
* SF-4. `spawnSync`'s own timeout signals only the direct child — `bash` — leaving the
|
|
348
|
+
* `cat`, the 8-second `sleep` and a live `codex app-server` behind, once per run, on a
|
|
349
|
+
* machine several agent sessions share. GNU `timeout` runs the command in its own
|
|
350
|
+
* process group and signals the GROUP.
|
|
351
|
+
*/
|
|
352
|
+
it('the default invocation is wrapped in `timeout -k` so the whole pipeline is killed', () => {
|
|
353
|
+
const src = readFileSync(fileURLToPath(new URL('../lib/runtime/codex-hooks-list.ts', import.meta.url)), 'utf-8');
|
|
354
|
+
expect(src).toMatch(/spawnSync\(\s*'timeout',\s*\['-k',\s*'5',/);
|
|
355
|
+
expect(src).not.toMatch(/spawnSync\('bash',/);
|
|
356
|
+
});
|
|
357
|
+
it('carryOverHashes re-keys onto the other file and drops foreign keys', () => {
|
|
358
|
+
const observed = new Map([['/m/.codex/hooks.json:pre_tool_use:0:0', HASH('x')]]);
|
|
359
|
+
const carried = carryOverHashes(observed, '/m/.codex/hooks.json', '/w/.codex/hooks.json');
|
|
360
|
+
expect([...carried.keys()]).toEqual(['/w/.codex/hooks.json:pre_tool_use:0:0']);
|
|
361
|
+
expect(carryOverHashes(observed, '/other/hooks.json', '/w/hooks.json').size).toBe(0);
|
|
362
|
+
});
|
|
363
|
+
});
|
|
364
|
+
describe('the trust precondition now VERIFIES the hash (KI-CODEX-TRUST-HASH-NOT-VERIFIED)', () => {
|
|
365
|
+
const wtKeys = () => keysFor(worktree);
|
|
366
|
+
it('a matching hash is trust', () => {
|
|
367
|
+
grantAll();
|
|
368
|
+
const observed = new Map(wtKeys().map((k) => [k, readGranted(k)]));
|
|
369
|
+
const trust = codexHookTrustPreconditions({
|
|
370
|
+
worktreePath: worktree,
|
|
371
|
+
codexHome,
|
|
372
|
+
observedHashes: observed,
|
|
373
|
+
});
|
|
374
|
+
expect(trust.find((t) => t.id === 'hook-trust')?.satisfied).toBe(true);
|
|
375
|
+
});
|
|
376
|
+
/**
|
|
377
|
+
* MUTATION CANARY. Delete the `observed !== recorded` comparison in
|
|
378
|
+
* codexHookTrustPreconditions and this test passes when it must fail: the record is
|
|
379
|
+
* present, enabled and non-empty — every check that existed before #4876.
|
|
380
|
+
*/
|
|
381
|
+
it('a stale hash is NOT trust, and the entry is named', () => {
|
|
382
|
+
grantAll();
|
|
383
|
+
const keys = wtKeys();
|
|
384
|
+
const observed = new Map(keys.map((k) => [k, readGranted(k)]));
|
|
385
|
+
const staleKey = keys[0];
|
|
386
|
+
observed.set(staleKey, HASH('the file changed'));
|
|
387
|
+
const trust = codexHookTrustPreconditions({
|
|
388
|
+
worktreePath: worktree,
|
|
389
|
+
codexHome,
|
|
390
|
+
observedHashes: observed,
|
|
391
|
+
});
|
|
392
|
+
const hookTrust = trust.find((t) => t.id === 'hook-trust');
|
|
393
|
+
expect(hookTrust?.satisfied).toBe(false);
|
|
394
|
+
expect(hookTrust?.detail).toContain('STALE');
|
|
395
|
+
expect(hookTrust?.detail).toContain(staleKey);
|
|
396
|
+
});
|
|
397
|
+
it('a key with NO observed hash is reported unverified, not assumed fine', () => {
|
|
398
|
+
grantAll();
|
|
399
|
+
const keys = wtKeys();
|
|
400
|
+
const observed = new Map(keys.slice(1).map((k) => [k, readGranted(k)]));
|
|
401
|
+
const hookTrust = codexHookTrustPreconditions({
|
|
402
|
+
worktreePath: worktree,
|
|
403
|
+
codexHome,
|
|
404
|
+
observedHashes: observed,
|
|
405
|
+
}).find((t) => t.id === 'hook-trust');
|
|
406
|
+
expect(hookTrust?.satisfied).toBe(false);
|
|
407
|
+
expect(hookTrust?.detail).toContain('could not be checked');
|
|
408
|
+
expect(hookTrust?.detail).toContain(keys[0]);
|
|
409
|
+
});
|
|
410
|
+
it('without observed hashes the old presence check stands — and SAYS it is unverified', () => {
|
|
411
|
+
grantAll();
|
|
412
|
+
const hookTrust = codexHookTrustPreconditions({ worktreePath: worktree, codexHome })
|
|
413
|
+
.find((t) => t.id === 'hook-trust');
|
|
414
|
+
expect(hookTrust?.satisfied).toBe(true);
|
|
415
|
+
expect(hookTrust?.detail).toContain('no observed hashes were supplied');
|
|
416
|
+
expect(hookTrust?.detail).toContain('trust-keys');
|
|
417
|
+
});
|
|
418
|
+
it('an ungranted entry still reports ungranted, separately from stale', () => {
|
|
419
|
+
writeConfig(`[projects."${worktree}"]\ntrust_level = "trusted"\n`);
|
|
420
|
+
const hookTrust = codexHookTrustPreconditions({
|
|
421
|
+
worktreePath: worktree,
|
|
422
|
+
codexHome,
|
|
423
|
+
observedHashes: new Map(wtKeys().map((k) => [k, HASH(k)])),
|
|
424
|
+
}).find((t) => t.id === 'hook-trust');
|
|
425
|
+
expect(hookTrust?.satisfied).toBe(false);
|
|
426
|
+
expect(hookTrust?.detail).toContain('NO usable trust record');
|
|
427
|
+
expect(hookTrust?.detail).not.toContain('STALE');
|
|
428
|
+
});
|
|
429
|
+
function readGranted(key) {
|
|
430
|
+
return readCodexTrustState(codexHome).records.get(key)?.hash ?? '';
|
|
431
|
+
}
|
|
432
|
+
});
|
|
433
|
+
describe('trust-keys report — both key sets, and the #27133 carry-over', () => {
|
|
434
|
+
it('reports BOTH key sets, and carries hashes to the worktree set when files match', () => {
|
|
435
|
+
grantAll();
|
|
436
|
+
const r = report();
|
|
437
|
+
expect(r.sets.map((s) => s.label).sort()).toEqual(['main-repo', 'worktree']);
|
|
438
|
+
const wt = r.sets.find((s) => s.label === 'worktree');
|
|
439
|
+
expect(wt?.rows).toHaveLength(4);
|
|
440
|
+
expect(wt?.rows.every((row) => row.observedFrom === 'carried-over')).toBe(true);
|
|
441
|
+
const main = r.sets.find((s) => s.label === 'main-repo');
|
|
442
|
+
expect(main?.rows.every((row) => row.observedFrom === 'hooks/list')).toBe(true);
|
|
443
|
+
expect(r.ok).toBe(true);
|
|
444
|
+
});
|
|
445
|
+
/**
|
|
446
|
+
* The carry-over is exact ONLY for byte-identical files. When the two diverge, Codex is
|
|
447
|
+
* running hooks this worktree never deployed — the runbook's §2b silent failure — and
|
|
448
|
+
* the worktree entries become unverifiable rather than being borrowed anyway.
|
|
449
|
+
*/
|
|
450
|
+
it('refuses to carry hashes between files that differ, and says why', () => {
|
|
451
|
+
grantAll();
|
|
452
|
+
writeFileSync(join(worktree, CODEX_HOOKS_FILENAME), `${readFileSync(join(worktree, CODEX_HOOKS_FILENAME), 'utf-8').replace('GENERATED', 'EDITED')}`);
|
|
453
|
+
const r = report();
|
|
454
|
+
expect(r.ok).toBe(false);
|
|
455
|
+
expect(r.warnings.join(' ')).toContain('#27133');
|
|
456
|
+
expect(r.warnings.join(' ')).toContain('DIFFER');
|
|
457
|
+
const wt = r.sets.find((s) => s.label === 'worktree');
|
|
458
|
+
expect(wt?.rows.every((row) => row.status === 'unverifiable')).toBe(true);
|
|
459
|
+
});
|
|
460
|
+
it('marks a stale-hash entry and an ungranted entry distinctly', () => {
|
|
461
|
+
grantAll();
|
|
462
|
+
const mainKeys = keysFor(mainRepo);
|
|
463
|
+
// One entry re-granted with a wrong hash, one dropped entirely.
|
|
464
|
+
const state = readCodexTrustState(codexHome).records;
|
|
465
|
+
const lines = [...state]
|
|
466
|
+
.filter(([k]) => k !== mainKeys[1])
|
|
467
|
+
.map(([k, v]) => `[hooks.state."${k}"]\nenabled = true\ntrusted_hash = "${k === mainKeys[0] ? HASH('drifted') : v.hash}"\n`);
|
|
468
|
+
writeConfig(`[projects."${mainRepo}"]\ntrust_level = "trusted"\n\n` +
|
|
469
|
+
`[projects."${worktree}"]\ntrust_level = "trusted"\n\n${lines.join('\n')}`);
|
|
470
|
+
const rows = report().sets.find((s) => s.label === 'main-repo')?.rows ?? [];
|
|
471
|
+
expect(rows.find((r) => r.key === mainKeys[0])?.status).toBe('stale-hash');
|
|
472
|
+
expect(rows.find((r) => r.key === mainKeys[1])?.status).toBe('ungranted');
|
|
473
|
+
expect(rows.find((r) => r.key === mainKeys[2])?.status).toBe('granted');
|
|
474
|
+
});
|
|
475
|
+
/**
|
|
476
|
+
* SF-8. The byte-identity sha that licenses the carry-over was read AFTER `hooks/list`
|
|
477
|
+
* returned — seconds later, on a machine where another session may be running
|
|
478
|
+
* `mx-agent codex deploy-config`. A deploy landing inside that window makes a carried
|
|
479
|
+
* hash describe bytes that are no longer on disk, and the row reads `granted`. The
|
|
480
|
+
* files are now hashed before AND after the call, and any change refuses the carry-over.
|
|
481
|
+
*/
|
|
482
|
+
it('refuses the carry-over when a hooks file changed during the hooks/list call', () => {
|
|
483
|
+
grantAll();
|
|
484
|
+
const shaBefore = shaCodexHooksFiles([worktree, mainRepo]);
|
|
485
|
+
// The concurrent deploy: same keys, different bytes, landing mid-call.
|
|
486
|
+
writeFileSync(join(worktree, CODEX_HOOKS_FILENAME), `${readFileSync(join(worktree, CODEX_HOOKS_FILENAME), 'utf-8')}\n`);
|
|
487
|
+
const r = buildTrustKeyReport({
|
|
488
|
+
worktreePath: worktree,
|
|
489
|
+
mainRepoPath: mainRepo,
|
|
490
|
+
codexHome,
|
|
491
|
+
hooksList: { ok: true, entries: liveEntries() },
|
|
492
|
+
shaBefore,
|
|
493
|
+
});
|
|
494
|
+
expect(r.ok).toBe(false);
|
|
495
|
+
expect(r.warnings.join(' ')).toContain('CHANGED while Codex was being asked for its hashes');
|
|
496
|
+
const wt = r.sets.find((s) => s.label === 'worktree');
|
|
497
|
+
expect(wt?.rows.every((row) => row.status === 'unverifiable')).toBe(true);
|
|
498
|
+
expect(wt?.rows.every((row) => row.observedFrom === null)).toBe(true);
|
|
499
|
+
});
|
|
500
|
+
it('an unchanged pair carries over exactly as before — the check costs nothing when quiet', () => {
|
|
501
|
+
grantAll();
|
|
502
|
+
const r = buildTrustKeyReport({
|
|
503
|
+
worktreePath: worktree,
|
|
504
|
+
mainRepoPath: mainRepo,
|
|
505
|
+
codexHome,
|
|
506
|
+
hooksList: { ok: true, entries: liveEntries() },
|
|
507
|
+
shaBefore: shaCodexHooksFiles([worktree, mainRepo]),
|
|
508
|
+
});
|
|
509
|
+
expect(r.ok).toBe(true);
|
|
510
|
+
expect(r.sets.find((s) => s.label === 'worktree')?.rows.every((row) => row.observedFrom === 'carried-over')).toBe(true);
|
|
511
|
+
});
|
|
512
|
+
it('shaCodexHooksFiles keys by hooks-file path and reports an absent file as null', () => {
|
|
513
|
+
const map = shaCodexHooksFiles([worktree, join(worktree, 'nope')]);
|
|
514
|
+
expect(map.get(join(worktree, CODEX_HOOKS_FILENAME))).toMatch(/^[0-9a-f]{64}$/);
|
|
515
|
+
expect(map.get(join(worktree, 'nope', CODEX_HOOKS_FILENAME))).toBeNull();
|
|
516
|
+
});
|
|
517
|
+
it('a failed hooks/list produces an error report, never an empty green one', () => {
|
|
518
|
+
const r = buildTrustKeyReport({
|
|
519
|
+
worktreePath: worktree,
|
|
520
|
+
mainRepoPath: mainRepo,
|
|
521
|
+
codexHome,
|
|
522
|
+
hooksList: { ok: false, error: 'app-server did not answer' },
|
|
523
|
+
});
|
|
524
|
+
expect(r.ok).toBe(false);
|
|
525
|
+
expect(r.error).toContain('app-server did not answer');
|
|
526
|
+
expect(r.sets).toEqual([]);
|
|
527
|
+
});
|
|
528
|
+
it('warns when a project directory is not trusted — hook trust is moot there', () => {
|
|
529
|
+
writeConfig('');
|
|
530
|
+
expect(report().warnings.join(' ')).toContain('is not trusted in the Codex config');
|
|
531
|
+
});
|
|
532
|
+
it('a missing hooks file is reported as an error for that set, not as zero keys granted', () => {
|
|
533
|
+
grantAll();
|
|
534
|
+
rmSync(join(worktree, CODEX_HOOKS_FILENAME));
|
|
535
|
+
const r = report();
|
|
536
|
+
expect(r.ok).toBe(false);
|
|
537
|
+
expect(r.sets.find((s) => s.label === 'worktree')?.error).toContain('No readable hooks document');
|
|
538
|
+
});
|
|
539
|
+
});
|
|
540
|
+
describe('the pasteable grant block — the double-prefix defect', () => {
|
|
541
|
+
/**
|
|
542
|
+
* THE DEFECT: `currentHash` already begins with `sha256:`. A record written as
|
|
543
|
+
* `sha256:sha256:<hex>` is never matched by Codex, so the hook does not run, while a
|
|
544
|
+
* presence-only precondition reports trust satisfied. Guards inert, tooling green.
|
|
545
|
+
*/
|
|
546
|
+
it('reproduces the observed hash VERBATIM and never doubles the prefix', () => {
|
|
547
|
+
writeConfig(`[projects."${mainRepo}"]\ntrust_level = "trusted"\n`);
|
|
548
|
+
const r = report();
|
|
549
|
+
const rows = r.sets.flatMap((s) => s.rows);
|
|
550
|
+
const { block } = trustGrantToml(rows);
|
|
551
|
+
expect(block).not.toContain('sha256:sha256:');
|
|
552
|
+
for (const row of rows) {
|
|
553
|
+
if (row.observedHash === null)
|
|
554
|
+
continue;
|
|
555
|
+
expect(block).toContain(`trusted_hash = "${row.observedHash}"`);
|
|
556
|
+
expect(row.observedHash).toMatch(CODEX_HASH_SHAPE);
|
|
557
|
+
expect(row.observedHash).toHaveLength(71);
|
|
558
|
+
}
|
|
559
|
+
});
|
|
560
|
+
it('emits a block only for entries that need one, and enables each record', () => {
|
|
561
|
+
grantAll();
|
|
562
|
+
const rows = report().sets.flatMap((s) => s.rows);
|
|
563
|
+
expect(trustGrantToml(rows).block).toBe('');
|
|
564
|
+
const stale = [{ ...rows[0], status: 'stale-hash' }];
|
|
565
|
+
const { block } = trustGrantToml(stale);
|
|
566
|
+
expect(block).toContain('enabled = true');
|
|
567
|
+
expect(block.match(/\[hooks\.state\./g)).toHaveLength(1);
|
|
568
|
+
});
|
|
569
|
+
/**
|
|
570
|
+
* SF-6. A hash that FAILED the shape check was still emitted into the pasteable block,
|
|
571
|
+
* under a heading that tells the operator to paste it — the one string this command
|
|
572
|
+
* exists to prevent them from writing. The renderer's shape warning came afterwards and
|
|
573
|
+
* removed nothing. Verbatim reproduction governs what is DISPLAYED; it is not a reason
|
|
574
|
+
* to offer a malformed value for pasting.
|
|
575
|
+
*/
|
|
576
|
+
it('a shape-failing hash never reaches the pasteable block, and says why', () => {
|
|
577
|
+
grantAll();
|
|
578
|
+
const rows = report().sets.flatMap((s) => s.rows);
|
|
579
|
+
const malformed = {
|
|
580
|
+
...rows[0],
|
|
581
|
+
status: 'ungranted',
|
|
582
|
+
observedHash: 'sha256:sha256:deadbeef',
|
|
583
|
+
};
|
|
584
|
+
const { block, unresolvable } = trustGrantToml([malformed]);
|
|
585
|
+
expect(block).toBe('');
|
|
586
|
+
expect(block).not.toContain('sha256:sha256:');
|
|
587
|
+
expect(unresolvable).toHaveLength(1);
|
|
588
|
+
expect(unresolvable[0]?.reason).toMatch(/not the sha256:<64 hex> shape/);
|
|
589
|
+
expect(unresolvable[0]?.reason).toMatch(/NOT offered for pasting/);
|
|
590
|
+
});
|
|
591
|
+
it('a well-shaped hash alongside a malformed one is still offered', () => {
|
|
592
|
+
grantAll();
|
|
593
|
+
const rows = report().sets.flatMap((s) => s.rows);
|
|
594
|
+
const good = { ...rows[0], status: 'stale-hash' };
|
|
595
|
+
const bad = {
|
|
596
|
+
...rows[1],
|
|
597
|
+
status: 'stale-hash',
|
|
598
|
+
observedHash: 'not-a-hash',
|
|
599
|
+
};
|
|
600
|
+
const { block, unresolvable } = trustGrantToml([good, bad]);
|
|
601
|
+
expect(block).toContain(`trusted_hash = "${good.observedHash}"`);
|
|
602
|
+
expect(block).not.toContain('not-a-hash');
|
|
603
|
+
expect(unresolvable.map((r) => r.key)).toEqual([bad.key]);
|
|
604
|
+
});
|
|
605
|
+
it('the rendered output shows the malformed row under unresolvable, with its reason', () => {
|
|
606
|
+
grantAll();
|
|
607
|
+
const rows = report().sets.flatMap((s) => s.rows);
|
|
608
|
+
const malformed = {
|
|
609
|
+
...rows[0],
|
|
610
|
+
status: 'ungranted',
|
|
611
|
+
observedHash: 'sha256:tooshort',
|
|
612
|
+
};
|
|
613
|
+
const text = renderTrustKeyReport({
|
|
614
|
+
ok: false,
|
|
615
|
+
sets: [{ label: 'worktree', hooksPath: join(worktree, CODEX_HOOKS_FILENAME), hooksSha256: null, rows: [malformed] }],
|
|
616
|
+
warnings: [],
|
|
617
|
+
observedHashes: new Map(),
|
|
618
|
+
}).join('\n');
|
|
619
|
+
expect(text).toContain('NO hash is offered for them');
|
|
620
|
+
expect(text).toContain('not the sha256:<64 hex> shape');
|
|
621
|
+
expect(text).not.toContain('Paste into ~/.codex/config.toml');
|
|
622
|
+
});
|
|
623
|
+
it('lists entries with no hash as unresolvable rather than inventing one', () => {
|
|
624
|
+
grantAll();
|
|
625
|
+
const rows = report().sets.flatMap((s) => s.rows);
|
|
626
|
+
const orphan = { ...rows[0], status: 'ungranted', observedHash: null, observedFrom: null };
|
|
627
|
+
const { block, unresolvable } = trustGrantToml([orphan]);
|
|
628
|
+
expect(block).toBe('');
|
|
629
|
+
expect(unresolvable).toHaveLength(1);
|
|
630
|
+
});
|
|
631
|
+
it('the rendered output tells the operator not to add another prefix, and covers both files', () => {
|
|
632
|
+
writeConfig(`[projects."${mainRepo}"]\ntrust_level = "trusted"\n`);
|
|
633
|
+
const text = renderTrustKeyReport(report()).join('\n');
|
|
634
|
+
expect(text).toContain('Do NOT add another one');
|
|
635
|
+
expect(text).not.toContain('sha256:sha256:');
|
|
636
|
+
expect(text).toContain(join(mainRepo, CODEX_HOOKS_FILENAME));
|
|
637
|
+
expect(text).toContain(join(worktree, CODEX_HOOKS_FILENAME));
|
|
638
|
+
expect(text).toContain('UNGRANTED');
|
|
639
|
+
expect(text).toContain('one sitting');
|
|
640
|
+
});
|
|
641
|
+
it('renders the failure reason when hooks/list could not be read', () => {
|
|
642
|
+
const text = renderTrustKeyReport({
|
|
643
|
+
ok: false,
|
|
644
|
+
sets: [],
|
|
645
|
+
warnings: [],
|
|
646
|
+
error: 'boom',
|
|
647
|
+
observedHashes: new Map(),
|
|
648
|
+
}).join('\n');
|
|
649
|
+
expect(text).toContain("Could not read Codex's own hook hashes: boom");
|
|
650
|
+
});
|
|
651
|
+
it('observedHashesByKey keys by the entry key, verbatim', () => {
|
|
652
|
+
const map = observedHashesByKey(liveEntries());
|
|
653
|
+
expect(map.size).toBe(keysFor(mainRepo).length);
|
|
654
|
+
for (const [, hash] of map)
|
|
655
|
+
expect(hash).toMatch(CODEX_HASH_SHAPE);
|
|
656
|
+
});
|
|
657
|
+
/**
|
|
658
|
+
* MUST FIX 2, layer two (security review, CVSS 8.2, executed). The parser now refuses a
|
|
659
|
+
* hostile key from `hooks/list` — but the OTHER vector never passes the parser: a
|
|
660
|
+
* `.codex/hooks.json` planted in the repository, whose EVENT NAME carries TOML.
|
|
661
|
+
* `codexHookTrustKeysForDoc` derives those keys locally and hands them straight to this
|
|
662
|
+
* renderer. The reviewer's payload put `[projects."/workspace"] trust_level = "trusted"`
|
|
663
|
+
* and `sandbox_mode = "danger-full-access"` into the block an operator is told to paste:
|
|
664
|
+
* a fleet-wide trust grant and a sandbox escape, written by the operator's own hand.
|
|
665
|
+
*/
|
|
666
|
+
it('renders a hostile key as ONE escaped table header — no [projects.] line appears', () => {
|
|
667
|
+
const evilEvent = 'pre_tool_use"]\n[projects."/workspace"]\ntrust_level = "trusted"\nsandbox_mode = "danger-full-access"\n#';
|
|
668
|
+
const hooksPath = join(worktree, CODEX_HOOKS_FILENAME);
|
|
669
|
+
writeFileSync(hooksPath, JSON.stringify({ description: 'x', hooks: { [evilEvent]: [{ hooks: [{ type: 'command', command: '/bin/true' }] }] } }, null, 2));
|
|
670
|
+
const keys = codexHookTrustKeysForDoc(hooksPath, readDeployedHooksDoc(worktree));
|
|
671
|
+
expect(keys).toHaveLength(1);
|
|
672
|
+
const { block } = trustGrantToml([
|
|
673
|
+
{
|
|
674
|
+
key: keys[0],
|
|
675
|
+
status: 'ungranted',
|
|
676
|
+
observedHash: HASH('a'),
|
|
677
|
+
observedFrom: 'hooks/list',
|
|
678
|
+
recordedHash: null,
|
|
679
|
+
recordEnabled: false,
|
|
680
|
+
codexTrustStatus: null,
|
|
681
|
+
detail: '',
|
|
682
|
+
},
|
|
683
|
+
]);
|
|
684
|
+
// The payload's own text may not appear as TOML structure: no second table header,
|
|
685
|
+
// and above all no project-trust or sandbox grant.
|
|
686
|
+
expect(block).not.toMatch(/^\[projects\./m);
|
|
687
|
+
expect(block).not.toMatch(/^trust_level/m);
|
|
688
|
+
expect(block).not.toMatch(/^sandbox_mode/m);
|
|
689
|
+
expect(block.match(/^\[hooks\.state\./gm)).toHaveLength(1);
|
|
690
|
+
// And it is escaped, not silently dropped — the operator sees the key they have.
|
|
691
|
+
expect(block).toContain('\\"');
|
|
692
|
+
expect(block).toContain('\\n');
|
|
693
|
+
// One header line, one enabled, one hash: the shape a grant block is allowed to have.
|
|
694
|
+
expect(block.split('\n').filter((l) => l.startsWith('enabled = '))).toHaveLength(1);
|
|
695
|
+
});
|
|
696
|
+
});
|
|
697
|
+
/**
|
|
698
|
+
* SF-E. `result.status !== undefined && result.status !== 0` made a result with NO status
|
|
699
|
+
* field the SUCCESS path: the invocation's outcome is unknown and its stdout was read as
|
|
700
|
+
* Codex's answer. `null` (killed by a signal) keeps its own branch.
|
|
701
|
+
*/
|
|
702
|
+
describe('hooks/list exec — an absent exit status is not a zero one', () => {
|
|
703
|
+
it('refuses when the exec result carries no status field', () => {
|
|
704
|
+
const good = JSON.stringify({
|
|
705
|
+
id: 2,
|
|
706
|
+
result: {
|
|
707
|
+
data: [
|
|
708
|
+
{
|
|
709
|
+
hooks: [
|
|
710
|
+
{
|
|
711
|
+
key: '/w/.codex/hooks.json:pre_tool_use:0:0',
|
|
712
|
+
currentHash: HASH('a'),
|
|
713
|
+
sourcePath: '/w/.codex/hooks.json',
|
|
714
|
+
},
|
|
715
|
+
],
|
|
716
|
+
},
|
|
717
|
+
],
|
|
718
|
+
},
|
|
719
|
+
});
|
|
720
|
+
const result = queryCodexHooksList({ cwd: '/w', exec: () => ({ stdout: good, stderr: '' }) });
|
|
721
|
+
expect(result.ok).toBe(false);
|
|
722
|
+
expect(result.ok === false && result.error).toMatch(/reported no exit status/);
|
|
723
|
+
// And a status of 0 still succeeds, so this is not simply refusing everything.
|
|
724
|
+
const okResult = queryCodexHooksList({
|
|
725
|
+
cwd: '/w',
|
|
726
|
+
exec: () => ({ stdout: good, status: 0, stderr: '' }),
|
|
727
|
+
});
|
|
728
|
+
expect(okResult.ok).toBe(true);
|
|
729
|
+
});
|
|
730
|
+
});
|
|
731
|
+
//# sourceMappingURL=codex-trust-keys.test.js.map
|