Heartbeat

import "github.com/operatoronline/weaver/pkg/heartbeat"

service := heartbeat.NewHeartbeatService(
    workspace,      // Workspace directory
    30,            // Interval in minutes
    true,          // Enabled
)

// Set message bus for sending results
service.SetBus(messageBus)

// Set heartbeat handler
handler := func(prompt, channel, chatID string) *tools.ToolResult {
    // Execute agent with heartbeat prompt
    return agentExecute(prompt, channel, chatID)
}
service.SetHandler(handler)

# Heartbeat Check List

This file contains tasks for the heartbeat service to check periodically.

## Examples

- Check for unread messages
- Review upcoming calendar events  
- Check device status (e.g., MaixCam)

## Instructions

- Execute ALL tasks listed below. Do NOT skip any task.
- For simple tasks (e.g., report current time), respond directly.
- For complex tasks that may take time, use the spawn tool to create a subagent.
- The spawn tool is async - subagent results will be sent to the user automatically.
- After spawning a subagent, CONTINUE to process remaining tasks.
- Only respond with HEARTBEAT_OK when ALL tasks are done AND nothing needs attention.

---

Add your heartbeat tasks below this line:

- Check MaixCam status every 30 minutes
- Review email for urgent messages
- Monitor disk space on server

service.Start() // Creates HEARTBEAT.md if missing

err := service.Start()
if err != nil {
    log.Fatalf("Failed to start heartbeat: %v", err)
}

service.Stop()

if service.IsRunning() {
    fmt.Println("Heartbeat service is active")
}

ticker := time.NewTicker(interval)
for {
    select {
    case <-ticker.C:
        executeHeartbeat()
    }
}

func (hs *HeartbeatService) buildPrompt() string {
    content := readFile("HEARTBEAT.md")
    now := time.Now().Format("2006-01-02 15:04:05")
    
    return fmt.Sprintf(`# Heartbeat Check

Current time: %s

You are a proactive AI assistant. This is a scheduled heartbeat check.
Review the following tasks and execute any necessary actions using available skills.
If there is nothing that requires attention, respond ONLY with: HEARTBEAT_OK

%s
`, now, content)
}

handler := func(prompt, channel, chatID string) *tools.ToolResult {
    // Agent processes heartbeat prompt
    // Can call tools, spawn subagents, etc.
    result := agent.Process(prompt)
    return result
}

if result.Silent {
    // No action needed, user not notified
    return
}

if result.Async {
    // Subagent running in background
    // Will notify user when complete
    return
}

if result.ForUser != "" {
    msgBus.PublishOutbound(bus.OutboundMessage{
        Channel: lastChannel,
        ChatID:  lastChatID,
        Content: result.ForUser,
    })
}

lastChannel := state.GetLastChannel()
// Format: "platform:user_id" (e.g., "telegram:123456")

platform, userID := parseLastChannel(lastChannel)

if constants.IsInternalChannel(platform) {
    // Skip cli, system, cron channels
    return
}

## Tasks

1. Check MaixCam camera status
2. Review email inbox for priority items
3. Monitor server disk space (spawn if over 80%)
4. Check for GitHub notifications

## Response Rules

- Process ALL tasks before responding
- Spawn subagents for time-consuming tasks
- Only say HEARTBEAT_OK if nothing needs attention

{
  "tool_calls": [
    {
      "name": "spawn",
      "args": {
        "task": "Check all security cameras and report any offline devices",
        "label": "camera-check"
      }
    }
  ]
}

## Disk Space Check

- Check disk usage with `df -h`
- If any partition is over 85%, spawn cleanup task
- Otherwise, respond HEARTBEAT_OK

// Critical monitoring: 5 minutes
service := heartbeat.NewHeartbeatService(workspace, 5, true)

// Regular checks: 30 minutes (default)
service := heartbeat.NewHeartbeatService(workspace, 30, true)

// Infrequent checks: 120 minutes
service := heartbeat.NewHeartbeatService(workspace, 120, true)

[2026-03-01 10:30:00] [INFO] Heartbeat service started
[2026-03-01 10:30:01] [INFO] Executing heartbeat
[2026-03-01 10:30:01] [INFO] Resolved channel: telegram, chatID: 123456
[2026-03-01 10:30:02] [INFO] Async task started: Spawned subagent 'camera-check'
[2026-03-01 10:31:00] [INFO] Heartbeat completed: HEARTBEAT_OK
[2026-03-01 11:00:00] [ERROR] Heartbeat error: agent timeout

if result.IsError {
    log.Printf("Heartbeat error: %s", result.ForLLM)
    // Error logged, service continues
    // Next heartbeat will retry
}

if !fileExists("HEARTBEAT.md") {
    createDefaultTemplate()
    return "" // Skip this heartbeat
}

if channel == "" || chatID == "" {
    // Result not sent to user
    // Logged for debugging
    return
}

# Heartbeat Tasks

- Check server CPU/memory with `top -b -n 1`
- Monitor docker containers: `docker ps --filter status=exited`
- Check disk space: `df -h`
- Review nginx error logs for 5xx errors
- If critical issues found, spawn alert subagent

# Heartbeat Tasks

- Check calendar for events in next 2 hours
- Review unread emails (priority inbox)
- Check weather forecast for travel planning
- Monitor package delivery status
- Update daily task list

# Heartbeat Tasks

- Check MaixCam status: `curl http://maixcam.local/status`
- Read temperature sensor via I2C (bus 1, addr 0x38)
- Monitor security camera connectivity
- Check smart home hub connection
- Report any offline devices

# Heartbeat Tasks (requires hardware skill)

- Use I2C tool to read AHT20 sensor
- Check temperature is within normal range (0-50°C)
- If abnormal, spawn alert subagent

# Heartbeat Tasks

- Check if any USB devices were hotplugged
- Verify MaixCam is still connected
- Restart camera service if needed