uupdate thread:

func (up RpmOstreeUpdater) Check() (bool, error) {
    if up.Config.DryRun {
        return true, nil
    }

    // This function may or may not be accurate, rpm-ostree updgrade --check has issues... https://github.com/coreos/rpm-ostree/issues/1579
    // Not worried because we will end up removing rpm-ostree from the equation soon
    cmd := exec.Command(up.BinaryPath, "upgrade", "--check")
    out, err := cmd.CombinedOutput()
    if err != nil {
        if cmd.ProcessState.ExitCode() == 77 {
            // No update, exit code 77
            return true, nil
        }
        return true, err
    }

    updateNecessary := strings.Contains(string(out), "AvailableUpdate")
    up.Config.Logger.Debug("Executed update check", slog.String("output", string(out)), slog.Bool("update", updateNecessary))
    return updateNecessary, nil
}

func (up RpmOstreeUpdater) Check() (bool, error) {
    if up.Config.DryRun {
        return true, nil
    }

    // This function may or may not be accurate, rpm-ostree updgrade --check has issues... https://github.com/coreos/rpm-ostree/issues/1579
    // Not worried because we will end up removing rpm-ostree from the equation soon
    cmd := exec.Command(up.BinaryPath, "upgrade", "--check")
    out, err := cmd.CombinedOutput()
    if err != nil {
        if cmd.ProcessState.ExitCode() == 77 {
            // No update, exit code 77
            return true, nil
        }
        return true, err
    }

    updateNecessary := strings.Contains(string(out), "AvailableUpdate")
    up.Config.Logger.Debug("Executed update check", slog.String("output", string(out)), slog.Bool("update", updateNecessary))
    return updateNecessary, nil
}

package main

import (
    "bufio"
    "fmt"
    "log"
    "os"
    "os/exec"
)

func main() {
    log.SetFlags(0)
    // Ignore the error here lol
    r, w, err := os.Pipe()
    if err != nil {
        log.Fatalf("Error creating pipe: %v", err)
    }

    defer r.Close()

    cmd := exec.Command("sudo", "/usr/bin/bootc", "upgrade", fmt.Sprintf("--progress-fd=%d", w.Fd))
    log.Printf("File descriptor: %d", w.Fd)
    cmd.ExtraFiles = []*os.File{w}

    // CLOSE THE FD BEFORE BAD
    err = cmd.Start()
    if err != nil {
        log.Fatalf("Failed to start cmd: %v", err)
    }

    w.Close()
    go func() {
        s := bufio.NewScanner(r)
        for s.Scan() {
            log.Println(s.Text())
        }
        err := s.Err()
        if err != nil {
            log.Fatalf("Error reading from pipe: %v", err)
        }
    }()

    err = cmd.Wait()

    if err != nil {
        log.Println(cmd.Stdout)
        log.Fatalf("Command errored: %v", err)
    }
}

package main

import (
    "bufio"
    "fmt"
    "log"
    "os"
    "os/exec"
)

func main() {
    log.SetFlags(0)
    // Ignore the error here lol
    r, w, err := os.Pipe()
    if err != nil {
        log.Fatalf("Error creating pipe: %v", err)
    }

    defer r.Close()

    cmd := exec.Command("sudo", "/usr/bin/bootc", "upgrade", fmt.Sprintf("--progress-fd=%d", w.Fd))
    log.Printf("File descriptor: %d", w.Fd)
    cmd.ExtraFiles = []*os.File{w}

    // CLOSE THE FD BEFORE BAD
    err = cmd.Start()
    if err != nil {
        log.Fatalf("Failed to start cmd: %v", err)
    }

    w.Close()
    go func() {
        s := bufio.NewScanner(r)
        for s.Scan() {
            log.Println(s.Text())
        }
        err := s.Err()
        if err != nil {
            log.Fatalf("Error reading from pipe: %v", err)
        }
    }()

    err = cmd.Wait()

    if err != nil {
        log.Println(cmd.Stdout)
        log.Fatalf("Command errored: %v", err)
    }
}

    go func() {
        s := bufio.NewScanner(r)
        for s.Scan() {
            log.Println(s.Text())
        }
        err := s.Err()
        if err != nil {
            log.Fatalf("Error reading from pipe: %v", err)
        }
    }()

    go func() {
        s := bufio.NewScanner(r)
        for s.Scan() {
            log.Println(s.Text())
        }
        err := s.Err()
        if err != nil {
            log.Fatalf("Error reading from pipe: %v", err)
        }
    }()

