feat(pm): auto run install

Author: fengmk2

crates/vite_task/src/config/mod.rs

@@ -65,6 +65,10 @@ pub struct ResolvedTask {
     pub args: Arc<[Str]>,
     pub resolved_config: ResolvedTaskConfig,
     pub resolved_command: ResolvedTaskCommand,
+    /// If true, the task will not be replayed from the cache.
+    /// This is useful for tasks that should not be replayed, like auto run install command.
+    /// TODO: this is a temporary solution, we should find a better way to handle this.
+    pub ignore_replay: bool,
 }
 
 impl ResolvedTask {
@@ -119,6 +123,7 @@ impl ResolvedTask {
             task_name,
             args,
             ResolveCommandResult { bin_path, envs },
+            false,
         )
     }
 
@@ -127,6 +132,7 @@ impl ResolvedTask {
         task_name: &str,
         args: impl Iterator<Item = impl AsRef<str>> + Clone,
         command_result: ResolveCommandResult,
+        ignore_replay: bool,
     ) -> Result<Self, Error> {
         let ResolveCommandResult { bin_path, envs } = command_result;
         let builtin_task = TaskCommand::Parsed(TaskParsedCommand {
@@ -156,6 +162,7 @@ impl ResolvedTask {
             args: args.map(|arg| arg.as_ref().into()).collect(),
             resolved_config: resolved_task_config,
             resolved_command,
+            ignore_replay,
         })
     }
 }

crates/vite_task/src/config/workspace.rs

@@ -229,6 +229,7 @@ impl Workspace {
             args: task_args,
             resolved_command,
             resolved_config,
+            ignore_replay: false,
         })
     }
 

crates/vite_task/src/execute.rs

@@ -186,8 +186,16 @@ fn is_default_passthrough_env(name: &str) -> bool {
     }
 
     // Wildcard patterns for common development tools and platforms
-    const WILDCARD_PATTERNS: &[&str] =
-        &["VSCODE_*", "DOCKER_*", "BUILDKIT_*", "COMPOSE_*", "JB_IDE_*", "VERCEL_*", "NEXT_*"];
+    const WILDCARD_PATTERNS: &[&str] = &[
+        "VSCODE_*",
+        "DOCKER_*",
+        "BUILDKIT_*",
+        "COMPOSE_*",
+        "JB_IDE_*",
+        "VERCEL_*",
+        "NEXT_*",
+        "*_TOKEN",
+    ];
 
     // Check wildcard patterns
     for pattern in WILDCARD_PATTERNS {
@@ -264,6 +272,7 @@ impl TaskEnvs {
                 );
             }
         }
+        tracing::debug!("all_envs: {:?}", all_envs);
 
         Ok(Self { all_envs, envs_without_pass_through })
     }
