fix(cli): address Codex review round 4

- vp/vpr script commands with a leading -C run verbatim instead of being
  parsed as CLIArgs (which has no global flags): the spawned binary applies
  the directory change exactly like a direct invocation
- bare app commands in scripts get the same workspace-root target
  elicitation as direct invocations via a pure needs_elicitation predicate:
  the handler spawns the real binary (which elicits identically) instead of
  synthesizing a silent root run
- add --configLoader/--config-loader/--tsconfig/--log-level/
  --deps.never-bundle to the required-value flag list
- PTY regression cases: a root script 'build: vp build' fails with the
  listing through vp run, and a 'vp -C' script runs in the target package

Shell-integration template gaps (env-use wrapper, vpr completers) are
tracked separately in #2056.

Author: fengmk2

crates/vite_cli_snapshots/tests/cli_snapshots/fixtures/app_root_listing/package.json

@@ -1 +1,11 @@
-{ "name": "app-root-listing", "private": true, "workspaces": ["apps/*", "packages/*"] }
+{
+  "name": "app-root-listing",
+  "private": true,
+  "workspaces": [
+    "apps/*",
+    "packages/*"
+  ],
+  "scripts": {
+    "build": "vp build"
+  }
+}

crates/vite_cli_snapshots/tests/cli_snapshots/fixtures/app_root_listing/snapshots.toml

@@ -38,3 +38,13 @@ steps = [
     { "write-key" = "ctrl-c" },
   ] },
 ]
+
+[[case]]
+name = "script_at_root_elicits"
+vp = ["local", "global"]
+comment = """
+A root package script "build": "vp build" run through vp run gets the same
+target elicitation as a direct bare invocation: the spawned vp prints the
+listing and the task fails instead of silently building the root.
+"""
+steps = [{ argv = ["vp", "run", "build"], tty = false }]

crates/vite_cli_snapshots/tests/cli_snapshots/fixtures/app_root_listing/snapshots/script_at_root_elicits.global.md

@@ -0,0 +1,23 @@
+# script_at_root_elicits
+
+A root package script "build": "vp build" run through vp run gets the same
+target elicitation as a direct bare invocation: the spawned vp prints the
+listing and the task fails instead of silently building the root.
+
+## `vp run build`
+
+**Exit code:** 1
+
+```
+$ vp build ⊘ cache disabled
+
+error: `vp build` at the workspace root needs a target package.
+
+  Packages in this workspace:
+    admin  apps/admin
+    web    apps/web
+    ui     packages/ui
+
+  Pass a directory:  vp -C apps/admin build
+  Or run every package's build script:  vp run -r build
+```

crates/vite_cli_snapshots/tests/cli_snapshots/fixtures/app_root_listing/snapshots/script_at_root_elicits.local.md

@@ -0,0 +1,23 @@
+# script_at_root_elicits
+
+A root package script "build": "vp build" run through vp run gets the same
+target elicitation as a direct bare invocation: the spawned vp prints the
+listing and the task fails instead of silently building the root.
+
+## `vp run build`
+
+**Exit code:** 1
+
+```
+$ vp build ⊘ cache disabled
+
+error: `vp build` at the workspace root needs a target package.
+
+  Packages in this workspace:
+    admin  apps/admin
+    web    apps/web
+    ui     packages/ui
+
+  Pass a directory:  vp -C apps/admin build
+  Or run every package's build script:  vp run -r build
+```

crates/vite_cli_snapshots/tests/cli_snapshots/fixtures/cwd_flag/package.json

@@ -1 +1,10 @@
-{ "name": "cwd-flag", "private": true, "workspaces": ["packages/*"] }
+{
+  "name": "cwd-flag",
+  "private": true,
+  "workspaces": [
+    "packages/*"
+  ],
+  "scripts": {
+    "where:hello": "vp -C packages/hello run where"
+  }
+}

crates/vite_cli_snapshots/tests/cli_snapshots/fixtures/cwd_flag/snapshots.toml

@@ -17,4 +17,5 @@ steps = [
   { argv = ["vp", "-C", "packages/missing", "build"], comment = "missing directory errors" },
   { argv = ["vp", "pack", "packages/hello"], comment = "positional stays a tsdown entry resolved from the invocation directory" },
   { argv = ["vpt", "list-dir", "dist"], comment = "upstream semantics: output lands at the invocation directory" },
+  { argv = ["vp", "run", "where:hello"], comment = "a script whose command starts with vp -C runs verbatim and honors the directory" },
 ]

crates/vite_cli_snapshots/tests/cli_snapshots/fixtures/cwd_flag/snapshots/cwd_flag.global.md

