Skip to content

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

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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
new file mode 100644
index 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.json
index 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.py
index 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.py
index 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_state
import workbench_saved_results as saved_results
import workbench_scan_history as scan_history
import workbench_scan_usage as scan_usage
-import workbench_severity as severity
from 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))
- return
if 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.py
deleted file mode 100644
index 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.py
index 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.py
index 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_occurrenc
assert 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, 10
for 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 = 0
def 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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" });