feat(pop-cli): add --json support for new, clean, completion, upgrade, and install commands (#994)

* feat(pop-cli): add --json support for clean, completion, upgrade, and install commands

Extends the global --json flag to the four remaining commands that didn't
support it yet. Each command emits a CliResponse envelope with structured
data and returns PromptRequiredError when interactive flags are missing.

* fix: cfg-gate imports and restore dead_code allows for feature compat

The CI builds with --no-default-features, --features contract, and
--features chain. The cli::Cli import is only used in feature-gated
blocks, and JsonCli infrastructure types need unconditional
allow(dead_code) since the compiler cannot trace trait dispatch.

* feat(pop-cli): add --json support for the `new` command

Wire OutputMode through `new chain`, `new pallet`, and `new contract`
subcommands so that `pop new --json` produces machine-readable output.

JSON mode behaviour:
- `pop new --json --list` emits a TemplateListOutput envelope with all
  non-deprecated chain and contract templates.
- Each subcommand's `--list` emits a SubcommandTemplateListOutput.
- Generation emits a NewOutput envelope with kind, name, path, and
  optional template fields.
- Missing required arguments (name, template, bare --with-frontend)
  return a PROMPT_REQUIRED error instead of launching interactive
  prompts.
- Human-mode behaviour is completely unchanged.

Closes #972

* fix: return PROMPT_REQUIRED for json new command prompt paths

address review feedback: guard prompt-driven JSON paths\n\nAddressed comments:\n- [new/pallet.rs] reject interactive advanced mode in --json unless advanced flags are provided\n- [new/{pallet,contract,chain}.rs] fail early with PromptRequiredError when destination path already exists\n- [new/{pallet,contract,chain}.rs tests] add JSON regression tests for existing-path and advanced prompt cases

Author: moliholy

crates/pop-cli/src/cli.rs

@@ -465,6 +465,9 @@ impl traits::Cli for JsonCli {
 	}
 }
 
