@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.
Files changed (45) hide show
  1. package/dist/__tests__/codex-deploy-config.test.d.ts +2 -0
  2. package/dist/__tests__/codex-deploy-config.test.d.ts.map +1 -0
  3. package/dist/__tests__/codex-deploy-config.test.js +1170 -0
  4. package/dist/__tests__/codex-deploy-config.test.js.map +1 -0
  5. package/dist/__tests__/codex-trust-keys.test.d.ts +2 -0
  6. package/dist/__tests__/codex-trust-keys.test.d.ts.map +1 -0
  7. package/dist/__tests__/codex-trust-keys.test.js +731 -0
  8. package/dist/__tests__/codex-trust-keys.test.js.map +1 -0
  9. package/dist/__tests__/codex-write-race.test.d.ts +2 -0
  10. package/dist/__tests__/codex-write-race.test.d.ts.map +1 -0
  11. package/dist/__tests__/codex-write-race.test.js +372 -0
  12. package/dist/__tests__/codex-write-race.test.js.map +1 -0
  13. package/dist/__tests__/runtime-codex-guard-proof.test.js +75 -0
  14. package/dist/__tests__/runtime-codex-guard-proof.test.js.map +1 -1
  15. package/dist/commands/codex-deploy-config.d.ts +111 -0
  16. package/dist/commands/codex-deploy-config.d.ts.map +1 -0
  17. package/dist/commands/codex-deploy-config.js +400 -0
  18. package/dist/commands/codex-deploy-config.js.map +1 -0
  19. package/dist/commands/codex-prove-guards.d.ts +20 -0
  20. package/dist/commands/codex-prove-guards.d.ts.map +1 -1
  21. package/dist/commands/codex-prove-guards.js +54 -1
  22. package/dist/commands/codex-prove-guards.js.map +1 -1
  23. package/dist/commands/codex-trust-keys.d.ts +12 -0
  24. package/dist/commands/codex-trust-keys.d.ts.map +1 -0
  25. package/dist/commands/codex-trust-keys.js +169 -0
  26. package/dist/commands/codex-trust-keys.js.map +1 -0
  27. package/dist/index.d.ts.map +1 -1
  28. package/dist/index.js +65 -0
  29. package/dist/index.js.map +1 -1
  30. package/dist/lib/runtime/codex-adapter.d.ts.map +1 -1
  31. package/dist/lib/runtime/codex-adapter.js +15 -15
  32. package/dist/lib/runtime/codex-adapter.js.map +1 -1
  33. package/dist/lib/runtime/codex-config.d.ts +211 -0
  34. package/dist/lib/runtime/codex-config.d.ts.map +1 -1
  35. package/dist/lib/runtime/codex-config.js +769 -40
  36. package/dist/lib/runtime/codex-config.js.map +1 -1
  37. package/dist/lib/runtime/codex-hooks-list.d.ts +91 -0
  38. package/dist/lib/runtime/codex-hooks-list.d.ts.map +1 -0
  39. package/dist/lib/runtime/codex-hooks-list.js +418 -0
  40. package/dist/lib/runtime/codex-hooks-list.js.map +1 -0
  41. package/dist/lib/runtime/codex-trust-keys.d.ts +95 -0
  42. package/dist/lib/runtime/codex-trust-keys.d.ts.map +1 -0
  43. package/dist/lib/runtime/codex-trust-keys.js +279 -0
  44. package/dist/lib/runtime/codex-trust-keys.js.map +1 -0
  45. 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