feat(init): ask to link org during hm init (CLI-39) (#110)

Author: markovejnovic

crates/hm-plugin-cloud/src/lib.rs

@@ -17,3 +17,17 @@ pub mod settings;
 
 mod auth;
 mod verbs;
+
+/// Run the interactive browser-loopback login flow.
+///
+/// Designed for embedding in host commands (e.g. `hm init`) that need
+/// the user to authenticate before proceeding.
+///
+/// # Errors
+///
+/// Returns an error if the browser cannot be opened, the login times
+/// out, or the token cannot be persisted.
+pub async fn login_interactive() -> anyhow::Result<()> {
+    let env: std::collections::BTreeMap<String, String> = std::env::vars().collect();
+    auth::login::run(&env, false).await
+}

crates/hm/src/commands/init.rs

@@ -88,6 +88,86 @@ fn prompt_skills() -> Result<bool> {
     Ok(install)
 }
 
+/// Prompt the user to link this repo to a Harmont Cloud organization.
+///
+/// Flow:
+/// - If not logged in → offer to log in first (Confirm, default no).
+/// - If logged in (or just logged in) → fetch orgs → Select with "No, skip" as first item.
+/// - On org selection → write a sparse `.hm/config.toml` with `backend = "cloud"` and the org slug.
+///
+/// Silently returns `Ok(())` on any user-cancellation (Esc, Ctrl-C on a prompt).
+async fn prompt_cloud_registration(dir: &std::path::Path) -> Result<()> {
+    let cfg = hm_config::Config::load(None).unwrap_or_default();
+    let api_url = &cfg.cloud.api_url;
+    let is_logged_in = hm_config::creds::cloud_token(api_url).is_some();
+
+    if !is_logged_in {
+        let want_login = dialoguer::Confirm::new()
+            .with_prompt("You are not logged in to Harmont Cloud. Log in now?")
+            .default(false)
+            .interact()
+            .unwrap_or(false);
+
+        if !want_login {
+            return Ok(());
+        }
+
+        hm_plugin_cloud::login_interactive().await?;
+    }
+
+    let (client, _ctx) = hm_plugin_cloud::settings::client()
+        .context("could not build authenticated cloud client")?;
+
+    let orgs = client
+        .raw()
+        .list_organizations(None, None)
+        .await
+        .map_err(hm_plugin_cloud::settings::map_raw)
+        .context("fetching organizations")?
+        .into_inner();
+
+    if orgs.data.is_empty() {
+        tracing::warn!("no organizations found — create one at https://app.harmont.dev");
+        return Ok(());
+    }
+
+    let mut items: Vec<String> = vec!["No, skip".to_string()];
+    items.extend(orgs.data.iter().map(|o| format!("{} ({})", o.name, o.slug)));
+
+    let selection = dialoguer::Select::new()
+        .with_prompt("Link this repo to Harmont Cloud?")
+        .items(&items)
+        .default(0)
+        .interact()
+        .unwrap_or(0);
+
+    if selection == 0 {
+        return Ok(());
+    }
+
+    let chosen = &orgs.data[selection - 1];
+    write_cloud_project_config(dir, &chosen.slug)?;
+    tracing::info!(
+        "linked to {} ({}) — `hm run` will now use Harmont Cloud by default",
+        chosen.name,
+        chosen.slug,
+    );
+    Ok(())
+}
+
+fn write_cloud_project_config(dir: &std::path::Path, org_slug: &str) -> Result<()> {
+    let config_path = dir.join(".hm/config.toml");
+    let content = format!(
+        "backend = \"cloud\"\n\
+         \n\
+         [cloud]\n\
+         org = \"{org_slug}\"\n"
+    );
+    std::fs::write(&config_path, &content)
+        .with_context(|| format!("writing {}", config_path.display()))?;
+    Ok(())
+}
+
 fn write_template(dir: &Path, tmpl: &Template, force: bool) -> Result<bool> {
     let harmont_dir = dir.join(".hm");
     let already_has_pipeline = detect::has_pipeline_files(dir);
@@ -164,7 +244,6 @@ fn has_github_workflows(dir: &Path) -> bool {
 ///
 /// Returns an error if the target directory is unwritable, or if no template
 /// can be determined in a non-interactive context.
-#[allow(clippy::unused_async)]
 pub async fn handle(args: InitArgs) -> Result<()> {
     let tty = std::io::stdin().is_terminal();
     let has_pipeline = detect::has_pipeline_files(&args.dir);
@@ -202,6 +281,10 @@ pub async fn handle(args: InitArgs) -> Result<()> {
         }
     }
 
+    if tty && let Err(e) = prompt_cloud_registration(&args.dir).await {
+        tracing::warn!("cloud registration skipped: {e:#}");
+    }
+
     if has_github_workflows(&args.dir) {
         tracing::info!(
             "detected GitHub Actions workflows in .github/workflows/\n  \
@@ -215,6 +298,17 @@ pub async fn handle(args: InitArgs) -> Result<()> {
         write_skills(&args.dir)?;
     }
 
-    tracing::info!("next step: run `hm run` to execute your pipeline locally");
+    let project_config = hm_config::Config::project_config_path(&args.dir);
+    if project_config.exists() {
+        let cfg =
+            hm_config::Config::load_from_paths(None, Some(&project_config)).unwrap_or_default();
+        if cfg.backend == "cloud" {
+            tracing::info!("next step: run `hm run` to execute your pipeline on Harmont Cloud");
+        } else {
+            tracing::info!("next step: run `hm run` to execute your pipeline locally");
+        }
+    } else {
+        tracing::info!("next step: run `hm run` to execute your pipeline locally");
+    }
     Ok(())
 }

crates/hm/tests/cmd_init.rs

@@ -460,3 +460,37 @@ fn init_without_template_in_non_tty_errors_clearly() {
         "no pipeline should be written when none could be chosen"
     );
 }
+
+// ── cloud registration ──────────────────────────────────────
+
+#[test]
+fn init_noninteractive_skips_cloud_registration() {
+    let dir = tempfile::tempdir().unwrap();
+    hm().args(["init", "--template", "rust", "--dir"])
+        .arg(dir.path())
+        .assert()
+        .success();
+
+    let config = dir.path().join(".hm/config.toml");
+    assert!(
+        !config.exists(),
+        "non-interactive init should not create .hm/config.toml"
+    );
+}
+
+#[test]
+fn cloud_project_config_layers_correctly() {
+    let dir = tempfile::tempdir().unwrap();
+    let hm_dir = dir.path().join(".hm");
+    std::fs::create_dir(&hm_dir).unwrap();
+
+    let config_path = hm_dir.join("config.toml");
+    let content = "backend = \"cloud\"\n\n[cloud]\norg = \"test-org\"\n";
+    std::fs::write(&config_path, content).unwrap();
+
+    let cfg = hm_config::Config::load_from_paths(None, Some(&config_path)).unwrap();
+    assert_eq!(cfg.backend, "cloud");
+    assert_eq!(cfg.cloud.org.as_deref(), Some("test-org"));
+    // Unrelated defaults survive layering.
+    assert_eq!(cfg.preferences.format, "human");
+}