From 76699b4de0c25b026283cd25e3c5cb509b2089cb Mon Sep 17 00:00:00 2001 From: Ryan Hughes Date: Sun, 16 Nov 2025 19:27:35 -0500 Subject: [PATCH] Refactor work --- bin/omarchy-iso-make | 34 +++- builder/README.md | 143 +++++++++++++ builder/build-iso.sh | 85 ++++++-- builder/build-omarchy-packages.sh | 203 +++++++++++++++++++ builder/templates/dev-pkgbuild-patch.sh | 39 ++++ configs/airootfs/etc/plymouth/plymouthd.conf | 2 +- configs/airootfs/root/.automated_script.sh | 188 +++++++++-------- configs/airootfs/root/configurator | 177 +++++++++++++--- configs/profiledef.sh | 1 - 9 files changed, 730 insertions(+), 142 deletions(-) create mode 100644 builder/README.md create mode 100755 builder/build-omarchy-packages.sh create mode 100755 builder/templates/dev-pkgbuild-patch.sh mode change 100644 => 100755 configs/airootfs/root/.automated_script.sh diff --git a/bin/omarchy-iso-make b/bin/omarchy-iso-make index 50638ed..b8eb934 100755 --- a/bin/omarchy-iso-make +++ b/bin/omarchy-iso-make @@ -57,9 +57,37 @@ DOCKER_ARGS=( -v "$BUILD_ROOT/configs:/configs:ro" ) -# Use local source of Omarchy from $OMARCHY_PATH instead of git checkout -if [[ -n "${LOCAL_SOURCE-}" ]]; then - DOCKER_ARGS+=(-v "$OMARCHY_PATH:/omarchy:ro") +# Mount omarchy-pkgs if it exists (for local package building) +# Can be overridden with OMARCHY_PKGS_PATH environment variable +if [ -z "$OMARCHY_PKGS_PATH" ]; then + OMARCHY_PKGS_PATH="$BUILD_ROOT/../omarchy-pkgs" +fi + +if [ -d "$OMARCHY_PKGS_PATH" ]; then + echo "Mounting omarchy-pkgs from: $OMARCHY_PKGS_PATH" + OMARCHY_PKGS_PATH=$(realpath "$OMARCHY_PKGS_PATH") + DOCKER_ARGS+=(-v "$OMARCHY_PKGS_PATH:/omarchy-pkgs:ro") +else + echo "Note: omarchy-pkgs not found at $OMARCHY_PKGS_PATH (build will fail)" +fi + +# Mount omarchy-installer for dev builds (optional) +# Can be overridden with OMARCHY_INSTALLER_PATH environment variable +# If not set, will auto-detect ../omarchy-installer for dev builds +if [ -n "$LOCAL_SOURCE" ]; then + if [ -z "$OMARCHY_INSTALLER_PATH" ]; then + OMARCHY_INSTALLER_PATH="$BUILD_ROOT/../omarchy-installer" + fi + + if [ -d "$OMARCHY_INSTALLER_PATH" ]; then + echo "Mounting omarchy-installer from: $OMARCHY_INSTALLER_PATH (dev mode)" + OMARCHY_INSTALLER_PATH=$(realpath "$OMARCHY_INSTALLER_PATH") + DOCKER_ARGS+=(-v "$OMARCHY_INSTALLER_PATH:/omarchy-installer:ro") + DOCKER_ARGS+=(-e "OMARCHY_DEV_BUILD=1") + else + echo "Note: omarchy-installer not found at $OMARCHY_INSTALLER_PATH" + echo " Will use git clone from PKGBUILD" + fi fi # Use local pacman cache if you already have one on host to speed up repeat runs diff --git a/builder/README.md b/builder/README.md new file mode 100644 index 0000000..12ef111 --- /dev/null +++ b/builder/README.md @@ -0,0 +1,143 @@ +# Omarchy ISO Builder + +## Overview + +The ISO build system now integrates local package building for development workflows. + +## Build Scripts + +### build-iso.sh +Main ISO build script that: +1. Sets up Arch Linux build environment +2. Builds omarchy-settings package locally (if omarchy-pkgs mounted) +3. Installs omarchy-settings in the ISO +4. Downloads remaining packages to offline mirror +5. Assembles the final ISO image + +### build-omarchy-packages.sh +Builds omarchy-settings package locally from source: +- Runs inside Docker container +- Builds as `nobody` user (makepkg requirement) +- Outputs package to `/tmp/omarchy-pkg-build/` +- Exports `OMARCHY_SETTINGS_PKG` variable for build-iso.sh + +## Package Integration + +### omarchy-settings +**Installed in ISO** - Provides EVERYTHING needed: +- User skeleton files (`/etc/skel/`) +- System configurations (`/etc/`) +- Plymouth boot theme +- Essential binaries (`omarchy-debug`, `omarchy-upload-log`) +- Install scripts (`/usr/share/omarchy/install/`) +- Default configs and migrations + +**Size**: ~5-10MB +**Purpose**: Complete self-contained package for ISO - no git clone needed! + +### omarchy (future) +**In offline mirror** - Full desktop environment: +- All omarchy-* binaries +- Install scripts and migrations +- Themes and assets +- Heavy dependencies (Hyprland, Waybar, etc.) + +**Installed during**: Post-install phase in chroot + +## Development Workflow + +### Quick Build +```bash +# From omarchy-iso directory (uses default paths) +omarchy-iso-make-dev + +# Or with custom paths +export OMARCHY_PKGS_PATH=/path/to/pkgs +export OMARCHY_INSTALLER_PATH=/path/to/installer +omarchy-iso-make-dev +``` + +This will: +1. Mount omarchy-pkgs into Docker container +2. Mount omarchy-installer (if OMARCHY_INSTALLER_PATH set) +3. Build omarchy-settings from local source +4. Install it in the ISO +5. Create bootable ISO with latest changes + +See [ENV_VARS.md](../ENV_VARS.md) for all configuration options. + +### Without Package Build +If `omarchy-pkgs` directory is not mounted: +- **Build will fail** with helpful error message +- The ISO build now requires omarchy-settings package +- No fallback to git clone (removed for simplicity) +- Set `OMARCHY_PKGS_PATH` to enable builds + +## Directory Structure + +``` +omarchy-iso/ +├── bin/ +│ └── omarchy-iso-make # Main entry point (updated to mount omarchy-pkgs) +├── builder/ +│ ├── build-iso.sh # Main ISO build (updated for package integration) +│ ├── build-omarchy-packages.sh # New: Local package builder +│ └── README.md # This file +├── configs/ +│ ├── profiledef.sh # ISO profile (updated to remove manual file perms) +│ └── ... +└── release/ + └── omarchy-*.iso # Built ISOs +``` + +## How It Works + +1. **omarchy-iso-make** detects `../omarchy-pkgs` directory +2. Mounts it read-only into Docker container at `/omarchy-pkgs` +3. **build-iso.sh** checks for `/omarchy-pkgs` mount (REQUIRED!) +4. Sources **build-omarchy-packages.sh** to build package +5. Package is built with makepkg as `nobody` user +6. Built package added to `packages.x86_64` list +7. Copied to offline mirror +8. mkarchiso installs it during ISO assembly +9. ISO boots with omarchy-settings pre-installed +10. **Everything works from package** - no git clone, no manual copying! + +## Benefits + +### For Development +- ✅ No need to publish packages for testing +- ✅ Instant iteration on configs and binaries +- ✅ Test package integration in real ISO environment +- ✅ Single command builds everything + +### For Production +- ✅ Same workflow works with published packages +- ✅ Fallback to manual copying if needed +- ✅ Reproducible builds +- ✅ Version-locked packages + +## Troubleshooting + +### Package build fails +```bash +# Check that omarchy-pkgs is mounted +docker run --rm -v "$PWD/../omarchy-pkgs:/omarchy-pkgs:ro" archlinux ls -la /omarchy-pkgs +``` + +### Manual file copying used instead of package +- Ensure omarchy-pkgs directory exists at `../omarchy-pkgs` +- Check Docker mount in omarchy-iso-make +- Look for "Mounting omarchy-pkgs" message during build + +### Permission errors +- build-omarchy-packages.sh runs makepkg as `nobody` user +- Temporary sudo access granted for pacman operations +- Cleaned up after build + +## Future Enhancements + +1. Build full `omarchy` package locally +2. Remove git clone of omarchy-installer entirely +3. Use only packages for all file installation +4. Support building other omarchy-* packages diff --git a/builder/build-iso.sh b/builder/build-iso.sh index c1d3bab..00cbdf5 100755 --- a/builder/build-iso.sh +++ b/builder/build-iso.sh @@ -30,21 +30,41 @@ rm -rf "$build_cache_dir/airootfs/etc/xdg/reflector" # Bring in our configs cp -r /configs/* $build_cache_dir/ -# Setup Omarchy itself -if [[ -d /omarchy ]]; then - cp -rp /omarchy "$build_cache_dir/airootfs/root/omarchy" +# Build omarchy-settings package locally +# This package provides EVERYTHING needed for the ISO: +# - User configs (/etc/skel/) +# - System configs (/etc/) +# - Plymouth theme +# - Essential binaries (debug, upload-log) +# - Install scripts (/usr/share/omarchy/install/) +if [ -d "/omarchy-pkgs" ]; then + echo "=========================================" + echo "Building omarchy-settings package locally" + echo "=========================================" + source /builder/build-omarchy-packages.sh + + # Add omarchy packages to ISO + # omarchy-settings provides configs and will be installed in ISO + # omarchy-installer provides install scripts and will be installed in ISO + echo "omarchy-settings" >> "$build_cache_dir/packages.x86_64" + echo "omarchy-installer" >> "$build_cache_dir/packages.x86_64" + + # Copy built packages to offline mirror (for installation on target system) + cp "$OMARCHY_SETTINGS_PKG" "$offline_mirror_dir/" + cp "$OMARCHY_INSTALLER_PKG" "$offline_mirror_dir/" + cp "$OMARCHY_PKG" "$offline_mirror_dir/" + + echo "✓ omarchy-settings will be installed in ISO (configs, binaries)" + echo "✓ omarchy-installer will be installed in ISO (install scripts, helpers)" + echo "✓ All omarchy packages available in offline mirror for installation" + echo "✓ No git clone needed - everything comes from packages!" else - git clone -b $OMARCHY_INSTALLER_REF https://github.com/$OMARCHY_INSTALLER_REPO.git "$build_cache_dir/airootfs/root/omarchy" + echo "ERROR: /omarchy-pkgs not mounted!" + echo "The ISO build now requires omarchy-settings package." + echo "Please set OMARCHY_PKGS_PATH or ensure ../omarchy-pkgs exists." + exit 1 fi -# Make log uploader available in the ISO too -mkdir -p "$build_cache_dir/airootfs/usr/local/bin/" -cp "$build_cache_dir/airootfs/root/omarchy/bin/omarchy-upload-log" "$build_cache_dir/airootfs/usr/local/bin/omarchy-upload-log" - -# Copy the Omarchy Plymouth theme to the ISO -mkdir -p "$build_cache_dir/airootfs/usr/share/plymouth/themes/omarchy" -cp -r "$build_cache_dir/airootfs/root/omarchy/default/plymouth/"* "$build_cache_dir/airootfs/usr/share/plymouth/themes/omarchy/" - # Download and verify Node.js binary for offline installation NODE_DIST_URL="https://nodejs.org/dist/latest" @@ -67,19 +87,41 @@ mkdir -p "$build_cache_dir/airootfs/opt/packages/" cp "/tmp/$NODE_FILENAME" "$build_cache_dir/airootfs/opt/packages/" # Add our additional packages to packages.x86_64 -arch_packages=(linux-t2 git gum jq openssl plymouth tzupdate omarchy-keyring) +arch_packages=(linux-t2 git gum jq openssl plymouth tzupdate omarchy-keyring python-terminaltexteffects) printf '%s\n' "${arch_packages[@]}" >>"$build_cache_dir/packages.x86_64" # Build list of all the packages needed for the offline mirror -all_packages=($(cat "$build_cache_dir/packages.x86_64")) -all_packages+=($(grep -v '^#' "$build_cache_dir/airootfs/root/omarchy/install/omarchy-base.packages" | grep -v '^$')) -all_packages+=($(grep -v '^#' "$build_cache_dir/airootfs/root/omarchy/install/omarchy-other.packages" | grep -v '^$')) -all_packages+=($(grep -v '^#' /builder/archinstall.packages | grep -v '^$')) +# Start with packages.x86_64 but exclude locally-built packages +all_packages=($(cat "$build_cache_dir/packages.x86_64" | grep -vE '^(omarchy|omarchy-settings|omarchy-installer)$')) + +# Add omarchy package lists from source, excluding locally-built packages +if [ -n "$OMARCHY_INSTALLER_SRC" ] && [ -d "$OMARCHY_INSTALLER_SRC" ]; then + # Filter out locally-built packages and known problematic packages + all_packages+=($(grep -v '^#' "$OMARCHY_INSTALLER_SRC/install/omarchy-base.packages" | grep -v '^$' | grep -vE '^(omarchy|omarchy-settings|omarchy-installer)$')) + all_packages+=($(grep -v '^#' "$OMARCHY_INSTALLER_SRC/install/omarchy-other.packages" | grep -v '^$' | grep -vE '^qt5-remoteobjects$')) +else + echo "WARNING: Could not find omarchy package lists, offline mirror may be incomplete" +fi + +all_packages+=($(grep -v '^#' /builder/archinstall.packages | grep -v '^$' | grep -vE '^(omarchy|omarchy-settings|omarchy-installer)$')) + +# Remove duplicates +all_packages=($(printf '%s\n' "${all_packages[@]}" | sort -u)) # Download all the packages to the offline mirror inside the ISO +# Use --needed to skip packages that are already in cache +# Use --noconfirm to avoid interactive prompts mkdir -p /tmp/offlinedb -pacman --config /configs/pacman-online.conf --noconfirm -Syw "${all_packages[@]}" --cachedir $offline_mirror_dir/ --dbpath /tmp/offlinedb -repo-add --new "$offline_mirror_dir/offline.db.tar.gz" "$offline_mirror_dir/"*.pkg.tar.zst +echo "Downloading ${#all_packages[@]} packages to offline mirror..." +pacman --config /configs/pacman-online.conf --noconfirm -Syw "${all_packages[@]}" --cachedir $offline_mirror_dir/ --dbpath /tmp/offlinedb --needed + +# Build repository database for the offline mirror +# First, create the database from all downloaded packages +echo "Building offline repository database..." +repo-add "$offline_mirror_dir/offline.db.tar.gz" "$offline_mirror_dir/"*.pkg.tar.zst + +# Note: Our locally built packages (omarchy, omarchy-settings) were copied earlier +# and are now included in the repository database # Create a symlink to the offline mirror instead of duplicating it. # mkarchiso needs packages at /var/cache/omarchy/mirror/offline in the container, @@ -91,6 +133,11 @@ ln -s "$offline_mirror_dir" "/var/cache/omarchy/mirror/offline" # same config when booted cp $build_cache_dir/pacman.conf "$build_cache_dir/airootfs/etc/pacman.conf" +# Create missing device-mapper udev rules file to silence mkinitcpio warning +# This file was removed in recent device-mapper versions but mkinitcpio still references it +mkdir -p /usr/lib/initcpio/udev +touch /usr/lib/initcpio/udev/11-dm-initramfs.rules + # Finally, we assemble the entire ISO mkarchiso -v -w "$build_cache_dir/work/" -o "/out/" "$build_cache_dir/" diff --git a/builder/build-omarchy-packages.sh b/builder/build-omarchy-packages.sh new file mode 100755 index 0000000..33e727d --- /dev/null +++ b/builder/build-omarchy-packages.sh @@ -0,0 +1,203 @@ +#!/bin/bash +# Build omarchy packages locally for ISO integration +# This runs inside the Docker container during ISO build + +set -e + +echo "=========================================" +echo "Building omarchy-settings package locally" +echo "=========================================" + +# Packages will be built in /tmp/omarchy-pkg-build +BUILD_DIR="/tmp/omarchy-pkg-build" +# Clean old builds to avoid checksum issues +rm -rf "$BUILD_DIR" +mkdir -p "$BUILD_DIR" + +# Create a writable build directory +WORK_DIR="/tmp/omarchy-pkg-work" +# Clean old work directory +rm -rf "$WORK_DIR" +mkdir -p "$WORK_DIR" + +# Copy package files to writable location +echo "Setting up build directory..." +cp -r /omarchy-pkgs/pkgbuilds/omarchy-settings "$WORK_DIR/" +cd "$WORK_DIR/omarchy-settings" + +# Set PKGDEST to control where built packages go +export PKGDEST="$BUILD_DIR" + +# Check if we should use dev build (local source) +if [ -n "$OMARCHY_DEV_BUILD" ] && [ -d "/omarchy-installer" ]; then + echo "=========================================" + echo "DEV MODE: Using locally mounted source" + echo "=========================================" + + # Source the dev PKGBUILD patch + source /builder/templates/dev-pkgbuild-patch.sh + convert_to_dev_pkgbuild "PKGBUILD" + + # Ensure local source is accessible + mkdir -p src + ln -sf /omarchy-installer src/omarchy-installer + + BUILD_FILE="PKGBUILD.dev" + BUILD_FLAGS="--noconfirm --skippgpcheck --skipchecksums --noextract" + echo "✓ Will build from local source (no git clone)" +else + echo "=========================================" + echo "PRODUCTION MODE: Using git source" + echo "=========================================" + BUILD_FILE="PKGBUILD" + BUILD_FLAGS="--noconfirm --skippgpcheck" + echo "✓ Will git clone from repository" +fi + +# Sync package databases (needed for dependency resolution) +echo "Syncing package databases..." +pacman -Sy --noconfirm + +# Build the package +# Note: The container runs as root, but makepkg refuses to run as root +# Create a fresh build user (nobody account is expired in base image) +if ! id builder &>/dev/null; then + useradd -m -s /bin/bash builder +fi + +# Give builder ownership +chown -R builder:builder "$WORK_DIR/omarchy-settings" +chown -R builder:builder "$BUILD_DIR" + +# Allow builder to run pacman without password (needed for dependency installation) +echo "builder ALL=(ALL) NOPASSWD: /usr/bin/pacman" > /etc/sudoers.d/99-builder-pacman +chmod 440 /etc/sudoers.d/99-builder-pacman + +# Build the package as builder user (makepkg will install dependencies via sudo) +su builder -c "cd $WORK_DIR/omarchy-settings && makepkg -p $BUILD_FILE $BUILD_FLAGS -s" + +# Find the built package +BUILT_PACKAGE=$(ls -t "$BUILD_DIR"/omarchy-settings-*.pkg.tar.zst 2>/dev/null | head -n1) + +if [ -z "$BUILT_PACKAGE" ]; then + echo "ERROR: Failed to build omarchy-settings package" + exit 1 +fi + +echo "✓ Successfully built: $(basename $BUILT_PACKAGE)" +echo "Package location: $BUILT_PACKAGE" + +# Export the path for use by build-iso.sh +export OMARCHY_SETTINGS_PKG="$BUILT_PACKAGE" + +# Export the source directory for accessing package lists before package is installed +# Check both possible locations (dev mode uses /omarchy-installer, prod uses src/) +if [ -d "/omarchy-installer" ]; then + export OMARCHY_INSTALLER_SRC="/omarchy-installer" + echo "✓ Package source available at: $OMARCHY_INSTALLER_SRC (mounted)" +elif [ -d "$WORK_DIR/omarchy-settings/src/omarchy-installer" ]; then + export OMARCHY_INSTALLER_SRC="$WORK_DIR/omarchy-settings/src/omarchy-installer" + echo "✓ Package source available at: $OMARCHY_INSTALLER_SRC (from build)" +fi + +echo "✓ Package contains everything needed for ISO (configs, package lists, binaries, theme)" + +# Now build the omarchy-installer package +echo "" +echo "=========================================" +echo "Building omarchy-installer package" +echo "=========================================" + +# Copy omarchy-installer package files to writable location +cp -r /omarchy-pkgs/pkgbuilds/omarchy-installer "$WORK_DIR/" +cd "$WORK_DIR/omarchy-installer" + +# Check if we should use dev build +if [ -n "$OMARCHY_DEV_BUILD" ] && [ -d "/omarchy-installer" ]; then + echo "DEV MODE: Using locally mounted source" + + # Generate dev PKGBUILD + source /builder/templates/dev-pkgbuild-patch.sh + convert_to_dev_pkgbuild "PKGBUILD" + + # Symlink local source + mkdir -p src + ln -sf /omarchy-installer src/omarchy-installer + + INSTALLER_BUILD_FILE="PKGBUILD.dev" + INSTALLER_BUILD_FLAGS="--noconfirm --skippgpcheck --skipchecksums --noextract" +else + echo "PRODUCTION MODE: Using git source" + INSTALLER_BUILD_FILE="PKGBUILD" + INSTALLER_BUILD_FLAGS="--noconfirm --skippgpcheck" +fi + +# Give builder ownership +chown -R builder:builder "$WORK_DIR/omarchy-installer" + +# Build the omarchy-installer package +su builder -c "cd $WORK_DIR/omarchy-installer && makepkg -p $INSTALLER_BUILD_FILE $INSTALLER_BUILD_FLAGS -d" + +# Find the built package +OMARCHY_INSTALLER_PKG=$(ls -t "$BUILD_DIR"/omarchy-installer-*.pkg.tar.zst 2>/dev/null | head -n1) + +if [ -z "$OMARCHY_INSTALLER_PKG" ]; then + echo "ERROR: Failed to build omarchy-installer package" + exit 1 +fi + +echo "✓ Successfully built: $(basename $OMARCHY_INSTALLER_PKG)" +echo "Package location: $OMARCHY_INSTALLER_PKG" + +# Now build the full omarchy package for offline mirror +echo "" +echo "=========================================" +echo "Building omarchy meta-package" +echo "=========================================" + +# Copy omarchy package files to writable location +cp -r /omarchy-pkgs/pkgbuilds/omarchy "$WORK_DIR/" +cd "$WORK_DIR/omarchy" + +# Check if we should use dev build +if [ -n "$OMARCHY_DEV_BUILD" ] && [ -d "/omarchy-installer" ]; then + echo "DEV MODE: Using locally mounted source" + + # Generate dev PKGBUILD + source /builder/templates/dev-pkgbuild-patch.sh + convert_to_dev_pkgbuild "PKGBUILD" + + # Symlink local source + mkdir -p src + ln -sf /omarchy-installer src/omarchy-installer + + OMARCHY_BUILD_FILE="PKGBUILD.dev" + OMARCHY_BUILD_FLAGS="--noconfirm --skippgpcheck --skipchecksums --noextract" +else + echo "PRODUCTION MODE: Using git source" + OMARCHY_BUILD_FILE="PKGBUILD" + OMARCHY_BUILD_FLAGS="--noconfirm --skippgpcheck" +fi + +# Give builder ownership +chown -R builder:builder "$WORK_DIR/omarchy" + +# Build the omarchy package +# Note: Skip dependency checks (-d) since we're just packaging files, not running them +# The dependencies will be resolved when the package is installed in the actual system +su builder -c "cd $WORK_DIR/omarchy && makepkg -p $OMARCHY_BUILD_FILE $OMARCHY_BUILD_FLAGS -d" + +# Find the built package +OMARCHY_PKG=$(ls -t "$BUILD_DIR"/omarchy-*.pkg.tar.zst 2>/dev/null | head -n1) + +if [ -z "$OMARCHY_PKG" ]; then + echo "ERROR: Failed to build omarchy package" + exit 1 +fi + +echo "✓ Successfully built: $(basename $OMARCHY_PKG)" +echo "Package location: $OMARCHY_PKG" + +# Export for use by build-iso.sh +export OMARCHY_PKG="$OMARCHY_PKG" +export OMARCHY_INSTALLER_PKG="$OMARCHY_INSTALLER_PKG" diff --git a/builder/templates/dev-pkgbuild-patch.sh b/builder/templates/dev-pkgbuild-patch.sh new file mode 100755 index 0000000..4a6ee6e --- /dev/null +++ b/builder/templates/dev-pkgbuild-patch.sh @@ -0,0 +1,39 @@ +#!/bin/bash +# Patch to convert production PKGBUILD to dev PKGBUILD +# This script modifies PKGBUILD to use local source instead of git clone + +convert_to_dev_pkgbuild() { + local pkgbuild_path="$1" + local dev_pkgbuild_path="${pkgbuild_path}.dev" + + echo "Creating dev PKGBUILD from production version..." + + # Copy production PKGBUILD + cp "$pkgbuild_path" "$dev_pkgbuild_path" + + # Remove git source (replace with empty source array) + sed -i '/^source=/c\source=()' "$dev_pkgbuild_path" + sed -i '/^sha256sums=/c\sha256sums=()' "$dev_pkgbuild_path" + + # Add prepare() function to symlink local source + # Insert after the source line + cat >> "$dev_pkgbuild_path" << 'EOF' + +# Dev build: use locally mounted source +prepare() { + # Symlink local omarchy-installer source + if [ -d "/omarchy-installer" ]; then + ln -sf /omarchy-installer "$srcdir/omarchy-installer" + echo "Using locally mounted omarchy-installer from /omarchy-installer" + elif [ -f "/omarchy-pkgs/pkgbuilds/omarchy-settings/src/omarchy-installer" ]; then + # Fallback: use source from previous build + echo "Using omarchy-installer from previous package build" + else + error "No local omarchy-installer source found!" + return 1 + fi +} +EOF + + echo "✓ Dev PKGBUILD created: $dev_pkgbuild_path" +} diff --git a/configs/airootfs/etc/plymouth/plymouthd.conf b/configs/airootfs/etc/plymouth/plymouthd.conf index fbdb629..9cce922 100644 --- a/configs/airootfs/etc/plymouth/plymouthd.conf +++ b/configs/airootfs/etc/plymouth/plymouthd.conf @@ -1,3 +1,3 @@ [Daemon] Theme=omarchy -ShowDelay=0 \ No newline at end of file +ShowDelay=0 diff --git a/configs/airootfs/root/.automated_script.sh b/configs/airootfs/root/.automated_script.sh old mode 100644 new mode 100755 index cccab4d..49aa721 --- a/configs/airootfs/root/.automated_script.sh +++ b/configs/airootfs/root/.automated_script.sh @@ -2,40 +2,122 @@ set -euo pipefail use_omarchy_helpers() { - export OMARCHY_PATH="/root/omarchy" - export OMARCHY_INSTALL="/root/omarchy/install" - export OMARCHY_INSTALL_LOG_FILE="/var/log/omarchy-install.log" - source /root/omarchy/install/helpers/all.sh + # Use omarchy-settings package location (installed in ISO) + export OMARCHY_PATH="/usr/share/omarchy" + export OMARCHY_INSTALL="/usr/share/omarchy/install" + export OMARCHY_INSTALL_LOG_FILE="/var/log/archinstall/install.log" + + # Load presentation helpers (clear_logo, etc.) and logging helpers (start_log_output, etc.) + source /usr/share/omarchy/install/helpers/all.sh } run_configurator() { set_tokyo_night_colors ./configurator - export OMARCHY_USER="$(jq -r '.users[0].username' user_credentials.json)" + export OMARCHY_USER="$(jq -r '.username' user_info.json)" + export OMARCHY_USER_PASSWORD_HASH="$(jq -r '.password_hash' user_info.json)" + export OMARCHY_USER_NAME="$(cat user_full_name.txt)" + export OMARCHY_USER_EMAIL="$(cat user_email_address.txt)" } -install_arch() { +install_omarchy() { clear_logo gum style --foreground 3 --padding "1 0 0 $PADDING_LEFT" "Installing..." echo + # Copy user info to /tmp on the ISO side + # omarchy-install will copy these into the chroot at the right time + cp user_full_name.txt /tmp/omarchy-user-name.txt 2>/dev/null || true + cp user_email_address.txt /tmp/omarchy-user-email.txt 2>/dev/null || true + + # Check if advanced disk mode (partition TUI) + EDIT_PARTITIONS_FLAG="" + if [[ -f edit_partitions_flag.txt ]]; then + EDIT_PARTITIONS_FLAG=$(cat edit_partitions_flag.txt | tr -d '\n' | xargs) + fi + + # ADVANCED MODE: Run disk configuration TUI before installation + if [[ -n "$EDIT_PARTITIONS_FLAG" ]]; then + clear_logo + gum style --foreground 3 --padding "1 0 0 $PADDING_LEFT" "Configuring disk layout..." + echo + + # Run omarchy-disk-config to show partition TUI and validate + # This updates user_configuration.json in place + /usr/share/omarchy/bin/omarchy-disk-config \ + --config user_configuration.json \ + --creds user_credentials.json + + disk_config_exit_code=$? + + if [[ $disk_config_exit_code -ne 0 ]]; then + echo "ERROR: Disk configuration failed or was cancelled" + exit $disk_config_exit_code + fi + + clear_logo + gum style --foreground 3 --padding "1 0 0 $PADDING_LEFT" "Disk configuration complete!" + echo + sleep 1 + fi + + # Run installation with the configuration (possibly updated by disk-config) + + # Create backup log file for raw output (with ANSI codes stripped) touch /var/log/omarchy-install.log - - start_log_output - - # Set CURRENT_SCRIPT for the trap to display better when nothing is returned for some reason - CURRENT_SCRIPT="install_base_system" - install_base_system > >(sed -u 's/\x1b\[[0-9;]*[a-zA-Z]//g' >>/var/log/omarchy-install.log) 2>&1 - unset CURRENT_SCRIPT + + # Ensure archinstall log directory exists + sudo mkdir -p /var/log/archinstall + + # Start tailing our backup log to show user what's happening + start_log_output "/var/log/omarchy-install.log" + + # Run omarchy-install and capture output + # archinstall writes to /var/log/archinstall/install.log internally + # We also capture stdout/stderr to our backup log (stripping ANSI codes for clean viewing) + /usr/share/omarchy/bin/omarchy-install \ + --config user_configuration.json \ + --creds user_credentials.json \ + 2>&1 | sed -u 's/\x1b\[[0-9;]*[a-zA-Z]//g' | tee -a /var/log/omarchy-install.log >/dev/null + + install_exit_code=$? + stop_log_output -} + + # Check if omarchy-install failed + if [[ $install_exit_code -ne 0 ]]; then + echo + echo "ERROR: Installation failed (exit code $install_exit_code)" + echo "Check /var/log/omarchy-install.log for details" + exit $install_exit_code + fi -install_omarchy() { - chroot_bash -lc "sudo pacman -S --noconfirm --needed gum" >/dev/null - chroot_bash -lc "source /home/$OMARCHY_USER/.local/share/omarchy/install.sh || bash" - - # Reboot if requested by installer - if [[ -f /mnt/var/tmp/omarchy-install-completed ]]; then + # Installation succeeded - copy logs to installed system for user access + echo "Copying installation logs to installed system..." + sudo mkdir -p /mnt/var/log + sudo cp /var/log/omarchy-install.log /mnt/var/log/omarchy-install.log 2>/dev/null || true + sudo cp /var/log/archinstall/install.log /mnt/var/log/archinstall-install.log 2>/dev/null || true + + # Show completion screen + clear + echo + tte -i /usr/share/omarchy/logo.txt --canvas-width 0 --anchor-text c --frame-rate 920 laseretch + echo + + # Display installation time if available + if [[ -f /mnt/tmp/omarchy-install-time.txt ]]; then + TOTAL_TIME=$(cat /mnt/tmp/omarchy-install-time.txt) + echo "Installed in $TOTAL_TIME" | tte --canvas-width 0 --anchor-text c --frame-rate 640 print + else + echo "Finished installing" | tte --canvas-width 0 --anchor-text c --frame-rate 640 print + fi + echo + + # Prompt for reboot (centered) + BUTTON_WIDTH=12 # "Reboot Now" + padding + BUTTON_PADDING=$(( (TERM_WIDTH - BUTTON_WIDTH) / 2 )) + if gum confirm --padding "0 0 0 $BUTTON_PADDING" --show-help=false --default --affirmative "Reboot Now" --negative "" ""; then + clear reboot fi } @@ -67,74 +149,8 @@ set_tokyo_night_colors() { fi } -install_base_system() { - # Initialize and populate the keyring - pacman-key --init - pacman-key --populate archlinux - pacman-key --populate omarchy - - # Sync the offline database so pacman can find packages - pacman -Sy --noconfirm - - # Ensure that no mounts exist from past install attempts - findmnt -R /mnt >/dev/null && umount -R /mnt - - # Install using files generated by the ./configurator - # Skip NTP and WKD sync since we're offline (keyring is pre-populated in ISO) - archinstall \ - --config user_configuration.json \ - --creds user_credentials.json \ - --silent \ - --skip-ntp \ - --skip-wkd - - # After archinstall sets up the base system but before our installer runs, - # we need to ensure the offline pacman.conf is in place - cp /etc/pacman.conf /mnt/etc/pacman.conf - - # Mount the offline mirror so it's accessible in the chroot - mkdir -p /mnt/var/cache/omarchy/mirror/offline - mount --bind /var/cache/omarchy/mirror/offline /mnt/var/cache/omarchy/mirror/offline - - # Mount the packages dir so it's accessible in the chroot - mkdir -p /mnt/opt/packages - mount --bind /opt/packages /mnt/opt/packages - - # No need to ask for sudo during the installation (omarchy itself responsible for removing after install) - mkdir -p /mnt/etc/sudoers.d - cat >/mnt/etc/sudoers.d/99-omarchy-installer </dev/null || true - chmod +x /mnt/home/$OMARCHY_USER/.local/share/omarchy/default/waybar/indicators/screen-recording.sh 2>/dev/null || true -} - -chroot_bash() { - HOME=/home/$OMARCHY_USER \ - arch-chroot -u $OMARCHY_USER /mnt/ \ - env OMARCHY_CHROOT_INSTALL=1 \ - OMARCHY_USER_NAME="$(/dev/null || sudo pacman -Sy --noconfirm tzupdate +# Build the package list for archinstall from omarchy-base.packages +build_package_json() { + local packages=("base-devel" "git" "omarchy-keyring" "omarchy-settings") + + # Read omarchy-base.packages and add to array + while IFS= read -r pkg; do + [[ -z "$pkg" || "$pkg" =~ ^# ]] && continue + packages+=("$pkg") + done < "$OMARCHY_INSTALL/omarchy-base.packages" + + # Format as JSON array + local json="[" + for i in "${!packages[@]}"; do + json+="\"${packages[$i]}\"" + [[ $i -lt $((${#packages[@]} - 1)) ]] && json+=", " + done + json+="]" + + echo "$json" +} + abort() { gum style "${1:-Aborted installation}" echo @@ -214,23 +235,54 @@ disk_form() { disk_options="$disk_options$disk_info"$'\n' fi done <<<"$available_disks" + + # Add "Advanced Disk Config" option at the bottom + disk_options="${disk_options}Advanced Disk Config (custom partitioning)" selected_display=$(echo "$disk_options" | gum choose --header "Select install disk") || abort - disk=$(echo "$selected_display" | awk '{print $1}') + + # Check if user selected advanced config + if echo "$selected_display" | grep -q "Advanced Disk Config"; then + USE_ADVANCED_DISK_CONFIG=1 + EDIT_PARTITIONS="--edit-partitions" + disk="" # Will be determined by TUI + else + USE_ADVANCED_DISK_CONFIG=0 + disk=$(echo "$selected_display" | awk '{print $1}') + fi } disk_form -while true; do - gum style "Everything will be overwritten. There is no recovery possible." - +# If user selected advanced config, skip to partition editor +if [[ $USE_ADVANCED_DISK_CONFIG -eq 1 ]]; then + gum style --foreground 3 "Advanced disk configuration selected." + gum style "You'll configure partitions in the archinstall TUI." echo - if gum confirm --affirmative "Yes, format disk" --negative "No, change it" "Confirm overwriting ${disk}"; then - break - else - disk_form - fi -done + EDIT_PARTITIONS="--edit-partitions" +else + # Normal flow: confirm disk wipe and use default layout + while true; do + gum style "Everything will be overwritten. There is no recovery possible." + + echo + if gum confirm --affirmative "Yes, format disk" --negative "No, change it" "Confirm overwriting ${disk}"; then + break + else + disk_form + # Check again if user switched to advanced config + if [[ $USE_ADVANCED_DISK_CONFIG -eq 1 ]]; then + gum style --foreground 3 "Advanced disk configuration selected." + gum style "You'll configure partitions in the archinstall TUI." + echo + EDIT_PARTITIONS="--edit-partitions" + break + fi + fi + done + # Normal flow always uses default layout (no editing) + EDIT_PARTITIONS="" +fi clear @@ -239,6 +291,9 @@ clear echo "$full_name" >user_full_name.txt echo "$email_address" >user_email_address.txt +# Save partition editing preference +echo "$EDIT_PARTITIONS" >edit_partitions_flag.txt + # Escape username and password for safe inclusion password_escaped=$(echo -n "$password" | jq -Rsa) password_hash_escaped=$(echo -n "$password_hash" | jq -Rsa) @@ -250,27 +305,36 @@ cat <<-_EOF_ >user_credentials.json "root_enc_password": $password_hash_escaped, "users": [ { + "username": $username_escaped, "enc_password": $password_hash_escaped, - "groups": [], - "sudo": true, - "username": $username_escaped + "sudo": true } ] } _EOF_ -# Setup partition layout -disk_size=$(lsblk -bdno SIZE "$disk") -mib=$((1024 * 1024)) -gib=$((mib * 1024)) -disk_size_in_mib=$((disk_size / mib * mib)) # Rounds to nearest MiB +# Save user info separately so we can create the user after packages are installed +cat <<-_EOF_ >user_info.json +{ + "username": $username_escaped, + "password_hash": $password_hash_escaped +} +_EOF_ -gpt_backup_reserve=$((mib)) -boot_partition_start=$((mib)) -boot_partition_size=$((2 * gib)) +# Setup partition layout (only for non-advanced config) +if [[ $USE_ADVANCED_DISK_CONFIG -eq 0 ]]; then + disk_size=$(lsblk -bdno SIZE "$disk") + mib=$((1024 * 1024)) + gib=$((mib * 1024)) + disk_size_in_mib=$((disk_size / mib * mib)) # Rounds to nearest MiB -main_partition_start=$((boot_partition_size + boot_partition_start)) -main_partition_size=$((disk_size_in_mib - main_partition_start - gpt_backup_reserve)) + gpt_backup_reserve=$((mib)) + boot_partition_start=$((mib)) + boot_partition_size=$((2 * gib)) + + main_partition_start=$((boot_partition_size + boot_partition_start)) + main_partition_size=$((disk_size_in_mib - main_partition_start - gpt_backup_reserve)) +fi # Detect T2 Mac and set appropriate kernel if lspci -nn 2>/dev/null | grep -q "106b:180[12]"; then @@ -279,14 +343,67 @@ else kernel_choice="linux" fi -cat <<-_EOF_ >user_configuration.json +# Build the complete package list including all Omarchy packages +packages_json=$(build_package_json) + +# Generate configuration based on mode +if [[ $USE_ADVANCED_DISK_CONFIG -eq 1 ]]; then + # Minimal config for advanced mode - user will configure disk in TUI + cat <<-_EOF_ >user_configuration.json { "app_config": null, "archinstall-language": "English", "auth_config": {}, "audio_config": { "audio": "pipewire" }, "bootloader": "Limine", - "custom_commands": [], + "custom_commands": [ + "/usr/share/omarchy/bin/omarchy-install-final-configurations.sh" + ], + "hostname": "$hostname", + "kernels": [ "$kernel_choice" ], + "network_config": { "type": "iso" }, + "ntp": true, + "parallel_downloads": 8, + "script": null, + "services": [], + "swap": true, + "timezone": "$timezone", + "locale_config": { + "kb_layout": "$keyboard", + "sys_enc": "UTF-8", + "sys_lang": "en_US.UTF-8" + }, + "mirror_config": { + "custom_repositories": [], + "custom_servers": [ + {"url": "https://mirror.omarchy.org/\$repo/os/\$arch"}, + {"url": "https://mirror.rackspace.com/archlinux/\$repo/os/\$arch"}, + {"url": "https://geo.mirror.pkgbuild.com/\$repo/os/\$arch"} + ], + "mirror_regions": {}, + "optional_repositories": [] + }, + "packages": $packages_json, + "profile_config": { + "gfx_driver": null, + "greeter": null, + "profile": {} + }, + "version": "3.0.9" +} +_EOF_ +else + # Full config with default partition layout + cat <<-_EOF_ >user_configuration.json +{ + "app_config": null, + "archinstall-language": "English", + "auth_config": {}, + "audio_config": { "audio": "pipewire" }, + "bootloader": "Limine", + "custom_commands": [ + "/usr/share/omarchy/bin/omarchy-install-final-configurations.sh" + ], "disk_config": { "btrfs_options": { "snapshot_config": { @@ -353,8 +470,7 @@ cat <<-_EOF_ >user_configuration.json "encryption_type": "luks", "lvm_volumes": [], "iter_time": 2000, - "partitions": [ "8c2c2b92-1070-455d-b76a-56263bab24aa" ], - "encryption_password": $password_escaped + "partitions": [ "8c2c2b92-1070-455d-b76a-56263bab24aa" ] } }, "hostname": "$hostname", @@ -381,11 +497,7 @@ cat <<-_EOF_ >user_configuration.json "mirror_regions": {}, "optional_repositories": [] }, - "packages": [ - "base-devel", - "git", - "omarchy-keyring" - ], + "packages": $packages_json, "profile_config": { "gfx_driver": null, "greeter": null, @@ -394,6 +506,7 @@ cat <<-_EOF_ >user_configuration.json "version": "3.0.9" } _EOF_ +fi if [[ $1 == "dry" ]]; then echo -e "User Configuration:" diff --git a/configs/profiledef.sh b/configs/profiledef.sh index b8d534a..2dda8ab 100644 --- a/configs/profiledef.sh +++ b/configs/profiledef.sh @@ -22,5 +22,4 @@ file_permissions=( ["/usr/local/bin/choose-mirror"]="0:0:755" ["/root/configurator"]="0:0:755" ["/var/cache/omarchy/mirror/offline/"]="0:0:775" - ["/usr/local/bin/omarchy-upload-log"]="0:0:755" )