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: consolidate workbench command handling (#1494)

mldangelo-oai92b90468e80b
diff --git a/plugins/codex-security/scripts/workbench_cli.py b/plugins/codex-security/scripts/workbench_cli.py
index 413fc0cfb..55f431a28 100644
--- a/plugins/codex-security/scripts/workbench_cli.py
+++ b/plugins/codex-security/scripts/workbench_cli.py
@@ -34,11 +34,16 @@ def parse_args(description: str) -> argparse.Namespace:
parser = argparse.ArgumentParser(description=description)
subparsers = parser.add_subparsers(dest="command", required=True)
+ def add_command(name: str, *required: str) -> argparse.ArgumentParser:
+ command_parser = subparsers.add_parser(name)
+ for flag in required:
+ command_parser.add_argument(flag, required=True)
+ return command_parser
+
resolve_scan_root = subparsers.add_parser("resolve-scan-root")
resolve_scan_root.add_argument("--scan-root")
- create_workspace = subparsers.add_parser("create-workspace")
- create_workspace.add_argument("--workspace-id", required=True)
+ create_workspace = add_command("create-workspace", "--workspace-id")
create_workspace.add_argument("--thread-id")
create_workspace.add_argument("--target-path")
create_workspace.add_argument("--target-title")
@@ -46,69 +51,44 @@ def parse_args(description: str) -> argparse.Namespace:
add_user_context(create_workspace)
create_workspace.add_argument("--scope")
create_workspace.add_argument("--mode", choices=MODES, default="standard")
- create_workspace.add_argument("--diff-target-kind", choices=DIFF_TARGET_KINDS)
- create_workspace.add_argument("--diff-base-revision")
- create_workspace.add_argument("--diff-head-revision")
- create_workspace.add_argument("--diff-content-digest")
- get_workspace = subparsers.add_parser("get-workspace")
- get_workspace.add_argument("--workspace-id", required=True)
+ get_workspace = add_command("get-workspace", "--workspace-id")
get_workspace.add_argument("--thread-id")
- inspect_target = subparsers.add_parser("inspect-target")
- inspect_target.add_argument("--target-path", required=True)
+ add_command("inspect-target", "--target-path")
- inspect_setup = subparsers.add_parser("inspect-setup")
- inspect_setup.add_argument("--target-path", required=True)
- inspect_setup.add_argument("--scope", required=True)
+ inspect_setup = add_command("inspect-setup", "--target-path", "--scope")
inspect_setup.add_argument("--mode", choices=MODES, required=True)
- inspect_setup.add_argument("--diff-target-kind", choices=DIFF_TARGET_KINDS)
- inspect_setup.add_argument("--diff-base-revision")
- inspect_setup.add_argument("--diff-head-revision")
- inspect_setup.add_argument("--diff-content-digest")
-
- save_workspace = subparsers.add_parser("save-workspace")
- save_workspace.add_argument("--workspace-id", required=True)
- save_workspace.add_argument("--target-path", required=True)
- save_workspace.add_argument("--scope", required=True)
+
+ save_workspace = add_command("save-workspace", "--workspace-id", "--target-path", "--scope")
save_workspace.add_argument("--mode", choices=MODES, required=True)
save_workspace.add_argument("--target-summary")
add_user_context(save_workspace)
- save_workspace.add_argument("--diff-target-kind", choices=DIFF_TARGET_KINDS)
- save_workspace.add_argument("--diff-base-revision")
- save_workspace.add_argument("--diff-head-revision")
- save_workspace.add_argument("--diff-content-digest")
-
- start_scan = subparsers.add_parser("start-scan")
- start_scan.add_argument("--workspace-id", required=True)
- start_scan.add_argument("--scan-root")
- start_scan.add_argument("--model")
- start_scan.add_argument("--reasoning-effort")
-
- start_prompt_only_scan = subparsers.add_parser("start-prompt-only-scan")
- start_prompt_only_scan.add_argument("--thread-id", required=True)
- start_prompt_only_scan.add_argument("--target-path", required=True)
- start_prompt_only_scan.add_argument("--scope", required=True)
+
+ start_scan = add_command("start-scan", "--workspace-id")
+
+ start_prompt_only_scan = add_command(
+ "start-prompt-only-scan", "--thread-id", "--target-path", "--scope"
+ )
start_prompt_only_scan.add_argument("--mode", choices=("diff", "standard"), required=True)
start_prompt_only_scan.add_argument("--target-summary")
add_user_context(start_prompt_only_scan)
- start_prompt_only_scan.add_argument("--diff-target-kind", choices=DIFF_TARGET_KINDS)
- start_prompt_only_scan.add_argument("--diff-base-revision")
- start_prompt_only_scan.add_argument("--diff-head-revision")
- start_prompt_only_scan.add_argument("--diff-content-digest")
- start_prompt_only_scan.add_argument("--scan-root")
- start_prompt_only_scan.add_argument("--model")
- start_prompt_only_scan.add_argument("--reasoning-effort")
-
- start_headless_standard_scan = subparsers.add_parser("start-headless-standard-scan")
- start_headless_standard_scan.add_argument("--thread-id", required=True)
- start_headless_standard_scan.add_argument("--target-path", required=True)
- start_headless_standard_scan.add_argument("--scope", required=True)
+ # Place shared options after each command's preceding arguments to preserve help order.
+ for diff_parser in (create_workspace, inspect_setup, save_workspace, start_prompt_only_scan):
+ diff_parser.add_argument("--diff-target-kind", choices=DIFF_TARGET_KINDS)
+ diff_parser.add_argument("--diff-base-revision")
+ diff_parser.add_argument("--diff-head-revision")
+ diff_parser.add_argument("--diff-content-digest")
+
+ start_headless_standard_scan = add_command(
+ "start-headless-standard-scan", "--thread-id", "--target-path", "--scope"
+ )
start_headless_standard_scan.add_argument("--target-summary")
add_user_context(start_headless_standard_scan)
- start_headless_standard_scan.add_argument("--scan-root")
- start_headless_standard_scan.add_argument("--model")
- start_headless_standard_scan.add_argument("--reasoning-effort")
+ for scan_parser in (start_scan, start_prompt_only_scan, start_headless_standard_scan):
+ scan_parser.add_argument("--scan-root")
+ scan_parser.add_argument("--model")
+ scan_parser.add_argument("--reasoning-effort")
start_headless_standard_scan.set_defaults(
mode="standard",
diff_target_kind=None,
@@ -119,19 +99,14 @@ def parse_args(description: str) -> argparse.Namespace:
deep_scan.register_subcommands(subparsers, positive_int)
- get_scan = subparsers.add_parser("get-scan")
- get_scan.add_argument("--scan-id", required=True)
+ get_scan = add_command("get-scan", "--scan-id")
get_scan.add_argument("--occurrence-id")
- rename_scan = subparsers.add_parser("rename-scan")
- rename_scan.add_argument("--scan-id", required=True)
- rename_scan.add_argument("--name", required=True)
+ add_command("rename-scan", "--scan-id", "--name")
- get_scan_feedback = subparsers.add_parser("get-scan-feedback")
- get_scan_feedback.add_argument("--scan-id", required=True)
+ add_command("get-scan-feedback", "--scan-id")
- update_scan_context = subparsers.add_parser("update-scan-context")
- update_scan_context.add_argument("--scan-id", required=True)
+ update_scan_context = add_command("update-scan-context", "--scan-id")
add_user_context(update_scan_context, required=True)
update_scan_context_owner = update_scan_context.add_mutually_exclusive_group(required=True)
update_scan_context_owner.add_argument("--workspace-id")
@@ -148,13 +123,10 @@ def parse_args(description: str) -> argparse.Namespace:
list_scans.add_argument("--offset", type=deep_scan.non_negative_int, default=0)
list_scans.add_argument("--limit", type=positive_int)
- list_unmatched_scan_pairs = subparsers.add_parser("list-unmatched-scan-pairs")
- list_unmatched_scan_pairs.add_argument("--repository", required=True)
+ list_unmatched_scan_pairs = add_command("list-unmatched-scan-pairs", "--repository")
list_unmatched_scan_pairs.add_argument("--force", action="store_true")
- register_cli_scan = subparsers.add_parser("register-cli-scan")
- register_cli_scan.add_argument("--scan-dir", required=True)
- register_cli_scan.add_argument("--repository", required=True)
+ register_cli_scan = add_command("register-cli-scan", "--scan-dir", "--repository")
recipe = register_cli_scan.add_mutually_exclusive_group(required=True)
recipe.add_argument("--recipe-json")
recipe.add_argument("--recipe-json-stdin", action="store_true")
@@ -167,24 +139,17 @@ def parse_args(description: str) -> argparse.Namespace:
)
register_cli_scan.add_argument("--archived-scan-dir")
- set_scan_thread = subparsers.add_parser("set-scan-thread")
- set_scan_thread.add_argument("--scan-id", required=True)
- set_scan_thread.add_argument("--thread-id", required=True)
+ add_command("set-scan-thread", "--scan-id", "--thread-id")
- set_scan_cost_limit = subparsers.add_parser("set-scan-cost-limit")
- set_scan_cost_limit.add_argument("--scan-id", required=True)
+ set_scan_cost_limit = add_command("set-scan-cost-limit", "--scan-id")
set_scan_cost_limit.add_argument("--max-cost-usd", required=True, type=float)
- get_scan_recipe = subparsers.add_parser("get-scan-recipe")
- get_scan_recipe.add_argument("--scan-id", required=True)
+ add_command("get-scan-recipe", "--scan-id")
- get_cli_scan_resume = subparsers.add_parser("get-cli-scan-resume")
- get_cli_scan_resume.add_argument("--scan-id", required=True)
+ get_cli_scan_resume = add_command("get-cli-scan-resume", "--scan-id")
get_cli_scan_resume.add_argument("--allow-unavailable", action="store_true")
- compare_scans = subparsers.add_parser("compare-scans")
- compare_scans.add_argument("--before-scan-id", required=True)
- compare_scans.add_argument("--after-scan-id", required=True)
+ compare_scans = add_command("compare-scans", "--before-scan-id", "--after-scan-id")
compare_scans.add_argument("--include-matching-inputs", action="store_true")
compare_scans.add_argument("--require-matches", action="store_true")
@@ -212,16 +177,14 @@ def parse_args(description: str) -> argparse.Namespace:
list_repositories.add_argument("--offset", type=deep_scan.non_negative_int, default=0)
list_repositories.add_argument("--limit", type=positive_int)
- list_findings = subparsers.add_parser("list-findings")
- list_findings.add_argument("--scan-id", required=True)
+ list_findings = add_command("list-findings", "--scan-id")
list_findings.add_argument("--query")
list_findings.add_argument("--severity", choices=FINDING_SEVERITIES)
list_findings.add_argument("--status", choices=FINDING_STATUSES)
list_findings.add_argument("--offset", type=deep_scan.non_negative_int, default=0)
list_findings.add_argument("--limit", type=positive_int, default=FINDINGS_PAGE_MAX)
- update_progress = subparsers.add_parser("update-progress")
- update_progress.add_argument("--scan-id", required=True)
+ update_progress = add_command("update-progress", "--scan-id")
update_progress.add_argument("--phase", choices=PHASES)
update_progress.add_argument("--phase-items-total", type=deep_scan.non_negative_int)
update_progress.add_argument("--phase-items-completed", type=deep_scan.non_negative_int)
@@ -238,33 +201,27 @@ def parse_args(description: str) -> argparse.Namespace:
update_progress.add_argument("--model")
update_progress.add_argument("--reasoning-effort")
- prepare_scan_completion = subparsers.add_parser("prepare-scan-completion")
- prepare_scan_completion.add_argument("--scan-id", required=True)
+ prepare_scan_completion = add_command("prepare-scan-completion", "--scan-id")
prepare_scan_completion.add_argument("--claim-token")
- complete_scan = subparsers.add_parser("complete-scan")
- complete_scan.add_argument("--scan-id", required=True)
+ complete_scan = add_command("complete-scan", "--scan-id")
complete_scan.add_argument("--claim-token")
complete_scan.add_argument("--cost-json")
complete_scan.add_argument("--thread-id")
- complete_budget_exhausted_scan = subparsers.add_parser("complete-budget-exhausted-scan")
- complete_budget_exhausted_scan.add_argument("--scan-id", required=True)
- complete_budget_exhausted_scan.add_argument("--cost-json", required=True)
+ complete_budget_exhausted_scan = add_command(
+ "complete-budget-exhausted-scan", "--scan-id", "--cost-json"
+ )
complete_budget_exhausted_scan.add_argument("--message")
- cancel_scan = subparsers.add_parser("cancel-scan")
- cancel_scan.add_argument("--scan-id", required=True)
+ cancel_scan = add_command("cancel-scan", "--scan-id")
cancel_scan.add_argument("--thread-id")
- fail_scan = subparsers.add_parser("fail-scan")
- fail_scan.add_argument("--scan-id", required=True)
- fail_scan.add_argument("--message", required=True)
+ fail_scan = add_command("fail-scan", "--scan-id", "--message")
fail_scan.add_argument("--claim-token")
fail_scan.add_argument("--cost-json")
- preserve_scan = subparsers.add_parser("preserve-scan-results")
- preserve_scan.add_argument("--scan-id", required=True)
+ preserve_scan = add_command("preserve-scan-results", "--scan-id")
preserve_scan.add_argument("--thread-id")
preserve_scan.add_argument("--claim-token")
preserve_scan.add_argument("--coordinator-generation", type=positive_int)
@@ -275,56 +232,37 @@ def parse_args(description: str) -> argparse.Namespace:
)
recover_scan.add_argument("--scan-id", required=True, help="ID of the stopped scan to recover.")
- write_scan_draft = subparsers.add_parser("write-scan-draft")
- write_scan_draft.add_argument("--scan-id", required=True)
- write_scan_draft.add_argument("--draft-path", required=True)
+ write_scan_draft = add_command("write-scan-draft", "--scan-id", "--draft-path")
write_scan_draft.add_argument("--checkpoint-path")
write_scan_draft.add_argument("--expected-draft-digest")
write_scan_draft.add_argument("--claim-token")
- save_scan_artifact = subparsers.add_parser("save-scan-artifact")
- save_scan_artifact.add_argument("--scan-id", required=True)
- save_scan_artifact.add_argument("--artifact-path", required=True)
+ save_scan_artifact = add_command("save-scan-artifact", "--scan-id", "--artifact-path")
save_scan_artifact.add_argument("--claim-token")
for command in ("save-artifact", "read-artifact"):
- artifact = subparsers.add_parser(command)
- artifact.add_argument("--artifact-root", required=True)
- artifact.add_argument("--artifact-path", required=True)
+ add_command(command, "--artifact-root", "--artifact-path")
- mark_handoff_delivered = subparsers.add_parser("mark-handoff-delivered")
- mark_handoff_delivered.add_argument("--scan-id", required=True)
- mark_handoff_delivered.add_argument("--claim-token", required=True)
+ mark_handoff_delivered = add_command("mark-handoff-delivered", "--scan-id", "--claim-token")
mark_handoff_delivered.add_argument("--thread-id")
- claim_handoff_delivery = subparsers.add_parser("claim-handoff-delivery")
- claim_handoff_delivery.add_argument("--scan-id", required=True)
- claim_handoff_delivery.add_argument("--claim-token", required=True)
+ claim_handoff_delivery = add_command("claim-handoff-delivery", "--scan-id", "--claim-token")
claim_handoff_delivery.add_argument("--take-over-stale", action="store_true")
- release_handoff_delivery = subparsers.add_parser("release-handoff-delivery")
- release_handoff_delivery.add_argument("--scan-id", required=True)
- release_handoff_delivery.add_argument("--claim-token", required=True)
+ add_command("release-handoff-delivery", "--scan-id", "--claim-token")
- attach_scan_continuation_thread = subparsers.add_parser("attach-scan-continuation-thread")
- attach_scan_continuation_thread.add_argument("--scan-id", required=True)
- attach_scan_continuation_thread.add_argument("--claim-token", required=True)
- attach_scan_continuation_thread.add_argument("--thread-id", required=True)
+ add_command("attach-scan-continuation-thread", "--scan-id", "--claim-token", "--thread-id")
- set_finding_triage = subparsers.add_parser("set-finding-triage")
- set_finding_triage.add_argument("--occurrence-id", required=True)
+ set_finding_triage = add_command("set-finding-triage", "--occurrence-id")
set_finding_triage.add_argument("--status", choices=FINDING_STATUSES, required=True)
set_finding_triage.add_argument("--close-reason", choices=FINDING_CLOSE_REASONS)
set_finding_triage.add_argument("--note")
- request_finding_remediation = subparsers.add_parser("request-finding-remediation")
- request_finding_remediation.add_argument("--occurrence-id", required=True)
- request_finding_remediation.add_argument("--request-id", required=True)
- request_finding_remediation.add_argument("--action-token", required=True)
+ add_command("request-finding-remediation", "--occurrence-id", "--request-id", "--action-token")
- request_finding_remediation_action = subparsers.add_parser("request-finding-remediation-action")
- request_finding_remediation_action.add_argument("--occurrence-id", required=True)
- request_finding_remediation_action.add_argument("--request-id", required=True)
+ request_finding_remediation_action = add_command(
+ "request-finding-remediation-action", "--occurrence-id", "--request-id"
+ )
request_finding_remediation_action.add_argument(
"--expected-version", type=positive_int, required=True
)
@@ -333,30 +271,17 @@ def parse_args(description: str) -> argparse.Namespace:
)
request_finding_remediation_action.add_argument("--action-token", required=True)
- claim_finding_remediation_resend = subparsers.add_parser("claim-finding-remediation-resend")
- claim_finding_remediation_resend.add_argument("--occurrence-id", required=True)
- claim_finding_remediation_resend.add_argument("--request-id", required=True)
- claim_finding_remediation_resend.add_argument("--action-token", required=True)
-
- mark_finding_remediation_delivered = subparsers.add_parser("mark-finding-remediation-delivered")
- mark_finding_remediation_delivered.add_argument("--occurrence-id", required=True)
- mark_finding_remediation_delivered.add_argument("--request-id", required=True)
- mark_finding_remediation_delivered.add_argument("--action-token", required=True)
-
- release_finding_remediation_claim = subparsers.add_parser("release-finding-remediation-claim")
- release_finding_remediation_claim.add_argument("--occurrence-id", required=True)
- release_finding_remediation_claim.add_argument("--request-id", required=True)
- release_finding_remediation_claim.add_argument("--action-token", required=True)
-
- cancel_remediation = subparsers.add_parser("cancel-finding-remediation-request")
- cancel_remediation.add_argument("--occurrence-id", required=True)
- cancel_remediation.add_argument("--request-id", required=True)
- cancel_remediation.add_argument("--action-token", required=True)
-
- set_finding_remediation = subparsers.add_parser("set-finding-remediation")
- set_finding_remediation.add_argument("--occurrence-id", required=True)
- set_finding_remediation.add_argument("--request-id", required=True)
- set_finding_remediation.add_argument("--action-token", required=True)
+ for command in (
+ "claim-finding-remediation-resend",
+ "mark-finding-remediation-delivered",
+ "release-finding-remediation-claim",
+ "cancel-finding-remediation-request",
+ ):
+ add_command(command, "--occurrence-id", "--request-id", "--action-token")
+
+ set_finding_remediation = add_command(
+ "set-finding-remediation", "--occurrence-id", "--request-id", "--action-token"
+ )
set_finding_remediation.add_argument("--expected-version", type=positive_int, required=True)
set_finding_remediation.add_argument(
"--state", choices=REMEDIATION_UPDATE_STATES, required=True
@@ -367,8 +292,7 @@ def parse_args(description: str) -> argparse.Namespace:
set_finding_remediation.add_argument("--base-revision")
set_finding_remediation.add_argument("--verification-summary")
- export_findings = subparsers.add_parser("export-findings")
- export_findings.add_argument("--scan-id", required=True)
+ export_findings = add_command("export-findings", "--scan-id")
export_findings.add_argument(
"--artifact", choices=("findings", "threat-model"), default="findings"
)
@@ -380,15 +304,13 @@ def parse_args(description: str) -> argparse.Namespace:
"prepare-linear-publication",
"record-linear-publications",
):
- publication = subparsers.add_parser(command)
- publication.add_argument("--input-file", required=True)
+ add_command(command, "--input-file")
subparsers.add_parser("database-info")
subparsers.add_parser("finding-workflow")
subparsers.add_parser("local-dedupe")
subparsers.add_parser("severity-classification")
- severity = subparsers.add_parser("read-severity-classification")
- severity.add_argument("--scan-id", required=True)
+ 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 c7a0ffbac..fc09b4e3b 100644
--- a/plugins/codex-security/scripts/workbench_db.py
+++ b/plugins/codex-security/scripts/workbench_db.py
@@ -19,6 +19,7 @@ import uuid
from collections.abc import Callable
from contextlib import closing, contextmanager, nullcontext
from datetime import datetime, timedelta, timezone
+from functools import partial
from pathlib import Path, PurePosixPath
from types import SimpleNamespace
from typing import Any
@@ -3332,40 +3333,72 @@ def main(*, before_archive: Callable[[], None] | None = None) -> None:
connect(deferred=args.command in {"get-scan", "list-scans", "database-info"})
) as connection:
remediation_state.require_available(connection, args, require_scan)
- if args.command == "create-workspace":
- result = create_workspace(connection, args)
+ handlers = {
+ "create-workspace": create_workspace,
+ "save-workspace": save_workspace,
+ "start-scan": start_scan,
+ "begin-deep-scan": deep_scan.begin_deep_scan,
+ "get-deep-scan": deep_scan.get_deep_scan,
+ "claim-deep-scan-coordinator": deep_scan.claim_deep_scan_coordinator,
+ "upsert-deep-scan-worker": deep_scan.upsert_deep_scan_worker,
+ "claim-deep-scan-dedup": deep_scan.claim_deep_scan_dedup,
+ "commit-deep-scan-dedup": deep_scan.commit_deep_scan_dedup,
+ "finish-deep-scan": deep_scan.finish_deep_scan,
+ "fail-deep-scan": deep_scan.fail_deep_scan,
+ "record-deep-scan-publication-failure": deep_scan.record_deep_scan_publication_failure,
+ "list-scans": scan_history.list_scans,
+ "register-cli-scan": partial(register_cli_scan, before_archive=before_archive),
+ "set-scan-thread": set_scan_thread,
+ "set-scan-cost-limit": set_scan_cost_limit,
+ "list-global-findings": native_indexes.list_global_findings,
+ "list-repositories": native_indexes.list_repositories,
+ "list-findings": list_findings,
+ "complete-budget-exhausted-scan": complete_budget_exhausted_scan,
+ "set-finding-triage": set_finding_triage,
+ "request-finding-remediation": request_finding_remediation,
+ "request-finding-remediation-action": request_finding_remediation_action,
+ "claim-finding-remediation-resend": claim_finding_remediation_resend,
+ "mark-finding-remediation-delivered": mark_finding_remediation_delivered,
+ "release-finding-remediation-claim": release_finding_remediation_claim,
+ "set-finding-remediation": set_finding_remediation,
+ "update-progress": partial(progress.update_progress, command_context),
+ "update-scan-context": partial(progress.update_context, command_context),
+ "cancel-scan": partial(saved_results.cancel_scan, _WORKBENCH_DB_CONTEXT),
+ "fail-scan": partial(saved_results.fail_scan, _WORKBENCH_DB_CONTEXT),
+ "preserve-scan-results": partial(
+ saved_results.preserve_scan_results, _WORKBENCH_DB_CONTEXT
+ ),
+ "recover-scan-results": partial(
+ saved_results.recover_scan_results, _WORKBENCH_DB_CONTEXT
+ ),
+ "write-scan-draft": partial(saved_results.write_scan_draft, _WORKBENCH_DB_CONTEXT),
+ "save-scan-artifact": partial(saved_results.save_scan_artifact, _WORKBENCH_DB_CONTEXT),
+ "mark-handoff-delivered": partial(handoff.mark_handoff_delivered, command_context),
+ "claim-handoff-delivery": partial(handoff.claim_handoff_delivery, command_context),
+ "release-handoff-delivery": partial(handoff.release_handoff_delivery, command_context),
+ "attach-scan-continuation-thread": partial(
+ handoff.attach_scan_continuation_thread, command_context
+ ),
+ "prepare-linear-publication": partial(
+ publication.prepare_linear_publication, _WORKBENCH_PUBLICATION_CONTEXT
+ ),
+ "record-linear-publications": partial(
+ publication.record_linear_publications, _WORKBENCH_PUBLICATION_CONTEXT
+ ),
+ "export-findings": partial(publication.export_findings, _WORKBENCH_PUBLICATION_CONTEXT),
+ }
+ if handler := handlers.get(args.command):
+ result = handler(connection, args)
elif args.command == "get-workspace":
result = workspace_state(
connection,
args.workspace_id,
thread_id=args.thread_id,
)
- elif args.command == "save-workspace":
- result = save_workspace(connection, args)
- elif args.command == "start-scan":
- result = start_scan(connection, args)
elif args.command == "start-prompt-only-scan":
result = _start_prompt_driven_scan(connection, args, headless_standard=False)
elif args.command == "start-headless-standard-scan":
result = _start_prompt_driven_scan(connection, args, headless_standard=True)
- elif args.command == "begin-deep-scan":
- result = deep_scan.begin_deep_scan(connection, args)
- elif args.command == "get-deep-scan":
- result = deep_scan.get_deep_scan(connection, args)
- elif args.command == "claim-deep-scan-coordinator":
- result = deep_scan.claim_deep_scan_coordinator(connection, args)
- elif args.command == "upsert-deep-scan-worker":
- result = deep_scan.upsert_deep_scan_worker(connection, args)
- elif args.command == "claim-deep-scan-dedup":
- result = deep_scan.claim_deep_scan_dedup(connection, args)
- elif args.command == "commit-deep-scan-dedup":
- result = deep_scan.commit_deep_scan_dedup(connection, args)
- elif args.command == "finish-deep-scan":
- result = deep_scan.finish_deep_scan(connection, args)
- elif args.command == "fail-deep-scan":
- result = deep_scan.fail_deep_scan(connection, args)
- elif args.command == "record-deep-scan-publication-failure":
- result = deep_scan.record_deep_scan_publication_failure(connection, args)
elif args.command == "get-scan":
result = scan_context(connection, args.scan_id, args.occurrence_id)
elif args.command == "rename-scan":
@@ -3374,8 +3407,6 @@ def main(*, before_archive: Callable[[], None] | None = None) -> None:
)
elif args.command == "get-scan-feedback":
result = get_scan_feedback(connection, require_scan(connection, args.scan_id))
- elif args.command == "list-scans":
- result = scan_history.list_scans(connection, args)
elif args.command == "list-unmatched-scan-pairs":
result = scan_history.list_unmatched_scan_pairs(
connection,
@@ -3383,12 +3414,6 @@ def main(*, before_archive: Callable[[], None] | None = None) -> None:
backfill_finding_details=backfill_legacy_finding_details,
read_coverage=coverage_for_comparison,
)
- elif args.command == "register-cli-scan":
- result = register_cli_scan(connection, args, before_archive=before_archive)
- elif args.command == "set-scan-thread":
- result = set_scan_thread(connection, args)
- elif args.command == "set-scan-cost-limit":
- result = set_scan_cost_limit(connection, args)
elif args.command == "get-scan-recipe":
result = scan_history.scan_recipe(require_scan(connection, args.scan_id))
elif args.command == "get-cli-scan-resume":
@@ -3422,71 +3447,15 @@ def main(*, before_archive: Callable[[], None] | None = None) -> None:
require_scan=require_scan,
read_coverage=coverage_for_comparison,
)
- elif args.command == "list-global-findings":
- result = native_indexes.list_global_findings(connection, args)
- elif args.command == "list-repositories":
- result = native_indexes.list_repositories(connection, args)
- elif args.command == "list-findings":
- result = list_findings(connection, args)
- elif args.command == "update-progress":
- result = progress.update_progress(command_context, connection, args)
- elif args.command == "update-scan-context":
- result = progress.update_context(command_context, connection, args)
elif args.command in {"prepare-scan-completion", "complete-scan"}:
result = complete_scan(
connection, args, prepare_only=args.command == "prepare-scan-completion"
)
- elif args.command == "complete-budget-exhausted-scan":
- result = complete_budget_exhausted_scan(connection, args)
- elif args.command == "cancel-scan":
- result = saved_results.cancel_scan(_WORKBENCH_DB_CONTEXT, connection, args)
- elif args.command == "fail-scan":
- result = saved_results.fail_scan(_WORKBENCH_DB_CONTEXT, connection, args)
- elif args.command == "preserve-scan-results":
- result = saved_results.preserve_scan_results(_WORKBENCH_DB_CONTEXT, connection, args)
- elif args.command == "recover-scan-results":
- result = saved_results.recover_scan_results(_WORKBENCH_DB_CONTEXT, connection, args)
- elif args.command == "write-scan-draft":
- result = saved_results.write_scan_draft(_WORKBENCH_DB_CONTEXT, connection, args)
- elif args.command == "save-scan-artifact":
- result = saved_results.save_scan_artifact(_WORKBENCH_DB_CONTEXT, connection, args)
- elif args.command == "mark-handoff-delivered":
- result = handoff.mark_handoff_delivered(command_context, connection, args)
- elif args.command == "claim-handoff-delivery":
- result = handoff.claim_handoff_delivery(command_context, connection, args)
- elif args.command == "release-handoff-delivery":
- result = handoff.release_handoff_delivery(command_context, connection, args)
- elif args.command == "attach-scan-continuation-thread":
- result = handoff.attach_scan_continuation_thread(command_context, connection, args)
- elif args.command == "set-finding-triage":
- result = set_finding_triage(connection, args)
- elif args.command == "request-finding-remediation":
- result = request_finding_remediation(connection, args)
- elif args.command == "request-finding-remediation-action":
- result = request_finding_remediation_action(connection, args)
- elif args.command == "claim-finding-remediation-resend":
- result = claim_finding_remediation_resend(connection, args)
- elif args.command == "mark-finding-remediation-delivered":
- result = mark_finding_remediation_delivered(connection, args)
- elif args.command == "release-finding-remediation-claim":
- result = release_finding_remediation_claim(connection, args)
elif args.command == "cancel-finding-remediation-request":
result = scan_context(
connection,
remediation_state.cancel_finding_remediation_request(connection, args),
)
- elif args.command == "set-finding-remediation":
- result = set_finding_remediation(connection, args)
- elif args.command == "prepare-linear-publication":
- result = publication.prepare_linear_publication(
- _WORKBENCH_PUBLICATION_CONTEXT, connection, args
- )
- elif args.command == "record-linear-publications":
- result = publication.record_linear_publications(
- _WORKBENCH_PUBLICATION_CONTEXT, connection, args
- )
- elif args.command == "export-findings":
- result = publication.export_findings(_WORKBENCH_PUBLICATION_CONTEXT, connection, args)
elif args.command == "database-info":
result = {"databasePath": str(database_path())}
elif args.command == "severity-classification":
diff --git a/plugins/codex-security/scripts/workbench_progress.py b/plugins/codex-security/scripts/workbench_progress.py
index 50dd55e80..576c9f0d9 100644
--- a/plugins/codex-security/scripts/workbench_progress.py
+++ b/plugins/codex-security/scripts/workbench_progress.py
@@ -37,7 +37,6 @@ def preflight_issues_json(value: str | None) -> str | None:
raise SystemExit(
f"Preflight issues must be an array of at most {MAX_PREFLIGHT_ISSUES} objects."
)
- normalized: list[dict[str, str]] = []
expected_keys = {"capability", "reason", "severity", "status"}
for index, issue in enumerate(payload):
label = f"{index + 1}"
@@ -49,17 +48,9 @@ def preflight_issues_json(value: str | None) -> str | None:
status = issue.get("status")
if severity not in {"block", "warn"} or status not in {"fail", "unknown"}:
raise SystemExit(f"Preflight issue {label} has an invalid severity or status.")
- normalized.append(
- {
- "capability": _preflight_issue_text(
- issue.get("capability"), 128, f"{label} capability"
- ),
- "reason": _preflight_issue_text(issue.get("reason"), 1200, f"{label} reason"),
- "severity": severity,
- "status": status,
- }
- )
- return json.dumps(normalized, ensure_ascii=True, separators=(",", ":"), sort_keys=True)
+ for field, maximum in (("capability", 128), ("reason", 1200)):
+ issue[field] = _preflight_issue_text(issue.get(field), maximum, f"{label} {field}")
+ return json.dumps(payload, ensure_ascii=True, separators=(",", ":"), sort_keys=True)
def reportable_count(