Compare commits

..
Author SHA1 Message Date
BaaRai 75efc29323 feat(findings): bulk status update from the findings table 2026-11-17 17:52:09 +01:00
BaaRai 6337341602 Merge pull request #295 from BaaRai/feat-keenable-wiring
feat(web_search): wire the opt-in Keenable backend
2026-11-17 17:39:38 +01:00
6 changed files with 244 additions and 1 deletions
+32
View File
@@ -509,6 +509,38 @@ func (d *DB) SetFindingStatusWithNotify(ctx context.Context, id int64, status st
return from, found, notified, err
}
// FindingStatusBatchResult is one id's outcome in a bulk status update.
type FindingStatusBatchResult struct {
ID int64 `json:"id"`
From string `json:"from,omitempty"`
Found bool `json:"found"`
Changed bool `json:"changed"`
Notified bool `json:"notified"`
}
// SetFindingStatusesWithNotify updates several findings to the same status in one
// transaction. It returns a result per id, so an unknown id is reported as
// found=false instead of hiding the others; a database error rolls the whole
// batch back. Notification semantics stay identical to the single-row path: one
// delivery event per finding whose status actually changed, none for a no-op.
func (d *DB) SetFindingStatusesWithNotify(ctx context.Context, ids []int64, status string) ([]FindingStatusBatchResult, error) {
out := make([]FindingStatusBatchResult, 0, len(ids))
err := d.WithEvidenceTx(ctx, func(tx *sql.Tx) error {
for _, id := range ids {
from, found, changed, notified, err := SetFindingStatusTx(ctx, tx, id, status)
if err != nil {
return err
}
out = append(out, FindingStatusBatchResult{ID: id, From: from, Found: found, Changed: changed, Notified: notified})
}
return nil
})
if err != nil {
return nil, err
}
return out, nil
}
// SetFindingStatusTx updates a finding's status and registers a status-change delivery
// event inside the **caller's transaction**.
//
+63
View File
@@ -607,6 +607,69 @@ func TestSetFindingStatusWithNotifyOnlyEmitsOnRealChange(t *testing.T) {
}
}
// A bulk update is one transaction with a per-id result: unknown ids are
// reported, not fatal, and a second call is a no-op that emits no event.
func TestSetFindingStatusesWithNotify(t *testing.T) {
d := notifyTestDB(t)
ctx := context.Background()
tk, err := d.CreateTask("bulk status test", "goal", nil, 0, 0)
if err != nil {
t.Fatal(err)
}
defer d.DeleteTask(tk.ID)
es := d.Exploration(tk.ExplorationID)
record := func(name string) int64 {
fi, err := es.RecordFinding(ctx, RecordFindingInput{
TaskID: tk.ID, Worker: "test", VulnClass: "XSS", Name: name,
Severity: "medium", Summary: "summary",
})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { d.Exec(`DELETE FROM notification_events WHERE finding_id=$1`, fi.FindingID) })
return fi.FindingID
}
first, second := record("bulk one"), record("bulk two")
const missingID = int64(999999999)
results, err := d.SetFindingStatusesWithNotify(ctx, []int64{first, second, missingID}, FindingConfirmed)
if err != nil {
t.Fatal(err)
}
if len(results) != 3 {
t.Fatalf("want 3 results, got %d", len(results))
}
for i, want := range []int64{first, second} {
r := results[i]
if r.ID != want || !r.Found || !r.Changed || !r.Notified || r.From != FindingPending {
t.Fatalf("result %d: %+v", i, r)
}
}
if r := results[2]; r.Found || r.Changed || r.Notified {
t.Fatalf("a missing id should be found=false with no change: %+v", r)
}
for _, id := range []int64{first, second} {
var status string
if err := d.QueryRow(`SELECT status FROM findings WHERE id=$1`, id).Scan(&status); err != nil || status != FindingConfirmed {
t.Fatalf("finding %d status = %q (%v)", id, status, err)
}
var events int
if err := d.QueryRow(`SELECT count(*) FROM notification_events WHERE finding_id=$1 AND kind=$2`, id, notify.EventFindingStatusChanged).Scan(&events); err != nil || events != 1 {
t.Fatalf("finding %d status events = %d (%v)", id, events, err)
}
}
// Same status again: no change, so no push.
again, err := d.SetFindingStatusesWithNotify(ctx, []int64{first}, FindingConfirmed)
if err != nil || len(again) != 1 {
t.Fatalf("second batch: %v %v", again, err)
}
if again[0].Changed || again[0].Notified {
t.Fatalf("a no-op batch should neither change nor notify: %+v", again[0])
}
}
func TestNotificationStatsSnapshot(t *testing.T) {
d := notifyTestDB(t)
ctx := context.Background()
+34
View File
@@ -0,0 +1,34 @@
package server
import (
"net/http"
"net/http/httptest"
"strings"
"testing"
)
// The bulk endpoint validates the whole request before touching the database, so
// a malformed body, an unknown status and an empty id list are client errors.
func TestBulkFindingStatusValidation(t *testing.T) {
s := &Server{m: &Manager{}}
cases := []struct {
name string
body string
want int
}{
{"bad json", `{`, http.StatusBadRequest},
{"unknown status", `{"ids":[1],"status":"nope"}`, http.StatusBadRequest},
{"empty ids", `{"ids":[],"status":"confirmed"}`, http.StatusBadRequest},
{"non-positive ids", `{"ids":[0,-3],"status":"confirmed"}`, 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-status", strings.NewReader(tc.body))
s.bulkPatchFindingStatus(rec, req)
if rec.Code != tc.want {
t.Fatalf("status %d, want %d: %s", rec.Code, tc.want, rec.Body.String())
}
})
}
}
+56
View File
@@ -801,6 +801,7 @@ func (s *Server) Handler() http.Handler {
mux.HandleFunc("GET /api/exploration/findings/retests/active", s.listActiveFindingRetests)
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("DELETE /api/exploration/findings/{id}", s.deleteFinding)
mux.HandleFunc("GET /api/exploration/intents", s.intents)
mux.HandleFunc("GET /api/exploration/graph", s.explorationGraph)
@@ -2565,6 +2566,61 @@ func (s *Server) patchFinding(w http.ResponseWriter, r *http.Request) {
writeJSON(w, 200, findingFromDB(f, s.resolveAssetIDs(f.AssetIDs)))
}
// maxBulkFindingStatus caps one bulk status request. The UI acts on a page at a
// time, so this is far above a normal selection and still bounds the work.
const maxBulkFindingStatus = 500
// bulkPatchFindingStatus sets the same triage status on a batch of findings in
// one transaction. Ids that do not exist are reported per id, not as a batch
// failure, and the notification semantics are the single-row ones: one event per
// finding whose status actually changed. The node payload mirror (#289) runs in
// the same transaction, so the per-task view stays in sync.
func (s *Server) bulkPatchFindingStatus(w http.ResponseWriter, r *http.Request) {
var body struct {
IDs []int64 `json:"ids"`
Status string `json:"status"`
}
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
writeErr(w, 400, "bad json: "+err.Error())
return
}
if !db.ValidFindingStatus(body.Status) {
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 {
if id <= 0 || seen[id] {
continue
}
seen[id] = true
ids = append(ids, id)
if len(ids) == maxBulkFindingStatus {
break
}
}
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})
}
// deleteFinding removes a finding (findings row + originating exploration node).
// id is the standalone findings-table id (DTO finding_id).
func (s *Server) deleteFinding(w http.ResponseWriter, r *http.Request) {
+52 -1
View File
@@ -260,6 +260,7 @@ export default function FindingsPage() {
// Export selection: tracked by finding_id (the standalone table's id), preserved across pages.
const [selectedIds, setSelectedIds] = React.useState<Set<string>>(() => new Set());
const [bulkBusy, setBulkBusy] = React.useState(false);
// Export dialog state: scope (current filter / all / selected) × format (single md / per-finding md zip / csv / json).
const [exportOpen, setExportOpen] = React.useState(false);
const [exportScope, setExportScope] = React.useState<"filtered" | "all" | "selected">("filtered");
@@ -656,6 +657,36 @@ export default function FindingsPage() {
[refreshAfterMutation, setFindings, status],
);
// 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(
async (next: FindingStatus) => {
if (selectedIds.size === 0 || bulkBusy) return;
setBulkBusy(true);
try {
const r = await api.bulkSetFindingStatus([...selectedIds], next);
setSelectedIds(new Set());
const label = statusMeta("finding", next).label;
toast.success(
r.updated === 1 ? `Marked 1 finding as "${label}"` : `Marked ${r.updated} findings as "${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<Record<string, FindingReport>>({});
@@ -995,7 +1026,27 @@ export default function FindingsPage() {
<div className="ml-auto flex items-center gap-3">
{selectedIds.size > 0 && (
<span className="text-xs text-muted-foreground tabular-nums">{selectedIds.size} selected</span>
<div className="flex items-center gap-2">
<span className="text-xs text-muted-foreground tabular-nums">{selectedIds.size} selected</span>
<Select
value=""
onValueChange={(v) => {
if (v) void applyBulkStatus(v as FindingStatus);
}}
disabled={bulkBusy}
>
<SelectTrigger size="sm" className="w-40" aria-label="Set the status of the selected findings">
<SelectValue placeholder={bulkBusy ? "Updating…" : "Set status"} />
</SelectTrigger>
<SelectContent>
{FINDING_STATUSES.map((st) => (
<SelectItem key={st} value={st}>
{statusMeta("finding", st).label}
</SelectItem>
))}
</SelectContent>
</Select>
</div>
)}
<Button size="sm" variant="outline" onClick={openExport}>
<DownloadIcon /> Export
+7
View File
@@ -698,6 +698,13 @@ export const api = {
// Vulnerability lineage: the subgraph (nodes + edges) from the vulnerability node back to the task's initial node.
findingLineage: (id: string) => get<{ nodes: TaskNode[]; edges: Edge[] }>(`/exploration/findings/${id}/lineage`),
setFindingStatus: (id: string, status: FindingStatus) => patch<Finding>(`/exploration/findings/${id}`, { status }),
// Bulk triage: one transaction server-side, with a per-id result. Unknown ids
// come back as found=false instead of failing the whole batch.
bulkSetFindingStatus: (ids: string[], status: FindingStatus) =>
post<{ updated: number; missing: number; results: { id: number; found: boolean; changed: boolean }[] }>(
"/exploration/findings/bulk-status",
{ ids: ids.map(Number), status },
),
setFindingSeverity: (id: string, severity: Severity) => patch<Finding>(`/exploration/findings/${id}`, { severity }),
// Save a vulnerability's name/class/severity in one call (inline edit in the findings list); only present fields are sent.
updateFinding: (