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
refactor(plugin): port candidate normalization to TypeScript (#837)
Kyle Brown67dee92afe94
diff --git a/plugins/codex-security/mcp-app/helpers-main.ts b/plugins/codex-security/mcp-app/helpers-main.tsindex 18c8611be..29d07df72 100644--- a/plugins/codex-security/mcp-app/helpers-main.ts+++ b/plugins/codex-security/mcp-app/helpers-main.ts@@ -1,6 +1,8 @@+import { closeSync, readFileSync } from "node:fs";import { resolveSecurityMdCommand } from "./src/helpers/resolve-security-md";import { decodePosixBytes } from "./src/helpers/posix-path";import { windowsBinding } from "./src/native";+import { normalizeCandidatesCommand } from "./src/helpers/normalize-candidates";let commandLine = process.argv.slice(2);if (process.platform === "win32") {@@ -14,8 +16,10 @@ if (commandLine[0] === "--helper") {if (process.platform === "win32") {commandLine = commandLine.slice(1);} else {+ const encoded = readFileSync(3, "ascii");+ closeSync(3);const [homeSet, home, ...args] = decodePosixBytes(- Buffer.from(commandLine[1] ?? "", "hex"),+ Buffer.from(encoded.trim(), "hex"),).split("\0").slice(0, -1);@@ -26,9 +30,11 @@ if (commandLine[0] === "--helper") {const [command, ...args] = commandLine;if (command === "resolve-security-md") {process.exitCode = resolveSecurityMdCommand(args, posixHome);+} else if (command === "normalize-candidates") {+ process.exitCode = normalizeCandidatesCommand(args, posixHome);} else {console.error(- "Usage: launch_codex_security_mcp[.cmd] --helper resolve-security-md [options]",+ "Usage: launch_codex_security_mcp[.cmd] --helper <resolve-security-md | normalize-candidates> [options]",);process.exitCode = 2;}diff --git a/plugins/codex-security/mcp-app/src/artifact-discovery.ts b/plugins/codex-security/mcp-app/src/artifact-discovery.tsindex 10ff561a0..86a9f190c 100644--- a/plugins/codex-security/mcp-app/src/artifact-discovery.ts+++ b/plugins/codex-security/mcp-app/src/artifact-discovery.ts@@ -17,10 +17,6 @@ import {type SchemaDocument,} from "./artifact-schema-loader.js";import { candidateSchemaV1 } from "./deep-scan/artifact-contracts.js";-import {- missingPythonHelperMessage,- resolvePythonCommand,-} from "./python_command.js";const execFileAsync = promisify(execFile);const discoveryComponents = ["artifacts", "02_discovery"] as const;@@ -144,7 +140,7 @@ export async function recordCodexSecurityDiscoveryCandidates("candidate_ledger.jsonl",];- // Verify the inventory is a context-bound regular file before passing it to Python.+ // Verify the inventory is a context-bound regular file before normalization.await readArtifactText(context,inventoryComponents,@@ -167,23 +163,21 @@ export async function recordCodexSecurityDiscoveryCandidates(try {await fs.chmod(temporaryDirectory, 0o700);- const content =- candidates.length === 0- ? ""- : `${candidates.map((candidate) => JSON.stringify(candidate)).join("\n")}\n`;+ const content = candidates+ .map((candidate) => `${JSON.stringify(candidate)}\n`)+ .join("");await fs.writeFile(temporaryInput, content, {encoding: "utf8",flag: "wx",mode: 0o600,});- const pythonCommand =- context.pythonCommand ?? (await resolvePythonCommand());try {await execFileAsync(- pythonCommand,+ process.execPath,[- join(pluginRoot, "scripts", "normalize_candidates.py"),+ join(pluginRoot, "mcp", "helpers.mjs"),+ "normalize-candidates","--input",temporaryInput,"--out",@@ -201,7 +195,7 @@ export async function recordCodexSecurityDiscoveryCandidates(},);} catch (error) {- throw discoveryNormalizationError(error, pythonCommand, [+ throw discoveryNormalizationError(error, [[temporaryInput, "candidate input"],[temporaryDirectory, "private candidate input"],[inventoryPath, "the assigned review inventory"],@@ -245,14 +239,8 @@ export async function listCodexSecurityCandidates(function discoveryNormalizationError(error: unknown,- pythonCommand: string,privateValues: Array<readonly [string, string]>,): Error {- const pythonMessage = missingPythonHelperMessage(error, pythonCommand);- if (pythonMessage) {- return new Error(`${discoveryLabel}: ${pythonMessage}`, { cause: error });- }-const stderr =error && typeof error === "object" && "stderr" in error? error.stderrdiff --git a/plugins/codex-security/mcp-app/src/helpers/normalize-candidates.ts b/plugins/codex-security/mcp-app/src/helpers/normalize-candidates.tsnew file mode 100644index 000000000..414791da1--- /dev/null+++ b/plugins/codex-security/mcp-app/src/helpers/normalize-candidates.ts@@ -0,0 +1,447 @@+import { decodeUtf8 } from "./utf8";+import { createHash, randomBytes } from "node:crypto";+import {+ closeSync,+ mkdirSync,+ openSync,+ readFileSync,+ renameSync,+ statSync,+ unlinkSync,+ writeFileSync,+} from "node:fs";+import { dirname, isAbsolute, join, relative, sep } from "node:path";+import { parseArgs } from "node:util";+import { decodePosixBytes, encodePosixPath } from "./posix-path";+import {+ expandHome,+ resolvedPath as resolveFilePath,+ windowsRelativePath,+} from "./resolve-security-md";+import { windowsBinding } from "../native";+import {+ pathText,+ widePath,+ windowsFileSystem,+} from "../../../native/windows-files.mjs";++const roles = [+ "entrypoint",+ "entrypoint/wrapper",+ "source",+ "root_control",+ "sink",+ "concrete_implementation",+ "evidence",+];+const fields = new Set([+ "candidate_id",+ "cwe_ids",+ "locations",+ "summary",+ "evidence",+ "context",+ "instance",+]);+const locationFields = new Set(["path", "start_line", "end_line", "role"]);+const jsonFields = [...fields, ...locationFields].sort();+type Row = Record<string, unknown>;+interface Location {+ path: string;+ start_line: number;+ end_line: number;+ role: string;+}+interface Candidate {+ cwe_ids: string[];+ locations: Location[];+ summary: string;+ evidence: string;+ context?: string;+ instance?: string;+}++function object(value: unknown): value is Row {+ return typeof value === "object" && value !== null && !Array.isArray(value);+}++function compare(left: string, right: string): number {+ return left < right ? -1 : left > right ? 1 : 0;+}++function stableJson(value: unknown): string {+ return JSON.stringify(value, jsonFields);+}++const windows = process.platform === "win32";+const windowsFiles = () => windowsFileSystem(windowsBinding());+const fsPath = (value: string) =>+ windows ? widePath(value) : encodePosixPath(value);+const readFile = (path: string) =>+ windows ? windowsFiles().readFile(fsPath(path)) : readFileSync(fsPath(path));+const stat = (path: string) =>+ windows ? windowsFiles().stat(fsPath(path)) : statSync(fsPath(path));+const pathKey = (value: string) => (windows ? value.toLowerCase() : value);++function resolvedPath(value: string, strict = true): string {+ const path = resolveFilePath(fsPath(value), strict);+ return windows ? pathText(path) : decodePosixBytes(path);+}++function inside(path: string, root: string, allowMissing = false): string {+ const result = windows+ ? windowsRelativePath(+ widePath(path),+ widePath(root),+ allowMissing,+ )?.toString("utf16le")+ : relative(root, path);+ if (+ result === undefined ||+ isAbsolute(result) ||+ result === ".." ||+ result.startsWith(`..${sep}`)+ )+ throw new Error("path: must resolve inside --repo-root");+ return result.split(sep).join("/");+}++function relativeFile(value: unknown, root: string): [string, string] {+ if (typeof value !== "string" || value === "" || value.includes("\0"))+ throw new Error("path: expected a non-empty repository-relative path");+ const raw = windows ? value.replaceAll("\\", "/") : value;+ if (+ raw.startsWith("/") ||+ raw.split("/").includes("..") ||+ (windows && /^[A-Za-z]:/u.test(raw))+ )+ throw new Error(+ "path: expected a repository-relative path without traversal",+ );+ const path = resolvedPath(join(root, raw));+ const name = inside(path, root);+ if (!stat(path).isFile()) throw new Error("path: expected a regular file");+ return [name, path];+}++function readScope(+ path: string,+ root: string,+ allowMissing: boolean,+): Set<string> {+ const lines = decodeUtf8(readFile(path)).split(/\r?\n/u);+ const scope = new Set<string>();+ for (const [index, line] of lines.entries()) {+ if (line === "") continue;+ try {+ scope.add(relativeFile(line, root)[0]);+ } catch (error) {+ if (allowMissing && (error as NodeJS.ErrnoException).code === "ENOENT") {+ try {+ scope.add(inside(resolvedPath(join(root, line), false), root, true));+ } catch (error) {+ throw new Error(+ `in-scope file row ${index + 1}: path escapes repository`,+ );+ }+ } else {+ throw new Error(+ `in-scope file row ${index + 1}: ${(error as Error).message}`,+ );+ }+ }+ }+ return scope;+}++function textField(+ row: Row,+ field: string,+ required = true,+): string | undefined {+ const value = row[field];+ if ((value === undefined || value === null) && !required) return undefined;+ if (typeof value !== "string" || value.trim() === "")+ throw new Error(`${field}: expected a non-empty string`);+ return value.trim();+}++function cweIds(row: Row): string[] {+ const values = row.cwe_ids;+ if (!Array.isArray(values)) throw new Error("cwe_ids: expected an array");+ const found = new Set<bigint>();+ for (const value of values) {+ if (typeof value !== "string")+ throw new Error("cwe_ids: expected CWE strings");+ const match = /^CWE-(\d+)$/iu.exec(value.trim());+ if (match === null)+ throw new Error(`cwe_ids: unsupported value ${JSON.stringify(value)}`);+ const number = BigInt(match[1]!);+ if (number < 1n)+ throw new Error(`cwe_ids: unsupported value ${JSON.stringify(value)}`);+ found.add(number);+ }+ return [...found]+ .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))+ .map((number) => `CWE-${number}`);+}++function positiveLine(value: unknown, field: string): number {+ if (typeof value !== "number" || !Number.isInteger(value) || value < 1)+ throw new Error(`${field}: expected a positive integer`);+ return value;+}++function normalizeLocations(+ row: Row,+ root: string,+ lineCounts: Map<string, number>,+): Location[] {+ if (!Array.isArray(row.locations) || row.locations.length === 0)+ throw new Error("locations: expected a non-empty array");+ const normalized = new Map<string, Location>();+ for (const item of row.locations) {+ if (!object(item)) throw new Error("locations: expected location objects");+ const unknown = Object.keys(item)+ .filter((key) => !locationFields.has(key))+ .sort();+ if (unknown.length)+ throw new Error(`locations: unsupported fields ${unknown.join(", ")}`);+ const [name, source] = relativeFile(item.path, root);+ if (name.trim() === "" || name.includes("\\") || name.includes(":"))+ throw new Error("path: expected a safe repository-relative POSIX path");+ const start = positiveLine(item.start_line, "start_line");+ const end = positiveLine(+ item.end_line === undefined ? start : item.end_line,+ "end_line",+ );+ if (end < start)+ throw new Error("end_line: must be greater than or equal to start_line");+ const key = pathKey(source);+ if (!lineCounts.has(key)) {+ const bytes = readFile(source);+ const contents = bytes.toString("latin1");+ const lines =+ contents.split(/\r\n|[\r\n]/u).length -+ (contents === "" || /[\r\n]$/u.test(contents) ? 1 : 0);+ lineCounts.set(key, lines);+ }+ const count = lineCounts.get(key)!;+ if (end > count)+ throw new Error(`line range ${start}-${end} exceeds ${name}:${count}`);+ if (typeof item.role !== "string" || !roles.includes(item.role))+ throw new Error(`role: unsupported value ${String(item.role)}`);+ const location = {+ path: name,+ start_line: start,+ end_line: end,+ role: item.role,+ };+ normalized.set(stableJson(location), location);+ }+ return [...normalized.values()].sort(+ (a, b) =>+ roles.indexOf(a.role) - roles.indexOf(b.role) ||+ compare(a.path, b.path) ||+ a.start_line - b.start_line ||+ a.end_line - b.end_line,+ );+}++function normalizeCandidate(+ row: Row,+ root: string,+ scope: Set<string>,+ lineCounts: Map<string, number>,+): Candidate {+ const unknown = Object.keys(row)+ .filter((key) => !fields.has(key))+ .sort();+ if (unknown.length)+ throw new Error(`unsupported fields ${unknown.join(", ")}`);+ if ("candidate_id" in row) textField(row, "candidate_id");+ const locations = normalizeLocations(row, root, lineCounts);+ if (!locations.some((item) => scope.has(item.path)))+ throw new Error("locations: expected at least one in-scope file");+ const result: Candidate = {+ cwe_ids: cweIds(row),+ locations,+ summary: textField(row, "summary")!,+ evidence: textField(row, "evidence")!,+ };+ for (const field of ["context", "instance"] as const) {+ const value = textField(row, field, false);+ if (value !== undefined) result[field] = value;+ }+ return result;+}++function combine(groups: Map<string, Candidate[]>) {+ return [...groups]+ .sort(([a], [b]) => compare(a, b))+ .map(([key, group]) => {+ const merged = (field: "summary" | "evidence" | "context") =>+ [+ ...new Set(+ group+ .map((row) => row[field])+ .filter((value): value is string => value !== undefined),+ ),+ ]+ .sort()+ .join("\n");+ const result = {+ ...group[0]!,+ candidate_id: `candidate-${createHash("sha256").update(key).digest("hex").slice(0, 16)}`,+ summary: merged("summary"),+ evidence: merged("evidence"),+ };+ const context = merged("context");+ if (context !== "") result.context = context;+ return result;+ });+}++function argumentsFor(args: string[]) {+ const { values, tokens } = parseArgs({+ args,+ allowPositionals: true,+ tokens: true,+ options: {+ input: { type: "string", multiple: true },+ out: { type: "string" },+ "repo-root": { type: "string" },+ "in-scope-files": { type: "string" },+ "allow-missing-in-scope": { type: "boolean" },+ help: { type: "boolean", short: "h" },+ },+ });+ let collectingInputs = false;+ for (const token of tokens) {+ if (token.kind === "option") collectingInputs = token.name === "input";+ else if (token.kind === "positional") {+ if (!collectingInputs)+ throw new Error(`unrecognized argument: ${token.value}`);+ values.input!.push(token.value);+ }+ }+ if (!values.help) {+ for (const name of ["input", "out", "repo-root", "in-scope-files"] as const)+ if (values[name] === undefined) throw new Error(`--${name} is required`);+ }+ return values;+}++export function normalizeCandidatesCommand(+ args: string[],+ posixHome = process.env.HOME,+): number {+ try {+ const values = argumentsFor(args);+ if (values.help) {+ console.log(+ "Validate and combine security-scan candidates into deterministic JSONL.\n",+ );+ console.log(+ "Usage: launch_codex_security_mcp[.cmd] --helper normalize-candidates --input PATH [PATH ...] --out PATH --repo-root PATH --in-scope-files PATH [--allow-missing-in-scope]",+ );+ return 0;+ }+ const resolve = (value: string, strict = true) =>+ resolvedPath(expandHome(value, posixHome), strict);+ const root = resolve(values["repo-root"]!);+ if (!stat(root).isDirectory())+ throw new Error("--repo-root: expected a directory");+ const output = resolve(values.out!, false);+ const scopePath = resolve(values["in-scope-files"]!);+ const inputs = [+ ...new Map(+ values.input!.map((value) => {+ const path = resolve(value);+ return [pathKey(path), path];+ }),+ ).values(),+ ].sort((a, b) => compare(pathKey(a), pathKey(b)));+ if (inputs.some((path) => pathKey(path) === pathKey(output)))+ throw new Error("--out: must not also be an input");+ if (pathKey(output) === pathKey(scopePath))+ throw new Error("--out: must not replace --in-scope-files");+ const scope = readScope(+ scopePath,+ root,+ values["allow-missing-in-scope"] ?? false,+ );+ const lineCounts = new Map<string, number>();+ const groups = new Map<string, Candidate[]>();+ let rowCount = 0;+ for (const source of inputs) {+ const lines = decodeUtf8(readFile(source)).split(/\r?\n/u);+ for (const [index, line] of lines.entries()) {+ if (line.trim() === "") continue;+ let candidate: Candidate;+ try {+ const row: unknown = JSON.parse(line);+ if (!object(row)) throw new Error("expected a JSON object");+ candidate = normalizeCandidate(row, root, scope, lineCounts);+ } catch (error) {+ throw new Error(+ `${source} row ${index + 1}: ${(error as Error).message}`,+ );+ }+ const key = stableJson({+ cwe_ids: candidate.cwe_ids,+ locations: candidate.locations,+ instance: candidate.instance ?? null,+ });+ const group = groups.get(key) ?? [];+ group.push(candidate);+ groups.set(key, group);+ rowCount++;+ }+ }+ const combined = combine(groups);+ if (windows) windowsFiles().mkdir(fsPath(dirname(output)));+ else mkdirSync(fsPath(dirname(output)), { recursive: true });+ const temporary = fsPath(+ join(+ dirname(output),+ `.candidates-${randomBytes(6).toString("base64url")}.tmp`,+ ),+ );+ let created = false;+ function* contents() {+ created = true;+ for (const row of combined) yield Buffer.from(`${stableJson(row)}\n`);+ }+ try {+ if (windows) {+ windowsFiles().writeFile(temporary, contents(), true);+ windowsFiles().rename(temporary, fsPath(output));+ } else {+ const descriptor = openSync(temporary, "wx", 0o600);+ try {+ for (const chunk of contents()) writeFileSync(descriptor, chunk);+ } finally {+ closeSync(descriptor);+ }+ renameSync(temporary, fsPath(output));+ }+ } finally {+ try {+ if (created) {+ if (windows) windowsFiles().unlink(temporary);+ else unlinkSync(temporary);+ }+ } catch (error) {+ if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;+ }+ }+ console.log(+ `Combined ${rowCount} candidate rows into ${combined.length} rows in ${output}`,+ );+ return 0;+ } catch (error) {+ console.error(`normalize_candidates: ${(error as Error).message}`);+ return 2;+ }+}diff --git a/plugins/codex-security/mcp-app/src/helpers/posix-path.ts b/plugins/codex-security/mcp-app/src/helpers/posix-path.tsindex 7952decaa..ea636908f 100644--- a/plugins/codex-security/mcp-app/src/helpers/posix-path.ts+++ b/plugins/codex-security/mcp-app/src/helpers/posix-path.ts@@ -1,30 +1,32 @@-const utf8 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });+import { isUtf8 } from "node:buffer";+import { lstatSync, realpathSync } from "node:fs";+import { posix } from "node:path";export function decodePosixBytes(bytes: Buffer): string {- try {- return utf8.decode(bytes);- } catch {- // Match Python's surrogateescape for undecodable POSIX path bytes.- let value = "";- for (let offset = 0; offset < bytes.length;) {- let decoded = false;- for (let size = 1; size <= 4 && offset + size <= bytes.length; size++) {- try {- value += utf8.decode(bytes.subarray(offset, offset + size));- offset += size;- decoded = true;- break;- } catch {- // A UTF-8 character can occupy up to four bytes.- }+ // Node 20's fatal TextDecoder can replace invalid bytes in longer inputs.+ if (isUtf8(bytes)) return bytes.toString("utf8");+ // Preserve undecodable POSIX bytes as lone low surrogates.+ let value = "";+ for (let offset = 0; offset < bytes.length;) {+ let decoded = false;+ for (let size = 1; size <= 4 && offset + size <= bytes.length; size++) {+ const part = bytes.subarray(offset, offset + size);+ if (isUtf8(part)) {+ value += part.toString("utf8");+ offset += size;+ decoded = true;+ break;}- if (!decoded) value += String.fromCharCode(0xdc00 + bytes[offset++]!);}- return value;+ if (!decoded) value += String.fromCharCode(0xdc00 + bytes[offset++]!);}+ return value;}export function encodePosixPath(value: string): Buffer {+ if (/[\ud800-\udc7f\udd00-\udfff]/u.test(value)) {+ throw new Error("UTF-8 cannot encode an unpaired surrogate");+ }return Buffer.concat(value.split(/([\udc80-\udcff])/u)@@ -36,53 +38,32 @@ export function encodePosixPath(value: string): Buffer {);}-export class SymlinkLoopError extends Error {}--export function resolvePosixPath(value: Buffer): Buffer {- // GNU Linux native realpath rejects file/.. and links targeting it with- // ENOTDIR. Retain the shipped pathlib contract for those inputs.- const seen = new Map<string, string | null>();- // Latin-1 is a lossless internal representation of pathname bytes.- function follow(directory: string, path: string): string {- if (path.startsWith("/")) directory = "/";- for (const name of path.split("/")) {- if (name === "" || name === ".") continue;- if (name === "..") {- directory = directory.slice(0, directory.lastIndexOf("/")) || "/";- continue;- }- const candidate = `${directory === "/" ? "" : directory}/${name}`;- const bytes = Buffer.from(candidate, "latin1");- if (!lstatSync(bytes).isSymbolicLink()) {- directory = candidate;- continue;- }- const cached = seen.get(candidate);- if (cached === null) {- throw new SymlinkLoopError(- `Symlink loop from ${decodePosixBytes(bytes)}`,- );- }- if (cached !== undefined) {- directory = cached;- continue;- }- seen.set(candidate, null);- directory = follow(- directory,- readlinkSync(bytes, { encoding: "buffer" }).toString("latin1"),+export function resolvePosixPath(value: Buffer, strict = true): Buffer {+ const missing: string[] = [];+ let current = value;+ while (true) {+ try {+ const resolved = realpathSync.native(current, { encoding: "buffer" });+ // Latin-1 preserves raw path bytes while joining missing components.+ return Buffer.from(+ posix.join(resolved.toString("latin1"), ...missing.reverse()),+ "latin1",);- seen.set(candidate, directory);+ } catch (error) {+ if (+ strict ||+ (error as NodeJS.ErrnoException).code !== "ENOENT" ||+ lstatSync(current, { throwIfNoEntry: false }) !== undefined+ )+ throw error;+ // Existing dangling links are rejected above; only absent components+ // may be appended to a canonical existing ancestor.+ const path = current.toString("latin1");+ const name = posix.basename(path);+ // Cancelling an unresolved component can expose an unresolved symlink.+ if (name === "..") throw error;+ missing.push(name);+ current = Buffer.from(posix.dirname(path), "latin1");}- return directory;}- const cwd =- value[0] === 0x2f- ? Buffer.from("/")- : realpathSync.native(".", { encoding: "buffer" });- return Buffer.from(- follow(cwd.toString("latin1"), value.toString("latin1")),- "latin1",- );}-import { lstatSync, readlinkSync, realpathSync } from "node:fs";diff --git a/plugins/codex-security/mcp-app/src/helpers/resolve-security-md.ts b/plugins/codex-security/mcp-app/src/helpers/resolve-security-md.tsindex 51494a03b..8f8ce1fd9 100644--- a/plugins/codex-security/mcp-app/src/helpers/resolve-security-md.ts+++ b/plugins/codex-security/mcp-app/src/helpers/resolve-security-md.ts@@ -1,3 +1,4 @@+import { decodeUtf8 } from "./utf8";import {closeSync,lstatSync,@@ -10,20 +11,17 @@ import {type Stats,} from "node:fs";import { homedir } from "node:os";-import { basename, dirname, parse, sep, win32 } from "node:path";+import { basename, dirname, sep, win32 } from "node:path";import { parseArgs } from "node:util";import { unixBinding, windowsBinding } from "../native";import { windowsFileSystem } from "../../../native/windows-files.mjs";import {decodePosixBytes,encodePosixPath,- SymlinkLoopError,resolvePosixPath,} from "./posix-path";const MAX_SECURITY_MD_BYTES = 1024 * 1024;-const utf8 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });-class HomeExpansionError extends Error {}const windows = process.platform === "win32";const windowsFiles = () => windowsFileSystem(windowsBinding());const encodePath = (path: string) =>@@ -56,33 +54,27 @@ function windowsJoin(left: string, right: string): string {: joined;}-function parsedPath(value: string): string {- // Preserve symlink/.. pairs while removing empty and '.' components.- const root = windows- ? win32.parse(value).root.replaceAll("/", "\\")- : value.startsWith("//") && !value.startsWith("///")- ? "//"- : parse(value).root;+export function parsedPath(value: string): string {+ if (!windows) return value || ".";+ const root = win32.parse(value).root.replaceAll("/", "\\");const parts = value.slice(root.length)- .split(windows ? /[/\\]/u : /\//u)+ .split(/[/\\]/u).filter((part) => part !== "" && part !== ".");- if (windows && !root && win32.parse(parts[0] ?? "").root) parts.unshift(".");+ if (!root && win32.parse(parts[0] ?? "").root) parts.unshift(".");return root + parts.join(sep) || ".";}-function resolvedPath(path: Buffer): Buffer {- if (process.platform !== "win32") return resolvePosixPath(path);- try {- return windowsFiles().realpath(path);- } catch (error) {- if ((error as NodeJS.ErrnoException).code === "ELOOP")- throw new SymlinkLoopError(`Symlink loop from ${decodePath(path)}`);- throw error;- }+export function resolvedPath(path: Buffer, strict = true): Buffer {+ return windows+ ? windowsFiles().realpath(path, strict)+ : resolvePosixPath(path, strict);}-function expandHome(path: string, posixHome: string | undefined): string {+export function expandHome(+ path: string,+ posixHome: string | undefined,+): string {if (!path.startsWith("~")) return path;if (process.platform === "win32") {// path.join('C:', 'name') is rooted; 'C:.' keeps it drive-relative.@@ -105,18 +97,18 @@ function expandHome(path: string, posixHome: string | undefined): string {home = `${environment("HOMEDRIVE") ?? ""}${homePath}`;}if (home === undefined)- throw new HomeExpansionError("Could not determine home directory.");+ throw new Error("Could not determine home directory.");// node:path recognizes share roots in ordinary UNC paths, not extended UNC.const namespacedUnc = home.slice(0, 8).toUpperCase() === "\\\\?\\UNC\\";if (namespacedUnc) home = `\\\\${home.slice(8)}`;if (username !== "" && username !== currentUsername) {if (currentUsername !== win32.parse(home).base) {- throw new HomeExpansionError("Could not determine home directory.");+ throw new Error("Could not determine home directory.");}home = joinHome(win32.dirname(home), username);}if (home.startsWith("~"))- throw new HomeExpansionError("Could not determine home directory.");+ throw new Error("Could not determine home directory.");const expanded = joinHome(home,separator === -1 ? "" : path.slice(end + 1),@@ -126,17 +118,17 @@ function expandHome(path: string, posixHome: string | undefined): string {if (path === "~" || path.startsWith("~/")) {const home = posixHome ?? homedir();if (home.startsWith("~"))- throw new HomeExpansionError("Could not determine home directory.");+ throw new Error("Could not determine home directory.");return home + path.slice(1) || "/";}const separator = path.indexOf("/");const end = separator === -1 ? path.length : separator;const result = unixBinding().userHome(encodePosixPath(path.slice(1, end)));if (result.value === null)- throw new HomeExpansionError("Could not determine home directory.");+ throw new Error("Could not determine home directory.");const home = decodePosixBytes(result.value).replace(/\/+$/u, "");if (home.startsWith("~"))- throw new HomeExpansionError("Could not determine home directory.");+ throw new Error("Could not determine home directory.");return home + path.slice(end) || "/";}@@ -158,18 +150,27 @@ function parentDirectory(path: Buffer): Buffer {: path.subarray(0, Math.max(1, separator));}-function windowsRelativePath(path: Buffer, root: Buffer): Buffer | undefined {+export function windowsRelativePath(+ path: Buffer,+ root: Buffer,+ allowMissing = false,+): Buffer | undefined {const files = windowsFiles();const rootIdentity = files.identity(root);const parts: string[] = [];let current = path;while (true) {- const identity = files.identity(current);- if (- identity.volume === rootIdentity.volume &&- identity.fileId.equals(rootIdentity.fileId)- )- return encodePath(parts.reverse().join("\\"));+ try {+ const identity = files.identity(current);+ if (+ identity.volume === rootIdentity.volume &&+ identity.fileId.equals(rootIdentity.fileId)+ )+ return encodePath(parts.reverse().join("\\"));+ } catch (error) {+ if (!allowMissing || (error as NodeJS.ErrnoException).code !== "ENOENT")+ throw error;+ }const parent = parentDirectory(current);if (parent.equals(current)) return undefined;parts.push(basename(decodePath(current)));@@ -192,15 +193,11 @@ function inside(path: Buffer, root: Buffer, label: string): Buffer {}function resolveRoot(repo: string, posixHome: string | undefined): Buffer {+ const expanded = encodePath(parsedPath(expandHome(repo, posixHome)));let root: Buffer;try {- root = resolvedPath(encodePath(parsedPath(expandHome(repo, posixHome))));- } catch (error) {- if (- error instanceof SymlinkLoopError ||- error instanceof HomeExpansionError- )- throw error;+ root = resolvedPath(expanded);+ } catch {throw new Error(`scan root does not exist: ${repo}`);}if (!statPath(root).isDirectory()) {@@ -234,34 +231,16 @@ function asciiJson(value: string): string {);}-function comparePaths(left: string, right: string): number {- let leftIndex = 0;- let rightIndex = 0;- while (leftIndex < left.length && rightIndex < right.length) {- const leftPoint = left.codePointAt(leftIndex)!;- const rightPoint = right.codePointAt(rightIndex)!;- if (leftPoint !== rightPoint) return leftPoint - rightPoint;- leftIndex += leftPoint > 0xffff ? 2 : 1;- rightIndex += rightPoint > 0xffff ? 2 : 1;- }- return left.length - right.length;-}-function listSecurityMd(repo: string, posixHome: string | undefined): string[] {const root = resolveRoot(repo, posixHome);const policies: string[] = [];function walk(directory: Buffer, prefix: string): void {- const entries = (- windows- ? windowsFiles().entriesWithTypes(directory)- : readdirSync(directory, { encoding: "buffer", withFileTypes: true })- ).map((entry) => ({- bytes: entry.name,- name: decodePath(entry.name),- entry,- }));- entries.sort((left, right) => comparePaths(left.name, right.name));- for (const { bytes, name, entry: listedEntry } of entries) {+ const entries = windows+ ? windowsFiles().entriesWithTypes(directory)+ : readdirSync(directory, { encoding: "buffer", withFileTypes: true });+ for (const listedEntry of entries) {+ const bytes = listedEntry.name;+ const name = decodePath(bytes);if (name === ".git") continue;const path = appendPath(directory, bytes);const source = prefix === "" ? name : `${prefix}/${name}`;@@ -297,7 +276,7 @@ function listSecurityMd(repo: string, posixHome: string | undefined): string[] {}}walk(root, "");- return policies.sort(comparePaths);+ return policies.sort();}function readPolicy(path: Buffer, displayedPath: Buffer): string {@@ -327,7 +306,7 @@ function readPolicy(path: Buffer, displayedPath: Buffer): string {throw new Error(`SECURITY.md exceeds 1 MiB: ${decodePath(displayedPath)}`);}try {- return utf8.decode(buffer.subarray(0, length));+ return decodeUtf8(buffer.subarray(0, length));} catch {throw new Error(`SECURITY.md is not valid UTF-8: ${decodePath(displayedPath)}`,@@ -363,10 +342,8 @@ function resolveSecurityMd(}let resolvedScope: Buffer;try {- // On POSIX, resolve links before '..', including accepted file/.. paths.resolvedScope = resolvedPath(requestedScope);- } catch (error) {- if (error instanceof SymlinkLoopError) throw error;+ } catch {throw new Error(`scan scope does not exist: ${decodePath(requestedScope)}`);}inside(resolvedScope, root, "scan scope");@@ -404,67 +381,15 @@ export function resolveSecurityMdCommand(posixHome = process.env.HOME,): number {try {- const options = {- repo: { type: "string" },- list: { type: "boolean" },- scope: { type: "string" },- out: { type: "string", default: "-" },- help: { type: "boolean", short: "h" },- } as const;- const names = Object.keys(options) as (keyof typeof options)[];- let parsedArgs: string[] = [];- for (let index = 0; index < args.length; index++) {- let arg = args[index]!;- if (arg === "--") throw new Error("Unexpected argument '--'");- if (arg.startsWith("-h")) {- if (/^-h+-/u.test(arg)) throw new Error(`Unexpected argument '${arg}'`);- if (/^-h+=/u.test(arg)) parseArgs({ args: [arg], options });- arg = "--help";- }- if (arg.startsWith("--") && arg !== "--") {- const equals = arg.indexOf("=");- const name = arg.slice(2, equals === -1 ? undefined : equals);- const matches = names.filter((option) => option.startsWith(name));- const option = matches.length === 1 ? matches[0] : undefined;- if (option !== undefined) {- // argparse accepts unique long-option prefixes.- arg = `--${option}${equals === -1 ? "" : arg.slice(equals)}`;- const next = args[index + 1];- if (- equals === -1 &&- options[option].type === "string" &&- next !== undefined- ) {- const prefix = next.split("=", 1)[0]!;- const optional =- next.startsWith("-h") ||- names.some((name) => `--${name}`.startsWith(prefix));- // Declared options take precedence over negative numbers and spaces.- if (- !next.startsWith("-") ||- next === "-" ||- (!optional &&- (next.includes(" ") ||- /^-(?:\p{Decimal_Number}+|\p{Decimal_Number}*\.\p{Decimal_Number}+)\n?$/u.test(- next,- )))- ) {- arg += `=${next}`;- index++;- }- }- }- if (matches.length) parseArgs({ args: [arg], options });- }- parsedArgs.push(arg);- if (arg === "--help") {- parsedArgs = [arg];- break;- }- }const { values } = parseArgs({- args: parsedArgs,- options,+ args,+ options: {+ repo: { type: "string" },+ list: { type: "boolean" },+ scope: { type: "string" },+ out: { type: "string", default: "-" },+ help: { type: "boolean", short: "h" },+ },});if (values.help) {console.log(@@ -503,10 +428,7 @@ export function resolveSecurityMdCommand(}} catch (error) {console.error(`resolve-security-md: error: ${(error as Error).message}`);- return error instanceof SymlinkLoopError ||- error instanceof HomeExpansionError- ? 1- : 2;+ return 2;}return 0;}diff --git a/plugins/codex-security/mcp-app/src/helpers/utf8.ts b/plugins/codex-security/mcp-app/src/helpers/utf8.tsnew file mode 100644index 000000000..5b2e71e4d--- /dev/null+++ b/plugins/codex-security/mcp-app/src/helpers/utf8.ts@@ -0,0 +1,8 @@+import { isUtf8 } from "node:buffer";++export function decodeUtf8(bytes: Buffer): string {+ // Node 20's fatal TextDecoder can silently replace invalid input bytes.+ if (!isUtf8(bytes))+ throw new TypeError("The encoded data was not valid for encoding utf-8");+ return bytes.toString("utf8");+}diff --git a/plugins/codex-security/mcp-app/tests/test_artifact_discovery.mjs b/plugins/codex-security/mcp-app/tests/test_artifact_discovery.mjsindex 1a663ab60..3c2d956c1 100644--- a/plugins/codex-security/mcp-app/tests/test_artifact_discovery.mjs+++ b/plugins/codex-security/mcp-app/tests/test_artifact_discovery.mjs@@ -1,5 +1,6 @@import assert from "node:assert/strict";import {+ copyFile,mkdir,mkdtemp,readFile,@@ -97,7 +98,24 @@ assert.deepEqual(toolSchemas.$defs.workbenchListCandidatesInput.required, [const root = await realpath(await mkdtemp(path.join(tmpdir(), "security-artifact-discovery-")),);+const runtimePluginRoot = path.join(root, "plugin");try {+ await build({+ bundle: true,+ entryPoints: [path.join(pluginRoot, "mcp-app", "helpers-main.ts")],+ outfile: path.join(runtimePluginRoot, "mcp", "helpers.mjs"),+ format: "esm",+ platform: "node",+ });+ if (process.platform === "win32") {+ const target = `win32-${process.arch}`;+ const destination = path.join(runtimePluginRoot, "mcp", "native", target);+ await mkdir(destination, { recursive: true });+ await copyFile(+ path.join(pluginRoot, "native", "prebuilt", target, "windows.node"),+ path.join(destination, "windows.node"),+ );+ }const repoRoot = path.join(root, "repository");await mkdir(path.join(repoRoot, "src"), { recursive: true });await mkdir(path.join(repoRoot, "support"), { recursive: true });@@ -561,7 +579,8 @@ async function createContext(root, repoRoot, name, layout) {root: artifactRoot,repoRoot,layout,- pluginRoot,+ pluginRoot: runtimePluginRoot,+ pythonCommand: path.join(root, "python-must-not-run"),};}diff --git a/plugins/codex-security/mcp-app/tests/test_compact_artifact_server.mjs b/plugins/codex-security/mcp-app/tests/test_compact_artifact_server.mjsindex 50b738044..35599cc67 100644--- a/plugins/codex-security/mcp-app/tests/test_compact_artifact_server.mjs+++ b/plugins/codex-security/mcp-app/tests/test_compact_artifact_server.mjs@@ -1341,7 +1341,7 @@ async function testDiscoveryWorkerToolList(bundle) {CODEX_SECURITY_REPO_ROOT: repoRoot,CODEX_SECURITY_ARTIFACT_LAYOUT: "worker",CODEX_SECURITY_SCAN_ID: scanId,- CODEX_SECURITY_PLUGIN_ROOT: pluginRoot,+ CODEX_SECURITY_PLUGIN_ROOT: bundledPluginRoot,});try {assert.deepEqual(@@ -1531,7 +1531,7 @@ async function testReducerWorkerToolList(bundle) {CODEX_SECURITY_REPO_ROOT: repoRoot,CODEX_SECURITY_ARTIFACT_LAYOUT: "reducer",CODEX_SECURITY_SCAN_ID: scanId,- CODEX_SECURITY_PLUGIN_ROOT: pluginRoot,+ CODEX_SECURITY_PLUGIN_ROOT: bundledPluginRoot,CODEX_SECURITY_REDUCER_CONTEXT_JSON: JSON.stringify({scanRoot,claimedWorkers: [{ id: workerId, resultPath: workerResultPath }],@@ -1722,7 +1722,7 @@ async function bundleEntrypoint(entrypoint, outfile) {await build({bundle: true,define: {- __dirname: JSON.stringify(applicationRoot),+ __dirname: JSON.stringify(path.join(bundledPluginRoot, "mcp")),"import.meta.url": "__filename",},entryPoints: [path.join(applicationRoot, entrypoint)],diff --git a/plugins/codex-security/native/examples/windows-wide-launcher.rs b/plugins/codex-security/native/examples/windows-wide-launcher.rsindex 395f8ef83..1392cce38 100644--- a/plugins/codex-security/native/examples/windows-wide-launcher.rs+++ b/plugins/codex-security/native/examples/windows-wide-launcher.rs@@ -222,7 +222,7 @@ fn main() -> std::io::Result<()> {"Windows policy helper lost directory names",));}- for sentinel in sentinels {+ for sentinel in &sentinels {if fs::read(sentinel)? != b"output sentinel" {return Err(io::Error::other("Windows policy helper changed a replacement output",@@ -261,8 +261,109 @@ fn main() -> std::io::Result<()> {if symlinks {verify_outside_root(&identity_root)?;}+ let input_name = raw("input-", 0xd800);+ let scope_name = raw("scope-files-", 0xdc80);+ fs::write(repo.join("source.py"), "source line\n")?;+ fs::write(repo.join(&scope_name), "./source.py\n./deleted.py\n")?;+ fs::write(repo.join(raw("scope-files-", 0xfffd)), "wrong.py\n")?;+ fs::write(+ repo.join(raw("input-", 0xfffd)),+ "invalid replacement input",+ )?;+ fs::write(+ repo.join(&input_name),+ concat!(+ r#"{"cwe_ids":["CWE-89"],"locations":[{"path":"./source.py","#,+ r#""start_line":1,"role":"entrypoint"}],"summary":"wide paths","#,+ r#""evidence":"source evidence"}"#,+ "\n",+ ),+ )?;+ let output_link = "i\u{0307}.jsonl";+ if symlinks {+ std::os::windows::fs::symlink_file(&output_name, repo.join(output_link))?;+ std::os::windows::fs::symlink_file(output_link, repo.join("İ.jsonl"))?;+ }+ let expected = concat!(+ r#"{"candidate_id":"candidate-a69fa65a28ed4e55","cwe_ids":["CWE-89"],"#,+ r#""evidence":"source evidence","locations":[{"end_line":1,"#,+ r#""path":"source.py","role":"entrypoint","start_line":1}],"#,+ r#""summary":"wide paths"}"#,+ "\n",+ );+ let candidate = |repo_arg: &Path, input: &Path, scope: &Path, output: &Path| {+ Command::new(&node)+ .arg(&script)+ .args(["--helper", "normalize-candidates", "--repo-root"])+ .arg(repo_arg)+ .arg("--input")+ .arg(input)+ .arg("--in-scope-files")+ .arg(scope)+ .arg("--out")+ .arg(output)+ .arg("--allow-missing-in-scope")+ .current_dir(&repo)+ .env("USERPROFILE", &repo)+ .output()+ };+ fs::write(&output, "previous output")?;+ for (index, prefix) in [repo.clone(), PathBuf::from("~"), PathBuf::from(".")]+ .into_iter()+ .enumerate()+ {+ let child = candidate(+ &prefix,+ &prefix.join(&input_name),+ &prefix.join(&scope_name),+ &prefix.join(if index == 0 || !symlinks {+ output_name.clone()+ } else {+ OsString::from("İ.jsonl")+ }),+ )?;+ if !child.status.success()+ || !child.stderr.is_empty()+ || fs::read(&output)? != expected.as_bytes()+ {+ return Err(io::Error::other(format!(+ "Wide candidate helper failed: {}",+ String::from_utf8_lossy(&child.stderr)+ )));+ }+ }+ fs::create_dir(repo.join("blocked-output"))?;+ let child = candidate(+ Path::new("."),+ Path::new(&input_name),+ Path::new(&scope_name),+ Path::new("blocked-output"),+ )?;+ if child.status.code() != Some(2) || !repo.join("blocked-output").is_dir() {+ return Err(io::Error::other(+ "Candidate replacement failure was not preserved",+ ));+ }+ for entry in fs::read_dir(&repo)? {+ if entry?+ .file_name()+ .to_string_lossy()+ .starts_with(".candidates-")+ {+ return Err(io::Error::other(+ "Candidate temporary output was not removed",+ ));+ }+ }+ for sentinel in &sentinels {+ if fs::read(sentinel)? != b"output sentinel" {+ return Err(io::Error::other(+ "Candidate helper changed a replacement output",+ ));+ }+ }println!(- "{{\"policyHelperRawPaths\":true,\"directoryIdentity\":true,\"policySymlinkBoundary\":{symlinks}}}"+ "{{\"policyHelperRawPaths\":true,\"candidateHelperRawPaths\":true,\"directoryIdentity\":true,\"policySymlinkBoundary\":{symlinks}}}");Ok(())}diff --git a/plugins/codex-security/plugin-files.json b/plugins/codex-security/plugin-files.jsonindex 2f0f6f641..f5f8e2cdd 100644--- a/plugins/codex-security/plugin-files.json+++ b/plugins/codex-security/plugin-files.json@@ -68,7 +68,6 @@"scripts/generate_rank_input.py","scripts/launch_codex_security_mcp","scripts/launch_codex_security_mcp.cmd",- "scripts/normalize_candidates.py","scripts/rank_preview.py","scripts/report_projection.py","scripts/reserved_artifact_paths.json",diff --git a/plugins/codex-security/scripts/launch_codex_security_mcp b/plugins/codex-security/scripts/launch_codex_security_mcpindex f7739b842..a112a2b9f 100755--- a/plugins/codex-security/scripts/launch_codex_security_mcp+++ b/plugins/codex-security/scripts/launch_codex_security_mcp@@ -10,7 +10,11 @@ if [ "${1:-}" = "--helper" ]; thenserver_path=$launcher_dir/../mcp/helpers.mjsshift# Node decodes argv and HOME as UTF-8; preserve POSIX bytes first.- set -- --helper "$(printf '%s\000' "${HOME+x}" "${HOME-}" "$@" | od -An -v -tx1 | tr -d ' \n')"+ # A separate descriptor preserves stdin and avoids a single argument limit.+ exec 3<<EOF+$(printf '%s\000' "${HOME+x}" "${HOME-}" "$@" | od -An -v -tx1 | tr -d ' \n')+EOF+ set -- --helperficache_root=${XDG_CACHE_HOME:-${HOME:-}/.cache}codex_resources=diff --git a/plugins/codex-security/scripts/normalize_candidates.py b/plugins/codex-security/scripts/normalize_candidates.pydeleted file mode 100644index a445acd70..000000000--- a/plugins/codex-security/scripts/normalize_candidates.py+++ /dev/null@@ -1,338 +0,0 @@-#!/usr/bin/env python3-"""Validate and combine security-scan candidates into deterministic JSONL."""--from __future__ import annotations--import argparse-import hashlib-import json-import re-import sys-import tempfile-from pathlib import Path, PurePosixPath-from typing import Any--CWE = re.compile(r"(?i)CWE-(\d+)")-ROLES = {- "entrypoint": 0,- "entrypoint/wrapper": 1,- "source": 2,- "root_control": 3,- "sink": 4,- "concrete_implementation": 5,- "evidence": 6,-}-FIELDS = {- "candidate_id",- "cwe_ids",- "locations",- "summary",- "evidence",- "context",- "instance",-}---def text_field(row: dict[str, Any], field: str, *, required: bool = True) -> str | None:- value = row.get(field)- if value is None and not required:- return None- if not isinstance(value, str) or not value.strip():- raise ValueError(f"{field}: expected a non-empty string")- return value.strip()---def cwe_ids(row: dict[str, Any]) -> list[str]:- value = row.get("cwe_ids")- if not isinstance(value, list):- raise ValueError("cwe_ids: expected an array")- found: set[int] = set()- for item in value:- if not isinstance(item, str):- raise ValueError("cwe_ids: expected CWE strings")- match = CWE.fullmatch(item.strip())- if match is None or int(match[1]) < 1:- raise ValueError(f"cwe_ids: unsupported value {item!r}")- found.add(int(match[1]))- return [f"CWE-{number}" for number in sorted(found)]---def relative_file(value: Any, repo_root: Path) -> tuple[str, Path]:- if not isinstance(value, str) or not value or "\0" in value:- raise ValueError("path: expected a non-empty repository-relative path")- raw = value- if sys.platform == "win32":- raw = raw.replace("\\", "/")- path = PurePosixPath(raw)- if (- path.is_absolute()- or ".." in path.parts- or (sys.platform == "win32" and re.match(r"^[A-Za-z]:", raw))- ):- raise ValueError("path: expected a repository-relative path without traversal")- resolved = (repo_root / raw).resolve(strict=True)- try:- relative = resolved.relative_to(repo_root).as_posix()- except ValueError as error:- raise ValueError("path: must resolve inside --repo-root") from error- if not resolved.is_file():- raise ValueError("path: expected a regular file")- return relative, resolved---def positive_line(value: Any, field: str) -> int:- if not isinstance(value, int) or isinstance(value, bool) or value < 1:- raise ValueError(f"{field}: expected a positive integer")- return value---def normalize_locations(- row: dict[str, Any], repo_root: Path, line_counts: dict[Path, int]-) -> list[dict[str, Any]]:- value = row.get("locations")- if not isinstance(value, list) or not value:- raise ValueError("locations: expected a non-empty array")- normalized: dict[tuple[str, int, int, str], dict[str, Any]] = {}- for item in value:- if not isinstance(item, dict):- raise ValueError("locations: expected location objects")- unknown = set(item) - {"path", "start_line", "end_line", "role"}- if unknown:- raise ValueError(f"locations: unsupported fields {', '.join(sorted(unknown))}")- relative, source = relative_file(item.get("path"), repo_root)- if (- not relative.strip()- or "\\" in relative- or any(":" in part for part in PurePosixPath(relative).parts)- ):- raise ValueError("path: expected a safe repository-relative POSIX path")- start = positive_line(item.get("start_line"), "start_line")- end = positive_line(item.get("end_line", start), "end_line")- if end < start:- raise ValueError("end_line: must be greater than or equal to start_line")- if source not in line_counts:- line_counts[source] = len(source.read_bytes().splitlines())- if end > line_counts[source]:- raise ValueError(f"line range {start}-{end} exceeds {relative}:{line_counts[source]}")- role = item.get("role")- if not isinstance(role, str) or role not in ROLES:- raise ValueError(f"role: unsupported value {role!r}")- key = (relative, start, end, role)- normalized[key] = {- "path": relative,- "start_line": start,- "end_line": end,- "role": role,- }- return sorted(- normalized.values(),- key=lambda item: (- ROLES[item["role"]],- item["path"],- item["start_line"],- item["end_line"],- ),- )---def read_scope(path: Path, repo_root: Path, *, allow_missing: bool = False) -> set[str]:- contents = path.read_bytes().decode("utf-8")- lines = contents.split("\n")- listed_rows = set(lines)-- def is_scope_file(value: str) -> bool:- try:- relative_file(value, repo_root)- except (OSError, ValueError):- return False- return True-- carriage_rows = {- line: (is_scope_file(line), is_scope_file(line.removesuffix("\r")))- for line in lines- if line.endswith("\r") and line != "\r" and sys.platform != "win32"- }- crlf_evidence = any(line == "\r" for line in lines) or any(- stripped and not literal for literal, stripped in carriage_rows.values()- )- literal_evidence = any(literal and not stripped for literal, stripped in carriage_rows.values())-- scope: set[str] = set()- for number, line in enumerate(lines, 1):- if sys.platform == "win32" or line == "\r":- line = line.removesuffix("\r")- elif line.endswith("\r"):- literal, stripped = carriage_rows[line]- if stripped and not literal:- line = line.removesuffix("\r")- elif stripped and literal:- if number == len(lines) and not contents.endswith("\n"):- pass- elif line.removesuffix("\r") in listed_rows:- pass- elif crlf_evidence and not literal_evidence:- line = line.removesuffix("\r")- elif literal_evidence and not crlf_evidence:- pass- else:- raise ValueError(f"in-scope file row {number}: ambiguous carriage-return paths")- elif not literal and crlf_evidence:- line = line.removesuffix("\r")- if not line:- continue- try:- relative, _ = relative_file(line, repo_root)- except (OSError, ValueError) as error:- if allow_missing and isinstance(error, FileNotFoundError):- candidate = PurePosixPath(line)- if candidate.is_absolute() or ".." in candidate.parts or "\0" in line:- raise ValueError(f"in-scope file row {number}: unsafe deleted path") from error- resolved = (repo_root / line).resolve(strict=False)- try:- relative = resolved.relative_to(repo_root).as_posix()- except ValueError as escaped:- raise ValueError(- f"in-scope file row {number}: path escapes repository"- ) from escaped- scope.add(relative)- continue- raise ValueError(f"in-scope file row {number}: {error}") from error- scope.add(relative)- return scope---def normalize_candidate(- row: dict[str, Any], repo_root: Path, scope: set[str], line_counts: dict[Path, int]-) -> dict[str, Any]:- unknown = set(row) - FIELDS- if unknown:- raise ValueError(f"unsupported fields {', '.join(sorted(unknown))}")- if "candidate_id" in row:- text_field(row, "candidate_id")- candidate_locations = normalize_locations(row, repo_root, line_counts)- if not any(item["path"] in scope for item in candidate_locations):- raise ValueError("locations: expected at least one in-scope file")- result: dict[str, Any] = {- "cwe_ids": cwe_ids(row),- "locations": candidate_locations,- "summary": text_field(row, "summary"),- "evidence": text_field(row, "evidence"),- }- context = text_field(row, "context", required=False)- if context is not None:- result["context"] = context- instance = text_field(row, "instance", required=False)- if instance is not None:- result["instance"] = instance- return result---def identity(row: dict[str, Any]) -> str:- return json.dumps(- {- "cwe_ids": row["cwe_ids"],- "locations": row["locations"],- "instance": row.get("instance"),- },- ensure_ascii=False,- separators=(",", ":"),- sort_keys=True,- )---def merged_text(group: list[dict[str, Any]], field: str) -> str:- return "\n".join(sorted({item[field] for item in group if field in item}))---def combine(rows: list[dict[str, Any]]) -> list[dict[str, Any]]:- groups: dict[str, list[dict[str, Any]]] = {}- for row in rows:- groups.setdefault(identity(row), []).append(row)- combined: list[dict[str, Any]] = []- for key, group in sorted(groups.items()):- candidate_id = hashlib.sha256(key.encode()).hexdigest()[:16]-- result = {- "candidate_id": f"candidate-{candidate_id}",- "cwe_ids": group[0]["cwe_ids"],- "locations": group[0]["locations"],- "summary": merged_text(group, "summary"),- "evidence": merged_text(group, "evidence"),- }- context = merged_text(group, "context")- if context:- result["context"] = context- if "instance" in group[0]:- result["instance"] = group[0]["instance"]- combined.append(result)- return combined---def main() -> None:- parser = argparse.ArgumentParser(description=__doc__)- parser.add_argument("--input", nargs="+", required=True, help="Candidate JSONL inputs.")- parser.add_argument("--out", required=True, help="Combined candidate JSONL output.")- parser.add_argument("--repo-root", required=True, help="Repository root for candidate paths.")- parser.add_argument("--in-scope-files", required=True, help="Repository-relative file list.")- parser.add_argument(- "--allow-missing-in-scope",- action="store_true",- help="Keep deleted Git paths in a diff inventory while validating existing candidate files.",- )- args = parser.parse_args()- try:- repo_root = Path(args.repo_root).expanduser().resolve(strict=True)- if not repo_root.is_dir():- raise ValueError("--repo-root: expected a directory")- output = Path(args.out).expanduser().resolve(strict=False)- scope_path = Path(args.in_scope_files).expanduser().resolve(strict=True)- inputs = sorted({Path(value).expanduser().resolve(strict=True) for value in args.input})- if output in inputs:- raise ValueError("--out: must not also be an input")- if output == scope_path:- raise ValueError("--out: must not replace --in-scope-files")- scope = read_scope(scope_path, repo_root, allow_missing=args.allow_missing_in_scope)- line_counts: dict[Path, int] = {}- rows: list[dict[str, Any]] = []- for source in inputs:- with source.open(encoding="utf-8") as handle:- for number, line in enumerate(handle, 1):- if not line.strip():- continue- try:- row = json.loads(line)- if not isinstance(row, dict):- raise ValueError("expected a JSON object")- rows.append(normalize_candidate(row, repo_root, scope, line_counts))- except (ValueError, TypeError, OSError) as error:- raise ValueError(f"{source} row {number}: {error}") from error- combined = combine(rows)- output.parent.mkdir(parents=True, exist_ok=True)- temporary: Path | None = None- try:- with tempfile.NamedTemporaryFile(- mode="w",- encoding="utf-8",- dir=output.parent,- prefix=f".{output.name}.",- suffix=".tmp",- delete=False,- ) as handle:- temporary = Path(handle.name)- for row in combined:- handle.write(- json.dumps(row, ensure_ascii=False, separators=(",", ":"), sort_keys=True)- + "\n"- )- temporary.replace(output)- finally:- if temporary is not None:- temporary.unlink(missing_ok=True)- print(f"Combined {len(rows)} candidate rows into {len(combined)} rows in {output}")- except (OSError, ValueError) as error:- print(f"normalize_candidates: {error}", file=sys.stderr)- raise SystemExit(2) from error---if __name__ == "__main__":- main()diff --git a/plugins/codex-security/skills/security-diff-scan/SKILL.md b/plugins/codex-security/skills/security-diff-scan/SKILL.mdindex af59e39c2..245e65aa0 100644--- a/plugins/codex-security/skills/security-diff-scan/SKILL.md+++ b/plugins/codex-security/skills/security-diff-scan/SKILL.md@@ -34,6 +34,6 @@ For terminal scans without a `scanId`, generate the changed-file list with:<python_command> <plugin_dir>/scripts/generate_in_scope_files.py --repo <repo_root> --scope . --diff-base <base> --diff-head <head> --diff-mode <revisions|local-patch> --out <discovery_dir>/in_scope_files.txt```-Record candidates with `normalize_candidates.py --input <candidate-source> --out <discovery_dir>/candidate_ledger.jsonl --repo-root <repo_root> --in-scope-files <discovery_dir>/in_scope_files.txt --allow-missing-in-scope`. Add validation and attack-path decisions to that same file. Following `../../references/final-report.md`, assemble unsealed `scan-manifest.json`, `findings.json`, and `coverage.json` before running `finalize_scan_contract.py --scan-dir <scan_dir> --source-root <repo_root>`.+Record candidates with `<plugin_dir>/scripts/launch_codex_security_mcp --helper normalize-candidates --input <candidate-source> --out <discovery_dir>/candidate_ledger.jsonl --repo-root <repo_root> --in-scope-files <discovery_dir>/in_scope_files.txt --allow-missing-in-scope`. Use the `.cmd` launcher on Windows. Add validation and attack-path decisions to that same file. Following `../../references/final-report.md`, assemble unsealed `scan-manifest.json`, `findings.json`, and `coverage.json` before running `finalize_scan_contract.py --scan-dir <scan_dir> --source-root <repo_root>`.Finish only after every changed file and candidate is accounted for. Return the generated report, actual coverage gaps, and Codex review comments for confirmed findings.diff --git a/plugins/codex-security/tests/test_normalize_candidates.py b/plugins/codex-security/tests/test_normalize_candidates.pydeleted file mode 100644index 94290fcb6..000000000--- a/plugins/codex-security/tests/test_normalize_candidates.py+++ /dev/null@@ -1,789 +0,0 @@-from __future__ import annotations--import json-import subprocess-import sys-from collections.abc import Callable-from pathlib import Path--import pytest--SCRIPT = Path(__file__).resolve().parents[1] / "scripts" / "normalize_candidates.py"---def write_jsonl(path: Path, rows: list[dict[str, object]]) -> None:- path.write_text("".join(json.dumps(row) + "\n" for row in rows), encoding="utf-8")---def location(path: str, line: int, role: str) -> dict[str, object]:- return {"path": path, "start_line": line, "role": role}---def candidate(- locations: list[dict[str, object]],- *,- cwes: list[str] | None = None,- summary: str = "Request input reaches an unsafe operation",- evidence: str = "The input is passed to the operation without a check",- context: str | None = None,- instance: str | None = None,-) -> dict[str, object]:- row: dict[str, object] = {- "cwe_ids": ["CWE-89"] if cwes is None else cwes,- "locations": locations,- "summary": summary,- "evidence": evidence,- }- if context is not None:- row["context"] = context- if instance is not None:- row["instance"] = instance- return row---def setup_repo(tmp_path: Path) -> tuple[Path, Path]:- repo = tmp_path / "repo"- for path in ("app/routes.py", "app/query.py", "app/export.py", "helpers/shared.py"):- source = repo / path- source.parent.mkdir(parents=True, exist_ok=True)- source.write_text("one\ntwo\nthree\nfour\nfive\n", encoding="utf-8")- scope = tmp_path / "in_scope_files.txt"- scope.write_text("app/routes.py\napp/query.py\napp/export.py\n", encoding="utf-8")- return repo, scope---def run_combiner(- tmp_path: Path,- inputs: list[list[dict[str, object]]],- *,- repo: Path | None = None,- scope: Path | None = None,- output_name: str = "combined.jsonl",- allow_missing: bool = False,-) -> tuple[subprocess.CompletedProcess[str], Path]:- if repo is None or scope is None:- repo, scope = setup_repo(tmp_path)- sources: list[Path] = []- for index, rows in enumerate(inputs):- source = tmp_path / f"candidates-{index}.jsonl"- write_jsonl(source, rows)- sources.append(source)- output = tmp_path / output_name- result = subprocess.run(- [- sys.executable,- str(SCRIPT),- "--input",- *(str(source) for source in sources),- "--out",- str(output),- "--repo-root",- str(repo),- "--in-scope-files",- str(scope),- *(["--allow-missing-in-scope"] if allow_missing else []),- ],- capture_output=True,- text=True,- )- return result, output---def read_jsonl(path: Path) -> list[dict[str, object]]:- return [json.loads(line) for line in path.read_text(encoding="utf-8").split("\n") if line]--[email protected](sys.platform == "win32", reason="POSIX-only literal file names")- "relative",- [- "app/ leading.py",- "app/trailing .py",- "app/ .py",- "app/ .py",- "app/carriage\rname.py",- "app/trailing-carriage.py\r",- "app/vertical\vname.py",- "app/form\fname.py",- "app/next\u0085name.py",- "app/line\u2028name.py",- "app/paragraph\u2029name.py",- ],-)-def test_scope_preserves_literal_posix_inventory_paths(tmp_path: Path, relative: str) -> None:- repo, scope = setup_repo(tmp_path)- source = repo / relative- source.write_text("one\ntwo\n", encoding="utf-8")- scope.write_bytes((relative + "\n").encode("utf-8"))-- result, output = run_combiner(- tmp_path,- [[candidate([location(relative, 1, "entrypoint")])]],- repo=repo,- scope=scope,- )-- assert result.returncode == 0, result.stderr- assert read_jsonl(output)[0]["locations"][0]["path"] == relative---def test_scope_accepts_crlf_inventory_on_every_platform(tmp_path: Path) -> None:- repo, scope = setup_repo(tmp_path)- scope.write_bytes(b"\r\napp/routes.py\r\napp/query.py\r\n")-- result, output = run_combiner(- tmp_path,- [[candidate([location("app/routes.py", 1, "entrypoint")])]],- repo=repo,- scope=scope,- )-- assert result.returncode == 0, result.stderr- assert read_jsonl(output)[0]["locations"][0]["path"] == "app/routes.py"---def test_diff_scope_accepts_deleted_files_without_weakening_candidate_locations(- tmp_path: Path,-) -> None:- repo, scope = setup_repo(tmp_path)- scope.write_text("app/deleted_guard.py\napp/routes.py\n", encoding="utf-8")-- rejected, _ = run_combiner(- tmp_path,- [[candidate([location("app/routes.py", 1, "entrypoint")])]],- repo=repo,- scope=scope,- )- assert rejected.returncode == 2- assert "in-scope file row 1" in rejected.stderr-- accepted, output = run_combiner(- tmp_path,- [[candidate([location("app/routes.py", 1, "entrypoint")])]],- repo=repo,- scope=scope,- allow_missing=True,- )- assert accepted.returncode == 0, accepted.stderr- assert read_jsonl(output)[0]["locations"][0]["path"] == "app/routes.py"-- missing_candidate, _ = run_combiner(- tmp_path,- [[candidate([location("app/deleted_guard.py", 1, "root_control")])]],- repo=repo,- scope=scope,- output_name="missing-candidate.jsonl",- allow_missing=True,- )- assert missing_candidate.returncode == 2- assert "deleted_guard.py" in missing_candidate.stderr---def test_diff_scope_rejects_deleted_path_outside_repository(tmp_path: Path) -> None:- repo, scope = setup_repo(tmp_path)- scope.write_text("../deleted_guard.py\napp/routes.py\n", encoding="utf-8")-- result, output = run_combiner(- tmp_path,- [[candidate([location("app/routes.py", 1, "entrypoint")])]],- repo=repo,- scope=scope,- allow_missing=True,- )-- assert result.returncode == 2- assert "in-scope file row 1" in result.stderr- assert not output.exists()--- "inventory",- [- b"app/routes.py\r\napp/query.py\n",- b"app/routes.py\r\napp/query.py",- ],-)-def test_scope_accepts_mixed_and_unterminated_crlf_inventories(- tmp_path: Path, inventory: bytes-) -> None:- repo, scope = setup_repo(tmp_path)- scope.write_bytes(inventory)-- result, output = run_combiner(- tmp_path,- [[candidate([location("app/routes.py", 1, "entrypoint")])]],- repo=repo,- scope=scope,- )-- assert result.returncode == 0, result.stderr- assert read_jsonl(output)[0]["locations"][0]["path"] == "app/routes.py"--[email protected](sys.platform == "win32", reason="POSIX-only literal file names")-def test_crlf_scope_preserves_paths_when_carriage_return_names_also_exist(- tmp_path: Path,-) -> None:- repo, scope = setup_repo(tmp_path)- (repo / "app/routes.py\r").write_text("one\ntwo\n", encoding="utf-8")- scope.write_bytes(b"app/routes.py\r\napp/query.py\r\n")-- result, output = run_combiner(- tmp_path,- [[candidate([location("app/routes.py", 1, "entrypoint")])]],- repo=repo,- scope=scope,- )-- assert result.returncode == 0, result.stderr- assert read_jsonl(output)[0]["locations"][0]["path"] == "app/routes.py"--[email protected](sys.platform == "win32", reason="POSIX-only literal file names")[email protected]("candidate_path", ["app/routes.py", "app/routes.py\r"])-def test_lf_scope_preserves_separately_listed_carriage_return_collisions(- tmp_path: Path, candidate_path: str-) -> None:- repo, scope = setup_repo(tmp_path)- for relative in ("app/routes.py\r", "app/query.py\r"):- (repo / relative).write_text("one\ntwo\n", encoding="utf-8")- scope.write_bytes(b"app/query.py\napp/query.py\r\napp/routes.py\napp/routes.py\r\n")-- result, output = run_combiner(- tmp_path,- [[candidate([location(candidate_path, 1, "entrypoint")])]],- repo=repo,- scope=scope,- )-- assert result.returncode == 0, result.stderr- assert read_jsonl(output)[0]["locations"][0]["path"] == candidate_path--[email protected](sys.platform == "win32", reason="POSIX-only literal file names")-def test_scope_preserves_unterminated_final_carriage_return_filename(- tmp_path: Path,-) -> None:- repo, scope = setup_repo(tmp_path)- relative = "app/routes.py\r"- (repo / relative).write_text("one\ntwo\n", encoding="utf-8")- scope.write_bytes(b"app/query.py\r\napp/routes.py\r")-- result, output = run_combiner(- tmp_path,- [[candidate([location(relative, 1, "entrypoint")])]],- repo=repo,- scope=scope,- )-- assert result.returncode == 0, result.stderr- assert read_jsonl(output)[0]["locations"][0]["path"] == relative--[email protected](sys.platform == "win32", reason="POSIX-only literal file names")- "relative",- ["app/literal\\name.py", "app/C:foo.py", " ", " "],-)-def test_candidate_rejects_paths_incompatible_with_scan_contract(- tmp_path: Path, relative: str-) -> None:- repo, scope = setup_repo(tmp_path)- source = repo / relative- source.write_text("one\ntwo\n", encoding="utf-8")- scope.write_bytes((relative + "\n").encode("utf-8"))-- result, output = run_combiner(- tmp_path,- [[candidate([location(relative, 1, "entrypoint")])]],- repo=repo,- scope=scope,- )-- assert result.returncode == 2- assert "safe repository-relative POSIX path" in result.stderr- assert not output.exists()--[email protected](sys.platform == "win32", reason="POSIX-only literal file names")[email protected]("candidate_path", ["app/routes.py", "app/routes.py\r"])-def test_mixed_scope_rejects_colliding_carriage_return_file_names(- tmp_path: Path, candidate_path: str-) -> None:- repo, scope = setup_repo(tmp_path)- (repo / "app/routes.py\r").write_text("one\ntwo\n", encoding="utf-8")- scope.write_bytes(b"app/routes.py\r\napp/query.py\n")-- result, output = run_combiner(- tmp_path,- [[candidate([location(candidate_path, 1, "entrypoint")])]],- repo=repo,- scope=scope,- )-- assert result.returncode == 2- assert "ambiguous carriage-return paths" in result.stderr- assert not output.exists()--[email protected](sys.platform == "win32", reason="POSIX-only literal file names")-def test_lf_scope_uses_independent_literal_carriage_return_evidence(- tmp_path: Path,-) -> None:- repo, scope = setup_repo(tmp_path)- relative = "app/routes.py\r"- evidence = "app/literal-evidence.py\r"- for path in (relative, evidence):- (repo / path).write_text("one\ntwo\n", encoding="utf-8")- scope.write_bytes(b"app/routes.py\r\napp/literal-evidence.py\r\napp/query.py\n")-- result, output = run_combiner(- tmp_path,- [[candidate([location(relative, 1, "entrypoint")])]],- repo=repo,- scope=scope,- )-- assert result.returncode == 0, result.stderr- assert read_jsonl(output)[0]["locations"][0]["path"] == relative--[email protected](sys.platform == "win32", reason="POSIX-only literal file names")-def test_scope_rejects_indistinguishable_carriage_return_inventories(- tmp_path: Path,-) -> None:- repo, scope = setup_repo(tmp_path)- for relative in ("app/routes.py\r", "app/query.py\r"):- (repo / relative).write_text("one\ntwo\n", encoding="utf-8")- scope.write_bytes(b"app/routes.py\r\napp/query.py\r\n")-- result, output = run_combiner(- tmp_path,- [[candidate([location("app/routes.py", 1, "entrypoint")])]],- repo=repo,- scope=scope,- )-- assert result.returncode == 2- assert "ambiguous carriage-return paths" in result.stderr- assert not output.exists()--[email protected](sys.platform == "win32", reason="POSIX-only literal file names")-def test_crlf_blank_line_disambiguates_colliding_carriage_return_paths(- tmp_path: Path,-) -> None:- repo, scope = setup_repo(tmp_path)- for relative in ("app/routes.py\r", "app/query.py\r"):- (repo / relative).write_text("one\ntwo\n", encoding="utf-8")- scope.write_bytes(b"\r\napp/routes.py\r\napp/query.py\r\n")-- result, output = run_combiner(- tmp_path,- [[candidate([location("app/routes.py", 1, "entrypoint")])]],- repo=repo,- scope=scope,- )-- assert result.returncode == 0, result.stderr- assert read_jsonl(output)[0]["locations"][0]["path"] == "app/routes.py"--[email protected](sys.platform != "win32", reason="Windows-native file paths")-def test_windows_scope_normalizes_native_separators(tmp_path: Path) -> None:- repo, scope = setup_repo(tmp_path)- scope.write_bytes(b"app\\routes.py\r\n")-- result, output = run_combiner(- tmp_path,- [[candidate([location("app\\routes.py", 2, "entrypoint")])]],- repo=repo,- scope=scope,- )-- assert result.returncode == 0, result.stderr- assert read_jsonl(output)[0]["locations"][0]["path"] == "app/routes.py"--[email protected](sys.platform != "win32", reason="Windows-native drive paths")-def test_windows_candidates_reject_drive_qualified_paths(tmp_path: Path) -> None:- result, output = run_combiner(- tmp_path,- [[candidate([location("C:routes.py", 1, "entrypoint")])]],- )-- assert result.returncode == 2- assert "repository-relative path without traversal" in result.stderr- assert not output.exists()---def test_matching_code_paths_combine_even_when_the_prose_differs(- tmp_path: Path,-) -> None:- first = candidate(- [- location("app/query.py", 4, "sink"),- location("app/routes.py", 2, "entrypoint"),- location("app/query.py", 3, "root_control"),- ],- cwes=["cwe-089", "CWE-89"],- summary="The request id reaches an interpolated query",- evidence="The query uses an f-string",- context="Intentional training application",- )- second = candidate(- [- location("app/query.py", 3, "root_control"),- location("app/routes.py", 2, "entrypoint"),- location("app/query.py", 4, "sink"),- location("app/query.py", 4, "sink"),- ],- summary="SQL injection is reachable from the request",- evidence="The id is inserted directly into SQL",- context="Runs only on localhost",- )-- result, output = run_combiner(tmp_path, [[first], [second]])-- assert result.returncode == 0, result.stderr- rows = read_jsonl(output)- assert len(rows) == 1- assert rows[0]["candidate_id"].startswith("candidate-")- assert rows[0]["cwe_ids"] == ["CWE-89"]- assert rows[0]["locations"] == [- {"path": "app/routes.py", "start_line": 2, "end_line": 2, "role": "entrypoint"},- {- "path": "app/query.py",- "start_line": 3,- "end_line": 3,- "role": "root_control",- },- {"path": "app/query.py", "start_line": 4, "end_line": 4, "role": "sink"},- ]- assert rows[0]["summary"] == (- "SQL injection is reachable from the request\nThe request id reaches an interpolated query"- )- assert rows[0]["evidence"] == "The id is inserted directly into SQL\nThe query uses an f-string"- assert rows[0]["context"] == "Intentional training application\nRuns only on localhost"--- "first_locations,second_locations",- [- (- [- location("app/routes.py", 2, "entrypoint"),- location("helpers/shared.py", 3, "root_control"),- location("app/query.py", 4, "sink"),- ],- [- location("app/routes.py", 2, "entrypoint"),- location("helpers/shared.py", 3, "root_control"),- location("app/export.py", 4, "sink"),- ],- ),- (- [- location("app/routes.py", 2, "entrypoint"),- location("helpers/shared.py", 3, "root_control"),- location("app/query.py", 4, "sink"),- ],- [- location("app/export.py", 2, "entrypoint"),- location("helpers/shared.py", 3, "root_control"),- location("app/query.py", 4, "sink"),- ],- ),- ],-)-def test_different_reachable_paths_remain_separate(- tmp_path: Path,- first_locations: list[dict[str, object]],- second_locations: list[dict[str, object]],-) -> None:- result, output = run_combiner(- tmp_path,- [[candidate(first_locations), candidate(second_locations)]],- )-- assert result.returncode == 0, result.stderr- rows = read_jsonl(output)- assert len(rows) == 2- assert rows[0]["candidate_id"] != rows[1]["candidate_id"]---def test_separate_bugs_at_the_same_locations_can_use_an_instance_label(- tmp_path: Path,-) -> None:- locations = [- location("app/routes.py", 2, "entrypoint"),- location("app/query.py", 4, "sink"),- ]- first = candidate(locations, instance="id parameter")- second = candidate(locations, instance="sort parameter")-- result, output = run_combiner(tmp_path, [[first, second]])-- assert result.returncode == 0, result.stderr- rows = read_jsonl(output)- assert len(rows) == 2- assert {row["instance"] for row in rows} == {"id parameter", "sort parameter"}- assert rows[0]["candidate_id"] != rows[1]["candidate_id"]---def test_output_is_stable_when_input_and_row_order_changes(tmp_path: Path) -> None:- duplicate_one = candidate(- [- location("app/routes.py", 2, "entrypoint"),- location("app/query.py", 4, "sink"),- ],- summary="Request id reaches SQL",- evidence="The query interpolates id",- )- duplicate_two = candidate(- [- location("app/query.py", 4, "sink"),- location("app/routes.py", 2, "entrypoint"),- ],- summary="SQL is built from request input",- evidence="The id is part of the query string",- )- separate = candidate(- [- location("app/export.py", 2, "entrypoint"),- location("app/export.py", 4, "sink"),- ],- cwes=["CWE-22"],- summary="The export path is unsafe",- evidence="The path is joined without a containment check",- )-- first, first_output = run_combiner(- tmp_path,- [[duplicate_one, separate], [duplicate_two]],- output_name="first.jsonl",- )- second, second_output = run_combiner(- tmp_path,- [[duplicate_two], [separate, duplicate_one]],- output_name="second.jsonl",- )-- assert first.returncode == 0, first.stderr- assert second.returncode == 0, second.stderr- assert first_output.read_bytes() == second_output.read_bytes()---def test_combined_output_can_be_combined_again_without_changing_it(- tmp_path: Path,-) -> None:- repo, scope = setup_repo(tmp_path)- locations = [- location("app/routes.py", 2, "entrypoint"),- location("app/query.py", 4, "sink"),- ]- first, first_output = run_combiner(- tmp_path,- [- [- candidate(locations, evidence="First trace"),- candidate(locations, evidence="Second trace"),- ]- ],- repo=repo,- scope=scope,- output_name="first.jsonl",- )- second_output = tmp_path / "second.jsonl"- second = subprocess.run(- [- sys.executable,- str(SCRIPT),- "--input",- str(first_output),- "--out",- str(second_output),- "--repo-root",- str(repo),- "--in-scope-files",- str(scope),- ],- capture_output=True,- text=True,- )-- assert first.returncode == 0, first.stderr- assert second.returncode == 0, second.stderr- assert first_output.read_bytes() == second_output.read_bytes()---def test_multiline_candidate_text_keeps_its_original_order(tmp_path: Path) -> None:- summary = "Z: attacker reaches the route.\nA: the route then reaches the sink."- evidence = "Z: read the request.\nA: pass it into the query."- context = "Z: enabled in the demo.\nA: runs only on localhost."- row = candidate(- [location("app/routes.py", 2, "entrypoint")],- summary=summary,- evidence=evidence,- context=context,- )-- result, output = run_combiner(tmp_path, [[row]])-- assert result.returncode == 0, result.stderr- combined = read_jsonl(output)[0]- assert combined["summary"] == summary- assert combined["evidence"] == evidence- assert combined["context"] == context---def test_unknown_cwe_and_supporting_location_outside_scope_are_allowed(- tmp_path: Path,-) -> None:- row = candidate(- [- location("app/routes.py", 2, "entrypoint"),- location("helpers/shared.py", 3, "root_control"),- ],- cwes=[],- )-- result, output = run_combiner(tmp_path, [[row]])-- assert result.returncode == 0, result.stderr- assert read_jsonl(output)[0]["cwe_ids"] == []--- ("change", "message"),- [- (lambda row: row.pop("cwe_ids"), "cwe_ids: expected an array"),- (- lambda row: row.update(cwe_ids=["SQL injection"]),- "cwe_ids: unsupported value",- ),- (lambda row: row.update(locations=[]), "locations: expected a non-empty array"),- (- lambda row: row["locations"][0].update(path="app/missing.py"),- "missing.py",- ),- (- lambda row: row["locations"][0].update(path="../outside.py"),- "repository-relative path without traversal",- ),- (- lambda row: row["locations"][0].update(start_line=6),- "line range 6-6 exceeds app/routes.py:5",- ),- (- lambda row: row["locations"][0].update(end_line=1),- "greater than or equal",- ),- (- lambda row: row["locations"][0].update(role="rootControl"),- "role: unsupported value",- ),- (- lambda row: row["locations"][0].update(line=2),- "locations: unsupported fields line",- ),- (- lambda row: row.update(technically_validated=True),- "unsupported fields technically_validated",- ),- (- lambda row: row.update(disposition="reportable"),- "unsupported fields disposition",- ),- ],-)-def test_invalid_candidates_fail_with_the_input_row(- tmp_path: Path, change: Callable[[dict[str, object]], object], message: str-) -> None:- valid = candidate([location("app/routes.py", 2, "entrypoint")])- invalid = candidate([location("app/routes.py", 2, "entrypoint")])- change(invalid)-- result, output = run_combiner(tmp_path, [[valid, invalid]])-- assert result.returncode == 2- assert "candidates-0.jsonl row 2:" in result.stderr- assert message in result.stderr- assert not output.exists()---def test_candidate_with_no_in_scope_location_fails(tmp_path: Path) -> None:- row = candidate([location("helpers/shared.py", 3, "root_control")])-- result, output = run_combiner(tmp_path, [[row]])-- assert result.returncode == 2- assert "expected at least one in-scope file" in result.stderr- assert not output.exists()---def test_malformed_json_does_not_replace_an_existing_output(tmp_path: Path) -> None:- repo, scope = setup_repo(tmp_path)- source = tmp_path / "candidates.jsonl"- source.write_text(- json.dumps(candidate([location("app/routes.py", 2, "entrypoint")])) + "\nnot-json\n",- encoding="utf-8",- )- output = tmp_path / "combined.jsonl"- output.write_text("previous output\n", encoding="utf-8")-- result = subprocess.run(- [- sys.executable,- str(SCRIPT),- "--input",- str(source),- "--out",- str(output),- "--repo-root",- str(repo),- "--in-scope-files",- str(scope),- ],- capture_output=True,- text=True,- )-- assert result.returncode == 2- assert "candidates.jsonl row 2:" in result.stderr- assert output.read_text(encoding="utf-8") == "previous output\n"---def test_empty_candidate_input_produces_an_empty_ledger(tmp_path: Path) -> None:- result, output = run_combiner(tmp_path, [[]])-- assert result.returncode == 0, result.stderr- assert output.read_text(encoding="utf-8") == ""---def test_output_cannot_replace_the_in_scope_file_list(tmp_path: Path) -> None:- repo, scope = setup_repo(tmp_path)- source = tmp_path / "candidates.jsonl"- write_jsonl(source, [candidate([location("app/routes.py", 2, "entrypoint")])])- original_scope = scope.read_text(encoding="utf-8")-- result = subprocess.run(- [- sys.executable,- str(SCRIPT),- "--input",- str(source),- "--out",- str(scope),- "--repo-root",- str(repo),- "--in-scope-files",- str(scope),- ],- capture_output=True,- text=True,- )-- assert result.returncode == 2- assert "--out: must not replace --in-scope-files" in result.stderr- assert scope.read_text(encoding="utf-8") == original_scopediff --git a/sdk/typescript/src/custom-validation-prompt.ts b/sdk/typescript/src/custom-validation-prompt.tsindex 93a1ec42e..dbf3cedc0 100644--- a/sdk/typescript/src/custom-validation-prompt.ts+++ b/sdk/typescript/src/custom-validation-prompt.ts@@ -13,7 +13,7 @@ const SOURCES = {"skills/security-scan/SKILL.md":"5b8f5d7debeca14c6b37e8e7ba737671362b8eb4b7f49e693c99c6bd04bc8fa0","skills/security-diff-scan/SKILL.md":- "0a4c519ad713585876ea7eb0a8af4b59892c86746f4c69851db9ab347b7fad2f",+ "a158847ce309e37fe367b52b02dbd169dd6c61ac31ee7b7daab06488ac1fef00",} as const;const DISABLED_TOOLS = [diff --git a/sdk/typescript/tests-ts/candidate-normalizer.test.ts b/sdk/typescript/tests-ts/candidate-normalizer.test.tsnew file mode 100644index 000000000..a5d0fe2d2--- /dev/null+++ b/sdk/typescript/tests-ts/candidate-normalizer.test.ts@@ -0,0 +1,794 @@+import { spawnSync } from "node:child_process";+import {+ existsSync,+ mkdirSync,+ mkdtempSync,+ readFileSync,+ readdirSync,+ realpathSync,+ rmSync,+ statSync,+ symlinkSync,+ writeFileSync,+} from "node:fs";+import { tmpdir } from "node:os";+import { basename, dirname, join, toNamespacedPath } from "node:path";+import { afterEach, describe, expect, test } from "bun:test";+import { PLUGIN_ROOT } from "./plugin-root.js";++const node = Bun.which("node")!;+const helper = join(PLUGIN_ROOT, "mcp", "helpers.mjs");+const roots: string[] = [];+type Row = Record<string, unknown>;+interface Fixture {+ root: string;+ repo: string;+ scope: string;+ output: string;+}+const location = (+ path = "app/routes.py",+ start_line = 2,+ role = "entrypoint",+) => ({ path, start_line, role });+const candidate = (locations: Row[] = [location()], extra: Row = {}) => ({+ cwe_ids: ["CWE-89"],+ locations,+ summary: "Request input reaches an unsafe operation",+ evidence: "The input reaches the operation without a check",+ ...extra,+});+function write(path: string, data: string | Buffer): void {+ mkdirSync(dirname(path), { recursive: true });+ writeFileSync(path, data);+}+function fixture(): Fixture {+ const root = realpathSync(+ mkdtempSync(join(tmpdir(), "candidate-normalizer-")),+ );+ roots.push(root);+ const repo = join(root, "İrepository");+ for (const path of [+ "app/routes.py",+ "app/query.py",+ "app/export.py",+ "helpers/shared.py",+ ])+ write(join(repo, path), "one\ntwo\nthree\nfour\nfive\n");+ const scope = join(root, "in-scope.txt");+ write(scope, "app/routes.py\napp/query.py\napp/export.py\n");+ return { root, repo, scope, output: join(root, "combined.jsonl") };+}+function run(+ f: Fixture,+ groups: Row[][],+ extra: string[] = [],+ env = process.env,+) {+ const inputs = groups.map((rows, index) => {+ const input = join(f.root, `candidates-${index}.jsonl`);+ write(input, rows.map((row) => JSON.stringify(row)).join("\n") + "\n");+ return input;+ });+ return invoke(f, inputs, extra, env);+}+function invoke(+ f: Fixture,+ inputs: string[],+ extra: string[] = [],+ env = process.env,+) {+ return spawnSync(+ node,+ [+ helper,+ "normalize-candidates",+ "--input",+ ...inputs,+ "--out",+ f.output,+ "--repo-root",+ f.repo,+ "--in-scope-files",+ f.scope,+ ...extra,+ ],+ {+ encoding: "utf8",+ env,+ cwd: f.root,+ maxBuffer: Infinity,+ },+ );+}+function ledger(f: Fixture): Row[] {+ return readFileSync(f.output, "utf8")+ .split(/\r?\n/u)+ .filter(Boolean)+ .map((line) => JSON.parse(line) as Row);+}+afterEach(() => {+ for (const root of roots.splice(0))+ rmSync(root, { recursive: true, force: true });+});++describe("built candidate normalizer", () => {+ test.skipIf(process.platform !== "linux")(+ "accepts many input paths through the packaged launcher",+ () => {+ const f = fixture();+ const row = `${JSON.stringify(candidate())}\n`;+ const inputs = Array.from({ length: 700 }, (_, index) => {+ const path = join(+ f.root,+ `worker-${index}-${"input".repeat(16)}.jsonl`,+ );+ write(path, row);+ return path;+ });+ const result = spawnSync(+ join(PLUGIN_ROOT, "scripts", "launch_codex_security_mcp"),+ [+ "--helper",+ "normalize-candidates",+ "--input",+ ...inputs,+ "--out",+ f.output,+ "--repo-root",+ f.repo,+ "--in-scope-files",+ f.scope,+ ],+ {+ cwd: f.root,+ env: { ...process.env, CODEX_MCP_NODE_PATH: node },+ encoding: "utf8",+ },+ );+ expect(result.status, result.stderr).toBe(0);+ expect(result.stdout).toBe(+ `Combined 700 candidate rows into 1 rows in ${f.output}\n`,+ );+ expect(ledger(f)).toHaveLength(1);+ },+ );++ test("combines canonical code paths without Python and preserves separate instances", () => {+ const f = fixture();+ const locations = [+ location("app/query.py", 4, "sink"),+ location("./app/routes.py"),+ location("app/query.py", 3, "root_control"),+ ];+ const first = candidate(locations, {+ cwe_ids: ["cwe-089", "CWE-89"],+ summary: "Z: request reaches SQL\nA: query runs",+ evidence: "First trace",+ context: "First review",+ });+ const second = candidate(+ [...locations].reverse().concat(location("app/query.py", 4, "sink")),+ {+ summary: "A second review",+ evidence: "Second trace",+ context: "Second review",+ },+ );+ const result = run(+ f,+ [[first], [second, candidate(locations, { instance: "sort parameter" })]],+ [],+ { ...process.env, PATH: "" },+ );+ expect(result.status, result.stderr).toBe(0);+ expect(result.stdout).toBe(+ `Combined 3 candidate rows into 2 rows in ${toNamespacedPath(f.output)}\n`,+ );+ const rows = ledger(f);+ expect(rows).toHaveLength(2);+ const merged = rows.find((row) => row["instance"] === undefined)!;+ expect(merged["cwe_ids"]).toEqual(["CWE-89"]);+ expect(merged["locations"]).toEqual([+ { path: "app/routes.py", start_line: 2, end_line: 2, role: "entrypoint" },+ {+ path: "app/query.py",+ start_line: 3,+ end_line: 3,+ role: "root_control",+ },+ { path: "app/query.py", start_line: 4, end_line: 4, role: "sink" },+ ]);+ expect(merged["summary"]).toBe(+ "A second review\nZ: request reaches SQL\nA: query runs",+ );+ expect(merged["evidence"]).toBe("First trace\nSecond trace");+ expect(merged["context"]).toBe("First review\nSecond review");+ expect(rows.some((row) => row["instance"] === "sort parameter")).toBe(true);+ if (process.platform !== "win32")+ expect(statSync(f.output).mode & 0o777).toBe(0o600);+ });++ test("is byte-stable across input order, duplicate aliases, and recombination", () => {+ const f = fixture();+ const first = candidate([location(), location("app/query.py", 4, "sink")], {+ evidence: "First trace",+ });+ const second = candidate([...first["locations"]].reverse(), {+ evidence: "Second trace",+ });+ const separate = candidate(+ [location("app/export.py", 2), location("app/export.py", 4, "sink")],+ { cwe_ids: ["CWE-22"] },+ );+ expect(run(f, [[first, separate], [second]]).status).toBe(0);+ const expected = readFileSync(f.output);+ expect(run(f, [[second], [separate, first]]).status).toBe(0);+ expect(readFileSync(f.output)).toEqual(expected);+ const input = join(f.root, "previous.jsonl");+ write(input, expected);+ expect(invoke(f, [input, input]).status).toBe(0);+ expect(readFileSync(f.output)).toEqual(expected);+ if (process.platform !== "win32") {+ const alias = join(f.root, "input-alias.jsonl");+ symlinkSync(input, alias);+ const result = invoke(f, [input, alias]);+ expect(result.status, result.stderr).toBe(0);+ expect(result.stdout).toContain("Combined 2 candidate rows into 2 rows");+ expect(readFileSync(f.output)).toEqual(expected);+ }+ });++ test("keeps different entrypoints and sinks and allows supporting files outside scope", () => {+ const f = fixture();+ const shared = location("helpers/shared.py", 3, "root_control");+ const rows = [+ candidate([location(), shared, location("app/query.py", 4, "sink")], {+ cwe_ids: [],+ }),+ candidate([location(), shared, location("app/export.py", 4, "sink")], {+ cwe_ids: [],+ }),+ candidate(+ [+ location("app/export.py", 2),+ shared,+ location("app/query.py", 4, "sink"),+ ],+ { cwe_ids: [] },+ ),+ ];+ expect(run(f, [rows]).status).toBe(0);+ expect(ledger(f)).toHaveLength(3);+ expect(+ ledger(f).every((row) => (row["cwe_ids"] as unknown[]).length === 0),+ ).toBe(true);+ const rejected = run(f, [[candidate([shared])]]);+ expect(rejected.status).toBe(2);+ expect(rejected.stderr).toContain("expected at least one in-scope file");+ });++ test("normalizes Unicode candidates deterministically with native string order", () => {+ const f = fixture();+ const names = ["app/\u{10000}.py", "app/\ue000.py"];+ for (const name of names) write(join(f.repo, name), "line\n");+ write(f.scope, names.join("\n") + "\n");+ const row = candidate(+ names.map((name) => location(name, 1, "evidence")),+ {+ cwe_ids: ["CWE-002", "cwe-0089", "CWE-89", "CWE-9007199254740993"],+ summary: " \ufeffSummary\u00a0",+ evidence: "\u{10000}",+ },+ );+ const result = run(f, [[row, { ...row, evidence: "\ue000" }]]);+ expect(result.status, result.stderr).toBe(0);+ const value = ledger(f)[0]!;+ expect(value["cwe_ids"]).toEqual([+ "CWE-2",+ "CWE-89",+ "CWE-9007199254740993",+ ]);+ expect((value["locations"] as Row[]).map((item) => item["path"])).toEqual(+ names,+ );+ expect(value["summary"]).toBe("Summary");+ expect(value["evidence"]).toBe("\u{10000}\n\ue000");+ const reordered = {+ ...row,+ locations: [...(row.locations as Row[])].reverse(),+ };+ expect(+ run(f, [[{ ...reordered, evidence: "\ue000" }, reordered]]).status,+ ).toBe(0);+ expect(ledger(f)).toEqual([value]);+ expect(readFileSync(f.output, "utf8").startsWith('{"candidate_id":')).toBe(+ true,+ );+ });++ test("counts source lines as bytes separated by CR, LF, or CRLF", () => {+ const f = fixture();+ for (const [contents, count] of [+ [Buffer.from("a\rb\r\nc\n"), 3],+ [Buffer.from("a\vb\fc\u0085d\u2028e"), 1],+ [Buffer.from("unterminated"), 1],+ [Buffer.alloc(0), 0],+ [Buffer.from([0xff, 0x0a, 0xfe]), 2],+ ] as const) {+ write(join(f.repo, "app/routes.py"), contents);+ if (count > 0)+ expect(+ run(f, [[candidate([location("app/routes.py", count)])]]).status,+ ).toBe(0);+ const result = run(f, [+ [candidate([location("app/routes.py", count + 1)])],+ ]);+ expect(result.status).toBe(2);+ expect(result.stderr).toContain(`exceeds app/routes.py:${count}`);+ }+ });++ test("rejects invalid line values, malformed rows, and invalid UTF-8 atomically", () => {+ const f = fixture();+ const input = join(f.root, "raw.jsonl");+ write(f.output, "previous output\n");+ for (const number of [+ "1.5",+ "true",+ "0",+ "-1",+ "NaN",+ "Infinity",+ "1e9999",+ '"1"',+ ]) {+ write(+ input,+ JSON.stringify(candidate([location("app/routes.py", 1)])).replace(+ '"start_line":1',+ `"start_line":${number}`,+ ) + "\n",+ );+ const result = invoke(f, [input]);+ expect(result.status).toBe(2);+ expect(result.stderr).toContain("row 1:");+ expect(readFileSync(f.output, "utf8")).toBe("previous output\n");+ }+ const prefix = Buffer.from(+ JSON.stringify(+ candidate(undefined, { cwe_ids: [], summary: "s", evidence: "" }),+ ).slice(0, -2),+ );+ const invalidLongJson = Buffer.concat([+ prefix,+ Buffer.alloc(191 - prefix.length, 0x61),+ Buffer.from([0xff]),+ Buffer.from('"}'),+ ]);+ for (const invalid of [+ invalidLongJson,+ "not-json",+ "[]",+ "null",+ '{"locations":',+ "\ufeff{}",+ Buffer.from([0xff]),+ ]) {+ write(input, invalid);+ const result = invoke(f, [input]);+ expect(result.status).toBe(2);+ expect(readFileSync(f.output, "utf8")).toBe("previous output\n");+ }+ write(input, JSON.stringify(candidate()) + "\r\n\nnot-json\n");+ expect(invoke(f, [input]).stderr).toContain("raw.jsonl row 3:");+ expect(readFileSync(f.output, "utf8")).toBe("previous output\n");+ expect(readdirSync(f.root).some((name) => name.endsWith(".tmp"))).toBe(+ false,+ );+ });++ test("reports invalid fields with the input row and preserves existing output", () => {+ const f = fixture();+ const cases: [Row, string][] = [+ [candidate(undefined, { cwe_ids: null }), "cwe_ids: expected an array"],+ [+ candidate(undefined, { cwe_ids: [12] }),+ "cwe_ids: expected CWE strings",+ ],+ [+ candidate(undefined, { cwe_ids: ["SQL injection"] }),+ "cwe_ids: unsupported value",+ ],+ [+ candidate(undefined, { cwe_ids: ["CWE-0"] }),+ "cwe_ids: unsupported value",+ ],+ [candidate([]), "locations: expected a non-empty array"],+ [+ candidate([null as unknown as Row]),+ "locations: expected location objects",+ ],+ [candidate([location("app/missing.py")]), "missing.py"],+ [+ candidate([location("../outside.py")]),+ "repository-relative path without traversal",+ ],+ [+ candidate([location(f.repo)]),+ "repository-relative path without traversal",+ ],+ [candidate([location("app")]), "path: expected a regular file"],+ [+ candidate([location("app/routes.py", 6)]),+ "line range 6-6 exceeds app/routes.py:5",+ ],+ [candidate([{ ...location(), end_line: 1 }]), "greater than or equal"],+ [+ candidate([location("app/routes.py", 1, "rootControl")]),+ "role: unsupported value",+ ],+ [+ candidate([{ ...location(), line: 2 }]),+ "locations: unsupported fields line",+ ],+ [+ candidate(undefined, { technically_validated: true }),+ "unsupported fields technically_validated",+ ],+ [+ candidate(undefined, { disposition: "reportable" }),+ "unsupported fields disposition",+ ],+ [+ candidate(undefined, { candidate_id: " " }),+ "candidate_id: expected a non-empty string",+ ],+ [+ candidate(undefined, { summary: " \t\r\n" }),+ "summary: expected a non-empty string",+ ],+ [+ candidate(undefined, { evidence: null }),+ "evidence: expected a non-empty string",+ ],+ [+ candidate(undefined, { context: " " }),+ "context: expected a non-empty string",+ ],+ [+ candidate(undefined, { instance: false }),+ "instance: expected a non-empty string",+ ],+ ];+ write(f.output, "previous output\n");+ for (const [row, message] of cases) {+ const result = run(f, [[candidate(), row]]);+ expect(result.status).toBe(2);+ expect(result.stderr).toContain("candidates-0.jsonl row 2:");+ expect(result.stderr).toContain(message);+ expect(readFileSync(f.output, "utf8")).toBe("previous output\n");+ }+ });++ test.skipIf(process.platform === "win32")(+ "rejects unsupported surrogate paths before replacement-character sibling lookup",+ () => {+ const f = fixture();+ write(join(f.repo, "\ufffd.py"), "replacement sibling\n");+ write(f.scope, "\ufffd.py\n");+ write(f.output, "previous output\n");+ for (const name of ["\ud800.py", "\udc00.py"]) {+ const result = run(f, [[candidate([location(name, 1)])]]);+ expect(result.status).toBe(2);+ expect(result.stderr).toContain("unpaired surrogate");+ expect(readFileSync(f.output, "utf8")).toBe("previous output\n");+ }+ },+ );++ test("writes valid long output basenames through a short exclusive temporary name", () => {+ const f = fixture();+ f.output = join(f.root, `${"x".repeat(249)}.jsonl`);+ const result = run(f, [[candidate()]]);+ expect(result.status, result.stderr).toBe(0);+ expect(ledger(f)).toHaveLength(1);+ expect(readdirSync(f.root).some((name) => name.endsWith(".tmp"))).toBe(+ false,+ );+ });++ test.skipIf(process.platform === "win32")(+ "rejects scope symlink loops without replacing existing output",+ () => {+ const f = fixture();+ const loop = join(f.repo, "app/loop.py");+ symlinkSync(loop, loop);+ write(f.scope, "app/loop.py\n");+ write(f.output, "previous output\n");+ const result = run(f, [[candidate()]]);+ expect(result.status).toBe(2);+ expect(result.stderr).toContain("in-scope file row 1:");+ expect(readFileSync(f.output, "utf8")).toBe("previous output\n");+ },+ );++ test("handles empty ledgers and protects resolved input and inventory destinations", () => {+ const f = fixture();+ expect(run(f, [[]]).status).toBe(0);+ expect(readFileSync(f.output, "utf8")).toBe("");+ const source = join(f.root, "candidates-0.jsonl");+ expect(invoke({ ...f, output: source }, [source]).stderr).toContain(+ "--out: must not also be an input",+ );+ const scopeBefore = readFileSync(f.scope);+ expect(invoke({ ...f, output: f.scope }, [source]).stderr).toContain(+ "--out: must not replace --in-scope-files",+ );+ expect(readFileSync(f.scope)).toEqual(scopeBefore);+ if (process.platform !== "win32") {+ const alias = join(f.root, "output-alias");+ symlinkSync(source, alias);+ expect(invoke({ ...f, output: alias }, [source]).stderr).toContain(+ "--out: must not also be an input",+ );+ const missing = join(f.root, "missing.jsonl");+ const dangling = join(f.root, "dangling-output");+ symlinkSync(missing, dangling);+ expect(run({ ...f, output: dangling }, [[candidate()]]).status).toBe(2);+ expect(existsSync(missing)).toBe(false);++ symlinkSync(f.root, join(f.root, "directory-alias"), "dir");+ for (const protectedPath of [source, f.scope]) {+ const before = readFileSync(protectedPath);+ const output = `${f.root}/missing/../directory-alias/${basename(protectedPath)}`;+ expect(invoke({ ...f, output }, [source]).status).toBe(2);+ expect(readFileSync(protectedPath)).toEqual(before);+ }+ expect(existsSync(join(f.root, "missing"))).toBe(false);+ }+ const nested = {+ ...f,+ output: join(f.root, "new", "nested", "ledger.jsonl"),+ };+ expect(run(nested, [[candidate()]]).status).toBe(0);+ expect(ledger(nested)).toHaveLength(1);+ });++ test("allows deleted inventory paths only when requested and keeps candidate files strict", () => {+ const f = fixture();+ write(f.scope, "app/deleted.py\napp/routes.py\n");+ const strict = run(f, [[candidate()]]);+ expect(strict.status).toBe(2);+ expect(strict.stderr).toContain("in-scope file row 1:");+ expect(run(f, [[candidate()]], ["--allow-missing-in-scope"]).status).toBe(+ 0,+ );+ expect(+ run(+ f,+ [[candidate([location("app/deleted.py")])]],+ ["--allow-missing-in-scope"],+ ).status,+ ).toBe(2);+ write(f.scope, "../deleted.py\napp/routes.py\n");+ expect(run(f, [[candidate()]], ["--allow-missing-in-scope"]).status).toBe(+ 2,+ );+ if (process.platform !== "win32") {+ const outside = join(f.root, "outside");+ mkdirSync(outside);+ symlinkSync(outside, join(f.repo, "outside"), "dir");+ write(f.scope, "outside/deleted.py\napp/routes.py\n");+ const escaped = run(f, [[candidate()]], ["--allow-missing-in-scope"]);+ expect(escaped.status).toBe(2);+ expect(escaped.stderr).toContain("path escapes repository");+ }+ });++ test("accepts CRLF, mixed newline, and unterminated inventories", () => {+ const f = fixture();+ for (const inventory of [+ "\r\napp/routes.py\r\napp/query.py\r\n",+ "app/routes.py\r\napp/query.py\n",+ "app/routes.py\r\napp/query.py",+ ]) {+ write(f.scope, inventory);+ expect(run(f, [[candidate()]]).status).toBe(0);+ expect((ledger(f)[0]!["locations"] as Row[])[0]!["path"]).toBe(+ "app/routes.py",+ );+ }+ });++ test.skipIf(process.platform === "win32")(+ "preserves literal POSIX names and rejects incompatible candidate paths",+ () => {+ const f = fixture();+ for (const name of [+ "app/ leading.py",+ "app/trailing .py",+ "app/résumé.py",+ "app/路径.py",+ ]) {+ write(join(f.repo, name), "line\n");+ write(f.scope, name + "\n");+ const result = run(f, [[candidate([location(name, 1)])]]);+ expect(result.status, result.stderr).toBe(0);+ expect((ledger(f)[0]!["locations"] as Row[])[0]!["path"]).toBe(name);+ }+ for (const name of ["app/literal\\name.py", "app/C:foo.py", " ", " "]) {+ write(join(f.repo, name), "line\n");+ write(f.scope, name + "\n");+ const result = run(f, [[candidate([location(name, 1)])]]);+ expect(result.status).toBe(2);+ expect(result.stderr).toContain("safe repository-relative POSIX path");+ }+ },+ );++ test.skipIf(process.platform !== "win32")(+ "normalizes Windows separators and rejects drive-qualified locations",+ () => {+ const f = fixture();+ write(f.scope, "app\\routes.py\r\n");+ expect(run(f, [[candidate([location("app\\routes.py")])]]).status).toBe(+ 0,+ );+ expect((ledger(f)[0]!["locations"] as Row[])[0]!["path"]).toBe(+ "app/routes.py",+ );+ const result = run(f, [[candidate([location("C:routes.py")])]]);+ expect(result.status).toBe(2);+ expect(result.stderr).toContain(+ "repository-relative path without traversal",+ );+ },+ );++ test.skipIf(process.platform !== "linux")(+ "preserves an invalid filename byte near the end of a longer launcher payload",+ () => {+ const f = fixture();+ const input = Buffer.concat([+ Buffer.from(join(f.root, "candidates-")),+ Buffer.from([0xff]),+ ]);+ writeFileSync(input, JSON.stringify(candidate()) + "\n");+ write(join(f.root, "candidates-\ufffd"), "wrong input\n");+ const args = [+ "normalize-candidates",+ "--repo-root",+ "İrepository",+ "--in-scope-files",+ "in-scope.txt",+ "--out",+ "combined.jsonl",+ "--input",+ "candidates-",+ ];+ // The invalid byte sits at offset 191, where Node 20's decoder lost it.+ const padding =+ 193 - Buffer.byteLength(["x", "", ...args].join("\0")) - 2;+ const result = spawnSync(+ "/bin/sh",+ [+ "-c",+ 'exec "$1" --helper normalize-candidates --repo-root "$2" --in-scope-files in-scope.txt --out combined.jsonl --input "candidates-$(printf \'\\377\')"',+ "helper-test",+ join(PLUGIN_ROOT, "scripts", "launch_codex_security_mcp"),+ "İrepository",+ ],+ {+ cwd: f.root,+ env: {+ ...process.env,+ HOME: "h".repeat(padding),+ CODEX_MCP_NODE_PATH: node,+ },+ encoding: "utf8",+ },+ );+ expect(result.status, result.stderr).toBe(0);+ expect(ledger(f)).toHaveLength(1);+ expect(readFileSync(join(f.root, "candidates-\ufffd"), "utf8")).toBe(+ "wrong input\n",+ );+ },+ );++ test.skipIf(process.platform === "win32")(+ "preserves canonical byte paths and rejects links outside the repository",+ () => {+ const f = fixture();+ const raw = Buffer.concat([+ Buffer.from(f.root + "/repository-"),+ process.platform === "darwin" ? Buffer.from("é") : Buffer.from([0xff]),+ ]);+ mkdirSync(raw);+ writeFileSync(Buffer.concat([raw, Buffer.from("/entry.py")]), "one\n");+ const alias = join(f.root, "alias");+ symlinkSync(raw, alias, "dir");+ write(f.scope, "entry.py\n");+ const result = run({ ...f, repo: alias }, [+ [candidate([location("entry.py", 1)])],+ ]);+ expect(result.status, result.stderr).toBe(0);+ expect((ledger(f)[0]!["locations"] as Row[])[0]!["path"]).toBe(+ "entry.py",+ );+ const outside = join(f.root, "outside.py");+ write(outside, "one\n");+ symlinkSync(outside, join(f.repo, "outside.py"));+ write(f.scope, "app/routes.py\n");+ const escaped = run(f, [+ [candidate([location(), location("outside.py", 1, "sink")])],+ ]);+ expect(escaped.status).toBe(2);+ expect(escaped.stderr).toContain("must resolve inside --repo-root");+ },+ );++ test.skipIf(process.platform !== "win32")(+ "keeps Unicode sibling directories outside candidate and deleted-file scope",+ () => {+ const f = fixture();+ const sibling = join(f.root, "i\u0307repository");+ write(join(sibling, "source.py"), "one\n");+ symlinkSync(sibling, join(f.repo, "outside"), "junction");+ const escaped = run(f, [+ [candidate([location(), location("outside/source.py", 1, "sink")])],+ ]);+ expect(escaped.status).toBe(2);+ expect(escaped.stderr).toContain("must resolve inside --repo-root");+ write(f.scope, "app/routes.py\noutside/deleted.py\n");+ const missing = run(f, [[candidate()]], ["--allow-missing-in-scope"]);+ expect(missing.status).toBe(2);+ expect(missing.stderr).toContain("path escapes repository");+ expect(existsSync(f.output)).toBe(false);+ },+ );++ test("accepts documented options, multiple inputs, home expansion, and literal dash output", () => {+ const f = fixture();+ run(f, [[candidate()]]);+ const input = join(f.root, "candidates-0.jsonl");+ const result = spawnSync(+ node,+ [+ helper,+ "normalize-candidates",+ "--input",+ input,+ input,+ "--out=-",+ "--repo-root",+ "~/İrepository",+ "--in-scope-files=~/in-scope.txt",+ ],+ {+ cwd: f.root,+ env: { ...process.env, HOME: f.root, USERPROFILE: f.root },+ encoding: "utf8",+ },+ );+ expect(result.status, result.stderr).toBe(0);+ expect(JSON.parse(readFileSync(join(f.root, "-"), "utf8"))).toHaveProperty(+ "candidate_id",+ );+ expect(+ spawnSync(node, [helper, "normalize-candidates", "--help"], {+ encoding: "utf8",+ }).status,+ ).toBe(0);+ for (const args of [+ [],+ ["--input"],+ ["--unknown", input],+ ["--allow-missing-in-scope=true"],+ ])+ expect(+ spawnSync(node, [helper, "normalize-candidates", ...args]).status,+ ).toBe(2);+ });+});diff --git a/sdk/typescript/tests-ts/compact-diff-scan.test.ts b/sdk/typescript/tests-ts/compact-diff-scan.test.tsindex f117cb0c3..087eeda64 100644--- a/sdk/typescript/tests-ts/compact-diff-scan.test.ts+++ b/sdk/typescript/tests-ts/compact-diff-scan.test.ts@@ -378,23 +378,26 @@ describe("compact diff scan", () => {.map((entry) => JSON.stringify(entry)).join("\n") + "\n",);- const args = [- "--input",- input,- "--out",- output,- "--repo-root",- repository,- "--in-scope-files",- inventory,- ];-- expect(python("normalize_candidates.py", ...args).status).toBe(2);- const accepted = python(- "normalize_candidates.py",- ...args,- "--allow-missing-in-scope",- );+ const normalize = (...options: string[]) =>+ spawnSync(+ process.execPath,+ [+ join(PLUGIN_ROOT, "mcp", "helpers.mjs"),+ "normalize-candidates",+ "--input",+ input,+ "--out",+ output,+ "--repo-root",+ repository,+ "--in-scope-files",+ inventory,+ ...options,+ ],+ { encoding: "utf8" },+ );+ expect(normalize().status).toBe(2);+ const accepted = normalize("--allow-missing-in-scope");expect(accepted.status, accepted.stderr).toBe(0);const contents = readFileSync(output, "utf8");expect(contents).toContain("Résumé: missing guard");@@ -408,11 +411,7 @@ describe("compact diff scan", () => {]);writeFileSync(inventory, "../escaped.py\nsrc/handler.py\n");- const escaped = python(- "normalize_candidates.py",- ...args,- "--allow-missing-in-scope",- );+ const escaped = normalize("--allow-missing-in-scope");expect(escaped.status).toBe(2);expect(escaped.stderr).toContain("in-scope file row 1");});diff --git a/sdk/typescript/tests-ts/runtime.test.ts b/sdk/typescript/tests-ts/runtime.test.tsindex 21d8039b3..4e1b55fc1 100644--- a/sdk/typescript/tests-ts/runtime.test.ts+++ b/sdk/typescript/tests-ts/runtime.test.ts@@ -783,109 +783,78 @@ describe("plugin runtime preparation", () => {const python = Bun.which("python3") ?? Bun.which("python");expect(python).not.toBeNull();- const sourcePlugin = await bundledPluginRoot();- const projector = new URL(- "../scripts/project-plugin.mjs",- import.meta.url,- );- const publicManifest = new URL(- "../public-repo/sdk/typescript/plugin.public.json",- import.meta.url,- );- let bundledPlugin = sourcePlugin;- if (existsSync(projector) && existsSync(publicManifest)) {- const packageRoot = join(root, "package");- const isolatedProjector = join(- packageRoot,- "scripts",- "project-plugin.mjs",- );- const isolatedManifest = join(- packageRoot,- "public-repo",- "sdk",- "typescript",- "plugin.public.json",+ const bundledPlugin = await bundledPluginRoot();+ const normalizer = join(bundledPlugin, "mcp", "helpers.mjs");+ const node = Bun.which("node");+ expect(node).not.toBeNull();+ const locations: { path: string }[] = [];+ const input = join(root, "candidate-input.jsonl");+ const output = join(root, "candidate-output.jsonl");+ for (const item of cases) {+ await writeFile(+ input,+ JSON.stringify({+ cwe_ids: ["CWE-89"],+ locations: [{ path: item.path, start_line: 1, role: "entrypoint" }],+ summary: "Test finding",+ evidence: "Test evidence",+ }) + "\n",);- await Promise.all([- mkdir(dirname(isolatedProjector), { recursive: true }),- mkdir(dirname(isolatedManifest), { recursive: true }),- ]);- await Promise.all([- copyFile(projector, isolatedProjector),- copyFile(publicManifest, isolatedManifest),+ const normalized = Bun.spawnSync([+ node!,+ normalizer,+ "normalize-candidates",+ "--input",+ input,+ "--out",+ output,+ "--repo-root",+ root,+ "--in-scope-files",+ scopePath,]);- const projection = Bun.spawnSync(- [process.execPath, isolatedProjector],- {- cwd: packageRoot,- env: {- ...process.env,- CODEX_SECURITY_PLUGIN_ROOT: sourcePlugin,- },- stdout: "pipe",- stderr: "pipe",- },- );- expect(new TextDecoder().decode(projection.stderr)).toBe("");- expect(projection.exitCode).toBe(0);- bundledPlugin = join(packageRoot, "_bundled_plugin");+ const safe =+ item.path.trim().length > 0 &&+ !item.path.includes(":") &&+ !item.path.includes("\\");+ expect(normalized.exitCode).toBe(safe ? 0 : 2);+ if (safe) {+ const row = JSON.parse(await readFile(output, "utf8")) as {+ locations: typeof locations;+ };+ const location = row.locations[0]!;+ expect(location.path).toBe(item.path);+ expect(await readFile(join(root, location.path), "utf8")).toBe(+ item.contents,+ );+ locations.push(location);+ }}- const normalizer = join(- bundledPlugin,- "scripts",- "normalize_candidates.py",- );- expect(await readFile(normalizer, "utf8")).toBe(- await readFile(- join(sourcePlugin, "scripts", "normalize_candidates.py"),- "utf8",- ),- );const result = Bun.spawnSync([python!,"-I","-B","-c",[- "import json, pathlib, runpy, sys",- "module = runpy.run_path(sys.argv[1])",- "root = pathlib.Path(sys.argv[2])",- "scope = module['read_scope'](pathlib.Path(sys.argv[3]), root)",- "finalizer = runpy.run_path(sys.argv[5])",+ "import json, runpy, sys",+ "finalizer = runpy.run_path(sys.argv[1])","results = []",- "for value in json.loads(sys.argv[4]):",- " path, source = module['relative_file'](value, root)",- " candidate = {'cwe_ids': ['CWE-89'], 'locations': [{'path': value, 'start_line': 1, 'role': 'entrypoint'}], 'summary': 'Test finding', 'evidence': 'Test evidence'}",+ "for location in json.loads(sys.argv[2]):"," try:",- " normalized = module['normalize_candidate'](candidate, root, scope, {})",- " location = normalized['locations'][0]"," finalizer['_validate_location']({'path': location['path'], 'startLine': location['start_line'], 'endLine': location['end_line'], 'role': location['role']}, 'candidate.locations[0]')"," except ValueError:",- " contract_valid = False",+ " results.append(False)"," else:",- " contract_valid = True",- " results.append({'path': path, 'contents': source.read_text(encoding='utf-8'), 'inScope': path in scope, 'contractValid': contract_valid})",+ " results.append(True)","print(json.dumps(results))",].join("\n"),- normalizer,- root,- scopePath,- JSON.stringify(cases.map((item) => item.path)),join(bundledPlugin, "scripts", "finalize_scan_contract.py"),+ JSON.stringify(locations),]);expect(result.exitCode).toBe(0);expect(JSON.parse(new TextDecoder().decode(result.stdout))).toEqual(- cases.map((item) => ({- ...item,- inScope: true,- contractValid:- item.path.trim().length > 0 &&- !/^[A-Za-z]:/.test(item.path) &&- !item.path.includes("\\") &&- !/[\u0000-\u001f]/u.test(item.path),- })),+ locations.map((item) => !/[\u0000-\u001f]/u.test(item.path)),);},);diff --git a/sdk/typescript/tests-ts/security-policy-helper.test.ts b/sdk/typescript/tests-ts/security-policy-helper.test.tsindex 303d4101d..9291d4074 100644--- a/sdk/typescript/tests-ts/security-policy-helper.test.ts+++ b/sdk/typescript/tests-ts/security-policy-helper.test.ts@@ -74,56 +74,24 @@ afterEach(() => {});describe("built SECURITY.md helper", () => {- test("accepts negative-number paths and unique long-option prefixes", () => {- const { root } = fixture();- const cases: [string, string, string][] = [- ["-1", "-2", "-3"],- ["-١", "-.5", "-1.5"],- ];- if (process.platform !== "win32") cases.push(["-4", "-1\n", "-3\n"]);- for (const [repo, scope, output] of cases) {- write(root, `${repo}/${scope}/SECURITY.md`, "negative path policy\n");- const result = run(- ["--r", repo, "--s", scope, "--o", output],- process.env,- root,- );- expect(result.status, result.stderr).toBe(0);- expect(result.stdout).toBe("");- expect(readFileSync(join(root, output), "utf8")).toContain(- "negative path policy",- );- }- });-- test("accepts dash-prefixed paths containing spaces after option matching", () => {+ test("accepts dash-prefixed paths with equals syntax", () => {const { root } = fixture();for (const [repo, scope, output] of [- ["- repository", "- archived", "- guidance"],- ["--repo space", "--special space", "--other= output"],+ ["-1", "-2", "-3"],+ ["--repo space", "--scope space", "--output= guidance"],] as const) {- write(root, `${repo}/${scope}/SECURITY.md`, "space path policy\n");+ write(root, `${repo}/${scope}/SECURITY.md`, "dash path policy\n");const result = run(- ["--repo", repo, "--scope", scope, "--out", output],+ [`--repo=${repo}`, `--scope=${scope}`, `--out=${output}`],process.env,root,);expect(result.status, result.stderr).toBe(0);+ expect(result.stdout).toBe("");expect(readFileSync(join(root, output), "utf8")).toContain(- "space path policy",+ "dash path policy",);}- for (const value of [- "-hello world",- "--help=some text",- "--s=some text",- "--unsupported",- "-tab\tvalue",- ]) {- const result = run(["--repo", root, "--scope", value]);- expect(result.status, result.stderr).toBe(2);- expect(result.stdout).toBe("");- }});test.skipIf(process.platform !== "win32")(@@ -176,17 +144,21 @@ describe("built SECURITY.md helper", () => {expect(result.status, result.stderr).toBe(0);expect(result.stdout).toContain("home-variable policy");}- expect(run(["--repo", root, "--scope", "~"], homeEnv({})).status).toBe(1);+ expect(+ run(["--repo", root, "--scope", "~"], homeEnv({})).status,+ ).not.toBe(0);const other = homeEnv({ USERPROFILE: home, USERNAME: "different" });- expect(run(["--repo", "~other", "--scope", "."], other).status).toBe(1);+ expect(run(["--repo", "~other", "--scope", "."], other).status).not.toBe(+ 0,+ );for (const profile of ["\\\\host\\share\\","\\\\?\\UNC\\host\\share\\","\\\\?\\unc\\host\\share",]) {const shareRoot = homeEnv({ USERPROFILE: profile, USERNAME: "share" });- const result = run(["--repo", "~other", "--scope", "."], shareRoot);- expect(result.status, result.stderr).toBe(1);+ const result = run(["--repo", root, "--scope", "~other"], shareRoot);+ expect(result.status, result.stderr).not.toBe(0);expect(result.stderr).toContain("Could not determine home directory.");}},@@ -283,7 +255,7 @@ describe("built SECURITY.md helper", () => {expect(existsSync(join(root, "temporary.tmp"))).toBe(false);});- test("frames Unicode paths as ASCII JSON in codepoint order", () => {+ test("frames Unicode paths as ASCII JSON in standard string order", () => {const { root } = fixture();for (const name of ["\u{10000}", "\ue000", "\u0080", "\u007f"]) {write(root, `${name}/SECURITY.md`, "policy\n");@@ -291,7 +263,7 @@ describe("built SECURITY.md helper", () => {const result = inventory(root);expect(result.status, result.stderr).toBe(0);expect(result.stdout).toBe(- '["\\u007f/SECURITY.md", "\\u0080/SECURITY.md", "\\ue000/SECURITY.md", "\\ud800\\udc00/SECURITY.md"]\n',+ '["\\u007f/SECURITY.md", "\\u0080/SECURITY.md", "\\ud800\\udc00/SECURITY.md", "\\ue000/SECURITY.md"]\n',);const guidance = resolve(root, "\u{10000}").stdout;expectGuidance(guidance, [["\u{10000}/SECURITY.md", "policy"]]);@@ -327,7 +299,7 @@ describe("built SECURITY.md helper", () => {const result = inventory(root);expect(result.status, result.stderr).toBe(0);expect(result.stdout).toBe(- '["SECURITY.md", "\\u00e9\\udcff/SECURITY.md", "\\u00e9\\ue000/SECURITY.md", "\\u00e9\\ud800\\udc00/SECURITY.md"]\n',+ '["SECURITY.md", "\\u00e9\\ud800\\udc00/SECURITY.md", "\\u00e9\\udcff/SECURITY.md", "\\u00e9\\ue000/SECURITY.md"]\n',);expect(result.stderr).toBe("");},@@ -521,63 +493,37 @@ describe("built SECURITY.md helper", () => {expectGuidance(result.stdout, [["SECURITY.md", "\ufeff"]]);});- test("preserves path parsing for file scopes and output destinations", () => {- const { root, output } = fixture();- write(root, "src/SECURITY.md", "source policy\n");- write(root, "src/app.ts", "export {};\n");- const expected: [string, string][] = [["src/SECURITY.md", "source policy"]];- for (const scope of ["src/app.ts/", "./src//app.ts/./"]) {- const result = resolve(`${root}/./`, scope, "./-/");- expect(result.status, result.stderr).toBe(0);- expectGuidance(result.stdout, expected);- }- const destination = `${output}/guidance.md/./`;- const result = resolve(root, "src/app.ts", destination);- expect(result.status, result.stderr).toBe(0);- expect(result.stdout).toBe("");- expectGuidance(readFileSync(join(output, "guidance.md"), "utf8"), expected);- });-- test("resolves parent components after existing files and symbolic links", () => {- const { root } = fixture();- write(root, "nested/SECURITY.md", "nested policy\n");- write(root, "nested/file.ts", "export {};\n");- const expected: [string, string][] = [- ["nested/SECURITY.md", "nested policy"],- ];- for (const scope of ["nested/file.ts/..", "nested/SECURITY.md/../."]) {- const result = resolve(root, scope);- expect(result.status, result.stderr).toBe(0);- expectGuidance(result.stdout, expected);- }- const result = resolve(`${root}/nested/file.ts/..`, ".");- expect(result.status, result.stderr).toBe(0);- expectGuidance(result.stdout, [["SECURITY.md", "nested policy"]]);- symlinkSync("nested/file.ts/..", join(root, "alias"), "dir");- const linked = resolve(root, "alias");- expect(linked.status, linked.stderr).toBe(0);- expectGuidance(linked.stdout, expected);- const missing = resolve(root, "missing/../nested");- expect(missing.status, missing.stderr).toBe(- process.platform === "win32" ? 0 : 2,- );- if (process.platform === "win32") expectGuidance(missing.stdout, expected);- else expect(missing.stdout).toBe("");- });-test.skipIf(process.platform === "win32")(- "returns the existing failure status for scope link cycles",+ "resolves parent components after directory symlinks",() => {- const { root } = fixture();- symlinkSync("second", join(root, "first"), "dir");- symlinkSync("first", join(root, "second"), "dir");- const result = resolve(root, "first");- expect(result.status).toBe(1);- expect(result.stdout).toBe("");- expect(result.stderr).toContain("Symlink loop");+ const { root, output } = fixture();+ write(root, "nested/SECURITY.md", "nested policy\n");+ mkdirSync(join(root, "nested", "child"));+ symlinkSync("nested/child", join(root, "alias"), "dir");+ const result = resolve(root, "alias/..");+ expect(result.status, result.stderr).toBe(0);+ expectGuidance(result.stdout, [["nested/SECURITY.md", "nested policy"]]);++ write(output, "SECURITY.md", "outside policy\n");+ mkdirSync(join(output, "child"));+ symlinkSync(join(output, "child"), join(root, "outside"), "dir");+ const outside = resolve(root, "outside/..");+ expect(outside.status).not.toBe(0);+ expect(outside.stdout).toBe("");+ expect(outside.stderr).toContain("outside the scan root");},);+ test.skipIf(process.platform === "win32")("rejects scope link cycles", () => {+ const { root } = fixture();+ symlinkSync("second", join(root, "first"), "dir");+ symlinkSync("first", join(root, "second"), "dir");+ const result = resolve(root, "first");+ expect(result.status).not.toBe(0);+ expect(result.stdout).toBe("");+ expect(result.stderr).toContain("scan scope does not exist");+ });+test("creates output directories and writes empty guidance when no policy exists", () => {const { root, output } = fixture();const destination = join(output, "artifacts", "guidance.md");@@ -901,27 +847,15 @@ describe("built SECURITY.md helper", () => {test("preserves required and mutually exclusive helper arguments", () => {const { root } = fixture();- for (const [args, status] of [- [["--help", "--bogus"], 0],- [["-h", "--scope"], 0],- [["--hel", "--scope"], 0],- [["-hh", "--bogus"], 0],- [["--bogus", "--help"], 0],- [["positional", "--help"], 0],- [["-hfoo"], 0],- [["-hfoo-"], 0],- [["--scope", "--help"], 2],- [["--list=value", "--help"], 2],- [["-h=foo"], 2],- [["-h-"], 2],- [["-hh-"], 2],- [["-h--help"], 2],- [["--"], 2],- [["--", "--help"], 2],- ] as const) {- const result = run(["--repo", root, "--scope", ".", ...args]);- expect(result.status, result.stderr).toBe(status);- expect(result.stdout.includes("Usage:")).toBe(status === 0);+ for (const flag of ["--help", "-h"]) {+ const result = run([flag]);+ expect(result.status, result.stderr).toBe(0);+ expect(result.stdout).toContain("Usage:");+ }+ for (const args of [["--unknown"], ["--scope"], ["positional"]]) {+ const result = run(["--repo", root, ...args]);+ expect(result.status, result.stderr).toBe(2);+ expect(result.stdout).toBe("");}for (const [args, message] of [[["--list"], "--repo is required"],