Compare commits

...
Author SHA1 Message Date
BaaRai eddf03ce61 Merge pull request #304 from Protonmatter/protonmatter/llmpool-health-queue
Coalesce circuit-breaker health writes
2026-11-17 22:52:27 +01:00
BaaRai 9bc5856565 Merge pull request #302 from Protonmatter/protonmatter/budget-restore
Restore task spend from the lanes the live ledger counts
2026-11-17 22:52:23 +01:00
protonmatter c9d81a453f Align the Server literal so gofmt accepts it. 2026-11-17 22:39:53 +01:00
protonmatter b2a2f95e8c Release the circuit-breaker queue lock around the database write. 2026-11-17 22:39:53 +01:00
protonmatter 1fbf2263a1 Keep circuit-breaker writes in state order and flush them before the database closes.
A later update can no longer be queued behind an older one, a failed save is retried, and shutdown waits for the last cooling window.
2026-11-17 22:39:53 +01:00
protonmatter 847e32407a Coalesce circuit-breaker writes onto one queue.
A newer state for the same profile replaces one that has not been written yet, and a failed write is logged instead of discarded on a detached goroutine.
2026-11-17 22:39:50 +01:00
BaaRai 7bd9bf6e3e Merge pull request #309 from BaaRai/feat/traffic-rewrite-p33b1
feat(traffic): apply rewrite rules in the capture proxy (P3.3b1)
2026-11-17 22:38:59 +01:00
BaaRai f8bc3b3b6d Merge pull request #305 from Protonmatter/protonmatter/json-body-cap
Cap JSON request bodies
2026-11-17 22:29:08 +01:00
BaaRai 4fb29fd841 Merge pull request #303 from Protonmatter/protonmatter/coverage-flag-error
Keep coverage tools available when the flag read fails
2026-11-17 22:29:04 +01:00
protonmatter 074962a351 Say that a revived task keeps the spend already recorded. 2026-11-17 16:25:16 -05:00
BaaRai 7c3d50d533 docs: describe applying the rewrite rules in the proxy
The status line said the proxy does not apply rules yet. Replace it with
the request and response phases, what exchange_rewrites records and how
the hashes are formed (plain SHA-256, keyed HMAC for sensitive actions),
the SSE and WebSocket behaviour, the 5 MiB response pass-through, the
snapshot limits (live slots are never deleted by the TTL), and the fact
that replays go through the proxy and are rewritten like captures.
2026-11-17 22:23:12 +01:00
BaaRai b57bafe74a feat(server): upgrade the built-in traffic_get description once
It now says that traffic_get shows the originals of a rewritten exchange
and that traffic_search never finds a value a rewrite rule wrote. As for
traffic_search, only the original built-in text is replaced.
2026-11-17 22:23:12 +01:00
BaaRai fa07d69f1d feat(traffic): apply rewrite rules in the capture proxy (P3.3b1)
The sink runs the request phase in the Request hook and the response phase
at the start of the Response hook; at SSEStart only status and header
actions apply. WebSocketStart comes after the client is upgraded, so the
handshake is traced "not rewritten: stream" and recorded as sent.

Exchanges keep what the client sent and what the target answered. The
original of a rewritten request lives in a per-flow snapshot slot (entry or
tombstone, 1024 entries / 64 MiB, 4096 tombstones), reserved before the
request is changed, released on Response, RequestError, SSEStart, a 5 MiB
response, or by a sweep of finished flows (ClientDisconnected, 1 s
debounce, 1 min period). Under pressure an entry older than 15 minutes is
turned into a tombstone in place, only when that frees room for the new
reservation; its exchange is recorded "original request unavailable".

record(), recordStreamStart() and insertExchange() clear any trace under
the id before INSERT OR REPLACE; the trace (exchange_rewrites, created
with CREATE TABLE IF NOT EXISTS) is written in the exchange's transaction,
its spilled values registered in blob_refs, and purged with the exchange.
The full-text index covers the originals only. Logs of a rewritten flow
name the host, the step or error class and the rule ids, never the URL or
the error text. A rewritten request's transport error never switches its
host to passthrough. traffic_get shows the rewritten flag and rule ids.