@@ -471,6 +480,7 @@ mod tests {
         assert!(is_default_passthrough_env("JB_IDE_PROJECT_DIR"));
         assert!(is_default_passthrough_env("VERCEL_URL"));
         assert!(is_default_passthrough_env("NEXT_PUBLIC_API_URL"));
+        assert!(is_default_passthrough_env("API_TOKEN"));
 
         // Test patterns that should not match anymore (since we removed the example patterns)
         assert!(!is_default_passthrough_env("MY_TEST_VARIABLE"));
@@ -479,7 +489,6 @@ mod tests {
 
         // Test variables that should NOT be passed through
         assert!(!is_default_passthrough_env("SECRET_KEY"));
-        assert!(!is_default_passthrough_env("API_TOKEN"));
         assert!(!is_default_passthrough_env("CUSTOM_VAR"));
         assert!(!is_default_passthrough_env("RANDOM_ENV"));
         assert!(!is_default_passthrough_env("MY_SECRET"));

crates/vite_task/src/install.rs

@@ -22,6 +22,7 @@ use vite_path::AbsolutePathBuf;
 ///
 pub struct InstallCommand {
     workspace_root: AbsolutePathBuf,
+    ignore_replay: bool,
 }
 
 /// Install command builder.
@@ -30,6 +31,7 @@ pub struct InstallCommand {
 ///
 pub struct InstallCommandBuilder {
     workspace_root: AbsolutePathBuf,
+    ignore_replay: bool,
 }
 
 impl InstallCommand {
@@ -58,6 +60,7 @@ impl InstallCommand {
             "install",
             iter::once("install").chain(args.iter().map(String::as_str)),
             ResolveCommandResult { bin_path: resolve_command.bin_path, envs: resolve_command.envs },
+            self.ignore_replay,
         )?;
         let mut task_graph: StableGraph<ResolvedTask, ()> = Default::default();
         task_graph.add_node(resolved_task);
@@ -70,11 +73,16 @@ impl InstallCommand {
 
 impl InstallCommandBuilder {
     pub fn new(workspace_root: AbsolutePathBuf) -> Self {
-        Self { workspace_root }
+        Self { workspace_root, ignore_replay: false }
+    }
+
+    pub fn ignore_replay(mut self) -> Self {
+        self.ignore_replay = true;
+        self
     }
 
     pub fn build(self) -> InstallCommand {
-        InstallCommand { workspace_root: self.workspace_root }
+        InstallCommand { workspace_root: self.workspace_root, ignore_replay: self.ignore_replay }
     }
 }
 

crates/vite_task/src/lib.rs

@@ -105,6 +105,17 @@ const fn resolve_bool_flag(positive: bool, negative: bool) -> bool {
     if negative { false } else { positive }
 }
 
+/// Automatically run install command
+async fn auto_install(workspace_root: &AbsolutePathBuf) -> Result<(), Error> {
+    tracing::debug!("Running install automatically...");
+    crate::install::InstallCommand::builder(workspace_root.clone())
+        .ignore_replay()
+        .build()
+        .execute(&vec![])
+        .await?;
+    Ok(())
+}
+
 pub struct CliOptions<
     Lint: Future<Output = Result<ResolveCommandResult, Error>> = Pin<
         Box<dyn Future<Output = Result<ResolveCommandResult, Error>>>,
@@ -171,6 +182,11 @@ pub async fn main<
     args: Args,
     options: Option<CliOptions<Lint, LintFn, Vite, ViteFn, Test, TestFn>>,
 ) -> Result<(), Error> {
+    // Auto-install dependencies if needed, but skip for install command itself
+    if !matches!(args.commands, Some(Commands::Install { .. })) {
+        auto_install(&cwd).await?;
+    }
+
     let mut recursive_run = false;
     let mut parallel_run = false;
     let (tasks, mut workspace, task_args) = match &args.commands {

crates/vite_task/src/schedule.rs

@@ -83,6 +83,7 @@ impl ExecutionPlan {
         let command = step.resolved_command.fingerprint.command.clone();
         let cwd = step.resolved_command.fingerprint.cwd.clone();
         let pretty_command = format!("~/{}$ {}", cwd, command);
+        let ignore_replay = step.ignore_replay;
 
         // Check cache and prepare execution
         let (cache_miss, execute_or_replay) = get_cached_or_execute(
@@ -112,12 +113,14 @@ impl ExecutionPlan {
                 );
             }
             None => {
-                println!(
-                    "{} {} {}",
-                    "►".style(Style::new().bright_green()),
-                    pretty_command.style(Style::new().dimmed()),
-                    "(Cache hit, replaying)".style(Style::new().green())
-                );
+                if !ignore_replay {
+                    println!(
+                        "{} {} {}",
+                        "►".style(Style::new().bright_green()),
+                        pretty_command.style(Style::new().dimmed()),
+                        "(Cache hit, replaying)".style(Style::new().green())
+                    );
+                }
             }
         }
 
@@ -140,6 +143,9 @@ async fn get_cached_or_execute<'a>(
             None,
             ({
                 async move {
+                    if task.ignore_replay {
+                        return Ok(());
+                    }
                     // replay
                     let std_outputs = Arc::clone(&cache_task.std_outputs);
                     let mut stdout = tokio::io::stdout();