Composefs-Native Backend Support Implementation Plan#

// ComposeFsBackend passes --composefs-backend to bootc install to-filesystem.
// Required for composefs-native images (e.g. ghcr.io/bootcrew/*).
// Independent of UnifiedStorage — these are different bootc features.
ComposeFsBackend bool `json:"composeFsBackend"`

type Recipe struct {
	Disk string `json:"disk"`
	Filesystem string `json:"filesystem"`
	BtrfsSubvolumes bool `json:"btrfsSubvolumes"`
	Encryption Encryption `json:"encryption"`
	Image string `json:"image"`
	TargetImgref string `json:"targetImgref"`
	SelinuxDisabled bool `json:"selinuxDisabled"`
	UnifiedStorage bool `json:"unifiedStorage"`
	ComposeFsBackend bool `json:"composeFsBackend"`
	Hostname string `json:"hostname"`
	Flatpaks []string `json:"flatpaks"`
}

{
    name: "valid composefs_backend true",
    r: recipe.Recipe{Disk: diskPath, Filesystem: "xfs", Hostname: "h", ComposeFsBackend: true},
},
{
    name: "valid composefs_backend with luks-passphrase",
    r: recipe.Recipe{
        Disk: diskPath, Filesystem: "xfs", Hostname: "h",
        ComposeFsBackend: true,
        Encryption: recipe.Encryption{Type: "luks-passphrase", Passphrase: "secret"},
    },
},
{
    name: "valid composefs_backend with btrfs",
    r: recipe.Recipe{Disk: diskPath, Filesystem: "btrfs", Hostname: "h", ComposeFsBackend: true},
},

cd /var/home/james/dev/bootc-installer/fisherman/fisherman
go test -v -count=1 ./internal/recipe/...

cd /var/home/james/dev/bootc-installer/fisherman/fisherman
git add internal/recipe/recipe.go internal/recipe/recipe_test.go
git commit -m "feat: add ComposeFsBackend field to recipe"

package install_test

import (
	"testing"

	"github.com/tuna-os/fisherman/internal/install"
)

func TestBuildBootcArgs_BaseArgs(t *testing.T) {
	args := install.BuildBootcArgs(install.Options{Target: "/mnt/target"}, "", "/target")
	// Must always include these
	assertContains(t, args, "install")
	assertContains(t, args, "to-filesystem")
	assertContains(t, args, "--skip-finalize")
	assertContains(t, args, "/target")
}

func TestBuildBootcArgs_ComposeFsBackend(t *testing.T) {
	args := install.BuildBootcArgs(install.Options{ComposeFsBackend: true}, "", "/target")
	assertContains(t, args, "--composefs-backend")
}

func TestBuildBootcArgs_NoComposeFsBackend(t *testing.T) {
	args := install.BuildBootcArgs(install.Options{ComposeFsBackend: false}, "", "/target")
	assertAbsent(t, args, "--composefs-backend")
}

func TestBuildBootcArgs_UnifiedStorage(t *testing.T) {
	args := install.BuildBootcArgs(install.Options{UnifiedStorage: true}, "", "/target")
	assertContains(t, args, "--experimental-unified-storage")
}

func TestBuildBootcArgs_NoUnifiedStorage(t *testing.T) {
	args := install.BuildBootcArgs(install.Options{UnifiedStorage: false}, "", "/target")
	assertAbsent(t, args, "--experimental-unified-storage")
}

func TestBuildBootcArgs_SelinuxDisabled(t *testing.T) {
	args := install.BuildBootcArgs(install.Options{SelinuxDisabled: true}, "", "/target")
	assertContains(t, args, "--disable-selinux")
}

func TestBuildBootcArgs_NoSelinux(t *testing.T) {
	args := install.BuildBootcArgs(install.Options{SelinuxDisabled: false}, "", "/target")
	assertAbsent(t, args, "--disable-selinux")
}

func TestBuildBootcArgs_TargetImgref(t *testing.T) {
	args := install.BuildBootcArgs(install.Options{}, "ghcr.io/tuna-os/yellowfin:gnome50", "/target")
	assertContains(t, args, "--target-imgref")
	assertContains(t, args, "ghcr.io/tuna-os/yellowfin:gnome50")
}