package main

import (
    "bufio"
    "fmt"
    "log"
    "os"
    "os/exec"
)

func main() {
    log.SetFlags(0)
    r, w, err := os.Pipe()
    if err != nil {
        log.Fatalf("Error creating pipe: %v", err)
    }

    defer r.Close()
    defer w.Close()

    cmd := exec.Command("sudo", "/usr/bin/bootc", "upgrade", fmt.Sprintf("--progress-fd=%d", w.Fd))
    log.Printf("File descriptor: %d", w.Fd)
    cmd.ExtraFiles = []*os.File{w}

    err = cmd.Start()
    if err != nil {
        log.Fatalf("Failed to start cmd: %v", err)
    }
    scanner := bufio.NewScanner(r)
    scanner.Split(bufio.ScanLines)
    for scanner.Scan() {
        log.Printf("%s", scanner.Text())
    }
    if err := cmd.Wait(); err != nil {
        log.Printf("Error waiting for command: %v", err)
    }
    err = cmd.Wait()

    if err != nil {
        log.Println(cmd.Stdout)
        log.Fatalf("Command errored: %v", err)
    }
}

package main

import (
    "bufio"
    "fmt"
    "log"
    "os"
    "os/exec"
)

func main() {
    log.SetFlags(0)
    r, w, err := os.Pipe()
    if err != nil {
        log.Fatalf("Error creating pipe: %v", err)
    }

    defer r.Close()
    defer w.Close()

    cmd := exec.Command("sudo", "/usr/bin/bootc", "upgrade", fmt.Sprintf("--progress-fd=%d", w.Fd))
    log.Printf("File descriptor: %d", w.Fd)
    cmd.ExtraFiles = []*os.File{w}

    err = cmd.Start()
    if err != nil {
        log.Fatalf("Failed to start cmd: %v", err)
    }
    scanner := bufio.NewScanner(r)
    scanner.Split(bufio.ScanLines)
    for scanner.Scan() {
        log.Printf("%s", scanner.Text())
    }
    if err := cmd.Wait(); err != nil {
        log.Printf("Error waiting for command: %v", err)
    }
    err = cmd.Wait()

    if err != nil {
        log.Println(cmd.Stdout)
        log.Fatalf("Command errored: %v", err)
    }
}

package main

import (
    "bufio"
    "fmt"
    "log"
    "os"
    "os/exec"
)

func main() {
    log.SetFlags(0)
    r, w, err := os.Pipe()
    if err != nil {
        log.Fatalf("Error creating pipe: %v", err)
    }

    defer r.Close()
    defer w.Close()

    cmd := exec.Command("/usr/bin/bootc", "upgrade", fmt.Sprintf("--progress-fd=%d", w.Fd))
    log.Printf("File descriptor: %d", w.Fd)
    cmd.ExtraFiles = []*os.File{w}

    err = cmd.Start()
    if err != nil {
        log.Fatalf("Failed to start cmd: %v", err)
    }
    scanner := bufio.NewScanner(r)
    scanner.Split(bufio.ScanLines)
    for scanner.Scan() {
        log.Printf("%s", scanner.Text())
    }
    if err := cmd.Wait(); err != nil {
        log.Printf("Error waiting for command: %v", err)
    }

    if err != nil {
        log.Println(cmd.Stdout)
        log.Fatalf("Command errored: %v", err)
    }
}

package main

import (
    "bufio"
    "fmt"
    "log"
    "os"
    "os/exec"
)

func main() {
    log.SetFlags(0)
    r, w, err := os.Pipe()
    if err != nil {
        log.Fatalf("Error creating pipe: %v", err)
    }

    defer r.Close()
    defer w.Close()

    cmd := exec.Command("/usr/bin/bootc", "upgrade", fmt.Sprintf("--progress-fd=%d", w.Fd))
    log.Printf("File descriptor: %d", w.Fd)
    cmd.ExtraFiles = []*os.File{w}

    err = cmd.Start()
    if err != nil {
        log.Fatalf("Failed to start cmd: %v", err)
    }
    scanner := bufio.NewScanner(r)
    scanner.Split(bufio.ScanLines)
    for scanner.Scan() {
        log.Printf("%s", scanner.Text())
    }
    if err := cmd.Wait(); err != nil {
        log.Printf("Error waiting for command: %v", err)
    }

    if err != nil {
        log.Println(cmd.Stdout)
        log.Fatalf("Command errored: %v", err)
    }
}