1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
|
package config
import (
"fmt"
"os"
"strings"
"time"
"gopkg.in/yaml.v3"
)
// Config represents the root configuration structure
type Config struct {
Site SiteConfig `yaml:"site"`
Server ServerConfig `yaml:"server"`
Storage StorageConfig `yaml:"storage"`
Display DisplayConfig `yaml:"display"`
Groups []GroupConfig `yaml:"groups"`
Incidents []IncidentConfig `yaml:"incidents"`
}
// DisplayConfig contains display/UI settings
type DisplayConfig struct {
// TickMode controls how history is aggregated: ping, minute, hour, day
TickMode string `yaml:"tick_mode"`
// TickCount is the number of ticks/bars to display in the history
TickCount int `yaml:"tick_count"`
// PingFixedSlots: when true and tick_mode=ping, shows fixed slots with empty bars
// when false, bars grow dynamically as pings come in
PingFixedSlots bool `yaml:"ping_fixed_slots"`
// Timezone for display (e.g., "UTC", "America/New_York", "Local")
Timezone string `yaml:"timezone"`
// Scale adjusts the overall UI scale (default: 1.0, range: 0.5-2.0)
Scale float64 `yaml:"scale"`
}
// SiteConfig contains site metadata
type SiteConfig struct {
Name string `yaml:"name"`
Description string `yaml:"description"`
Logo string `yaml:"logo"`
Favicon string `yaml:"favicon"`
ThemeURL string `yaml:"theme_url"` // URL to OpenCode-compatible theme JSON
CustomHead string `yaml:"custom_head"` // Custom HTML to inject into <head> (e.g., analytics)
}
// ServerConfig contains HTTP server settings
type ServerConfig struct {
Host string `yaml:"host"`
Port int `yaml:"port"`
}
// StorageConfig contains database settings
type StorageConfig struct {
Path string `yaml:"path"`
HistoryDays int `yaml:"history_days"`
}
// GroupConfig represents a group of monitors
type GroupConfig struct {
Name string `yaml:"name"`
Monitors []MonitorConfig `yaml:"monitors"`
DefaultCollapsed *bool `yaml:"default_collapsed"` // nil = false (expanded by default)
ShowGroupUptime *bool `yaml:"show_group_uptime"` // nil = true (show by default)
// Group-level defaults that apply to all monitors in the group (can be overridden per monitor)
Defaults *MonitorDefaults `yaml:"defaults,omitempty"`
}
// MonitorDefaults contains default values that can be set at group level
type MonitorDefaults struct {
Interval *Duration `yaml:"interval,omitempty"`
Timeout *Duration `yaml:"timeout,omitempty"`
Retries *int `yaml:"retries,omitempty"`
VerifySSL *bool `yaml:"verify_ssl,omitempty"`
DisablePingTooltips *bool `yaml:"disable_ping_tooltips,omitempty"`
}
// MonitorConfig represents a single monitor
type MonitorConfig struct {
Name string `yaml:"name"`
Type string `yaml:"type"` // http, https, tcp, gemini
Target string `yaml:"target"`
Link string `yaml:"link,omitempty"` // Custom URL for clicking the monitor name (e.g., docs page)
Interval Duration `yaml:"interval"`
Timeout Duration `yaml:"timeout"`
Retries int `yaml:"retries,omitempty"` // Number of retry attempts before marking as down
ResetOnNextCheck bool `yaml:"reset_on_next_check,omitempty"` // Wipe monitor data on next check and flip to false
ExpectedStatus int `yaml:"expected_status,omitempty"`
ExpectedContent string `yaml:"expected_content,omitempty"` // Expected text in response body
VerifySSL *bool `yaml:"verify_ssl,omitempty"`
HideSSLDays bool `yaml:"hide_ssl_days,omitempty"` // Hide SSL days left from display
HidePing bool `yaml:"hide_ping,omitempty"` // Hide response time from display
RoundResponseTime bool `yaml:"round_response_time,omitempty"` // Round response time to nearest second
RoundUptime bool `yaml:"round_uptime,omitempty"` // Round uptime percentage (e.g., 99.99% → 100%)
DisablePingTooltips bool `yaml:"disable_ping_tooltips,omitempty"` // Disable hover tooltips on ping history bars
Method string `yaml:"method,omitempty"`
UserAgent string `yaml:"user_agent,omitempty"` // Custom User-Agent header (default: "Kaze-Monitor/1.0")
Headers map[string]string `yaml:"headers,omitempty"`
Body string `yaml:"body,omitempty"`
// ICMP specific fields
PingCount int `yaml:"ping_count,omitempty"` // Number of ICMP packets to send (default: 4)
// DNS specific fields
DNSServer string `yaml:"dns_server,omitempty"` // DNS server to query (default: system resolver)
ExpectedIPs []string `yaml:"expected_ips,omitempty"` // Expected IP addresses for DNS resolution
ExpectedCNAME string `yaml:"expected_cname,omitempty"` // Expected CNAME record
RecordType string `yaml:"record_type,omitempty"` // DNS record type (A, AAAA, CNAME, MX, TXT, etc.)
// GraphQL specific fields
GraphQLQuery string `yaml:"graphql_query,omitempty"` // GraphQL query to execute
GraphQLVariables map[string]string `yaml:"graphql_variables,omitempty"` // GraphQL query variables
// Database specific fields
DBType string `yaml:"db_type,omitempty"` // Database type: postgres, mysql, redis, memcached, mongodb
}
// IncidentConfig represents an incident or maintenance
type IncidentConfig struct {
Title string `yaml:"title"`
Status string `yaml:"status"` // scheduled, investigating, identified, monitoring, resolved
Message string `yaml:"message"`
ScheduledStart *time.Time `yaml:"scheduled_start,omitempty"`
ScheduledEnd *time.Time `yaml:"scheduled_end,omitempty"`
CreatedAt *time.Time `yaml:"created_at,omitempty"`
ResolvedAt *time.Time `yaml:"resolved_at,omitempty"`
AffectedMonitors []string `yaml:"affected_monitors,omitempty"`
Updates []IncidentUpdate `yaml:"updates,omitempty"`
}
// IncidentUpdate represents an update to an incident
type IncidentUpdate struct {
Time time.Time `yaml:"time"`
Status string `yaml:"status"`
Message string `yaml:"message"`
}
// Duration is a wrapper around time.Duration for YAML parsing
type Duration struct {
time.Duration
}
// UnmarshalYAML implements yaml.Unmarshaler for Duration
func (d *Duration) UnmarshalYAML(value *yaml.Node) error {
var s string
if err := value.Decode(&s); err != nil {
return err
}
duration, err := time.ParseDuration(s)
if err != nil {
return fmt.Errorf("invalid duration %q: %w", s, err)
}
d.Duration = duration
return nil
}
// MarshalYAML implements yaml.Marshaler for Duration
func (d Duration) MarshalYAML() (interface{}, error) {
return d.Duration.String(), nil
}
// Load reads and parses a configuration file
func Load(path string) (*Config, error) {
data, err := os.ReadFile(path)
if err != nil {
return nil, fmt.Errorf("failed to read config file: %w", err)
}
var cfg Config
if err := yaml.Unmarshal(data, &cfg); err != nil {
return nil, fmt.Errorf("failed to parse config file: %w", err)
}
// Apply defaults
cfg.applyDefaults()
// Validate configuration
if err := cfg.validate(); err != nil {
return nil, fmt.Errorf("invalid configuration: %w", err)
}
return &cfg, nil
}
// applyDefaults sets default values for missing configuration
func (c *Config) applyDefaults() {
if c.Site.Name == "" {
c.Site.Name = "Kaze Status"
}
if c.Site.Description == "" {
c.Site.Description = "Service Status Page"
}
if c.Server.Host == "" {
c.Server.Host = "0.0.0.0"
}
if c.Server.Port == 0 {
c.Server.Port = 8080
}
if c.Storage.Path == "" {
c.Storage.Path = "./kaze.db"
}
if c.Storage.HistoryDays == 0 {
c.Storage.HistoryDays = 90
}
// Apply display defaults
if c.Display.TickMode == "" {
c.Display.TickMode = "hour"
}
if c.Display.TickCount == 0 {
c.Display.TickCount = 45
}
if c.Display.Timezone == "" {
c.Display.Timezone = "Local"
}
if c.Display.Scale == 0 {
c.Display.Scale = 1.0
}
// Clamp scale to reasonable range
if c.Display.Scale < 0.5 {
c.Display.Scale = 0.5
} else if c.Display.Scale > 2.0 {
c.Display.Scale = 2.0
}
// Apply group defaults
for i := range c.Groups {
grp := &c.Groups[i]
if grp.DefaultCollapsed == nil {
defaultCollapsed := false
grp.DefaultCollapsed = &defaultCollapsed
}
if grp.ShowGroupUptime == nil {
defaultShow := true
grp.ShowGroupUptime = &defaultShow
}
for j := range c.Groups[i].Monitors {
m := &c.Groups[i].Monitors[j]
// Apply group-level defaults first, then monitor-level overrides
if m.Interval.Duration == 0 {
if grp.Defaults != nil && grp.Defaults.Interval != nil {
m.Interval = *grp.Defaults.Interval
} else {
m.Interval.Duration = 30 * time.Second
}
}
if m.Timeout.Duration == 0 {
if grp.Defaults != nil && grp.Defaults.Timeout != nil {
m.Timeout = *grp.Defaults.Timeout
} else {
m.Timeout.Duration = 10 * time.Second
}
}
// Apply group-level retries default
if m.Retries == 0 && grp.Defaults != nil && grp.Defaults.Retries != nil {
m.Retries = *grp.Defaults.Retries
}
// Retries default to 0 (no retries) if not specified
if m.Retries < 0 {
m.Retries = 0
}
if m.Type == "http" || m.Type == "https" {
if m.ExpectedStatus == 0 {
m.ExpectedStatus = 200
}
if m.Method == "" {
m.Method = "GET"
}
if m.VerifySSL == nil {
// Apply group default if available
if grp.Defaults != nil && grp.Defaults.VerifySSL != nil {
m.VerifySSL = grp.Defaults.VerifySSL
} else {
defaultVerify := true
m.VerifySSL = &defaultVerify
}
}
}
if m.Type == "gemini" {
if m.VerifySSL == nil {
// Apply group default if available
if grp.Defaults != nil && grp.Defaults.VerifySSL != nil {
m.VerifySSL = grp.Defaults.VerifySSL
} else {
defaultVerify := true
m.VerifySSL = &defaultVerify
}
}
}
// Apply group-level disable_ping_tooltips default
if !m.DisablePingTooltips && grp.Defaults != nil && grp.Defaults.DisablePingTooltips != nil && *grp.Defaults.DisablePingTooltips {
m.DisablePingTooltips = true
}
}
}
}
// validate checks the configuration for errors
func (c *Config) validate() error {
if len(c.Groups) == 0 {
return fmt.Errorf("at least one group with monitors is required")
}
for _, group := range c.Groups {
if group.Name == "" {
return fmt.Errorf("group name cannot be empty")
}
if len(group.Monitors) == 0 {
return fmt.Errorf("group %q must have at least one monitor", group.Name)
}
for _, monitor := range group.Monitors {
if monitor.Name == "" {
return fmt.Errorf("monitor name cannot be empty in group %q", group.Name)
}
if monitor.Target == "" {
return fmt.Errorf("monitor %q must have a target", monitor.Name)
}
switch monitor.Type {
case "http", "https", "tcp", "gemini", "icmp", "dns", "graphql", "database", "db":
// Valid types
default:
return fmt.Errorf("monitor %q has invalid type %q (must be http, https, tcp, gemini, icmp, dns, graphql, or database)", monitor.Name, monitor.Type)
}
// Type-specific validation
if monitor.Type == "graphql" && monitor.GraphQLQuery == "" {
return fmt.Errorf("monitor %q is type 'graphql' but missing required 'graphql_query' field", monitor.Name)
}
if (monitor.Type == "database" || monitor.Type == "db") && monitor.DBType == "" {
return fmt.Errorf("monitor %q is type 'database' but missing required 'db_type' field", monitor.Name)
}
}
}
// Validate incidents
for _, incident := range c.Incidents {
if incident.Title == "" {
return fmt.Errorf("incident title cannot be empty")
}
switch incident.Status {
case "scheduled", "investigating", "identified", "monitoring", "resolved":
// Valid statuses
default:
return fmt.Errorf("incident %q has invalid status %q", incident.Title, incident.Status)
}
}
// Validate display config
switch c.Display.TickMode {
case "ping", "minute", "hour", "day":
// Valid modes
default:
return fmt.Errorf("invalid tick_mode %q (must be ping, minute, hour, or day)", c.Display.TickMode)
}
if c.Display.TickCount < 1 || c.Display.TickCount > 200 {
return fmt.Errorf("tick_count must be between 1 and 200, got %d", c.Display.TickCount)
}
return nil
}
// GetAllMonitors returns all monitors from all groups with their group names
func (c *Config) GetAllMonitors() []MonitorWithGroup {
var monitors []MonitorWithGroup
for _, group := range c.Groups {
for _, monitor := range group.Monitors {
monitors = append(monitors, MonitorWithGroup{
GroupName: group.Name,
Monitor: monitor,
})
}
}
return monitors
}
// MonitorWithGroup pairs a monitor with its group name
type MonitorWithGroup struct {
GroupName string
Monitor MonitorConfig
}
// UpdateResetFlag updates the reset_on_next_check flag for a specific monitor in the config file
// Uses a line-based approach to preserve original formatting and omitted fields
func UpdateResetFlag(configPath string, monitorName string, value bool) error {
// Read the config file
data, err := os.ReadFile(configPath)
if err != nil {
return fmt.Errorf("failed to read config file: %w", err)
}
lines := strings.Split(string(data), "\n")
inMonitor := false
monitorIndent := ""
foundMonitor := false
for i := 0; i < len(lines); i++ {
line := lines[i]
trimmed := strings.TrimSpace(line)
// Check if this is the start of our target monitor
if strings.HasPrefix(trimmed, "- name:") || strings.HasPrefix(trimmed, "name:") {
// Extract monitor name from line
namePart := strings.TrimPrefix(trimmed, "- name:")
namePart = strings.TrimPrefix(namePart, "name:")
namePart = strings.TrimSpace(namePart)
namePart = strings.Trim(namePart, "\"'")
if namePart == monitorName {
inMonitor = true
foundMonitor = true
// Calculate the indentation level
monitorIndent = line[:len(line)-len(strings.TrimLeft(line, " \t"))]
continue
}
}
// If we're in the target monitor, look for reset_on_next_check or end of monitor
if inMonitor {
// Check if we've left the monitor section (new monitor or less indented line)
if strings.HasPrefix(trimmed, "- name:") || strings.HasPrefix(trimmed, "name:") {
// We've reached another monitor without finding reset_on_next_check
// Insert the line before this one if we're setting to false
if !value {
// Only add if setting to false (after a reset)
insertLine := monitorIndent + " reset_on_next_check: false"
lines = append(lines[:i], append([]string{insertLine}, lines[i:]...)...)
}
break
}
// Check if this line is reset_on_next_check
if strings.Contains(trimmed, "reset_on_next_check:") {
// Update the value
if !value {
// Set to false after reset
lines[i] = monitorIndent + " reset_on_next_check: false"
} else {
// Keep as true (should already be true, but update to be sure)
lines[i] = monitorIndent + " reset_on_next_check: true"
}
break
}
}
}
if !foundMonitor {
return fmt.Errorf("monitor %q not found in config", monitorName)
}
// Write back to file
newData := []byte(strings.Join(lines, "\n"))
if err := os.WriteFile(configPath, newData, 0644); err != nil {
return fmt.Errorf("failed to write config file: %w", err)
}
return nil
}
|