feat: add 11 missing pm subcommands (login, logout, whoami, token, audit, dist-tag, deprecate, search, rebuild, fund, ping) (#613)

Implements the commands from issue #611. Each command follows existing
patterns: "always npm" commands (token, deprecate, search, fund, ping)
hardcode npm as the binary, while PM-specific commands (login, logout,
whoami, audit, dist-tag, rebuild) branch on the detected package manager
with appropriate mappings for pnpm, npm, yarn@1, and yarn@2+.

Includes CLI definitions, dispatch wiring, unit tests for all command
resolution logic, and updated RFC documentation.

closes VP-191

Author: fengmk2

crates/vite_global_cli/src/cli.rs

@@ -1040,6 +1040,153 @@ pub enum PmCommands {
     /// Manage package manager configuration
     #[command(subcommand, visible_alias = "c")]
     Config(ConfigCommands),
+
+    /// Log in to a registry
+    #[command(visible_alias = "adduser")]
+    Login {
+        /// Registry URL
+        #[arg(long, value_name = "URL")]
+        registry: Option<String>,
+
+        /// Scope for the login
+        #[arg(long, value_name = "SCOPE")]
+        scope: Option<String>,
+
+        /// Additional arguments
+        #[arg(last = true, allow_hyphen_values = true)]
+        pass_through_args: Option<Vec<String>>,
+    },
+
+    /// Log out from a registry
+    Logout {
+        /// Registry URL
+        #[arg(long, value_name = "URL")]
+        registry: Option<String>,
+
+        /// Scope for the logout
+        #[arg(long, value_name = "SCOPE")]
+        scope: Option<String>,
+
+        /// Additional arguments
+        #[arg(last = true, allow_hyphen_values = true)]
+        pass_through_args: Option<Vec<String>>,
+    },
+
+    /// Show the current logged-in user
+    Whoami {
+        /// Registry URL
+        #[arg(long, value_name = "URL")]
+        registry: Option<String>,
+
+        /// Additional arguments
+        #[arg(last = true, allow_hyphen_values = true)]
+        pass_through_args: Option<Vec<String>>,
+    },
+
+    /// Manage authentication tokens
+    #[command(subcommand)]
+    Token(TokenCommands),
+
+    /// Run a security audit
+    Audit {
+        /// Automatically fix vulnerabilities
+        #[arg(long)]
+        fix: bool,
+
+        /// Output in JSON format
+        #[arg(long)]
+        json: bool,
+
+        /// Minimum vulnerability level to report
+        #[arg(long, value_name = "LEVEL")]
+        level: Option<String>,
+
+        /// Only audit production dependencies
+        #[arg(long)]
+        production: bool,
+
+        /// Additional arguments
+        #[arg(last = true, allow_hyphen_values = true)]
+        pass_through_args: Option<Vec<String>>,
+    },
+
+    /// Manage distribution tags
+    #[command(name = "dist-tag", subcommand)]
+    DistTag(DistTagCommands),
+
+    /// Deprecate a package version
+    Deprecate {
+        /// Package name with version (e.g., "my-pkg@1.0.0")
+        package: String,
+
+        /// Deprecation message
+        message: String,
+
+        /// One-time password for authentication
+        #[arg(long, value_name = "OTP")]
+        otp: Option<String>,
+
+        /// Registry URL
+        #[arg(long, value_name = "URL")]
+        registry: Option<String>,
+
+        /// Additional arguments
+        #[arg(last = true, allow_hyphen_values = true)]
+        pass_through_args: Option<Vec<String>>,
+    },
+
+    /// Search for packages in the registry
+    Search {
+        /// Search terms
+        #[arg(required = true, num_args = 1..)]
+        terms: Vec<String>,
+
+        /// Output in JSON format
+        #[arg(long)]
+        json: bool,
+
+        /// Show extended information
+        #[arg(long)]
+        long: bool,
+
+        /// Registry URL
+        #[arg(long, value_name = "URL")]
+        registry: Option<String>,
+
+        /// Additional arguments
+        #[arg(last = true, allow_hyphen_values = true)]
+        pass_through_args: Option<Vec<String>>,
+    },
+
+    /// Rebuild native modules
+    #[command(visible_alias = "rb")]
+    Rebuild {
+        /// Additional arguments
+        #[arg(last = true, allow_hyphen_values = true)]
+        pass_through_args: Option<Vec<String>>,
+    },
+
+    /// Show funding information for installed packages
+    Fund {
+        /// Output in JSON format
+        #[arg(long)]
+        json: bool,
+
+        /// Additional arguments
+        #[arg(last = true, allow_hyphen_values = true)]
+        pass_through_args: Option<Vec<String>>,
+    },
+
+    /// Ping the registry
+    Ping {
+        /// Registry URL
+        #[arg(long, value_name = "URL")]
+        registry: Option<String>,
+
+        /// Additional arguments
+        #[arg(last = true, allow_hyphen_values = true)]
+        pass_through_args: Option<Vec<String>>,
+    },
 }
 
 /// Configuration subcommands
@@ -1153,6 +1300,92 @@ pub enum OwnerCommands {
     },
 }
 
