343 lines
14 KiB
Rust
343 lines
14 KiB
Rust
use anyhow::Result;
|
|
use clap::Parser;
|
|
|
|
use super::*;
|
|
|
|
pub(crate) fn run_cli() -> Result<()> {
|
|
let cli = Cli::parse();
|
|
match cli.command {
|
|
Commands::Doctor(args) => {
|
|
let json_output = args.scope.json;
|
|
let report = doctor_report(args, std::env::current_dir()?)?;
|
|
emit_report(&report, json_output)?;
|
|
}
|
|
Commands::Login(args) => {
|
|
let args = crate::auth_scope::login_args_for_project(args, &std::env::current_dir()?)?;
|
|
let json_output = args.json;
|
|
if args.non_interactive && !args.plan {
|
|
let report = non_interactive_browser_login_report(&args);
|
|
emit_report(&report, json_output)?;
|
|
} else if !args.plan {
|
|
let report = execute_interactive_browser_login(args)?;
|
|
if json_output {
|
|
emit_report(&report, true)?;
|
|
} else {
|
|
print_browser_login_success(&report);
|
|
}
|
|
} else {
|
|
let plan = login_plan(args);
|
|
emit_report(&plan, json_output)?;
|
|
}
|
|
}
|
|
Commands::Logout(args) => {
|
|
let json_output = args.scope.json;
|
|
let report = logout_report(args, std::env::current_dir()?, "logout")?;
|
|
emit_report(&report, json_output)?;
|
|
}
|
|
Commands::Auth { command } => {
|
|
let (report, json_output) = match command {
|
|
AuthCommands::Status(args) => {
|
|
let json_output = args.scope.json;
|
|
(
|
|
auth_status_report(args, std::env::current_dir()?)?,
|
|
json_output,
|
|
)
|
|
}
|
|
AuthCommands::ConnectSelfHosted(args) => {
|
|
let json_output = args.scope.json;
|
|
let secret = read_session_secret_from_stdin()?;
|
|
(
|
|
connect_self_hosted_report(args, std::env::current_dir()?, secret)?,
|
|
json_output,
|
|
)
|
|
}
|
|
AuthCommands::Logout(args) => {
|
|
let json_output = args.scope.json;
|
|
(
|
|
auth_logout_report(args, std::env::current_dir()?)?,
|
|
json_output,
|
|
)
|
|
}
|
|
};
|
|
emit_report(&report, json_output)?;
|
|
}
|
|
Commands::Agent {
|
|
command: AgentCommands::Enroll(args),
|
|
} => {
|
|
let json_output = args.json;
|
|
let plan = agent_enrollment_plan(args);
|
|
emit_report(&plan, json_output)?;
|
|
}
|
|
Commands::Key { command } => {
|
|
let cwd = std::env::current_dir()?;
|
|
let stored_session = read_cli_session(&cwd)?;
|
|
let (report, json_output) = match command {
|
|
KeyCommands::Add(args) => {
|
|
let json_output = args.scope.json;
|
|
(
|
|
key_add_report_with_session(args, stored_session.as_ref())?,
|
|
json_output,
|
|
)
|
|
}
|
|
KeyCommands::List(args) => {
|
|
let json_output = args.scope.json;
|
|
(
|
|
key_list_report_with_session(args, stored_session.as_ref())?,
|
|
json_output,
|
|
)
|
|
}
|
|
KeyCommands::Revoke(args) => {
|
|
let json_output = args.scope.json;
|
|
(
|
|
key_revoke_report_with_session(args, stored_session.as_ref())?,
|
|
json_output,
|
|
)
|
|
}
|
|
};
|
|
emit_report(&report, json_output)?;
|
|
}
|
|
Commands::Project { command } => {
|
|
let cwd = std::env::current_dir()?;
|
|
let (report, json_output) = match command {
|
|
ProjectCommands::Init(args) => {
|
|
let json_output = args.scope.json;
|
|
(project_init_report(args, cwd)?, json_output)
|
|
}
|
|
ProjectCommands::Status(args) => {
|
|
let json_output = args.scope.json;
|
|
(project_status_report(args, cwd)?, json_output)
|
|
}
|
|
ProjectCommands::List(args) => {
|
|
let json_output = args.scope.json;
|
|
(project_list_report(args, cwd)?, json_output)
|
|
}
|
|
ProjectCommands::Select(args) => {
|
|
let json_output = args.scope.json;
|
|
(project_select_report(args, cwd)?, json_output)
|
|
}
|
|
};
|
|
emit_report(&report, json_output)?;
|
|
}
|
|
Commands::Inspect(args) => {
|
|
let json_output = args.json;
|
|
let inspection = bundle_inspection(args, std::env::current_dir()?)?;
|
|
emit_report(&inspection, json_output)?;
|
|
}
|
|
Commands::Build(args) => {
|
|
let json_output = args.json;
|
|
let report = build_report(args, std::env::current_dir()?)?;
|
|
emit_report(&report, json_output)?;
|
|
}
|
|
Commands::Bundle {
|
|
command: BundleCommands::Inspect(args),
|
|
} => {
|
|
let json_output = args.json;
|
|
let inspection = bundle_inspection(args, std::env::current_dir()?)?;
|
|
emit_report(&inspection, json_output)?;
|
|
}
|
|
Commands::Run(args) => {
|
|
let json_output = args.json;
|
|
let cwd = std::env::current_dir()?;
|
|
let session_project = args.project.clone().unwrap_or_else(|| cwd.clone());
|
|
let session = session_from_sources(&session_project)?;
|
|
let report = run_report(args, cwd, session)?;
|
|
emit_report(&report, json_output)?;
|
|
}
|
|
Commands::Node {
|
|
command: NodeCommands::Attach(args),
|
|
} => {
|
|
let json_output = args.json;
|
|
if args.coordinator.is_some() {
|
|
let report = execute_node_attach(args)?;
|
|
emit_report(&report, json_output)?;
|
|
} else {
|
|
let plan = attach_plan(args);
|
|
emit_report(&plan, json_output)?;
|
|
}
|
|
}
|
|
Commands::Node { command } => {
|
|
let cwd = std::env::current_dir()?;
|
|
let (report, json_output) = match command {
|
|
NodeCommands::Enroll(args) => {
|
|
let json_output = args.scope.json;
|
|
(node_enroll_report(args, cwd.clone())?, json_output)
|
|
}
|
|
NodeCommands::List(args) => {
|
|
let json_output = args.scope.json;
|
|
(node_list_report(args, cwd.clone())?, json_output)
|
|
}
|
|
NodeCommands::Status(args) => {
|
|
let json_output = args.scope.json;
|
|
(node_status_report(args, cwd.clone())?, json_output)
|
|
}
|
|
NodeCommands::Revoke(args) => {
|
|
let json_output = args.scope.json;
|
|
(node_revoke_report(args, cwd)?, json_output)
|
|
}
|
|
NodeCommands::Attach(_) => unreachable!("node attach is handled above"),
|
|
};
|
|
emit_report(&report, json_output)?;
|
|
}
|
|
Commands::Process { command } => {
|
|
let cwd = std::env::current_dir()?;
|
|
let stored_session = read_cli_session(&cwd)?;
|
|
let (report, json_output) = match command {
|
|
ProcessCommands::List(args) => {
|
|
let json_output = args.scope.json;
|
|
(
|
|
process_list_report_with_session(args, stored_session.as_ref())?,
|
|
json_output,
|
|
)
|
|
}
|
|
ProcessCommands::Status(args) => {
|
|
let json_output = args.scope.json;
|
|
(
|
|
process_status_report_with_session(args, stored_session.as_ref())?,
|
|
json_output,
|
|
)
|
|
}
|
|
ProcessCommands::Restart(args) => {
|
|
let json_output = args.scope.json;
|
|
(
|
|
process_restart_report_with_session(args, stored_session.as_ref())?,
|
|
json_output,
|
|
)
|
|
}
|
|
ProcessCommands::Cancel(args) => {
|
|
let json_output = args.scope.json;
|
|
(
|
|
process_cancel_report_with_session(args, stored_session.as_ref())?,
|
|
json_output,
|
|
)
|
|
}
|
|
ProcessCommands::Abort(args) => {
|
|
let json_output = args.scope.json;
|
|
(
|
|
process_abort_report_with_session(args, stored_session.as_ref())?,
|
|
json_output,
|
|
)
|
|
}
|
|
};
|
|
emit_report(&report, json_output)?;
|
|
}
|
|
Commands::Task { command } => {
|
|
let cwd = std::env::current_dir()?;
|
|
let stored_session = read_cli_session(&cwd)?;
|
|
let (report, json_output) = match command {
|
|
TaskCommands::List(args) => {
|
|
let json_output = args.scope.json;
|
|
(
|
|
task_list_report_with_session(args, stored_session.as_ref())?,
|
|
json_output,
|
|
)
|
|
}
|
|
TaskCommands::Restart(args) => {
|
|
let json_output = args.scope.json;
|
|
(
|
|
task_restart_report_with_session(args, stored_session.as_ref())?,
|
|
json_output,
|
|
)
|
|
}
|
|
};
|
|
emit_report(&report, json_output)?;
|
|
}
|
|
Commands::Logs(args) => {
|
|
let json_output = args.scope.json;
|
|
let cwd = std::env::current_dir()?;
|
|
let stored_session = read_cli_session(&cwd)?;
|
|
emit_report(
|
|
&logs_report_with_session(args, stored_session.as_ref())?,
|
|
json_output,
|
|
)?;
|
|
}
|
|
Commands::Artifact { command } => {
|
|
let cwd = std::env::current_dir()?;
|
|
let stored_session = read_cli_session(&cwd)?;
|
|
let (report, json_output) = match command {
|
|
ArtifactCommands::List(args) => {
|
|
let json_output = args.scope.json;
|
|
(
|
|
artifact_list_report_with_session(args, stored_session.as_ref())?,
|
|
json_output,
|
|
)
|
|
}
|
|
ArtifactCommands::Download(args) => {
|
|
let json_output = args.scope.json;
|
|
(
|
|
artifact_download_report_with_session(args, stored_session.as_ref())?,
|
|
json_output,
|
|
)
|
|
}
|
|
ArtifactCommands::Export(args) => {
|
|
let json_output = args.scope.json;
|
|
(
|
|
artifact_export_report_with_session(args, stored_session.as_ref())?,
|
|
json_output,
|
|
)
|
|
}
|
|
};
|
|
emit_report(&report, json_output)?;
|
|
}
|
|
Commands::Dap(args) => {
|
|
let json_output = args.json;
|
|
if args.plan {
|
|
emit_report(&dap_plan(args)?, json_output)?;
|
|
} else {
|
|
return exec_dap(args);
|
|
}
|
|
}
|
|
Commands::Debug {
|
|
command: DebugCommands::Attach(args),
|
|
} => {
|
|
let json_output = args.scope.json;
|
|
let cwd = std::env::current_dir()?;
|
|
let stored_session = read_cli_session(&cwd)?;
|
|
let dap = dap_binary_path()?.display().to_string();
|
|
emit_report(
|
|
&debug_attach_report_with_dap_and_session(args, dap, stored_session.as_ref())?,
|
|
json_output,
|
|
)?;
|
|
}
|
|
Commands::Quota {
|
|
command: QuotaCommands::Status(args),
|
|
} => {
|
|
let json_output = args.scope.json;
|
|
emit_report(
|
|
"a_status_report(args, std::env::current_dir()?)?,
|
|
json_output,
|
|
)?;
|
|
}
|
|
Commands::Admin { command } => {
|
|
let (report, json_output) = match command {
|
|
AdminCommands::Status(args) => {
|
|
let json_output = args.scope.json;
|
|
(admin_status_report(args)?, json_output)
|
|
}
|
|
AdminCommands::Bootstrap(args) => {
|
|
let json_output = args.scope.json;
|
|
(
|
|
admin_bootstrap_report(args, std::env::current_dir()?)?,
|
|
json_output,
|
|
)
|
|
}
|
|
AdminCommands::RevokeNode(args) => {
|
|
let json_output = args.scope.json;
|
|
(
|
|
node_revoke_report(args, std::env::current_dir()?)?,
|
|
json_output,
|
|
)
|
|
}
|
|
AdminCommands::StopProcess(args) => {
|
|
let json_output = args.scope.json;
|
|
(process_cancel_report(args)?, json_output)
|
|
}
|
|
AdminCommands::SuspendTenant(args) => {
|
|
let json_output = args.scope.json;
|
|
(admin_suspend_tenant_report(args)?, json_output)
|
|
}
|
|
};
|
|
emit_report(&report, json_output)?;
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|