more cleanup

Author: markovejnovic

crates/hm-common/src/git.rs

@@ -21,7 +21,7 @@ pub struct Git<'bin> {
 }
 
 impl<'bin> Git<'bin> {
-    /// Wrap a `git` executable, typically via `SysRuntime::git()`.
+    /// Wrap a `git` executable, typically via `AppContext::git()`.
     #[must_use]
     pub const fn new(bin: &'bin Path) -> Self {
         Self { bin }

crates/hm-common/src/python.rs

@@ -15,7 +15,7 @@ pub struct Python<'bin> {
 }
 
 impl<'bin> Python<'bin> {
-    /// Wrap a `python3` executable, typically via `SysRuntime::python()`.
+    /// Wrap a `python3` executable, typically via `AppContext::python()`.
     #[must_use]
     pub const fn new(bin: &'bin Path) -> Self {
         Self { bin }

crates/hm-core/src/app_context.rs

@@ -1,9 +1,5 @@
-//! Process-wide application context: resolved toolchain, directories, and the
-//! user-scoped config.
-//!
-//! Built once in `main` via [`AppContext::init`] and threaded through the
-//! application by shared reference (typically leaked to `&'static` so it can be
-//! held across `await` points).
+//! Process-wide application context: resolved toolchain, directories, and user
+//! config.
 
 use std::path::{Path, PathBuf};
 
@@ -32,11 +28,7 @@ pub enum InitError {
     UserConfig(#[source] ConfigLoadingError),
 }
 
-/// Resolved toolchain, platform directories, and the user config, captured once
-/// at startup.
-///
-/// Accessed by shared reference; not a global. A missing user config is not an
-/// error — [`AppContext::user_config`] returns `None`.
+/// Resolved toolchain, platform directories, and the user config.
 #[derive(Debug)]
 pub struct AppContext {
     git: PathBuf,
@@ -59,7 +51,7 @@ impl AppContext {
         let python3 = pathbin("python3")?;
         let cwd = std::env::current_dir().map_err(InitError::Cwd)?;
         let dirs = DirProvider::new().ok_or(InitError::Dirs)?;
-        let user_config = Self::load_user_config(&Self::user_config_path(&dirs))
+        let user_config = Self::load_user_config(&Self::user_config_file(&dirs))
             .await
             .map_err(InitError::UserConfig)?;
 
@@ -73,8 +65,9 @@ impl AppContext {
     }
 
     /// The user config path (`~/.hm/config.toml`).
-    fn user_config_path(dirs: &DirProvider) -> PathBuf {
-        dirs.home().join(".hm").join("config.toml")
+    #[must_use]
+    pub fn user_config_path(&self) -> PathBuf {
+        Self::user_config_file(&self.dirs)
     }
 
     /// Read the user config, treating a missing file as [`None`].
@@ -122,6 +115,11 @@ impl AppContext {
     pub fn python(&self) -> Python<'_> {
         Python::new(&self.python3)
     }
+
+    /// The user config path (`~/.hm/config.toml`) under `dirs`.
+    fn user_config_file(dirs: &DirProvider) -> PathBuf {
+        dirs.home().join(".hm").join("config.toml")
+    }
 }
 
 #[cfg(test)]

crates/hm-core/src/config/mod.rs

@@ -1,8 +1,7 @@
 //! Resolving the user and project config layers into one effective view.
 //!
-//! [`UserConfig`] and [`ProjectConfig`] are sparse, all-optional layers loaded
-//! from their respective files. [`ResolvedProjectConfig`] is what the rest of
-//! the CLI reads: the two layers merged, project over user, with defaults
+//! [`UserConfig`] and [`ProjectConfig`] are sparse file layers;
+//! [`ResolvedProjectConfig`] is the two merged — project over user, defaults
 //! applied.
 
 pub mod creds;

crates/hm-core/src/config/user.rs

@@ -2,6 +2,7 @@
 
 use std::path::Path;
 
+use anyhow::Context as _;
 use serde::{Deserialize, Serialize};
 
 use super::domain::{BackendConfig, BackendDomain, ConfigLoadingError};
@@ -36,4 +37,15 @@ impl UserConfig {
         let contents = tokio::fs::read_to_string(path).await?;
         Ok(toml::from_str(&contents)?)
     }
+
+    /// Serialize to `path`, creating parent directories as needed.
+    ///
+    /// # Errors
+    /// [`anyhow::Error`] if serialization or the write fails.
+    pub async fn save(&self, path: &Path) -> anyhow::Result<()> {
+        let serialized = toml::to_string_pretty(self).context("serializing user config")?;
+        hm_common::fs::write_create_all(path, serialized)
+            .await
+            .with_context(|| format!("writing {}", path.display()))
+    }
 }

crates/hm-core/src/exec/cloud/backend.rs

@@ -37,7 +37,7 @@ pub struct CloudBackend {
     api_base: String,
     /// Dashboard (SPA) base used to build the human-clickable watch URL. This
     /// is the `app.` host, NOT `api.` — a link built from `api_base` lands on
-    /// raw JSON. Resolved via [`crate::config::app_url`] at the call site.
+    /// raw JSON. Derived from the configured domain's `app_url` at the call site.
     app_base: String,
     org: String,
 }
@@ -319,7 +319,7 @@ mod tests {
 
     #[rstest]
     fn watch_url_uses_app_host_and_pipelines_path() {
-        // Mirrors crate::config::app_url(DEFAULT_API_URL) -> https://app.harmont.dev.
+        // Mirrors BackendDomain::default().app_url() -> https://app.harmont.dev.
         assert_eq!(
             dashboard_build_url("https://app.harmont.dev", "acme", "web", 42),
             "https://app.harmont.dev/acme/pipelines/web/builds/42"

crates/hm-core/src/lib.rs

@@ -1,11 +1,8 @@
-//! Core of the `hm` CLI: layered configuration, the pluggable CI execution
-//! backends, and the application/project runtime context. Shared by the `hm`
-//! binary and `hm-plugin-cloud`.
+//! Core of the `hm` CLI.
 //!
 //! - [`config`] — user/project config resolution.
-//! - [`exec`] — the [`exec::ExecutionBackend`] trait and its local + cloud
-//!   implementations.
-//! - [`app_context`] — the process-wide toolchain/directory/user-config context.
+//! - [`exec`] — the [`exec::ExecutionBackend`] trait and its backends.
+//! - [`app_context`] — process-wide toolchain, directories, and user config.
 //! - [`project`] — a workspace and its resolved config.
 
 pub mod app_context;

crates/hm-core/src/project.rs

@@ -1,9 +1,6 @@
 //! A Harmont workspace and its resolved configuration.
 //!
-//! A project is a directory tree rooted at a directory containing `.hm/`. A
-//! [`ProjectContext`] wraps that root, exposes its `.hm/` paths, and holds the
-//! [`ResolvedProjectConfig`] merged from the user and project layers at
-//! construction.
+//! A project is a directory tree rooted at a directory containing `.hm/`.
 
 use std::path::{Path, PathBuf};
 
@@ -32,7 +29,7 @@ impl ProjectContext {
         start: &Path,
         user: Option<&UserConfig>,
     ) -> Result<Option<Self>, ConfigLoadingError> {
-        match find_project_root(start) {
+        match Self::find_root(start) {
             Some(root) => Ok(Some(Self::at(root, user).await?)),
             None => Ok(None),
         }
@@ -45,7 +42,7 @@ impl ProjectContext {
     /// [`ConfigLoadingError`] if the project config file is present but
     /// unreadable or malformed.
     pub async fn at(path: PathBuf, user: Option<&UserConfig>) -> Result<Self, ConfigLoadingError> {
-        let project = load_project_config(&config_path_for(&path)).await?;
+        let project = Self::load_config(&Self::config_file(&path)).await?;
         let user = user.cloned().unwrap_or_default();
         let config = ResolvedProjectConfig::from_user_project(&user, &project);
         Ok(Self { path, config })
@@ -70,44 +67,41 @@ impl ProjectContext {
     /// The project config file path (`.hm/config.toml`).
     #[must_use]
     pub fn config_path(&self) -> PathBuf {
-        config_path_for(&self.path)
+        Self::config_file(&self.path)
     }
 
     /// The resolved configuration for this workspace.
     #[must_use]
     pub const fn config(&self) -> &ResolvedProjectConfig {
         &self.config
     }
-}
 
-/// The project config file path for a workspace root.
-fn config_path_for(root: &Path) -> PathBuf {
-    root.join(".hm").join("config.toml")
-}
+    /// The project config file path for a workspace root.
+    fn config_file(root: &Path) -> PathBuf {
+        root.join(".hm").join("config.toml")
+    }
 
-/// Walk up from `start` to the first directory containing `.hm/`.
-///
-/// Returns the directory *containing* `.hm/`, or `None` at the filesystem root.
-#[must_use]
-pub fn find_project_root(start: &Path) -> Option<PathBuf> {
-    let mut current = start;
-    loop {
-        if current.join(".hm").is_dir() {
-            return Some(current.to_path_buf());
+    /// Walk up from `start` to the first directory containing `.hm/`.
+    ///
+    /// Returns the directory *containing* `.hm/`, or `None` at the filesystem
+    /// root.
+    fn find_root(start: &Path) -> Option<PathBuf> {
+        let mut current = start;
+        loop {
+            if current.join(".hm").is_dir() {
+                return Some(current.to_path_buf());
+            }
+            current = current.parent()?;
         }
-        current = current.parent()?;
     }
-}
 
-/// Read a project config, treating a missing file as defaults.
-///
-/// # Errors
-/// [`ConfigLoadingError`] if the file is present but unreadable or malformed.
-async fn load_project_config(path: &Path) -> Result<ProjectConfig, ConfigLoadingError> {
-    match tokio::fs::read_to_string(path).await {
-        Ok(contents) => Ok(toml::from_str(&contents)?),
-        Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(ProjectConfig::default()),
-        Err(e) => Err(e.into()),
+    /// Read a project config, treating a missing file as defaults.
+    async fn load_config(path: &Path) -> Result<ProjectConfig, ConfigLoadingError> {
+        match tokio::fs::read_to_string(path).await {
+            Ok(contents) => Ok(toml::from_str(&contents)?),
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(ProjectConfig::default()),
+            Err(e) => Err(e.into()),
+        }
     }
 }
 
@@ -123,13 +117,16 @@ mod tests {
         std::fs::create_dir(tmp.path().join(".hm")).unwrap();
         let nested = tmp.path().join("src").join("deep");
         std::fs::create_dir_all(&nested).unwrap();
-        assert_eq!(find_project_root(&nested), Some(tmp.path().to_path_buf()));
+        assert_eq!(
+            ProjectContext::find_root(&nested),
+            Some(tmp.path().to_path_buf())
+        );
     }
 
     #[rstest]
     fn find_project_root_none_when_absent() {
         let tmp = tempfile::tempdir().unwrap();
-        assert_eq!(find_project_root(tmp.path()), None);
+        assert_eq!(ProjectContext::find_root(tmp.path()), None);
     }
 
     #[rstest]

crates/hm-dsl-engine/src/python_engine.rs

@@ -2,8 +2,8 @@ use std::path::Path;
 
 use anyhow::{Context, Result};
 use async_trait::async_trait;
-use hm_core::sys_runtime::SysRuntime;
 use hm_common::process::CapturedStreams as _;
+use hm_core::app_context::AppContext;
 use tracing::debug;
 
 use crate::bundled_sources;
@@ -59,15 +59,16 @@ if match is None:
 print(json.dumps(match['definition']))
 ";
 
-#[derive(Debug, Default)]
-pub struct SubprocessPythonEngine;
+#[derive(Debug)]
+pub struct SubprocessPythonEngine<'app> {
+    app: &'app AppContext,
+}
 
-impl SubprocessPythonEngine {
-    /// Create the engine. It runs `python3` through [`SysRuntime::python`], so
-    /// [`SysRuntime::init`] must have been called first.
+impl<'app> SubprocessPythonEngine<'app> {
+    /// Create the engine bound to `app`, whose resolved `python3` it runs.
     #[must_use]
-    pub const fn new() -> Self {
-        Self
+    pub const fn new(app: &'app AppContext) -> Self {
+        Self { app }
     }
 
     async fn run_script(
@@ -80,7 +81,7 @@ impl SubprocessPythonEngine {
         let harmont_pkg = tmp.path().join("harmont");
         bundled_sources::extract_to(&bundled_sources::HARMONT_PY, &harmont_pkg)?;
 
-        let mut py = SysRuntime::python().program(script);
+        let mut py = self.app.python().program(script);
         py.args(extra_args).current_dir(project_dir);
         py.pythonpath(tmp.path());
 
@@ -91,7 +92,7 @@ impl SubprocessPythonEngine {
 }
 
 #[async_trait]
-impl DslEngine for SubprocessPythonEngine {
+impl DslEngine for SubprocessPythonEngine<'_> {
     async fn list_pipelines(&self, project_dir: &Path) -> Result<Vec<PipelineMeta>> {
         let stdout = self
             .run_script(project_dir, LIST_PIPELINES_SCRIPT, &[])

crates/hm-dsl-engine/tests/python_engine_test.rs

@@ -10,10 +10,10 @@ use hm_dsl_engine::DslEngine;
 #[tokio::test]
 async fn python_roundtrip() {
     // Skip if the toolchain (python3 + git) is unavailable.
-    if hm_core::sys_runtime::SysRuntime::init().is_err() {
+    let Ok(app) = hm_core::app_context::AppContext::init().await else {
         eprintln!("skipping: build toolchain unavailable");
         return;
-    }
+    };
 
     let dir = tempfile::tempdir().unwrap();
     let harmont = dir.path().join(".hm");
@@ -31,7 +31,7 @@ def ci() -> hm.Step:
 
     hm_dsl_engine::detect::check_python(dir.path()).unwrap();
 
-    let engine = hm_dsl_engine::SubprocessPythonEngine::new();
+    let engine = hm_dsl_engine::SubprocessPythonEngine::new(&app);
     let metas = engine.list_pipelines(dir.path()).await.unwrap();
     assert_eq!(metas.len(), 1);
     assert_eq!(metas[0].slug, "ci");
@@ -43,10 +43,10 @@ def ci() -> hm.Step:
 
 #[tokio::test]
 async fn python_registry_json_carries_triggers_and_allow_manual() {
-    if hm_core::sys_runtime::SysRuntime::init().is_err() {
+    let Ok(app) = hm_core::app_context::AppContext::init().await else {
         eprintln!("skipping: build toolchain unavailable");
         return;
-    }
+    };
 
     let dir = tempfile::tempdir().unwrap();
     let harmont = dir.path().join(".hm");
@@ -62,7 +62,7 @@ def ci() -> hm.Step:
     )
     .unwrap();
 
-    let engine = hm_dsl_engine::SubprocessPythonEngine::new();
+    let engine = hm_dsl_engine::SubprocessPythonEngine::new(&app);
     let json = engine.registry_json(dir.path()).await.unwrap();
     let v: serde_json::Value = serde_json::from_str(&json).unwrap();