refactor(monorepo): reorganización lógica + renames + SDDs + split CHANGELOG

Reorganización física de crates/: - core/ (mezclaba 6 propósitos) se divide en protocol/, init/, runtime/, compat/ - shared/ (3 crates) se redistribuye en protocol/ e init/ - lapaloma (sub-módulo de ui_engine) se promueve a modules/pineal/ Renames de proyectos: - shipote → shuma (runtime de sandboxes) - nouser → akasha (explorador de Mónadas) - yahweh → nahual (motor GPUI, antes ui_engine/) - lapaloma → pineal (data-viz agnóstica) Fraccionamiento UI → core agnóstico: - vista-core (DeckState + snap, 175 LOC, 5 tests verdes) - barra-core (Task + render_html + sanitize, 90 LOC, 5 tests verdes) - vista-web y barra-web ahora son thin DOM bindings Documentación nueva: - 16 SDDs por subdirectorio (≤80 LOC c/u): protocol/init/runtime/compat + 10 módulos + apps/ - docs/STATUS.md con cifras reales por proyecto - docs/ROADMAP.md con plan a finalización (6 hitos, ~6-8 semanas) - CHANGELOG.md particionado en docs/changelog/<proyecto>.md (7 buckets) Automatización: - scripts/reorg.py — script idempotente que: git mv directorios, renombra package names, recomputa path = refs, reescribe imports rust, actualiza workspace Cargo.toml. Soporta --dry-run. - scripts/split-changelog.py — particiona CHANGELOG por componente. Validación: - cargo check --workspace pasa (124 crates + 2 nuevos cores). - 10 tests adicionales (5 en vista-core + 5 en barra-core) verdes. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
2026-05-19 14:48:34 +00:00
parent 86fb6ae20b
commit 550c98f275
375 changed files with 8512 additions and 7155 deletions
@@ -0,0 +1,19 @@
+[package]
+name = "ente-timedated-compat"
+version = "0.0.1"
+edition.workspace = true
+license.workspace = true
+publish.workspace = true
+
+[[bin]]
+name = "ente-timedated-compat"
+path = "src/main.rs"
+
+[dependencies]
+ente-card = { path = "../../protocol/ente-card" }
+ente-bus = { path = "../../runtime/ente-bus" }
+anyhow = { workspace = true }
+tokio = { workspace = true }
+tracing = { workspace = true }
+tracing-subscriber = { workspace = true }
+zbus = { version = "4", default-features = false, features = ["tokio"] }
@@ -0,0 +1,182 @@
+//! ente-timedated-compat: shim de `org.freedesktop.timedate1`.
+//!
+//! GNOME settings panel "Date & Time" llama aquí. Properties read-only se
+//! mapean a syscalls/lecturas del sistema; setters log + forward.
+
+use ente_bus::{BusClient, BusRequest, BusResponse};
+use ente_card::Capability;
+use std::time::{SystemTime, UNIX_EPOCH};
+use tokio::signal::unix::{signal, SignalKind};
+use tracing::{info, warn};
+use tracing_subscriber::EnvFilter;
+use zbus::{fdo, interface};
+
+const BUS_NAME: &str = "org.freedesktop.timedate1";
+const OBJ_PATH: &str = "/org/freedesktop/timedate1";
+
+#[tokio::main(flavor = "current_thread")]
+async fn main() -> anyhow::Result<()> {
+    init_tracing();
+    info!("ente-timedated-compat: arrancando");
+    announce_to_fractal().await;
+
+    let manager = TimedateManager::default();
+    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");
+                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
+        }
+    }
+}
+
+#[derive(Default)]
+struct TimedateManager;
+
+#[interface(name = "org.freedesktop.timedate1")]
+impl TimedateManager {
+    // ----- Properties -----
+
+    /// Timezone configurada. Por defecto leemos el target de /etc/localtime
+    /// (un symlink a /usr/share/zoneinfo/<TZ>).
+    #[zbus(property)]
+    async fn timezone(&self) -> String {
+        std::fs::read_link("/etc/localtime")
+            .ok()
+            .and_then(|p| {
+                let s = p.to_string_lossy().into_owned();
+                s.strip_prefix("/usr/share/zoneinfo/").map(String::from)
+                    .or_else(|| s.split("/zoneinfo/").nth(1).map(String::from))
+            })
+            .unwrap_or_else(|| "UTC".into())
+    }
+
+    /// True si el RTC del hardware está en local time. Convención moderna
+    /// es UTC (false). Reportamos false como default.
+    #[zbus(property)]
+    async fn local_rtc(&self) -> bool { false }
+
+    /// Si NTP es soportado. Reportamos true (asumimos systemd-timesyncd
+    /// o chrony están disponibles en el host).
+    #[zbus(property)]
+    async fn can_ntp(&self) -> bool { true }
+
+    /// Si NTP está activo. Sin daemon real bajo nuestro control no podemos
+    /// consultarlo con precisión — false como default seguro.
+    #[zbus(property)]
+    async fn ntp(&self) -> bool { false }
+
+    #[zbus(property)]
+    async fn ntpsynchronized(&self) -> bool { false }
+
+    /// Timestamp actual en microsegundos desde epoch.
+    #[zbus(property)]
+    async fn time_usec(&self) -> u64 {
+        SystemTime::now().duration_since(UNIX_EPOCH)
+            .map(|d| d.as_micros() as u64)
+            .unwrap_or(0)
+    }
+
+    #[zbus(property)]
+    async fn rtctime_usec(&self) -> u64 {
+        // El RTC real requiere ioctl a /dev/rtc — usamos system clock como aprox.
+        SystemTime::now().duration_since(UNIX_EPOCH)
+            .map(|d| d.as_micros() as u64)
+            .unwrap_or(0)
+    }
+
+    // ----- Setters -----
+
+    async fn set_time(&self, usec_utc: i64, _relative: bool, _interactive: bool) -> fdo::Result<()> {
+        info!(usec_utc, "SetTime (stub: requiere CAP_SYS_TIME para aplicar)");
+        Ok(())
+    }
+
+    async fn set_timezone(&self, timezone: String, _interactive: bool) -> fdo::Result<()> {
+        // Validar contra zoneinfo: el archivo destino debe existir.
+        let zoneinfo = format!("/usr/share/zoneinfo/{timezone}");
+        if !std::path::Path::new(&zoneinfo).exists() {
+            return Err(fdo::Error::InvalidArgs(format!("timezone desconocida: {timezone}")));
+        }
+        // Atomic relink: crear localtime.tmp como symlink, rename.
+        let tmp = "/etc/localtime.tmp";
+        let _ = std::fs::remove_file(tmp);
+        if let Err(e) = std::os::unix::fs::symlink(&zoneinfo, tmp) {
+            return Err(fdo::Error::Failed(format!("symlink: {e}")));
+        }
+        if let Err(e) = std::fs::rename(tmp, "/etc/localtime") {
+            return Err(fdo::Error::Failed(format!("rename: {e}")));
+        }
+        info!(%timezone, "SetTimezone → /etc/localtime");
+        Ok(())
+    }
+
+    async fn set_local_rtc(&self, local_rtc: bool, _fix_system: bool, _interactive: bool) -> fdo::Result<()> {
+        info!(local_rtc, "SetLocalRTC (stub)");
+        Ok(())
+    }
+
+    async fn set_ntp(&self, ntp: bool, _interactive: bool) -> fdo::Result<()> {
+        info!(ntp, "SetNTP (stub: no controlamos timesyncd)");
+        Ok(())
+    }
+
+    async fn list_timezones(&self) -> fdo::Result<Vec<String>> {
+        // Listar /usr/share/zoneinfo recursivamente. Hacemos un best-effort.
+        let mut out = Vec::new();
+        if let Ok(rd) = std::fs::read_dir("/usr/share/zoneinfo") {
+            for entry in rd.flatten() {
+                if let Ok(name) = entry.file_name().into_string() {
+                    if !name.starts_with(|c: char| c.is_lowercase()) && name != "posix" && name != "right" {
+                        out.push(name);
+                    }
+                }
+            }
+        }
+        Ok(out)
+    }
+}
+
+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([0xa1; 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_timedated_compat=info"));
+    tracing_subscriber::fmt().with_env_filter(filter).with_target(true).init();
+}