187 lines
6.2 KiB
Python
187 lines
6.2 KiB
Python
"""euri-mklive — Universal CLI ISO builder."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import os
|
|
import sys
|
|
import tempfile
|
|
from pathlib import Path
|
|
|
|
import click
|
|
|
|
from . import __version__
|
|
from .config import load
|
|
from .rootfs import build, cleanup
|
|
from .iso import generate
|
|
from .distros import REGISTRY
|
|
|
|
BANNER = """\033[1;36m ________ ______ ____
|
|
/ ____/ / / / __ \\/ _/
|
|
/ __/ / / / / /_/ // /
|
|
/ /___/ /_/ / _, _// /
|
|
/_____/\\____/_/ |_/___/\033[0m
|
|
\033[1m universal iso builder\033[0m
|
|
\033[90m any distro, from any distro\033[0m
|
|
"""
|
|
|
|
SUPPORTED = ", ".join(sorted(REGISTRY.keys()))
|
|
|
|
|
|
@click.group(invoke_without_command=True)
|
|
@click.version_option(__version__, prog_name="euri-mklive")
|
|
@click.pass_context
|
|
def cli(ctx: click.Context) -> None:
|
|
"""\033[1mBuild bootable ISOs for any Linux distribution.\033[0m"""
|
|
if ctx.invoked_subcommand is None:
|
|
click.echo(BANNER)
|
|
click.echo(f" \033[90msupported distros:\033[0m {SUPPORTED}")
|
|
click.echo()
|
|
click.echo(" \033[1;36meuri-mklive build-iso <config> \033[0m build from YAML config")
|
|
click.echo(" \033[1;36meuri-mklive interactive \033[0m launch interactive TUI")
|
|
click.echo()
|
|
click.echo(ctx.get_help())
|
|
|
|
|
|
@cli.command()
|
|
@click.argument("config", type=click.Path(exists=True, path_type=Path))
|
|
@click.option("-o", "--output", type=click.Path(path_type=Path), default=".", help="Output directory")
|
|
@click.option("--keep-rootfs", is_flag=True, help="Don't remove rootfs after ISO generation")
|
|
def build_iso(config: Path, output: Path, keep_rootfs: bool) -> None:
|
|
"""Build an ISO from a YAML config file."""
|
|
click.echo(BANNER)
|
|
|
|
cfg = load(config)
|
|
output.mkdir(parents=True, exist_ok=True)
|
|
|
|
distro = cfg["distro"]
|
|
arch = cfg["arch"]
|
|
init = cfg.get("init", "dinit")
|
|
pkgs = len(cfg.get("packages", []))
|
|
|
|
click.echo(f" \033[36mdistro:\033[0m {distro}")
|
|
click.echo(f" \033[36march:\033[0m {arch}")
|
|
click.echo(f" \033[36minit:\033[0m {init}")
|
|
click.echo(f" \033[36mpackages:\033[0m {pkgs}")
|
|
click.echo()
|
|
|
|
try:
|
|
rootfs = build(cfg, output)
|
|
iso = generate(rootfs, cfg, output)
|
|
|
|
if not keep_rootfs:
|
|
cleanup(rootfs)
|
|
click.echo(f"\n\033[90mRootfs cleaned up.\033[0m")
|
|
|
|
click.echo(f"\n\033[1;32mDone! ISO ready at {iso}\033[0m")
|
|
|
|
except Exception as e:
|
|
click.echo(f"\n\033[1;31mError: {e}\033[0m", err=True)
|
|
sys.exit(1)
|
|
|
|
|
|
@cli.command()
|
|
@click.option("--fake", "mode", flag_value="fake", help="Run in fakeroot mode (no root needed)")
|
|
@click.option("--root", "mode", flag_value="root", default=True, help="Run as root (default)")
|
|
@click.option("-o", "--output", type=click.Path(path_type=Path), default=None, help="Output directory")
|
|
@click.option("--keep-rootfs", is_flag=True, help="Don't remove rootfs after ISO generation")
|
|
@click.option("-y", "--yes", is_flag=True, help="Skip confirmation prompts")
|
|
@click.option("--config", "config_file", type=click.Path(path_type=Path), default=None,
|
|
help="Load config from file (used by sudo re-exec)")
|
|
def interactive(mode: str | None, output: Path | None, keep_rootfs: bool, yes: bool,
|
|
config_file: Path | None) -> None:
|
|
"""Launch interactive TUI — select distro, packages, and build."""
|
|
from .tui import run_interactive, banner as tui_banner
|
|
|
|
# load config from file (sudo re-exec) or run TUI
|
|
if config_file and config_file.exists():
|
|
import json
|
|
cfg = json.loads(config_file.read_text())
|
|
config_file.unlink(missing_ok=True)
|
|
else:
|
|
cfg = run_interactive()
|
|
|
|
# override mode if flag given
|
|
if mode:
|
|
cfg["_mode"] = mode
|
|
|
|
# override output
|
|
out = output or Path(".")
|
|
out.mkdir(parents=True, exist_ok=True)
|
|
|
|
# inject skip confirmations
|
|
if yes:
|
|
cfg["_skip_confirm"] = True
|
|
|
|
tui_banner()
|
|
|
|
from rich.console import Console
|
|
from rich.panel import Panel
|
|
console = Console()
|
|
|
|
# check mode and re-exec if needed
|
|
if cfg["_mode"] == "root" and os.geteuid() != 0:
|
|
console.print("[bold yellow]Root mode selected but not root. Re-executing with sudo...[/]")
|
|
import subprocess as _sp
|
|
import site
|
|
import json
|
|
|
|
# save config to temp file for sudo re-exec
|
|
cfg_file = Path(tempfile.mktemp(suffix=".json", prefix="euri-cfg-"))
|
|
cfg_file.write_text(json.dumps(cfg))
|
|
|
|
args = [sys.executable, "-m", "euri_mklive", "interactive", "--root",
|
|
"--config", str(cfg_file)]
|
|
if keep_rootfs:
|
|
args.append("--keep-rootfs")
|
|
if output:
|
|
args.extend(["-o", str(output)])
|
|
# use 'sudo env PYTHONPATH=...' so root finds user-installed packages
|
|
user_site = site.getusersitepackages()
|
|
sudo_cmd = ["sudo", "env", f"PYTHONPATH={user_site}"] + args
|
|
_sp.run(sudo_cmd, check=True)
|
|
return
|
|
|
|
if cfg["_mode"] == "fakeroot":
|
|
import shutil as _shutil
|
|
if not _shutil.which("fakeroot"):
|
|
console.print("[bold red]Error:[/] fakeroot not found. Install it first.")
|
|
sys.exit(1)
|
|
console.print(Panel(
|
|
"[bold yellow]Fakeroot mode[/]\n"
|
|
"Performance degraded. Some post-install scripts may fail.\n"
|
|
"For full functionality, run with sudo.",
|
|
border_style="yellow",
|
|
))
|
|
|
|
# build
|
|
try:
|
|
from .rootfs import build as _build
|
|
from .iso import generate as _generate
|
|
|
|
rootfs = _build(cfg, out)
|
|
iso = _generate(rootfs, cfg, out)
|
|
|
|
if not keep_rootfs:
|
|
cleanup(rootfs)
|
|
|
|
console.print(Panel(
|
|
f"[bold green]ISO ready![/]\n{iso}",
|
|
border_style="green",
|
|
title="Success",
|
|
))
|
|
|
|
except Exception as e:
|
|
console.print(Panel(f"[bold red]Build failed:[/] {e}", border_style="red"))
|
|
sys.exit(1)
|
|
|
|
|
|
@cli.command()
|
|
def supported() -> None:
|
|
"""List all supported distros."""
|
|
click.echo(BANNER)
|
|
click.echo(" \033[1mSupported distros:\033[0m")
|
|
for name, cls in sorted(REGISTRY.items()):
|
|
click.echo(f" \033[36m{name:<15}\033[0m {cls.__doc__ or ''}")
|
|
click.echo()
|
|
click.echo(" \033[90mEach distro can be built FROM any other distro.\033[0m")
|