mirror of
https://github.com/usestrix/strix.git
synced 2026-09-24 00:51:20 +00:00
feat(report): add local false-positive triage in TUI and viewer
This commit is contained in:
bearsyankees
parent
910c1ea4bb
commit
475f4838f6
39 changed files with 4099 additions and 654 deletions
155
docs/design/false-positive-triage.md
Normal file
155
docs/design/false-positive-triage.md
Normal file
|
|
@ -0,0 +1,155 @@
|
|||
# Local false-positive triage
|
||||
|
||||
Design and implementation record, 2026-09-16. Implemented for the local terminal UI and web viewer. This change adds no standalone triage CLI command or Cloud behavior.
|
||||
|
||||
**User experience**
|
||||
|
||||
The finding detail offers **False positive (f)** in the terminal UI and **Mark as false positive** in the web viewer. Users can close a finding with an optional reason and local note, see **Closed · False positive**, and use **Undo** or **Reopen**. Closing works offline and with telemetry disabled. The original finding is preserved, with the human decision stored separately.
|
||||
|
||||
When telemetry is enabled, a small classification event follows a successfully saved decision. Written explanations and finding content stay local. The telemetry policy and feature docs describe this collection; the terminal UI and web viewer contain no telemetry copy, indicators, prompts or toggles. Detailed examples for improving detection belong in a separate, explicit sharing flow.
|
||||
|
||||
**Findings from the initial investigation**
|
||||
|
||||
| Area | Observed behavior | Implication |
|
||||
| --- | --- | --- |
|
||||
| Local viewer | The finding detail renders a status badge and banners, but offers no mutation. `parseOneVulnerability` hardcodes `open` and discards status metadata. | Adding a button alone will not persist a decision. Both the data path and UI need changes. |
|
||||
| Finding storage | `ReportState` owns the findings list, assigns run-local sequential IDs, and rewrites scan artifacts from memory. | Editing `vulnerabilities.json` from the viewer can be overwritten by a live scan or resume. Deleting findings can also undermine ID allocation and deduplication. |
|
||||
| Terminal UI | Its finding collection comes directly from `ReportState`, not the viewer's disk reads. | Native close/reopen commands and the collection projection must use the shared triage service. |
|
||||
| Telemetry | Optional, enabled by default, configured through environment/saved settings. Identity is a random UUID per process. Existing finding events contain severity, CWE and CVE presence. | Respect the effective setting in the backend. There is no existing persistent user/finding identity for longitudinal feedback joins. |
|
||||
| General feedback | The viewer's support form sends a message and email to a remote relay. | It is unsuitable for closing a local issue: closure should require neither email nor a network call. |
|
||||
|
||||
Code anchors: [viewer parser](../../strix/interface/viewer/frontend/src/lib/local-run-parser.ts), [finding detail](../../strix/interface/viewer/frontend/src/components/vulnerability/VulnerabilityDetail.tsx), [report state](../../strix/report/state.py), [terminal collection](../../strix/interface/tui/backend/controller.py), [telemetry policy](../../strix/telemetry/README.md), [feedback form](../../strix/interface/viewer/frontend/src/components/FeedbackView.tsx).
|
||||
|
||||
**The user flow**
|
||||
|
||||
1. Open an issue in the terminal UI or web viewer and choose **Mark as false positive**. The terminal detail has a visible action and keyboard shortcut; the viewer places the action beside the status.
|
||||
2. Show a compact form with a reason selector and a note of up to 2,000 characters, rendered natively in the active interface. Primary action: **Close issue**. No required essay, email, account signup, additional confirmation, browser launch, or scan rerun.
|
||||
3. On successful save, keep the detail open, show **Closed · False positive**, the date and local explanation, and offer **Reopen**. A brief **Undo** action restores the prior state.
|
||||
4. The issue moves out of the active list. Offer **Open / Closed / All**, retaining the original severity and all evidence in the closed view.
|
||||
|
||||
Viewer form copy:
|
||||
|
||||
```text
|
||||
Mark as false positive
|
||||
|
||||
This finding is incorrect or does not apply to your target.
|
||||
Applies to this finding in this run.
|
||||
|
||||
Reason (optional) [ Select a reason ]
|
||||
Note (optional) [ Add context for your future review ]
|
||||
|
||||
[Cancel] [Close issue]
|
||||
```
|
||||
|
||||
Reason choices: **Incorrect assumption**, **Existing protection prevents the reported exploit**, **Code or dependency is not affected**, **Expected behavior, not a vulnerability**, and **Other**. Omission becomes `unspecified`. These are user assessments. Inconclusive reproduction alone should not be offered as a false-positive reason; provide “Not sure? Keep open for review” as the form's cancel path. Accepted residual risk belongs under accepted risk, even when a mitigation exists.
|
||||
|
||||
The form, status banner, terminal footer and success messages contain no telemetry disclosure or controls. Keep that information in documentation. The backend still honors the effective telemetry setting and never enables it as a side effect of closing.
|
||||
|
||||
Display counts such as **8 open · 2 false positives · 10 found**. Never count false-positive closures as fixes or show “no vulnerabilities found” when findings were dismissed. If every issue is closed, use “No open findings. 2 marked as false positives.”
|
||||
|
||||
A save failure keeps the original state and preserves entered text for retry. An ambiguous response triggers a read of the saved state before another mutation. Keep focus and selection on the reviewed finding instead of making the page jump when it leaves the active list.
|
||||
|
||||
**Local status semantics**
|
||||
|
||||
| User meaning | Status | Structured resolution |
|
||||
| --- | --- | --- |
|
||||
| Awaiting action | `open` | none |
|
||||
| Incorrect finding | `closed` | `false_positive` |
|
||||
|
||||
Use `resolution_reason: false_positive` and a separate optional `reason_code` for the form's category. Keep lifecycle status separate from the reason for closing. The first release offers this false-positive resolution and reopening; accepted-risk and fixed workflows are not required. Never infer false positives from another status or prose notes. Reopening clears the current resolution but preserves history. A user label is not an independently verified scanner error.
|
||||
|
||||
**Persistence and integration**
|
||||
|
||||
A shared local triage service handles viewer mutations, native terminal commands and the terminal projection. It stores a versioned `triage.json` alongside the run artifacts, keyed by the real finding ID within that run and including the run identity in the document. Legacy runs without this file remain open. Mutations of missing, duplicate or synthetic finding IDs are rejected.
|
||||
|
||||
Each decision records current status, resolution reason, reason code, optional note, timestamp, revision, and an audit history of transitions. The actor label is `local_operator`; do not collect an OS username or imply a verified human identity. Record the reviewed finding revision/digest locally so material evidence changes can be detected. Local digests must never enter telemetry.
|
||||
|
||||
Protect read-modify-write with a stable per-run cross-process lock and a thread lock, write a temporary file, then atomically replace it. Lock a separate lockfile: replacing the data file must not replace the inode being locked. Validate an expected revision to reject stale edits. If a platform cannot provide the required locking, fail the mutation clearly rather than silently proceeding without it.
|
||||
|
||||
The scanner continues to own its original reports, IDs and dedupe inputs. Human triage is not an agent-editable reporting field. Compose the latest triage into reads instead of copying it into the agent's mutable finding dictionary. Closing cannot cause resume or dedupe to re-report the same finding as a new issue.
|
||||
|
||||
The viewer uses `POST /api/vulnerabilities/{id}/triage?run=<run>` with both the expected triage revision and the digest of the finding the user reviewed, returning the saved record. A changed finding while the form was open must require fresh review. Reuse the process session capability and run authorization, enforce same-origin browser writes, bound request/note sizes, and reject traversal or symlink escape for writable paths. A note is untrusted text in HTML, terminal and exported reports. Local closure of the launched run needs no email verification; preserve the existing access rule when selecting historical runs through the viewer.
|
||||
|
||||
Update the parser, detail controls, active/closed filtering and every displayed count. The terminal backend must read the same overlay and expose native close/reopen commands through its existing command protocol. The terminal finding detail gets a keyboard-accessible action, an optional reason/note form, save errors, Undo and Reopen. Terminal badges, counts, filters and copied reports reflect the same saved decisions. This flow works entirely inside the terminal; **Ctrl+O** remains an optional way to view the run in a browser.
|
||||
|
||||
Terminal controls: **F2** opens findings, including on narrow terminals where the sidebar is hidden. **f** opens the false-positive form, **r** reopens a closed finding, and **u** undoes a recent change, scoped to the finding-detail modal. In the detail or focused findings panel, **v** cycles **Open / Closed / All** so closed findings remain reachable. If the current filter is empty, **F2** opens All. Show focusable buttons as well as these shortcuts; preserve **c** to copy, arrow navigation, **Tab / Shift+Tab** to move button focus, **Enter** to activate and **Esc** to go back. Use a separate form state for reason/note input so typing `f`, `r` or `v` cannot trigger a mutation, and preserve the scan composer's draft. See [native triage controls](../../strix/interface/tui/internal/app/triage.go).
|
||||
|
||||
The `vulnerability.triage` command in the [terminal backend dispatcher](../../strix/interface/tui/backend/controller.py) handles the native controls. Its request carries the real finding ID, desired status, resolution reason, optional reason/note, expected triage revision and reviewed finding digest. The run is resolved from the terminal session. Saved state returns through the existing request/result protocol, and the collection refreshes only after success. Pending/error state is bound to the finding ID, not its list index. Closing or reopening never sends a chat message to the pentesting agent.
|
||||
|
||||
The web viewer refreshes on mutation, window focus and run switch, and checks a small file revision token to pick up terminal or other-tab changes, including for finished runs. The terminal's sidecar revision watcher notifies it of viewer edits even when the scanner is idle. Older in-flight updates cannot overwrite newer successful mutations. UI updates remain scoped to run ID and finding ID when users switch runs mid-request. Read-only run directories expose an unavailable write capability.
|
||||
|
||||
**Scope, later evidence and reports**
|
||||
|
||||
V1 dismissal applies to one finding in one run and survives restarts/resume. A new scan may rediscover it. Do not silently suppress another finding by title, CWE or file alone. The existing SARIF fingerprints are useful matching inputs, but they do not establish safe cross-scan identity for changing AI-generated findings.
|
||||
|
||||
If an agent materially changes the evidence or affected location under an already-reviewed ID, preserve the saved human decision in `triage_status` but project `review_stale: true` and `status: open`. Show **Needs review** in the Open filter and active counts, excluding it from closed counts. Reclosing requires a fresh reviewed digest and creates a new review even if its status/reason are unchanged. This derived staleness is not a human reopen event. Presentation-only edits should not invalidate review. Compare structured evidence/claim inputs, not just the title.
|
||||
|
||||
The original scan report and artifacts remain available with an explicit “Original scan report” label. Current triage counts appear beside that report so its original narrative is not mistaken for today's open issue count. The emailed PDF's send/download action, filename and document cover identify it as the original scan report, say subsequent triage is excluded, and label counts as detected findings. The current PDF reads the original findings directly ([PDF generation](../../strix/interface/viewer/report_pdf.py)).
|
||||
|
||||
A later curated export should include open findings and an appendix of closed findings/reasons with a triage-as-of timestamp. Freeform notes should be included only when the user selects that export option. Generate exports from one consistent triage revision.
|
||||
|
||||
Preserve the original `findings.sarif`. A separately named triaged SARIF export can represent external suppressions where supported, or offer an explicitly selected active-only export. Do not claim that SARIF suppression metadata closes existing GitHub alerts: consumer support and native alert updates need separate verification. Do not retroactively alter a scan's exit code, completion status or coverage assessment after human triage.
|
||||
|
||||
**Telemetry contract**
|
||||
|
||||
Use PostHog for the richer event through the existing gate. There is no need to duplicate a new classification event across both analytics vendors in v1. Emit from the triage service after a successful, real transition, not from a click handler or the generic `/api/event` endpoint. The latter is currently unauthenticated and cannot prove that a decision was saved; the authenticated successful-feedback handler is a better precedent. See [server events](../../strix/interface/viewer/server.py) and [feedback completion](../../strix/interface/viewer/server.py).
|
||||
|
||||
Classification event:
|
||||
|
||||
```json
|
||||
{
|
||||
"event": "finding_triage_changed",
|
||||
"properties": {
|
||||
"schema_version": 1,
|
||||
"surface": "viewer",
|
||||
"previous_status": "open",
|
||||
"new_status": "closed",
|
||||
"previous_resolution_reason": null,
|
||||
"resolution_reason": "false_positive",
|
||||
"reason_code": "incorrect_assumption",
|
||||
"severity": "high",
|
||||
"cwe": "cwe-79",
|
||||
"is_cve": false,
|
||||
"scan_mode": "standard"
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Reuse current common app-version/OS properties and the process-only anonymous session identifier. `surface` is `viewer` or `tui`. Validate every category against a closed vocabulary, and validate CWE syntax. Derive classification attributes from persisted data on the backend. Do not forward arbitrary interface fields or arbitrary strings from findings. Missing legacy metadata is `unknown` or omitted.
|
||||
|
||||
Exclude notes, titles, descriptions, PoCs, evidence, source code, email, targets, paths, URLs, run names, finding IDs and target-derived hashes. Do not attach the viewer's current model as if it produced an old scan. Model/version comparisons require reliable original-scan provenance and an approved bounded model identifier; leave that dimension out until it exists.
|
||||
|
||||
Check the effective telemetry setting before enqueueing and before sending. The sender uses a bounded in-memory background queue; closure should complete without waiting for network timeouts. Delivery may be dropped when the process exits or the queue is full. Failed delivery never reverses the local decision. Do not persist an analytics backlog, replay old triage when telemetry is enabled later, or emit events for read-only loads, failed writes, conflicts and repeated no-op submissions. Notes-only edits need no analytics event. Human reopen, reason-category changes and fresh review of changed evidence are real classification transitions.
|
||||
|
||||
Settings are memoized and resolve environment → saved configuration → defaults. Keep the existing controls; add no UI toggle, setting indicator or telemetry copy. The [telemetry policy](../../strix/telemetry/README.md) and local feature documentation describe the event fields, exclusions, best-effort delivery and `STRIX_TELEMETRY=0` opt-out. See [settings loader](../../strix/config/loader.py), [PostHog gate](../../strix/telemetry/posthog.py), and [identity](../../strix/telemetry/_common.py).
|
||||
|
||||
This yields useful **user-reported false-positive trends** by reason, severity, CWE and Strix version. It does not yield a defensible scanner false-positive rate: later viewer sessions have different identities, no durable finding correlation exists, users self-select what to review, and undo/reopen actions can repeat. Start with transition counts and reason distributions, labeled honestly. A measured precision/FP rate needs a reviewed sample with a denominator and independent validation.
|
||||
|
||||
If detailed examples become necessary, add **Share this finding with Strix** as a separate optional action with a concrete payload preview and deliberate submission. Do not reinterpret enabled basic telemetry as permission to upload content. No backend for this detailed triage submission was verified in this research.
|
||||
|
||||
**Why this interaction**
|
||||
|
||||
The recommendation follows established review workflows while keeping Strix's run scope explicit. GitHub offers dismissal reasons, optional comments, a closed list and reopening; its API separates state from reason. [GitHub alert management](https://docs.github.com/en/code-security/how-tos/manage-security-alerts/manage-code-scanning-alerts/resolve-alerts), [GitHub alert update API](https://docs.github.com/en/rest/code-scanning/code-scanning#update-a-code-scanning-alert).
|
||||
|
||||
Semgrep distinguishes false positives, accepted risk and deferral, and keeps fixed separate. Snyk explicitly names repository-wide ignore scope and supports undoing it. Those are good precedents for precise labels and visible scope, but cross-scan persistence requires identity support Strix has not yet established. [Semgrep triage](https://semgrep.dev/docs/for-developers/resolve-findings-through-app), [Snyk consistent ignores](https://docs.snyk.io/manage-risk/prioritize-issues-for-fixing/ignore-issues/consistent-ignores-for-snyk-code).
|
||||
|
||||
Semgrep's metrics documentation also separates counts from source content and warns that deterministic hashes can be pseudonymous. That supports a minimal metadata event rather than uploading the dismissed report. [Semgrep metrics](https://docs.semgrep.dev/metrics).
|
||||
|
||||
**Delivery and acceptance**
|
||||
|
||||
The implementation includes the local triage service, native terminal close/reopen flow, viewer flow, terminal status projection, original-report labeling (including the emailed PDF), consent-gated metadata event and documentation. Decisions are durable and reversible across both local interfaces. Curated exports, bulk triage, detailed sharing and cross-scan carryover can follow as separate changes.
|
||||
|
||||
Acceptance checks:
|
||||
|
||||
- Close, reload, restart viewer, resume scan and reopen all preserve evidence, IDs, decisions and audit history.
|
||||
- A live scan artifact rewrite cannot erase triage; simultaneous terminal and viewer edits either serialize or return a conflict without losing decisions.
|
||||
- Close and reopen directly inside the terminal, with optional reason/note input, without starting a web viewer. The web viewer reads those same decisions, and viewer changes appear in the terminal.
|
||||
- Active/closed counts, the selected detail, terminal output and report labels agree. A materially changed finding becomes active for review.
|
||||
- Unknown findings, duplicate IDs, stale revisions, malformed sidecars, unauthorized/cross-origin requests, path escapes, read-only directories and interrupted writes cannot produce a successful closure.
|
||||
- Telemetry disabled through either environment or saved settings causes zero analytics HTTP calls while closure and reopening still succeed.
|
||||
- Sentinel secrets in every freeform field never appear in event payloads; malformed categories cannot bypass allowlisting.
|
||||
- Telemetry failure cannot delay/fail closure; failed/no-op mutations emit nothing; re-enabling telemetry never replays prior disabled actions.
|
||||
- Both interfaces omit telemetry copy, prompts and indicators. Documentation describes the collection and opt-out accurately.
|
||||
- Keyboard/focus behavior, small screens, errors and live-poll/run-switch races work. Build/type-check the viewer and run the relevant Python/Go tests plus repository checks.
|
||||
|
||||
Implementation lives in the [shared triage service](../../strix/report/triage.py), [atomic store](../../strix/report/triage_store.py), [native terminal controls](../../strix/interface/tui/internal/app/triage.go), [viewer controls](../../strix/interface/viewer/frontend/src/components/vulnerability/TriageControls.tsx), and [classification telemetry](../../strix/telemetry/triage.py). Tests cover local persistence and real scanner resume, simultaneous processes, invalid storage and failed writes, authenticated viewer and native terminal mutations, and the telemetry network boundary. Synthetic browser and real 80×24 PTY workflows were exercised; original PDF pages were rendered and visually checked. No pentest or cloud account mutation was required.
|
||||
|
|
@ -155,6 +155,16 @@ strix --target ./my-project --workspace-file ./wordlist.txt
|
|||
strix --target https://app.com --workspace-file ./openapi.yaml:specs/openapi.yaml
|
||||
```
|
||||
|
||||
## Reviewing Findings In The Terminal
|
||||
|
||||
In the interactive terminal UI, press **F2** to open findings, then **f** to mark one as a false positive, **r** to reopen it, or **u** to undo a recent change. You can also click **False positive (f)** in the finding detail. The native form accepts an optional reason and note of up to 2,000 characters. In the finding detail or focused findings panel, press **v** to cycle **Open / Closed / All**. The same actions are available through focusable buttons; **Tab / Shift+Tab** moves focus, **Enter** activates a button, and **Esc** goes back. **c** still copies the finding, and **Ctrl+O** opens the optional web viewer.
|
||||
|
||||
Triage applies to one finding in one run and is saved in the run's `triage.json`. It survives restarts and scan resume, and is visible in the terminal and [local web viewer](/usage/viewer#marking-false-positives). Closing preserves the finding's severity and evidence. A new scan has its own review state; material changes to a closed finding show **Needs review** and return it to the Open filter while preserving the previous decision. The original scan artifacts and emailed **Original scan report** PDF retain all detected findings and exclude subsequent local triage.
|
||||
|
||||
Closing and reopening work with telemetry disabled. When enabled, the existing telemetry setting permits an asynchronous, best-effort classification event containing only the interface, status/resolution transition, reason category, severity, CWE, CVE presence, scan mode, and common system/version information. Written notes, finding content, targets, run and finding IDs, and local digests are excluded. Actions taken with telemetry disabled are not sent later. Set `STRIX_TELEMETRY=0` before starting Strix to opt out.
|
||||
|
||||
Triage decisions do not change the original scan's exit code, completion status, or coverage assessment.
|
||||
|
||||
## Exit Codes
|
||||
|
||||
| Code | Meaning |
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ strix view my-run-name # a specific run under ./strix_run
|
|||
strix view --host 0.0.0.0 --port 8080 --no-open
|
||||
```
|
||||
|
||||
The UI ships prebuilt with Strix, so there is no extra install and no JavaScript build step. The dashboard reads the run files straight off disk. Nothing leaves your machine, and you do not need a cloud account.
|
||||
The UI ships prebuilt with Strix, so there is no extra install and no JavaScript build step. The dashboard reads the run files straight off disk. You do not need a cloud account to review or triage the launched run. Anonymous usage telemetry follows your [telemetry setting](/advanced/configuration); emailing a report and sending feedback use the remote services described by those actions.
|
||||
|
||||
## Options
|
||||
|
||||
|
|
@ -33,17 +33,31 @@ The UI ships prebuilt with Strix, so there is no extra install and no JavaScript
|
|||
|
||||
## What Is In The Dashboard
|
||||
|
||||
- **Overview** — run status, target, and a severity breakdown of everything found so far.
|
||||
- **Vulnerabilities** — each validated finding with its severity, details, and reproduction steps.
|
||||
- **Overview** — run status, target, a severity breakdown of open findings, and counts of false positives and total findings detected.
|
||||
- **Vulnerabilities** — each validated finding with its severity, details, and reproduction steps. Mark incorrect findings as false positives, reopen them, and filter by **Open / Closed / All**.
|
||||
- **Agent graph** — a live map of the multi-agent team, and what each agent is doing.
|
||||
- **Steering** — send instructions to a live scan to redirect the agents during the run. Steering works only in the dashboard the running scan opens. A standalone `strix view` has no live scan to steer.
|
||||
- **History** — browse past runs on this machine and move between them. Verify your email address in the dashboard to unlock the other runs.
|
||||
- **Reports** — generate a shareable report and send it by email. Verify your email address first.
|
||||
- **Reports** — generate an **Original scan report** and send it by email. Verify your email address first. This PDF includes all detected findings and excludes subsequent local triage decisions and notes.
|
||||
|
||||
## Marking False Positives
|
||||
|
||||
Open a finding and choose **Mark as false positive** when it is incorrect or does not apply to your target. Choose an optional reason, add an optional note of up to 2,000 characters for future review, and select **Close issue**. The finding shows **Closed · False positive**. Use **Undo** or **Reopen** to reverse the decision.
|
||||
|
||||
The **Open / Closed / All** filters keep closed findings available with their original severity and evidence. Counts distinguish open findings from false positives and the total detected. Closing an issue does not mean it was fixed.
|
||||
|
||||
In the terminal UI, press **F2** to open findings, including on narrow terminals where the sidebar is hidden. In a finding, click **False positive (f)** or press **f** to open the native false-positive form; **r** reopens a closed issue, and **u** undoes a recent change. Use **Tab / Shift+Tab** to move through the optional reason, note and buttons, **Enter** to activate a button, and **Esc** to return. Press **v** in the finding detail or focused findings panel to cycle **Open / Closed / All**. If the selected filter is empty, **F2** opens **All** so closed issues remain accessible. No browser is required.
|
||||
|
||||
Decisions apply to that finding in that run. They are saved locally in `triage.json`, survive restarts and scan resume, and are shared by the viewer and terminal UI. Closing and reopening work offline and with telemetry disabled. They do not require an email address for the launched run. A separate scan starts with its own review state; material changes to a closed finding show **Needs review** and return it to the Open filter while preserving the previous decision.
|
||||
|
||||
The original scan report, emailed PDF, raw finding files, and SARIF retain the scanner's findings. The PDF cover and filename identify it as the **Original scan report**; its counts describe detected findings, including those you later closed. Local decisions do not change the original scan's exit code or coverage assessment.
|
||||
|
||||
When telemetry is enabled, a saved classification change sends anonymous metadata: the interface used, previous and new status and resolution, optional reason category, severity, CWE, CVE presence, scan mode, and common system/version information. Notes, finding content, targets, run and finding IDs, and local digests are excluded. Delivery is asynchronous and best effort; actions taken with telemetry off are not queued for later delivery. Set `STRIX_TELEMETRY=0` to opt out.
|
||||
|
||||
## Sharing The Link
|
||||
|
||||
<Warning>
|
||||
The token in the printed URL grants access to the run data, and to the steering of a live scan. Share it only with trusted users.
|
||||
The token in the printed URL grants access to the run data, changes to local finding triage, and steering of a live scan. Share it only with trusted users.
|
||||
</Warning>
|
||||
|
||||
To reach the viewer from another machine, start it with `--host 0.0.0.0` and replace `0.0.0.0` in the printed URL with a reachable IP address or hostname. Restrict the port with your firewall. A request without the token-derived session cannot read run data.
|
||||
|
|
|
|||
|
|
@ -34,6 +34,20 @@ if TYPE_CHECKING:
|
|||
|
||||
|
||||
_STOPPABLE_AGENT_STATUSES = frozenset({"running", "waiting", "budget_paused"})
|
||||
_TRIAGE_FIELDS = (
|
||||
"status",
|
||||
"triage_status",
|
||||
"resolution_reason",
|
||||
"reason_code",
|
||||
"status_note",
|
||||
"status_changed_at",
|
||||
"status_changed_by",
|
||||
"triage_revision",
|
||||
"finding_digest",
|
||||
"review_stale",
|
||||
"can_triage",
|
||||
"triage_error",
|
||||
)
|
||||
|
||||
ChangeCallback = Callable[[], None]
|
||||
StartCallback = Callable[[], Awaitable[None]]
|
||||
|
|
@ -264,9 +278,29 @@ class TuiController:
|
|||
reports = (
|
||||
self.report_state.vulnerability_reports if self.report_state is not None else []
|
||||
)[-MAX_TERMINAL_VULNERABILITIES:]
|
||||
if self.report_state is not None and hasattr(self.report_state, "get_run_dir"):
|
||||
from strix.report.triage import TriageError, read_triaged_vulnerabilities
|
||||
|
||||
try:
|
||||
reports = read_triaged_vulnerabilities(self.report_state.get_run_dir(), reports)
|
||||
except TriageError as exc:
|
||||
# A broken sidecar must not hide evidence or stop the scan UI.
|
||||
reports = [
|
||||
{**report, "can_triage": False, "triage_error": str(exc)}
|
||||
for report in reports
|
||||
]
|
||||
result: list[dict[str, Any]] = []
|
||||
for index, report in enumerate(reports):
|
||||
projected = collection_item_projection(report)
|
||||
projected = collection_item_projection(
|
||||
{key: value for key, value in report.items() if key != "triage_history"}
|
||||
)
|
||||
# The optional evidence projection may truncate a large finding;
|
||||
# its small revision and write-capability fields must survive.
|
||||
projected.update(
|
||||
terminal_projection(
|
||||
{key: report[key] for key in _TRIAGE_FIELDS if key in report}
|
||||
)
|
||||
)
|
||||
report_id = projected.get("id")
|
||||
if not isinstance(report_id, str) or not report_id:
|
||||
projected["id"] = f"vulnerability-{index}"
|
||||
|
|
@ -303,6 +337,7 @@ class TuiController:
|
|||
"agent.send_message": self._send_message,
|
||||
"agent.stop": self._stop_agent,
|
||||
"viewer.open": self._open_viewer,
|
||||
"vulnerability.triage": self._triage_vulnerability,
|
||||
"app.quit": self._quit,
|
||||
}
|
||||
handler = handlers.get(command)
|
||||
|
|
@ -312,6 +347,47 @@ class TuiController:
|
|||
self.notify_changed()
|
||||
return result
|
||||
|
||||
def triage_stamp(self) -> tuple[int, int] | None:
|
||||
"""Observe external decisions even while the scan has nothing to broadcast."""
|
||||
if self.report_state is None or not hasattr(self.report_state, "get_run_dir"):
|
||||
return None
|
||||
from strix.report.triage import triage_stamp
|
||||
|
||||
return triage_stamp(self.report_state.get_run_dir())
|
||||
|
||||
async def _triage_vulnerability(self, payload: dict[str, Any]) -> dict[str, Any]:
|
||||
from strix.report.triage import TriageError, triage_finding
|
||||
|
||||
if self.report_state is None:
|
||||
raise TriageError("unavailable", "Scan output is not ready")
|
||||
finding_id = self._required_string(payload, "finding_id")
|
||||
status = self._required_string(payload, "status")
|
||||
if payload.get("resolution_reason") not in (None, "false_positive"):
|
||||
raise TriageError("invalid_request", "Unsupported resolution reason")
|
||||
revision = payload.get("expected_revision")
|
||||
digest = payload.get("reviewed_digest")
|
||||
if (
|
||||
not isinstance(revision, int)
|
||||
or isinstance(revision, bool)
|
||||
or not isinstance(digest, str)
|
||||
):
|
||||
raise TriageError("invalid_request", "Review revision and finding digest are required")
|
||||
result = await asyncio.to_thread(
|
||||
triage_finding,
|
||||
self.report_state.get_run_dir(),
|
||||
finding_id,
|
||||
status=status,
|
||||
expected_revision=revision,
|
||||
reviewed_digest=digest,
|
||||
reason_code=payload.get("reason_code", "unspecified"),
|
||||
note=payload.get("note", ""),
|
||||
surface="tui",
|
||||
)
|
||||
# The evidence travels in collection frames; keep the acknowledgement
|
||||
# below the command-result size limit even for very large findings.
|
||||
finding = {key: result["finding"].get(key) for key in ("id", *_TRIAGE_FIELDS)}
|
||||
return {"changed": result["changed"], "finding": terminal_projection(finding)}
|
||||
|
||||
async def _add_target(self, payload: dict[str, Any]) -> dict[str, Any]:
|
||||
self._require_setup_mutable()
|
||||
target = self._required_string(payload, "target")
|
||||
|
|
|
|||
|
|
@ -20,6 +20,7 @@ from strix.interface.tui.backend.protocol import (
|
|||
ProtocolHandshakeError,
|
||||
envelope,
|
||||
)
|
||||
from strix.report.triage import TriageError
|
||||
|
||||
|
||||
if TYPE_CHECKING:
|
||||
|
|
@ -60,6 +61,7 @@ class TuiBackendServer:
|
|||
self._reader_task: asyncio.Task[None] | None = None
|
||||
self._broadcast_event = asyncio.Event()
|
||||
self._broadcast_task: asyncio.Task[None] | None = None
|
||||
self._triage_watch_task: asyncio.Task[None] | None = None
|
||||
self._write_lock = asyncio.Lock()
|
||||
self._sync_lock = asyncio.Lock()
|
||||
self._state_revision = 0
|
||||
|
|
@ -89,10 +91,15 @@ class TuiBackendServer:
|
|||
self.activated = True
|
||||
self._reader_task = asyncio.create_task(self._read_loop())
|
||||
self._broadcast_task = asyncio.create_task(self._broadcast_loop())
|
||||
self._triage_watch_task = asyncio.create_task(self._watch_triage())
|
||||
self.notify_changed()
|
||||
|
||||
async def close(self) -> None:
|
||||
tasks = [task for task in (self._reader_task, self._broadcast_task) if task is not None]
|
||||
tasks = [
|
||||
task
|
||||
for task in (self._reader_task, self._broadcast_task, self._triage_watch_task)
|
||||
if task is not None
|
||||
]
|
||||
for task in tasks:
|
||||
task.cancel()
|
||||
for task in tasks:
|
||||
|
|
@ -102,6 +109,7 @@ class TuiBackendServer:
|
|||
await task
|
||||
self._reader_task = None
|
||||
self._broadcast_task = None
|
||||
self._triage_watch_task = None
|
||||
self._close_socket()
|
||||
|
||||
def _close_socket(self) -> None:
|
||||
|
|
@ -188,6 +196,8 @@ class TuiBackendServer:
|
|||
|
||||
@staticmethod
|
||||
def _structured_error(exc: Exception) -> dict[str, object]:
|
||||
if isinstance(exc, TriageError):
|
||||
return {"code": exc.code, "message": str(exc), "retryable": False}
|
||||
if isinstance(exc, OSError):
|
||||
return {"code": "persistence_error", "message": str(exc), "retryable": True}
|
||||
if isinstance(exc, TypeError | ValueError | json.JSONDecodeError | UnicodeDecodeError):
|
||||
|
|
@ -529,3 +539,15 @@ class TuiBackendServer:
|
|||
self._close_socket()
|
||||
except (ConnectionError, OSError):
|
||||
self._close_socket()
|
||||
|
||||
async def _watch_triage(self) -> None:
|
||||
previous: tuple[int, int] | None = None
|
||||
while True:
|
||||
await asyncio.sleep(0.5)
|
||||
try:
|
||||
current = self.controller.triage_stamp()
|
||||
except (OSError, TriageError):
|
||||
current = None
|
||||
if current != previous:
|
||||
previous = current
|
||||
self.notify_changed()
|
||||
|
|
|
|||
|
|
@ -64,6 +64,7 @@ const (
|
|||
modalStop
|
||||
modalConfirmMount
|
||||
modalVulnerability
|
||||
modalTriage
|
||||
)
|
||||
|
||||
type focusMode int
|
||||
|
|
@ -134,6 +135,12 @@ type Model struct {
|
|||
seenMessages map[string]bool
|
||||
vulnerabilityCopied bool
|
||||
vulnerabilityCopyError string
|
||||
findingFilter int
|
||||
triage triageForm
|
||||
triagePending *triageRequest
|
||||
triageUndo *triageUndoState
|
||||
triageError string
|
||||
triageErrorID string
|
||||
}
|
||||
|
||||
var (
|
||||
|
|
@ -335,6 +342,7 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
|
|||
m.resizeVulnerabilityViewport()
|
||||
m.ensureAgentVisible()
|
||||
m.ensureVulnerabilityVisible()
|
||||
m.resizeTriageForm()
|
||||
case wireErrMsg:
|
||||
if !m.quitting {
|
||||
m.errorText = "Backend disconnected: " + msg.err.Error()
|
||||
|
|
@ -354,6 +362,13 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
|
|||
cmds = append(cmds, readWire(m.client))
|
||||
case sentMsg:
|
||||
if msg.err != nil {
|
||||
if msg.command == "vulnerability.triage" {
|
||||
if m.triagePending != nil {
|
||||
m.triageErrorID = m.triagePending.findingID
|
||||
}
|
||||
m.triagePending = nil
|
||||
m.triageError = msg.err.Error()
|
||||
}
|
||||
m.errorText = msg.err.Error()
|
||||
if msg.command == "collection.resync" && msg.collection != "" {
|
||||
m.resyncRequested[msg.collection] = false
|
||||
|
|
@ -407,6 +422,8 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
|
|||
var cmd tea.Cmd
|
||||
if m.modal == modalNone {
|
||||
m.input, cmd = m.input.Update(msg)
|
||||
} else if m.modal == modalTriage {
|
||||
m.triage.note, cmd = m.triage.note.Update(msg)
|
||||
}
|
||||
cmds = append(cmds, cmd)
|
||||
return m, tea.Batch(cmds...)
|
||||
|
|
|
|||
453
strix/interface/tui/internal/app/triage.go
Normal file
453
strix/interface/tui/internal/app/triage.go
Normal file
|
|
@ -0,0 +1,453 @@
|
|||
package app
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/charmbracelet/bubbles/textarea"
|
||||
tea "github.com/charmbracelet/bubbletea"
|
||||
"github.com/charmbracelet/lipgloss"
|
||||
"github.com/usestrix/strix/tui/internal/protocol"
|
||||
"github.com/usestrix/strix/tui/internal/render"
|
||||
)
|
||||
|
||||
var triageReasons = []struct{ code, label string }{
|
||||
{"unspecified", "Select a reason (optional)"},
|
||||
{"incorrect_assumption", "Incorrect assumption"},
|
||||
{"existing_protection", "Existing protection prevents the exploit"},
|
||||
{"not_affected", "Code or dependency is not affected"},
|
||||
{"expected_behavior", "Expected behavior, not a vulnerability"},
|
||||
{"other", "Other"},
|
||||
}
|
||||
|
||||
var triageFields = []string{"status", "triage_status", "resolution_reason", "reason_code",
|
||||
"status_note", "status_changed_at", "status_changed_by", "triage_revision", "finding_digest", "review_stale", "can_triage"}
|
||||
|
||||
type triageForm struct {
|
||||
findingID string
|
||||
revision int64
|
||||
digest string
|
||||
reason int
|
||||
focus int // reason, note, cancel, submit
|
||||
note textarea.Model
|
||||
}
|
||||
|
||||
type triageRequest struct {
|
||||
findingID string
|
||||
previous map[string]any
|
||||
undo bool
|
||||
}
|
||||
|
||||
type triageUndoState struct {
|
||||
findingID string
|
||||
previous map[string]any
|
||||
revision int64
|
||||
digest string
|
||||
expires time.Time
|
||||
}
|
||||
|
||||
func boolField(finding map[string]any, key string) bool {
|
||||
value, _ := finding[key].(bool)
|
||||
return value
|
||||
}
|
||||
|
||||
func findingStatus(finding map[string]any) string {
|
||||
if render.StringValue(finding["status"]) == "closed" {
|
||||
return "closed"
|
||||
}
|
||||
return "open"
|
||||
}
|
||||
|
||||
func findingStatusLabel(finding map[string]any) string {
|
||||
if boolField(finding, "review_stale") {
|
||||
return "Needs review · evidence changed since review"
|
||||
}
|
||||
if findingStatus(finding) == "closed" {
|
||||
return "Closed · False positive"
|
||||
}
|
||||
return "Open"
|
||||
}
|
||||
|
||||
func triageReasonLabel(code string) string {
|
||||
if code == "" || code == "unspecified" {
|
||||
return ""
|
||||
}
|
||||
for _, reason := range triageReasons {
|
||||
if reason.code == code {
|
||||
return reason.label
|
||||
}
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (m Model) selectedFinding() map[string]any {
|
||||
if m.selectedVuln < 0 || m.selectedVuln >= len(m.snapshot.Vulnerabilities) {
|
||||
return nil
|
||||
}
|
||||
return m.snapshot.Vulnerabilities[m.selectedVuln]
|
||||
}
|
||||
|
||||
func (m Model) selectedFindingID() string { return collectionItemID(m.selectedFinding()) }
|
||||
|
||||
func (m Model) findingFilterLabel() string { return []string{"Open", "Closed", "All"}[m.findingFilter] }
|
||||
|
||||
func (m Model) findingVisible(index int) bool {
|
||||
if index < 0 || index >= len(m.snapshot.Vulnerabilities) {
|
||||
return false
|
||||
}
|
||||
return m.findingFilter == 2 || (findingStatus(m.snapshot.Vulnerabilities[index]) == "closed") == (m.findingFilter == 1)
|
||||
}
|
||||
|
||||
func (m Model) visibleFindingIndices() []int {
|
||||
indices := make([]int, 0, len(m.snapshot.Vulnerabilities))
|
||||
for i := range m.snapshot.Vulnerabilities {
|
||||
if m.findingVisible(i) {
|
||||
indices = append(indices, i)
|
||||
}
|
||||
}
|
||||
return indices
|
||||
}
|
||||
|
||||
func (m *Model) selectVisibleFinding() {
|
||||
if m.findingVisible(m.selectedVuln) {
|
||||
return
|
||||
}
|
||||
indices := m.visibleFindingIndices()
|
||||
if len(indices) > 0 {
|
||||
m.selectedVuln = indices[0]
|
||||
}
|
||||
}
|
||||
|
||||
func (m *Model) restoreFindingSelection(id string) {
|
||||
for i, finding := range m.snapshot.Vulnerabilities {
|
||||
if collectionItemID(finding) == id {
|
||||
m.selectedVuln = i
|
||||
return
|
||||
}
|
||||
}
|
||||
// Never show a different issue under an already-open review form.
|
||||
if m.modal == modalTriage {
|
||||
m.triageError = "This finding is no longer available."
|
||||
}
|
||||
m.selectedVuln = min(m.selectedVuln, max(0, len(m.snapshot.Vulnerabilities)-1))
|
||||
if m.modal != modalTriage {
|
||||
m.selectVisibleFinding()
|
||||
}
|
||||
}
|
||||
|
||||
func (m *Model) stepVulnerability(direction int) {
|
||||
indices := m.visibleFindingIndices()
|
||||
if direction < 0 {
|
||||
for i := len(indices) - 1; i >= 0; i-- {
|
||||
if indices[i] < m.selectedVuln {
|
||||
m.showVulnerability(indices[i])
|
||||
return
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for _, index := range indices {
|
||||
if index > m.selectedVuln {
|
||||
m.showVulnerability(index)
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (m *Model) openTriageForm() tea.Cmd {
|
||||
finding := m.selectedFinding()
|
||||
if m.triagePending != nil || !boolField(finding, "can_triage") || findingStatus(finding) == "closed" {
|
||||
return nil
|
||||
}
|
||||
input := textarea.New()
|
||||
input.ShowLineNumbers = false
|
||||
input.CharLimit = 2000
|
||||
input.Prompt = ""
|
||||
input.Placeholder = "Optional context for your future review"
|
||||
input.SetHeight(4)
|
||||
reason := 0
|
||||
if m.triage.findingID == collectionItemID(finding) {
|
||||
input.SetValue(m.triage.note.Value())
|
||||
reason = m.triage.reason
|
||||
}
|
||||
m.triage = triageForm{findingID: collectionItemID(finding), revision: numberValue(finding["triage_revision"]),
|
||||
digest: render.StringValue(finding["finding_digest"]), note: input, reason: reason}
|
||||
m.triageError = ""
|
||||
m.triageErrorID = collectionItemID(finding)
|
||||
m.modal = modalTriage
|
||||
m.input.Blur()
|
||||
m.resizeTriageForm()
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *Model) resizeTriageForm() {
|
||||
if m.modal != modalTriage {
|
||||
return
|
||||
}
|
||||
m.triage.note.SetWidth(max(12, min(66, m.width-12)))
|
||||
m.triage.note.SetHeight(max(2, min(4, m.height-18)))
|
||||
}
|
||||
|
||||
func (m Model) updateTriageForm(key tea.KeyMsg) (tea.Model, tea.Cmd) {
|
||||
if m.triagePending != nil {
|
||||
return m, nil
|
||||
}
|
||||
switch key.String() {
|
||||
case "esc":
|
||||
m.modal = modalVulnerability
|
||||
m.triage.note.Blur()
|
||||
m.triageError = ""
|
||||
m.resizeVulnerabilityViewport()
|
||||
return m, nil
|
||||
case "tab", "shift+tab":
|
||||
delta := 1
|
||||
if key.String() == "shift+tab" {
|
||||
delta = -1
|
||||
}
|
||||
m.triage.focus = clampCycle(m.triage.focus+delta, 4)
|
||||
if m.triage.focus == 1 {
|
||||
return m, m.triage.note.Focus()
|
||||
}
|
||||
m.triage.note.Blur()
|
||||
return m, nil
|
||||
case "left", "up", "right", "down":
|
||||
if m.triage.focus == 0 {
|
||||
delta := 1
|
||||
if key.String() == "left" || key.String() == "up" {
|
||||
delta = -1
|
||||
}
|
||||
m.triage.reason = clampCycle(m.triage.reason+delta, len(triageReasons))
|
||||
return m, nil
|
||||
}
|
||||
case "enter":
|
||||
switch m.triage.focus {
|
||||
case 0:
|
||||
m.triage.focus = 1
|
||||
return m, m.triage.note.Focus()
|
||||
case 2:
|
||||
return m.updateTriageForm(tea.KeyMsg{Type: tea.KeyEsc})
|
||||
case 3:
|
||||
return m, m.submitTriage("closed", triageReasons[m.triage.reason].code, m.triage.note.Value())
|
||||
}
|
||||
}
|
||||
if m.triage.focus == 1 {
|
||||
var cmd tea.Cmd
|
||||
m.triage.note, cmd = m.triage.note.Update(key)
|
||||
return m, cmd
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
|
||||
func (m Model) triageFormView() string {
|
||||
width := max(20, min(72, m.width-6))
|
||||
inner := width - 6
|
||||
gap, padding := "\n\n", 1
|
||||
uncertain := "Not sure? Keep open for review."
|
||||
if m.height < 26 {
|
||||
gap, padding, uncertain = "\n", 0, "Not sure? Keep open."
|
||||
}
|
||||
button := func(text string, focus int) string {
|
||||
style := lipgloss.NewStyle().Foreground(textColor)
|
||||
if m.triage.focus == focus {
|
||||
style = style.Bold(true).Background(dark).Foreground(white)
|
||||
}
|
||||
return style.Render(" " + text + " ")
|
||||
}
|
||||
content := render.Bold(white).Render("Mark as false positive") + "\n" +
|
||||
wrapBlock("Applies to this finding in this run.", inner) + gap +
|
||||
"Reason (optional)\n" + button("‹ "+triageReasons[m.triage.reason].label+" ›", 0) + gap +
|
||||
"Note (optional)\n" + m.triage.note.View() + "\n" +
|
||||
wrapBlock(uncertain, inner) + gap +
|
||||
button("Cancel", 2) + " " + button("Close issue", 3) + "\n" +
|
||||
render.Dim().Render("Tab: next field · Esc: back")
|
||||
content = wrapBlock(content, inner)
|
||||
if m.triagePending != nil {
|
||||
content += "\nSaving…"
|
||||
} else if m.triageError != "" {
|
||||
lines := strings.Split(wrapBlock(m.triageError, inner), "\n")
|
||||
room := max(1, m.height-lipgloss.Height(content)-padding*2-3)
|
||||
if len(lines) > room {
|
||||
lines = lines[:room]
|
||||
lines[room-1] = truncate(lines[room-1], max(1, inner-1)) + "…"
|
||||
}
|
||||
content += "\n" + render.Col(red).Render(strings.Join(lines, "\n"))
|
||||
}
|
||||
return lipgloss.NewStyle().Width(width-2).Border(lipgloss.RoundedBorder()).BorderForeground(dark).Background(black).Padding(padding, 2).Render(content)
|
||||
}
|
||||
|
||||
func (m *Model) submitTriage(status, reason, note string) tea.Cmd {
|
||||
if m.triagePending != nil || m.client == nil {
|
||||
return nil
|
||||
}
|
||||
finding := m.selectedFinding()
|
||||
if !boolField(finding, "can_triage") {
|
||||
return nil
|
||||
}
|
||||
id := collectionItemID(finding)
|
||||
revision := numberValue(finding["triage_revision"])
|
||||
digest := render.StringValue(finding["finding_digest"])
|
||||
if m.modal == modalTriage {
|
||||
id, revision, digest = m.triage.findingID, m.triage.revision, m.triage.digest
|
||||
if id != collectionItemID(finding) {
|
||||
m.triageError = "This finding changed. Review it again."
|
||||
return nil
|
||||
}
|
||||
}
|
||||
previous := make(map[string]any, len(finding))
|
||||
for key, value := range finding {
|
||||
previous[key] = value
|
||||
}
|
||||
m.triagePending = &triageRequest{findingID: id, previous: previous}
|
||||
m.triageError = ""
|
||||
m.triageErrorID = id
|
||||
return send(m.client, "vulnerability.triage", map[string]any{"finding_id": id, "status": status,
|
||||
"resolution_reason": "false_positive", "expected_revision": revision, "reviewed_digest": digest,
|
||||
"reason_code": reason, "note": note})
|
||||
}
|
||||
|
||||
func (m Model) canUndoTriage() bool {
|
||||
return m.triageUndo != nil && time.Now().Before(m.triageUndo.expires) && m.selectedFindingID() == m.triageUndo.findingID &&
|
||||
numberValue(m.selectedFinding()["triage_revision"]) == m.triageUndo.revision &&
|
||||
render.StringValue(m.selectedFinding()["finding_digest"]) == m.triageUndo.digest
|
||||
}
|
||||
|
||||
func (m *Model) undoTriage() tea.Cmd {
|
||||
if !m.canUndoTriage() || m.triagePending != nil {
|
||||
return nil
|
||||
}
|
||||
previous := m.triageUndo.previous
|
||||
cmd := m.submitTriage(findingStatus(previous), normalizeTriageReason(render.StringValue(previous["reason_code"])), render.StringValue(previous["status_note"]))
|
||||
if m.triagePending != nil {
|
||||
m.triagePending.undo = true
|
||||
}
|
||||
return cmd
|
||||
}
|
||||
|
||||
func (m *Model) handleTriageResult(result protocol.CommandResult) tea.Cmd {
|
||||
pending := m.triagePending
|
||||
if pending == nil {
|
||||
return nil
|
||||
}
|
||||
m.triagePending = nil
|
||||
m.triageErrorID = pending.findingID
|
||||
if !result.OK {
|
||||
m.triageError = "Could not save this decision."
|
||||
if result.Error != nil {
|
||||
m.triageError = result.Error.Message
|
||||
}
|
||||
if result.Error != nil && result.Error.Code == "conflict" {
|
||||
m.triageError += " Press Esc and review the updated finding before retrying."
|
||||
}
|
||||
return m.collectionMismatch("vulnerabilities")
|
||||
}
|
||||
var data struct {
|
||||
Changed bool `json:"changed"`
|
||||
Finding map[string]any `json:"finding"`
|
||||
}
|
||||
if err := json.Unmarshal(result.Result, &data); err != nil || collectionItemID(data.Finding) != pending.findingID {
|
||||
m.triageError = "Save outcome unknown. Refreshing the finding before another decision."
|
||||
return m.collectionMismatch("vulnerabilities")
|
||||
}
|
||||
for i, finding := range m.snapshot.Vulnerabilities {
|
||||
if collectionItemID(finding) == pending.findingID {
|
||||
updated := make(map[string]any, len(finding))
|
||||
for key, value := range finding {
|
||||
updated[key] = value
|
||||
}
|
||||
if numberValue(data.Finding["triage_revision"]) >= numberValue(finding["triage_revision"]) {
|
||||
for key, value := range data.Finding {
|
||||
updated[key] = value
|
||||
}
|
||||
// A command acknowledges a decision, not a new evidence snapshot.
|
||||
// Preserve evidence that arrived while the save was in flight.
|
||||
preserveCurrentEvidence(finding, updated)
|
||||
}
|
||||
m.snapshot.Vulnerabilities[i] = updated
|
||||
}
|
||||
}
|
||||
m.triageError = ""
|
||||
if m.modal == modalTriage && m.triage.findingID == pending.findingID {
|
||||
m.modal = modalVulnerability
|
||||
m.triage.note.Blur()
|
||||
}
|
||||
if m.triage.findingID == pending.findingID {
|
||||
m.triage.findingID = ""
|
||||
}
|
||||
if data.Changed && !pending.undo {
|
||||
m.triageUndo = &triageUndoState{findingID: pending.findingID, previous: pending.previous,
|
||||
revision: numberValue(data.Finding["triage_revision"]), digest: render.StringValue(data.Finding["finding_digest"]), expires: time.Now().Add(15 * time.Second)}
|
||||
} else if pending.undo {
|
||||
m.triageUndo = nil
|
||||
}
|
||||
m.resizeViewport()
|
||||
m.resizeVulnerabilityViewport()
|
||||
return nil
|
||||
}
|
||||
|
||||
// A queued collection frame predating the save cannot roll its acknowledgement back.
|
||||
func keepNewerTriage(current, incoming map[string]any) map[string]any {
|
||||
if render.StringValue(incoming["triage_error"]) != "" {
|
||||
return incoming
|
||||
}
|
||||
if numberValue(current["triage_revision"]) > numberValue(incoming["triage_revision"]) {
|
||||
evidence := map[string]any{"finding_digest": incoming["finding_digest"]}
|
||||
for _, key := range triageFields {
|
||||
incoming[key] = current[key]
|
||||
}
|
||||
preserveCurrentEvidence(evidence, incoming)
|
||||
}
|
||||
return incoming
|
||||
}
|
||||
|
||||
func preserveCurrentEvidence(evidence, decision map[string]any) {
|
||||
digest := render.StringValue(evidence["finding_digest"])
|
||||
if digest != "" && digest != render.StringValue(decision["finding_digest"]) {
|
||||
decision["finding_digest"] = digest
|
||||
if render.StringValue(decision["triage_status"]) == "closed" {
|
||||
decision["status"], decision["review_stale"] = "open", true
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (m *Model) preserveTriageUpdates(incoming []map[string]any) {
|
||||
current := map[string]map[string]any{}
|
||||
for _, finding := range m.snapshot.Vulnerabilities {
|
||||
current[collectionItemID(finding)] = finding
|
||||
}
|
||||
for _, finding := range incoming {
|
||||
keepNewerTriage(current[collectionItemID(finding)], finding)
|
||||
}
|
||||
}
|
||||
|
||||
func (m Model) updateTriageMouse(msg tea.MouseMsg) (tea.Model, tea.Cmd) {
|
||||
if msg.Button != tea.MouseButtonLeft || msg.Action != tea.MouseActionPress || m.triagePending != nil {
|
||||
return m, nil
|
||||
}
|
||||
view := m.triageFormView()
|
||||
if m.centeredLabelHit(view, "Close issue", msg.X, msg.Y) {
|
||||
m.triage.focus = 3
|
||||
return m.updateTriageForm(tea.KeyMsg{Type: tea.KeyEnter})
|
||||
}
|
||||
if m.centeredLabelHit(view, "Cancel", msg.X, msg.Y) {
|
||||
return m.updateTriageForm(tea.KeyMsg{Type: tea.KeyEsc})
|
||||
}
|
||||
if m.centeredLabelHit(view, triageReasons[m.triage.reason].label, msg.X, msg.Y) {
|
||||
m.triage.focus = 0
|
||||
m.triage.reason = (m.triage.reason + 1) % len(triageReasons)
|
||||
m.triage.note.Blur()
|
||||
}
|
||||
if m.centeredLabelHit(view, "Note (optional)", msg.X, msg.Y) {
|
||||
m.triage.focus = 1
|
||||
return m, m.triage.note.Focus()
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
|
||||
// Legacy decisions can omit the optional category.
|
||||
func normalizeTriageReason(reason string) string {
|
||||
if strings.TrimSpace(reason) == "" {
|
||||
return "unspecified"
|
||||
}
|
||||
return reason
|
||||
}
|
||||
231
strix/interface/tui/internal/app/triage_test.go
Normal file
231
strix/interface/tui/internal/app/triage_test.go
Normal file
|
|
@ -0,0 +1,231 @@
|
|||
package app
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
tea "github.com/charmbracelet/bubbletea"
|
||||
"github.com/charmbracelet/lipgloss"
|
||||
"github.com/charmbracelet/x/ansi"
|
||||
"github.com/usestrix/strix/tui/internal/protocol"
|
||||
)
|
||||
|
||||
func triageModel(t *testing.T) Model {
|
||||
t.Helper()
|
||||
m := reportModel(t, 2)
|
||||
m.client = newClient(&recordingConn{})
|
||||
for _, finding := range m.snapshot.Vulnerabilities {
|
||||
finding["status"] = "open"
|
||||
finding["triage_revision"] = 0
|
||||
finding["finding_digest"] = strings.Repeat("a", 64)
|
||||
finding["can_triage"] = true
|
||||
}
|
||||
return m
|
||||
}
|
||||
|
||||
func triageKey(m Model, key tea.KeyMsg) Model {
|
||||
updated, _ := m.updateModal(key)
|
||||
return updated.(Model)
|
||||
}
|
||||
|
||||
func TestNativeTriageFormKeepsLettersAndComposerDraft(t *testing.T) {
|
||||
m := triageModel(t)
|
||||
m.input.SetValue("unfinished scan instruction")
|
||||
m = triageKey(m, tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'f'}})
|
||||
if m.modal != modalTriage {
|
||||
t.Fatal("f did not open a native form")
|
||||
}
|
||||
view := ansi.Strip(m.triageFormView())
|
||||
for _, label := range []string{"Mark as false positive", "Reason (optional)", "Note (optional)", "Close issue", "Cancel"} {
|
||||
if !strings.Contains(view, label) {
|
||||
t.Fatalf("form lacks %q", label)
|
||||
}
|
||||
}
|
||||
if strings.Contains(strings.ToLower(view), "telemetry") {
|
||||
t.Fatal("form contains telemetry copy")
|
||||
}
|
||||
m = triageKey(m, tea.KeyMsg{Type: tea.KeyTab})
|
||||
for _, letter := range "frv" {
|
||||
m = triageKey(m, tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{letter}})
|
||||
}
|
||||
if m.triage.note.Value() != "frv" || m.triagePending != nil {
|
||||
t.Fatal("note typing triggered a command")
|
||||
}
|
||||
m = triageKey(m, tea.KeyMsg{Type: tea.KeyEsc})
|
||||
if m.modal != modalVulnerability || m.input.Value() != "unfinished scan instruction" {
|
||||
t.Fatal("cancel lost detail or composer draft")
|
||||
}
|
||||
}
|
||||
|
||||
func TestNativeTriageRequestUsesOriginallyReviewedDigest(t *testing.T) {
|
||||
m := triageModel(t)
|
||||
connection := &recordingConn{}
|
||||
m.client = newClient(connection)
|
||||
m.openTriageForm()
|
||||
m.triage.reason = 1
|
||||
m.triage.note.SetValue("The claim is incorrect")
|
||||
m.selectedFinding()["finding_digest"] = strings.Repeat("b", 64)
|
||||
m.triage.focus = 3
|
||||
updated, cmd := m.updateModal(tea.KeyMsg{Type: tea.KeyEnter})
|
||||
m = updated.(Model)
|
||||
if cmd == nil {
|
||||
t.Fatal("close did not send a command")
|
||||
}
|
||||
message := cmd().(sentMsg)
|
||||
if message.err != nil || message.command != "vulnerability.triage" {
|
||||
t.Fatalf("wrong command: %#v", message)
|
||||
}
|
||||
frame, err := readEnvelopeFrame(bytes.NewReader(connection.Bytes()))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var payload map[string]any
|
||||
if err := json.Unmarshal(frame.Payload, &payload); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if payload["reviewed_digest"] != strings.Repeat("a", 64) || payload["finding_id"] != "a" || payload["status"] != "closed" || payload["note"] != "The claim is incorrect" {
|
||||
t.Fatalf("review request changed: %#v", payload)
|
||||
}
|
||||
if retry := m.submitTriage("closed", "unspecified", ""); retry != nil {
|
||||
t.Fatal("sent duplicate pending review")
|
||||
}
|
||||
result := protocol.CommandResult{OK: false, Command: "vulnerability.triage", Error: &protocol.CommandError{Code: "conflict", Message: "Evidence changed"}}
|
||||
m.handleEnvelope(protocol.Envelope{Version: protocol.Version, Type: "command_result", RequestID: message.requestID, Payload: rawJSON(t, result)})
|
||||
if m.modal != modalTriage || m.triage.note.Value() != "The claim is incorrect" || !strings.Contains(m.triageError, "review") {
|
||||
t.Fatal("conflict lost the editable form")
|
||||
}
|
||||
m = triageKey(m, tea.KeyMsg{Type: tea.KeyEsc})
|
||||
m.openTriageForm()
|
||||
if m.triage.note.Value() != "The claim is incorrect" || m.triage.digest != strings.Repeat("b", 64) {
|
||||
t.Fatal("fresh review lost the failed submission draft")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSavedTriagePinsDetailOffersUndoAndFiltersClosedFinding(t *testing.T) {
|
||||
m := triageModel(t)
|
||||
m.openTriageForm()
|
||||
m.submitTriage("closed", "incorrect_assumption", "note")
|
||||
closed := map[string]any{"id": "a", "status": "closed", "triage_status": "closed", "resolution_reason": "false_positive", "reason_code": "incorrect_assumption", "status_note": "note", "triage_revision": 1, "finding_digest": strings.Repeat("a", 64), "can_triage": true}
|
||||
m.handleTriageResult(protocol.CommandResult{OK: true, Command: "vulnerability.triage", Result: rawJSON(t, map[string]any{"changed": true, "finding": closed})})
|
||||
if m.modal != modalVulnerability || m.selectedFindingID() != "a" || !m.canUndoTriage() {
|
||||
t.Fatal("saved closure lost the detail or undo")
|
||||
}
|
||||
if rows := m.vulnerabilityRows(60); len(rows) != 1 || rows[0].index != 1 {
|
||||
t.Fatalf("closed finding remained active: %#v", rows)
|
||||
}
|
||||
if !strings.Contains(ansi.Strip(m.vulnerabilityDetail()), "Reopen (r)") {
|
||||
t.Fatal("native reopen is missing")
|
||||
}
|
||||
if !strings.Contains(vulnerabilityMarkdownReport(m.selectedFinding()), "Closed · False positive") {
|
||||
t.Fatal("copy lacks triage")
|
||||
}
|
||||
if cmd := m.undoTriage(); cmd == nil || m.triagePending == nil || !m.triagePending.undo {
|
||||
t.Fatal("undo unavailable")
|
||||
}
|
||||
// A saved reopen is active again and consumes the brief undo action.
|
||||
closed["status"], closed["triage_revision"] = "open", 2
|
||||
m.handleTriageResult(protocol.CommandResult{OK: true, Command: "vulnerability.triage", Result: rawJSON(t, map[string]any{"changed": true, "finding": closed})})
|
||||
if len(m.visibleFindingIndices()) != 2 || m.triageUndo != nil {
|
||||
t.Fatal("undo did not restore active finding")
|
||||
}
|
||||
}
|
||||
|
||||
func TestNativeClosedFilterIsReachableWithoutViewer(t *testing.T) {
|
||||
m := triageModel(t)
|
||||
m.snapshot.Vulnerabilities[0]["status"] = "closed"
|
||||
m.closeModal()
|
||||
m.focus = focusVulnerabilities
|
||||
updated, cmd := m.updateMain(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'v'}})
|
||||
m = updated.(Model)
|
||||
if cmd != nil || m.findingFilterLabel() != "Closed" || m.selectedFindingID() != "a" {
|
||||
t.Fatal("v did not select the closed view locally")
|
||||
}
|
||||
updated, _ = m.updateMain(tea.KeyMsg{Type: tea.KeyEnter})
|
||||
m = updated.(Model)
|
||||
updated, cmd = m.updateModal(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'r'}})
|
||||
m = updated.(Model)
|
||||
if cmd == nil || m.triagePending == nil {
|
||||
t.Fatal("r did not submit native reopen")
|
||||
}
|
||||
}
|
||||
|
||||
func TestCollectionRefreshPreservesReviewSelectionAndNewerAcknowledgement(t *testing.T) {
|
||||
m := triageModel(t)
|
||||
m.selectedVuln = 1
|
||||
m.openTriageForm()
|
||||
m.snapshot.Vulnerabilities[1]["triage_revision"] = 2
|
||||
m.snapshot.Vulnerabilities[1]["status"] = "closed"
|
||||
items := []json.RawMessage{rawJSON(t, map[string]any{"id": "b", "title": "Updated", "status": "open", "triage_revision": 1}), rawJSON(t, m.snapshot.Vulnerabilities[0])}
|
||||
m.handleCollectionBootstrap(rawJSON(t, protocol.CollectionBootstrap{Collection: "vulnerabilities", Revision: 2, Cursor: 0, NextCursor: 2, Done: true, Items: items}))
|
||||
if m.selectedFindingID() != "b" || m.triage.findingID != "b" || m.selectedVuln != 0 {
|
||||
t.Fatal("reorder changed the finding being reviewed")
|
||||
}
|
||||
if findingStatus(m.selectedFinding()) != "closed" || numberValue(m.selectedFinding()["triage_revision"]) != 2 {
|
||||
t.Fatal("old queued projection overwrote saved decision")
|
||||
}
|
||||
}
|
||||
|
||||
func TestStaleClosureRemainsActiveAndCanBeReviewedAgain(t *testing.T) {
|
||||
m := triageModel(t)
|
||||
finding := m.selectedFinding()
|
||||
finding["triage_status"], finding["status"], finding["review_stale"] = "closed", "open", true
|
||||
if !m.findingVisible(0) || !strings.Contains(findingStatusLabel(finding), "Needs review") {
|
||||
t.Fatal("stale review remained suppressed")
|
||||
}
|
||||
m.openTriageForm()
|
||||
if m.modal != modalTriage {
|
||||
t.Fatal("fresh review unavailable")
|
||||
}
|
||||
}
|
||||
|
||||
func TestNativeTriageFitsSmallTerminal(t *testing.T) {
|
||||
for _, size := range [][2]int{{130, 30}, {80, 24}, {60, 22}, {40, 18}} {
|
||||
m := triageModel(t)
|
||||
m.width, m.height = size[0], size[1]
|
||||
m.openTriageForm()
|
||||
m.triage.reason = 2
|
||||
m.triageError = "Finding evidence changed. Reload and review it again. Press Esc and review the updated finding before retrying."
|
||||
view := m.triageFormView()
|
||||
if lipgloss.Width(view) > m.width || lipgloss.Height(view) > m.height {
|
||||
t.Errorf("%dx%d form is %dx%d:\n%s", m.width, m.height, lipgloss.Width(view), lipgloss.Height(view), ansi.Strip(view))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestF2OpensClosedOnlyFindingsOnNarrowTerminal(t *testing.T) {
|
||||
m := triageModel(t)
|
||||
m.width, m.height = 80, 24
|
||||
for _, finding := range m.snapshot.Vulnerabilities {
|
||||
finding["status"] = "closed"
|
||||
}
|
||||
m.closeModal()
|
||||
updated, cmd := m.updateMain(tea.KeyMsg{Type: tea.KeyF2})
|
||||
m = updated.(Model)
|
||||
if cmd != nil || m.modal != modalVulnerability || m.findingFilterLabel() != "All" {
|
||||
t.Fatal("F2 did not reach closed findings without a sidebar")
|
||||
}
|
||||
if !strings.Contains(ansi.Strip(m.statusView(80)), "F2 findings") {
|
||||
t.Fatal("entry point is not discoverable")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSaveAcknowledgementCannotDismissEvidenceArrivingInFlight(t *testing.T) {
|
||||
m := triageModel(t)
|
||||
m.openTriageForm()
|
||||
m.submitTriage("closed", "unspecified", "")
|
||||
finding := m.selectedFinding()
|
||||
finding["finding_digest"] = strings.Repeat("b", 64)
|
||||
finding["evidence"] = "Changed after submission"
|
||||
finding["triage_revision"] = 1
|
||||
finding["review_stale"] = true
|
||||
m.handleTriageResult(protocol.CommandResult{OK: true, Command: "vulnerability.triage", Result: rawJSON(t, map[string]any{"changed": true, "finding": map[string]any{
|
||||
"id": "a", "status": "closed", "triage_status": "closed", "triage_revision": 1, "finding_digest": strings.Repeat("a", 64), "review_stale": false}})})
|
||||
if findingStatus(m.selectedFinding()) != "open" || !boolField(m.selectedFinding(), "review_stale") || m.selectedFinding()["finding_digest"] != strings.Repeat("b", 64) {
|
||||
t.Fatal("save hid evidence the user never reviewed")
|
||||
}
|
||||
if m.canUndoTriage() {
|
||||
t.Fatal("undo should be unavailable after evidence changed")
|
||||
}
|
||||
}
|
||||
|
|
@ -10,9 +10,26 @@ import (
|
|||
|
||||
func (m Model) updateMain(key tea.KeyMsg) (tea.Model, tea.Cmd) {
|
||||
switch key.String() {
|
||||
case "v":
|
||||
if m.focus == focusVulnerabilities {
|
||||
m.findingFilter = (m.findingFilter + 1) % 3
|
||||
m.selectVisibleFinding()
|
||||
m.vulnOffset = 0
|
||||
m.resizeViewport()
|
||||
return m, nil
|
||||
}
|
||||
case "f1":
|
||||
m.openModal(modalHelp)
|
||||
return m, nil
|
||||
case "f2":
|
||||
if len(m.snapshot.Vulnerabilities) > 0 {
|
||||
if len(m.visibleFindingIndices()) == 0 {
|
||||
m.findingFilter = 2
|
||||
}
|
||||
m.selectVisibleFinding()
|
||||
m.openModal(modalVulnerability)
|
||||
}
|
||||
return m, nil
|
||||
case "ctrl+c", "ctrl+q":
|
||||
// Nothing to lose on the start screen; quit without confirmation.
|
||||
if m.snapshot.SetupMode {
|
||||
|
|
@ -70,6 +87,9 @@ func (m Model) updateMain(key tea.KeyMsg) (tea.Model, tea.Cmd) {
|
|||
case "enter", " ":
|
||||
if m.focus == focusVulnerabilities && len(m.snapshot.Vulnerabilities) > 0 {
|
||||
if key.String() == "enter" {
|
||||
if !m.findingVisible(m.selectedVuln) {
|
||||
return m, nil
|
||||
}
|
||||
m.openModal(modalVulnerability)
|
||||
return m, nil
|
||||
}
|
||||
|
|
@ -128,12 +148,16 @@ func (m Model) updateMain(key tea.KeyMsg) (tea.Model, tea.Cmd) {
|
|||
case "home":
|
||||
if m.focus == focusVulnerabilities && len(m.snapshot.Vulnerabilities) > 0 {
|
||||
m.selectedVuln = 0
|
||||
m.selectVisibleFinding()
|
||||
m.ensureVulnerabilityVisible()
|
||||
return m, nil
|
||||
}
|
||||
case "end":
|
||||
if m.focus == focusVulnerabilities && len(m.snapshot.Vulnerabilities) > 0 {
|
||||
m.selectedVuln = len(m.snapshot.Vulnerabilities) - 1
|
||||
if indices := m.visibleFindingIndices(); len(indices) > 0 {
|
||||
m.selectedVuln = indices[len(indices)-1]
|
||||
}
|
||||
m.ensureVulnerabilityVisible()
|
||||
return m, nil
|
||||
}
|
||||
|
|
@ -466,9 +490,15 @@ func (m Model) updateSetupMouse(msg tea.MouseMsg) (tea.Model, tea.Cmd) {
|
|||
func (m Model) pressReportButton(button string) (tea.Model, tea.Cmd) {
|
||||
switch button {
|
||||
case reportPrev:
|
||||
m.showVulnerability(m.selectedVuln - 1)
|
||||
m.stepVulnerability(-1)
|
||||
case reportNext:
|
||||
m.showVulnerability(m.selectedVuln + 1)
|
||||
m.stepVulnerability(1)
|
||||
case reportTriage:
|
||||
return m, m.openTriageForm()
|
||||
case reportReopen:
|
||||
return m, m.submitTriage("open", "unspecified", "")
|
||||
case reportUndo:
|
||||
return m, m.undoTriage()
|
||||
case reportCopy:
|
||||
m.reportFocus = reportCopy
|
||||
return m, m.startVulnerabilityCopy()
|
||||
|
|
@ -479,6 +509,9 @@ func (m Model) pressReportButton(button string) (tea.Model, tea.Cmd) {
|
|||
}
|
||||
|
||||
func (m Model) updateModalMouse(msg tea.MouseMsg) (tea.Model, tea.Cmd) {
|
||||
if m.modal == modalTriage {
|
||||
return m.updateTriageMouse(msg)
|
||||
}
|
||||
if m.modal == modalVulnerability {
|
||||
view := m.modalView()
|
||||
left, top, _, _ := m.centeredViewBounds(view)
|
||||
|
|
@ -610,6 +643,9 @@ func clampCycle(value, length int) int {
|
|||
}
|
||||
|
||||
func (m Model) updateModal(key tea.KeyMsg) (tea.Model, tea.Cmd) {
|
||||
if m.modal == modalTriage {
|
||||
return m.updateTriageForm(key)
|
||||
}
|
||||
if m.modal == modalHelp {
|
||||
if key.String() != "" {
|
||||
m.closeModal()
|
||||
|
|
@ -622,9 +658,23 @@ func (m Model) updateModal(key tea.KeyMsg) (tea.Model, tea.Cmd) {
|
|||
m.closeModal()
|
||||
// The arrows step between reports directly; tab walks the button row.
|
||||
case "left":
|
||||
m.showVulnerability(m.selectedVuln - 1)
|
||||
m.stepVulnerability(-1)
|
||||
case "right":
|
||||
m.showVulnerability(m.selectedVuln + 1)
|
||||
m.stepVulnerability(1)
|
||||
case "f":
|
||||
return m, m.openTriageForm()
|
||||
case "v":
|
||||
m.findingFilter = (m.findingFilter + 1) % 3
|
||||
m.selectVisibleFinding()
|
||||
m.vulnOffset = 0
|
||||
m.resizeVulnerabilityViewport()
|
||||
return m, nil
|
||||
case "r":
|
||||
if findingStatus(m.selectedFinding()) == "closed" {
|
||||
return m, m.submitTriage("open", "unspecified", "")
|
||||
}
|
||||
case "u":
|
||||
return m, m.undoTriage()
|
||||
case "tab":
|
||||
m.stepReportFocus(1)
|
||||
case "shift+tab":
|
||||
|
|
@ -706,6 +756,7 @@ func (m *Model) openModal(mode modalMode) {
|
|||
|
||||
func (m *Model) closeModal() {
|
||||
m.modal = modalNone
|
||||
m.selectVisibleFinding()
|
||||
if m.focus == focusInput {
|
||||
m.input.Focus()
|
||||
}
|
||||
|
|
|
|||
|
|
@ -266,7 +266,7 @@ func (m Model) viewInner() string {
|
|||
} else if m.modal != modalNone {
|
||||
// Only the vulnerability detail dims its backdrop (#000000 80%); Help,
|
||||
// Quit and Stop are transparent.
|
||||
main = m.overlay(main, m.modalView(), m.modal == modalVulnerability)
|
||||
main = m.overlay(main, m.modalView(), m.modal == modalVulnerability || m.modal == modalTriage)
|
||||
}
|
||||
return m.toastOverlay(main)
|
||||
}
|
||||
|
|
@ -569,7 +569,7 @@ func (m Model) sidebarHeights() (statsHeight, vulnHeight, mcpHeight, agentHeight
|
|||
statsRows := lipgloss.Height(lipgloss.NewStyle().Width(m.viewerContentWidth()).Render(m.statsView()))
|
||||
statsHeight = min(15, statsRows+2)
|
||||
if len(m.snapshot.Vulnerabilities) > 0 {
|
||||
vulnHeight = min(12, len(m.vulnerabilityRows(m.vulnerabilityListWidth()))+2)
|
||||
vulnHeight = min(12, max(3, len(m.vulnerabilityRows(m.vulnerabilityListWidth())))+2)
|
||||
}
|
||||
// One header line + one line per connection + the box border (2). Capped so a
|
||||
// long roster cannot crowd out the agent tree; a roster past the cap scrolls
|
||||
|
|
@ -614,6 +614,15 @@ func (m Model) viewerView(width int) string {
|
|||
func (m Model) statsView() string {
|
||||
w := lipgloss.NewStyle().Foreground(white)
|
||||
var b strings.Builder
|
||||
if total := len(m.snapshot.Vulnerabilities); total > 0 {
|
||||
closed := 0
|
||||
for _, finding := range m.snapshot.Vulnerabilities {
|
||||
if findingStatus(finding) == "closed" {
|
||||
closed++
|
||||
}
|
||||
}
|
||||
b.WriteString(w.Render(fmt.Sprintf("%d open · %d false positives\n%d found · %s (v)\n", total-closed, closed, total, m.findingFilterLabel())))
|
||||
}
|
||||
if model := m.snapshot.Model; model != "" {
|
||||
b.WriteString(w.Render(model))
|
||||
}
|
||||
|
|
@ -826,6 +835,14 @@ func (m Model) statusView(width int) string {
|
|||
if m.errorText != "" {
|
||||
left = statusMessage(m.errorText, red, "", width-lipgloss.Width(right))
|
||||
}
|
||||
if len(m.snapshot.Vulnerabilities) > 0 {
|
||||
hint := lipgloss.NewStyle().Foreground(textColor).Render("F2 findings")
|
||||
if right == "" {
|
||||
right = hint
|
||||
} else {
|
||||
right = hint + " · " + right
|
||||
}
|
||||
}
|
||||
return composeStatusRow(left, right, width)
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -65,6 +65,9 @@ func vulnerabilityMarkdownReport(v map[string]any) string {
|
|||
}
|
||||
}
|
||||
field("ID", render.StringValue(v["id"]))
|
||||
field("Status", findingStatusLabel(v))
|
||||
field("Reviewed", render.StringValue(v["status_changed_at"]))
|
||||
field("Review reason", triageReasonLabel(render.StringValue(v["reason_code"])))
|
||||
field("Severity", strings.ToUpper(render.StringValue(v["severity"])))
|
||||
field("Found", render.StringValue(v["timestamp"]))
|
||||
field("Agent", render.StringValue(v["agent_name"]))
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@ func (m Model) vulnerabilityRows(width int) []vulnerabilityRow {
|
|||
// Wrapped lines sit under the title rather than under the severity dot.
|
||||
body := max(1, width-2)
|
||||
rows := make([]vulnerabilityRow, 0, len(m.snapshot.Vulnerabilities))
|
||||
for i := range m.snapshot.Vulnerabilities {
|
||||
for _, i := range m.visibleFindingIndices() {
|
||||
for line, text := range strings.Split(wrapBlock(m.vulnerabilityTitle(i), body), "\n") {
|
||||
rows = append(rows, vulnerabilityRow{index: i, text: text, first: line == 0})
|
||||
}
|
||||
|
|
@ -38,6 +38,9 @@ func (m Model) vulnerabilityRows(width int) []vulnerabilityRow {
|
|||
|
||||
func (m Model) vulnerabilitiesView(width, height int) string {
|
||||
rows := m.vulnerabilityRows(width)
|
||||
if len(rows) == 0 {
|
||||
return wrapBlock("No "+strings.ToLower(m.findingFilterLabel())+" findings.\nv: Open / Closed / All", width)
|
||||
}
|
||||
start := min(max(0, m.vulnOffset), max(0, len(rows)-1))
|
||||
end := min(len(rows), start+height)
|
||||
lines := make([]string, 0, max(0, end-start))
|
||||
|
|
@ -78,6 +81,12 @@ func (m Model) vulnerabilityTitle(index int) string {
|
|||
if title == "" {
|
||||
title = "Unknown Vulnerability"
|
||||
}
|
||||
if boolField(m.snapshot.Vulnerabilities[index], "review_stale") {
|
||||
return "[Needs review] " + title
|
||||
}
|
||||
if findingStatus(m.snapshot.Vulnerabilities[index]) == "closed" {
|
||||
return "[False positive] " + title
|
||||
}
|
||||
return title
|
||||
}
|
||||
|
||||
|
|
@ -157,7 +166,18 @@ func (m Model) vulnerabilityPageItems() int {
|
|||
}
|
||||
|
||||
func (m *Model) moveVulnerabilitySelection(delta int) {
|
||||
m.selectedVuln = max(0, min(len(m.snapshot.Vulnerabilities)-1, m.selectedVuln+delta))
|
||||
indices := m.visibleFindingIndices()
|
||||
if len(indices) == 0 {
|
||||
return
|
||||
}
|
||||
position := 0
|
||||
for i, index := range indices {
|
||||
if index == m.selectedVuln {
|
||||
position = i
|
||||
break
|
||||
}
|
||||
}
|
||||
m.selectedVuln = indices[max(0, min(len(indices)-1, position+delta))]
|
||||
}
|
||||
|
||||
// keepVulnerabilitySelectionInWindow pulls the selection to the nearest finding
|
||||
|
|
@ -192,7 +212,7 @@ func (m Model) modalView() string {
|
|||
switch m.modal {
|
||||
case modalHelp:
|
||||
title := lipgloss.NewStyle().Bold(true).Foreground(green).Width(34).Align(lipgloss.Center).Render("Strix Help")
|
||||
body := lipgloss.NewStyle().Foreground(textColor).Render("F1 Help\nCtrl+O Open viewer\nCtrl+Q/C Quit\nESC Stop Agent\nEnter Send / expand node\nCtrl+J Newline in message\nTab Switch panels\n↑/↓ Navigate tree\nDrag Select & copy text\nClick Expand/collapse tool")
|
||||
body := lipgloss.NewStyle().Foreground(textColor).Render("F1 Help\nF2 Findings\nCtrl+O Open viewer\nCtrl+Q/C Quit\nESC Stop Agent\nEnter Send / expand node\nCtrl+J Newline in message\nTab Switch panels\n↑/↓ Navigate tree\nf / r / u Review / reopen / undo (finding)\nv Open / Closed / All (findings)\nDrag Select & copy text\nClick Expand/collapse tool")
|
||||
content := title + "\n\n" + body
|
||||
return lipgloss.NewStyle().Width(38).Border(lipgloss.RoundedBorder()).BorderForeground(green).Background(black).Padding(1, 2).Render(content)
|
||||
case modalQuit:
|
||||
|
|
@ -212,6 +232,8 @@ func (m Model) modalView() string {
|
|||
return ""
|
||||
}
|
||||
return m.vulnerabilityDetail()
|
||||
case modalTriage:
|
||||
return m.triageFormView()
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
|
@ -328,6 +350,14 @@ func vulnerabilityBody(v map[string]any) string {
|
|||
}
|
||||
}
|
||||
field("Agent", render.StringValue(v["agent_name"]))
|
||||
field("Status", findingStatusLabel(v))
|
||||
field("Reviewed", render.StringValue(v["status_changed_at"]))
|
||||
field("Reason", triageReasonLabel(render.StringValue(v["reason_code"])))
|
||||
field("Note", render.StringValue(v["status_note"]))
|
||||
field("Review unavailable", render.StringValue(v["triage_error"]))
|
||||
if allowed, present := v["can_triage"]; present && allowed == false && v["triage_error"] == nil {
|
||||
field("Review", "Read-only finding; decisions cannot be changed.")
|
||||
}
|
||||
field("Title", render.StringValue(v["title"]))
|
||||
if sev := render.StringValue(v["severity"]); sev != "" {
|
||||
b.WriteString("\n\n" + fieldStyle.Render("Severity: ") +
|
||||
|
|
@ -389,8 +419,9 @@ func (m *Model) resizeVulnerabilityViewport() {
|
|||
width, height := m.vulnerabilityDialogSize()
|
||||
innerWidth := max(1, width-8) // border plus three cells of horizontal padding
|
||||
m.vulnViewport.Width = max(1, innerWidth-2) // right padding and one-cell scrollbar
|
||||
m.vulnViewport.Height = max(1, height-9) // padding, one-row grid gutter, and two-row footer
|
||||
m.vulnViewport.SetContent(wrapBlock(vulnerabilityBody(m.snapshot.Vulnerabilities[m.selectedVuln]), m.vulnViewport.Width))
|
||||
m.vulnViewport.Height = max(1, height-11) // action row, navigation and mutation outcome
|
||||
body := vulnerabilityBody(m.snapshot.Vulnerabilities[m.selectedVuln])
|
||||
m.vulnViewport.SetContent(wrapBlock(body, m.vulnViewport.Width))
|
||||
m.vulnViewport.SetYOffset(m.vulnViewport.YOffset)
|
||||
}
|
||||
|
||||
|
|
@ -430,13 +461,21 @@ func (m Model) vulnerabilityDetail() string {
|
|||
}
|
||||
// Stepping sits on the left behind the position, acting on the right.
|
||||
right := strings.Join(acting, " ")
|
||||
left := strings.Join(stepping, " ")
|
||||
left := m.findingFilterLabel() + " (v) " + strings.Join(stepping, " ")
|
||||
if total := len(m.snapshot.Vulnerabilities); total > 1 {
|
||||
left = render.Dim().Render(fmt.Sprintf("%d/%d", m.selectedVuln+1, total)) + " " + left
|
||||
}
|
||||
room := max(0, inner-lipgloss.Width(right))
|
||||
buttonRow := rule + "\n" +
|
||||
lipgloss.NewStyle().Width(room).Render(truncate(left, room)) + right
|
||||
buttonRow := rule + "\n" + truncate(left, inner) + "\n" + wrapBlock(right, inner)
|
||||
outcome := ""
|
||||
if m.triageErrorID == m.selectedFindingID() {
|
||||
outcome = m.triageError
|
||||
}
|
||||
if m.triagePending != nil && m.triagePending.findingID == m.selectedFindingID() {
|
||||
outcome = "Saving…"
|
||||
}
|
||||
if outcome != "" {
|
||||
buttonRow += "\n" + truncate(outcome, inner)
|
||||
}
|
||||
content := m.vulnerabilityScrollView() + "\n" + buttonRow
|
||||
return lipgloss.NewStyle().Width(width-2).Height(height-2).Border(lipgloss.NormalBorder()).BorderForeground(lipgloss.Color("#262626")).Background(lipgloss.Color("#0a0a0a")).Padding(2, 3).Render(content)
|
||||
}
|
||||
|
|
@ -459,10 +498,13 @@ func (m *Model) showVulnerability(index int) {
|
|||
// The report's buttons. Prev and Next carry their arrows so a click test cannot
|
||||
// be fooled by the same word appearing in the body of a finding.
|
||||
const (
|
||||
reportPrev = "‹ Prev"
|
||||
reportNext = "Next ›"
|
||||
reportCopy = "Copy"
|
||||
reportDone = "Done"
|
||||
reportPrev = "‹ Prev"
|
||||
reportNext = "Next ›"
|
||||
reportCopy = "Copy"
|
||||
reportDone = "Done"
|
||||
reportTriage = "False positive (f)"
|
||||
reportReopen = "Reopen (r)"
|
||||
reportUndo = "Undo (u)"
|
||||
)
|
||||
|
||||
// reportButtons is the row as it stands, left to right. Stepping is offered only
|
||||
|
|
@ -476,6 +518,16 @@ func (m Model) reportButtons() []string {
|
|||
if next {
|
||||
buttons = append(buttons, reportNext)
|
||||
}
|
||||
if boolField(m.selectedFinding(), "can_triage") {
|
||||
if findingStatus(m.selectedFinding()) == "closed" {
|
||||
buttons = append(buttons, reportReopen)
|
||||
} else {
|
||||
buttons = append(buttons, reportTriage)
|
||||
}
|
||||
}
|
||||
if m.canUndoTriage() {
|
||||
buttons = append(buttons, reportUndo)
|
||||
}
|
||||
return append(buttons, reportCopy, reportDone)
|
||||
}
|
||||
|
||||
|
|
@ -507,7 +559,11 @@ func (m *Model) stepReportFocus(delta int) {
|
|||
// ends are not wrapped: a report is one of an ordered list, and rolling from the
|
||||
// last to the first hides that you reached the end.
|
||||
func (m Model) vulnerabilityNeighbors() (previous, next bool) {
|
||||
return m.selectedVuln > 0, m.selectedVuln < len(m.snapshot.Vulnerabilities)-1
|
||||
for _, index := range m.visibleFindingIndices() {
|
||||
previous = previous || index < m.selectedVuln
|
||||
next = next || index > m.selectedVuln
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// reportButton renders one button of the report row. Copy reports the outcome of
|
||||
|
|
|
|||
|
|
@ -76,6 +76,9 @@ func (m *Model) handleEnvelope(envelope protocol.Envelope) tea.Cmd {
|
|||
if result.Command != expectedCommand || !m.client.Resolve(envelope.RequestID, result.Command) {
|
||||
return nil
|
||||
}
|
||||
if result.Command == "vulnerability.triage" {
|
||||
return m.handleTriageResult(result)
|
||||
}
|
||||
if !result.OK {
|
||||
if result.Command == "collection.resync" {
|
||||
if collection := m.resyncRequests[envelope.RequestID]; collection != "" {
|
||||
|
|
@ -240,7 +243,10 @@ func (m *Model) handleCollectionBootstrap(payload json.RawMessage) tea.Cmd {
|
|||
} else if chunk.Collection == "events" {
|
||||
m.snapshot.Events = assembly.events
|
||||
} else {
|
||||
selectedID := m.selectedFindingID()
|
||||
m.preserveTriageUpdates(assembly.findings)
|
||||
m.snapshot.Vulnerabilities = assembly.findings
|
||||
m.restoreFindingSelection(selectedID)
|
||||
}
|
||||
m.collectionRevisions[chunk.Collection] = chunk.Revision
|
||||
delete(m.collectionAssemblies, chunk.Collection)
|
||||
|
|
@ -379,6 +385,7 @@ func (m *Model) applyCollectionOperations(name string, operations []protocol.Col
|
|||
return true
|
||||
}
|
||||
|
||||
selectedID := m.selectedFindingID()
|
||||
values := append([]map[string]any(nil), m.snapshot.Vulnerabilities...)
|
||||
positions := make(map[string]int, len(values))
|
||||
for index, finding := range values {
|
||||
|
|
@ -417,13 +424,14 @@ func (m *Model) applyCollectionOperations(name string, operations []protocol.Col
|
|||
}
|
||||
seen[id] = true
|
||||
if index, exists := positions[id]; exists {
|
||||
values[index] = finding
|
||||
values[index] = keepNewerTriage(values[index], finding)
|
||||
} else {
|
||||
positions[id] = len(values)
|
||||
values = append(values, finding)
|
||||
}
|
||||
}
|
||||
m.snapshot.Vulnerabilities = values
|
||||
m.restoreFindingSelection(selectedID)
|
||||
return true
|
||||
}
|
||||
|
||||
|
|
@ -443,6 +451,9 @@ func (m *Model) refreshAfterCollection(name string) tea.Cmd {
|
|||
return nil
|
||||
}
|
||||
m.selectedVuln = min(m.selectedVuln, max(0, len(m.snapshot.Vulnerabilities)-1))
|
||||
if m.modal == modalNone {
|
||||
m.selectVisibleFinding()
|
||||
}
|
||||
m.ensureVulnerabilityVisible()
|
||||
m.resizeVulnerabilityViewport()
|
||||
return nil
|
||||
|
|
|
|||
|
|
@ -26,10 +26,12 @@ import {
|
|||
fetchAll,
|
||||
fetchAuthStatus,
|
||||
fetchCapabilities,
|
||||
fetchRunSummary,
|
||||
fetchRuns,
|
||||
fetchTranscript,
|
||||
fetchVulnerabilities,
|
||||
fetchTriageRevision,
|
||||
updateFindingTriage,
|
||||
TriageRequestError,
|
||||
type TriageUpdate,
|
||||
forgetAuth,
|
||||
parseMcpConnectionStatus,
|
||||
type AuthStatus,
|
||||
|
|
@ -67,6 +69,13 @@ export default function App() {
|
|||
// Whether this viewer can steer a live scan (true only inside the in-TUI
|
||||
// launcher that shares the running scan's coordinator + event loop).
|
||||
const [canSteer, setCanSteer] = useState(false);
|
||||
const [issueFilter, setIssueFilter] = useState<"open" | "closed" | "all">("open");
|
||||
const activeRunRef = useRef(activeRun);
|
||||
activeRunRef.current = activeRun;
|
||||
const dataVersionRef = useRef(0);
|
||||
const mutationsPendingRef = useRef(0);
|
||||
const uncertainWritesRef = useRef(new Set<string>());
|
||||
const refreshCurrentRef = useRef<() => void>(() => {});
|
||||
|
||||
const refreshAuth = useCallback(async () => {
|
||||
try {
|
||||
|
|
@ -95,77 +104,110 @@ export default function App() {
|
|||
});
|
||||
}, [refreshAuth, refreshRuns]);
|
||||
|
||||
// Live polling, scoped to the active run. Re-runs when the active run changes
|
||||
// so switching to a past run (?run=<name>) reloads its data; a finished run
|
||||
// does a single full fetch and stops.
|
||||
const finishedRef = useRef(false);
|
||||
// Finished runs only poll a small file revision token. Live scans, external
|
||||
// triage edits and focus changes refresh the same authoritative projection.
|
||||
useEffect(() => {
|
||||
let cancelled = false;
|
||||
let timer: ReturnType<typeof setTimeout> | undefined;
|
||||
finishedRef.current = false;
|
||||
|
||||
const schedule = () => {
|
||||
timer = setTimeout(tick, POLL_MS);
|
||||
};
|
||||
let finished = false;
|
||||
let lastStamp = "";
|
||||
let forceRefresh = true;
|
||||
let busy = false;
|
||||
dataVersionRef.current += 1;
|
||||
|
||||
const tick = async () => {
|
||||
if (cancelled) return;
|
||||
if (cancelled || busy) return;
|
||||
if (timer) clearTimeout(timer);
|
||||
busy = true;
|
||||
const version = dataVersionRef.current;
|
||||
try {
|
||||
const { summary, raw, finished } = await fetchRunSummary(activeRun);
|
||||
if (cancelled) return;
|
||||
if (finished && !finishedRef.current) {
|
||||
finishedRef.current = true;
|
||||
const full = await fetchAll(activeRun);
|
||||
if (!cancelled) setRun(full);
|
||||
return; // stop polling
|
||||
}
|
||||
const [transcript, vulnerabilities] = await Promise.all([
|
||||
fetchTranscript(activeRun).catch(() => ({ agents: [], events: [] })),
|
||||
fetchVulnerabilities(summary.runId, activeRun).catch(() => [] as Vulnerability[]),
|
||||
]);
|
||||
if (cancelled) return;
|
||||
setRun((prev) => ({
|
||||
summary,
|
||||
raw,
|
||||
finished,
|
||||
transcript,
|
||||
vulnerabilities,
|
||||
reportMarkdown: prev?.reportMarkdown ?? null,
|
||||
}));
|
||||
schedule();
|
||||
if (mutationsPendingRef.current) return;
|
||||
const stamp = await fetchTriageRevision(activeRun);
|
||||
if (finished && stamp === lastStamp && !forceRefresh) return;
|
||||
const full = await fetchAll(activeRun);
|
||||
if (cancelled || version !== dataVersionRef.current || mutationsPendingRef.current) return;
|
||||
finished = full.finished;
|
||||
if (finished && lastStamp && stamp !== lastStamp) void refreshRuns();
|
||||
lastStamp = stamp;
|
||||
forceRefresh = false;
|
||||
setRun(full);
|
||||
setError(null);
|
||||
} catch (e) {
|
||||
if (cancelled) return;
|
||||
setError(e instanceof Error ? e.message : "Could not load run data.");
|
||||
schedule();
|
||||
} finally {
|
||||
busy = false;
|
||||
if (!cancelled) timer = setTimeout(tick, finished ? 1500 : POLL_MS);
|
||||
}
|
||||
};
|
||||
|
||||
(async () => {
|
||||
try {
|
||||
const full = await fetchAll(activeRun);
|
||||
if (cancelled) return;
|
||||
setRun(full);
|
||||
if (full.finished) {
|
||||
finishedRef.current = true;
|
||||
} else {
|
||||
schedule();
|
||||
}
|
||||
} catch (e) {
|
||||
if (cancelled) return;
|
||||
setError(e instanceof Error ? e.message : "Could not load run data.");
|
||||
schedule();
|
||||
}
|
||||
})();
|
||||
|
||||
const refresh = () => { forceRefresh = true; void tick(); };
|
||||
refreshCurrentRef.current = refresh;
|
||||
window.addEventListener("focus", refresh);
|
||||
void tick();
|
||||
return () => {
|
||||
cancelled = true;
|
||||
if (timer) clearTimeout(timer);
|
||||
window.removeEventListener("focus", refresh);
|
||||
};
|
||||
}, [activeRun]);
|
||||
}, [activeRun, refreshRuns]);
|
||||
|
||||
const saveTriage = useCallback(async (finding: Vulnerability, update: TriageUpdate) => {
|
||||
const requestedRun = activeRun;
|
||||
const requestKey = JSON.stringify([requestedRun, finding.id]);
|
||||
dataVersionRef.current += 1;
|
||||
mutationsPendingRef.current += 1;
|
||||
const applyFindings = (findings: Vulnerability[]) => {
|
||||
if (activeRunRef.current === requestedRun) {
|
||||
setRun((previous) => previous ? { ...previous, vulnerabilities: findings } : previous);
|
||||
}
|
||||
};
|
||||
try {
|
||||
if (uncertainWritesRef.current.has(requestKey)) {
|
||||
const latest = await fetchVulnerabilities(finding.scan_id, requestedRun);
|
||||
applyFindings(latest);
|
||||
uncertainWritesRef.current.delete(requestKey);
|
||||
const current = latest.find((item) => item.id === finding.id);
|
||||
if (!current || current.triage_revision !== finding.triage_revision || current.finding_digest !== finding.finding_digest) {
|
||||
throw new TriageRequestError("conflict", "The saved finding changed. Review its current state before trying again.");
|
||||
}
|
||||
}
|
||||
const saved = await updateFindingTriage(finding, update, requestedRun);
|
||||
if (activeRunRef.current === requestedRun) {
|
||||
setRun((previous) => previous ? {
|
||||
...previous,
|
||||
vulnerabilities: previous.vulnerabilities.map((item) => item.id === saved.id ? saved : item),
|
||||
} : previous);
|
||||
}
|
||||
void refreshRuns();
|
||||
return saved;
|
||||
} catch (error) {
|
||||
if (!(error instanceof TriageRequestError)) uncertainWritesRef.current.add(requestKey);
|
||||
// A lost response can follow a successful write. Read the saved state
|
||||
// before allowing another attempt, without automatically repeating it.
|
||||
try {
|
||||
const latest = await fetchVulnerabilities(finding.scan_id, requestedRun);
|
||||
applyFindings(latest);
|
||||
uncertainWritesRef.current.delete(requestKey);
|
||||
const saved = latest.find((item) => item.id === finding.id);
|
||||
if (!(error instanceof TriageRequestError) && saved &&
|
||||
saved.triage_revision === (finding.triage_revision ?? 0) + 1 &&
|
||||
saved.finding_digest === finding.finding_digest && saved.status === update.status &&
|
||||
(update.status === "open" || (saved.reason_code === (update.reason_code ?? "unspecified") &&
|
||||
(saved.status_note ?? "") === (update.note ?? "").trim()))) return saved;
|
||||
} catch { /* Leave the current view intact if reconciliation also fails. */ }
|
||||
if (error instanceof TriageRequestError) throw error;
|
||||
throw new Error("Could not confirm the save. The latest saved state will refresh before you retry.");
|
||||
} finally {
|
||||
mutationsPendingRef.current -= 1;
|
||||
dataVersionRef.current += 1;
|
||||
if (activeRunRef.current === requestedRun) refreshCurrentRef.current();
|
||||
}
|
||||
}, [activeRun, refreshRuns]);
|
||||
|
||||
const openFindings = useMemo(() => run?.vulnerabilities.filter((finding) => finding.status !== "closed") ?? [], [run]);
|
||||
const counts = useMemo(
|
||||
() => (run ? severityCounts(run.vulnerabilities) : null),
|
||||
[run]
|
||||
() => (run ? severityCounts(openFindings) : null),
|
||||
[run, openFindings]
|
||||
);
|
||||
const selected = run?.vulnerabilities.find((v) => v.id === selectedId) ?? null;
|
||||
const agentCount = run?.transcript.agents.length ?? 0;
|
||||
|
|
@ -228,6 +270,7 @@ export default function App() {
|
|||
setSelectedId(null);
|
||||
setRun(null);
|
||||
setError(null);
|
||||
setIssueFilter("open");
|
||||
// Reset the guard so the per-run default applies to the newly selected run.
|
||||
initialViewAppliedRef.current = false;
|
||||
}, []);
|
||||
|
|
@ -272,7 +315,7 @@ export default function App() {
|
|||
if (v === "history") openHistory();
|
||||
else userSetView(v);
|
||||
}}
|
||||
issuesCount={run?.vulnerabilities.length ?? 0}
|
||||
issuesCount={openFindings.length}
|
||||
agentCount={agentCount}
|
||||
mcpConnections={mcpConnections}
|
||||
mcpInUse={mcpInUse}
|
||||
|
|
@ -325,7 +368,7 @@ export default function App() {
|
|||
</div>
|
||||
|
||||
<div className="max-w-[88rem] mx-auto px-3 sm:px-6 py-8 sm:py-12 space-y-6">
|
||||
{error && !run && view !== "history" && view !== "email" && (
|
||||
{error && view !== "history" && view !== "email" && (
|
||||
<div className="rounded-lg px-4 py-3 flex gap-3 items-start border border-red-500/30 bg-red-500/5">
|
||||
<AlertCircle className="w-5 h-5 flex-shrink-0 mt-0.5 text-red-400" aria-hidden="true" />
|
||||
<p className="text-sm text-red-300">{error}</p>
|
||||
|
|
@ -383,7 +426,7 @@ export default function App() {
|
|||
Pentest Overview
|
||||
</TabButton>
|
||||
<TabButton active={view === "issues"} onClick={() => userSetView("issues")}>
|
||||
Issues{run.vulnerabilities.length > 0 ? ` (${run.vulnerabilities.length})` : ""}
|
||||
Issues{run.vulnerabilities.length > 0 ? ` (${openFindings.length} open)` : ""}
|
||||
</TabButton>
|
||||
{agentCount > 0 && (
|
||||
<TabButton active={view === "agents"} onClick={() => userSetView("agents")}>
|
||||
|
|
@ -396,7 +439,8 @@ export default function App() {
|
|||
<OverviewTab
|
||||
summary={run.summary}
|
||||
counts={counts}
|
||||
total={run.vulnerabilities.length}
|
||||
total={openFindings.length}
|
||||
detected={run.vulnerabilities.length}
|
||||
reportMarkdown={run.reportMarkdown}
|
||||
raw={run.raw}
|
||||
finished={run.finished}
|
||||
|
|
@ -412,12 +456,14 @@ export default function App() {
|
|||
>
|
||||
<ArrowLeft className="w-4 h-4" /> Back to all findings
|
||||
</button>
|
||||
<VulnerabilityDetail vulnerability={selected} />
|
||||
<VulnerabilityDetail vulnerability={{ ...selected, can_triage: selected.can_triage && !error }} onTriage={saveTriage} />
|
||||
</div>
|
||||
) : (
|
||||
<FindingsList
|
||||
vulnerabilities={run.vulnerabilities}
|
||||
finished={run.finished}
|
||||
filter={issueFilter}
|
||||
onFilter={setIssueFilter}
|
||||
onSelect={(id) => setSelectedId(id)}
|
||||
/>
|
||||
)}
|
||||
|
|
@ -550,16 +596,23 @@ function Meta({ label }: { label: string }) {
|
|||
function FindingsList({
|
||||
vulnerabilities,
|
||||
finished,
|
||||
filter,
|
||||
onFilter,
|
||||
onSelect,
|
||||
}: {
|
||||
vulnerabilities: Vulnerability[];
|
||||
finished: boolean;
|
||||
filter: "open" | "closed" | "all";
|
||||
onFilter: (filter: "open" | "closed" | "all") => void;
|
||||
onSelect: (id: string) => void;
|
||||
}) {
|
||||
const sorted = [...vulnerabilities].sort(
|
||||
const open = vulnerabilities.filter((finding) => finding.status !== "closed").length;
|
||||
const closed = vulnerabilities.length - open;
|
||||
const sorted = vulnerabilities.filter((finding) => filter === "all" ||
|
||||
(filter === "closed" ? finding.status === "closed" : finding.status !== "closed")).sort(
|
||||
(a, b) => SEVERITY_ORDER.indexOf(a.severity) - SEVERITY_ORDER.indexOf(b.severity)
|
||||
);
|
||||
if (sorted.length === 0) {
|
||||
if (vulnerabilities.length === 0) {
|
||||
return (
|
||||
<div className="space-y-4">
|
||||
<div className="rounded-xl border border-[#222] bg-[rgba(255,255,255,0.02)] p-8 text-center text-sm text-[#888]">
|
||||
|
|
@ -585,6 +638,22 @@ function FindingsList({
|
|||
}
|
||||
return (
|
||||
<div className="space-y-2">
|
||||
<div className="mb-4 flex flex-wrap items-center justify-between gap-3">
|
||||
<div className="flex gap-1 rounded-lg border border-[#333] p-1" aria-label="Finding status">
|
||||
{(["open", "closed", "all"] as const).map((value) => (
|
||||
<button type="button" key={value} aria-pressed={filter === value} onClick={() => onFilter(value)}
|
||||
className={`rounded-md px-3 py-1.5 text-sm capitalize ${filter === value ? "bg-white/10 text-white" : "text-[#888] hover:text-white"}`}>
|
||||
{value} ({value === "open" ? open : value === "closed" ? closed : vulnerabilities.length})
|
||||
</button>
|
||||
))}
|
||||
</div>
|
||||
<p className="text-sm text-[#888]">{open} open · {closed} false positives · {vulnerabilities.length} found</p>
|
||||
</div>
|
||||
{sorted.length === 0 && (
|
||||
<div className="rounded-xl border border-[#222] p-8 text-center text-sm text-[#aaa]">
|
||||
{filter === "open" ? `No open findings. ${closed} marked as false positives.` : "No closed findings."}
|
||||
</div>
|
||||
)}
|
||||
{sorted.map((v) => (
|
||||
<button
|
||||
key={v.id}
|
||||
|
|
@ -598,6 +667,7 @@ function FindingsList({
|
|||
<span className="block text-xs text-[#666] font-mono truncate">{v.target}</span>
|
||||
)}
|
||||
</span>
|
||||
{(v.status === "closed" || v.review_stale) && <span className="text-xs text-[#aaa]">{v.review_stale ? "Needs review" : "Closed · False positive"}</span>}
|
||||
<span
|
||||
className={`text-xs font-semibold px-2 py-0.5 rounded-full border capitalize ${SEVERITY_COLORS[v.severity]}`}
|
||||
>
|
||||
|
|
@ -646,13 +716,13 @@ function EmailReportCta({ onOpenEmail }: { onOpenEmail: () => void }) {
|
|||
<Mail className="h-4 w-4 text-emerald-400" aria-hidden="true" />
|
||||
</div>
|
||||
<div className="min-w-0 flex-1">
|
||||
<p className="text-sm font-semibold text-white">Email an encrypted PDF report of this run</p>
|
||||
<p className="text-sm font-semibold text-white">Email the original scan report as an encrypted PDF</p>
|
||||
<p className="mt-0.5 text-xs text-[#888]">
|
||||
Encrypted with a key only you can see, email verified with a one-time code before sending.
|
||||
Excludes subsequent triage. Encrypted with a key only you can see; email verified before sending.
|
||||
</p>
|
||||
</div>
|
||||
<span className="flex-shrink-0 rounded-lg bg-white px-3 py-1.5 text-xs font-semibold text-black transition-opacity group-hover:opacity-90">
|
||||
Export report to PDF
|
||||
Export original report
|
||||
</span>
|
||||
</div>
|
||||
</button>
|
||||
|
|
@ -663,6 +733,7 @@ function OverviewTab({
|
|||
summary,
|
||||
counts,
|
||||
total,
|
||||
detected,
|
||||
reportMarkdown,
|
||||
raw,
|
||||
finished,
|
||||
|
|
@ -671,6 +742,7 @@ function OverviewTab({
|
|||
summary: ParsedRunSummary;
|
||||
counts: Record<VulnerabilitySeverity, number>;
|
||||
total: number;
|
||||
detected: number;
|
||||
reportMarkdown: string | null;
|
||||
raw: Record<string, unknown>;
|
||||
finished: boolean;
|
||||
|
|
@ -693,8 +765,9 @@ function OverviewTab({
|
|||
<RunDetails raw={raw} durationSeconds={summary.durationSeconds} />
|
||||
</div>
|
||||
|
||||
{total > 0 && (
|
||||
{detected > 0 && (
|
||||
<div className="animate-card-in rounded-xl border border-[#222] bg-[rgba(255,255,255,0.02)] p-5">
|
||||
<p className="mb-3 text-sm text-[#aaa]">{total} open · {detected - total} false positives · {detected} found</p>
|
||||
<IssueSeveritySummary findings={{ total, ...counts }} />
|
||||
</div>
|
||||
)}
|
||||
|
|
@ -734,12 +807,14 @@ function OverviewTab({
|
|||
|
||||
{sections.length > 0 ? (
|
||||
<div className="animate-card-in rounded-xl border border-[#222] bg-[rgba(255,255,255,0.02)] p-5 space-y-8">
|
||||
<OriginalReportLabel />
|
||||
{sections.map((s) => (
|
||||
<ContentSection key={s.title} title={s.title} content={s.content} />
|
||||
))}
|
||||
</div>
|
||||
) : reportMarkdown ? (
|
||||
<div className="animate-card-in rounded-xl border border-[#222] bg-[rgba(255,255,255,0.02)] p-5">
|
||||
<OriginalReportLabel />
|
||||
<ContentSection content={dedupeHeadings(reportMarkdown)} />
|
||||
</div>
|
||||
) : (
|
||||
|
|
@ -752,6 +827,11 @@ function OverviewTab({
|
|||
);
|
||||
}
|
||||
|
||||
function OriginalReportLabel() {
|
||||
return <div className="mb-5"><h2 className="text-base font-semibold text-white">Original scan report</h2>
|
||||
<p className="mt-1 text-sm text-[#888]">Preserved as generated. Subsequent false-positive decisions are excluded; current triage counts appear above.</p></div>;
|
||||
}
|
||||
|
||||
function TabButton({
|
||||
active,
|
||||
onClick,
|
||||
|
|
|
|||
|
|
@ -192,9 +192,10 @@ export default function EmailReportView({
|
|||
<div className="flex items-center gap-2">
|
||||
<Mail className="h-5 w-5 text-[#888]" aria-hidden="true" />
|
||||
<h1 className="text-2xl font-semibold text-white">
|
||||
{verifyOnly ? "Verify your email" : "Export report to PDF"}
|
||||
{verifyOnly ? "Verify your email" : "Export original scan report"}
|
||||
</h1>
|
||||
</div>
|
||||
{!verifyOnly && <p className="text-sm text-[#aaa]">This PDF preserves the original detected findings. Subsequent false-positive decisions and local triage notes are excluded.</p>}
|
||||
|
||||
<div
|
||||
className="w-full rounded-2xl bg-[rgba(255,255,255,0.02)] p-6"
|
||||
|
|
@ -239,7 +240,7 @@ export default function EmailReportView({
|
|||
onClick={startFlow}
|
||||
className="w-full cursor-pointer rounded-lg bg-white px-4 py-2.5 text-sm font-semibold text-black transition-opacity hover:opacity-90"
|
||||
>
|
||||
Export report
|
||||
Export original report
|
||||
</button>
|
||||
{verified && auth?.email && (
|
||||
<p className="text-center text-xs text-[#666]">Sending to {auth.email}</p>
|
||||
|
|
|
|||
|
|
@ -22,7 +22,7 @@ const SEV = [
|
|||
function SeverityChips({ counts }: { counts: RunSeverityCounts }) {
|
||||
const shown = SEV.filter((s) => counts[s.key] > 0);
|
||||
if (shown.length === 0) {
|
||||
return <span className="text-xs text-[#555]">No findings</span>;
|
||||
return <span className="text-xs text-[#888]">No open findings</span>;
|
||||
}
|
||||
return (
|
||||
<div className="flex items-center gap-3">
|
||||
|
|
@ -164,6 +164,7 @@ export default function PastRunsView({
|
|||
{date && <span>{date}</span>}
|
||||
{date && run.status && <span className="text-[#333]">·</span>}
|
||||
{run.status && <span className="capitalize">{run.status}</span>}
|
||||
{run.open_count !== undefined && <span>· {run.open_count} open · {run.closed_count ?? 0} false positives · {run.detected_count ?? run.open_count} found</span>}
|
||||
</div>
|
||||
</div>
|
||||
<SeverityChips counts={run.severity_counts} />
|
||||
|
|
|
|||
|
|
@ -264,7 +264,7 @@ export default function Sidebar({
|
|||
{finished && (
|
||||
<NavItem
|
||||
icon={<Mail className="h-4 w-4" />}
|
||||
label="Export report"
|
||||
label="Export original report"
|
||||
active={view === "email"}
|
||||
onClick={onOpenEmail}
|
||||
/>
|
||||
|
|
|
|||
|
|
@ -0,0 +1,142 @@
|
|||
import { useEffect, useRef, useState } from "react";
|
||||
import type { TriageUpdate } from "@/data/serverSource";
|
||||
import { TRIAGE_REASONS, type TriageReason, type Vulnerability } from "@/types/issues";
|
||||
|
||||
export type SaveTriage = (finding: Vulnerability, update: TriageUpdate) => Promise<Vulnerability>;
|
||||
|
||||
const buttonClass = "cursor-pointer rounded-lg border border-[#444] px-3 py-1.5 text-sm text-white hover:bg-white/5 disabled:cursor-not-allowed disabled:opacity-50";
|
||||
|
||||
export function TriageControls({ finding, onSave }: { finding: Vulnerability; onSave: SaveTriage }) {
|
||||
const [reviewed, setReviewed] = useState<Vulnerability | null>(null);
|
||||
const [reason, setReason] = useState<TriageReason>("unspecified");
|
||||
const [note, setNote] = useState("");
|
||||
const [pending, setPending] = useState(false);
|
||||
const [error, setError] = useState<string | null>(null);
|
||||
const [undo, setUndo] = useState<{ finding: Vulnerability; update: TriageUpdate } | null>(null);
|
||||
const [message, setMessage] = useState<string | null>(null);
|
||||
const triggerRef = useRef<HTMLButtonElement>(null);
|
||||
const reasonRef = useRef<HTMLSelectElement>(null);
|
||||
const focusAfterSaveRef = useRef(false);
|
||||
|
||||
useEffect(() => {
|
||||
if (reviewed) reasonRef.current?.focus();
|
||||
}, [reviewed]);
|
||||
useEffect(() => {
|
||||
if (focusAfterSaveRef.current && !pending && !reviewed) {
|
||||
focusAfterSaveRef.current = false;
|
||||
triggerRef.current?.focus();
|
||||
}
|
||||
}, [pending, reviewed]);
|
||||
useEffect(() => {
|
||||
if (undo && (undo.finding.triage_revision !== finding.triage_revision ||
|
||||
undo.finding.finding_digest !== finding.finding_digest)) {
|
||||
setUndo(null);
|
||||
setMessage(null);
|
||||
}
|
||||
}, [finding.triage_revision, finding.finding_digest, undo]);
|
||||
useEffect(() => {
|
||||
if (!undo) return;
|
||||
const timer = setTimeout(() => setUndo(null), 10000);
|
||||
return () => clearTimeout(timer);
|
||||
}, [undo]);
|
||||
|
||||
const closeForm = () => {
|
||||
setReviewed(null);
|
||||
setError(null);
|
||||
triggerRef.current?.focus();
|
||||
};
|
||||
const save = async (snapshot: Vulnerability, update: TriageUpdate, undoing = false) => {
|
||||
if (pending) return;
|
||||
setPending(true);
|
||||
setError(null);
|
||||
try {
|
||||
const saved = await onSave(snapshot, update);
|
||||
focusAfterSaveRef.current = true;
|
||||
setReviewed(null);
|
||||
setMessage(update.status === "closed" ? "Marked as a false positive." : "Finding reopened.");
|
||||
setUndo(undoing ? null : {
|
||||
finding: saved,
|
||||
update: snapshot.status === "closed"
|
||||
? { status: "closed", reason_code: snapshot.reason_code, note: snapshot.status_note ?? "" }
|
||||
: { status: "open" },
|
||||
});
|
||||
} catch (err) {
|
||||
setError(err instanceof Error ? err.message : "Could not save this decision. Try again.");
|
||||
} finally {
|
||||
setPending(false);
|
||||
}
|
||||
};
|
||||
const changed = reviewed && (
|
||||
reviewed.triage_revision !== finding.triage_revision || reviewed.finding_digest !== finding.finding_digest
|
||||
);
|
||||
|
||||
return (
|
||||
<div className="space-y-3">
|
||||
<div className="flex flex-wrap items-center gap-3">
|
||||
<button
|
||||
ref={triggerRef}
|
||||
type="button"
|
||||
disabled={!finding.can_triage || pending}
|
||||
className={buttonClass}
|
||||
onClick={() => {
|
||||
setError(null);
|
||||
setMessage(null);
|
||||
if (finding.status === "closed") void save(finding, { status: "open" });
|
||||
else setReviewed(finding);
|
||||
}}
|
||||
>
|
||||
{pending ? "Saving…" : finding.status === "closed" ? "Reopen" : "Mark as false positive"}
|
||||
</button>
|
||||
{!finding.can_triage && <span className="text-xs text-[#999]">Triage is unavailable for this finding or run.</span>}
|
||||
{message && <span className="text-sm text-[#aaa]" role="status">{message}</span>}
|
||||
{undo && (
|
||||
<button type="button" className="text-sm text-white underline disabled:opacity-50" disabled={pending}
|
||||
onClick={() => void save(undo.finding, undo.update, true)}>Undo</button>
|
||||
)}
|
||||
</div>
|
||||
{error && <p role="alert" className="text-sm text-red-300">{error}</p>}
|
||||
{reviewed && (
|
||||
<form
|
||||
className="max-w-2xl space-y-4 rounded-xl border border-[#444] bg-[#111] p-4 sm:p-5"
|
||||
aria-labelledby="triage-title"
|
||||
onSubmit={(event) => {
|
||||
event.preventDefault();
|
||||
if (!changed) void save(reviewed, { status: "closed", reason_code: reason, note });
|
||||
}}
|
||||
onKeyDown={(event) => {
|
||||
if (event.key === "Escape" && !pending) { event.preventDefault(); closeForm(); }
|
||||
}}
|
||||
>
|
||||
<div>
|
||||
<h2 id="triage-title" className="text-base font-semibold text-white">Mark as false positive</h2>
|
||||
<p className="mt-1 text-sm text-[#aaa]">This finding is incorrect or does not apply to your target.</p>
|
||||
<p className="mt-1 text-xs text-[#888]">Applies to this finding in this run. A later scan may report it again.</p>
|
||||
</div>
|
||||
<label className="block text-sm text-[#bbb]">
|
||||
Reason (optional)
|
||||
<select ref={reasonRef} value={reason} disabled={pending}
|
||||
onChange={(event) => setReason(event.target.value as TriageReason)}
|
||||
className="mt-1.5 block w-full rounded-lg border border-[#444] bg-[#161616] px-3 py-2 text-sm text-white">
|
||||
{Object.entries(TRIAGE_REASONS).map(([value, label]) => <option value={value} key={value}>{label}</option>)}
|
||||
</select>
|
||||
</label>
|
||||
<label className="block text-sm text-[#bbb]">
|
||||
Note (optional)
|
||||
<textarea value={note} onChange={(event) => setNote(event.target.value)} maxLength={2000}
|
||||
disabled={pending} rows={3} placeholder="Add context for your future review"
|
||||
className="mt-1.5 block w-full resize-y rounded-lg border border-[#444] bg-[#161616] px-3 py-2 text-sm text-white" />
|
||||
</label>
|
||||
{changed && <p role="alert" className="text-sm text-amber-300">This finding changed while the form was open. Cancel and review its current evidence before marking it again.</p>}
|
||||
<div className="flex flex-wrap items-center justify-between gap-3">
|
||||
<button type="button" onClick={closeForm} disabled={pending} className="text-sm text-[#aaa] hover:text-white disabled:opacity-50">Not sure? Keep open for review</button>
|
||||
<div className="flex gap-2">
|
||||
<button type="button" onClick={closeForm} disabled={pending} className={buttonClass}>Cancel</button>
|
||||
<button type="submit" disabled={pending || !!changed || !finding.can_triage}
|
||||
className="rounded-lg bg-white px-3 py-1.5 text-sm font-semibold text-black disabled:opacity-50">{pending ? "Saving…" : "Close issue"}</button>
|
||||
</div>
|
||||
</div>
|
||||
</form>
|
||||
)}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
|
@ -3,7 +3,8 @@
|
|||
import React, { useState } from "react";
|
||||
import { Clock, CheckCircle2, Ban, History, BellOff, Wrench, GitMerge } from "lucide-react";
|
||||
import { SIGNUP_URL, ctaUrl, trackCta } from "@/lib/cta";
|
||||
import { Vulnerability, VulnerabilityStatus, SEVERITY_COLORS, STATUS_META, isSeverityOverridden } from "@/types/issues";
|
||||
import { Vulnerability, VulnerabilityStatus, SEVERITY_COLORS, STATUS_META, TRIAGE_REASONS, isSeverityOverridden } from "@/types/issues";
|
||||
import { TriageControls, type SaveTriage } from "@/components/vulnerability/TriageControls";
|
||||
import { formatTimeAgo } from "@/lib/utils";
|
||||
import { getSeverityDot } from "@/lib/vulnerability-utils";
|
||||
import { formatStrixId } from "@/lib/display-number";
|
||||
|
|
@ -21,6 +22,7 @@ function bannerTime(dateString: string | null): string {
|
|||
|
||||
const STATUS_BANNER: Record<VulnerabilityStatus, { icon: React.ElementType; label: string; iconColor: string } | null> = {
|
||||
open: null,
|
||||
closed: { icon: Ban, label: "Marked as a false positive", iconColor: "text-[#aaa]" },
|
||||
in_progress: { icon: Clock, label: "Marked as In Progress", iconColor: "text-blue-400" },
|
||||
snoozed: { icon: BellOff, label: "Snoozed", iconColor: "text-purple-400" },
|
||||
fixed: { icon: CheckCircle2, label: "Marked as Fixed", iconColor: "text-emerald-400" },
|
||||
|
|
@ -40,6 +42,7 @@ const WORKFLOW_CTAS: { label: string; slug: string; icon: React.ElementType; req
|
|||
|
||||
interface VulnerabilityDetailProps {
|
||||
vulnerability: Vulnerability;
|
||||
onTriage: SaveTriage;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -47,8 +50,9 @@ interface VulnerabilityDetailProps {
|
|||
* without page chrome. Shared by the public /share/issues page and the local
|
||||
* /results view so both render findings identically.
|
||||
*/
|
||||
export default function VulnerabilityDetail({ vulnerability }: VulnerabilityDetailProps) {
|
||||
export default function VulnerabilityDetail({ vulnerability, onTriage }: VulnerabilityDetailProps) {
|
||||
const currentMeta = STATUS_META[vulnerability.status];
|
||||
const statusLabel = vulnerability.review_stale ? "Needs review" : currentMeta.label;
|
||||
const hasCodeLocations = vulnerability.code_locations && vulnerability.code_locations.length > 0;
|
||||
const hasFix = hasCodeLocations || vulnerability.remediation_steps;
|
||||
const hasReproduction = !!(vulnerability.evidence || vulnerability.assumptions || vulnerability.poc_description || vulnerability.poc_script_code);
|
||||
|
|
@ -76,7 +80,7 @@ export default function VulnerabilityDetail({ vulnerability }: VulnerabilityDeta
|
|||
</div>
|
||||
<div className="flex flex-wrap items-center gap-3">
|
||||
<span className={`inline-flex items-center gap-1.5 px-3 py-1 text-sm font-medium rounded-full border ${currentMeta.color}`}>
|
||||
{currentMeta.label}
|
||||
{statusLabel}
|
||||
</span>
|
||||
<div
|
||||
className={`inline-flex items-center gap-1.5 px-3 py-1 text-sm font-semibold rounded-full border ${SEVERITY_COLORS[vulnerability.severity]}`}
|
||||
|
|
@ -120,6 +124,14 @@ export default function VulnerabilityDetail({ vulnerability }: VulnerabilityDeta
|
|||
</div>
|
||||
</div>
|
||||
|
||||
<TriageControls finding={vulnerability} onSave={onTriage} />
|
||||
|
||||
{vulnerability.review_stale && (
|
||||
<p className="rounded-lg border border-amber-500/30 bg-amber-500/5 p-4 text-sm text-amber-200" role="status">
|
||||
Evidence changed since the previous false-positive decision. This finding is open for review.
|
||||
</p>
|
||||
)}
|
||||
|
||||
{/* Status banner */}
|
||||
{vulnerability.status !== "open" && (() => {
|
||||
const banner = STATUS_BANNER[vulnerability.status];
|
||||
|
|
@ -132,8 +144,11 @@ export default function VulnerabilityDetail({ vulnerability }: VulnerabilityDeta
|
|||
<p className="text-sm font-semibold text-white">
|
||||
{banner.label}{bannerTime(vulnerability.status_changed_at)}
|
||||
</p>
|
||||
{vulnerability.reason_code && vulnerability.reason_code !== "unspecified" && (
|
||||
<p className="mt-1 text-sm text-[#aaa]">{TRIAGE_REASONS[vulnerability.reason_code]}</p>
|
||||
)}
|
||||
{vulnerability.status_note && (
|
||||
<p className="text-sm text-[#666] italic mt-1">
|
||||
<p className="text-sm text-[#aaa] whitespace-pre-wrap break-words mt-1">
|
||||
“{vulnerability.status_note}”
|
||||
</p>
|
||||
)}
|
||||
|
|
@ -253,7 +268,7 @@ export default function VulnerabilityDetail({ vulnerability }: VulnerabilityDeta
|
|||
statusSlot={
|
||||
<span className={`inline-flex items-center gap-1.5 px-2.5 py-1 text-xs font-medium rounded-full border ${currentMeta.color}`}>
|
||||
<div className={`w-1.5 h-1.5 rounded-full ${currentMeta.dotColor}`} />
|
||||
{currentMeta.label}
|
||||
{statusLabel}
|
||||
</span>
|
||||
}
|
||||
/>
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
import type { Vulnerability } from "@/types/issues";
|
||||
import type { TriageReason, Vulnerability } from "@/types/issues";
|
||||
import {
|
||||
parseRunJson,
|
||||
parseVulnerabilitiesJson,
|
||||
|
|
@ -84,7 +84,11 @@ export interface LoadedRun {
|
|||
|
||||
async function getJson(path: string): Promise<unknown> {
|
||||
const res = await fetch(path, { cache: "no-store" });
|
||||
if (!res.ok) throw new Error(`${path} responded ${res.status}`);
|
||||
if (!res.ok) {
|
||||
const data = await res.json().catch(() => null);
|
||||
if (data?.error === "invalid_triage") throw new Error("The saved triage file could not be read. Findings have not been refreshed; repair the file before continuing.");
|
||||
throw new Error(`Could not refresh run data (${res.status}).`);
|
||||
}
|
||||
return res.json();
|
||||
}
|
||||
|
||||
|
|
@ -113,6 +117,52 @@ export async function fetchVulnerabilities(
|
|||
return parseVulnerabilitiesJson(JSON.stringify(arr), runId);
|
||||
}
|
||||
|
||||
export async function fetchTriageRevision(runName?: string | null): Promise<string> {
|
||||
const data = await getJson("/api/triage/revision" + runQuery(runName)) as { revision: unknown };
|
||||
return JSON.stringify(data.revision);
|
||||
}
|
||||
|
||||
export interface TriageUpdate {
|
||||
status: "open" | "closed";
|
||||
reason_code?: TriageReason;
|
||||
note?: string;
|
||||
}
|
||||
|
||||
export class TriageRequestError extends Error {
|
||||
constructor(public code: string, message: string) {
|
||||
super(message);
|
||||
}
|
||||
}
|
||||
|
||||
export async function updateFindingTriage(
|
||||
finding: Vulnerability,
|
||||
update: TriageUpdate,
|
||||
runName?: string | null,
|
||||
): Promise<Vulnerability> {
|
||||
const { ok, data } = await postJson(
|
||||
`/api/vulnerabilities/${encodeURIComponent(finding.id)}/triage` + runQuery(runName),
|
||||
{
|
||||
...update,
|
||||
expected_revision: finding.triage_revision ?? 0,
|
||||
reviewed_digest: finding.finding_digest ?? "",
|
||||
},
|
||||
);
|
||||
if (!ok || !data.finding || typeof data.finding !== "object") {
|
||||
const code = String(data.error ?? "unavailable");
|
||||
const messages: Record<string, string> = {
|
||||
conflict: "This finding changed. Review the latest evidence and reopen the form before saving.",
|
||||
invalid_triage: "The saved triage file could not be read. Fix it before changing this finding.",
|
||||
read_only: "This run is read-only. Its findings cannot be changed.",
|
||||
unknown_finding: "This finding is no longer available in the run.",
|
||||
unverified: "Verify your email to access this historical run.",
|
||||
forbidden: "Your viewer session has expired. Reopen the viewer using its authorized link.",
|
||||
invalid_request: "The decision could not be saved. Check the form and try again.",
|
||||
};
|
||||
throw new TriageRequestError(code, messages[code] ?? "Could not save this decision. Try again.");
|
||||
}
|
||||
return parseVulnerabilitiesJson(JSON.stringify([data.finding]), finding.scan_id)[0];
|
||||
}
|
||||
|
||||
export async function fetchReportMarkdown(runName?: string | null): Promise<string | null> {
|
||||
const obj = (await getJson("/api/report" + runQuery(runName))) as { markdown?: string };
|
||||
return obj?.markdown ?? null;
|
||||
|
|
@ -130,7 +180,7 @@ export async function fetchTranscript(runName?: string | null): Promise<Transcri
|
|||
export async function fetchAll(runName?: string | null): Promise<LoadedRun> {
|
||||
const { summary, raw, finished } = await fetchRunSummary(runName);
|
||||
const [vulnerabilities, reportMarkdown, transcript] = await Promise.all([
|
||||
fetchVulnerabilities(summary.runId, runName).catch(() => [] as Vulnerability[]),
|
||||
fetchVulnerabilities(summary.runId, runName),
|
||||
fetchReportMarkdown(runName).catch(() => null),
|
||||
fetchTranscript(runName).catch(() => ({ agents: [], events: [] }) as Transcript),
|
||||
]);
|
||||
|
|
@ -161,6 +211,9 @@ export interface RunListEntry {
|
|||
end_time: string | null;
|
||||
finished: boolean;
|
||||
severity_counts: RunSeverityCounts;
|
||||
open_count?: number;
|
||||
closed_count?: number;
|
||||
detected_count?: number;
|
||||
}
|
||||
|
||||
export interface RunsPayload {
|
||||
|
|
@ -277,7 +330,7 @@ export async function sendReport(runName?: string | null): Promise<SendReportRes
|
|||
return {
|
||||
ok: true,
|
||||
password: String(data.password ?? ""),
|
||||
filename: String(data.filename ?? "strix-report.pdf"),
|
||||
filename: String(data.filename ?? "strix-original-scan-report.pdf"),
|
||||
};
|
||||
}
|
||||
return { ok: false, error: String(data.error ?? "unavailable") };
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@ import type {
|
|||
VulnerabilitySeverity,
|
||||
VulnerabilityStatus,
|
||||
} from "@/types/issues";
|
||||
import { TRIAGE_REASONS } from "@/types/issues";
|
||||
|
||||
/**
|
||||
* Pure, dependency-free parsers that turn a Strix CLI local run
|
||||
|
|
@ -196,7 +197,7 @@ function parseOneVulnerability(
|
|||
? (cweRaw.filter((c) => typeof c === "string" && c) as string[])
|
||||
: null;
|
||||
|
||||
const status: VulnerabilityStatus = "open";
|
||||
const status: VulnerabilityStatus = raw.status === "closed" ? "closed" : "open";
|
||||
|
||||
return {
|
||||
...emptyVulnerabilityDefaults(),
|
||||
|
|
@ -206,6 +207,18 @@ function parseOneVulnerability(
|
|||
description: asStringOrNull(raw.description) ?? "",
|
||||
severity: coerceSeverity(raw.severity),
|
||||
status,
|
||||
triage_status: raw.triage_status === "closed" ? "closed" : "open",
|
||||
resolution_reason: raw.resolution_reason === "false_positive" ? "false_positive" : null,
|
||||
reason_code: typeof raw.reason_code === "string" && Object.hasOwn(TRIAGE_REASONS, raw.reason_code)
|
||||
? raw.reason_code as Vulnerability["reason_code"] : "unspecified",
|
||||
triage_revision: typeof raw.triage_revision === "number" && Number.isSafeInteger(raw.triage_revision)
|
||||
? raw.triage_revision : 0,
|
||||
finding_digest: asStringOrNull(raw.finding_digest) ?? "",
|
||||
review_stale: raw.review_stale === true,
|
||||
can_triage: raw.can_triage === true && typeof raw.id === "string" && !!raw.id,
|
||||
status_note: asStringOrNull(raw.status_note),
|
||||
status_changed_at: asStringOrNull(raw.status_changed_at),
|
||||
status_changed_by: asStringOrNull(raw.status_changed_by),
|
||||
created_at: toIsoTimestamp(raw.timestamp),
|
||||
cve: asStringOrNull(raw.cve),
|
||||
cvss: asNumberOrNull(raw.cvss),
|
||||
|
|
|
|||
|
|
@ -1,19 +1,29 @@
|
|||
export type VulnerabilitySeverity = "critical" | "high" | "medium" | "low";
|
||||
export type VulnerabilityStatus = "open" | "in_progress" | "snoozed" | "fixed" | "ignored";
|
||||
export type VulnerabilityStatus = "open" | "closed" | "in_progress" | "snoozed" | "fixed" | "ignored";
|
||||
export type TriageReason = "unspecified" | "incorrect_assumption" | "existing_protection" | "not_affected" | "expected_behavior" | "other";
|
||||
export const TRIAGE_REASONS: Record<TriageReason, string> = {
|
||||
unspecified: "Select a reason",
|
||||
incorrect_assumption: "Incorrect assumption",
|
||||
existing_protection: "Existing protection prevents the reported exploit",
|
||||
not_affected: "Code or dependency is not affected",
|
||||
expected_behavior: "Expected behavior, not a vulnerability",
|
||||
other: "Other",
|
||||
};
|
||||
export type FixEffort = "trivial" | "low" | "medium" | "high";
|
||||
|
||||
export const ACTIVE_STATUSES: VulnerabilityStatus[] = ["open", "in_progress", "snoozed"];
|
||||
export const RESOLVED_STATUSES: VulnerabilityStatus[] = ["fixed", "ignored"];
|
||||
export const RESOLVED_STATUSES: VulnerabilityStatus[] = ["closed", "fixed", "ignored"];
|
||||
|
||||
// Statuses worth retesting in a "retest all" — everything except ignored
|
||||
// (fixed issues are still re-verified; ignored issues are intentionally skipped).
|
||||
export const RETESTABLE_STATUSES: VulnerabilityStatus[] = ["open", "in_progress", "snoozed", "fixed"];
|
||||
|
||||
export const ALL_STATUSES: VulnerabilityStatus[] = ["open", "in_progress", "snoozed", "fixed", "ignored"];
|
||||
export const ALL_STATUSES: VulnerabilityStatus[] = ["open", "closed", "in_progress", "snoozed", "fixed", "ignored"];
|
||||
|
||||
export interface StatusCounts {
|
||||
all: number;
|
||||
open: number;
|
||||
closed: number;
|
||||
in_progress: number;
|
||||
snoozed: number;
|
||||
fixed: number;
|
||||
|
|
@ -28,6 +38,12 @@ export interface StatusMeta {
|
|||
}
|
||||
|
||||
export const STATUS_META: Record<VulnerabilityStatus, StatusMeta> = {
|
||||
closed: {
|
||||
label: "Closed · False positive",
|
||||
color: "bg-gray-500/10 text-gray-300 border-gray-500/20",
|
||||
dotColor: "bg-gray-400",
|
||||
description: "Marked as a false positive in this run",
|
||||
},
|
||||
open: {
|
||||
label: "Open",
|
||||
color: "bg-red-500/10 text-red-400 border-red-500/20",
|
||||
|
|
@ -100,6 +116,13 @@ export interface Vulnerability {
|
|||
potential_risk_saving: number | null;
|
||||
risk_saving_description: string | null;
|
||||
status: VulnerabilityStatus;
|
||||
triage_status?: "open" | "closed";
|
||||
resolution_reason?: "false_positive" | null;
|
||||
reason_code?: TriageReason;
|
||||
triage_revision?: number;
|
||||
finding_digest?: string;
|
||||
review_stale?: boolean;
|
||||
can_triage?: boolean;
|
||||
severity: VulnerabilitySeverity;
|
||||
impact: string | null;
|
||||
endpoint: string | null;
|
||||
|
|
@ -176,6 +199,7 @@ export const SEVERITY_COLORS: Record<VulnerabilitySeverity, string> = {
|
|||
|
||||
export const STATUS_COLORS: Record<VulnerabilityStatus, string> = {
|
||||
open: STATUS_META.open.color,
|
||||
closed: STATUS_META.closed.color,
|
||||
in_progress: STATUS_META.in_progress.color,
|
||||
snoozed: STATUS_META.snoozed.color,
|
||||
fixed: STATUS_META.fixed.color,
|
||||
|
|
|
|||
|
|
@ -5,7 +5,8 @@ severity grid, per-finding detail with colored severity badges) but is rendered
|
|||
entirely locally with reportlab, so it ships without a browser or heavy system
|
||||
deps and keeps the report on the user's machine.
|
||||
|
||||
The PDF carries FULL finding detail, including proof-of-concept scripts, so it
|
||||
The PDF preserves the original scan findings and excludes subsequent local
|
||||
triage decisions. It carries FULL finding detail, including proof-of-concept scripts, so it
|
||||
is encrypted end to end with AES-256. The password is generated locally with a
|
||||
CSPRNG, shown only to the local browser, and never leaves the machine except in
|
||||
the user's own hands. Strix cannot read the delivered report.
|
||||
|
|
@ -419,11 +420,17 @@ def _cover(
|
|||
Spacer(1, 150),
|
||||
Paragraph("PENETRATION TEST REPORT", styles["badge_label"]),
|
||||
Spacer(1, 20),
|
||||
Paragraph("Security Assessment", styles["cover_title"]),
|
||||
Paragraph("Original scan report", styles["cover_title"]),
|
||||
Paragraph(_esc(target), styles["cover_org"]),
|
||||
Spacer(1, 14),
|
||||
Paragraph(
|
||||
"Includes all detected findings. Subsequent local triage decisions, "
|
||||
"including false-positive closures and notes, are excluded.",
|
||||
styles["body"],
|
||||
),
|
||||
Spacer(1, 28),
|
||||
meta_table,
|
||||
Spacer(1, 90),
|
||||
Spacer(1, 50),
|
||||
confidential,
|
||||
PageBreak(),
|
||||
]
|
||||
|
|
@ -610,7 +617,7 @@ def _overview_flowables(
|
|||
Spacer(1, 16),
|
||||
_severity_grid(styles, counts),
|
||||
Spacer(1, 10),
|
||||
Paragraph(f"<b>{total}</b> total findings across this assessment.", styles["body"]),
|
||||
Paragraph(f"<b>{total}</b> detected findings across this assessment.", styles["body"]),
|
||||
]
|
||||
scan_results = record.get("scan_results")
|
||||
if not isinstance(scan_results, dict):
|
||||
|
|
@ -634,7 +641,7 @@ def _overview_flowables(
|
|||
|
||||
|
||||
def generate_report_pdf(run_dir: Path) -> bytes:
|
||||
"""Render a branded, full-detail PDF report for the run at ``run_dir``."""
|
||||
"""Render the original scan report, without applying the local triage overlay."""
|
||||
record = read_run_summary(run_dir)
|
||||
vulns = [v for v in read_vulnerabilities(run_dir) if isinstance(v, dict)]
|
||||
counts = severity_counts(vulns)
|
||||
|
|
@ -645,7 +652,7 @@ def generate_report_pdf(run_dir: Path) -> bytes:
|
|||
doc = SimpleDocTemplate(
|
||||
buffer,
|
||||
pagesize=A4,
|
||||
title="Strix Security Report",
|
||||
title="Strix Original Scan Report",
|
||||
author="Strix",
|
||||
leftMargin=20 * mm,
|
||||
rightMargin=20 * mm,
|
||||
|
|
@ -658,7 +665,7 @@ def generate_report_pdf(run_dir: Path) -> bytes:
|
|||
story.extend(_overview_flowables(styles, record, len(vulns), counts))
|
||||
|
||||
story.append(PageBreak())
|
||||
story.append(_section(styles, "Findings"))
|
||||
story.append(_section(styles, "Detected findings"))
|
||||
story.append(Spacer(1, 16))
|
||||
if vulns:
|
||||
for index, vuln in enumerate(vulns, start=1):
|
||||
|
|
@ -693,7 +700,7 @@ def build_encrypted_report(run_dir: Path) -> tuple[bytes, str, str]:
|
|||
pdf_bytes = generate_report_pdf(run_dir)
|
||||
password = generate_password()
|
||||
encrypted = encrypt_pdf(pdf_bytes, password)
|
||||
filename = f"strix-report-{run_name}.pdf"
|
||||
filename = f"strix-original-scan-report-{run_name}.pdf"
|
||||
return encrypted, password, filename
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -4,8 +4,8 @@ Design notes:
|
|||
- Uses only the standard library (no new runtime dependency). The workload is
|
||||
serving static files plus a handful of JSON reads off disk, so an async stack
|
||||
buys nothing here.
|
||||
- The browser polls the JSON endpoints (~1s) rather than using SSE: a finished
|
||||
run stops polling, and short-lived polls survive sleep/network blips without
|
||||
- The browser polls the JSON endpoints rather than using SSE: finished runs
|
||||
poll a small revision token, and short-lived polls survive sleep/network blips without
|
||||
server-side connection state, which suits a stdlib ThreadingHTTPServer.
|
||||
- All reads happen per-request straight from disk, so the same server serves a
|
||||
live in-progress run and a finished one identically; the SPA distinguishes
|
||||
|
|
@ -23,7 +23,7 @@ import webbrowser
|
|||
from http import HTTPStatus
|
||||
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||||
from pathlib import Path
|
||||
from typing import TYPE_CHECKING, Any
|
||||
from typing import TYPE_CHECKING, Any, cast
|
||||
from urllib.parse import parse_qs, unquote, urlencode, urlsplit
|
||||
|
||||
from strix.core.paths import run_record_path
|
||||
|
|
@ -33,9 +33,14 @@ from strix.interface.viewer.transcript import (
|
|||
primary_target,
|
||||
read_report_markdown,
|
||||
read_run_summary,
|
||||
read_vulnerabilities,
|
||||
severity_counts,
|
||||
)
|
||||
from strix.report.triage import (
|
||||
TriageError,
|
||||
read_triaged_vulnerabilities,
|
||||
triage_finding,
|
||||
triage_stamp,
|
||||
)
|
||||
|
||||
|
||||
if TYPE_CHECKING:
|
||||
|
|
@ -66,6 +71,8 @@ def _iter_run_dirs(base_dir: Path) -> list[Path]:
|
|||
def run_list_entry(run_dir: Path) -> dict[str, Any]:
|
||||
"""Compact summary of a single run for the history list."""
|
||||
record = read_run_summary(run_dir)
|
||||
findings = read_triaged_vulnerabilities(run_dir)
|
||||
active = [finding for finding in findings if finding.get("status") != "closed"]
|
||||
return {
|
||||
"name": record.get("run_name") or run_dir.name,
|
||||
"target": primary_target(record),
|
||||
|
|
@ -74,7 +81,10 @@ def run_list_entry(run_dir: Path) -> dict[str, Any]:
|
|||
"start_time": record.get("start_time"),
|
||||
"end_time": record.get("end_time"),
|
||||
"finished": bool(record.get("finished")),
|
||||
"severity_counts": severity_counts(read_vulnerabilities(run_dir)),
|
||||
"severity_counts": severity_counts(active),
|
||||
"open_count": len(active),
|
||||
"closed_count": len(findings) - len(active),
|
||||
"detected_count": len(findings),
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -163,6 +173,8 @@ def _make_handler(state: _ViewerState) -> type[BaseHTTPRequestHandler]:
|
|||
# The browser closed the connection mid-response (e.g. it
|
||||
# navigated away between polls). Not an error.
|
||||
logger.debug("viewer client disconnected during %s", path)
|
||||
except TriageError as exc:
|
||||
self._send_triage_error(exc)
|
||||
except Exception:
|
||||
# A bad request must never kill the worker thread.
|
||||
logger.exception("viewer request failed: %s", path)
|
||||
|
|
@ -185,10 +197,14 @@ def _make_handler(state: _ViewerState) -> type[BaseHTTPRequestHandler]:
|
|||
self._handle_feedback()
|
||||
elif path == "/api/agents/steer":
|
||||
self._handle_steer()
|
||||
elif path.startswith("/api/vulnerabilities/") and path.endswith("/triage"):
|
||||
self._handle_triage(path)
|
||||
else:
|
||||
self._send_json(HTTPStatus.NOT_FOUND, {"error": "unknown endpoint"})
|
||||
except BrokenPipeError:
|
||||
logger.debug("viewer client disconnected during POST %s", path)
|
||||
except TriageError as exc:
|
||||
self._send_triage_error(exc)
|
||||
except Exception:
|
||||
# A bad request must never kill the worker thread.
|
||||
logger.exception("viewer request failed: POST %s", path)
|
||||
|
|
@ -278,7 +294,9 @@ def _make_handler(state: _ViewerState) -> type[BaseHTTPRequestHandler]:
|
|||
if path == "/api/run":
|
||||
self._send_json(HTTPStatus.OK, read_run_summary(run_dir))
|
||||
elif path == "/api/vulnerabilities":
|
||||
self._send_json(HTTPStatus.OK, read_vulnerabilities(run_dir))
|
||||
self._send_json(HTTPStatus.OK, read_triaged_vulnerabilities(run_dir))
|
||||
elif path == "/api/triage/revision":
|
||||
self._send_json(HTTPStatus.OK, {"revision": triage_stamp(run_dir)})
|
||||
elif path == "/api/report":
|
||||
self._send_json(HTTPStatus.OK, {"markdown": read_report_markdown(run_dir)})
|
||||
elif path == "/api/transcript":
|
||||
|
|
@ -286,6 +304,114 @@ def _make_handler(state: _ViewerState) -> type[BaseHTTPRequestHandler]:
|
|||
else:
|
||||
self._send_json(HTTPStatus.NOT_FOUND, {"error": "unknown endpoint"})
|
||||
|
||||
def _handle_triage(self, path: str) -> None:
|
||||
if not self._has_session():
|
||||
self._send_json(HTTPStatus.FORBIDDEN, {"error": "forbidden"})
|
||||
return
|
||||
# The capability cookie is host-scoped. An unrelated local server
|
||||
# must not be able to exercise it using cross-origin browser writes.
|
||||
origin = self.headers.get("Origin")
|
||||
expected_origin = f"http://{self.headers.get('Host', '')}"
|
||||
if origin != expected_origin or self.headers.get("Sec-Fetch-Site") not in (
|
||||
None,
|
||||
"same-origin",
|
||||
):
|
||||
self._send_json(HTTPStatus.FORBIDDEN, {"error": "forbidden_origin"})
|
||||
return
|
||||
if self.headers.get_content_type() != "application/json":
|
||||
self._send_json(HTTPStatus.UNSUPPORTED_MEDIA_TYPE, {"error": "invalid_request"})
|
||||
return
|
||||
run_dir = self._triage_run()
|
||||
if run_dir is None:
|
||||
return
|
||||
finding_id = unquote(path.removeprefix("/api/vulnerabilities/").removesuffix("/triage"))
|
||||
if not finding_id or "/" in finding_id or "\\" in finding_id:
|
||||
self._send_json(HTTPStatus.BAD_REQUEST, {"error": "invalid_request"})
|
||||
return
|
||||
body = self._read_triage_body()
|
||||
if body is None:
|
||||
return
|
||||
result = triage_finding(
|
||||
run_dir,
|
||||
finding_id,
|
||||
status=body["status"],
|
||||
expected_revision=body["expected_revision"],
|
||||
reviewed_digest=body["reviewed_digest"],
|
||||
reason_code=body.get("reason_code", "unspecified"),
|
||||
note=body.get("note", ""),
|
||||
surface="viewer",
|
||||
)
|
||||
self._send_json(HTTPStatus.OK, result)
|
||||
|
||||
def _triage_run(self) -> Path | None:
|
||||
query = parse_qs(urlsplit(self.path).query)
|
||||
run_values = query.get("run", [])
|
||||
run_param = run_values[0] if run_values else None
|
||||
if len(run_values) > 1 or (
|
||||
run_param is not None
|
||||
and (run_param in {".", ".."} or "/" in run_param or "\\" in run_param)
|
||||
):
|
||||
self._send_json(HTTPStatus.NOT_FOUND, {"error": "unknown_run"})
|
||||
return None
|
||||
requested = state.base_dir / run_param if run_param else state.run_dir
|
||||
if requested.is_symlink():
|
||||
self._send_json(HTTPStatus.FORBIDDEN, {"error": "read_only"})
|
||||
return None
|
||||
run_dir = resolve_run_dir(state.base_dir, run_param, state.run_dir)
|
||||
if run_dir is None:
|
||||
self._send_json(HTTPStatus.NOT_FOUND, {"error": "unknown_run"})
|
||||
return None
|
||||
if run_dir.resolve() != state.run_dir.resolve() and not auth.is_verified():
|
||||
self._send_json(HTTPStatus.UNAUTHORIZED, {"error": "unverified"})
|
||||
return None
|
||||
return run_dir
|
||||
|
||||
def _read_triage_body(self) -> dict[str, Any] | None:
|
||||
try:
|
||||
length = int(self.headers.get("Content-Length", "0"))
|
||||
except ValueError:
|
||||
length = -1
|
||||
if not 0 < length <= 32768 or self.headers.get("Transfer-Encoding"):
|
||||
self.close_connection = True
|
||||
status = (
|
||||
HTTPStatus.REQUEST_ENTITY_TOO_LARGE
|
||||
if length > 32768
|
||||
else HTTPStatus.BAD_REQUEST
|
||||
)
|
||||
self._send_json(status, {"error": "invalid_request"})
|
||||
return None
|
||||
try:
|
||||
body = json.loads(self.rfile.read(length))
|
||||
except (ValueError, UnicodeDecodeError):
|
||||
body = None
|
||||
if not isinstance(body, dict):
|
||||
self._send_json(HTTPStatus.BAD_REQUEST, {"error": "invalid_request"})
|
||||
return None
|
||||
body = cast("dict[str, Any]", body)
|
||||
allowed = {"status", "expected_revision", "reviewed_digest", "reason_code", "note"}
|
||||
if (
|
||||
set(body) - allowed
|
||||
or not {"status", "expected_revision", "reviewed_digest"}.issubset(body)
|
||||
or not isinstance(body.get("status"), str)
|
||||
or type(body.get("expected_revision")) is not int
|
||||
or not isinstance(body.get("reviewed_digest"), str)
|
||||
or not isinstance(body.get("reason_code", "unspecified"), str)
|
||||
or not isinstance(body.get("note", ""), str)
|
||||
):
|
||||
self._send_json(HTTPStatus.BAD_REQUEST, {"error": "invalid_request"})
|
||||
return None
|
||||
return body
|
||||
|
||||
def _send_triage_error(self, exc: TriageError) -> None:
|
||||
status = {
|
||||
"conflict": HTTPStatus.CONFLICT,
|
||||
"invalid_request": HTTPStatus.BAD_REQUEST,
|
||||
"unknown_finding": HTTPStatus.NOT_FOUND,
|
||||
"invalid_triage": HTTPStatus.CONFLICT,
|
||||
"read_only": HTTPStatus.FORBIDDEN,
|
||||
}.get(exc.code, HTTPStatus.SERVICE_UNAVAILABLE)
|
||||
self._send_json(status, {"error": exc.code, "message": str(exc)})
|
||||
|
||||
def _handle_auth_status(self) -> None:
|
||||
# The cached verified email is only disclosed to a caller holding this
|
||||
# process's session capability, so a cookie-less client on an exposed
|
||||
|
|
|
|||
File diff suppressed because one or more lines are too long
10
strix/interface/viewer/static/assets/index-CBqNY5AA.css
Normal file
10
strix/interface/viewer/static/assets/index-CBqNY5AA.css
Normal file
File diff suppressed because one or more lines are too long
512
strix/interface/viewer/static/assets/index-CY2QniKa.js
Normal file
512
strix/interface/viewer/static/assets/index-CY2QniKa.js
Normal file
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
|
|
@ -6,8 +6,8 @@
|
|||
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
|
||||
<meta name="color-scheme" content="dark" />
|
||||
<title>Strix Results</title>
|
||||
<script type="module" crossorigin src="./assets/index-B94ANU8d.js"></script>
|
||||
<link rel="stylesheet" crossorigin href="./assets/index-DN__rVv3.css">
|
||||
<script type="module" crossorigin src="./assets/index-CY2QniKa.js"></script>
|
||||
<link rel="stylesheet" crossorigin href="./assets/index-CBqNY5AA.css">
|
||||
</head>
|
||||
<body>
|
||||
<div id="root"></div>
|
||||
|
|
|
|||
339
strix/report/triage.py
Normal file
339
strix/report/triage.py
Normal file
|
|
@ -0,0 +1,339 @@
|
|||
"""Local human finding triage shared by the terminal UI and web viewer.
|
||||
|
||||
Scan evidence is never changed. The overlay is scoped to a run and reviewed
|
||||
evidence digest; updated evidence becomes active until it is reviewed again.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import json
|
||||
import logging
|
||||
import re
|
||||
from collections import Counter
|
||||
from datetime import UTC, datetime
|
||||
from typing import TYPE_CHECKING, Any, cast
|
||||
|
||||
from strix.report.triage_store import (
|
||||
TriageError,
|
||||
can_write_triage,
|
||||
locked_store,
|
||||
read_json,
|
||||
triage_stamp,
|
||||
write_store,
|
||||
)
|
||||
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from collections.abc import Sequence
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
REASON_CODES = (
|
||||
"unspecified",
|
||||
"incorrect_assumption",
|
||||
"existing_protection",
|
||||
"not_affected",
|
||||
"expected_behavior",
|
||||
"other",
|
||||
)
|
||||
MAX_NOTE_LENGTH = 2000
|
||||
logger = logging.getLogger(__name__)
|
||||
_ID = re.compile(r"[A-Za-z0-9][A-Za-z0-9_.-]{0,127}\Z")
|
||||
_DIGEST = re.compile(r"[0-9a-f]{64}\Z")
|
||||
# Evidence, impact and scope determine what was reviewed. Titles, suggested
|
||||
# fixes, timestamps and display formatting do not invalidate a human review.
|
||||
_EVIDENCE_FIELDS = (
|
||||
"description",
|
||||
"impact",
|
||||
"technical_analysis",
|
||||
"evidence",
|
||||
"assumptions",
|
||||
"counterevidence",
|
||||
"confidence",
|
||||
"confidence_rationale",
|
||||
"severity_change_conditions",
|
||||
"poc_description",
|
||||
"poc_script_code",
|
||||
"target",
|
||||
"endpoint",
|
||||
"method",
|
||||
"cwe",
|
||||
"cve",
|
||||
"severity",
|
||||
"cvss",
|
||||
"code_locations",
|
||||
"dependency_metadata",
|
||||
"http_exchange_ids",
|
||||
)
|
||||
|
||||
|
||||
def _normalized(value: Any) -> Any:
|
||||
if isinstance(value, str):
|
||||
return value.replace("\r\n", "\n").strip()
|
||||
if isinstance(value, dict):
|
||||
return {key: _normalized(item) for key, item in cast("dict[str, Any]", value).items()}
|
||||
if isinstance(value, list):
|
||||
items = cast("Sequence[Any]", value)
|
||||
return [_normalized(item) for item in items]
|
||||
return value
|
||||
|
||||
|
||||
def finding_digest(finding: dict[str, Any]) -> str:
|
||||
evidence = {key: _normalized(finding.get(key)) for key in _EVIDENCE_FIELDS}
|
||||
# Remediation suggestions inside locations are not evidence changes.
|
||||
locations = evidence.get("code_locations")
|
||||
if isinstance(locations, list):
|
||||
code_locations = cast("Sequence[Any]", locations)
|
||||
evidence["code_locations"] = [
|
||||
{
|
||||
key: value
|
||||
for key, value in cast("dict[str, Any]", location).items()
|
||||
if key not in {"fix_before", "fix_after"}
|
||||
}
|
||||
if isinstance(location, dict)
|
||||
else location
|
||||
for location in code_locations
|
||||
]
|
||||
payload = json.dumps(evidence, sort_keys=True, ensure_ascii=False, default=str)
|
||||
return hashlib.sha256(payload.encode("utf-8")).hexdigest()
|
||||
|
||||
|
||||
def _run_identity(run_dir: Path) -> dict[str, Any]:
|
||||
record = read_json(run_dir / "run.json", default={})
|
||||
if not isinstance(record, dict):
|
||||
raise TriageError("invalid_triage", "The run record is malformed.")
|
||||
record = cast("dict[str, Any]", record)
|
||||
return {
|
||||
"run_id": record.get("run_id") or record.get("run_name") or run_dir.name,
|
||||
"start_time": record.get("start_time"),
|
||||
}
|
||||
|
||||
|
||||
def _valid_id(value: Any) -> bool:
|
||||
return isinstance(value, str) and _ID.fullmatch(value) is not None
|
||||
|
||||
|
||||
def _validate_decision(decision: Any) -> None:
|
||||
if not isinstance(decision, dict):
|
||||
raise TriageError("invalid_triage", "A saved review is malformed.")
|
||||
decision = cast("dict[str, Any]", decision)
|
||||
status = decision.get("status")
|
||||
if (
|
||||
not isinstance(status, str)
|
||||
or status not in {"open", "closed"}
|
||||
or type(decision.get("revision")) is not int
|
||||
or decision["revision"] < 1
|
||||
or decision.get("reason_code") not in REASON_CODES
|
||||
or not isinstance(decision.get("note"), str)
|
||||
or len(decision["note"]) > MAX_NOTE_LENGTH
|
||||
or not isinstance(decision.get("changed_at"), str)
|
||||
or decision.get("changed_by") != "local_operator"
|
||||
or not isinstance(decision.get("reviewed_digest"), str)
|
||||
or not _DIGEST.fullmatch(decision["reviewed_digest"])
|
||||
or decision.get("resolution_reason") != ("false_positive" if status == "closed" else None)
|
||||
):
|
||||
raise TriageError("invalid_triage", "A saved review has unsupported fields.")
|
||||
|
||||
|
||||
def _read_store(run_dir: Path) -> dict[str, Any]:
|
||||
identity = _run_identity(run_dir)
|
||||
missing = object()
|
||||
document = read_json(run_dir / "triage.json", default=missing)
|
||||
if document is missing:
|
||||
return {"schema_version": 1, "run_identity": identity, "findings": {}}
|
||||
if not isinstance(document, dict):
|
||||
raise TriageError("invalid_triage", "Review data belongs to another run or is unsupported.")
|
||||
document = cast("dict[str, Any]", document)
|
||||
if (
|
||||
type(document.get("schema_version")) is not int
|
||||
or document["schema_version"] != 1
|
||||
or document.get("run_identity") != identity
|
||||
or not isinstance(document.get("findings"), dict)
|
||||
):
|
||||
raise TriageError("invalid_triage", "Review data belongs to another run or is unsupported.")
|
||||
for finding_id, raw_decision in cast("dict[str, Any]", document["findings"]).items():
|
||||
if not _valid_id(finding_id):
|
||||
raise TriageError("invalid_triage", "A saved finding ID is invalid.")
|
||||
_validate_decision(raw_decision)
|
||||
decision = cast("dict[str, Any]", raw_decision)
|
||||
history = decision.get("history")
|
||||
if not isinstance(history, list):
|
||||
raise TriageError("invalid_triage", "Review history is malformed.")
|
||||
entries = cast("Sequence[Any]", history)
|
||||
if len(entries) != decision["revision"]:
|
||||
raise TriageError("invalid_triage", "Review history is malformed.")
|
||||
for index, entry in enumerate(entries, 1):
|
||||
_validate_decision(entry)
|
||||
if entry["revision"] != index:
|
||||
raise TriageError("invalid_triage", "Review history revisions are inconsistent.")
|
||||
if {key: value for key, value in decision.items() if key != "history"} != entries[-1]:
|
||||
raise TriageError("invalid_triage", "Review history does not match the saved decision.")
|
||||
return document
|
||||
|
||||
|
||||
def _read_findings(run_dir: Path) -> list[dict[str, Any]]:
|
||||
reports = read_json(run_dir / "vulnerabilities.json", default=[], limit=128 * 1024 * 1024)
|
||||
if not isinstance(reports, list):
|
||||
raise TriageError("invalid_triage", "The finding list is malformed.")
|
||||
records = cast("Sequence[Any]", reports)
|
||||
if any(not isinstance(item, dict) for item in records):
|
||||
raise TriageError("invalid_triage", "The finding list is malformed.")
|
||||
return cast("list[dict[str, Any]]", records)
|
||||
|
||||
|
||||
def _project(
|
||||
report: dict[str, Any], decision: dict[str, Any] | None, *, writable: bool
|
||||
) -> dict[str, Any]:
|
||||
saved = decision or {}
|
||||
digest = finding_digest(report)
|
||||
stored_status = saved.get("status", "open")
|
||||
stale = stored_status == "closed" and saved.get("reviewed_digest") != digest
|
||||
return {
|
||||
**report,
|
||||
"status": "open" if stale else stored_status,
|
||||
"triage_status": stored_status,
|
||||
"resolution_reason": saved.get("resolution_reason"),
|
||||
"reason_code": saved.get("reason_code", "unspecified"),
|
||||
"status_note": saved.get("note") or None,
|
||||
"status_changed_at": saved.get("changed_at"),
|
||||
"status_changed_by": saved.get("changed_by"),
|
||||
"triage_revision": saved.get("revision", 0),
|
||||
"finding_digest": digest,
|
||||
"review_stale": stale,
|
||||
"can_triage": writable,
|
||||
"triage_history": saved.get("history", []),
|
||||
}
|
||||
|
||||
|
||||
def read_triaged_vulnerabilities(
|
||||
run_dir: Path, reports: list[dict[str, Any]] | None = None
|
||||
) -> list[dict[str, Any]]:
|
||||
"""Join a validated sidecar with disk or in-memory evidence without mutating it."""
|
||||
document = _read_store(run_dir)
|
||||
raw = _read_findings(run_dir) if reports is None else reports
|
||||
ids = Counter(item.get("id") for item in raw if _valid_id(item.get("id")))
|
||||
writable = can_write_triage(run_dir)
|
||||
return [
|
||||
_project(
|
||||
report,
|
||||
document["findings"].get(report.get("id")) if _valid_id(report.get("id")) else None,
|
||||
writable=writable and _valid_id(report.get("id")) and ids[report["id"]] == 1,
|
||||
)
|
||||
for report in raw
|
||||
]
|
||||
|
||||
|
||||
def _validate_request(
|
||||
finding_id: Any,
|
||||
status: Any,
|
||||
expected_revision: Any,
|
||||
reviewed_digest: Any,
|
||||
reason_code: Any,
|
||||
note: Any,
|
||||
surface: Any,
|
||||
) -> None:
|
||||
if (
|
||||
not _valid_id(finding_id)
|
||||
or not isinstance(status, str)
|
||||
or status not in {"open", "closed"}
|
||||
or type(expected_revision) is not int
|
||||
or expected_revision < 0
|
||||
or not isinstance(reviewed_digest, str)
|
||||
or not _DIGEST.fullmatch(reviewed_digest)
|
||||
or not isinstance(reason_code, str)
|
||||
or reason_code not in REASON_CODES
|
||||
or not isinstance(note, str)
|
||||
or len(note) > MAX_NOTE_LENGTH
|
||||
or not isinstance(surface, str)
|
||||
or surface not in {"viewer", "tui"}
|
||||
):
|
||||
raise TriageError("invalid_request", "Invalid finding review request.")
|
||||
|
||||
|
||||
def triage_finding(
|
||||
run_dir: Path,
|
||||
finding_id: str,
|
||||
*,
|
||||
status: str,
|
||||
expected_revision: int,
|
||||
reviewed_digest: str,
|
||||
reason_code: str = "unspecified",
|
||||
note: str = "",
|
||||
surface: str,
|
||||
) -> dict[str, Any]:
|
||||
"""Commit a human decision, then enqueue only its bounded classification metadata."""
|
||||
_validate_request(
|
||||
finding_id, status, expected_revision, reviewed_digest, reason_code, note, surface
|
||||
)
|
||||
with locked_store(run_dir):
|
||||
if not (run_dir / "run.json").is_file():
|
||||
raise TriageError("unknown_finding", "The run record is missing.")
|
||||
document = _read_store(run_dir)
|
||||
reports = _read_findings(run_dir)
|
||||
matches = [report for report in reports if report.get("id") == finding_id]
|
||||
if len(matches) != 1:
|
||||
raise TriageError("unknown_finding", "The finding is missing or its ID is ambiguous.")
|
||||
report = matches[0]
|
||||
old = document["findings"].get(finding_id)
|
||||
previous = _project(report, old, writable=True)
|
||||
if previous["finding_digest"] != reviewed_digest:
|
||||
raise TriageError("conflict", "Finding evidence changed. Reload and review it again.")
|
||||
reason = reason_code if status == "closed" else "unspecified"
|
||||
saved_note = note.strip() if status == "closed" else ""
|
||||
same = (
|
||||
previous["status"] == status
|
||||
and not previous["review_stale"]
|
||||
and previous["reason_code"] == reason
|
||||
and (previous["status_note"] or "") == saved_note
|
||||
)
|
||||
# A retry with the immediately preceding revision is an idempotent no-op.
|
||||
revision = previous["triage_revision"]
|
||||
if expected_revision != revision:
|
||||
if same and old is not None and expected_revision == revision - 1:
|
||||
return {"changed": False, "finding": previous}
|
||||
raise TriageError(
|
||||
"conflict", "This finding was reviewed elsewhere. Reload before saving."
|
||||
)
|
||||
if same:
|
||||
return {"changed": False, "finding": previous}
|
||||
decision: dict[str, Any] = {
|
||||
"status": status,
|
||||
"resolution_reason": "false_positive" if status == "closed" else None,
|
||||
"reason_code": reason,
|
||||
"note": saved_note,
|
||||
"changed_at": datetime.now(UTC).isoformat(),
|
||||
"changed_by": "local_operator",
|
||||
"revision": revision + 1,
|
||||
"reviewed_digest": reviewed_digest,
|
||||
}
|
||||
history: list[dict[str, Any]] = [*(old["history"] if old else []), decision.copy()]
|
||||
document["findings"][finding_id] = {**decision, "history": history}
|
||||
write_store(run_dir, document)
|
||||
result = _project(report, document["findings"][finding_id], writable=True)
|
||||
# Notes-only edits remain entirely local. Never allow analytics failure to
|
||||
# turn a committed local review into an apparent save failure.
|
||||
if (
|
||||
previous["status"] != status
|
||||
or previous["reason_code"] != reason
|
||||
or previous["review_stale"]
|
||||
):
|
||||
try:
|
||||
from strix.telemetry.triage import record_triage # noqa: PLC0415
|
||||
|
||||
record_triage(previous, result, run_dir=run_dir, surface=surface)
|
||||
except Exception: # noqa: BLE001
|
||||
logger.debug("Saved review metric was skipped")
|
||||
return {"changed": True, "finding": result}
|
||||
|
||||
|
||||
__all__ = [
|
||||
"MAX_NOTE_LENGTH",
|
||||
"REASON_CODES",
|
||||
"TriageError",
|
||||
"can_write_triage",
|
||||
"finding_digest",
|
||||
"read_triaged_vulnerabilities",
|
||||
"triage_finding",
|
||||
"triage_stamp",
|
||||
]
|
||||
190
strix/report/triage_store.py
Normal file
190
strix/report/triage_store.py
Normal file
|
|
@ -0,0 +1,190 @@
|
|||
"""Bounded, atomic storage for human review decisions, separate from scan output."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import contextlib
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import stat
|
||||
import sys
|
||||
import tempfile
|
||||
import threading
|
||||
import time
|
||||
from pathlib import Path
|
||||
from typing import TYPE_CHECKING, Any
|
||||
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from collections.abc import Generator
|
||||
|
||||
|
||||
MAX_STORE_BYTES = 16 * 1024 * 1024
|
||||
LOCK_TIMEOUT = 3.0
|
||||
_locks: dict[Path, threading.Lock] = {}
|
||||
_locks_guard = threading.Lock()
|
||||
|
||||
|
||||
class TriageError(Exception):
|
||||
"""A user-actionable review failure with a stable interface error code."""
|
||||
|
||||
def __init__(self, code: str, message: str) -> None:
|
||||
super().__init__(message)
|
||||
self.code = code
|
||||
|
||||
|
||||
def regular_file(path: Path) -> bool:
|
||||
try:
|
||||
return stat.S_ISREG(path.lstat().st_mode)
|
||||
except FileNotFoundError:
|
||||
return True
|
||||
except OSError:
|
||||
return False
|
||||
|
||||
|
||||
def can_write_triage(run_dir: Path) -> bool:
|
||||
"""Read-only capability check. Never creates a sidecar or lockfile."""
|
||||
try:
|
||||
if run_dir.is_symlink() or not run_dir.is_dir() or not (run_dir / "run.json").is_file():
|
||||
return False
|
||||
if not run_dir.stat().st_mode & 0o222 or not os.access(run_dir, os.W_OK):
|
||||
return False
|
||||
for name in ("triage.json", "triage.lock", "run.json", "vulnerabilities.json"):
|
||||
path = run_dir / name
|
||||
if not regular_file(path):
|
||||
return False
|
||||
if (
|
||||
name in {"triage.json", "triage.lock"}
|
||||
and path.exists()
|
||||
and (not path.stat().st_mode & 0o222 or not os.access(path, os.W_OK))
|
||||
):
|
||||
return False
|
||||
except OSError:
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def read_json(path: Path, *, default: Any, limit: int = MAX_STORE_BYTES) -> Any:
|
||||
"""Read a regular file only, rejecting links/devices and malformed contents."""
|
||||
flags = os.O_RDONLY | getattr(os, "O_NOFOLLOW", 0) | getattr(os, "O_NONBLOCK", 0)
|
||||
try:
|
||||
if not regular_file(path):
|
||||
raise TriageError("invalid_triage", "Run data must be a regular file, not a link.")
|
||||
descriptor = os.open(path, flags)
|
||||
with os.fdopen(descriptor, "rb") as stream:
|
||||
info = os.fstat(stream.fileno())
|
||||
if not stat.S_ISREG(info.st_mode) or info.st_size > limit:
|
||||
raise TriageError("invalid_triage", "Run data is not a supported regular file.")
|
||||
content = stream.read(limit + 1)
|
||||
if len(content) > limit:
|
||||
raise TriageError("invalid_triage", "Run data exceeds the supported size.")
|
||||
return json.loads(content)
|
||||
except FileNotFoundError:
|
||||
return default
|
||||
except (ValueError, UnicodeError, RecursionError) as exc:
|
||||
raise TriageError(
|
||||
"invalid_triage", "Run data is malformed; no decisions were changed."
|
||||
) from exc
|
||||
except OSError as exc:
|
||||
raise TriageError("unavailable", "Could not read the run's review data.") from exc
|
||||
|
||||
|
||||
def triage_stamp(run_dir: Path) -> tuple[int, int]:
|
||||
"""Opaque token for review/evidence changes, including resumed finished runs."""
|
||||
stamps: list[tuple[int, int, int]] = []
|
||||
for name in ("triage.json", "vulnerabilities.json", "run.json"):
|
||||
try:
|
||||
info = (run_dir / name).lstat()
|
||||
stamps.append((info.st_mtime_ns, info.st_size, info.st_ino))
|
||||
except FileNotFoundError:
|
||||
stamps.append((0, 0, 0))
|
||||
except OSError:
|
||||
stamps.append((-1, -1, -1))
|
||||
digest = hashlib.sha256(repr(stamps).encode("ascii")).digest()
|
||||
# Keep each number exactly representable in browser JavaScript.
|
||||
return int.from_bytes(digest[:6]), int.from_bytes(digest[6:12])
|
||||
|
||||
|
||||
def _file_lock(descriptor: int, *, unlock: bool = False) -> None:
|
||||
if sys.platform == "win32":
|
||||
import msvcrt # noqa: PLC0415
|
||||
|
||||
os.lseek(descriptor, 0, os.SEEK_SET)
|
||||
msvcrt.locking(descriptor, msvcrt.LK_UNLCK if unlock else msvcrt.LK_NBLCK, 1)
|
||||
else:
|
||||
import fcntl # noqa: PLC0415
|
||||
|
||||
fcntl.flock(descriptor, fcntl.LOCK_UN if unlock else fcntl.LOCK_EX | fcntl.LOCK_NB)
|
||||
|
||||
|
||||
@contextlib.contextmanager
|
||||
def locked_store(run_dir: Path) -> Generator[None]:
|
||||
"""Serialize threads and processes using a stable inode, never the replaced JSON."""
|
||||
if not can_write_triage(run_dir):
|
||||
raise TriageError("read_only", "This run is read-only or has unsafe review file paths.")
|
||||
with _locks_guard:
|
||||
thread_lock = _locks.setdefault(run_dir.resolve(), threading.Lock())
|
||||
if not thread_lock.acquire(timeout=LOCK_TIMEOUT):
|
||||
raise TriageError("unavailable", "Another review is being saved. Try again.")
|
||||
descriptor: int | None = None
|
||||
acquired = False
|
||||
try:
|
||||
path = run_dir / "triage.lock"
|
||||
flags = os.O_RDWR | os.O_CREAT | getattr(os, "O_NOFOLLOW", 0) | getattr(os, "O_NONBLOCK", 0)
|
||||
descriptor = os.open(path, flags, 0o600)
|
||||
if not stat.S_ISREG(os.fstat(descriptor).st_mode):
|
||||
raise TriageError("read_only", "The review lock must be a regular file.")
|
||||
deadline = time.monotonic() + LOCK_TIMEOUT
|
||||
while True:
|
||||
try:
|
||||
_file_lock(descriptor)
|
||||
acquired = True
|
||||
break
|
||||
except OSError:
|
||||
if time.monotonic() >= deadline:
|
||||
raise TriageError(
|
||||
"unavailable", "Could not lock review data. Try again."
|
||||
) from None
|
||||
time.sleep(0.025)
|
||||
yield
|
||||
except PermissionError as exc:
|
||||
raise TriageError("read_only", "This run's review data is read-only.") from exc
|
||||
except OSError as exc:
|
||||
raise TriageError(
|
||||
"unavailable", "Could not save the review. Reload before retrying."
|
||||
) from exc
|
||||
finally:
|
||||
if descriptor is not None:
|
||||
if acquired:
|
||||
with contextlib.suppress(OSError):
|
||||
_file_lock(descriptor, unlock=True)
|
||||
with contextlib.suppress(OSError):
|
||||
os.close(descriptor)
|
||||
thread_lock.release()
|
||||
|
||||
|
||||
def write_store(run_dir: Path, document: dict[str, Any]) -> None:
|
||||
"""Commit complete JSON durably; callers must hold locked_store."""
|
||||
payload = json.dumps(document, ensure_ascii=False, indent=2).encode("utf-8")
|
||||
if len(payload) > MAX_STORE_BYTES:
|
||||
raise TriageError("invalid_triage", "Review history exceeds the supported size.")
|
||||
path = run_dir / "triage.json"
|
||||
if not regular_file(path):
|
||||
raise TriageError("invalid_triage", "Review data must be a regular file, not a link.")
|
||||
temporary: Path | None = None
|
||||
try:
|
||||
with tempfile.NamedTemporaryFile(dir=run_dir, prefix=".triage-", delete=False) as stream:
|
||||
temporary = Path(stream.name)
|
||||
stream.write(payload)
|
||||
stream.flush()
|
||||
os.fsync(stream.fileno())
|
||||
temporary.replace(path)
|
||||
if os.name != "nt":
|
||||
descriptor = os.open(run_dir, os.O_RDONLY | getattr(os, "O_DIRECTORY", 0))
|
||||
try:
|
||||
os.fsync(descriptor)
|
||||
finally:
|
||||
os.close(descriptor)
|
||||
finally:
|
||||
if temporary is not None:
|
||||
temporary.unlink(missing_ok=True)
|
||||
|
|
@ -17,13 +17,30 @@ We collect only very **basic** usage data including:
|
|||
**Scan Context:** Scan mode (quick/standard/deep), scan type (whitebox/blackbox)\
|
||||
**Model Usage:** Which LLM model is being used and whether it runs via an API key or a model subscription (not prompts or responses)\
|
||||
**Feature Usage:** Which built-in skills were used during a scan (reported once, at scan end)\
|
||||
**Aggregate Metrics:** Vulnerability counts by severity and weakness category (CWE)
|
||||
**Aggregate Metrics:** Vulnerability counts by severity and weakness category (CWE)\
|
||||
**Finding Triage:** Saved classification changes from the local web viewer and terminal UI, as described below
|
||||
|
||||
### False-Positive Triage
|
||||
|
||||
Closing a finding as a false positive and reopening it work locally whether telemetry is enabled or disabled. Classification changes include closing, reopening, a changed reason category, or a fresh review after evidence changes. When enabled, a successfully saved classification change can emit `finding_triage_changed` with:
|
||||
|
||||
- Source interface: `viewer` or `tui`
|
||||
- Previous and new status and resolution, plus an optional predefined reason category (`reason_code`)
|
||||
- Finding severity, weakness category (CWE), and whether a CVE is present
|
||||
- Scan mode and the common Strix/Python version, OS, and architecture properties
|
||||
|
||||
The event uses the existing random process-only session identifier. It excludes notes, titles, descriptions, evidence, proof-of-concept scripts, code, targets, URLs, paths, email addresses, run names, finding IDs, and local finding digests. Freeform text is never included; categories are validated against a fixed vocabulary.
|
||||
|
||||
Events are emitted after the local decision is saved and sent asynchronously on a best-effort basis. Delivery may be dropped when the process exits or the in-memory queue is full. Delivery failure does not affect the saved decision. Failed changes, repeated no-op submissions, reading a run, and notes-only edits do not emit classification events. There is no persisted analytics backlog, and enabling telemetry later does not replay actions taken while it was disabled.
|
||||
|
||||
These events describe user-reported classification trends, not an independently verified scanner false-positive rate. They do not provide persistent user or finding tracking across processes.
|
||||
|
||||
### What We **Never** Collect
|
||||
|
||||
- Usernames, or any identifying information
|
||||
- Scan targets, file paths, target URLs, or domains
|
||||
- Vulnerability details, descriptions, or code
|
||||
- Vulnerability details, descriptions, code, or written triage notes
|
||||
- Finding IDs, run names, or local finding digests
|
||||
- LLM requests and responses
|
||||
|
||||
### How to Opt Out
|
||||
|
|
|
|||
|
|
@ -91,6 +91,11 @@ def finding(severity: str, cwe: str | None = None, is_cve: bool = False) -> None
|
|||
)
|
||||
|
||||
|
||||
def finding_triage_changed(properties: dict[str, Any]) -> None:
|
||||
"""Send the allowlisted metadata built by the local review metrics module."""
|
||||
_send("finding_triage_changed", properties)
|
||||
|
||||
|
||||
def end(report_state: "ReportState", exit_reason: str = "completed") -> None:
|
||||
if report_state.posthog_scan_ended_sent:
|
||||
return
|
||||
|
|
|
|||
113
strix/telemetry/triage.py
Normal file
113
strix/telemetry/triage.py
Normal file
|
|
@ -0,0 +1,113 @@
|
|||
"""Best-effort classification metrics; never includes finding content or notes."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
import queue
|
||||
import re
|
||||
import threading
|
||||
from typing import TYPE_CHECKING, Any, cast
|
||||
|
||||
from strix.config import load_settings
|
||||
from strix.report.triage_store import read_json
|
||||
from strix.telemetry import posthog
|
||||
from strix.telemetry._common import base_props
|
||||
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
_queue: queue.Queue[dict[str, Any]] = queue.Queue(maxsize=128)
|
||||
_worker: threading.Thread | None = None
|
||||
_guard = threading.Lock()
|
||||
_REASONS = frozenset(
|
||||
{
|
||||
"unspecified",
|
||||
"incorrect_assumption",
|
||||
"existing_protection",
|
||||
"not_affected",
|
||||
"expected_behavior",
|
||||
"other",
|
||||
}
|
||||
)
|
||||
_CWE = re.compile(r"cwe-[1-9][0-9]{0,5}\Z")
|
||||
|
||||
|
||||
def _category(value: Any, allowed: set[str] | frozenset[str]) -> str:
|
||||
normalized = value.lower().strip() if isinstance(value, str) else ""
|
||||
return normalized if normalized in allowed else "unknown"
|
||||
|
||||
|
||||
def _cwe(value: Any) -> str:
|
||||
if not isinstance(value, str):
|
||||
return "unknown"
|
||||
normalized = value.lower().strip()
|
||||
return normalized if _CWE.fullmatch(normalized) else "unknown"
|
||||
|
||||
|
||||
def _deliver() -> None:
|
||||
global _worker # noqa: PLW0603
|
||||
while True:
|
||||
# Share the producer's lock while retiring: an event arriving as the
|
||||
# queue empties must either find this worker or start its replacement.
|
||||
with _guard:
|
||||
try:
|
||||
properties = _queue.get_nowait()
|
||||
except queue.Empty:
|
||||
_worker = None
|
||||
return
|
||||
try:
|
||||
# The final sender also checks the current setting. No disk backlog
|
||||
# survives this process, and disabled events are never enqueued.
|
||||
if load_settings().telemetry.enabled:
|
||||
posthog.finding_triage_changed(properties)
|
||||
except Exception: # noqa: BLE001
|
||||
logger.debug("Review metric delivery failed")
|
||||
finally:
|
||||
_queue.task_done()
|
||||
|
||||
|
||||
def _enqueue(properties: dict[str, Any]) -> None:
|
||||
global _worker # noqa: PLW0603
|
||||
with _guard:
|
||||
_queue.put_nowait(properties)
|
||||
if _worker is None or not _worker.is_alive():
|
||||
_worker = threading.Thread(target=_deliver, name="strix-triage-metrics", daemon=True)
|
||||
_worker.start()
|
||||
|
||||
|
||||
def record_triage(
|
||||
previous: dict[str, Any], current: dict[str, Any], *, run_dir: Path, surface: str
|
||||
) -> None:
|
||||
"""Build an allowlisted event after commit; errors never reach the user's action."""
|
||||
try:
|
||||
if not load_settings().telemetry.enabled:
|
||||
return
|
||||
record = read_json(run_dir / "run.json", default={})
|
||||
mode = cast("dict[str, Any]", record).get("scan_mode") if isinstance(record, dict) else None
|
||||
previous_resolution = previous.get("resolution_reason")
|
||||
resolution = current.get("resolution_reason")
|
||||
properties = {
|
||||
**base_props(),
|
||||
"schema_version": 1,
|
||||
"surface": _category(surface, {"viewer", "tui"}),
|
||||
"previous_status": _category(previous.get("status"), {"open", "closed"}),
|
||||
"new_status": _category(current.get("status"), {"open", "closed"}),
|
||||
"previous_resolution_reason": (
|
||||
"false_positive" if previous_resolution == "false_positive" else None
|
||||
),
|
||||
"resolution_reason": "false_positive" if resolution == "false_positive" else None,
|
||||
"reason_code": _category(current.get("reason_code"), _REASONS),
|
||||
"severity": _category(
|
||||
current.get("severity"), {"critical", "high", "medium", "low", "info"}
|
||||
),
|
||||
"cwe": _cwe(current.get("cwe")),
|
||||
"is_cve": bool(current.get("cve")),
|
||||
"scan_mode": _category(mode, {"quick", "standard", "deep"}),
|
||||
}
|
||||
if load_settings().telemetry.enabled:
|
||||
_enqueue(properties)
|
||||
except Exception: # noqa: BLE001
|
||||
logger.debug("Review metric skipped")
|
||||
|
|
@ -22,6 +22,7 @@ from strix.interface.viewer.report_pdf import (
|
|||
generate_password,
|
||||
generate_report_pdf,
|
||||
)
|
||||
from strix.report.triage import read_triaged_vulnerabilities, triage_finding
|
||||
|
||||
|
||||
if TYPE_CHECKING:
|
||||
|
|
@ -46,6 +47,7 @@ def _make_run(base: Path, name: str = "sample") -> Path:
|
|||
(run_dir / "run.json").write_text(json.dumps(record), encoding="utf-8")
|
||||
vulns = [
|
||||
{
|
||||
"id": "vuln-0001",
|
||||
"title": "SQL Injection",
|
||||
"severity": "CRITICAL",
|
||||
"cvss": 9.8,
|
||||
|
|
@ -60,7 +62,7 @@ def _make_run(base: Path, name: str = "sample") -> Path:
|
|||
"endpoint": "/login",
|
||||
"method": "POST",
|
||||
},
|
||||
{"title": "Informational note", "severity": "info"},
|
||||
{"id": "vuln-0002", "title": "Informational note", "severity": "info"},
|
||||
]
|
||||
(run_dir / "vulnerabilities.json").write_text(json.dumps(vulns), encoding="utf-8")
|
||||
return run_dir
|
||||
|
|
@ -77,6 +79,50 @@ def test_generate_report_pdf_has_pdf_header(tmp_path: Path) -> None:
|
|||
assert len(pdf) > 1000
|
||||
|
||||
|
||||
def test_generate_report_pdf_labels_original_scan_and_detected_counts(tmp_path: Path) -> None:
|
||||
run_dir = _make_run(tmp_path)
|
||||
pdf = generate_report_pdf(run_dir)
|
||||
reader = PdfReader(BytesIO(pdf))
|
||||
cover = reader.pages[0].extract_text()
|
||||
text = " ".join(_pdf_text(pdf).split())
|
||||
|
||||
assert "Original scan report" in cover
|
||||
assert "Subsequent local triage decisions" in cover
|
||||
assert "false-positive closures and notes, are excluded." in " ".join(cover.split())
|
||||
assert "2 detected findings across this assessment." in text
|
||||
assert "Detected findings" in text
|
||||
assert reader.metadata is not None
|
||||
assert reader.metadata.title == "Strix Original Scan Report"
|
||||
|
||||
|
||||
def test_original_report_preserves_closed_findings_and_excludes_triage_notes(
|
||||
tmp_path: Path, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
monkeypatch.setattr("strix.telemetry.triage.record_triage", lambda *_args, **_kwargs: None)
|
||||
run_dir = _make_run(tmp_path)
|
||||
original = _pdf_text(generate_report_pdf(run_dir))
|
||||
for finding in read_triaged_vulnerabilities(run_dir):
|
||||
triage_finding(
|
||||
run_dir,
|
||||
finding["id"],
|
||||
status="closed",
|
||||
expected_revision=finding["triage_revision"],
|
||||
reviewed_digest=finding["finding_digest"],
|
||||
reason_code="incorrect_assumption",
|
||||
note="Private local review context must stay out of the original report.",
|
||||
surface="viewer",
|
||||
)
|
||||
|
||||
assert all(finding["status"] == "closed" for finding in read_triaged_vulnerabilities(run_dir))
|
||||
exported = _pdf_text(generate_report_pdf(run_dir))
|
||||
assert exported == original
|
||||
assert "2 detected findings" in exported
|
||||
assert "SQL Injection" in exported
|
||||
assert "HTTP 500 with SQL error." in exported
|
||||
assert "Informational note" in exported
|
||||
assert "Private local review context" not in exported
|
||||
|
||||
|
||||
def test_generate_password_is_long_and_random() -> None:
|
||||
first = generate_password()
|
||||
second = generate_password()
|
||||
|
|
@ -108,7 +154,7 @@ def test_build_encrypted_report(tmp_path: Path) -> None:
|
|||
run_dir = _make_run(tmp_path, name="run-42")
|
||||
pdf_bytes, password, filename = build_encrypted_report(run_dir)
|
||||
|
||||
assert filename == "strix-report-run-42.pdf"
|
||||
assert filename == "strix-original-scan-report-run-42.pdf"
|
||||
assert len(password) >= 20
|
||||
reader = PdfReader(BytesIO(pdf_bytes))
|
||||
assert reader.is_encrypted
|
||||
|
|
|
|||
325
tests/test_triage.py
Normal file
325
tests/test_triage.py
Normal file
|
|
@ -0,0 +1,325 @@
|
|||
"""Persistence, concurrency and evidence invariants for local human review."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import multiprocessing
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
from unittest.mock import Mock
|
||||
|
||||
import pytest
|
||||
|
||||
from strix.report import triage, triage_store
|
||||
from strix.report.triage import TriageError, read_triaged_vulnerabilities, triage_finding
|
||||
from strix.report.triage_store import triage_stamp
|
||||
from strix.telemetry import triage as metrics
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def run_dir(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
|
||||
monkeypatch.setenv("STRIX_TELEMETRY", "0")
|
||||
path = tmp_path / "run"
|
||||
path.mkdir()
|
||||
(path / "run.json").write_text(json.dumps({"run_id": "run", "start_time": "2026-09-16"}))
|
||||
reports = [
|
||||
{
|
||||
"id": f"vuln-{i:04d}",
|
||||
"title": f"Finding {i}",
|
||||
"evidence": f"Evidence {i}",
|
||||
"severity": "high",
|
||||
"timestamp": "2026-09-16 12:00:00 UTC",
|
||||
}
|
||||
for i in (1, 2)
|
||||
]
|
||||
(path / "vulnerabilities.json").write_text(json.dumps(reports))
|
||||
monkeypatch.setattr(metrics, "record_triage", Mock())
|
||||
return path
|
||||
|
||||
|
||||
def close(run_dir: Path, finding_id: str = "vuln-0001", **kwargs: Any) -> dict[str, Any]:
|
||||
finding = next(
|
||||
item for item in read_triaged_vulnerabilities(run_dir) if item["id"] == finding_id
|
||||
)
|
||||
values = {
|
||||
"status": "closed",
|
||||
"expected_revision": finding["triage_revision"],
|
||||
"reviewed_digest": finding["finding_digest"],
|
||||
"reason_code": "incorrect_assumption",
|
||||
"surface": "tui",
|
||||
**kwargs,
|
||||
}
|
||||
return triage_finding(run_dir, finding_id, **values)
|
||||
|
||||
|
||||
def test_legacy_read_is_open_and_does_not_write(run_dir: Path) -> None:
|
||||
before = {p.name: p.read_bytes() for p in run_dir.iterdir()}
|
||||
findings = read_triaged_vulnerabilities(run_dir)
|
||||
assert all(item["status"] == "open" and item["can_triage"] for item in findings)
|
||||
assert all(item["triage_revision"] == 0 for item in findings)
|
||||
assert before == {p.name: p.read_bytes() for p in run_dir.iterdir()}
|
||||
|
||||
|
||||
def test_close_reopen_preserves_evidence_and_history(run_dir: Path) -> None:
|
||||
evidence = (run_dir / "vulnerabilities.json").read_bytes()
|
||||
result = close(run_dir, note="My private explanation")
|
||||
assert result["changed"] is True
|
||||
finding = read_triaged_vulnerabilities(run_dir)[0]
|
||||
assert finding["status"] == "closed"
|
||||
assert finding["status_note"] == "My private explanation"
|
||||
reopened = close(run_dir, status="open")["finding"]
|
||||
assert reopened["status"] == "open"
|
||||
assert reopened["status_note"] is None
|
||||
assert reopened["resolution_reason"] is None
|
||||
assert [event["status"] for event in reopened["triage_history"]] == ["closed", "open"]
|
||||
assert reopened["triage_history"][0]["note"] == "My private explanation"
|
||||
assert (run_dir / "vulnerabilities.json").read_bytes() == evidence
|
||||
assert metrics.record_triage.call_count == 2 # type: ignore[attr-defined]
|
||||
|
||||
|
||||
def test_repeated_request_is_idempotent_and_note_edits_stay_local(run_dir: Path) -> None:
|
||||
first = read_triaged_vulnerabilities(run_dir)[0]
|
||||
closed = close(run_dir)
|
||||
assert close(run_dir)["changed"] is False
|
||||
assert close(run_dir, expected_revision=0)["changed"] is False
|
||||
assert closed["finding"]["triage_revision"] == 1
|
||||
updated = close(run_dir, note="Local note only")
|
||||
assert updated["finding"]["triage_revision"] == 2
|
||||
assert metrics.record_triage.call_count == 1 # type: ignore[attr-defined]
|
||||
with pytest.raises(TriageError, match="reviewed elsewhere"):
|
||||
close(run_dir, status="open", expected_revision=first["triage_revision"])
|
||||
|
||||
|
||||
def test_evidence_changes_require_new_review(run_dir: Path) -> None:
|
||||
old = read_triaged_vulnerabilities(run_dir)[0]
|
||||
close(run_dir)
|
||||
raw = json.loads((run_dir / "vulnerabilities.json").read_text())
|
||||
raw[0]["evidence"] = "New evidence changes the claim"
|
||||
(run_dir / "vulnerabilities.json").write_text(json.dumps(raw))
|
||||
finding = read_triaged_vulnerabilities(run_dir)[0]
|
||||
assert finding["status"] == "open" and finding["review_stale"]
|
||||
assert finding["triage_status"] == "closed"
|
||||
assert len(finding["triage_history"]) == 1
|
||||
with pytest.raises(TriageError, match="evidence changed"):
|
||||
close(run_dir, reviewed_digest=old["finding_digest"])
|
||||
result = close(run_dir)["finding"]
|
||||
assert result["triage_revision"] == 2
|
||||
assert result["status"] == "closed" and not result["review_stale"]
|
||||
|
||||
|
||||
def test_presentation_and_fix_changes_do_not_invalidate_review(run_dir: Path) -> None:
|
||||
close(run_dir)
|
||||
raw = json.loads((run_dir / "vulnerabilities.json").read_text())
|
||||
raw[0].update(title="Clearer title", remediation_steps="A better fix", timestamp="later")
|
||||
(run_dir / "vulnerabilities.json").write_text(json.dumps(raw))
|
||||
assert read_triaged_vulnerabilities(run_dir)[0]["status"] == "closed"
|
||||
|
||||
|
||||
def test_projection_does_not_modify_in_memory_agent_reports(run_dir: Path) -> None:
|
||||
close(run_dir)
|
||||
raw = json.loads((run_dir / "vulnerabilities.json").read_text())
|
||||
before = json.dumps(raw)
|
||||
assert read_triaged_vulnerabilities(run_dir, raw)[0]["status"] == "closed"
|
||||
assert json.dumps(raw) == before
|
||||
assert len(raw) == 2 and "status" not in raw[0]
|
||||
|
||||
|
||||
@pytest.mark.parametrize("payload", ["{", "[]", '{"schema_version": 99}', "null"])
|
||||
def test_invalid_sidecar_is_never_overwritten(run_dir: Path, payload: str) -> None:
|
||||
finding = read_triaged_vulnerabilities(run_dir)[0]
|
||||
(run_dir / "triage.json").write_text(payload)
|
||||
with pytest.raises(TriageError):
|
||||
triage_finding(
|
||||
run_dir,
|
||||
"vuln-0001",
|
||||
status="closed",
|
||||
expected_revision=0,
|
||||
reviewed_digest=finding["finding_digest"],
|
||||
surface="tui",
|
||||
)
|
||||
assert (run_dir / "triage.json").read_text() == payload
|
||||
metrics.record_triage.assert_not_called() # type: ignore[attr-defined]
|
||||
|
||||
|
||||
def test_reused_run_identity_cannot_inherit_decision(run_dir: Path) -> None:
|
||||
close(run_dir)
|
||||
(run_dir / "run.json").write_text(json.dumps({"run_id": "run", "start_time": "new scan"}))
|
||||
with pytest.raises(TriageError, match="another run"):
|
||||
read_triaged_vulnerabilities(run_dir)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"field,value",
|
||||
[
|
||||
("status", []),
|
||||
("reason_code", {}),
|
||||
("expected_revision", True),
|
||||
("expected_revision", -1),
|
||||
("reviewed_digest", "arbitrary"),
|
||||
("note", "a" * 2001),
|
||||
("note", []),
|
||||
("surface", "untrusted"),
|
||||
],
|
||||
)
|
||||
def test_bad_requests_are_rejected(run_dir: Path, field: str, value: Any) -> None:
|
||||
with pytest.raises(TriageError) as error:
|
||||
close(run_dir, **{field: value})
|
||||
assert error.value.code == "invalid_request"
|
||||
assert not (run_dir / "triage.json").exists()
|
||||
|
||||
|
||||
def test_duplicate_and_synthetic_ids_are_not_writable(run_dir: Path) -> None:
|
||||
raw = json.loads((run_dir / "vulnerabilities.json").read_text())
|
||||
raw[1]["id"] = raw[0]["id"]
|
||||
raw.append({"title": "No ID"})
|
||||
(run_dir / "vulnerabilities.json").write_text(json.dumps(raw))
|
||||
assert not any(item["can_triage"] for item in read_triaged_vulnerabilities(run_dir))
|
||||
with pytest.raises(TriageError) as error:
|
||||
close(run_dir)
|
||||
assert error.value.code == "unknown_finding"
|
||||
|
||||
|
||||
@pytest.mark.parametrize("name", ["triage.json", "triage.lock"])
|
||||
def test_symlink_cannot_redirect_writes(run_dir: Path, name: str) -> None:
|
||||
finding = read_triaged_vulnerabilities(run_dir)[0]
|
||||
outside = run_dir.parent / "outside"
|
||||
outside.write_text("unchanged")
|
||||
(run_dir / name).symlink_to(outside)
|
||||
with pytest.raises(TriageError):
|
||||
triage_finding(
|
||||
run_dir,
|
||||
"vuln-0001",
|
||||
status="closed",
|
||||
expected_revision=0,
|
||||
reviewed_digest=finding["finding_digest"],
|
||||
surface="tui",
|
||||
)
|
||||
assert outside.read_text() == "unchanged"
|
||||
|
||||
|
||||
def test_read_only_directory_still_displays_findings(run_dir: Path) -> None:
|
||||
run_dir.chmod(0o555)
|
||||
try:
|
||||
assert not any(item["can_triage"] for item in read_triaged_vulnerabilities(run_dir))
|
||||
with pytest.raises(TriageError) as error:
|
||||
close(run_dir)
|
||||
assert error.value.code == "read_only"
|
||||
finally:
|
||||
run_dir.chmod(0o755)
|
||||
|
||||
|
||||
def test_failed_save_has_no_success_event(run_dir: Path, monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
monkeypatch.setattr(triage, "write_store", Mock(side_effect=OSError("disk unavailable")))
|
||||
with pytest.raises(TriageError):
|
||||
close(run_dir)
|
||||
assert not (run_dir / "triage.json").exists()
|
||||
metrics.record_triage.assert_not_called() # type: ignore[attr-defined]
|
||||
|
||||
|
||||
def test_telemetry_exception_cannot_fail_committed_review(
|
||||
run_dir: Path, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
monkeypatch.setattr(metrics, "record_triage", Mock(side_effect=RuntimeError("offline")))
|
||||
assert close(run_dir)["changed"]
|
||||
assert read_triaged_vulnerabilities(run_dir)[0]["status"] == "closed"
|
||||
|
||||
|
||||
def test_change_token_tracks_evidence_and_sidecar(run_dir: Path) -> None:
|
||||
initial = triage_stamp(run_dir)
|
||||
close(run_dir)
|
||||
reviewed = triage_stamp(run_dir)
|
||||
assert reviewed != initial
|
||||
reports = json.loads((run_dir / "vulnerabilities.json").read_text())
|
||||
reports[0]["evidence"] = "Changed"
|
||||
(run_dir / "vulnerabilities.json").write_text(json.dumps(reports))
|
||||
assert triage_stamp(run_dir) != reviewed
|
||||
assert all(0 <= value < 2**53 for value in triage_stamp(run_dir))
|
||||
|
||||
|
||||
def _process_close(path: str, finding_id: str) -> None:
|
||||
# Spawned processes inherit STRIX_TELEMETRY=0 from the parent fixture.
|
||||
run = Path(path)
|
||||
finding = next(item for item in read_triaged_vulnerabilities(run) if item["id"] == finding_id)
|
||||
triage_finding(
|
||||
run,
|
||||
finding_id,
|
||||
status="closed",
|
||||
expected_revision=0,
|
||||
reviewed_digest=finding["finding_digest"],
|
||||
surface="tui",
|
||||
)
|
||||
|
||||
|
||||
def test_separate_processes_preserve_both_decisions(run_dir: Path) -> None:
|
||||
context = multiprocessing.get_context("spawn")
|
||||
processes = [
|
||||
context.Process(target=_process_close, args=(str(run_dir), f"vuln-{i:04d}")) for i in (1, 2)
|
||||
]
|
||||
for process in processes:
|
||||
process.start()
|
||||
for process in processes:
|
||||
process.join(timeout=20)
|
||||
if process.is_alive():
|
||||
process.terminate()
|
||||
pytest.fail("Review process did not finish")
|
||||
assert process.exitcode == 0
|
||||
findings = read_triaged_vulnerabilities(run_dir)
|
||||
assert all(item["status"] == "closed" for item in findings)
|
||||
assert all(item["triage_revision"] == 1 for item in findings)
|
||||
|
||||
|
||||
def test_atomic_replace_failure_preserves_prior_decision(
|
||||
run_dir: Path, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
close(run_dir)
|
||||
saved = (run_dir / "triage.json").read_bytes()
|
||||
monkeypatch.setattr(Path, "replace", Mock(side_effect=OSError("replace failed")))
|
||||
with pytest.raises(TriageError):
|
||||
close(run_dir, status="open")
|
||||
assert (run_dir / "triage.json").read_bytes() == saved
|
||||
assert not list(run_dir.glob(".triage-*"))
|
||||
assert metrics.record_triage.call_count == 1 # type: ignore[attr-defined]
|
||||
|
||||
|
||||
def test_lock_failure_never_saves_unlocked(run_dir: Path, monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
monkeypatch.setattr(triage_store, "LOCK_TIMEOUT", 0)
|
||||
monkeypatch.setattr(triage_store, "_file_lock", Mock(side_effect=OSError("lock unavailable")))
|
||||
with pytest.raises(TriageError, match="lock review data"):
|
||||
close(run_dir)
|
||||
assert not (run_dir / "triage.json").exists()
|
||||
metrics.record_triage.assert_not_called() # type: ignore[attr-defined]
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"field,value",
|
||||
[
|
||||
("counterevidence", "New contrary evidence"),
|
||||
("http_exchange_ids", ["new-archived-exchange"]),
|
||||
("confidence_rationale", "Previously assumed protection disproved"),
|
||||
],
|
||||
)
|
||||
def test_additional_evidence_fields_invalidate_review(
|
||||
run_dir: Path, field: str, value: Any
|
||||
) -> None:
|
||||
close(run_dir)
|
||||
reports = json.loads((run_dir / "vulnerabilities.json").read_text())
|
||||
reports[0][field] = value
|
||||
(run_dir / "vulnerabilities.json").write_text(json.dumps(reports))
|
||||
assert read_triaged_vulnerabilities(run_dir)[0]["review_stale"]
|
||||
|
||||
|
||||
def test_resume_and_scanner_artifact_rewrite_preserve_review(run_dir: Path) -> None:
|
||||
from strix.report.state import ReportState # noqa: PLC0415
|
||||
from strix.report.writer import write_vulnerabilities # noqa: PLC0415
|
||||
|
||||
close(run_dir)
|
||||
state = ReportState(run_name="run")
|
||||
state._run_dir = run_dir
|
||||
state.hydrate_from_run_dir()
|
||||
assert len(state.vulnerability_reports) == 2
|
||||
assert "status" not in state.vulnerability_reports[0]
|
||||
write_vulnerabilities(run_dir, state.vulnerability_reports, set())
|
||||
assert read_triaged_vulnerabilities(run_dir)[0]["status"] == "closed"
|
||||
assert state.add_vulnerability_report(title="Third finding", severity="low") == "vuln-0003"
|
||||
assert len(state.vulnerability_reports) == 3
|
||||
assert read_triaged_vulnerabilities(run_dir)[0]["status"] == "closed"
|
||||
393
tests/test_triage_telemetry.py
Normal file
393
tests/test_triage_telemetry.py
Normal file
|
|
@ -0,0 +1,393 @@
|
|||
"""Triage analytics respect consent and keep finding content off the network."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
import queue
|
||||
import threading
|
||||
from typing import TYPE_CHECKING, Any
|
||||
|
||||
import pytest
|
||||
import requests
|
||||
|
||||
from strix.config import loader
|
||||
from strix.telemetry import triage
|
||||
from strix.telemetry._common import SESSION_ID
|
||||
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from collections.abc import Iterator
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
PRIVATE = "private finding content https://private.invalid customer@example.invalid"
|
||||
|
||||
|
||||
def _wait_for_delivery() -> None:
|
||||
worker = triage._worker
|
||||
if worker is not None:
|
||||
worker.join(timeout=3)
|
||||
assert not worker.is_alive(), "Telemetry worker did not finish"
|
||||
assert triage._queue.unfinished_tasks == 0
|
||||
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def _isolated_telemetry(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Iterator[None]:
|
||||
for name in list(os.environ):
|
||||
if name.upper() == "STRIX_TELEMETRY":
|
||||
monkeypatch.delenv(name)
|
||||
monkeypatch.setattr(loader, "_override", tmp_path / "config.json")
|
||||
monkeypatch.setattr(loader, "_cached", None)
|
||||
monkeypatch.setattr(triage, "_queue", queue.Queue(maxsize=128))
|
||||
monkeypatch.setattr(triage, "_worker", None)
|
||||
monkeypatch.setattr(triage, "_guard", threading.Lock())
|
||||
yield
|
||||
_wait_for_delivery()
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def sent(monkeypatch: pytest.MonkeyPatch) -> list[dict[str, Any]]:
|
||||
payloads: list[dict[str, Any]] = []
|
||||
|
||||
def capture(_url: str, *, json: dict[str, Any], timeout: Any) -> requests.Response:
|
||||
assert timeout is not None
|
||||
payloads.append(json)
|
||||
response = requests.Response()
|
||||
response.status_code = 200
|
||||
return response
|
||||
|
||||
monkeypatch.setattr(requests, "post", capture)
|
||||
return payloads
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def run_dir(tmp_path: Path) -> Path:
|
||||
path = tmp_path / "synthetic-run"
|
||||
path.mkdir()
|
||||
(path / "run.json").write_text(
|
||||
json.dumps({"scan_mode": "standard", "run_name": PRIVATE, "target": PRIVATE}),
|
||||
encoding="utf-8",
|
||||
)
|
||||
return path
|
||||
|
||||
|
||||
def _record(run_dir: Path, **fields: Any) -> None:
|
||||
current = {
|
||||
"status": "closed",
|
||||
"resolution_reason": "false_positive",
|
||||
"reason_code": "incorrect_assumption",
|
||||
"severity": "high",
|
||||
"cwe": "CWE-79",
|
||||
"cve": "CVE-2026-12345",
|
||||
**fields,
|
||||
}
|
||||
triage.record_triage({"status": "open"}, current, run_dir=run_dir, surface="viewer")
|
||||
|
||||
|
||||
def test_payload_contains_only_classification_metadata(
|
||||
run_dir: Path, sent: list[dict[str, Any]]
|
||||
) -> None:
|
||||
_record(
|
||||
run_dir,
|
||||
**dict.fromkeys(
|
||||
(
|
||||
"id",
|
||||
"title",
|
||||
"description",
|
||||
"target",
|
||||
"endpoint",
|
||||
"email",
|
||||
"evidence",
|
||||
"poc_script_code",
|
||||
"status_note",
|
||||
"note",
|
||||
"code_locations",
|
||||
"finding_digest",
|
||||
"reviewed_digest",
|
||||
"status_changed_by",
|
||||
"status_changed_at",
|
||||
"triage_history",
|
||||
"model",
|
||||
"agent_id",
|
||||
"agent_name",
|
||||
),
|
||||
PRIVATE,
|
||||
),
|
||||
)
|
||||
_wait_for_delivery()
|
||||
|
||||
assert len(sent) == 1
|
||||
payload = sent[0]
|
||||
assert payload["event"] == "finding_triage_changed"
|
||||
assert payload["distinct_id"] == SESSION_ID
|
||||
properties = payload["properties"]
|
||||
assert set(properties) == {
|
||||
"os",
|
||||
"arch",
|
||||
"python",
|
||||
"strix_version",
|
||||
"$lib",
|
||||
"$lib_version",
|
||||
"$process_person_profile",
|
||||
"schema_version",
|
||||
"surface",
|
||||
"previous_status",
|
||||
"new_status",
|
||||
"previous_resolution_reason",
|
||||
"resolution_reason",
|
||||
"reason_code",
|
||||
"severity",
|
||||
"cwe",
|
||||
"is_cve",
|
||||
"scan_mode",
|
||||
}
|
||||
assert properties["schema_version"] == 1
|
||||
assert properties["surface"] == "viewer"
|
||||
assert properties["previous_status"] == "open"
|
||||
assert properties["new_status"] == "closed"
|
||||
assert properties["previous_resolution_reason"] is None
|
||||
assert properties["resolution_reason"] == "false_positive"
|
||||
assert properties["reason_code"] == "incorrect_assumption"
|
||||
assert properties["severity"] == "high"
|
||||
assert properties["cwe"] == "cwe-79"
|
||||
assert properties["is_cve"] is True
|
||||
assert properties["scan_mode"] == "standard"
|
||||
assert properties["$process_person_profile"] is False
|
||||
assert PRIVATE not in json.dumps(payload)
|
||||
assert "CVE-2026-12345" not in json.dumps(payload)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("surface", ["viewer", "tui"])
|
||||
def test_reopen_preserves_transition_direction(
|
||||
run_dir: Path, sent: list[dict[str, Any]], surface: str
|
||||
) -> None:
|
||||
triage.record_triage(
|
||||
{"status": "closed", "resolution_reason": "false_positive", "status_note": PRIVATE},
|
||||
{"status": "open", "reason_code": "unspecified", "severity": " HIGH "},
|
||||
run_dir=run_dir,
|
||||
surface=surface,
|
||||
)
|
||||
_wait_for_delivery()
|
||||
properties = sent[0]["properties"]
|
||||
assert properties["surface"] == surface
|
||||
assert properties["previous_status"] == "closed"
|
||||
assert properties["new_status"] == "open"
|
||||
assert properties["previous_resolution_reason"] == "false_positive"
|
||||
assert properties["resolution_reason"] is None
|
||||
assert properties["severity"] == "high"
|
||||
assert properties["is_cve"] is False
|
||||
assert PRIVATE not in json.dumps(sent)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("bad_value", [PRIVATE, {"private": PRIVATE}, [PRIVATE], 42, None])
|
||||
def test_untrusted_categories_cannot_be_forwarded(
|
||||
run_dir: Path, sent: list[dict[str, Any]], bad_value: Any
|
||||
) -> None:
|
||||
(run_dir / "run.json").write_text(json.dumps({"scan_mode": bad_value}), encoding="utf-8")
|
||||
triage.record_triage(
|
||||
{"status": bad_value, "resolution_reason": bad_value},
|
||||
dict.fromkeys(
|
||||
("status", "resolution_reason", "reason_code", "severity", "cwe", "cve"), bad_value
|
||||
),
|
||||
run_dir=run_dir,
|
||||
surface=bad_value,
|
||||
)
|
||||
_wait_for_delivery()
|
||||
assert len(sent) == 1
|
||||
properties = sent[0]["properties"]
|
||||
for field in (
|
||||
"surface",
|
||||
"previous_status",
|
||||
"new_status",
|
||||
"reason_code",
|
||||
"severity",
|
||||
"cwe",
|
||||
"scan_mode",
|
||||
):
|
||||
assert properties[field] == "unknown"
|
||||
assert properties["previous_resolution_reason"] is None
|
||||
assert properties["resolution_reason"] is None
|
||||
assert isinstance(properties["is_cve"], bool)
|
||||
assert PRIVATE not in json.dumps(sent)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("cwe", "expected"),
|
||||
[
|
||||
(" CWE-79 ", "cwe-79"),
|
||||
("cwe-1000", "cwe-1000"),
|
||||
("CWE-79 " + PRIVATE, "unknown"),
|
||||
("CWE-79\n" + PRIVATE, "unknown"),
|
||||
("cwe-0", "unknown"),
|
||||
("cwe-00079", "unknown"),
|
||||
("cwe-1234567", "unknown"),
|
||||
("79", "unknown"),
|
||||
],
|
||||
)
|
||||
def test_cwe_is_a_bounded_identifier(
|
||||
run_dir: Path, sent: list[dict[str, Any]], cwe: str, expected: str
|
||||
) -> None:
|
||||
_record(run_dir, cwe=cwe)
|
||||
_wait_for_delivery()
|
||||
assert sent[0]["properties"]["cwe"] == expected
|
||||
assert PRIVATE not in json.dumps(sent)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("source", ["environment", "saved_config"])
|
||||
@pytest.mark.parametrize("disabled", ["0", "false", "no", "off"])
|
||||
def test_opt_out_does_not_send_or_replay_disabled_actions(
|
||||
run_dir: Path,
|
||||
sent: list[dict[str, Any]],
|
||||
monkeypatch: pytest.MonkeyPatch,
|
||||
source: str,
|
||||
disabled: str,
|
||||
) -> None:
|
||||
config = run_dir / "config.json"
|
||||
if source == "environment":
|
||||
config.write_text(json.dumps({"env": {"STRIX_TELEMETRY": "1"}}), encoding="utf-8")
|
||||
monkeypatch.setenv("STRIX_TELEMETRY", disabled)
|
||||
else:
|
||||
config.write_text(json.dumps({"env": {"STRIX_TELEMETRY": disabled}}), encoding="utf-8")
|
||||
loader.apply_config_override(config)
|
||||
|
||||
_record(run_dir, reason_code="other")
|
||||
assert loader.load_settings().telemetry.enabled is False
|
||||
assert sent == []
|
||||
assert triage._queue.empty()
|
||||
assert triage._worker is None
|
||||
|
||||
monkeypatch.delenv("STRIX_TELEMETRY", raising=False)
|
||||
config.write_text(json.dumps({"env": {"STRIX_TELEMETRY": "1"}}), encoding="utf-8")
|
||||
loader.apply_config_override(config)
|
||||
_record(run_dir, reason_code="expected_behavior")
|
||||
_wait_for_delivery()
|
||||
assert len(sent) == 1
|
||||
assert sent[0]["properties"]["reason_code"] == "expected_behavior"
|
||||
|
||||
|
||||
def test_environment_enable_overrides_saved_opt_out(
|
||||
run_dir: Path, sent: list[dict[str, Any]], monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
config = run_dir / "config.json"
|
||||
config.write_text(json.dumps({"env": {"STRIX_TELEMETRY": "0"}}), encoding="utf-8")
|
||||
monkeypatch.setenv("STRIX_TELEMETRY", "1")
|
||||
loader.apply_config_override(config)
|
||||
_record(run_dir)
|
||||
_wait_for_delivery()
|
||||
assert len(sent) == 1
|
||||
|
||||
|
||||
def test_consent_is_rechecked_after_loading_scan_metadata(
|
||||
run_dir: Path, sent: list[dict[str, Any]], monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
settings = loader.load_settings()
|
||||
|
||||
def disable_during_read(*_args: Any, **_kwargs: Any) -> dict[str, str]:
|
||||
settings.telemetry.enabled = False
|
||||
return {"scan_mode": "standard"}
|
||||
|
||||
monkeypatch.setattr(triage, "read_json", disable_during_read)
|
||||
_record(run_dir)
|
||||
assert sent == []
|
||||
assert triage._queue.empty()
|
||||
assert triage._worker is None
|
||||
|
||||
|
||||
def test_network_delivery_never_blocks_the_caller_and_queue_is_bounded(
|
||||
run_dir: Path, sent: list[dict[str, Any]], monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
started = threading.Event()
|
||||
release = threading.Event()
|
||||
returned = threading.Event()
|
||||
capture = requests.post
|
||||
monkeypatch.setattr(triage, "_queue", queue.Queue(maxsize=2))
|
||||
|
||||
def blocked_post(*args: Any, **kwargs: Any) -> requests.Response:
|
||||
started.set()
|
||||
release.wait(timeout=5)
|
||||
return capture(*args, **kwargs)
|
||||
|
||||
def close_action() -> None:
|
||||
_record(run_dir)
|
||||
returned.set()
|
||||
|
||||
monkeypatch.setattr(requests, "post", blocked_post)
|
||||
caller = threading.Thread(target=close_action, daemon=True)
|
||||
caller.start()
|
||||
try:
|
||||
assert started.wait(timeout=2)
|
||||
# This asserts completion order while the request is still blocked,
|
||||
# rather than imposing a performance threshold on a successful send.
|
||||
assert returned.wait(timeout=2)
|
||||
assert not release.is_set()
|
||||
_record(run_dir)
|
||||
_record(run_dir)
|
||||
_record(run_dir) # The full queue drops this event without blocking.
|
||||
assert triage._queue.qsize() == 2
|
||||
assert triage._worker is not None
|
||||
assert triage._worker.daemon
|
||||
finally:
|
||||
release.set()
|
||||
caller.join(timeout=3)
|
||||
_wait_for_delivery()
|
||||
assert len(sent) == 3
|
||||
|
||||
|
||||
def test_pending_event_is_dropped_if_disabled_before_worker_delivery(
|
||||
run_dir: Path, sent: list[dict[str, Any]], monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
started = threading.Event()
|
||||
release = threading.Event()
|
||||
capture = requests.post
|
||||
|
||||
def blocked_post(*args: Any, **kwargs: Any) -> requests.Response:
|
||||
started.set()
|
||||
release.wait(timeout=5)
|
||||
return capture(*args, **kwargs)
|
||||
|
||||
monkeypatch.setattr(requests, "post", blocked_post)
|
||||
_record(run_dir)
|
||||
try:
|
||||
assert started.wait(timeout=2)
|
||||
_record(run_dir)
|
||||
assert triage._queue.qsize() == 1
|
||||
loader.load_settings().telemetry.enabled = False
|
||||
finally:
|
||||
release.set()
|
||||
_wait_for_delivery()
|
||||
assert len(sent) == 1 # Only the request already in progress was sent.
|
||||
loader.load_settings().telemetry.enabled = True
|
||||
_record(run_dir)
|
||||
_wait_for_delivery()
|
||||
assert len(sent) == 2 # The disabled queued event was not replayed.
|
||||
|
||||
|
||||
def test_delivery_failure_does_not_break_later_delivery(
|
||||
run_dir: Path, sent: list[dict[str, Any]], monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
capture = requests.post
|
||||
failures: list[bool] = []
|
||||
|
||||
def fail_once(*args: Any, **kwargs: Any) -> requests.Response:
|
||||
if not failures:
|
||||
failures.append(True)
|
||||
raise requests.Timeout(PRIVATE)
|
||||
return capture(*args, **kwargs)
|
||||
|
||||
monkeypatch.setattr(requests, "post", fail_once)
|
||||
_record(run_dir)
|
||||
_wait_for_delivery()
|
||||
_record(run_dir)
|
||||
_wait_for_delivery()
|
||||
assert len(sent) == 1
|
||||
assert PRIVATE not in json.dumps(sent)
|
||||
|
||||
|
||||
def test_malformed_scan_metadata_never_fails_the_local_action(
|
||||
run_dir: Path, sent: list[dict[str, Any]]
|
||||
) -> None:
|
||||
(run_dir / "run.json").write_text("{" + PRIVATE, encoding="utf-8")
|
||||
_record(run_dir)
|
||||
assert sent == []
|
||||
assert triage._queue.empty()
|
||||
168
tests/test_tui_triage.py
Normal file
168
tests/test_tui_triage.py
Normal file
|
|
@ -0,0 +1,168 @@
|
|||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import asyncio
|
||||
import json
|
||||
from types import SimpleNamespace
|
||||
from typing import TYPE_CHECKING, Any, cast
|
||||
|
||||
import pytest
|
||||
|
||||
from strix.config import loader
|
||||
from strix.interface.tui.backend.controller import TuiController
|
||||
from strix.interface.tui.backend.protocol import PROTOCOL_VERSION
|
||||
from strix.interface.tui.backend.server import TuiBackendServer
|
||||
from strix.report.triage import TriageError, read_triaged_vulnerabilities, triage_finding
|
||||
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from pathlib import Path
|
||||
|
||||
from strix.report.state import ReportState
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def triage_controller(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> TuiController:
|
||||
monkeypatch.setenv("STRIX_TELEMETRY", "0")
|
||||
monkeypatch.setattr(loader, "_cached", None)
|
||||
monkeypatch.setattr(loader, "_override", tmp_path / "config.json")
|
||||
reports = [{"id": "vuln-0001", "title": "Example", "severity": "high", "evidence": "proof"}]
|
||||
(tmp_path / "vulnerabilities.json").write_text(json.dumps(reports))
|
||||
(tmp_path / "run.json").write_text(json.dumps({"run_id": "test-run"}))
|
||||
args = argparse.Namespace(
|
||||
needs_setup=False,
|
||||
targets_info=[],
|
||||
instruction=None,
|
||||
scan_mode="standard",
|
||||
max_budget_usd=None,
|
||||
max_turns=50,
|
||||
scope_mode="auto",
|
||||
diff_base=None,
|
||||
)
|
||||
state = SimpleNamespace(vulnerability_reports=reports, get_run_dir=lambda: tmp_path)
|
||||
return TuiController(args, report_state=cast("ReportState", state))
|
||||
|
||||
|
||||
def _request(finding: dict[str, Any], status: str = "closed") -> dict[str, Any]:
|
||||
return {
|
||||
"finding_id": finding["id"],
|
||||
"status": status,
|
||||
"expected_revision": finding["triage_revision"],
|
||||
"reviewed_digest": finding["finding_digest"],
|
||||
"reason_code": "incorrect_assumption",
|
||||
"note": "Local explanation",
|
||||
}
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_native_close_reopen_updates_shared_overlay_without_mutating_evidence(
|
||||
triage_controller: TuiController,
|
||||
) -> None:
|
||||
controller = triage_controller
|
||||
finding = controller.collection("vulnerabilities")[0]
|
||||
state = controller.report_state
|
||||
assert state is not None
|
||||
raw = json.loads((state.get_run_dir() / "vulnerabilities.json").read_text())
|
||||
result = await controller.handle("vulnerability.triage", _request(finding))
|
||||
assert result["changed"] is True
|
||||
assert result["finding"]["status"] == "closed"
|
||||
assert "evidence" not in result["finding"]
|
||||
assert (
|
||||
read_triaged_vulnerabilities(state.get_run_dir())[0]["status_note"] == "Local explanation"
|
||||
)
|
||||
assert controller.collection("vulnerabilities")[0]["status"] == "closed"
|
||||
assert state.vulnerability_reports == raw
|
||||
assert json.loads((state.get_run_dir() / "vulnerabilities.json").read_text()) == raw
|
||||
reopened = await controller.handle("vulnerability.triage", _request(result["finding"], "open"))
|
||||
assert reopened["finding"]["status"] == "open"
|
||||
assert reopened["finding"]["resolution_reason"] is None
|
||||
assert len(read_triaged_vulnerabilities(state.get_run_dir())[0]["triage_history"]) == 2
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_native_stale_review_is_a_structured_conflict(
|
||||
triage_controller: TuiController,
|
||||
) -> None:
|
||||
controller = triage_controller
|
||||
finding = controller.collection("vulnerabilities")[0]
|
||||
assert controller.report_state is not None
|
||||
path = controller.report_state.get_run_dir() / "vulnerabilities.json"
|
||||
reports = json.loads(path.read_text())
|
||||
reports[0]["evidence"] = "New evidence"
|
||||
path.write_text(json.dumps(reports))
|
||||
server = TuiBackendServer(controller)
|
||||
response, _ = await server._handle_message(
|
||||
json.dumps(
|
||||
{
|
||||
"version": PROTOCOL_VERSION,
|
||||
"type": "vulnerability.triage",
|
||||
"request_id": "review",
|
||||
"payload": _request(finding),
|
||||
}
|
||||
).encode()
|
||||
)
|
||||
assert response is not None
|
||||
assert response["payload"]["ok"] is False
|
||||
assert response["payload"]["error"]["code"] == "conflict"
|
||||
assert not (path.parent / "triage.json").exists()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_native_retries_do_not_duplicate_reviews(triage_controller: TuiController) -> None:
|
||||
controller = triage_controller
|
||||
request = _request(controller.collection("vulnerabilities")[0])
|
||||
await controller.handle("vulnerability.triage", request)
|
||||
repeated = await controller.handle("vulnerability.triage", request)
|
||||
assert repeated["changed"] is False
|
||||
assert repeated["finding"]["triage_revision"] == 1
|
||||
|
||||
|
||||
def test_corrupt_sidecar_leaves_evidence_visible_without_write_capability(
|
||||
triage_controller: TuiController,
|
||||
) -> None:
|
||||
assert triage_controller.report_state is not None
|
||||
(triage_controller.report_state.get_run_dir() / "triage.json").write_text("broken")
|
||||
finding = triage_controller.collection("vulnerabilities")[0]
|
||||
assert finding["evidence"] == "proof"
|
||||
assert finding["can_triage"] is False
|
||||
assert finding["triage_error"]
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_external_decision_notifies_idle_terminal(triage_controller: TuiController) -> None:
|
||||
controller = triage_controller
|
||||
server = TuiBackendServer(controller)
|
||||
changed = asyncio.Event()
|
||||
controller.set_change_callback(changed.set)
|
||||
server.activated = True
|
||||
# Observe the real watcher callback without opening another socket.
|
||||
server.notify_changed = changed.set # type: ignore[method-assign]
|
||||
task = asyncio.create_task(server._watch_triage())
|
||||
try:
|
||||
await asyncio.wait_for(changed.wait(), 2)
|
||||
changed.clear()
|
||||
finding = controller.collection("vulnerabilities")[0]
|
||||
assert controller.report_state is not None
|
||||
triage_finding(
|
||||
controller.report_state.get_run_dir(),
|
||||
finding["id"],
|
||||
status="closed",
|
||||
expected_revision=0,
|
||||
reviewed_digest=finding["finding_digest"],
|
||||
surface="viewer",
|
||||
)
|
||||
await asyncio.wait_for(changed.wait(), 2)
|
||||
assert controller.collection("vulnerabilities")[0]["status"] == "closed"
|
||||
finally:
|
||||
task.cancel()
|
||||
with pytest.raises(asyncio.CancelledError):
|
||||
await task
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_native_missing_finding_cannot_be_created(triage_controller: TuiController) -> None:
|
||||
request = _request(triage_controller.collection("vulnerabilities")[0])
|
||||
request["finding_id"] = "vulnerability-0"
|
||||
with pytest.raises(TriageError) as failure:
|
||||
await triage_controller.handle("vulnerability.triage", request)
|
||||
assert failure.value.code == "unknown_finding"
|
||||
271
tests/test_viewer_triage.py
Normal file
271
tests/test_viewer_triage.py
Normal file
|
|
@ -0,0 +1,271 @@
|
|||
"""The viewer's authenticated triage boundary and shared on-disk projection."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import http.client
|
||||
import json
|
||||
from dataclasses import dataclass
|
||||
from typing import TYPE_CHECKING, Any
|
||||
from urllib.parse import urlsplit
|
||||
|
||||
import pytest
|
||||
|
||||
from strix.interface.viewer.server import serve
|
||||
from strix.interface.viewer.transcript import read_vulnerabilities
|
||||
from strix.report.triage import read_triaged_vulnerabilities, triage_finding
|
||||
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from collections.abc import Iterator
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
@dataclass
|
||||
class ViewerClient:
|
||||
run_dir: Path
|
||||
url: str
|
||||
cookie: str
|
||||
|
||||
def request(
|
||||
self,
|
||||
path: str,
|
||||
body: Any = None,
|
||||
*,
|
||||
authorized: bool = True,
|
||||
headers: dict[str, str] | None = None,
|
||||
) -> tuple[int, Any]:
|
||||
request_headers = {"Content-Type": "application/json", "Origin": self.url}
|
||||
if authorized:
|
||||
request_headers["Cookie"] = self.cookie
|
||||
request_headers.update(headers or {})
|
||||
parts = urlsplit(self.url)
|
||||
connection = http.client.HTTPConnection(str(parts.hostname), parts.port, timeout=5)
|
||||
raw = body if isinstance(body, bytes) else json.dumps(body)
|
||||
connection.request(
|
||||
"GET" if body is None else "POST",
|
||||
path,
|
||||
body=None if body is None else raw,
|
||||
headers=request_headers,
|
||||
)
|
||||
response = connection.getresponse()
|
||||
status = response.status
|
||||
data = json.loads(response.read())
|
||||
connection.close()
|
||||
return status, data
|
||||
|
||||
def finding(self) -> dict[str, Any]:
|
||||
status, findings = self.request("/api/vulnerabilities")
|
||||
assert status == 200
|
||||
return dict(findings[0])
|
||||
|
||||
def change(self, finding: dict[str, Any], **changes: Any) -> tuple[int, Any]:
|
||||
return self.request(
|
||||
f"/api/vulnerabilities/{finding['id']}/triage",
|
||||
{
|
||||
"status": "closed",
|
||||
"expected_revision": finding["triage_revision"],
|
||||
"reviewed_digest": finding["finding_digest"],
|
||||
**changes,
|
||||
},
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def viewer(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Iterator[ViewerClient]:
|
||||
run_dir = tmp_path / "runs" / "example"
|
||||
run_dir.mkdir(parents=True)
|
||||
(run_dir / "run.json").write_text(
|
||||
json.dumps({"run_name": "example", "status": "completed", "end_time": "2026-09-16"}),
|
||||
encoding="utf-8",
|
||||
)
|
||||
(run_dir / "vulnerabilities.json").write_text(
|
||||
json.dumps(
|
||||
[
|
||||
{
|
||||
"id": "vuln-0001",
|
||||
"title": "Example finding",
|
||||
"severity": "high",
|
||||
"evidence": "original evidence",
|
||||
}
|
||||
]
|
||||
),
|
||||
encoding="utf-8",
|
||||
)
|
||||
assets = tmp_path / "assets"
|
||||
assets.mkdir()
|
||||
(assets / "index.html").write_text("<!doctype html><title>Test</title>", encoding="utf-8")
|
||||
monkeypatch.setattr("strix.interface.viewer.server.bundle_dir", lambda: assets)
|
||||
monkeypatch.setattr("strix.interface.viewer.auth.is_verified", lambda: False)
|
||||
monkeypatch.setattr("strix.telemetry.triage.record_triage", lambda *_args, **_kwargs: None)
|
||||
server, url, token = serve(run_dir, open_browser=False)
|
||||
parts = urlsplit(url)
|
||||
connection = http.client.HTTPConnection(str(parts.hostname), parts.port, timeout=5)
|
||||
connection.request("GET", f"/?token={token}")
|
||||
response = connection.getresponse()
|
||||
cookie = str(response.getheader("Set-Cookie")).split(";", 1)[0]
|
||||
response.read()
|
||||
connection.close()
|
||||
try:
|
||||
yield ViewerClient(run_dir, url, cookie)
|
||||
finally:
|
||||
server.shutdown()
|
||||
server.server_close()
|
||||
|
||||
|
||||
def test_close_and_reopen_preserve_raw_finding_and_refresh_projection(viewer: ViewerClient) -> None:
|
||||
original = read_vulnerabilities(viewer.run_dir)
|
||||
finding = viewer.finding()
|
||||
_, before = viewer.request("/api/triage/revision")
|
||||
status, result = viewer.change(
|
||||
finding, reason_code="incorrect_assumption", note="<script>local note</script>"
|
||||
)
|
||||
assert status == 200
|
||||
assert result["changed"] is True
|
||||
saved = viewer.finding()
|
||||
assert saved["status"] == "closed"
|
||||
assert saved["resolution_reason"] == "false_positive"
|
||||
assert saved["status_note"] == "<script>local note</script>"
|
||||
assert saved["evidence"] == "original evidence"
|
||||
assert read_triaged_vulnerabilities(viewer.run_dir)[0] == saved
|
||||
assert read_vulnerabilities(viewer.run_dir) == original
|
||||
_, after = viewer.request("/api/triage/revision")
|
||||
assert before != after
|
||||
|
||||
status, result = viewer.change(saved, status="open")
|
||||
assert status == 200
|
||||
assert result["finding"]["status"] == "open"
|
||||
assert result["finding"]["resolution_reason"] is None
|
||||
assert result["finding"]["status_note"] is None
|
||||
assert read_vulnerabilities(viewer.run_dir) == original
|
||||
|
||||
|
||||
def test_external_change_and_new_evidence_are_visible_to_finished_viewer(
|
||||
viewer: ViewerClient,
|
||||
) -> None:
|
||||
finding = viewer.finding()
|
||||
_, before = viewer.request("/api/triage/revision")
|
||||
triage_finding(
|
||||
viewer.run_dir,
|
||||
finding["id"],
|
||||
status="closed",
|
||||
expected_revision=0,
|
||||
reviewed_digest=finding["finding_digest"],
|
||||
surface="tui",
|
||||
)
|
||||
assert viewer.finding()["status"] == "closed"
|
||||
_, after = viewer.request("/api/triage/revision")
|
||||
assert before != after
|
||||
raw = read_vulnerabilities(viewer.run_dir)
|
||||
raw[0]["evidence"] = "materially different evidence"
|
||||
(viewer.run_dir / "vulnerabilities.json").write_text(json.dumps(raw), encoding="utf-8")
|
||||
changed = viewer.finding()
|
||||
assert changed["review_stale"] is True
|
||||
assert changed["status"] == "open"
|
||||
assert viewer.change(finding)[0] == 409
|
||||
_, evidence_revision = viewer.request("/api/triage/revision")
|
||||
assert evidence_revision != after
|
||||
assert viewer.change(changed)[0] == 200
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("headers", "authorized", "status"),
|
||||
[
|
||||
({}, False, 403),
|
||||
({"Origin": "http://untrusted.example"}, True, 403),
|
||||
({"Origin": "null"}, True, 403),
|
||||
({"Origin": ""}, True, 403),
|
||||
({"Sec-Fetch-Site": "cross-site"}, True, 403),
|
||||
({"Content-Type": "text/plain"}, True, 415),
|
||||
],
|
||||
)
|
||||
def test_mutations_require_authorized_same_origin_json(
|
||||
viewer: ViewerClient, headers: dict[str, str], authorized: bool, status: int
|
||||
) -> None:
|
||||
actual, _ = viewer.request(
|
||||
"/api/vulnerabilities/vuln-0001/triage",
|
||||
{"status": "closed"},
|
||||
headers=headers,
|
||||
authorized=authorized,
|
||||
)
|
||||
assert actual == status
|
||||
assert not (viewer.run_dir / "triage.json").exists()
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"body",
|
||||
[
|
||||
b"{",
|
||||
[],
|
||||
{"status": "closed"},
|
||||
{"expected_revision": True},
|
||||
{"reason_code": []},
|
||||
{"note": "x" * 2001},
|
||||
{"surface": "tui"},
|
||||
{"status": "fixed"},
|
||||
],
|
||||
)
|
||||
def test_bad_payloads_cannot_create_a_decision(viewer: ViewerClient, body: Any) -> None:
|
||||
finding = viewer.finding()
|
||||
if isinstance(body, dict):
|
||||
body = {
|
||||
"status": "closed",
|
||||
"expected_revision": 0,
|
||||
"reviewed_digest": finding["finding_digest"],
|
||||
**body,
|
||||
}
|
||||
if body == {
|
||||
"status": "closed",
|
||||
"expected_revision": 0,
|
||||
"reviewed_digest": finding["finding_digest"],
|
||||
}:
|
||||
body.pop("reviewed_digest")
|
||||
status, _ = viewer.request("/api/vulnerabilities/vuln-0001/triage", body)
|
||||
assert status == 400
|
||||
assert not (viewer.run_dir / "triage.json").exists()
|
||||
|
||||
|
||||
def test_oversized_payload_rejected_before_parsing(viewer: ViewerClient) -> None:
|
||||
status, _ = viewer.request("/api/vulnerabilities/vuln-0001/triage", b"x" * 32769)
|
||||
assert status == 413
|
||||
|
||||
|
||||
def test_mutation_run_selection_and_history_gate(
|
||||
viewer: ViewerClient, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
other = viewer.run_dir.parent / "other"
|
||||
other.mkdir()
|
||||
for filename in ("run.json", "vulnerabilities.json"):
|
||||
(other / filename).write_bytes((viewer.run_dir / filename).read_bytes())
|
||||
finding = viewer.finding()
|
||||
body = {
|
||||
"status": "closed",
|
||||
"expected_revision": 0,
|
||||
"reviewed_digest": finding["finding_digest"],
|
||||
}
|
||||
route = "/api/vulnerabilities/vuln-0001/triage"
|
||||
assert viewer.request(route + "?run=other", body)[0] == 401
|
||||
assert viewer.request(route + "?run=../other", body)[0] == 404
|
||||
assert viewer.request(route + "?run=other&run=example", body)[0] == 404
|
||||
(viewer.run_dir.parent / "alias").symlink_to(other, target_is_directory=True)
|
||||
assert viewer.request(route + "?run=alias", body)[0] == 403
|
||||
monkeypatch.setattr("strix.interface.viewer.auth.is_verified", lambda: True)
|
||||
assert viewer.request(route + "?run=other", body)[0] == 200
|
||||
assert viewer.finding()["status"] == "open"
|
||||
|
||||
|
||||
def test_corrupt_sidecar_is_a_visible_error_not_empty_findings(viewer: ViewerClient) -> None:
|
||||
(viewer.run_dir / "triage.json").write_text("{", encoding="utf-8")
|
||||
status, error = viewer.request("/api/vulnerabilities")
|
||||
assert status == 409
|
||||
assert error["error"] == "invalid_triage"
|
||||
assert read_vulnerabilities(viewer.run_dir)[0]["evidence"] == "original evidence"
|
||||
|
||||
|
||||
def test_read_only_run_has_no_write_capability(viewer: ViewerClient) -> None:
|
||||
viewer.run_dir.chmod(0o500)
|
||||
try:
|
||||
finding = viewer.finding()
|
||||
assert finding["can_triage"] is False
|
||||
assert viewer.change(finding)[0] == 403
|
||||
finally:
|
||||
viewer.run_dir.chmod(0o700)
|
||||
Loading…
Add table
Reference in a new issue