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

test: reuse MCP descriptor and worker fixtures (#1447)

mldangelo-oaic7b028c6d43e
diff --git a/plugins/codex-security/mcp-app/tests/test_artifact_scan_draft.ts b/plugins/codex-security/mcp-app/tests/test_artifact_scan_draft.ts
index f91f1571e..e4d091e35 100644
--- a/plugins/codex-security/mcp-app/tests/test_artifact_scan_draft.ts
+++ b/plugins/codex-security/mcp-app/tests/test_artifact_scan_draft.ts
@@ -123,6 +123,17 @@ try {
return { ...workerContext, root: directory };
};
+ const createRetryWorker = async (name: string) => {
+ const directory = path.join(root, name, "output");
+ await mkdir(directory, { recursive: true });
+ const context = { ...workerContext, root: directory };
+ await recordCodexSecurityWorkerScanDraft(context, {
+ ...workerInput,
+ complete: false,
+ });
+ return context;
+ };
+
const workerInput = {
scanId,
scope: { summary: "Archive handling" },
@@ -1671,14 +1682,7 @@ try {
);
assert.equal(monotonicWrites, 2);
- const archivedRetryRoot = path.join(root, "archived-retry-worker");
- const archivedRetryOutput = path.join(archivedRetryRoot, "output");
- await mkdir(archivedRetryOutput, { recursive: true });
- const archivedRetryContext = { ...workerContext, root: archivedRetryOutput };
- await recordCodexSecurityWorkerScanDraft(archivedRetryContext, {
- ...workerInput,
- complete: false,
- });
+ const archivedRetry = await createRetryWorker("archived-retry-worker");
const checkpointOnlyFinding: typeof finding & {
identity?: { anchor: string };
} = structuredClone(finding);
@@ -1686,25 +1690,17 @@ try {
checkpointOnlyFinding.identity = { anchor: "checkpoint-only-finding" };
checkpointOnlyFinding.provenance.candidateId = "checkpoint-only-candidate";
checkpointOnlyFinding.extensions.candidateId = "checkpoint-only-candidate";
- await saveScanDraftCheckpoint(archivedRetryContext, {
+ await saveScanDraftCheckpoint(archivedRetry, {
...workerInput,
complete: false,
findings: [finding, checkpointOnlyFinding],
});
- await mkdir(path.join(archivedRetryRoot, "attempts"));
- await rename(
- archivedRetryOutput,
- path.join(archivedRetryRoot, "attempts", "attempt-01"),
- );
- await mkdir(archivedRetryOutput);
- await recordCodexSecurityWorkerScanDraft(archivedRetryContext, {
+ await archiveFirstWorkerAttempt(archivedRetry.root);
+ await recordCodexSecurityWorkerScanDraft(archivedRetry, {
...withoutScanContext(workerInput),
findings: [],
});
- const archivedRetryResult = await readJson(
- archivedRetryOutput,
- "result.json",
- );
+ const archivedRetryResult = await readJson(archivedRetry.root, "result.json");
assert.deepEqual(
new Set(
archivedRetryResult.findings.map(
@@ -1725,22 +1721,14 @@ try {
"a replacement attempt must retain the threat model from archived checkpoints",
);
- const archivedResolutionRoot = path.join(root, "archived-resolution-worker");
- const archivedResolutionOutput = path.join(archivedResolutionRoot, "output");
- await mkdir(archivedResolutionOutput, { recursive: true });
- const archivedResolutionContext = {
- ...workerContext,
- root: archivedResolutionOutput,
- };
- await recordCodexSecurityWorkerScanDraft(archivedResolutionContext, {
- ...workerInput,
- complete: false,
- });
+ const archivedResolution = await createRetryWorker(
+ "archived-resolution-worker",
+ );
const demotedCandidate = {
candidateId: finding.provenance.candidateId,
reason: "The later attempt demoted this candidate for more review.",
};
- await recordCodexSecurityWorkerScanDraft(archivedResolutionContext, {
+ await recordCodexSecurityWorkerScanDraft(archivedResolution, {
...workerInput,
complete: false,
findings: [],
@@ -1751,18 +1739,13 @@ try {
deferred: [demotedCandidate],
},
});
- await mkdir(path.join(archivedResolutionRoot, "attempts"));
- await rename(
- archivedResolutionOutput,
- path.join(archivedResolutionRoot, "attempts", "attempt-01"),
- );
- await mkdir(archivedResolutionOutput);
- await recordCodexSecurityWorkerScanDraft(archivedResolutionContext, {
+ await archiveFirstWorkerAttempt(archivedResolution.root);
+ await recordCodexSecurityWorkerScanDraft(archivedResolution, {
...withoutScanContext(workerInput),
findings: [],
});
const archivedResolutionResult = await readJson(
- archivedResolutionOutput,
+ archivedResolution.root,
"result.json",
);
assert.deepEqual(
@@ -1772,30 +1755,18 @@ try {
);
assert.deepEqual(archivedResolutionResult.coverage.deferred, []);
- const repeatedCheckpointRoot = path.join(root, "repeated-checkpoint-worker");
- const repeatedCheckpointOutput = path.join(repeatedCheckpointRoot, "output");
- const repeatedCheckpointContext = {
- ...workerContext,
- root: repeatedCheckpointOutput,
- };
- await mkdir(repeatedCheckpointOutput, { recursive: true });
- let repeatedFindingDraft = {
- ...workerInput,
- complete: false,
- };
- await recordCodexSecurityWorkerScanDraft(
- repeatedCheckpointContext,
- repeatedFindingDraft,
+ const repeatedCheckpoint = await createRetryWorker(
+ "repeated-checkpoint-worker",
);
const [findingCheckpointName] = await readdir(
- path.join(repeatedCheckpointOutput, "checkpoints"),
+ path.join(repeatedCheckpoint.root, "checkpoints"),
);
- repeatedFindingDraft = await readJson(
- repeatedCheckpointOutput,
+ const repeatedFindingDraft = await readJson(
+ repeatedCheckpoint.root,
"checkpoints",
findingCheckpointName,
);
- await recordCodexSecurityWorkerScanDraft(repeatedCheckpointContext, {
+ await recordCodexSecurityWorkerScanDraft(repeatedCheckpoint, {
...workerInput,
complete: false,
findings: [],
@@ -1807,38 +1778,30 @@ try {
},
});
const demotionCheckpointName = (
- await readdir(path.join(repeatedCheckpointOutput, "checkpoints"))
+ await readdir(path.join(repeatedCheckpoint.root, "checkpoints"))
).find((name) => name !== findingCheckpointName);
assert.ok(demotionCheckpointName);
const oldCheckpointTime = new Date("2026-01-01T00:00:00.000Z");
const newerDemotionTime = new Date("2026-01-01T00:00:10.000Z");
await utimes(
- path.join(repeatedCheckpointOutput, "checkpoints", findingCheckpointName),
+ path.join(repeatedCheckpoint.root, "checkpoints", findingCheckpointName),
oldCheckpointTime,
oldCheckpointTime,
);
for (const path_ of [
- path.join(repeatedCheckpointOutput, "checkpoints", demotionCheckpointName),
- path.join(repeatedCheckpointOutput, "result.json"),
+ path.join(repeatedCheckpoint.root, "checkpoints", demotionCheckpointName),
+ path.join(repeatedCheckpoint.root, "result.json"),
]) {
await utimes(path_, newerDemotionTime, newerDemotionTime);
}
- await saveScanDraftCheckpoint(
- repeatedCheckpointContext,
- repeatedFindingDraft,
- );
- await mkdir(path.join(repeatedCheckpointRoot, "attempts"));
- await rename(
- repeatedCheckpointOutput,
- path.join(repeatedCheckpointRoot, "attempts", "attempt-01"),
- );
- await mkdir(repeatedCheckpointOutput);
- await recordCodexSecurityWorkerScanDraft(repeatedCheckpointContext, {
+ await saveScanDraftCheckpoint(repeatedCheckpoint, repeatedFindingDraft);
+ await archiveFirstWorkerAttempt(repeatedCheckpoint.root);
+ await recordCodexSecurityWorkerScanDraft(repeatedCheckpoint, {
...withoutScanContext(workerInput),
findings: [],
});
const repeatedCheckpointResult = await readJson(
- repeatedCheckpointOutput,
+ repeatedCheckpoint.root,
"result.json",
);
assert.deepEqual(
@@ -1849,22 +1812,15 @@ try {
"a byte-identical repeated checkpoint must supersede an intervening demotion",
);
- const multiAttemptRoot = path.join(root, "multi-attempt-resolution-worker");
- const multiAttemptOutput = path.join(multiAttemptRoot, "output");
- const multiAttemptContext = { ...workerContext, root: multiAttemptOutput };
- const multiAttemptArchive = path.join(multiAttemptRoot, "attempts");
- await mkdir(multiAttemptOutput, { recursive: true });
- await recordCodexSecurityWorkerScanDraft(multiAttemptContext, {
- ...workerInput,
- complete: false,
- });
- await mkdir(multiAttemptArchive);
- await rename(
- multiAttemptOutput,
- path.join(multiAttemptArchive, "attempt-01"),
+ const multiAttempt = await createRetryWorker(
+ "multi-attempt-resolution-worker",
);
- await mkdir(multiAttemptOutput);
- await recordCodexSecurityWorkerScanDraft(multiAttemptContext, {
+ const multiAttemptArchive = path.join(
+ path.dirname(multiAttempt.root),
+ "attempts",
+ );
+ await archiveFirstWorkerAttempt(multiAttempt.root);
+ await recordCodexSecurityWorkerScanDraft(multiAttempt, {
...withoutScanContext(workerInput),
complete: false,
findings: [],
@@ -1875,16 +1831,13 @@ try {
deferred: [demotedCandidate],
},
});
- await rename(
- multiAttemptOutput,
- path.join(multiAttemptArchive, "attempt-02"),
- );
- await mkdir(multiAttemptOutput);
- await recordCodexSecurityWorkerScanDraft(multiAttemptContext, {
+ await rename(multiAttempt.root, path.join(multiAttemptArchive, "attempt-02"));
+ await mkdir(multiAttempt.root);
+ await recordCodexSecurityWorkerScanDraft(multiAttempt, {
...withoutScanContext(workerInput),
findings: [],
});
- const multiAttemptResult = await readJson(multiAttemptOutput, "result.json");
+ const multiAttemptResult = await readJson(multiAttempt.root, "result.json");
assert.deepEqual(
multiAttemptResult.findings,
[finding],
@@ -1896,62 +1849,39 @@ try {
"the retained finding resolves the stale archived deferred row",
);
- const malformedArchivedRoot = path.join(
- root,
+ const malformedArchived = await createRetryWorker(
"malformed-archived-result-worker",
);
- const malformedArchivedOutput = path.join(malformedArchivedRoot, "output");
- const malformedArchivedContext = {
- ...workerContext,
- root: malformedArchivedOutput,
- };
- await mkdir(malformedArchivedOutput, { recursive: true });
- await recordCodexSecurityWorkerScanDraft(malformedArchivedContext, {
- ...workerInput,
- complete: false,
- });
await writeFile(
- path.join(malformedArchivedOutput, "result.json"),
+ path.join(malformedArchived.root, "result.json"),
"{malformed",
);
- await mkdir(path.join(malformedArchivedRoot, "attempts"));
- await rename(
- malformedArchivedOutput,
- path.join(malformedArchivedRoot, "attempts", "attempt-01"),
- );
- await mkdir(malformedArchivedOutput);
- await recordCodexSecurityWorkerScanDraft(malformedArchivedContext, {
+ await archiveFirstWorkerAttempt(malformedArchived.root);
+ await recordCodexSecurityWorkerScanDraft(malformedArchived, {
...withoutScanContext(workerInput),
findings: [],
});
assert.deepEqual(
- (await readJson(malformedArchivedOutput, "result.json")).findings,
+ (await readJson(malformedArchived.root, "result.json")).findings,
[finding],
"valid checkpoints must recover evidence when an archived result is malformed",
);
- const crossScanRetryRoot = path.join(root, "cross-scan-retry-worker");
- const crossScanRetryOutput = path.join(crossScanRetryRoot, "output");
- await mkdir(crossScanRetryOutput, { recursive: true });
- const crossScanRetryContext = {
- ...workerContext,
- root: crossScanRetryOutput,
- };
- await recordCodexSecurityWorkerScanDraft(crossScanRetryContext, {
- ...workerInput,
- complete: false,
- });
- const crossScanAttempts = path.join(crossScanRetryRoot, "attempts");
+ const crossScanRetry = await createRetryWorker("cross-scan-retry-worker");
+ const crossScanAttempts = path.join(
+ path.dirname(crossScanRetry.root),
+ "attempts",
+ );
const crossScanAttempt = path.join(crossScanAttempts, "attempt-01");
await mkdir(crossScanAttempts);
- await rename(crossScanRetryOutput, crossScanAttempt);
+ await rename(crossScanRetry.root, crossScanAttempt);
const crossScanResultPath = path.join(crossScanAttempt, "result.json");
const crossScanResult = await readJson(crossScanResultPath);
crossScanResult.scanId = "11111111-1111-4111-8111-111111111111";
await writeFile(crossScanResultPath, JSON.stringify(crossScanResult));
- await mkdir(crossScanRetryOutput);
+ await mkdir(crossScanRetry.root);
await assert.rejects(
- recordCodexSecurityWorkerScanDraft(crossScanRetryContext, {
+ recordCodexSecurityWorkerScanDraft(crossScanRetry, {
...withoutScanContext(workerInput),
findings: [],
}),
@@ -3111,6 +3041,13 @@ try {
console.log("Codex Security scan draft artifact tests passed");
+async function archiveFirstWorkerAttempt(output: string) {
+ const workerRoot = path.dirname(output);
+ await mkdir(path.join(workerRoot, "attempts"));
+ await rename(output, path.join(workerRoot, "attempts", "attempt-01"));
+ await mkdir(output);
+}
+
// Projection cases below use the same fixture root but model independent scans.
async function recordFreshScanDraft(
context: ArtifactContext,
diff --git a/plugins/codex-security/mcp-app/tests/test_deep_scan_executor.ts b/plugins/codex-security/mcp-app/tests/test_deep_scan_executor.ts
index 829575ad2..9a1221ad6 100644
--- a/plugins/codex-security/mcp-app/tests/test_deep_scan_executor.ts
+++ b/plugins/codex-security/mcp-app/tests/test_deep_scan_executor.ts
@@ -1210,13 +1210,7 @@ async function testUnsupportedProviderSnapshotFailsBeforeLaunch() {
process.env.CODEX_SECURITY_CONFIG_PATH = configPath;
process.env.CODEX_SECURITY_DEEP_SCAN_CONFIG_PATH = deepPath;
await assert.rejects(
- new CodexSdkWorkerExecutor({ parentSandbox: trustedParentSandbox }).run({
- kind: "discovery",
- promptPath,
- workingDirectory: fixture.root,
- subagents: 0,
- signal: new AbortController().signal,
- }),
+ runWorker(promptPath, fixture.root),
(error: Error) =>
error.name === "DeepScanNonRetryableError" &&
error.message.includes("Update the SDK and bundled plugin together"),
@@ -1231,15 +1225,7 @@ async function testUnsupportedProviderSnapshotFailsBeforeLaunch() {
stringifyToml({ worker_runtime: { native_profile: nativeProfile } }),
);
await assert.rejects(
- new CodexSdkWorkerExecutor({ parentSandbox: trustedParentSandbox }).run(
- {
- kind: "discovery",
- promptPath,
- workingDirectory: fixture.root,
- subagents: 0,
- signal: new AbortController().signal,
- },
- ),
+ runWorker(promptPath, fixture.root),
(error: Error) =>
error.name === "DeepScanNonRetryableError" &&
error.message.includes("invalid --profile value"),
diff --git a/plugins/codex-security/mcp-app/tests/test_mcp_app_smoke.ts b/plugins/codex-security/mcp-app/tests/test_mcp_app_smoke.ts
index 1218c713c..9c1a9ad0b 100644
--- a/plugins/codex-security/mcp-app/tests/test_mcp_app_smoke.ts
+++ b/plugins/codex-security/mcp-app/tests/test_mcp_app_smoke.ts
@@ -1315,68 +1315,35 @@ try {
code: "ENOENT",
});
- const launcher = toolList.result.tools.find(
- (tool: { name: string }) => tool.name === "open_codex_security_workspace",
- );
- const startPromptOnlyScan = toolList.result.tools.find(
- (tool: { name: string }) =>
- tool.name === "start_codex_security_prompt_only_scan",
- );
+ const findTool = (name: string) =>
+ toolList.result.tools.find((tool: { name: string }) => tool.name === name);
+
+ const launcher = findTool("open_codex_security_workspace");
+ const startPromptOnlyScan = findTool("start_codex_security_prompt_only_scan");
assert.match(
startPromptOnlyScan.description,
/Standard and diff scans save progress checkpoints before their final semantic draft/,
"Prompt-only scan instructions must align Diff callers with checkpointed handoffs",
);
- const startHeadlessStandardScan = toolList.result.tools.find(
- (tool: { name: string }) =>
- tool.name === "start_codex_security_standard_scan",
- );
- const getScan = toolList.result.tools.find(
- (tool: { name: string }) => tool.name === "get_codex_security_scan",
- );
- const recoverScanResults = toolList.result.tools.find(
- (tool: { name: string }) =>
- tool.name === "recover_codex_security_scan_results",
- );
- const listScans = toolList.result.tools.find(
- (tool: { name: string }) => tool.name === "list_codex_security_scans",
- );
- const listGlobalFindings = toolList.result.tools.find(
- (tool: { name: string }) =>
- tool.name === "list_codex_security_global_findings",
- );
- const listRepositories = toolList.result.tools.find(
- (tool: { name: string }) =>
- tool.name === "list_codex_security_repositories",
+ const startHeadlessStandardScan = findTool(
+ "start_codex_security_standard_scan",
);
- const getScanContext = toolList.result.tools.find(
- (tool: { name: string }) => tool.name === "get_codex_security_scan_context",
- );
- const updateScanContext = toolList.result.tools.find(
- (tool: { name: string }) =>
- tool.name === "update_codex_security_scan_context",
- );
- const updateScanContextFromApp = toolList.result.tools.find(
- (tool: { name: string }) =>
- tool.name === "update_codex_security_scan_context_from_app",
- );
- const renameScan = toolList.result.tools.find(
- (tool: { name: string }) => tool.name === "rename_codex_security_scan",
+ const getScan = findTool("get_codex_security_scan");
+ const recoverScanResults = findTool("recover_codex_security_scan_results");
+ const listScans = findTool("list_codex_security_scans");
+ const listGlobalFindings = findTool("list_codex_security_global_findings");
+ const listRepositories = findTool("list_codex_security_repositories");
+ const getScanContext = findTool("get_codex_security_scan_context");
+ const updateScanContext = findTool("update_codex_security_scan_context");
+ const updateScanContextFromApp = findTool(
+ "update_codex_security_scan_context_from_app",
);
+ const renameScan = findTool("rename_codex_security_scan");
assert.deepEqual(renameScan._meta.ui.visibility, ["app"]);
- const submit = toolList.result.tools.find(
- (tool: { name: string }) => tool.name === "submit_codex_security_setup",
- );
- const inspectTarget = toolList.result.tools.find(
- (tool: { name: string }) => tool.name === "inspect_codex_security_target",
- );
- const inspectSetup = toolList.result.tools.find(
- (tool: { name: string }) => tool.name === "inspect_codex_security_setup",
- );
- const requestUserInput = toolList.result.tools.find(
- (tool: { name: string }) =>
- tool.name === "request_codex_security_user_input",
- );
+ const submit = findTool("submit_codex_security_setup");
+ const inspectTarget = findTool("inspect_codex_security_target");
+ const inspectSetup = findTool("inspect_codex_security_setup");
+ const requestUserInput = findTool("request_codex_security_user_input");
assert.ok(
requestUserInput,
"Expected the Codex Security user-input fallback tool.",
@@ -1580,83 +1547,45 @@ try {
assertNoError(response);
assert.deepEqual(response.result.structuredContent, { status });
}
- const start = toolList.result.tools.find(
- (tool: { name: string }) => tool.name === "start_codex_security_scan",
+ const start = findTool("start_codex_security_scan");
+ const startDeepScan = findTool("start_codex_security_deep_scan");
+ const cancel = findTool("cancel_codex_security_scan");
+ const cancelFromApp = findTool("cancel_codex_security_scan_from_app");
+ const markHandoff = findTool("mark_codex_security_scan_handoff_delivered");
+ const claimHandoff = findTool("claim_codex_security_scan_handoff_delivery");
+ const releaseHandoff = findTool(
+ "release_codex_security_scan_handoff_delivery",
);
- const startDeepScan = toolList.result.tools.find(
- (tool: { name: string }) => tool.name === "start_codex_security_deep_scan",
+ const attachHandoff = findTool(
+ "attach_codex_security_scan_continuation_thread",
);
- const cancel = toolList.result.tools.find(
- (tool: { name: string }) => tool.name === "cancel_codex_security_scan",
+ const progress = findTool("update_codex_security_scan_progress");
+ const complete = findTool("complete_codex_security_scan");
+ const fail = findTool("fail_codex_security_scan");
+ const setFindingTriage = findTool("set_codex_security_finding_triage");
+ const requestFindingRemediation = findTool(
+ "request_codex_security_finding_remediation",
);
- const cancelFromApp = toolList.result.tools.find(
- (tool: { name: string }) =>
- tool.name === "cancel_codex_security_scan_from_app",
+ const requestFindingRemediationAction = findTool(
+ "request_codex_security_finding_remediation_action",
);
- const markHandoff = toolList.result.tools.find(
- (tool: { name: string }) =>
- tool.name === "mark_codex_security_scan_handoff_delivered",
+ const claimFindingRemediationResend = findTool(
+ "claim_codex_security_finding_remediation_resend",
);
- const claimHandoff = toolList.result.tools.find(
- (tool: { name: string }) =>
- tool.name === "claim_codex_security_scan_handoff_delivery",
- );
- const releaseHandoff = toolList.result.tools.find(
- (tool: { name: string }) =>
- tool.name === "release_codex_security_scan_handoff_delivery",
- );
- const attachHandoff = toolList.result.tools.find(
- (tool: { name: string }) =>
- tool.name === "attach_codex_security_scan_continuation_thread",
- );
- const progress = toolList.result.tools.find(
- (tool: { name: string }) =>
- tool.name === "update_codex_security_scan_progress",
- );
- const complete = toolList.result.tools.find(
- (tool: { name: string }) => tool.name === "complete_codex_security_scan",
- );
- const fail = toolList.result.tools.find(
- (tool: { name: string }) => tool.name === "fail_codex_security_scan",
- );
- const setFindingTriage = toolList.result.tools.find(
- (tool: { name: string }) =>
- tool.name === "set_codex_security_finding_triage",
- );
- const requestFindingRemediation = toolList.result.tools.find(
- (tool: { name: string }) =>
- tool.name === "request_codex_security_finding_remediation",
- );
- const requestFindingRemediationAction = toolList.result.tools.find(
- (tool: { name: string }) =>
- tool.name === "request_codex_security_finding_remediation_action",
- );
- const claimFindingRemediationResend = toolList.result.tools.find(
- (tool: { name: string }) =>
- tool.name === "claim_codex_security_finding_remediation_resend",
- );
- const releaseFindingRemediationClaim = toolList.result.tools.find(
- (tool: { name: string }) =>
- tool.name === "release_codex_security_finding_remediation_claim",
- );
- const cancelFindingRemediationRequest = toolList.result.tools.find(
- (tool: { name: string }) =>
- tool.name === "cancel_codex_security_finding_remediation_request",
+ const releaseFindingRemediationClaim = findTool(
+ "release_codex_security_finding_remediation_claim",
);
- const markFindingRemediationDelivered = toolList.result.tools.find(
- (tool: { name: string }) =>
- tool.name === "mark_codex_security_finding_remediation_delivered",
- );
- const setFindingRemediation = toolList.result.tools.find(
- (tool: { name: string }) =>
- tool.name === "set_codex_security_finding_remediation",
+ const cancelFindingRemediationRequest = findTool(
+ "cancel_codex_security_finding_remediation_request",
);
- const exportFindings = toolList.result.tools.find(
- (tool: { name: string }) => tool.name === "export_codex_security_findings",
+ const markFindingRemediationDelivered = findTool(
+ "mark_codex_security_finding_remediation_delivered",
);
- const listFindings = toolList.result.tools.find(
- (tool: { name: string }) => tool.name === "list_codex_security_findings",
+ const setFindingRemediation = findTool(
+ "set_codex_security_finding_remediation",
);
+ const exportFindings = findTool("export_codex_security_findings");
+ const listFindings = findTool("list_codex_security_findings");
assert.ok(launcher);
assert.ok(startPromptOnlyScan);
assert.ok(startHeadlessStandardScan);