feat: add tracing to callbacks, NAPI entry, and JS startup

Instrument vite-plus callback implementations (handle_command,
load_user_config_file, resolve), NAPI bridge (run, JS resolvers,
vite config resolver), and JS startup timing for performance
measurement.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: branchseer

packages/cli/binding/src/cli.rs

@@ -277,6 +277,7 @@ impl SubcommandResolver {
     }
 
     /// Resolve a synthesizable subcommand to a concrete program, args, cache config, and envs.
+    #[tracing::instrument(level = "debug", skip_all)]
     async fn resolve(
         &mut self,
         subcommand: SynthesizableSubcommand,
@@ -602,6 +603,7 @@ impl CommandHandler for VitePlusCommandHandler {
         &mut self,
         command: &mut ScriptCommand,
     ) -> anyhow::Result<HandledCommand> {
+        let _span = tracing::debug_span!("handle_command").entered();
         // Intercept both "vp" and "vite" commands in task scripts.
         // "vp" is the conventional alias used in vite-plus task configs.
         // "vite" must also be intercepted so that `vite test`, `vite build`, etc.
@@ -655,6 +657,8 @@ impl UserConfigLoader for VitePlusConfigLoader {
         &self,
         package_path: &AbsolutePath,
     ) -> anyhow::Result<Option<UserRunConfig>> {
+        let _span = tracing::debug_span!("load_user_config_file").entered();
+
         // Try static config extraction first (no JS runtime needed)
         if let Some(static_fields) = vite_static_config::resolve_static_config(package_path) {
             match static_fields.get("run") {
@@ -701,6 +705,7 @@ impl UserConfigLoader for VitePlusConfigLoader {
 }
 
 /// Resolve a single subcommand and execute it, returning its exit status.
+#[tracing::instrument(level = "debug", skip_all)]
 async fn resolve_and_execute(
     resolver: &mut SubcommandResolver,
     subcommand: SynthesizableSubcommand,
@@ -742,6 +747,7 @@ async fn resolve_and_execute(
 
 /// Execute a synthesizable subcommand directly (not through vite-task Session).
 /// No caching, no task graph, no dependency resolution.
+#[tracing::instrument(level = "debug", skip_all)]
 async fn execute_direct_subcommand(
     subcommand: SynthesizableSubcommand,
     cwd: &AbsolutePathBuf,
@@ -865,6 +871,7 @@ async fn execute_direct_subcommand(
 }
 
 /// Execute a vite-task command (run, cache) through Session.
+#[tracing::instrument(level = "debug", skip_all)]
 async fn execute_vite_task_command(
     command: Command,
     cwd: AbsolutePathBuf,

packages/cli/binding/src/lib.rs

@@ -75,6 +75,7 @@ fn create_resolver(
     Box::new(move || {
         let tsf = tsf.clone();
         Box::pin(async move {
+            let _span = tracing::debug_span!("js_resolver", resolver = error_message).entered();
             // Call JS function - map napi::Error to anyhow::Error
             let promise: Promise<JsCommandResolvedResult> = tsf
                 .call_async(Ok(()))
@@ -97,6 +98,7 @@ fn create_vite_config_resolver(
     Arc::new(move |package_path: String| {
         let tsf = tsf.clone();
         Box::pin(async move {
+            let _span = tracing::debug_span!("js_resolve_vite_config").entered();
             let promise: Promise<String> = tsf
                 .call_async(Ok(package_path))
                 .await
@@ -118,6 +120,7 @@ fn create_vite_config_resolver(
 /// and process JavaScript callbacks (via ThreadsafeFunction).
 #[napi]
 pub async fn run(options: CliOptions) -> Result<i32> {
+    let _span = tracing::debug_span!("napi_run").entered();
     // Use provided cwd or current directory
     let mut cwd = current_dir()?;
     if let Some(options_cwd) = options.cwd {

packages/cli/src/bin.ts

@@ -10,6 +10,8 @@
  * If no local installation is found, this global dist/bin.js is used as fallback.
  */
 
+const jsStartTime = performance.now();
+
 import { run } from '../binding/index.js';
 import { doc } from './resolve-doc.js';
 import { fmt } from './resolve-fmt.js';
@@ -43,6 +45,11 @@ if (command === 'create') {
   await import('./global/version.js');
 } else {
   // All other commands — delegate to Rust core via NAPI binding
+  if (process.env.VITE_LOG) {
+    console.log(
+      `[vite-plus] JS startup: ${(performance.now() - jsStartTime).toFixed(2)}ms`,
+    );
+  }
   run({
     lint,
     pack,