+/// Token subcommands
+#[derive(Subcommand, Debug, Clone)]
+pub enum TokenCommands {
+    /// List all known tokens
+    #[command(visible_alias = "ls")]
+    List {
+        /// Output in JSON format
+        #[arg(long)]
+        json: bool,
+
+        /// Registry URL
+        #[arg(long, value_name = "URL")]
+        registry: Option<String>,
+
+        /// Additional arguments
+        #[arg(last = true, allow_hyphen_values = true)]
+        pass_through_args: Option<Vec<String>>,
+    },
+
+    /// Create a new authentication token
+    Create {
+        /// Output in JSON format
+        #[arg(long)]
+        json: bool,
+
+        /// Registry URL
+        #[arg(long, value_name = "URL")]
+        registry: Option<String>,
+
+        /// CIDR ranges to restrict the token to
+        #[arg(long, value_name = "CIDR")]
+        cidr: Option<Vec<String>>,
+
+        /// Create a read-only token
+        #[arg(long)]
+        readonly: bool,
+
+        /// Additional arguments
+        #[arg(last = true, allow_hyphen_values = true)]
+        pass_through_args: Option<Vec<String>>,
+    },
+
+    /// Revoke an authentication token
+    Revoke {
+        /// Token or token ID to revoke
+        token: String,
+
+        /// Registry URL
+        #[arg(long, value_name = "URL")]
+        registry: Option<String>,
+
+        /// Additional arguments
+        #[arg(last = true, allow_hyphen_values = true)]
+        pass_through_args: Option<Vec<String>>,
+    },
+}
+
+/// Distribution tag subcommands
+#[derive(Subcommand, Debug, Clone)]
+pub enum DistTagCommands {
+    /// List distribution tags for a package
+    #[command(visible_alias = "ls")]
+    List {
+        /// Package name
+        package: Option<String>,
+    },
+
+    /// Add a distribution tag
+    Add {
+        /// Package name with version (e.g., "my-pkg@1.0.0")
+        package_at_version: String,
+
+        /// Tag name
+        tag: String,
+    },
+
+    /// Remove a distribution tag
+    Rm {
+        /// Package name
+        package: String,
+
+        /// Tag name
+        tag: String,
+    },
+}
+
 /// Determine the save dependency type from CLI flags.
 fn determine_save_dependency_type(
     save_dev: bool,

crates/vite_global_cli/src/commands/pm.rs

@@ -7,15 +7,31 @@
 use std::process::ExitStatus;
 
 use vite_install::commands::{
-    cache::CacheCommandOptions, config::ConfigCommandOptions, list::ListCommandOptions,
-    owner::OwnerSubcommand, pack::PackCommandOptions, prune::PruneCommandOptions,
-    publish::PublishCommandOptions, view::ViewCommandOptions,
+    audit::AuditCommandOptions,
+    cache::CacheCommandOptions,
+    config::ConfigCommandOptions,
+    deprecate::DeprecateCommandOptions,
+    dist_tag::{DistTagCommandOptions, DistTagSubcommand},
+    fund::FundCommandOptions,
+    list::ListCommandOptions,
+    login::LoginCommandOptions,
+    logout::LogoutCommandOptions,
+    owner::OwnerSubcommand,
+    pack::PackCommandOptions,
+    ping::PingCommandOptions,
+    prune::PruneCommandOptions,
+    publish::PublishCommandOptions,
+    rebuild::RebuildCommandOptions,
+    search::SearchCommandOptions,
+    token::TokenSubcommand,
+    view::ViewCommandOptions,
+    whoami::WhoamiCommandOptions,
 };
 use vite_path::AbsolutePathBuf;
 
 use super::{build_package_manager, prepend_js_runtime_to_path_env};
 use crate::{
-    cli::{ConfigCommands, OwnerCommands, PmCommands},
+    cli::{ConfigCommands, DistTagCommands, OwnerCommands, PmCommands, TokenCommands},
     error::Error,
 };
 
@@ -228,6 +244,111 @@ pub async fn execute_pm_subcommand(
                 Ok(package_manager.run_config_command(&options, &cwd).await?)
             }
         },
