Dashboard rework, GLOAS beacon-API compatibility playbook & cron scheduling

Dockerfile

@@ -1,5 +1,5 @@
 # syntax=docker/dockerfile:1
-FROM node:20-slim AS ui-builder
+FROM node:24-slim AS ui-builder
 WORKDIR /src
 COPY web-ui/package.json web-ui/package-lock.json ./web-ui/
 RUN cd web-ui && npm ci
@@ -24,6 +24,9 @@ RUN apt-get update && apt-get -y upgrade && apt-get install -y --no-install-reco
   curl \
   make \
   sudo \
+  gnupg \
+  && curl -fsSL https://deb.nodesource.com/setup_24.x | bash - \
+  && apt-get install -y --no-install-recommends nodejs \
   && apt-get clean \
   && rm -rf /var/lib/apt/lists/* \
   && update-ca-certificates

Dockerfile-local

@@ -1,5 +1,5 @@
 # syntax=docker/dockerfile:1
-FROM node:20-slim AS ui-builder
+FROM node:24-slim AS ui-builder
 WORKDIR /src
 COPY web-ui/package.json web-ui/package-lock.json ./web-ui/
 RUN cd web-ui && npm ci
@@ -27,6 +27,9 @@ RUN apt-get update && apt-get -y upgrade && apt-get install -y --no-install-reco
   curl \
   make \
   sudo \
+  gnupg \
+  && curl -fsSL https://deb.nodesource.com/setup_24.x | bash - \
+  && apt-get install -y --no-install-recommends nodejs \
   && apt-get clean \
   && rm -rf /var/lib/apt/lists/* \
   && update-ca-certificates

Dockerfile-stub

@@ -9,6 +9,9 @@ RUN apt-get update && apt-get -y upgrade && apt-get install -y --no-install-reco
   curl \
   make \
   sudo \
+  gnupg \
+  && curl -fsSL https://deb.nodesource.com/setup_24.x | bash - \
+  && apt-get install -y --no-install-recommends nodejs \
   && apt-get clean \
   && rm -rf /var/lib/apt/lists/* \
   && update-ca-certificates

go.mod

@@ -95,6 +95,7 @@ require (
 	github.com/protolambda/bls12-381-util v0.1.0 // indirect
 	github.com/r3labs/sse/v2 v2.10.0 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
+	github.com/santhosh-tekuri/jsonschema/v5 v5.3.1 // indirect
 	github.com/sethvargo/go-retry v0.3.0 // indirect
 	github.com/shirou/gopsutil v3.21.11+incompatible // indirect
 	github.com/supranational/blst v0.3.16 // indirect

go.sum

@@ -287,6 +287,8 @@ github.com/rs/zerolog v1.35.1 h1:m7xQeoiLIiV0BCEY4Hs+j2NG4Gp2o2KPKmhnnLiazKI=
 github.com/rs/zerolog v1.35.1/go.mod h1:EjML9kdfa/RMA7h/6z6pYmq1ykOuA8/mjWaEvGI+jcw=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/santhosh-tekuri/jsonschema/v5 v5.3.1 h1:lZUw3E0/J3roVtGQ+SCrUrg3ON6NgVqpn3+iol9aGu4=
+github.com/santhosh-tekuri/jsonschema/v5 v5.3.1/go.mod h1:uToXkOrWAZ6/Oc07xWQrPOhJotwFIyu2bBVN41fcDUY=
 github.com/sethvargo/go-retry v0.3.0 h1:EEt31A35QhrcRZtrYFDTBg91cqZVnFL2navjDrah2SE=
 github.com/sethvargo/go-retry v0.3.0/go.mod h1:mNX17F0C/HguQMyMyJxcnU471gOZGxCLyYaFyAZraas=
 github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI=

pkg/assertoor/coordinator.go

@@ -328,6 +328,10 @@ func (c *Coordinator) ScheduleTest(descriptor types.TestDescriptor, configOverri
 	return c.runner.ScheduleTest(descriptor, configOverrides, allowDuplicate, skipQueue)
 }
 
+func (c *Coordinator) ScheduleTestWithOptions(descriptor types.TestDescriptor, configOverrides map[string]any, opts types.ScheduleOptions) (types.TestRunner, error) {
+	return c.runner.ScheduleTestWithOptions(descriptor, configOverrides, opts)
+}
+
 func (c *Coordinator) startMetrics() error {
 	c.log.GetLogger().
 		Info(fmt.Sprintf("Starting metrics server on :%v", c.metricsPort))

pkg/assertoor/testregistry.go

@@ -14,6 +14,7 @@ import (
 	"github.com/ethpandaops/assertoor/pkg/test"
 	"github.com/ethpandaops/assertoor/pkg/types"
 	"github.com/ethpandaops/assertoor/pkg/vars"
+	"github.com/gorhill/cronexpr"
 	"github.com/jmoiron/sqlx"
 	"gopkg.in/yaml.v3"
 )
@@ -393,6 +394,72 @@ func (c *TestRegistry) externalTestCfgToDB(cfgExternalTest *types.ExternalTestCo
 	return dbTestCfg, nil
 }
 
+// UpdateTestSchedule validates the schedule's cron expressions, then
+// swaps the schedule in on the registered descriptor and writes it
+// to the test_configs row. Returns an error without touching state
+// if any cron expression is invalid.
+func (c *TestRegistry) UpdateTestSchedule(testID string, schedule *types.TestSchedule) error {
+	// Validate up-front so we don't half-apply.
+	if schedule != nil {
+		for _, expr := range schedule.Cron {
+			if _, err := cronexpr.Parse(expr); err != nil {
+				return fmt.Errorf("invalid cron expression %q: %w", expr, err)
+			}
+		}
+	}
+
+	c.testDescriptorsMutex.Lock()
+	entry, ok := c.testDescriptors[testID]
+	c.testDescriptorsMutex.Unlock()
+
+	if !ok {
+		return fmt.Errorf("test %q not registered", testID)
+	}
+
+	// SetSchedule is on the concrete *test.Descriptor — the registry
+	// only handles its own type so the cast is safe here.
+	type scheduleSetter interface {
+		SetSchedule(s *types.TestSchedule)
+	}
+
+	setter, ok := entry.descriptor.(scheduleSetter)
+	if !ok {
+		return fmt.Errorf("descriptor for %q does not support schedule updates", testID)
+	}
+
+	setter.SetSchedule(schedule)
+
+	// Persist the change. Fetch existing row, mutate schedule fields,
+	// re-upsert — we never want to clobber yaml/config/configVars.
+	dbCfg, err := c.coordinator.Database().GetTestConfig(testID)
+	if err != nil || dbCfg == nil {
+		// No existing row — the test was registered without going
+		// through the DB path. Skip persistence; the in-memory change
+		// is still in effect for this process's lifetime.
+		return nil
+	}
+
+	dbCfg.ScheduleStartup = false
+	dbCfg.ScheduleCronYaml = ""
+
+	if schedule != nil {
+		dbCfg.ScheduleStartup = schedule.Startup
+
+		if len(schedule.Cron) > 0 {
+			cronYaml, err := yaml.Marshal(schedule.Cron)
+			if err != nil {
+				return fmt.Errorf("error encoding cron schedule: %w", err)
+			}
+
+			dbCfg.ScheduleCronYaml = string(cronYaml)
+		}
+	}
+
+	return c.coordinator.Database().RunTransaction(func(tx *sqlx.Tx) error {
+		return c.coordinator.Database().InsertTestConfig(tx, dbCfg)
+	})
+}
+
 func (c *TestRegistry) DeleteTest(testID string) error {
 	c.testDescriptorsMutex.Lock()
 

pkg/assertoor/testrunner.go

@@ -76,17 +76,38 @@ func (c *TestRunner) RemoveTestFromQueue(runID uint64) bool {
 	return false
 }
 
+// ScheduleTest is the legacy 4-arg entry point. New callers should
+// use ScheduleTestWithOptions; this signature is kept so any external
+// code (and the deprecated `skip_queue` request field) continues to
+// work unchanged.
 func (c *TestRunner) ScheduleTest(descriptor types.TestDescriptor, configOverrides map[string]any, allowDuplicate, skipQueue bool) (types.TestRunner, error) {
+	return c.ScheduleTestWithOptions(descriptor, configOverrides, types.ScheduleOptions{
+		AllowDuplicate: allowDuplicate,
+		SkipQueue:      skipQueue,
+	})
+}
+
+// ScheduleTestWithOptions adds explicit support for inserting at a
+// chosen position in the pending queue (opts.AfterRunID). Mutually
+// exclusive with SkipQueue — when AfterRunID is non-zero the test is
+// inserted into the regular queue regardless of SkipQueue.
+func (c *TestRunner) ScheduleTestWithOptions(descriptor types.TestDescriptor, configOverrides map[string]any, opts types.ScheduleOptions) (types.TestRunner, error) {
 	if descriptor.Err() != nil {
 		return nil, fmt.Errorf("cannot create test from failed test descriptor: %w", descriptor.Err())
 	}
 
-	testRef, err := c.createTestRun(descriptor, configOverrides, allowDuplicate, skipQueue)
+	// AfterRunID always wins over SkipQueue: the user explicitly asked
+	// to slot the test into the queue at a known position.
+	if opts.AfterRunID > 0 {
+		opts.SkipQueue = false
+	}
+
+	testRef, err := c.createTestRun(descriptor, configOverrides, opts)
 	if err != nil {
 		return nil, err
 	}
 
-	if skipQueue {
+	if opts.SkipQueue {
 		c.offQueueNotificationChan <- testRef
 	} else {
 		select {
@@ -98,11 +119,11 @@ func (c *TestRunner) ScheduleTest(descriptor types.TestDescriptor, configOverrid
 	return testRef, nil
 }
 
-func (c *TestRunner) createTestRun(descriptor types.TestDescriptor, configOverrides map[string]any, allowDuplicate, skipQueue bool) (types.TestRunner, error) {
+func (c *TestRunner) createTestRun(descriptor types.TestDescriptor, configOverrides map[string]any, opts types.ScheduleOptions) (types.TestRunner, error) {
 	c.testSchedulerMutex.Lock()
 	defer c.testSchedulerMutex.Unlock()
 
-	if !allowDuplicate {
+	if !opts.AllowDuplicate {
 		for _, queuedTest := range c.GetTestQueue() {
 			if queuedTest.TestID() == descriptor.ID() {
 				return nil, fmt.Errorf("test already in queue")
@@ -120,8 +141,28 @@ func (c *TestRunner) createTestRun(descriptor types.TestDescriptor, configOverri
 
 	c.testRegistryMutex.Lock()
 
-	if !skipQueue {
-		c.testQueue = append(c.testQueue, testRef)
+	if !opts.SkipQueue {
+		insertIdx := -1
+
+		// When the user explicitly asked to slot in after a known
+		// queued run, locate it and insert just behind. If the target
+		// isn't queued any more (already started, was cancelled, etc.)
+		// we fall through to "append" — never silently drop the
+		// schedule request.
+		if opts.AfterRunID > 0 {
+			for idx, qt := range c.testQueue {
+				if qt.RunID() == opts.AfterRunID {
+					insertIdx = idx + 1
+					break
+				}
+			}
+		}
+
+		if insertIdx < 0 || insertIdx > len(c.testQueue) {
+			c.testQueue = append(c.testQueue, testRef)
+		} else {
+			c.testQueue = append(c.testQueue[:insertIdx], append([]types.TestRunner{testRef}, c.testQueue[insertIdx:]...)...)
+		}
 	}
 
 	c.testRunMap[runID] = testRef

pkg/db/task_results.go

@@ -83,8 +83,46 @@ func (db *Database) GetAllTaskResultHeaders(runID uint64) ([]TaskResultHeader, e
 
 	err := db.reader.Select(&headers, `
 		SELECT task_id, result_type, result_index, name, size FROM task_results
-		WHERE run_id = $1`,
+		WHERE run_id = $1 AND task_id != 0`,
 		runID)
 
 	return headers, err
 }
+
+// testResultTaskID and testResultType are the sentinel coordinates we use
+// to store the run-level "test result" markdown in the shared
+// task_results table. TaskID 0 is unused by real tasks (real indices
+// start at 1).
+const (
+	testResultTaskID = 0
+	testResultType   = "test_result"
+)
+
+// UpsertTestResult stores the run-level markdown blob (set by tasks that
+// write to $ASSERTOOR_TEST_RESULT). One blob per test run.
+func (db *Database) UpsertTestResult(runID uint64, data []byte) error {
+	return db.RunTransaction(func(tx *sqlx.Tx) error {
+		return db.UpsertTaskResult(tx, &TaskResult{
+			RunID:  runID,
+			TaskID: testResultTaskID,
+			Type:   testResultType,
+			Index:  0,
+			Name:   "result.md",
+			Size:   uint64(len(data)),
+			Data:   data,
+		})
+	})
+}
+
+// GetTestResult returns the run-level markdown blob, or nil + nil error
+// when none is set.
+func (db *Database) GetTestResult(runID uint64) (*TaskResult, error) {
+	result, err := db.GetTaskResultByIndex(runID, testResultTaskID, testResultType, 0)
+	if err != nil {
+		// Surface "no rows" as nil, nil so callers can distinguish "not
+		// set" from "fetch failed".
+		return nil, nil //nolint:nilerr // sql.ErrNoRows-style miss
+	}
+
+	return result, nil
+}