Add boot-once support to generate

Author: GlitchSlayed

README.md

@@ -31,6 +31,7 @@
 - [Installation](#installation)
 - [Configuration](#configuration)
 - [Usage](#usage)
+- [Safer First Boot Workflow](#safer-first-boot-workflow)
 - [Example Workflow](#example-workflow)
 - [⚠️ Backups & Recovery](#%EF%B8%8F-backups--recovery)
 - [⚠️ Warnings & Known Failure Modes](#%EF%B8%8F-warnings--known-failure-modes)
@@ -203,9 +204,12 @@ Output is written atomically (temp file → rename) to prevent partial writes fr
 ```bash
 sudo rustyuki generate
 sudo rustyuki generate --kernel-version "$(uname -r)"
+sudo rustyuki generate --boot-once
 sudo rustyuki generate --dry-run   # preview only
 ```
 
+Use `--boot-once` when you want firmware to trial the new UKI exactly once via `efibootmgr --bootnext` before you make it permanent with `rustyuki confirm`.
+
 #### `install` — Generate and sync the ESP
 
 Identical to `generate`, followed by `bootctl update` to synchronise the ESP.
@@ -215,6 +219,12 @@ sudo rustyuki install
 sudo rustyuki install --kernel-version "6.12.0-200.fc41.x86_64"
 ```
 
+Add `--boot-once` to schedule the new EFI entry as the next boot only via `efibootmgr --bootnext`, leaving your permanent `BootOrder` unchanged until you confirm the trial boot succeeded. The same flag is available on `generate` if you only want to register the UKI entry without running `bootctl update`.
+
+```bash
+sudo rustyuki install --boot-once
+```
+
 #### `reconcile` — Rebuild all installed kernel UKIs and prune stale artifacts
 
 Rebuilds UKIs for every kernel reported by `rpm -q kernel`, prunes stale `linux-*.efi` entries in the output directory, and runs `bootctl update`.
@@ -223,6 +233,14 @@ Rebuilds UKIs for every kernel reported by `rpm -q kernel`, prunes stale `linux-
 sudo rustyuki reconcile
 ```
 
+#### `confirm` — Make a successful trial boot permanent
+
+After booting the one-time UKI successfully, run `confirm` from that booted system. RustyUKI reads `BootCurrent` and moves that entry to the front of `BootOrder`, making the tested UKI your permanent default.
+
+```bash
+sudo rustyuki confirm
+```
+
 #### `install-hook` — Run reconcile automatically on kernel updates
 
 Installs a `kernel-install` plugin so `rustyuki reconcile` runs on kernel add/remove events.
@@ -233,6 +251,23 @@ sudo rustyuki install-hook
 
 ---
 
+## Safer First Boot Workflow
+
+For first-time GRUB replacement or any risky UKI change, prefer a one-time boot trial instead of immediately changing your permanent firmware boot order.
+
+```bash
+# Build the UKI, refresh the ESP, and schedule it for the next boot only
+sudo rustyuki install --boot-once
+
+# Reboot normally; firmware will use BootNext exactly once
+sudo reboot
+
+# If the system came back successfully from the UKI, make it permanent
+sudo rustyuki confirm
+```
+
+This workflow keeps your existing default entry in `BootOrder` as the fallback if the trial boot fails, while still letting you verify the UKI end-to-end before committing to it.
+
 ## Example Workflow
 
 > [!WARNING]
@@ -245,11 +280,14 @@ sudo rustyuki status
 # Step 2 — dry run: see every command that will execute, without running anything
 sudo rustyuki generate --dry-run
 
-# Step 3 — build and install the UKI
-sudo rustyuki install
+# Step 3 — build and schedule a one-time trial boot
+sudo rustyuki install --boot-once
+
+# Step 4 — reboot normally and let BootNext test the UKI once
+sudo reboot
 
-# Step 4 — use your firmware's one-time boot menu (F12 / F2) to select the UKI entry
-#           DO NOT change your default boot order until you confirm it boots correctly
+# Step 5 — after a successful UKI boot, make it permanent
+sudo rustyuki confirm
 ```
 
 After booting into the UKI, verify it was used:

src/app.rs

@@ -2,7 +2,9 @@ use crate::cli::GenerateArgs;
 use crate::cmd::CommandRunner;
 use crate::config::AppConfig;
 use crate::dracut::build_initramfs;
-use crate::efi::{register_boot_entry, validate_esp_mount};
+use crate::efi::{
+    promote_current_boot_entry, register_boot_entry, schedule_one_time_boot, validate_esp_mount,
+};
 use crate::kernel::{
     list_installed_kernels, prune_stale_uki_artifacts, resolve_cmdline, CmdlineSettings,
 };
@@ -75,7 +77,8 @@ pub fn generate(
     runner: &dyn CommandRunner,
     cfg: &AppConfig,
     settings: &GenerateSettings,
-) -> Result<PathBuf> {
+    boot_once: bool,
+) -> Result<(PathBuf, String)> {
     validate_esp_mount(&settings.esp_path)?;
     ensure_required_paths(settings)?;
 
@@ -124,19 +127,29 @@ pub fn generate(
     let built_uki = build_uki(runner, &params)?;
 
     let label = format!("Linux UKI {}", settings.kernel_version);
-    register_boot_entry(runner, &settings.esp_path, &built_uki, &label)?;
+    let boot_num = register_boot_entry(runner, &settings.esp_path, &built_uki, &label)?;
+
+    if boot_once {
+        schedule_one_time_boot(runner, &boot_num)?;
+        info!("Scheduled BootNext for Boot{boot_num}; run `rustyuki confirm` after a successful trial boot to make it permanent");
+    }
 
-    info!("UKI generation finished: {}", built_uki.display());
-    Ok(built_uki)
+    info!(
+        "UKI generation finished: {} (Boot{})",
+        built_uki.display(),
+        boot_num
+    );
+    Ok((built_uki, boot_num))
 }
 
 /// Performs install flow: generate UKI, then execute bootloader maintenance.
 pub fn install(
     runner: &dyn CommandRunner,
     cfg: &AppConfig,
     settings: &GenerateSettings,
+    boot_once: bool,
 ) -> Result<PathBuf> {
-    let path = generate(runner, cfg, settings)?;
+    let (path, _boot_num) = generate(runner, cfg, settings, boot_once)?;
 
     let installed = list_installed_kernels(runner)?;
     let removed = prune_stale_uki_artifacts(&settings.output_dir, &installed)?;
@@ -148,6 +161,7 @@ pub fn install(
     runner
         .run("bootctl", &["update"])
         .context("bootctl update failed")?;
+
     Ok(path)
 }
 
@@ -161,7 +175,7 @@ pub fn reconcile(
     for kernel in &kernels {
         let mut settings = base.clone();
         settings.kernel_version = kernel.clone();
-        let _ = generate(runner, cfg, &settings)?;
+        let _ = generate(runner, cfg, &settings, false)?;
     }
 
     let removed = prune_stale_uki_artifacts(&base.output_dir, &kernels)?;
@@ -176,6 +190,13 @@ pub fn reconcile(
     Ok(())
 }
 
+/// Promotes the currently booted EFI entry to the front of BootOrder.
+pub fn confirm(runner: &dyn CommandRunner) -> Result<String> {
+    let boot_num = promote_current_boot_entry(runner)?;
+    info!("Confirmed Boot{boot_num} as the permanent default boot entry");
+    Ok(boot_num)
+}
+
 /// Reports current status and resolved paths.
 pub fn status(runner: &dyn CommandRunner, cfg: &AppConfig) -> Result<String> {
     let uname = runner
@@ -229,6 +250,7 @@ mod tests {
             cmdline_file: None,
             splash: None,
             os_release: None,
+            boot_once: false,
         };
 
         let resolved = resolve_generate_settings(&cfg, &args, "6.9.0-test");

src/cli.rs

@@ -1,4 +1,4 @@
-use clap::{ArgAction, Parser, Subcommand};
+use clap::{ArgAction, Args, Parser, Subcommand};
 use std::path::PathBuf;
 
 /// RustyUKI command-line interface.
@@ -34,10 +34,12 @@ pub enum Commands {
     InstallHook(InstallHookArgs),
     /// Show current operational status and resolved settings.
     Status,
+    /// Make the currently booted trial UKI the permanent default boot entry.
+    Confirm,
 }
 
 /// Shared override arguments for generation actions.
-#[derive(Debug, Clone, Parser)]
+#[derive(Debug, Clone, Args)]
 pub struct GenerateArgs {
     /// Kernel version override.
     #[arg(long)]
@@ -57,6 +59,9 @@ pub struct GenerateArgs {
     /// Optional os-release path override.
     #[arg(long)]
     pub os_release: Option<PathBuf>,
+    /// Set the new EFI entry as the one-time next boot target instead of immediately changing permanent boot order.
+    #[arg(long)]
+    pub boot_once: bool,
 }
 
 /// Options for installing the kernel-install hook.