Skip to content

OpenAI's Codex Security CLI and TypeScript SDK for finding, validating, and fixing security vulnerabilities. npm: https://www.npmjs.com/package/@openai/codex-security

fix(import): align required finding text across runtimes (#1706)

Michael D'Angelo2a7f9b6ddec6
diff --git a/plugins/codex-security/mcp-app/src/artifact-contracts.ts b/plugins/codex-security/mcp-app/src/artifact-contracts.ts
index c31269773..dc068a9bd 100644
--- a/plugins/codex-security/mcp-app/src/artifact-contracts.ts
+++ b/plugins/codex-security/mcp-app/src/artifact-contracts.ts
@@ -20,7 +20,13 @@ function pattern(schema: z.ZodString, source: string) {
});
}
-const nonEmptyText = z.string().min(1).regex(/\S/);
+// Match Python str.strip in both runtimes; \S differs on BOM and C0/NEL whitespace.
+const nonEmptyText = z
+ .string()
+ .min(1)
+ .regex(
+ /[^\u0009-\u000d\u001c-\u0020\u0085\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000]/,
+ );
const scanId = z
.string()
diff --git a/plugins/codex-security/mcp-app/tests/test_artifact_contracts.ts b/plugins/codex-security/mcp-app/tests/test_artifact_contracts.ts
index 687340ca7..1adfd79cd 100644
--- a/plugins/codex-security/mcp-app/tests/test_artifact_contracts.ts
+++ b/plugins/codex-security/mcp-app/tests/test_artifact_contracts.ts
@@ -1,8 +1,10 @@
import path from "node:path";
import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
import Ajv2020 from "ajv/dist/2020.js";
import { importSource } from "./import-module.ts";
import { readJson } from "./support/json.ts";
+import { finding as fixtureFinding } from "./scan-draft-fixture.ts";
const { artifactSchemaDocuments } = await importSource(
path.join(import.meta.dirname, "../src/artifact-contracts.ts"),
@@ -95,6 +97,70 @@ for (const [path, name, value, message] of [
// SDK JSON consumers disable formats; native tools retain Zod's UUID and safe
// integer validation. Generated exports must preserve both existing contracts.
const common = artifactSchemaDocuments["definitions/artifact-common"].$defs;
+const requiredTextValues = [
+ "",
+ " \t\r\n",
+ "\u0085",
+ "\u001c\u001d\u001e\u001f",
+ "\u00a0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000",
+ "\uFEFF",
+ "\u0085\uFEFF\u001c",
+ " Required text. \n",
+];
+const commonJson = await readJson(
+ import.meta.dirname,
+ "../../schemas/definitions/artifact-common.schema.json",
+);
+const pythonTextResults = JSON.parse(
+ execFileSync(
+ process.env.PYTHON || "python3",
+ [
+ "-c",
+ "import json, re, sys; values, pattern = json.load(sys.stdin.buffer); print(json.dumps([[bool(value.strip()), bool(re.search(pattern, value))] for value in values]))",
+ ],
+ {
+ input: JSON.stringify([
+ requiredTextValues,
+ commonJson.$defs.nonEmptyText.pattern,
+ ]),
+ encoding: "utf8",
+ },
+ ),
+) as [boolean, boolean][];
+const draftFinding = artifactSchemaDocuments["tools/scan-draft"].$defs.finding;
+for (const [index, value] of requiredTextValues.entries()) {
+ const [valid, pythonSchemaValid] = pythonTextResults[index]!;
+ assert.equal(pythonSchemaValid, valid);
+ assert.equal(common.nonEmptyText.safeParse(value).success, valid);
+ assert.equal(
+ jsonSchema("definitions/artifact-common", "nonEmptyText")(value),
+ valid,
+ );
+ for (const field of [
+ "title",
+ "summary",
+ "remediation",
+ "confidence.rationale",
+ "taxonomy.category",
+ "provenance.source",
+ "severity.scoringSystem",
+ ]) {
+ const finding: Record<string, unknown> = {
+ ...fixtureFinding("text", "src/file.ts"),
+ severity: { level: "high", score: 5, scoringSystem: "synthetic" },
+ };
+ const parts = field.split(".");
+ const object =
+ parts.length === 1
+ ? finding
+ : (finding[parts[0]!] as Record<string, unknown>);
+ object[parts.at(-1)!] = value;
+ const parsed = draftFinding.safeParse(finding);
+ assert.equal(parsed.success, valid, `${field}: ${JSON.stringify(value)}`);
+ if (parsed.success) assert.deepEqual(parsed.data, finding);
+ assert.equal(jsonSchema("tools/scan-draft", "finding")(finding), valid);
+ }
+}
const uuid = "61a20957-1be8-4ccf-8de8-eab4061e8cc3";
for (const [value, valid] of [
[uuid, true],
diff --git a/plugins/codex-security/schemas/definitions/artifact-common.schema.json b/plugins/codex-security/schemas/definitions/artifact-common.schema.json
index f2dcd094e..c3b6dc32f 100644
--- a/plugins/codex-security/schemas/definitions/artifact-common.schema.json
+++ b/plugins/codex-security/schemas/definitions/artifact-common.schema.json
@@ -2,7 +2,11 @@
"$schema": "https://json-schema.org/draft/2020-12/schema",
"$id": "codex-security://schemas/definitions/artifact-common.schema.json",
"$defs": {
- "nonEmptyText": { "type": "string", "minLength": 1, "pattern": "\\S" },
+ "nonEmptyText": {
+ "type": "string",
+ "minLength": 1,
+ "pattern": "[^\\u0009-\\u000d\\u001c-\\u0020\\u0085\\u00a0\\u1680\\u2000-\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000]"
+ },
"scanId": { "type": "string", "format": "uuid" },
"repositoryPath": {
"type": "string",
diff --git a/sdk/typescript/src/contract.ts b/sdk/typescript/src/contract.ts
index 345e6e468..09d20d03e 100644
--- a/sdk/typescript/src/contract.ts
+++ b/sdk/typescript/src/contract.ts
@@ -201,6 +201,11 @@ function normalizePersistedFindings(payload: unknown): unknown {
return compatible;
}
+/** Match the producer's Python str.strip without changing saved text. */
+export function hasRequiredFindingText(value: string): boolean {
+ return !/^[\p{White_Space}\u001c-\u001f]*$/u.test(value);
+}
+
function validateCanonicalContract(
manifest: ScanManifest,
findings: FindingsDocument,
@@ -292,8 +297,7 @@ function validateCanonicalContract(
? []
: [["severity.scoringSystem", finding.severity.scoringSystem]]),
]) {
- // Match the producer's Python str.strip without changing saved text.
- if (/^[\p{White_Space}\u001c-\u001f]*$/u.test(value ?? "")) {
+ if (!hasRequiredFindingText(value ?? "")) {
throw new ContractValidationError(
`${context}.${field}: expected a non-empty string.`,
);
diff --git a/sdk/typescript/src/findings-import.ts b/sdk/typescript/src/findings-import.ts
index fb7c71301..38140873b 100644
--- a/sdk/typescript/src/findings-import.ts
+++ b/sdk/typescript/src/findings-import.ts
@@ -1,5 +1,9 @@
import { isRecord } from "./record.js";
-import { deriveFindingIdentity, sha256Text as sha256 } from "./contract.js";
+import {
+ deriveFindingIdentity,
+ hasRequiredFindingText,
+ sha256Text as sha256,
+} from "./contract.js";
import { readFile } from "node:fs/promises";
import { isAbsolute, join, posix } from "node:path";
import Ajv2020 from "ajv/dist/2020.js";
@@ -309,7 +313,7 @@ export function csvRowFinding(row: CsvFindingRow): Finding {
}
function requiredCsvText(column: string) {
- return z.string().refine((value) => value.trim().length > 0, {
+ return z.string().refine(hasRequiredFindingText, {
error: `requires ${column}`,
});
}
diff --git a/sdk/typescript/tests-ts/findings-import.test.ts b/sdk/typescript/tests-ts/findings-import.test.ts
index 541dc6fcb..57918f9ec 100644
--- a/sdk/typescript/tests-ts/findings-import.test.ts
+++ b/sdk/typescript/tests-ts/findings-import.test.ts
@@ -88,7 +88,7 @@ describe("findings import formats", () => {
).rejects.toThrow("duplicate occurrence_id");
});
- test("round-trips literal apostrophes and spreadsheet escapes through the exporter", async () => {
+ test("round-trips required text and spreadsheet escapes through the exporter", async () => {
const {
findings: [finding],
} = await sourceDocument();
@@ -100,6 +100,9 @@ describe("findings import formats", () => {
"''-x",
"''literal",
"ordinary λ",
+ "\uFEFF",
+ "\u0085\uFEFF\u001c",
+ " Required text. \n",
"=formula",
"\u0085=formula",
"\u001c=formula",
@@ -144,6 +147,25 @@ describe("findings import formats", () => {
}
});
+ test.each(
+ (["title", "summary", "remediation"] as const).flatMap((field) =>
+ [" \t\r\n", "\u0085", "\u001c\u001d\u001e\u001f"].map(
+ (value) => [field, value] as const,
+ ),
+ ),
+ )("rejects canonical whitespace in CSV %s %j", async (field, value) => {
+ const {
+ findings: [finding],
+ } = await sourceDocument();
+ await expect(
+ parseImportedFindings(
+ exportCsv([{ ...finding!, [field]: value }]),
+ "csv",
+ PLUGIN_ROOT,
+ ),
+ ).rejects.toThrow(`requires ${field}`);
+ });
+
test("retains a literal apostrophe before a non-whitespace byte order mark", async () => {
const title = "'\uFEFF=formula";
const [imported] = await parseImportedFindings(
diff --git a/sdk/typescript/tests-ts/import-scan.test.ts b/sdk/typescript/tests-ts/import-scan.test.ts
index 5b8ccab53..33a278d8c 100644
--- a/sdk/typescript/tests-ts/import-scan.test.ts
+++ b/sdk/typescript/tests-ts/import-scan.test.ts
@@ -297,6 +297,33 @@ test.each(["csv", "json"] as const)(
},
);
+test("CSV import seals and reloads non-whitespace byte order marks in required text", async () => {
+ const context = await fixture();
+ const title = "\uFEFF";
+ const source = context.source.replaceAll(
+ "Reported archive extraction issue",
+ title,
+ );
+ await writeFile(context.options.sourcePath, source);
+ expect(
+ await importScan(
+ { ...context.options, dryRun: true },
+ context.dependencies,
+ ),
+ ).toMatchObject({ findingCount: 2 });
+ const result = completed(
+ await importScan(context.options, context.dependencies),
+ );
+ const loaded = await loadContract(result.scanDir, {
+ pluginRoot: PLUGIN_ROOT,
+ });
+ expect(loaded.findings.findings.map((finding) => finding.title)).toEqual([
+ title,
+ title,
+ ]);
+ expect(await readFile(context.options.sourcePath, "utf8")).toBe(source);
+});
+
test.each(["csv", "json"] as const)(
"empty %s imports preserve source integrity without claiming an analyzed surface",
async (format) => {