mod extension_installers;
mod install;
use install::*;
mod update;
use update::*;
mod manifest;
use manifest::*;
mod fallback;
use fallback::*;
mod flex_install;
use flex_install::*;
mod dump;
use dump::*;
mod remove;
use remove::*;
mod flex;
mod flex_recipes;
mod no_install;
mod plugin_order;
mod require;
mod scripts;
mod verbose_listeners;
use anyhow::Context as _;
use clap::Parser;
use std::path::PathBuf;
use std::sync::Arc;
#[derive(Parser, Debug)]
#[command(
name = "vivacity",
version,
about = "Fast, Composer-compatible installer"
)]
enum Cli {
Install(InstallArgs),
#[command(name = "dump-autoload", alias = "dumpautoload")]
DumpAutoload(DumpArgs),
#[command(alias = "upgrade")]
Update(UpdateArgs),
#[command(alias = "rm")]
Remove(RemoveArgs),
#[command(alias = "r")]
Require(RequireArgs),
}
#[derive(clap::Args, Debug)]
struct RequireArgs {
#[arg(value_name = "PACKAGES")]
packages: Vec<String>,
#[arg(long)]
dev: bool,
#[arg(long)]
dry_run: bool,
#[arg(long)]
prefer_source: bool,
#[arg(long)]
prefer_dist: bool,
#[arg(long)]
prefer_install: Option<String>,
#[arg(long)]
fixed: bool,
#[arg(long)]
no_suggest: bool,
#[arg(long)]
no_progress: bool,
#[arg(long)]
no_update: bool,
#[arg(long)]
no_install: bool,
#[arg(long)]
no_audit: bool,
#[arg(long, value_name = "FORMAT")]
audit_format: Option<String>,
#[arg(long)]
no_blocking: bool,
#[arg(long)]
no_security_blocking: bool,
#[arg(long)]
update_no_dev: bool,
#[arg(short = 'w', long)]
update_with_dependencies: bool,
#[arg(long)]
with_dependencies: bool,
#[arg(short = 'W', long)]
update_with_all_dependencies: bool,
#[arg(long)]
with_all_dependencies: bool,
#[arg(short = 'm', long)]
minimal_changes: bool,
#[arg(long)]
prefer_stable: bool,
#[arg(long)]
prefer_lowest: bool,
#[arg(long)]
sort_packages: bool,
#[arg(short = 'o', long)]
optimize_autoloader: bool,
#[arg(short = 'a', long)]
classmap_authoritative: bool,
#[arg(long)]
apcu_autoloader: bool,
#[arg(long, value_name = "PREFIX")]
apcu_autoloader_prefix: Option<String>,
#[arg(long)]
ignore_platform_reqs: bool,
#[arg(long = "ignore-platform-req", value_name = "REQ")]
ignore_platform_req: Vec<String>,
#[arg(short = 'n', long)]
no_interaction: bool,
#[arg(short = 'q', long)]
quiet: bool,
#[arg(short = 'v', long, action = clap::ArgAction::Count)]
verbose: u8,
#[arg(long)]
no_ansi: bool,
#[arg(long)]
no_scripts: bool,
#[arg(long)]
no_plugins: bool,
#[arg(long)]
no_autoloader: bool,
#[arg(long)]
no_fallback: bool,
#[arg(long)]
offline: bool,
#[arg(long, value_name = "DIR")]
working_dir: Option<PathBuf>,
}
#[derive(clap::Args, Debug, Default)]
struct GlobalCompatArgs {
#[arg(short = 'n', long)]
no_interaction: bool,
#[arg(short = 'q', long)]
quiet: bool,
#[arg(short = 'v', long, action = clap::ArgAction::Count)]
verbose: u8,
#[arg(long)]
no_ansi: bool,
}
#[derive(clap::Args, Debug)]
struct RemoveArgs {
#[arg(value_name = "PACKAGES")]
packages: Vec<String>,
#[arg(long)]
dev: bool,
#[arg(long)]
no_update: bool,
#[arg(long)]
no_install: bool,
#[arg(long)]
no_audit: bool,
#[arg(long)]
update_no_dev: bool,
#[arg(short = 'w', long)]
update_with_dependencies: bool,
#[arg(short = 'W', long)]
update_with_all_dependencies: bool,
#[arg(long)]
with_all_dependencies: bool,
#[arg(long)]
no_update_with_dependencies: bool,
#[arg(long)]
unused: bool,
#[arg(long)]
dry_run: bool,
#[arg(short = 'm', long)]
minimal_changes: bool,
#[arg(short = 'n', long)]
no_interaction: bool,
#[arg(long)]
no_blocking: bool,
#[arg(long)]
no_security_blocking: bool,
#[arg(long, value_name = "FORMAT")]
audit_format: Option<String>,
#[arg(long)]
apcu_autoloader: bool,
#[arg(long, value_name = "PREFIX")]
apcu_autoloader_prefix: Option<String>,
#[arg(short = 'q', long)]
quiet: bool,
#[arg(short = 'v', long, action = clap::ArgAction::Count)]
verbose: u8,
#[arg(long)]
no_ansi: bool,
#[arg(long)]
no_progress: bool,
#[arg(long)]
no_scripts: bool,
#[arg(long)]
no_plugins: bool,
#[arg(long)]
no_autoloader: bool,
#[arg(short = 'o', long)]
optimize_autoloader: bool,
#[arg(short = 'a', long)]
classmap_authoritative: bool,
#[arg(long)]
ignore_platform_reqs: bool,
#[arg(long = "ignore-platform-req", value_name = "REQ")]
ignore_platform_req: Vec<String>,
#[arg(long)]
no_fallback: bool,
#[arg(long)]
offline: bool,
#[arg(long, value_name = "DIR")]
working_dir: Option<PathBuf>,
}
#[derive(clap::Args, Debug)]
struct UpdateArgs {
#[command(flatten)]
compat: GlobalCompatArgs,
#[arg(long)]
no_progress: bool,
#[arg(value_name = "PACKAGES")]
packages: Vec<String>,
#[arg(long = "with", value_name = "REQ")]
with: Vec<String>,
#[arg(short = 'w', long)]
with_dependencies: bool,
#[arg(short = 'W', long)]
with_all_dependencies: bool,
#[arg(long)]
no_install: bool,
#[arg(long)]
dry_run: bool,
#[arg(long)]
no_dev: bool,
#[arg(long)]
no_autoloader: bool,
#[arg(short = 'o', long)]
optimize_autoloader: bool,
#[arg(short = 'a', long)]
classmap_authoritative: bool,
#[arg(long)]
apcu_autoloader: bool,
#[arg(long, value_name = "PREFIX")]
apcu_autoloader_prefix: Option<String>,
#[arg(long)]
no_scripts: bool,
#[arg(long)]
no_plugins: bool,
#[arg(long)]
no_audit: bool,
#[arg(long)]
no_blocking: bool,
#[arg(long)]
no_security_blocking: bool,
#[arg(long)]
prefer_stable: bool,
#[arg(long)]
prefer_lowest: bool,
#[arg(long)]
ignore_platform_reqs: bool,
#[arg(long = "ignore-platform-req", value_name = "REQ")]
ignore_platform_req: Vec<String>,
#[arg(long)]
no_fallback: bool,
#[arg(long)]
offline: bool,
#[arg(long, value_name = "DIR")]
working_dir: Option<PathBuf>,
#[arg(skip)]
prefer_source: bool,
#[arg(skip)]
prefer_dist: bool,
#[arg(skip)]
prefer_install: Option<String>,
#[arg(skip)]
command_dispatched: bool,
#[arg(skip)]
lockless_install: Option<String>,
#[arg(skip)]
allow_plugins_at_load: Option<serde_json::Value>,
}
#[derive(clap::Args, Debug)]
struct DumpArgs {
#[arg(long)]
no_dev: bool,
#[arg(short = 'o', long)]
optimize: bool,
#[arg(short = 'a', long)]
classmap_authoritative: bool,
#[arg(long = "apcu")]
apcu_autoloader: bool,
#[arg(long = "apcu-prefix", value_name = "PREFIX")]
apcu_autoloader_prefix: Option<String>,
#[arg(long)]
ignore_platform_reqs: bool,
#[arg(long = "ignore-platform-req", value_name = "REQ")]
ignore_platform_req: Vec<String>,
#[arg(long)]
no_plugins: bool,
#[arg(long)]
run_scripts: bool,
#[arg(long, conflicts_with = "run_scripts")]
no_scripts: bool,
#[arg(long)]
no_fallback: bool,
#[arg(long, value_name = "DIR")]
working_dir: Option<PathBuf>,
#[command(flatten)]
compat: GlobalCompatArgs,
}
#[derive(clap::Args, Debug)]
struct InstallArgs {
#[command(flatten)]
compat: GlobalCompatArgs,
#[arg(long)]
no_dev: bool,
#[arg(long)]
prefer_source: bool,
#[arg(long)]
prefer_dist: bool,
#[arg(long, value_name = "PREFER-INSTALL")]
prefer_install: Option<String>,
#[arg(long)]
no_progress: bool,
#[arg(long)]
no_autoloader: bool,
#[arg(short = 'o', long)]
optimize_autoloader: bool,
#[arg(short = 'a', long)]
classmap_authoritative: bool,
#[arg(long)]
apcu_autoloader: bool,
#[arg(long, value_name = "PREFIX")]
apcu_autoloader_prefix: Option<String>,
#[arg(long)]
no_scripts: bool,
#[arg(long)]
run_scripts: bool,
#[arg(long)]
no_plugins: bool,
#[arg(long)]
ignore_platform_reqs: bool,
#[arg(long = "ignore-platform-req", value_name = "REQ")]
ignore_platform_req: Vec<String>,
#[arg(long)]
no_fallback: bool,
#[arg(long)]
check_scope: bool,
#[arg(long)]
offline: bool,
#[arg(long)]
no_blocking: bool,
#[arg(long)]
no_security_blocking: bool,
#[arg(long)]
no_install: bool,
#[arg(long)]
dry_run: bool,
#[arg(long, value_name = "DIR")]
working_dir: Option<PathBuf>,
#[arg(skip)]
fallback_line: Option<Vec<std::ffi::OsString>>,
#[arg(skip)]
virtual_lock: Option<serde_json::Value>,
#[arg(skip)]
virtual_manifest: Option<serde_json::Value>,
#[arg(skip)]
post_update: Option<Box<UpdateReport>>,
}
impl InstallArgs {
fn after_update(&self) -> bool {
self.post_update.is_some()
}
}
fn trace(label: &str, since: std::time::Instant) {
if std::env::var_os("VIVACITY_TRACE").is_some() {
eprintln!(
"trace: {label:<22} {:>7.1} ms",
since.elapsed().as_secs_f64() * 1000.0
);
}
}
pub fn run<I, T>(args: I) -> i32
where
I: IntoIterator<Item = T>,
T: Into<std::ffi::OsString> + Clone,
{
let argv: Vec<std::ffi::OsString> = args.into_iter().map(Into::into).collect();
let _git_answers = vivacity_core::root_version::remember_git_answers();
run_once(argv)
}
fn run_once(argv: Vec<std::ffi::OsString>) -> i32 {
if let Ok(mut a) = ARGV.lock() {
*a = argv.clone();
}
let tokens: Vec<String> = argv
.iter()
.skip(1)
.map(|a| a.to_string_lossy().into_owned())
.collect();
let requested = vivacity_core::io::requested_verbosity(
&tokens,
std::env::var("SHELL_VERBOSITY").ok().as_deref(),
);
let _verbosity = vivacity_core::io::Scope::new(match requested {
0 => vivacity_core::io::Verbosity::Quiet,
1 => vivacity_core::io::Verbosity::Normal,
_ => vivacity_core::io::Verbosity::Verbose,
});
let cli = match Cli::try_parse_from(argv.clone()) {
Ok(cli) => cli,
Err(e) => {
let _ = e.print();
return e.exit_code();
}
};
let tail = &argv[1..];
let check_scope = tail.iter().any(|t| t == "--check-scope");
if requested >= 3 && !check_scope {
let reason = "-vv/-vvv, Composer's debug output";
return delegate_for_verbosity(tail, reason, &format!("drop {reason}"));
}
if requested == 2 && !check_scope {
if let Ok(project) = project_dir(cli.working_dir()) {
if let Some(reason) = active_plugin(
&project,
cli.plugins_enabled(),
cli.run_scripts(),
cli.resolves_without_install(),
) {
return delegate_for_verbosity(tail, &reason, "drop -v");
}
}
}
verbose_listeners::reset();
if requested == 2 && cli.plugins_enabled() && cli.resolves_then_installs() {
vivacity_core::io::defer();
}
if let Ok(project) = project_dir(cli.working_dir()) {
if let Some(vcs) = foreign_vcs_root(&project) {
return delegate_for_verbosity(
tail,
&format!("a root version from {vcs}"),
"set COMPOSER_ROOT_VERSION",
);
}
}
match dispatch(cli) {
Ok(code) => {
vivacity_core::io::release_held();
code
}
Err(e) => {
if let Some(ComposerException(message)) = e
.chain()
.find_map(|c| c.downcast_ref::<ComposerException>())
{
vivacity_core::say_always!("{message}");
vivacity_core::io::github_action_error(message);
return 1;
}
vivacity_core::say_always!("Error: {e:?}");
exit_code_of(&e)
}
}
}
fn foreign_vcs_root(project: &std::path::Path) -> Option<&'static str> {
if refuse_alternate_manifest().is_err()
|| !vivacity_core::root_version::foreign_vcs_marked(project)
{
return None;
}
let text = std::fs::read_to_string(project.join("composer.json")).ok()?;
let manifest: serde_json::Value = serde_json::from_str(&text).ok()?;
vivacity_core::root_version::root_version_from_foreign_vcs(&manifest, project)
}
fn session_error(e: vivacity_resolver::session::SessionError) -> anyhow::Error {
if e.kind == vivacity_resolver::session::SessionErrorKind::Transport {
anyhow::Error::new(TransportFailure(e.message))
} else if e.message == vivacity_resolver::repository::LOCK_WITHOUT_DEV {
anyhow::Error::new(ComposerException(e.message))
} else {
anyhow::anyhow!("{}", e.message)
}
}
#[derive(Debug)]
pub(crate) struct ComposerException(pub(crate) String);
impl std::fmt::Display for ComposerException {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(&self.0)
}
}
impl std::error::Error for ComposerException {}
#[derive(Debug)]
struct TransportFailure(String);
impl std::fmt::Display for TransportFailure {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(&self.0)
}
}
impl std::error::Error for TransportFailure {}
fn exit_code_of(e: &anyhow::Error) -> i32 {
let transport = e.chain().any(|c| {
matches!(
c.downcast_ref::<vivacity_core::Error>(),
Some(vivacity_core::Error::Http { .. })
) || c.downcast_ref::<TransportFailure>().is_some()
});
if transport {
100
} else {
1
}
}
static ARGV: std::sync::Mutex<Vec<std::ffi::OsString>> = std::sync::Mutex::new(Vec::new());
impl Cli {
fn working_dir(&self) -> Option<&std::path::Path> {
match self {
Cli::Install(a) => a.working_dir.as_deref(),
Cli::DumpAutoload(a) => a.working_dir.as_deref(),
Cli::Update(a) => a.working_dir.as_deref(),
Cli::Remove(a) => a.working_dir.as_deref(),
Cli::Require(a) => a.working_dir.as_deref(),
}
}
fn resolves_without_install(&self) -> bool {
match self {
Cli::Update(a) => a.no_install && !a.dry_run,
Cli::Require(a) => a.no_install && !a.no_update && !a.dry_run,
Cli::Remove(a) => a.no_install && !a.no_update && !a.dry_run,
Cli::Install(_) | Cli::DumpAutoload(_) => false,
}
}
fn resolves_then_installs(&self) -> bool {
match self {
Cli::Update(a) => !a.no_install && !a.dry_run,
Cli::Require(a) => !a.no_install && !a.no_update && !a.dry_run,
Cli::Remove(a) => !a.no_install && !a.no_update && !a.dry_run,
Cli::Install(_) | Cli::DumpAutoload(_) => false,
}
}
fn run_scripts(&self) -> bool {
match self {
Cli::Install(a) => a.run_scripts,
Cli::DumpAutoload(a) => a.run_scripts,
Cli::Update(_) | Cli::Remove(_) | Cli::Require(_) => false,
}
}
fn plugins_enabled(&self) -> bool {
!match self {
Cli::Install(a) => a.no_plugins,
Cli::DumpAutoload(a) => a.no_plugins,
Cli::Update(a) => a.no_plugins,
Cli::Remove(a) => a.no_plugins,
Cli::Require(a) => a.no_plugins,
}
}
}
fn dispatch(cli: Cli) -> anyhow::Result<i32> {
match cli {
Cli::Install(args) => run_install(&args),
Cli::DumpAutoload(args) => run_dump(&args),
Cli::Update(args) => run_update(&args),
Cli::Remove(args) => run_remove(&args),
Cli::Require(args) => require::run_require(&args),
}
}
fn project_dir(working_dir: Option<&std::path::Path>) -> anyhow::Result<PathBuf> {
let cwd = std::env::current_dir().context("cannot determine the current directory")?;
Ok(match working_dir {
Some(d) if d.is_absolute() => d.to_path_buf(),
Some(d) => cwd.join(d),
None => cwd,
})
}