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
feat(scanner-imports): add ArmorCode findings support (#2608)
Michael D'Angelo5aa4d394ea14
diff --git a/docs/scanner-imports/README.md b/docs/scanner-imports/README.mdindex 98a5fbc7c..6ff1c871f 100644--- a/docs/scanner-imports/README.md+++ b/docs/scanner-imports/README.md@@ -20,11 +20,12 @@ the local workbench in a later session using their stored IDs and versions.The `--provider` value selects the reader for a saved report. To see whichreaders your installed CLI supports, run `codex-security publish findings --help`.-The guides cover local and Cloud imports unless an input is marked local only.+The guides cover local and Cloud imports unless a row limits its scope.| Guide | `--provider` | Supported input || ----------------------------------------------------------- | ------------ | ------------------------------------------------------------------------------- || [Amazon Inspector](inspector.md) | `inspector` | Inspector2 `ListFindings` JSON for one Code Security repository |+| [ArmorCode](armorcode.md) | `armorcode` | Findings API JSON for one repository (local verified, Cloud unverified) || [AWS Continuum](continuum.md) | `continuum` | Summaries or selected code finding details for one verified repository || [Black Duck SCA](blackduck.md) | `blackduck` | BOM-6 vulnerable components for one project version || [Checkmarx SAST](checkmarx.md) | `checkmarx` | Checkmarx One CLI JSON or self-managed CxSAST XML for one scan |diff --git a/docs/scanner-imports/armorcode.md b/docs/scanner-imports/armorcode.mdnew file mode 100644index 000000000..dae6c5461--- /dev/null+++ b/docs/scanner-imports/armorcode.md@@ -0,0 +1,53 @@+# Import ArmorCode findings++Import a saved response from ArmorCode's `POST /api/findings` endpoint into the+local workbench. Cloud publication of ArmorCode findings is unverified. The reader+accepts the API's `data.findings` envelope, as well as a top-level `findings`+array for exported reports. Each finding needs a stable numeric or string `id`+and a `title`. Reuse the same source key for repeat imports from the same+ArmorCode organization and finding selection.++Choose SAST findings for one repository in ArmorCode. Set `ARMORCODE_QUERY` to+the path of the JSON request body for that selection. Severity and status+filters alone can return findings from multiple repositories. From the checkout+root, save the response in a private temporary directory outside the checkout.++```sh+report_dir=$(mktemp -d "${TMPDIR:-/tmp}/armorcode.XXXXXX")+curl --fail-with-body -X POST "https://$HOST_URL/api/findings" \+ -H 'accept: application/json' \+ -H "authorization: Bearer $ARMORCODE_API_KEY" \+ -H 'content-type: application/json' \+ --data-binary "@$ARMORCODE_QUERY" > "$report_dir/armorcode-findings.json"+```++Preview the same file against the selected checkout.++```sh+codex-security publish findings "$report_dir/armorcode-findings.json" \+ --to local --repository . --provider armorcode \+ --source-key ORG_ID/APP_ID --dry-run --format json+```++If any SAST row omits its repository URL, verify the report's repository in+ArmorCode and add `--source-repository-url URL` to the command. The import+checks declared repository URLs against the checkout's configured remotes.+A conflicting repository in the report causes the import to fail.++The import preserves the complete source record as evidence. It maps severity,+description, mitigation, finding URLs, CVE identifiers, file path and line+number, and the last-updated timestamp when present. The evidence URL uses the+source scanner's `url` when present. ArmorCode's `findingUrl` remains in the+retained source record. Findings whose `scanType` contains `SAST` also expose+their source status, scanner origin and verdict, rule IDs, CWE IDs, and+mitigation as typed SAST details. A record's `sourceRepositoryUrl`,+`repositoryUrl`, or repository URL is projected when present. Unknown severities+are retained as `unknown`. The local assessment starts as `not_assessed`.+Repeated IDs in a single input are excluded as ambiguous. Repeat imports with+the same provider, source key and finding ID update the existing observation.++Review the preview's findings, exclusions, repository and source key. Remove+`--dry-run` to save the findings, then run+`codex-security findings imported . --format json` to read them back.+Records omitted from a later import remain stored. Use the normalized field+names above when an export uses different field names.diff --git a/docs/scanner-imports/schema-guide.md b/docs/scanner-imports/schema-guide.mdindex 1298708dd..f4cf3f485 100644--- a/docs/scanner-imports/schema-guide.md+++ b/docs/scanner-imports/schema-guide.md@@ -24,6 +24,7 @@ which changes can give an occurrence a different ID.| Report | What identifies one record || ------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- || [Amazon Inspector](inspector.md), [Endor Labs](endor.md), [SonarQube Cloud](sonar.md) | Inspector finding ARN, Endor Finding UUID or Sonar issue key. Endor native JSON and SARIF use the same UUID. |+| [ArmorCode](armorcode.md) | ArmorCode finding ID (`id`) within the source key. || [AWS Continuum](continuum.md) | Continuum finding ARN. A list summary and a detailed response for that ARN identify the same finding. || [Tenable One](tenable.md) | Exact Tenable `finding_id` within the local checkout and a stable tenant/asset source key. Use the Code Repository asset UUID in the key. || [Checkmarx SAST](checkmarx.md) | Checkmarx One uses the similarity ID and result hash. CxSAST scopes the similarity ID and ordered flow to the project and query. |diff --git a/sdk/typescript/schemas/external-findings.schema.json b/sdk/typescript/schemas/external-findings.schema.jsonindex 5fb9905e8..1830317b0 100644--- a/sdk/typescript/schemas/external-findings.schema.json+++ b/sdk/typescript/schemas/external-findings.schema.json@@ -390,7 +390,8 @@"sonar","continuum","checkmarx",- "trivy"+ "trivy",+ "armorcode"],"title": "Provider","type": "string"diff --git a/sdk/typescript/scripts/package-dist-files.mjs b/sdk/typescript/scripts/package-dist-files.mjsindex 46b790f94..8b41b12c1 100644--- a/sdk/typescript/scripts/package-dist-files.mjs+++ b/sdk/typescript/scripts/package-dist-files.mjs@@ -35,6 +35,7 @@ const distModules = ["external-findings-import","external-findings-read","scanner-import",+ "armorcode-findings","inspector-findings","continuum-findings","checkmarx-evidence",diff --git a/sdk/typescript/src/armorcode-findings.ts b/sdk/typescript/src/armorcode-findings.tsnew file mode 100644index 000000000..c7c4e8940--- /dev/null+++ b/sdk/typescript/src/armorcode-findings.ts@@ -0,0 +1,192 @@+import type { ExternalImportTarget } from "./external-import-contract.js";+import { validateExternalEvidence } from "./external-import-contract.js";+import type { ExternalFindings } from "./external-findings.js";+import type { ExternalFindingEvidence } from "./external-import-models.js";+import { declaredScannerRepositoryUrl } from "./scanner-repository-url.js";+import { isRecord } from "./record.js";+import {+ normalizeRecords,+ record,+ requiredText,+ text,+} from "./scanner-import.js";++type ArmorCodeFinding = Record<string, unknown>;++function armorCodeId(value: unknown): string {+ if (typeof value === "string")+ return requiredText(value, "ArmorCode finding ID");+ if (typeof value === "number" && Number.isSafeInteger(value))+ return String(value);+ throw new Error("ArmorCode finding ID must be text or a safe integer.");+}++function stringValues(value: unknown): string[] {+ const values = Array.isArray(value) ? value : value == null ? [] : [value];+ return values.flatMap((item) => {+ if (typeof item === "string" && item.trim()) return [item];+ if (typeof item === "number" && Number.isSafeInteger(item))+ return [String(item)];+ return [];+ });+}++/** Recover the source repository independently of the finding's scan type. */+export function armorCodeRepositoryUrl(+ finding: ArmorCodeFinding | null | undefined,+ target: ExternalImportTarget,+): string | undefined {+ const repository = finding?.["repository"];+ const url =+ text(finding?.["sourceRepositoryUrl"]) ??+ text(finding?.["repositoryUrl"]) ??+ text(isRecord(repository) ? repository["url"] : repository);+ return url+ ? declaredScannerRepositoryUrl(url, "ArmorCode", target)+ : undefined;+}++/** Normalize stable finding records while retaining the original ArmorCode row. */+export function normalizeArmorCodeFindings(+ input: unknown,+ target: ExternalImportTarget = "cloud",+ sourceRepositoryUrl?: string,+): ExternalFindings {+ const document = Array.isArray(input)+ ? { findings: input }+ : record(input, "ArmorCode report");+ const raw =+ document["findings"] ??+ document["issues"] ??+ (isRecord(document["data"]) ? document["data"]["findings"] : undefined);+ if (!Array.isArray(raw))+ throw new Error("ArmorCode report must contain a findings array.");+ const report = { ...document };+ delete report["findings"];+ delete report["issues"];+ if (isRecord(report["data"])) {+ const data = { ...report["data"] };+ delete data["findings"];+ if (Object.keys(data).length) report["data"] = data;+ else delete report["data"];+ }+ const declaredUrl =+ sourceRepositoryUrl === undefined+ ? undefined+ : declaredScannerRepositoryUrl(sourceRepositoryUrl, "ArmorCode", target);+ return normalizeRecords(+ raw as ArmorCodeFinding[],+ (finding) => {+ const severity = (text(finding["severity"]) ?? "unknown").toLowerCase();+ const locations = Array.isArray(finding["locations"])+ ? finding["locations"]+ : finding["location"]+ ? [finding["location"]]+ : text(finding["filePath"])+ ? [{ path: finding["filePath"], line: finding["lineNumber"] }]+ : [];+ const description = text(+ finding["description"] ??+ finding["details"] ??+ finding["toolDescription"],+ );+ const mitigation = text(finding["mitigation"]);+ const lastUpdated = finding["lastUpdated"];+ const isSast =+ Array.isArray(finding["scanType"]) &&+ finding["scanType"].some(+ (value) =>+ typeof value === "string" && value.toLowerCase() === "sast",+ );+ const ruleIds = stringValues(finding["ruleId"]);+ const weaknessIds = [+ ...stringValues(finding["cwe"]),+ ...stringValues(finding["cwesStrings"]),+ ];+ const repositoryUrl =+ armorCodeRepositoryUrl(finding, target) ?? declaredUrl;+ if (isSast && !repositoryUrl)+ throw new Error(+ "ArmorCode SAST evidence requires its source repository. For a single-repository report, supply its verified --source-repository-url.",+ );+ const evidence: ExternalFindingEvidence = {+ title: requiredText(+ finding["title"] ?? finding["name"] ?? finding["findingName"],+ "ArmorCode finding title",+ ),+ severity: ([+ "critical",+ "high",+ "medium",+ "low",+ "informational",+ ].includes(severity)+ ? severity+ : "unknown") as ExternalFindingEvidence["severity"],+ description: isSast+ ? description+ : description && mitigation+ ? `${description}\n\nMitigation: ${mitigation}`+ : (description ?? mitigation),+ // ArmorCode's findingUrl remains available in source_data; url points+ // to the originating scanner when ArmorCode provides both links.+ url: text(finding["url"] ?? finding["findingUrl"]),+ ...(Array.isArray(finding["cve"]) && {+ advisory_ids: finding["cve"].filter(+ (value): value is string => typeof value === "string",+ ),+ }),+ locations: locations.flatMap((value) => {+ if (!isRecord(value)) return [];+ const path = text(+ value["path"] ?? value["filePath"] ?? value["file"],+ );+ if (!path) return [];+ const line =+ value["line"] ?? value["startLine"] ?? value["lineNumber"];+ return [+ {+ path,+ line:+ Number.isSafeInteger(line) && Number(line) > 0+ ? Number(line)+ : null,+ },+ ];+ }),+ ...(typeof lastUpdated === "number" &&+ Number.isSafeInteger(lastUpdated) && {+ source_updated_at: Math.floor(lastUpdated / 1000),+ }),+ ...(isSast && {+ details: {+ kind: "sast",+ ...(repositoryUrl && { repository: { url: repositoryUrl } }),+ source_status: text(+ finding["status"] ?? finding["toolFindingStatus"],+ ),+ scanner_origin: text(finding["source"]),+ scanner_verdict: text(finding["toolStatusOriginal"]),+ ...(ruleIds.length > 0 && { rule: { id: ruleIds.join(", ") } }),+ ...(weaknessIds.length > 0 && {+ weakness_ids: [...new Set(weaknessIds)],+ }),+ ...(mitigation && { remediation_instructions: mitigation }),+ },+ }),+ source_data: structuredClone(finding),+ };+ validateExternalEvidence(evidence, target);+ return evidence;+ },+ (finding) =>+ armorCodeId(+ finding["source_finding_id"] ??+ finding["findingId"] ??+ finding["id"] ??+ finding["finding_id"],+ ),+ target,+ { report },+ );+}diff --git a/sdk/typescript/src/external-findings-local.ts b/sdk/typescript/src/external-findings-local.tsindex d2f37e9bf..429be2886 100644--- a/sdk/typescript/src/external-findings-local.ts+++ b/sdk/typescript/src/external-findings-local.ts@@ -81,6 +81,7 @@ import { continuumReportRepositories } from "./continuum-findings.js";import { veracodeReportRepositories } from "./veracode-findings.js";import { inspectorReportRepository } from "./inspector-findings.js";import { declaredScannerRepositoryUrl } from "./scanner-repository-url.js";+import { armorCodeRepositoryUrl } from "./armorcode-findings.js";import { sonarRepositoryUrls } from "./sonar-findings.js";import { isRecord } from "./record.js";import { dependabotRepository } from "./github-dependabot-findings.js";@@ -1189,6 +1190,10 @@ export async function prepareLocalImport(if (semgrep.migration) Object.assign(finding.evidence, semgrep.migration);}const { evidence } = finding;+ if (options.provider === "armorcode") {+ const nativeUrl = armorCodeRepositoryUrl(evidence.source_data, "local");+ if (nativeUrl) sources.set(nativeUrl, { url: nativeUrl });+ }if (options.provider === "github") {const source = retainedGitHubRepository(finding,@@ -1437,6 +1442,20 @@ export async function prepareLocalImport(throw new Error("The retained Checkmarx report repository does not match the finding repository.",);+ if (options.provider === "armorcode") {+ if (options.sourceRepositoryUrl !== undefined) {+ const url = declaredScannerRepositoryUrl(+ options.sourceRepositoryUrl,+ "ArmorCode",+ "local",+ );+ sources.set(url, { url });+ }+ if (!sameRepositories(sources.keys()))+ throw new CodexSecurityError(+ "ArmorCode findings must belong to a single source repository.",+ );+ }const sonarSources = sonarRepositoryUrls(options.provider,current.findings,diff --git a/sdk/typescript/src/external-findings-publish.ts b/sdk/typescript/src/external-findings-publish.tsindex 3ca6666dd..1fd689547 100644--- a/sdk/typescript/src/external-findings-publish.ts+++ b/sdk/typescript/src/external-findings-publish.ts@@ -19,6 +19,7 @@ import {} from "./private-finding-import.js";import { readCloudCredentials } from "./cloud-publish.js";import type { LocalExternalImportOptions } from "./external-findings-import.js";+import { armorCodeRepositoryUrl } from "./armorcode-findings.js";import { declaredScannerRepositoryUrl } from "./scanner-repository-url.js";import { tenableReportFormat } from "./tenable-findings.js";import {@@ -1555,6 +1556,8 @@ async function preparePublicationInput(`Finding ${JSON.stringify(id)} belongs to ${JSON.stringify(url)}, which does not match the selected Cloud repository ${JSON.stringify(destination.url)}. Verify the source repository mapping before publishing.`,);}+ if (provider === "armorcode")+ requireDestination("ArmorCode source", declaredUrl);if (report?.["format"] === guardianSelectionFormat)requireDestination("Guardian source",@@ -1615,6 +1618,7 @@ async function preparePublicationInput(if (binding) requireDestination(binding.findingId, binding.url);}const checkOnlyProjected = !checkNative(+ "armorcode","blackduck","inspector","veracode",@@ -1648,7 +1652,9 @@ async function preparePublicationInput(checkmarxRepository(finding)?.url,evidence.details?.repository?.url,];- if (provider === "wiz") {+ if (provider === "armorcode") {+ urls.push(armorCodeRepositoryUrl(evidence.source_data, "cloud"));+ } else if (provider === "wiz") {const native =hasProjection ||(!historical && isWizPackageFinding(evidence.source_data));diff --git a/sdk/typescript/src/external-findings-read.ts b/sdk/typescript/src/external-findings-read.tsindex 5fcb5b316..1bb3f2041 100644--- a/sdk/typescript/src/external-findings-read.ts+++ b/sdk/typescript/src/external-findings-read.ts@@ -35,12 +35,14 @@ import { readCheckmarxFindings } from "./checkmarx-findings.js";import { normalizeInspectorFindings } from "./inspector-findings.js";import { isRecord } from "./record.js";import { readWizSelection, wizFindingRepository } from "./wiz-findings.js";+import { normalizeArmorCodeFindings } from "./armorcode-findings.js";export type LocalFindingProvider = Provider | "tenable";/** File reader names mapped to the provider stored with each finding. */export const EXTERNAL_FINDINGS_PROVIDERS = {wiz: "wiz",+ armorcode: "armorcode",snyk: "snyk",semgrep: "semgrep",trivy: "trivy",@@ -221,6 +223,16 @@ export async function readExternalFindings(sourceRepositories.push({ url: options.sourceRepositoryUrl });return { findings, sourceRepositories };}+ if (provider === "armorcode") {+ const input = await readScannerJson(path);+ return {+ findings: normalizeArmorCodeFindings(+ input,+ target,+ options.sourceRepositoryUrl,+ ),+ };+ }if (provider === "github")return { findings: await readGitHubFindings(path, target) };if (provider === "wiz") {diff --git a/sdk/typescript/src/external-import-models.ts b/sdk/typescript/src/external-import-models.tsindex d19314b29..26ef1ff68 100644--- a/sdk/typescript/src/external-import-models.ts+++ b/sdk/typescript/src/external-import-models.ts@@ -17,7 +17,8 @@ export type Provider =| "sonar"| "continuum"| "checkmarx"- | "trivy";+ | "trivy"+ | "armorcode";export type SourceKey = string;export type ClientId = string;export type SourceFindingId = string;diff --git a/sdk/typescript/tests-ts/armorcode-findings.test.ts b/sdk/typescript/tests-ts/armorcode-findings.test.tsnew file mode 100644index 000000000..e0303f617--- /dev/null+++ b/sdk/typescript/tests-ts/armorcode-findings.test.ts@@ -0,0 +1,182 @@+import { describe, expect, test } from "bun:test";+import { normalizeArmorCodeFindings } from "../src/armorcode-findings.js";+import { localReportFixture } from "./external-findings-local-helpers.js";++describe("ArmorCode finding imports", () => {+ const repositoryUrl = "https://github.com/example/project";+ const source = { provider: "armorcode", sourceKey: "org/app" } as const;++ test("uses a declared source for SAST rows without changing the stored source record", async () => {+ await using fixture = await localReportFixture("armorcode.json", source, {+ remote: repositoryUrl,+ });+ const row = { id: 1, title: "Unchecked index", scanType: ["SAST"] };+ await fixture.writeJson({ data: { findings: [row] } });+ const { preview } = await fixture.prepare({+ sourceRepositoryUrl: repositoryUrl,+ });+ expect(preview.excluded).toEqual([]);+ expect(preview.findings[0]?.evidence.details).toMatchObject({+ kind: "sast",+ repository: { url: repositoryUrl },+ });+ expect(preview.findings[0]?.evidence.source_data).toEqual(row);+ await expect(+ fixture.prepare({+ sourceRepositoryUrl: "https://github.com/example/other",+ }),+ ).rejects.toThrow(/does not match/iu);+ });++ test("rejects a mixed report when a generic row belongs to another checkout", async () => {+ await using fixture = await localReportFixture("armorcode.json", source, {+ remote: repositoryUrl,+ });+ const report = {+ data: {+ findings: [+ {+ id: 1,+ title: "Unchecked index",+ scanType: ["SAST"],+ repositoryUrl,+ },+ {+ id: 2,+ title: "Vulnerable package",+ scanType: ["SCA"],+ repository: { url: "https://github.com/example/other" },+ },+ ],+ },+ };+ await fixture.writeJson(report);+ await expect(fixture.prepare()).rejects.toThrow(+ /single source repository/iu,+ );+ await expect(+ fixture.prepareNormalized(normalizeArmorCodeFindings(report, "local")),+ ).rejects.toThrow(/single source repository/iu);+ });++ test("normalizes findings and retains the source records", () => {+ const result = normalizeArmorCodeFindings({+ findings: [+ {+ findingId: "AC-42",+ name: "Unsafe query construction",+ severity: "HIGH",+ description: "Untrusted input reaches a query.",+ location: { filePath: "src/query.ts", startLine: 18 },+ status: "open",+ },+ ],+ });++ expect(result.findings).toHaveLength(1);+ expect(result.findings[0]).toMatchObject({+ source_finding_id: "AC-42",+ evidence: {+ title: "Unsafe query construction",+ severity: "high",+ locations: [{ path: "src/query.ts", line: 18 }],+ source_data: { status: "open" },+ },+ });+ });++ test("excludes colliding source IDs instead of selecting one", () => {+ const result = normalizeArmorCodeFindings(+ [+ { id: "same", title: "First" },+ { id: "same", title: "Second" },+ ],+ "local",+ );++ expect(result.findings).toHaveLength(0);+ expect(result.excluded).toHaveLength(2);+ });++ test("normalizes the ArmorCode findings API response envelope", () => {+ const result = normalizeArmorCodeFindings({+ data: {+ findings: [+ {+ id: 1097722461,+ title: "Container(s) run as root",+ severity: "CRITICAL",+ description: "Container is configured to run as root.",+ mitigation: "Set runAsUser to a non-zero ID.",+ findingUrl: "https://armorcode.example/findings/1097722461",+ filePath: "deploy/workload.yaml",+ lineNumber: 12,+ cve: [],+ status: "OPEN",+ lastUpdated: 1792740664000,+ },+ ],+ },+ success: true,+ });++ expect(result.findings).toHaveLength(1);+ expect(result.findings[0]).toMatchObject({+ source_finding_id: "1097722461",+ evidence: {+ title: "Container(s) run as root",+ severity: "critical",+ description:+ "Container is configured to run as root.\n\nMitigation: Set runAsUser to a non-zero ID.",+ url: "https://armorcode.example/findings/1097722461",+ locations: [{ path: "deploy/workload.yaml", line: 12 }],+ source_updated_at: 1792740664,+ source_data: { status: "OPEN" },+ },+ });+ });++ test("projects typed SAST metadata and keeps both scanner links", () => {+ const result = normalizeArmorCodeFindings({+ data: {+ findings: [+ {+ id: 42,+ title: "Buffer index access",+ repositoryUrl: "https://github.com/example/repository",+ severity: "HIGH",+ description: "Query: Buffer index access",+ mitigation: "Validate the buffer index.",+ source: "Checkmarx",+ status: "OPEN",+ toolStatusOriginal: "TO VERIFY",+ scanType: ["SAST"],+ ruleId: ["CX-101"],+ cwe: "CWE-129",+ url: "https://scanner.example/findings/42",+ findingUrl: "https://armorcode.example/findings/42",+ },+ ],+ },+ });++ expect(result.findings[0]).toMatchObject({+ source_finding_id: "42",+ evidence: {+ url: "https://scanner.example/findings/42",+ description: "Query: Buffer index access",+ details: {+ kind: "sast",+ repository: { url: "https://github.com/example/repository" },+ source_status: "OPEN",+ scanner_origin: "Checkmarx",+ scanner_verdict: "TO VERIFY",+ rule: { id: "CX-101" },+ weakness_ids: ["CWE-129"],+ remediation_instructions: "Validate the buffer index.",+ },+ source_data: { findingUrl: "https://armorcode.example/findings/42" },+ },+ });+ });+});diff --git a/sdk/typescript/tests-ts/external-findings-publish.test.ts b/sdk/typescript/tests-ts/external-findings-publish.test.tsindex 418065ffe..2b11e40ef 100644--- a/sdk/typescript/tests-ts/external-findings-publish.test.ts+++ b/sdk/typescript/tests-ts/external-findings-publish.test.ts@@ -21,6 +21,7 @@ import {import { endorFinding, endorSarif } from "./support/endor-import-fixtures.js";import { sonarGitTestEnvironment } from "./support/sonar-import-fixtures.js";import { normalizeEndorFindings } from "../src/endor-findings.js";+import { normalizeArmorCodeFindings } from "../src/armorcode-findings.js";import { createServer, type ServerResponse } from "node:http";import { execFile } from "node:child_process";import { hash } from "node:crypto";@@ -319,6 +320,45 @@ test("Wiz's gzip JSON report retains finding identity, evidence and repository l).toBeNull();});+test("ArmorCode rejects generic rows from a different Cloud repository before publishing", async () => {+ const sourceRepositoryUrl = "https://github.com/example/project";+ const report = {+ data: {+ findings: [+ {+ id: 1,+ title: "Unchecked index",+ scanType: ["SAST"],+ repositoryUrl: sourceRepositoryUrl,+ },+ {+ id: 2,+ title: "Vulnerable package",+ scanType: ["SCA"],+ repositoryUrl: "https://github.com/example/other",+ },+ ],+ },+ };+ const f = await fixture(report, sourceRepositoryUrl);+ const selection = {+ ...options,+ provider: "armorcode" as const,+ sourceRepositoryUrl,+ };+ await expect(+ prepareExternalPublication(f.file, selection, f.deps),+ ).rejects.toThrow("does not match the selected Cloud repository");+ await expect(+ prepareNormalizedExternalPublication(+ normalizeArmorCodeFindings(report),+ selection,+ f.deps,+ ),+ ).rejects.toThrow("does not match the selected Cloud repository");+ expect(f.posts).toHaveLength(0);+});+test("a Wiz Raw Event export explains the finding-report path before contacting Cloud", async () => {const f = await fixture({id: "scan-event-1",