+#[allow(dead_code)]
+const JSON_PROMPT_ERR: &str = "interactive prompt required but --json mode is active";
+
 #[allow(dead_code)]
 struct JsonConfirm;
 impl traits::Confirm for JsonConfirm {

crates/pop-cli/src/commands/build/mod.rs

@@ -554,7 +554,8 @@ impl Command {
 			return Err(BuildCommandError::new("Build failed").with_details(details).into());
 		}
 
-		let artifact_path = profile.target_directory(path);
+		let root = pop_common::find_workspace_root(path).unwrap_or_else(|| path.to_path_buf());
+		let artifact_path = profile.target_directory(&root);
 		Ok(BuildOutput {
 			artifact_path: artifact_path.display().to_string(),
 			profile: profile.to_string(),
@@ -1136,6 +1137,63 @@ mod tests {
 		Ok(())
 	}
 
+	#[test]
+	fn build_json_workspace_member_uses_workspace_root_target() -> anyhow::Result<()> {
+		let temp_dir = tempfile::tempdir()?;
+		let ws = temp_dir.path();
+
+		// Create workspace Cargo.toml
+		std::fs::write(ws.join("Cargo.toml"), "[workspace]\nmembers = [\"member\"]\n")?;
+
+		// Create a member crate
+		cmd("cargo", ["new", "member", "--bin"]).dir(ws).run()?;
+		let member_path = ws.join("member");
+		std::fs::write(
+			member_path.join("src/main.rs"),
+			"//! test binary\nfn main() { println!(\"ok\"); }\n",
+		)?;
+		let output = Command::build_json(
+			&BuildArgs {
+				#[cfg(feature = "chain")]
+				command: None,
+				path: Some(member_path.clone()),
+				path_pos: None,
+				package: None,
+				release: false,
+				profile: Some(Profile::Debug),
+				features: None,
+				#[cfg(feature = "chain")]
+				benchmark: false,
+				#[cfg(feature = "chain")]
+				try_runtime: false,
+				#[cfg(feature = "chain")]
+				deterministic: false,
+				#[cfg(feature = "chain")]
+				tag: None,
+				#[cfg(feature = "chain")]
+				only_runtime: false,
+				#[cfg(feature = "contract")]
+				metadata: None,
+				#[cfg(feature = "contract")]
+				verifiable: false,
+				#[cfg(feature = "contract")]
+				image: None,
+			},
+			&member_path,
+		)?;
+
+		// artifact_path must point to the workspace root target, not the member's
+		let artifact = PathBuf::from(&output.artifact_path);
+		let ws_canonical = ws.canonicalize()?;
+		assert!(
+			artifact.starts_with(&ws_canonical),
+			"expected artifact under workspace root {ws_canonical:?}, got {artifact:?}"
+		);
+		assert!(!artifact.starts_with(ws_canonical.join("member")));
+		assert!(artifact.exists());
+		Ok(())
+	}
+
 	#[test]
 	fn build_json_failure_returns_build_command_error() -> anyhow::Result<()> {
 		let name = "json_build_fail";

crates/pop-cli/src/commands/mod.rs

@@ -4,6 +4,8 @@
 use crate::cli::Cli;
 #[cfg(any(feature = "chain", feature = "contract"))]
 use crate::cli::traits::Cli as _;
+#[cfg(any(feature = "chain", feature = "contract"))]
+use crate::output::PromptRequiredError;
 use crate::{
 	cache,
 	output::{CliResponse, OutputMode, reject_unsupported_json},
@@ -129,6 +131,8 @@ impl Command {
 			Self::Fork(_) => true,
 			#[cfg(any(feature = "chain", feature = "contract"))]
 			Self::Install(_) => true,
+			#[cfg(any(feature = "chain", feature = "contract"))]
+			Self::New(_) => true,
 			#[cfg(feature = "chain")]
 			Self::Bench(_) => true,
 			#[cfg(any(feature = "chain", feature = "contract"))]
@@ -151,6 +155,48 @@ impl Command {
 			Self::New(args) => {
 				env_logger::init();
 
+				if output_mode == OutputMode::Json {
+					if args.list {
+						let output = new::TemplateListOutput {
+							#[cfg(feature = "chain")]
+							chain_templates: pop_chains::ChainTemplate::templates()
+								.iter()
+								.filter(|t| !t.is_deprecated())
+								.map(|t| new::TemplateInfo {
+									name: t.name().to_string(),
+									description: t.description().to_string(),
+								})
+								.collect(),
+							#[cfg(feature = "contract")]
+							contract_templates: pop_contracts::Contract::templates()
+								.iter()
+								.filter(|t| !t.is_deprecated())
+								.map(|t| new::TemplateInfo {
+									name: t.name().to_string(),
+									description: t.description().to_string(),
+								})
+								.collect(),
+						};
+						CliResponse::ok(output).print_json();
+						return Ok(());
+					}
+
+					return match &mut args.command {
+						None => Err(PromptRequiredError(
+							"--json mode requires a subcommand (chain, pallet, or contract)".into(),
+						)
+						.into()),
+						Some(cmd) => match cmd {
+							#[cfg(feature = "chain")]
+							new::Command::Chain(cmd) => cmd.execute(output_mode).await,
+							#[cfg(feature = "chain")]
+							new::Command::Pallet(cmd) => cmd.execute(output_mode).await,
+							#[cfg(feature = "contract")]
+							new::Command::Contract(cmd) => cmd.execute(output_mode).await,
+						},
+					};
+				}
+
 				if args.list {
 					Cli.intro("Available templates")?;
 					#[cfg(feature = "chain")]
@@ -190,11 +236,11 @@ impl Command {
 
 				match command {
 					#[cfg(feature = "chain")]
-					new::Command::Chain(cmd) => cmd.execute().await,
+					new::Command::Chain(cmd) => cmd.execute(output_mode).await,
 					#[cfg(feature = "chain")]
-					new::Command::Pallet(cmd) => cmd.execute().await,
+					new::Command::Pallet(cmd) => cmd.execute(output_mode).await,
 					#[cfg(feature = "contract")]
-					new::Command::Contract(cmd) => cmd.execute().await,
+					new::Command::Contract(cmd) => cmd.execute(output_mode).await,
 				}
 			},
 			#[cfg(feature = "chain")]

crates/pop-cli/src/commands/new/chain.rs

@@ -3,7 +3,11 @@
 use crate::{
 	cli::{self, traits::*},
 	common::helpers::check_destination_path,
-	new::frontend::{PackageManager, create_frontend, prompt_frontend_template},
+	new::{
+		NewOutput, SubcommandTemplateListOutput, TemplateInfo,
+		frontend::{PackageManager, create_frontend, prompt_frontend_template},
+	},
+	output::{CliResponse, OutputMode, PromptRequiredError},
 };
 use anyhow::Result;
 use clap::{
@@ -85,7 +89,10 @@ pub struct NewChainCommand {
 
 impl NewChainCommand {
 	/// Executes the command.
-	pub(crate) async fn execute(&self) -> Result<()> {
+	pub(crate) async fn execute(&self, output_mode: OutputMode) -> Result<()> {
+		if output_mode == OutputMode::Json {
+			return self.execute_json().await;
+		}
 		if self.list {
 			let mut cli = cli::Cli;
 			cli.intro("Available templates")?;
@@ -151,6 +158,93 @@ impl NewChainCommand {
 		Ok(())
 	}
 
+	/// Executes the command in JSON mode.
+	async fn execute_json(&self) -> Result<()> {
+		// --list: return structured template listing.
+		if self.list {
+			let templates: Vec<TemplateInfo> = ChainTemplate::templates()
+				.iter()
+				.filter(|t| !t.is_deprecated())
+				.map(|t| TemplateInfo {
+					name: t.name().to_string(),
+					description: t.description().to_string(),
+				})
+				.collect();
+			CliResponse::ok(SubcommandTemplateListOutput { templates }).print_json();
+			return Ok(());
+		}
+
+		// Name is required in JSON mode.
+		let name = self.name.as_ref().ok_or_else(|| {
+			PromptRequiredError(
+				"--json mode requires the chain name as a positional argument".into(),
+			)
+		})?;
+
+		let destination_path = Path::new(name);
+		if destination_path.exists() {
+			return Err(PromptRequiredError(format!(
+				"--json mode cannot confirm deleting existing path \"{}\". Remove it first or choose a different name.",
+				destination_path.display()
+			))
+			.into());
+		}
+
+		// Bare --with-frontend (empty string = needs prompt) is not allowed.
+		if let Some(frontend_arg) = &self.with_frontend &&
+			frontend_arg.is_empty()
+		{
+			return Err(PromptRequiredError(
+				"--json mode requires --with-frontend=<TEMPLATE_NAME> (e.g. create-dot-app)".into(),
+			)
+			.into());
+		}
+
+		// Generate the chain using JsonCli (suppresses interactive output).
+		let template = self.template.clone().unwrap_or_default();
+		let config = get_customization_value(
+			&template,
+			self.symbol.clone(),
+			self.decimals,
+			self.initial_endowment.clone(),
+			&mut cli::JsonCli,
+		)?;
+		let tag_version = self.release_tag.clone();
+
+		let frontend_template: Option<FrontendTemplate> = self
+			.with_frontend
+			.as_ref()
+			.map(|arg| {
+				FrontendTemplate::from_str(arg)
+					.map_err(|_| anyhow::anyhow!("Invalid frontend template: {}", arg))
+			})
+			.transpose()?;
+
+		generate_parachain_from_template(
+			name,
+			&template,
+			tag_version,
+			config,
+			self.verify,
+			frontend_template,
+			self.package_manager,
+			&mut cli::JsonCli,
+		)
+		.await?;
+
+		let path = std::path::PathBuf::from(name).canonicalize().unwrap_or_else(|_| name.into());
+
+		CliResponse::ok(NewOutput {
+			kind: "chain".into(),
+			name: name.clone(),
+			path: path.display().to_string(),
+			template: Some(template.name().to_string()),
+		})
+		.print_json();
+
+		Ok(())
+	}
+
 	fn display(&self) -> String {
 		let mut full_message = "pop new chain".to_string();
 		if let Some(name) = &self.name {
@@ -514,6 +608,7 @@ fn prompt_customizable_options(cli: &mut impl Cli) -> Result<Config> {
 mod tests {
 	use super::*;
 	use cli::MockCli;
+	use tempfile::tempdir;
 
 	#[test]
 	fn test_new_chain_command_display() {
@@ -714,7 +809,37 @@ mod tests {
 	#[tokio::test]
 	async fn test_new_chain_list_templates() -> Result<()> {
 		let command = NewChainCommand { list: true, ..Default::default() };
-		command.execute().await?;
+		command.execute(OutputMode::Human).await?;
+		Ok(())
+	}
+
+	#[tokio::test]
+	async fn execute_json_missing_name_returns_prompt_required() {
+		let cmd = NewChainCommand { ..Default::default() };
+		let err = cmd.execute(OutputMode::Json).await.unwrap_err();
+		assert!(err.downcast_ref::<PromptRequiredError>().is_some());
+	}
+
+	#[tokio::test]
+	async fn execute_json_bare_with_frontend_returns_prompt_required() {
+		let cmd = NewChainCommand {
+			name: Some("test-chain".into()),
+			with_frontend: Some(String::new()),
+			..Default::default()
+		};
+		let err = cmd.execute(OutputMode::Json).await.unwrap_err();
+		assert!(err.downcast_ref::<PromptRequiredError>().is_some());
+	}
+
+	#[tokio::test]
+	async fn execute_json_existing_path_returns_prompt_required() -> Result<()> {
+		let dir = tempdir()?;
+		let chain_path = dir.path().join("my-chain");
+		std::fs::create_dir_all(&chain_path)?;
+		let cmd =
+			NewChainCommand { name: Some(chain_path.display().to_string()), ..Default::default() };
+		let err = cmd.execute(OutputMode::Json).await.unwrap_err();
+		assert!(err.downcast_ref::<PromptRequiredError>().is_some());
 		Ok(())
 	}
 }