tawasuyu/arje

1//! Construcción de la Tarjeta Semilla.
2//!
3//! Tres caminos:
4//!   1. `--restore <path>`: leer `FractalSnapshot` y reconstruir Semilla
5//!      con seed_id preservado + entes anteriores como genesis.
6//!   2. `seed.card` en disco: deserialize directo (prod o dev).
7//!   3. Fallback dev: sintetizar Semilla + 6 genesis Entes que ejercitan
8//!      todas las capacidades del fractal.
9
10use anyhow::Context;
11use ente_card::{
12    Capability, CardError, CgroupSpec, EntityCard, NamespaceSet, Payload,
13    ResourceLimits, SomaSpec, Supervision, CARD_SCHEMA_VERSION,
14};
15use std::collections::BTreeSet;
16use std::path::{Path, PathBuf};
17use std::time::Duration;
18use tracing::{info, warn};
19use ulid::Ulid;
20
21const SEED_PATH_PROD: &str = "/ente/seed.card";
22const SEED_PATH_DEV: &str = "seed.card";
23
24pub fn load(dev_mode: bool, restore: Option<&Path>) -> anyhow::Result<EntityCard> {
25    let card = if let Some(path) = restore {
26        load_from_snapshot(path)?
27    } else {
28        load_or_synthesize(dev_mode)?
29    };
30    card.validate()
31        .map_err(|e: CardError| anyhow::anyhow!("semilla inválida: {e}"))?;
32    Ok(card)
33}
34
35fn load_from_snapshot(path: &Path) -> anyhow::Result<EntityCard> {
36    let snap = ente_snapshot::FractalSnapshot::read(path)
37        .with_context(|| format!("read snapshot {}", path.display()))?;
38    info!(
39        path = %path.display(),
40        seed_id = %snap.seed_id,
41        entes = snap.entes.len(),
42        timestamp_ms = snap.timestamp_ms,
43        "snapshot cargado, restaurando fractal"
44    );
45    // Reconstruimos la Semilla con su Ulid original. Las Cards persistidas
46    // van a `genesis` con sus Ulids preservados — son las mismas identidades
47    // que vivieron antes del checkpoint.
48    let mut provides = BTreeSet::new();
49    provides.insert(Capability::Spawn);
50    provides.insert(Capability::Journal);
51    Ok(EntityCard {
52        schema_version: CARD_SCHEMA_VERSION,
53        id: snap.seed_id,
54        lineage: None,
55        label: snap.seed_label,
56        provides,
57        requires: BTreeSet::new(),
58        soma: SomaSpec::default(),
59        payload: Payload::Virtual,
60        supervision: Supervision::OneShot,
61        genesis: snap.entes,
62    })
63}
64
65fn load_or_synthesize(dev_mode: bool) -> anyhow::Result<EntityCard> {
66    // Buscamos primero `.k` (KCL canónico, validado por su schema), luego
67    // `.json` para compatibilidad. La puerta genética se cruza vía
68    // `ente_brain::load_card_file` que pasa por `validate()` extendido.
69    let candidates: &[&str] = if dev_mode {
70        &["seed.card.k", SEED_PATH_DEV]
71    } else {
72        &["/ente/seed.card.k", SEED_PATH_PROD]
73    };
74    for cand in candidates {
75        let path = PathBuf::from(cand);
76        if !path.exists() { continue; }
77        let card = ente_brain::load_card_file(&path)
78            .with_context(|| format!("load {}", path.display()))?;
79        info!(path = %path.display(), "Tarjeta Semilla cargada y validada");
80        return Ok(card);
81    }
82    if dev_mode {
83        info!("sin seed.card — sintetizando semilla mínima (dev)");
84        return Ok(synthesize_dev_seed());
85    }
86    anyhow::bail!("seed.card no encontrada en /ente/seed.card[.k]")
87}
88
89fn synthesize_dev_seed() -> EntityCard {
90    let mut provides = BTreeSet::new();
91    provides.insert(Capability::Spawn);
92    provides.insert(Capability::Journal);
93
94    // Pre-registramos el módulo Wasm demo en el CAS y obtenemos su SHA real.
95    // Si el CAS no es escribible (raro en dev) caemos a un SHA cero — la
96    // resolución fallará y el Wasm no encarnará, pero el resto queda intacto.
97    let demo_wasm_sha = match ente_wasm::demo_module_bytes()
98        .and_then(|b| ente_cas::store(&b))
99    {
100        Ok(sha) => sha,
101        Err(e) => {
102            warn!(?e, "CAS no disponible — demo-wasm no encarnará");
103            [0u8; 32]
104        }
105    };
106
107    let mut genesis = Vec::new();
108    genesis.push(make_card("demo-sleep", Payload::Native {
109        exec: "/bin/sleep".into(), argv: vec!["1".into()], envp: vec![],
110    }, Supervision::OneShot));
111
112    genesis.push(make_card("demo-persist", Payload::Native {
113        exec: "/bin/sleep".into(), argv: vec!["60".into()], envp: vec![],
114    }, restart_supervision()));
115
116    // Card namespaced: padre escribe uid_map, hijo cat /proc/self/uid_map.
117    let mut ns_card = make_card("demo-userns", Payload::Native {
118        exec: "/bin/cat".into(),
119        argv: vec!["/proc/self/uid_map".into()],
120        envp: vec![],
121    }, Supervision::OneShot);
122    ns_card.soma = SomaSpec {
123        namespaces: NamespaceSet { user: true, ..Default::default() },
124        ..Default::default()
125    };
126    genesis.push(ns_card);
127
128    genesis.push(make_card("demo-wasm", Payload::Wasm {
129        module_sha256: demo_wasm_sha,
130        entry: "_start".into(),
131    }, Supervision::OneShot));
132
133    if let Some(card) = optional_native_card(
134        "demo-echo", "target/debug/ente-echo",
135        [ente_echo::echo_capability()].into_iter().collect(),
136        restart_supervision(),
137    ) {
138        genesis.push(card);
139    }
140
141    if let Some(card) = optional_native_card(
142        "compat-logind", "target/debug/ente-logind-compat",
143        [Capability::LegacyLogind].into_iter().collect(),
144        restart_supervision(),
145    ) {
146        genesis.push(card);
147    }
148
149    // Constelación de shims D-Bus que reemplazan systemd: cada uno provee
150    // un nombre `org.freedesktop.X1` que GNOME/KDE consultan al boot.
151    for (label, bin) in &[
152        ("compat-hostnamed", "target/debug/ente-hostnamed-compat"),
153        ("compat-timedated", "target/debug/ente-timedated-compat"),
154        ("compat-localed",   "target/debug/ente-localed-compat"),
155        ("compat-journald",  "target/debug/ente-journald-compat"),
156        ("compat-resolved",  "target/debug/ente-resolved-compat"),
157        ("compat-polkit",    "target/debug/ente-polkit-compat"),
158    ] {
159        if let Some(card) = optional_native_card(
160            label, bin,
161            std::collections::BTreeSet::new(),
162            restart_supervision(),
163        ) {
164            genesis.push(card);
165        }
166    }
167
168    EntityCard {
169        schema_version: CARD_SCHEMA_VERSION,
170        id: Ulid::new(),
171        lineage: None,
172        label: "ente-zero-dev".into(),
173        provides,
174        requires: BTreeSet::new(),
175        soma: SomaSpec {
176            namespaces: NamespaceSet::default(),
177            rlimits: ResourceLimits::default(),
178            cgroup: CgroupSpec {
179                path: "ente.slice/zero".into(),
180                cpu_weight: None,
181                io_weight: None,
182            },
183            cpu_affinity: None,
184        },
185        payload: Payload::Virtual,
186        supervision: Supervision::OneShot,
187        genesis,
188    }
189}
190
191fn make_card(label: &str, payload: Payload, supervision: Supervision) -> EntityCard {
192    EntityCard {
193        schema_version: CARD_SCHEMA_VERSION,
194        id: Ulid::new(),
195        lineage: None,
196        label: label.into(),
197        provides: BTreeSet::new(),
198        requires: BTreeSet::new(),
199        soma: SomaSpec::default(),
200        payload,
201        supervision,
202        genesis: vec![],
203    }
204}
205
206fn optional_native_card(
207    label: &str,
208    bin_path: &str,
209    provides: BTreeSet<Capability>,
210    supervision: Supervision,
211) -> Option<EntityCard> {
212    let path = Path::new(bin_path);
213    if !path.exists() {
214        return None;
215    }
216    Some(EntityCard {
217        schema_version: CARD_SCHEMA_VERSION,
218        id: Ulid::new(),
219        lineage: None,
220        label: label.into(),
221        provides,
222        requires: BTreeSet::new(),
223        soma: SomaSpec::default(),
224        payload: Payload::Native {
225            exec: path.to_string_lossy().into_owned(),
226            argv: vec![],
227            envp: vec![],
228        },
229        supervision,
230        genesis: vec![],
231    })
232}
233
234fn restart_supervision() -> Supervision {
235    Supervision::Restart {
236        initial: Duration::from_millis(100),
237        max: Duration::from_secs(30),
238    }
239}