electron-cli 0.3.0-alpha.12 → 0.3.0-alpha.14

package/src/commands/publish.rs

@@ -8,20 +8,28 @@ use std::{
 use anyhow::{bail, Context, Result};
 use camino::Utf8PathBuf;
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
+use serde_json::{Map as JsonMap, Value as JsonValue};
 
 use crate::{
     cli::{MakeArgs, PublishArgs, PublishTarget},
     commands::make::{self, MakeReport},
     output,
+    project::ProjectSnapshot,
 };
 
 #[derive(Debug, Serialize)]
 struct PublishReport {
     make: MakeReport,
     publisher: String,
+    #[serde(skip)]
+    publisher_kind: PublishTarget,
     channel: String,
     local: Option<LocalPublishPlan>,
     github: Option<GithubPublishPlan>,
+    #[serde(skip)]
+    force_publish: bool,
+    #[serde(skip)]
+    github_auth_token: Option<String>,
     skip_make: bool,
     dry_run: bool,
     status: PublishStatus,
@@ -49,13 +57,21 @@ struct GithubPublishPlan {
     asset_url: Option<String>,
 }
 
-#[derive(Debug, Serialize)]
+#[derive(Clone, Copy, Debug, Serialize)]
 #[serde(rename_all = "kebab-case")]
 enum PublishStatus {
     Planned,
     Published,
 }
 
+#[derive(Debug, Serialize)]
+struct PublishRunReport<'a> {
+    publishes: &'a [PublishReport],
+    dry_run: bool,
+    status: PublishStatus,
+    warnings: Vec<String>,
+}
+
 #[derive(Debug, Serialize)]
 struct PublishManifest {
     schema_version: u8,
@@ -78,33 +94,112 @@ struct PublishedArtifact {
     size: u64,
 }
 
+#[derive(Debug)]
+struct ResolvedPublishers {
+    publishers: Vec<ResolvedPublisher>,
+    warnings: Vec<String>,
+}
+
+#[derive(Clone, Debug)]
+struct ResolvedPublisher {
+    target: PublishTarget,
+    to: PathBuf,
+    channel: String,
+    github_repo: Option<String>,
+    github_tag: Option<String>,
+    github_tag_prefix: Option<String>,
+    github_release_name: Option<String>,
+    github_draft: bool,
+    github_prerelease: bool,
+    github_api_url: String,
+    github_auth_token: Option<String>,
+    force_publish: bool,
+}
+
+#[derive(Debug)]
+struct ConfiguredPublisher {
+    label: String,
+    target: Option<PublishTarget>,
+    platforms: Vec<String>,
+    to: Option<PathBuf>,
+    channel: Option<String>,
+    github_repo: Option<String>,
+    github_tag: Option<String>,
+    github_tag_prefix: Option<String>,
+    github_release_name: Option<String>,
+    github_draft: Option<bool>,
+    github_prerelease: Option<bool>,
+    github_api_url: Option<String>,
+    github_auth_token: Option<String>,
+    force_publish: Option<bool>,
+}
+
 pub fn run(args: PublishArgs) -> Result<()> {
-    let mut report = build_report(&args)?;
+    let mut make_reports = make::build_reports(&make_args(&args))?;
+    let mut reports = build_reports_from_make_reports(&args, &make_reports)?;
 
     if args.dry_run {
-        return print_report(&report, args.json);
+        return print_reports(&reports, args.json, PublishStatus::Planned);
     }
 
-    execute_publish(&mut report, &args)?;
-    report.status = PublishStatus::Published;
+    execute_publish_reports(&mut reports, &mut make_reports, &args)?;
 
-    print_report(&report, args.json)
+    print_reports(&reports, args.json, PublishStatus::Published)
 }
 
+#[cfg(test)]
 fn build_report(args: &PublishArgs) -> Result<PublishReport> {
-    let make_args = MakeArgs {
-        cwd: args.cwd.clone(),
-        out_dir: args.out_dir.clone(),
-        name: args.name.clone(),
-        platform: args.platform.clone(),
-        arch: args.arch.clone(),
-        target: args.target,
-        skip_package: false,
-        force: args.force,
-        dry_run: false,
-        json: false,
-    };
-    let make = make::build_report(&make_args)?;
+    let reports = build_reports(args)?;
+    if reports.len() != 1 {
+        bail!(
+            "Expected one publish target, but resolved {}. Pass --target and --publisher to select one target.",
+            reports.len()
+        );
+    }
+    Ok(reports
+        .into_iter()
+        .next()
+        .expect("length was checked above"))
+}
+
+#[cfg(test)]
+fn build_reports(args: &PublishArgs) -> Result<Vec<PublishReport>> {
+    let make_reports = make::build_reports(&make_args(args))?;
+    build_reports_from_make_reports(args, &make_reports)
+}
+
+fn build_reports_from_make_reports(
+    args: &PublishArgs,
+    make_reports: &[MakeReport],
+) -> Result<Vec<PublishReport>> {
+    let first_make = make_reports
+        .first()
+        .context("No make targets were resolved for publish.")?;
+    let project = first_make.package().project();
+    let platform = first_make.package().platform();
+    let resolved = resolve_publishers(project, args, platform)?;
+    let mut reports = Vec::new();
+
+    for publisher in &resolved.publishers {
+        for make in make_reports {
+            reports.push(build_report_for_publisher(
+                args,
+                make.clone(),
+                publisher,
+                &resolved.warnings,
+            )?);
+        }
+    }
+
+    Ok(reports)
+}
+
+fn build_report_for_publisher(
+    args: &PublishArgs,
+    make: MakeReport,
+    publisher: &ResolvedPublisher,
+    config_warnings: &[String],
+) -> Result<PublishReport> {
     let root = Path::new(make.package().project().root.as_str());
     let artifact_name = make
         .artifact()
@@ -113,22 +208,23 @@ fn build_report(args: &PublishArgs) -> Result<PublishReport> {
         .to_string();
 
     let mut warnings = make.warnings().to_vec();
+    warnings.extend(config_warnings.iter().cloned());
     if args.skip_make && !Path::new(make.artifact().as_str()).exists() {
         warnings.push(format!(
             "Make artifact does not exist: {}.",
             make.artifact()
         ));
     }
-    let (local, github) = match args.publisher {
+    let (local, github) = match publisher.target {
         PublishTarget::Local => {
-            let local = build_local_plan(root, args, &make, &artifact_name)?;
-            if Path::new(local.destination_artifact.as_str()).exists() && !args.force {
+            let local = build_local_plan(root, publisher, &make, &artifact_name)?;
+            if Path::new(local.destination_artifact.as_str()).exists() && !publisher.force_publish {
                 warnings.push(format!(
                     "Publish artifact already exists: {}. Use --force to overwrite it.",
                     local.destination_artifact
                 ));
             }
-            if Path::new(local.manifest.as_str()).exists() && !args.force {
+            if Path::new(local.manifest.as_str()).exists() && !publisher.force_publish {
                 warnings.push(format!(
                     "Publish manifest already exists: {}. Use --force to overwrite it.",
                     local.manifest
@@ -137,17 +233,20 @@ fn build_report(args: &PublishArgs) -> Result<PublishReport> {
             (Some(local), None)
         }
         PublishTarget::Github => {
-            let github = build_github_plan(args, &make, &artifact_name, &mut warnings)?;
+            let github = build_github_plan(publisher, &make, &artifact_name, &mut warnings)?;
             (None, Some(github))
         }
     };
 
     Ok(PublishReport {
         make,
-        publisher: args.publisher.as_str().to_string(),
-        channel: args.channel.clone(),
+        publisher: publisher.target.as_str().to_string(),
+        publisher_kind: publisher.target,
+        channel: publisher.channel.clone(),
         local,
         github,
+        force_publish: publisher.force_publish,
+        github_auth_token: publisher.github_auth_token.clone(),
         skip_make: args.skip_make,
         dry_run: args.dry_run,
         status: PublishStatus::Planned,
@@ -158,13 +257,13 @@ fn build_report(args: &PublishArgs) -> Result<PublishReport> {
 
 fn build_local_plan(
     root: &Path,
-    args: &PublishArgs,
+    publisher: &ResolvedPublisher,
     make: &MakeReport,
     artifact_name: &str,
 ) -> Result<LocalPublishPlan> {
-    let publish_root = resolve_destination(root, &args.to);
+    let publish_root = resolve_destination(root, &publisher.to);
     let destination_dir = publish_root
-        .join(&args.channel)
+        .join(&publisher.channel)
         .join(make.package().platform())
         .join(make.package().arch());
     let destination_artifact = destination_dir.join(artifact_name);
@@ -178,12 +277,12 @@ fn build_local_plan(
 }
 
 fn build_github_plan(
-    args: &PublishArgs,
+    publisher: &ResolvedPublisher,
     make: &MakeReport,
     artifact_name: &str,
     warnings: &mut Vec<String>,
 ) -> Result<GithubPublishPlan> {
-    let repo = args
+    let repo = publisher
         .github_repo
         .clone()
         .or_else(|| {
@@ -204,44 +303,359 @@ fn build_github_plan(
         ));
     }
 
-    let tag = args
-        .github_tag
-        .clone()
-        .unwrap_or_else(|| default_github_tag(make, &args.channel));
-    let release_name = args
+    let tag = publisher.github_tag.clone().unwrap_or_else(|| {
+        default_github_tag(
+            make,
+            &publisher.channel,
+            publisher.github_tag_prefix.as_deref(),
+        )
+    });
+    let release_name = publisher
         .github_release_name
         .clone()
         .unwrap_or_else(|| tag.clone());
-    let prerelease = args.github_prerelease || tag.contains('-');
+    let prerelease = publisher.github_prerelease || tag.contains('-');
 
     Ok(GithubPublishPlan {
         repo,
         tag,
         release_name,
-        draft: args.github_draft,
+        draft: publisher.github_draft,
         prerelease,
-        api_url: args.github_api_url.trim_end_matches('/').to_string(),
+        api_url: publisher.github_api_url.trim_end_matches('/').to_string(),
         artifact_name: artifact_name.to_string(),
         release_url: None,
         asset_url: None,
     })
 }
 
+fn make_args(args: &PublishArgs) -> MakeArgs {
+    MakeArgs {
+        cwd: args.cwd.clone(),
+        out_dir: args.out_dir.clone(),
+        name: args.name.clone(),
+        platform: args.platform.clone(),
+        arch: args.arch.clone(),
+        target: args.target,
+        skip_package: false,
+        force: args.force,
+        dry_run: false,
+        json: false,
+    }
+}
+
+fn resolve_publishers(
+    project: &ProjectSnapshot,
+    args: &PublishArgs,
+    platform: &str,
+) -> Result<ResolvedPublishers> {
+    if let Some(target) = args.publisher {
+        return Ok(ResolvedPublishers {
+            publishers: vec![resolved_publisher_from_args(args, target, None)],
+            warnings: Vec::new(),
+        });
+    }
+
+    let configured = configured_publishers(project)?;
+    let mut warnings = Vec::new();
+    let mut publishers = Vec::new();
+
+    for publisher in &configured {
+        let Some(target) = publisher.target else {
+            warnings.push(format!(
+                "Configured publisher is not implemented yet and will be skipped: {}.",
+                publisher.label
+            ));
+            continue;
+        };
+        if !publisher_applies_to_platform(publisher, platform) {
+            continue;
+        }
+        publishers.push(resolved_publisher_from_args(args, target, Some(publisher)));
+    }
+
+    if publishers.is_empty() {
+        if !configured.is_empty() {
+            warnings.push(format!(
+                "No supported configured publishers apply to {platform}; defaulting to local. Pass --publisher to override."
+            ));
+        }
+        publishers.push(resolved_publisher_from_args(
+            args,
+            PublishTarget::Local,
+            None,
+        ));
+    }
+
+    Ok(ResolvedPublishers {
+        publishers,
+        warnings,
+    })
+}
+
+fn resolved_publisher_from_args(
+    args: &PublishArgs,
+    target: PublishTarget,
+    configured: Option<&ConfiguredPublisher>,
+) -> ResolvedPublisher {
+    let default_to = PathBuf::from("out/publish/local");
+    let default_channel = "default".to_string();
+    let default_github_api_url = "https://api.github.com".to_string();
+
+    ResolvedPublisher {
+        target,
+        to: args
+            .to
+            .clone()
+            .or_else(|| configured.and_then(|publisher| publisher.to.clone()))
+            .unwrap_or(default_to),
+        channel: args
+            .channel
+            .clone()
+            .or_else(|| configured.and_then(|publisher| publisher.channel.clone()))
+            .unwrap_or(default_channel),
+        github_repo: args
+            .github_repo
+            .clone()
+            .or_else(|| configured.and_then(|publisher| publisher.github_repo.clone())),
+        github_tag: args
+            .github_tag
+            .clone()
+            .or_else(|| configured.and_then(|publisher| publisher.github_tag.clone())),
+        github_tag_prefix: configured.and_then(|publisher| publisher.github_tag_prefix.clone()),
+        github_release_name: args
+            .github_release_name
+            .clone()
+            .or_else(|| configured.and_then(|publisher| publisher.github_release_name.clone())),
+        github_draft: args.github_draft
+            || configured
+                .and_then(|publisher| publisher.github_draft)
+                .unwrap_or(false),
+        github_prerelease: args.github_prerelease
+            || configured
+                .and_then(|publisher| publisher.github_prerelease)
+                .unwrap_or(false),
+        github_api_url: args
+            .github_api_url
+            .clone()
+            .or_else(|| configured.and_then(|publisher| publisher.github_api_url.clone()))
+            .unwrap_or(default_github_api_url),
+        github_auth_token: configured.and_then(|publisher| publisher.github_auth_token.clone()),
+        force_publish: args.force
+            || configured
+                .and_then(|publisher| publisher.force_publish)
+                .unwrap_or(false),
+    }
+}
+
+fn configured_publishers(project: &ProjectSnapshot) -> Result<Vec<ConfiguredPublisher>> {
+    let Some(package_json_path) = &project.package_json else {
+        return Ok(Vec::new());
+    };
+    let package_json_path = Path::new(package_json_path.as_str());
+    let raw = fs::read_to_string(package_json_path)
+        .with_context(|| format!("Could not read {}", package_json_path.display()))?;
+    let package = serde_json::from_str::<JsonValue>(&raw)
+        .with_context(|| format!("Could not parse {}", package_json_path.display()))?;
+
+    let mut publishers = Vec::new();
+    for value in [
+        package
+            .get("config")
+            .and_then(|config| config.get("forge"))
+            .and_then(|forge| forge.get("publishers")),
+        package
+            .get("electronCli")
+            .or_else(|| package.get("electron-cli"))
+            .and_then(|config| config.get("publishers")),
+    ]
+    .into_iter()
+    .flatten()
+    {
+        publishers.extend(parse_publisher_list(value));
+    }
+
+    Ok(publishers)
+}
+
+fn parse_publisher_list(value: &JsonValue) -> Vec<ConfiguredPublisher> {
+    match value {
+        JsonValue::Array(values) => values.iter().filter_map(parse_publisher).collect(),
+        _ => Vec::new(),
+    }
+}
+
+fn parse_publisher(value: &JsonValue) -> Option<ConfiguredPublisher> {
+    match value {
+        JsonValue::String(label) => Some(ConfiguredPublisher {
+            label: label.clone(),
+            target: publisher_target(label),
+            platforms: Vec::new(),
+            to: None,
+            channel: None,
+            github_repo: None,
+            github_tag: None,
+            github_tag_prefix: None,
+            github_release_name: None,
+            github_draft: None,
+            github_prerelease: None,
+            github_api_url: None,
+            github_auth_token: None,
+            force_publish: None,
+        }),
+        JsonValue::Object(object) => {
+            let label = object
+                .get("name")
+                .or_else(|| object.get("publisher"))
+                .or_else(|| object.get("target"))
+                .and_then(JsonValue::as_str)?
+                .to_string();
+            Some(ConfiguredPublisher {
+                target: publisher_target(&label),
+                platforms: string_values(object.get("platforms")),
+                to: publisher_config_string(object, &["to", "path", "dir", "directory"])
+                    .map(PathBuf::from),
+                channel: publisher_config_string(object, &["channel"]),
+                github_repo: publisher_config_github_repo(object),
+                github_tag: publisher_config_string(object, &["tag", "tagName", "tag_name"]),
+                github_tag_prefix: publisher_config_string(object, &["tagPrefix", "tag_prefix"]),
+                github_release_name: publisher_config_string(
+                    object,
+                    &["releaseName", "release_name"],
+                ),
+                github_draft: publisher_config_bool(object, &["draft"]),
+                github_prerelease: publisher_config_bool(object, &["prerelease", "preRelease"]),
+                github_api_url: publisher_config_api_url(object),
+                github_auth_token: publisher_config_string(object, &["authToken", "auth_token"]),
+                force_publish: publisher_config_bool(object, &["force"]),
+                label,
+            })
+        }
+        _ => None,
+    }
+}
+
+fn publisher_target(label: &str) -> Option<PublishTarget> {
+    let label = label.trim().to_ascii_lowercase();
+    let compact = label
+        .trim_start_matches("@electron-forge/")
+        .trim_start_matches("electron-forge-")
+        .trim_start_matches("publisher-");
+
+    if compact == "github"
+        || label.ends_with("/publisher-github")
+        || label.ends_with("publisher-github")
+    {
+        Some(PublishTarget::Github)
+    } else if compact == "local"
+        || label.ends_with("/publisher-local")
+        || label.ends_with("publisher-local")
+    {
+        Some(PublishTarget::Local)
+    } else {
+        None
+    }
+}
+
+fn publisher_applies_to_platform(publisher: &ConfiguredPublisher, platform: &str) -> bool {
+    publisher.platforms.is_empty()
+        || publisher
+            .platforms
+            .iter()
+            .any(|configured| configured == platform || configured == "*")
+}
+
+fn string_values(value: Option<&JsonValue>) -> Vec<String> {
+    match value {
+        Some(JsonValue::String(value)) => vec![value.clone()],
+        Some(JsonValue::Array(values)) => values
+            .iter()
+            .filter_map(JsonValue::as_str)
+            .map(ToOwned::to_owned)
+            .collect(),
+        _ => Vec::new(),
+    }
+}
+
+fn publisher_config_string(object: &JsonMap<String, JsonValue>, keys: &[&str]) -> Option<String> {
+    keys.iter().find_map(|key| {
+        publisher_config_value(object, key)
+            .and_then(JsonValue::as_str)
+            .map(str::trim)
+            .filter(|value| !value.is_empty())
+            .map(ToOwned::to_owned)
+    })
+}
+
+fn publisher_config_bool(object: &JsonMap<String, JsonValue>, keys: &[&str]) -> Option<bool> {
+    keys.iter()
+        .find_map(|key| publisher_config_value(object, key).and_then(JsonValue::as_bool))
+}
+
+fn publisher_config_value<'a>(
+    object: &'a JsonMap<String, JsonValue>,
+    key: &str,
+) -> Option<&'a JsonValue> {
+    object
+        .get("config")
+        .and_then(JsonValue::as_object)
+        .and_then(|config| config.get(key))
+        .or_else(|| object.get(key))
+}
+
+fn publisher_config_github_repo(object: &JsonMap<String, JsonValue>) -> Option<String> {
+    ["repository", "repo", "githubRepo", "github_repo"]
+        .iter()
+        .find_map(|key| publisher_config_value(object, key).and_then(github_repo_from_config_value))
+}
+
+fn github_repo_from_config_value(value: &JsonValue) -> Option<String> {
+    match value {
+        JsonValue::String(value) => {
+            let value = value.trim();
+            (!value.is_empty()).then(|| value.to_string())
+        }
+        JsonValue::Object(object) => {
+            let owner = object
+                .get("owner")
+                .or_else(|| object.get("user"))
+                .and_then(JsonValue::as_str)?
+                .trim();
+            let name = object
+                .get("name")
+                .or_else(|| object.get("repo"))
+                .and_then(JsonValue::as_str)?
+                .trim();
+            if owner.is_empty() || name.is_empty() {
+                None
+            } else {
+                Some(format!("{owner}/{name}"))
+            }
+        }
+        _ => None,
+    }
+}
+
+fn publisher_config_api_url(object: &JsonMap<String, JsonValue>) -> Option<String> {
+    publisher_config_string(object, &["apiUrl", "api_url", "baseUrl", "base_url"]).or_else(|| {
+        publisher_config_value(object, "octokitOptions")
+            .and_then(JsonValue::as_object)
+            .and_then(|octokit| {
+                octokit
+                    .get("baseUrl")
+                    .or_else(|| octokit.get("base_url"))
+                    .and_then(JsonValue::as_str)
+            })
+            .map(str::trim)
+            .filter(|value| !value.is_empty())
+            .map(ToOwned::to_owned)
+    })
+}
+
+#[cfg(test)]
 fn execute_publish(report: &mut PublishReport, args: &PublishArgs) -> Result<()> {
     if !args.skip_make {
-        let make_args = MakeArgs {
-            cwd: args.cwd.clone(),
-            out_dir: args.out_dir.clone(),
-            name: args.name.clone(),
-            platform: args.platform.clone(),
-            arch: args.arch.clone(),
-            target: args.target,
-            skip_package: false,
-            force: args.force,
-            dry_run: false,
-            json: false,
-        };
-        make::execute_make(&mut report.make, &make_args)?;
+        make::execute_make(&mut report.make, &make_args(args))?;
         report.make.mark_made()?;
     } else if !Path::new(report.make.artifact().as_str()).exists() {
         bail!(
@@ -252,18 +666,68 @@ fn execute_publish(report: &mut PublishReport, args: &PublishArgs) -> Result<()>
 
     let published_at_unix_seconds = now_unix_seconds()?;
     report.published_at_unix_seconds = Some(published_at_unix_seconds);
+    execute_publish_destination(report, published_at_unix_seconds)?;
+    report.status = PublishStatus::Published;
 
-    match args.publisher {
-        PublishTarget::Local => execute_local_publish(report, args, published_at_unix_seconds),
-        PublishTarget::Github => execute_github_publish(report, args),
-    }
+    Ok(())
 }
 
-fn execute_local_publish(
-    report: &PublishReport,
+fn execute_publish_reports(
+    reports: &mut [PublishReport],
+    make_reports: &mut [MakeReport],
     args: &PublishArgs,
+) -> Result<()> {
+    if !args.skip_make {
+        make::execute_make_reports(make_reports, &make_args(args))?;
+        sync_make_reports(reports, make_reports);
+    } else {
+        ensure_make_artifacts_exist(make_reports)?;
+    }
+
+    let published_at_unix_seconds = now_unix_seconds()?;
+    for report in reports {
+        report.published_at_unix_seconds = Some(published_at_unix_seconds);
+        execute_publish_destination(report, published_at_unix_seconds)?;
+        report.status = PublishStatus::Published;
+    }
+
+    Ok(())
+}
+
+fn sync_make_reports(reports: &mut [PublishReport], make_reports: &[MakeReport]) {
+    for report in reports {
+        if let Some(make) = make_reports
+            .iter()
+            .find(|make| make.artifact().as_str() == report.make.artifact().as_str())
+        {
+            report.make = make.clone();
+        }
+    }
+}
+
+fn ensure_make_artifacts_exist(make_reports: &[MakeReport]) -> Result<()> {
+    for make in make_reports {
+        if !Path::new(make.artifact().as_str()).exists() {
+            bail!(
+                "Make artifact does not exist: {}. Run without --skip-make or run electron-cli make first.",
+                make.artifact()
+            );
+        }
+    }
+    Ok(())
+}
+
+fn execute_publish_destination(
+    report: &mut PublishReport,
     published_at_unix_seconds: u64,
 ) -> Result<()> {
+    match report.publisher_kind {
+        PublishTarget::Local => execute_local_publish(report, published_at_unix_seconds),
+        PublishTarget::Github => execute_github_publish(report),
+    }
+}
+
+fn execute_local_publish(report: &PublishReport, published_at_unix_seconds: u64) -> Result<()> {
     let local = report
         .local
         .as_ref()
@@ -273,7 +737,7 @@ fn execute_local_publish(
 
     for path in [destination_artifact, manifest] {
         if path.exists() {
-            if args.force {
+            if report.force_publish {
                 fs::remove_file(path)
                     .with_context(|| format!("Could not remove {}", path.display()))?;
             } else {
@@ -303,10 +767,10 @@ fn execute_local_publish(
     Ok(())
 }
 
-fn execute_github_publish(report: &mut PublishReport, args: &PublishArgs) -> Result<()> {
-    let token = github_token()?;
+fn execute_github_publish(report: &mut PublishReport) -> Result<()> {
+    let token = github_token(report.github_auth_token.as_deref())?;
     let agent = github_agent();
-    publish_to_github(report, args, &token, &agent)
+    publish_to_github(report, &token, &agent)
 }
 
 #[derive(Debug, Serialize)]
@@ -338,12 +802,7 @@ struct GithubErrorBody {
     message: Option<String>,
 }
 
-fn publish_to_github(
-    report: &mut PublishReport,
-    args: &PublishArgs,
-    token: &str,
-    agent: &ureq::Agent,
-) -> Result<()> {
+fn publish_to_github(report: &mut PublishReport, token: &str, agent: &ureq::Agent) -> Result<()> {
     let artifact_path = Path::new(report.make.artifact().as_str());
     let github = report
         .github
@@ -359,7 +818,7 @@ fn publish_to_github(
         .iter()
         .find(|asset| asset.name == github.artifact_name)
     {
-        if args.force {
+        if report.force_publish {
             delete_github_asset(agent, token, github, asset.id)?;
         } else {
             bail!(
@@ -511,9 +970,13 @@ fn github_agent() -> ureq::Agent {
         .into()
 }
 
-fn github_token() -> Result<String> {
-    std::env::var("GITHUB_TOKEN")
-        .or_else(|_| std::env::var("GH_TOKEN"))
+fn github_token(configured_token: Option<&str>) -> Result<String> {
+    configured_token
+        .map(str::trim)
+        .filter(|token| !token.is_empty())
+        .map(ToOwned::to_owned)
+        .or_else(|| std::env::var("GITHUB_TOKEN").ok())
+        .or_else(|| std::env::var("GH_TOKEN").ok())
         .context("GitHub publisher requires GITHUB_TOKEN or GH_TOKEN")
 }
 
@@ -608,6 +1071,85 @@ fn print_report(report: &PublishReport, json: bool) -> Result<()> {
     Ok(())
 }
 
+fn print_reports(reports: &[PublishReport], json: bool, status: PublishStatus) -> Result<()> {
+    if reports.len() == 1 {
+        return print_report(&reports[0], json);
+    }
+
+    let warnings = combined_warnings(reports);
+    if json {
+        return output::json(&PublishRunReport {
+            publishes: reports,
+            dry_run: reports.iter().any(|report| report.dry_run),
+            status,
+            warnings,
+        });
+    }
+
+    println!("electron-cli publish");
+    println!();
+    if let Some(first) = reports.first() {
+        println!("Project");
+        println!("  root: {}", first.make.package().project().root);
+        match first.make.package().project().package_label() {
+            Some(label) => println!("  package: {label}"),
+            None => println!("  package: not found"),
+        }
+        println!("  app name: {}", first.make.package().app_name());
+        println!(
+            "  target platform: {} {}",
+            first.make.package().platform(),
+            first.make.package().arch()
+        );
+        println!("  status: {}", status.as_str());
+    }
+
+    println!();
+    println!("Publishes");
+    for report in reports {
+        println!(
+            "  {} {}: {}",
+            report.publisher,
+            report.make.target(),
+            report.make.artifact()
+        );
+        if let Some(local) = &report.local {
+            println!("    artifact: {}", local.destination_artifact);
+            println!("    manifest: {}", local.manifest);
+        }
+        if let Some(github) = &report.github {
+            println!("    repository: {}", github.repo);
+            println!("    tag: {}", github.tag);
+            if let Some(url) = &github.release_url {
+                println!("    release url: {url}");
+            }
+            if let Some(url) = &github.asset_url {
+                println!("    asset url: {url}");
+            }
+        }
+    }
+
+    if !warnings.is_empty() {
+        println!();
+        println!("Warnings");
+        for warning in warnings {
+            println!("  {warning}");
+        }
+    }
+
+    Ok(())
+}
+
+fn combined_warnings(reports: &[PublishReport]) -> Vec<String> {
+    let mut warnings = Vec::new();
+    for warning in reports.iter().flat_map(|report| report.warnings.iter()) {
+        if !warnings.contains(warning) {
+            warnings.push(warning.clone());
+        }
+    }
+    warnings
+}
+
 fn resolve_destination(root: &Path, destination: &Path) -> PathBuf {
     if destination.is_absolute() {
         destination.to_path_buf()
@@ -616,16 +1158,17 @@ fn resolve_destination(root: &Path, destination: &Path) -> PathBuf {
     }
 }
 
-fn default_github_tag(make: &MakeReport, channel: &str) -> String {
+fn default_github_tag(make: &MakeReport, channel: &str, tag_prefix: Option<&str>) -> String {
     make.package()
         .project()
         .version
         .as_deref()
         .map(|version| {
-            if version.starts_with('v') {
+            let prefix = tag_prefix.unwrap_or("v");
+            if prefix.is_empty() || version.starts_with(prefix) {
                 version.to_string()
             } else {
-                format!("v{version}")
+                format!("{prefix}{version}")
             }
         })
         .unwrap_or_else(|| channel.to_string())
@@ -807,6 +1350,106 @@ mod tests {
         let _ = fs::remove_dir_all(root);
     }
 
+    #[test]
+    fn builds_github_publish_report_from_configured_forge_publisher() {
+        let root = unique_temp_dir("configured-github-plan");
+        write_package_json_with_publishers(
+            &root,
+            r#"[
+                {
+                    "name":"@electron-forge/publisher-github",
+                    "platforms":["*"],
+                    "config":{
+                        "repository":{"owner":"Ikana","name":"electron-cli"},
+                        "draft":true,
+                        "prerelease":true,
+                        "tagPrefix":"release-",
+                        "releaseName":"Configured Release",
+                        "baseUrl":"http://127.0.0.1:9"
+                    }
+                }
+            ]"#,
+        );
+        write_app_file(&root);
+        write_fake_electron_dist(&root);
+
+        let mut args = publish_args(root.clone(), true);
+        args.target = None;
+        args.publisher = None;
+        args.github_api_url = None;
+        args.channel = None;
+        let report = build_report(&args).expect("report should build");
+
+        assert_eq!(report.publisher, "github");
+        assert!(report.local.is_none());
+        assert_eq!(report.channel, "default");
+        let github = report.github.as_ref().expect("github plan should exist");
+        assert_eq!(github.repo, "Ikana/electron-cli");
+        assert_eq!(github.tag, "release-0.1.0");
+        assert_eq!(github.release_name, "Configured Release");
+        assert!(github.draft);
+        assert!(github.prerelease);
+        assert_eq!(github.api_url, "http://127.0.0.1:9");
+
+        let _ = fs::remove_dir_all(root);
+    }
+
+    #[test]
+    fn builds_publish_reports_from_configured_makers_and_publishers() {
+        let root = unique_temp_dir("configured-publishers");
+        write_package_json_with_makers_and_publishers(
+            &root,
+            r#"[
+                {"name":"@electron-forge/maker-zip"},
+                {"name":"@electron-forge/maker-deb","platforms":["linux"]}
+            ]"#,
+            r#"[
+                {"name":"@electron-forge/publisher-github","config":{"repository":"Ikana/electron-cli"}},
+                {"name":"local","config":{"to":"dist/publish","channel":"beta"}},
+                {"name":"@electron-forge/publisher-s3"}
+            ]"#,
+        );
+        write_app_file(&root);
+        write_fake_electron_dist(&root);
+
+        let mut args = publish_args(root.clone(), true);
+        args.platform = Some("linux".to_string());
+        args.arch = Some("x64".to_string());
+        args.target = None;
+        args.publisher = None;
+        args.to = None;
+        args.channel = None;
+        args.github_api_url = None;
+        let reports = build_reports(&args).expect("reports should build");
+
+        assert_eq!(reports.len(), 4);
+        assert_eq!(reports[0].publisher, "github");
+        assert_eq!(reports[0].make.target(), "zip");
+        assert_eq!(reports[1].publisher, "github");
+        assert_eq!(reports[1].make.target(), "deb");
+        assert_eq!(reports[2].publisher, "local");
+        assert_eq!(reports[2].make.target(), "zip");
+        assert_eq!(reports[3].publisher, "local");
+        assert_eq!(reports[3].make.target(), "deb");
+        let local = reports[2].local.as_ref().expect("local plan should exist");
+        let local_parent = Path::new(local.destination_artifact.as_str())
+            .parent()
+            .expect("local artifact should have parent");
+        assert!(local_parent.ends_with(
+            PathBuf::from("dist")
+                .join("publish")
+                .join("beta")
+                .join("linux")
+                .join("x64")
+        ));
+        assert!(reports[0]
+            .warnings
+            .iter()
+            .any(|warning| warning.contains("@electron-forge/publisher-s3")));
+
+        let _ = fs::remove_dir_all(root);
+    }
+
     #[test]
     fn publishes_make_artifact_to_github_release() {
         let server = MockGithubServer::new(3);
@@ -824,7 +1467,7 @@ mod tests {
         fs::write(artifact, b"artifact bytes").expect("artifact should be written");
 
         let agent = github_agent();
-        publish_to_github(&mut report, &args, "test-token", &agent)
+        publish_to_github(&mut report, "test-token", &agent)
             .expect("github publish should succeed");
 
         let github = report.github.as_ref().expect("github plan should exist");
@@ -903,16 +1546,16 @@ mod tests {
             name: None,
             platform: None,
             arch: None,
-            target: crate::cli::MakeTarget::Zip,
-            publisher: crate::cli::PublishTarget::Local,
-            to: PathBuf::from("out/publish/local"),
+            target: Some(crate::cli::MakeTarget::Zip),
+            publisher: Some(crate::cli::PublishTarget::Local),
+            to: Some(PathBuf::from("out/publish/local")),
             github_repo: None,
             github_tag: None,
             github_release_name: None,
             github_draft: false,
             github_prerelease: false,
-            github_api_url: "https://api.github.com".to_string(),
-            channel: "default".to_string(),
+            github_api_url: Some("https://api.github.com".to_string()),
+            channel: Some("default".to_string()),
             skip_make: false,
             force: false,
             dry_run,
@@ -922,8 +1565,8 @@ mod tests {
 
     fn github_publish_args(root: PathBuf, dry_run: bool, api_url: &str) -> PublishArgs {
         let mut args = publish_args(root, dry_run);
-        args.publisher = crate::cli::PublishTarget::Github;
-        args.github_api_url = api_url.to_string();
+        args.publisher = Some(crate::cli::PublishTarget::Github);
+        args.github_api_url = Some(api_url.to_string());
         args
     }
 
@@ -943,6 +1586,38 @@ mod tests {
         .expect("package.json should be written");
     }
 
+    fn write_package_json_with_publishers(root: &Path, publishers: &str) {
+        fs::write(
+            root.join("package.json"),
+            format!(
+                r#"{{
+                    "name":"starter-app",
+                    "version":"0.1.0",
+                    "main":"src/main.js",
+                    "devDependencies":{{"electron":"30.0.0"}},
+                    "config":{{"forge":{{"publishers":{publishers}}}}}
+                }}"#
+            ),
+        )
+        .expect("package.json with publishers should be written");
+    }
+
+    fn write_package_json_with_makers_and_publishers(root: &Path, makers: &str, publishers: &str) {
+        fs::write(
+            root.join("package.json"),
+            format!(
+                r#"{{
+                    "name":"starter-app",
+                    "version":"0.1.0",
+                    "main":"src/main.js",
+                    "devDependencies":{{"electron":"30.0.0"}},
+                    "config":{{"forge":{{"makers":{makers},"publishers":{publishers}}}}}
+                }}"#
+            ),
+        )
+        .expect("package.json with makers and publishers should be written");
+    }
+
     fn write_app_file(root: &Path) {
         fs::create_dir_all(root.join("src")).expect("src should be created");
         fs::write(root.join("src/main.js"), "console.log('hello');")