Port packages/tools bins to single Rust binary (vtt)

.github/workflows/ci.yml

@@ -127,10 +127,20 @@ jobs:
       # Must run after setup-node so correct native binaries are installed
       - run: pnpm install
 
-      - run: cargo test --target ${{ matrix.target }}
+      - name: Build tests
+        run: cargo test --no-run --target ${{ matrix.target }}
         if: ${{ matrix.os != 'ubuntu-latest' }}
 
-      - run: cargo-zigbuild test --target x86_64-unknown-linux-gnu.2.17
+      - name: Build tests
+        run: cargo-zigbuild test --no-run --target x86_64-unknown-linux-gnu.2.17
+        if: ${{ matrix.os == 'ubuntu-latest' }}
+
+      - name: Run tests
+        run: cargo test --target ${{ matrix.target }}
+        if: ${{ matrix.os != 'ubuntu-latest' }}
+
+      - name: Run tests
+        run: cargo-zigbuild test --target x86_64-unknown-linux-gnu.2.17
         if: ${{ matrix.os == 'ubuntu-latest' }}
 
   test-musl:
@@ -175,7 +185,11 @@ jobs:
           corepack enable
           pnpm install
 
-      - run: cargo test
+      - name: Build tests
+        run: cargo test --no-run
+
+      - name: Run tests
+        run: cargo test
 
   fmt:
     name: Format and Check Deps

Cargo.toml

@@ -93,8 +93,8 @@ os_str_bytes = "7.1.1"
 ouroboros = "0.18.5"
 owo-colors = { version = "4.1.0", features = ["supports-colors"] }
 passfd = { git = "https://github.com/polachok/passfd", rev = "d55881752c16aced1a49a75f9c428d38d3767213", default-features = false }
+notify = "8.0.0"
 path-clean = "1.0.1"
-pathdiff = "0.2.3"
 petgraph = "0.8.2"
 phf = { version = "0.11.3", features = ["macros"] }
 portable-pty = "0.9.0"
