sergio/takana

1#!/bin/sh
2# takana-install — instalador a disco DESDE el medio live (Etapa E5 / refinamiento #1).
3#
4# Se inyecta en el rootfs del producto como /usr/bin/takana-install (ver scripts/iso-image.sh
5# INSTALLER=1). Corre DENTRO del live, como root real (arje-zero es PID1) ⇒ NO necesita unshare -r
6# ni los rodeos rootless de install-image.sh: particiona, formatea, monta y copia con privilegios
7# reales, usando sólo herramientas que el producto ya trae (busybox fdisk/mke2fs/mount/dd + uutils cp).
8#
9# El sistema que se instala es EL PROPIO LIVE: la raíz en RAM se copia al disco (autoinstalador). El
10# payload de arranque (kernel + GRUB) viaja en /usr/lib/hammer/install/, armado en build-time (el host
11# tiene grub-mkimage; el live no lo necesita).
12#
13# Layout en disco (MBR, no GPT — más simple y busybox-friendly; GRUB va en el hueco post-MBR):
14#   /dev/<dev>1  /                ext2(montable ext4)   + /boot/bzImage + /boot/grub + wrapper /sbin/init
15#   /dev/<dev>2  /store           ext2
16#   /dev/<dev>3  /var/lib/hammer  ext2
17#
18# Cadena de arranque del disco resultante: BIOS → MBR (boot.img) → core.img (hueco post-MBR) →
19# (hd0,msdos1)/boot/grub/grub.cfg → linux /boot/bzImage root=/dev/<dev>1 → wrapper /sbin/init.
20#
21# Modo de uso:
22#   INTERACTIVO (sin argumentos, con TTY):  takana-install
23#       TUI en busybox sh: detecta discos, el usuario elige destino + confirma el borrado, recoge
24#       hostname / credencial de root / zona horaria / teclado / tamaños de partición, y recién ahí
25#       particiona+instala. Es la cara humana del instalador (el /init del ISO installer lo lanza).
26#   DESATENDIDO (con device):  takana-install /dev/vdb [ROOT_MB] [STORE_MB]
27#       Autoinstalador (lo usa iso-install-test.sh con AUTO_INSTALL). La config sale de env:
28#       TAKANA_HOSTNAME / TAKANA_ROOT_PW / TAKANA_ROOT_AUTHKEYS / TAKANA_TZ / TAKANA_KEYMAP.
29#       Los nombres viejos HAMMER_* se siguen aceptando (ADR 0016); gana el nuevo si están los dos.
30set -eu
31
32DEV="${1:-}"
33ROOT_MB="${2:-}"
34STORE_MB="${3:-}"        # /var/lib/hammer toma el resto
35PAYLOAD=/usr/lib/hammer/install
36BB="${BB:-/bin/busybox}"
37SYS_BLOCK="${SYS_BLOCK:-/sys/block}"   # override para tests
38MOUNTS="${MOUNTS:-/proc/mounts}"       # override para tests
39
40# bb: usa el busybox del live si existe; si no (p.ej. tests en el host), cae a las herramientas del PATH.
41# Sólo lo usan las funciones NUEVAS (config/TUI). Las ramas EFI/BIOS validadas siguen con "$BB" literal
42# y jamás corren en el host (el dry-run sale antes).
43bb() { if [ -x "$BB" ]; then "$BB" "$@"; else "$@"; fi; }
44
45_human() {  # bytes → humano
46    _b="$1"
47    if   [ "$_b" -ge 1073741824 ]; then printf '%s.%s GiB' "$((_b/1073741824))" "$(( (_b%1073741824)*10/1073741824 ))"
48    elif [ "$_b" -ge 1048576    ]; then printf '%s MiB' "$((_b/1048576))"
49    else printf '%s B' "$_b"; fi
50}
51
52_is_mounted() {  # ¿alguna partición del disco $1 aparece en MOUNTS? (heurística "es el medio live")
53    _d="$1"
54    while read -r _src _rest; do
55        case "$_src" in "/dev/$_d"|"/dev/$_d"[0-9]*|"/dev/$_d"p[0-9]*) return 0 ;; esac
56    done < "$MOUNTS" 2>/dev/null
57    return 1
58}
59
60list_disks() {  # emite por disco candidato:  name<TAB>bytes<TAB>model<TAB>mounted(0|1)
61    for _p in "$SYS_BLOCK"/*; do
62        [ -d "$_p" ] || continue
63        _n=${_p##*/}
64        case "$_n" in loop*|ram*|sr*|fd*|dm-*|md*|zram*) continue ;; esac
65        [ -r "$_p/size" ] || continue
66        _sz=$(cat "$_p/size" 2>/dev/null || echo 0); [ "$_sz" -gt 0 ] || continue
67        _model=$(cat "$_p/device/model" 2>/dev/null | tr -d '\n'); _model=$(printf '%s' "$_model" | sed 's/[[:space:]]*$//')
68        _m=0; _is_mounted "$_n" && _m=1
69        printf '%s\t%s\t%s\t%s\n' "$_n" "$((_sz*512))" "${_model:-disco}" "$_m"
70    done
71}
72
73ask() {  # ask VAR "prompt" "default"
74    if [ -n "$3" ]; then printf '%s [%s]: ' "$2" "$3"; else printf '%s: ' "$2"; fi
75    IFS= read -r _ans || _ans=""
76    [ -n "$_ans" ] || _ans="$3"
77    eval "$1=\$_ans"
78}
79
80read_secret() {  # read_secret VAR "prompt"  (sin eco si hay stty)
81    printf '%s: ' "$2"
82    bb stty -echo 2>/dev/null || true
83    IFS= read -r _sec || _sec=""
84    bb stty echo 2>/dev/null || true
85    echo
86    eval "$1=\$_sec"
87}
88
89have_cryptpw() { bb 2>&1 | grep -qw cryptpw; }
90
91# Reescribe el campo de contraseña de un usuario en $mnt/etc/shadow (o crea el fichero).
92_set_shadow() {
93    _u="$1"; _h="$2"; _f="$3/etc/shadow"
94    if [ ! -f "$_f" ]; then
95        bb mkdir -p "$3/etc"
96        printf '%s:%s:19000:0:99999:7:::\n' "$_u" "$_h" > "$_f"; bb chmod 600 "$_f"; return
97    fi
98    _t="$_f.hammer-tmp"
99    bb awk -F: -v u="$_u" -v h="$_h" 'BEGIN{OFS=":"}
100        { if ($1==u){ $2=h; seen=1 } print }
101        END{ if(!seen) print u,h,"19000","0","99999","7","","","" }' "$_f" > "$_t" && bb mv "$_t" "$_f"
102    bb chmod 600 "$_f"
103}
104
105# Aplica la config recogida al rootfs YA copiado y montado en $1 (llamada por ambas ramas tras la copia).
106apply_post_install_config() {
107    _mnt="$1"
108    bb mkdir -p "$_mnt/etc/hammer"
109    if [ -n "${CFG_HOSTNAME:-}" ]; then
110        printf '%s\n' "$CFG_HOSTNAME" > "$_mnt/etc/hostname"
111        if ! grep -q "[[:space:]]$CFG_HOSTNAME\$" "$_mnt/etc/hosts" 2>/dev/null; then
112            printf '127.0.0.1\tlocalhost %s\n::1\t\tlocalhost %s\n' "$CFG_HOSTNAME" "$CFG_HOSTNAME" >> "$_mnt/etc/hosts"
113        fi
114    fi
115    if [ -n "${CFG_ROOT_HASH:-}" ]; then _set_shadow root "$CFG_ROOT_HASH" "$_mnt"; fi
116    if [ -n "${CFG_ROOT_AUTHKEYS:-}" ]; then
117        bb mkdir -p "$_mnt/root/.ssh"; bb chmod 700 "$_mnt/root/.ssh"
118        printf '%s\n' "$CFG_ROOT_AUTHKEYS" >> "$_mnt/root/.ssh/authorized_keys"
119        bb chmod 600 "$_mnt/root/.ssh/authorized_keys"
120    fi
121    if [ -n "${CFG_TZ:-}" ] && [ -e "$_mnt/usr/share/zoneinfo/$CFG_TZ" ]; then
122        bb ln -sf "/usr/share/zoneinfo/$CFG_TZ" "$_mnt/etc/localtime"
123        printf '%s\n' "$CFG_TZ" > "$_mnt/etc/timezone"
124    fi
125    _ts=$(bb date -u +%FT%TZ 2>/dev/null || echo unknown)
126    {
127        echo "# escrito por takana-install en $_ts"
128        echo "HOSTNAME=${CFG_HOSTNAME:-}"
129        echo "TIMEZONE=${CFG_TZ:-}"
130        echo "KEYMAP=${CFG_KEYMAP:-}"     # best-effort: el producto aún no trae kbd/loadkeys
131        echo "TARGET=${DEV:-}"
132    } > "$_mnt/etc/hammer/install.conf"
133}
134
135# ---- recolección de config: interactiva (TUI) o desde env (desatendido) ----
136CFG_HOSTNAME="${TAKANA_HOSTNAME:-${HAMMER_HOSTNAME:-takana}}"
137CFG_ROOT_AUTHKEYS="${TAKANA_ROOT_AUTHKEYS:-${HAMMER_ROOT_AUTHKEYS:-}}"
138CFG_ROOT_HASH="${TAKANA_ROOT_HASH:-${HAMMER_ROOT_HASH:-}}"
139CFG_TZ="${TAKANA_TZ:-${HAMMER_TZ:-}}"
140CFG_KEYMAP="${TAKANA_KEYMAP:-${HAMMER_KEYMAP:-us}}"
141
142interactive_setup() {
143    echo
144    echo "   #  instalador de hammer"
145    echo "   ─────────────────────────"
146    echo
147    _disks=$(list_disks)
148    [ -n "$_disks" ] || { echo "No detecté discos instalables (¿el medio live es el único dispositivo?)."; exit 1; }
149    echo "Discos detectados:"
150    OLDIFS=$IFS; IFS='
151'; set --
152    for _l in $_disks; do set -- "$@" "$_l"; done
153    IFS=$OLDIFS
154    _i=1
155    for _l in "$@"; do
156        _n=$(printf '%s' "$_l" | cut -f1); _by=$(printf '%s' "$_l" | cut -f2)
157        _mo=$(printf '%s' "$_l" | cut -f3); _mm=$(printf '%s' "$_l" | cut -f4)
158        _w=""; [ "$_mm" = 1 ] && _w="   ⚠ montado (¿medio live?)"
159        printf '  %s) /dev/%-8s %10s   %s%s\n' "$_i" "$_n" "$(_human "$_by")" "$_mo" "$_w"
160        _i=$((_i+1))
161    done
162    _total=$#
163    while :; do
164        ask _sel "Disco destino (1-$_total)" ""
165        case "$_sel" in ''|*[!0-9]*) echo "  número inválido"; continue ;; esac
166        [ "$_sel" -ge 1 ] && [ "$_sel" -le "$_total" ] && break
167        echo "  fuera de rango"
168    done
169    eval "_line=\${$_sel}"
170    _name=$(printf '%s' "$_line" | cut -f1); _bytes=$(printf '%s' "$_line" | cut -f2)
171    DEV="/dev/$_name"
172    _disk_mb=$((_bytes/1048576))
173
174    # --- tamaños de partición ---
175    _esp=64; _slack=16; _avail=$((_disk_mb - _esp - _slack))
176    [ "$_avail" -ge 600 ] || { echo "Disco demasiado chico ($(_human "$_bytes")); se necesitan ~700 MiB."; exit 1; }
177    _defr=4096; [ "$_defr" -gt $((_avail*6/10)) ] && _defr=$((_avail*6/10))
178    _defs=1024; [ "$_defs" -gt $((_avail/5)) ] && _defs=$((_avail/5))
179    while :; do
180        ask ROOT_MB  "Tamaño de / en MB"      "$_defr"
181        ask STORE_MB "Tamaño de /store en MB" "$_defs"
182        case "$ROOT_MB$STORE_MB" in *[!0-9]*) echo "  usá sólo números"; continue ;; esac
183        if [ $((ROOT_MB + STORE_MB + _esp + _slack)) -le "$_disk_mb" ]; then break; fi
184        echo "  no entra en el disco ($_disk_mb MiB) — / + /store + ESP deben sumar menos"
185    done
186
187    # --- identidad ---
188    ask CFG_HOSTNAME "Hostname" "${CFG_HOSTNAME:-hammer}"
189    echo "Credencial de root:"
190    echo "  1) contraseña"
191    echo "  2) clave SSH (authorized_keys)"
192    echo "  3) omitir"
193    ask _cred "Opción" "1"
194    case "$_cred" in
195        1)  if have_cryptpw; then
196                while :; do
197                    read_secret _pw1 "Contraseña de root"
198                    read_secret _pw2 "Repetir"
199                    [ "$_pw1" = "$_pw2" ] && [ -n "$_pw1" ] && break
200                    echo "  no coinciden (o vacía) — reintentá"
201                done
202                CFG_ROOT_HASH=$(printf '%s' "$_pw1" | bb cryptpw -m sha512 2>/dev/null || true)
203                [ -n "$CFG_ROOT_HASH" ] || echo "  ⚠ no pude generar el hash; root queda como está"
204            else
205                echo "  (cryptpw no disponible en este busybox — usá la opción de clave SSH)"
206                ask CFG_ROOT_AUTHKEYS "Pegá una línea authorized_keys" ""
207            fi ;;
208        2)  ask CFG_ROOT_AUTHKEYS "Pegá una línea authorized_keys (o ruta a un fichero .pub)" ""
209            if [ -n "$CFG_ROOT_AUTHKEYS" ] && [ -f "$CFG_ROOT_AUTHKEYS" ]; then
210                CFG_ROOT_AUTHKEYS=$(cat "$CFG_ROOT_AUTHKEYS")
211            fi ;;
212        *)  echo "  (root sin credencial nueva)" ;;
213    esac
214
215    # --- locale (best-effort) ---
216    _zi="${ZONEINFO:-/usr/share/zoneinfo}"
217    if [ -d "$_zi" ]; then
218        ask CFG_TZ "Zona horaria (ej. America/La_Paz; vacío = UTC)" "${CFG_TZ:-}"
219        if [ -n "$CFG_TZ" ] && [ ! -e "$_zi/$CFG_TZ" ]; then
220            echo "  ⚠ zona desconocida, se ignora"; CFG_TZ=""
221        fi
222    else
223        echo "(tzdata no instalado — la zona horaria se omite)"; CFG_TZ=""
224    fi
225    ask CFG_KEYMAP "Layout de teclado" "${CFG_KEYMAP:-us}"
226
227    # --- resumen + confirmación fuerte ---
228    _cd="sin cambios"; [ -n "$CFG_ROOT_HASH" ] && _cd="contraseña"; [ -n "$CFG_ROOT_AUTHKEYS" ] && _cd="clave SSH"
229    echo
230    echo "Resumen de instalación:"
231    echo "  destino : $DEV   ($(_human "$_bytes"))"
232    echo "  / = ${ROOT_MB} MiB    /store = ${STORE_MB} MiB    /var/lib/hammer = resto"
233    echo "  hostname: $CFG_HOSTNAME"
234    echo "  root    : $_cd"
235    echo "  zona    : ${CFG_TZ:-UTC}    teclado: $CFG_KEYMAP"
236    echo
237    echo "  ⚠  ESTO BORRA TODO EN $DEV."
238    ask _ok "Escribí el nombre del disco ($DEV) para confirmar, o Enter para cancelar" ""
239    [ "$_ok" = "$DEV" ] || { echo "Cancelado — no se tocó ningún disco."; exit 1; }
240}
241
242# --- resolución del modo: interactivo (sin device + TTY) vs desatendido (device dado) ---
243if [ -z "$DEV" ]; then
244    if [ -t 0 ] || [ "${TAKANA_INSTALL_INTERACTIVE:-${HAMMER_INSTALL_INTERACTIVE:-}}" = 1 ]; then
245        interactive_setup
246    else
247        echo "uso: takana-install <device> [ROOT_MB] [STORE_MB]   (o sin args con un TTY para el modo interactivo)" >&2
248        exit 2
249    fi
250fi
251ROOT_MB="${ROOT_MB:-1500}"
252STORE_MB="${STORE_MB:-400}"
253# En modo desatendido con contraseña por env, derivar el hash acá (interactivo ya lo hizo).
254if [ -z "$CFG_ROOT_HASH" ] && [ -n "${TAKANA_ROOT_PW:-${HAMMER_ROOT_PW:-}}" ] && have_cryptpw; then
255    CFG_ROOT_HASH=$(printf '%s' "${TAKANA_ROOT_PW:-$HAMMER_ROOT_PW}" | bb cryptpw -m sha512 2>/dev/null || true)
256fi
257
258# --- gancho de prueba: valida TUI + config sin tocar disco (TAKANA_INSTALL_DRYRUN=1) ---
259if [ "${TAKANA_INSTALL_DRYRUN:-${HAMMER_INSTALL_DRYRUN:-}}" = 1 ]; then
260    echo "== DRYRUN: plan de instalación =="
261    echo "  DEV=$DEV  ROOT_MB=$ROOT_MB  STORE_MB=$STORE_MB"
262    echo "  HOSTNAME=$CFG_HOSTNAME  TZ=${CFG_TZ:-UTC}  KEYMAP=$CFG_KEYMAP"
263    echo "  ROOT_HASH=$([ -n "$CFG_ROOT_HASH" ] && echo set || echo -)  AUTHKEYS=$([ -n "$CFG_ROOT_AUTHKEYS" ] && echo set || echo -)"
264    _testroot="${TAKANA_INSTALL_TESTROOT:-${HAMMER_INSTALL_TESTROOT:-}}"
265    if [ -n "$_testroot" ]; then
266        apply_post_install_config "$_testroot"
267        echo "  config aplicada a $_testroot"
268    fi
269    exit 0
270fi
271
272[ -b "$DEV" ] || { echo "takana-install: $DEV no es un block device" >&2; exit 1; }
273[ -d "$PAYLOAD" ] || { echo "takana-install: falta el payload $PAYLOAD (¿ISO sin INSTALLER=1?)" >&2; exit 1; }
274
275# --- Detección de firmware: UEFI ⇒ rama EFI-stub SOBERANA (ADR 0010 paso 5); BIOS ⇒ MBR+GRUB (abajo) ---
276# La rama EFI usa una ESP tipo 0xEF en tabla MBR (UEFI arranca \EFI\BOOT\BOOTX64.EFI de una ESP MBR igual
277# que de GPT) ⇒ alcanza con busybox fdisk/mkfs.vfat/mount, sin GPT-tool ni mtools. El bzImage metal ES el
278# binario EFI (EFI-stub, cmdline horneada carga el initrd); un initramfs mínimo pivota por LABEL. Mismos
279# artefactos que scripts/install-image-efi.sh (validado en OVMF), armados desde dentro del live.
280if [ -d /sys/firmware/efi ]; then
281    [ -r "$PAYLOAD/kernel/bzImage-efi" ] || { echo "takana-install: live en UEFI pero falta $PAYLOAD/kernel/bzImage-efi (ISO sin kernel metal)" >&2; exit 1; }
282    ESP_MB="${ESP_MB:-64}"
283    echo "==> takana-install (UEFI): EFI-stub soberano en $DEV (ESP ${ESP_MB}M, root ${ROOT_MB}M, store ${STORE_MB}M, estado=resto)"
284    echo "    ¡esto BORRA $DEV!"
285
286    # MBR, 4 primarias: p1=ESP(0xEF) p2=root p3=store p4=estado. Sectores explícitos (como la rama BIOS).
287    SPM=2048
288    P1S=2048;            P1E=$(( P1S + ESP_MB  * SPM - 1 ))
289    P2S=$(( P1E + 1 ));  P2E=$(( P2S + ROOT_MB * SPM - 1 ))
290    P3S=$(( P2E + 1 ));  P3E=$(( P3S + STORE_MB* SPM - 1 ))
291    P4S=$(( P3E + 1 ))   # estado = resto del disco
292    echo "==> particionando $DEV (MBR: ESP ${P1S}-${P1E} tipo ef, root ${P2S}-${P2E}, store ${P3S}-${P3E}, estado ${P4S}-fin)"
293    "$BB" fdisk "$DEV" >/dev/null 2>&1 <<FDISK || true
294o
295n
296p
2971
298$P1S
299$P1E
300n
301p
3022
303$P2S
304$P2E
305n
306p
3073
308$P3S
309$P3E
310n
311p
3124
313$P4S
314
315t
3161
317ef
318a
3191
320w
321FDISK
322    "$BB" partprobe "$DEV" 2>/dev/null || true
323    "$BB" sync; sleep 1
324    P1="${DEV}1"; P2="${DEV}2"; P3="${DEV}3"; P4="${DEV}4"
325    for p in "$P1" "$P2" "$P3" "$P4"; do
326        [ -b "$p" ] || { echo "takana-install: no apareció la partición $p tras particionar" >&2; exit 1; }
327    done
328
329    echo "==> formateando (ESP FAT32 + 3 ext2 etiquetadas para el pivote por LABEL)"
330    "$BB" mkfs.vfat -F 32 -n HAMMER "$P1" >/dev/null 2>&1
331    "$BB" mke2fs -F -L hammer-root  "$P2" >/dev/null 2>&1
332    "$BB" mke2fs -F -L hammer-store "$P3" >/dev/null 2>&1
333    "$BB" mke2fs -F -L hammer-state "$P4" >/dev/null 2>&1
334
335    # initramfs de pivote (busybox estático del live + /init: findfs LABEL=takana-root → switch_root).
336    echo "==> armando el initramfs de pivote (busybox + /init switch_root a hammer-root)"
337    IRD_TREE=/run/hammer-efi-ird
338    "$BB" rm -rf "$IRD_TREE"
339    "$BB" mkdir -p "$IRD_TREE/bin" "$IRD_TREE/dev" "$IRD_TREE/proc" "$IRD_TREE/sys" "$IRD_TREE/newroot"
340    cp "$BB" "$IRD_TREE/bin/busybox"; "$BB" chmod 0755 "$IRD_TREE/bin/busybox"
341    for a in sh mount umount findfs switch_root mkdir echo sleep; do "$BB" ln -sf busybox "$IRD_TREE/bin/$a"; done
342    cat > "$IRD_TREE/init" <<'INIT'
343#!/bin/busybox sh
344export PATH=/bin
345mount -t proc     proc /proc 2>/dev/null || true
346mount -t sysfs    sys  /sys  2>/dev/null || true
347mount -t devtmpfs dev  /dev  2>/dev/null || true
348log() { echo "$*"; echo "$*" > /dev/ttyS0 2>/dev/null || true; }
349log "HAMMER-EFI: initramfs de pivote — resolviendo hammer-root por LABEL"
350ROOTDEV=""
351for _try in 1 2 3 4 5; do
352    ROOTDEV="$(findfs LABEL=hammer-root 2>/dev/null || true)"
353    [ -n "$ROOTDEV" ] && break
354    log "HAMMER-EFI: hammer-root aún no visible, reintento $_try…"; sleep 1
355done
356[ -n "$ROOTDEV" ] || { log "HAMMER-EFI-FALLO: no encuentro LABEL=hammer-root"; exec sh; }
357log "HAMMER-EFI: hammer-root = $ROOTDEV → montando en /newroot"
358mount -t ext4 "$ROOTDEV" /newroot || { log "HAMMER-EFI-FALLO: no pude montar $ROOTDEV"; exec sh; }
359STOREDEV="$(findfs LABEL=hammer-store 2>/dev/null || true)"
360STATEDEV="$(findfs LABEL=hammer-state 2>/dev/null || true)"
361[ -n "$STOREDEV" ] && mount -t ext4 "$STOREDEV" /newroot/store          2>/dev/null || true
362[ -n "$STATEDEV" ] && mount -t ext4 "$STATEDEV" /newroot/var/lib/hammer  2>/dev/null || true
363log "HAMMER-EFI-DISK-PIVOT-OK: switch_root → /sbin/init"
364exec switch_root /newroot /sbin/init
365INIT
366    "$BB" chmod +x "$IRD_TREE/init"
367    ( cd "$IRD_TREE" && "$BB" find . | "$BB" cpio -o -H newc 2>/dev/null | "$BB" gzip -1 ) > /run/hammer-efi-ird.cpio.gz
368
369    # Poblar la ESP (FAT32, montable por el live): BOOTX64.EFI = bzImage metal + el initramfs de pivote.
370    echo "==> poblando la ESP (\\EFI\\BOOT\\BOOTX64.EFI = kernel metal + \\initramfs.cpio.gz)"
371    ESPMNT=/run/hammer-esp
372    "$BB" mkdir -p "$ESPMNT"
373    "$BB" mount -t vfat "$P1" "$ESPMNT"
374    "$BB" mkdir -p "$ESPMNT/EFI/BOOT"
375    cp "$PAYLOAD/kernel/bzImage-efi" "$ESPMNT/EFI/BOOT/BOOTX64.EFI"
376    cp /run/hammer-efi-ird.cpio.gz   "$ESPMNT/initramfs.cpio.gz"
377    "$BB" sync; "$BB" umount "$ESPMNT"
378
379    # Poblar la root (copia del live) — sin wrapper que monte particiones (el pivote ya montó store/estado).
380    echo "==> copiando la raíz del live → $P2 (excluye virtuales/efímeros, /store, /var/lib/hammer, payload)"
381    MNT=/run/takana-install
382    "$BB" mkdir -p "$MNT"
383    "$BB" mount -t ext4 "$P2" "$MNT"
384    for entry in /* /.[!.]*; do
385        [ -e "$entry" ] || continue
386        name="${entry##*/}"
387        case "$name" in
388            proc|sys|dev|run|tmp|store|init) continue ;;
389            *) cp -a "$entry" "$MNT/" 2>/dev/null || true ;;
390        esac
391    done
392    "$BB" rm -rf "$MNT/var/lib/hammer" 2>/dev/null || true
393    "$BB" rm -rf "$MNT/usr/lib/hammer/install" 2>/dev/null || true
394    "$BB" mkdir -p "$MNT/store" "$MNT/var/lib/hammer" "$MNT/proc" "$MNT/sys" "$MNT/dev" "$MNT/run" "$MNT/tmp"
395    # /sbin/init: wrapper que auto-sana un upgrade interrumpido y arranca arje-zero (el pivote ya montó
396    # store/estado por LABEL, así que acá NO hace falta montar nada — sólo hammer-recover + exec).
397    if [ -x "$PAYLOAD/hammer-recover" ]; then
398        "$BB" mkdir -p "$MNT/usr/sbin"
399        cp "$PAYLOAD/hammer-recover" "$MNT/usr/sbin/hammer-recover"; "$BB" chmod 0755 "$MNT/usr/sbin/hammer-recover"
400    fi
401    # CLI takana (static musl) para el menú de arranque por grafo (ADR 0010): lo copia al disco desde el
402    # payload; el wrapper lo invoca como `takana boot menu`.
403    if [ -x "$PAYLOAD/hammer" ]; then
404        cp "$PAYLOAD/hammer" "$MNT/usr/bin/hammer"; "$BB" chmod 0755 "$MNT/usr/bin/hammer"
405    fi
406    "$BB" rm -f "$MNT/sbin/init"
407    cat > "$MNT/sbin/init" <<'INIT'
408#!/bin/sh
409# Wrapper PID1 (rama UEFI): el initramfs de pivote ya montó / /store /var/lib/hammer por LABEL antes del
410# switch_root; sólo auto-sanamos un upgrade interrumpido y arrancamos el init real. El marcador a
411# /dev/ttyS0 sobrevive `quiet` (que suprime el printk kernel-side) ⇒ prueba serie de que llegó a PID1.
412# busybox switch_root NO mueve /dev ⇒ montamos devtmpfs antes (si no, /dev/ttyS0 aún no existe).
413/bin/busybox mount -t devtmpfs dev /dev 2>/dev/null || true
414echo "HAMMER-EFI-INIT-OK: arje-zero PID1" > /dev/ttyS0 2>/dev/null || true
415[ -x /usr/sbin/hammer-recover ] && /usr/sbin/hammer-recover || true
416# Menú de arranque por grafo (ADR 0010): emite /run/hammer/boot-graph.json y, si hay compositor (mirada),
417# lo pinta sobre KMS. Graceful (sin compositor sigue) y al serial (no pinta tty0 ⇒ cero-parpadeo).
418[ -x /usr/bin/hammer ] && /usr/bin/hammer boot menu > /dev/ttyS0 2>&1 || true
419exec /usr/bin/arje-zero
420INIT
421    "$BB" chmod +x "$MNT/sbin/init"
422    # config del usuario (hostname / root / zona / teclado) recogida al inicio
423    apply_post_install_config "$MNT"
424    "$BB" sync
425    "$BB" umount "$MNT"
426
427    echo "✓ takana-install (UEFI): $DEV instalado con EFI-stub SOBERANO (sin GRUB ni systemd-boot). Reiniciá sin el medio live."
428    exit 0
429fi
430
431# ===================== rama BIOS (MBR + GRUB) — el firmware NO es UEFI ==============================
432[ -r "$PAYLOAD/grub/boot.img" ] && [ -r "$PAYLOAD/grub/core.img" ] || { echo "takana-install: payload GRUB incompleto" >&2; exit 1; }
433[ -r "$PAYLOAD/kernel/bzImage" ] || { echo "takana-install: falta el kernel en el payload" >&2; exit 1; }
434
435echo "==> takana-install: instalando el sistema live en $DEV (root ${ROOT_MB}M, store ${STORE_MB}M, estado=resto)"
436echo "    ¡esto BORRA $DEV!"
437
438# --- particionar MBR con busybox fdisk (3 primarias; p1 bootable) ---
439# Pasamos sectores de inicio/fin EXPLÍCITOS para las tres: busybox fdisk, al pedir el inicio por
440# defecto, ofrece el sector LIBRE MÁS BAJO (= el hueco 63..2047 que dejamos antes de p1) ⇒ con <enter>
441# colocaría p2 en ese hueco. Por eso computamos los sectores y los tecleamos.
442#   p1 ARRANCA EN 2048 (1 MiB) A PROPÓSITO: deja un hueco post-MBR de 2047 sectores para el core.img de
443#   GRUB (~281 sectores). El default CHS de busybox (sector 63 ⇒ hueco de 62) lo DESBORDA, pisando el
444#   filesystem de p1 ⇒ GRUB cae a `grub>`.
445SPM=2048
446P1S=2048;                  P1E=$(( P1S + ROOT_MB  * SPM - 1 ))
447P2S=$(( P1E + 1 ));        P2E=$(( P2S + STORE_MB * SPM - 1 ))
448P3S=$(( P2E + 1 ))         # p3 toma hasta el final del disco (último sector = default)
449echo "==> particionando $DEV (MBR: p1 ${P1S}-${P1E}, p2 ${P2S}-${P2E}, p3 ${P3S}-fin)"
450"$BB" fdisk "$DEV" >/dev/null 2>&1 <<FDISK || true
451o
452n
453p
4541
455$P1S
456$P1E
457n
458p
4592
460$P2S
461$P2E
462n
463p
4643
465$P3S
466
467a
4681
469w
470FDISK
471"$BB" partprobe "$DEV" 2>/dev/null || true
472"$BB" sync; sleep 1
473
474P1="${DEV}1"; P2="${DEV}2"; P3="${DEV}3"
475for p in "$P1" "$P2" "$P3"; do
476    [ -b "$p" ] || { echo "takana-install: no apareció la partición $p tras particionar" >&2; exit 1; }
477done
478
479# --- formatear (busybox mke2fs = ext2; el driver ext4 del kernel lo monta) ---
480echo "==> formateando particiones (ext2, montables como ext4)"
481"$BB" mke2fs -F -L hammer-root  "$P1" >/dev/null 2>&1
482"$BB" mke2fs -F -L hammer-store "$P2" >/dev/null 2>&1
483"$BB" mke2fs -F -L hammer-state "$P3" >/dev/null 2>&1
484
485# --- copiar la raíz del live a la partición root, excluyendo virtuales + el payload ---
486MNT=/run/takana-install
487"$BB" mkdir -p "$MNT"
488"$BB" mount -t ext4 "$P1" "$MNT"
489echo "==> copiando la raíz del live → $P1 (excluye virtuales/efímeros, /store, /var/lib/hammer y el payload)"
490# Enumeramos TODO el top-level de / y copiamos salvo lo virtual/efímero — así no se nos escapa ningún
491# dir del producto (p.ej. /ente con la seed.card, /linuxrc). uutils cp -a preserva modos/symlinks.
492for entry in /* /.[!.]*; do
493    [ -e "$entry" ] || continue
494    name="${entry##*/}"
495    case "$name" in
496        proc|sys|dev|run|tmp|store|init) continue ;;  # virtuales/efímeros + el /init marcador del live
497        *) cp -a "$entry" "$MNT/" 2>/dev/null || true ;;
498    esac
499done
500# /var sin /var/lib/hammer (estado) — se recrea vacío como mountpoint.
501"$BB" rm -rf "$MNT/var/lib/hammer" 2>/dev/null || true
502# Quitar el payload del disco instalado (sólo sirve en el live) y recrear mountpoints.
503"$BB" rm -rf "$MNT/usr/lib/hammer/install" 2>/dev/null || true
504"$BB" mkdir -p "$MNT/store" "$MNT/var/lib/hammer" "$MNT/proc" "$MNT/sys" "$MNT/dev" "$MNT/run" "$MNT/tmp" "$MNT/boot/grub/i386-pc"
505
506# --- /boot: kernel + módulos GRUB + grub.cfg, y wrapper /sbin/init (monta las particiones dedicadas) ---
507echo "==> poblando /boot (kernel + GRUB) y wrapper /sbin/init"
508cp "$PAYLOAD/kernel/bzImage" "$MNT/boot/bzImage"; "$BB" chmod 0644 "$MNT/boot/bzImage"
509cp "$PAYLOAD"/grub/i386-pc/*.mod "$MNT/boot/grub/i386-pc/" 2>/dev/null || true
510cp "$PAYLOAD"/grub/i386-pc/*.lst "$MNT/boot/grub/i386-pc/" 2>/dev/null || true
511ROOTDEV="${P1##*/}"   # p.ej. vda1 cuando el disco instalado sea el único
512cat > "$MNT/boot/grub/grub.cfg" <<CFG
513set timeout=2
514set default=0
515serial --unit=0 --speed=115200
516terminal_input serial console
517terminal_output serial console
518insmod part_msdos
519insmod ext2
520menuentry "hammer" {
521    linux /boot/bzImage console=ttyS0 root=/dev/vda1 rw rdinit=/sbin/init
522}
523CFG
524# hammer-recover: auto-sana un upgrade interrumpido al arranque (E4 #4b). Lo dejamos en /usr/sbin del
525# disco; el wrapper lo corre tras montar /store y /var/lib/hammer (que necesita) y antes de incarnar.
526if [ -x "$PAYLOAD/hammer-recover" ]; then
527    "$BB" mkdir -p "$MNT/usr/sbin"
528    cp "$PAYLOAD/hammer-recover" "$MNT/usr/sbin/hammer-recover"; "$BB" chmod 0755 "$MNT/usr/sbin/hammer-recover"
529fi
530"$BB" rm -f "$MNT/sbin/init"
531cat > "$MNT/sbin/init" <<'INIT'
532#!/bin/sh
533# Wrapper PID1: el kernel monta la partición root; montamos las dedicadas, auto-sanamos un upgrade
534# interrumpido (si lo hay) y arrancamos el init real.
535/bin/busybox mount -t ext4 /dev/vda2 /store          || echo "init: no pude montar /store (/dev/vda2)"
536/bin/busybox mount -t ext4 /dev/vda3 /var/lib/hammer  || echo "init: no pude montar /var/lib/hammer (/dev/vda3)"
537[ -x /usr/sbin/hammer-recover ] && /usr/sbin/hammer-recover || true
538exec /usr/bin/arje-zero
539INIT
540"$BB" chmod +x "$MNT/sbin/init"
541# config del usuario (hostname / root / zona / teclado) recogida al inicio
542apply_post_install_config "$MNT"
543"$BB" sync
544"$BB" umount "$MNT"
545
546# --- instalar GRUB: boot.img→MBR (440 B, sin pisar la tabla de particiones) + core.img→hueco post-MBR.
547#     Con install contiguo MBR los punteros por defecto de GRUB (kernel_sector=1, blocklist=2) ya valen
548#     ⇒ NO hace falta el parcheo binario que sí pide el caso GPT de install-image.sh.
549echo "==> instalando GRUB (boot.img→MBR + core.img→hueco post-MBR)"
550"$BB" dd if="$PAYLOAD/grub/boot.img"  of="$DEV" bs=1 count=440 conv=notrunc 2>/dev/null
551"$BB" dd if="$PAYLOAD/grub/core.img"  of="$DEV" bs=512 seek=1 conv=notrunc 2>/dev/null
552"$BB" sync
553
554echo "✓ takana-install: $DEV instalado. Reiniciá sin el medio live para arrancar del disco."