From 6a0b79d34f31a0cfc378c868f5635278498b70db Mon Sep 17 00:00:00 2001 From: Coff0xc <184964491+Coff0xc@users.noreply.github.com> Date: Tue, 17 Nov 2026 19:46:58 +0000 Subject: [PATCH] feat(findings): add report_state separate from triage --- db/findings.go | 109 ++++++++++++- db/findings_test.go | 131 ++++++++++++++++ db/migrate_test.go | 4 +- db/migrations/0007_finding_report_state.sql | 5 + db/schema.sql | 5 + db/task_archives.go | 2 + db/task_archives_restore.go | 52 ++++--- db/task_archives_test.go | 31 ++++ report/findings.go | 5 +- server/bulk_finding_status_test.go | 34 ++++ server/dto.go | 40 +++-- server/finding_reasoning_test.go | 11 ++ server/findings_groups.go | 1 + server/server.go | 87 +++++++++-- .../findings/_components/findings-table.tsx | 68 +++++++- .../(main)/function/findings/detail/page.tsx | 51 +++++- web/src/app/(main)/function/findings/page.tsx | 145 ++++++++++++++++-- web/src/lib/api.ts | 11 +- web/src/lib/mock/handler.ts | 27 ++++ web/src/lib/types.ts | 7 + 20 files changed, 751 insertions(+), 75 deletions(-) create mode 100644 db/migrations/0007_finding_report_state.sql diff --git a/db/findings.go b/db/findings.go index 7a242e69a..3c812c783 100644 --- a/db/findings.go +++ b/db/findings.go @@ -31,6 +31,7 @@ type DBFinding struct { Worker string AssetIDs []int64 Status string + ReportState string // none / submitted / accepted / rejected / duplicate; separate from Status PoELevel int // proof-of-exploitation level 0-4 (S1); 0 = none declared VerificationStatus string // verified / unverified / blocked / not_assessed / false_positive VerificationNote string // why the status was reached; empty when verified @@ -65,6 +66,27 @@ func ValidFindingStatus(s string) bool { return false } +// Finding report stages (findings.report_state). A workflow stage after triage, +// not a verdict: a finding can be confirmed and submitted at the same time. +// RSI lesson extraction still reads findings.status. +const ( + FindingReportNone = "none" + FindingReportSubmitted = "submitted" + FindingReportAccepted = "accepted" + FindingReportRejected = "rejected" + FindingReportDuplicate = "duplicate" +) + +// ValidFindingReportState reports whether s is a known report stage. +func ValidFindingReportState(s string) bool { + switch s { + case FindingReportNone, FindingReportSubmitted, FindingReportAccepted, + FindingReportRejected, FindingReportDuplicate: + return true + } + return false +} + // Finding severity levels (findings.severity). const ( SeverityCritical = "critical" // Critical @@ -109,7 +131,7 @@ func (d *DB) AddFinding(taskID, nodeID int64, vulnclass, name, severity, summary // findingSelectCols is the column list (with task_description join) every finding // list query selects, so scanFinding stays in sync across callers. const findingSelectCols = `f.id, f.task_id, f.node_id, f.vulnclass, COALESCE(f.name, ''), f.severity, f.summary, - f.evidence, f.worker, f.asset_ids, COALESCE(f.status, 'pending'), f.created_at, + f.evidence, f.worker, f.asset_ids, COALESCE(f.status, 'pending'), COALESCE(f.report_state, 'none'), f.created_at, COALESCE(t.description, '') AS task_description, f.evidence_version, f.report_evidence_version, f.poe_level, COALESCE(f.verification_status, 'unverified'), COALESCE(f.verification_note, ''), f.counterevidence, f.confidence_rationale, @@ -126,7 +148,7 @@ func scanFindings(rows interface { f := &DBFinding{} var aidsJSON string if err := rows.Scan(&f.ID, &f.TaskID, &f.NodeID, &f.VulnClass, &f.Name, &f.Severity, - &f.Summary, &f.Evidence, &f.Worker, &aidsJSON, &f.Status, &f.CreatedAt, &f.TaskDescription, &f.EvidenceVersion, &f.ReportEvidenceVersion, &f.PoELevel, &f.VerificationStatus, &f.VerificationNote, &f.Counterevidence, &f.ConfidenceRationale, &f.TrafficCount); err != nil { + &f.Summary, &f.Evidence, &f.Worker, &aidsJSON, &f.Status, &f.ReportState, &f.CreatedAt, &f.TaskDescription, &f.EvidenceVersion, &f.ReportEvidenceVersion, &f.PoELevel, &f.VerificationStatus, &f.VerificationNote, &f.Counterevidence, &f.ConfidenceRationale, &f.TrafficCount); err != nil { return nil, err } _ = json.Unmarshal([]byte(aidsJSON), &f.AssetIDs) @@ -160,6 +182,7 @@ func (d *DB) ListFindings(limit int) ([]*DBFinding, error) { type FindingFilter struct { Severity string // high | medium | low Status string // pending | false_positive | ignored | resolved + ReportState string // none | submitted | accepted | rejected | duplicate VerificationStatus string // verified | unverified | blocked | not_assessed | false_positive VulnClass string TaskID string // task id (in string form; empty/invalid = do not filter by task) @@ -197,6 +220,7 @@ func (f FindingFilter) where() (string, []any) { } add("severity", f.Severity) add("status", f.Status) + add("report_state", f.ReportState) add("verification_status", f.VerificationStatus) add("vulnclass", f.VulnClass) // task_id is a bigint column, compared as an integer (it cannot go through @@ -528,7 +552,7 @@ func (d *DB) ListFindingsForExport(f FindingFilter, ids []int64) ([]*DBFinding, f := &DBFinding{} var aidsJSON string if err := rows.Scan(&f.ID, &f.TaskID, &f.NodeID, &f.VulnClass, &f.Name, &f.Severity, - &f.Summary, &f.Evidence, &f.Worker, &aidsJSON, &f.Status, &f.CreatedAt, + &f.Summary, &f.Evidence, &f.Worker, &aidsJSON, &f.Status, &f.ReportState, &f.CreatedAt, &f.TaskDescription, &f.EvidenceVersion, &f.ReportEvidenceVersion, &f.PoELevel, &f.VerificationStatus, &f.VerificationNote, &f.Counterevidence, &f.ConfidenceRationale, &f.TrafficCount, &f.Report); err != nil { return nil, err } @@ -544,6 +568,8 @@ func (d *DB) ListFindingsForExport(f FindingFilter, ids []int64) ([]*DBFinding, type FindingStats struct { Total int `json:"total"` Pending int `json:"pending"` + Submitted int `json:"submitted"` + Accepted int `json:"accepted"` Critical int `json:"critical"` High int `json:"high"` Medium int `json:"medium"` @@ -563,18 +589,20 @@ type FindingTaskOption struct { Count int `json:"count"` } -// FindingStats returns whole-table counts (by severity + pending) and the sorted -// set of distinct vuln classes. +// FindingStats returns whole-table counts (by severity, pending, and report +// stage) and the sorted set of distinct vuln classes. func (d *DB) FindingStats() (*FindingStats, error) { st := &FindingStats{VulnClasses: []string{}, Tasks: []FindingTaskOption{}} err := d.QueryRow(`SELECT COUNT(*), COUNT(*) FILTER (WHERE status = 'pending'), + COUNT(*) FILTER (WHERE report_state = 'submitted'), + COUNT(*) FILTER (WHERE report_state = 'accepted'), COUNT(*) FILTER (WHERE severity = 'critical'), COUNT(*) FILTER (WHERE severity = 'high'), COUNT(*) FILTER (WHERE severity = 'medium'), COUNT(*) FILTER (WHERE severity = 'low') - FROM findings`).Scan(&st.Total, &st.Pending, &st.Critical, &st.High, &st.Medium, &st.Low) + FROM findings`).Scan(&st.Total, &st.Pending, &st.Submitted, &st.Accepted, &st.Critical, &st.High, &st.Medium, &st.Low) if err != nil { return nil, err } @@ -629,6 +657,8 @@ func (d *DB) FindingStats() (*FindingStats, error) { cold := aggregate.FindingStats st.Total += cold.Total st.Pending += cold.Pending + st.Submitted += cold.Submitted + st.Accepted += cold.Accepted st.Critical += cold.Critical st.High += cold.High st.Medium += cold.Medium @@ -658,7 +688,7 @@ func (d *DB) GetFinding(id int64) (*DBFinding, error) { LEFT JOIN tasks t ON f.task_id = t.id WHERE f.id = $1`, id).Scan( &f.ID, &f.TaskID, &f.NodeID, &f.VulnClass, &f.Name, &f.Severity, - &f.Summary, &f.Evidence, &f.Worker, &aidsJSON, &f.Status, &f.CreatedAt, + &f.Summary, &f.Evidence, &f.Worker, &aidsJSON, &f.Status, &f.ReportState, &f.CreatedAt, &f.TaskDescription, &f.EvidenceVersion, &f.ReportEvidenceVersion, &f.PoELevel, &f.VerificationStatus, &f.VerificationNote, &f.Counterevidence, &f.ConfidenceRationale, &f.TrafficCount, &f.Report) if err == sql.ErrNoRows { return nil, nil @@ -723,6 +753,71 @@ func (d *DB) SetFindingStatus(id int64, status string) (int64, error) { return d.setFindingCol(id, "status", "status", status) } +// SetFindingReportState updates one finding's report stage and mirrors it onto +// the originating exploration node's payload under "report_state". It does not +// register a status-change notification: report_state is a workflow stage, not +// a triage verdict. Returns rows affected. +func (d *DB) SetFindingReportState(id int64, state string) (int64, error) { + return d.setFindingCol(id, "report_state", "report_state", state) +} + +// FindingReportStateBatchResult is one id's outcome in a bulk report-stage update. +type FindingReportStateBatchResult struct { + ID int64 `json:"id"` + From string `json:"from,omitempty"` + Found bool `json:"found"` + Changed bool `json:"changed"` +} + +// SetFindingReportStates updates several findings to the same report stage in +// one transaction. Unknown ids come back as found=false instead of hiding the +// others; a database error rolls the whole batch back. No notification event +// is written — status-change pushes stay on findings.status. +func (d *DB) SetFindingReportStates(ctx context.Context, ids []int64, state string) ([]FindingReportStateBatchResult, error) { + out := make([]FindingReportStateBatchResult, 0, len(ids)) + err := d.WithEvidenceTx(ctx, func(tx *sql.Tx) error { + for _, id := range ids { + from, found, changed, err := setFindingReportStateTx(ctx, tx, id, state) + if err != nil { + return err + } + out = append(out, FindingReportStateBatchResult{ID: id, From: from, Found: found, Changed: changed}) + } + return nil + }) + if err != nil { + return nil, err + } + return out, nil +} + +func setFindingReportStateTx(ctx context.Context, tx *sql.Tx, id int64, state string) (from string, found bool, changed bool, err error) { + var nodeID sql.NullInt64 + scanErr := tx.QueryRowContext(ctx, `SELECT COALESCE(report_state,'none'), node_id +FROM findings WHERE id=$1 FOR UPDATE`, id).Scan(&from, &nodeID) + if scanErr == sql.ErrNoRows { + return "", false, false, nil + } + if scanErr != nil { + return "", false, false, scanErr + } + found = true + if from == state { + return from, true, false, nil + } + if _, err := tx.ExecContext(ctx, `UPDATE findings SET report_state=$2 WHERE id=$1`, id, state); err != nil { + return from, true, false, err + } + if nodeID.Valid { + if _, err := tx.ExecContext(ctx, `UPDATE exploration_nodes + SET payload = jsonb_set(payload, '{report_state}', to_jsonb($1::text)) + WHERE id = $2`, state, nodeID.Int64); err != nil { + return from, true, false, err + } + } + return from, true, true, nil +} + // SetFindingReportByNodeID sets the Markdown report on the standalone finding row // whose node_id matches — report_finding returns that node id, so an agent tool // can address the finding it just created. Returns rows affected (0 when no row). diff --git a/db/findings_test.go b/db/findings_test.go index a5e915d9b..c88006f64 100644 --- a/db/findings_test.go +++ b/db/findings_test.go @@ -13,6 +13,25 @@ import ( // TestDeleteFinding verifies that deleting a finding removes both the findings // row and its originating exploration node (kind='finding'). +func TestValidFindingReportState(t *testing.T) { + for _, s := range []string{ + FindingReportNone, FindingReportSubmitted, FindingReportAccepted, + FindingReportRejected, FindingReportDuplicate, + } { + if !ValidFindingReportState(s) { + t.Fatalf("%q should be valid", s) + } + } + for _, s := range []string{"", "confirmed", "pending", "SUBMITTED", "submitted "} { + if ValidFindingReportState(s) { + t.Fatalf("%q should be invalid", s) + } + } + if ValidFindingStatus(FindingReportSubmitted) { + t.Fatal("submitted must not be a triage status") + } +} + func TestDeleteFinding(t *testing.T) { d, err := Open(testDSN(t)) if err != nil { @@ -122,6 +141,115 @@ func TestSetFindingStatusMirrorsNodePayload(t *testing.T) { } } +func TestFindingReportState(t *testing.T) { + d, err := Open(testDSN(t)) + if err != nil { + t.Skipf("postgres unavailable (%v) — skipping", err) + } + defer d.Close() + + tk, err := d.CreateTask("finding report state", "goal", nil, 0, 0) + if err != nil { + t.Fatal(err) + } + defer d.DeleteTask(tk.ID) + + es := d.Exploration(tk.ExplorationID) + nodeID, err := es.AddNode(KindFinding, map[string]any{"summary": "x", "severity": "high"}, 5, "confirmed", "worker", nil) + if err != nil { + t.Fatal(err) + } + fid, err := d.AddFinding(tk.ID, nodeID, "XSS", "reflected XSS", "high", "summary", "poc", "worker", nil) + if err != nil { + t.Fatal(err) + } + second, err := d.AddFinding(tk.ID, 0, "XSS", "other", "low", "summary", "poc", "worker", nil) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { d.Exec(`DELETE FROM notification_events WHERE finding_id IN ($1,$2)`, fid, second) }) + + one, err := d.GetFinding(fid) + if err != nil || one == nil || one.ReportState != FindingReportNone { + t.Fatalf("new finding report_state: %+v err=%v", one, err) + } + + n, err := d.SetFindingReportState(fid, FindingReportSubmitted) + if err != nil || n != 1 { + t.Fatalf("SetFindingReportState: n=%d err=%v", n, err) + } + one, _ = d.GetFinding(fid) + if one.ReportState != FindingReportSubmitted { + t.Fatalf("report_state=%q", one.ReportState) + } + if one.Status != FindingPending { + t.Fatalf("triage status changed: %q", one.Status) + } + + var payload []byte + if err := d.QueryRow(`SELECT payload FROM exploration_nodes WHERE id=$1`, nodeID).Scan(&payload); err != nil { + t.Fatal(err) + } + var p map[string]any + if err := json.Unmarshal(payload, &p); err != nil { + t.Fatal(err) + } + if p["report_state"] != FindingReportSubmitted { + t.Fatalf("payload report_state=%v", p["report_state"]) + } + + listed, total, err := d.ListFindingsPage(FindingFilter{TaskID: fmt.Sprintf("%d", tk.ID), ReportState: FindingReportSubmitted}, 1, 20) + if err != nil || total != 1 || len(listed) != 1 || listed[0].ID != fid { + t.Fatalf("filter submitted: total=%d listed=%d err=%v", total, len(listed), err) + } + + st, err := d.FindingStats() + if err != nil || st.Submitted < 1 { + t.Fatalf("stats submitted undercount: %+v err=%v", st, err) + } + + const missingID = int64(999999999) + results, err := d.SetFindingReportStates(context.Background(), []int64{fid, second, missingID}, FindingReportAccepted) + if err != nil { + t.Fatal(err) + } + if len(results) != 3 { + t.Fatalf("want 3 results, got %d", len(results)) + } + if !results[0].Found || !results[0].Changed || results[0].From != FindingReportSubmitted { + t.Fatalf("first: %+v", results[0]) + } + if !results[1].Found || !results[1].Changed || results[1].From != FindingReportNone { + t.Fatalf("second: %+v", results[1]) + } + if results[2].Found || results[2].Changed { + t.Fatalf("missing: %+v", results[2]) + } + + again, err := d.SetFindingReportStates(context.Background(), []int64{fid}, FindingReportAccepted) + if err != nil || len(again) != 1 || again[0].Changed { + t.Fatalf("noop batch: %v %v", again, err) + } + + var events int + if err := d.QueryRow(`SELECT count(*) FROM notification_events WHERE finding_id IN ($1,$2)`, fid, second).Scan(&events); err != nil || events != 0 { + t.Fatalf("report_state must not write notification_events: %d (%v)", events, err) + } + + one, _ = d.GetFinding(fid) + if one.Status != FindingPending { + t.Fatalf("bulk report_state mutated triage: %q", one.Status) + } + if one.ReportState != FindingReportAccepted { + t.Fatalf("bulk report_state=%q", one.ReportState) + } + + st, err = d.FindingStats() + if err != nil || st.Accepted < 2 { + t.Fatalf("stats accepted undercount: %+v err=%v", st, err) + } +} + // TestFindingsPageAndStats exercises ListFindingsPage (filter/sort/paging) and // FindingStats against the live dev PG. It tags its rows with a unique vulnclass // so assertions are isolated from any pre-existing data, and cleans up after. @@ -226,6 +354,9 @@ func TestFindingsPageAndStats(t *testing.T) { if one == nil || one.ID != ids[0] || one.Severity != "critical" || one.Name != "Critical Vulnerability Title" { t.Fatalf("GetFinding mismatch: %+v", one) } + if one.ReportState != FindingReportNone { + t.Fatalf("new finding report_state should be none, got %q", one.ReportState) + } if one.Report != "" { t.Fatalf("new finding report should be empty, got %q", one.Report) } diff --git a/db/migrate_test.go b/db/migrate_test.go index fc6d756ef..49b2ca8fb 100644 --- a/db/migrate_test.go +++ b/db/migrate_test.go @@ -137,9 +137,9 @@ func assertEmbeddedApplied(t *testing.T, d *DB) []appliedMigration { version int name string }{{1, llmRecordsMigration}, {2, llmUsageMigration}, {3, "0003_task_scope_icp_index.sql"}, {4, "0004_llm_usage_ts_index.sql"}, - {5, "0005_traffic_rewrite_rules.sql"}, {6, "0006_activity_outbox.sql"}} + {5, "0005_traffic_rewrite_rules.sql"}, {6, "0006_activity_outbox.sql"}, {7, "0007_finding_report_state.sql"}} if len(applied) != len(want) { - t.Fatalf("schema_migrations = %+v, want versions 1 to 6", applied) + t.Fatalf("schema_migrations = %+v, want versions 1 to 7", applied) } for i, w := range want { content, err := fs.ReadFile(migrationsFS(), w.name) diff --git a/db/migrations/0007_finding_report_state.sql b/db/migrations/0007_finding_report_state.sql new file mode 100644 index 000000000..66b4a439d --- /dev/null +++ b/db/migrations/0007_finding_report_state.sql @@ -0,0 +1,5 @@ +-- Report stage on findings, separate from triage status. Existing rows stay +-- 'none'. Values are validated server-side (no CHECK): none / submitted / +-- accepted / rejected / duplicate. RSI lessons still read findings.status. +ALTER TABLE findings ADD COLUMN IF NOT EXISTS report_state TEXT NOT NULL DEFAULT 'none'; +CREATE INDEX IF NOT EXISTS idx_findings_report_state ON findings (report_state, created_at DESC); diff --git a/db/schema.sql b/db/schema.sql index abbfdf878..9d6d14bbd 100644 --- a/db/schema.sql +++ b/db/schema.sql @@ -1256,6 +1256,11 @@ ALTER TABLE findings ADD COLUMN IF NOT EXISTS verification_note TEXT NOT NULL DE -- tested and did not work; confidence_rationale is why the conclusion holds. ALTER TABLE findings ADD COLUMN IF NOT EXISTS counterevidence TEXT NOT NULL DEFAULT ''; ALTER TABLE findings ADD COLUMN IF NOT EXISTS confidence_rationale TEXT NOT NULL DEFAULT ''; +-- Report stage after triage (none / submitted / accepted / rejected / duplicate). +-- Separate from status so a finding can be confirmed and submitted at once; RSI +-- lessons still read status. Server whitelist, no CHECK (same as status). +ALTER TABLE findings ADD COLUMN IF NOT EXISTS report_state TEXT NOT NULL DEFAULT 'none'; +CREATE INDEX IF NOT EXISTS idx_findings_report_state ON findings (report_state, created_at DESC); CREATE TABLE IF NOT EXISTS traffic_evidence_snapshots ( id TEXT PRIMARY KEY, diff --git a/db/task_archives.go b/db/task_archives.go index f312000e4..bb9aae241 100644 --- a/db/task_archives.go +++ b/db/task_archives.go @@ -770,6 +770,8 @@ FROM skill_usage WHERE (task_id=$1 OR exploration_id=$2) AND NOT found GROUP BY {"findings", `SELECT COALESCE(jsonb_object_agg(name,n),'{}'::jsonb) FROM (SELECT COALESCE(NULLIF(severity,''),'unknown') name,count(*) n FROM findings WHERE task_id=$1 GROUP BY severity) x`, []any{taskID}}, {"finding_stats", `SELECT jsonb_build_object( 'total',count(*),'pending',count(*) FILTER (WHERE status='pending'), + 'submitted',count(*) FILTER (WHERE report_state='submitted'), + 'accepted',count(*) FILTER (WHERE report_state='accepted'), 'critical',count(*) FILTER (WHERE severity='critical'),'high',count(*) FILTER (WHERE severity='high'), 'medium',count(*) FILTER (WHERE severity='medium'),'low',count(*) FILTER (WHERE severity='low'), 'vulnclasses',COALESCE(jsonb_agg(DISTINCT vulnclass) FILTER (WHERE vulnclass<>''),'[]'::jsonb)) diff --git a/db/task_archives_restore.go b/db/task_archives_restore.go index 11e9f1895..e92fe2a60 100644 --- a/db/task_archives_restore.go +++ b/db/task_archives_restore.go @@ -361,28 +361,40 @@ func rowExists(tx *sql.Tx, table string, id int64) bool { return exists } -func insertArchiveRows(tx *sql.Tx, table string, raw json.RawMessage) error { - // json_populate_recordset inserts NULL for absent columns, bypassing SQL - // defaults. Preserve compatibility with v3 archives predating side memory. - if (table == "side_question_sessions" || table == "side_question_requests") && len(raw) > 0 { - var rows []map[string]json.RawMessage - if err := json.Unmarshal(raw, &rows); err != nil { - return err - } - field := "memory" - if table == "side_question_requests" { - field = "context_info" - } - for _, row := range rows { +// archiveDefaults are the columns that did not exist when older archives were +// written. json_populate_recordset inserts NULL for an absent key, bypassing the +// SQL default, and a NOT NULL column then rejects the whole restore. +var archiveDefaults = map[string]map[string]string{ + "side_question_sessions": {"memory": `{}`}, + "side_question_requests": {"context_info": `{}`}, + "findings": {"report_state": `"none"`}, +} + +// fillArchiveDefaults restores the default of a column an older archive +// predates, so a restore keeps working across schema additions. +func fillArchiveDefaults(table string, raw json.RawMessage) (json.RawMessage, error) { + defaults, ok := archiveDefaults[table] + if !ok || len(raw) == 0 { + return raw, nil + } + var rows []map[string]json.RawMessage + if err := json.Unmarshal(raw, &rows); err != nil { + return nil, err + } + for _, row := range rows { + for field, def := range defaults { if len(row[field]) == 0 || string(row[field]) == "null" { - row[field] = json.RawMessage(`{}`) + row[field] = json.RawMessage(def) } } - var err error - raw, err = json.Marshal(rows) - if err != nil { - return err - } + } + return json.Marshal(rows) +} + +func insertArchiveRows(tx *sql.Tx, table string, raw json.RawMessage) error { + raw, err := fillArchiveDefaults(table, raw) + if err != nil { + return err } allowed := map[string]bool{ "exploration_nodes": true, "exploration_edges": true, "exploration_anchors": true, @@ -396,7 +408,7 @@ func insertArchiveRows(tx *sql.Tx, table string, raw json.RawMessage) error { if rawRowCount(raw) == 0 { return nil } - _, err := tx.Exec(`INSERT INTO `+table+` SELECT * FROM json_populate_recordset(NULL::`+table+`,$1::json)`, string(raw)) + _, err = tx.Exec(`INSERT INTO `+table+` SELECT * FROM json_populate_recordset(NULL::`+table+`,$1::json)`, string(raw)) return err } diff --git a/db/task_archives_test.go b/db/task_archives_test.go index aefab198c..62f51672d 100644 --- a/db/task_archives_test.go +++ b/db/task_archives_test.go @@ -486,3 +486,34 @@ func assertArchiveGlobalStats(t *testing.T, d *DB, profileName, skillName, toolN t.Fatalf("archive finding class %q missing", vulnclass) } } + +// An archive written before report_state existed restores with the column's +// default instead of failing on the NOT NULL constraint. +func TestFillArchiveDefaults(t *testing.T) { + raw := json.RawMessage(`[{"id":1,"summary":"old"},{"id":2,"report_state":null},{"id":3,"report_state":"submitted"}]`) + out, err := fillArchiveDefaults("findings", raw) + if err != nil { + t.Fatal(err) + } + var rows []map[string]json.RawMessage + if err := json.Unmarshal(out, &rows); err != nil { + t.Fatal(err) + } + want := []string{`"none"`, `"none"`, `"submitted"`} + for i, row := range rows { + if string(row["report_state"]) != want[i] { + t.Fatalf("row %d report_state=%s, want %s", i, row["report_state"], want[i]) + } + } + + // Side memory keeps its own default, and other tables pass through. + out, err = fillArchiveDefaults("side_question_sessions", json.RawMessage(`[{"id":1}]`)) + if err != nil || !strings.Contains(string(out), `"memory":{}`) { + t.Fatalf("side memory default missing: %s err=%v", out, err) + } + in := json.RawMessage(`[{"id":1}]`) + out, err = fillArchiveDefaults("activity", in) + if err != nil || string(out) != string(in) { + t.Fatalf("activity changed: %s err=%v", out, err) + } +} diff --git a/report/findings.go b/report/findings.go index a059e6946..16431b61a 100644 --- a/report/findings.go +++ b/report/findings.go @@ -70,6 +70,7 @@ func FindingsMarkdown(fs []*db.DBFinding, generatedAt time.Time) string { fmt.Fprintf(&b, "- **Class**: %s\n", f.VulnClass) } fmt.Fprintf(&b, "- **Status**: %s\n", nz(f.Status, "pending")) + fmt.Fprintf(&b, "- **Report stage**: %s\n", nz(f.ReportState, "none")) if desc := strings.TrimSpace(f.TaskDescription); desc != "" { fmt.Fprintf(&b, "- **Task**: %s\n", desc) } @@ -99,6 +100,7 @@ func SingleFindingMarkdown(f *db.DBFinding, generatedAt time.Time) string { } fmt.Fprintf(&b, "- **Severity**: %s\n", nz(f.Severity, "info")) fmt.Fprintf(&b, "- **Status**: %s\n", nz(f.Status, "pending")) + fmt.Fprintf(&b, "- **Report stage**: %s\n", nz(f.ReportState, "none")) if desc := strings.TrimSpace(f.TaskDescription); desc != "" { fmt.Fprintf(&b, "- **Task**: %s\n", desc) } @@ -148,7 +150,7 @@ func FindingsCSV(fs []*db.DBFinding) []byte { var buf bytes.Buffer buf.WriteString("\xEF\xBB\xBF") // UTF-8 BOM w := csv.NewWriter(&buf) - _ = w.Write([]string{"ID", "Name", "Class", "Severity", "Status", "Task", "Found At", "Summary", "Traffic Evidence Count", "Traffic Evidence IDs"}) + _ = w.Write([]string{"ID", "Name", "Class", "Severity", "Status", "Report Stage", "Task", "Found At", "Summary", "Traffic Evidence Count", "Traffic Evidence IDs"}) for _, f := range items { _ = w.Write([]string{ fmt.Sprintf("%d", f.ID), @@ -156,6 +158,7 @@ func FindingsCSV(fs []*db.DBFinding) []byte { f.VulnClass, nz(f.Severity, "info"), nz(f.Status, "pending"), + nz(f.ReportState, "none"), f.TaskDescription, f.CreatedAt.Format("2006-01-02 15:04:05"), strings.TrimSpace(f.Summary), diff --git a/server/bulk_finding_status_test.go b/server/bulk_finding_status_test.go index a0932add7..3e565d834 100644 --- a/server/bulk_finding_status_test.go +++ b/server/bulk_finding_status_test.go @@ -32,3 +32,37 @@ func TestBulkFindingStatusValidation(t *testing.T) { }) } } + +func TestNormalizeFindingIDs(t *testing.T) { + got := normalizeFindingIDs([]int64{0, -1, 2, 2, 3, 4}, 2) + if len(got) != 2 || got[0] != 2 || got[1] != 3 { + t.Fatalf("got %v, want [2 3]", got) + } + if got := normalizeFindingIDs(nil, 500); len(got) != 0 { + t.Fatalf("empty input: %v", got) + } +} + +func TestBulkFindingReportStateValidation(t *testing.T) { + s := &Server{m: &Manager{}} + cases := []struct { + name string + body string + want int + }{ + {"bad json", `{`, http.StatusBadRequest}, + {"unknown state", `{"ids":[1],"report_state":"confirmed"}`, http.StatusBadRequest}, + {"empty ids", `{"ids":[],"report_state":"submitted"}`, http.StatusBadRequest}, + {"non-positive ids", `{"ids":[0,-3],"report_state":"submitted"}`, http.StatusBadRequest}, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + rec := httptest.NewRecorder() + req := httptest.NewRequest(http.MethodPost, "/api/exploration/findings/bulk-report-state", strings.NewReader(tc.body)) + s.bulkPatchFindingReportState(rec, req) + if rec.Code != tc.want { + t.Fatalf("status %d, want %d: %s", rec.Code, tc.want, rec.Body.String()) + } + }) + } +} diff --git a/server/dto.go b/server/dto.go index 891d3717a..3d11398db 100644 --- a/server/dto.go +++ b/server/dto.go @@ -327,15 +327,16 @@ type FindingDTO struct { Counterevidence string `json:"counterevidence,omitempty"` // what was tested and did not work; optional ConfidenceRationale string `json:"confidence_rationale,omitempty"` // why the conclusion holds; optional - ID string `json:"id"` - FindingID string `json:"finding_id,omitempty"` // standalone findings-table id — the handle for status updates - VulnClass string `json:"vulnclass"` - Name string `json:"name,omitempty"` // vulnerability name; the frontend falls back to displaying vulnclass when empty - Severity string `json:"severity"` // critical | high | medium | low - Status string `json:"status"` // pending | in_progress | confirmed | resolved | fixed | false_positive | ignored | duplicate | risk_accepted - Summary string `json:"summary"` - Evidence string `json:"evidence"` - Report string `json:"report,omitempty"` // detailed report (Markdown); returned only by the detail endpoint, empty in lists + ID string `json:"id"` + FindingID string `json:"finding_id,omitempty"` // standalone findings-table id — the handle for status updates + VulnClass string `json:"vulnclass"` + Name string `json:"name,omitempty"` // vulnerability name; the frontend falls back to displaying vulnclass when empty + Severity string `json:"severity"` // critical | high | medium | low + Status string `json:"status"` // pending | in_progress | confirmed | resolved | fixed | false_positive | ignored | duplicate | risk_accepted + ReportState string `json:"report_state"` // none | submitted | accepted | rejected | duplicate; workflow stage, not a triage verdict + Summary string `json:"summary"` + Evidence string `json:"evidence"` + Report string `json:"report,omitempty"` // detailed report (Markdown); returned only by the detail endpoint, empty in lists IntentID string `json:"intent_id,omitempty"` ParamID string `json:"param_id,omitempty"` @@ -461,6 +462,10 @@ func findingFromDB(f *db.DBFinding, assets map[int64]*db.Asset) FindingDTO { if status == "" { status = db.FindingPending } + reportState := f.ReportState + if reportState == "" { + reportState = db.FindingReportNone + } d := FindingDTO{ ID: i64s(f.ID), FindingID: i64s(f.ID), @@ -468,14 +473,15 @@ func findingFromDB(f *db.DBFinding, assets map[int64]*db.Asset) FindingDTO { ReportStale: f.Report != "" && f.EvidenceVersion != f.ReportEvidenceVersion, TrafficBindings: f.TrafficBindings, PoELevel: f.PoELevel, VerificationStatus: f.VerificationStatus, VerificationNote: f.VerificationNote, Counterevidence: f.Counterevidence, ConfidenceRationale: f.ConfidenceRationale, - VulnClass: f.VulnClass, - Name: f.Name, - Severity: f.Severity, - Status: status, - Summary: f.Summary, - Evidence: f.Evidence, - Report: f.Report, - TS: rfc3339(f.CreatedAt), + VulnClass: f.VulnClass, + Name: f.Name, + Severity: f.Severity, + Status: status, + ReportState: reportState, + Summary: f.Summary, + Evidence: f.Evidence, + Report: f.Report, + TS: rfc3339(f.CreatedAt), } d.Assets = findingAssetDTOs(f.AssetIDs, assets) if f.TaskID != nil { diff --git a/server/finding_reasoning_test.go b/server/finding_reasoning_test.go index 1a614edf5..7ccf79062 100644 --- a/server/finding_reasoning_test.go +++ b/server/finding_reasoning_test.go @@ -26,6 +26,17 @@ func TestFindingDTOReasoningFields(t *testing.T) { } } +func TestFindingDTOReportState(t *testing.T) { + raw, _ := json.Marshal(findingFromDB(&db.DBFinding{ID: 1}, nil)) + if !strings.Contains(string(raw), `"report_state":"none"`) { + t.Fatalf("empty report_state should serialize as none: %s", raw) + } + d := findingFromDB(&db.DBFinding{ID: 2, ReportState: db.FindingReportSubmitted}, nil) + if d.ReportState != db.FindingReportSubmitted { + t.Fatalf("report_state lost: %q", d.ReportState) + } +} + // PG: the detail endpoint returns the stored fields, and the report_finding // schema upgrade adds both properties to an existing (customized) row without // overwriting it. diff --git a/server/findings_groups.go b/server/findings_groups.go index 075f8b00c..b920ae3f1 100644 --- a/server/findings_groups.go +++ b/server/findings_groups.go @@ -31,6 +31,7 @@ func findingFilterFromQuery(q url.Values) db.FindingFilter { return db.FindingFilter{ Severity: normFilter(q.Get("severity")), Status: normFilter(q.Get("status")), + ReportState: normFilter(q.Get("report_state")), VerificationStatus: normFilter(q.Get("verification_status")), VulnClass: normFilter(q.Get("vulnclass")), // task_id (independent of the task param, which switches to the per-task-node branch): filters the global table by task. diff --git a/server/server.go b/server/server.go index 4bb6f7a49..5e709bbbc 100644 --- a/server/server.go +++ b/server/server.go @@ -848,6 +848,7 @@ func (s *Server) Handler() http.Handler { mux.HandleFunc("POST /api/exploration/findings/{id}/retests", s.startFindingRetest) mux.HandleFunc("PATCH /api/exploration/findings/{id}", s.patchFinding) mux.HandleFunc("POST /api/exploration/findings/bulk-status", s.bulkPatchFindingStatus) + mux.HandleFunc("POST /api/exploration/findings/bulk-report-state", s.bulkPatchFindingReportState) mux.HandleFunc("DELETE /api/exploration/findings/{id}", s.deleteFinding) mux.HandleFunc("GET /api/exploration/intents", s.intents) mux.HandleFunc("GET /api/exploration/graph", s.explorationGraph) @@ -2364,7 +2365,7 @@ func (s *Server) getFinding(w http.ResponseWriter, r *http.Request) { // format = md-single (one combined .md) | md-zip (one .md per vulnerability, zipped) // | csv | json // ids = comma-separated finding ids (required when scope=selected) -// Filter params severity/status/vulnclass/task_id/q/sort match the list endpoint (used when scope=filtered). +// Filter params severity/status/report_state/vulnclass/task_id/q/sort match the list endpoint (used when scope=filtered). func (s *Server) findingsExport(w http.ResponseWriter, r *http.Request) { q := r.URL.Query() scope := q.Get("scope") @@ -2529,17 +2530,18 @@ func (s *Server) patchFinding(w http.ResponseWriter, r *http.Request) { return } var body struct { - Status *string `json:"status"` - Severity *string `json:"severity"` - Name *string `json:"name"` - VulnClass *string `json:"vulnclass"` + Status *string `json:"status"` + ReportState *string `json:"report_state"` + Severity *string `json:"severity"` + Name *string `json:"name"` + VulnClass *string `json:"vulnclass"` } if err := json.NewDecoder(r.Body).Decode(&body); err != nil { writeErr(w, 400, "bad json: "+err.Error()) return } - if body.Status == nil && body.Severity == nil && body.Name == nil && body.VulnClass == nil { - writeErr(w, 400, "nothing to update: provide status/severity/name/vulnclass") + if body.Status == nil && body.ReportState == nil && body.Severity == nil && body.Name == nil && body.VulnClass == nil { + writeErr(w, 400, "nothing to update: provide status/severity/name/vulnclass/report_state") return } if body.Status != nil { @@ -2563,6 +2565,21 @@ func (s *Server) patchFinding(w http.ResponseWriter, r *http.Request) { log.Printf("[notify] status-change event not registered finding=%d %s→%s (status was updated)", id, from, *body.Status) } } + if body.ReportState != nil { + if !db.ValidFindingReportState(*body.ReportState) { + writeErr(w, 400, "bad report_state: "+*body.ReportState) + return + } + n, err := s.m.pg.SetFindingReportState(id, *body.ReportState) + if err != nil { + writeErr(w, 500, err.Error()) + return + } + if n == 0 { + writeErr(w, 404, "finding not found") + return + } + } if body.Severity != nil { if !db.ValidSeverity(*body.Severity) { writeErr(w, 400, "bad severity: "+*body.Severity) @@ -2634,23 +2651,67 @@ func (s *Server) bulkPatchFindingStatus(w http.ResponseWriter, r *http.Request) writeErr(w, 400, "bad status: "+body.Status) return } - seen := make(map[int64]bool, len(body.IDs)) - ids := make([]int64, 0, len(body.IDs)) - for _, id := range body.IDs { + ids := normalizeFindingIDs(body.IDs, maxBulkFindingStatus) + if len(ids) == 0 { + writeErr(w, 400, "no finding ids") + return + } + results, err := s.m.pg.SetFindingStatusesWithNotify(r.Context(), ids, body.Status) + if err != nil { + writeErr(w, 500, err.Error()) + return + } + updated, missing := 0, 0 + for _, res := range results { + if res.Changed { + updated++ + } + if !res.Found { + missing++ + } + } + writeJSON(w, 200, map[string]any{"updated": updated, "missing": missing, "results": results}) +} + +// normalizeFindingIDs drops non-positive and duplicate ids, then caps the list. +func normalizeFindingIDs(ids []int64, capN int) []int64 { + seen := make(map[int64]bool, len(ids)) + out := make([]int64, 0, len(ids)) + for _, id := range ids { if id <= 0 || seen[id] { continue } seen[id] = true - ids = append(ids, id) - if len(ids) == maxBulkFindingStatus { + out = append(out, id) + if capN > 0 && len(out) == capN { break } } + return out +} + +// bulkPatchFindingReportState sets the same report stage on a batch of findings +// in one transaction. Same cap/dedupe/per-id result as bulk status, without +// status-change notifications: report_state is a workflow stage, not a verdict. +func (s *Server) bulkPatchFindingReportState(w http.ResponseWriter, r *http.Request) { + var body struct { + IDs []int64 `json:"ids"` + ReportState string `json:"report_state"` + } + if err := json.NewDecoder(r.Body).Decode(&body); err != nil { + writeErr(w, 400, "bad json: "+err.Error()) + return + } + if !db.ValidFindingReportState(body.ReportState) { + writeErr(w, 400, "bad report_state: "+body.ReportState) + return + } + ids := normalizeFindingIDs(body.IDs, maxBulkFindingStatus) if len(ids) == 0 { writeErr(w, 400, "no finding ids") return } - results, err := s.m.pg.SetFindingStatusesWithNotify(r.Context(), ids, body.Status) + results, err := s.m.pg.SetFindingReportStates(r.Context(), ids, body.ReportState) if err != nil { writeErr(w, 500, err.Error()) return diff --git a/web/src/app/(main)/function/findings/_components/findings-table.tsx b/web/src/app/(main)/function/findings/_components/findings-table.tsx index 3821f564c..56b7b5bbb 100644 --- a/web/src/app/(main)/function/findings/_components/findings-table.tsx +++ b/web/src/app/(main)/function/findings/_components/findings-table.tsx @@ -37,7 +37,14 @@ import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@ import { Spinner } from "@/components/ui/spinner"; import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table"; import { statusMeta, type Tone, toneClasses } from "@/lib/status"; -import type { ActiveFindingRetest, Finding, FindingStatus, Severity, VerificationStatus } from "@/lib/types"; +import type { + ActiveFindingRetest, + Finding, + FindingReportState, + FindingStatus, + Severity, + VerificationStatus, +} from "@/lib/types"; import { cn } from "@/lib/utils"; export const SEVERITIES: Severity[] = ["critical", "high", "medium", "low"]; @@ -62,6 +69,37 @@ export const VERIFICATION_STATUSES: VerificationStatus[] = [ "false_positive", ]; +export const FINDING_REPORT_STATES: FindingReportState[] = [ + "none", + "submitted", + "accepted", + "rejected", + "duplicate", +]; + +export const REPORT_STATE_META: Record = { + none: { label: "Not submitted", tone: "slate" }, + submitted: { label: "Submitted", tone: "amber" }, + accepted: { label: "Accepted", tone: "green" }, + rejected: { label: "Rejected", tone: "red" }, + duplicate: { label: "Duplicate report", tone: "neutral" }, +}; + +export function ReportStateBadge({ state }: { state?: FindingReportState }) { + const value = state ?? "none"; + const meta = REPORT_STATE_META[value] ?? REPORT_STATE_META.none; + return ( + + {meta.label} + + ); +} + // Verification outcome → label/tone, on the same tone tokens StatusBadge uses. export const VERIFICATION_META: Record = { verified: { label: "Verified", tone: "green" }, @@ -125,7 +163,7 @@ export function fmtTime(ts: string) { }); } -const COLUMN_COUNT = 9; +const COLUMN_COUNT = 10; interface FindingsTableProps { items: Finding[]; @@ -141,6 +179,7 @@ interface FindingsTableProps { saving: boolean; onSave: (finding: Finding) => void; onStatusChange: (finding: Finding, next: FindingStatus) => void; + onReportStateChange: (finding: Finding, next: FindingReportState) => void; onRetest: (finding: Finding) => void; activeRetests: Record; onDeepen: (finding: Finding) => void; @@ -164,6 +203,7 @@ export function FindingsTable({ saving, onSave, onStatusChange, + onReportStateChange, onRetest, activeRetests, onDeepen, @@ -181,7 +221,7 @@ export function FindingsTable({ return ( /* Fixed column widths keep expanded content from stretching the table; narrow screens scroll horizontally inside the table only. */ - +
@@ -196,6 +236,7 @@ export function FindingsTable({ Vulnerability Asset Status + Report Task Time Actions @@ -296,6 +337,27 @@ export function FindingsTable({ )} + e.stopPropagation()}> + {f.finding_id ? ( + + ) : ( + + )} + {f.task_id ? ( { + if (!finding || finding.inherited || next === (finding.report_state ?? "none")) return; + const prev = finding.report_state ?? "none"; + setFinding({ ...finding, report_state: next }); + try { + const updated = await api.setFindingReportState(id, next); + setFinding(updated); + toast.success(`Report stage changed to "${REPORT_STATE_META[next].label}"`); + } catch (e) { + setFinding((cur) => (cur ? { ...cur, report_state: prev } : cur)); + toast.error("Update failed: " + (e as Error).message); + } + }, + [finding, id], + ); + if (!finding) { return (
@@ -148,6 +170,7 @@ function FindingDetailInner() { + {finding.inherited && finding.source_task_id && ( Source task #{finding.source_task_id} · read-only @@ -294,6 +317,30 @@ function FindingDetailInner() { )} + + {finding.inherited ? ( + + ) : ( + + )} + + {/* Verification: automated outcome; the note explains any state other than verified */} {finding.verification_status && ( diff --git a/web/src/app/(main)/function/findings/page.tsx b/web/src/app/(main)/function/findings/page.tsx index 68e4f904c..25eb1c18f 100644 --- a/web/src/app/(main)/function/findings/page.tsx +++ b/web/src/app/(main)/function/findings/page.tsx @@ -8,8 +8,10 @@ import { ArrowUpRightIcon, BugIcon, ChevronRightIcon, + CircleCheckIcon, ClockIcon, DownloadIcon, + FileUpIcon, InfoIcon, SearchIcon, ShieldAlertIcon, @@ -46,6 +48,7 @@ import type { Finding, FindingAssetNode, FindingGroup, + FindingReportState, FindingStats, FindingStatus, Severity, @@ -55,6 +58,7 @@ import { cn } from "@/lib/utils"; import { AssetTree, assetPathOf } from "./_components/asset-tree"; import { + FINDING_REPORT_STATES, FINDING_STATUSES, type FindingEdit, type FindingReport, @@ -62,6 +66,7 @@ import { findingRowKey, fmtTime, isSameFinding, + REPORT_STATE_META, SEVERITIES, UNASSIGNED_TASK, VERIFICATION_META, @@ -124,6 +129,8 @@ function findingGroupKey(group: FindingGroup) { const EMPTY_STATS: FindingStats = { total: 0, pending: 0, + submitted: 0, + accepted: 0, critical: 0, high: 0, medium: 0, @@ -136,6 +143,7 @@ export default function FindingsPage() { const [view, setView] = React.useState("flat"); const [severity, setSeverity] = React.useState<"all" | Severity>("all"); const [status, setStatus] = React.useState<"all" | FindingStatus>("all"); + const [reportState, setReportState] = React.useState<"all" | FindingReportState>("all"); const [verificationStatus, setVerificationStatus] = React.useState<"all" | VerificationStatus>("all"); const [vulnclass, setVulnclass] = React.useState("all"); const [task, setTask] = React.useState("all"); @@ -167,7 +175,16 @@ export default function FindingsPage() { const retestRefreshVersion = React.useRef(0); const [deepenDescription, setDeepenDescription] = React.useState(""); const [deepening, setDeepening] = React.useState(false); - const filterFingerprint = JSON.stringify([severity, status, verificationStatus, vulnclass, task, sort, query]); + const filterFingerprint = JSON.stringify([ + severity, + status, + reportState, + verificationStatus, + vulnclass, + task, + sort, + query, + ]); const activeFilterFingerprint = React.useRef(filterFingerprint); activeFilterFingerprint.current = filterFingerprint; @@ -205,6 +222,7 @@ export default function FindingsPage() { view?: unknown; severity?: unknown; status?: unknown; + reportState?: unknown; verificationStatus?: unknown; vulnclass?: unknown; task?: unknown; @@ -217,6 +235,9 @@ export default function FindingsPage() { if (parsed.status === "all" || FINDING_STATUSES.includes(parsed.status as FindingStatus)) { setStatus(parsed.status as "all" | FindingStatus); } + if (parsed.reportState === "all" || FINDING_REPORT_STATES.includes(parsed.reportState as FindingReportState)) { + setReportState(parsed.reportState as "all" | FindingReportState); + } if ( parsed.verificationStatus === "all" || VERIFICATION_STATUSES.includes(parsed.verificationStatus as VerificationStatus) @@ -237,9 +258,9 @@ export default function FindingsPage() { if (!preferencesHydrated) return; setLocalStorageValue( FINDING_LIST_PREFERENCE_KEY, - JSON.stringify({ view, severity, status, verificationStatus, vulnclass, task, sort }), + JSON.stringify({ view, severity, status, reportState, verificationStatus, vulnclass, task, sort }), ); - }, [preferencesHydrated, severity, sort, status, task, verificationStatus, view, vulnclass]); + }, [preferencesHydrated, reportState, severity, sort, status, task, verificationStatus, view, vulnclass]); React.useEffect(() => { const timer = window.setTimeout(() => setQuery(search.trim()), 300); @@ -299,7 +320,7 @@ export default function FindingsPage() { await api.exportFindings({ format: exportFormat, scope: exportScope, - filters: { severity, status, verificationStatus, vulnclass, task, query, sort }, + filters: { severity, status, reportState, verificationStatus, vulnclass, task, query, sort }, ids: [...selectedIds], }); setExportOpen(false); @@ -339,6 +360,7 @@ export default function FindingsPage() { pageSize: flatPageSize, severity, status, + reportState, verificationStatus, vulnclass, task, @@ -360,6 +382,7 @@ export default function FindingsPage() { flatPageSize, severity, status, + reportState, verificationStatus, vulnclass, task, @@ -375,7 +398,16 @@ export default function FindingsPage() { const request = ++assetTreeRequest.current; setAssetTree((current) => ({ ...current, loading: true })); try { - const result = await api.findingAssetTree({ severity, status, verificationStatus, vulnclass, task, query, sort }); + const result = await api.findingAssetTree({ + severity, + status, + reportState, + verificationStatus, + vulnclass, + task, + query, + sort, + }); if (request !== assetTreeRequest.current || activeFilterFingerprint.current !== requestFilter) return; setAssetTree({ nodes: result.nodes ?? [], @@ -390,7 +422,7 @@ export default function FindingsPage() { setAssetTree((current) => ({ ...current, loading: false })); toast.error(`Failed to load the asset tree: ${(e as Error).message}`); } - }, [filterFingerprint, severity, status, verificationStatus, vulnclass, task, query, sort]); + }, [filterFingerprint, reportState, severity, status, verificationStatus, vulnclass, task, query, sort]); const refreshGroups = React.useCallback(async () => { const requestFilter = filterFingerprint; @@ -402,6 +434,7 @@ export default function FindingsPage() { pageSize, severity, status, + reportState, verificationStatus, vulnclass, task, @@ -415,7 +448,7 @@ export default function FindingsPage() { } catch { // Polling keeps the last successful snapshot visible. } - }, [filterFingerprint, page, pageSize, severity, status, verificationStatus, vulnclass, task, query, sort]); + }, [filterFingerprint, page, pageSize, reportState, severity, status, verificationStatus, vulnclass, task, query, sort]); const loadGroup = React.useCallback( async (key: string, groupPage: number, groupPageSize: number) => { @@ -440,6 +473,7 @@ export default function FindingsPage() { pageSize: groupPageSize, severity, status, + reportState, verificationStatus, vulnclass, task: key, @@ -475,7 +509,7 @@ export default function FindingsPage() { })); } }, - [filterFingerprint, severity, status, verificationStatus, vulnclass, query, sort], + [filterFingerprint, reportState, severity, status, verificationStatus, vulnclass, query, sort], ); React.useEffect(() => { @@ -657,6 +691,34 @@ export default function FindingsPage() { [refreshAfterMutation, setFindings, status], ); + const updateReportState = React.useCallback( + async (f: Finding, next: FindingReportState) => { + if (!f.finding_id || next === (f.report_state ?? "none")) return; + const prev = f.report_state ?? "none"; + setFindings((cur) => cur.map((x) => (isSameFinding(x, f) ? { ...x, report_state: next } : x))); + try { + await api.setFindingReportState(f.finding_id, next); + toast.success(`Report stage set to "${REPORT_STATE_META[next].label}"`); + api + .findingStats() + .then(setStats) + .catch(() => { + // The row update remains valid even if the aggregate refresh fails. + }); + if (reportState !== "all" && next !== reportState) { + setFindings((cur) => cur.filter((x) => !isSameFinding(x, f))); + setTotal((t) => Math.max(0, t - 1)); + setFlat((cur) => ({ ...cur, total: Math.max(0, cur.total - 1) })); + } + refreshAfterMutation(f); + } catch (e) { + setFindings((cur) => cur.map((x) => (isSameFinding(x, f) ? { ...x, report_state: prev } : x))); + toast.error(`Update failed: ${(e as Error).message}`); + } + }, + [refreshAfterMutation, reportState, setFindings], + ); + // applyBulkStatus sets the same triage status on every selected finding, then // reloads the current view so rows hidden by the status filter disappear. const applyBulkStatus = React.useCallback( @@ -687,6 +749,36 @@ export default function FindingsPage() { [bulkBusy, loadAssetTree, loadFlat, selectedIds, view], ); + const applyBulkReportState = React.useCallback( + async (next: FindingReportState) => { + if (selectedIds.size === 0 || bulkBusy) return; + setBulkBusy(true); + try { + const r = await api.bulkSetFindingReportState([...selectedIds], next); + setSelectedIds(new Set()); + const label = REPORT_STATE_META[next].label; + toast.success( + r.updated === 1 + ? `Set report stage of 1 finding to "${label}"` + : `Set report stage of ${r.updated} findings to "${label}"`, + ); + void loadFlat(); + if (view === "asset") void loadAssetTree(); + api + .findingStats() + .then(setStats) + .catch(() => { + // The list reload remains valid even if the aggregate refresh fails. + }); + } catch (e) { + toast.error(`Bulk update failed: ${(e as Error).message}`); + } finally { + setBulkBusy(false); + } + }, + [bulkBusy, loadAssetTree, loadFlat, selectedIds, view], + ); + // The inline expanded detailed-report cache is keyed by the globally stable row key. report is long-form // Markdown the list query doesn't include, so it is fetched once by finding_id on expand; done with empty text = no report yet. const [reports, setReports] = React.useState>({}); @@ -812,6 +904,8 @@ export default function FindingsPage() { const statCards = [ { label: "Total findings", value: stats.total, icon: BugIcon }, { label: "Pending", value: stats.pending, tone: "text-amber-500", icon: ClockIcon }, + { label: "Submitted", value: stats.submitted, tone: "text-amber-500", icon: FileUpIcon }, + { label: "Accepted", value: stats.accepted, tone: "text-emerald-500", icon: CircleCheckIcon }, { label: "Critical", value: stats.critical, tone: "text-rose-600", icon: ShieldAlertIcon }, { label: "High", value: stats.high, tone: "text-red-500", icon: TriangleAlertIcon }, { label: "Medium", value: stats.medium, tone: "text-amber-500", icon: TriangleAlertIcon }, @@ -838,6 +932,7 @@ export default function FindingsPage() { saving, onSave: saveEdit, onStatusChange: updateStatus, + onReportStateChange: updateReportState, onRetest: setRetestFinding, activeRetests, onDeepen: openDeepen, @@ -888,7 +983,7 @@ export default function FindingsPage() {
-
+
{statCards.map((stat) => { const StatIcon = stat.icon; return ( @@ -956,6 +1051,20 @@ export default function FindingsPage() { + + +
)}