+
+        PmCommands::Login { registry, scope, pass_through_args } => {
+            let options = LoginCommandOptions {
+                registry: registry.as_deref(),
+                scope: scope.as_deref(),
+                pass_through_args: pass_through_args.as_deref(),
+            };
+            Ok(package_manager.run_login_command(&options, &cwd).await?)
+        }
+
+        PmCommands::Logout { registry, scope, pass_through_args } => {
+            let options = LogoutCommandOptions {
+                registry: registry.as_deref(),
+                scope: scope.as_deref(),
+                pass_through_args: pass_through_args.as_deref(),
+            };
+            Ok(package_manager.run_logout_command(&options, &cwd).await?)
+        }
+
+        PmCommands::Whoami { registry, pass_through_args } => {
+            let options = WhoamiCommandOptions {
+                registry: registry.as_deref(),
+                pass_through_args: pass_through_args.as_deref(),
+            };
+            Ok(package_manager.run_whoami_command(&options, &cwd).await?)
+        }
+
+        PmCommands::Token(token_command) => {
+            let subcommand = match token_command {
+                TokenCommands::List { json, registry, pass_through_args } => {
+                    TokenSubcommand::List { json, registry, pass_through_args }
+                }
+                TokenCommands::Create { json, registry, cidr, readonly, pass_through_args } => {
+                    TokenSubcommand::Create { json, registry, cidr, readonly, pass_through_args }
+                }
+                TokenCommands::Revoke { token, registry, pass_through_args } => {
+                    TokenSubcommand::Revoke { token, registry, pass_through_args }
+                }
+            };
+            Ok(package_manager.run_token_command(&subcommand, &cwd).await?)
+        }
+
+        PmCommands::Audit { fix, json, level, production, pass_through_args } => {
+            let options = AuditCommandOptions {
+                fix,
+                json,
+                level: level.as_deref(),
+                production,
+                pass_through_args: pass_through_args.as_deref(),
+            };
+            Ok(package_manager.run_audit_command(&options, &cwd).await?)
+        }
+
+        PmCommands::DistTag(dist_tag_command) => {
+            let subcommand = match dist_tag_command {
+                DistTagCommands::List { package } => DistTagSubcommand::List { package },
+                DistTagCommands::Add { package_at_version, tag } => {
+                    DistTagSubcommand::Add { package_at_version, tag }
+                }
+                DistTagCommands::Rm { package, tag } => DistTagSubcommand::Rm { package, tag },
+            };
+            let options = DistTagCommandOptions { subcommand, pass_through_args: None };
+            Ok(package_manager.run_dist_tag_command(&options, &cwd).await?)
+        }
+
+        PmCommands::Deprecate { package, message, otp, registry, pass_through_args } => {
+            let options = DeprecateCommandOptions {
+                package: &package,
+                message: &message,
+                otp: otp.as_deref(),
+                registry: registry.as_deref(),
+                pass_through_args: pass_through_args.as_deref(),
+            };
+            Ok(package_manager.run_deprecate_command(&options, &cwd).await?)
+        }
+
+        PmCommands::Search { terms, json, long, registry, pass_through_args } => {
+            let options = SearchCommandOptions {
+                terms: &terms,
+                json,
+                long,
+                registry: registry.as_deref(),
+                pass_through_args: pass_through_args.as_deref(),
+            };
+            Ok(package_manager.run_search_command(&options, &cwd).await?)
+        }
+
+        PmCommands::Rebuild { pass_through_args } => {
+            let options = RebuildCommandOptions { pass_through_args: pass_through_args.as_deref() };
+            Ok(package_manager.run_rebuild_command(&options, &cwd).await?)
+        }
+
+        PmCommands::Fund { json, pass_through_args } => {
+            let options =
+                FundCommandOptions { json, pass_through_args: pass_through_args.as_deref() };
+            Ok(package_manager.run_fund_command(&options, &cwd).await?)
+        }
+
+        PmCommands::Ping { registry, pass_through_args } => {
+            let options = PingCommandOptions {
+                registry: registry.as_deref(),
+                pass_through_args: pass_through_args.as_deref(),
+            };
+            Ok(package_manager.run_ping_command(&options, &cwd).await?)
+        }
     }
 }