chore: monorepo inicial con arje + minga + yahweh absorbidos

Workspace en 4 ejes (core/modules/apps/shared): - core/: 24 crates de arje (Init systemd-compatible: ente-card, ente-zero, ente-kernel, ente-bus, ente-cas, ente-soma, ente-wasm, ente-snapshot, ente-brain, ente-echo, ente-policy-provider, + 12 crates *-compat) - modules/semantic_dht/: 5 crates de minga (minga-core con AST/CAS/MST, minga-p2p con libp2p Kad, minga-store, minga-vfs, minga-cli) - modules/ui_engine/: 11 crates de yahweh (libs/{core,theme,bus,providers}, widgets/{tree,splitter,tabs,tiled,container_core,text_input}) - apps/: 5 crates de yahweh (file_explorer, database_explorer, text_viewer, image_viewer, yahweh-shell) - shared_wit/protocol.wit: handshake/lifecycle inicial Cargo.toml unificado: thiserror bumped a 2 (transparente para arje), tokio "full", paths intra-workspace de yahweh redirigidos a su nueva ubicación. cargo check --workspace: 0 errores, 17 warnings (dead code preexistente). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-05-08 04:45:44 +00:00
commit 53dbdf0f1d
176 changed files with 34845 additions and 0 deletions
@@ -0,0 +1,280 @@
+//! ente-systemd1-compat: shim de `org.freedesktop.systemd1.Manager`.
+//!
+//! Centro de control que `systemctl` consulta. Sin esto, `systemctl list-units`
+//! falla con `Failed to connect to bus` aunque el sistema funcione.
+//!
+//! Mapeo: cada Ente vivo del fractal aparece como una "unit" cuyo nombre es
+//! `<label>.service`. Estados:
+//!   - `loaded` siempre (porque está en el grafo)
+//!   - `active` si tiene PID o es Wasm corriendo, `inactive` si está virtual
+//!   - sub_state: `running`/`exited`/`virtual`
+//!
+//! Métodos cubiertos del subset que `systemctl` típicamente llama al boot:
+//!   - ListUnits (basis de `systemctl list-units`)
+//!   - GetUnit / GetUnitByPID (object-path lookup; no servimos métodos del unit)
+//!   - StartUnit / StopUnit / RestartUnit (forwardea al bus interno)
+//!   - Subscribe / Unsubscribe (no-op)
+//!   - Reload (no-op — Cards inmutables)
+//!   - ListUnitFiles (vacío)
+//!   - GetVersion / Environment / Architecture (properties)
+
+use ente_bus::{BusClient, BusRequest, BusResponse};
+use ente_card::Capability;
+use std::collections::HashMap;
+use tokio::signal::unix::{signal, SignalKind};
+use tracing::{info, warn};
+use tracing_subscriber::EnvFilter;
+use zbus::{fdo, interface, zvariant::{ObjectPath, OwnedObjectPath, OwnedValue}};
+
+const BUS_NAME: &str = "org.freedesktop.systemd1";
+const OBJ_PATH: &str = "/org/freedesktop/systemd1";
+
+#[tokio::main(flavor = "current_thread")]
+async fn main() -> anyhow::Result<()> {
+    init_tracing();
+    info!("ente-systemd1-compat: arrancando");
+    announce_to_fractal().await;
+
+    let manager = SystemdManager;
+    let conn_result = zbus::connection::Builder::system()
+        .and_then(|b| b.name(BUS_NAME))
+        .and_then(|b| b.serve_at(OBJ_PATH, manager));
+    match conn_result {
+        Ok(builder) => match builder.build().await {
+            Ok(_conn) => {
+                info!(name = BUS_NAME, "name acquired, sirviendo systemctl");
+                wait_for_term().await
+            }
+            Err(e) => { warn!(?e, "build conn falló — modo idle"); wait_for_term().await }
+        },
+        Err(e) => { warn!(?e, "builder D-Bus falló — modo idle"); wait_for_term().await }
+    }
+}
+
+struct SystemdManager;
+
+/// Wire format de un unit en `ListUnits`:
+/// (name, description, load_state, active_state, sub_state, followed,
+///  unit_path, job_id, job_type, job_path)
+type UnitInfo = (
+    String, String, String, String, String, String,
+    OwnedObjectPath, u32, String, OwnedObjectPath,
+);
+
+#[interface(name = "org.freedesktop.systemd1.Manager")]
+impl SystemdManager {
+    async fn list_units(&self) -> fdo::Result<Vec<UnitInfo>> {
+        let entes = match query_list_entes().await {
+            Some(es) => es,
+            None => return Ok(vec![]),
+        };
+        let unit_path = ObjectPath::try_from("/org/freedesktop/systemd1/unit/_invalid")
+            .map_err(|e| fdo::Error::Failed(format!("path: {e}")))?;
+        let job_path = ObjectPath::try_from("/")
+            .map_err(|e| fdo::Error::Failed(format!("path: {e}")))?;
+
+        let mut out = Vec::with_capacity(entes.len());
+        for e in entes {
+            let name = format!("{}.service", e.label);
+            let description = format!("Ente: {} ({})", e.label, e.id);
+            let active_state = if e.pid.is_some() { "active" } else { "active" };
+            let sub_state = match e.pid {
+                Some(_) => "running",
+                None => "virtual",
+            };
+            out.push((
+                name,
+                description,
+                "loaded".to_string(),
+                active_state.to_string(),
+                sub_state.to_string(),
+                String::new(),  // followed_unit
+                unit_path.clone().into(),
+                0u32,           // job_id
+                String::new(),  // job_type
+                job_path.clone().into(),
+            ));
+        }
+        info!(count = out.len(), "ListUnits");
+        Ok(out)
+    }
+
+    async fn list_units_filtered(&self, _states: Vec<String>) -> fdo::Result<Vec<UnitInfo>> {
+        // Subset simple: ignoramos el filtro y devolvemos todas.
+        self.list_units().await
+    }
+
+    async fn list_units_by_names(&self, names: Vec<String>) -> fdo::Result<Vec<UnitInfo>> {
+        let all = self.list_units().await?;
+        let want: std::collections::HashSet<&String> = names.iter().collect();
+        Ok(all.into_iter().filter(|u| want.contains(&u.0)).collect())
+    }
+
+    async fn get_unit(&self, name: String) -> fdo::Result<OwnedObjectPath> {
+        if let Some(entes) = query_list_entes().await {
+            if entes.iter().any(|e| format!("{}.service", e.label) == name) {
+                let path = format!("/org/freedesktop/systemd1/unit/{}", escape_unit_name(&name));
+                return ObjectPath::try_from(path)
+                    .map(OwnedObjectPath::from)
+                    .map_err(|e| fdo::Error::Failed(format!("path: {e}")));
+            }
+        }
+        Err(fdo::Error::Failed(format!("Unit {name} not found")))
+    }
+
+    async fn get_unit_by_pid(&self, pid: u32) -> fdo::Result<OwnedObjectPath> {
+        if let Some(entes) = query_list_entes().await {
+            if let Some(e) = entes.iter().find(|e| e.pid == Some(pid as i32)) {
+                let path = format!("/org/freedesktop/systemd1/unit/{}",
+                    escape_unit_name(&format!("{}.service", e.label)));
+                return ObjectPath::try_from(path)
+                    .map(OwnedObjectPath::from)
+                    .map_err(|e| fdo::Error::Failed(format!("path: {e}")));
+            }
+        }
+        Err(fdo::Error::Failed(format!("PID {pid} not in any unit")))
+    }
+
+    async fn start_unit(&self, name: String, _mode: String) -> fdo::Result<OwnedObjectPath> {
+        warn!(%name, "StartUnit no implementado — Cards no se 'start' tras boot");
+        Err(fdo::Error::NotSupported(
+            "StartUnit: el fractal usa Cards cargadas al boot, no unit files dinámicos".into()
+        ))
+    }
+
+    async fn stop_unit(&self, name: String, _mode: String) -> fdo::Result<OwnedObjectPath> {
+        warn!(%name, "StopUnit (stub: TODO via bus capability)");
+        // TODO: bus → graph → kill PID por label. Por ahora no-op.
+        let path = ObjectPath::try_from("/").unwrap();
+        Ok(path.into())
+    }
+
+    async fn restart_unit(&self, name: String, mode: String) -> fdo::Result<OwnedObjectPath> {
+        info!(%name, "RestartUnit (delega a StopUnit)");
+        self.stop_unit(name, mode).await
+    }
+
+    async fn reload_unit(&self, name: String, _mode: String) -> fdo::Result<OwnedObjectPath> {
+        info!(%name, "ReloadUnit (no-op — Cards inmutables)");
+        let path = ObjectPath::try_from("/").unwrap();
+        Ok(path.into())
+    }
+
+    async fn kill_unit(&self, name: String, _who: String, _signal: i32) -> fdo::Result<()> {
+        warn!(%name, "KillUnit (stub)");
+        Ok(())
+    }
+
+    async fn subscribe(&self) -> fdo::Result<()> { Ok(()) }
+    async fn unsubscribe(&self) -> fdo::Result<()> { Ok(()) }
+
+    async fn reload(&self) -> fdo::Result<()> {
+        info!("Reload: trigger re-read (no-op — Cards no se recargan tras boot)");
+        Ok(())
+    }
+
+    async fn list_unit_files(&self) -> fdo::Result<Vec<(String, String)>> {
+        // Empty: no usamos unit files. Cards en su lugar.
+        Ok(vec![])
+    }
+
+    async fn list_jobs(&self) -> fdo::Result<Vec<(u32, String, String, String, OwnedObjectPath, OwnedObjectPath)>> {
+        Ok(vec![])
+    }
+
+    async fn get_default_target(&self) -> fdo::Result<String> {
+        Ok("multi-user.target".into())
+    }
+
+    async fn set_default_target(&self, _name: String, _force: bool) -> fdo::Result<(Vec<String>, Vec<String>, Vec<String>)> {
+        Err(fdo::Error::NotSupported("default target gestionado por Card de Semilla".into()))
+    }
+
+    // ----- Properties -----
+
+    #[zbus(property)]
+    async fn version(&self) -> String { format!("ente-systemd1-compat {}", env!("CARGO_PKG_VERSION")) }
+
+    #[zbus(property)]
+    async fn architecture(&self) -> String { std::env::consts::ARCH.into() }
+
+    #[zbus(property)]
+    async fn features(&self) -> String { "+ENTE-FRACTAL".into() }
+
+    #[zbus(property)]
+    async fn virtualization(&self) -> String { String::new() }
+
+    #[zbus(property)]
+    async fn confined(&self) -> bool { false }
+
+    #[zbus(property)]
+    async fn environment(&self) -> Vec<String> {
+        std::env::vars().map(|(k, v)| format!("{k}={v}")).collect()
+    }
+
+    #[zbus(property)]
+    async fn n_names(&self) -> u32 { 0 }
+
+    #[zbus(property)]
+    async fn n_jobs(&self) -> u32 { 0 }
+
+    #[zbus(property)]
+    async fn progress(&self) -> f64 { 1.0 }
+}
+
+/// Pregunta al bus interno por la lista de Entes vivos.
+async fn query_list_entes() -> Option<Vec<ente_bus::EnteInfo>> {
+    let mut client = match BusClient::from_env().await {
+        Ok(c) => c,
+        Err(e) => { warn!(?e, "no bus client — devuelvo vacío"); return None; }
+    };
+    match client.call(BusRequest::ListEntes).await {
+        Ok(BusResponse::Entes(entes)) => Some(entes),
+        Ok(other) => { warn!(?other, "ListEntes respuesta inesperada"); None }
+        Err(e) => { warn!(?e, "ListEntes call falló"); None }
+    }
+}
+
+/// Escape de nombres de units para object paths según convención systemd:
+/// `.` → `_2e`, `-` → `_2d`, etc. Para el demo usamos un escape simple.
+fn escape_unit_name(name: &str) -> String {
+    name.chars().map(|c| match c {
+        c if c.is_ascii_alphanumeric() => c.to_string(),
+        c => format!("_{:02x}", c as u32),
+    }).collect()
+}
+
+async fn announce_to_fractal() {
+    if let Ok(mut client) = BusClient::from_env().await {
+        let req = BusRequest::Announce {
+            capabilities: vec![Capability::Endpoint {
+                interface: ente_card::InterfaceId([0xa6; 16]),
+                version: 1,
+            }],
+        };
+        match client.call(req).await {
+            Ok(BusResponse::Ok) => info!("Announce → bus interno OK"),
+            Ok(other) => warn!(?other, "Announce respuesta inesperada"),
+            Err(e) => warn!(?e, "Announce falló"),
+        }
+    }
+}
+
+async fn wait_for_term() -> anyhow::Result<()> {
+    let mut term = signal(SignalKind::terminate())?;
+    let mut int_ = signal(SignalKind::interrupt())?;
+    tokio::select! {
+        _ = term.recv() => info!("SIGTERM"),
+        _ = int_.recv() => info!("SIGINT"),
+    }
+    Ok(())
+}
+
+fn init_tracing() {
+    let filter = EnvFilter::try_from_default_env()
+        .unwrap_or_else(|_| EnvFilter::new("ente_systemd1_compat=info"));
+    tracing_subscriber::fmt().with_env_filter(filter).with_target(true).init();
+}
+
+#[allow(dead_code)]
+fn _suppress(_: HashMap<String, OwnedValue>) {} // mantener import si se reduce