/api/recovery/status

# Check recovery status
curl -X GET "http://localhost:8080/api/recovery/status"

# Check if ready (recovering=false and scan_complete=true)
curl -s "http://localhost:8080/api/recovery/status" | jq '{ready: (.scan_complete and (.recovering | not)), message: .message}'

# Poll until ready (bash loop)
while true; do
    STATUS=$(curl -s "http://localhost:8080/api/recovery/status")
    RECOVERING=$(echo "$STATUS" | jq -r '.recovering')
    SCAN_DONE=$(echo "$STATUS" | jq -r '.scan_complete')
    MESSAGE=$(echo "$STATUS" | jq -r '.message')
    echo "$MESSAGE"
    if [ "$RECOVERING" = "false" ] && [ "$SCAN_DONE" = "true" ]; then
        echo "Server is ready."
        break
    fi
    sleep 2
done

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
    "time"
)

const ApiHost = "http://localhost:8080"

type RecoveryTask struct {
    TaskID    string `json:"task_id"`
    Wallet    string `json:"wallet"`
    CoinCount int    `json:"coin_count"`
    Status    string `json:"status"`
    Phase     string `json:"phase"`
    Message   string `json:"message"`
}

type RecoveryResponse struct {
    Command      string         `json:"command"`
    Success      bool           `json:"success"`
    Recovering   bool           `json:"recovering"`
    ScanComplete bool           `json:"scan_complete"`
    Message      string         `json:"message"`
    TotalCoins   int            `json:"total_coins"`
    OrphanCoins  int            `json:"orphan_coins"`
    TaskCount    int            `json:"task_count"`
    Tasks        []RecoveryTask `json:"tasks"`
}

func getRecoveryStatus() (*RecoveryResponse, error) {
    resp, err := http.Get(fmt.Sprintf("%s/api/recovery/status", ApiHost))
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }

    var result RecoveryResponse
    if err := json.Unmarshal(body, &result); err != nil {
        return nil, err
    }

    return &result, nil
}

// WaitForReady polls recovery status until the server is ready.
func WaitForReady() error {
    for {
        status, err := getRecoveryStatus()
        if err != nil {
            return fmt.Errorf("recovery check failed: %w", err)
        }

        fmt.Printf("Recovery: %s\n", status.Message)

        if status.ScanComplete && !status.Recovering {
            fmt.Println("Server is ready.")
            return nil
        }

        for _, task := range status.Tasks {
            fmt.Printf("  %s: %d coins [%s] %s\n",
                task.Wallet, task.CoinCount, task.Status, task.Phase)
        }

        time.Sleep(2 * time.Second)
    }
}

func main() {
    if err := WaitForReady(); err != nil {
        panic(err)
    }

    fmt.Println("Application ready - proceeding with normal operations.")
}