@@ -167,6 +167,9 @@ ignored = [
 # and we don't rely on it for debugging that much.
 debug = false
 
+[profile.test]
+debug = false
+
 [profile.release]
 # Configurations explicitly listed here for clarity.
 # Using the best options for performance.

crates/vite_task_bin/Cargo.toml

@@ -10,12 +10,17 @@ rust-version.workspace = true
 name = "vt"
 path = "src/main.rs"
 
+[[bin]]
+name = "vtt"
+path = "src/vtt/main.rs"
+
 [dependencies]
 anyhow = { workspace = true }
+libc = { workspace = true }
+notify = { workspace = true }
 async-trait = { workspace = true }
 clap = { workspace = true, features = ["derive"] }
 jsonc-parser = { workspace = true }
-rustc-hash = { workspace = true }
 serde_json = { workspace = true }
 tokio = { workspace = true, features = ["full"] }
 vite_path = { workspace = true }
@@ -27,7 +32,6 @@ which = { workspace = true }
 cow-utils = { workspace = true }
 cp_r = { workspace = true }
 insta = { workspace = true, features = ["glob", "json", "redactions", "filters", "ron"] }
-pathdiff = { workspace = true }
 pty_terminal = { workspace = true }
 pty_terminal_test = { workspace = true }
 regex = { workspace = true }

crates/vite_task_bin/src/lib.rs

@@ -6,7 +6,6 @@ use std::{
 };
 
 use clap::Parser;
-use rustc_hash::FxHashMap;
 use vite_path::AbsolutePath;
 use vite_str::Str;
 use vite_task::{
@@ -47,44 +46,25 @@ pub fn find_executable(
     Ok(executable_path.into_os_string().into())
 }
 
-/// Create a synthetic plan request for running a tool from `node_modules/.bin`.
+/// Internal argument parser for `vt`/`vp` commands that appear inside task scripts.
 ///
-/// # Errors
-///
-/// Returns an error if the executable cannot be found.
-fn synthesize_node_modules_bin_task(
-    executable_name: &str,
-    args: &[Str],
-    envs: &Arc<FxHashMap<Arc<OsStr>, Arc<OsStr>>>,
-    cwd: &Arc<AbsolutePath>,
-) -> anyhow::Result<SyntheticPlanRequest> {
-    Ok(SyntheticPlanRequest {
-        program: find_executable(get_path_env(envs), cwd, executable_name)?,
-        args: args.into(),
-        cache_config: UserCacheConfig::with_config(EnabledCacheConfig {
-            env: None,
-            untracked_env: None,
-            input: None,
-        }),
-        envs: Arc::clone(envs),
-    })
-}
-
+/// [`CommandHandler`] uses this to parse the command line when it intercepts a `vt` or `vp`
+/// invocation during script execution. It extends [`Command`] with a `tool` subcommand that
+/// forwards to the `vtt` test-utility binary — a subcommand that only makes sense within
+/// script execution and is therefore not exposed on the top-level `vt` CLI entry point.
 #[derive(Debug, Parser)]
 #[command(name = "vt", version)]
-pub enum Args {
-    Lint {
+enum Args {
+    /// Forward arguments to the `vtt` test-utility binary.
+    ///
+    /// Resolves `vtt` via `node_modules/.bin` lookup (same as any other script executable),
+    /// then synthesizes a cached invocation with the given arguments. The `--` separator,
+    /// if present, is stripped before forwarding.
+    Tool {
         #[clap(trailing_var_arg = true, allow_hyphen_values = true)]
         args: Vec<Str>,
     },
-    Test {
-        #[clap(trailing_var_arg = true, allow_hyphen_values = true)]
-        args: Vec<Str>,
-    },
-    EnvTest {
-        name: Str,
-        value: Str,
-    },
+    /// Any other `vt` subcommand, delegated to the standard [`Command`] parser.
     #[command(flatten)]
     Task(Command),
 }
@@ -109,30 +89,17 @@ impl vite_task::CommandHandler for CommandHandler {
             std::iter::once(command.program.as_str()).chain(command.args.iter().map(Str::as_str)),
         )?;
         match args {
-            Args::Lint { args } => Ok(HandledCommand::Synthesized(
-                synthesize_node_modules_bin_task("oxlint", &args, &command.envs, &command.cwd)?,
-            )),
-            Args::Test { args } => Ok(HandledCommand::Synthesized(
-                synthesize_node_modules_bin_task("vitest", &args, &command.envs, &command.cwd)?,
-            )),
-            Args::EnvTest { name, value } => {
-                let mut envs = FxHashMap::clone(&command.envs);
-                envs.insert(
-                    Arc::from(OsStr::new(name.as_str())),
-                    Arc::from(OsStr::new(value.as_str())),
-                );
-
+            Args::Tool { args } => {
+                let program = find_executable(get_path_env(&command.envs), &command.cwd, "vtt")?;
                 Ok(HandledCommand::Synthesized(SyntheticPlanRequest {
-                    program: find_executable(get_path_env(&envs), &command.cwd, "print-env")?,
-                    args: [name.clone()].into(),
-                    cache_config: UserCacheConfig::with_config({
-                        EnabledCacheConfig {
-                            env: None,
-                            untracked_env: Some(vec![name]),
-                            input: None,
-                        }
+                    program,
+                    args: args.into_iter().filter(|a| a.as_str() != "--").collect(),
+                    cache_config: UserCacheConfig::with_config(EnabledCacheConfig {
+                        env: None,
+                        untracked_env: None,
+                        input: None,
                     }),
-                    envs: Arc::new(envs),
+                    envs: Arc::clone(&command.envs),
                 }))
             }
             Args::Task(parsed) => Ok(HandledCommand::ViteTaskCommand(parsed)),

crates/vite_task_bin/src/main.rs

@@ -1,59 +1,18 @@
-use std::{process::ExitCode, sync::Arc};
+use std::process::ExitCode;
 
-use clap::Parser;
-use vite_str::Str;
-use vite_task::{
-    EnabledCacheConfig, ExitStatus, Session, UserCacheConfig, get_path_env,
-    plan_request::SyntheticPlanRequest,
-};
-use vite_task_bin::{Args, OwnedSessionConfig, find_executable};
+use clap::Parser as _;
+use vite_task::{Command, ExitStatus, Session};
+use vite_task_bin::OwnedSessionConfig;
 
 #[tokio::main]
 async fn main() -> anyhow::Result<ExitCode> {
-    #[expect(clippy::large_futures, reason = "top-level await in main, no alternative")]
     let exit_status = run().await?;
     Ok(exit_status.0.into())
 }
 
 async fn run() -> anyhow::Result<ExitStatus> {
-    let args = Args::parse();
+    let args = Command::parse();
     let mut owned_config = OwnedSessionConfig::default();
     let session = Session::init(owned_config.as_config())?;
-    match args {
-        Args::Task(parsed) => session.main(parsed).await,
-        args => {
-            // If env FOO is set, run `print-env FOO` via Session::exec before proceeding.
-            // In vite-plus, Session::exec is used for auto-install.
-            let envs = session.envs();
-            if envs.contains_key(std::ffi::OsStr::new("FOO")) {
-                let program = find_executable(get_path_env(envs), session.cwd(), "print-env")?;
-                let request = SyntheticPlanRequest {
-                    program,
-                    args: [Str::from("FOO")].into(),
-                    cache_config: UserCacheConfig::with_config({
-                        EnabledCacheConfig {
-                            env: Some(Box::from([Str::from("FOO")])),
-                            untracked_env: None,
-                            input: None,
-                        }
-                    }),
-                    envs: Arc::clone(envs),
-                };
-                let cache_key: Arc<[Str]> = Arc::from([Str::from("print-env-foo")]);
-                #[expect(
-                    clippy::large_futures,
-                    reason = "execute_synthetic produces a large future"
-                )]
-                let status = session.execute_synthetic(request, cache_key, true).await?;
-                if status != ExitStatus::SUCCESS {
-                    return Ok(status);
-                }
-            }
-            #[expect(clippy::print_stdout, reason = "CLI binary output for non-task commands")]
-            {
-                println!("{args:?}");
-            }
-            Ok(ExitStatus::SUCCESS)
-        }
-    }
+    session.main(args).await
 }