func TestBuildBootcArgs_NoTargetImgref(t *testing.T) {
	args := install.BuildBootcArgs(install.Options{}, "", "/target")
	assertAbsent(t, args, "--target-imgref")
}

func TestBuildBootcArgs_AllFlags(t *testing.T) {
	opts := install.Options{
		ComposeFsBackend: true,
		UnifiedStorage: true,
		SelinuxDisabled: true,
	}
	args := install.BuildBootcArgs(opts, "img:tag", "/target")
	assertContains(t, args, "--composefs-backend")
	assertContains(t, args, "--experimental-unified-storage")
	assertContains(t, args, "--disable-selinux")
	assertContains(t, args, "--target-imgref")
}

// assertContains fails the test if s is not present in slice.
func assertContains(t *testing.T, slice []string, s string) {
	t.Helper()
	for _, v := range slice {
		if v == s {
			return
		}
	}
	t.Errorf("expected %q in args %v", s, slice)
}

// assertAbsent fails the test if s is present in slice.
func assertAbsent(t *testing.T, slice []string, s string) {
	t.Helper()
	for _, v := range slice {
		if v == s {
			t.Errorf("unexpected %q in args %v", s, slice)
			return
		}
	}
}

cd /var/home/james/dev/bootc-installer/fisherman/fisherman
go test -v -count=1 ./internal/install/...

// ComposeFsBackend passes --composefs-backend when true.
// Required for images using the composefs-native deployment backend (e.g. ghcr.io/bootcrew/*).
ComposeFsBackend bool

// BuildBootcArgs builds the argument slice for `bootc install to-filesystem`.
// resolvedTargetImgref is the --target-imgref value (empty to omit the flag).
// installTarget is the final positional argument (e.g. "/target" in container mode,
// or opts.Target in direct mode).
func BuildBootcArgs(opts Options, resolvedTargetImgref, installTarget string) []string {
	args := []string{"install", "to-filesystem"}
	if resolvedTargetImgref != "" {
		args = append(args, "--target-imgref", resolvedTargetImgref)
	}
	if opts.SelinuxDisabled {
		args = append(args, "--disable-selinux")
	}
	if opts.UnifiedStorage {
		args = append(args, "--experimental-unified-storage")
	}
	if opts.ComposeFsBackend {
		args = append(args, "--composefs-backend")
	}
	args = append(args, "--skip-finalize")
	args = append(args, installTarget)
	return args
}

bootcArgs := []string{"install", "to-filesystem"}
if targetImgref != "" {
    bootcArgs = append(bootcArgs, "--target-imgref", targetImgref)
}
if opts.SelinuxDisabled {
    bootcArgs = append(bootcArgs, "--disable-selinux")
}
if opts.UnifiedStorage {
    bootcArgs = append(bootcArgs, "--experimental-unified-storage")
}
bootcArgs = append(bootcArgs, "--skip-finalize")
bootcArgs = append(bootcArgs, "/target")

bootcArgs := BuildBootcArgs(opts, targetImgref, "/target")

args := []string{"install", "to-filesystem"}
if opts.TargetImgref != "" {
    args = append(args, "--target-imgref", opts.TargetImgref)
}
if opts.SelinuxDisabled {
    args = append(args, "--disable-selinux")
}
if opts.UnifiedStorage {
    args = append(args, "--experimental-unified-storage")
}
args = append(args, "--skip-finalize")
args = append(args, opts.Target)

args := BuildBootcArgs(opts, opts.TargetImgref, opts.Target)

cd /var/home/james/dev/bootc-installer/fisherman/fisherman
go test -v -count=1 ./internal/install/...

go test -count=1 ./...

git add internal/install/bootc.go internal/install/bootc_test.go
git commit -m "feat: extract BuildBootcArgs, add ComposeFsBackend flag support"

