feat: docker-compose stacks with Forge-themed UI

Adds a new Stacks feature: upload/edit docker-compose YAML, deploy as atomic units, browse revisions, roll back, and stream logs. Backend in internal/stack + internal/api/stacks.go, persistent storage in internal/store/stacks.go. Stacks pages (list, new, detail) use a modern Forge aesthetic — Instrument Serif display type, JetBrains Mono for meta/code, indigo ember accents, dot-grid hero, registration marks on hover, terminal panel for logs. Palette is sourced from the app's existing design tokens so the feature remains consistent with the rest of Tinyforge. Fonts self-hosted via @fontsource/instrument-serif and @fontsource/jetbrains-mono to satisfy the strict CSP.
2026-04-16 03:48:37 +03:00
parent b622384774
commit 75424a5f25
23 changed files with 3603 additions and 18 deletions
@@ -234,6 +234,44 @@ type StaticSiteSecret struct {
 	UpdatedAt string `json:"updated_at"`
 }

+// Stack represents a docker-compose stack managed as a single deployable unit.
+type Stack struct {
+	ID                 string `json:"id"`
+	Name               string `json:"name"`
+	Description        string `json:"description"`
+	ComposeProjectName string `json:"compose_project_name"` // `-p` arg for docker compose
+	Status             string `json:"status"`               // stopped, deploying, running, failed
+	Error              string `json:"error"`
+	CurrentRevisionID  string `json:"current_revision_id"`
+	CreatedAt          string `json:"created_at"`
+	UpdatedAt          string `json:"updated_at"`
+}
+
+// StackRevision is an append-only record of a YAML version for a stack.
+// Rollback = insert a new revision whose YAML is copied from an older one.
+type StackRevision struct {
+	ID        string `json:"id"`
+	StackID   string `json:"stack_id"`
+	Revision  int    `json:"revision"` // monotonic per stack
+	YAML      string `json:"yaml"`
+	Author    string `json:"author"`
+	DeployID  string `json:"deploy_id"`
+	Status    string `json:"status"` // pending, success, failed
+	CreatedAt string `json:"created_at"`
+}
+
+// StackDeploy records a deployment attempt of a specific revision.
+type StackDeploy struct {
+	ID         string `json:"id"`
+	StackID    string `json:"stack_id"`
+	RevisionID string `json:"revision_id"`
+	Status     string `json:"status"` // pending, deploying, success, failed, rolled_back
+	Log        string `json:"log"`
+	Error      string `json:"error"`
+	StartedAt  string `json:"started_at"`
+	FinishedAt string `json:"finished_at"`
+}
+
 // EventLog represents a persistent event log entry.
 type EventLog struct {
 	ID        int64  `json:"id"`
@@ -0,0 +1,324 @@
+package store
+
+import (
+	"database/sql"
+	"errors"
+	"fmt"
+
+	"github.com/google/uuid"
+)
+
+const stackCols = `id, name, description, compose_project_name, status, error,
+	current_revision_id, created_at, updated_at`
+
+// CreateStack inserts a new stack and returns it.
+func (s *Store) CreateStack(st Stack) (Stack, error) {
+	st.ID = uuid.New().String()
+	st.CreatedAt = Now()
+	st.UpdatedAt = st.CreatedAt
+	if st.Status == "" {
+		st.Status = "stopped"
+	}
+
+	_, err := s.db.Exec(
+		`INSERT INTO stacks (`+stackCols+`)
+		 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+		st.ID, st.Name, st.Description, st.ComposeProjectName, st.Status,
+		st.Error, st.CurrentRevisionID, st.CreatedAt, st.UpdatedAt,
+	)
+	if err != nil {
+		return Stack{}, fmt.Errorf("insert stack: %w", err)
+	}
+	return st, nil
+}
+
+// GetStackByID returns a single stack by its ID.
+func (s *Store) GetStackByID(id string) (Stack, error) {
+	st, err := scanStackRow(s.db.QueryRow(
+		`SELECT `+stackCols+` FROM stacks WHERE id = ?`, id,
+	))
+	if errors.Is(err, sql.ErrNoRows) {
+		return Stack{}, fmt.Errorf("stack %s: %w", id, ErrNotFound)
+	}
+	if err != nil {
+		return Stack{}, fmt.Errorf("query stack: %w", err)
+	}
+	return st, nil
+}
+
+// GetAllStacks returns every stack ordered by name.
+func (s *Store) GetAllStacks() ([]Stack, error) {
+	rows, err := s.db.Query(`SELECT ` + stackCols + ` FROM stacks ORDER BY name`)
+	if err != nil {
+		return nil, fmt.Errorf("query stacks: %w", err)
+	}
+	defer rows.Close()
+
+	out := []Stack{}
+	for rows.Next() {
+		st, err := scanStackRows(rows)
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, st)
+	}
+	return out, rows.Err()
+}
+
+// UpdateStack updates the mutable metadata fields (name, description).
+func (s *Store) UpdateStack(st Stack) error {
+	st.UpdatedAt = Now()
+	result, err := s.db.Exec(
+		`UPDATE stacks SET name=?, description=?, updated_at=? WHERE id=?`,
+		st.Name, st.Description, st.UpdatedAt, st.ID,
+	)
+	if err != nil {
+		return fmt.Errorf("update stack: %w", err)
+	}
+	n, _ := result.RowsAffected()
+	if n == 0 {
+		return fmt.Errorf("stack %s: %w", st.ID, ErrNotFound)
+	}
+	return nil
+}
+
+// UpdateStackStatus updates the deployment status + error fields.
+func (s *Store) UpdateStackStatus(id, status, errMsg string) error {
+	now := Now()
+	result, err := s.db.Exec(
+		`UPDATE stacks SET status=?, error=?, updated_at=? WHERE id=?`,
+		status, errMsg, now, id,
+	)
+	if err != nil {
+		return fmt.Errorf("update stack status: %w", err)
+	}
+	n, _ := result.RowsAffected()
+	if n == 0 {
+		return fmt.Errorf("stack %s: %w", id, ErrNotFound)
+	}
+	return nil
+}
+
+// SetStackCurrentRevision updates the current_revision_id pointer.
+func (s *Store) SetStackCurrentRevision(id, revisionID string) error {
+	now := Now()
+	result, err := s.db.Exec(
+		`UPDATE stacks SET current_revision_id=?, updated_at=? WHERE id=?`,
+		revisionID, now, id,
+	)
+	if err != nil {
+		return fmt.Errorf("update stack revision pointer: %w", err)
+	}
+	n, _ := result.RowsAffected()
+	if n == 0 {
+		return fmt.Errorf("stack %s: %w", id, ErrNotFound)
+	}
+	return nil
+}
+
+// DeleteStack removes a stack by ID. Cascading deletes handle revisions + deploys.
+func (s *Store) DeleteStack(id string) error {
+	result, err := s.db.Exec(`DELETE FROM stacks WHERE id = ?`, id)
+	if err != nil {
+		return fmt.Errorf("delete stack: %w", err)
+	}
+	n, _ := result.RowsAffected()
+	if n == 0 {
+		return fmt.Errorf("stack %s: %w", id, ErrNotFound)
+	}
+	return nil
+}
+
+func scanStackRow(row *sql.Row) (Stack, error) {
+	var st Stack
+	err := row.Scan(
+		&st.ID, &st.Name, &st.Description, &st.ComposeProjectName,
+		&st.Status, &st.Error, &st.CurrentRevisionID, &st.CreatedAt, &st.UpdatedAt,
+	)
+	return st, err
+}
+
+func scanStackRows(rows *sql.Rows) (Stack, error) {
+	var st Stack
+	err := rows.Scan(
+		&st.ID, &st.Name, &st.Description, &st.ComposeProjectName,
+		&st.Status, &st.Error, &st.CurrentRevisionID, &st.CreatedAt, &st.UpdatedAt,
+	)
+	if err != nil {
+		return Stack{}, fmt.Errorf("scan stack: %w", err)
+	}
+	return st, nil
+}
+
+// --- Stack revisions ---
+
+const stackRevisionCols = `id, stack_id, revision, yaml, author, deploy_id, status, created_at`
+
+// CreateStackRevision inserts a new revision with the next monotonic revision number.
+func (s *Store) CreateStackRevision(r StackRevision) (StackRevision, error) {
+	r.ID = uuid.New().String()
+	r.CreatedAt = Now()
+	if r.Status == "" {
+		r.Status = "pending"
+	}
+
+	tx, err := s.db.Begin()
+	if err != nil {
+		return StackRevision{}, fmt.Errorf("begin tx: %w", err)
+	}
+	defer tx.Rollback()
+
+	var next int
+	if err := tx.QueryRow(
+		`SELECT COALESCE(MAX(revision), 0) + 1 FROM stack_revisions WHERE stack_id = ?`,
+		r.StackID,
+	).Scan(&next); err != nil {
+		return StackRevision{}, fmt.Errorf("next revision: %w", err)
+	}
+	r.Revision = next
+
+	if _, err := tx.Exec(
+		`INSERT INTO stack_revisions (`+stackRevisionCols+`)
+		 VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+		r.ID, r.StackID, r.Revision, r.YAML, r.Author, r.DeployID, r.Status, r.CreatedAt,
+	); err != nil {
+		return StackRevision{}, fmt.Errorf("insert revision: %w", err)
+	}
+	if err := tx.Commit(); err != nil {
+		return StackRevision{}, fmt.Errorf("commit revision: %w", err)
+	}
+	return r, nil
+}
+
+// GetStackRevisionByID returns a single revision by ID.
+func (s *Store) GetStackRevisionByID(id string) (StackRevision, error) {
+	r, err := scanStackRevisionRow(s.db.QueryRow(
+		`SELECT `+stackRevisionCols+` FROM stack_revisions WHERE id = ?`, id,
+	))
+	if errors.Is(err, sql.ErrNoRows) {
+		return StackRevision{}, fmt.Errorf("revision %s: %w", id, ErrNotFound)
+	}
+	if err != nil {
+		return StackRevision{}, fmt.Errorf("query revision: %w", err)
+	}
+	return r, nil
+}
+
+// GetStackRevisionsByStackID returns revisions newest-first.
+func (s *Store) GetStackRevisionsByStackID(stackID string) ([]StackRevision, error) {
+	rows, err := s.db.Query(
+		`SELECT `+stackRevisionCols+` FROM stack_revisions WHERE stack_id = ?
+		 ORDER BY revision DESC`,
+		stackID,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("query revisions: %w", err)
+	}
+	defer rows.Close()
+
+	out := []StackRevision{}
+	for rows.Next() {
+		r, err := scanStackRevisionRows(rows)
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, r)
+	}
+	return out, rows.Err()
+}
+
+// UpdateStackRevisionStatus updates status + deploy_id linkage.
+func (s *Store) UpdateStackRevisionStatus(id, status, deployID string) error {
+	result, err := s.db.Exec(
+		`UPDATE stack_revisions SET status=?, deploy_id=? WHERE id=?`,
+		status, deployID, id,
+	)
+	if err != nil {
+		return fmt.Errorf("update revision status: %w", err)
+	}
+	n, _ := result.RowsAffected()
+	if n == 0 {
+		return fmt.Errorf("revision %s: %w", id, ErrNotFound)
+	}
+	return nil
+}
+
+func scanStackRevisionRow(row *sql.Row) (StackRevision, error) {
+	var r StackRevision
+	err := row.Scan(
+		&r.ID, &r.StackID, &r.Revision, &r.YAML, &r.Author, &r.DeployID, &r.Status, &r.CreatedAt,
+	)
+	return r, err
+}
+
+func scanStackRevisionRows(rows *sql.Rows) (StackRevision, error) {
+	var r StackRevision
+	err := rows.Scan(
+		&r.ID, &r.StackID, &r.Revision, &r.YAML, &r.Author, &r.DeployID, &r.Status, &r.CreatedAt,
+	)
+	if err != nil {
+		return StackRevision{}, fmt.Errorf("scan revision: %w", err)
+	}
+	return r, nil
+}
+
+// --- Stack deploys ---
+
+const stackDeployCols = `id, stack_id, revision_id, status, log, error, started_at, finished_at`
+
+// CreateStackDeploy inserts a new deploy record.
+func (s *Store) CreateStackDeploy(d StackDeploy) (StackDeploy, error) {
+	d.ID = uuid.New().String()
+	d.StartedAt = Now()
+	if d.Status == "" {
+		d.Status = "pending"
+	}
+
+	_, err := s.db.Exec(
+		`INSERT INTO stack_deploys (`+stackDeployCols+`)
+		 VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+		d.ID, d.StackID, d.RevisionID, d.Status, d.Log, d.Error, d.StartedAt, d.FinishedAt,
+	)
+	if err != nil {
+		return StackDeploy{}, fmt.Errorf("insert stack deploy: %w", err)
+	}
+	return d, nil
+}
+
+// GetStackDeployByID returns a single deploy by ID.
+func (s *Store) GetStackDeployByID(id string) (StackDeploy, error) {
+	d, err := scanStackDeployRow(s.db.QueryRow(
+		`SELECT `+stackDeployCols+` FROM stack_deploys WHERE id = ?`, id,
+	))
+	if errors.Is(err, sql.ErrNoRows) {
+		return StackDeploy{}, fmt.Errorf("stack deploy %s: %w", id, ErrNotFound)
+	}
+	if err != nil {
+		return StackDeploy{}, fmt.Errorf("query stack deploy: %w", err)
+	}
+	return d, nil
+}
+
+// UpdateStackDeploy updates status, log, error, finished_at.
+func (s *Store) UpdateStackDeploy(d StackDeploy) error {
+	result, err := s.db.Exec(
+		`UPDATE stack_deploys SET status=?, log=?, error=?, finished_at=? WHERE id=?`,
+		d.Status, d.Log, d.Error, d.FinishedAt, d.ID,
+	)
+	if err != nil {
+		return fmt.Errorf("update stack deploy: %w", err)
+	}
+	n, _ := result.RowsAffected()
+	if n == 0 {
+		return fmt.Errorf("stack deploy %s: %w", d.ID, ErrNotFound)
+	}
+	return nil
+}
+
+func scanStackDeployRow(row *sql.Row) (StackDeploy, error) {
+	var d StackDeploy
+	err := row.Scan(
+		&d.ID, &d.StackID, &d.RevisionID, &d.Status, &d.Log, &d.Error, &d.StartedAt, &d.FinishedAt,
+	)
+	return d, err
+}
@@ -130,6 +130,48 @@ func (s *Store) runMigrations() error {
 		`ALTER TABLE static_sites ADD COLUMN storage_limit_mb INTEGER NOT NULL DEFAULT 0`,
 	}

+	// Additive stack tables (2026-04-16). Created here rather than in the
+	// schema constant so older databases pick them up on restart.
+	stackTables := []string{
+		`CREATE TABLE IF NOT EXISTS stacks (
+			id                   TEXT PRIMARY KEY,
+			name                 TEXT NOT NULL UNIQUE,
+			description          TEXT NOT NULL DEFAULT '',
+			compose_project_name TEXT NOT NULL UNIQUE,
+			status               TEXT NOT NULL DEFAULT 'stopped',
+			error                TEXT NOT NULL DEFAULT '',
+			current_revision_id  TEXT NOT NULL DEFAULT '',
+			created_at           TEXT NOT NULL DEFAULT (datetime('now')),
+			updated_at           TEXT NOT NULL DEFAULT (datetime('now'))
+		)`,
+		`CREATE TABLE IF NOT EXISTS stack_revisions (
+			id         TEXT PRIMARY KEY,
+			stack_id   TEXT NOT NULL REFERENCES stacks(id) ON DELETE CASCADE,
+			revision   INTEGER NOT NULL,
+			yaml       TEXT NOT NULL,
+			author     TEXT NOT NULL DEFAULT '',
+			deploy_id  TEXT NOT NULL DEFAULT '',
+			status     TEXT NOT NULL DEFAULT 'pending',
+			created_at TEXT NOT NULL DEFAULT (datetime('now')),
+			UNIQUE(stack_id, revision)
+		)`,
+		`CREATE TABLE IF NOT EXISTS stack_deploys (
+			id          TEXT PRIMARY KEY,
+			stack_id    TEXT NOT NULL REFERENCES stacks(id) ON DELETE CASCADE,
+			revision_id TEXT NOT NULL DEFAULT '',
+			status      TEXT NOT NULL DEFAULT 'pending',
+			log         TEXT NOT NULL DEFAULT '',
+			error       TEXT NOT NULL DEFAULT '',
+			started_at  TEXT NOT NULL DEFAULT (datetime('now')),
+			finished_at TEXT NOT NULL DEFAULT ''
+		)`,
+	}
+	for _, t := range stackTables {
+		if _, err := s.db.Exec(t); err != nil {
+			return fmt.Errorf("create stack table: %w", err)
+		}
+	}
+
 	for _, m := range migrations {
 		// Ignore errors from already-applied migrations (duplicate column).
 		_, _ = s.db.Exec(m)
@@ -150,6 +192,8 @@ func (s *Store) runMigrations() error {
 		`CREATE INDEX IF NOT EXISTS idx_event_log_created_at ON event_log(created_at)`,
 		`CREATE INDEX IF NOT EXISTS idx_dns_records_consumer ON dns_records(consumer_type, consumer_id)`,
 		`CREATE INDEX IF NOT EXISTS idx_static_site_secrets_site_id ON static_site_secrets(site_id)`,
+		`CREATE INDEX IF NOT EXISTS idx_stack_revisions_stack_id ON stack_revisions(stack_id)`,
+		`CREATE INDEX IF NOT EXISTS idx_stack_deploys_stack_id ON stack_deploys(stack_id)`,
 	}
 	for _, idx := range indexes {
 		if _, err := s.db.Exec(idx); err != nil {