@@ -101,3 +101,17 @@ upstream semantics: output lands at the invocation directory
 ```
 hello.mjs
 ```
+
+## `vp run where:hello`
+
+a script whose command starts with vp -C runs verbatim and honors the directory
+
+```
+VITE+ - The Unified Toolchain for the Web
+
+$ vp -C packages/hello run where ⊘ cache disabled
+VITE+ - The Unified Toolchain for the Web
+
+~/packages/hello$ node -e "console.log('cwd base: ' + require('node:path').basename(process.cwd()))" ⊘ cache disabled
+cwd base: hello
+```

crates/vite_cli_snapshots/tests/cli_snapshots/fixtures/cwd_flag/snapshots/cwd_flag.local.md

@@ -91,3 +91,13 @@ upstream semantics: output lands at the invocation directory
 ```
 hello.mjs
 ```
+
+## `vp run where:hello`
+
+a script whose command starts with vp -C runs verbatim and honors the directory
+
+```
+$ vp -C packages/hello run where ⊘ cache disabled
+~/packages/hello$ node -e "console.log('cwd base: ' + require('node:path').basename(process.cwd()))" ⊘ cache disabled
+cwd base: hello
+```

packages/cli/binding/src/cli/app_target.rs

@@ -62,6 +62,11 @@ const VALUE_TAKING_FLAGS: &[&str] = &[
     "--assetsDir",
     "--assetsInlineLimit",
     "--filter",
+    "--configLoader",
+    "--config-loader",
+    "--tsconfig",
+    "--log-level",
+    "--deps.never-bundle",
     "-d",
     "--out-dir",
     "--target",
@@ -190,6 +195,31 @@ fn run_package_picker(command: &str, rows: &[PackageRow]) -> Result<Option<usize
     })
 }
 
+/// Pure predicate for the vp-script interception: would `resolve_app_target`
+/// do anything other than run in `cwd`? Never prints and never runs the
+/// picker. Slightly over-approximates (an empty workspace reports true), in
+/// which case the script merely spawns the real binary, which then behaves
+/// identically to a direct invocation.
+pub(super) fn needs_elicitation(
+    subcommand: &SynthesizableSubcommand,
+    cwd: &AbsolutePathBuf,
+) -> bool {
+    let Some((_, args)) = app_command_parts(subcommand) else {
+        return false;
+    };
+    if !is_bare(args) {
+        return false;
+    }
+    if vite_static_config::resolve_static_config(cwd).get_declared("defaultPackage").is_some() {
+        return true;
+    }
+    let Ok((workspace_root, rel_from_root)) = vite_workspace::find_workspace_root(cwd) else {
+        return false;
+    };
+    rel_from_root.as_str().is_empty()
+        && !matches!(workspace_root.workspace_file, WorkspaceFile::NonWorkspacePackage(_))
+}
+
 pub(super) fn resolve_app_target(
     subcommand: &SynthesizableSubcommand,
     cwd: &AbsolutePathBuf,

packages/cli/binding/src/cli/handler.rs

@@ -44,6 +44,17 @@ impl CommandHandler for VitePlusCommandHandler {
         if program != "vp" && program != "vpr" {
             return Ok(HandledCommand::Verbatim);
         }
+        // A leading global `-C` runs verbatim: CLIArgs has no global flags, and
+        // the spawned vp/vpr binary applies the directory change (and target
+        // elicitation) exactly like a direct invocation.
+        if command
+            .args
+            .first()
+            .map(Str::as_str)
+            .is_some_and(|arg| arg == "-C" || (arg.starts_with("-C") && arg.len() > 2))
+        {
+            return Ok(HandledCommand::Verbatim);
+        }
         // "vpr <args>" is shorthand for "vp run <args>", so prepend "run" for parsing.
         let is_vpr = program == "vpr";
         let cli_args = match CLIArgs::try_parse_from(
@@ -72,6 +83,14 @@ impl CommandHandler for VitePlusCommandHandler {
                 )))
             }
             CLIArgs::Synthesizable(subcmd) => {
+                // Bare app commands in scripts get the same workspace-root
+                // target elicitation as direct invocations: spawn the real
+                // binary, which elicits (defaultPackage note, listing +
+                // exit 1) identically instead of silently running the root.
+                let cwd = command.cwd.to_absolute_path_buf();
+                if super::app_target::needs_elicitation(&subcmd, &cwd) {
+                    return Ok(HandledCommand::Verbatim);
+                }
                 let resolved = self.resolver.resolve(subcmd, None, &command.envs).await?;
                 Ok(HandledCommand::Synthesized(resolved.into_synthetic_plan_request()))
             }