Files
skillshare/internal/server/handler_audit_stream.go
T
Willie 6e86537987 fix(audit): honor enabled:false for synthetic tier and cross-skill findings
Tier and cross-skill findings are generated programmatically rather than
compiled from the rule list, so they bypassed the disabled-ID filter applied
at rule-compile time. Setting enabled:false in audit-rules.yaml marked the
rule disabled in the listing but the scan still fired it at full severity.

Filter synthetic findings against the disabled-ID set in both the skill-scan
and single-file paths, threading the set through the cross-skill call sites
(analyzer, cmd, server). Fixes #204.
2026-06-05 20:51:32 +08:00

99 lines
2.4 KiB
Go

package server
import (
"net/http"
"sync"
"sync/atomic"
"time"
"skillshare/internal/audit"
)
// handleAuditStream serves an SSE endpoint that streams audit progress in real time.
// Events:
// - "start" → {"total": N} after skill discovery
// - "progress" → {"scanned": N} every 200ms during scan
// - "done" → {"results":…,"summary":…} final payload (same shape as GET /api/audit)
func (s *Server) handleAuditStream(w http.ResponseWriter, r *http.Request) {
safeSend, ok := initSSE(w)
if !ok {
return
}
start := time.Now()
// Snapshot config under RLock, then release before slow I/O.
s.mu.RLock()
source, resultKind, isAgents := s.resolveAuditSource(r)
projectRoot := s.projectRoot
policy := s.auditPolicy()
s.mu.RUnlock()
// 1. Discover skills/agents
var skills []skillEntry
var err error
if isAgents {
skills, err = discoverAuditAgents(source)
} else {
skills, err = discoverAuditSkills(source)
}
if err != nil {
safeSend("error", map[string]string{"error": err.Error()})
return
}
safeSend("start", map[string]int{"total": len(skills)})
// 2. Atomic counter + ticker for progress events
var scanned atomic.Int64
ctx := r.Context()
done := make(chan struct{})
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
ticker := time.NewTicker(200 * time.Millisecond)
defer ticker.Stop()
for {
select {
case <-ticker.C:
safeSend("progress", map[string]int64{"scanned": scanned.Load()})
case <-done:
return
case <-ctx.Done():
return
}
}
}()
onDone := func() { scanned.Add(1) }
// 3. Parallel scan (blocks until all skills are scanned)
var inputs []audit.SkillInput
if isAgents {
inputs = make([]audit.SkillInput, len(skills))
for i, s := range skills {
inputs[i] = audit.SkillInput{Name: s.name, Path: s.path, IsFile: true}
}
} else {
inputs = skillsToAuditInputs(skills)
}
outputs := audit.ParallelScan(inputs, projectRoot, onDone, nil)
close(done) // signal ticker goroutine to stop
wg.Wait() // wait for it to fully exit before writing to w
// 4. Process results
agg := processAuditResults(skills, outputs, policy, projectRoot)
for i := range agg.Results {
agg.Results[i].Kind = resultKind
}
s.writeAuditLog(agg.Status, start, agg.LogArgs, agg.Message)
// 5. Send final result (no concurrent writers at this point)
safeSend("done", map[string]any{
"results": agg.Results,
"summary": agg.Summary,
})
}