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(severity)!: move severity persistence to Node (#1543)
mldangelo-oaibf9a5bce9d27
diff --git a/plugins/codex-security/mcp-app/helpers-main.ts b/plugins/codex-security/mcp-app/helpers-main.tsindex d1a508371..1a361e6c9 100644--- a/plugins/codex-security/mcp-app/helpers-main.ts+++ b/plugins/codex-security/mcp-app/helpers-main.ts@@ -53,6 +53,10 @@ const workbenchUsage: Record<string, string> = {"Usage: store-dedupe-groups\nReads a JSON object from stdin with an absolute stateDirectory and payload.groups containing arrays of finding IDs.","list-dedupe-groups":"Usage: list-dedupe-groups\nReads a JSON object from stdin with an absolute stateDirectory and payload.findingId.",+ "severity-classification":+ "Usage: severity-classification\nReads a JSON object from stdin with an absolute stateDirectory and payload describing the begin or save action.",+ "read-severity-classification":+ "Usage: read-severity-classification --scan-id <id>\nReads a JSON object from stdin with an absolute stateDirectory. Reads saved assessments without updating the database.",};if (!isMainThread) {parentPort!.postMessage(normalizeCandidateBatch(workerData));@@ -85,7 +89,12 @@ if (!isMainThread) {void (async () => {const { values } = parseArgs({args,- options: { help: { type: "boolean", short: "h" } },+ options: {+ help: { type: "boolean", short: "h" },+ ...(command === "read-severity-classification"+ ? { "scan-id": { type: "string" as const } }+ : {}),+ },});if (values.help) {console.log(workbenchUsage[command]);@@ -96,8 +105,12 @@ if (!isMainThread) {const { databaseInfo } = await import("./src/workbench/database");result = await databaseInfo(JSON.parse(decodeUtf8(readFileSync(0))));} else {- const { findingsCommand } = await import("./src/workbench/commands");- result = await findingsCommand(command, decodeUtf8(readFileSync(0)));+ const { workbenchCommand } = await import("./src/workbench/commands");+ result = await workbenchCommand(+ command,+ decodeUtf8(readFileSync(0)),+ values["scan-id"] as string | undefined,+ );}console.log(stringifyJson(result, 0).replace(/[\p{Cc}\p{Cf}]/gu, (character) =>diff --git a/plugins/codex-security/mcp-app/src/workbench/commands.ts b/plugins/codex-security/mcp-app/src/workbench/commands.tsindex e74c72836..67d5bf25b 100644--- a/plugins/codex-security/mcp-app/src/workbench/commands.ts+++ b/plugins/codex-security/mcp-app/src/workbench/commands.ts@@ -11,15 +11,31 @@ import {storeDedupeGroups,} from "./duplicates";-export async function findingsCommand(+import {+ readSeverityClassification,+ severityCheckpoint,+ type SeverityCheckpoint,+} from "./severity";++export async function workbenchCommand(command: string,input: string,+ scanId?: string,): Promise<unknown> {const request = parseJson(input) as {stateDirectory: string;payload: unknown;};const { stateDirectory, payload } = request;+ if (command === "read-severity-classification") {+ const selectedScanId = scanId ?? (payload as { scanId?: unknown })?.scanId;+ if (typeof selectedScanId !== "string")+ throw new Error("read-severity-classification requires --scan-id.");+ return readSeverityClassification(+ workbenchDatabasePath(stateDirectory),+ selectedScanId,+ );+ }const page = payload as { limit: number; offset: number };if (command === "list-stored-findings" &&@@ -59,10 +75,18 @@ export async function findingsCommand(workbenchDatabasePath(stateDirectory),{deferred:- command !== "store-findings" && command !== "store-dedupe-groups",+ command !== "store-findings" &&+ command !== "store-dedupe-groups" &&+ command !== "severity-classification",},);try {+ if (command === "severity-classification")+ return severityCheckpoint(+ database,+ payload as SeverityCheckpoint,+ new Date().toISOString(),+ );if (command === "store-findings") {const { entries, repositoryId } = payload as {entries: EmbeddedFinding[];diff --git a/plugins/codex-security/mcp-app/src/workbench/severity.ts b/plugins/codex-security/mcp-app/src/workbench/severity.tsnew file mode 100644index 000000000..d3f53e4f8--- /dev/null+++ b/plugins/codex-security/mcp-app/src/workbench/severity.ts@@ -0,0 +1,224 @@+import { DatabaseSync } from "node:sqlite";+import { parseJson, stringifyJson } from "../helpers/json";+import { requireSqliteText } from "./database";+import type { Finding } from "./findings";+import { transaction } from "./transaction";++const fields = {+ findingId: "finding_id",+ occurrenceId: "occurrence_id",+ inputSha256: "input_sha256",+ rubricSha256: "rubric_sha256",+ knowledgeBaseSha256: "knowledge_base_sha256",+ assessedAt: "assessed_at",+ source: "source",+ decision: "decision",+ level: "level",+ rubricLabel: "rubric_label",+ rationale: "rationale",+ confidence: "confidence",+ reviewTrigger: "review_trigger",+} as const;++type Assessment = Record<keyof typeof fields, string | null>;++export type SeverityCheckpoint =+ | {+ action: "begin";+ scanId: string;+ findingIds: string[];+ assessedAt: string;+ rubricSha256: string | null;+ knowledgeBaseSha256: string | null;+ }+ | {+ action: "save";+ scanId: string;+ finding: Finding;+ assessment: Assessment;+ };++export function assessments(+ database: DatabaseSync,+ findingIds: string[],+ scanId?: string,+): Assessment[] {+ requireSqliteText([...findingIds, scanId]);+ const table =+ scanId === undefined+ ? "finding_severity_assessments"+ : "scan_severity_assessments";+ const scope = scanId === undefined ? "" : "WHERE assessment.scan_id = ?";+ // JSON preserves embedded NULs across Node 22 SQLite TEXT results.+ const projection = Object.entries(fields)+ .map(([key, column]) => `'${key}', assessment.${column}`)+ .join(", ");+ // Keep selected IDs first so each assessment is a primary-key lookup.+ const rows = database+ .prepare(+ `SELECT json_object(${projection}) AS value FROM json_each(?) AS selected+ CROSS JOIN ${table} AS assessment ON assessment.finding_id = selected.value+ ${scope} ORDER BY selected.key`,+ )+ .all(+ stringifyJson(findingIds, 0),+ ...(scanId === undefined ? [] : [scanId]),+ );+ return rows.map((row) => parseJson(String(row.value)) as Assessment);+}++export function severityCheckpoint(+ database: DatabaseSync,+ payload: SeverityCheckpoint,+ timestamp: string,+): { assessments?: Assessment[] } {+ requireSqliteText([payload.scanId, timestamp]);+ return transaction(database, "BEGIN IMMEDIATE", () => {+ if (payload.action === "begin") {+ requireSqliteText([+ ...payload.findingIds,+ payload.assessedAt,+ payload.rubricSha256,+ payload.knowledgeBaseSha256,+ ]);+ database+ .prepare(+ `INSERT INTO scan_severity_classifications (+ scan_id, finding_ids_json, assessed_at, rubric_sha256, knowledge_base_sha256+ ) VALUES (?, ?, ?, ?, ?)+ ON CONFLICT(scan_id) DO UPDATE SET+ finding_ids_json = excluded.finding_ids_json,+ assessed_at = excluded.assessed_at,+ rubric_sha256 = excluded.rubric_sha256,+ knowledge_base_sha256 = excluded.knowledge_base_sha256`,+ )+ .run(+ payload.scanId,+ stringifyJson(payload.findingIds, 0),+ payload.assessedAt,+ payload.rubricSha256,+ payload.knowledgeBaseSha256,+ );+ // Cache hits are not saved again by the classifier. Keep each scan's own assessments.+ database+ .prepare(+ `INSERT INTO scan_severity_assessments+ SELECT ?, assessment.* FROM json_each(?) AS selected+ JOIN finding_severity_assessments AS assessment+ ON assessment.finding_id = selected.value+ WHERE true+ ON CONFLICT(scan_id, finding_id) DO NOTHING`,+ )+ .run(payload.scanId, stringifyJson(payload.findingIds, 0));+ return {+ assessments: assessments(database, payload.findingIds, payload.scanId),+ };+ }+ if (payload.action !== "save")+ throw new Error("Unknown severity checkpoint action.");+ const { finding } = payload;+ const assessment = { ...payload.assessment, assessedAt: timestamp };+ const values = Object.fromEntries(+ Object.entries(fields).map(([key, column]) => [+ column,+ assessment[key as keyof Assessment],+ ]),+ );+ requireSqliteText([finding.findingId, ...Object.values(values)]);+ // External scan directories may not have been indexed on this machine.+ if (+ !database+ .prepare("SELECT 1 FROM findings WHERE id = ?")+ .get(finding.findingId)+ ) {+ requireSqliteText([+ finding.fingerprints.primary,+ finding.ruleId,+ finding.identity.anchor,+ finding.identity.instance,+ ]);+ database+ .prepare(+ `INSERT INTO findings (id, fingerprint, rule_id, identity_anchor, identity_instance,+ details_json, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,+ )+ .run(+ finding.findingId,+ finding.fingerprints.primary,+ finding.ruleId,+ finding.identity.anchor,+ finding.identity.instance ?? null,+ stringifyJson(finding, 0),+ timestamp,+ timestamp,+ );+ }+ for (const [table, key, row] of [+ ["finding_severity_assessments", "finding_id", values],+ [+ "scan_severity_assessments",+ "scan_id, finding_id",+ { scan_id: payload.scanId, ...values },+ ],+ ] as const) {+ const columns = Object.keys(row);+ database+ .prepare(+ `INSERT INTO ${table} (${columns.join(", ")})+ VALUES (${columns.map(() => "?").join(", ")})+ ON CONFLICT(${key}) DO UPDATE SET ${columns.map((column) => `${column} = excluded.${column}`).join(", ")}`,+ )+ .run(...Object.values(row));+ }+ return {};+ });+}++export function readSeverityClassification(+ databasePath: string,+ scanId: string,+): unknown {+ requireSqliteText([scanId]);+ const database = new DatabaseSync(databasePath, { readOnly: true });+ try {+ database.exec("PRAGMA busy_timeout = 5000");+ return transaction(database, "BEGIN", () => {+ if (+ !database+ .prepare(+ "SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'scan_severity_classifications'",+ )+ .get()+ )+ return {};+ const row = database+ .prepare(+ `SELECT json_object(+ 'findingIds', json(finding_ids_json), 'assessedAt', assessed_at,+ 'rubricSha256', rubric_sha256, 'knowledgeBaseSha256', knowledge_base_sha256+ ) AS value FROM scan_severity_classifications WHERE scan_id = ?`,+ )+ .get(scanId);+ if (!row) return {};+ const classification = parseJson(String(row.value)) as {+ findingIds: string[];+ };+ const hasScanAssessments = database+ .prepare(+ "SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'scan_severity_assessments'",+ )+ .get();+ return {+ scanId,+ ...classification,+ assessments: assessments(+ database,+ classification.findingIds,+ hasScanAssessments ? scanId : undefined,+ ),+ };+ });+ } finally {+ database.close();+ }+}diff --git a/plugins/codex-security/mcp-app/tests/test_workbench_findings.ts b/plugins/codex-security/mcp-app/tests/test_workbench_findings.tsindex 66cc381b9..5162450cc 100644--- a/plugins/codex-security/mcp-app/tests/test_workbench_findings.ts+++ b/plugins/codex-security/mcp-app/tests/test_workbench_findings.ts@@ -127,6 +127,8 @@ test("finding helper help exits without reading stdin", async () => {"find-potential-duplicates","store-dedupe-groups","list-dedupe-groups",+ "severity-classification",+ "read-severity-classification",];for (const command of commands) {// execFile leaves stdin open; help must exit without waiting for JSON.diff --git a/plugins/codex-security/mcp-app/tests/test_workbench_severity.ts b/plugins/codex-security/mcp-app/tests/test_workbench_severity.tsnew file mode 100644index 000000000..e1ee0cb36--- /dev/null+++ b/plugins/codex-security/mcp-app/tests/test_workbench_severity.ts@@ -0,0 +1,235 @@+import assert from "node:assert/strict";+import { readFile, stat } from "node:fs/promises";+import { join } from "node:path";+import { DatabaseSync } from "node:sqlite";+import { after, test, type TestContext } from "node:test";+import { importSource } from "./import-module.ts";+import { createTemporaryDirectories } from "./support/temporary-directories.ts";+import type * as Severity from "../src/workbench/severity.ts";+import type * as Migrations from "../src/workbench/migrations.ts";++const { assessments, severityCheckpoint, readSeverityClassification } =+ (await importSource("src/workbench/severity.ts")) as typeof Severity;+const { applyMigrations, migrations } = (await importSource(+ "src/workbench/migrations.ts",+)) as typeof Migrations;+const temporary = createTemporaryDirectories(true);+after(() => temporary.cleanup());++function open(t: TestContext, path = ":memory:", version?: number) {+ const database = new DatabaseSync(path);+ t.after(() => database.close());+ applyMigrations(+ database,+ migrations.filter(+ (item) => version === undefined || item.version <= version,+ ),+ );+ return database;+}++function save(+ findingId: string,+ scanId = "scan",+): Extract<Severity.SeverityCheckpoint, { action: "save" }> {+ return {+ action: "save",+ scanId,+ finding: {+ findingId,+ fingerprints: { primary: `fingerprint-${findingId}` },+ ruleId: "synthetic-rule",+ identity: { anchor: "synthetic-anchor" },+ evidence: { count: 18446744073709551617n },+ },+ assessment: {+ findingId,+ occurrenceId: `occurrence-${findingId}`,+ inputSha256: "evidence-digest",+ rubricSha256: null,+ knowledgeBaseSha256: null,+ assessedAt: "unused",+ source: "existing-severity",+ decision: "assessed",+ level: "high",+ rubricLabel: null,+ rationale: "Complete\0diagnostic λ",+ confidence: null,+ reviewTrigger: null,+ },+ };+}++function begin(+ scanId: string,+ findingIds: string[],+): Severity.SeverityCheckpoint {+ return {+ action: "begin",+ scanId,+ findingIds,+ assessedAt: "started",+ rubricSha256: null,+ knowledgeBaseSha256: null,+ };+}++test("severity checkpoints retain external findings and each scan's cached assessments", (t) => {+ const database = open(t);+ const payload = save("finding\0suffix", "scan-a");+ for (const field of [+ "occurrenceId",+ "inputSha256",+ "rubricSha256",+ "knowledgeBaseSha256",+ "rubricLabel",+ "reviewTrigger",+ ] as const)+ payload.assessment[field] = `${field}\0suffix λ`;+ assert.deepEqual(+ severityCheckpoint(+ database,+ begin("scan-a", [payload.finding.findingId]),+ "started",+ ),+ { assessments: [] },+ );+ severityCheckpoint(database, payload, "first\0timestamp");+ const details = database+ .prepare("SELECT details_json FROM findings WHERE id = ?")+ .get(payload.finding.findingId)!.details_json;+ assert.match(String(details), /18446744073709551617/);+ const first = { ...payload.assessment, assessedAt: "first\0timestamp" };+ assert.deepEqual(+ severityCheckpoint(+ database,+ begin("scan-b", [payload.finding.findingId]),+ "started",+ ),+ { assessments: [first] },+ );+ payload.scanId = "scan-b";+ payload.finding.identity.anchor = "must-not-replace-existing-finding";+ payload.assessment.level = "low";+ severityCheckpoint(database, payload, "second");+ assert.deepEqual(+ severityCheckpoint(+ database,+ begin("scan-a", [payload.finding.findingId]),+ "restarted",+ ),+ { assessments: [first] },+ );+ assert.deepEqual(assessments(database, [payload.finding.findingId]), [+ { ...payload.assessment, assessedAt: "second" },+ ]);+ assert.equal(+ database+ .prepare("SELECT details_json FROM findings WHERE id = ?")+ .get(payload.finding.findingId)!.details_json,+ details,+ );+});++test("failed assessment writes roll back external finding insertion and preserve the cache", (t) => {+ const database = open(t);+ severityCheckpoint(database, begin("scan", ["saved", "new"]), "started");+ severityCheckpoint(database, save("saved"), "first");+ const invalid = save("new");+ invalid.assessment.findingId = "missing";+ assert.throws(+ () => severityCheckpoint(database, invalid, "second"),+ /FOREIGN KEY/,+ );+ assert.equal(+ database.prepare("SELECT 1 FROM findings WHERE id = 'new'").get(),+ undefined,+ );+ assert.equal(assessments(database, ["saved"])[0].assessedAt, "first");+ invalid.finding.findingId = "saved\ud800";+ assert.throws(+ () => severityCheckpoint(database, invalid, "third"),+ /valid Unicode/,+ );+ assert.equal(+ database.prepare("SELECT COUNT(*) AS count FROM findings").get()!.count,+ 1,+ );+});++test("severity reads retain requested order and scan scope in a larger assessment cache", (t) => {+ const database = open(t);+ const ids = Array.from({ length: 250 }, (_, index) => `finding-${index}`);+ for (const scanId of ["scan-a", "scan-b"])+ severityCheckpoint(database, begin(scanId, ids), "started");+ for (let index = 0; index < 250; index++) {+ const id = `finding-${index}`;+ severityCheckpoint(database, save(id, "scan-a"), "first");+ const other = save(id, "scan-b");+ other.assessment.level = "medium";+ severityCheckpoint(database, other, "second");+ }+ const selected = ["finding-249", "finding-17", "finding-0"];+ assert.deepEqual(+ assessments(database, selected, "scan-a").map(({ findingId, level }) => ({+ findingId,+ level,+ })),+ selected.map((findingId) => ({ findingId, level: "high" })),+ );+ assert.deepEqual(+ assessments(database, selected, "scan-b").map(({ findingId, level }) => ({+ findingId,+ level,+ })),+ selected.map((findingId) => ({ findingId, level: "medium" })),+ );+});++test("old database reads use legacy assessments without migrating or changing the file", async (t) => {+ const directory = await temporary.create("severity-legacy-");+ const path = join(directory, "workbench.sqlite3");+ const database = open(t, path, 42);+ database.exec(`INSERT INTO scan_severity_classifications (scan_id, finding_ids_json, assessed_at)+ VALUES ('scan', '["finding"]', 'started');+ INSERT INTO findings (id, fingerprint, rule_id, identity_anchor, created_at, updated_at)+ VALUES ('finding', 'fingerprint', 'rule', 'anchor', 'created', 'updated');+ INSERT INTO finding_severity_assessments+ (finding_id, occurrence_id, input_sha256, assessed_at, source, decision, level, rationale)+ VALUES ('finding', 'occurrence', 'digest', 'assessed', 'existing-severity', 'assessed', 'high', 'Saved');`);+ database+ .prepare(+ "UPDATE scan_severity_classifications SET assessed_at = ?, rubric_sha256 = ?, knowledge_base_sha256 = ? WHERE scan_id = 'scan'",+ )+ .run("started\0suffix", "rubric\0suffix", "knowledge\0suffix");+ const before = await readFile(path);+ const metadata = await stat(path);+ const schema = database+ .prepare("SELECT name, sql FROM sqlite_master ORDER BY name")+ .all();+ const result = readSeverityClassification(path, "scan") as {+ assessments: { findingId: string }[];+ assessedAt: string;+ rubricSha256: string;+ knowledgeBaseSha256: string;+ };+ assert.equal(result.assessedAt, "started\0suffix");+ assert.equal(result.rubricSha256, "rubric\0suffix");+ assert.equal(result.knowledgeBaseSha256, "knowledge\0suffix");+ assert.deepEqual(+ result.assessments.map((row) => row.findingId),+ ["finding"],+ );+ assert.deepEqual(readSeverityClassification(path, "missing"), {});+ assert.deepEqual(await readFile(path), before);+ assert.equal((await stat(path)).mode, metadata.mode);+ assert.deepEqual(+ database.prepare("SELECT name, sql FROM sqlite_master ORDER BY name").all(),+ schema,+ );+ database.exec("DROP TABLE scan_severity_classifications");+ assert.deepEqual(readSeverityClassification(path, "scan"), {});+ const missing = join(directory, "missing.sqlite3");+ assert.throws(() => readSeverityClassification(missing, "scan"));+ await assert.rejects(stat(missing), { code: "ENOENT" });+});diff --git a/plugins/codex-security/plugin-files.json b/plugins/codex-security/plugin-files.jsonindex b7b6ac3b5..3cc0afd8e 100644--- a/plugins/codex-security/plugin-files.json+++ b/plugins/codex-security/plugin-files.json@@ -98,7 +98,6 @@"scripts/workbench_scan_start.py","scripts/workbench_scan_usage.py","scripts/workbench_schema.py",- "scripts/workbench_severity.py","scripts/workbench_source_excerpt.py","scripts/workbench_target.py","scripts/workbench_target_state.py",diff --git a/plugins/codex-security/scripts/workbench_cli.py b/plugins/codex-security/scripts/workbench_cli.pyindex 55f431a28..c3928f886 100644--- a/plugins/codex-security/scripts/workbench_cli.py+++ b/plugins/codex-security/scripts/workbench_cli.py@@ -309,8 +309,6 @@ def parse_args(description: str) -> argparse.Namespace:subparsers.add_parser("database-info")subparsers.add_parser("finding-workflow")subparsers.add_parser("local-dedupe")- subparsers.add_parser("severity-classification")- add_command("read-severity-classification", "--scan-id")arguments = sys.argv[1:]if "--user-context-stdin" in arguments:if arguments.count("--user-context-stdin") != 1 or "--user-context" in arguments:diff --git a/plugins/codex-security/scripts/workbench_db.py b/plugins/codex-security/scripts/workbench_db.pyindex 88791d5a6..ad5c585fa 100644--- a/plugins/codex-security/scripts/workbench_db.py+++ b/plugins/codex-security/scripts/workbench_db.py@@ -43,7 +43,6 @@ import workbench_remediation as remediation_stateimport workbench_saved_results as saved_resultsimport workbench_scan_history as scan_historyimport workbench_scan_usage as scan_usage-import workbench_severity as severityfrom finalize_scan_contract import (PRODUCER_NAME,ContractError,@@ -3339,10 +3338,6 @@ def main(*, before_archive: Callable[[], None] | None = None) -> None:if args.command in {"save-artifact", "read-artifact"}:print(json.dumps(saved_results.read_or_save_artifact(args)))return- if args.command == "read-severity-classification":- result = severity.read_classification(database_path(), args.scan_id)- print(json.dumps(result, allow_nan=False, sort_keys=True))- returnif args.command == "inspect-linear-publication":result = publication.inspect_linear_publication(_WORKBENCH_PUBLICATION_CONTEXT, read_json_object(Path(args.input_file))@@ -3483,8 +3478,6 @@ def main(*, before_archive: Callable[[], None] | None = None) -> None:)elif args.command == "database-info":result = {"databasePath": str(database_path())}- elif args.command == "severity-classification":- result = severity.checkpoint(connection, json.load(sys.stdin), now())elif args.command == "local-dedupe":result = local_dedupe(connection, json.load(sys.stdin), now())elif args.command == "finding-workflow":diff --git a/plugins/codex-security/scripts/workbench_severity.py b/plugins/codex-security/scripts/workbench_severity.pydeleted file mode 100644index 0363c2b59..000000000--- a/plugins/codex-security/scripts/workbench_severity.py+++ /dev/null@@ -1,158 +0,0 @@-"""Reusable severity checkpoints and the assessments saved for each scan."""--import argparse-import json-import sqlite3-import sys-from contextlib import closing-from pathlib import Path-from typing import Any-from urllib.parse import quote--# Some plugin hosts launch Python with safe-path isolation enabled.-sys.path.insert(0, str(Path(__file__).resolve().parent))-from workbench_finding_index import upsert_finding--FIELDS = {- "findingId": "finding_id",- "occurrenceId": "occurrence_id",- "inputSha256": "input_sha256",- "rubricSha256": "rubric_sha256",- "knowledgeBaseSha256": "knowledge_base_sha256",- "assessedAt": "assessed_at",- "source": "source",- "decision": "decision",- "level": "level",- "rubricLabel": "rubric_label",- "rationale": "rationale",- "confidence": "confidence",- "reviewTrigger": "review_trigger",-}---def assessments(- connection: sqlite3.Connection, finding_ids: list[str], scan_id: str | None = None-) -> list[dict[str, Any]]:- table = "finding_severity_assessments" if scan_id is None else "scan_severity_assessments"- scope = "" if scan_id is None else "WHERE assessment.scan_id = ?"- parameters = (- (json.dumps(finding_ids),) if scan_id is None else (json.dumps(finding_ids), scan_id)- )- # Keep selected IDs first so each assessment is a primary-key lookup.- rows = connection.execute(- f"""SELECT assessment.* FROM json_each(?) AS selected- CROSS JOIN {table} AS assessment ON assessment.finding_id = selected.value- {scope} ORDER BY selected.key""",- parameters,- )- return [{key: row[column] for key, column in FIELDS.items()} for row in rows]---def checkpoint(- connection: sqlite3.Connection, payload: dict[str, Any], timestamp: str-) -> dict[str, Any]:- if payload["action"] == "begin":- with connection:- connection.execute(- """INSERT INTO scan_severity_classifications (- scan_id, finding_ids_json, assessed_at, rubric_sha256, knowledge_base_sha256- ) VALUES (?, ?, ?, ?, ?)- ON CONFLICT(scan_id) DO UPDATE SET- finding_ids_json = excluded.finding_ids_json,- assessed_at = excluded.assessed_at,- rubric_sha256 = excluded.rubric_sha256,- knowledge_base_sha256 = excluded.knowledge_base_sha256""",- (- payload["scanId"],- json.dumps(payload["findingIds"]),- payload["assessedAt"],- payload["rubricSha256"],- payload["knowledgeBaseSha256"],- ),- )- # Cache hits are not saved again by the classifier. Copy them once,- # without replacing assessments this scan already owns.- connection.execute(- """INSERT INTO scan_severity_assessments- SELECT ?, assessment.* FROM json_each(?) AS selected- JOIN finding_severity_assessments AS assessment- ON assessment.finding_id = selected.value- WHERE true- ON CONFLICT(scan_id, finding_id) DO NOTHING""",- (payload["scanId"], json.dumps(payload["findingIds"])),- )- return {- "assessments": assessments(connection, payload["findingIds"], payload["scanId"])- }- if payload["action"] != "save":- raise SystemExit("Unknown severity checkpoint action.")- finding = payload["finding"]- assessment = {**payload["assessment"], "assessedAt": timestamp}- with connection:- # External scan directories may not have been indexed on this machine.- if (- connection.execute(- "SELECT 1 FROM findings WHERE id = ?", (finding["findingId"],)- ).fetchone()- is None- ):- upsert_finding(connection, finding, timestamp)- values = {column: assessment[key] for key, column in FIELDS.items()}- for table, key, row in (- ("finding_severity_assessments", "finding_id", values),- (- "scan_severity_assessments",- "scan_id, finding_id",- {"scan_id": payload["scanId"], **values},- ),- ):- columns = ", ".join(row)- parameters = ", ".join("?" for _ in row)- updates = ", ".join(f"{column} = excluded.{column}" for column in row)- connection.execute(- f"""INSERT INTO {table} ({columns}) VALUES ({parameters})- ON CONFLICT({key}) DO UPDATE SET {updates}""",- tuple(row.values()),- )- return {}---def read_classification(database: Path, scan_id: str) -> dict[str, Any]:- uri = f"file:{quote(str(database), safe='')}?mode=ro"- with closing(sqlite3.connect(uri, uri=True, timeout=5)) as connection:- connection.row_factory = sqlite3.Row- connection.execute("BEGIN")- if (- connection.execute(- "SELECT 1 FROM sqlite_master WHERE type = 'table' "- "AND name = 'scan_severity_classifications'"- ).fetchone()- is None- ):- return {}- row = connection.execute(- "SELECT * FROM scan_severity_classifications WHERE scan_id = ?", (scan_id,)- ).fetchone()- if row is None:- return {}- finding_ids = json.loads(row["finding_ids_json"])- has_scan_assessments = (- connection.execute(- "SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'scan_severity_assessments'"- ).fetchone()- is not None- )- return {- "scanId": scan_id,- "findingIds": finding_ids,- "assessedAt": row["assessed_at"],- "rubricSha256": row["rubric_sha256"],- "knowledgeBaseSha256": row["knowledge_base_sha256"],- "assessments": assessments(- connection, finding_ids, scan_id if has_scan_assessments else None- ),- }---if __name__ == "__main__":- argparse.ArgumentParser(description=__doc__).parse_args()diff --git a/plugins/codex-security/tests/test_cli_dry_runs.py b/plugins/codex-security/tests/test_cli_dry_runs.pyindex 3ff83f635..3c1c451d6 100644--- a/plugins/codex-security/tests/test_cli_dry_runs.py+++ b/plugins/codex-security/tests/test_cli_dry_runs.py@@ -31,7 +31,6 @@ def test_all_scripts_support_help() -> None:"name",("workbench_publication.py",- "workbench_severity.py","finalize_scan_contract.py","validate_scan_contract.py","validate_tracking_source.py",diff --git a/plugins/codex-security/tests/test_workbench_setup_and_migrations.py b/plugins/codex-security/tests/test_workbench_setup_and_migrations.pyindex 37e926584..9131f16e9 100644--- a/plugins/codex-security/tests/test_workbench_setup_and_migrations.py+++ b/plugins/codex-security/tests/test_workbench_setup_and_migrations.py@@ -849,9 +849,7 @@ def test_severity_migration_only_copies_assessments_with_matching_scan_occurrencassert connection.execute("PRAGMA foreign_key_check").fetchall() == [][email protected]("operation", ["migration", "read"])-def test_severity_work_scales_with_selected_findings(operation: str) -> None:- severity = load_script("workbench_severity")+def test_severity_migration_scales_with_classified_scans() -> None:timestamp = "2026-09-01T00:00:00Z"def instruction_count(scale: int) -> int:@@ -862,9 +860,7 @@ def test_severity_work_scales_with_selected_findings(operation: str) -> None:"INSERT INTO workspaces (id, created_at, updated_at) VALUES ('workspace', ?, ?)",(timestamp, timestamp),)- scan_count, findings_per_scan = (- (scale, 10) if operation == "migration" else (1, scale * 10)- )+ scan_count, findings_per_scan = scale, 10for scan in range(scan_count):scan_id = f"scan-{scan}"finding_ids = [f"finding-{scan}-{item}" for item in range(findings_per_scan)]@@ -905,9 +901,6 @@ def test_severity_work_scales_with_selected_findings(operation: str) -> None:(finding_id, occurrence_id, timestamp),)connection.commit()- if operation == "read":- apply_migrations(connection)-instructions = 0def progress() -> int:@@ -917,12 +910,7 @@ def test_severity_work_scales_with_selected_findings(operation: str) -> None:connection.set_progress_handler(progress, 100)try:- if operation == "migration":- apply_migrations(connection)- else:- selected = list(reversed(finding_ids))- result = severity.assessments(connection, selected, scan_id)- assert [assessment["findingId"] for assessment in result] == selected+ apply_migrations(connection)finally:connection.set_progress_handler(None, 0)assert (diff --git a/sdk/typescript/src/runtime.ts b/sdk/typescript/src/runtime.tsindex 761f9233c..8c4395c0a 100644--- a/sdk/typescript/src/runtime.ts+++ b/sdk/typescript/src/runtime.ts@@ -1631,6 +1631,8 @@ export async function runWorkbench("store-dedupe-groups","list-dedupe-groups","dashboard",+ "severity-classification",+ "read-severity-classification",].includes(arguments_[0] ?? "");const node =native && process.versions["bun"]diff --git a/sdk/typescript/src/severity-store.ts b/sdk/typescript/src/severity-store.tsindex cee256ef2..fcc05df09 100644--- a/sdk/typescript/src/severity-store.ts+++ b/sdk/typescript/src/severity-store.ts@@ -7,20 +7,21 @@ import {type SeverityClassificationCheckpoint,} from "./classify-severity.js";import type { JsonObject } from "./config.js";+import { gitProtectionRoots } from "./targets.js";import { CodexSecurityError } from "./errors.js";import {canonicalizeModelSafePath,+ bundledPluginRoot,codexSecurityStateDirectory,workbenchEnvironment,requireOutputOutsideRepository,- resolveWorkbenchRuntime,runWorkbench,type WorkbenchCommandOptions,} from "./runtime.js";/** @internal */export class SeverityStore {- private options?: Promise<WorkbenchCommandOptions>;+ private options?: Promise<Omit<WorkbenchCommandOptions, "python">>;constructor(private readonly environment: NodeJS.ProcessEnv,@@ -35,7 +36,7 @@ export class SeverityStore {): SeverityClassificationCheckpoint {return {load: async (result) => {- const response = await this.run(["severity-classification"], {+ const response = await this.run("severity-classification", {action: "begin",scanId,findingIds,@@ -51,7 +52,7 @@ export class SeverityStore {);},save: async (finding, assessment, result) => {- await this.run(["severity-classification"], {+ await this.run("severity-classification", {action: "save",scanId,finding,@@ -77,11 +78,7 @@ export class SeverityStore {if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;throw error;}- const saved = await this.run([- "read-severity-classification",- "--scan-id",- scanId,- ]);+ const saved = await this.run("read-severity-classification", { scanId });if (saved["scanId"] === undefined) return undefined;const result: SeverityClassification = {schemaVersion: 1,@@ -103,30 +100,31 @@ export class SeverityStore {return result;}- private async run(args: string[], input?: object) {+ private async run(command: string, input: object) {return runWorkbench(await (this.options ??= this.resolveOptions()),- args,- input === undefined ? undefined : JSON.stringify(input),+ [command],+ JSON.stringify(input),);}- private async resolveOptions(): Promise<WorkbenchCommandOptions> {+ private async resolveOptions(): Promise<+ Omit<WorkbenchCommandOptions, "python">+ > {const environment = workbenchEnvironment(this.environment);requireOutputOutsideRepository(this.scanDirectory,await canonicalizeModelSafePath(environment.CODEX_SECURITY_STATE_DIR),"runtime",);- const [python, pluginRoot] = await resolveWorkbenchRuntime({- environment,- protectedRoot: this.scanDirectory,- signal: this.signal,- });return {- python,- pluginRoot,+ pluginRoot: await bundledPluginRoot(),environment,+ protectedRoot: [+ this.scanDirectory,+ ...(await gitProtectionRoots(process.cwd(), this.signal)),+ ...(await gitProtectionRoots(this.scanDirectory, this.signal)),+ ],signal: this.signal,failureMessage: "Could not access severity assessments",};diff --git a/sdk/typescript/tests-ts/classify-scan-severity.test.ts b/sdk/typescript/tests-ts/classify-scan-severity.test.tsindex 9af4ba3ad..745047201 100644--- a/sdk/typescript/tests-ts/classify-scan-severity.test.ts+++ b/sdk/typescript/tests-ts/classify-scan-severity.test.ts@@ -1,8 +1,15 @@import { codexWithRun, jsonCodex } from "./support/codex.js";import { setFindingIdentity, sha256 } from "./support/finding-identity.js";import { spawnSync } from "node:child_process";-import { chmod, readFile, rm, symlink, writeFile } from "node:fs/promises";-import { join } from "node:path";+import {+ chmod,+ mkdir,+ readFile,+ rm,+ symlink,+ writeFile,+} from "node:fs/promises";+import { delimiter, dirname, join } from "node:path";import { afterEach, expect, test } from "bun:test";import {classifyScanDirectorySeverity,@@ -18,7 +25,6 @@ import type { JsonObject } from "../src/config.js";import type { Finding, FindingsDocument, ScanManifest } from "../src/models.js";import { prepareScanPublication } from "../src/publication.js";import { publishScanInternal } from "../src/publish.js";-import { resolvePluginPython } from "../src/runtime.js";import { copyCompletedScanFixture, PLUGIN_ROOT } from "./plugin-root.js";import { createApiTestFixtures } from "./support/temporary-directories.js";@@ -103,10 +109,14 @@ function classifier(async function query(environment: NodeJS.ProcessEnv, sql: string) {const result = spawnSync(- await resolvePluginPython({ environment }),+ Bun.which("node")!,[- "-c",- "import json,sqlite3,sys; c=sqlite3.connect(sys.argv[1]); c.row_factory=sqlite3.Row; print(json.dumps([dict(r) for r in c.execute(sys.argv[2]) ])); c.commit()",+ "--input-type=module",+ "--eval",+ `import { DatabaseSync } from "node:sqlite";+const database = new DatabaseSync(process.argv[1]);+try { console.log(JSON.stringify(database.prepare(process.argv[2]).all())); }+finally { database.close(); }`,join(environment["CODEX_SECURITY_STATE_DIR"]!, "workbench.sqlite3"),sql,],@@ -116,6 +126,88 @@ async function query(environment: NodeJS.ProcessEnv, sql: string) {return JSON.parse(result.stdout) as Record<string, unknown>[];}+test("classification and saved assessments run with Node and no Python", async () => {+ const { environment, root, scanDirectory, scanId, findings } =+ await fixture();+ const withoutPython = {+ ...environment,+ PATH: dirname(Bun.which("node")!),+ PYTHON: join(root, "missing-python"),+ };+ const { scanId: _scanId, ...classification } =+ await classifyScanDirectorySeverity(scanDirectory, {+ environment: withoutPython,+ });+ expect(+ await readScanSeverityClassification(+ scanDirectory,+ scanId,+ findings,+ undefined,+ withoutPython,+ ),+ ).toEqual(classification);+});++test("saved assessments retain embedded NULs in imported scan IDs", async () => {+ const { environment, scanDirectory, scanId, findings } =+ await fixture("imported\0scan");+ const { scanId: classifiedScanId, ...classification } =+ await classifyScanDirectorySeverity(scanDirectory, { environment });+ expect(classifiedScanId).toBe(scanId);+ expect(+ await readScanSeverityClassification(+ scanDirectory,+ scanId,+ findings,+ undefined,+ environment,+ ),+ ).toEqual(classification);+});++test("severity helpers skip Node executables in the caller's enclosing checkout", async () => {+ const { root, environment, scanDirectory } = await fixture();+ const repository = join(root, "repository");+ const bin = join(repository, "bin");+ const cwd = join(repository, "nested");+ await mkdir(bin, { recursive: true });+ await mkdir(cwd);+ await mkdir(join(repository, ".git"));+ const marker = join(root, "untrusted-node-ran");+ const node = join(bin, process.platform === "win32" ? "node.exe" : "node");+ await writeFile(+ node,+ process.platform === "win32"+ ? "synthetic invalid executable"+ : '#!/bin/sh\nprintf called > "$NODE_MARKER"\nexit 91\n',+ { mode: 0o700 },+ );+ const entryPoint = new URL(+ "../src/classify-scan-severity.ts",+ import.meta.url,+ );+ const result = spawnSync(+ process.execPath,+ [+ "--eval",+ `import { classifyScanDirectorySeverity } from ${JSON.stringify(entryPoint.href)};+await classifyScanDirectorySeverity(${JSON.stringify(scanDirectory)}, { environment: process.env });`,+ ],+ {+ cwd,+ encoding: "utf8",+ env: {+ ...environment,+ PATH: [bin, dirname(Bun.which("node")!)].join(delimiter),+ NODE_MARKER: marker,+ },+ },+ );+ expect(result.status, result.stderr).toBe(0);+ await expect(readFile(marker)).rejects.toMatchObject({ code: "ENOENT" });+});+function recordingClassifier() {const calls: string[] = [];const control = { failOn: "", excluded: false };diff --git a/sdk/typescript/tests-ts/publication-integration.test.ts b/sdk/typescript/tests-ts/publication-integration.test.tsindex 9686700ac..9866149bc 100644--- a/sdk/typescript/tests-ts/publication-integration.test.ts+++ b/sdk/typescript/tests-ts/publication-integration.test.ts@@ -999,7 +999,7 @@ describe("database-backed Linear publication integration", () => {const publisherPidFile = join(root, "sdk-publication-child.pid");await writeFile(preload,- 'const fs = require("node:fs");fs.readFileSync(0, "utf8");fs.writeFileSync(process.env.CODEX_PUBLICATION_PARENT_PID, String(process.pid));const waiter = new Int32Array(new SharedArrayBuffer(4));for (;;) Atomics.wait(waiter, 0, 0, 1000);',+ 'if (require("node:path").basename(process.argv[1] ?? "") !== "exec") return; const fs = require("node:fs");fs.readFileSync(0, "utf8");fs.writeFileSync(process.env.CODEX_PUBLICATION_PARENT_PID, String(process.pid));const waiter = new Int32Array(new SharedArrayBuffer(4));for (;;) Atomics.wait(waiter, 0, 0, 1000);',{ mode: 0o600 },);const publishing = publishScanInternal(completed.scanDirectory, OPTIONS, {@@ -1088,7 +1088,8 @@ describe("database-backed Linear publication integration", () => {'const fs = require("node:fs");process.on("SIGINT", () => {});process.on("SIGTERM", () => {});fs.writeFileSync(process.env.CODEX_PUBLICATION_DESCENDANT_PID, String(process.pid));setInterval(() => {}, 1000);';await writeFile(preload,- `const fs = require("node:fs"); const { spawn } = require("node:child_process");+ `if (require("node:path").basename(process.argv[1] ?? "") !== "exec") return;+const fs = require("node:fs"); const { spawn } = require("node:child_process");const prompt = fs.readFileSync(0, "utf8"); const payload = JSON.parse(prompt.split("BEGIN UNTRUSTED PUBLICATION DATA\\n")[1].split("\\nEND UNTRUSTED PUBLICATION DATA")[0]); const finding = JSON.parse(fs.readFileSync(payload.publicationFile, "utf8")).batches[0][0];fs.appendFileSync(payload.handoffFile, JSON.stringify({ scanId: payload.scanId, findingId: finding.findingId, occurrenceId: finding.occurrenceId, error: "Synthetic connected publication may have completed.", possibleMutation: true, arguments: finding.arguments }) + "\\n"); fs.writeFileSync(process.env.CODEX_PUBLICATION_PARENT_PID, String(process.pid));spawn(process.execPath, ["-e", ${JSON.stringify(descendant)}], { env: { ...(process.platform === "win32" ? { SystemRoot: process.env.SystemRoot } : {}), CODEX_PUBLICATION_DESCENDANT_PID: process.env.CODEX_PUBLICATION_DESCENDANT_PID }, stdio: "ignore" });