OpenAI's Codex Security CLI and TypeScript SDK for finding, validating, and fixing security vulnerabilities. npm: https://www.npmjs.com/package/@openai/codex-security
TypeScript ai-securityapplication-securityclicode-scanningcodexcodex-securitycybersecuritydevsecopsnodejsnpmopenaisdksecuritytypescriptvulnerability-scanning
import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
import { dirname, join } from "node:path";
import { Writable } from "node:stream";
import { afterEach, describe, expect, test, mock } from "bun:test";
import { main } from "../src/cli.js";
import {
securityPolicyDiff,
type SecurityPolicyDraft,
type SecurityPolicyOptions,
} from "../src/index.js";
import { formatSecurityPolicyText } from "../src/security-policy.js";
import type { PolicyPrompt } from "../src/security-policy-cli.js";
import { capture, dependencies, FakeSignals } from "./cli-fixtures.js";
import {
POLICY,
PYTHON,
createPolicyTestFixtures,
stageResult,
} from "./support/security-policy.js";
import { rejecting, throwing } from "./support/errors.js";
import {
createCliTest,
captureCli,
runCapturedCli,
} from "./support/cli-run.js";
const { fixture, cleanup } = createPolicyTestFixtures();
afterEach(cleanup);
function prompt(overrides: Partial<PolicyPrompt> = {}): PolicyPrompt {
return {
isInteractive: () => false,
input: rejecting("Unexpected input prompt"),
...overrides,
};
}
function policyDependencies(
f: Awaited<ReturnType<typeof fixture>>,
options: {
draft?: SecurityPolicyDraft;
prompt?: PolicyPrompt;
onGenerate?: (
repository: string,
options: SecurityPolicyOptions,
) => void | Promise<void>;
onPreflight?: (
repository: string,
options: SecurityPolicyOptions,
) => void | Promise<void>;
onClose?: () => void;
onPreview?: () => void;
onConfig?: (config: unknown) => void;
signals?: FakeSignals;
} = {},
) {
return {
...dependencies({
currentDirectory: f.repository,
signals: options.signals,
}),
policyPrompt: options.prompt ?? prompt(),
createPolicySecurity: (config: unknown) => {
options.onConfig?.(config);
return {
generatePolicy: async (
repository: string,
generation: SecurityPolicyOptions,
) => {
await options.onGenerate?.(repository, generation);
generation.onOutputDirReady?.(f.outputDir);
generation.onStage?.("architecture");
generation.onStage?.("threat_model");
generation.onStage?.("policy");
return (
options.draft ??
(await f.generate({
path: generation.path,
answerQuestions: generation.answerQuestions,
}))
);
},
preflightPolicy: async (
repository: string,
generation: SecurityPolicyOptions,
) => {
await options.onPreflight?.(repository, generation);
return {
repository: f.repository,
scope: ".",
targetPath: join(f.repository, "SECURITY.md"),
outputDir: null,
authentication: {
method: "stored_credentials" as const,
verified: false as const,
},
model: "gpt-5.6-sol",
reasoningEffort: "xhigh",
};
},
previewPolicy: async (
draft: SecurityPolicyDraft,
preview: { signal?: AbortSignal } = {},
) => {
options.onPreview?.();
return formatSecurityPolicyText(
await securityPolicyDiff(draft, PYTHON, preview.signal),
true,
);
},
close: async () => {
options.onClose?.();
},
};
},
};
}
describe("policy CLI", () => {
test.each(["openai", "openrouter", "amazon-bedrock", "command"] as const)(
"uses the file-profile %s provider before interactive policy authentication",
async (provider) => {
const f = await fixture();
const home = join(f.root, "profile-home");
await mkdir(home, { mode: 0o700 });
await writeFile(
join(home, "review.config.toml"),
provider === "command"
? 'model_provider = "synthetic-command"\n[model_providers.synthetic-command]\nname = "Synthetic"\nwire_api = "responses"\n[model_providers.synthetic-command.auth]\ncommand = "synthetic-auth"\n'
: `model_provider = "${provider}"\n`,
);
const draft = await f.generate();
let authPrompts = 0;
const deps = {
...policyDependencies(f, {
draft,
prompt: prompt({ isInteractive: () => true }),
}),
environment: {
CODEX_HOME: home,
OPENAI_API_KEY: "synthetic-openai-key",
},
hasStoredChatGPTSignIn: async () => true,
scanAuthenticationPrompt: {
isInteractive: () => true,
select: async <T>(
_message: string,
choices: readonly { value: T }[],
) => {
authPrompts += 1;
return choices[0]!.value;
},
},
};
const code = await main(
["policy", "--codex", 'profile="review"'],
capture().stream,
capture(true).stream,
deps,
);
expect(code).toBe(0);
expect(authPrompts).toBe(provider === "openai" ? 1 : 0);
},
);
test("documents the policy workflow in help", async () => {
const stdout = captureCli(main, "stdout");
expect(await stdout.run(["policy", "--help"], dependencies())).toBe(0);
expect(stdout.text()).toContain("SECURITY.md");
expect(stdout.text()).not.toContain("--apply");
expect(stdout.text()).not.toContain("--write");
expect(stdout.text()).toContain("--headless");
expect(stdout.text()).not.toContain("--outputDir");
expect(stdout.text()).not.toContain("--write true");
expect(stdout.text()).toContain(
"codex-security policy . --output-dir ../policy-draft --json",
);
});
test("generates a headless draft with machine-readable paths and no source edits", async () => {
const f = await fixture();
const draft = await f.generate();
draft.cost = {
model: "synthetic-model",
inputTokens: 1,
cachedInputTokens: 0,
cacheWriteInputTokens: 0,
outputTokens: 1,
estimatedUsd: 1,
estimatedUsdRange: { min: 1, max: 2, context: "unknown" },
};
const { stdout, stderr, runCli } = createCliTest(main);
const onClose = mock();
const onConfig = mock<(config: unknown) => void>();
expect(
await runCli(
[
"policy",
".",
"--headless",
"--model",
"gpt-5.6-terra",
"--effort",
"high",
"--json",
],
policyDependencies(f, {
draft,
onClose,
onConfig,
}),
),
).toBe(0);
const result = JSON.parse(stdout.text());
expect(result.status).toBe("draft");
expect(result.targetPath).toBe(join(f.repository, "SECURITY.md"));
expect(result.threatModelPath).toBe(join(f.outputDir, "threatmodel.md"));
expect(result.cost).toEqual(draft.cost);
expect(stderr.text()).toContain("$1.00–$2.00 (standard, context unknown)");
expect(stderr.text()).toContain("[1/3]");
expect(stderr.text()).not.toContain("+Requests must be authorized");
expect(onConfig.mock.lastCall?.[0]).toMatchObject({
codexOverrides: {
model: "gpt-5.6-terra",
model_reasoning_effort: "high",
},
});
expect(await readdir(f.repository)).toEqual([]);
expect(onClose).toHaveBeenCalled();
});
test("offers the scan credential chooser before interactive policy generation", async () => {
const f = await fixture();
const draft = await f.generate();
for (const [source, selection] of [
["OPENAI_API_KEY", "chatgpt"],
["CODEX_API_KEY", "api-key"],
] as const) {
let selected: SecurityPolicyOptions["auth"];
let question = "";
let choices: readonly { label: string; value: string }[] = [];
const stderr = capture(true);
const deps = policyDependencies(f, {
draft,
prompt: prompt({
isInteractive: () => true,
}),
onGenerate: (_repository, options) => {
selected = options.auth;
},
});
deps.environment = { [source]: "synthetic-private-key" };
deps.hasStoredChatGPTSignIn = async () => true;
deps.scanAuthenticationPrompt = {
isInteractive: () => true,
select: async <Value extends string>(
message: string,
options: readonly { label: string; value: Value }[],
): Promise<Value> => {
question = message;
choices = options;
return options.find((option) => option.value === selection)!.value;
},
};
expect(
await main(["policy"], capture(true).stream, stderr.stream, deps),
).toBe(0);
expect(selected).toBe(selection);
expect(question).toContain("policy generation");
expect(choices.map((choice) => choice.value)).toEqual([
"chatgpt",
"api-key",
]);
expect(stderr.text()).toContain(source);
expect(stderr.text()).not.toContain("synthetic-private-key");
}
expect(await readdir(f.repository)).toEqual([]);
});
test("does not choose credentials for automated, explicit policy requests", async () => {
const f = await fixture();
const draft = await f.generate();
for (const scenario of [
{ args: ["--headless"] },
{ args: ["--json"] },
{ args: ["--format", "toon"] },
{ args: ["--dry-run"] },
{ args: ["--auth", "chatgpt"] },
{ args: ["--auth", "api-key"] },
{ args: ["--provider", "openrouter", "--model", "vendor/model"] },
{ args: [], ci: true },
{ args: [], stored: false },
{ args: [], key: false },
{ args: [], terminal: false },
{ args: [], inputInteractive: false },
]) {
let choices = 0;
const deps = policyDependencies(f, {
draft,
prompt: prompt({
isInteractive: () => scenario.inputInteractive !== false,
}),
});
deps.environment = {
...(scenario.key === false
? {}
: { OPENAI_API_KEY: "synthetic-private-key" }),
...(scenario.ci ? { CI: "1" } : {}),
};
deps.hasStoredChatGPTSignIn = async () => scenario.stored !== false;
deps.scanAuthenticationPrompt = {
isInteractive: () => true,
select: async <Value extends string>(
_message: string,
options: readonly { label: string; value: Value }[],
): Promise<Value> => {
choices++;
return options[0]!.value;
},
};
expect(
await main(
["policy", ...scenario.args],
capture().stream,
capture(scenario.terminal !== false).stream,
deps,
),
).toBe(0);
expect(choices).toBe(0);
}
expect(await readdir(f.repository)).toEqual([]);
});
test("cancels credential selection before starting the policy runtime", async () => {
for (const phase of ["status", "prompt"] as const) {
const f = await fixture();
const signals = new FakeSignals();
const onConfig = mock();
const deps = policyDependencies(f, {
signals,
prompt: prompt({ isInteractive: () => true }),
onConfig,
});
deps.environment = { OPENAI_API_KEY: "synthetic-private-key" };
deps.hasStoredChatGPTSignIn = async (signal) => {
expect(signal).toBeDefined();
if (phase === "status") {
queueMicrotask(() => signals.emit("SIGTERM"));
return await new Promise<boolean>(() => {});
}
return true;
};
deps.scanAuthenticationPrompt = {
isInteractive: () => true,
select: async <Value extends string>(
_message: string,
_options: readonly { label: string; value: Value }[],
_presentation?: { header?: string },
signal?: AbortSignal,
): Promise<Value> => {
expect(signal).toBeDefined();
queueMicrotask(() => signals.emit("SIGTERM"));
return await new Promise<Value>(() => {});
},
};
expect(
await main(["policy"], capture().stream, capture(true).stream, deps),
).toBe(143);
expect(onConfig).not.toHaveBeenCalled();
expect(await readdir(f.outputDir)).toEqual([]);
expect(signals.listeners.get("SIGTERM")?.size).toBe(0);
}
});
test("does not present a partial cost as the final estimate", async () => {
const f = await fixture();
const draft = await f.generate();
const { stdout, stderr, runCli } = createCliTest(main);
expect(
await runCli(
["policy", "--headless", "--json"],
policyDependencies(f, {
draft,
onGenerate: (_repository, options) =>
options.onCost?.({
model: "synthetic-model",
inputTokens: 1,
cachedInputTokens: 0,
cacheWriteInputTokens: 0,
outputTokens: 1,
estimatedUsd: 0.5,
}),
}),
),
).toBe(0);
expect(JSON.parse(stdout.text()).cost).toBeNull();
expect(stderr.text()).not.toContain("$0.50");
});
test("preserves a headless result when optional progress writes throw", async () => {
const f = await fixture();
const stdout = capture();
expect(
await main(
["policy", "--headless", "--json"],
stdout.stream,
{
write: throwing("Progress output failed"),
},
policyDependencies(f),
),
).toBe(0);
expect(JSON.parse(stdout.text()).status).toBe("draft");
expect(await readdir(f.repository)).toEqual([]);
});
test("preserves a completed draft when runtime cleanup fails", async () => {
const f = await fixture();
const { stdout, stderr, runCli } = createCliTest(main);
expect(
await runCli(
["policy", "--headless", "--json"],
policyDependencies(f, {
onClose: throwing("synthetic cleanup failure"),
}),
),
).toBe(0);
expect(JSON.parse(stdout.text()).status).toBe("draft");
expect(stderr.text()).toContain("Could not clean up the policy runtime");
});
test("isolates asynchronous progress stream errors", async () => {
const f = await fixture();
const stdout = capture();
const stderr = new Writable({
autoDestroy: false,
write(_chunk, _encoding, callback) {
queueMicrotask(() => callback(new Error("Progress output failed")));
},
});
const failure = new Promise<Error>((resolve) =>
stderr.once("error", resolve),
);
expect(
await main(
["policy", "--headless", "--json"],
stdout.stream,
stderr,
policyDependencies(f),
),
).toBe(0);
await expect(failure).resolves.toMatchObject({
message: "Progress output failed",
});
expect(JSON.parse(stdout.text()).status).toBe("draft");
});
test("preserves a completed draft when writing the preview fails", async () => {
const f = await fixture();
const draft = await f.generate();
expect(
await main(
["policy"],
capture(true).stream,
{
isTTY: true,
write: (value: string) => {
if (value.includes("Policy target:"))
throw new Error("Preview output failed");
return true;
},
},
policyDependencies(f, {
draft,
prompt: prompt({ isInteractive: () => true }),
}),
),
).toBe(0);
expect(await readFile(draft.draftPath, "utf8")).toBe(POLICY);
expect(await readdir(f.repository)).toEqual([]);
});
test("preserves a completed draft when the diff preview fails", async () => {
const f = await fixture();
const stderr = capture(true);
const draft = await f.generate();
expect(
await main(
["policy"],
capture(true).stream,
stderr.stream,
policyDependencies(f, {
draft,
onPreview: throwing("Python preview failed"),
}),
),
).toBe(0);
expect(stderr.text()).toContain("Python preview failed");
expect(stderr.text()).toContain(draft.draftPath);
expect(await readFile(draft.draftPath, "utf8")).toBe(POLICY);
});
test("asks owner questions and previews the exact draft without writing source", async () => {
const f = await fixture();
const stderr = capture(true);
const input = mock(async (question: string) => {
expect(question).toContain("internet-facing");
return "Private service";
});
expect(
await main(
["policy"],
capture(true).stream,
stderr.stream,
policyDependencies(f, {
prompt: prompt({
isInteractive: () => true,
input,
}),
}),
),
).toBe(0);
expect(input).toHaveBeenCalledTimes(1);
expect(stderr.text()).toContain("--- /dev/null");
expect(stderr.text()).toContain("+Requests must be authorized");
expect(stderr.text()).toContain("Review notes:");
expect(stderr.text()).toContain("No repository files changed");
expect(await readFile(join(f.outputDir, "SECURITY.md"), "utf8")).toBe(
POLICY,
);
expect(await readdir(f.repository)).toEqual([]);
});
test("preserves significant trailing spaces in the proposed diff", async () => {
const f = await fixture();
const draft = await f.generate({
run: async (stage) => stageResult(stage, "# Policy\n\nLast line \n"),
});
const stderr = capture(true);
expect(
await main(
["policy"],
capture(true).stream,
stderr.stream,
policyDependencies(f, {
draft,
prompt: prompt({
isInteractive: () => true,
}),
}),
),
).toBe(0);
expect(stderr.text()).toContain("+Last line \n");
});
test("preflights without generation", async () => {
const f = await fixture();
const stdout = captureCli(main, "stdout");
const deps = policyDependencies(f, {
onGenerate: throwing("Must not generate"),
});
expect(await stdout.run(["policy", "--dry-run", "--json"], deps)).toBe(0);
expect(JSON.parse(stdout.text()).dryRun).toBe(true);
expect(await readdir(f.outputDir)).toEqual([]);
});
test("propagates dry-run cancellation and never returns false success", async () => {
for (const [signal, exitCode] of [
["SIGINT", 130],
["SIGTERM", 143],
] as const) {
for (const cooperative of [false, true]) {
const f = await fixture();
const signals = new FakeSignals();
const stdout = captureCli(main, "stdout");
const onClose = mock();
expect(
await stdout.run(
["policy", "--dry-run", "--json"],
policyDependencies(f, {
signals,
onPreflight: (_repository, options) => {
signals.emit(signal);
expect(options.signal?.aborted).toBe(true);
if (cooperative) options.signal!.throwIfAborted();
},
onClose,
}),
),
).toBe(exitCode);
expect(stdout.text()).toBe("");
expect(onClose).toHaveBeenCalled();
expect(signals.listeners.get(signal)?.size).toBe(0);
expect(await readdir(f.outputDir)).toEqual([]);
}
}
});
test("returns only policy Markdown on stdout in Markdown mode", async () => {
const f = await fixture();
const markdown = `${POLICY.trimEnd()} `;
const draft = await f.generate({
run: async (stage) => stageResult(stage, markdown),
});
const stdout = captureCli(main, "stdout");
expect(
await stdout.run(
["policy", "--format", "md"],
policyDependencies(f, { draft }),
),
).toBe(0);
expect(stdout.text()).toBe(markdown);
expect(await readdir(f.repository)).toEqual([]);
});
test("returns policy metadata for explicit formats and filters without prompting", async () => {
const f = await fixture();
const draft = await f.generate();
const deps = policyDependencies(f, {
draft,
prompt: prompt({ isInteractive: () => true }),
onGenerate: (_repository, options) =>
expect(options.answerQuestions).toBeUndefined(),
});
for (const [args, marker] of [
[["--json"], '"status": "draft"'],
[["--format", "jsonl"], '"status":"draft"'],
[["--format", "toon"], "status: draft"],
[["--format=toon"], "status: draft"],
[["--format", "yaml"], "status: draft"],
[["--full-output"], "ok: true"],
[["--filter-output", "status"], "draft"],
[["--format", "md", "--filter-output", "status"], "draft"],
] as const) {
const { stdout, stderr, runCli } = createCliTest(main, {
stdout: true,
stderr: true,
});
expect(await runCli(["policy", ...args], deps)).toBe(0);
expect(stdout.text()).toContain(marker);
expect(stderr.text()).not.toContain(
draft.content.split("\n").filter(Boolean).at(-1)!,
);
expect(stderr.text()).not.toContain(draft.reviewNotes[0]!);
}
const stdout = captureCli(main, "stdout");
expect(await stdout.run(["policy", "--json", "--full-output"], deps)).toBe(
0,
);
expect(JSON.parse(stdout.text())).toMatchObject({
ok: true,
data: { status: "draft", draftPath: draft.draftPath },
});
expect(await readdir(f.repository)).toEqual([]);
});
test("honors token transforms for policy metadata and Markdown", async () => {
const f = await fixture();
const draft = await f.generate();
const deps = policyDependencies(f, {
draft,
prompt: prompt({ isInteractive: () => true }),
});
for (const format of [[], ["--format", "md"]]) {
for (const transform of [
["--token-count"],
["--token-limit", "4"],
["--token-offset", "1"],
["--token-offset", "1", "--token-limit", "4"],
]) {
const { stdout, stderr, runCli } = createCliTest(main);
expect(await runCli(["policy", ...format, ...transform], deps)).toBe(0);
expect(stderr.text()).not.toContain(
draft.content.split("\n").filter(Boolean).at(-1)!,
);
expect(stderr.text()).not.toContain(draft.reviewNotes[0]!);
if (transform[0] === "--token-count") {
expect(stdout.text().trim()).toMatch(/^\d+$/u);
expect(Number(stdout.text())).toBeGreaterThan(0);
} else {
expect(stdout.text()).toContain("[truncated: showing tokens ");
expect(stdout.text()).not.toContain(POLICY);
}
}
}
const stdout = captureCli(main, "stdout");
expect(
await stdout.run(["policy", "--format", "md", "--full-output"], deps),
).toBe(0);
expect(stdout.text()).toContain("## data");
expect(stdout.text()).toContain(POLICY.trim());
expect(await readdir(f.repository)).toEqual([]);
});
test("renders TOON metadata safely while preserving JSON and Markdown", async () => {
const f = await fixture();
const scope = "component\u202ename";
const note = "Review\u202ethis\u001b[2J";
const content = `${POLICY}\n${note}\n`;
await mkdir(join(f.repository, scope));
const draft = await f.generate({
path: scope,
run: async (stage) => stageResult(stage, content, note),
});
const onPreview = mock();
const deps = policyDependencies(f, { draft, onPreview });
const create = deps.createPolicySecurity;
deps.createPolicySecurity = (config) => {
const security = create(config);
return {
...security,
preflightPolicy: async (repository, options) => ({
...(await security.preflightPolicy(repository, options)),
scope,
targetPath: draft.targetPath,
}),
};
};
for (const args of [["--dry-run"], ["--format", "toon"]]) {
const stdout = captureCli(main, "stdout", true);
expect(await stdout.run(["policy", ...args], deps)).toBe(0);
expect(stdout.text()).not.toMatch(/[\u001b\p{Bidi_Control}]/u);
expect(stdout.text()).toContain("\\u202e");
}
const json = captureCli(main, "stdout");
expect(await json.run(["policy", "--json"], deps)).toBe(0);
expect(JSON.parse(json.text())).toMatchObject({
scope,
reviewNotes: expect.arrayContaining([note]),
});
const markdown = captureCli(main, "stdout");
expect(await markdown.run(["policy", "--format", "md"], deps)).toBe(0);
expect(markdown.text()).toBe(content);
expect(onPreview).not.toHaveBeenCalled();
});
test("marks failed generation and cancellation envelopes as errors", async () => {
const f = await fixture();
for (const [signal, expectedExit] of [
[undefined, 2],
["SIGINT", 130],
["SIGTERM", 143],
] as const) {
const signals = new FakeSignals();
const { stdout, stderr, runCli } = createCliTest(main);
expect(
await runCli(
["policy", "--json", "--full-output"],
policyDependencies(f, {
signals,
onGenerate: (_repository, options) => {
if (signal !== undefined) {
signals.emit(signal);
options.signal!.throwIfAborted();
}
throw new Error("Synthetic generation failure");
},
}),
),
).toBe(expectedExit);
const result = JSON.parse(stdout.text());
expect(result).toMatchObject({
ok: false,
error: { code: "POLICY_FAILED" },
});
expect(result).not.toHaveProperty("data");
expect(stderr.text()).toContain(result.error.message);
}
expect(await readdir(f.repository)).toEqual([]);
});
test("keeps policy argument and schema errors in full-output stdout", async () => {
const f = await fixture();
const createPolicySecurity = mock(
throwing("Validation must finish before initializing Codex"),
);
const deps = policyDependencies(f);
deps.createPolicySecurity = createPolicySecurity;
for (const [args, message] of [
[["policy", "--write"], "Unknown flag"],
[["policy", "--path"], "Missing value"],
[["policy", "--path", "--headless"], "Missing value"],
[["policy", ".", "extra"], "Unexpected positional argument"],
[["policy", "--unknown-policy-option"], "Unknown flag"],
[["policy", "--max-cost", "0"], "Too small"],
] as const) {
for (const leadingOutputFlags of [false, true]) {
const flags = ["--json", "--full-output"];
const { stdout, stderr, runCli } = createCliTest(main);
expect(
await runCli(
leadingOutputFlags ? [...flags, ...args] : [...args, ...flags],
deps,
),
).toBe(2);
const result = JSON.parse(stdout.text());
expect(result.ok).toBe(false);
expect(result.error.message).toContain(message);
expect(stderr.text()).not.toContain('"ok": false');
}
}
expect(createPolicySecurity).not.toHaveBeenCalled();
expect(await readdir(f.repository)).toEqual([]);
});
test("returns a full-output error when policy setup fails", async () => {
const f = await fixture();
const deps = policyDependencies(f);
deps.currentDirectory = throwing("Working directory is unavailable");
const stdout = capture();
expect(
await main(
["policy", "--json", "--full-output"],
stdout.stream,
{
write: throwing("Diagnostic output failed"),
},
deps,
),
).toBe(2);
expect(JSON.parse(stdout.text())).toMatchObject({
ok: false,
error: {
code: "POLICY_FAILED",
message: "Working directory is unavailable",
},
});
});
test("renders terminal controls visibly without changing reviewed bytes", async () => {
const f = await fixture();
const controls =
"\u061c\u200e\u200f\u202a\u202b\u202c\u202d\u202e\u2066\u2067\u2068\u2069";
const scope = `component${controls}name`;
await mkdir(join(f.repository, scope));
const draft = await f.generate({ path: scope });
const controlled = `${POLICY}\nLiteral \u001b[2J text.${controls}\n`;
await writeFile(draft.draftPath, controlled);
const stderr = captureCli(main, "stderr");
expect(
await stderr.run(
["policy", "--path", scope],
policyDependencies(f, { draft: { ...draft, content: controlled } }),
),
).toBe(0);
expect(stderr.text()).not.toContain("\u001b");
expect(stderr.text()).not.toMatch(/\p{Bidi_Control}/u);
expect(stderr.text()).toContain("\\u001b[2J");
for (const character of controls)
expect(stderr.text()).toContain(
`\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`,
);
expect(await readFile(draft.draftPath, "utf8")).toBe(controlled);
expect(await readdir(dirname(draft.targetPath))).toEqual([]);
});
test("returns the interrupt exit code and removes signal listeners", async () => {
const f = await fixture();
const signals = new FakeSignals();
const onClose = mock();
expect(
await runCapturedCli(
main,
["policy", "--headless"],
policyDependencies(f, {
signals,
onClose,
onGenerate: (_repository, options) => {
signals.emit("SIGINT");
options.signal!.throwIfAborted();
},
}),
),
).toBe(130);
expect(onClose).toHaveBeenCalled();
expect(
[...signals.listeners.values()].every(
(listeners) => listeners.size === 0,
),
).toBe(true);
expect(await readdir(f.repository)).toEqual([]);
});
test("treats Inquirer's Ctrl-C error as cancellation without a process signal", async () => {
const f = await fixture();
const stderr = capture(true);
expect(
await main(
["policy"],
capture(true).stream,
stderr.stream,
policyDependencies(f, {
prompt: prompt({
isInteractive: () => true,
input: async () => {
throw Object.assign(new Error("Prompt closed"), {
name: "ExitPromptError",
});
},
}),
}),
),
).toBe(130);
expect(stderr.text()).toContain("canceled by Ctrl-C");
expect(await readdir(f.repository)).toEqual([]);
});
});