if err := install.BootcInstall(install.Options{
    SourceImgref: r.Image,
    TargetImgref: targetImgref,
    SelinuxDisabled: r.SelinuxDisabled,
    UnifiedStorage: r.UnifiedStorage,
    Target: targetMount,
}); err != nil {

if err := install.BootcInstall(install.Options{
    SourceImgref: r.Image,
    TargetImgref: targetImgref,
    SelinuxDisabled: r.SelinuxDisabled,
    UnifiedStorage: r.UnifiedStorage,
    ComposeFsBackend: r.ComposeFsBackend,
    Target: targetMount,
}); err != nil {

cd /var/home/james/dev/bootc-installer/fisherman/fisherman
go build ./cmd/fisherman/

go test -count=1 ./...

git add cmd/fisherman/main.go
git commit -m "feat: wire ComposeFsBackend through main.go to bootc install"

package post_test

import (
	"os"
	"path/filepath"
	"testing"

	"github.com/tuna-os/fisherman/internal/post"
	"github.com/tuna-os/fisherman/internal/runner"
)

// setupRecorder, recorder, execCall are defined in cleanup_test.go (same package)

// TestWriteHostname_ComposeFsNative verifies that when no /ostree/ directory
// exists under the target (composefs-native deployment), hostname is written
// directly to $TARGET/etc/hostname.
func TestWriteHostname_ComposeFsNative(t *testing.T) {
	// No runner interception needed — this path uses os.WriteFile, not exec.
	target := t.TempDir()
	// Deliberately do NOT create target/ostree/ — that's what makes it composefs-native.

	if err := post.WriteHostname(target, "myhost"); err != nil {
		t.Fatalf("WriteHostname: %v", err)
	}

	hostnameFile := filepath.Join(target, "etc", "hostname")
	data, err := os.ReadFile(hostnameFile)
	if err != nil {
		t.Fatalf("reading hostname file: %v", err)
	}
	if string(data) != "myhost\n" {
		t.Errorf("hostname file content = %q, want %q", string(data), "myhost\n")
	}
}

// TestWriteHostname_ComposeFsNative_CreatesEtcDir verifies that /etc is created
// if it doesn't already exist (composefs-native path).
func TestWriteHostname_ComposeFsNative_CreatesEtcDir(t *testing.T) {
	target := t.TempDir()
	// No ostree dir, no etc dir — both should be created.
	if err := post.WriteHostname(target, "bootcos"); err != nil {
		t.Fatalf("WriteHostname: %v", err)
	}
	if _, err := os.Stat(filepath.Join(target, "etc", "hostname")); err != nil {
		t.Errorf("hostname file not created: %v", err)
	}
}

// TestWriteHostname_OstreeBackend verifies that when /ostree/ exists under the
// target (ostree-based deployment), hostname is written to the path returned by
// deploymentDirFn, not to $TARGET/etc/hostname directly.
func TestWriteHostname_OstreeBackend(t *testing.T) {
	target := t.TempDir()

	// Create the ostree directory to trigger the ostree code path.
	if err := os.MkdirAll(filepath.Join(target, "ostree"), 0o755); err != nil {
		t.Fatal(err)
	}

	// Create a fake deploy dir that deploymentDirFn will return.
	fakeDeployDir := filepath.Join(target, "ostree", "deploy", "default", "deploy", "abc123.0")
	if err := os.MkdirAll(fakeDeployDir, 0o755); err != nil {
		t.Fatal(err)
	}

	// Stub deploymentDirFn to return our fake deploy dir.
	post.DeploymentDirFn = func(sysroot string) (string, error) {
		return fakeDeployDir, nil
	}
	t.Cleanup(func() { post.DeploymentDirFn = post.DefaultDeploymentDir })

	// Also need runner for the ostree exec — but DeploymentDirFn bypasses exec.
	rec := setupRecorder(t)
	_ = rec // no exec calls expected in this path

	if err := post.WriteHostname(target, "bootchost"); err != nil {
		t.Fatalf("WriteHostname: %v", err)
	}

	// Hostname must be in the deploy dir's etc/, NOT in target/etc/.
	hostnameInDeploy := filepath.Join(fakeDeployDir, "etc", "hostname")
	data, err := os.ReadFile(hostnameInDeploy)
	if err != nil {
		t.Fatalf("reading hostname from deploy dir: %v", err)
	}
	if string(data) != "bootchost\n" {
		t.Errorf("hostname = %q, want %q", string(data), "bootchost\n")
	}

	// The direct target/etc/hostname must NOT exist.
	if _, err := os.Stat(filepath.Join(target, "etc", "hostname")); err == nil {
		t.Error("hostname should NOT be written to target/etc/hostname for ostree deployments")
	}
}

cd /var/home/james/dev/bootc-installer/fisherman/fisherman
go test -v -count=1 ./internal/post/...

// DefaultDeploymentDir returns the ostree deployment directory inside sysroot
// using `ostree admin --sysroot=<sysroot> --print-current-dir`.
func DefaultDeploymentDir(sysroot string) (string, error) {
	out, err := exec.Command("ostree", "admin", "--sysroot="+sysroot, "--print-current-dir").Output()
	if err != nil {
		return "", fmt.Errorf("ostree admin --print-current-dir: %w", err)
	}
	path := strings.TrimSpace(string(out))
	if path == "" {
		return "", fmt.Errorf("ostree admin --print-current-dir returned empty path")
	}
	return path, nil
}

// DeploymentDirFn is called by WriteHostname to locate the ostree deployment
// directory. Tests replace this with a stub; restore with post.DefaultDeploymentDir.
var DeploymentDirFn = DefaultDeploymentDir

// isComposeFsNative reports whether the installed system at sysroot uses the
// composefs-native backend. Composefs-native deployments have no /ostree/
// directory; ostree-based deployments always create one.
func isComposeFsNative(sysroot string) bool {
	_, err := os.Stat(filepath.Join(sysroot, "ostree"))
	return os.IsNotExist(err)
}

// WriteHostname writes /etc/hostname into the installed system at target.
// For ostree-based deployments the hostname goes into the ostree deployment
// subtree (found via DeploymentDirFn). For composefs-native deployments it goes
// directly at $TARGET/etc/hostname.
func WriteHostname(target, hostname string) error {
	var etcDir string
	if isComposeFsNative(target) {
		etcDir = filepath.Join(target, "etc")
	} else {
		deployDir, err := DeploymentDirFn(target)
		if err != nil {
			return fmt.Errorf("finding deployment dir: %w", err)
		}
		etcDir = filepath.Join(deployDir, "etc")
	}
	if err := os.MkdirAll(etcDir, 0o755); err != nil {
		return fmt.Errorf("mkdir %s: %w", etcDir, err)
	}
	hostnameFile := filepath.Join(etcDir, "hostname")
	if err := os.WriteFile(hostnameFile, []byte(hostname+"\n"), 0o644); err != nil {
		return fmt.Errorf("write %s: %w", hostnameFile, err)
	}
	fmt.Fprintf(os.Stdout, " wrote hostname %q to %s\n", hostname, hostnameFile)
	return nil
}

cd /var/home/james/dev/bootc-installer/fisherman/fisherman
go test -v -count=1 ./internal/post/...

go test -count=1 ./...

git add internal/post/post.go internal/post/post_test.go
git commit -m "feat: add composefs-native WriteHostname path + DeploymentDirFn"

cd /var/home/james/dev/bootc-installer/fisherman/fisherman
git push

cd /var/home/james/dev/bootc-installer
git add fisherman
git commit -m "chore: update fisherman submodule (composefs-native backend support)"

# Bootcrew CI regression test matrix.
# Used by both bootcrew-fast.yml (PR gate) and bootcrew-nightly.yml (full install).
# Add new images here; both workflows pick them up automatically.
images:
  - name: yellowfin-gnome50
    image: ghcr.io/tuna-os/yellowfin:gnome50
    filesystem: xfs
    composefs_backend: false
    unified_storage: false
    selinux_disabled: true

  - name: ubuntu-bootc
    image: ghcr.io/bootcrew/ubuntu-bootc:latest
    filesystem: xfs
    composefs_backend: true
    unified_storage: false
    selinux_disabled: false

  - name: gnomeos-bootc
    image: ghcr.io/bootcrew/gnomeos-bootc:latest
    filesystem: xfs
    composefs_backend: true
    unified_storage: false
    selinux_disabled: false

  - name: opensuse-bootc
    image: ghcr.io/bootcrew/opensuse-bootc:latest
    filesystem: xfs
    composefs_backend: true
    unified_storage: false
    selinux_disabled: false

mkdir -p /var/home/james/dev/bootc-installer/tests/fake-bins

#!/usr/bin/env bash
# Fake podman for fisherman's fast disk-ops CI test.
# Used when FISHERMAN_FAKE_BINS=1 is set to avoid real container pulls.
#
# Parses the --mount type=bind,src=<TARGET>,... arg to find the bind-mount
# target, then creates the minimal post-bootc directory structure so fisherman's
# post-install steps (WriteHostname, CopyFlatpaks) can proceed.

set -euo pipefail

TARGET=""
COMPOSEFS=false

for arg in "$@"; do
    # Extract src= from --mount type=bind,src=<PATH>,dst=/target,...
    if [[ "$arg" == type=bind,src=* ]]; then
        TARGET=$(printf '%s' "$arg" | sed 's/type=bind,src=\([^,]*\).*/\1/')
    fi
    if [[ "$arg" == "--composefs-backend" ]]; then
        COMPOSEFS=true
    fi
done

# Fall back to env var if mount arg parsing failed (e.g. bootcDirect path).
if [[ -z "$TARGET" ]]; then
    TARGET="${FISHERMAN_TARGET:-}"
fi

if [[ -z "$TARGET" ]]; then
    echo "fake-podman: could not determine target directory" >&2
    exit 1
fi

if [[ "$COMPOSEFS" == "true" ]]; then
    # Composefs-native layout: /etc directly in sysroot.
    mkdir -p "$TARGET/etc"
    mkdir -p "$TARGET/boot/loader/entries"
    printf '[Match]\nName=eth0\n' > "$TARGET/etc/hostname" # placeholder, overwritten by fisherman
else
    # Ostree layout: deployment subtree.
    DEPLOY="$TARGET/ostree/deploy/default/deploy/fake123.0"
    mkdir -p "$DEPLOY/etc"
    mkdir -p "$TARGET/boot/loader/entries"
    mkdir -p "$TARGET/boot/grub2"
    echo "fake grub cfg" > "$TARGET/boot/grub2/grub.cfg"
fi

exit 0

#!/usr/bin/env bash
# Fake ostree for fisherman's fast disk-ops CI test.
# Responds to: ostree admin --sysroot=<PATH> --print-current-dir
# Returns the fake deployment directory created by fake podman.

set -euo pipefail

SYSROOT=""
for arg in "$@"; do
    if [[ "$arg" == --sysroot=* ]]; then
        SYSROOT="${arg#--sysroot=}"
    fi
done

if [[ -n "$SYSROOT" ]]; then
    echo "$SYSROOT/ostree/deploy/default/deploy/fake123.0"
    exit 0
fi

# Pass through any other ostree subcommands (shouldn't happen in tests).
echo "fake-ostree: unhandled args: $*" >&2
exit 1

chmod +x /var/home/james/dev/bootc-installer/tests/fake-bins/podman
chmod +x /var/home/james/dev/bootc-installer/tests/fake-bins/ostree

cd /var/home/james/dev/bootc-installer
git add tests/bootcrew-matrix.yaml tests/fake-bins/
git commit -m "test: add bootcrew image matrix and fake podman/ostree bins"

name: Bootcrew Fast (disk ops)

on:
  pull_request:
    branches: [main]

jobs:
  # Read the image matrix from tests/bootcrew-matrix.yaml and output JSON.
  setup:
    runs-on: ubuntu-latest
    outputs:
      matrix: ${{ steps.read-matrix.outputs.matrix }}
    steps:
      - uses: actions/checkout@v4
        with:
          submodules: recursive

      - name: Parse image matrix
        id: read-matrix
        run: |
          # yq and jq are pre-installed on ubuntu-latest
          MATRIX=$(yq -o json tests/bootcrew-matrix.yaml | jq -c '.images')
          echo "matrix=$MATRIX" >> "$GITHUB_OUTPUT"

  disk-ops:
    name: disk-ops / ${{ matrix.image.name }}
    needs: setup
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        image: ${{ fromJson(needs.setup.outputs.matrix) }}

    defaults:
      run:
        working-directory: fisherman/fisherman

    steps:
      - uses: actions/checkout@v4
        with:
          submodules: recursive

      - uses: actions/setup-go@v5
        with:
          go-version: "1.22"
          cache: true
          cache-dependency-path: fisherman/fisherman/go.sum

      - name: Install disk tools
        run: sudo apt-get install -y xfsprogs btrfs-progs cryptsetup-bin

      - name: Build fisherman
        run: go build -o /tmp/fisherman ./cmd/fisherman/

      - name: Add fake bins to PATH
        working-directory: ${{ github.workspace }}
        run: |
          chmod +x tests/fake-bins/podman tests/fake-bins/ostree
          echo "${{ github.workspace }}/tests/fake-bins" >> "$GITHUB_PATH"

      - name: Create loop device
        id: loopdev
        run: |
          TMPFILE=$(mktemp)
          truncate -s 20G "$TMPFILE"
          LOOPDEV=$(sudo losetup --find --show "$TMPFILE")
          echo "loopdev=$LOOPDEV" >> "$GITHUB_OUTPUT"
          echo "tmpfile=$TMPFILE" >> "$GITHUB_OUTPUT"

      - name: Generate recipe
        run: |
          cat > /tmp/recipe.json <<EOF
          {
            "disk": "${{ steps.loopdev.outputs.loopdev }}",
            "filesystem": "${{ matrix.image.filesystem }}",
            "composeFsBackend": ${{ matrix.image.composefs_backend }},
            "unifiedStorage": ${{ matrix.image.unified_storage }},
            "selinuxDisabled": ${{ matrix.image.selinux_disabled }},
            "encryption": {"type": "none"},
            "image": "${{ matrix.image.image }}",
            "hostname": "ci-test",
            "flatpaks": []
          }
          EOF

      - name: Run fisherman (fake podman/ostree)
        run: |
          sudo FISHERMAN_TARGET=/mnt/fisherman-target /tmp/fisherman /tmp/recipe.json

      - name: Verify partition layout
        run: |
          LOOPDEV="${{ steps.loopdev.outputs.loopdev }}"
          # Expect exactly 3 partitions: EFI-SYSTEM, boot, root
          LABEL_COUNT=$(sudo lsblk -o LABEL "$LOOPDEV" | grep -cE 'EFI-SYSTEM|boot|root' || true)
          if [ "$LABEL_COUNT" -ne 3 ]; then
            echo "ERROR: expected 3 labelled partitions, got $LABEL_COUNT"
            sudo lsblk -o NAME,SIZE,FSTYPE,LABEL "$LOOPDEV"
            exit 1
          fi
          echo "OK: 3 partitions found"

      - name: Cleanup
        if: always()
        run: |
          sudo losetup -d "${{ steps.loopdev.outputs.loopdev }}" || true
          rm -f "${{ steps.loopdev.outputs.tmpfile }}" || true

cd /var/home/james/dev/bootc-installer
git add .github/workflows/bootcrew-fast.yml
git commit -m "ci: add bootcrew-fast PR disk-ops gate"

name: Bootcrew Nightly (full install)

on:
  schedule:
    - cron: '0 2 * * 1' # Weekly, Monday 02:00 UTC
  workflow_dispatch: # Manual trigger

jobs:
  # Read the image matrix from tests/bootcrew-matrix.yaml.
  setup:
    runs-on: ubuntu-latest
    outputs:
      matrix: ${{ steps.read-matrix.outputs.matrix }}
    steps:
      - uses: actions/checkout@v4
        with:
          submodules: recursive

      - name: Parse image matrix
        id: read-matrix
        run: |
          MATRIX=$(yq -o json tests/bootcrew-matrix.yaml | jq -c '.images')
          echo "matrix=$MATRIX" >> "$GITHUB_OUTPUT"

  full-install:
    name: install / ${{ matrix.image.name }}
    needs: setup
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false # All images run even if one fails
      matrix:
        image: ${{ fromJson(needs.setup.outputs.matrix) }}

    defaults:
      run:
        working-directory: fisherman/fisherman

    steps:
      - uses: actions/checkout@v4
        with:
          submodules: recursive

      - uses: actions/setup-go@v5
        with:
          go-version: "1.22"
          cache: true
          cache-dependency-path: fisherman/fisherman/go.sum

      - name: Install tools
        run: |
          sudo apt-get update -qq
          sudo apt-get install -y podman xfsprogs btrfs-progs cryptsetup-bin ostree

      - name: Build fisherman
        run: go build -o /tmp/fisherman ./cmd/fisherman/

      - name: Create loop device (50 GB sparse)
        id: loopdev
        run: |
          TMPFILE=$(mktemp)
          truncate -s 50G "$TMPFILE"
          LOOPDEV=$(sudo losetup --find --show "$TMPFILE")
          echo "loopdev=$LOOPDEV" >> "$GITHUB_OUTPUT"
          echo "tmpfile=$TMPFILE" >> "$GITHUB_OUTPUT"

      - name: Generate recipe
        run: |
          cat > /tmp/recipe.json <<EOF
          {
            "disk": "${{ steps.loopdev.outputs.loopdev }}",
            "filesystem": "${{ matrix.image.filesystem }}",
            "composeFsBackend": ${{ matrix.image.composefs_backend }},
            "unifiedStorage": ${{ matrix.image.unified_storage }},
            "selinuxDisabled": ${{ matrix.image.selinux_disabled }},
            "encryption": {"type": "none"},
            "image": "${{ matrix.image.image }}",
            "hostname": "ci-test",
            "flatpaks": []
          }
          EOF

      - name: Run fisherman
        run: sudo /tmp/fisherman /tmp/recipe.json

      - name: Verify installation
        run: |
          LOOPDEV="${{ steps.loopdev.outputs.loopdev }}"
          COMPOSEFS="${{ matrix.image.composefs_backend }}"

          # 1. Check 3-partition layout.
          LABEL_COUNT=$(sudo lsblk -o LABEL "$LOOPDEV" | grep -cE 'EFI-SYSTEM|boot|root' || true)
          if [ "$LABEL_COUNT" -ne 3 ]; then
            echo "FAIL: expected 3 labelled partitions, got $LABEL_COUNT"
            sudo lsblk -o NAME,SIZE,FSTYPE,LABEL "$LOOPDEV"
            exit 1
          fi

          # 2. Mount /boot partition (p2) and verify boot layout.
          BOOT_PART="${LOOPDEV}p2"
          VERIFY_DIR=$(mktemp -d)
          sudo mount "$BOOT_PART" "$VERIFY_DIR"

          if [ "$COMPOSEFS" = "true" ]; then
            # Composefs-native: verify hostname in sysroot /etc.
            ROOT_PART="${LOOPDEV}p3"
            ROOT_DIR=$(mktemp -d)
            sudo mount "$ROOT_PART" "$ROOT_DIR"
            if [ ! -f "$ROOT_DIR/etc/hostname" ]; then
              echo "FAIL: $ROOT_DIR/etc/hostname not found (composefs-native)"
              sudo umount "$ROOT_DIR" || true
              sudo umount "$VERIFY_DIR" || true
              exit 1
            fi
            echo "OK: composefs-native hostname at $ROOT_DIR/etc/hostname"
            sudo umount "$ROOT_DIR"
          else
            # Ostree: verify boot loader entries exist.
            if ! ls "$VERIFY_DIR/loader/entries/"*.conf 1>/dev/null 2>&1; then
              echo "FAIL: no boot loader entries in $VERIFY_DIR/loader/entries/"
              sudo umount "$VERIFY_DIR" || true
              exit 1
            fi
            echo "OK: ostree boot loader entries found"
          fi

          sudo umount "$VERIFY_DIR"
          echo "PASS: ${{ matrix.image.name }}"

      - name: Cleanup
        if: always()
        run: |
          sudo losetup -d "${{ steps.loopdev.outputs.loopdev }}" || true
          rm -f "${{ steps.loopdev.outputs.tmpfile }}" || true

      - name: Report result to job summary
        if: always()
        run: |
          STATUS="${{ job.status }}"
          IMAGE="${{ matrix.image.name }}"
          echo "| $IMAGE | $STATUS |" >> "$GITHUB_STEP_SUMMARY"

cd /var/home/james/dev/bootc-installer
git add .github/workflows/bootcrew-nightly.yml
git commit -m "ci: add bootcrew-nightly weekly full install workflow"