Compare commits

...
Author SHA1 Message Date
BaaRai c0e713d32f feat(engine): intent claim heartbeat, TTL and fencing token (S3c)
An intent claim was atomic but had no heartbeat, no expiry and no owner
token: startup reset every running intent to open unconditionally, so a
second instance on the same database stole live claims, and the worker
that lost its intent could still write the result.

- schema: last_heartbeat_at and unclaim_token on exploration_nodes
  (idempotent ADD COLUMN IF NOT EXISTS, nullable, no CHECK, no backfill).
- db: every claim (open->running and the paused->running message path)
  gets a fresh crypto/rand token and starts its lease in the same UPDATE.
  HeartbeatIntentClaim renews it for that token only.
- TTL: db.IntentClaimTTL = 90s, heartbeat every 15s
  (db.IntentClaimHeartbeatInterval), both on the database clock.
- takeover: ResetRunningIntents now reopens only claims whose heartbeat
  is older than the TTL, or NULL (rows claimed before the columns
  existed). The engine runs it per task every 15s as well as at startup.
- fencing: a heartbeat or result write whose token is not the current
  one returns db.ErrIntentClaimLost and writes nothing. All intent state
  writes in runIntent go through the fenced SettleIntentClaim /
  SettleIntentClaimBlocked; a rejected heartbeat cancels the stale run
  with the new work_claim_lost cause.

Behaviour change: after a restart, intents that were in flight are
resumed once their claim expires (at most 105s) instead of immediately.

Not in this change: fencing of the facts, findings and activity a worker
writes during its run; they are not guarded by the token.
2026-11-10 17:45:11 +01:00
BaaRai b51a0bf74b Merge pull request #175 from BaaRai/chore/server-tests-skip-without-dsn
server: skip Postgres-backed tests when no database is configured
2026-11-10 17:06:23 +01:00
BaaRai b847867e5c Merge pull request #174 from BaaRai/fix/feishu-digest-overflow
notify: pack Feishu digests against the serialized request body
2026-11-10 17:06:19 +01:00
BaaRai 9b7276d65a Merge pull request #173 from BaaRai/feat/notify-limits-ui
web: add the notification render limits to the notify settings page
2026-11-10 17:06:15 +01:00
BaaRai 542582e3bc notify: pack Feishu digests against the serialized request body
A Feishu digest sends every item as its own card element. The packing
counted the text of each line only, not the element around it (about 52
bytes of JSON per item, plus whatever the encoding escapes) nor the rest
of the body beyond a fixed 320-byte reserve. A digest of 500 short lines
therefore left as a single request of 41846 bytes, while Feishu rejects
a request body over 20 KB as a whole.

feishuCard now adds whole items while the request body, measured as it
is serialized, stays within feishuMaxCardBytes: each item element by its
JSON encoding, the card around the items (header, intro, platform link)
by encoding it for the number of items kept, and what Send adds around
the card (msg_type, timestamp, sign) as feishuEnvelopeBytes, which the
new test pins to the bytes on the wire.

Unchanged: the first item of a digest is always kept and its text is
truncated to the same budget, single pushes are built as before, and
the other channels still pack with packItemCount.
2026-11-10 16:28:30 +01:00
BaaRai a422a071f6 server: skip Postgres-backed tests when no database is configured
Without ARTEX_PG_DSN and without a config file, go test ./server/ failed
44 tests with "no database config found" instead of skipping them. The
tests go through NewManager and t.Fatal on its error: 35 through the
shared fixture trafficEvidenceServer (directly, or through
verificationFixture and newNotifyFixture), 2 through ingestServer, and 7
call NewManager themselves. The 7 already carry a skip on m.pg == nil,
but it sits after the t.Fatal and is never reached.