Without a rule that applies, what is recorded is unchanged byte for byte.
2026-11-17 22:23:12 +01:00
BaaRai b3e1f5359f feat(traffic/rewrite): let the proxy record a rule's transport error
The request phase can fail after the engine is done: the rewritten request
does not reach the target. NoteError records that as the rule's last error,
under the new class transport_error.
2026-11-17 22:22:56 +01:00
BaaRai 5fdf8eb075 fix(server): keep the MaxBytesError so a caller's 413 mapping still works
A handler that installs its own MaxBytesReader and then calls decode lost the 413: decode converted the error to a plain one and the middleware's limitedBody had been replaced. Return the original *http.MaxBytesError and update the cap test to errors.As.
2026-11-17 22:19:59 +01:00
BaaRai d646f6999b fix(test): check each coverage tool on the set that carries it
list_untested_assets is a planner tool, not a worker tool; the fail-open assertion can only be made against PlannerTools.
2026-11-17 22:18:54 +01:00
BaaRai 8ae53f74cf Merge pull request #306 from Protonmatter/protonmatter/mitm-passthrough-ttl
Expire MITM passthrough after one minute
2026-11-17 22:14:58 +01:00
BaaRai 03ac1c7d47 Merge pull request #300 from Protonmatter/protonmatter/shutdown-outbox
Drain task goroutines on shutdown and replay unsaved activities
2026-11-17 22:08:25 +01:00
protonmatter 287cbb685c Treat an expired passthrough mark as intercepted again, and say what the window costs.
Replay was still honoring a stale bypass, and a host whose interception always fails now loses one request per minute instead of one per process.
2026-11-17 15:58:24 -05:00
protonmatter 186594ed3a Cap every non-multipart body and answer an oversized one with 413.
Handlers that decode JSON directly were still unbounded, and a body past the cap was reported as a bad request.
2026-11-17 15:57:43 -05:00
protonmatter 133dc68668 Test that a failed coverage read stays enabled, including auto-scope writes.
A missing task and a query error both leave the flag on. The worker keeps the coverage tools and still records auto scope when the stored flag is off.
2026-11-17 15:52:04 -05:00
protonmatter 40de6ba898 Say what a restored task budget still allows, and test the lanes that count.
A task already inside the wrap-up reserve only has that reserve left. The worker estimate starts from the defaults because usage rows have no run boundary.
2026-11-17 15:50:00 -05:00
protonmatter a1c6103cbf Stop admitting work before the drain and replay each outbox row once.
The listener closes before Wait, and a shutdown refuses new task operations. Wait also stays until detached runs finish. The activity insert and the outbox delete commit together, and a row that keeps failing is dropped after five attempts so it cannot block the rest.
2026-11-17 15:41:56 -05:00
BaaRai 56d11bb51c Merge pull request #290 from Coff0xc/fix/rsi-lesson-retract
fix(db): retract lesson evidence when a disposition reverses
2026-11-17 20:30:19 +01:00
Coff0xc c73fec7471 fix(db): look up caution lessons by cue
The caution action carries the vulnclass, not the finding summary.
2026-11-17 19:13:32 +00:00
Coff0xc 0fb4ed145d fix(db): retract every retest when a finding is reversed
The negative path only dropped the latest retest. Operator-retired
lessons with evidence also came back on the next extract.
2026-11-17 19:13:31 +00:00
Coff0xc c0ce7a9494 fix(db): retract lesson evidence when a disposition reverses
Re-extract after flipping a finding to false_positive left the old
positive lesson in place.
2026-11-17 19:13:19 +00:00
BaaRai 758bc416dd Merge pull request #307 from BaaRai/chore/contributing-pr-cap
docs: cap contributors at 7 open pull requests, and have the bot say so
2026-11-17 20:11:38 +01:00
BaaRai 28363ec3e5 docs: document the 7 open pull request cap 2026-11-17 20:06:36 +01:00
BaaRai d4c1a5cca1 Merge pull request #298 from BaaRai/feat-bulk-finding-status
feat(findings): bulk status update from the findings table
2026-11-17 19:58:49 +01:00
BaaRai 72f3b0c3af Merge pull request #287 from Coff0xc/fix/rsi-lesson-correctness
fix(db): scope RSI lessons from task_scope and stop splitting UTF-8
2026-11-17 19:58:45 +01:00
Coff0xc a2b26f5416 fix(db): skip RSI lesson extract on multi-company tasks
NULL company_id leaked those lessons to every later task.
2026-11-17 18:08:49 +00:00
protonmatter 0234025d28 Drain task goroutines on shutdown and replay activities that could not be stored.
The outbox migration is 0006 because 0005 is already traffic rewrite rules. A shutdown cancel leaves an in-flight intent claim running, so the next start can reset it to open instead of recording the interrupt as done or blocked.
2026-11-17 13:05:23 -05:00
protonmatter 69bdd94d13 Cap JSON request bodies and bound how long a body may arrive.
decode stops at 32 MiB. ReadTimeout limits header and body arrival without cutting a handler that is already running.
2026-11-17 13:04:50 -05:00
protonmatter 08eb4ec244 Expire a MITM passthrough mark after one minute.
A host that cannot be intercepted is tunneled until the mark expires, then interception is tried again.
2026-11-17 13:04:37 -05:00
protonmatter ce218c4b16 Leave asset-coverage tools available when the flag read fails.
A missing task stays enabled. A database error is returned to the caller and logged, instead of being treated as a reason to hide the tools.
2026-11-17 13:04:36 -05:00
protonmatter be25f14970 Restore a task spend cap from the lanes the live ledger counts.
Planner, worker, judge, and compactor rows rebuild the cap. Main-agent chat, goal decomposition, and side questions stay out, so a restart does not count turns the running process never metered.
2026-11-17 13:04:36 -05:00
Coff0xc cc0082cfda fix(db): scope RSI lessons from task_scope and stop splitting UTF-8
Lessons were scoped on tasks.company_id, which create never writes.
Generic rows also sorted first on Postgres.
2026-11-17 18:03:10 +00:00
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
71 changed files with 5292 additions and 360 deletions
+3 -1
View File
@@ -23,10 +23,12 @@ All notable changes to this project are documented in this file. The format is b
- **`ask_operator` target warning**: a request whose question names a host or URL outside the goal targets is tagged as containing target-derived text (#197).
- **Opt-in update banner**: `ARTEX_UPDATE_CHECK` makes the backend check the latest GitHub release at most once per 24 hours and the UI show a banner; off by default (#202).
- **Release provenance**: release archives carry GitHub build provenance attestations and a CycloneDX SBOM (`gh attestation verify <zip> --repo BaaRai/ARTEX`); release notes are the matching `CHANGELOG.md` section (#219, #201).
- **Capture-proxy rewrite rules, storage and API**: `GET`, `POST`, `PUT` and `DELETE /api/traffic/rewrite-rules` and `POST /api/traffic/rewrite-rules/{id}/toggle` manage rules that match a request or a response (method, host, URL, headers, body, status) and describe a rewrite (method, path and query, headers, body, status). Rules are validated on save, limited to 100 of which 50 enabled, created disabled, and stored in the new table `traffic_rewrite_rules` (migration `0005_traffic_rewrite_rules.sql`) with `matchers` and `actions` encrypted at rest. The value of an action marked `sensitive` is never returned, and an update sent without it keeps the stored one. The server compiles the enabled rules at startup and after every change and hands the snapshot to the proxy. **The proxy does not apply the rules yet: capture is unchanged.** See `docs/traffic-rewrite-rules.md`.
- **Capture-proxy rewrite rules, storage and API**: `GET`, `POST`, `PUT` and `DELETE /api/traffic/rewrite-rules` and `POST /api/traffic/rewrite-rules/{id}/toggle` manage rules that match a request or a response (method, host, URL, headers, body, status) and describe a rewrite (method, path and query, headers, body, status). Rules are validated on save, limited to 100 of which 50 enabled, created disabled, and stored in the new table `traffic_rewrite_rules` (migration `0005_traffic_rewrite_rules.sql`) with `matchers` and `actions` encrypted at rest. The value of an action marked `sensitive` is never returned, and an update sent without it keeps the stored one. The server compiles the enabled rules at startup and after every change and hands the snapshot to the proxy. The proxy applies them from the next entry. See `docs/traffic-rewrite-rules.md`.
- **Capture-proxy rewrite rules applied**: the capture proxy applies enabled rules to each HTTP request before it is sent to the target and to each response before it reaches the client. Each action that ran is recorded in the new table `exchange_rewrites` in the same transaction as the exchange, `traffic_get` shows a `REWRITTEN` line, and `traffic_search` never finds a value a rule wrote. SSE status and headers are rewritten at the start of the stream. **WebSocket handshakes are not rewritten**: the capture library runs its hook after the upgrade, so the status and headers cannot be changed, and frames pass unchanged. **Responses of 5 MiB or more** are forwarded unchanged and not recorded in full, because the library does not call the response hook for them. Snapshots of original requests are capped at 1024 entries and 64 MiB. Replays go through the proxy, so the rules apply to them. Archives, a per-replay rule toggle, the web UI and the proof flag come later.
### Changed
- **Task budgets survive a restart**: planner, worker, judge, and compactor rows in `llm_usage` are counted back into `ARTEX_TASK_BUDGET_*`. A restored task already inside the wrap-up reserve only has that reserve left, so the run wraps up instead of starting another worker. The per-worker estimate is not restored and starts from the defaults (50,000 tokens and 10 turns) until a worker finishes in this process. Chat, goal decomposition, and side questions stay outside the cap.
- **Untrusted-output boundary is now on by default**: Norma frames tool results for the worker, planner, chat and main agent unless `ARTEX_UNTRUSTED_BOUNDARY` is set to `0`, `false`, `off` or `no`. It was opt-in via `ARTEX_UNTRUSTED_BOUNDARY=1` in 0.6.0 (#166); the default flips here (#203).
- **Versioned migrations**: the `db` package applies numbered `db/migrations/NNNN_slug.sql` files once, in order, under the schema advisory lock, and records a SHA-256 checksum in `schema_migrations`; missing, renamed, changed or out-of-order migrations fail closed (#226).
- **Coverage graph performance**: the coverage graph batches its connector lookups (three queries instead of one per root and per company) and adds the partial index `idx_ts_icp`; on a task of about 3,000 assets the p50 dropped from 126 ms to 27 ms and the queries per call from 221 to 3 (#230).
+15
View File
@@ -0,0 +1,15 @@
# Contributing
## Pull requests
- **At most 7 open pull requests per contributor.** The repository enforces this with GitHub's pull request creation limit, drafts included: when you reach it, close or merge one before opening another. Review is manual, one change at a time, so a larger batch makes the queue unmanageable and slows everyone down, including you. If you have more changes queued, open one issue that lists them and wait for the current ones to be reviewed.
- **One focused change per PR.** If a change has independent parts, split it into a small number of PRs and say in each description what the other parts depend on.
- **Describe the change.** State the problem, the behavior change and what you tested. A pull request with no description is a request for changes.
## Issues
- One problem per issue. Include the version or commit, what you ran and what you expected.
## Security
- Do not open a public issue for a vulnerability in ARTEX itself. Use the private advisory form in the repository's Security tab.
+11 -2
View File
@@ -255,7 +255,10 @@ worker remains confined to the intent it claimed.
- **Budgets**: `ARTEX_TASK_BUDGET_TOKENS` / `ARTEX_TASK_BUDGET_TURNS` cap a whole task (planner and
workers); `ARTEX_INTENT_BUDGET_TOKENS` / `ARTEX_INTENT_BUDGET_TURNS` cap one worker run. Near the
limit the task enters a forced wrap-up; a worker is not started when the remaining budget cannot
cover it. Budgets are in memory: a restart starts fresh.
cover it. Spend already in `llm_usage` is restored after a restart. A task that is already inside
the wrap-up reserve only has that reserve left, so the revived run wraps up instead of starting
another worker. The per-worker cost estimate starts again from the defaults (50,000 tokens and
10 turns) until a worker finishes in this process.
- **Noise governor**: `ARTEX_NOISE_PROFILE=quiet|balanced|aggressive` paces requests ARTEX sends to
targets (per-host rate, burst, in-flight limit, jitter, backoff on 429/503, short GET caching).
With a profile set, agents also receive low-and-slow flags for the installed scanners.
@@ -455,7 +458,13 @@ workers, else 50,000 tokens and 10 turns). Near the wrap-up reserve (the larger
tokens, and 2 turns) the task enters a forced wrap-up: the planner writes a summary and final goal
judgment, and workers may only write back. The task then ends `done` if its goals are met, else
`timeout`. Practical floor: below 50,000 tokens no worker starts; 50,000-70,000 typically gives one
worker then wrap-up; pick well above 70,000 for real exploration.
worker then wrap-up; pick well above 70,000 for real exploration. Planner, worker, judge, and
compactor rows in `llm_usage` are counted back into the cap when a ledger is created, including
after a restart and after a revived run drops its ledger. A restored task already inside the
wrap-up reserve does not get another worker: only that reserve remains, and the run wraps up.
Chat, goal decomposition, and side questions are stored on the same task and are not counted.
The per-worker average is not restored (usage rows have no run boundary), so the estimate starts
from the defaults until a worker finishes in this process.
**Common flags**: `./start.sh -addr :8787 -proxy :8788` (`-addr` frontend/API, `-proxy` traffic
recording proxy).
+17 -1
View File
@@ -92,7 +92,8 @@ func BudgetsFromEnv() (task, intent Budget) {
NewBudget(env("ARTEX_INTENT_BUDGET_TOKENS"), env("ARTEX_INTENT_BUDGET_TURNS"))
}
// BudgetLedger meters one task, in memory (a process restart starts afresh).
// BudgetLedger meters one task. The total is restored from llm_usage when the
// ledger is created, including after a restart. Per-worker averages are not.
type BudgetLedger struct {
task, intent Budget
mu sync.Mutex
@@ -110,6 +111,21 @@ func NewBudgetLedger(task, intent Budget) *BudgetLedger {
return &BudgetLedger{task: task, intent: intent}
}
// RestoreSpend adds usage that was already recorded before this ledger existed.
// It only adds to the task total. Per-worker averages stay at the defaults
// until a worker finishes against this ledger, because llm_usage rows do not
// mark where one worker run ends and the next begins. A nil ledger (no budget
// configured) is a no-op.
func (l *BudgetLedger) RestoreSpend(spent Spend) {
if l == nil || (spent.Tokens == 0 && spent.Turns == 0) {
return
}
l.mu.Lock()
l.spent.Tokens += spent.Tokens
l.spent.Turns += spent.Turns
l.mu.Unlock()
}
// Record meters one task-level call (the planner's own rounds).
func (l *BudgetLedger) Record(u llm.Usage) {
l.mu.Lock()
+11
View File
@@ -144,3 +144,14 @@ func TestBudgetCountsMatchUsageFixture(t *testing.T) {
t.Fatalf("spent %+v remaining %+v estimate %+v, want {%d 5}, remaining, {10400 3}", st.Spent, st.Remaining, st.Estimate, want)
}
}
func TestRestoreSpendCountsTowardCap(t *testing.T) {
l := NewBudgetLedger(NewBudget(100, 10), NewBudget(0, 0))
l.RestoreSpend(Spend{Tokens: 40, Turns: 4})
st := l.State()
if st.Spent != (Spend{40, 4}) || st.Remaining != (Budget{60, 6}) {
t.Fatalf("spent=%+v remaining=%+v", st.Spent, st.Remaining)
}
var none *BudgetLedger
none.RestoreSpend(Spend{Tokens: 1, Turns: 1})
}
+22
View File
@@ -0,0 +1,22 @@
package agent
import (
"log"
"github.com/Autumn-27/artex/db"
)
// coverageOn reports whether asset-coverage tools stay available for this task.
// A nil store is the historical default (enabled). A database error is logged and
// treated as enabled so a transient read failure does not drop the tools mid-run.
func coverageOn(as *db.AssetStore, taskID int64) bool {
if as == nil {
return true
}
enabled, err := as.CoverageEnabled(taskID)
if err != nil {
log.Printf("[coverage] task %d: reading the coverage flag failed; leaving coverage on: %v", taskID, err)
return true
}
return enabled
}
+113
View File
@@ -0,0 +1,113 @@
package agent
import (
"bytes"
"fmt"
"log"
"strings"
"testing"
"time"
"github.com/Autumn-27/artex/db"
)
// A failed coverage-flag read stays enabled: the log says so, the worker keeps
// record_coverage and list_untested_assets, and AddAutoScope still writes. That
// write happens even when the stored flag is off, which is the outage behaviour.
func TestCoverageReadFailureKeepsToolsAndWritesAutoScope(t *testing.T) {
d := testDB(t)
defer d.Close()
off := false
task, err := d.CreateTaskWithOptions("coverage outage", "goal", db.TaskCreateOptions{CoverageEnabled: &off})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = d.DeleteTask(task.ID) })
live := d.Assets()
stored, err := live.CoverageEnabled(task.ID)
if err != nil || stored {
t.Fatalf("stored flag enabled=%v err=%v, want off", stored, err)
}
if coverageOn(live, task.ID) {
t.Fatal("a readable off flag was treated as on")
}
dsn, _, err := db.DSN()
if err != nil {
t.Fatal(err)
}
broken, err := db.Open(dsn)
if err != nil {
t.Fatal(err)
}
if err := broken.Close(); err != nil {
t.Fatal(err)
}
var logged bytes.Buffer
prev := log.Default().Writer()
log.SetOutput(&logged)
t.Cleanup(func() { log.SetOutput(prev) })
if !coverageOn(broken.Assets(), task.ID) {
t.Fatal("a failed coverage read turned the feature off")
}
if !strings.Contains(logged.String(), "leaving coverage on") {
t.Fatalf("coverage read failure was not logged: %q", logged.String())
}
// record_coverage is the worker's coverage tool; list_untested_assets is the
// planner's, so each is checked on the tool set that actually carries it.
hasPlannerTool := func(ts *ToolSet, name string) bool {
for _, tool := range ts.DropCoverageTools(ts.PlannerTools()) {
if tool.Name() == name {
return true
}
}
return false
}
offWorker := NewToolSet(nil, "worker-off")
offWorker.SetCoverageEnabled(false)
if hasTool(offWorker, "record_coverage") {
t.Fatal("record_coverage stayed available to a worker with coverage off")
}
offPlanner := NewToolSet(nil, "planner-off")
offPlanner.SetCoverageEnabled(false)
if hasPlannerTool(offPlanner, "list_untested_assets") {
t.Fatal("list_untested_assets stayed available to the planner with coverage off")
}
outage := coverageOn(broken.Assets(), task.ID)
outWorker := NewToolSet(nil, "worker-outage")
outWorker.SetCoverageEnabled(outage)
if !hasTool(outWorker, "record_coverage") {
t.Fatal("record_coverage dropped from the worker when the coverage read failed")
}
outPlanner := NewToolSet(nil, "planner-outage")
outPlanner.SetCoverageEnabled(outage)
if !hasPlannerTool(outPlanner, "list_untested_assets") {
t.Fatal("list_untested_assets dropped from the planner when the coverage read failed")
}
keptOff := fmt.Sprintf("off-%d.invalid", time.Now().UnixNano())
writeIntentAutoScope(live, task.ID, []*db.Asset{{Type: "root_domain", Domain: keptOff}}, false)
wrote := fmt.Sprintf("outage-%d.invalid", time.Now().UnixNano())
writeIntentAutoScope(live, task.ID, []*db.Asset{{Type: "root_domain", Domain: wrote}}, coverageOn(broken.Assets(), task.ID))
scope, err := live.ListTaskScope(task.ID)
if err != nil {
t.Fatal(err)
}
var sawKept, sawWrote bool
for _, row := range scope {
if row.Domain == keptOff {
sawKept = true
}
if row.Domain == wrote {
sawWrote = true
}
}
if sawKept {
t.Fatal("auto scope was written while coverage was off")
}
if !sawWrote {
t.Fatal("auto scope was not written when the coverage read failed")
}
}
+1 -1
View File
@@ -118,7 +118,7 @@ func (m *MainAgent) Chat(ctx context.Context, taskID int64, mainSeg int, as *db.
tsx.SetAssetStore(as, as.Companies())
}
tsx.SetTaskID(taskID)
tsx.SetCoverageEnabled(as == nil || as.CoverageEnabled(taskID))
tsx.SetCoverageEnabled(coverageOn(as, taskID))
tsx.SetNotify(notify) // generic wake-up (write ops without a dedicated callback go through it, debounced)
tsx.SetResumeTask(resume) // set_goals adds a goal → pull a completed/paused task back to running
tsx.SetNotifyGoal(notifyGoal) // set_goals adds a goal → record a "human added a goal: …" trigger for the planner
+1 -1
View File
@@ -473,7 +473,7 @@ func (p *Planner) Plan(ctx context.Context, taskID int64, as *db.AssetStore, ts
tsx.SetAssetStore(as, as.Companies())
}
tsx.SetTaskID(taskID)
tsx.SetCoverageEnabled(as == nil || as.CoverageEnabled(taskID))
tsx.SetCoverageEnabled(coverageOn(as, taskID))
tsx.killWork = p.killWork // enable kill_work tool (nil = unavailable)
tsx.steerWork = p.steerWork // enable steer_work tool (nil = unavailable)
if origin, _ := ts.OriginFactID(); origin > 0 {
+19 -7
View File
@@ -387,6 +387,21 @@ func renderWorkerGraphOverview(data map[string]any, env dataEnvelope) string {
sections
}
// writeIntentAutoScope records the intent's target assets as auto scope when
// coverage is on. coverageEnabled is fail-open: a failed flag read is true, so
// an outage still writes, including when the stored flag is off.
func writeIntentAutoScope(as *db.AssetStore, taskID int64, assets []*db.Asset, coverageEnabled bool) {
if as == nil || !coverageEnabled {
return
}
for _, a := range assets {
if a == nil {
continue
}
_ = as.AddAutoScope(taskID, a.Type, a.Domain, a.URL, a.IP)
}
}
// Execute runs one intent. hooks (the per-task Guard) gates every tool call; may
// be nil. emit, if non-nil, receives one ActivityRecord per execution step.
// notifyFinding, if non-nil, is called (intentID, summary) when this worker writes
@@ -412,7 +427,7 @@ func (w *Worker) execute(ctx context.Context, name string, taskID int64, as *db.
tsx := NewToolSet(ts, name)
tsx.SetFindingRecorder(w.findingRecorder)
tsx.SetTaskID(taskID)
coverageEnabled := as == nil || as.CoverageEnabled(taskID)
coverageEnabled := coverageOn(as, taskID)
tsx.SetCoverageEnabled(coverageEnabled)
if as != nil {
tsx.SetAssetStore(as, as.Companies())
@@ -473,12 +488,9 @@ func (w *Worker) execute(ctx context.Context, name string, taskID int64, as *db.
// toward coverage only under a declared domain or IP root (db.declaredScopeFilter);
// coverage scope, not enforced.
// When the asset-coverage feature is off, the test scope (denominator) is no
// longer accumulated.
if coverageEnabled {
for _, a := range assets {
_ = as.AddAutoScope(taskID, a.Type, a.Domain, a.URL, a.IP)
}
}
// longer accumulated. A failed flag read is treated as on, so an outage
// still writes, including for a task whose stored flag is off.
writeIntentAutoScope(as, taskID, assets, coverageEnabled)
}
}
}
+26 -3
View File
@@ -110,10 +110,15 @@ func run() int {
log.Printf("[config] trusted proxies: %v", trusted)
}
srv := server.New(ctx, mgr, skillDir, *dataDir, keyDir, server.WithSecretScrub(), server.WithTrustedProxies(trusted))
// ReadTimeout bounds how long the request headers and body may take to arrive.
// It does not limit how long a handler runs, so an event stream stays open.
// WriteTimeout is left unset: a write deadline would cut that stream.
httpSrv := &http.Server{
Addr: *addr,
Handler: srv.Handler(),
ReadHeaderTimeout: 10 * time.Second,
ReadTimeout: 30 * time.Minute,
IdleTimeout: 2 * time.Minute,
}
go func() {
@@ -127,9 +132,27 @@ func run() int {
<-ctx.Done()
log.Println("shutting down...")
shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
_ = httpSrv.Shutdown(shutdownCtx)
// Close the listener before draining. Otherwise a request accepted during
// the drain can start a detached run, and mgr.Close runs while that run
// is still writing.
shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
httpErr := httpSrv.Shutdown(shutdownCtx)
cancel()
if httpErr != nil {
log.Printf("http shutdown: %v", httpErr)
}
drainCtx, drainCancel := context.WithTimeout(context.Background(), 15*time.Second)
drainErr := srv.Wait(drainCtx)
drainCancel()
if drainErr != nil {
log.Printf("task drain: %v", drainErr)
}
// The health writer flushes on ctx.Done(). Wait for it before the deferred
// store close, so the last cooling window is not written at a closed database.
srv.FlushLLMHealth()
if httpErr != nil || drainErr != nil {
return 1
}
return 0
}
+118
View File
@@ -0,0 +1,118 @@
package db
import (
"encoding/json"
"fmt"
"log"
)
// activityOutboxMaxAttempts is how many times a row may fail AppendActivity
// before it is dropped. One stuck row must not sit at the head of the queue
// and keep every later row from being replayed.
const activityOutboxMaxAttempts = 5
// activityOutboxPayload is Activity plus Detail. Activity.Detail is omitted
// from ordinary JSON (the list payload stays small); the outbox has to keep it
// so a replayed row is the same step that failed to store.
type activityOutboxPayload struct {
Activity
Detail string `json:"detail,omitempty"`
}
func marshalActivity(a Activity) ([]byte, error) {
return json.Marshal(activityOutboxPayload{Activity: a, Detail: a.Detail})
}
func unmarshalActivity(raw []byte) (Activity, error) {
var payload activityOutboxPayload
if err := json.Unmarshal(raw, &payload); err != nil {
return Activity{}, err
}
a := payload.Activity
a.Detail = payload.Detail
return a, nil
}
// EnqueueActivity keeps one activity that AppendActivity could not store.
func (s *ExplorationStore) EnqueueActivity(a Activity, cause string) error {
if s == nil || s.db == nil {
return fmt.Errorf("activity outbox: no store")
}
raw, err := marshalActivity(a)
if err != nil {
return err
}
_, err = s.db.Exec(`INSERT INTO activity_outbox (exploration_id, payload, last_error) VALUES ($1, $2::jsonb, $3)`, s.expID, string(raw), cause)
return err
}
// FlushActivityOutbox inserts queued activities in order and deletes each row
// that lands. The insert and the delete commit together, so a crash cannot
// leave the activity stored and the outbox row still queued. A row that still
// cannot be inserted stays, with its attempt count increased, and the flush
// continues with the next row. After activityOutboxMaxAttempts the row is
// dropped and logged. A payload that cannot be decoded is discarded.
func (s *ExplorationStore) FlushActivityOutbox() (int, error) {
if s == nil || s.db == nil {
return 0, fmt.Errorf("activity outbox: no store")
}
rows, err := s.db.Query(`SELECT id, payload, attempts FROM activity_outbox WHERE exploration_id=$1 ORDER BY id`, s.expID)
if err != nil {
return 0, err
}
defer rows.Close()
type item struct {
id int64
payload []byte
attempts int
}
var items []item
for rows.Next() {
var it item
if err := rows.Scan(&it.id, &it.payload, &it.attempts); err != nil {
return 0, err
}
items = append(items, it)
}
if err := rows.Err(); err != nil {
return 0, err
}
stored := 0
for _, it := range items {
a, err := unmarshalActivity(it.payload)
if err != nil {
if _, delErr := s.db.Exec(`DELETE FROM activity_outbox WHERE id=$1`, it.id); delErr != nil {
return stored, delErr
}
continue
}
tx, err := s.db.Begin()
if err != nil {
return stored, err
}
if _, err := s.appendActivity(tx, a); err != nil {
_ = tx.Rollback()
next := it.attempts + 1
if next >= activityOutboxMaxAttempts {
log.Printf("[activity] outbox %d for exploration %d dropped after %d attempts: %v", it.id, s.expID, next, err)
if _, delErr := s.db.Exec(`DELETE FROM activity_outbox WHERE id=$1`, it.id); delErr != nil {
return stored, delErr
}
continue
}
if _, updErr := s.db.Exec(`UPDATE activity_outbox SET attempts=$2, last_error=$3 WHERE id=$1`, it.id, next, err.Error()); updErr != nil {
return stored, updErr
}
continue
}
if _, err := tx.Exec(`DELETE FROM activity_outbox WHERE id=$1`, it.id); err != nil {
_ = tx.Rollback()
return stored, err
}
if err := tx.Commit(); err != nil {
return stored, err
}
stored++
}
return stored, nil
}
+99
View File
@@ -0,0 +1,99 @@
package db
import "testing"
func TestActivityOutboxKeepsDetail(t *testing.T) {
in := Activity{Worker: "worker", Kind: "tool_result", Summary: "done", Detail: "full body", IsError: true}
raw, err := marshalActivity(in)
if err != nil {
t.Fatal(err)
}
out, err := unmarshalActivity(raw)
if err != nil {
t.Fatal(err)
}
if out.Detail != in.Detail || out.Summary != in.Summary || out.Worker != in.Worker || out.Kind != in.Kind || !out.IsError {
t.Fatalf("round trip = %+v", out)
}
}
func TestFlushActivityOutboxReplaysOnce(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Skipf("postgres unavailable (%v) — skipping", err)
}
defer d.Close()
expID, err := d.CreateExploration("outbox", "replay")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() {
_, _ = d.Exec(`DELETE FROM activity_outbox WHERE exploration_id=$1`, expID)
_, _ = d.Exec(`DELETE FROM explorations WHERE id=$1`, expID)
})
es := d.Exploration(expID)
if err := es.EnqueueActivity(Activity{Worker: "worker", Kind: "text", Summary: "kept", Detail: "body"}, "insert failed"); err != nil {
t.Fatal(err)
}
n, err := es.FlushActivityOutbox()
if err != nil || n != 1 {
t.Fatalf("flush n=%d err=%v", n, err)
}
var activities, queued int
if err := d.QueryRow(`SELECT count(*) FROM activity WHERE exploration_id=$1 AND summary='kept'`, expID).Scan(&activities); err != nil {
t.Fatal(err)
}
if err := d.QueryRow(`SELECT count(*) FROM activity_outbox WHERE exploration_id=$1`, expID).Scan(&queued); err != nil {
t.Fatal(err)
}
if activities != 1 || queued != 0 {
t.Fatalf("activities=%d outbox=%d, want 1 and 0", activities, queued)
}
if n, err = es.FlushActivityOutbox(); err != nil || n != 0 {
t.Fatalf("second flush n=%d err=%v", n, err)
}
if err := d.QueryRow(`SELECT count(*) FROM activity WHERE exploration_id=$1 AND summary='kept'`, expID).Scan(&activities); err != nil {
t.Fatal(err)
}
if activities != 1 {
t.Fatalf("activities=%d after a second flush, want 1", activities)
}
}
func TestFlushActivityOutboxDropsStuckRow(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Skipf("postgres unavailable (%v) — skipping", err)
}
defer d.Close()
const missing = int64(9_000_000_000_001)
t.Cleanup(func() { _, _ = d.Exec(`DELETE FROM activity_outbox WHERE exploration_id=$1`, missing) })
es := d.Exploration(missing)
if err := es.EnqueueActivity(Activity{Worker: "worker", Kind: "text", Summary: "stuck"}, "no parent"); err != nil {
t.Fatal(err)
}
for attempt := 1; attempt < activityOutboxMaxAttempts; attempt++ {
n, err := es.FlushActivityOutbox()
if err != nil || n != 0 {
t.Fatalf("attempt %d: n=%d err=%v", attempt, n, err)
}
var queued int
if err := d.QueryRow(`SELECT count(*) FROM activity_outbox WHERE exploration_id=$1`, missing).Scan(&queued); err != nil {
t.Fatal(err)
}
if queued != 1 {
t.Fatalf("attempt %d: outbox rows=%d, want the stuck row kept", attempt, queued)
}
}
n, err := es.FlushActivityOutbox()
if err != nil || n != 0 {
t.Fatalf("final flush n=%d err=%v", n, err)
}
var queued int
if err := d.QueryRow(`SELECT count(*) FROM activity_outbox WHERE exploration_id=$1`, missing).Scan(&queued); err != nil {
t.Fatal(err)
}
if queued != 0 {
t.Fatalf("outbox rows=%d, want the stuck row dropped", queued)
}
}
+15 -2
View File
@@ -354,7 +354,10 @@ WHERE exploration_id=$1 AND kind='intent' AND state='running'
if err != nil {
return 0, err
}
n, _ := res.RowsAffected()
n, err := res.RowsAffected()
if err != nil {
return 0, err
}
return n, nil
}
@@ -1379,14 +1382,24 @@ func (s *ExplorationStore) Stats() (map[string]int, error) {
// --- activity (poll by global id cursor) ---
// queryRower is the subset of *sql.DB and *sql.Tx that AppendActivity needs,
// so a replay can insert the activity and delete the outbox row together.
type queryRower interface {
QueryRow(query string, args ...any) *sql.Row
}
// AppendActivity records one worker step and returns its id.
func (s *ExplorationStore) AppendActivity(a Activity) (int64, error) {
return s.appendActivity(s.db, a)
}
func (s *ExplorationStore) appendActivity(q queryRower, a Activity) (int64, error) {
metadata := a.Metadata
if len(metadata) == 0 {
metadata = json.RawMessage(`{}`)
}
var id int64
err := s.db.QueryRow(`
err := q.QueryRow(`
INSERT INTO activity(exploration_id, node_id, worker, kind, tool, tool_use_id, is_error, summary, detail, metadata, input_tokens, output_tokens, cache_read_tokens, cache_write_tokens, main_seg)
VALUES ($1,$2,NULLIF($3,''),NULLIF($4,''),NULLIF($5,''),NULLIF($6,''),$7,NULLIF($8,''),NULLIF($9,''),$10,$11,$12,$13,$14,$15)
RETURNING id`, s.expID, a.NodeID, utf8Clean(a.Worker), utf8Clean(a.Kind), utf8Clean(a.Tool), utf8Clean(a.ToolUseID), a.IsError, utf8Clean(a.Summary), utf8Clean(a.Detail),
+149 -22
View File
@@ -45,8 +45,11 @@ func lessonText(s string, limit int) string {
return r
}, s)
s = strings.Join(strings.Fields(s), " ")
if len(s) > limit {
s = s[:limit]
if limit > 0 {
r := []rune(s)
if len(r) > limit {
s = string(r[:limit])
}
}
return s
}
@@ -58,31 +61,56 @@ func lessonDedupeKey(kind string, categoryID, companyID int64, cue, action strin
return hex.EncodeToString(sum[:])
}
func taskLessonScope(ctx context.Context, d *DB, taskID int64) (categoryID, companyID int64, err error) {
var cat, comp sql.NullInt64
func taskLessonScope(ctx context.Context, d *DB, taskID int64) (categoryID int64, companyIDs []int64, err error) {
var cat sql.NullInt64
err = d.QueryRowContext(ctx,
`SELECT category_id, company_id FROM tasks WHERE id=$1 AND deleted_at IS NULL`, taskID).
Scan(&cat, &comp)
`SELECT category_id FROM tasks WHERE id=$1 AND deleted_at IS NULL`, taskID).
Scan(&cat)
if err != nil {
return 0, 0, err
return 0, nil, err
}
if cat.Valid {
categoryID = cat.Int64
}
if comp.Valid {
companyID = comp.Int64
companyIDs, err = d.TaskCompanyIDsContext(ctx, taskID)
if err != nil {
return 0, nil, err
}
return categoryID, companyID, nil
if companyIDs == nil {
companyIDs = []int64{}
}
return categoryID, companyIDs, nil
}
// lessonExtractCompanyID is the company written onto a new lesson. The row has
// one company_id. Scope only when the task has exactly one company. Zero
// companies → generic (NULL). ExtractLessonsForTask skips when there are several.
func lessonExtractCompanyID(companyIDs []int64) int64 {
if len(companyIDs) == 1 {
return companyIDs[0]
}
return 0
}
// ExtractLessonsForTask derives candidate lessons from one task's findings and
// retests. It is idempotent: the evidence primary key means a second run adds
// no support. Returns the number of distinct lessons touched.
// retests. It is idempotent for the same disposition: the evidence primary key
// means a second run adds no support. A later run after a reversed disposition
// retracts that finding's evidence from the opposite-kind lesson, including
// every retest of the finding, and retires the lesson when nothing else
// supports it. Confirming again restores the evidence; a retired lesson is
// un-retired only when it has no remaining evidence. Pending and in_progress
// produce nothing and retract nothing. A task with more than one company is
// skipped so a generic (NULL company_id) lesson cannot leak across companies.
// Returns the number of distinct lessons written.
func (d *DB) ExtractLessonsForTask(ctx context.Context, taskID int64) (int, error) {
categoryID, companyID, err := taskLessonScope(ctx, d, taskID)
categoryID, companyIDs, err := taskLessonScope(ctx, d, taskID)
if err != nil {
return 0, err
}
if len(companyIDs) > 1 {
return 0, nil
}
companyID := lessonExtractCompanyID(companyIDs)
rows, err := d.QueryContext(ctx, `
SELECT f.id, f.vulnclass, f.name, f.summary, f.severity, f.status,
COALESCE(r.id,0), COALESCE(r.verdict,'')
@@ -152,11 +180,20 @@ func (d *DB) ExtractLessonsForTask(ctx context.Context, taskID int64) (int, erro
return 0, err
}
}
if err := d.retractLessonEvidence(ctx, "finding", findingID, "negative"); err != nil {
return 0, err
}
case "false_positive", "duplicate", "ignored", "risk_accepted":
if err := add("negative", "Do not re-report without new mechanics: "+label+" (prior "+status+")",
"finding", findingID, sourceDetail); err != nil {
return 0, err
}
if err := d.retractLessonEvidence(ctx, "finding", findingID, "positive"); err != nil {
return 0, err
}
if err := d.retractFindingRetestEvidence(ctx, findingID, "positive"); err != nil {
return 0, err
}
}
if retestID > 0 && (verdict == "fixed" || verdict == "inconclusive") {
if err := add("caution", "Recheck before reporting "+cue+": a prior retest was "+verdict,
@@ -173,16 +210,102 @@ func (d *DB) upsertLesson(ctx context.Context, key, kind, cue, action string, ca
err := d.QueryRowContext(ctx, `
INSERT INTO rsi_lessons(dedupe_key,kind,cue,action,category_id,company_id)
VALUES($1,$2,$3,$4,NULLIF($5,0),NULLIF($6,0))
ON CONFLICT (dedupe_key) DO UPDATE SET updated_at=now()
ON CONFLICT (dedupe_key) DO UPDATE SET
updated_at=now(),
status=CASE
WHEN rsi_lessons.status='retired'
AND NOT EXISTS (
SELECT 1 FROM rsi_lesson_evidence e WHERE e.lesson_id=rsi_lessons.id
)
THEN 'candidate'
ELSE rsi_lessons.status
END
RETURNING id`, key, kind, cue, action, categoryID, companyID).Scan(&id)
return id, err
}
// retractLessonEvidence removes this source from lessons of fromKind and
// retires any of those lessons that now have zero evidence. Shared lessons
// that still have other evidence stay active.
func (d *DB) retractLessonEvidence(ctx context.Context, sourceKind string, sourceID int64, fromKind string) error {
rows, err := d.QueryContext(ctx, `
DELETE FROM rsi_lesson_evidence e
USING rsi_lessons l
WHERE e.lesson_id=l.id
AND l.kind=$1
AND e.source_kind=$2
AND e.source_id=$3
RETURNING e.lesson_id`, fromKind, sourceKind, sourceID)
if err != nil {
return err
}
ids, err := collectLessonIDs(rows)
if err != nil {
return err
}
return d.retireLessonsIfEmpty(ctx, ids)
}
// retractFindingRetestEvidence removes every retest of this finding from
// lessons of fromKind, not only the latest row.
func (d *DB) retractFindingRetestEvidence(ctx context.Context, findingID int64, fromKind string) error {
rows, err := d.QueryContext(ctx, `
DELETE FROM rsi_lesson_evidence e
USING rsi_lessons l, finding_retests r
WHERE e.lesson_id=l.id
AND l.kind=$1
AND e.source_kind='retest'
AND e.source_id=r.id
AND r.finding_id=$2
RETURNING e.lesson_id`, fromKind, findingID)
if err != nil {
return err
}
ids, err := collectLessonIDs(rows)
if err != nil {
return err
}
return d.retireLessonsIfEmpty(ctx, ids)
}
func collectLessonIDs(rows *sql.Rows) ([]int64, error) {
defer rows.Close()
seen := map[int64]bool{}
var ids []int64
for rows.Next() {
var id int64
if err := rows.Scan(&id); err != nil {
return nil, err
}
if !seen[id] {
seen[id] = true
ids = append(ids, id)
}
}
if err := rows.Err(); err != nil {
return nil, err
}
return ids, nil
}
func (d *DB) retireLessonsIfEmpty(ctx context.Context, ids []int64) error {
if len(ids) == 0 {
return nil
}
_, err := d.ExecContext(ctx, `
UPDATE rsi_lessons l
SET status='retired', updated_at=now()
WHERE l.id=ANY($1::bigint[])
AND l.status<>'retired'
AND NOT EXISTS (SELECT 1 FROM rsi_lesson_evidence e WHERE e.lesson_id=l.id)`, ids)
return err
}
// TaskLessons selects lessons visible to one task: generic lessons plus those
// scoped to the task's company and category. Scope matches rank first, then
// positive before negative before caution, then support.
func (d *DB) TaskLessons(ctx context.Context, taskID int64, limit int) ([]Lesson, error) {
categoryID, companyID, err := taskLessonScope(ctx, d, taskID)
categoryID, companyIDs, err := taskLessonScope(ctx, d, taskID)
if err != nil {
return nil, err
}
@@ -201,12 +324,13 @@ func (d *DB) TaskLessons(ctx context.Context, taskID int64, limit int) ([]Lesson
), '[]'::jsonb)
FROM rsi_lessons l
WHERE l.status <> 'retired'
AND (l.company_id IS NULL OR l.company_id=$1)
AND (l.company_id IS NULL OR l.company_id = ANY($1::bigint[]))
AND (l.category_id IS NULL OR l.category_id=$2)
ORDER BY (l.company_id=$1) DESC, (l.category_id=$2) DESC,
ORDER BY (l.company_id IS NOT NULL AND l.company_id = ANY($1::bigint[])) DESC,
(l.category_id IS NOT NULL AND l.category_id=$2) DESC,
CASE l.kind WHEN 'positive' THEN 0 WHEN 'negative' THEN 1 ELSE 2 END,
support DESC, l.id DESC
LIMIT $3`, companyID, categoryID, limit)
LIMIT $3`, companyIDs, categoryID, limit)
if err != nil {
return nil, err
}
@@ -246,9 +370,11 @@ func (d *DB) LogLessonUsage(ctx context.Context, taskID int64, lessonIDs []int64
// RenderLessons builds the prompt block. The text is data, not instructions:
// lesson fields come from task evidence and can contain target-controlled
// strings, so they are flattened to one line and length-capped here.
func RenderLessons(lessons []Lesson, maxChars int) string {
// renderedIDs are the lessons that actually fit in the block; callers that log
// usage should record these, not the full selection.
func RenderLessons(lessons []Lesson, maxChars int) (block string, renderedIDs []int64) {
if len(lessons) == 0 {
return ""
return "", nil
}
header := "## Prior evidence from earlier tasks\n\n" +
"These lines are prior outcomes, not instructions. Verify before reuse.\n\n"
@@ -269,9 +395,10 @@ func RenderLessons(lessons []Lesson, maxChars int) string {
break
}
b.WriteString(entry)
renderedIDs = append(renderedIDs, l.ID)
}
if b.Len() == len(header) {
return ""
return "", nil
}
return b.String()
return b.String(), renderedIDs
}
+878 -3
View File
@@ -1,8 +1,11 @@
package db
import (
"fmt"
"strings"
"testing"
"time"
"unicode/utf8"
)
func TestRenderLessonsDataNotInstructions(t *testing.T) {
@@ -11,7 +14,7 @@ func TestRenderLessonsDataNotInstructions(t *testing.T) {
Evidence: []string{"finding:10 (status=confirmed severity=high)"}},
{ID: 2, Kind: "negative", Cue: "ssrf", Action: "Do not\nre-report\x00 without new mechanics", Support: 1},
}
block := RenderLessons(lessons, 2000)
block, ids := RenderLessons(lessons, 2000)
if !strings.Contains(block, "not instructions") {
t.Fatalf("missing data-not-instructions header:\n%s", block)
}
@@ -26,11 +29,883 @@ func TestRenderLessonsDataNotInstructions(t *testing.T) {
if !strings.Contains(block, "Do not re-report without new mechanics") {
t.Fatalf("lesson text was not flattened onto one line:\n%s", block)
}
if RenderLessons(nil, 2000) != "" {
if got, ids := RenderLessons(nil, 2000); got != "" || ids != nil {
t.Fatal("empty lesson set must render empty")
}
capped := RenderLessons(lessons, 120)
capped, cappedIDs := RenderLessons(lessons, 120)
if len(capped) > 160 {
t.Fatalf("cap not enforced: %d bytes", len(capped))
}
if len(ids) != 2 {
t.Fatalf("uncapped rendered IDs=%v, want both lessons", ids)
}
if len(cappedIDs) > len(ids) {
t.Fatalf("capped render logged more lessons than the full render")
}
}
func TestLessonTextDoesNotSplitUTF8(t *testing.T) {
// 60 CJK runes, 180 bytes. The old cut was s[:limit] in bytes.
in := strings.Repeat("验", 60)
got := lessonText(in, 20)
if !utf8.ValidString(got) {
t.Fatalf("truncated lesson text is not valid UTF-8: %q", got)
}
if n := utf8.RuneCountInString(got); n != 20 {
t.Fatalf("truncated to %d runes, want 20", n)
}
}
func TestRenderLessonsUsageOmitsTruncated(t *testing.T) {
lessons := []Lesson{
{ID: 11, Kind: "positive", Cue: "xss", Action: "Confirmed xss: " + strings.Repeat("a", 80), Support: 1},
{ID: 12, Kind: "negative", Cue: "ssrf", Action: "Do not re-report: " + strings.Repeat("b", 80), Support: 1},
}
block, ids := RenderLessons(lessons, 250)
if block == "" {
t.Fatal("expected at least the first lesson to fit")
}
if len(ids) == 0 || ids[0] != 11 {
t.Fatalf("rendered IDs=%v, want the first lesson", ids)
}
if len(ids) > 1 {
t.Fatalf("cap should have dropped the second lesson, got %v", ids)
}
}
func TestTaskLessonsUsesTaskScopeAndRanksCompanyFirst(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Skipf("postgres unavailable (%v) — skipping", err)
}
t.Cleanup(func() { d.Close() })
stamp := time.Now().UnixNano()
cs := d.Companies()
companyA, _, err := cs.UpsertCompany(fmt.Sprintf("LessonCoA %d", stamp), "")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupCompany(d, companyA) })
companyB, _, err := cs.UpsertCompany(fmt.Sprintf("LessonCoB %d", stamp), "")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupCompany(d, companyB) })
taskA, err := d.CreateTaskWithOptions("lesson scope A", "goal", TaskCreateOptions{
Name: fmt.Sprintf("lesson-a-%d", stamp), CompanyIDs: []int64{companyA},
})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupErr(t, "task A", d.DeleteTask(taskA.ID)) })
taskB, err := d.CreateTaskWithOptions("lesson scope B", "goal", TaskCreateOptions{
Name: fmt.Sprintf("lesson-b-%d", stamp), CompanyIDs: []int64{companyB},
})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupErr(t, "task B", d.DeleteTask(taskB.ID)) })
genericKey := fmt.Sprintf("lesson-generic-%d", stamp)
aKey := fmt.Sprintf("lesson-a-%d", stamp)
bKey := fmt.Sprintf("lesson-b-%d", stamp)
var genericID, aID, bID int64
if err := d.QueryRow(`
INSERT INTO rsi_lessons(dedupe_key,kind,cue,action,company_id)
VALUES ($1,'positive','xss','company A prior',$2) RETURNING id`, aKey, companyA).Scan(&aID); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, aID) })
if err := d.QueryRow(`
INSERT INTO rsi_lessons(dedupe_key,kind,cue,action,company_id)
VALUES ($1,'positive','xss','company B prior',$2) RETURNING id`, bKey, companyB).Scan(&bID); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, bID) })
// Generic last: without the company rank term, id DESC would put this first.
if err := d.QueryRow(`
INSERT INTO rsi_lessons(dedupe_key,kind,cue,action,company_id)
VALUES ($1,'positive','xss','generic prior',NULL) RETURNING id`, genericKey).Scan(&genericID); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, genericID) })
got, err := d.TaskLessons(t.Context(), taskA.ID, 8)
if err != nil {
t.Fatal(err)
}
var sawGeneric, sawA, sawB bool
if len(got) == 0 {
t.Fatal("task A saw no lessons")
}
if got[0].ID != aID {
t.Fatalf("company-scoped lesson should rank first, got id=%d company=%d (want %d)", got[0].ID, got[0].CompanyID, aID)
}
for _, l := range got {
switch l.ID {
case genericID:
sawGeneric = true
case aID:
sawA = true
case bID:
sawB = true
}
}
if !sawA || !sawGeneric {
t.Fatalf("task A should see its company lesson and generic, sawA=%v sawGeneric=%v", sawA, sawGeneric)
}
if sawB {
t.Fatal("task A saw company B's lesson")
}
gotB, err := d.TaskLessons(t.Context(), taskB.ID, 8)
if err != nil {
t.Fatal(err)
}
for _, l := range gotB {
if l.ID == aID {
t.Fatal("task B saw company A's lesson")
}
}
}
func TestExtractLessonsScopesSingleCompanyFromTaskScope(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Skipf("postgres unavailable (%v) — skipping", err)
}
t.Cleanup(func() { d.Close() })
stamp := time.Now().UnixNano()
companyID, _, err := d.Companies().UpsertCompany(fmt.Sprintf("LessonExtract %d", stamp), "")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupCompany(d, companyID) })
task, err := d.CreateTaskWithOptions("extract scope", "goal", TaskCreateOptions{
Name: fmt.Sprintf("lesson-extract-%d", stamp), CompanyIDs: []int64{companyID},
})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupErr(t, "extract task", d.DeleteTask(task.ID)) })
if _, err := d.Exec(`
INSERT INTO findings(task_id,vulnclass,name,summary,severity,status)
VALUES ($1,'xss','Reflected XSS','reflected in search','high','confirmed')`, task.ID); err != nil {
t.Fatal(err)
}
n, err := d.ExtractLessonsForTask(t.Context(), task.ID)
if err != nil {
t.Fatal(err)
}
if n != 1 {
t.Fatalf("extracted=%d, want 1", n)
}
lessons, err := d.TaskLessons(t.Context(), task.ID, 8)
if err != nil {
t.Fatal(err)
}
if len(lessons) == 0 {
t.Fatal("no lessons after extract")
}
var scoped *Lesson
for i := range lessons {
if lessons[i].CompanyID == companyID {
scoped = &lessons[i]
break
}
}
if scoped == nil {
t.Fatalf("extracted lesson was not scoped to company %d: %+v", companyID, lessons)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, scoped.ID) })
}
func TestExtractLessonsSkipsMultiCompanyTask(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Skipf("postgres unavailable (%v) — skipping", err)
}
t.Cleanup(func() { d.Close() })
stamp := time.Now().UnixNano()
cs := d.Companies()
companyA, _, err := cs.UpsertCompany(fmt.Sprintf("LessonMultiA %d", stamp), "")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupCompany(d, companyA) })
companyB, _, err := cs.UpsertCompany(fmt.Sprintf("LessonMultiB %d", stamp), "")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupCompany(d, companyB) })
task, err := d.CreateTaskWithOptions("extract multi company", "goal", TaskCreateOptions{
Name: fmt.Sprintf("lesson-multi-%d", stamp), CompanyIDs: []int64{companyA, companyB},
})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupErr(t, "multi-company task", d.DeleteTask(task.ID)) })
findingID := insertLessonFinding(t, d, task.ID, "confirmed")
n, err := d.ExtractLessonsForTask(t.Context(), task.ID)
if err != nil {
t.Fatal(err)
}
if n != 0 {
t.Fatalf("extracted=%d, want 0 for a multi-company task", n)
}
var evidence int
if err := d.QueryRow(`
SELECT COUNT(*) FROM rsi_lesson_evidence
WHERE source_kind='finding' AND source_id=$1`, findingID).Scan(&evidence); err != nil {
t.Fatal(err)
}
if evidence != 0 {
t.Fatalf("multi-company extract wrote %d evidence rows", evidence)
}
}
func TestExtractLessonsGenericWhenTaskHasNoCompany(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Skipf("postgres unavailable (%v) — skipping", err)
}
t.Cleanup(func() { d.Close() })
stamp := time.Now().UnixNano()
task, err := d.CreateTaskWithOptions("extract no company", "goal", TaskCreateOptions{
Name: fmt.Sprintf("lesson-nocompany-%d", stamp),
})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupErr(t, "no-company task", d.DeleteTask(task.ID)) })
findingID := insertLessonFinding(t, d, task.ID, "confirmed")
n, err := d.ExtractLessonsForTask(t.Context(), task.ID)
if err != nil {
t.Fatal(err)
}
if n != 1 {
t.Fatalf("extracted=%d, want 1", n)
}
var lessonID, companyID int64
if err := d.QueryRow(`
SELECT l.id, COALESCE(l.company_id,0)
FROM rsi_lessons l
JOIN rsi_lesson_evidence e ON e.lesson_id=l.id
WHERE e.source_kind='finding' AND e.source_id=$1`, findingID).Scan(&lessonID, &companyID); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, lessonID) })
if companyID != 0 {
t.Fatalf("no-company extract scoped lesson to company %d", companyID)
}
}
func TestTaskLessonsRanksCategoryBeforeGeneric(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Skipf("postgres unavailable (%v) — skipping", err)
}
t.Cleanup(func() { d.Close() })
stamp := time.Now().UnixNano()
category, err := d.CreateTaskCategory(fmt.Sprintf("LessonCat %d", stamp))
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() {
_, err := d.DeleteTaskCategory(category.ID)
cleanupErr(t, "category", err)
})
task, err := d.CreateTaskWithOptions("lesson category rank", "goal", TaskCreateOptions{
Name: fmt.Sprintf("lesson-cat-%d", stamp), CategoryID: &category.ID,
})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupErr(t, "category task", d.DeleteTask(task.ID)) })
var catID, genericID int64
if err := d.QueryRow(`
INSERT INTO rsi_lessons(dedupe_key,kind,cue,action,category_id)
VALUES ($1,'positive','xss','category prior',$2) RETURNING id`,
fmt.Sprintf("lesson-cat-%d", stamp), category.ID).Scan(&catID); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, catID) })
// Generic last: without the category rank term, id DESC would put this first.
if err := d.QueryRow(`
INSERT INTO rsi_lessons(dedupe_key,kind,cue,action)
VALUES ($1,'positive','xss','generic prior') RETURNING id`,
fmt.Sprintf("lesson-cat-generic-%d", stamp)).Scan(&genericID); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, genericID) })
got, err := d.TaskLessons(t.Context(), task.ID, 8)
if err != nil {
t.Fatal(err)
}
if len(got) == 0 {
t.Fatal("categorized task saw no lessons")
}
if got[0].ID != catID {
t.Fatalf("category-scoped lesson should rank first, got id=%d category=%d (want %d)",
got[0].ID, got[0].CategoryID, catID)
}
var sawCat, sawGeneric bool
for _, l := range got {
switch l.ID {
case catID:
sawCat = true
case genericID:
sawGeneric = true
}
}
if !sawCat || !sawGeneric {
t.Fatalf("want category and generic lessons, sawCat=%v sawGeneric=%v", sawCat, sawGeneric)
}
}
func TestLogLessonUsageRecordsOnlyRendered(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Skipf("postgres unavailable (%v) — skipping", err)
}
t.Cleanup(func() { d.Close() })
stamp := time.Now().UnixNano()
task, err := d.CreateTaskWithOptions("lesson usage", "goal", TaskCreateOptions{
Name: fmt.Sprintf("lesson-usage-%d", stamp),
})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupErr(t, "usage task", d.DeleteTask(task.ID)) })
var firstID, secondID int64
if err := d.QueryRow(`
INSERT INTO rsi_lessons(dedupe_key,kind,cue,action)
VALUES ($1,'positive','xss',$2) RETURNING id`,
fmt.Sprintf("lesson-usage-a-%d", stamp),
"Confirmed xss: "+strings.Repeat("a", 80)).Scan(&firstID); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, firstID) })
if err := d.QueryRow(`
INSERT INTO rsi_lessons(dedupe_key,kind,cue,action)
VALUES ($1,'negative','ssrf',$2) RETURNING id`,
fmt.Sprintf("lesson-usage-b-%d", stamp),
"Do not re-report: "+strings.Repeat("b", 80)).Scan(&secondID); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, secondID) })
lessons := []Lesson{
{ID: firstID, Kind: "positive", Cue: "xss", Action: "Confirmed xss: " + strings.Repeat("a", 80), Support: 1},
{ID: secondID, Kind: "negative", Cue: "ssrf", Action: "Do not re-report: " + strings.Repeat("b", 80), Support: 1},
}
_, ids := RenderLessons(lessons, 250)
if len(ids) != 1 || ids[0] != firstID {
t.Fatalf("rendered IDs=%v, want only %d", ids, firstID)
}
if err := d.LogLessonUsage(t.Context(), task.ID, ids, "shadow"); err != nil {
t.Fatal(err)
}
rows, err := d.Query(`SELECT lesson_id FROM rsi_lesson_usage WHERE task_id=$1 ORDER BY lesson_id`, task.ID)
if err != nil {
t.Fatal(err)
}
defer rows.Close()
var logged []int64
for rows.Next() {
var id int64
if err := rows.Scan(&id); err != nil {
t.Fatal(err)
}
logged = append(logged, id)
}
if err := rows.Err(); err != nil {
t.Fatal(err)
}
if len(logged) != 1 || logged[0] != firstID {
t.Fatalf("usage log=%v, want only rendered lesson %d (dropped %d)", logged, firstID, secondID)
}
}
func insertLessonFinding(t *testing.T, d *DB, taskID int64, status string) int64 {
t.Helper()
var id int64
if err := d.QueryRow(`
INSERT INTO findings(task_id,vulnclass,name,summary,severity,status)
VALUES ($1,'xss','Reflected XSS','reflected in search','high',$2)
RETURNING id`, taskID, status).Scan(&id); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, id) })
return id
}
func TestExtractLessonsRetractsReversedDisposition(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Skipf("postgres unavailable (%v) — skipping", err)
}
t.Cleanup(func() { d.Close() })
stamp := time.Now().UnixNano()
task, err := d.CreateTask(fmt.Sprintf("lesson retract %d", stamp), "goal", nil, 0, 0)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupErr(t, "task", d.DeleteTask(task.ID)) })
cue := fmt.Sprintf("xss-retract-%d", stamp)
label := fmt.Sprintf("reflected in search %d", stamp)
var fid int64
if err := d.QueryRow(`
INSERT INTO findings(task_id,vulnclass,name,summary,severity,status)
VALUES ($1,$2,'Reflected XSS',$3,'high','confirmed')
RETURNING id`, task.ID, cue, label).Scan(&fid); err != nil {
t.Fatal(err)
}
n, err := d.ExtractLessonsForTask(t.Context(), task.ID)
if err != nil {
t.Fatal(err)
}
if n != 1 {
t.Fatalf("first extract=%d, want 1", n)
}
first, err := d.TaskLessons(t.Context(), task.ID, 8)
if err != nil {
t.Fatal(err)
}
var pos *Lesson
for i := range first {
if first[i].Kind == "positive" && strings.Contains(first[i].Action, label) {
pos = &first[i]
break
}
}
if pos == nil {
t.Fatalf("no positive lesson: %+v", first)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, pos.ID) })
posID := pos.ID
if _, err := d.SetFindingStatus(fid, FindingFalsePositive); err != nil {
t.Fatal(err)
}
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
t.Fatal(err)
}
var posStatus string
var posSupport int
if err := d.QueryRow(`SELECT status,
(SELECT COUNT(*) FROM rsi_lesson_evidence e WHERE e.lesson_id=rsi_lessons.id)
FROM rsi_lessons WHERE id=$1`, posID).Scan(&posStatus, &posSupport); err != nil {
t.Fatal(err)
}
if posStatus != "retired" || posSupport != 0 {
t.Fatalf("positive after FP: status=%s support=%d", posStatus, posSupport)
}
afterFP, err := d.TaskLessons(t.Context(), task.ID, 8)
if err != nil {
t.Fatal(err)
}
var neg *Lesson
for i := range afterFP {
if afterFP[i].ID == posID {
t.Fatal("retired positive still selected")
}
if afterFP[i].Kind == "negative" && strings.Contains(afterFP[i].Action, label) {
neg = &afterFP[i]
}
}
if neg == nil {
t.Fatalf("no negative lesson after FP: %+v", afterFP)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, neg.ID) })
if _, err := d.SetFindingStatus(fid, FindingConfirmed); err != nil {
t.Fatal(err)
}
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
t.Fatal(err)
}
if err := d.QueryRow(`SELECT status,
(SELECT COUNT(*) FROM rsi_lesson_evidence e WHERE e.lesson_id=rsi_lessons.id)
FROM rsi_lessons WHERE id=$1`, posID).Scan(&posStatus, &posSupport); err != nil {
t.Fatal(err)
}
if posStatus != "candidate" || posSupport != 1 {
t.Fatalf("positive after re-confirm: status=%s support=%d", posStatus, posSupport)
}
var negStatus string
var negSupport int
if err := d.QueryRow(`SELECT status,
(SELECT COUNT(*) FROM rsi_lesson_evidence e WHERE e.lesson_id=rsi_lessons.id)
FROM rsi_lessons WHERE id=$1`, neg.ID).Scan(&negStatus, &negSupport); err != nil {
t.Fatal(err)
}
if negStatus != "retired" || negSupport != 0 {
t.Fatalf("negative after re-confirm: status=%s support=%d", negStatus, negSupport)
}
}
func TestExtractLessonsRetireOnlyWhenLastEvidence(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Skipf("postgres unavailable (%v) — skipping", err)
}
t.Cleanup(func() { d.Close() })
stamp := time.Now().UnixNano()
task, err := d.CreateTask(fmt.Sprintf("lesson shared retract %d", stamp), "goal", nil, 0, 0)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupErr(t, "task", d.DeleteTask(task.ID)) })
cue := fmt.Sprintf("xss-shared-%d", stamp)
label := fmt.Sprintf("reflected in search %d", stamp)
var aID, bID int64
if err := d.QueryRow(`
INSERT INTO findings(task_id,vulnclass,name,summary,severity,status)
VALUES ($1,$2,'Reflected XSS',$3,'high','confirmed')
RETURNING id`, task.ID, cue, label).Scan(&aID); err != nil {
t.Fatal(err)
}
if err := d.QueryRow(`
INSERT INTO findings(task_id,vulnclass,name,summary,severity,status)
VALUES ($1,$2,'Reflected XSS',$3,'high','confirmed')
RETURNING id`, task.ID, cue, label).Scan(&bID); err != nil {
t.Fatal(err)
}
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
t.Fatal(err)
}
lessons, err := d.TaskLessons(t.Context(), task.ID, 8)
if err != nil {
t.Fatal(err)
}
var pos *Lesson
for i := range lessons {
if lessons[i].Kind == "positive" && strings.Contains(lessons[i].Action, label) {
pos = &lessons[i]
break
}
}
if pos == nil {
t.Fatalf("no shared positive lesson: %+v", lessons)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, pos.ID) })
if pos.Support != 2 {
t.Fatalf("shared support=%d, want 2", pos.Support)
}
if _, err := d.SetFindingStatus(aID, FindingFalsePositive); err != nil {
t.Fatal(err)
}
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
t.Fatal(err)
}
var status string
var support int
if err := d.QueryRow(`SELECT status,
(SELECT COUNT(*) FROM rsi_lesson_evidence e WHERE e.lesson_id=rsi_lessons.id)
FROM rsi_lessons WHERE id=$1`, pos.ID).Scan(&status, &support); err != nil {
t.Fatal(err)
}
if status == "retired" || support != 1 {
t.Fatalf("shared positive should stay active with support 1, got status=%s support=%d", status, support)
}
after, err := d.TaskLessons(t.Context(), task.ID, 8)
if err != nil {
t.Fatal(err)
}
var sawNeg bool
for i := range after {
if after[i].ID == pos.ID && after[i].Kind == "positive" {
if after[i].Support != 1 {
t.Fatalf("selected support=%d, want 1", after[i].Support)
}
}
if after[i].Kind == "negative" && strings.Contains(after[i].Action, label) {
sawNeg = true
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, after[i].ID) })
}
}
if !sawNeg {
t.Fatalf("expected a negative lesson for the flipped finding: %+v", after)
}
}
func TestExtractLessonsRetractsAllRetests(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Skipf("postgres unavailable (%v) — skipping", err)
}
t.Cleanup(func() { d.Close() })
stamp := time.Now().UnixNano()
task, err := d.CreateTask(fmt.Sprintf("lesson all retests %d", stamp), "goal", nil, 0, 0)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupErr(t, "task", d.DeleteTask(task.ID)) })
cue := fmt.Sprintf("xss-all-retest-%d", stamp)
label := fmt.Sprintf("reflected in search %d", stamp)
var fid int64
if err := d.QueryRow(`
INSERT INTO findings(task_id,vulnclass,name,summary,severity,status)
VALUES ($1,$2,'Reflected XSS',$3,'high','confirmed')
RETURNING id`, task.ID, cue, label).Scan(&fid); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, fid) })
r1 := insertLessonRetest(t, d, fid, "reproduced")
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
t.Fatal(err)
}
reproduced := findLessonByAction(t, d, task.ID, "positive", "Reproduced", label)
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, reproduced.ID) })
confirmed := findLessonByAction(t, d, task.ID, "positive", "Confirmed", label)
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, confirmed.ID) })
if positiveRetestEvidence(t, d, r1) != 1 {
t.Fatal("first retest was not extracted")
}
r2 := insertLessonRetest(t, d, fid, "fixed")
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
t.Fatal(err)
}
caution := findLessonByAction(t, d, task.ID, "caution", "Recheck", cue)
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, caution.ID) })
if positiveRetestEvidence(t, d, r1) != 1 {
t.Fatal("older reproduced retest lost its evidence after a later fixed retest")
}
if _, err := d.SetFindingStatus(fid, FindingFalsePositive); err != nil {
t.Fatal(err)
}
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
t.Fatal(err)
}
if n := positiveRetestEvidence(t, d, r1); n != 0 {
t.Fatalf("older retest still has %d positive evidence rows after FP", n)
}
if n := positiveRetestEvidence(t, d, r2); n != 0 {
t.Fatalf("latest retest still has %d positive evidence rows after FP", n)
}
status, support := lessonStatusSupport(t, d, reproduced.ID)
if status != "retired" || support != 0 {
t.Fatalf("reproduced retest lesson after FP: status=%s support=%d", status, support)
}
status, support = lessonStatusSupport(t, d, confirmed.ID)
if status != "retired" || support != 0 {
t.Fatalf("confirmed lesson after FP: status=%s support=%d", status, support)
}
neg := findLessonByAction(t, d, task.ID, "negative", "Do not re-report", label)
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, neg.ID) })
}
func TestExtractLessonsDoesNotUnretireWithEvidence(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Skipf("postgres unavailable (%v) — skipping", err)
}
t.Cleanup(func() { d.Close() })
stamp := time.Now().UnixNano()
task, err := d.CreateTask(fmt.Sprintf("lesson keep retired %d", stamp), "goal", nil, 0, 0)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupErr(t, "task", d.DeleteTask(task.ID)) })
cue := fmt.Sprintf("xss-keep-retired-%d", stamp)
label := fmt.Sprintf("reflected in search %d", stamp)
var fid int64
if err := d.QueryRow(`
INSERT INTO findings(task_id,vulnclass,name,summary,severity,status)
VALUES ($1,$2,'Reflected XSS',$3,'high','confirmed')
RETURNING id`, task.ID, cue, label).Scan(&fid); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, fid) })
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
t.Fatal(err)
}
pos := findLessonByAction(t, d, task.ID, "positive", "Confirmed", label)
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, pos.ID) })
if _, err := d.Exec(`UPDATE rsi_lessons SET status='retired' WHERE id=$1`, pos.ID); err != nil {
t.Fatal(err)
}
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
t.Fatal(err)
}
status, support := lessonStatusSupport(t, d, pos.ID)
if status != "retired" {
t.Fatalf("operator-retired lesson with evidence became %s", status)
}
if support != 1 {
t.Fatalf("support=%d, want 1", support)
}
}
func TestExtractLessonsLeavesAdopted(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Skipf("postgres unavailable (%v) — skipping", err)
}
t.Cleanup(func() { d.Close() })
stamp := time.Now().UnixNano()
task, err := d.CreateTask(fmt.Sprintf("lesson keep adopted %d", stamp), "goal", nil, 0, 0)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupErr(t, "task", d.DeleteTask(task.ID)) })
cue := fmt.Sprintf("xss-keep-adopted-%d", stamp)
label := fmt.Sprintf("reflected in search %d", stamp)
var fid int64
if err := d.QueryRow(`
INSERT INTO findings(task_id,vulnclass,name,summary,severity,status)
VALUES ($1,$2,'Reflected XSS',$3,'high','confirmed')
RETURNING id`, task.ID, cue, label).Scan(&fid); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, fid) })
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
t.Fatal(err)
}
pos := findLessonByAction(t, d, task.ID, "positive", "Confirmed", label)
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, pos.ID) })
if _, err := d.Exec(`UPDATE rsi_lessons SET status='adopted' WHERE id=$1`, pos.ID); err != nil {
t.Fatal(err)
}
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
t.Fatal(err)
}
status, _ := lessonStatusSupport(t, d, pos.ID)
if status != "adopted" {
t.Fatalf("adopted lesson became %s", status)
}
}
func TestExtractLessonsReopenRetractsNothing(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Skipf("postgres unavailable (%v) — skipping", err)
}
t.Cleanup(func() { d.Close() })
stamp := time.Now().UnixNano()
task, err := d.CreateTask(fmt.Sprintf("lesson reopen %d", stamp), "goal", nil, 0, 0)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupErr(t, "task", d.DeleteTask(task.ID)) })
cue := fmt.Sprintf("xss-reopen-%d", stamp)
label := fmt.Sprintf("reflected in search %d", stamp)
var fid int64
if err := d.QueryRow(`
INSERT INTO findings(task_id,vulnclass,name,summary,severity,status)
VALUES ($1,$2,'Reflected XSS',$3,'high','confirmed')
RETURNING id`, task.ID, cue, label).Scan(&fid); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, fid) })
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
t.Fatal(err)
}
pos := findLessonByAction(t, d, task.ID, "positive", "Confirmed", label)
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, pos.ID) })
if _, err := d.SetFindingStatus(fid, FindingPending); err != nil {
t.Fatal(err)
}
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
t.Fatal(err)
}
status, support := lessonStatusSupport(t, d, pos.ID)
if status != "candidate" || support != 1 {
t.Fatalf("reopened finding retracted the lesson: status=%s support=%d", status, support)
}
}
func insertLessonRetest(t *testing.T, d *DB, findingID int64, verdict string) int64 {
t.Helper()
var id int64
if err := d.QueryRow(`
INSERT INTO finding_retests(finding_id,status,verdict,snapshot)
VALUES ($1,'completed',$2,'{}'::jsonb)
RETURNING id`, findingID, verdict).Scan(&id); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM finding_retests WHERE id=$1`, id) })
return id
}
func findLessonByAction(t *testing.T, d *DB, taskID int64, kind, actionPrefix, label string) *Lesson {
t.Helper()
lessons, err := d.TaskLessons(t.Context(), taskID, 8)
if err != nil {
t.Fatal(err)
}
for i := range lessons {
if lessons[i].Kind == kind && strings.Contains(lessons[i].Action, actionPrefix) && strings.Contains(lessons[i].Action, label) {
return &lessons[i]
}
}
t.Fatalf("no %s lesson with %q and %q: %+v", kind, actionPrefix, label, lessons)
return nil
}
func positiveRetestEvidence(t *testing.T, d *DB, retestID int64) int {
t.Helper()
var n int
if err := d.QueryRow(`
SELECT COUNT(*) FROM rsi_lesson_evidence e
JOIN rsi_lessons l ON l.id=e.lesson_id
WHERE e.source_kind='retest' AND e.source_id=$1 AND l.kind='positive'`, retestID).Scan(&n); err != nil {
t.Fatal(err)
}
return n
}
func lessonStatusSupport(t *testing.T, d *DB, lessonID int64) (status string, support int) {
t.Helper()
if err := d.QueryRow(`SELECT status,
(SELECT COUNT(*) FROM rsi_lesson_evidence e WHERE e.lesson_id=rsi_lessons.id)
FROM rsi_lessons WHERE id=$1`, lessonID).Scan(&status, &support); err != nil {
t.Fatal(err)
}
return status, support
}
+18
View File
@@ -33,6 +33,24 @@ func (d *DB) EnsureLLMUsageTable() error {
return d.execEmbeddedMigration(llmUsageMigration)
}
// TaskLLMSpend is the token and turn total the in-memory task ledger would
// already have counted. One row is one turn. The ledger sees planner and worker
// completions, plus judge and compactor calls made on those contexts. Main-agent
// chat, goal decomposition, and side questions write llm_usage rows for the same
// task and never enter the ledger, so they are left out: counting them would
// tighten the turn cap after a restart. Cache read and write are not added:
// input_tokens already includes them. Every status counts, because a failed call
// is metered too.
func (d *DB) TaskLLMSpend(taskID string) (tokens, turns int64, err error) {
if d == nil || taskID == "" {
return 0, 0, nil
}
err = d.QueryRow(`SELECT COALESCE(SUM(input_tokens + output_tokens), 0), COUNT(*)
FROM llm_usage
WHERE task_id=$1 AND worker IN ('planner', 'worker', 'judge', 'compactor')`, taskID).Scan(&tokens, &turns)
return tokens, turns, err
}
// InsertLLMUsage appends one metering row. Best-effort: callers log and continue on
// error (a lost metering row must never break the LLM call).
func (d *DB) InsertLLMUsage(u *LLMUsage) error {
+2 -2
View File
@@ -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"}}
{5, "0005_traffic_rewrite_rules.sql"}, {6, "0006_activity_outbox.sql"}}
if len(applied) != len(want) {
t.Fatalf("schema_migrations = %+v, want versions 1 to 5", applied)
t.Fatalf("schema_migrations = %+v, want versions 1 to 6", applied)
}
for i, w := range want {
content, err := fs.ReadFile(migrationsFS(), w.name)
+15
View File
@@ -0,0 +1,15 @@
-- Activities that could not be inserted (the exploration row was missing, or
-- the write failed after retries) are kept here and replayed into activity
-- once the parent row accepts them. No foreign key: the row has to survive
-- the missing exploration that caused the original failure.
CREATE TABLE IF NOT EXISTS activity_outbox (
id BIGSERIAL PRIMARY KEY,
exploration_id BIGINT NOT NULL,
payload JSONB NOT NULL,
last_error TEXT,
attempts INT NOT NULL DEFAULT 0,
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE INDEX IF NOT EXISTS activity_outbox_exploration_idx
ON activity_outbox (exploration_id, id);
+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()
+7 -1
View File
@@ -1,6 +1,7 @@
package db
import (
"context"
"database/sql"
"fmt"
"strings"
@@ -344,7 +345,12 @@ func (d *DB) TaskSourceIDs(taskID int64) ([]int64, error) {
// TaskCompanyIDs returns the companies whose asset scopes are available to the
// task. The task_scope rows remain the single source of truth.
func (d *DB) TaskCompanyIDs(taskID int64) ([]int64, error) {
rows, err := d.Query(`
return d.TaskCompanyIDsContext(context.Background(), taskID)
}
// TaskCompanyIDsContext is the context-aware form of TaskCompanyIDs.
func (d *DB) TaskCompanyIDsContext(ctx context.Context, taskID int64) ([]int64, error) {
rows, err := d.QueryContext(ctx, `
SELECT company_id FROM task_scope
WHERE task_id=$1 AND kind='company' AND company_id IS NOT NULL
ORDER BY id`, taskID)
+40
View File
@@ -0,0 +1,40 @@
package db
import (
"fmt"
"testing"
"time"
)
// Judge calls share the planner or worker sink and count toward the task cap.
// Chat rows for the same task do not, or a restart would tighten the cap.
func TestTaskLLMSpendCountsJudgeNotChat(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Skipf("postgres unavailable (%v)", err)
}
defer d.Close()
taskID := fmt.Sprintf("spend-%d", time.Now().UnixNano())
t.Cleanup(func() {
_, _ = d.Exec(`DELETE FROM llm_usage WHERE task_id=$1`, taskID)
})
insert := func(worker string, in, out int) {
t.Helper()
if err := d.InsertLLMUsage(&LLMUsage{
TaskID: taskID, Worker: worker, InputTokens: in, OutputTokens: out, Status: "ok",
}); err != nil {
t.Fatal(err)
}
}
insert("judge", 30, 10)
insert("chat", 1000, 1000)
tokens, turns, err := d.TaskLLMSpend(taskID)
if err != nil {
t.Fatal(err)
}
if tokens != 40 || turns != 1 {
t.Fatalf("tokens=%d turns=%d, want the judge row only (40 tokens, 1 turn)", tokens, turns)
}
}
+12 -7
View File
@@ -297,17 +297,22 @@ type Coverage struct {
}
// CoverageEnabled reports whether a task has the asset-coverage feature turned on
// (tasks.coverage_enabled). Missing row / error → true (fail open to the default),
// so unknown/legacy tasks keep the historical behavior. taskID<=0 → true.
func (s *AssetStore) CoverageEnabled(taskID int64) bool {
// (tasks.coverage_enabled). A missing row stays enabled, which is the historical
// default for unknown and legacy tasks. taskID<=0 stays enabled. A query error is
// returned with enabled=true so a database blip does not turn the feature off.
func (s *AssetStore) CoverageEnabled(taskID int64) (bool, error) {
if taskID <= 0 {
return true
return true, nil
}
var enabled bool
if err := s.db.QueryRow(`SELECT COALESCE(coverage_enabled,true) FROM tasks WHERE id=$1`, taskID).Scan(&enabled); err != nil {
return true
err := s.db.QueryRow(`SELECT COALESCE(coverage_enabled,true) FROM tasks WHERE id=$1`, taskID).Scan(&enabled)
if err == sql.ErrNoRows {
return true, nil
}
return enabled
if err != nil {
return true, err
}
return enabled, nil
}
// declaredScopeFilter keeps a task_scope row ts in the coverage match only when it is
+33
View File
@@ -2,6 +2,39 @@ package db
import "testing"
func TestCoverageEnabledWithoutTask(t *testing.T) {
on, err := (&AssetStore{}).CoverageEnabled(0)
if err != nil || !on {
t.Fatalf("enabled=%v err=%v", on, err)
}
}
func TestCoverageEnabledMissingRowStaysOn(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Skipf("postgres unavailable (%v)", err)
}
defer d.Close()
on, err := d.Assets().CoverageEnabled(9_000_000_000_001)
if err != nil || !on {
t.Fatalf("missing task: enabled=%v err=%v, want enabled with no error", on, err)
}
}
func TestCoverageEnabledQueryErrorStaysOn(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Skipf("postgres unavailable (%v)", err)
}
if err := d.Close(); err != nil {
t.Fatal(err)
}
on, err := d.Assets().CoverageEnabled(1)
if err == nil || !on {
t.Fatalf("failed query: enabled=%v err=%v, want enabled and the error", on, err)
}
}
// TestStripHostPort covers the ip:port / [ipv6]:port stripping used by the
// ip/cidr scope path so a target like "10.0.188.136:3000" no longer 404s.
func TestStripHostPort(t *testing.T) {
+25 -7
View File
@@ -32,9 +32,15 @@ Extraction runs automatically when a task reaches a terminal status
POST /api/tasks/{id}/lessons/extract
```
It is idempotent. `rsi_lesson_evidence` is keyed by `(lesson, source_kind,
source_id)`, so a second run for the same task adds no evidence and cannot
inflate support.
It is idempotent for the same disposition. `rsi_lesson_evidence` is keyed by
`(lesson, source_kind, source_id)`, so a second run for the same finding adds
no evidence and cannot inflate support. A later extract after a reversed
disposition retracts that finding's evidence from the opposite-kind lesson,
including every retest of the finding, and retires the lesson when its
support hits zero. Confirming again restores the evidence; a retired lesson
is un-retired only when it has no remaining evidence. Extraction does not
run on status PATCH; call the endpoint after triage. Reopening a finding
(`pending` / `in_progress`) produces nothing and retracts nothing.
Rules:
@@ -48,13 +54,22 @@ Rules:
Pending and in-progress findings produce nothing: there is no outcome yet.
Empty cue, action, or source is refused by the gate.
A task with more than one company in `task_scope` is skipped. A generic
(`company_id` NULL) lesson would be visible to every later task, including
those of the other companies on this one. Per-finding company attribution is
a later change.
## Selection
`GET /api/tasks/{id}/lessons` returns the lessons visible to a task plus the
rendered block. Selection is scoped:
- generic lessons (no company, no category) are visible to every task;
- lessons from the same company or the same task category rank first;
- company scope comes from `task_scope`, not `tasks.company_id`; a lesson is
company-scoped only when the source task had exactly one company, and a
task with several companies is not extracted;
- lessons from the same company or the same task category rank first
(company/category matches sort ahead of generic rows);
- within a scope: positive before negative before caution, then support, then
recency;
- at most eight lessons and 1800 characters are rendered.
@@ -75,10 +90,13 @@ What this layer deliberately does not do:
- no LLM summarization in this phase: rules only, so every lesson traces to a
finding or retest id;
- no adoption: `status` is `candidate`; `adopted` and `retired` are reserved for
a later, owner-approved phase;
- no prompt mutation, no benchmark probing, no lesson editing through the UI;
- no decay or deletion; the evidence table is the audit trail.
- `status` starts as `candidate`. Extraction auto-retires a lesson when its last
evidence is retracted. It un-retires only a retired lesson with no remaining
evidence. Adopted stays adopted; a retired lesson that still has evidence
stays retired;
- no time-based decay; reversed dispositions retract that finding's evidence
from the opposite-kind lesson on the next extract.
## Measuring it
+67 -3
View File
@@ -3,9 +3,10 @@
A rewrite rule matches a request or a response that goes through the capture proxy and describes
how to change it: the method, the path and query, headers, the body, the status code.
**Status: rules are stored, validated and compiled. The proxy does not apply them yet.** Creating
or enabling a rule changes nothing in what the proxy forwards or records. Applying the rules, the
per-exchange trace, the archive format and the web UI come in a later change.
**Status: the capture proxy applies enabled rules to HTTP traffic (request and response phases),
and records what it did.** Not yet in this change: archive format, a per-replay rule toggle, the web UI,
and the proof flag. See [Application in the capture proxy](#application-in-the-capture-proxy) for
what is covered and what is not.
Rules are a convenience for the operator, not a security control: a rule that fails leaves the
message unchanged (fail open).
@@ -145,3 +146,66 @@ cannot restore them, and ARTEX refuses to start under a key that cannot open the
The server compiles the enabled rules into an immutable snapshot at startup and after every rule
change, and hands it to the proxy without a restart.
## Application in the capture proxy
The proxy applies the snapshot to each exchange in two phases. The request phase runs before the
request is sent to the target; the response phase runs before the response is returned to the
client. Each rule sees the output of the previous one. Only rules whose phase matches the step
are run, and a rule that fails leaves the message as it was (fail open).
### What is recorded
For a rewritten exchange, the record keeps the request as the client sent it and the response as
the target sent it. The rewritten values are not stored as the exchange's original data.
- Each action that ran (applied, skipped or failed) is written in the SQLite table
`exchange_rewrites`, in the same transaction as the exchange itself, with the rule id, a copy of
the rule as it was applied, the action, the outcome and the reason.
- The before value is kept as its SHA-256. The after value is kept as the value itself, inline or
in the blob store when it is large, with its SHA-256. A sensitive action stores neither value nor
plain hash: its after value is not stored, and the hashes it leaves are a keyed HMAC when a key is
available (empty otherwise). The same HMAC applies to later actions on a field a sensitive action
wrote.
- `traffic_get` shows a `=== REWRITTEN ===` line naming the rule ids when the exchange was changed.
The line says that the shown values are the originals.
- `traffic_search` searches only the original values. It never finds a value that a rule wrote.
Reasons a rule is not applied are recorded in the trace, for example `not rewritten: binary`,
`not rewritten: stream`, or `not rewritten: snapshot capacity`.
### Streams: SSE and WebSocket
- **SSE** (`text/event-stream`): status and headers are rewritten at the start of the stream
(SSEStart), since they are sent once. Later event frames pass unchanged.
- **WebSocket**: not rewritten. The capture library calls its start hook after the upgrade is
already done, and it short-circuits the upgrade before the request and response hooks run, so
the handshake status and headers cannot be changed. Frames pass unchanged. The exchange is
traced `not rewritten: stream`.
### Large responses
go-mitmproxy does not call the response hook for a body of 5 MiB or more (its `StreamLargeBodies`
default). Such a response is forwarded to the client unchanged and is not recorded in full, and no
response rule runs on it.
### Snapshot limits
Each exchange with a rewrite trace (at least one rule matched and produced a line: applied, skipped or failed) keeps an original copy in memory until it finishes. Limits:
| Limit | Value |
|---|---|
| Entries holding an original request | 1024 |
| Bytes held by those entries | 64 MiB |
| Tombstones (slots whose data was released) | 4096 |
| Time after which the slot of a live flow may be turned into a tombstone (see below) | 15 minutes |
When there is no room, the request is not rewritten. The exchange is traced `not rewritten: snapshot capacity` when a tombstone slot is free; when the tombstone table is full, the request is refused with no trace line at all (the refusal is counted and logged, at most once a minute).
The slot of a finished flow is swept when its connection closes (at most once per second) and at
least once a minute while slots exist. The 15-minute TTL never deletes a live flow's slot: past it,
the slot may be converted into a tombstone if a new reservation needs the room.
### Replay
Replay goes through the recording proxy like any other traffic, so the enabled rules apply to a
replay and the resulting exchange is traced like a captured one. There is no per-replay toggle yet.
+13 -16
View File
@@ -46,7 +46,9 @@ type Registry struct {
m map[int64]*State
// persist / forget mirror state to the DB so a cooling-off window survives a
// restart. Both may be nil (no DB); both are called off the hot path.
// restart. Both may be nil (no DB). Both run while r.mu is held, so a later
// change to the same profile cannot enqueue ahead of this one. They must not
// call back into the registry or wait on database I/O.
persist func(id int64, st State)
forget func(id int64)
@@ -118,16 +120,14 @@ func (r *Registry) IsOpen(id int64) bool { return r.Get(id).Open() }
// recovers is fully trusted again (and drops the persisted row).
func (r *Registry) Pass(id int64) {
r.mu.Lock()
defer r.mu.Unlock()
st := r.m[id]
if st == nil || (st.Fails == 0 && st.Trips == 0 && st.OpenUntil.IsZero()) {
r.mu.Unlock()
return // already clean — nothing to write
return // already clean; nothing to write
}
delete(r.m, id)
forget := r.forget
r.mu.Unlock()
if forget != nil {
forget(id)
if r.forget != nil {
r.forget(id)
}
}
@@ -137,6 +137,7 @@ func (r *Registry) Pass(id int64) {
// true when this call is what opened the breaker, so the caller can log it once.
func (r *Registry) Trip(id int64, errMsg string, hard bool) (tripped bool) {
r.mu.Lock()
defer r.mu.Unlock()
st := r.m[id]
if st == nil {
st = &State{}
@@ -152,11 +153,8 @@ func (r *Registry) Trip(id int64, errMsg string, hard bool) (tripped bool) {
st.Fails = 0 // counted into this trip; start fresh for the half-open probe
tripped = true
}
snap := *st
persist := r.persist
r.mu.Unlock()
if persist != nil {
persist(id, snap)
if r.persist != nil {
r.persist(id, *st)
}
return tripped
}
@@ -164,11 +162,10 @@ func (r *Registry) Trip(id int64, errMsg string, hard bool) (tripped bool) {
// Reset clears one profile's state — the UI's "Recover now" action.
func (r *Registry) Reset(id int64) {
r.mu.Lock()
defer r.mu.Unlock()
delete(r.m, id)
forget := r.forget
r.mu.Unlock()
if forget != nil {
forget(id)
if r.forget != nil {
r.forget(id)
}
}
+51
View File
@@ -0,0 +1,51 @@
package llmpool
import (
"sync/atomic"
"testing"
"time"
)
// persist and forget run under the registry lock. A second update on the same
// profile cannot enqueue until the first callback returns, so the queue cannot
// observe the later state first.
func TestHealthCallbacksStayInStateOrder(t *testing.T) {
var entered atomic.Int32
firstIn := make(chan struct{})
release := make(chan struct{})
block := func() {
if entered.Add(1) == 1 {
close(firstIn)
<-release
}
}
reg := NewRegistry(
func(int64, State) { block() },
func(int64) { block() },
)
go reg.Trip(1, "down", true)
select {
case <-firstIn:
case <-time.After(2 * time.Second):
t.Fatal("Trip did not reach persist")
}
passed := make(chan struct{})
go func() {
reg.Pass(1)
close(passed)
}()
select {
case <-passed:
t.Fatal("Pass enqueued while Trip's persist was still running")
case <-time.After(50 * time.Millisecond):
}
close(release)
select {
case <-passed:
case <-time.After(2 * time.Second):
t.Fatal("Pass did not finish after Trip released the lock")
}
if entered.Load() != 2 {
t.Fatalf("callbacks=%d, want Trip then Pass", entered.Load())
}
}
+3 -3
View File
@@ -36,7 +36,7 @@ func (s *Server) assetInterceptCreateRule(w http.ResponseWriter, r *http.Request
return
}
var req assetInterceptRuleReq
if err := decode(r, &req); err != nil {
if err := decode(w, r, &req); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -63,7 +63,7 @@ func (s *Server) assetInterceptUpdateRule(w http.ResponseWriter, r *http.Request
return
}
var req assetInterceptRuleReq
if err := decode(r, &req); err != nil {
if err := decode(w, r, &req); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -109,7 +109,7 @@ func (s *Server) assetInterceptToggleRule(w http.ResponseWriter, r *http.Request
var req struct {
Enabled bool `json:"enabled"`
}
if err := decode(r, &req); err != nil {
if err := decode(w, r, &req); err != nil {
writeErr(w, 400, err.Error())
return
}
+3 -3
View File
@@ -297,7 +297,7 @@ func (s *Server) authInit(w http.ResponseWriter, r *http.Request) {
Password string `json:"password"`
SetupToken string `json:"setup_token"`
}
if err := decode(r, &req); err != nil || req.Password == "" {
if err := decode(w, r, &req); err != nil || req.Password == "" {
writeErr(w, 400, "Password cannot be empty")
return
}
@@ -354,7 +354,7 @@ func (s *Server) authChangePassword(w http.ResponseWriter, r *http.Request) {
OldPassword string `json:"old_password"`
NewPassword string `json:"new_password"`
}
if err := decode(r, &req); err != nil {
if err := decode(w, r, &req); err != nil {
writeErr(w, 400, "Invalid request format")
return
}
@@ -416,7 +416,7 @@ func (s *Server) login(w http.ResponseWriter, r *http.Request, getSetting func(s
Username string `json:"username"`
Password string `json:"password"`
}
if err := decode(r, &req); err != nil {
if err := decode(w, r, &req); err != nil {
writeErr(w, 400, "Invalid request format")
return
}
+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())
}
})
}
}
+2 -2
View File
@@ -27,7 +27,7 @@ const (
func decodeConversationRequest(w http.ResponseWriter, r *http.Request, value any) bool {
r.Body = http.MaxBytesReader(w, r.Body, maxConversationRequestBytes)
if err := decode(r, value); err != nil {
if err := decode(w, r, value); err != nil {
var tooLarge *http.MaxBytesError
if errors.As(err, &tooLarge) {
writeErr(w, http.StatusRequestEntityTooLarge, "Request body too large")
@@ -396,7 +396,7 @@ func (s *Server) pgSendConversationMessage(w http.ResponseWriter, r *http.Reques
Message string `json:"message"`
Attachments []chatAttachment `json:"attachments,omitempty"` // files uploaded via method 1 (paths relative to the conversation working dir)
}
if err := decode(r, &req); err != nil {
if err := decode(w, r, &req); err != nil {
writeErr(w, 400, err.Error())
return
}
+2 -2
View File
@@ -52,7 +52,7 @@ func (s *Server) pgCreateCustomTool(w http.ResponseWriter, r *http.Request) {
return
}
var req customToolReq
if err := decode(r, &req); err != nil {
if err := decode(w, r, &req); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -104,7 +104,7 @@ func (s *Server) pgUpdateCustomTool(w http.ResponseWriter, r *http.Request) {
return
}
var req customToolReq
if err := decode(r, &req); err != nil {
if err := decode(w, r, &req); err != nil {
writeErr(w, 400, err.Error())
return
}
+69
View File
@@ -0,0 +1,69 @@
package server
import (
"encoding/json"
"errors"
"net/http"
"net/http/httptest"
"strings"
"testing"
)
func TestDecodeAcceptsSmallBody(t *testing.T) {
w := httptest.NewRecorder()
r := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(`{"x":"ok"}`))
var v map[string]string
if err := decode(w, r, &v); err != nil || v["x"] != "ok" {
t.Fatalf("decode: %v %+v", err, v)
}
}
func TestDecodeCapsBody(t *testing.T) {
w := httptest.NewRecorder()
body := strings.NewReader(`{"x":"` + strings.Repeat("a", decodeMaxBytes) + `"}`)
r := httptest.NewRequest(http.MethodPost, "/", body)
var v map[string]string
err := decode(w, r, &v)
var tooLarge *http.MaxBytesError
if !errors.As(err, &tooLarge) {
t.Fatalf("err=%v, want the body cap", err)
}
}
func TestRawJSONBodyOverTheCapIs413(t *testing.T) {
h := limitRequestBody(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
var v map[string]string
if err := json.NewDecoder(r.Body).Decode(&v); err != nil {
writeErr(w, 400, err.Error())
return
}
writeJSON(w, 200, v)
}))
small := httptest.NewRecorder()
h.ServeHTTP(small, httptest.NewRequest(http.MethodPost, "/", strings.NewReader(`{"x":"ok"}`)))
if small.Code != 200 {
t.Fatalf("small body status=%d", small.Code)
}
large := httptest.NewRecorder()
req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(`{"x":"`+strings.Repeat("a", decodeMaxBytes)+`"}`))
h.ServeHTTP(large, req)
if large.Code != http.StatusRequestEntityTooLarge {
t.Fatalf("status=%d body=%s, want 413", large.Code, large.Body.String())
}
}
func TestMultipartBodyIsNotGivenTheJSONCap(t *testing.T) {
h := limitRequestBody(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if _, ok := r.Body.(*limitedBody); ok {
t.Errorf("multipart body was given the JSON cap")
}
w.WriteHeader(http.StatusNoContent)
}))
r := httptest.NewRequest(http.MethodPost, "/", strings.NewReader("not-read"))
r.Header.Set("Content-Type", "multipart/form-data; boundary=abc")
w := httptest.NewRecorder()
h.ServeHTTP(w, r)
if w.Code != http.StatusNoContent {
t.Fatalf("status=%d", w.Code)
}
}
+91 -4
View File
@@ -118,6 +118,7 @@ type Engine struct {
// runs under one task-scoped context. Successful deletion cancels that context,
// waits for all goroutines, then releases every task-level Engine reference.
runtimeMu sync.Mutex
draining bool
runtimes map[string]*taskRuntime
// per-task execution context: each planner.Plan / worker.Execute runs under it,
@@ -162,7 +163,7 @@ type Engine struct {
type taskRuntime struct {
ctx context.Context
cancel context.CancelFunc
cancel context.CancelCauseFunc
wg sync.WaitGroup
}
@@ -231,9 +232,12 @@ func (e *Engine) IsDeleting(taskID string) bool {
func (e *Engine) registerTaskRoutines(parent context.Context, taskID string, count int) *taskRuntime {
e.runtimeMu.Lock()
defer e.runtimeMu.Unlock()
if e.draining {
return nil
}
rt := e.runtimes[taskID]
if rt == nil {
ctx, cancel := context.WithCancel(parent)
ctx, cancel := context.WithCancelCause(parent)
rt = &taskRuntime{ctx: ctx, cancel: cancel}
e.runtimes[taskID] = rt
}
@@ -248,6 +252,61 @@ func runTaskRoutine(rt *taskRuntime, fn func(context.Context)) {
}()
}
// Wait blocks until the task goroutines registered at the moment of the call,
// and every admitted task operation, have finished, or until ctx ends. It
// refuses new registrations and new beginTaskOperation calls first. Goroutines
// that were already running are cancelled with AbortShutdown. That cancel does
// not write a terminal task status, and an in-flight intent claim stays running
// so the next start can reset it to open. Detached chat runs are not in a task
// WaitGroup; they are counted in inflight and Wait stays until they return.
func (e *Engine) Wait(ctx context.Context) error {
if e == nil {
return nil
}
e.runtimeMu.Lock()
e.draining = true
groups := make([]*sync.WaitGroup, 0, len(e.runtimes))
for _, rt := range e.runtimes {
if rt == nil {
continue
}
if rt.cancel != nil {
rt.cancel(agent.AbortShutdown)
}
groups = append(groups, &rt.wg)
}
e.runtimeMu.Unlock()
for _, wg := range groups {
if err := waitGroup(ctx, wg); err != nil {
return err
}
}
for e.inflightTotal() > 0 {
timer := time.NewTimer(20 * time.Millisecond)
select {
case <-ctx.Done():
timer.Stop()
return ctx.Err()
case <-timer.C:
}
}
return nil
}
func waitGroup(ctx context.Context, wg *sync.WaitGroup) error {
done := make(chan struct{})
go func() {
wg.Wait()
close(done)
}()
select {
case <-done:
return nil
case <-ctx.Done():
return ctx.Err()
}
}
// StopTask permanently stops every long-lived goroutine and removes all Engine
// state for a successfully deleted task. The delete barrier remains installed
// until cleanup finishes, so no new task operation can race the teardown.
@@ -260,7 +319,7 @@ func (e *Engine) StopTask(taskID string) {
e.runtimeMu.Lock()
rt := e.runtimes[taskID]
if rt != nil {
rt.cancel()
rt.cancel(agent.AbortTaskDeleted)
}
e.runtimeMu.Unlock()
if rt != nil {
@@ -664,6 +723,23 @@ func (e *Engine) emitActivity(t *Task, r db.Activity) db.Activity {
}
log.Printf("[activity] task %s dropping activity record (%d dropped for this task so far) worker=%s kind=%s tool=%s tuid=%s reason=%s summary=%q: %v%s",
t.ID, n, r.Worker, r.Kind, r.Tool, r.ToolUseID, dropReason(err), preview(r.Summary, 80), err, diag)
if t.Store != nil {
if qerr := t.Store.EnqueueActivity(r, err.Error()); qerr != nil {
log.Printf("[activity] task %s outbox: %v", t.ID, qerr)
}
}
// The row has no database id. Publish an error copy so a live session
// does not stay on "Running" while the original return value is unchanged.
notice := r
notice.IsError = true
if notice.Summary == "" {
notice.Summary = "activity was not stored"
} else {
notice.Summary += " (not stored)"
}
if e.bc != nil {
e.bc.Publish(t.ID, notice)
}
e.touch(t.ID)
return r
}
@@ -762,6 +838,10 @@ func (e *Engine) Run(ctx context.Context, t *Task) {
}
rt := e.registerTaskRoutines(ctx, t.ID, 2+workers)
e.deleteMu.RUnlock()
if rt == nil {
e.started.Delete(t.ID)
return
}
e.touch(t.ID)
runTaskRoutine(rt, func(loopCtx context.Context) { e.plannerLoop(loopCtx, t) })
runTaskRoutine(rt, func(loopCtx context.Context) { e.claimSweepLoop(loopCtx, t) })
@@ -1266,6 +1346,13 @@ func (e *Engine) runIntent(ctx context.Context, t *Task, name string, worker *ag
e.touch(t.ID)
return true
}
// Process shutdown cancels the task context. Leave the claim running: AbortShutdown
// says restart resets leftover running intents to open. Settling done or blocked
// here would make that reset miss the intent, so the task would resume without it.
if ectx.Err() != nil && errors.Is(context.Cause(ectx), agent.AbortShutdown) {
log.Printf("[worker %s] task %s intent #%d shutdown: leaving the claim running", name, t.ID, intent.ID)
return true
}
// killed by the planner: mark stopped (don't write back results, don't auto-reclaim).
if killed {
if err := t.Store.SettleIntentClaim(intent.ID, token, "stopped"); err != nil {
@@ -1324,7 +1411,7 @@ func (e *Engine) runIntent(ctx context.Context, t *Task, name string, worker *ag
// be started; the intent is left untouched in that case.
func (e *Engine) runDetachedIntent(ctx context.Context, t *Task, intentID int64, requestID, message, agentMessage string) error {
if !e.beginTaskOperation(t.ID) {
return fmt.Errorf("task is being deleted")
return fmt.Errorf("task is not accepting work")
}
release := true
defer func() {
+30 -2
View File
@@ -17,8 +17,36 @@ func (e *Engine) budgetFor(taskID string) *agent.BudgetLedger {
if v, ok := e.budgets.Load(taskID); ok {
return v.(*agent.BudgetLedger)
}
v, _ := e.budgets.LoadOrStore(taskID, agent.NewBudgetLedger(agent.BudgetsFromEnv()))
return v.(*agent.BudgetLedger)
created := agent.NewBudgetLedger(agent.BudgetsFromEnv())
e.seedBudget(taskID, created)
v, loaded := e.budgets.LoadOrStore(taskID, created)
if loaded {
return v.(*agent.BudgetLedger)
}
return created
}
// seedBudget rebuilds spent tokens and turns from llm_usage for every new
// ledger. budgetFor calls it on first use, and again after resetSettledRun or
// StopTask deletes the ledger in this same process. The in-memory sink runs
// before the row is inserted, so a call that happens after this seed is
// counted once. A nil ledger means no budget is configured and nothing is read.
// The restore does not rebuild per-worker averages, so the next worker estimate
// starts from the defaults until a worker finishes against this ledger.
func (e *Engine) seedBudget(taskID string, ledger *agent.BudgetLedger) {
if ledger == nil || e == nil || e.m == nil || e.m.pg == nil || taskID == "" {
return
}
tokens, turns, err := e.m.pg.TaskLLMSpend(taskID)
if err != nil {
log.Printf("[budget] task %s: cannot restore spend from llm_usage: %v", taskID, err)
return
}
if tokens == 0 && turns == 0 {
return
}
ledger.RestoreSpend(agent.Spend{Tokens: tokens, Turns: turns})
log.Printf("[budget] task %s restored %d tokens / %d turns from llm_usage", taskID, tokens, turns)
}
// budgetStop is the enforcement point of a planner round: it logs the remaining
+64
View File
@@ -2,9 +2,12 @@ package server
import (
"context"
"strconv"
"testing"
"time"
"github.com/Autumn-27/artex/agent"
pgdb "github.com/Autumn-27/artex/db"
"github.com/Autumn-27/norma/llm"
)
@@ -67,3 +70,64 @@ func TestResetSettledRunRestartsBudget(t *testing.T) {
t.Fatalf("revived run: ledger not fresh, spent %d tokens", got)
}
}
// With Postgres, resetSettledRun drops the ledger and the next one is seeded
// again from llm_usage. In-memory spend that was never written does not come
// back. A restore that lands on the wrap-up reserve leaves only that reserve,
// and the worker estimate starts from the defaults.
func TestResetSettledRunReseedsBudgetFromUsage(t *testing.T) {
for _, k := range []string{"ARTEX_TASK_BUDGET_TURNS", "ARTEX_INTENT_BUDGET_TOKENS", "ARTEX_INTENT_BUDGET_TURNS"} {
t.Setenv(k, "")
}
t.Setenv("ARTEX_TASK_BUDGET_TOKENS", "100000")
m, err := NewManager(t.TempDir(), "")
if err != nil {
t.Skipf("postgres unavailable (%v)", err)
}
defer m.Close()
taskID := strconv.FormatInt(time.Now().UnixNano(), 10)
t.Cleanup(func() {
_, _ = m.pg.Exec(`DELETE FROM llm_usage WHERE task_id=$1`, taskID)
})
// 100000 - wrap-up reserve (max(5%, 20000)) = 80000. One planner row.
if err := m.pg.InsertLLMUsage(&pgdb.LLMUsage{
TaskID: taskID, Worker: "planner", InputTokens: 80_000, Status: "ok",
}); err != nil {
t.Fatal(err)
}
e := NewEngine(m)
task := &Task{ID: taskID}
l := e.budgetFor(task.ID)
st := l.State()
if st.Spent.Tokens != 80_000 || st.Spent.Turns != 1 {
t.Fatalf("seed spent=%+v, want 80000 tokens and 1 turn", st.Spent)
}
if st.Remaining.Tokens != st.Margin.Tokens || !st.AtMargin || st.Dispatch {
t.Fatalf("restored task near the cap: remaining=%d margin=%d at=%v dispatch=%v",
st.Remaining.Tokens, st.Margin.Tokens, st.AtMargin, st.Dispatch)
}
if st.Estimate.Tokens != agent.DefaultWorkerEstimateTokens || st.Estimate.Turns != agent.DefaultWorkerEstimateTurns {
t.Fatalf("estimate=%+v, want the defaults (worker history is not restored)", st.Estimate)
}
l.Record(llm.Usage{InputTokens: 1000})
l.BeginWrapup()
e.settling.Store(task.ID, true)
e.resetSettledRun(task.ID)
if e.isSettling(task.ID) {
t.Fatal("revived run is still marked settling")
}
again := e.budgetFor(task.ID)
if again == l {
t.Fatal("revive reused the deleted ledger")
}
got := again.State()
if got.Spent.Tokens != 80_000 || got.Spent.Turns != 1 {
t.Fatalf("reseed spent=%+v, want the usage row and not the in-memory extra", got.Spent)
}
if got.Remaining.Tokens != got.Margin.Tokens || got.Dispatch {
t.Fatalf("reseed still past the wrap-up margin: remaining=%d margin=%d dispatch=%v",
got.Remaining.Tokens, got.Margin.Tokens, got.Dispatch)
}
}
+54
View File
@@ -9,6 +9,60 @@ import (
"github.com/Autumn-27/artex/agent"
)
func TestWaitBlocksUntilDetachedInflightEnds(t *testing.T) {
e := NewEngine(nil)
if !e.beginTaskOperation("t1") {
t.Fatal("detached work was not admitted")
}
release := make(chan struct{})
finished := make(chan struct{})
go func() {
<-release
e.decInflight("t1")
close(finished)
}()
done := make(chan error, 1)
go func() { done <- e.Wait(context.Background()) }()
select {
case err := <-done:
t.Fatalf("Wait returned while the detached operation was still running: %v", err)
case <-time.After(80 * time.Millisecond):
}
if e.beginTaskOperation("t1") {
t.Fatal("Wait admitted new work while draining")
}
close(release)
<-finished
select {
case err := <-done:
if err != nil {
t.Fatal(err)
}
case <-time.After(time.Second):
t.Fatal("Wait did not return after the detached operation ended")
}
}
func TestWaitCancelsRuntimeWithShutdown(t *testing.T) {
e := NewEngine(nil)
rt := e.registerTaskRoutines(context.Background(), "t1", 1)
if rt == nil {
t.Fatal("runtime was not registered")
}
started := make(chan struct{})
runTaskRoutine(rt, func(ctx context.Context) {
close(started)
<-ctx.Done()
})
<-started
if err := e.Wait(context.Background()); err != nil {
t.Fatal(err)
}
if !errors.Is(context.Cause(rt.ctx), agent.AbortShutdown) {
t.Fatalf("cause=%v, want shutdown", context.Cause(rt.ctx))
}
}
func TestPauseCancelsWithNamedCause(t *testing.T) {
e := NewEngine(nil)
execCtx := e.execContextFor(context.Background(), "t1")
+25 -3
View File
@@ -46,14 +46,20 @@ func (e *Engine) inflightCounter(taskID string) *int64 {
}
// beginTaskOperation atomically registers a task-owned operation unless deletion
// has already installed its barrier. The delete handler can therefore wait for
// inflight==0 without a check-then-start race recreating files after cleanup.
// has already installed its barrier, or the engine is draining for shutdown.
// The delete handler and Wait can therefore wait for inflight==0 without a
// check-then-start race admitting work that outlives the drain.
func (e *Engine) beginTaskOperation(taskID string) bool {
e.deleteMu.RLock()
defer e.deleteMu.RUnlock()
if e.IsDeleting(taskID) {
return false
}
e.runtimeMu.Lock()
defer e.runtimeMu.Unlock()
if e.draining {
return false
}
atomic.AddInt64(e.inflightCounter(taskID), 1)
return true
}
@@ -63,6 +69,17 @@ func (e *Engine) inflightCount(taskID string) int64 {
return atomic.LoadInt64(e.inflightCounter(taskID))
}
// inflightTotal is the sum of every task's admitted operations, including
// detached chat runs that are not members of a task WaitGroup.
func (e *Engine) inflightTotal() int64 {
var n int64
e.inflight.Range(func(_, v any) bool {
n += atomic.LoadInt64(v.(*int64))
return true
})
return n
}
// ---------- deadline ----------
// taskDeadline returns the task's absolute deadline (unix). Prefers the in-process
@@ -93,7 +110,8 @@ func (e *Engine) resetTimeoutRevival(taskID string) {
}
// resetSettledRun clears the settle state of a finished run (settling and the
// budget ledger) so a revived task can plan and claim again with a fresh budget.
// budget ledger) so a revived task can plan and claim again. The next ledger
// is seeded from llm_usage, so the spend already recorded still counts.
// It also clears the persisted end_reason of the previous run (ApplyTaskAdmission
// already did in the same UPDATE as the revive; this is idempotent and never
// touches a task that is terminal again).
@@ -161,6 +179,10 @@ func (e *Engine) startDeadlineCoordinator(ctx context.Context, t *Task) {
}
rt := e.registerTaskRoutines(ctx, t.ID, 1)
e.deleteMu.RUnlock()
if rt == nil {
e.coordStarted.Delete(t.ID)
return
}
runTaskRoutine(rt, func(loopCtx context.Context) { e.deadlineCoordinator(loopCtx, t) })
}
+10
View File
@@ -29,6 +29,16 @@ func (s *Server) seedFindingWorkflowTools() {
_ = s.m.pg.SetSetting(hostSearchDescriptionFlag, "true")
}
}
const getRewriteDescriptionFlag = "traffic_get_rewrite_description_v1"
if value, _, _ := s.m.pg.GetSetting(getRewriteDescriptionFlag); value != "true" {
// Same rule: only the original built-in text is replaced.
legacy := "Fetch the raw request/response of one captured traffic record by id (truncated when too large). Use together with traffic_search to avoid re-curling. A WebSocket (status 101) or SSE (text/event-stream) record shows only its handshake here; read its messages with traffic_messages."
if _, err := s.m.pg.Exec(`UPDATE tools SET description=$1,updated_at=now() WHERE key='traffic_get' AND system AND description=$2`, traffic.TrafficGetDescription, legacy); err != nil {
log.Printf("[evidence] upgrade traffic_get description: %v", err)
} else {
_ = s.m.pg.SetSetting(getRewriteDescriptionFlag, "true")
}
}
const flag = "finding_workflow_tools_v2_reporter"
if value, _, _ := s.m.pg.GetSetting(flag); value == "true" {
return
+8 -8
View File
@@ -141,7 +141,7 @@ func (s *Server) interceptCreateRule(w http.ResponseWriter, r *http.Request) {
return
}
var req interceptRuleReq
if err := decode(r, &req); err != nil {
if err := decode(w, r, &req); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -169,7 +169,7 @@ func (s *Server) interceptUpdateRule(w http.ResponseWriter, r *http.Request) {
return
}
var req interceptRuleReq
if err := decode(r, &req); err != nil {
if err := decode(w, r, &req); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -217,7 +217,7 @@ func (s *Server) interceptToggleRule(w http.ResponseWriter, r *http.Request) {
var req struct {
Enabled bool `json:"enabled"`
}
if err := decode(r, &req); err != nil {
if err := decode(w, r, &req); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -400,7 +400,7 @@ func (s *Server) interceptDecide(w http.ResponseWriter, r *http.Request) {
var req struct {
Decision string `json:"decision"` // "allowed" | "denied"
}
if err := decode(r, &req); err != nil {
if err := decode(w, r, &req); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -445,7 +445,7 @@ func (s *Server) interceptBatchDecide(w http.ResponseWriter, r *http.Request) {
IDs []int64 `json:"ids"`
Decision string `json:"decision"` // "allowed" | "denied"
}
if err := decode(r, &req); err != nil {
if err := decode(w, r, &req); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -647,7 +647,7 @@ func (s *Server) targetGateSetExemptions(w http.ResponseWriter, r *http.Request)
var req struct {
Exemptions []db.TargetExemption `json:"exemptions"`
}
if err := decode(r, &req); err != nil {
if err := decode(w, r, &req); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -697,7 +697,7 @@ func (s *Server) interceptSetToolConfig(w http.ResponseWriter, r *http.Request)
var req struct {
EnabledTools []string `json:"enabled_tools"`
}
if err := decode(r, &req); err != nil {
if err := decode(w, r, &req); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -722,7 +722,7 @@ func (s *Server) interceptGetJudgeConfig(w http.ResponseWriter, r *http.Request)
// interceptSetJudgeConfig persists the judge configuration.
func (s *Server) interceptSetJudgeConfig(w http.ResponseWriter, r *http.Request) {
var req intercept.JudgeConfig
if err := decode(r, &req); err != nil {
if err := decode(w, r, &req); err != nil {
writeErr(w, 400, err.Error())
return
}
+3 -6
View File
@@ -52,7 +52,7 @@ func (s *Server) wireTaskLessons(t *Task, wk *agent.Worker, pl *agent.Planner) {
log.Printf("[rsi] lesson selection failed for task %s: %v", t.ID, err)
return
}
block := db.RenderLessons(lessons, 1800)
block, ids := db.RenderLessons(lessons, 1800)
if block == "" {
return
}
@@ -60,10 +60,6 @@ func (s *Server) wireTaskLessons(t *Task, wk *agent.Worker, pl *agent.Planner) {
wk.SetLessonsBlock(block)
pl.SetLessonsBlock(block)
}
ids := make([]int64, 0, len(lessons))
for _, l := range lessons {
ids = append(ids, l.ID)
}
if err := s.m.PG().LogLessonUsage(context.Background(), taskID, ids, mode); err != nil {
log.Printf("[rsi] lesson usage log failed for task %s: %v", t.ID, err)
}
@@ -87,10 +83,11 @@ func (s *Server) taskLessons(w http.ResponseWriter, r *http.Request) {
writeErr(w, 500, "lesson query failed")
return
}
block, _ := db.RenderLessons(lessons, 1800)
writeJSON(w, 200, map[string]any{
"mode": rsiLessonsMode(),
"lessons": lessons,
"block": db.RenderLessons(lessons, 1800),
"block": block,
"count": len(lessons),
})
}
+203 -16
View File
@@ -1,7 +1,9 @@
package server
import (
"context"
"log"
"sync"
"time"
"github.com/Autumn-27/artex/agent"
@@ -17,26 +19,19 @@ import (
// - Circuit-breaker state is process-wide (s.llmHealth); rebuilding the pool does not clear it.
// newLLMHealthRegistry builds the process-wide circuit-breaker registry, mirroring
// state into PG so a cooling-off window survives a restart. Writes are async and
// best-effort — the in-memory copy is authoritative.
func newLLMHealthRegistry(pg *db.DB) *llmpool.Registry {
// state into PG so a cooling-off window survives a restart. Writes are async.
// The in-memory copy is authoritative. The returned syncer is nil when there is
// no database; otherwise it flushes when ctx is cancelled.
func newLLMHealthRegistry(ctx context.Context, pg *db.DB) (*llmpool.Registry, *healthSync) {
if pg == nil {
return llmpool.NewRegistry(nil, nil)
return llmpool.NewRegistry(nil, nil), nil
}
syncer := newHealthSync(ctx, pg.SaveLLMHealth, pg.ClearLLMHealth)
persist := func(id int64, st llmpool.State) {
h := db.LLMHealth{ProfileID: id, Fails: st.Fails, Trips: st.Trips, LastError: st.LastError}
if !st.OpenUntil.IsZero() {
t := st.OpenUntil
h.OpenUntil = &t
}
go func() {
if err := pg.SaveLLMHealth(h); err != nil {
log.Printf("[llmpool] failed to persist circuit-breaker state: %v", err)
}
}()
syncer.enqueue(id, healthOp{st: st})
}
forget := func(id int64) {
go func() { _ = pg.ClearLLMHealth(id) }()
syncer.enqueue(id, healthOp{clear: true})
}
reg := llmpool.NewRegistry(persist, forget)
// Restore only windows that haven't expired (LoadLLMHealth filters), so a
@@ -51,7 +46,199 @@ func newLLMHealthRegistry(pg *db.DB) *llmpool.Registry {
log.Printf("[llmpool] restored circuit-breaker state: profile #%d cooling until %s", h.ProfileID, st.OpenUntil.Format(time.RFC3339))
}
}
return reg
return reg, syncer
}
// healthOp is one circuit-breaker write for a profile. clear drops the row.
// seq orders writes for that profile: a newer op wins over one still in flight.
type healthOp struct {
seq uint64
clear bool
st llmpool.State
}
// healthSync writes circuit-breaker state from one goroutine. A newer update for
// the same profile replaces one that has not been written yet, so a burst of
// state changes becomes one database call. The database call runs without mu,
// so enqueue does not wait on a slow write. writeMu keeps those calls in order.
// Before each call, an op that is already older than the applied or pending
// sequence is dropped. save and clear must not call enqueue.
type healthSync struct {
save func(db.LLMHealth) error
clear func(int64) error
retryAfter time.Duration // tests set a short delay; zero uses one second
mu sync.Mutex
writeMu sync.Mutex // orders database calls; enqueue does not take it
pending map[int64]healthOp
applied map[int64]uint64
seq uint64
stopped bool
wake chan struct{}
done chan struct{}
}
func newHealthSync(ctx context.Context, save func(db.LLMHealth) error, clear func(int64) error) *healthSync {
if ctx == nil {
ctx = context.Background()
}
h := &healthSync{
save: save,
clear: clear,
pending: map[int64]healthOp{},
applied: map[int64]uint64{},
wake: make(chan struct{}, 1),
done: make(chan struct{}),
}
go h.loop(ctx)
return h
}
// FlushLLMHealth waits until the circuit-breaker writer has flushed the ops
// queued before shutdown. Call it after the server context is cancelled and
// before the database closes.
func (s *Server) FlushLLMHealth() {
if s == nil || s.llmHealthSync == nil {
return
}
select {
case <-s.llmHealthSync.done:
case <-time.After(5 * time.Second):
log.Printf("[llmpool] timed out flushing circuit-breaker state")
}
}
func (h *healthSync) enqueue(id int64, op healthOp) {
h.mu.Lock()
h.seq++
op.seq = h.seq
if h.stopped {
h.mu.Unlock()
if err := h.apply(id, op); err != nil {
log.Printf("[llmpool] write circuit-breaker profile #%d: %v", id, err)
}
return
}
if prev, ok := h.pending[id]; ok && prev.seq > op.seq {
h.mu.Unlock()
return
}
h.pending[id] = op
h.mu.Unlock()
select {
case h.wake <- struct{}{}:
default:
}
}
func (h *healthSync) take() map[int64]healthOp {
h.mu.Lock()
defer h.mu.Unlock()
if len(h.pending) == 0 {
return nil
}
out := h.pending
h.pending = map[int64]healthOp{}
return out
}
func (h *healthSync) restore(id int64, op healthOp) {
h.mu.Lock()
defer h.mu.Unlock()
if h.stopped || h.applied[id] >= op.seq {
return
}
if cur, ok := h.pending[id]; ok && cur.seq >= op.seq {
return
}
h.pending[id] = op
}
// superseded reports whether a newer op for id is already applied or waiting.
// The caller holds writeMu, so the decision and the database call stay in order.
func (h *healthSync) superseded(id int64, seq uint64) bool {
h.mu.Lock()
defer h.mu.Unlock()
if seq > 0 && h.applied[id] >= seq {
return true
}
cur, ok := h.pending[id]
return ok && cur.seq > seq
}
func (h *healthSync) apply(id int64, op healthOp) error {
h.writeMu.Lock()
defer h.writeMu.Unlock()
if h.superseded(id, op.seq) {
return nil
}
var err error
if op.clear {
if h.clear != nil {
err = h.clear(id)
}
} else if h.save != nil {
row := db.LLMHealth{ProfileID: id, Fails: op.st.Fails, Trips: op.st.Trips, LastError: op.st.LastError}
if !op.st.OpenUntil.IsZero() {
openUntil := op.st.OpenUntil
row.OpenUntil = &openUntil
}
err = h.save(row)
}
if err != nil {
return err
}
h.mu.Lock()
if h.applied[id] < op.seq {
h.applied[id] = op.seq
}
h.mu.Unlock()
return nil
}
func (h *healthSync) write(batch map[int64]healthOp) (failed bool) {
for id, op := range batch {
if err := h.apply(id, op); err != nil {
log.Printf("[llmpool] write circuit-breaker profile #%d: %v", id, err)
h.restore(id, op)
failed = true
}
}
return failed
}
func (h *healthSync) finish() {
h.mu.Lock()
h.stopped = true
batch := h.pending
h.pending = map[int64]healthOp{}
h.mu.Unlock()
for id, op := range batch {
if err := h.apply(id, op); err != nil {
log.Printf("[llmpool] write circuit-breaker profile #%d: %v", id, err)
}
}
}
func (h *healthSync) loop(ctx context.Context) {
defer close(h.done)
for {
failed := h.write(h.take())
delay := h.retryAfter
if delay <= 0 {
delay = time.Second
}
var retry <-chan time.Time
if failed {
retry = time.After(delay)
}
select {
case <-ctx.Done():
h.finish()
return
case <-h.wake:
case <-retry:
}
}
}
// poolMember builds one chain member from a profile, reusing the per-profile
+183
View File
@@ -0,0 +1,183 @@
package server
import (
"context"
"errors"
"sync"
"testing"
"time"
"github.com/Autumn-27/artex/db"
"github.com/Autumn-27/artex/llmpool"
)
func TestHealthSyncLoopWritesLatest(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
var mu sync.Mutex
saved := map[int64]db.LLMHealth{}
cleared := map[int64]int{}
savedCh := make(chan struct{}, 4)
clearedCh := make(chan struct{}, 4)
h := newHealthSync(ctx,
func(row db.LLMHealth) error {
mu.Lock()
saved[row.ProfileID] = row
mu.Unlock()
savedCh <- struct{}{}
return nil
},
func(id int64) error {
mu.Lock()
cleared[id]++
delete(saved, id)
mu.Unlock()
clearedCh <- struct{}{}
return nil
},
)
openUntil := time.Now().Add(time.Minute).UTC().Truncate(time.Second)
h.enqueue(8, healthOp{st: llmpool.State{Fails: 1, LastError: "first"}})
h.enqueue(8, healthOp{st: llmpool.State{Fails: 4, Trips: 1, OpenUntil: openUntil, LastError: "down"}})
deadline := time.After(2 * time.Second)
var latest db.LLMHealth
for {
mu.Lock()
latest = saved[8]
mu.Unlock()
if latest.Fails == 4 && latest.OpenUntil != nil && latest.OpenUntil.Equal(openUntil) {
break
}
select {
case <-savedCh:
case <-deadline:
t.Fatalf("loop saved=%+v, want the latest trip", latest)
}
}
h.enqueue(7, healthOp{clear: true})
select {
case <-clearedCh:
case <-time.After(2 * time.Second):
t.Fatal("loop did not clear")
}
mu.Lock()
defer mu.Unlock()
got := saved[8]
if got.Fails != 4 || got.Trips != 1 || got.LastError != "down" || got.OpenUntil == nil || !got.OpenUntil.Equal(openUntil) {
t.Fatalf("saved=%+v, want the latest trip including OpenUntil", got)
}
if cleared[7] != 1 {
t.Fatalf("cleared=%v", cleared)
}
}
func TestHealthSyncRetriesFailedSave(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
var mu sync.Mutex
calls := 0
done := make(chan struct{})
h := newHealthSync(ctx,
func(row db.LLMHealth) error {
mu.Lock()
calls++
n := calls
mu.Unlock()
if n == 1 {
return errors.New("database down")
}
if n == 2 {
close(done)
}
return nil
},
func(int64) error { return nil },
)
h.retryAfter = 20 * time.Millisecond
h.enqueue(3, healthOp{st: llmpool.State{Fails: 2, LastError: "blip"}})
select {
case <-done:
case <-time.After(2 * time.Second):
t.Fatal("failed save was not retried")
}
mu.Lock()
defer mu.Unlock()
if calls < 2 {
t.Fatalf("save calls=%d, want a retry", calls)
}
}
func TestHealthSyncEnqueueDoesNotWaitOnSave(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
started := make(chan struct{})
release := make(chan struct{})
later := make(chan struct{})
h := newHealthSync(ctx,
func(row db.LLMHealth) error {
if row.Fails == 1 {
close(started)
<-release
return nil
}
if row.Fails == 9 {
close(later)
}
return nil
},
func(int64) error { return nil },
)
h.enqueue(4, healthOp{st: llmpool.State{Fails: 1}})
select {
case <-started:
case <-time.After(2 * time.Second):
t.Fatal("save did not start")
}
done := make(chan struct{})
go func() {
h.enqueue(4, healthOp{st: llmpool.State{Fails: 9, LastError: "later"}})
close(done)
}()
select {
case <-done:
case <-time.After(200 * time.Millisecond):
t.Fatal("enqueue blocked while a save was in flight")
}
close(release)
select {
case <-later:
case <-time.After(2 * time.Second):
t.Fatal("the later state was not written")
}
}
func TestHealthSyncDropsStaleWrite(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
writes := 0
h := newHealthSync(ctx,
func(db.LLMHealth) error {
writes++
return nil
},
func(int64) error { return nil },
)
h.mu.Lock()
h.seq = 4
h.applied[5] = 2
h.pending[6] = healthOp{seq: 4, clear: true}
h.mu.Unlock()
if err := h.apply(5, healthOp{seq: 1, st: llmpool.State{Fails: 1}}); err != nil {
t.Fatal(err)
}
if err := h.apply(6, healthOp{seq: 3, st: llmpool.State{Fails: 3}}); err != nil {
t.Fatal(err)
}
if writes != 0 {
t.Fatalf("stale writes=%d", writes)
}
}
+95 -5
View File
@@ -117,7 +117,9 @@ type Server struct {
// It deliberately lives OUTSIDE the provider caches: rebuilding the chain
// (saving an unrelated profile, flipping a setting) must not erase what we
// learned about which backends are out of credit / rate-limited.
llmHealth *llmpool.Registry
// llmHealthSync flushes that state when ctx is cancelled, before the database closes.
llmHealth *llmpool.Registry
llmHealthSync *healthSync
// Explicit task chains use one task-scoped dynamic provider shared by goals,
// planner, workers, and the main agent. Bundles are stable; their runtime reads
@@ -163,9 +165,10 @@ func New(ctx context.Context, m *Manager, skillDir string, dataDir string, keyDi
chatCancel: map[string]context.CancelCauseFunc{}, triggerQ: map[string][]triggeredRun{},
triggerActive: map[string]int{}, triggerCfg: map[string]triggerBehavior{},
profChatAgents: map[int64]*agent.ChatAgent{},
provByProfile: map[int64]*provEntry{}, llmHealth: newLLMHealthRegistry(m.pg),
taskAgents: map[string]*taskAgentBundle{}, archiveWake: make(chan struct{}, 1),
provByProfile: map[int64]*provEntry{},
taskAgents: map[string]*taskAgentBundle{}, archiveWake: make(chan struct{}, 1),
loginLimit: newLoginLimiter(time.Now)}
s.llmHealth, s.llmHealthSync = newLLMHealthRegistry(ctx, m.pg)
for _, o := range opts {
o(s)
}
@@ -296,9 +299,16 @@ func (s *Server) restoreTaskRuntimes() {
lifecycle := t.lifecycleSnapshot()
// clear stale 'running' intents from a prior crash/restart (no live worker
// owns them) so they re-claim instead of spinning forever in the UI.
if n, _ := t.Store.ResetRunningIntents(); n > 0 {
if n, err := t.Store.ResetRunningIntents(); err != nil {
log.Printf("[engine] task %s reset leftover running intents: %v", t.ID, err)
} else if n > 0 {
log.Printf("[engine] task %s reset %d leftover running intents to open", t.ID, n)
}
if n, err := t.Store.FlushActivityOutbox(); err != nil {
log.Printf("[activity] task %s outbox: %v", t.ID, err)
} else if n > 0 {
log.Printf("[activity] task %s stored %d activities recovered from the outbox", t.ID, n)
}
if lifecycle.Paused {
s.engine.Pause(t.ID, agent.AbortPausedOnReload)
}
@@ -320,6 +330,30 @@ func (s *Server) restoreTaskRuntimes() {
}
}
// Wait blocks until the task goroutines snapshotted now, and the archive
// worker, have finished, or until ctx ends.
func (s *Server) Wait(ctx context.Context) error {
if s == nil {
return nil
}
if s.engine != nil {
if err := s.engine.Wait(ctx); err != nil {
return err
}
}
done := make(chan struct{})
go func() {
s.archiveWG.Wait()
close(done)
}()
select {
case <-done:
return nil
case <-ctx.Done():
return ctx.Err()
}
}
// agentMaxTurns returns the configured max_turns for an agent key (0 = unlimited,
// also the fallback when no DB or no row).
func (s *Server) agentMaxTurns(key string) int {
@@ -801,6 +835,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)
@@ -992,7 +1027,7 @@ func (s *Server) Handler() http.Handler {
root := http.NewServeMux()
root.Handle("/api/", api)
root.Handle("/", s.webuiHandler())
return root
return limitRequestBody(root)
}
// --- handlers ---
@@ -2565,6 +2600,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) {
+103 -22
View File
@@ -9,6 +9,7 @@ import (
"fmt"
"io"
"log"
"mime"
"net/http"
"net/url"
"os"
@@ -79,7 +80,87 @@ func pathInt(r *http.Request, name string) (int64, bool) {
return n, err == nil
}
func decode(r *http.Request, v any) error { return json.NewDecoder(r.Body).Decode(v) }
// decodeMaxBytes is the default JSON body cap. Multipart uploads are not capped
// here; those handlers set their own limit. A smaller MaxBytesReader installed
// by a handler still wins, because it sits inside this one.
const decodeMaxBytes = 32 << 20
// limitedBody records a MaxBytesError so a later 400 can be answered as 413.
type limitedBody struct {
io.ReadCloser
tooLarge bool
}
func (b *limitedBody) Read(p []byte) (int, error) {
n, err := b.ReadCloser.Read(p)
var tooLarge *http.MaxBytesError
if errors.As(err, &tooLarge) {
b.tooLarge = true
}
return n, err
}
type bodyLimitWriter struct {
http.ResponseWriter
tooLarge func() bool
}
func (b *bodyLimitWriter) WriteHeader(code int) {
if code == http.StatusBadRequest && b.tooLarge != nil && b.tooLarge() {
code = http.StatusRequestEntityTooLarge
}
b.ResponseWriter.WriteHeader(code)
}
func (b *bodyLimitWriter) Flush() {
if f, ok := b.ResponseWriter.(http.Flusher); ok {
f.Flush()
}
}
func (b *bodyLimitWriter) Unwrap() http.ResponseWriter { return b.ResponseWriter }
// limitRequestBody caps a non-multipart body at decodeMaxBytes and passes the
// real ResponseWriter into MaxBytesReader. A handler that then answers 400 for
// that read is rewritten to 413.
func limitRequestBody(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Body == nil || r.Body == http.NoBody || isMultipart(r) {
next.ServeHTTP(w, r)
return
}
body := &limitedBody{ReadCloser: http.MaxBytesReader(w, r.Body, decodeMaxBytes)}
r.Body = body
next.ServeHTTP(&bodyLimitWriter{ResponseWriter: w, tooLarge: func() bool { return body.tooLarge }}, r)
})
}
func isMultipart(r *http.Request) bool {
media, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
if err != nil {
return false
}
return strings.HasPrefix(media, "multipart/")
}
func decode(w http.ResponseWriter, r *http.Request, v any) error {
if r.Body != nil {
if _, already := r.Body.(*limitedBody); !already {
r.Body = &limitedBody{ReadCloser: http.MaxBytesReader(w, r.Body, decodeMaxBytes)}
}
}
err := json.NewDecoder(r.Body).Decode(v)
var tooLarge *http.MaxBytesError
if errors.As(err, &tooLarge) {
if lb, ok := r.Body.(*limitedBody); ok {
lb.tooLarge = true
}
// Return the original error: a caller that maps 413 itself keeps working,
// and the middleware still rewrites a 400 for callers that do not.
return tooLarge
}
return err
}
// ---------- tasks (delete) ----------
@@ -138,7 +219,7 @@ func (s *Server) pgDeleteTask(w http.ResponseWriter, r *http.Request) {
return
}
var opts DeleteTaskOptions
if err := decode(r, &opts); err != nil && err != io.EOF {
if err := decode(w, r, &opts); err != nil && err != io.EOF {
writeErr(w, 400, "invalid JSON: "+err.Error())
return
}
@@ -250,7 +331,7 @@ func (s *Server) pgCreateAgent(w http.ResponseWriter, r *http.Request) {
return
}
var req struct{ Key, Name, Description string }
if err := decode(r, &req); err != nil {
if err := decode(w, r, &req); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -290,7 +371,7 @@ func (s *Server) pgUpdateAgent(w http.ResponseWriter, r *http.Request) {
return
}
var req struct{ Name, Description string }
if err := decode(r, &req); err != nil {
if err := decode(w, r, &req); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -516,7 +597,7 @@ func (s *Server) pgSavePrompt(w http.ResponseWriter, r *http.Request) {
return
}
var body struct{ Template, Note string }
if err := decode(r, &body); err != nil {
if err := decode(w, r, &body); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -565,7 +646,7 @@ func (s *Server) pgSaveWrapup(w http.ResponseWriter, r *http.Request) {
Prompt string `json:"prompt"`
MaxTurns *int `json:"max_turns"`
}
if err := decode(r, &body); err != nil {
if err := decode(w, r, &body); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -619,7 +700,7 @@ func (s *Server) pgSaveTaskTimeoutWrapup(w http.ResponseWriter, r *http.Request)
Prompt string `json:"prompt"`
MaxTurns *int `json:"max_turns"`
}
if err := decode(r, &body); err != nil {
if err := decode(w, r, &body); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -689,7 +770,7 @@ func (s *Server) pgPreviewPrompt(w http.ResponseWriter, r *http.Request) {
Template string `json:"template"`
Sample map[string]string `json:"sample"`
}
_ = decode(r, &body)
_ = decode(w, r, &body)
vars, _ := pg.PromptVars(a.ID)
if body.Template == "" {
body.Template, _ = pg.CurrentPrompt(a.ID)
@@ -724,7 +805,7 @@ func (s *Server) pgSetAgentVisibility(w http.ResponseWriter, r *http.Request) {
MCP []int64 `json:"mcp"`
Skill []string `json:"skill"`
}
if err := decode(r, &body); err != nil {
if err := decode(w, r, &body); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -797,7 +878,7 @@ func (s *Server) pgUpdateTool(w http.ResponseWriter, r *http.Request) {
Agents []string `json:"agents"`
Enabled bool `json:"enabled"`
}
if err := decode(r, &body); err != nil {
if err := decode(w, r, &body); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -963,7 +1044,7 @@ func (s *Server) pgSaveMCP(w http.ResponseWriter, r *http.Request) {
return
}
var m db.MCPServer
if err := decode(r, &m); err != nil {
if err := decode(w, r, &m); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -1182,7 +1263,7 @@ func (s *Server) fsCreateSkill(w http.ResponseWriter, r *http.Request) {
MCPs []string `json:"mcps"` // optional; MCP servers this skill unlocks
Instructions string `json:"instructions"` // optional; scaffolded if empty
}
if err := decode(r, &body); err != nil {
if err := decode(w, r, &body); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -1267,7 +1348,7 @@ func (s *Server) fsUpdateSkillMeta(w http.ResponseWriter, r *http.Request) {
License *string `json:"license"`
Compatibility *string `json:"compatibility"`
}
if err := decode(r, &body); err != nil {
if err := decode(w, r, &body); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -1788,7 +1869,7 @@ func (s *Server) fsWriteFile(w http.ResponseWriter, r *http.Request) {
var body struct {
Content string `json:"content"`
}
if err := decode(r, &body); err != nil {
if err := decode(w, r, &body); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -1819,7 +1900,7 @@ func (s *Server) fsCreateDir(w http.ResponseWriter, r *http.Request) {
var body struct {
Path string `json:"path"`
}
if err := decode(r, &body); err != nil {
if err := decode(w, r, &body); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -1888,7 +1969,7 @@ func (s *Server) pgToggleSkillVisibility(w http.ResponseWriter, r *http.Request)
SkillName string `json:"skill_name"`
Visible bool `json:"visible"`
}
if err := decode(r, &body); err != nil {
if err := decode(w, r, &body); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -1926,7 +2007,7 @@ func (s *Server) pgToggleVisibility(w http.ResponseWriter, r *http.Request) {
ResourceID int64 `json:"resource_id"`
Visible bool `json:"visible"`
}
if err := decode(r, &body); err != nil {
if err := decode(w, r, &body); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -1967,7 +2048,7 @@ func (s *Server) pgSaveProfile(w http.ResponseWriter, r *http.Request) {
APIKey string `json:"api_key"`
Streaming *bool `json:"streaming"`
}
if err := decode(r, &body); err != nil {
if err := decode(w, r, &body); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -2036,7 +2117,7 @@ func (s *Server) pgSaveLLMRetryPolicy(w http.ResponseWriter, r *http.Request) {
return
}
var pol db.LLMRetryPolicy
if err := decode(r, &pol); err != nil {
if err := decode(w, r, &pol); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -2108,7 +2189,7 @@ func (s *Server) pgActivateProfile(w http.ResponseWriter, r *http.Request) {
var body struct {
ID int64 `json:"id"`
}
if err := decode(r, &body); err != nil {
if err := decode(w, r, &body); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -2141,7 +2222,7 @@ func (s *Server) pgLLMPoolReset(w http.ResponseWriter, r *http.Request) {
var body struct {
ID int64 `json:"id"` // 0 / omitted = all
}
if err := decode(r, &body); err != nil {
if err := decode(w, r, &body); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -2168,7 +2249,7 @@ func (s *Server) pgListModels(w http.ResponseWriter, r *http.Request) {
Proxy string `json:"proxy"`
ProfileID *int64 `json:"profile_id"` // fallback: use stored key from this profile
}
if err := decode(r, &req); err != nil {
if err := decode(w, r, &req); err != nil {
writeErr(w, 400, err.Error())
return
}
+2 -2
View File
@@ -124,7 +124,7 @@ func (s *Server) syncSSDatasource(w http.ResponseWriter, r *http.Request) {
URL string `json:"url"`
APIKey string `json:"api_key"`
}
_ = decode(r, &body) // empty body = just create the placeholder
_ = decode(w, r, &body) // empty body = just create the placeholder
body.URL = strings.TrimSpace(body.URL)
body.APIKey = strings.TrimSpace(body.APIKey)
@@ -266,7 +266,7 @@ func (s *Server) syncSSRun(w http.ResponseWriter, r *http.Request) {
return
}
var req ssSyncReq
if err := decode(r, &req); err != nil {
if err := decode(w, r, &req); err != nil {
writeErr(w, 400, "invalid JSON: "+err.Error())
return
}
+2 -2
View File
@@ -512,7 +512,7 @@ func (s *Server) queueTaskArchiveDelete(w http.ResponseWriter, r *http.Request)
func (s *Server) queueTaskArchivesBatch(w http.ResponseWriter, r *http.Request) {
var request archiveBatchRequest
if err := decode(r, &request); err != nil {
if err := decode(w, r, &request); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -552,7 +552,7 @@ func (s *Server) queueTaskArchivesBatch(w http.ResponseWriter, r *http.Request)
func (s *Server) queueTaskArchiveActionBatch(w http.ResponseWriter, r *http.Request, action string) {
var request archiveBatchRequest
if err := decode(r, &request); err != nil {
if err := decode(w, r, &request); err != nil {
writeErr(w, 400, err.Error())
return
}
+1 -1
View File
@@ -33,7 +33,7 @@ func (s *Server) attachTaskAssets(w http.ResponseWriter, r *http.Request) {
SourceSummary string `json:"source_summary"`
Scope companyScopeInputs `json:"scope"`
}
if err := decode(r, &request); err != nil {
if err := decode(w, r, &request); err != nil {
var tooLarge *http.MaxBytesError
if errors.As(err, &tooLarge) {
writeErr(w, http.StatusRequestEntityTooLarge, "request body too large")
+3 -3
View File
@@ -21,7 +21,7 @@ type taskCategoryRequest struct {
func decodeTaskCategoryRequest(w http.ResponseWriter, r *http.Request) (*taskCategoryRequest, bool) {
r.Body = http.MaxBytesReader(w, r.Body, maxTaskCategoryRequestBytes)
var request taskCategoryRequest
if err := decode(r, &request); err != nil {
if err := decode(w, r, &request); err != nil {
var tooLarge *http.MaxBytesError
if errors.As(err, &tooLarge) {
writeErr(w, http.StatusRequestEntityTooLarge, "request body too large")
@@ -150,7 +150,7 @@ func (s *Server) updateTaskCategory(w http.ResponseWriter, r *http.Request) {
var request struct {
CategoryID json.RawMessage `json:"category_id"`
}
if err := decode(r, &request); err != nil {
if err := decode(w, r, &request); err != nil {
writeErr(w, http.StatusBadRequest, err.Error())
return
}
@@ -184,7 +184,7 @@ func (s *Server) updateTasksCategoryBatch(w http.ResponseWriter, r *http.Request
TaskIDs []string `json:"task_ids"`
CategoryID json.RawMessage `json:"category_id"`
}
if err := decode(r, &request); err != nil {
if err := decode(w, r, &request); err != nil {
var tooLarge *http.MaxBytesError
if errors.As(err, &tooLarge) {
writeErr(w, http.StatusRequestEntityTooLarge, "request body too large")
+3 -3
View File
@@ -91,7 +91,7 @@ func (s *Server) taskInterceptCreateRule(w http.ResponseWriter, r *http.Request)
return
}
var req taskInterceptRuleReq
if err := decode(r, &req); err != nil {
if err := decode(w, r, &req); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -123,7 +123,7 @@ func (s *Server) taskInterceptUpdateRule(w http.ResponseWriter, r *http.Request)
return
}
var req taskInterceptRuleReq
if err := decode(r, &req); err != nil {
if err := decode(w, r, &req); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -180,7 +180,7 @@ func (s *Server) taskInterceptToggleRule(w http.ResponseWriter, r *http.Request)
var req struct {
Enabled bool `json:"enabled"`
}
if err := decode(r, &req); err != nil {
if err := decode(w, r, &req); err != nil {
writeErr(w, 400, err.Error())
return
}
+1 -1
View File
@@ -30,7 +30,7 @@ func (s *Server) updateTaskMetadata(w http.ResponseWriter, r *http.Request) {
PlanQuietMode *bool `json:"plan_quiet_mode"`
TargetGate *bool `json:"target_gate"`
}
if err := decode(r, &request); err != nil {
if err := decode(w, r, &request); err != nil {
var tooLarge *http.MaxBytesError
if errors.As(err, &tooLarge) {
writeErr(w, http.StatusRequestEntityTooLarge, "request body too large")
+44
View File
@@ -0,0 +1,44 @@
package server
import (
"encoding/json"
"testing"
"github.com/Autumn-27/artex/traffic"
)
// The traffic_get description that says traffic_search never finds a value a
// rewrite rule wrote replaces the original built-in text once, and never a
// description the user edited.
func TestTrafficGetDescriptionUpgrade(t *testing.T) {
s, _, _ := trafficEvidenceServer(t)
pg := s.m.pg
old, err := pg.GetTool("traffic_get")
if err != nil || old == nil {
t.Fatal("missing tool traffic_get", err)
}
bindings, _ := json.Marshal(old.Agents)
t.Cleanup(func() { pg.UpdateTool("traffic_get", old.Description, old.Schema, bindings, old.Enabled) })
const flag = "traffic_get_rewrite_description_v1"
legacy := "Fetch the raw request/response of one captured traffic record by id (truncated when too large). Use together with traffic_search to avoid re-curling. A WebSocket (status 101) or SSE (text/event-stream) record shows only its handshake here; read its messages with traffic_messages."
for _, c := range []struct{ stored, want string }{
{legacy, traffic.TrafficGetDescription},
{"USER DESCRIPTION", "USER DESCRIPTION"},
} {
if err := pg.UpdateTool("traffic_get", c.stored, old.Schema, bindings, old.Enabled); err != nil {
t.Fatal(err)
}
if err := pg.SetSetting(flag, "false"); err != nil {
t.Fatal(err)
}
s.seedFindingWorkflowTools()
row, _ := pg.GetTool("traffic_get")
if row.Description != c.want {
t.Fatalf("stored %q: description %q, want %q", c.stored, row.Description, c.want)
}
if v, _, _ := pg.GetSetting(flag); v != "true" {
t.Fatal("flag not set")
}
}
}
+3 -3
View File
@@ -216,7 +216,7 @@ func (s *Server) rewriteCreateRule(w http.ResponseWriter, r *http.Request) {
return
}
var req rewriteRuleReq
if err := decode(r, &req); err != nil {
if err := decode(w, r, &req); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -249,7 +249,7 @@ func (s *Server) rewriteUpdateRule(w http.ResponseWriter, r *http.Request) {
return
}
var req rewriteRuleReq
if err := decode(r, &req); err != nil {
if err := decode(w, r, &req); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -308,7 +308,7 @@ func (s *Server) rewriteToggleRule(w http.ResponseWriter, r *http.Request) {
var req struct {
Enabled bool `json:"enabled"`
}
if err := decode(r, &req); err != nil {
if err := decode(w, r, &req); err != nil {
writeErr(w, 400, err.Error())
return
}
+2 -2
View File
@@ -60,7 +60,7 @@ func (s *Server) pgCreateTrigger(w http.ResponseWriter, r *http.Request) {
return
}
var req triggerReq
if err := decode(r, &req); err != nil {
if err := decode(w, r, &req); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -96,7 +96,7 @@ func (s *Server) pgUpdateTrigger(w http.ResponseWriter, r *http.Request) {
return
}
var req triggerReq
if err := decode(r, &req); err != nil {
if err := decode(w, r, &req); err != nil {
writeErr(w, 400, err.Error())
return
}
+2 -2
View File
@@ -139,7 +139,7 @@ func (s *Server) wsWrite(w http.ResponseWriter, r *http.Request) {
Path string `json:"path"`
Content string `json:"content"`
}
if err := decode(r, &req); err != nil {
if err := decode(w, r, &req); err != nil {
writeErr(w, 400, err.Error())
return
}
@@ -168,7 +168,7 @@ func (s *Server) wsMkdir(w http.ResponseWriter, r *http.Request) {
var req struct {
Path string `json:"path"`
}
if err := decode(r, &req); err != nil {
if err := decode(w, r, &req); err != nil {
writeErr(w, 400, err.Error())
return
}
+5
View File
@@ -76,6 +76,11 @@ func (t *Traffic) insertExchange(id string, ts int64, host, method, urlTemplate,
}
defer tx.Rollback() //nolint:errcheck // no-op once committed
// An id can repeat (seconds plus a rolling counter); the trace of the
// exchange it replaces must not stay attached to this one.
if _, err := tx.Exec(`DELETE FROM exchange_rewrites WHERE exchange_id=?`, id); err != nil {
return fmt.Errorf("clearing rewrite trace: %w", err)
}
res, err := tx.Exec(`INSERT OR REPLACE INTO exchanges(id,ts,host,method,url_template,url,status,content_type,req_len,resp_len,path)
VALUES(?,?,?,?,?,?,?,?,?,?,'')`,
id, ts, host, method, urlTemplate, rawURL, status, contentType, reqLen, respLen)
+5 -1
View File
@@ -40,11 +40,15 @@ func (s *sink) Requestheaders(f *mproxy.Flow) {
}
}
// ClientDisconnected forgets a closed connection's mark.
// ClientDisconnected forgets a closed connection's mark, and asks for a sweep
// of the request snapshots its flows may have left (rewrite_flow.go).
func (s *sink) ClientDisconnected(c *mproxy.ClientConn) {
if c != nil {
s.paced.Delete(c.Id)
}
if s.t != nil {
s.t.snaps.requestSweep()
}
}
// pace waits for the request's host under the current noise profile, bounded
+20
View File
@@ -4,6 +4,7 @@ import (
"errors"
"net/url"
"testing"
"time"
mproxy "github.com/lqqyt2423/go-mitmproxy/proxy"
)
@@ -65,4 +66,23 @@ func TestMaybePassthroughFlagsHostOnce(t *testing.T) {
if _, tunnel := tr.pass.Load(hostOnly("target.test:443")); !tunnel {
t.Fatal("flagged host must be recognized for the CONNECT form with port")
}
if !tr.tunneling("target.test") {
t.Fatal("a fresh passthrough mark must tunnel")
}
}
func TestPassthroughMarkExpires(t *testing.T) {
tr := &Traffic{}
host := "expired.example"
tr.pass.Store(host, time.Now().Add(-time.Second))
if tr.tunneling(host) {
t.Fatal("expired passthrough mark still tunnels")
}
if _, ok := tr.pass.Load(host); ok {
t.Fatal("expired mark was kept")
}
tr.pass.Store(host, time.Now().Add(time.Minute))
if !tr.tunneling(host) {
t.Fatal("fresh passthrough mark should tunnel")
}
}
+1 -2
View File
@@ -86,8 +86,7 @@ func (t *Traffic) replayRecorded(scheme, host string) bool {
if scheme != "https" {
return true
}
_, tunneled := t.pass.Load(hostOnly(host))
return !tunneled
return !t.tunneling(hostOnly(host))
}
func replayInvalid(format string, args ...any) error {
+10 -2
View File
@@ -199,7 +199,10 @@ func TestReplayPassthroughHostIsNotIntercepted(t *testing.T) {
tr, _, _ := startProxy(t)
srv := httptest.NewTLSServer(http.HandlerFunc(echoHandler))
t.Cleanup(srv.Close)
tr.pass.Store("localhost", struct{}{})
tr.pass.Store("localhost", time.Now().Add(passthroughTTL))
if !tr.tunneling("localhost") {
t.Fatal("passthrough mark was not recognized before the replay")
}
target := localhostURL(srv.URL) + "/tunneled"
_, err := tr.Replay(t.Context(), ReplayRequest{Method: "GET", URL: target})
if err == nil || !strings.Contains(err.Error(), "certificate") {
@@ -249,7 +252,11 @@ func TestReplayRejectsInvalidRequests(t *testing.T) {
// Only an https host in passthrough is reported as not recorded.
func TestReplayRecordedHelper(t *testing.T) {
tr := &Traffic{}
tr.pass.Store("localhost", struct{}{})
tr.pass.Store("localhost", time.Now().Add(passthroughTTL))
if !tr.tunneling("localhost") {
t.Fatal("fresh passthrough mark was not tunneling")
}
tr.pass.Store("expired.example", time.Now().Add(-time.Second))
for _, c := range []struct {
scheme, host string
want bool
@@ -257,6 +264,7 @@ func TestReplayRecordedHelper(t *testing.T) {
{"https", "localhost:443", false},
{"https", "example.com:443", true},
{"http", "localhost:80", true},
{"https", "expired.example:443", true},
} {
if got := tr.replayRecorded(c.scheme, c.host); got != c.want {
t.Errorf("replayRecorded(%s, %s) = %v, want %v", c.scheme, c.host, got, c.want)
+8
View File
@@ -80,6 +80,14 @@ func (s *Set) LoadErrors() map[int64]string {
return s.loadErrors
}
// NoteError records a run-time error of a rule seen outside the engine, such
// as the transport failure of a request the rule rewrote.
func (s *Set) NoteError(id int64, class string) {
if s != nil {
s.errors.record(id, class)
}
}
// LastError is the most recent run-time error of a rule. It lives in memory
// only; the per-exchange trace keeps the history.
type LastError struct {
+3
View File
@@ -30,6 +30,9 @@ const (
ErrClassInvalidURL = "invalid_url" // a rewritten path and query is not a valid request URI
ErrClassExpansion = "expansion_limit" // a replace result exceeds MaxExpansion
ErrClassPanic = "panic"
// ErrClassTransport is recorded by the proxy, not the engine: the request a
// rule rewrote could not be sent or answered.
ErrClassTransport = "transport_error"
)
// TraceLine is one row of an exchange's rewrite trace, in order. An exchange is
+663
View File
@@ -0,0 +1,663 @@
package traffic
import (
"database/sql"
"io"
"log"
"net/http"
"net/url"
"sync"
"sync/atomic"
"time"
"github.com/Autumn-27/artex/traffic/rewrite"
mproxy "github.com/lqqyt2423/go-mitmproxy/proxy"
)
// Applying the rewrite rules to the proxied flows.
//
// The request phase runs in the Request hook. A request a rule rewrote leaves
// the proxy changed, but its exchange records what the client sent: the
// original is kept in a per-flow request snapshot until the Response hook
// records the exchange. The response phase runs at the start of the Response
// hook (status and headers only at SSEStart), and the exchange records the
// response as the target sent it. The trace of both phases is written in the
// exchange's own transaction (exchange_rewrites).
//
// A request is rewritten only once its snapshot slot is reserved, and a slot
// stays until the flow's exchange is recorded or the flow is finished, so the
// Response hook never takes a rewritten request for the client's.
// Limits of the request snapshots.
const (
maxSnapEntries = 1024 // entries holding an original request
maxSnapBytes = 64 << 20 // what those entries hold
maxSnapTombs = 4096 // tombstones: slots whose data was released
// snapTTL deletes nothing: past it, the entry of a live flow may be turned
// into a tombstone when a new reservation finds no room.
snapTTL = 15 * time.Minute
sweepDebounce = time.Second // at most one sweep per second
sweepPeriod = time.Minute // a sweep at least this often while slots exist
// libraryStreamBody is go-mitmproxy's StreamLargeBodies default: a body this
// large reaches neither the Request nor the Response hook.
libraryStreamBody = 5 << 20
reasonSnapshotCapacity = "not rewritten: snapshot capacity"
reasonOriginalUnavailable = "original request unavailable"
)
// testRuleHook, when a test sets it, runs inside each rule that checks a body
// ("rule") and in the sink right after the engine ("request", "response"), so
// a test can make a rule, or the sink itself, panic.
var testRuleHook atomic.Pointer[func(stage string)]
func runTestHook(stage string) {
if h := testRuleHook.Load(); h != nil {
(*h)(stage)
}
}
// rulesIsBinary is the binary predicate handed to the engine: the recorder's
// own, so "not rewritten: binary" follows what the recorder treats as binary.
func rulesIsBinary(contentType string, body []byte) bool {
runTestHook("rule")
return isBinaryBody(contentType, body)
}
type flowKey [16]byte
func keyOf(f *mproxy.Flow) flowKey { return flowKey(f.Id) }
// reqSnap is one slot of the table: an entry, which holds the original of a
// request, or a tombstone, which holds only why it has none.
type reqSnap struct {
// done is the flow's Done() channel: closed, no hook will come for the
// slot any more. The flow itself is not referenced.
done <-chan struct{}
rules *rewrite.Set // the snapshot of rules the flow runs with, both phases
host string // host name: the only part of the request a log shows
tomb bool
// Entry.
created time.Time
cost int64
rewritten bool // the request phase changed the request
method string
url *url.URL
header http.Header
rawHost string
body []byte // the client's body, kept when a body action applied
keepBody bool
lines []rewrite.TraceLine // request-phase trace
// Tombstone.
reason string // reasonSnapshotCapacity or reasonOriginalUnavailable
ruleIDs []int64 // rules that had rewritten the request
}
// requestRewritten reports a flow whose request left the proxy changed.
func (s *reqSnap) requestRewritten() bool {
if s.tomb {
return s.reason == reasonOriginalUnavailable
}
return s.rewritten
}
func (s *reqSnap) appliedRuleIDs() []int64 {
if s.tomb {
return s.ruleIDs
}
_, ids := appliedRules(s.lines)
return ids
}
// snapTable holds the slots, keyed by flow id. Its mutex is a leaf lock.
type snapTable struct {
mu sync.Mutex
slots map[flowKey]*reqSnap
entries int
bytes int64
tombs int
lastSweep time.Time
lastFullLog time.Time
sweepWanted atomic.Bool
now func() time.Time
maxEntries int
maxBytes int64
maxTombs int
ttl time.Duration
sweeps, capacity, tombDrops, conversions, largeResponses atomic.Int64
}
func newSnapTable() *snapTable {
return &snapTable{slots: map[flowKey]*reqSnap{}, now: time.Now,
maxEntries: maxSnapEntries, maxBytes: maxSnapBytes, maxTombs: maxSnapTombs, ttl: snapTTL}
}
func doneClosed(ch <-chan struct{}) bool {
if ch == nil {
return false // a nil channel is never ready: the flow counts as live
}
select {
case <-ch:
return true
default:
return false
}
}
// reserve stores the entry of a rewritten request. On failure the request must
// leave unchanged: a capacity tombstone then stands for the flow, when there is
// room for one.
func (t *snapTable) reserve(k flowKey, e *reqSnap) bool {
if t == nil {
return false
}
t.mu.Lock()
defer t.mu.Unlock()
t.removeLocked(k)
if !t.fitsLocked(e.cost) {
// A failed reservation asks for an immediate sweep, under the same
// debounce; a sweep refused by the debounce fails the reservation.
now := t.now()
if now.Sub(t.lastSweep) < sweepDebounce {
t.refuseLocked(k, e)
return false
}
t.sweepLocked(now)
if !t.fitsLocked(e.cost) && !t.convertLocked(e.cost) {
t.refuseLocked(k, e)
return false
}
}
e.created = t.now()
t.slots[k] = e
t.entries++
t.bytes += e.cost
return true
}
func (t *snapTable) fitsLocked(cost int64) bool {
return t.entries < t.maxEntries && t.bytes+cost <= t.maxBytes
}
// convertLocked turns the oldest entry of a live flow older than the TTL into
// a tombstone, in place, so the flow is never without a slot. It does so only
// when releasing that entry lets a reservation of cost succeed, and when a
// tombstone place is free (after evicting tombstones of finished flows only).
// Otherwise nothing changes and it reports false.
func (t *snapTable) convertLocked(cost int64) bool {
now := t.now()
var victim *reqSnap
for _, s := range t.slots {
if s.tomb || doneClosed(s.done) || now.Sub(s.created) < t.ttl {
continue
}
if t.entries-1 >= t.maxEntries || t.bytes-s.cost+cost > t.maxBytes {
continue // released, it would still leave no room
}
if victim == nil || s.created.Before(victim.created) {
victim = s
}
}
if victim == nil {
return false
}
if t.tombs >= t.maxTombs {
t.evictFinishedTombsLocked()
}
if t.tombs >= t.maxTombs {
return false
}
ids := victim.appliedRuleIDs()
t.entries--
t.bytes -= victim.cost
t.tombs++
*victim = reqSnap{done: victim.done, rules: victim.rules, host: victim.host, tomb: true, reason: reasonOriginalUnavailable, ruleIDs: ids}
t.conversions.Add(1)
log.Printf("[traffic] rewrite snapshot of a request to %s (rules %v) released under pressure: its exchange will be recorded as original request unavailable", victim.host, ids)
return true
}
// refuseLocked is the capacity path: the request is not rewritten, and a
// tombstone records why, when a place is free.
func (t *snapTable) refuseLocked(k flowKey, e *reqSnap) {
t.capacity.Add(1)
if t.tombs >= t.maxTombs {
t.evictFinishedTombsLocked()
}
full := t.tombs >= t.maxTombs
if full {
t.tombDrops.Add(1)
} else {
t.slots[k] = &reqSnap{done: e.done, rules: e.rules, host: e.host, tomb: true, reason: reasonSnapshotCapacity}
t.tombs++
}
if now := t.now(); now.Sub(t.lastFullLog) >= time.Minute {
t.lastFullLog = now
log.Printf("[traffic] rewrite snapshot table full: requests are sent without rewriting (%d refused, %d without a trace so far)", t.capacity.Load(), t.tombDrops.Load())
}
}
func (t *snapTable) evictFinishedTombsLocked() {
for k, s := range t.slots {
if s.tomb && doneClosed(s.done) {
t.removeLocked(k)
}
}
}
// sweepLocked deletes every slot whose flow is finished. The slot of a live
// flow is never touched, whatever its age.
func (t *snapTable) sweepLocked(now time.Time) {
for k, s := range t.slots {
if doneClosed(s.done) {
t.removeLocked(k)
}
}
t.lastSweep = now
t.sweepWanted.Store(false)
t.sweeps.Add(1)
}
func (t *snapTable) removeLocked(k flowKey) {
s := t.slots[k]
if s == nil {
return
}
if s.tomb {
t.tombs--
} else {
t.entries--
t.bytes -= s.cost
}
delete(t.slots, k)
}
// take removes and returns the slot of a flow, nil when it has none.
func (t *snapTable) take(k flowKey) *reqSnap {
if t == nil {
return nil
}
t.mu.Lock()
defer t.mu.Unlock()
s := t.slots[k]
t.removeLocked(k)
return s
}
// requestSweep asks the sweeper for a pass; it runs at most once a second.
func (t *snapTable) requestSweep() {
if t != nil {
t.sweepWanted.Store(true)
}
}
// tick is one beat of the sweeper: a sweep when one was asked for and the last
// is a second old, or when the last is a minute old. Nothing on an empty table.
func (t *snapTable) tick() {
t.mu.Lock()
defer t.mu.Unlock()
if len(t.slots) == 0 {
t.sweepWanted.Store(false)
return
}
now := t.now()
since := now.Sub(t.lastSweep)
if (t.sweepWanted.Load() && since >= sweepDebounce) || since >= sweepPeriod {
t.sweepLocked(now)
}
}
// counts reports the entries and tombstones in the table.
func (t *snapTable) counts() (entries, tombs int) {
t.mu.Lock()
defer t.mu.Unlock()
return t.entries, t.tombs
}
// sweepSnapshots is the single sweeper goroutine, started by Open and stopped
// by Close.
func (t *Traffic) sweepSnapshots() {
tick := time.NewTicker(time.Second)
defer tick.Stop()
for {
select {
case <-t.closed:
return
case <-tick.C:
t.snaps.tick()
}
}
}
// RewriteStats are the proxy-side counters of the rewrite rules since start.
type RewriteStats struct {
// LargeResponses counts flows with a snapshot whose response reached the
// library's 5 MiB stream threshold: passed through, not recorded.
LargeResponses int64 `json:"large_responses"`
// CapacityRefusals counts requests sent without rewriting for lack of room.
CapacityRefusals int64 `json:"capacity_refusals"`
// TombstoneDrops counts those of them that got no capacity tombstone either.
TombstoneDrops int64 `json:"tombstone_drops"`
// Conversions counts entries released under pressure.
Conversions int64 `json:"conversions"`
Sweeps int64 `json:"sweeps"`
}
func (t *Traffic) RewriteStats() RewriteStats {
s := t.snaps
if s == nil {
return RewriteStats{}
}
return RewriteStats{LargeResponses: s.largeResponses.Load(), CapacityRefusals: s.capacity.Load(),
TombstoneDrops: s.tombDrops.Load(), Conversions: s.conversions.Load(), Sweeps: s.sweeps.Load()}
}
// newEntry builds the snapshot of a request before the rules' result is put on
// the flow: URL and headers cloned, the body referenced, and only when a body
// action applied (otherwise the flow's body is still the client's).
func newEntry(f *mproxy.Flow, set *rewrite.Set, res rewrite.Result) *reqSnap {
r := f.Request
u := *r.URL
e := &reqSnap{done: f.Done(), rules: set, host: r.URL.Hostname(), rewritten: res.Changed,
method: r.Method, url: &u, header: r.Header.Clone(), lines: res.Lines}
if raw := r.Raw(); raw != nil {
e.rawHost = raw.Host
}
for _, l := range res.Lines {
if l.Outcome == rewrite.OutcomeApplied && l.Field == "body" && len(r.Body) <= rewrite.MaxBodySize {
e.body, e.keepBody = r.Body, true
break
}
}
e.cost = int64(len(e.method) + len(u.String()) + len(e.rawHost) + len(e.body))
for k, vs := range e.header {
for _, v := range vs {
e.cost += int64(len(k) + len(v))
}
}
for _, l := range e.lines {
e.cost += int64(len(l.After) + len(l.RuleSnapshot))
}
return e
}
// originalRequest is the request an exchange records, with the request-phase
// trace: the flow's own request when no rule rewrote it, the entry's copy when
// one did, and only what Raw() still knows when the entry was released.
func originalRequest(f *mproxy.Flow, snap *reqSnap) (requestView, []rewrite.TraceLine) {
switch {
case snap == nil:
return flowRequestView(f.Request), nil
case !snap.tomb:
v := requestView{method: snap.method, url: snap.url, proto: f.Request.Proto, header: snap.header, rawHost: snap.rawHost, body: f.Request.Body}
if snap.keepBody {
v.body = snap.body
}
return v, snap.lines
case snap.reason == reasonSnapshotCapacity:
// The request was not rewritten: the flow's request is the client's.
return flowRequestView(f.Request), []rewrite.TraceLine{{Phase: rewrite.PhaseRequest, Outcome: rewrite.OutcomeSkipped, Reason: reasonSnapshotCapacity}}
default:
// Rewritten, original released: never record the rewritten request as
// the client's. Raw() is the client's request line and Host.
v := requestView{unavailable: true}
if raw := f.Request.Raw(); raw != nil {
v.method, v.url, v.proto, v.rawHost = raw.Method, raw.URL, raw.Proto, raw.Host
}
lines := []rewrite.TraceLine{{Phase: rewrite.PhaseRequest, Outcome: rewrite.OutcomeError, Reason: reasonOriginalUnavailable}}
for _, id := range snap.ruleIDs {
lines = append(lines, rewrite.TraceLine{Phase: rewrite.PhaseRequest, RuleID: id, Outcome: rewrite.OutcomeApplied})
}
return v, lines
}
}
func engineRequest(r *mproxy.Request) rewrite.Request {
return rewrite.Request{Method: r.Method, URL: r.URL, Header: r.Header, Body: r.Body}
}
// Request runs the request phase. The result goes on the flow only once the
// request's snapshot slot is reserved; without one the request leaves as the
// client sent it. Rules fail open: a panic leaves the request unchanged.
func (s *sink) Request(f *mproxy.Flow) {
if s.t == nil || f.Request == nil || f.Request.URL == nil {
return
}
set := s.t.rewriteRules.Load()
if set.Len(rewrite.PhaseRequest) == 0 {
return
}
host := f.Request.URL.Hostname()
defer func() {
if recover() != nil {
log.Printf("[traffic] rewrite rules stopped on a request to %s (class %s): it is sent as the client sent it", host, rewrite.ErrClassPanic)
}
}()
res := set.Apply(rewrite.PhaseRequest, rewrite.Input{Request: engineRequest(f.Request), IsBinary: rulesIsBinary})
runTestHook("request")
if len(res.Lines) == 0 {
return
}
if !s.t.snaps.reserve(keyOf(f), newEntry(f, set, res)) {
return
}
if res.Changed {
r := f.Request
r.Method, r.URL, r.Header, r.Body = res.Request.Method, res.Request.URL, res.Request.Header, res.Request.Body
}
}
// Response records the exchange and runs the response phase: the exchange
// keeps the client's request and the target's response, the client gets the
// rewritten response. Without a slot and without response rules this is the
// plain record.
func (s *sink) Response(f *mproxy.Flow) {
if f.Request == nil || f.Response == nil {
return
}
snap := s.t.snaps.take(keyOf(f))
set := s.t.rewriteRules.Load()
if snap != nil {
set = snap.rules
}
if snap == nil && set.Len(rewrite.PhaseResponse) == 0 {
s.t.record(f)
return
}
rq, lines := originalRequest(f, snap)
rs := flowResponseView(f.Response)
res := s.applyResponse(f, set, rewrite.Input{
Request: engineRequest(f.Request), // as sent to the target
Response: rewrite.Response{Status: rs.status, Header: rs.header, Body: rs.body},
IsBinary: rulesIsBinary,
})
s.t.recordViews(rq, rs, append(lines, res.Lines...))
if res.Changed {
f.Response.StatusCode, f.Response.Header, f.Response.Body = res.Response.Status, res.Response.Header, res.Response.Body
}
}
// applyResponse runs the response phase; a panic yields no change and no line.
func (s *sink) applyResponse(f *mproxy.Flow, set *rewrite.Set, in rewrite.Input) (res rewrite.Result) {
if set.Len(rewrite.PhaseResponse) == 0 {
return rewrite.Result{}
}
defer func() {
if recover() != nil {
res = rewrite.Result{}
log.Printf("[traffic] rewrite rules stopped on a response from %s (class %s): it is sent as the target sent it", f.Request.URL.Hostname(), rewrite.ErrClassPanic)
}
}()
r := set.Apply(rewrite.PhaseResponse, in)
runTestHook("response")
return r
}
// rewriteStream prepares the exchange of a stream at SSEStart or
// WebSocketStart: the client's request, the target's status and headers (SSE),
// and the trace. For SSE, the response phase runs in stream mode: status and
// header actions apply (res, put on the flow by applyStreamResponse), rules
// that read or write the response body are traced "not rewritten: stream".
// WebSocketStart runs once go-mitmproxy has already answered the client's
// upgrade, with no response on the flow: nothing of the handshake can change
// there, so every candidate rule is traced "not rewritten: stream".
func (s *sink) rewriteStream(f *mproxy.Flow, kind string) (rq requestView, rs responseView, lines []rewrite.TraceLine, res rewrite.Result) {
snap := s.t.snaps.take(keyOf(f))
set := s.t.rewriteRules.Load()
if snap != nil {
set = snap.rules
}
rq, lines = originalRequest(f, snap)
if kind == "sse" {
rs = flowResponseView(f.Response)
}
cur := engineRequest(f.Request)
if kind != "websocket" {
res = s.applyResponse(f, set, rewrite.Input{Request: cur, Response: rewrite.Response{Status: rs.status, Header: rs.header}, Stream: true, IsBinary: rulesIsBinary})
return rq, rs, append(lines, res.Lines...), res
}
if set.Len(rewrite.PhaseRequest)+set.Len(rewrite.PhaseResponse) == 0 {
return rq, rs, lines, rewrite.Result{}
}
// The engine never changes a request with Upgrade; a ws:// stream arrives
// on its CONNECT flow, which has none.
if cur.Header.Get("Upgrade") == "" {
cur.Header = cur.Header.Clone()
if cur.Header == nil {
cur.Header = http.Header{}
}
cur.Header.Set("Upgrade", "websocket")
}
if snap == nil {
lines = append(lines, s.applyRequestTrace(f, set, cur)...)
}
r := s.applyResponse(f, set, rewrite.Input{Request: cur, Response: rewrite.Response{Status: http.StatusSwitchingProtocols}, Stream: true, IsBinary: rulesIsBinary})
return rq, rs, append(lines, r.Lines...), rewrite.Result{}
}
// applyRequestTrace runs the request phase for its trace only.
func (s *sink) applyRequestTrace(f *mproxy.Flow, set *rewrite.Set, req rewrite.Request) (lines []rewrite.TraceLine) {
defer func() {
if recover() != nil {
lines = nil
log.Printf("[traffic] rewrite rules stopped on a request to %s (class %s)", f.Request.URL.Hostname(), rewrite.ErrClassPanic)
}
}()
return set.Apply(rewrite.PhaseRequest, rewrite.Input{Request: req, IsBinary: rulesIsBinary}).Lines
}
// applyStreamResponse puts the rewritten status and headers of an SSE
// response on the flow, before go-mitmproxy replies to the client.
func (s *sink) applyStreamResponse(f *mproxy.Flow, res rewrite.Result) {
if res.Changed && f.Response != nil {
f.Response.StatusCode, f.Response.Header = res.Response.Status, res.Response.Header
}
}
// RequestError fires when a request through an established MITM tunnel fails. If
// the failure looks proxy/protocol-caused (h2 quirks, HEAD-with-body, protocol
// errors) and not a plain target-unreachable error, the host is tunneled for
// passthroughTTL: this request has already failed, later requests in the window
// connect straight through, and the first one after the window tries
// interception again. A request a rule rewrote never flags its host: the rule,
// not the interception, may be at fault. Its log names the host, the error class
// and the rules, never the URL or the error text.
func (s *sink) RequestError(f *mproxy.Flow, err error) {
if f != nil {
if snap := s.t.snaps.take(keyOf(f)); snap != nil && snap.requestRewritten() {
ids := snap.appliedRuleIDs()
for _, id := range ids {
snap.rules.NoteError(id, rewrite.ErrClassTransport)
}
log.Printf("[traffic] a request to %s rewritten by rules %v failed (class %s); the host stays intercepted", snap.host, ids, rewrite.ErrClassTransport)
return
}
}
s.t.maybePassthrough(f, err)
}
// StreamResponseModifier passes every body through as received, nil included,
// without wrapping it. A response that reached the library's stream threshold
// is never recorded: the slot of its flow, if any, is released here.
func (s *sink) StreamResponseModifier(f *mproxy.Flow, in io.Reader) (out io.Reader) {
out = in
defer func() {
if recover() != nil {
out = in
}
}()
if s == nil || s.t == nil || f == nil || !f.Stream || f.SSE != nil {
return in
}
snap := s.t.snaps.take(keyOf(f))
if snap == nil {
return in
}
s.t.snaps.largeResponses.Add(1)
log.Printf("[traffic] the response to a request to %s with rewrite rules %v reached %d MiB: passed through, not recorded", snap.host, snap.appliedRuleIDs(), libraryStreamBody>>20)
return in
}
// spillTrace stores the values of the trace lines as record stores bodies.
// Called under wmu, before the transaction.
func (t *Traffic) spillTrace(lines []rewrite.TraceLine) []storedBody {
out := make([]storedBody, len(lines))
for i, l := range lines {
out[i] = t.spill(l.After, "")
}
return out
}
// writeTrace inserts an exchange's trace rows and the blob references of their
// spilled values, inside the exchange's transaction.
func writeTrace(tx *sql.Tx, id string, lines []rewrite.TraceLine, trace []storedBody) error {
for _, b := range trace {
if b.hash == "" {
continue
}
if _, err := tx.Exec(`INSERT OR IGNORE INTO blob_refs(hash,exchange_id) VALUES(?,?)`, b.hash, id); err != nil {
return &recordError{"registering blob reference", err}
}
}
for i, l := range lines {
var ruleID, after any
if l.RuleID != 0 {
ruleID = l.RuleID
}
if trace[i].inline != nil {
after = trace[i].inline
}
if _, err := tx.Exec(`INSERT INTO exchange_rewrites(exchange_id,seq,phase,rule_id,rule_snapshot,action,field,outcome,reason,before_hash,after_hash,after_inline,after_blob)
VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?)`,
id, i, string(l.Phase), ruleID, nullIfEmpty(l.RuleSnapshot), nullIfEmpty(l.Action), nullIfEmpty(l.Field), l.Outcome, l.Reason,
nullIfEmpty(l.BeforeHash), nullIfEmpty(l.AfterHash), after, nullIfEmpty(trace[i].hash)); err != nil {
return &recordError{"writing rewrite trace", err}
}
}
return nil
}
// RewriteInfo reports whether rules rewrote an exchange (at least one applied
// trace line) and which rules did, by id.
func (t *Traffic) RewriteInfo(id string) (rewritten bool, ruleIDs []int64, err error) {
if err := t.db.QueryRow(`SELECT EXISTS(SELECT 1 FROM exchange_rewrites r WHERE r.exchange_id=? AND r.outcome='applied')`, id).Scan(&rewritten); err != nil || !rewritten {
return false, nil, err
}
rows, err := t.db.Query(`SELECT DISTINCT rule_id FROM exchange_rewrites WHERE exchange_id=? AND outcome='applied' AND rule_id IS NOT NULL ORDER BY rule_id`, id)
if err != nil {
return false, nil, err
}
defer rows.Close()
for rows.Next() {
var rid int64
if err := rows.Scan(&rid); err != nil {
return false, nil, err
}
ruleIDs = append(ruleIDs, rid)
}
return true, ruleIDs, rows.Err()
}
File diff suppressed because it is too large Load Diff
-102
View File
@@ -1,102 +0,0 @@
package traffic
import (
"io"
"net/http"
"net/http/httptest"
"slices"
"sort"
"strings"
"sync"
"testing"
"github.com/Autumn-27/artex/traffic/rewrite"
)
// The proxy stores the compiled rewrite rules and does not apply them. With a
// snapshot whose rules match every exchange, what the target receives, what the
// client receives and what is recorded are the same as with no rule at all.
func TestRewriteRulesStoredNotApplied(t *testing.T) {
var mu sync.Mutex
var seen []string
target := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
body, _ := io.ReadAll(r.Body)
mu.Lock()
seen = append(seen, r.Method+" "+r.RequestURI+" X-Client="+r.Header.Get("X-Client")+" "+string(body))
mu.Unlock()
w.Header().Set("X-Target", "t")
w.WriteHeader(http.StatusTeapot)
io.WriteString(w, "target body")
}))
t.Cleanup(target.Close)
set := rewrite.Compile([]rewrite.Rule{
{ID: 1, Name: "request", Enabled: true, Phase: rewrite.PhaseRequest, Actions: []rewrite.Action{
{Type: rewrite.ActionSetMethod, Value: "PUT"},
{Type: rewrite.ActionSetPathQuery, Value: "/rewritten"},
{Type: rewrite.ActionSetHeader, Name: "X-Client", Value: "rewritten"},
{Type: rewrite.ActionSetBody, Value: "rewritten"}}},
{ID: 2, Name: "response", Enabled: true, Phase: rewrite.PhaseResponse, Actions: []rewrite.Action{
{Type: rewrite.ActionSetStatus, Value: "200"},
{Type: rewrite.ActionSetHeader, Name: "X-Rewritten", Value: "1"},
{Type: rewrite.ActionSetBody, Value: "rewritten"}}},
}, rewrite.Options{})
if set.Len(rewrite.PhaseRequest) != 1 || set.Len(rewrite.PhaseResponse) != 1 || len(set.LoadErrors()) != 0 {
t.Fatalf("the snapshot must hold both rules: %v", set.LoadErrors())
}
// canon makes a recorded message comparable: the recorder writes headers in
// map order, and the target dates its response.
canon := func(raw string) string {
head, body, _ := strings.Cut(raw, "\n\n")
lines := strings.Split(head, "\n")
sort.Strings(lines[1:])
lines = slices.DeleteFunc(lines, func(l string) bool { return strings.HasPrefix(l, "Date: ") })
return strings.Join(lines, "\n") + "\n\n" + body
}
// exchange sends one request through a fresh proxy holding set and returns
// what the client received and what the proxy recorded.
exchange := func(set *rewrite.Set) (client, recorded string) {
tr, _, proxyURL := startProxy(t)
if tr.RewriteRules() != nil {
t.Fatal("Open published rewrite rules")
}
tr.SetRewriteRules(set)
if tr.RewriteRules() != set {
t.Fatal("RewriteRules must return the snapshot last published")
}
req, err := http.NewRequest("POST", target.URL+"/path?q=1", strings.NewReader("client body"))
if err != nil {
t.Fatal(err)
}
req.Header.Set("X-Client", "c")
resp, err := proxyClient(t, tr, proxyURL).Do(req)
if err != nil {
t.Fatal(err)
}
defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)
client = resp.Status + " X-Target=" + resp.Header.Get("X-Target") + " X-Rewritten=" + resp.Header.Get("X-Rewritten") + " " + string(body)
reqText, respText, err := tr.Get(onlyExchangeID(t, tr))
if err != nil {
t.Fatal(err)
}
return client, canon(reqText) + "\n--\n" + canon(respText)
}
baseClient, baseRecorded := exchange(nil)
client, recorded := exchange(set)
if want := "418 I'm a teapot X-Target=t X-Rewritten= target body"; baseClient != want || client != want {
t.Fatalf("client received %q without rules and %q with rules, want %q", baseClient, client, want)
}
if recorded != baseRecorded {
t.Fatalf("the recorded exchange differs with rules stored:\n without: %s\n with: %s", baseRecorded, recorded)
}
if !strings.Contains(recorded, "client body") || !strings.Contains(recorded, "target body") || strings.Contains(recorded, "rewritten") {
t.Fatalf("recorded exchange: %s", recorded)
}
want := "POST /path?q=1 X-Client=c client body"
if len(seen) != 2 || seen[0] != want || seen[1] != want {
t.Fatalf("the target received %q, want %q twice", seen, want)
}
}
+60 -27
View File
@@ -16,6 +16,7 @@ import (
"unsafe"
"github.com/Autumn-27/artex/db"
"github.com/Autumn-27/artex/traffic/rewrite"
mproxy "github.com/lqqyt2423/go-mitmproxy/proxy"
)
@@ -144,17 +145,35 @@ func (s *sink) startStream(f *mproxy.Flow, kind string) {
if f.Request == nil || f.Request.URL == nil || (kind == "sse" && f.Response == nil) {
return
}
id, err := s.t.recordStreamStart(f, kind)
rq, rs, lines, res := s.rewriteStream(f, kind)
id, err := s.t.recordStreamStart(rq, rs, kind, lines)
s.applyStreamResponse(f, res)
if err != nil {
if rewritten, ruleIDs := appliedRules(lines); rewritten {
var re *recordError
errors.As(err, &re)
log.Printf("[traffic] failed to record a rewritten %s stream of %s (%s; rules %v)", kind, f.Request.URL.Hostname(), re.step, ruleIDs)
return
}
log.Printf("[traffic] failed to record %s stream %s: %v", kind, f.Request.URL, err)
return
}
st.id = id
if kind == "sse" {
st.reqBytes = int64(len(f.Request.Body))
st.reqBytes = int64(len(rq.body))
}
}
// recordError names the step of a recording that failed. Its text is the step
// and the cause, as recordStreamStart always reported.
type recordError struct {
step string
err error
}
func (e *recordError) Error() string { return e.step + ": " + e.err.Error() }
func (e *recordError) Unwrap() error { return e.err }
// libMutex returns the unexported mu sync.Mutex that go-mitmproxy holds while it
// appends to WebSocketData.Messages / SSEData.Events. The library exposes no
// accessor, and the two WebSocket goroutines append concurrently, so reading the
@@ -252,9 +271,9 @@ func sseEventsSince(sse *mproxy.SSEData, st *streamState) []streamRow {
// streamDisplayURL is the URL shown for a WebSocket exchange: http→ws and
// https→wss. A plain ws:// connection reaches the WebSocket hooks through its
// CONNECT tunnel, where only the target authority is known, not the path.
func streamDisplayURL(f *mproxy.Flow, kind string) (method, display, tmpl string) {
u := *f.Request.URL
method = f.Request.Method
func streamDisplayURL(reqMethod string, reqURL *url.URL, kind string) (method, display, tmpl string) {
u := *reqURL
method = reqMethod
if kind == "websocket" && strings.EqualFold(method, "CONNECT") {
host := u.Host
if host == "" {
@@ -270,63 +289,77 @@ func streamDisplayURL(f *mproxy.Flow, kind string) (method, display, tmpl string
u.Scheme = "wss"
}
}
return method, u.String(), db.TemplatePath(f.Request.URL.EscapedPath())
return method, u.String(), db.TemplatePath(reqURL.EscapedPath())
}
// recordStreamStart writes the stream's exchange: metadata, request head and
// body, the response head (synthetic 101 for WebSocket), and the header text in
// the full-text index. Messages are never indexed.
func (t *Traffic) recordStreamStart(f *mproxy.Flow, kind string) (string, error) {
// body, the response head (synthetic 101 for WebSocket), the rewrite trace,
// and the header text in the full-text index. Messages are never indexed. rq
// is the request the client sent and rs (SSE only) the status and headers the
// target sent, whatever the rules changed.
func (t *Traffic) recordStreamStart(rq requestView, rs responseView, kind string, lines []rewrite.TraceLine) (string, error) {
now := time.Now()
id := t.newExchangeID(now)
method, display, tmpl := streamDisplayURL(f, kind)
host := f.Request.URL.Hostname()
target := f.Request.URL.RequestURI()
if strings.EqualFold(f.Request.Method, "CONNECT") {
target = f.Request.URL.Host // authority-form, as on the wire
method, display, tmpl, host, target := rq.method, "", "", "", ""
if rq.url != nil {
method, display, tmpl = streamDisplayURL(rq.method, rq.url, kind)
host = rq.url.Hostname()
target = rq.url.RequestURI()
if strings.EqualFold(rq.method, "CONNECT") {
target = rq.url.Host // authority-form, as on the wire
}
}
reqHead := fmt.Sprintf("%s %s %s\n%s", f.Request.Method, target, f.Request.Proto, requestHeaderLines(f.Request))
reqHead := requestHead(rq, target)
status, ct, respHead := 101, "websocket", "HTTP/1.1 101 Switching Protocols\n"
if kind == "sse" {
status = f.Response.StatusCode
ct = f.Response.Header.Get("Content-Type")
respHead = fmt.Sprintf("HTTP %d\n%s", status, headerLines(f.Response.Header))
status = rs.status
ct = rs.header.Get("Content-Type")
respHead = fmt.Sprintf("HTTP %d\n%s", status, headerLines(rs.header))
}
t.wmu.Lock()
defer t.wmu.Unlock()
reqB := t.spill(f.Request.Body, f.Request.Header.Get("Content-Type"))
reqB := t.spill(rq.body, rq.header.Get("Content-Type"))
trace := t.spillTrace(lines)
tx, err := t.db.Begin()
if err != nil {
return "", fmt.Errorf("beginning transaction: %w", err)
return "", &recordError{"beginning transaction", err}
}
defer tx.Rollback() //nolint:errcheck // no-op once committed
// An id can repeat (seconds plus a rolling counter); the trace of the
// exchange it replaces must not stay attached to this one.
if _, err := tx.Exec(`DELETE FROM exchange_rewrites WHERE exchange_id=?`, id); err != nil {
return "", &recordError{"clearing rewrite trace", err}
}
res, err := tx.Exec(`INSERT OR REPLACE INTO exchanges(id,ts,host,method,url_template,url,status,content_type,req_len,resp_len,path)
VALUES(?,?,?,?,?,?,?,?,?,?,'')`, id, now.Unix(), host, method, tmpl, display, status, ct, len(f.Request.Body), 0)
VALUES(?,?,?,?,?,?,?,?,?,?,'')`, id, now.Unix(), host, method, tmpl, display, status, ct, len(rq.body), 0)
if err != nil {
return "", fmt.Errorf("writing index: %w", err)
return "", &recordError{"writing index", err}
}
rowid, err := res.LastInsertId()
if err != nil {
return "", fmt.Errorf("fetching rowid: %w", err)
return "", &recordError{"fetching rowid", err}
}
if _, err := tx.Exec(`INSERT OR REPLACE INTO exchange_bodies(id,req_head,req_body,req_blob,resp_head,resp_body,resp_blob)
VALUES(?,?,?,?,?,NULL,NULL)`, id, reqHead, reqB.inline, nullIfEmpty(reqB.hash), respHead); err != nil {
return "", fmt.Errorf("writing body: %w", err)
return "", &recordError{"writing body", err}
}
if reqB.hash != "" {
if _, err := tx.Exec(`INSERT OR IGNORE INTO blob_refs(hash,exchange_id) VALUES(?,?)`, reqB.hash, id); err != nil {
return "", fmt.Errorf("registering blob reference: %w", err)
return "", &recordError{"registering blob reference", err}
}
}
if err := writeTrace(tx, id, lines, trace); err != nil {
return "", err
}
if t.fts {
idx := strings.Join([]string{display, reqHead, reqB.index, respHead}, "\n")
if _, err := tx.Exec(`INSERT INTO ex_fts(rowid,content) VALUES(?,?)`, rowid, idx); err != nil {
return "", fmt.Errorf("writing full-text index: %w", err)
return "", &recordError{"writing full-text index", err}
}
}
if err := tx.Commit(); err != nil {
return "", fmt.Errorf("committing: %w", err)
return "", &recordError{"committing", err}
}
return id, nil
}
+221 -51
View File
@@ -22,6 +22,7 @@ import (
"os"
"path/filepath"
"regexp"
"slices"
"sort"
"strconv"
"strings"
@@ -92,6 +93,26 @@ CREATE TABLE IF NOT EXISTS stream_messages (
PRIMARY KEY (exchange_id, seq)
);
CREATE INDEX IF NOT EXISTS idx_stream_messages_ex ON stream_messages(exchange_id, seq);
-- Rewrite-rule trace of an exchange, in order. The exchange row keeps what the
-- client sent and what the target answered; these rows say what the rules
-- changed on the way. An exchange is rewritten when it has an 'applied' row.
CREATE TABLE IF NOT EXISTS exchange_rewrites (
exchange_id TEXT NOT NULL,
seq INTEGER NOT NULL,
phase TEXT NOT NULL, -- 'request' | 'response'
rule_id INTEGER, -- NULL on a global line
rule_snapshot TEXT, -- JSON, no sensitive action value
action TEXT,
field TEXT, -- 'method' | 'url' | 'header:<Name>' | 'body' | 'status'
outcome TEXT NOT NULL, -- 'applied' | 'skipped' | 'error'
reason TEXT NOT NULL DEFAULT '',
before_hash TEXT,
after_hash TEXT,
after_inline BLOB,
after_blob TEXT,
PRIMARY KEY (exchange_id, seq)
);
`
// ftsSchema is applied separately from indexSchema: a driver build without FTS5
@@ -160,6 +181,10 @@ const (
// and the catalog migration cannot drift apart.
const TrafficSearchDescription = "Query the target traffic the recording proxy has captured (host is required; accepts a bare host, host:port, or full URL, optionally filtered further by URL substring or body keyword). When a port is specified, only that service's traffic is returned, avoiding cross-talk between different ports on the same IP. body_contains runs a full-text search over the captured request/response headers and bodies, supporting any substring including Chinese (at least 3 characters). Returns only an ultra-light index (id/method/url/status/resp_len) with no response content; once results are non-empty, use traffic_get to verify the request/response of each one, then hand the IDs that actually support the current vulnerability to bind_finding_traffic. Returns 3 by default, at most 10 per page; use page to paginate when there are more results."
// TrafficGetDescription is the traffic_get description, kept here for the same
// reason as TrafficSearchDescription.
const TrafficGetDescription = "Fetch the raw request/response of one captured traffic record by id (truncated when too large). Use together with traffic_search to avoid re-curling. A WebSocket (status 101) or SSE (text/event-stream) record shows only its handshake here; read its messages with traffic_messages. When proxy rewrite rules changed the exchange, the result starts with a REWRITTEN line naming the rule ids, and shows the request as the client sent it and the response as the target sent it. traffic_search searches only these original values: it never finds a value a rewrite rule wrote."
// Traffic runs the recording proxy and owns the file tree + index.
type Traffic struct {
dir string
@@ -190,16 +215,23 @@ type Traffic struct {
closeOnce sync.Once
// pass is the set of hosts whose MITM interception failed for a proxy/protocol
// reason; connections to them are tunneled transparently (fail-open) so the
// request still reaches the target — unrecorded — instead of being killed.
pass sync.Map // hostname(string) -> struct{}
// request still reaches the target, unrecorded, instead of being killed.
// The value is the time the mark expires. After that, interception is tried again.
pass sync.Map // hostname(string) -> time.Time
// upstream is the global egress proxy every captured request is forwarded
// through (nil = dial targets directly). Both the intercepted and the
// transparent-passthrough paths honor it (go-mitmproxy's getUpstreamConn),
// so no host escapes it. Hot-swappable at runtime via SetUpstreamProxy.
upstream atomic.Pointer[url.URL]
// rewriteRules is the compiled snapshot of the rewrite rules, replaced as a
// whole by SetRewriteRules. The proxy does not apply it yet.
// whole by SetRewriteRules and applied by the sink (rewrite_flow.go).
rewriteRules atomic.Pointer[rewrite.Set]
// snaps keeps the original of each request a rule rewrote until its
// exchange is recorded (rewrite_flow.go). Nil on the zero value.
snaps *snapTable
// sweeping tracks the snapshot sweeper, which runs until Close. It is kept
// apart from reaping, which only ever holds work that finishes on its own.
sweeping sync.WaitGroup
}
// Open initializes the traffic tree, blob store and SQLite index under dir.
@@ -225,7 +257,7 @@ func Open(dir, addr string) (*Traffic, error) {
if err != nil {
return nil, err
}
t := &Traffic{dir: dir, addr: addr, db: db, closed: make(chan struct{})}
t := &Traffic{dir: dir, addr: addr, db: db, closed: make(chan struct{}), snaps: newSnapTable()}
if err := t.initIndex(); err != nil {
db.Close()
return nil, err
@@ -253,11 +285,11 @@ func Open(dir, addr string) (*Traffic, error) {
// can't intercept without breaking (see maybePassthrough). Those are tunneled
// transparently so the request still reaches the target instead of being killed.
p.SetShouldInterceptRule(func(req *http.Request) bool {
_, tunnel := t.pass.Load(hostOnly(req.Host))
return !tunnel
return !t.tunneling(hostOnly(req.Host))
})
p.AddAddon(&sink{t: t})
t.proxy = p
t.sweeping.Go(t.sweepSnapshots) // stops on t.closed; Close waits for it
return t, nil
}
@@ -358,8 +390,8 @@ func (t *Traffic) SetUpstreamProxy(raw string) error {
}
// SetRewriteRules publishes a compiled snapshot of the rewrite rules. The swap
// is atomic; nil clears the rules. The snapshot is stored only: the proxy does
// not apply rewrite rules yet, so capture is unchanged whatever it holds.
// is atomic; nil clears the rules. A flow already rewritten keeps the snapshot
// its request saw for its response as well.
func (t *Traffic) SetRewriteRules(s *rewrite.Set) { t.rewriteRules.Store(s) }
// RewriteRules returns the snapshot last published, nil when there is none.
@@ -406,6 +438,7 @@ func (t *Traffic) Close() error {
t.closeOnce.Do(func() { close(t.closed) })
}
t.reaping.Wait()
t.sweeping.Wait()
return t.db.Close()
}
@@ -430,19 +463,6 @@ type sink struct {
streams sync.Map // *mproxy.Flow of a live WebSocket/SSE stream -> *streamState (stream.go)
}
func (s *sink) Response(f *mproxy.Flow) {
if f.Request == nil || f.Response == nil {
return
}
s.t.record(f)
}
// RequestError fires when a request through an established MITM tunnel fails. If
// the failure looks proxy/protocol-caused (h2 quirks, HEAD-with-body, protocol
// errors) — not a plain target-unreachable error — we flag the host for
// transparent passthrough so future requests to it succeed instead of dying.
func (s *sink) RequestError(f *mproxy.Flow, err error) { s.t.maybePassthrough(f, err) }
// maybePassthrough marks a host to be tunneled transparently on the next
// connection, but only for errors the proxy itself caused — a target that is
// simply down/filtered would fail without us too, and must stay MITM'd+recorded.
@@ -454,9 +474,34 @@ func (t *Traffic) maybePassthrough(f *mproxy.Flow, err error) {
if host == "" {
return
}
if _, loaded := t.pass.LoadOrStore(host, struct{}{}); !loaded {
log.Printf("[traffic] MITM with %s failed, falling back to passthrough (this host now connects straight to the target and is no longer recorded, but requests proceed normally): %v", host, err)
if t.tunneling(host) {
return
}
until := time.Now().Add(passthroughTTL)
if _, loaded := t.pass.LoadOrStore(host, until); !loaded {
log.Printf("[traffic] MITM with %s failed, falling back to passthrough for %s (this request failed; the host connects straight to the target and is not recorded until then; the first request after the window fails again if interception still cannot handle it): %v", host, passthroughTTL, err)
}
}
// passthroughTTL is how long a host stays tunneled after a proxy-caused MITM
// failure. A host whose interception always fails pays one lost request per
// window: one per host per minute, where a mark that never expired cost one
// per process. The window is what lets a stale bypass end.
const passthroughTTL = time.Minute
// tunneling reports whether host is inside an unexpired passthrough mark.
// An expired mark is removed so the next connection tries interception again.
func (t *Traffic) tunneling(host string) bool {
v, ok := t.pass.Load(host)
if !ok {
return false
}
until, ok := v.(time.Time)
if !ok || !time.Now().Before(until) {
t.pass.CompareAndDelete(host, v)
return false
}
return true
}
// proxyCausedErr reports whether err indicates the interception layer (not the
@@ -475,52 +520,121 @@ func proxyCausedErr(err error) bool {
// full-text index. Nothing is written to a per-request directory — only bodies
// above maxInlineBody spill to the content-addressed blob store.
func (t *Traffic) record(f *mproxy.Flow) {
t.recordViews(flowRequestView(f.Request), flowResponseView(f.Response), nil)
}
// requestView is the request an exchange records: what the client sent, which
// is not the flow's request once a rule rewrote it.
type requestView struct {
method string
url *url.URL // nil when the original request is unavailable and Raw() is nil
proto string
header http.Header
// rawHost is the client's Host header (Raw().Host), "" when unknown.
rawHost string
body []byte
// unavailable marks a request rewritten by a rule whose original was not
// kept: only its method, URL and Host are known.
unavailable bool
}
// responseView is the response an exchange records: what the target answered.
type responseView struct {
status int
header http.Header
body []byte
}
func flowRequestView(r *mproxy.Request) requestView {
v := requestView{method: r.Method, url: r.URL, proto: r.Proto, header: r.Header, body: r.Body}
if raw := r.Raw(); raw != nil {
v.rawHost = raw.Host
}
return v
}
func flowResponseView(r *mproxy.Response) responseView {
return responseView{status: r.StatusCode, header: r.Header, body: r.Body}
}
// unavailableMarker stands for the headers and body of a request whose
// original was not kept (see rewrite_flow.go).
const unavailableMarker = "[original request unavailable]\n"
// recordViews writes one exchange from explicit views, with its rewrite trace,
// in one transaction: the exchange row, its bodies, blob references, the trace
// and the full-text index of the views only. A failure rolls everything back,
// so there is never a rewritten exchange without its trace. Without trace
// lines this is exactly what record always wrote.
func (t *Traffic) recordViews(rq requestView, rs responseView, lines []rewrite.TraceLine) {
// The write lock covers blob + index writes, so DeleteHost (and its blob GC)
// can run under the same lock without racing a concurrent record.
t.wmu.Lock()
defer t.wmu.Unlock()
host := f.Request.URL.Hostname()
method := f.Request.Method
tmpl := db.TemplatePath(f.Request.URL.EscapedPath())
var host, tmpl, url, uri string
if rq.url != nil {
host = rq.url.Hostname()
tmpl = db.TemplatePath(rq.url.EscapedPath())
url = rq.url.String()
uri = rq.url.RequestURI()
}
method := rq.method
now := time.Now()
id := t.newExchangeID(now)
ct := f.Response.Header.Get("Content-Type")
url := f.Request.URL.String()
reqHead := fmt.Sprintf("%s %s %s\n%s", method, f.Request.URL.RequestURI(), f.Request.Proto, requestHeaderLines(f.Request))
respHead := fmt.Sprintf("HTTP %d\n%s", f.Response.StatusCode, headerLines(f.Response.Header))
ct := rs.header.Get("Content-Type")
reqHead := requestHead(rq, uri)
respHead := fmt.Sprintf("HTTP %d\n%s", rs.status, headerLines(rs.header))
// Bodies are spilled before the transaction opens: blob writes are filesystem
// work and must not sit inside the SQLite write lock.
reqB := t.spill(f.Request.Body, f.Request.Header.Get("Content-Type"))
respB := t.spill(f.Response.Body, ct)
reqB := t.spill(rq.body, rq.header.Get("Content-Type"))
respB := t.spill(rs.body, ct)
trace := t.spillTrace(lines)
// A rewritten exchange is logged by host, step and rule ids only: its URL
// and the error text may carry a value a rule wrote.
rewritten, ruleIDs := appliedRules(lines)
fail := func(step string, err error) {
if rewritten {
log.Printf("[traffic] failed to record a rewritten exchange of %s (%s; rules %v)", host, step, ruleIDs)
return
}
log.Printf("[traffic] failed to record %s (%s): %v", url, step, err)
}
tx, err := t.db.Begin()
if err != nil {
log.Printf("[traffic] failed to record %s (beginning transaction): %v", url, err)
fail("beginning transaction", err)
return
}
defer tx.Rollback() //nolint:errcheck // no-op once committed
// An id can repeat (seconds plus a rolling counter); the trace of the
// exchange it replaces must not stay attached to this one.
if _, err := tx.Exec(`DELETE FROM exchange_rewrites WHERE exchange_id=?`, id); err != nil {
fail("clearing rewrite trace", err)
return
}
// path stays empty for db-resident exchanges; a non-empty path marks a legacy
// row whose bodies still live in the old on-disk tree (see Get).
res, err := tx.Exec(`INSERT OR REPLACE INTO exchanges(id,ts,host,method,url_template,url,status,content_type,req_len,resp_len,path)
VALUES(?,?,?,?,?,?,?,?,?,?,'')`,
id, now.Unix(), host, method, tmpl, url, f.Response.StatusCode, ct,
len(f.Request.Body), len(f.Response.Body))
id, now.Unix(), host, method, tmpl, url, rs.status, ct,
len(rq.body), len(rs.body))
if err != nil {
log.Printf("[traffic] failed to record %s (writing index): %v", url, err)
fail("writing index", err)
return
}
rowid, err := res.LastInsertId()
if err != nil {
log.Printf("[traffic] failed to record %s (fetching rowid): %v", url, err)
fail("fetching rowid", err)
return
}
if _, err := tx.Exec(`INSERT OR REPLACE INTO exchange_bodies(id,req_head,req_body,req_blob,resp_head,resp_body,resp_blob)
VALUES(?,?,?,?,?,?,?)`,
id, reqHead, reqB.inline, nullIfEmpty(reqB.hash), respHead, respB.inline, nullIfEmpty(respB.hash)); err != nil {
log.Printf("[traffic] failed to record %s (writing body): %v", url, err)
fail("writing body", err)
return
}
@@ -529,26 +643,51 @@ VALUES(?,?,?,?,?,?,?)`,
continue
}
if _, err := tx.Exec(`INSERT OR IGNORE INTO blob_refs(hash,exchange_id) VALUES(?,?)`, h, id); err != nil {
log.Printf("[traffic] failed to record %s (registering blob reference): %v", url, err)
fail("registering blob reference", err)
return
}
}
if err := writeTrace(tx, id, lines, trace); err != nil {
var re *recordError
errors.As(err, &re)
fail(re.step, re.err)
return
}
if t.fts {
// The index is fed from memory, so a body that spilled to _blobs is still
// fully searchable even though only its preview is stored inline.
// fully searchable even though only its preview is stored inline. Only the
// recorded views are indexed, never a value a rule wrote.
idx := strings.Join([]string{url, reqHead, reqB.index, respHead, respB.index}, "\n")
if _, err := tx.Exec(`INSERT INTO ex_fts(rowid,content) VALUES(?,?)`, rowid, idx); err != nil {
log.Printf("[traffic] failed to record %s (writing full-text index): %v", url, err)
fail("writing full-text index", err)
return
}
}
if err := tx.Commit(); err != nil {
log.Printf("[traffic] failed to record %s (committing): %v", url, err)
fail("committing", err)
}
}
// appliedRules reports whether a trace rewrote its exchange, with the ids of
// the rules that did, in order of first appearance.
func appliedRules(lines []rewrite.TraceLine) (bool, []int64) {
rewritten := false
var ids []int64
for _, l := range lines {
if l.Outcome != rewrite.OutcomeApplied {
continue
}
rewritten = true
if l.RuleID != 0 && !slices.Contains(ids, l.RuleID) {
ids = append(ids, l.RuleID)
}
}
return rewritten, ids
}
// newExchangeID names a recorded exchange: unix seconds plus a rolling sequence.
func (t *Traffic) newExchangeID(now time.Time) string {
n := t.seq.Add(1)
@@ -699,15 +838,35 @@ func headerLines(h map[string][]string) string {
return b.String()
}
// requestHeaderLines restores the HTTP Host header, which net/http stores on
// Request.Host rather than in Header. Keeping it in request.http makes the raw
// capture complete and directly replayable.
// requestHeaderLines is requestHeaderLinesOf for a flow's request.
func requestHeaderLines(req *mproxy.Request) string {
headers := req.Header.Clone()
v := flowRequestView(req)
return requestHeaderLinesOf(v.header, req.URL.Host, v.rawHost)
}
// requestHead is the head an exchange records for a request view: request
// line and headers, or only the Host when the original request is unavailable.
func requestHead(rq requestView, target string) string {
urlHost := ""
if rq.url != nil {
urlHost = rq.url.Host
}
if rq.unavailable {
return fmt.Sprintf("%s %s %s\n%s%s", rq.method, target, rq.proto, requestHeaderLinesOf(nil, urlHost, rq.rawHost), unavailableMarker)
}
return fmt.Sprintf("%s %s %s\n%s", rq.method, target, rq.proto, requestHeaderLinesOf(rq.header, urlHost, rq.rawHost))
}
// requestHeaderLinesOf restores the HTTP Host header, which net/http stores on
// Request.Host rather than in Header. Keeping it in request.http makes the raw
// capture complete and directly replayable. rawHost is the client's Host
// header (Raw().Host); urlHost stands in when it is empty.
func requestHeaderLinesOf(header http.Header, urlHost, rawHost string) string {
headers := header.Clone()
headers.Del("Host")
host := req.URL.Host
if raw := req.Raw(); raw != nil && strings.TrimSpace(raw.Host) != "" {
host = raw.Host
host := urlHost
if strings.TrimSpace(rawHost) != "" {
host = rawHost
}
var b strings.Builder
if host = strings.TrimSpace(host); host != "" {
@@ -1244,6 +1403,9 @@ func (t *Traffic) deleteWhere(tx *sql.Tx, where string, args ...any) (int64, err
if _, err := tx.Exec(`DELETE FROM stream_messages WHERE exchange_id IN (SELECT id FROM exchanges WHERE `+where+`)`, args...); err != nil {
return 0, fmt.Errorf("delete stream messages: %w", err)
}
if _, err := tx.Exec(`DELETE FROM exchange_rewrites WHERE exchange_id IN (SELECT id FROM exchanges WHERE `+where+`)`, args...); err != nil {
return 0, fmt.Errorf("delete rewrite trace: %w", err)
}
if _, err := tx.Exec(`DELETE FROM blob_refs WHERE exchange_id IN (SELECT id FROM exchanges WHERE `+where+`)`, args...); err != nil {
return 0, fmt.Errorf("delete blob references: %w", err)
}
@@ -2111,7 +2273,7 @@ func (t *Traffic) Tools() []actool.CoreTool {
get := actool.Build(actool.Spec{
Name: "traffic_get",
Description: "Fetch the raw request/response of one captured traffic record by id (truncated when too large). Use together with traffic_search to avoid re-curling. A WebSocket (status 101) or SSE (text/event-stream) record shows only its handshake here; read its messages with traffic_messages.",
Description: TrafficGetDescription,
Schema: map[string]any{
"type": "object",
"properties": map[string]any{"id": map[string]any{"type": "string", "description": "the id returned by traffic_search"}},
@@ -2126,7 +2288,15 @@ func (t *Traffic) Tools() []actool.CoreTool {
if err != nil {
return actool.Errorf(err.Error()), nil
}
return actool.Text("=== REQUEST ===\n" + clip(req, 2500) + "\n\n=== RESPONSE ===\n" + clip(resp, 4000)), nil
rewritten, ruleIDs, err := t.RewriteInfo(a.ID)
if err != nil {
return actool.Errorf(err.Error()), nil
}
head := ""
if rewritten {
head = fmt.Sprintf("=== REWRITTEN === rewrite rules %v changed this exchange in the proxy. Shown below: the request as the client sent it and the response as the target sent it, not the rewritten values.\n\n", ruleIDs)
}
return actool.Text(head + "=== REQUEST ===\n" + clip(req, 2500) + "\n\n=== RESPONSE ===\n" + clip(resp, 4000)), nil
},
})
+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: (