[suiop][env] move to pulumi env interactive for suiop env

crates/suiop-cli/Cargo.toml

@@ -59,6 +59,7 @@ futures-timer = "3.0.3"
 tempfile.workspace = true
 kube = { version = "0.97.0", features = ["client"] }
 k8s-openapi = { version = "0.23.0", features = ["latest"] }
+query-shell = "0.3.0"
 
 
 [dev-dependencies]

crates/suiop-cli/src/cli/env/mod.rs

@@ -1,12 +1,11 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::run_cmd;
+use crate::{command::CommandOptions, run_cmd};
 use anyhow::Result;
 use clap::Parser;
 use inquire::Select;
-use std::io::Write;
-use tracing::{debug, info};
+use query_shell::get_shell_name;
 
 /// Load an environment from pulumi
 ///
@@ -17,8 +16,9 @@ pub struct LoadEnvironmentArgs {
     environment_name: Option<String>,
 }
 
-pub fn load_environment_cmd(args: &LoadEnvironmentArgs) -> Result<()> {
-    setup_pulumi_environment(&args.environment_name.clone().unwrap_or_else(|| {
+pub fn load_environment(args: &LoadEnvironmentArgs) -> Result<()> {
+    // list envs from pulumi using `pulumi env ls`
+    let env = args.environment_name.clone().unwrap_or_else(|| {
         let output = run_cmd(vec!["pulumi", "env", "ls"], None).expect("Running pulumi env ls");
         let output_str = String::from_utf8_lossy(&output.stdout);
         let options: Vec<&str> = output_str.lines().collect();
@@ -31,42 +31,12 @@ pub fn load_environment_cmd(args: &LoadEnvironmentArgs) -> Result<()> {
             .prompt()
             .expect("Failed to select environment")
             .to_owned()
-    }))
-}
-
-pub fn setup_pulumi_environment(environment_name: &str) -> Result<()> {
-    let output = run_cmd(vec!["pulumi", "env", "open", environment_name], None)?;
-    let output_str = String::from_utf8_lossy(&output.stdout);
-    let output_json: serde_json::Value = serde_json::from_str(&output_str)?;
-    let env_vars = &output_json["environmentVariables"];
-    // Open a file to write environment variables
-    let home_dir = std::env::var("HOME").expect("HOME environment variable not set");
-    let suiop_dir = format!("{}/.suiop", home_dir);
-    std::fs::create_dir_all(&suiop_dir).expect("Failed to create .suiop directory");
-    let env_file_path = format!("{}/env_vars", suiop_dir);
-    let mut env_file =
-        std::fs::File::create(&env_file_path).expect("Failed to create env_vars file");
+    });
 
-    if let serde_json::Value::Object(env_vars) = env_vars {
-        for (key, value) in env_vars {
-            if let Some(value_str) = value.as_str() {
-                writeln!(env_file, "{}={}", key, value_str)?;
-                info!("writing environment variable {}", key);
-                debug!("={}", value_str);
-            } else {
-                info!(
-                    "Failed to set environment variable: {}. Value is not a string.",
-                    key
-                );
-            }
-        }
-    } else {
-        info!("Environment variables are not in the expected format.");
-        debug!("env: {:?}", output_json);
-    }
-    info!(
-        "finished loading environment. use `source {}` to load them into your shell",
-        env_file_path
-    );
+    // get the user's shell
+    let shell = get_shell_name()?;
+    // use `pulumi env run <env_name> -i <shell>` to load the environment into the shell
+    let opts = CommandOptions::new(true, false);
+    run_cmd(vec!["pulumi", "env", "run", &env, "-i", &shell], Some(opts))?;
     Ok(())
 }

crates/suiop-cli/src/cli/mod.rs

@@ -14,7 +14,7 @@ mod slack;
 
 pub use ci::{ci_cmd, CIArgs};
 pub use docker::{docker_cmd, DockerArgs};
-pub use env::{load_environment_cmd, LoadEnvironmentArgs};
+pub use env::{load_environment, LoadEnvironmentArgs};
 pub use iam::{iam_cmd, IAMArgs};
 pub use incidents::{incidents_cmd, IncidentsArgs};
 pub use pulumi::{pulumi_cmd, PulumiArgs};

crates/suiop-cli/src/command.rs

@@ -8,6 +8,7 @@ use spinners::Spinner;
 use spinners::Spinners;
 use std::path::PathBuf;
 use std::process::Command;
+use std::process::ExitStatus;
 use std::process::Output;
 use std::process::Stdio;
 use tracing::debug;
@@ -45,7 +46,9 @@ pub fn run_cmd(cmd_in: Vec<&str>, options: Option<CommandOptions>) -> Result<Out
     let opts = options.unwrap_or_default();
 
     let mut cmd = Command::new(cmd_in[0]);
-    cmd.current_dir(opts.current_dir.unwrap_or_default());
+    if let Some(current_dir) = opts.current_dir.clone() {
+        cmd.current_dir(current_dir);
+    }
     // add extra args
     let cmd = if cmd_in.len() > 1 {
         cmd.args(cmd_in[1..].iter())
@@ -59,15 +62,25 @@ pub fn run_cmd(cmd_in: Vec<&str>, options: Option<CommandOptions>) -> Result<Out
     } else {
         cmd
     };
+    debug!("opts: {:?}", opts.clone());
     let res = if opts.show_spinner {
         let mut sp = Spinner::new(SPINNER, "".into());
+        debug!("running command: {:?}", cmd);
         let result = cmd.output().context(format!(
-            "failed to run command with spinner {}",
+            "failed to run command with spinner '{}'",
             cmd_in.join(" ")
         ))?;
         sp.stop();
         print!("\r");
         result
+    } else if opts.shared_stdio {
+        cmd.status()
+            .context(format!("failed to run command {}", cmd_in.join(" ")))?;
+        Output {
+            status: ExitStatus::default(),
+            stdout: Vec::new(),
+            stderr: Vec::new(),
+        }
     } else {
         cmd.output()
             .context(format!("failed to run command {}", cmd_in.join(" ")))?

crates/suiop-cli/src/main.rs

@@ -6,7 +6,7 @@ use clap::Parser;
 use suioplib::{
     cli::{
         ci::{image_cmd, ImageAction, ImageArgs, ImageBuildArgs, ImageQueryArgs},
-        ci_cmd, docker_cmd, iam_cmd, incidents_cmd, load_environment_cmd, pulumi_cmd,
+        ci_cmd, docker_cmd, iam_cmd, incidents_cmd, load_environment, pulumi_cmd,
         service::ServiceAction,
         service_cmd, CIArgs, DockerArgs, IAMArgs, IncidentsArgs, LoadEnvironmentArgs, PulumiArgs,
         ServiceArgs,
@@ -118,7 +118,7 @@ async fn main() -> Result<()> {
             ci_cmd(&args).await?;
         }
         Resource::LoadEnvironment(args) => {
-            load_environment_cmd(&args)?;
+            load_environment(&args)?;
         }
         Resource::Logs => {
             service_cmd(&ServiceArgs {