ci: run the full workspace test suite (CLI-37) (#109)

Author: markovejnovic

.hm/ci.py

@@ -20,14 +20,18 @@ def shared_base() -> hm.Step:
 
 @hm.target()
 def rust_project(shared_base: hm.Target[hm.Step]) -> tuple[hm.Step, ...]:
-    project = hm.rust.project(path=".", base=shared_base)
+    # Build esbuild into the image first: hm-dsl-engine's build.rs shells out
+    # to esbuild at compile time to embed the TypeScript SDK bundle. Without it
+    # the build emits an 18-byte stub and the bundled_sources tests fail (CLI-37).
+    # Installing Node here also lets the JS-runtime-gated render tests actually
+    # run instead of self-skipping.
+    ts_deps = hm.js.project(
+        path="crates/hm-dsl-engine/harmont-ts",
+        base=shared_base,
+    ).install()
+    project = hm.rust.project(path=".", base=ts_deps)
     return hm.group([
-        project.test(flags=("--lib",), packages=("harmont-cli",)),
-        project.test(
-            flags=("--test", "cmd_init"),
-            packages=("harmont-cli",),
-            label=":test_tube: init template roundtrip",
-        ),
+        project.test(),  # cargo test --workspace --locked — every package
         project.clippy(),
         project.fmt(),
     ])

crates/hm/src/commands/run/mod.rs

@@ -31,10 +31,8 @@ use crate::error::{ErrorCategory, HmError};
 /// the backend rejects the build, authentication fails, the network is
 /// unreachable, the local daemon is down, or the pipeline fails to render.
 pub async fn handle(args: RunArgs, ctx: RunContext) -> Result<i32> {
-    // 1. Build the backend. Cloud needs auth + org resolution BEFORE any
-    //    (local) render work — fail fast on a missing token.
-    //    Resolution: explicit --backend > legacy --cloud alias > config.backend
-    //    (figment-layered default "docker").
+    // 1. Resolve the backend name: explicit --backend > legacy --cloud alias >
+    //    config.backend (figment-layered default "docker").
     let backend_name = args
         .backend
         .clone()
@@ -47,7 +45,13 @@ pub async fn handle(args: RunArgs, ctx: RunContext) -> Result<i32> {
         })
         .unwrap_or_else(|| ctx.config.backend.clone());
 
-    let backend: Box<dyn hm_exec::ExecutionBackend> = if backend_name == "cloud" {
+    // 2. Cloud needs auth + org resolution up front — fail fast on a missing
+    //    token before any render work. We resolve the credentials here but
+    //    defer *constructing* the backend (and, for local runs, *connecting* to
+    //    Docker) until after the pipeline renders, so an unknown slug or a
+    //    missing/ambiguous pipeline argument fails with a helpful message
+    //    instead of a daemon-connection error.
+    let cloud_creds = if backend_name == "cloud" {
         let api_url = ctx.config.cloud.api_url.clone();
         let token = hm_config::creds::cloud_token(&api_url).context(
             "`hm run --backend cloud` requires authentication — run `hm cloud login` or set HARMONT_API_TOKEN",
@@ -57,23 +61,43 @@ pub async fn handle(args: RunArgs, ctx: RunContext) -> Result<i32> {
             .clone()
             .or_else(|| ctx.config.cloud.org.clone())
             .context("no organization — pass --org or set `[cloud] org = \"…\"` in .hm/config.toml or ~/.config/hm/config.toml")?;
-        let client = harmont_cloud::HarmontClient::with_base_url(token, &api_url);
-        Box::new(hm_exec::CloudBackend::new(client, api_url, org))
+        Some((api_url, token, org))
+    } else if backend_name != "docker" {
+        anyhow::bail!("unknown --backend '{backend_name}'\n  available: docker, cloud");
     } else {
-        // Local execution on a hm-vm VmBackend, selected by name.
-        let vm_backend: std::sync::Arc<dyn hm_vm::VmBackend> = match backend_name.as_str() {
-            "docker" => std::sync::Arc::new(
+        None
+    };
+
+    // 3. Render + parse the plan once (shared by every backend). This validates
+    //    the pipeline argument — unknown slug, or zero/many declared pipelines
+    //    — before we connect to any daemon.
+    let (repo_root, slug, ir_json) = render_pipeline(&args, &ctx).await?;
+    let plan = hm_exec::Plan::parse(ir_json).map_err(|e| backend_anyhow(&e))?;
+
+    // 4. Pick the renderer — this validates `--format` — before any daemon
+    //    connection, so an unknown format fails fast without a running Docker.
+    let use_logs = args.logs
+        || std::env::var_os("CI").is_some_and(|v| !v.is_empty())
+        || !hm_render::stderr_interactive();
+    let renderer = hm_render::renderer_for(&args.format, ctx.output.color_enabled(), use_logs)?;
+
+    // 5. Build the backend. For local runs this is where we connect to Docker.
+    let backend: Box<dyn hm_exec::ExecutionBackend> =
+        if let Some((api_url, token, org)) = cloud_creds {
+            let client = harmont_cloud::HarmontClient::with_base_url(token, &api_url);
+            Box::new(hm_exec::CloudBackend::new(client, api_url, org))
+        } else {
+            // Local execution on a hm-vm VmBackend (docker).
+            let vm_backend: std::sync::Arc<dyn hm_vm::VmBackend> = std::sync::Arc::new(
                 hm_vm::docker::DockerBackend::connect().map_err(|e| anyhow::anyhow!("{e:#}"))?,
-            ),
-            other => anyhow::bail!("unknown --backend '{other}'\n  available: docker, cloud"),
+            );
+            Box::new(hm_exec::LocalBackend::new(
+                resolve_parallelism(&args),
+                vm_backend,
+            ))
         };
-        Box::new(hm_exec::LocalBackend::new(
-            resolve_parallelism(&args),
-            vm_backend,
-        ))
-    };
 
-    // 2. Capability-driven flag validation (replaces the old silent ignoring).
+    // 6. Capability-driven flag validation (replaces the old silent ignoring).
     let caps = backend.capabilities();
     if args.no_watch && !caps.supports_no_watch {
         anyhow::bail!(
@@ -94,9 +118,7 @@ pub async fn handle(args: RunArgs, ctx: RunContext) -> Result<i32> {
         );
     }
 
-    // 3. Render + parse the plan once (shared by every backend).
-    let (repo_root, slug, ir_json) = render_pipeline(&args, &ctx).await?;
-    let plan = hm_exec::Plan::parse(ir_json).map_err(|e| backend_anyhow(&e))?;
+    // 7. Assemble the run request.
     let (branch, commit) = git_metadata(&repo_root, args.branch.clone());
     let req = hm_exec::RunRequest {
         plan,
@@ -116,13 +138,7 @@ pub async fn handle(args: RunArgs, ctx: RunContext) -> Result<i32> {
         },
     };
 
-    // 4. Renderer selection (unchanged): logs stream in CI or with --logs.
-    let use_logs = args.logs
-        || std::env::var_os("CI").is_some_and(|v| !v.is_empty())
-        || !hm_render::stderr_interactive();
-    let renderer = hm_render::renderer_for(&args.format, ctx.output.color_enabled(), use_logs)?;
-
-    // 5. Start, drive events, own Ctrl-C, await the outcome.
+    // 8. Start, drive events, own Ctrl-C, await the outcome.
     let handle = backend.start(req).await.map_err(|e| backend_anyhow(&e))?;
     let (events, control) = handle.into_parts();
     let _ctrlc = crate::signal::install_ctrlc(control.cancel_token());