Add skipWithoutDSN, which calls db.DSN() and skips with the message the
db package and assembly_test.go already use ("no database config (%v) —
skipping"), and call it before NewManager at those 9 sites.

Nothing changes when a database is configured: db.DSN() succeeds, the
helper returns, and a NewManager error (for example an unreachable
Postgres) still fails the test.
2026-11-10 16:28:26 +01:00
BaaRai 0cc22cb794 web: add the notification render limits to the notify settings page
PR #172 made the summary length and the number of assets listed in an IM
message configurable, but only through the API. The Notifications page now
shows both next to the other global settings:

  Summary length (characters)   notify_summary_max_runes   0-4000
  Assets listed per finding     notify_assets_max_shown    0-50

The values are read from GET /api/settings (they are not part of
/notify/meta) and saved with the existing "Save global settings" PUT.
Each field carries a help text stating that 0 means no truncation.

A value that is not a whole number within the bounds marks the input
invalid and blocks the save with a toast. The check runs before the
request because the backend applies the fields of one PUT in order, so a
400 on a limit would leave the URL and digest interval already saved. An
empty field is not submitted and keeps the stored value.
2026-11-10 16:24:07 +01:00
BaaRai 3b6eb2fd2c Merge pull request #172 from BaaRai/feat/notify-configurable-limits
notify: make the summary and asset limits configurable
2026-11-10 16:16:30 +01:00
BaaRai 2ab1046746 Merge pull request #171 from BaaRai/fix/companies-overflow-count
db: report hidden asset count in malformed-ip warning suffix
2026-11-10 16:16:24 +01:00
BaaRai 809436e111 notify: make the summary and asset limits configurable
The IM renderers cut the summary of a single push at 120 characters and
listed at most 3 assets, as fixed constants. Both are now global settings
in the settings table, read by the delivery engine when it renders:

  notify_summary_max_runes   0-4000, default 120
  notify_assets_max_shown    0-50,   default 3

0 means no truncation and an unset key keeps 120 / 3. PUT /api/settings
answers 400 for a value outside the bounds. The limits travel on
notify.Message, so the notify package still does not touch the database.

With no truncation, nothing bounded a single item in a Feishu card, and
Feishu rejects an oversized request as a whole. feishuCard now truncates
an item's text as the final backstop, the role TruncateBytes plays in
markdownBody for DingTalk and WeCom. feishuMaxCardBytes goes from 24000
to 16000: Feishu custom bots cap the request body at 20 KB, which the old
value exceeded.

Refs #168.
2026-11-10 16:05:31 +01:00
BaaRai c84f124cb4 db: report hidden asset count in malformed-ip warning suffix
malformedIPAssetWarning appended "and N more" with N = total, the number
of offending assets, instead of the number left out of the sample. With 8
bad rows and 5 named it read "... and 8 more"; it now reads "... and 3
more". Same bug as the one fixed in notify/render.go.

Move the wording into malformedIPAssetWarningText so it can be tested
without Postgres, and add a test for the 8-of-5 and 5-of-5 cases.
2026-11-10 15:49:41 +01:00
BaaRai cf0b0c1002 Merge pull request #170 from BaaRai/fix/notify-overflow-count
notify: report hidden asset count in overflow suffix
2026-11-10 15:44:46 +01:00
29 changed files with 1480 additions and 106 deletions
+2
View File
@@ -47,6 +47,8 @@ var (
"The user paused a running Worker. This call was cancelled and the intent turned paused; all recorded intents, facts, vulnerabilities, and activity records are kept, and execution restarts from scratch after resuming")
AbortWorkCancelledByUser = cause("work_cancelled_by_user", "The user deleted this Worker intent",
"The user deleted a running Worker. This call was cancelled; after the Worker exits the write area, the server handles the intent per the user-chosen deletion mode — soft delete only marks it deleted and keeps all outputs, hard delete cascades to remove the intent and the downstream nodes supported only by it")
AbortWorkClaimLost = cause("work_claim_lost", "Another Worker took this intent over",
"This Worker's claim on the intent expired (no heartbeat reached the database within the claim TTL) and another Worker took the intent over, so its heartbeat was rejected. This run was cancelled and its result is discarded; the intent now belongs to the new claimer")
AbortWorkFinished = cause("work_finished", "Worker finished normally, context freed",
"The Worker finished normally, and the engine released its context resources in detachWork. This is not an interruption; if it appears in an interruption message, the cancel and finish events raced")
AbortPausedRaceGuard = cause("paused_race_guard", "Refused a new run while task is paused",
+1 -1
View File
@@ -141,7 +141,7 @@ func TestAbortCausesAreWellFormed(t *testing.T) {
all := []*AbortCause{
AbortPausedByUser, AbortPausedByOrchestrator, AbortTaskDeleted, AbortPausedOnReload,
AbortGoalMet, AbortSettleDrainTimeout, AbortKilledByPlanner, AbortWorkPausedByUser,
AbortWorkCancelledByUser, AbortWorkFinished, AbortPausedRaceGuard,
AbortWorkCancelledByUser, AbortWorkClaimLost, AbortWorkFinished, AbortPausedRaceGuard,
AbortChatStoppedByUser, AbortChatPausedWithTask, AbortChatTurnFinished,
AbortShutdown, AbortRunHardTimeout,
}
+8 -2
View File
@@ -633,14 +633,20 @@ LIMIT $1`, malformedIPAssetsSampled)
if total == 0 {
return "", nil
}
return malformedIPAssetWarningText(total, samples), nil
}
// malformedIPAssetWarningText words the warning for total offending assets, of
// which only samples are named; the ones left out are counted in the suffix.
func malformedIPAssetWarningText(total int, samples []string) string {
warning := fmt.Sprintf(
"%d assets have an ip field that is not a valid IP; skipped for IP/CIDR scope matching (these assets will not be attributed to a company by subnet rules): %s",
total, strings.Join(samples, ", "),
)
if total > len(samples) {
warning += fmt.Sprintf(" and %d more", total)
warning += fmt.Sprintf(" and %d more", total-len(samples))
}
return warning, nil
return warning
}
// UpdateScope replaces all scope rules for a company and reattributes.
+18
View File
@@ -458,3 +458,21 @@ func TestListCompanies(t *testing.T) {
t.Error("ListCompanies: created company not found")
}
}
func TestMalformedIPAssetWarningTextCountsOmitted(t *testing.T) {
samples := []string{"#1 a", "#2 b", "#3 c", "#4 d", "#5 e"}
// The suffix must count the assets left out, not repeat the total, otherwise
// the operator is told about more bad rows than exist.
got := malformedIPAssetWarningText(8, samples)
if !strings.HasPrefix(got, "8 assets have an ip field") {
t.Fatalf("the warning should lead with the total of 8, got %q", got)
}
if !strings.HasSuffix(got, ": #1 a, #2 b, #3 c, #4 d, #5 e and 3 more") {
t.Fatalf("8 assets with 5 named should note the 3 omitted, got %q", got)
}
// When every offending asset is named there is nothing to add.
got = malformedIPAssetWarningText(5, samples)
if !strings.HasSuffix(got, ": #1 a, #2 b, #3 c, #4 d, #5 e") {
t.Fatalf("5 assets with 5 named should have no suffix, got %q", got)
}
}
+140 -7
View File
@@ -2,7 +2,9 @@ package db
import (
"bytes"
"crypto/rand"
"database/sql"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
@@ -16,6 +18,33 @@ import (
// it to distinguish an expected control race (HTTP 409) from a storage failure.
var ErrIntentStateConflict = errors.New("intent state changed concurrently")
// ErrIntentClaimLost marks a heartbeat or a result write rejected by the claim
// fence: the caller's unclaim token is no longer the intent's current one (its
// claim expired and another worker took the intent over, or it was already
// settled). Nothing was written; the caller must stop working on that intent.
var ErrIntentClaimLost = errors.New("intent claim lost")
// IntentClaimTTL is how long an intent claim stays valid without a heartbeat. A
// running intent whose last_heartbeat_at is older than this (per the database
// clock) is considered abandoned — its worker crashed or its process is gone —
// and may be taken over; a younger claim is live and is never taken over. It is
// six heartbeat intervals, so a live worker loses its claim only after five
// consecutive missed heartbeats (about 75s of lost database connectivity).
const IntentClaimTTL = 90 * time.Second
// IntentClaimHeartbeatInterval is how often a busy worker renews its claim, and
// how often the engine looks for expired claims to take over.
const IntentClaimHeartbeatInterval = 15 * time.Second
// newUnclaimToken returns a fresh random claim token (128 bits, hex).
func newUnclaimToken() (string, error) {
var b [16]byte
if _, err := rand.Read(b[:]); err != nil {
return "", err
}
return hex.EncodeToString(b[:]), nil
}
// utf8Clean makes a string safe for a PostgreSQL text column. It (1) replaces
// invalid UTF-8 byte sequences with U+FFFD and (2) strips NUL (0x00) bytes.
// Tool output (nmap/curl/… stdout) can carry raw/truncated bytes that PostgreSQL's
@@ -309,9 +338,19 @@ func (s *ExplorationStore) DeleteGoal(id int64) error {
// is re-claimed. Called on startup: a 'running' intent with no live worker (a
// backend restart or crashed worker goroutine left it stuck) would otherwise spin
// forever in the UI. Workers resume from their transcript, so reopening is safe.
//
// Only an expired claim is taken over: last_heartbeat_at older than
// IntentClaimTTL, or NULL (a legacy row claimed before the lease columns
// existed, whose claimer never heartbeats). A live claim — including one held by
// another instance on the same database — is left alone. The expiry check and
// the takeover are one atomic UPDATE on the database clock, and clearing
// unclaim_token fences the previous claimer out. The engine also calls this
// periodically, so a claim that was still live at startup is taken over once it
// expires.
func (s *ExplorationStore) ResetRunningIntents() (int64, error) {
res, err := s.db.Exec(`UPDATE exploration_nodes SET state='open', completed_at=NULL, blocked_reason=NULL
WHERE exploration_id=$1 AND kind='intent' AND state='running'`, s.expID)
res, err := s.db.Exec(`UPDATE exploration_nodes SET state='open', completed_at=NULL, blocked_reason=NULL, unclaim_token=NULL
WHERE exploration_id=$1 AND kind='intent' AND state='running'
AND (last_heartbeat_at IS NULL OR last_heartbeat_at < now() - $2 * INTERVAL '1 second')`, s.expID, IntentClaimTTL.Seconds())
if err != nil {
return 0, err
}
@@ -1216,13 +1255,107 @@ WHERE exploration_id=$1 AND kind='goal' AND state='open' ORDER BY id`, s.expID)
// ClaimIntent atomically moves an open intent to running. Returns true if claimed.
func (s *ExplorationStore) ClaimIntent(id int64, owner string) (bool, error) {
res, err := s.db.Exec(`UPDATE exploration_nodes SET state='running', owner=$1
WHERE id=$2 AND exploration_id=$3 AND kind='intent' AND state='open'`, owner, id, s.expID)
token, err := s.ClaimIntentToken(id, owner)
return token != "", err
}
// ClaimIntentToken is ClaimIntent returning the claim's unclaim token ("" when
// the intent was not claimable). Every claim gets a fresh random token and
// starts its lease (last_heartbeat_at) in the same statement; the claimer must
// present the token to HeartbeatIntentClaim and to the SettleIntentClaim* writes.
func (s *ExplorationStore) ClaimIntentToken(id int64, owner string) (string, error) {
token, err := newUnclaimToken()
if err != nil {
return false, err
return "", err
}
n, _ := res.RowsAffected()
return n == 1, nil
res, err := s.db.Exec(`UPDATE exploration_nodes SET state='running', owner=$1, unclaim_token=$4, last_heartbeat_at=now()
WHERE id=$2 AND exploration_id=$3 AND kind='intent' AND state='open'`, owner, id, s.expID, token)
if err != nil {
return "", err
}
if n, _ := res.RowsAffected(); n != 1 {
return "", nil
}
return token, nil
}
// ClaimPausedIntentToken is the paused->running counterpart of ClaimIntentToken
// (the human-message path, which never goes through 'open'). It applies the same
// column updates as CompareAndSetIntentState(id, "paused", "running") and starts
// a claim with a fresh token. Returns "" when the intent is no longer paused.
func (s *ExplorationStore) ClaimPausedIntentToken(id int64) (string, error) {
token, err := newUnclaimToken()
if err != nil {
return "", err
}
res, err := s.db.Exec(`UPDATE exploration_nodes
SET state='running', blocked_reason=NULL, content_version=content_version+1, completed_at=NULL, unclaim_token=$3, last_heartbeat_at=now()
WHERE id=$1 AND exploration_id=$2 AND kind='intent' AND state='paused'`, id, s.expID, token)
if err != nil {
return "", err
}
if n, _ := res.RowsAffected(); n != 1 {
return "", nil
}
return token, nil
}
// HeartbeatIntentClaim renews the lease of the claim identified by token. It
// touches the row only while token is the running intent's current unclaim
// token; otherwise it returns ErrIntentClaimLost and writes nothing.
func (s *ExplorationStore) HeartbeatIntentClaim(id int64, token string) error {
res, err := s.db.Exec(`UPDATE exploration_nodes SET last_heartbeat_at=now()
WHERE id=$1 AND exploration_id=$2 AND kind='intent' AND state='running' AND unclaim_token=$3`, id, s.expID, token)
if err != nil {
return err
}
if n, _ := res.RowsAffected(); n != 1 {
return fmt.Errorf("%w: heartbeat for intent %d rejected", ErrIntentClaimLost, id)
}
return nil
}
// SettleIntentClaim is the fenced write of a worker's intent result: it moves
// the running intent to state and releases the claim, but only while token is
// still the intent's current unclaim token. A worker whose claim was taken over
// gets ErrIntentClaimLost and nothing is written. ErrIntentStateConflict means
// the claim is still the caller's but the intent left 'running' concurrently.
func (s *ExplorationStore) SettleIntentClaim(id int64, token, state string) error {
terminal := state == "done" || state == "blocked" || state == "exhausted" || state == "stopped"
res, err := s.db.Exec(`UPDATE exploration_nodes
SET state=$1, blocked_reason=NULL, content_version=content_version+1, completed_at = CASE WHEN $5 THEN now() ELSE NULL END, unclaim_token=NULL
WHERE id=$2 AND exploration_id=$3 AND kind='intent' AND state='running' AND unclaim_token=$4`, state, id, s.expID, token, terminal)
return s.settleIntentClaimResult(id, token, res, err)
}
// SettleIntentClaimBlocked is the fenced counterpart of SetIntentBlockedReason:
// it settles the running intent as blocked with reason under the same token
// check as SettleIntentClaim.
func (s *ExplorationStore) SettleIntentClaimBlocked(id int64, token, reason string) error {
res, err := s.db.Exec(`UPDATE exploration_nodes
SET state='blocked', blocked_reason=NULLIF($1,''), completed_at=now(), unclaim_token=NULL
WHERE id=$2 AND exploration_id=$3 AND kind='intent' AND state='running' AND unclaim_token=$4`, reason, id, s.expID, token)
return s.settleIntentClaimResult(id, token, res, err)
}
// settleIntentClaimResult turns a fenced settle that matched no row into the
// explicit rejection: claim lost unless the token is still the current one.
func (s *ExplorationStore) settleIntentClaimResult(id int64, token string, res sql.Result, err error) error {
if err != nil {
return err
}
if n, _ := res.RowsAffected(); n == 1 {
return nil
}
var current sql.NullString
err = s.db.QueryRow(`SELECT unclaim_token FROM exploration_nodes WHERE id=$1 AND exploration_id=$2 AND kind='intent'`, id, s.expID).Scan(&current)
if err != nil && err != sql.ErrNoRows {
return err
}
if current.Valid && current.String == token {
return fmt.Errorf("%w: intent %d is no longer in the running state", ErrIntentStateConflict, id)
}
return fmt.Errorf("%w: result write for intent %d rejected", ErrIntentClaimLost, id)
}
// Stats returns node counts grouped by kind (for dashboard).
+398
View File
@@ -0,0 +1,398 @@
package db
import (
"database/sql"
"errors"
"sync"
"testing"
"time"
)
// openClaimInstances opens the test database twice — two application instances
// sharing one database — and returns each instance's store for a fresh
// exploration.
func openClaimInstances(t *testing.T) (*DB, *ExplorationStore, *ExplorationStore) {
t.Helper()
dsn := testDSN(t)
a, err := Open(dsn)
if err != nil {
t.Skipf("postgres unavailable (%v) - skipping", err)
}
t.Cleanup(func() { a.Close() })
b, err := Open(dsn)
if err != nil {
t.Fatalf("open second instance: %v", err)
}
t.Cleanup(func() { b.Close() })
expID, err := a.CreateExploration("intent claim lease", "heartbeat, expiry and fencing")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { a.Exec(`DELETE FROM explorations WHERE id=$1`, expID) })
return a, a.Exploration(expID), b.Exploration(expID)
}
func addClaimIntent(t *testing.T, store *ExplorationStore) int64 {
t.Helper()
id, err := store.AddIntent(map[string]any{"summary": "leased"}, 1, nil, "planner")
if err != nil {
t.Fatal(err)
}
return id
}
func claimIntentToken(t *testing.T, store *ExplorationStore, id int64, owner string) string {
t.Helper()
token, err := store.ClaimIntentToken(id, owner)
if err != nil || token == "" {
t.Fatalf("claim by %s: token=%q err=%v", owner, token, err)
}
return token
}
// ageClaimHeartbeat moves the intent's last heartbeat age into the past, on the
// database clock the expiry check uses.
func ageClaimHeartbeat(t *testing.T, d *DB, id int64, age time.Duration) {
t.Helper()
if _, err := d.Exec(`UPDATE exploration_nodes SET last_heartbeat_at = now() - $2 * INTERVAL '1 second' WHERE id=$1`, id, age.Seconds()); err != nil {
t.Fatal(err)
}
}
type claimRow struct {
state string
token sql.NullString
blockedReason sql.NullString
heartbeatAge sql.NullFloat64 // seconds since last_heartbeat_at; NULL when never set
}
func readClaimRow(t *testing.T, d *DB, id int64) claimRow {
t.Helper()
var row claimRow
if err := d.QueryRow(`SELECT state, unclaim_token, blocked_reason, EXTRACT(EPOCH FROM now() - last_heartbeat_at)::float8
FROM exploration_nodes WHERE id=$1`, id).Scan(&row.state, &row.token, &row.blockedReason, &row.heartbeatAge); err != nil {
t.Fatal(err)
}
return row
}
func mustResetRunning(t *testing.T, store *ExplorationStore, want int64) {
t.Helper()
n, err := store.ResetRunningIntents()
if err != nil {
t.Fatal(err)
}
if n != want {
t.Fatalf("ResetRunningIntents reclaimed %d intents, want %d", n, want)
}
}
func TestIntentClaimLiveClaimIsNotReclaimed(t *testing.T) {
d, a, b := openClaimInstances(t)
id := addClaimIntent(t, a)
token := claimIntentToken(t, a, id, "work#1")
row := readClaimRow(t, d, id)
if row.state != "running" || row.token.String != token || !row.heartbeatAge.Valid {
t.Fatalf("claim did not start a lease: %+v", row)
}
// Neither the claiming instance nor a second instance on the same database
// may take a live claim over, by reset or by a fresh claim.
mustResetRunning(t, a, 0)
mustResetRunning(t, b, 0)
if other, err := b.ClaimIntentToken(id, "work#2"); err != nil || other != "" {
t.Fatalf("second instance claimed a live intent: token=%q err=%v", other, err)
}
// Still live just inside the TTL.
ageClaimHeartbeat(t, d, id, IntentClaimTTL-10*time.Second)
mustResetRunning(t, b, 0)
row = readClaimRow(t, d, id)
if row.state != "running" || row.token.String != token {
t.Fatalf("live claim changed: %+v, want running with token %q", row, token)
}
if err := a.HeartbeatIntentClaim(id, token); err != nil {
t.Fatalf("heartbeat of the live claimer: %v", err)
}
}
func TestIntentClaimExpiredClaimIsReclaimed(t *testing.T) {
d, a, b := openClaimInstances(t)
id := addClaimIntent(t, a)
old := claimIntentToken(t, a, id, "work#1")
ageClaimHeartbeat(t, d, id, IntentClaimTTL+time.Second)
mustResetRunning(t, b, 1)
row := readClaimRow(t, d, id)
if row.state != "open" || row.token.Valid {
t.Fatalf("expired claim not released: %+v, want open with no token", row)
}
fresh := claimIntentToken(t, b, id, "work#2")
if fresh == old {
t.Fatal("re-claim reused the previous unclaim token")
}
mustResetRunning(t, a, 0) // the new claim is live
}
// A row claimed before the lease columns existed has neither a heartbeat nor a
// token; SetIntentState produces exactly that shape. It counts as expired.
func TestIntentClaimLegacyRunningRowIsReclaimed(t *testing.T) {
d, a, b := openClaimInstances(t)
id := addClaimIntent(t, a)
if err := a.SetIntentState(id, "running"); err != nil {
t.Fatal(err)
}
row := readClaimRow(t, d, id)
if row.heartbeatAge.Valid || row.token.Valid {
t.Fatalf("legacy fixture carries lease data: %+v", row)
}
mustResetRunning(t, b, 1)
if row = readClaimRow(t, d, id); row.state != "open" {
t.Fatalf("legacy running row state=%q, want open", row.state)
}
claimIntentToken(t, b, id, "work#1")
}
func TestIntentClaimHeartbeatExtendsLease(t *testing.T) {
d, a, b := openClaimInstances(t)
id := addClaimIntent(t, a)
token := claimIntentToken(t, a, id, "work#1")
// Past the TTL but not yet taken over: the claimer's heartbeat renews it.
ageClaimHeartbeat(t, d, id, IntentClaimTTL+time.Second)
if err := a.HeartbeatIntentClaim(id, token); err != nil {
t.Fatalf("heartbeat: %v", err)
}
mustResetRunning(t, b, 0)
row := readClaimRow(t, d, id)
if row.state != "running" || row.token.String != token {
t.Fatalf("heartbeat did not keep the claim: %+v", row)
}
if !row.heartbeatAge.Valid || row.heartbeatAge.Float64 > 30 {
t.Fatalf("last_heartbeat_at not renewed: age=%+v", row.heartbeatAge)
}
// Without a further heartbeat the same claim does expire.
ageClaimHeartbeat(t, d, id, IntentClaimTTL+time.Second)
mustResetRunning(t, b, 1)
}
func TestIntentClaimStaleWorkerIsFencedAfterReclaim(t *testing.T) {
d, a, b := openClaimInstances(t)
id := addClaimIntent(t, a)
stale := claimIntentToken(t, a, id, "work#1")
ageClaimHeartbeat(t, d, id, IntentClaimTTL+time.Second)
mustResetRunning(t, b, 1)
assertFenced := func(when string) {
t.Helper()
before := readClaimRow(t, d, id)
if err := a.HeartbeatIntentClaim(id, stale); !errors.Is(err, ErrIntentClaimLost) {
t.Fatalf("%s: stale heartbeat err=%v, want ErrIntentClaimLost", when, err)
}
if err := a.SettleIntentClaim(id, stale, "done"); !errors.Is(err, ErrIntentClaimLost) {
t.Fatalf("%s: stale result write err=%v, want ErrIntentClaimLost", when, err)
}
if err := a.SettleIntentClaimBlocked(id, stale, IntentBlockedLLMQuota); !errors.Is(err, ErrIntentClaimLost) {
t.Fatalf("%s: stale blocked write err=%v, want ErrIntentClaimLost", when, err)
}
after := readClaimRow(t, d, id)
if after.state != before.state || after.token != before.token || after.blockedReason != before.blockedReason {
t.Fatalf("%s: a rejected stale write changed the intent: %+v -> %+v", when, before, after)
}
}
assertFenced("after takeover, before the re-claim")
current := claimIntentToken(t, b, id, "work#2")
ageClaimHeartbeat(t, d, id, time.Minute)
assertFenced("after the re-claim")
if row := readClaimRow(t, d, id); row.state != "running" || row.token.String != current || row.heartbeatAge.Float64 < 50 {
t.Fatalf("stale worker touched the new claim: %+v", row)
}
// The current claimer is unaffected and its result write releases the claim.
if err := b.HeartbeatIntentClaim(id, current); err != nil {
t.Fatalf("current claimer heartbeat: %v", err)
}
if err := b.SettleIntentClaim(id, current, "done"); err != nil {
t.Fatalf("current claimer result write: %v", err)
}
if row := readClaimRow(t, d, id); row.state != "done" || row.token.Valid {
t.Fatalf("settled intent: %+v, want done with no token", row)
}
if err := b.SettleIntentClaim(id, current, "blocked"); !errors.Is(err, ErrIntentClaimLost) {
t.Fatalf("second settle with a released token err=%v, want ErrIntentClaimLost", err)
}
}
func TestSettleIntentClaimBlockedAndStateConflict(t *testing.T) {
d, a, _ := openClaimInstances(t)
blocked := addClaimIntent(t, a)
token := claimIntentToken(t, a, blocked, "work#1")
if err := a.SettleIntentClaimBlocked(blocked, token, IntentBlockedLLMQuota); err != nil {
t.Fatal(err)
}
if row := readClaimRow(t, d, blocked); row.state != "blocked" || row.blockedReason.String != IntentBlockedLLMQuota || row.token.Valid {
t.Fatalf("blocked settle: %+v", row)
}
// The token is still current but the intent left 'running' through an
// unfenced path: that is a state conflict, not a lost claim.
moved := addClaimIntent(t, a)
token = claimIntentToken(t, a, moved, "work#1")
if err := a.SetIntentState(moved, "paused"); err != nil {
t.Fatal(err)
}
err := a.SettleIntentClaim(moved, token, "done")
if !errors.Is(err, ErrIntentStateConflict) || errors.Is(err, ErrIntentClaimLost) {
t.Fatalf("settle of a non-running intent err=%v, want ErrIntentStateConflict", err)
}
if row := readClaimRow(t, d, moved); row.state != "paused" {
t.Fatalf("rejected settle changed the state to %q", row.state)
}
}
func TestClaimPausedIntentTokenStartsLease(t *testing.T) {
d, a, b := openClaimInstances(t)
id := addClaimIntent(t, a)
first := claimIntentToken(t, a, id, "work#1")
if err := a.SettleIntentClaim(id, first, "paused"); err != nil {
t.Fatal(err)
}
ageClaimHeartbeat(t, d, id, IntentClaimTTL+time.Second) // the paused intent's old heartbeat is stale
token, err := a.ClaimPausedIntentToken(id)
if err != nil || token == "" || token == first {
t.Fatalf("claim paused: token=%q first=%q err=%v", token, first, err)
}
if again, err := b.ClaimPausedIntentToken(id); err != nil || again != "" {
t.Fatalf("second paused claim: token=%q err=%v, want none", again, err)
}
mustResetRunning(t, b, 0)
if row := readClaimRow(t, d, id); row.state != "running" || row.token.String != token {
t.Fatalf("paused claim: %+v", row)
}
if err := a.SettleIntentClaim(id, first, "done"); !errors.Is(err, ErrIntentClaimLost) {
t.Fatalf("previous run's token err=%v, want ErrIntentClaimLost", err)
}
}
// A heartbeat racing a takeover of the same expired claim must have exactly one
// winner: either the claim is renewed and stays, or it is taken over and the
// heartbeat is rejected. Both succeeding would be a stolen live claim.
func TestIntentClaimTakeoverRacesHeartbeatAtomically(t *testing.T) {
d, a, b := openClaimInstances(t)
id := addClaimIntent(t, a)
token := claimIntentToken(t, a, id, "work#1")
var renewed, takenOver int
for round := 0; round < 40; round++ {
ageClaimHeartbeat(t, d, id, IntentClaimTTL+time.Second)
var heartbeatErr, resetErr error
var reclaimed int64
var wg sync.WaitGroup
start := make(chan struct{})
wg.Add(2)
go func() {
defer wg.Done()
<-start
heartbeatErr = a.HeartbeatIntentClaim(id, token)
}()
go func() {
defer wg.Done()
<-start
reclaimed, resetErr = b.ResetRunningIntents()
}()
close(start)
wg.Wait()
if resetErr != nil {
t.Fatal(resetErr)
}
row := readClaimRow(t, d, id)
switch {
case heartbeatErr == nil && reclaimed == 0:
renewed++
if row.state != "running" || row.token.String != token {
t.Fatalf("round %d: renewed claim is %+v", round, row)
}
case errors.Is(heartbeatErr, ErrIntentClaimLost) && reclaimed == 1:
takenOver++
if row.state != "open" || row.token.Valid {
t.Fatalf("round %d: taken-over claim is %+v", round, row)
}
token = claimIntentToken(t, a, id, "work#1")
default:
t.Fatalf("round %d: heartbeat err=%v with %d reclaimed, want exactly one winner", round, heartbeatErr, reclaimed)
}
}
t.Logf("heartbeat won %d rounds, takeover won %d rounds", renewed, takenOver)
}
// The lease columns reach existing installs through schema.sql, which runs on
// every startup. This replays it on a table stripped back to its pre-upgrade
// shape, inside a transaction that is always rolled back.
func TestIntentClaimColumnsMigrateIdempotently(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Skipf("postgres unavailable (%v) - skipping", err)
}
defer d.Close()
tx, err := d.Begin()
if err != nil {
t.Fatal(err)
}
defer tx.Rollback() //nolint:errcheck // the test never commits
if _, err := tx.Exec(`ALTER TABLE exploration_nodes DROP COLUMN IF EXISTS last_heartbeat_at, DROP COLUMN IF EXISTS unclaim_token`); err != nil {
t.Fatalf("simulate old table: %v", err)
}
var legacy int64
if err := tx.QueryRow(`
WITH exp AS (INSERT INTO explorations(description, goal) VALUES ('legacy', 'pre-lease install') RETURNING id)
INSERT INTO exploration_nodes(exploration_id, kind, state, owner)
SELECT id, 'intent', 'running', 'work#1' FROM exp RETURNING id`).Scan(&legacy); err != nil {
t.Fatalf("insert legacy running intent: %v", err)
}
for run := 1; run <= 2; run++ {
if _, err := tx.Exec(schemaSQL); err != nil {
t.Fatalf("schema run %d: %v", run, err)
}
for col, typ := range map[string]string{"last_heartbeat_at": "timestamp with time zone", "unclaim_token": "text"} {
var dataType, nullable string
if err := tx.QueryRow(`SELECT data_type, is_nullable FROM information_schema.columns
WHERE table_schema=current_schema() AND table_name='exploration_nodes' AND column_name=$1`, col).Scan(&dataType, &nullable); err != nil {
t.Fatalf("schema run %d: column %s: %v", run, col, err)
}
if dataType != typ || nullable != "YES" {
t.Fatalf("schema run %d: column %s is %s nullable=%s, want %s nullable", run, col, dataType, nullable, typ)
}
}
var checks int
if err := tx.QueryRow(`SELECT count(*) FROM pg_constraint
WHERE conrelid='exploration_nodes'::regclass AND contype='c'
AND (pg_get_constraintdef(oid) LIKE '%last_heartbeat_at%' OR pg_get_constraintdef(oid) LIKE '%unclaim_token%')`).Scan(&checks); err != nil {
t.Fatal(err)
}
if checks != 0 {
t.Fatalf("schema run %d: %d CHECK constraints on the lease columns, want none", run, checks)
}
var state string
var heartbeat sql.NullTime
var token sql.NullString
if err := tx.QueryRow(`SELECT state, last_heartbeat_at, unclaim_token FROM exploration_nodes WHERE id=$1`, legacy).Scan(&state, &heartbeat, &token); err != nil {
t.Fatal(err)
}
if state != "running" || heartbeat.Valid || token.Valid {
t.Fatalf("schema run %d: legacy row state=%q heartbeat=%v token=%v, want running with NULL lease columns", run, state, heartbeat, token)
}
}
}
+7
View File
@@ -201,6 +201,13 @@ ALTER TABLE exploration_nodes ADD COLUMN IF NOT EXISTS delete_reason TEXT;
-- a node most recently went from "has a live downstream branch" to none (NULL = hot).
ALTER TABLE exploration_nodes ADD COLUMN IF NOT EXISTS content_version INT NOT NULL DEFAULT 0;
ALTER TABLE exploration_nodes ADD COLUMN IF NOT EXISTS cold_since_round BIGINT;
-- Intent claim lease: unclaim_token is the fencing token of the current claim (fresh
-- per claim, cleared when the claim is settled or taken over); last_heartbeat_at is
-- the claimer's latest heartbeat. A running intent whose heartbeat is older than
-- db.IntentClaimTTL may be taken over. Both are NULL on rows claimed before these
-- columns existed, which counts as expired.
ALTER TABLE exploration_nodes ADD COLUMN IF NOT EXISTS last_heartbeat_at TIMESTAMPTZ;
ALTER TABLE exploration_nodes ADD COLUMN IF NOT EXISTS unclaim_token TEXT;
-- ck_node_kind: existing installs predate the 'digest' kind — recreate to allow it.
DO $$
BEGIN
+24
View File
@@ -79,4 +79,28 @@ type Message struct {
// HomeURL is the platform dashboard address (global public_base_url); empty
// means no dashboard entry is included.
HomeURL string
// Limits are the truncation limits to render with; nil means the defaults.
// A pointer because the zero value is meaningful (no truncation).
Limits *Limits
}
// Limits are the render-time truncation limits of a message, configured
// globally (see the server's notify_summary_max_runes / notify_assets_max_shown
// settings). In both fields 0 means no truncation; each channel's own length
// cap remains the final guard.
type Limits struct {
// SummaryRunes is how many characters the summary of a single push is
// compressed to.
SummaryRunes int
// AssetsShown is the maximum number of assets listed per vulnerability.
AssetsShown int
}
// limits returns the limits to render with, falling back to the defaults when
// none were passed in.
func (m Message) limits() Limits {
if m.Limits == nil {
return Limits{SummaryRunes: DefaultMaxSummaryRunes, AssetsShown: DefaultMaxAssetsShown}
}
return *m.Limits
}
+68 -30
View File
@@ -121,52 +121,90 @@ func feishuSeverityTemplate(severity string) string {
}
}
// feishuMaxCardBytes is a conservative cap on card content. Feishu enforces a
// size limit on cards and rejects the whole message when exceeded; pick a value
// clearly below the official limit to also cover JSON wrapping overhead.
const feishuMaxCardBytes = 24000
// feishuMaxCardBytes is a conservative cap on card content. Feishu custom bots
// reject a request body over 20 KB as a whole (not truncated); pick a value
// clearly below that limit to also cover JSON wrapping overhead.
const feishuMaxCardBytes = 16000
// feishuEnvelopeBytes is the size of what Send serializes around the card when a
// signing secret is configured (without one the request is smaller):
//
// {"card":…,"msg_type":"interactive","sign":"<44 characters>","timestamp":"<10 digits>"}
const feishuEnvelopeBytes = 113
// feishuCard builds the interactive card and returns it along with the **number
// of items actually written**. kept serves the same purpose as in markdownBody:
// only items that actually made it into the card should be marked as sent.
func feishuCard(m Message) (map[string]any, int) {
lim := m.limits()
// budget is the final truncation backstop for one item's text, the same role
// TruncateBytes plays in markdownBody. With the summary or asset limit set to
// 0 an item has no other bound, and an oversized card loses the whole message.
budget := feishuMaxCardBytes - markdownReservedBytes
card := map[string]any{
"config": map[string]any{"wide_screen_mode": true},
"header": map[string]any{"title": map[string]any{"tag": "plain_text", "content": markdownTitle(m)}},
}
if len(m.Items) > 0 {
card["header"].(map[string]any)["template"] = feishuSeverityTemplate(m.Items[0].Severity)
}
elements := []any{}
kept := 0
if m.Batch {
// Pack whole items first, then assemble the header: the header must state
// "the remaining N items will continue in the next message", and N must
// come from the number of items that actually fit.
kept = packItemCount(m.Items, feishuMaxCardBytes, markdownReservedBytes, "", byteSize, func(it Item, idx int) string {
return feishuBatchLine(it, idx+1)
})
items := m.Items[:kept]
elements = append(elements, feishuMarkdownDiv(markdownBatchIntro(m, items, len(m.Items))))
for i, it := range items {
elements = append(elements, feishuMarkdownDiv(feishuBatchLine(it, i+1)))
// digest assembles the elements of a digest card around the lines of its
// first n items. The intro must state "the remaining N items will continue
// in the next message", and N must come from the number of items that
// actually fit.
digest := func(n int, lines []any) []any {
out := []any{feishuMarkdownDiv(markdownBatchIntro(m, m.Items[:n], len(m.Items)))}
out = append(out, lines...)
if m.HomeURL != "" {
out = append(out, feishuButton("View all on the platform", m.HomeURL))
}
return out
}
if m.HomeURL != "" {
elements = append(elements, feishuButton("View all on the platform", m.HomeURL))
// Pack whole items (see packItemCount) against the request body as it will
// be serialized, not against the text of the lines. Each line is sent as
// its own element: about 52 bytes of JSON around the text, plus whatever
// the encoding escapes. Counted as text alone, several hundred short lines
// left as one request of more than twice the 20 KB limit. The rest of the
// body is measured too: it changes with the number of items kept (the
// intro) and with the platform link.
//
// The first item is always kept: otherwise one oversized item would jam
// the whole batch in place. Its text is truncated to budget.
var lines []any
used := 0
for i, it := range m.Items {
line := feishuMarkdownDiv(TruncateBytes(feishuBatchLine(it, i+1, lim), budget))
used += feishuJSONSize(line) + 1 // the element and its separating comma
card["elements"] = digest(i+1, nil)
if i > 0 && feishuEnvelopeBytes+feishuJSONSize(card)+used > feishuMaxCardBytes {
break
}
lines = append(lines, line)
}
kept = len(lines)
elements = digest(kept, lines)
} else if len(m.Items) > 0 {
kept = 1
it := m.Items[0]
elements = append(elements, feishuMarkdownDiv(feishuItemLines(it)))
elements = append(elements, feishuMarkdownDiv(TruncateBytes(feishuItemLines(it, lim), budget)))
if it.DetailURL != "" {
elements = append(elements, feishuButton("View details", it.DetailURL))
}
}
card := map[string]any{
"config": map[string]any{"wide_screen_mode": true},
"header": map[string]any{"title": map[string]any{"tag": "plain_text", "content": markdownTitle(m)}},
"elements": elements,
}
if len(m.Items) > 0 {
card["header"].(map[string]any)["template"] = feishuSeverityTemplate(m.Items[0].Severity)
}
card["elements"] = elements
return card, kept
}
// feishuJSONSize returns the number of bytes v takes in the request body.
func feishuJSONSize(v any) int {
raw, _ := json.Marshal(v)
return len(raw)
}
func feishuMarkdownDiv(content string) map[string]any {
return map[string]any{"tag": "div", "text": map[string]any{"tag": "lark_md", "content": content}}
}
@@ -189,7 +227,7 @@ func feishuButton(label, url string) map[string]any {
// emphasis, so every field coming from outside goes through markdownText
// (single-lining + escaping) — otherwise a single vulnerability title could turn
// into a clickable external link inside Feishu.
func feishuItemLines(it Item) string {
func feishuItemLines(it Item, lim Limits) string {
out := fmt.Sprintf("**%s · %s**", SeverityLabel(it.Severity), markdownText(it.Title(), 0))
if it.IsStatusChange() {
out += fmt.Sprintf("\n**Status change**: %s → %s",
@@ -198,11 +236,11 @@ func feishuItemLines(it Item) string {
if it.VulnClass != "" && it.VulnClass != it.Title() {
out += fmt.Sprintf("\n**Type**: %s", markdownText(it.VulnClass, 0))
}
if a := assetLine(it.Assets, maxAssetsShown); a != "" {
if a := assetLine(it.Assets, lim.AssetsShown); a != "" {
out += fmt.Sprintf("\n**Assets**: %s", markdownText(a, 0))
}
if it.Summary != "" {
if s := markdownText(it.Summary, maxSummaryRunes); s != "" {
if s := markdownText(it.Summary, lim.SummaryRunes); s != "" {
out += fmt.Sprintf("\n**Summary**: %s", s)
}
}
@@ -210,9 +248,9 @@ func feishuItemLines(it Item) string {
}
// feishuBatchLine renders one entry of a digest card.
func feishuBatchLine(it Item, index int) string {
func feishuBatchLine(it Item, index int, lim Limits) string {
line := fmt.Sprintf("**%d. %s · %s**", index, SeverityLabel(it.Severity), markdownText(it.Title(), 0))
if a := assetLine(it.Assets, maxAssetsShown); a != "" {
if a := assetLine(it.Assets, lim.AssetsShown); a != "" {
line += " — " + markdownText(a, 0)
}
return line
+6 -6
View File
@@ -39,10 +39,10 @@ func htmlBody(m Message, maxRunes int) string {
if m.Batch {
b.WriteString(htmlBatchIntro(m))
for _, it := range m.Items {
b.WriteString(htmlItem(it, false))
b.WriteString(htmlItem(it, false, m.limits()))
}
} else if len(m.Items) > 0 {
b.WriteString(htmlItem(m.Items[0], true))
b.WriteString(htmlItem(m.Items[0], true, m.limits()))
}
if m.HomeURL != "" {
fmt.Fprintf(&b, `<p style="margin:16px 0 0;"><a href="%s" style="color:#1677ff;">View all on the platform</a></p>`, htmlEscapeAttr(m.HomeURL))
@@ -79,7 +79,7 @@ func htmlBatchIntro(m Message) string {
// htmlItem renders a single vulnerability. full=true includes the summary and
// backlink (single push); false compresses it into one line (digest list).
func htmlItem(it Item, full bool) string {
func htmlItem(it Item, full bool, lim Limits) string {
color := htmlSeverityColor(it.Severity)
var b strings.Builder
if full {
@@ -92,7 +92,7 @@ func htmlItem(it Item, full bool) string {
if !full {
var extras []string
if a := assetLine(it.Assets, maxAssetsShown); a != "" {
if a := assetLine(it.Assets, lim.AssetsShown); a != "" {
extras = append(extras, htmlEscape(a))
}
if it.Summary != "" {
@@ -112,10 +112,10 @@ func htmlItem(it Item, full bool) string {
if it.VulnClass != "" && it.VulnClass != it.Title() {
fmt.Fprintf(&b, `<div><b>Type</b>: %s</div>`, htmlEscape(it.VulnClass))
}
if a := assetLine(it.Assets, maxAssetsShown); a != "" {
if a := assetLine(it.Assets, lim.AssetsShown); a != "" {
fmt.Fprintf(&b, `<div><b>Assets</b>: %s</div>`, htmlEscape(a))
}
if s := OneLine(it.Summary, maxSummaryRunes); s != "" {
if s := OneLine(it.Summary, lim.SummaryRunes); s != "" {
fmt.Fprintf(&b, `<div><b>Summary</b>: %s</div>`, htmlEscape(s))
}
if it.DetailURL != "" {
+183
View File
@@ -0,0 +1,183 @@
package notify
import (
"context"
"io"
"net/http"
"net/http/httptest"
"strings"
"testing"
"unicode/utf8"
)
// This file covers the configurable render limits (Message.Limits). The summary
// length and the number of assets listed used to be the fixed constants 120 / 3;
// they now come from the caller, with 0 meaning "no truncation" and nil meaning
// "the old defaults".
// limitsItem returns an item whose summary (200 characters) and asset list (8)
// both exceed the defaults. It contains no markdown/HTML metacharacters, so
// every renderer emits the text verbatim and one set of assertions fits all.
func limitsItem() Item {
assets := make([]string, 8)
for i := range assets {
assets[i] = "host" + itoa(i+1)
}
return Item{Severity: "high", Name: "title", Summary: strings.Repeat("Z", 200), Assets: assets}
}
// feishuContent returns the lark_md text of the card's element idx.
func feishuContent(t *testing.T, m Message, idx int) string {
t.Helper()
card, _ := feishuCard(m)
elements, _ := card["elements"].([]any)
if idx >= len(elements) {
t.Fatalf("card has %d elements, cannot get element %d", len(elements), idx)
}
div, _ := elements[idx].(map[string]any)
text, _ := div["text"].(map[string]any)
content, _ := text["content"].(string)
return content
}
// limitsRenderings returns the body of every channel family that applies the
// limits. For a digest, the Feishu entry is the first item line (element 0 is
// the intro).
func limitsRenderings(t *testing.T, m Message) map[string]string {
t.Helper()
md, _ := markdownBody(m, 0)
tg, _ := telegramHTML(m)
feishuIdx := 0
if m.Batch {
feishuIdx = 1
}
return map[string]string{
"markdown": md,
"feishu": feishuContent(t, m, feishuIdx),
"telegram": tg,
"email": htmlBody(m, 0),
}
}
func TestMessageLimitsApplyToSinglePush(t *testing.T) {
cases := []struct {
name string
lim *Limits
must []string
wrong []string
}{
{
name: "unset keeps the 120 / 3 defaults",
lim: nil,
must: []string{strings.Repeat("Z", 119) + ellipsis, "host1, host2, host3 and 5 more"},
wrong: []string{strings.Repeat("Z", 120), "host4"},
},
{
name: "zero means no truncation",
lim: &Limits{},
must: []string{strings.Repeat("Z", 200), "host7, host8"},
wrong: []string{ellipsis, " more"},
},
{
name: "custom values",
lim: &Limits{SummaryRunes: 10, AssetsShown: 1},
must: []string{strings.Repeat("Z", 9) + ellipsis, "host1 and 7 more"},
wrong: []string{strings.Repeat("Z", 10), "host2"},
},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
m := Message{Items: []Item{limitsItem()}, Limits: tc.lim}
for channel, got := range limitsRenderings(t, m) {
for _, want := range tc.must {
if !strings.Contains(got, want) {
t.Errorf("%s: missing %q:\n%s", channel, want, got)
}
}
for _, bad := range tc.wrong {
if strings.Contains(got, bad) {
t.Errorf("%s: %q should not appear:\n%s", channel, bad, got)
}
}
}
})
}
}
// TestMessageLimitsApplyToDigestAssets covers the digest lines, which list the
// assets too. The digest summary is not governed by Limits.SummaryRunes: it
// stays at its own fixed 60 characters (markdown and email), a digest being a
// list of one-liners.
func TestMessageLimitsApplyToDigestAssets(t *testing.T) {
m := Message{Batch: true, Items: []Item{limitsItem()}}
for channel, got := range limitsRenderings(t, m) {
if !strings.Contains(got, "host1, host2, host3 and 5 more") {
t.Errorf("%s: unset should keep 3 assets:\n%s", channel, got)
}
}
m.Limits = &Limits{}
for channel, got := range limitsRenderings(t, m) {
if !strings.Contains(got, "host7, host8") || strings.Contains(got, " more") {
t.Errorf("%s: 0 should list every asset:\n%s", channel, got)
}
if strings.Contains(got, strings.Repeat("Z", 60)) {
t.Errorf("%s: the digest summary should stay within 60 characters:\n%s", channel, got)
}
}
}
// TestFeishuUntruncatedItemStaysWithinBodyLimit is the guard that goes with
// "0 = no truncation". Feishu custom bots reject a request body over 20 KB as a
// whole, so an unbounded summary or asset list would not arrive shortened — it
// would not arrive at all. The body measured here is the real one sent on the
// wire, signature included.
func TestFeishuUntruncatedItemStaysWithinBodyLimit(t *testing.T) {
const feishuBodyLimit = 20000
huge := limitsItem()
huge.DetailURL = "https://artex.local/function/findings/detail?id=42"
// 36000 bytes of CJK: also checks that the cut lands on a character boundary.
huge.Summary = strings.Repeat("漏洞摘要", 3000)
huge.Assets = nil
for i := 0; i < 1500; i++ {
huge.Assets = append(huge.Assets, "host"+itoa(i+1)+".example.com")
}
cases := []struct {
name string
m Message
idx int
}{
{"single push", Message{Items: []Item{huge}, Limits: &Limits{}}, 0},
{"digest whose first item is oversized", Message{
Batch: true, WindowMinutes: 30, HomeURL: "https://artex.local/function/findings",
Items: []Item{huge, huge}, Limits: &Limits{},
}, 1},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
size := 0
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
raw, _ := io.ReadAll(r.Body)
size = len(raw)
_, _ = io.WriteString(w, `{"code":0,"msg":"success"}`)
}))
defer srv.Close()
kept, err := (feishuChannel{}).Send(context.Background(), map[string]any{"webhook": srv.URL, "secret": "SECtest123"}, tc.m)
if err != nil {
t.Fatalf("delivery failed: %v", err)
}
if kept != 1 {
t.Fatalf("exactly the first item should be reported as delivered, got %d", kept)
}
if size == 0 || size > feishuBodyLimit {
t.Fatalf("request body of %d bytes, want 1..%d", size, feishuBodyLimit)
}
content := feishuContent(t, tc.m, tc.idx)
if !utf8.ValidString(content) || !strings.HasSuffix(content, ellipsis) {
t.Fatalf("the item should be cut on a character boundary and end with an ellipsis, got tail %q", content[len(content)-12:])
}
})
}
}
+16 -16
View File
@@ -9,16 +9,16 @@ import (
// (DingTalk, WeCom). Feishu uses card JSON, Telegram uses HTML, and email uses
// HTML; each renders in its own adapter.
// maxAssetsShown is the maximum number of assets listed in a message. A
// vulnerability can be anchored to dozens of assets; listing them all would blow
// up the message with no informational value — nobody reads the 4th domain
// onwards in an IM.
const maxAssetsShown = 3
// DefaultMaxAssetsShown is the default maximum number of assets listed in a
// message (Limits.AssetsShown). A vulnerability can be anchored to dozens of
// assets; listing them all would blow up the message with no informational
// value — nobody reads the 4th domain onwards in an IM.
const DefaultMaxAssetsShown = 3
// maxSummaryRunes is how many characters the summary is compressed to. An IM
// message is a "go look at the details" hint, not the report itself; the full
// content lives on the platform.
const maxSummaryRunes = 120
// DefaultMaxSummaryRunes is the default number of characters the summary is
// compressed to (Limits.SummaryRunes). An IM message is a "go look at the
// details" hint, not the report itself; the full content lives on the platform.
const DefaultMaxSummaryRunes = 120
// markdownReservedBytes is reserved for the message header (digest line +
// severity distribution + possible truncation notice) and footer (platform
@@ -114,7 +114,7 @@ func markdownBody(m Message, maxBytes int) (string, int) {
return "", 0
}
var b strings.Builder
writeItem(&b, m.Items[0], "", true)
writeItem(&b, m.Items[0], "", true, m.limits())
// A single message is sent even if oversized (with final truncation as
// the backstop): partial information about one vulnerability is better
// than sending nothing at all.
@@ -127,7 +127,7 @@ func markdownBody(m Message, maxBytes int) (string, int) {
}
kept := packItemCount(m.Items, maxBytes, markdownReservedBytes, footer, byteSize, func(it Item, idx int) string {
var b strings.Builder
writeItem(&b, it, fmt.Sprintf("%d. ", idx+1), false)
writeItem(&b, it, fmt.Sprintf("%d. ", idx+1), false, m.limits())
return b.String()
})
@@ -135,7 +135,7 @@ func markdownBody(m Message, maxBytes int) (string, int) {
var b strings.Builder
b.WriteString(markdownBatchIntro(m, items, len(m.Items)))
for i, it := range items {
writeItem(&b, it, fmt.Sprintf("%d. ", i+1), false)
writeItem(&b, it, fmt.Sprintf("%d. ", i+1), false, m.limits())
}
b.WriteString(footer)
return TruncateBytes(b.String(), maxBytes), kept
@@ -191,13 +191,13 @@ func markdownBatchIntro(m Message, items []Item, total int) string {
// markdownText: single-lining + escaping. The backlink is built from the
// admin-configured public_base_url, is not untrusted content, and must be a
// clickable link, so it is emitted as-is.
func writeItem(b *strings.Builder, it Item, prefix string, single bool) {
func writeItem(b *strings.Builder, it Item, prefix string, single bool, lim Limits) {
line := fmt.Sprintf("%s**%s · %s**", prefix, SeverityLabel(it.Severity), markdownText(it.Title(), 0))
if !single {
// Digest mode: single-line presentation, with assets and summary
// compressed and appended.
var extras []string
if a := assetLine(it.Assets, maxAssetsShown); a != "" {
if a := assetLine(it.Assets, lim.AssetsShown); a != "" {
extras = append(extras, markdownText(a, 0))
}
if it.Summary != "" {
@@ -217,11 +217,11 @@ func writeItem(b *strings.Builder, it Item, prefix string, single bool) {
if it.VulnClass != "" && it.VulnClass != it.Title() {
fmt.Fprintf(b, "**Type**: %s\n", markdownText(it.VulnClass, 0))
}
if a := assetLine(it.Assets, maxAssetsShown); a != "" {
if a := assetLine(it.Assets, lim.AssetsShown); a != "" {
fmt.Fprintf(b, "**Assets**: %s\n", markdownText(a, 0))
}
if it.Summary != "" {
if s := markdownText(it.Summary, maxSummaryRunes); s != "" {
if s := markdownText(it.Summary, lim.SummaryRunes); s != "" {
fmt.Fprintf(b, "**Summary**: %s\n", s)
}
}
+112 -1
View File
@@ -1,6 +1,11 @@
package notify
import (
"context"
"encoding/json"
"io"
"net/http"
"net/http/httptest"
"strings"
"testing"
"unicode/utf8"
@@ -105,6 +110,112 @@ func TestFeishuPackingReportsKept(t *testing.T) {
}
}
// TestFeishuDigestBodiesStayWithinCardLimit covers digests of many short items.
//
// Every digest line is sent as its own card element, which costs about 52 bytes
// of JSON around the text plus whatever the encoding escapes. The packing used
// to count the text only, so a digest of several hundred short lines left as one
// request of more than twice Feishu's 20 KB limit, and Feishu rejects such a
// request as a whole.
//
// The digest is sent the way the delivery engine does it: the items a message
// did not hold go into the next one. The bodies measured are the real ones sent
// on the wire, signature included. No item may be lost on the way: across the
// messages, every item appears exactly once and in order.
func TestFeishuDigestBodiesStayWithinCardLimit(t *testing.T) {
const total = 500
short := batchMsg(total)
for i := range short.Items {
short.Items[i].Assets = nil
}
// The JSON encoding escapes quotes, angle brackets and ampersands, and the
// backslashes the lark_md escaping put in before it: these titles take
// several times their length once serialized.
escaped := batchMsg(total)
for i := range escaped.Items {
escaped.Items[i].Name = `<a href="x">R&D</a> vuln` + itoa(i+1)
}
cases := []struct {
name string
m Message
}{
{"short lines without assets", short},
{"short lines with one asset", batchMsg(total)},
{"lines that grow when serialized", escaped},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
var raw []byte
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
raw, _ = io.ReadAll(r.Body)
_, _ = io.WriteString(w, `{"code":0,"msg":"success"}`)
}))
defer srv.Close()
cfg := map[string]any{"webhook": srv.URL, "secret": "SECtest123"}
m := tc.m
seen, messages := 0, 0
for len(m.Items) > 0 {
kept, err := (feishuChannel{}).Send(context.Background(), cfg, m)
if err != nil {
t.Fatalf("message %d: delivery failed: %v", messages+1, err)
}
messages++
if len(raw) > feishuMaxCardBytes {
t.Fatalf("message %d: request body of %d bytes exceeds the limit of %d (%d of %d items left to send)",
messages, len(raw), feishuMaxCardBytes, len(m.Items), total)
}
var body struct {
Card json.RawMessage `json:"card"`
}
var card struct {
Elements []struct {
Tag string `json:"tag"`
Text struct {
Content string `json:"content"`
} `json:"text"`
} `json:"elements"`
}
if err := json.Unmarshal(raw, &body); err != nil {
t.Fatalf("message %d: request body is not valid JSON: %v", messages, err)
}
if err := json.Unmarshal(body.Card, &card); err != nil {
t.Fatalf("message %d: card is not valid JSON: %v", messages, err)
}
// The packing counts what Send adds around the card as a constant.
if got := len(raw) - len(body.Card); got != feishuEnvelopeBytes {
t.Fatalf("message %d: %d bytes around the card, feishuEnvelopeBytes says %d", messages, got, feishuEnvelopeBytes)
}
// Element 0 is the intro; the button, when present, is not a div.
lines := 0
for _, el := range card.Elements[1:] {
if el.Tag != "div" {
continue
}
lines++
if want := "vuln" + itoa(seen+lines) + "**"; !strings.Contains(el.Text.Content, want) {
t.Fatalf("message %d: line %d should be item %d (%q), got %q", messages, lines, seen+lines, want, el.Text.Content)
}
}
if kept <= 0 || kept != lines {
t.Fatalf("message %d: %d items reported as delivered, the body holds %d", messages, kept, lines)
}
t.Logf("message %d: %d items, %d bytes", messages, kept, len(raw))
seen += kept
m.Items = m.Items[kept:]
}
if seen != total {
t.Fatalf("%d items went out across %d messages, want %d", seen, messages, total)
}
if messages < 2 {
t.Fatalf("%d items should not fit one message", total)
}
})
}
}
func TestWebhookAndEmailReportAllItems(t *testing.T) {
// These two channels do not truncate the body; the whole batch counts as
// delivered.
@@ -178,7 +289,7 @@ func TestMarkdownEscapesUntrustedContent(t *testing.T) {
// writeItem in single mode is the rendering path shared by all three
// markdown channels.
var b strings.Builder
writeItem(&b, tc.item, "", true)
writeItem(&b, tc.item, "", true, m.limits())
got := b.String()
for _, want := range tc.must {
if !strings.Contains(got, want) {
+7 -6
View File
@@ -115,6 +115,7 @@ func telegramEndpoint(cfg map[string]any) (string, error) {
// telegramHTML renders the HTML body and returns it together with the number of
// items actually written (see Channel.Send).
func telegramHTML(m Message) (string, int) {
lim := m.limits()
var b strings.Builder
b.WriteString("<b>" + telegramEscape(markdownTitle(m)) + "</b>\n")
if m.Batch {
@@ -125,13 +126,13 @@ func telegramHTML(m Message) (string, int) {
footer = fmt.Sprintf("\n\n<a href=\"%s\">View all on the platform</a>", telegramEscapeAttr(m.HomeURL))
}
kept := packItemCount(m.Items, telegramTextLimit, telegramReservedRunes, footer, runeSize, func(it Item, idx int) string {
return telegramBatchLine(it, idx+1)
return telegramBatchLine(it, idx+1, lim)
})
items := m.Items[:kept]
b.Reset()
b.WriteString("<b>" + telegramEscape(telegramBatchTitle(m, items, len(m.Items))) + "</b>")
for i, it := range items {
b.WriteString("\n" + telegramEscape(telegramBatchLine(it, i+1)))
b.WriteString("\n" + telegramEscape(telegramBatchLine(it, i+1, lim)))
}
b.WriteString(footer)
return TruncateHTML(b.String(), telegramTextLimit), kept
@@ -147,10 +148,10 @@ func telegramHTML(m Message) (string, int) {
if it.VulnClass != "" && it.VulnClass != it.Title() {
b.WriteString("\n<b>Type</b>: " + telegramEscape(it.VulnClass))
}
if a := assetLine(it.Assets, maxAssetsShown); a != "" {
if a := assetLine(it.Assets, lim.AssetsShown); a != "" {
b.WriteString("\n<b>Assets</b>: " + telegramEscape(a))
}
if s := OneLine(it.Summary, maxSummaryRunes); s != "" {
if s := OneLine(it.Summary, lim.SummaryRunes); s != "" {
b.WriteString("\n<b>Summary</b>: " + telegramEscape(s))
}
if it.DetailURL != "" {
@@ -165,8 +166,8 @@ const telegramReservedRunes = 160
// telegramBatchLine renders one entry of a digest (unescaped; the caller escapes
// it uniformly).
func telegramBatchLine(it Item, idx int) string {
if a := assetLine(it.Assets, maxAssetsShown); a != "" {
func telegramBatchLine(it Item, idx int, lim Limits) string {
if a := assetLine(it.Assets, lim.AssetsShown); a != "" {
return fmt.Sprintf("%d. %s · %s — %s", idx, SeverityLabel(it.Severity), it.Title(), a)
}
return fmt.Sprintf("%d. %s · %s", idx, SeverityLabel(it.Severity), it.Title())
+102
View File
@@ -0,0 +1,102 @@
package server
import (
"context"
"errors"
"testing"
"time"
"github.com/Autumn-27/artex/agent"
"github.com/Autumn-27/artex/db"
)
// The worker-side heartbeat must keep a claim alive while it runs and, once
// another worker has taken the intent over, cancel the stale run with the named
// claim-lost cause instead of carrying on.
func TestClaimHeartbeatRenewsThenCancelsOnTakeover(t *testing.T) {
skipWithoutDSN(t)
dsn, _, err := db.DSN()
if err != nil {
t.Fatal(err)
}
d, err := db.Open(dsn)
if err != nil {
t.Fatal(err)
}
defer d.Close()
expID, err := d.CreateExploration("claim heartbeat", "renew, then stop on takeover")
if err != nil {
t.Fatal(err)
}
defer d.Exec(`DELETE FROM explorations WHERE id=$1`, expID)
store := d.Exploration(expID)
id, err := store.AddIntent(map[string]any{"summary": "leased"}, 1, nil, "planner")
if err != nil {
t.Fatal(err)
}
token, err := store.ClaimIntentToken(id, "work#1")
if err != nil || token == "" {
t.Fatalf("claim: token=%q err=%v", token, err)
}
expire := func() {
t.Helper()
if _, err := d.Exec(`UPDATE exploration_nodes SET last_heartbeat_at = now() - $2 * INTERVAL '1 second' WHERE id=$1`,
id, (db.IntentClaimTTL + time.Second).Seconds()); err != nil {
t.Fatal(err)
}
}
ctx, cancel := context.WithCancelCause(context.Background())
defer cancel(nil)
stop := startClaimHeartbeat(store, 20*time.Millisecond, "work#1", id, token, cancel)
defer stop()
// Renewal: an expired-looking heartbeat is refreshed by the next ticks.
expire()
deadline := time.Now().Add(5 * time.Second)
for {
var fresh bool
if err := d.QueryRow(`SELECT last_heartbeat_at > now() - INTERVAL '30 seconds' FROM exploration_nodes WHERE id=$1`, id).Scan(&fresh); err != nil {
t.Fatal(err)
}
if fresh {
break
}
if time.Now().After(deadline) {
t.Fatal("heartbeat did not renew the claim")
}
time.Sleep(10 * time.Millisecond)
}
if ctx.Err() != nil {
t.Fatalf("run cancelled while its claim was live: %v", context.Cause(ctx))
}
// Takeover: expire the claim and reclaim it before the next heartbeat lands
// (retried, because a heartbeat may win the race and renew the claim first).
var reclaimed int64
for attempt := 0; attempt < 200 && reclaimed == 0; attempt++ {
expire()
if reclaimed, err = store.ResetRunningIntents(); err != nil {
t.Fatal(err)
}
}
if reclaimed != 1 {
t.Fatalf("could not take the claim over: reclaimed=%d", reclaimed)
}
other, err := store.ClaimIntentToken(id, "work#2")
if err != nil || other == "" {
t.Fatalf("re-claim: token=%q err=%v", other, err)
}
select {
case <-ctx.Done():
case <-time.After(5 * time.Second):
t.Fatal("stale run was not cancelled after the takeover")
}
if cause := context.Cause(ctx); !errors.Is(cause, agent.AbortWorkClaimLost) {
t.Fatalf("cancel cause=%v, want AbortWorkClaimLost", cause)
}
if err := store.HeartbeatIntentClaim(id, other); err != nil {
t.Fatalf("new claimer lost its claim: %v", err)
}
}
+1
View File
@@ -9,6 +9,7 @@ import (
// The cost ledger: profile prices (EUR per 1M tokens) turn token buckets into
// EUR on the usage aggregation; unpriced profiles stay nil.
func TestCostLedgerEurOnUsage(t *testing.T) {
skipWithoutDSN(t)
m, err := NewManager(t.TempDir(), "")
if err != nil {
t.Fatal(err)
+97 -32
View File
@@ -480,17 +480,6 @@ func (e *Engine) releaseWorkControl(intentID int64, run *workExecution, action s
e.workMu.Unlock()
}
func transitionIntentState(store *db.ExplorationStore, intentID int64, expected, state string) error {
changed, err := store.CompareAndSetIntentState(intentID, expected, state)
if err != nil {
return err
}
if !changed {
return fmt.Errorf("%w: intent %d is no longer in the %s state", db.ErrIntentStateConflict, intentID, expected)
}
return nil
}
// SteerWork queues a mid-run course-correction for the work running intentID (the
// planner's steer_work tool). The worker delivers it before its next tool call and
// re-plans — no kill. Errors if no work is currently running that intent.
@@ -761,10 +750,11 @@ func (e *Engine) Run(ctx context.Context, t *Task) {
t.Notify() // already running — just nudge a planning round
return
}
rt := e.registerTaskRoutines(ctx, t.ID, 1+workers)
rt := e.registerTaskRoutines(ctx, t.ID, 2+workers)
e.deleteMu.RUnlock()
e.touch(t.ID)
runTaskRoutine(rt, func(loopCtx context.Context) { e.plannerLoop(loopCtx, t) })
runTaskRoutine(rt, func(loopCtx context.Context) { e.claimSweepLoop(loopCtx, t) })
for i := 0; i < workers; i++ {
name := fmt.Sprintf("work#%d", i+1)
runTaskRoutine(rt, func(loopCtx context.Context) { e.workerLoop(loopCtx, t, name) })
@@ -950,6 +940,64 @@ func (e *Engine) plannerLoop(ctx context.Context, t *Task) {
}
}
// claimSweepLoop periodically returns this task's expired intent claims (no
// heartbeat within db.IntentClaimTTL: the claiming worker crashed or its process
// is gone) to the frontier, where the worker loops re-claim them. The startup
// reset alone would miss a claim that was still live when this process started.
func (e *Engine) claimSweepLoop(ctx context.Context, t *Task) {
ticker := time.NewTicker(db.IntentClaimHeartbeatInterval)
defer ticker.Stop()
for {
select {
case <-ctx.Done():
return
case <-ticker.C:
}
if !e.beginTaskOperation(t.ID) {
return
}
n, err := t.Store.ResetRunningIntents()
e.decInflight(t.ID)
if err != nil {
log.Printf("[engine] task %s expired-claim sweep failed: %v", t.ID, err)
} else if n > 0 {
log.Printf("[engine] task %s returned %d expired intent claims to open", t.ID, n)
}
}
}
// startClaimHeartbeat renews an intent claim every interval while its worker is
// busy. A heartbeat rejected with db.ErrIntentClaimLost means the claim expired
// and another worker took the intent over: the run is cancelled with
// AbortWorkClaimLost so the stale worker stops. Any other store error is logged
// and retried on the next tick; the claim survives until db.IntentClaimTTL
// passes without a heartbeat. stop blocks until the heartbeat has ended.
func startClaimHeartbeat(store *db.ExplorationStore, interval time.Duration, label string, intentID int64, token string, cancel context.CancelCauseFunc) (stop func()) {
quit, done := make(chan struct{}), make(chan struct{})
go func() {
defer close(done)
ticker := time.NewTicker(interval)
defer ticker.Stop()
for {
select {
case <-quit:
return
case <-ticker.C:
}
err := store.HeartbeatIntentClaim(intentID, token)
if errors.Is(err, db.ErrIntentClaimLost) {
log.Printf("[worker %s] intent #%d heartbeat rejected, cancelling this run: %v", label, intentID, err)
cancel(agent.AbortWorkClaimLost)
return
}
if err != nil {
log.Printf("[worker %s] intent #%d heartbeat failed, retrying: %v", label, intentID, err)
}
}
}()
return func() { close(quit); <-done }
}
func (e *Engine) workerLoop(ctx context.Context, t *Task, name string) {
for {
select {
@@ -1000,12 +1048,12 @@ func (e *Engine) workerLoop(ctx context.Context, t *Task, name string) {
// runIntent. Returns false when nothing was claimable. The pool worker loop is its
// only caller.
func (e *Engine) runWorkerStep(ctx context.Context, t *Task, name string, worker *agent.Worker) bool {
intent := e.claimNext(t, name)
intent, token := e.claimNext(t, name)
if intent == nil {
return false
}
log.Printf("[worker %s] task %s claimed intent #%d", name, t.ID, intent.ID)
return e.runIntent(ctx, t, name, worker, intent, "", "")
return e.runIntent(ctx, t, name, worker, intent, token, "", "")
}
// runIntent executes and fully settles one already-claimed (state=running) intent.
@@ -1016,7 +1064,10 @@ func (e *Engine) runWorkerStep(ctx context.Context, t *Task, name string, worker
// transcript marker that dedups re-injection across model_error retries. The caller
// must already hold one task-operation admission for the whole sequence so a delete
// cannot observe quiescence between the LLM return and the final DB writes.
func (e *Engine) runIntent(ctx context.Context, t *Task, name string, worker *agent.Worker, intent *db.Node, requestID, message string) bool {
// token is the unclaim token of the caller's claim: a heartbeat renews the claim
// while the worker is busy, and every intent state write below is fenced on it,
// so a worker whose claim was taken over cannot overwrite the new claimer.
func (e *Engine) runIntent(ctx context.Context, t *Task, name string, worker *agent.Worker, intent *db.Node, token, requestID, message string) bool {
// Per-intent LLM rotation (#85): each claimed worker intent runs on the
// next chain head. The pin travels through the run context into the
// provider resolver; non-worker roles and failover keep the active head.
@@ -1031,7 +1082,7 @@ func (e *Engine) runIntent(ctx context.Context, t *Task, name string, worker *ag
emit := func(r db.Activity) { e.emitActivity(t, r) }
ectx := e.clockCtx(e.execContextFor(ctx, t.ID), t, false) // cancellable by Pause; carries the task deadline
if ectx.Err() != nil || e.IsDeleting(t.ID) {
if err := transitionIntentState(t.Store, intent.ID, "running", "open"); err != nil {
if err := t.Store.SettleIntentClaim(intent.ID, token, "open"); err != nil {
log.Printf("[worker %s] task %s intent #%d claim rollback failed: %v", name, t.ID, intent.ID, err)
}
return true
@@ -1039,6 +1090,7 @@ func (e *Engine) runIntent(ctx context.Context, t *Task, name string, worker *ag
// per-work child context so the planner's kill_work can stop just this work.
workCtx, workCancel := context.WithCancelCause(ectx)
e.registerWork(intent.ID, workCancel)
stopHeartbeat := startClaimHeartbeat(t.Store, db.IntentClaimHeartbeatInterval, name, intent.ID, token, workCancel)
// wrap the guard hooks so steer_work can inject a mid-run course-correction
// for THIS intent (drained before the worker's next tool call).
iid := intent.ID
@@ -1089,6 +1141,7 @@ func (e *Engine) runIntent(ctx context.Context, t *Task, name string, worker *ag
}
e.EndLLMCall(t.ID)
}
stopHeartbeat() // no longer busy: the state writes below follow within the just-renewed claim
// Capture kill state before detachWork cancels workCtx. kill = this work's
// ctx was cancelled (planner kill_work) while the TASK ctx kept running; a
// pause cancels the task ctx (ectx) instead. Checking workCtx.Err() AFTER
@@ -1111,7 +1164,7 @@ func (e *Engine) runIntent(ctx context.Context, t *Task, name string, worker *ag
var controlErr error
defer func() { completeWork(controlErr) }()
if action == "pause" {
controlErr = transitionIntentState(t.Store, intent.ID, "running", "paused")
controlErr = t.Store.SettleIntentClaim(intent.ID, token, "paused")
if controlErr != nil {
log.Printf("[worker %s] task %s intent #%d failed to persist the paused state: %v", name, t.ID, intent.ID, controlErr)
return true
@@ -1124,7 +1177,7 @@ func (e *Engine) runIntent(ctx context.Context, t *Task, name string, worker *ag
// Park the stopped run in paused before handing cleanup to the API. If the
// request disconnects after cancellation, the intent remains recoverable and
// a later cancel can finish cleanup instead of leaving a phantom running row.
controlErr = transitionIntentState(t.Store, intent.ID, "running", "paused")
controlErr = t.Store.SettleIntentClaim(intent.ID, token, "paused")
if controlErr != nil {
log.Printf("[worker %s] task %s intent #%d failed to persist the cancel barrier: %v", name, t.ID, intent.ID, controlErr)
return true
@@ -1133,11 +1186,18 @@ func (e *Engine) runIntent(ctx context.Context, t *Task, name string, worker *ag
e.touch(t.ID)
return true
}
// The heartbeat was rejected: the claim expired and another worker took the
// intent over. This run's result is void and the intent state is not ours to
// write (the fence would reject every write below).
if errors.Is(workCause, agent.AbortWorkClaimLost) {
log.Printf("[worker %s] task %s intent #%d claim lost to another worker, result discarded", name, t.ID, intent.ID)
return true
}
// if a pause cancelled this run mid-flight, return the intent to the frontier
// so it is re-claimed on resume — the worker will resume the prior LLM
// conversation from its transcript instead of restarting from scratch.
if ectx.Err() != nil && taskExecutionPaused(context.Cause(ectx)) {
if err := transitionIntentState(t.Store, intent.ID, "running", "open"); err != nil {
if err := t.Store.SettleIntentClaim(intent.ID, token, "open"); err != nil {
log.Printf("[worker %s] task %s intent #%d task-pause rollback failed: %v", name, t.ID, intent.ID, err)
}
return true
@@ -1145,7 +1205,7 @@ func (e *Engine) runIntent(ctx context.Context, t *Task, name string, worker *ag
// The hard-fallback cancel of task-timeout settlement (not pause, not kill) cancelled
// this run → classify it as exhausted (settled), not mislabeled blocked. By then the worker has usually written its result back during the settlement phase.
if ectx.Err() != nil && e.isSettling(t.ID) {
if err := transitionIntentState(t.Store, intent.ID, "running", "exhausted"); err != nil {
if err := t.Store.SettleIntentClaim(intent.ID, token, "exhausted"); err != nil {
log.Printf("[worker %s] task %s intent #%d failed to persist the timeout-settlement state: %v", name, t.ID, intent.ID, err)
}
log.Printf("[worker %s] task %s intent #%d ended by task-timeout settlement (exhausted), wrote back %s", name, t.ID, intent.ID, wrote)
@@ -1155,7 +1215,7 @@ func (e *Engine) runIntent(ctx context.Context, t *Task, name string, worker *ag
// Task judged complete (done via the regular path) → cancelExec above cancelled this
// run. The intent's result is meaningless now; mark it stopped (not blocked) and do not pollute the intent states of a completed task.
if ectx.Err() != nil && isTerminalStatus(e.m.TaskStatus(t.ID)) {
if err := transitionIntentState(t.Store, intent.ID, "running", "stopped"); err != nil {
if err := t.Store.SettleIntentClaim(intent.ID, token, "stopped"); err != nil {
log.Printf("[worker %s] task %s intent #%d failed to persist the terminal stop: %v", name, t.ID, intent.ID, err)
}
log.Printf("[worker %s] task %s intent #%d cancelled because the task completed (stopped)", name, t.ID, intent.ID)
@@ -1164,7 +1224,7 @@ func (e *Engine) runIntent(ctx context.Context, t *Task, name string, worker *ag
}
// killed by the planner: mark stopped (don't write back results, don't auto-reclaim).
if killed {
if err := transitionIntentState(t.Store, intent.ID, "running", "stopped"); err != nil {
if err := t.Store.SettleIntentClaim(intent.ID, token, "stopped"); err != nil {
log.Printf("[worker %s] task %s intent #%d failed to persist the planner stop: %v", name, t.ID, intent.ID, err)
}
log.Printf("[worker %s] task %s intent #%d killed (stopped)", name, t.ID, intent.ID)
@@ -1188,11 +1248,16 @@ func (e *Engine) runIntent(ctx context.Context, t *Task, name string, worker *ag
state = "exhausted"
log.Printf("[worker %s] intent %d ran out of time (exhausted), wrote back %s after settling", name, intent.ID, wrote)
}
var stateErr error
if state == "blocked" && isTaskLLMChainExhausted(err) {
_ = t.Store.SetIntentBlockedReason(intent.ID, db.IntentBlockedLLMQuota)
stateErr = t.Store.SettleIntentClaimBlocked(intent.ID, token, db.IntentBlockedLLMQuota)
} else {
if stateErr := transitionIntentState(t.Store, intent.ID, "running", state); stateErr != nil {
log.Printf("[worker %s] task %s intent #%d failed to persist terminal state %s: %v", name, t.ID, intent.ID, state, stateErr)
stateErr = t.Store.SettleIntentClaim(intent.ID, token, state)
}
if stateErr != nil {
log.Printf("[worker %s] task %s intent #%d failed to persist terminal state %s: %v", name, t.ID, intent.ID, state, stateErr)
if errors.Is(stateErr, db.ErrIntentClaimLost) {
return true // taken over: the intent is not finished, its new claimer reports the result
}
}
log.Printf("[worker %s] task %s intent #%d finished: %s (wrote back %s)", name, t.ID, intent.ID, state, wrote)
@@ -1234,11 +1299,11 @@ func (e *Engine) runDetachedIntent(ctx context.Context, t *Task, intentID int64,
if node == nil || node.Kind != db.KindIntent {
return fmt.Errorf("intent not found")
}
changed, err := t.Store.CompareAndSetIntentState(intentID, "paused", "running")
token, err := t.Store.ClaimPausedIntentToken(intentID)
if err != nil {
return err
}
if !changed {
if token == "" {
return fmt.Errorf("%w: intent is no longer in the paused state", db.ErrIntentStateConflict)
}
node.State, node.Owner = "running", "chat"
@@ -1251,7 +1316,7 @@ func (e *Engine) runDetachedIntent(ctx context.Context, t *Task, intentID int64,
release = false // ownership of the admission passes to the goroutine
go func() {
defer e.decInflight(t.ID)
e.runIntent(ctx, t, "chat", worker, node, requestID, agentMessage)
e.runIntent(ctx, t, "chat", worker, node, token, requestID, agentMessage)
}()
return nil
}
@@ -1279,12 +1344,12 @@ func sleepCtx(ctx context.Context, d time.Duration) (done bool) {
}
}
func (e *Engine) claimNext(t *Task, name string) *db.Node {
func (e *Engine) claimNext(t *Task, name string) (*db.Node, string) {
fr, _ := t.Store.Frontier(20)
for _, in := range fr {
if ok, _ := t.Store.ClaimIntent(in.ID, name); ok {
return in
if token, _ := t.Store.ClaimIntentToken(in.ID, name); token != "" {
return in, token
}
}
return nil
return nil, ""
}
+1
View File
@@ -22,6 +22,7 @@ import (
func trafficEvidenceServer(t *testing.T) (*Server, *db.RecordedFinding, func(string, string, string) *httptest.ResponseRecorder) {
t.Helper()
skipWithoutDSN(t)
m, err := NewManager(t.TempDir(), "")
if err != nil {
t.Fatal(err)
+2
View File
@@ -103,6 +103,7 @@ func TestOllamaProviderWiresOpenAIProtocol(t *testing.T) {
// loadProfileConfig accepts it, the task chain validates it, the failover pool
// includes it, and the connection test completes against a fake Ollama.
func TestOllamaKeylessProfileLifecycle(t *testing.T) {
skipWithoutDSN(t)
m, err := NewManager(t.TempDir(), "")
if err != nil {
t.Fatal(err)
@@ -180,6 +181,7 @@ func TestOllamaKeylessProfileLifecycle(t *testing.T) {
// Model listing for an Ollama server works without an API key and tolerates a
// base URL with or without the /v1 suffix.
func TestOllamaListModels(t *testing.T) {
skipWithoutDSN(t)
var calls atomic.Value // []string paths
fake := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
+2
View File
@@ -18,6 +18,7 @@ import (
// assigned raw, so a key saved with surrounding whitespace ran fine in
// conversations but 401'd the connection test.
func TestLLMTestStoredKeyFallbackIsTrimmed(t *testing.T) {
skipWithoutDSN(t)
m, err := NewManager(t.TempDir(), "")
if err != nil {
t.Fatal(err)
@@ -97,6 +98,7 @@ func TestLLMTestFallbackMatchesRuntimeNormalization(t *testing.T) {
// (the list-view test button) fills provider/model/base_url from the row, so
// the key lands on the configured host instead of the canonical default one.
func TestLLMTestStoredProfileUsesProfileEndpoint(t *testing.T) {
skipWithoutDSN(t)
m, err := NewManager(t.TempDir(), "")
if err != nil {
t.Fatal(err)
+43 -5
View File
@@ -5,6 +5,8 @@ import (
"encoding/json"
"fmt"
"log"
"strconv"
"strings"
"sync"
"time"
@@ -25,6 +27,12 @@ const (
settingNotifyPublicBaseURL = "notify_public_base_url"
// settingNotifyDigestMinutes is the digest-mode period (minutes).
settingNotifyDigestMinutes = "notify_digest_interval_min"
// settingNotifySummaryMaxRunes is how many characters the summary of a single
// push is cut to, and settingNotifyAssetsMaxShown how many asset names a
// message lists. 0 means no truncation; unset means the notify package
// defaults (120 / 3).
settingNotifySummaryMaxRunes = "notify_summary_max_runes"
settingNotifyAssetsMaxShown = "notify_assets_max_shown"
)
const (
@@ -43,6 +51,10 @@ const (
notifyFanOutPerTick = 200
// notifyDefaultDigestMinutes is the default digest period.
notifyDefaultDigestMinutes = 30
// notifySummaryMaxRunesCap / notifyAssetsMaxShownCap are the upper bounds the
// settings API accepts for the two render limits.
notifySummaryMaxRunesCap = 4000
notifyAssetsMaxShownCap = 50
// notifyUnlimitedBurstPerTick is the per-tick delivery cap when a channel has
// no rate limit configured. It exists to prevent "one channel configured as
// unlimited + a single scan finding thousands of vulnerabilities" from dragging
@@ -223,8 +235,9 @@ func (n *Notifier) stepRealtime(ctx context.Context, ch *db.NotificationChannel,
_ = n.pg.FailDeliveries(ctx, deliveryIDs(deliveries), fmt.Sprintf("channel type %q is not registered", ch.Kind))
return
}
limits := notifyLimits(n.pg)
for _, dl := range deliveries {
msg, err := n.renderSingle(ctx, dl, baseURL)
msg, err := n.renderSingle(ctx, dl, baseURL, limits)
if err != nil {
// A render failure is a local data problem; retrying will not help.
_ = n.pg.FailDeliveries(ctx, []int64{dl.ID}, err.Error())
@@ -259,7 +272,7 @@ func (n *Notifier) stepDigest(ctx context.Context, ch *db.NotificationChannel, a
_ = n.pg.FailDeliveries(ctx, deliveryIDs(deliveries), fmt.Sprintf("channel type %q is not registered", ch.Kind))
return
}
msg, included, err := n.renderBatch(ctx, deliveries, baseURL, int(window.Minutes()))
msg, included, err := n.renderBatch(ctx, deliveries, baseURL, int(window.Minutes()), notifyLimits(n.pg))
if err != nil {
_ = n.pg.FailDeliveries(ctx, deliveryIDs(deliveries), err.Error())
return
@@ -423,7 +436,7 @@ func (n *Notifier) adapt(ch *db.NotificationChannel) (notify.Channel, map[string
}
// renderSingle renders a single-vulnerability message.
func (n *Notifier) renderSingle(ctx context.Context, dl *db.NotificationDelivery, baseURL string) (notify.Message, error) {
func (n *Notifier) renderSingle(ctx context.Context, dl *db.NotificationDelivery, baseURL string, limits notify.Limits) (notify.Message, error) {
snap, err := parseSnapshot(dl)
if err != nil {
return notify.Message{}, err
@@ -432,7 +445,7 @@ func (n *Notifier) renderSingle(ctx context.Context, dl *db.NotificationDelivery
if err != nil {
return notify.Message{}, err
}
return notify.Message{Items: []notify.Item{item}, HomeURL: baseURL}, nil
return notify.Message{Items: []notify.Item{item}, HomeURL: baseURL, Limits: &limits}, nil
}
// renderBatch renders a digest message. Snapshots are parsed one by one — a
@@ -446,7 +459,7 @@ func (n *Notifier) renderSingle(ctx context.Context, dl *db.NotificationDelivery
// entry that should have failed would be marked sent, and a good entry would be
// misjudged as undelivered. The broken ones are marked failed explicitly by the
// caller, see stepDigest.
func (n *Notifier) renderBatch(ctx context.Context, deliveries []*db.NotificationDelivery, baseURL string, windowMinutes int) (notify.Message, []*db.NotificationDelivery, error) {
func (n *Notifier) renderBatch(ctx context.Context, deliveries []*db.NotificationDelivery, baseURL string, windowMinutes int, limits notify.Limits) (notify.Message, []*db.NotificationDelivery, error) {
items := make([]notify.Item, 0, len(deliveries))
included := make([]*db.NotificationDelivery, 0, len(deliveries))
for _, dl := range deliveries {
@@ -473,6 +486,7 @@ func (n *Notifier) renderBatch(ctx context.Context, deliveries []*db.Notificatio
Batch: true,
WindowMinutes: windowMinutes,
HomeURL: baseURL,
Limits: &limits,
}, included, nil
}
@@ -582,6 +596,30 @@ func (n *Notifier) digestInterval() time.Duration {
return time.Duration(m) * time.Minute
}
// notifyLimits reads the summary/asset render limits from the settings.
func notifyLimits(pg *db.DB) notify.Limits {
summary, sOK, _ := pg.GetSetting(settingNotifySummaryMaxRunes)
assets, aOK, _ := pg.GetSetting(settingNotifyAssetsMaxShown)
return notify.Limits{
SummaryRunes: notifyLimitValue(summary, sOK, notify.DefaultMaxSummaryRunes, notifySummaryMaxRunesCap),
AssetsShown: notifyLimitValue(assets, aOK, notify.DefaultMaxAssetsShown, notifyAssetsMaxShownCap),
}
}
// notifyLimitValue resolves one stored render limit: def when the key is unset,
// unparseable, or outside [0, max]. 0 is a valid value (no truncation), which is
// why "unset" is carried by ok and not by the number.
func notifyLimitValue(v string, ok bool, def, max int) int {
if !ok {
return def
}
n, err := strconv.Atoi(strings.TrimSpace(v))
if err != nil || n < 0 || n > max {
return def
}
return n
}
// parseSnapshot parses the snapshot of the event a delivery corresponds to.
func parseSnapshot(dl *db.NotificationDelivery) (notify.Snapshot, error) {
var snap notify.Snapshot
+2
View File
@@ -447,6 +447,8 @@ func (s *Server) notifyTestChannel(w http.ResponseWriter, r *http.Request) {
return
}
msg := notifyTestMessage(s.notifierBaseURL(pg))
limits := notifyLimits(pg)
msg.Limits = &limits
start := time.Now()
// The test message is a single entry, so the delivered count is not needed
// here (for a single message the channel length limit falls back to
+129
View File
@@ -700,6 +700,108 @@ func TestNotifyMetaAndSettingsRoundTrip(t *testing.T) {
}
}
// TestNotifyLimitSettingsRoundTrip covers the two render-limit keys through the
// settings API and the settings table: unset reads as the 120 / 3 defaults, a
// stored 0 reads back as 0 (no truncation) and not as the default, and
// out-of-range values are rejected without touching the stored value.
func TestNotifyLimitSettingsRoundTrip(t *testing.T) {
f := newNotifyFixture(t)
clear := func() {
f.pg.Exec(`DELETE FROM settings WHERE key IN ($1,$2)`, settingNotifySummaryMaxRunes, settingNotifyAssetsMaxShown)
}
clear()
t.Cleanup(clear)
expect := func(step string, summary, assets int) {
t.Helper()
payload := f.s.settingsPayload()
if payload["notify_summary_max_runes"] != summary || payload["notify_assets_max_shown"] != assets {
t.Fatalf("%s: settings payload should report %d / %d, got %v / %v", step, summary, assets,
payload["notify_summary_max_runes"], payload["notify_assets_max_shown"])
}
if got := notifyLimits(f.pg); got != (notify.Limits{SummaryRunes: summary, AssetsShown: assets}) {
t.Fatalf("%s: the delivery engine should read %d / %d, got %+v", step, summary, assets, got)
}
}
expect("unset", notify.DefaultMaxSummaryRunes, notify.DefaultMaxAssetsShown)
for _, tc := range []struct{ summary, assets int }{{500, 10}, {0, 0}, {4000, 50}} {
body := fmt.Sprintf(`{"notify_summary_max_runes":%d,"notify_assets_max_shown":%d}`, tc.summary, tc.assets)
if r := f.request("PUT", "/api/settings", body); r.Code != 200 {
t.Fatalf("%s failed %d: %s", body, r.Code, r.Body)
}
expect(body, tc.summary, tc.assets)
for key, want := range map[string]int{settingNotifySummaryMaxRunes: tc.summary, settingNotifyAssetsMaxShown: tc.assets} {
if v, ok, err := f.pg.GetSetting(key); err != nil || !ok || v != strconv.Itoa(want) {
t.Fatalf("%s: settings row %s should hold %d, got %q (ok=%v err=%v)", body, key, want, v, ok, err)
}
}
}
for _, body := range []string{
`{"notify_summary_max_runes":-1}`,
`{"notify_summary_max_runes":4001}`,
`{"notify_assets_max_shown":-1}`,
`{"notify_assets_max_shown":51}`,
} {
if r := f.request("PUT", "/api/settings", body); r.Code != 400 {
t.Errorf("%s should return 400, got %d", body, r.Code)
}
}
expect("after rejected writes", 4000, 50)
}
// TestNotifySummaryLimitReachesDelivery is the end-to-end evidence that the
// stored limit reaches the message actually sent: with the key unset the summary
// is cut at 120 characters as before, and once it is set to 0 the same summary
// goes out whole.
func TestNotifySummaryLimitReachesDelivery(t *testing.T) {
f := newNotifyFixture(t)
clear := func() { f.pg.Exec(`DELETE FROM settings WHERE key=$1`, settingNotifySummaryMaxRunes) }
clear()
t.Cleanup(clear)
hook := newFakeWebhook(t)
chID := f.createChannel(t, map[string]any{
"name": "summary limit",
"kind": notify.KindDingTalk,
"config": map[string]any{"webhook": hook.URL},
})
summary := strings.Repeat("Z", 300)
record := func(name string) {
t.Helper()
if _, err := f.s.evidenceStore().Record(context.Background(), db.RecordFindingInput{
TaskID: f.taskID,
ExplorationID: f.expID,
Worker: "test",
VulnClass: name,
Name: name,
Severity: "high",
Summary: summary,
Evidence: "poc",
}, nil); err != nil {
t.Fatalf("failed to record finding: %v", err)
}
}
record("summary limit unset")
f.deliver(t, chID, "")
text := markdownText(t, hook.last(t))
if !strings.Contains(text, strings.Repeat("Z", 119)+"…") || strings.Contains(text, strings.Repeat("Z", 120)) {
t.Fatalf("with the key unset the summary should be cut at 120 characters:\n%s", text)
}
if r := f.request("PUT", "/api/settings", `{"notify_summary_max_runes":0}`); r.Code != 200 {
t.Fatalf("failed to write settings %d: %s", r.Code, r.Body)
}
record("summary limit zero")
f.deliver(t, chID, "")
if hook.count() != 2 {
t.Fatalf("expected 2 messages sent, got %d", hook.count())
}
if text := markdownText(t, hook.last(t)); !strings.Contains(text, summary) {
t.Fatalf("with the limit at 0 the whole summary should be sent:\n%s", text)
}
}
// TestNotifyDeepLinkUsesPublicBaseURL covers back-link building: when
// public_base_url is configured, single messages must use the ActionCard with a
// button, and the link must point to the vulnerability detail page.
@@ -1008,3 +1110,30 @@ func TestNotifyTickBudgetFitsWithinLease(t *testing.T) {
worst, notifyLease, notifyMaxSendsPerChannelPerTick, notifySendTimeout)
}
}
// TestNotifyLimitValue pins how a stored render limit is resolved. The case that
// matters is "0": it is a real value (no truncation) and must not be read as
// "unset", while anything unparseable or outside the bounds falls back to the
// default instead of reaching the renderer.
func TestNotifyLimitValue(t *testing.T) {
const def, max = 120, 4000
cases := []struct {
v string
ok bool
want int
}{
{"", false, def},
{"0", true, 0},
{" 500 ", true, 500},
{"4000", true, max},
{"4001", true, def},
{"-1", true, def},
{"abc", true, def},
{"", true, def},
}
for _, tc := range cases {
if got := notifyLimitValue(tc.v, tc.ok, def, max); got != tc.want {
t.Errorf("notifyLimitValue(%q, %v) = %d, want %d", tc.v, tc.ok, got, tc.want)
}
}
}
+2
View File
@@ -10,6 +10,7 @@ import (
// open-goal fingerprint is unchanged since the last completed round AND active
// work exists (open or running intents). Every other combination plans.
func TestPlannerQuietSkipEdge(t *testing.T) {
skipWithoutDSN(t)
m, err := NewManager(t.TempDir(), "")
if err != nil {
t.Fatal(err)
@@ -78,6 +79,7 @@ func TestPlannerQuietSkipEdge(t *testing.T) {
// The quiet-mode switch is editable mid-run (#86): PATCHing plan_quiet_mode
// updates both the stored row and the live Task the engine reads per round.
func TestPlannerQuietModeToggleMidRun(t *testing.T) {
skipWithoutDSN(t)
m, err := NewManager(t.TempDir(), "")
if err != nil {
t.Fatal(err)
+27
View File
@@ -3454,6 +3454,7 @@ func (s *Server) settingsPayload() map[string]any {
if concLimit == 0 {
concLimit = defaultConcurrencyLimit // when off, still echo a sane default to the UI
}
limits := notifyLimits(s.m.pg)
return map[string]any{
"traffic_capture": s.m.TrafficEnabled(),
"agent_traffic_binding": s.m.pg.GetBool(settingAgentTrafficBinding, false),
@@ -3483,6 +3484,9 @@ func (s *Server) settingsPayload() map[string]any {
"notify_enabled": s.m.pg.GetBool(settingNotifyEnabled, true),
"notify_public_base_url": notifyPublicBaseURL(s.m.pg),
"notify_digest_interval_min": notifyDigestIntervalMin(s.m.pg),
// Render limits of IM messages; 0 = no truncation.
"notify_summary_max_runes": limits.SummaryRunes,
"notify_assets_max_shown": limits.AssetsShown,
}
}
@@ -3555,6 +3559,9 @@ func (s *Server) putSettings(w http.ResponseWriter, r *http.Request) {
NotifyEnabled *bool `json:"notify_enabled"`
NotifyBaseURL *string `json:"notify_public_base_url"`
NotifyDigestMins *int `json:"notify_digest_interval_min"`
// Render limits of IM messages: summary characters (0-4000) and asset names listed (0-50); 0 = no truncation.
NotifySummaryMaxRunes *int `json:"notify_summary_max_runes"`
NotifyAssetsMaxShown *int `json:"notify_assets_max_shown"`
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
writeErr(w, 400, err.Error())
@@ -3610,6 +3617,26 @@ func (s *Server) putSettings(w http.ResponseWriter, r *http.Request) {
return
}
}
if req.NotifySummaryMaxRunes != nil {
if *req.NotifySummaryMaxRunes < 0 || *req.NotifySummaryMaxRunes > notifySummaryMaxRunesCap {
writeErr(w, 400, fmt.Sprintf("summary limit must be between 0 and %d characters (0 = no truncation)", notifySummaryMaxRunesCap))
return
}
if err := s.m.pg.SetSetting(settingNotifySummaryMaxRunes, strconv.Itoa(*req.NotifySummaryMaxRunes)); err != nil {
writeErr(w, 500, err.Error())
return
}
}
if req.NotifyAssetsMaxShown != nil {
if *req.NotifyAssetsMaxShown < 0 || *req.NotifyAssetsMaxShown > notifyAssetsMaxShownCap {
writeErr(w, 400, fmt.Sprintf("asset limit must be between 0 and %d (0 = no truncation)", notifyAssetsMaxShownCap))
return
}
if err := s.m.pg.SetSetting(settingNotifyAssetsMaxShown, strconv.Itoa(*req.NotifyAssetsMaxShown)); err != nil {
writeErr(w, 500, err.Error())
return
}
}
if req.Workers != nil {
if err := s.m.SetWorkers(*req.Workers); err != nil {
writeErr(w, 400, err.Error())
+10
View File
@@ -32,3 +32,13 @@ func TestMain(m *testing.M) {
defer conn.Exec(`SELECT pg_advisory_unlock(7337741002)`) //nolint:errcheck
os.Exit(m.Run())
}
// skipWithoutDSN skips the test when neither ARTEX_PG_DSN nor a config file
// supplies a database, so fixtures that t.Fatal on a NewManager error skip
// instead of failing. A configured database that cannot be reached still fails.
func skipWithoutDSN(t *testing.T) {
t.Helper()
if _, _, err := db.DSN(); err != nil {
t.Skipf("no database config (%v) — skipping", err)
}
}
+1
View File
@@ -15,6 +15,7 @@ import (
// trafficEvidenceServer but without the finding plumbing.
func ingestServer(t *testing.T) (*Server, func(method, path, body string) *httptest.ResponseRecorder) {
t.Helper()
skipWithoutDSN(t)
m, err := NewManager(t.TempDir(), "")
if err != nil {
t.Fatal(err)
+68
View File
@@ -32,6 +32,18 @@ import { ConfigField, FilterSummary } from "./_components/channel-form";
import { DeliveryList } from "./_components/delivery-list";
import { formatBacklog, StatTile } from "./_components/stat-tile";
// Upper bounds of the two message render limits. They mirror the backend, which answers 400 outside [0, max].
const SUMMARY_LIMIT_MAX = 4000;
const ASSETS_LIMIT_MAX = 50;
// limitInvalid reports whether a limit input holds anything other than a whole number in [0, max].
// Empty is valid: it is not submitted, so the stored value stays as it is.
function limitInvalid(raw: string, max: number): boolean {
if (raw.trim() === "") return false;
const n = Number(raw);
return !Number.isInteger(n) || n < 0 || n > max;
}
// This page only orchestrates: loading data, holding form state, calling the API.
// Field definitions and parsing live in _components/channel-fields.ts, controls and the filter summary in
// _components/channel-form.tsx, and the delivery log in _components/delivery-list.tsx —
@@ -50,6 +62,8 @@ export default function NotifyPage() {
const [globalSaving, setGlobalSaving] = React.useState(false);
const [baseURL, setBaseURL] = React.useState("");
const [digestMin, setDigestMin] = React.useState("");
const [summaryMax, setSummaryMax] = React.useState("");
const [assetsMax, setAssetsMax] = React.useState("");
const load = React.useCallback(() => {
api
@@ -60,6 +74,14 @@ export default function NotifyPage() {
setDigestMin(m.digest_interval_min);
})
.catch((e) => toast.error("Failed to load notification settings: " + (e as Error).message));
// The two render limits are not part of /notify/meta; they are only exposed through /api/settings.
api
.settings()
.then((s) => {
setSummaryMax(String(s.notify_summary_max_runes ?? ""));
setAssetsMax(String(s.notify_assets_max_shown ?? ""));
})
.catch((e) => toast.error(`Failed to load message limits: ${(e as Error).message}`));
// Channel-list load failures must be reported: failing silently would render as "no channels at all",
// and users would think their config was lost — scarier than a straight-up error.
api
@@ -244,11 +266,23 @@ export default function NotifyPage() {
}
async function saveGlobal() {
// Checked before anything is sent: the backend applies the fields of one PUT in order,
// so a 400 on a limit would leave the URL and digest interval already saved.
if (limitInvalid(summaryMax, SUMMARY_LIMIT_MAX)) {
toast.error(`Summary length must be a whole number between 0 and ${SUMMARY_LIMIT_MAX}`);
return;
}
if (limitInvalid(assetsMax, ASSETS_LIMIT_MAX)) {
toast.error(`Assets listed must be a whole number between 0 and ${ASSETS_LIMIT_MAX}`);
return;
}
setGlobalSaving(true);
try {
const patch: Record<string, unknown> = { notify_public_base_url: baseURL.trim() };
const n = Number(digestMin);
if (Number.isFinite(n) && n > 0) patch.notify_digest_interval_min = n;
if (summaryMax.trim() !== "") patch.notify_summary_max_runes = Number(summaryMax);
if (assetsMax.trim() !== "") patch.notify_assets_max_shown = Number(assetsMax);
await api.setSettings(patch);
toast.success("Saved");
load();
@@ -331,6 +365,40 @@ export default function NotifyPage() {
/>
<p className="text-muted-foreground text-xs">Only applies to channels in "digest" mode.</p>
</div>
<div className="grid gap-2">
<Label htmlFor="n-summary-max">Summary length (characters)</Label>
<Input
id="n-summary-max"
type="number"
min={0}
max={SUMMARY_LIMIT_MAX}
step={1}
placeholder="120"
value={summaryMax}
onChange={(e) => setSummaryMax(e.target.value)}
aria-invalid={limitInvalid(summaryMax, SUMMARY_LIMIT_MAX)}
/>
<p className="text-muted-foreground text-xs">
Longest finding summary shown in a message, 0–{SUMMARY_LIMIT_MAX}. 0 = no truncation.
</p>
</div>
<div className="grid gap-2">
<Label htmlFor="n-assets-max">Assets listed per finding</Label>
<Input
id="n-assets-max"
type="number"
min={0}
max={ASSETS_LIMIT_MAX}
step={1}
placeholder="3"
value={assetsMax}
onChange={(e) => setAssetsMax(e.target.value)}
aria-invalid={limitInvalid(assetsMax, ASSETS_LIMIT_MAX)}
/>
<p className="text-muted-foreground text-xs">
Most asset names listed for a finding, 0–{ASSETS_LIMIT_MAX}. 0 = no truncation (all assets listed).
</p>
</div>
<div className="sm:col-span-2">
<Button onClick={saveGlobal} disabled={globalSaving}>
Save global settings
+3
View File
@@ -957,6 +957,9 @@ export interface Settings {
notify_enabled?: boolean; // master push switch, on by default; one-click kill switch for maintenance windows
notify_public_base_url?: string; // external base URL for vulnerability detail links; empty = messages carry no link
notify_digest_interval_min?: number; // digest mode period (minutes), default 30
// Render limits of IM messages; 0 = no truncation. The backend answers 400 outside the bounds.
notify_summary_max_runes?: number; // summary characters per finding, 0-4000, default 120
notify_assets_max_shown?: number; // asset names listed per finding, 0-50, default 3
}
// ---- Vulnerability IM push ----