#![deny(clippy::print_stdout)]
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 config;
use config::*;
mod dump;
use dump::*;
mod remove;
use remove::*;
mod discovery;
mod effect_plugins;
mod flex;
mod flex_recipes;
mod no_install;
mod plugin_allow;
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),
Config(ConfigArgs),
}
#[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(short = 'm', long)]
minimal_changes: bool,
#[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>,
#[arg(skip)]
resolution_command: Option<vivacity_core::scope::ResolutionCommand>,
}
#[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 {
vivacity_core::fetch::forget_global_files();
fallback::forget_manifest_restored();
fallback::forget_hold_trigger();
vivacity_core::io::forget_held_write();
vivacity_resolver::repository::forget_preparsed();
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())
{
return delegate_for_verbosity(tail, &reason, "drop -v");
}
}
}
if let Some(reason) = cli.unsupported_hand_over() {
return delegate_for_verbosity(tail, &reason, "drop it");
}
let (cache_reason, tls_reason) = cli.startup_hand_over();
if let Some(reason) = tls_reason {
let remedy = if reason == "disable-tls is set" {
"unset disable-tls".to_owned()
} else {
format!("fix the configuration ({reason})")
};
return delegate_for_verbosity(tail, &reason, &remedy);
}
if let Some(reason) = cache_reason {
return delegate_for_verbosity(
tail,
&reason,
&format!("change the cache directory settings ({reason})"),
);
}
verbose_listeners::reset();
if requested == 2 && cli.plugins_enabled() && cli.resolves_then_installs() {
vivacity_core::io::defer();
}
let loads_root = !matches!(cli, Cli::Config(_));
if let (true, Ok(project)) = (loads_root, 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",
);
}
}
vivacity_core::secure_http::begin(
project_dir(cli.working_dir()).ok().as_deref(),
cli.offline(),
);
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;
}
let code = exit_code_of(&e);
let message = format!("{e:?}");
if code == 100 && message.contains(vivacity_core::fetch::TIMED_OUT) {
vivacity_core::say_always!("If you intend to run Composer without connecting to the internet, run the command again prefixed with COMPOSER_DISABLE_NETWORK=1 to make Composer run in offline mode.");
}
vivacity_core::say_always!("Error: {message}");
code
}
}
}
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.kind == vivacity_resolver::session::SessionErrorKind::Unsupported {
anyhow::Error::new(HandOverReason(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 HandOverReason(pub(crate) String);
impl std::fmt::Display for HandOverReason {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(&self.0)
}
}
impl std::error::Error for HandOverReason {}
#[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 { .. } | vivacity_core::Error::Transport(_))
) || 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(),
Cli::Config(_) => None,
}
}
fn offline(&self) -> bool {
match self {
Cli::Install(a) => a.offline,
Cli::Update(a) => a.offline,
Cli::Remove(a) => a.offline,
Cli::Require(a) => a.offline,
Cli::DumpAutoload(_) | Cli::Config(_) => 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(_) | Cli::Config(_) => 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(_) | Cli::Config(_) => 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,
Cli::Config(_) => true,
}
}
fn unsupported_hand_over(&self) -> Option<String> {
if let Some(f) = std::env::var("COMPOSER").ok().map(|f| f.trim().to_owned()) {
if !f.is_empty() && f != "composer.json" && f != "./composer.json" {
return Some(format!("COMPOSER={f} (an alternate manifest)"));
}
}
None
}
fn minimal_changes(&self, manifest: Option<&serde_json::Value>) -> bool {
let (flag, no_update) = match self {
Cli::Require(a) => (a.minimal_changes, a.no_update),
Cli::Remove(a) => (a.minimal_changes, a.no_update),
Cli::Update(a) => (a.minimal_changes, false),
_ => return false,
};
let env =
std::env::var("COMPOSER_MINIMAL_CHANGES").is_ok_and(|v| !v.is_empty() && v != "0");
if !no_update && (flag || env) {
return true;
}
const KEY: &str = "update-with-minimal-changes";
let layer = |config: Option<&serde_json::Value>| -> Result<Option<bool>, ()> {
match config.and_then(|c| c.get(KEY)) {
None => Ok(None),
Some(serde_json::Value::Bool(b)) => Ok(Some(*b)),
Some(_) => Err(()),
}
};
let env_auth = match vivacity_core::fetch::composer_auth_env(
std::env::var("COMPOSER_AUTH").ok().as_deref(),
) {
Ok(env) => env,
Err(_) => return true,
};
let home = vivacity_core::fetch::composer_home();
let project = project_dir(self.working_dir()).ok();
let mut layers: Vec<Result<Option<bool>, ()>> = Vec::with_capacity(6);
if let Some(home) = &home {
layers.push(vivacity_core::fetch::with_global_json(
home,
"config.json",
|c| layer(c.and_then(|c| c.get("config"))),
));
layers.push(vivacity_core::fetch::with_global_json(
home,
"auth.json",
layer,
));
}
layers.push(layer(env_auth.as_ref()));
layers.push(layer(manifest.and_then(|m| m.get("config"))));
if let Some(project) = &project {
layers.push(vivacity_core::fetch::with_global_json(
project,
"auth.json",
layer,
));
}
layers.push(layer(env_auth.as_ref()));
let mut value = false;
for l in layers {
match l {
Ok(Some(b)) => value = b,
Ok(None) => {}
Err(()) => return true,
}
}
!no_update && value
}
fn startup_hand_over(&self) -> (Option<String>, Option<String>) {
let reads_cache = match self {
Cli::Config(_) => {
let manifest = project_dir(self.working_dir())
.ok()
.and_then(|p| std::fs::read_to_string(p.join("composer.json")).ok())
.and_then(|t| serde_json::from_str::<serde_json::Value>(&t).ok());
return (
None,
vivacity_core::secure_http::disable_tls_reason(
manifest.as_ref().and_then(|m| m.get("config")),
)
.or_else(|| {
crate::fallback::repository_construction_issue(
project_dir(self.working_dir()).ok().as_deref(),
manifest.as_ref(),
)
}),
);
}
Cli::DumpAutoload(_) => false,
Cli::Install(_) | Cli::Update(_) | Cli::Remove(_) | Cli::Require(_) => true,
};
let manifest = reads_cache
.then(|| {
project_dir(self.working_dir())
.ok()
.and_then(|p| std::fs::read_to_string(p.join("composer.json")).ok())
.and_then(|t| serde_json::from_str::<serde_json::Value>(&t).ok())
})
.flatten();
let tls = vivacity_core::secure_http::disable_tls_reason(
manifest.as_ref().and_then(|m| m.get("config")),
)
.or_else(|| {
self.minimal_changes(manifest.as_ref())
.then(|| "update-with-minimal-changes".to_owned())
})
.or_else(|| {
reads_cache
.then(|| {
crate::fallback::repository_construction_issue(
project_dir(self.working_dir()).ok().as_deref(),
manifest.as_ref(),
)
})
.flatten()
});
if let Some(why) = vivacity_core::fetch::cache_dir_hand_over(reads_cache) {
return (Some(why), tls);
}
if let Some(why) = manifest
.as_ref()
.and_then(vivacity_core::fetch::project_cache_config)
{
return (Some(why), tls);
}
if reads_cache {
let project_auth = project_dir(self.working_dir()).ok().and_then(|p| {
vivacity_core::fetch::with_global_json(&p, "auth.json", |a| a.cloned())
});
if let Err(why) = vivacity_core::fetch::files_cache(
manifest.as_ref().and_then(|m| m.get("config")),
project_auth.as_ref(),
) {
return (Some(why), tls);
}
}
let cache = (reads_cache
&& self.working_dir().is_some()
&& vivacity_core::fetch::cache_dir_is_relative())
.then(|| "a relative cache-dir with --working-dir".to_owned());
(cache, tls)
}
}
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),
Cli::Config(args) => run_config(&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,
})
}