mirror of
https://github.com/garrytan/gstack.git
synced 2026-11-22 16:11:34 +01:00
`./setup --host codex` now adds gstack's skill-routing hint and destructive-command check to Codex's `~/.codex/hooks.json`, next to your own hooks, so Codex users get the same guardrails Claude Code users have. Codex runs a hook only after you trust it, so nothing fires until you accept gstack's hooks at Codex's startup prompt or in `/hooks`; `gstack-doctor` shows whether you have. Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com> Review-Finding: p1/red-team#1 reader=red-team
348 lines
23 KiB
TypeScript
348 lines
23 KiB
TypeScript
/**
|
|
* gstack's hooks on Codex (GST-3172, plan GSTA-638 A1/B1/C1/D1): the Codex hooks.json format of
|
|
* bin/gstack-settings-hook, the routing and destructive-command hooks with host codex, and setup's and uninstall's
|
|
* wiring. Payloads come from codex-cli 0.170 probes (test/fixtures/codex-hooks). Claude Code's output is pinned
|
|
* unchanged here: the hint text, the routing of a "$" prompt, and the settings.json entries for the three hooks.
|
|
*/
|
|
import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
|
|
import { spawnSync } from 'node:child_process';
|
|
import * as fs from 'node:fs';
|
|
import * as os from 'node:os';
|
|
import * as path from 'node:path';
|
|
import { codexDecision, CODEX_ASK_NOTE } from '../hosts/codex/hooks/codex-destructive-guard-hook.ts';
|
|
import { ASK_NOTE } from '../hosts/claude/hooks/destructive-guard-hook.ts';
|
|
import { hintLine, routePrompt, scanCodexSkills, type RouteCandidate } from '../lib/skill-route';
|
|
|
|
const ROOT = path.resolve(import.meta.dir, '..');
|
|
const HOOK_BIN = path.join(ROOT, 'bin', 'gstack-settings-hook');
|
|
const PAYLOADS = JSON.parse(fs.readFileSync(path.join(ROOT, 'test', 'fixtures', 'codex-hooks', 'codex-0.170-payloads.json'), 'utf8'));
|
|
|
|
let dir = '';
|
|
beforeEach(() => { dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gstack-codex-hooks-')); });
|
|
afterEach(() => fs.rmSync(dir, { recursive: true, force: true }));
|
|
|
|
const hooksFile = () => path.join(dir, 'hooks.json');
|
|
const read = () => JSON.parse(fs.readFileSync(hooksFile(), 'utf8'));
|
|
const backups = () => fs.readdirSync(dir).filter(f => f.startsWith('hooks.json.bak.'));
|
|
function settingsHook(args: string[], env: Record<string, string> = {}) {
|
|
const r = spawnSync('bash', [HOOK_BIN, ...args], {
|
|
env: { PATH: process.env.PATH ?? '', HOME: dir, GSTACK_HOOKS_FORMAT: 'codex', GSTACK_SETTINGS_FILE: hooksFile(), ...env },
|
|
encoding: 'utf8', timeout: 30_000,
|
|
});
|
|
return { code: r.status, out: (r.stdout ?? '') + (r.stderr ?? '') };
|
|
}
|
|
const runtime = () => path.join(dir, 'skills', 'gstack');
|
|
const ROUTE_CMD = (root = runtime()) => path.join(root, 'hosts', 'codex', 'hooks', 'codex-skill-route-hook');
|
|
const GUARD_CMD = (root = runtime()) => path.join(root, 'hosts', 'codex', 'hooks', 'codex-destructive-guard-hook');
|
|
const ensureRoute = (root?: string) => settingsHook(['ensure-event', '--event', 'UserPromptSubmit', '--command', ROUTE_CMD(root), '--source', 'gstack-skill-route', '--timeout', '5']);
|
|
const ensureGuard = (root?: string) => settingsHook(['ensure-event', '--event', 'PreToolUse', '--command', GUARD_CMD(root), '--source', 'gstack-destructive-guard', '--matcher', 'Bash', '--timeout', '10']);
|
|
|
|
const USER_FILE = {
|
|
description: 'my hooks',
|
|
hooks: {
|
|
PreToolUse: [{ matcher: 'Bash', hooks: [{ type: 'command', command: '/usr/local/bin/my-guard', timeout: 3, statusMessage: 'checking' }] }],
|
|
UserPromptSubmit: [{ hooks: [{ type: 'command', command: '/usr/local/bin/my-prompt-log' }] }],
|
|
Stop: [{ hooks: [{ type: 'command', command: '/usr/local/bin/my-stop', async: false }] }],
|
|
},
|
|
};
|
|
const writeUser = (doc: unknown = USER_FILE) => fs.writeFileSync(hooksFile(), JSON.stringify(doc, null, 2) + '\n');
|
|
|
|
/** The keys Codex 0.170 accepts (codex-rs/config/src/hook_config.rs HooksFile, codex-rs/protocol/src/hooks.rs), written out independently. */
|
|
const CODEX_KEYS = {
|
|
top: ['description', 'hooks'],
|
|
group: ['matcher', 'hooks'],
|
|
command: ['type', 'command', 'commandWindows', 'command_windows', 'timeout', 'async', 'statusMessage', 'additionalContextLimit'],
|
|
};
|
|
function codexKeysOnly(doc: Record<string, any>): void {
|
|
for (const k of Object.keys(doc)) expect(CODEX_KEYS.top).toContain(k);
|
|
for (const groups of Object.values(doc.hooks ?? {}) as any[][]) {
|
|
for (const g of groups) {
|
|
for (const k of Object.keys(g)) expect(CODEX_KEYS.group).toContain(k);
|
|
for (const h of g.hooks) for (const k of Object.keys(h)) expect(CODEX_KEYS.command).toContain(k);
|
|
}
|
|
}
|
|
}
|
|
|
|
describe('gstack-settings-hook: Codex hooks.json format', () => {
|
|
test('merges after the user groups: theirs keep content and position, gstack adds one group per hook with explicit timeouts and no tag keys', () => {
|
|
writeUser();
|
|
expect(ensureRoute().out).toContain('OK: UserPromptSubmit hook registered (source: gstack-skill-route)');
|
|
expect(ensureGuard().out).toContain('OK: PreToolUse hook registered (source: gstack-destructive-guard)');
|
|
const doc = read();
|
|
expect(doc.description).toBe('my hooks');
|
|
expect(doc.hooks.Stop).toEqual(USER_FILE.hooks.Stop);
|
|
expect(doc.hooks.PreToolUse[0]).toEqual(USER_FILE.hooks.PreToolUse[0]);
|
|
expect(doc.hooks.UserPromptSubmit[0]).toEqual(USER_FILE.hooks.UserPromptSubmit[0]);
|
|
expect(doc.hooks.PreToolUse[1]).toEqual({ matcher: 'Bash', hooks: [{ type: 'command', command: GUARD_CMD(), timeout: 10 }] });
|
|
expect(doc.hooks.UserPromptSubmit[1]).toEqual({ hooks: [{ type: 'command', command: ROUTE_CMD(), timeout: 5 }] });
|
|
expect(JSON.stringify(doc)).not.toContain('_gstack_source');
|
|
codexKeysOnly(doc);
|
|
});
|
|
|
|
test('a re-run changes nothing: no write and no new backup; a moved runtime root re-points in place', () => {
|
|
writeUser();
|
|
ensureRoute(); ensureGuard();
|
|
const bytes = fs.readFileSync(hooksFile(), 'utf8');
|
|
const baks = backups().length;
|
|
expect(ensureRoute().out).toContain('unchanged');
|
|
expect(ensureGuard().out).toContain('unchanged');
|
|
expect(fs.readFileSync(hooksFile(), 'utf8')).toBe(bytes);
|
|
expect(backups().length).toBe(baks);
|
|
const moved = path.join(dir, 'other', 'gstack');
|
|
expect(ensureGuard(moved).out).toContain('re-pointed');
|
|
const doc = read();
|
|
expect(doc.hooks.PreToolUse).toHaveLength(2);
|
|
expect(doc.hooks.PreToolUse[1].hooks[0].command).toBe(GUARD_CMD(moved));
|
|
});
|
|
|
|
test('refuses a hooks.json that does not parse, or that Codex would skip, and leaves it byte-identical', () => {
|
|
const cases: Array<[string, string]> = [
|
|
['{ "hooks": ', 'is not valid JSON'],
|
|
[JSON.stringify({ hooks: { PreToolUse: [{ matcher: 'Bash', _gstack_source: 'x', hooks: [] }] } }), 'has the key "_gstack_source", which Codex does not know'],
|
|
[JSON.stringify({ hooks: { BeforeTool: [] } }), 'has the key "BeforeTool"'],
|
|
[JSON.stringify({ hooks: { Stop: [{ hooks: [{ type: 'command', command: 'x', retries: 2 }] }] } }), 'has the key "retries"'],
|
|
[JSON.stringify({ hooks: { Stop: [{ hooks: [{ type: 'shell', command: 'x' }] }] } }), '.type is "shell"'],
|
|
[JSON.stringify({ hooks: { Stop: [{ hooks: [{ type: 'command', command: 'x', timeout: 1.5 }] }] } }), 'timeout is not a whole number'],
|
|
[JSON.stringify({ version: 1, hooks: {} }), 'has the key "version"'],
|
|
];
|
|
for (const [text, why] of cases) {
|
|
fs.writeFileSync(hooksFile(), text);
|
|
const r = ensureRoute();
|
|
expect(r.code).toBe(3);
|
|
expect(r.out).toContain(why);
|
|
expect(r.out).toContain('refusing to mutate');
|
|
expect(fs.readFileSync(hooksFile(), 'utf8')).toBe(text);
|
|
}
|
|
expect(backups()).toEqual([]);
|
|
});
|
|
|
|
test('refuses while config.toml declares a gstack hook under [hooks] or does not parse; user hooks and trust state there are fine', () => {
|
|
writeUser();
|
|
const cfg = path.join(dir, 'config.toml');
|
|
fs.writeFileSync(cfg, '[[hooks.PreToolUse]]\nmatcher = "Bash"\n[[hooks.PreToolUse.hooks]]\ntype = "command"\ncommand = "' + GUARD_CMD() + '"\n');
|
|
let r = ensureRoute();
|
|
expect(r.code).toBe(3);
|
|
expect(r.out).toContain('already declares gstack hook gstack-destructive-guard under [hooks.PreToolUse], and Codex would run it twice');
|
|
fs.writeFileSync(cfg, 'model = [\n');
|
|
r = ensureRoute();
|
|
expect(r.code).toBe(3);
|
|
expect(r.out).toContain('does not parse');
|
|
expect(read()).toEqual(USER_FILE);
|
|
fs.writeFileSync(cfg, 'model = "gpt-6.1-sol"\n[[hooks.Stop]]\n[[hooks.Stop.hooks]]\ntype = "command"\ncommand = "/usr/local/bin/my-stop"\n[hooks.state."/x/hooks.json:stop:0:0"]\ntrusted_hash = "sha256:1"\n');
|
|
expect(ensureRoute().code).toBe(0);
|
|
});
|
|
|
|
test('remove-source takes only its hook, prune-stale --all returns the user file exactly, and rollback undoes the last write', () => {
|
|
writeUser();
|
|
ensureRoute(); ensureGuard();
|
|
expect(settingsHook(['remove-source', '--source', 'gstack-skill-route']).out).toContain('removed 1');
|
|
expect(read().hooks.UserPromptSubmit).toEqual(USER_FILE.hooks.UserPromptSubmit);
|
|
expect(read().hooks.PreToolUse).toHaveLength(2);
|
|
const beforeSweep = fs.readFileSync(hooksFile(), 'utf8');
|
|
expect(settingsHook(['prune-stale', '--all']).out).toContain('removed 1 gstack hook entries');
|
|
expect(read()).toEqual(USER_FILE);
|
|
expect(settingsHook(['rollback']).code).toBe(0);
|
|
expect(fs.readFileSync(hooksFile(), 'utf8')).toBe(beforeSweep);
|
|
});
|
|
|
|
test('the legacy settings.json verbs are refused in the Codex format', () => {
|
|
for (const verb of ['add', 'remove']) {
|
|
const r = settingsHook([verb, '/x/bin/gstack-session-update']);
|
|
expect(r.code).toBe(1);
|
|
expect(r.out).toContain('legacy settings.json verb');
|
|
}
|
|
expect(fs.existsSync(hooksFile())).toBe(false);
|
|
});
|
|
|
|
test('trust-status reads the key Codex writes (<hooks.json>:<event>:<group>:<handler>) and never computes a hash', () => {
|
|
writeUser();
|
|
ensureRoute(); ensureGuard();
|
|
expect(settingsHook(['trust-status']).out.trim().split('\n').sort()).toEqual([
|
|
'gstack-destructive-guard\tPreToolUse\tuntrusted', 'gstack-skill-route\tUserPromptSubmit\tuntrusted',
|
|
]);
|
|
const file = fs.realpathSync(hooksFile());
|
|
fs.writeFileSync(path.join(dir, 'config.toml'), [
|
|
'[hooks.state]', '',
|
|
'[hooks.state."' + file + ':pre_tool_use:0:0"]', 'trusted_hash = "sha256:aa"', '',
|
|
'[hooks.state."' + file + ':pre_tool_use:1:0"]', 'trusted_hash = "sha256:bb"', '',
|
|
'[hooks.state."' + file + ':user_prompt_submit:1:0"]', 'enabled = false', 'trusted_hash = "sha256:cc"', '',
|
|
].join('\n'));
|
|
expect(settingsHook(['trust-status']).out.trim().split('\n').sort()).toEqual([
|
|
'gstack-destructive-guard\tPreToolUse\ttrusted', 'gstack-skill-route\tUserPromptSubmit\tdisabled',
|
|
]);
|
|
expect(settingsHook(['trust-status'], { GSTACK_HOOKS_FORMAT: '' }).code).toBe(1);
|
|
});
|
|
|
|
test('removing a gstack group that one of your hooks follows in the same event refuses and leaves the file as it was, so Codex keeps trusting your hook', () => {
|
|
writeUser();
|
|
ensureRoute(); ensureGuard();
|
|
const doc = read();
|
|
doc.hooks.PreToolUse.push({ matcher: 'Bash', hooks: [{ type: 'command', command: '/usr/local/bin/my-late-guard' }] });
|
|
writeUser(doc);
|
|
const text = fs.readFileSync(hooksFile(), 'utf8');
|
|
for (const args of [['remove-source', '--source', 'gstack-destructive-guard'], ['prune-stale', '--all']]) {
|
|
const r = settingsHook(args);
|
|
expect(r.code).toBe(3);
|
|
expect(r.out).toContain('would move your own PreToolUse hooks');
|
|
expect(r.out).toContain('re-trust your hooks in Codex with /hooks');
|
|
expect(fs.readFileSync(hooksFile(), 'utf8')).toBe(text);
|
|
}
|
|
expect(ensureGuard().out).toContain('unchanged');
|
|
expect(settingsHook(['remove-source', '--source', 'gstack-skill-route']).code).toBe(0);
|
|
expect(read().hooks.UserPromptSubmit).toEqual(USER_FILE.hooks.UserPromptSubmit);
|
|
expect(read().hooks.PreToolUse).toEqual(doc.hooks.PreToolUse);
|
|
});
|
|
|
|
test('a symlinked hooks.json still reads config.toml from the Codex home, not from beside the link target', () => {
|
|
const home = path.join(dir, 'codex');
|
|
const dotfiles = path.join(dir, 'dotfiles');
|
|
fs.mkdirSync(home); fs.mkdirSync(dotfiles);
|
|
fs.writeFileSync(path.join(dotfiles, 'hooks.json'), JSON.stringify(USER_FILE, null, 2) + '\n');
|
|
fs.symlinkSync(path.join(dotfiles, 'hooks.json'), path.join(home, 'hooks.json'));
|
|
const linked = { GSTACK_SETTINGS_FILE: path.join(home, 'hooks.json') };
|
|
const cfg = path.join(home, 'config.toml');
|
|
fs.writeFileSync(cfg, '[[hooks.UserPromptSubmit]]\n[[hooks.UserPromptSubmit.hooks]]\ntype = "command"\ncommand = "' + ROUTE_CMD() + '"\n');
|
|
const route = ['ensure-event', '--event', 'UserPromptSubmit', '--command', ROUTE_CMD(), '--source', 'gstack-skill-route', '--timeout', '5'];
|
|
const r = settingsHook(route, linked);
|
|
expect(r.code).toBe(3);
|
|
expect(r.out).toContain(cfg + ' already declares gstack hook gstack-skill-route');
|
|
fs.writeFileSync(cfg, '[hooks.state."' + path.join(home, 'hooks.json') + ':user_prompt_submit:1:0"]\ntrusted_hash = "sha256:aa"\n');
|
|
expect(settingsHook(route, linked).code).toBe(0);
|
|
expect(settingsHook(['trust-status'], linked).out.trim()).toBe('gstack-skill-route\tUserPromptSubmit\ttrusted');
|
|
});
|
|
|
|
test('the formats stay apart: Codex rows never claim settings.json items, Claude rows never claim hooks.json items', () => {
|
|
const claudeShaped = { hooks: { PreToolUse: [{ matcher: 'Bash|PowerShell', hooks: [{ type: 'command', command: '/x/.claude/skills/gstack/hosts/claude/hooks/destructive-guard-hook', timeout: 10 }] }] } };
|
|
writeUser(claudeShaped);
|
|
expect(settingsHook(['prune-stale', '--all']).out).toContain('removed 0');
|
|
expect(read()).toEqual(claudeShaped);
|
|
const settings = path.join(dir, 'settings.json');
|
|
const codexShaped = { hooks: { PreToolUse: [{ matcher: 'Bash', hooks: [{ type: 'command', command: GUARD_CMD() }] }] } };
|
|
fs.writeFileSync(settings, JSON.stringify(codexShaped));
|
|
expect(settingsHook(['prune-stale', '--all'], { GSTACK_HOOKS_FORMAT: '', GSTACK_SETTINGS_FILE: settings }).out).toContain('removed 0');
|
|
expect(JSON.parse(fs.readFileSync(settings, 'utf8'))).toEqual(codexShaped);
|
|
});
|
|
|
|
test("Claude Code's settings.json entries for the three hooks are unchanged", () => {
|
|
const settings = path.join(dir, 'settings.json');
|
|
const claude = (args: string[]) => settingsHook(args, { GSTACK_HOOKS_FORMAT: '', GSTACK_SETTINGS_FILE: settings });
|
|
const root = '/home/you/.claude/skills/gstack/hosts/claude/hooks';
|
|
claude(['ensure-event', '--event', 'UserPromptSubmit', '--command', root + '/skill-route-hook', '--source', 'gstack-skill-route', '--timeout', '5']);
|
|
claude(['ensure-event', '--event', 'Stop', '--command', root + '/skill-contract-stop-hook', '--source', 'gstack-skill-contract', '--timeout', '10']);
|
|
claude(['ensure-event', '--event', 'PreToolUse', '--command', root + '/destructive-guard-hook', '--source', 'gstack-destructive-guard', '--timeout', '10', '--matcher', 'Bash|PowerShell']);
|
|
expect(fs.readFileSync(settings, 'utf8')).toBe(JSON.stringify({
|
|
hooks: {
|
|
UserPromptSubmit: [{ _gstack_source: 'gstack-skill-route', hooks: [{ type: 'command', command: root + '/skill-route-hook', timeout: 5 }] }],
|
|
Stop: [{ _gstack_source: 'gstack-skill-contract', hooks: [{ type: 'command', command: root + '/skill-contract-stop-hook', timeout: 10 }] }],
|
|
PreToolUse: [{ _gstack_source: 'gstack-destructive-guard', hooks: [{ type: 'command', command: root + '/destructive-guard-hook', timeout: 10 }], matcher: 'Bash|PowerShell' }],
|
|
},
|
|
}, null, 2) + '\n');
|
|
});
|
|
});
|
|
|
|
const route = (skill: string, trigger: string): RouteCandidate => ({ skill, score: 1, matched: 3, trigger, file: '/x/SKILL.md', gstack: true });
|
|
|
|
describe('skill routing on Codex', () => {
|
|
function codexSkills(): string {
|
|
const skills = path.join(dir, 'codex-skills');
|
|
for (const [entry, name] of [['gstack-review', 'review'], ['gstack-ship', 'ship'], ['gstack-qa', 'qa']]) {
|
|
fs.mkdirSync(path.join(skills, entry), { recursive: true });
|
|
fs.writeFileSync(path.join(skills, entry, 'SKILL.md'), '---\nname: ' + name + '\ndescription: |\n A Codex render keeps only name and description.\n---\nbody\n');
|
|
}
|
|
fs.mkdirSync(path.join(skills, 'my-notes'), { recursive: true });
|
|
fs.writeFileSync(path.join(skills, 'my-notes', 'SKILL.md'), '---\nname: my-notes\ndescription: notes\n---\n');
|
|
return skills;
|
|
}
|
|
|
|
test("gstack's Codex skills take Codex's names and the triggers of the same skill in this checkout", () => {
|
|
const { skills } = scanCodexSkills(codexSkills());
|
|
const review = skills.find(s => s.name === 'gstack-review');
|
|
expect(review?.gstack).toBe(true);
|
|
expect(review?.triggers).toContain('review my changes');
|
|
expect(skills.find(s => s.name === 'my-notes')?.triggers).toEqual([]);
|
|
const decision = routePrompt(PAYLOADS.UserPromptSubmit.prompt, skills, undefined, 'codex');
|
|
expect(decision.route?.skill).toBe('gstack-review');
|
|
});
|
|
|
|
test('a $ skill mention or a / command is never routed on Codex; on Claude Code a $ prompt still routes as before', () => {
|
|
const { skills } = scanCodexSkills(codexSkills());
|
|
expect(routePrompt('$gstack-review review my changes', skills, undefined, 'codex')).toMatchObject({ route: null, reason: 'skill-mention' });
|
|
expect(routePrompt('/review review my changes', skills, undefined, 'codex')).toMatchObject({ route: null, reason: 'slash-command' });
|
|
expect(routePrompt(' $ review my changes', skills).route?.skill).toBe('gstack-review');
|
|
});
|
|
|
|
test("the Codex line names Codex's skill; Claude Code's line is unchanged", () => {
|
|
expect(hintLine(route('review', 'review my changes'))).toBe('gstack skill routing (UserPromptSubmit hook; matched the installed /review trigger "review my changes"; off: gstack-config set skill_routing off): this request fits /review. Run /review with the Skill tool before you start, and tell the user in one sentence that gstack routed this to /review.');
|
|
expect(hintLine(route('review', 'review my changes'), '', route('qa', 'test the site'))).toBe('gstack skill routing (UserPromptSubmit hook; matched the installed /review trigger "review my changes" and the installed /qa trigger "test the site"; off: gstack-config set skill_routing off): this request fits /review or /qa. Run the one that fits better with the Skill tool before you start (/review if both fit), and tell the user in one sentence which skill gstack routed this to.');
|
|
expect(hintLine(route('gstack-review', 'review my changes'), '', undefined, 'codex')).toBe('gstack skill routing (UserPromptSubmit hook; matched the installed gstack-review trigger "review my changes"; off: gstack-config set skill_routing off): this request fits the gstack-review skill. Read and follow the gstack-review skill before you start, and tell the user in one sentence that gstack routed this to gstack-review.');
|
|
expect(hintLine(route('gstack-review', 'review my changes'), '', route('gstack-qa', 'test the site'), 'codex')).toContain('fits the gstack-review or gstack-qa skill. Read and follow the one that fits better before you start (gstack-review if both fit)');
|
|
});
|
|
|
|
test('the Codex shim answers a Codex payload with the Codex line, and prints nothing with skill_routing off', () => {
|
|
const skills = codexSkills();
|
|
const run = (env: Record<string, string> = {}) => spawnSync('bash', [path.join(ROOT, 'hosts', 'codex', 'hooks', 'codex-skill-route-hook')], {
|
|
input: JSON.stringify(PAYLOADS.UserPromptSubmit),
|
|
env: { PATH: process.env.PATH ?? '', HOME: dir, GSTACK_STATE_ROOT: path.join(dir, 'state'), GSTACK_INSTALLED_SKILLS_DIR: skills, ...env },
|
|
encoding: 'utf8', timeout: 30_000,
|
|
});
|
|
const r = run();
|
|
expect(r.status).toBe(0);
|
|
const out = JSON.parse(r.stdout).hookSpecificOutput;
|
|
expect(out.hookEventName).toBe('UserPromptSubmit');
|
|
expect(out.additionalContext).toContain('this request fits the gstack-review skill. Read and follow the gstack-review skill');
|
|
expect(fs.readFileSync(path.join(dir, 'state', 'hooks', 'skill-route.log'), 'utf8')).toMatch(/event=routed skill=gstack-review .*host=codex/);
|
|
expect(run({ GSTACK_SKILL_ROUTING: 'off' }).stdout).toBe('');
|
|
});
|
|
});
|
|
|
|
describe('the destructive-command check on Codex', () => {
|
|
const ask = (reason: string) => ({ decision: { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'ask', permissionDecisionReason: reason } } });
|
|
|
|
test('Codex has no ask: interactive sessions get a deny that tells the model to ask the user, others a warning; a deny stays a deny', () => {
|
|
expect(codexDecision(ask('[careful] Destructive: git reset --hard discards all uncommitted changes.'), 'interactive')).toEqual({
|
|
hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: '[careful] Destructive: git reset --hard discards all uncommitted changes. ' + CODEX_ASK_NOTE },
|
|
});
|
|
expect(CODEX_ASK_NOTE).toContain('stop and ask the user');
|
|
expect(CODEX_ASK_NOTE).toContain('typing ! followed by the command');
|
|
expect(CODEX_ASK_NOTE).toContain('gstack-config set destructive_guard off');
|
|
expect(codexDecision(ask('[careful] x.'), 'headless')).toEqual({ systemMessage: '[careful] x. ' + ASK_NOTE + ' Allowed without asking: this headless session has nobody to answer.' });
|
|
expect(codexDecision(ask('[careful] x.'), 'unattended')).toHaveProperty('systemMessage');
|
|
const deny = { decision: { hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: '[careful][HIGH] no.' } } };
|
|
for (const kind of ['interactive', 'headless']) {
|
|
expect(codexDecision(deny, kind)).toEqual({ hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: '[careful][HIGH] no.' } });
|
|
}
|
|
});
|
|
|
|
test('any ask category, including ones check-careful.sh adds later, takes the same path; everything else prints nothing', () => {
|
|
const later = codexDecision(ask('[careful] Destructive: a category added after this hook.'), 'interactive') as any;
|
|
expect(later.hookSpecificOutput.permissionDecision).toBe('deny');
|
|
expect(later.hookSpecificOutput.permissionDecisionReason).toStartWith('[careful] Destructive: a category added after this hook. Codex hooks cannot ask');
|
|
expect(codexDecision(null, 'interactive')).toBeNull();
|
|
expect(codexDecision({ raw: 'not json' }, 'interactive')).toBeNull();
|
|
expect(codexDecision({ decision: {} }, 'interactive')).toBeNull();
|
|
});
|
|
|
|
const guard = (payload: unknown, env: Record<string, string> = {}) => {
|
|
const r = spawnSync('bash', [path.join(ROOT, 'hosts', 'codex', 'hooks', 'codex-destructive-guard-hook')], {
|
|
input: JSON.stringify(payload),
|
|
env: { PATH: process.env.PATH ?? '', HOME: dir, GSTACK_STATE_ROOT: path.join(dir, 'state'), ...env },
|
|
encoding: 'utf8', timeout: 30_000,
|
|
});
|
|
expect(r.status).toBe(0);
|
|
return r.stdout.trim() ? JSON.parse(r.stdout) : null;
|
|
};
|
|
const withCommand = (command: string) => ({ ...PAYLOADS.PreToolUse, tool_input: { command } });
|
|
|
|
test('end to end on Codex payloads: ask maps by session kind, root deletes stay denied, only Codex output keys, off prints nothing', () => {
|
|
const interactive = guard(PAYLOADS.PreToolUse);
|
|
expect(interactive.hookSpecificOutput.permissionDecision).toBe('deny');
|
|
expect(interactive.hookSpecificOutput.permissionDecisionReason).toContain(CODEX_ASK_NOTE);
|
|
expect(Object.keys(interactive)).toEqual(['hookSpecificOutput']);
|
|
expect(Object.keys(interactive.hookSpecificOutput).sort()).toEqual(['hookEventName', 'permissionDecision', 'permissionDecisionReason']);
|
|
expect(guard(PAYLOADS.PreToolUse, { CI: '1' })).toEqual({ systemMessage: expect.stringContaining('Allowed without asking: this headless session') });
|
|
expect(guard(withCommand('rm -rf /'), { CI: '1' }).hookSpecificOutput.permissionDecision).toBe('deny');
|
|
expect(guard(PAYLOADS.PreToolUseTui)).toBeNull();
|
|
expect(guard(PAYLOADS.PreToolUse, { GSTACK_DESTRUCTIVE_GUARD: 'off' })).toBeNull();
|
|
});
|
|
});
|