mirror of
https://github.com/Cian-H/My_NixOS_Config.git
synced 2026-07-02 13:14:51 +01:00
325 lines
10 KiB
Makefile
325 lines
10 KiB
Makefile
set shell := ["bash", "-c"]
|
|
|
|
git := "true"
|
|
flake := "true"
|
|
flatpak := "true"
|
|
|
|
default:
|
|
@just --choose
|
|
|
|
_git-sync:
|
|
git pull --recurse
|
|
git submodule update --remote --recursive
|
|
|
|
_flake-update:
|
|
nix flake update
|
|
|
|
prebuild:
|
|
@if [ "{{git}}" == "true" ]; then \
|
|
echo ">> Syncing Git..."; \
|
|
just _git-sync; \
|
|
fi
|
|
@if [ "{{flake}}" == "true" ]; then \
|
|
echo ">> Updating Flake..."; \
|
|
just _flake-update; \
|
|
fi
|
|
|
|
_update-root:
|
|
if `/usr/bin/env grep -Rq "nixos" /etc/*-release`; then \
|
|
sudo nixos-rebuild switch --flake .?submodules=1#$HOSTNAME; \
|
|
fi
|
|
|
|
update-root: prebuild _update-root
|
|
|
|
install-home:
|
|
home-manager switch --flake .?submodules=1#$USER@core \
|
|
--extra-experimental-features nix-command \
|
|
--extra-experimental-features flakes
|
|
|
|
_update-home:
|
|
home-manager switch --flake .?submodules=1#$USER@$HOSTNAME \
|
|
|| home-manager switch --flake .?submodules=1#$USER@core
|
|
|
|
update-home: prebuild _update-home
|
|
|
|
quick-update-root:
|
|
just git=false flake=false update-root
|
|
|
|
quick-update-home:
|
|
just git=false flake=false update-home
|
|
|
|
quick-update:
|
|
just git=false flake=false update
|
|
|
|
nogit-update-root:
|
|
just git=false update-root
|
|
|
|
nogit-update-home:
|
|
just git=false update-home
|
|
|
|
nogit-update:
|
|
just git=false update
|
|
|
|
noflake-update-root:
|
|
just flake=false update-root
|
|
|
|
noflake-update-home:
|
|
just flake=false update-home
|
|
|
|
noflake-update:
|
|
just flake=false update
|
|
|
|
update-flatpaks:
|
|
@if [ "{{flatpak}}" == "true" ] && command -v flatpak &> /dev/null; then \
|
|
echo ">> Updating Flatpaks..."; \
|
|
flatpak update -y; \
|
|
flatpak uninstall --unused -y; \
|
|
else \
|
|
echo ">> Flatpak not found or disabled. Skipping."; \
|
|
fi
|
|
|
|
history:
|
|
@echo ">> System Generations:"
|
|
@nix-env -p /nix/var/nix/profiles/system --list-generations | tail -n 5
|
|
@echo "\n>> Home Manager Generations:"
|
|
@home-manager generations | head -n 5
|
|
|
|
repl:
|
|
nix repl --file flake.nix
|
|
|
|
update: prebuild _update-root _update-home update-flatpaks
|
|
|
|
cleanup days="":
|
|
@if [ -n "{{days}}" ]; then \
|
|
echo ">> Deleting system generations older than {{days}}..."; \
|
|
sudo nix-collect-garbage --delete-older-than {{days}}; \
|
|
fi
|
|
@echo ">> Cleaning Nix Store..."
|
|
nix-store --gc
|
|
nix-store --optimise
|
|
@if command -v flatpak &> /dev/null; then \
|
|
echo ">> Cleaning unused Flatpaks..."; \
|
|
flatpak uninstall --unused -y; \
|
|
fi
|
|
|
|
edit target:
|
|
#!/usr/bin/env python3
|
|
import os
|
|
import subprocess
|
|
import sys
|
|
|
|
target = "{{target}}"
|
|
|
|
# If it doesn't exist, assume we are creating a new text file
|
|
if not os.path.exists(target):
|
|
subprocess.run(["nvim", target])
|
|
sys.exit(0)
|
|
|
|
# If it's a directory, use yazi
|
|
if os.path.isdir(target):
|
|
subprocess.run(["yazi", target])
|
|
else:
|
|
# Check if the file is text or binary by attempting to read it
|
|
is_text = True
|
|
try:
|
|
with open(target, 'tr', encoding='utf-8') as check_file:
|
|
check_file.read(1024)
|
|
except UnicodeDecodeError:
|
|
is_text = False
|
|
|
|
if is_text:
|
|
subprocess.run(["nvim", target])
|
|
else:
|
|
subprocess.run(["heh", target])
|
|
|
|
# Opens the relevant packages.nix file for editing.
|
|
# Flags:
|
|
# --home : Edit home-manager config instead of NixOS config
|
|
# --sys <name> : Specify system (defaults to current hostname)
|
|
# --user <name> : Specify user (defaults to current user, only relevant if --home is passed)
|
|
# --no-update : Skip the auto-update after editing
|
|
packages *flags:
|
|
#!/usr/bin/env bash
|
|
set -e
|
|
|
|
# Inject 'just' parameters into the bash script's positional arguments
|
|
eval set -- "{{flags}}"
|
|
|
|
HOME_FLAG=false
|
|
SYS="$(hostname)"
|
|
USER_VAL="$(whoami)"
|
|
UPDATE_FLAG=true
|
|
|
|
# Parse command line flags
|
|
while [[ $# -gt 0 ]]; do
|
|
case "$1" in
|
|
--help|help|-h)
|
|
echo "Usage: just packages [OPTIONS]"
|
|
echo ""
|
|
echo "Opens the packages.nix file for editing and optionally updates."
|
|
echo ""
|
|
echo "Options:"
|
|
echo " home, --home Edit home-manager config instead of NixOS config"
|
|
echo " sys, --sys <name> Specify system (defaults to current hostname: $(hostname))"
|
|
echo " user, --user <name> Specify user (defaults to current user: $(whoami))"
|
|
echo " update, --update Run auto-update after editing (Default)"
|
|
echo " no-update, --no-update Skip the auto-update after editing"
|
|
echo " help, --help, -h Show this help message"
|
|
echo ""
|
|
echo "Examples:"
|
|
echo " just packages home (Edits HM for current system/user)"
|
|
echo " just packages sys homeserver no-update (Edits NixOS on homeserver, skips update)"
|
|
exit 0
|
|
;;
|
|
--home|home)
|
|
HOME_FLAG=true
|
|
shift
|
|
;;
|
|
--sys|sys)
|
|
SYS="$2"
|
|
shift 2
|
|
;;
|
|
--user|user)
|
|
USER_VAL="$2"
|
|
shift 2
|
|
;;
|
|
--no-update|no-update)
|
|
UPDATE_FLAG=false
|
|
shift
|
|
;;
|
|
--update|update)
|
|
UPDATE_FLAG=true
|
|
shift
|
|
;;
|
|
*)
|
|
echo "Unknown option: $1"
|
|
echo "Run 'just packages help' for valid options."
|
|
exit 1
|
|
;;
|
|
esac
|
|
done
|
|
|
|
# Determine the target path
|
|
if [ "$HOME_FLAG" = "true" ]; then
|
|
TARGET="home-manager/$SYS/packages.nix"
|
|
else
|
|
TARGET="nixos/$SYS/packages.nix"
|
|
fi
|
|
|
|
echo ">> Editing $TARGET..."
|
|
just edit "$TARGET"
|
|
|
|
if [ "$UPDATE_FLAG" = "true" ]; then
|
|
echo ">> Applying updates..."
|
|
just quick-update
|
|
else
|
|
echo ">> Skipping update (no-update provided)."
|
|
fi
|
|
|
|
# Bootstraps a system from scratch. Clones the repo and installs configs based on OS.
|
|
bootstrap:
|
|
#!/usr/bin/env python3
|
|
import os
|
|
import sys
|
|
import subprocess
|
|
import socket
|
|
import getpass
|
|
from pathlib import Path
|
|
|
|
REPO_URL = "https://github.com/Cian-H/My_NixOS_Config"
|
|
TARGET_DIR = os.path.expanduser("~/.config/nix")
|
|
|
|
# Prevent running if directory already exists
|
|
if os.path.exists(TARGET_DIR):
|
|
print(f"Error: {TARGET_DIR} already exists. Aborting bootstrap.", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
# Clone the repository
|
|
print(f">> Cloning {REPO_URL} into {TARGET_DIR}...")
|
|
try:
|
|
subprocess.run(["git", "clone", REPO_URL, TARGET_DIR], check=True)
|
|
except subprocess.CalledProcessError:
|
|
print("Error: Failed to clone repository.", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
# Change to the newly cloned repo directory for remaining commands
|
|
os.chdir(TARGET_DIR)
|
|
|
|
# OS Detection
|
|
is_nixos = False
|
|
if os.path.exists("/etc/os-release"):
|
|
with open("/etc/os-release", "r") as f:
|
|
if "ID=nixos" in f.read():
|
|
is_nixos = True
|
|
|
|
target_sys = socket.gethostname()
|
|
target_user = getpass.getuser()
|
|
|
|
# Determine if system configuration directories exist
|
|
def config_exists(sys_name):
|
|
has_nixos = os.path.isdir(f"nixos/{sys_name}")
|
|
has_hm = os.path.isdir(f"home-manager/{sys_name}")
|
|
return (has_nixos and has_hm) if is_nixos else has_hm
|
|
|
|
# Handle Missing Configurations
|
|
if not config_exists(target_sys):
|
|
print(f"\n>> Configuration for system '{target_sys}' (user: '{target_user}') not found.")
|
|
ans = input("Do you want to create the missing directories now? [y/N]: ").strip().lower()
|
|
|
|
if ans == 'y':
|
|
print(">> Creating directories...")
|
|
if is_nixos:
|
|
os.makedirs(f"nixos/{target_sys}", exist_ok=True)
|
|
os.makedirs(f"home-manager/{target_sys}", exist_ok=True)
|
|
|
|
print(">> Opening yazi. Please add your configs and exit yazi when finished.")
|
|
subprocess.run(["yazi", TARGET_DIR])
|
|
else:
|
|
ans = input("Do you want to switch to one of the existing configs instead? [y/N]: ").strip().lower()
|
|
if ans == 'y':
|
|
# Gather available options
|
|
opts = set()
|
|
if os.path.exists("nixos"):
|
|
opts.update([d for d in os.listdir("nixos") if os.path.isdir(f"nixos/{d}")])
|
|
if os.path.exists("home-manager"):
|
|
opts.update([d for d in os.listdir("home-manager") if os.path.isdir(f"home-manager/{d}")])
|
|
|
|
# Filter out base/core directories
|
|
opts = [o for o in opts if o not in ["core"] and not o.startswith(".")]
|
|
|
|
print("\nAvailable systems:")
|
|
for o in opts:
|
|
print(f" - {o}")
|
|
|
|
# Option selection for missing parameters
|
|
chosen_sys = input(f"\nEnter system to use [default: {target_sys}]: ").strip()
|
|
if chosen_sys:
|
|
if chosen_sys not in opts:
|
|
print(f"Error: '{chosen_sys}' is not a valid option.")
|
|
sys.exit(1)
|
|
target_sys = chosen_sys
|
|
|
|
chosen_user = input(f"Enter user configuration to use [default: {target_user}]: ").strip()
|
|
if chosen_user:
|
|
target_user = chosen_user
|
|
|
|
else:
|
|
print("Error: Cannot proceed without a valid configuration. Aborting.", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
print(f"\n>> Proceeding with installation for user '{target_user}' on system '{target_sys}'...")
|
|
|
|
# Execute Installations
|
|
try:
|
|
if is_nixos:
|
|
print(">> [NixOS detected] Performing full system and home-manager install...")
|
|
subprocess.run(["sudo", "nixos-rebuild", "switch", "--flake", f".#{target_sys}"], check=True)
|
|
subprocess.run(["home-manager", "switch", "--flake", f".#{target_user}@{target_sys}"], check=True)
|
|
else:
|
|
print(">> [Non-NixOS detected] Performing home-manager install only...")
|
|
subprocess.run(["home-manager", "switch", "--flake", f".#{target_user}@{target_sys}"], check=True)
|
|
print("\n>> Bootstrap complete! Welcome to your new environment.")
|
|
except subprocess.CalledProcessError:
|
|
print("\nError: An issue occurred during installation.", file=sys.stderr)
|
|
sys.exit(1)
|