Jarl 0.1.0: manage BIND through a web UI, REST API and CLI

Jarl keeps a BIND 9.20 server's whole configuration (views, ACLs, TSIG
keys, zones of every type, records, named.conf options) in SQLite and
renders named.conf, keys.conf and zone files from it.

Every change goes through one changeset pipeline: whole-configuration
validation, named-checkconf -z and named-checkzone in a staging
directory, atomic install, rndc reconfig/reload, serial verification
with rndc zonestatus, and rollback if named does not load the change.
Changes apply one at a time by default or are bundled and applied
together. Applied changesets can be reverted.

- jarld: the daemon with the REST API and an embedded web UI, plus import,
  adopt, check, resync, backup and local user recovery commands
- jarl: the CLI, including ACME DNS-01 hooks for certbot and acme.sh
- users with argon2id passwords and CSRF-protected sessions; hashed API
  tokens with granular grants and roles; an audit log
- systemd unit, sysusers.d/tmpfiles.d files, Makefile
- unit tests, integration tests against a real named, scripts/e2e.sh
- docs/ guides, README and CHANGELOG

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

internal/namedconf/printer.go

@@ -0,0 +1,160 @@
+package namedconf
+
+import (
+	"strings"
+)
+
+// maxInline is the widest a block may be to be printed on one line.
+const maxInline = 72
+
+// Format returns stmts in canonical form, one statement per line, with
+// nested blocks indented by tabs.
+func Format(stmts []*Stmt) string {
+	var sb strings.Builder
+	for _, s := range stmts {
+		writeStmt(&sb, s, 0)
+	}
+	return sb.String()
+}
+
+// FormatStmt returns a single statement in canonical form, indented by
+// indent tabs, including the trailing newline.
+func FormatStmt(s *Stmt, indent int) string {
+	var sb strings.Builder
+	writeStmt(&sb, s, indent)
+	return sb.String()
+}
+
+// Compact returns the statement's items on a single line, without the
+// trailing semicolon: `allow-query { 10.0.0.0/8; localhost; }`.
+func Compact(items []Item) string {
+	var sb strings.Builder
+	writeItemsInline(&sb, items)
+	return sb.String()
+}
+
+// CompactStmt returns the statement on a single line with its semicolon.
+func CompactStmt(s *Stmt) string { return Compact(s.Items) + ";" }
+
+// QuoteString returns s as a named.conf quoted string.
+func QuoteString(s string) string {
+	var sb strings.Builder
+	sb.WriteByte('"')
+	for i := 0; i < len(s); i++ {
+		if s[i] == '"' || s[i] == '\\' {
+			sb.WriteByte('\\')
+		}
+		sb.WriteByte(s[i])
+	}
+	sb.WriteByte('"')
+	return sb.String()
+}
+
+func valueText(v *Value) string {
+	if v.Quoted {
+		return QuoteString(v.Text)
+	}
+	return v.Text
+}
+
+func writeStmt(sb *strings.Builder, s *Stmt, indent int) {
+	tabs := strings.Repeat("\t", indent)
+	sb.WriteString(tabs)
+	inline := Compact(s.Items)
+	if !hasNestedBlocks(s.Items) && len(inline)+indent*8 <= maxInline+8 {
+		sb.WriteString(inline)
+		sb.WriteString(";\n")
+		return
+	}
+	needSpace := false
+	for _, it := range s.Items {
+		switch {
+		case it.Bang:
+			if needSpace {
+				sb.WriteByte(' ')
+			}
+			sb.WriteByte('!')
+			needSpace = false
+		case it.Value != nil:
+			if needSpace {
+				sb.WriteByte(' ')
+			}
+			sb.WriteString(valueText(it.Value))
+			needSpace = true
+		case it.Block != nil:
+			if needSpace {
+				sb.WriteByte(' ')
+			}
+			blockInline := Compact([]Item{it})
+			if !blockHasBlocks(it.Block) && len(blockInline) <= 40 {
+				sb.WriteString(blockInline)
+			} else if len(it.Block.Stmts) == 0 {
+				sb.WriteString("{ }")
+			} else {
+				sb.WriteString("{\n")
+				for _, inner := range it.Block.Stmts {
+					writeStmt(sb, inner, indent+1)
+				}
+				sb.WriteString(tabs)
+				sb.WriteString("}")
+			}
+			needSpace = true
+		}
+	}
+	sb.WriteString(";\n")
+}
+
+func hasNestedBlocks(items []Item) bool {
+	for _, it := range items {
+		if it.Block != nil && blockHasBlocks(it.Block) {
+			return true
+		}
+	}
+	return false
+}
+
+func blockHasBlocks(b *Block) bool {
+	for _, s := range b.Stmts {
+		for _, it := range s.Items {
+			if it.Block != nil {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func writeItemsInline(sb *strings.Builder, items []Item) {
+	needSpace := false
+	for _, it := range items {
+		switch {
+		case it.Bang:
+			if needSpace {
+				sb.WriteByte(' ')
+			}
+			sb.WriteByte('!')
+			needSpace = false
+		case it.Value != nil:
+			if needSpace {
+				sb.WriteByte(' ')
+			}
+			sb.WriteString(valueText(it.Value))
+			needSpace = true
+		case it.Block != nil:
+			if needSpace {
+				sb.WriteByte(' ')
+			}
+			if len(it.Block.Stmts) == 0 {
+				sb.WriteString("{ }")
+			} else {
+				sb.WriteString("{ ")
+				for _, s := range it.Block.Stmts {
+					writeItemsInline(sb, s.Items)
+					sb.WriteString("; ")
+				}
+				sb.WriteString("}")
+			}
+			needSpace = true
+		}
+	}
+}