P1.1: Registry package with full CRUD and tests

SQLite schema (services, components, ports, volumes, cmd, events), migrations, and complete CRUD operations. 7 tests covering: idempotent migration, service CRUD, duplicate name rejection, component CRUD with ports/volumes/cmd, composite PK enforcement, cascade delete, and event insert/query/count/prune. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
2026-03-26 11:18:35 -07:00
parent 3f23b14ef4
commit 6122123064
8 changed files with 963 additions and 4 deletions
--- a/internal/registry/components.go
+++ b/internal/registry/components.go
@@ -0,0 +1,276 @@
+package registry
+
+import (
+	"database/sql"
+	"fmt"
+	"time"
+)
+
+// Component represents a component in the registry.
+type Component struct {
+	Name          string
+	Service       string
+	Image         string
+	Network       string
+	UserSpec      string
+	Restart       string
+	DesiredState  string
+	ObservedState string
+	Version       string
+	Ports         []string
+	Volumes       []string
+	Cmd           []string
+	CreatedAt     time.Time
+	UpdatedAt     time.Time
+}
+
+// CreateComponent creates a new component in the registry.
+func CreateComponent(db *sql.DB, c *Component) error {
+	tx, err := db.Begin()
+	if err != nil {
+		return fmt.Errorf("begin tx: %w", err)
+	}
+	defer tx.Rollback() //nolint:errcheck
+
+	_, err = tx.Exec(`
+		INSERT INTO components (name, service, image, network, user_spec, restart, desired_state, observed_state, version)
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+		c.Name, c.Service, c.Image, c.Network, c.UserSpec, c.Restart,
+		c.DesiredState, c.ObservedState, c.Version,
+	)
+	if err != nil {
+		return fmt.Errorf("insert component %q/%q: %w", c.Service, c.Name, err)
+	}
+
+	if err := setPorts(tx, c.Service, c.Name, c.Ports); err != nil {
+		return err
+	}
+	if err := setVolumes(tx, c.Service, c.Name, c.Volumes); err != nil {
+		return err
+	}
+	if err := setCmd(tx, c.Service, c.Name, c.Cmd); err != nil {
+		return err
+	}
+
+	return tx.Commit()
+}
+
+// GetComponent retrieves a component by service and name.
+func GetComponent(db *sql.DB, service, name string) (*Component, error) {
+	c := &Component{}
+	var createdAt, updatedAt string
+	err := db.QueryRow(`
+		SELECT name, service, image, network, user_spec, restart,
+		       desired_state, observed_state, version, created_at, updated_at
+		FROM components WHERE service = ? AND name = ?`,
+		service, name,
+	).Scan(&c.Name, &c.Service, &c.Image, &c.Network, &c.UserSpec, &c.Restart,
+		&c.DesiredState, &c.ObservedState, &c.Version, &createdAt, &updatedAt)
+	if err != nil {
+		return nil, fmt.Errorf("get component %q/%q: %w", service, name, err)
+	}
+	c.CreatedAt, _ = time.Parse("2006-01-02 15:04:05", createdAt)
+	c.UpdatedAt, _ = time.Parse("2006-01-02 15:04:05", updatedAt)
+
+	c.Ports, err = getPorts(db, service, name)
+	if err != nil {
+		return nil, err
+	}
+	c.Volumes, err = getVolumes(db, service, name)
+	if err != nil {
+		return nil, err
+	}
+	c.Cmd, err = getCmd(db, service, name)
+	if err != nil {
+		return nil, err
+	}
+
+	return c, nil
+}
+
+// ListComponents returns all components for a service.
+func ListComponents(db *sql.DB, service string) ([]Component, error) {
+	rows, err := db.Query(`
+		SELECT name, service, image, network, user_spec, restart,
+		       desired_state, observed_state, version, created_at, updated_at
+		FROM components WHERE service = ? ORDER BY name`,
+		service,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("list components for %q: %w", service, err)
+	}
+	defer func() { _ = rows.Close() }()
+
+	var components []Component
+	for rows.Next() {
+		var c Component
+		var createdAt, updatedAt string
+		if err := rows.Scan(&c.Name, &c.Service, &c.Image, &c.Network, &c.UserSpec, &c.Restart,
+			&c.DesiredState, &c.ObservedState, &c.Version, &createdAt, &updatedAt); err != nil {
+			return nil, fmt.Errorf("scan component: %w", err)
+		}
+		c.CreatedAt, _ = time.Parse("2006-01-02 15:04:05", createdAt)
+		c.UpdatedAt, _ = time.Parse("2006-01-02 15:04:05", updatedAt)
+
+		c.Ports, _ = getPorts(db, c.Service, c.Name)
+		c.Volumes, _ = getVolumes(db, c.Service, c.Name)
+		c.Cmd, _ = getCmd(db, c.Service, c.Name)
+
+		components = append(components, c)
+	}
+	return components, rows.Err()
+}
+
+// UpdateComponentState updates desired and/or observed state.
+func UpdateComponentState(db *sql.DB, service, name, desiredState, observedState string) error {
+	res, err := db.Exec(`
+		UPDATE components
+		SET desired_state = CASE WHEN ? = '' THEN desired_state ELSE ? END,
+		    observed_state = CASE WHEN ? = '' THEN observed_state ELSE ? END,
+		    updated_at = datetime('now')
+		WHERE service = ? AND name = ?`,
+		desiredState, desiredState, observedState, observedState, service, name,
+	)
+	if err != nil {
+		return fmt.Errorf("update state %q/%q: %w", service, name, err)
+	}
+	n, _ := res.RowsAffected()
+	if n == 0 {
+		return fmt.Errorf("update state %q/%q: %w", service, name, sql.ErrNoRows)
+	}
+	return nil
+}
+
+// UpdateComponentSpec updates the full spec for an existing component.
+func UpdateComponentSpec(db *sql.DB, c *Component) error {
+	tx, err := db.Begin()
+	if err != nil {
+		return fmt.Errorf("begin tx: %w", err)
+	}
+	defer tx.Rollback() //nolint:errcheck
+
+	_, err = tx.Exec(`
+		UPDATE components
+		SET image = ?, network = ?, user_spec = ?, restart = ?, version = ?, updated_at = datetime('now')
+		WHERE service = ? AND name = ?`,
+		c.Image, c.Network, c.UserSpec, c.Restart, c.Version, c.Service, c.Name,
+	)
+	if err != nil {
+		return fmt.Errorf("update component %q/%q: %w", c.Service, c.Name, err)
+	}
+
+	if err := setPorts(tx, c.Service, c.Name, c.Ports); err != nil {
+		return err
+	}
+	if err := setVolumes(tx, c.Service, c.Name, c.Volumes); err != nil {
+		return err
+	}
+	if err := setCmd(tx, c.Service, c.Name, c.Cmd); err != nil {
+		return err
+	}
+
+	return tx.Commit()
+}
+
+// DeleteComponent removes a component.
+func DeleteComponent(db *sql.DB, service, name string) error {
+	res, err := db.Exec("DELETE FROM components WHERE service = ? AND name = ?", service, name)
+	if err != nil {
+		return fmt.Errorf("delete component %q/%q: %w", service, name, err)
+	}
+	n, _ := res.RowsAffected()
+	if n == 0 {
+		return fmt.Errorf("delete component %q/%q: %w", service, name, sql.ErrNoRows)
+	}
+	return nil
+}
+
+// helper: set port mappings (delete + re-insert)
+func setPorts(tx *sql.Tx, service, component string, ports []string) error {
+	if _, err := tx.Exec("DELETE FROM component_ports WHERE service = ? AND component = ?", service, component); err != nil {
+		return fmt.Errorf("clear ports %q/%q: %w", service, component, err)
+	}
+	for _, p := range ports {
+		if _, err := tx.Exec("INSERT INTO component_ports (service, component, mapping) VALUES (?, ?, ?)", service, component, p); err != nil {
+			return fmt.Errorf("insert port %q/%q %q: %w", service, component, p, err)
+		}
+	}
+	return nil
+}
+
+func getPorts(db *sql.DB, service, component string) ([]string, error) {
+	rows, err := db.Query("SELECT mapping FROM component_ports WHERE service = ? AND component = ? ORDER BY mapping", service, component)
+	if err != nil {
+		return nil, fmt.Errorf("get ports %q/%q: %w", service, component, err)
+	}
+	defer func() { _ = rows.Close() }()
+	var ports []string
+	for rows.Next() {
+		var p string
+		if err := rows.Scan(&p); err != nil {
+			return nil, err
+		}
+		ports = append(ports, p)
+	}
+	return ports, rows.Err()
+}
+
+// helper: set volume mappings
+func setVolumes(tx *sql.Tx, service, component string, volumes []string) error {
+	if _, err := tx.Exec("DELETE FROM component_volumes WHERE service = ? AND component = ?", service, component); err != nil {
+		return fmt.Errorf("clear volumes %q/%q: %w", service, component, err)
+	}
+	for _, v := range volumes {
+		if _, err := tx.Exec("INSERT INTO component_volumes (service, component, mapping) VALUES (?, ?, ?)", service, component, v); err != nil {
+			return fmt.Errorf("insert volume %q/%q %q: %w", service, component, v, err)
+		}
+	}
+	return nil
+}
+
+func getVolumes(db *sql.DB, service, component string) ([]string, error) {
+	rows, err := db.Query("SELECT mapping FROM component_volumes WHERE service = ? AND component = ? ORDER BY mapping", service, component)
+	if err != nil {
+		return nil, fmt.Errorf("get volumes %q/%q: %w", service, component, err)
+	}
+	defer func() { _ = rows.Close() }()
+	var volumes []string
+	for rows.Next() {
+		var v string
+		if err := rows.Scan(&v); err != nil {
+			return nil, err
+		}
+		volumes = append(volumes, v)
+	}
+	return volumes, rows.Err()
+}
+
+// helper: set command args
+func setCmd(tx *sql.Tx, service, component string, cmd []string) error {
+	if _, err := tx.Exec("DELETE FROM component_cmd WHERE service = ? AND component = ?", service, component); err != nil {
+		return fmt.Errorf("clear cmd %q/%q: %w", service, component, err)
+	}
+	for i, arg := range cmd {
+		if _, err := tx.Exec("INSERT INTO component_cmd (service, component, position, arg) VALUES (?, ?, ?, ?)", service, component, i, arg); err != nil {
+			return fmt.Errorf("insert cmd %q/%q [%d]: %w", service, component, i, err)
+		}
+	}
+	return nil
+}
+
+func getCmd(db *sql.DB, service, component string) ([]string, error) {
+	rows, err := db.Query("SELECT arg FROM component_cmd WHERE service = ? AND component = ? ORDER BY position", service, component)
+	if err != nil {
+		return nil, fmt.Errorf("get cmd %q/%q: %w", service, component, err)
+	}
+	defer func() { _ = rows.Close() }()
+	var cmd []string
+	for rows.Next() {
+		var arg string
+		if err := rows.Scan(&arg); err != nil {
+			return nil, err
+		}
+		cmd = append(cmd, arg)
+	}
+	return cmd, rows.Err()
+}
--- a/internal/registry/db.go
+++ b/internal/registry/db.go
@@ -0,0 +1,130 @@
+package registry
+
+import (
+	"database/sql"
+	"fmt"
+
+	_ "modernc.org/sqlite"
+)
+
+// Open opens the registry database at the given path and runs migrations.
+func Open(path string) (*sql.DB, error) {
+	db, err := sql.Open("sqlite", path)
+	if err != nil {
+		return nil, fmt.Errorf("open database: %w", err)
+	}
+
+	for _, pragma := range []string{
+		"PRAGMA journal_mode = WAL",
+		"PRAGMA foreign_keys = ON",
+		"PRAGMA busy_timeout = 5000",
+	} {
+		if _, err := db.Exec(pragma); err != nil {
+			_ = db.Close()
+			return nil, fmt.Errorf("exec %q: %w", pragma, err)
+		}
+	}
+
+	if err := migrate(db); err != nil {
+		_ = db.Close()
+		return nil, fmt.Errorf("migrate: %w", err)
+	}
+
+	return db, nil
+}
+
+func migrate(db *sql.DB) error {
+	_, err := db.Exec(`
+		CREATE TABLE IF NOT EXISTS schema_migrations (
+			version INTEGER PRIMARY KEY,
+			applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+		);
+	`)
+	if err != nil {
+		return fmt.Errorf("create migrations table: %w", err)
+	}
+
+	for i, m := range migrations {
+		version := i + 1
+		var count int
+		if err := db.QueryRow("SELECT COUNT(*) FROM schema_migrations WHERE version = ?", version).Scan(&count); err != nil {
+			return fmt.Errorf("check migration %d: %w", version, err)
+		}
+		if count > 0 {
+			continue
+		}
+
+		if _, err := db.Exec(m); err != nil {
+			return fmt.Errorf("run migration %d: %w", version, err)
+		}
+		if _, err := db.Exec("INSERT INTO schema_migrations (version) VALUES (?)", version); err != nil {
+			return fmt.Errorf("record migration %d: %w", version, err)
+		}
+	}
+
+	return nil
+}
+
+var migrations = []string{
+	// Migration 1: initial schema
+	`
+	CREATE TABLE IF NOT EXISTS services (
+		name       TEXT PRIMARY KEY,
+		active     INTEGER NOT NULL DEFAULT 1,
+		created_at TEXT NOT NULL DEFAULT (datetime('now')),
+		updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+	);
+
+	CREATE TABLE IF NOT EXISTS components (
+		name           TEXT NOT NULL,
+		service        TEXT NOT NULL REFERENCES services(name) ON DELETE CASCADE,
+		image          TEXT NOT NULL,
+		network        TEXT NOT NULL DEFAULT 'bridge',
+		user_spec      TEXT NOT NULL DEFAULT '',
+		restart        TEXT NOT NULL DEFAULT 'unless-stopped',
+		desired_state  TEXT NOT NULL DEFAULT 'running',
+		observed_state TEXT NOT NULL DEFAULT 'unknown',
+		version        TEXT NOT NULL DEFAULT '',
+		created_at     TEXT NOT NULL DEFAULT (datetime('now')),
+		updated_at     TEXT NOT NULL DEFAULT (datetime('now')),
+		PRIMARY KEY (service, name)
+	);
+
+	CREATE TABLE IF NOT EXISTS component_ports (
+		service   TEXT NOT NULL,
+		component TEXT NOT NULL,
+		mapping   TEXT NOT NULL,
+		PRIMARY KEY (service, component, mapping),
+		FOREIGN KEY (service, component) REFERENCES components(service, name) ON DELETE CASCADE
+	);
+
+	CREATE TABLE IF NOT EXISTS component_volumes (
+		service   TEXT NOT NULL,
+		component TEXT NOT NULL,
+		mapping   TEXT NOT NULL,
+		PRIMARY KEY (service, component, mapping),
+		FOREIGN KEY (service, component) REFERENCES components(service, name) ON DELETE CASCADE
+	);
+
+	CREATE TABLE IF NOT EXISTS component_cmd (
+		service   TEXT NOT NULL,
+		component TEXT NOT NULL,
+		position  INTEGER NOT NULL,
+		arg       TEXT NOT NULL,
+		PRIMARY KEY (service, component, position),
+		FOREIGN KEY (service, component) REFERENCES components(service, name) ON DELETE CASCADE
+	);
+
+	CREATE TABLE IF NOT EXISTS events (
+		id         INTEGER PRIMARY KEY AUTOINCREMENT,
+		service    TEXT NOT NULL,
+		component  TEXT NOT NULL,
+		prev_state TEXT NOT NULL,
+		new_state  TEXT NOT NULL,
+		timestamp  TEXT NOT NULL DEFAULT (datetime('now'))
+	);
+
+	CREATE INDEX IF NOT EXISTS idx_events_component_time
+		ON events(service, component, timestamp);
+	`,
+}
--- a/internal/registry/events.go
+++ b/internal/registry/events.go
@@ -0,0 +1,96 @@
+package registry
+
+import (
+	"database/sql"
+	"fmt"
+	"time"
+)
+
+// Event represents a state-change event.
+type Event struct {
+	ID        int64
+	Service   string
+	Component string
+	PrevState string
+	NewState  string
+	Timestamp time.Time
+}
+
+// InsertEvent records a state transition.
+func InsertEvent(db *sql.DB, service, component, prevState, newState string) error {
+	_, err := db.Exec(
+		"INSERT INTO events (service, component, prev_state, new_state) VALUES (?, ?, ?, ?)",
+		service, component, prevState, newState,
+	)
+	if err != nil {
+		return fmt.Errorf("insert event %q/%q: %w", service, component, err)
+	}
+	return nil
+}
+
+// QueryEvents returns events for a service/component within a time window.
+// If service is empty, returns events for all services.
+// If component is empty, returns events for all components in the service.
+func QueryEvents(db *sql.DB, service, component string, since time.Time, limit int) ([]Event, error) {
+	query := "SELECT id, service, component, prev_state, new_state, timestamp FROM events WHERE timestamp > ?"
+	args := []any{since.UTC().Format("2006-01-02 15:04:05")}
+
+	if service != "" {
+		query += " AND service = ?"
+		args = append(args, service)
+	}
+	if component != "" {
+		query += " AND component = ?"
+		args = append(args, component)
+	}
+
+	query += " ORDER BY timestamp DESC"
+	if limit > 0 {
+		query += " LIMIT ?"
+		args = append(args, limit)
+	}
+
+	rows, err := db.Query(query, args...)
+	if err != nil {
+		return nil, fmt.Errorf("query events: %w", err)
+	}
+	defer func() { _ = rows.Close() }()
+
+	var events []Event
+	for rows.Next() {
+		var e Event
+		var ts string
+		if err := rows.Scan(&e.ID, &e.Service, &e.Component, &e.PrevState, &e.NewState, &ts); err != nil {
+			return nil, fmt.Errorf("scan event: %w", err)
+		}
+		e.Timestamp, _ = time.Parse("2006-01-02 15:04:05", ts)
+		events = append(events, e)
+	}
+	return events, rows.Err()
+}
+
+// CountEvents counts events for a component within a time window matching
+// a specific new_state. Used for flap detection.
+func CountEvents(db *sql.DB, service, component string, since time.Time) (int, error) {
+	var count int
+	err := db.QueryRow(
+		"SELECT COUNT(*) FROM events WHERE service = ? AND component = ? AND timestamp > ?",
+		service, component, since.UTC().Format("2006-01-02 15:04:05"),
+	).Scan(&count)
+	if err != nil {
+		return 0, fmt.Errorf("count events %q/%q: %w", service, component, err)
+	}
+	return count, nil
+}
+
+// PruneEvents deletes events older than the given time.
+func PruneEvents(db *sql.DB, before time.Time) (int64, error) {
+	res, err := db.Exec(
+		"DELETE FROM events WHERE timestamp < ?",
+		before.UTC().Format("2006-01-02 15:04:05"),
+	)
+	if err != nil {
+		return 0, fmt.Errorf("prune events: %w", err)
+	}
+	return res.RowsAffected()
+}
--- a/internal/registry/registry_test.go
+++ b/internal/registry/registry_test.go
@@ -0,0 +1,307 @@
+package registry
+
+import (
+	"database/sql"
+	"errors"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+func openTestDB(t *testing.T) *sql.DB {
+	t.Helper()
+	db, err := Open(filepath.Join(t.TempDir(), "test.db"))
+	if err != nil {
+		t.Fatalf("open db: %v", err)
+	}
+	t.Cleanup(func() { _ = db.Close() })
+	return db
+}
+
+func TestMigrationIdempotent(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "test.db")
+	db1, err := Open(path)
+	if err != nil {
+		t.Fatalf("first open: %v", err)
+	}
+	_ = db1.Close()
+
+	db2, err := Open(path)
+	if err != nil {
+		t.Fatalf("second open: %v", err)
+	}
+	_ = db2.Close()
+}
+
+func TestServiceCRUD(t *testing.T) {
+	db := openTestDB(t)
+
+	// Create
+	if err := CreateService(db, "metacrypt", true); err != nil {
+		t.Fatalf("create: %v", err)
+	}
+
+	// Get
+	s, err := GetService(db, "metacrypt")
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	if s.Name != "metacrypt" || !s.Active {
+		t.Fatalf("got %+v", s)
+	}
+
+	// List
+	services, err := ListServices(db)
+	if err != nil {
+		t.Fatalf("list: %v", err)
+	}
+	if len(services) != 1 || services[0].Name != "metacrypt" {
+		t.Fatalf("list: got %d services", len(services))
+	}
+
+	// Update active
+	if err := UpdateServiceActive(db, "metacrypt", false); err != nil {
+		t.Fatalf("update: %v", err)
+	}
+	s, _ = GetService(db, "metacrypt")
+	if s.Active {
+		t.Fatal("expected inactive")
+	}
+
+	// Delete
+	if err := DeleteService(db, "metacrypt"); err != nil {
+		t.Fatalf("delete: %v", err)
+	}
+	_, err = GetService(db, "metacrypt")
+	if !errors.Is(err, sql.ErrNoRows) {
+		t.Fatalf("expected ErrNoRows after delete, got: %v", err)
+	}
+}
+
+func TestServiceDuplicateName(t *testing.T) {
+	db := openTestDB(t)
+	if err := CreateService(db, "metacrypt", true); err != nil {
+		t.Fatalf("first create: %v", err)
+	}
+	if err := CreateService(db, "metacrypt", true); err == nil {
+		t.Fatal("expected error on duplicate name")
+	}
+}
+
+func TestComponentCRUD(t *testing.T) {
+	db := openTestDB(t)
+	if err := CreateService(db, "metacrypt", true); err != nil {
+		t.Fatalf("create service: %v", err)
+	}
+
+	// Create component
+	c := &Component{
+		Name:          "api",
+		Service:       "metacrypt",
+		Image:         "mcr.svc.mcp.metacircular.net:8443/metacrypt:v1.0.0",
+		Network:       "docker_default",
+		UserSpec:      "0:0",
+		Restart:       "unless-stopped",
+		DesiredState:  "running",
+		ObservedState: "unknown",
+		Ports:         []string{"127.0.0.1:18443:8443", "127.0.0.1:19443:9443"},
+		Volumes:       []string{"/srv/metacrypt:/srv/metacrypt"},
+		Cmd:           nil,
+	}
+	if err := CreateComponent(db, c); err != nil {
+		t.Fatalf("create component: %v", err)
+	}
+
+	// Get
+	got, err := GetComponent(db, "metacrypt", "api")
+	if err != nil {
+		t.Fatalf("get: %v", err)
+	}
+	if got.Image != c.Image {
+		t.Fatalf("image: got %q, want %q", got.Image, c.Image)
+	}
+	if len(got.Ports) != 2 {
+		t.Fatalf("ports: got %d, want 2", len(got.Ports))
+	}
+	if len(got.Volumes) != 1 {
+		t.Fatalf("volumes: got %d, want 1", len(got.Volumes))
+	}
+
+	// Create a second component
+	c2 := &Component{
+		Name:          "web",
+		Service:       "metacrypt",
+		Image:         "mcr.svc.mcp.metacircular.net:8443/metacrypt-web:v1.0.0",
+		Network:       "docker_default",
+		Restart:       "unless-stopped",
+		DesiredState:  "running",
+		ObservedState: "unknown",
+		Ports:         []string{"127.0.0.1:18080:8080"},
+		Volumes:       []string{"/srv/metacrypt:/srv/metacrypt"},
+		Cmd:           []string{"server", "--config", "/srv/metacrypt/metacrypt.toml"},
+	}
+	if err := CreateComponent(db, c2); err != nil {
+		t.Fatalf("create web: %v", err)
+	}
+
+	// List
+	components, err := ListComponents(db, "metacrypt")
+	if err != nil {
+		t.Fatalf("list: %v", err)
+	}
+	if len(components) != 2 {
+		t.Fatalf("list: got %d, want 2", len(components))
+	}
+
+	// Verify cmd
+	got2, _ := GetComponent(db, "metacrypt", "web")
+	if len(got2.Cmd) != 3 || got2.Cmd[0] != "server" {
+		t.Fatalf("cmd: got %v", got2.Cmd)
+	}
+
+	// Update state
+	if err := UpdateComponentState(db, "metacrypt", "api", "", "running"); err != nil {
+		t.Fatalf("update state: %v", err)
+	}
+	got, _ = GetComponent(db, "metacrypt", "api")
+	if got.ObservedState != "running" {
+		t.Fatalf("observed: got %q, want running", got.ObservedState)
+	}
+	if got.DesiredState != "running" {
+		t.Fatalf("desired should be unchanged: got %q", got.DesiredState)
+	}
+
+	// Update spec
+	c.Image = "mcr.svc.mcp.metacircular.net:8443/metacrypt:v2.0.0"
+	c.Version = "v2.0.0"
+	c.Ports = []string{"127.0.0.1:18443:8443"}
+	if err := UpdateComponentSpec(db, c); err != nil {
+		t.Fatalf("update spec: %v", err)
+	}
+	got, _ = GetComponent(db, "metacrypt", "api")
+	if got.Image != c.Image {
+		t.Fatalf("updated image: got %q", got.Image)
+	}
+	if len(got.Ports) != 1 {
+		t.Fatalf("updated ports: got %d, want 1", len(got.Ports))
+	}
+
+	// Delete component
+	if err := DeleteComponent(db, "metacrypt", "web"); err != nil {
+		t.Fatalf("delete: %v", err)
+	}
+	components, _ = ListComponents(db, "metacrypt")
+	if len(components) != 1 {
+		t.Fatalf("after delete: got %d, want 1", len(components))
+	}
+}
+
+func TestComponentCompositePK(t *testing.T) {
+	db := openTestDB(t)
+	if err := CreateService(db, "metacrypt", true); err != nil {
+		t.Fatalf("create service: %v", err)
+	}
+
+	c := &Component{Name: "api", Service: "metacrypt", Image: "img:v1", Restart: "unless-stopped", DesiredState: "running", ObservedState: "unknown"}
+	if err := CreateComponent(db, c); err != nil {
+		t.Fatalf("first create: %v", err)
+	}
+	if err := CreateComponent(db, c); err == nil {
+		t.Fatal("expected error on duplicate (service, name)")
+	}
+}
+
+func TestCascadeDelete(t *testing.T) {
+	db := openTestDB(t)
+	if err := CreateService(db, "metacrypt", true); err != nil {
+		t.Fatalf("create service: %v", err)
+	}
+
+	c := &Component{
+		Name: "api", Service: "metacrypt", Image: "img:v1",
+		Restart: "unless-stopped", DesiredState: "running", ObservedState: "unknown",
+		Ports: []string{"8443:8443"}, Volumes: []string{"/srv/metacrypt:/srv/metacrypt"},
+	}
+	if err := CreateComponent(db, c); err != nil {
+		t.Fatalf("create component: %v", err)
+	}
+
+	// Delete service should cascade to components, ports, volumes
+	if err := DeleteService(db, "metacrypt"); err != nil {
+		t.Fatalf("delete service: %v", err)
+	}
+
+	components, _ := ListComponents(db, "metacrypt")
+	if len(components) != 0 {
+		t.Fatalf("components should be empty after cascade, got %d", len(components))
+	}
+}
+
+func TestEvents(t *testing.T) {
+	db := openTestDB(t)
+
+	// Insert events
+	if err := InsertEvent(db, "metacrypt", "api", "unknown", "running"); err != nil {
+		t.Fatalf("insert: %v", err)
+	}
+	if err := InsertEvent(db, "metacrypt", "api", "running", "exited"); err != nil {
+		t.Fatalf("insert: %v", err)
+	}
+	if err := InsertEvent(db, "mcr", "api", "unknown", "running"); err != nil {
+		t.Fatalf("insert: %v", err)
+	}
+
+	// Query all recent
+	events, err := QueryEvents(db, "", "", time.Now().Add(-1*time.Hour), 0)
+	if err != nil {
+		t.Fatalf("query: %v", err)
+	}
+	if len(events) != 3 {
+		t.Fatalf("got %d events, want 3", len(events))
+	}
+
+	// Query by service
+	events, _ = QueryEvents(db, "metacrypt", "", time.Now().Add(-1*time.Hour), 0)
+	if len(events) != 2 {
+		t.Fatalf("by service: got %d, want 2", len(events))
+	}
+
+	// Query by component
+	events, _ = QueryEvents(db, "metacrypt", "api", time.Now().Add(-1*time.Hour), 0)
+	if len(events) != 2 {
+		t.Fatalf("by component: got %d, want 2", len(events))
+	}
+
+	// Query with limit
+	events, _ = QueryEvents(db, "", "", time.Now().Add(-1*time.Hour), 1)
+	if len(events) != 1 {
+		t.Fatalf("with limit: got %d, want 1", len(events))
+	}
+
+	// Count
+	count, err := CountEvents(db, "metacrypt", "api", time.Now().Add(-1*time.Hour))
+	if err != nil {
+		t.Fatalf("count: %v", err)
+	}
+	if count != 2 {
+		t.Fatalf("count: got %d, want 2", count)
+	}
+
+	// Prune (prune nothing since events are recent)
+	pruned, err := PruneEvents(db, time.Now().Add(-1*time.Hour))
+	if err != nil {
+		t.Fatalf("prune: %v", err)
+	}
+	if pruned != 0 {
+		t.Fatalf("pruned: got %d, want 0", pruned)
+	}
+
+	// Prune everything
+	pruned, err = PruneEvents(db, time.Now().Add(1*time.Hour))
+	if err != nil {
+		t.Fatalf("prune all: %v", err)
+	}
+	if pruned != 3 {
+		t.Fatalf("pruned all: got %d, want 3", pruned)
+	}
+}
--- a/internal/registry/services.go
+++ b/internal/registry/services.go
@@ -0,0 +1,94 @@
+package registry
+
+import (
+	"database/sql"
+	"fmt"
+	"time"
+)
+
+// Service represents a service in the registry.
+type Service struct {
+	Name      string
+	Active    bool
+	CreatedAt time.Time
+	UpdatedAt time.Time
+}
+
+// CreateService creates a new service in the registry.
+func CreateService(db *sql.DB, name string, active bool) error {
+	_, err := db.Exec(
+		"INSERT INTO services (name, active) VALUES (?, ?)",
+		name, active,
+	)
+	if err != nil {
+		return fmt.Errorf("create service %q: %w", name, err)
+	}
+	return nil
+}
+
+// GetService retrieves a service by name.
+func GetService(db *sql.DB, name string) (*Service, error) {
+	s := &Service{}
+	var createdAt, updatedAt string
+	err := db.QueryRow(
+		"SELECT name, active, created_at, updated_at FROM services WHERE name = ?",
+		name,
+	).Scan(&s.Name, &s.Active, &createdAt, &updatedAt)
+	if err != nil {
+		return nil, fmt.Errorf("get service %q: %w", name, err)
+	}
+	s.CreatedAt, _ = time.Parse("2006-01-02 15:04:05", createdAt)
+	s.UpdatedAt, _ = time.Parse("2006-01-02 15:04:05", updatedAt)
+	return s, nil
+}
+
+// ListServices returns all services.
+func ListServices(db *sql.DB) ([]Service, error) {
+	rows, err := db.Query("SELECT name, active, created_at, updated_at FROM services ORDER BY name")
+	if err != nil {
+		return nil, fmt.Errorf("list services: %w", err)
+	}
+	defer func() { _ = rows.Close() }()
+
+	var services []Service
+	for rows.Next() {
+		var s Service
+		var createdAt, updatedAt string
+		if err := rows.Scan(&s.Name, &s.Active, &createdAt, &updatedAt); err != nil {
+			return nil, fmt.Errorf("scan service: %w", err)
+		}
+		s.CreatedAt, _ = time.Parse("2006-01-02 15:04:05", createdAt)
+		s.UpdatedAt, _ = time.Parse("2006-01-02 15:04:05", updatedAt)
+		services = append(services, s)
+	}
+	return services, rows.Err()
+}
+
+// UpdateServiceActive updates a service's active flag.
+func UpdateServiceActive(db *sql.DB, name string, active bool) error {
+	res, err := db.Exec(
+		"UPDATE services SET active = ?, updated_at = datetime('now') WHERE name = ?",
+		active, name,
+	)
+	if err != nil {
+		return fmt.Errorf("update service %q: %w", name, err)
+	}
+	n, _ := res.RowsAffected()
+	if n == 0 {
+		return fmt.Errorf("update service %q: %w", name, sql.ErrNoRows)
+	}
+	return nil
+}
+
+// DeleteService removes a service and all its components (via CASCADE).
+func DeleteService(db *sql.DB, name string) error {
+	res, err := db.Exec("DELETE FROM services WHERE name = ?", name)
+	if err != nil {
+		return fmt.Errorf("delete service %q: %w", name, err)
+	}
+	n, _ := res.RowsAffected()
+	if n == 0 {
+		return fmt.Errorf("delete service %q: %w", name, sql.ErrNoRows)
+	}
+	return nil
+}