electron-cli 0.3.0-alpha.3 → 0.3.0-alpha.4

package/Cargo.lock

@@ -2,6 +2,12 @@
 # It is not intended for manual editing.
 version = 4
 
+[[package]]
+name = "adler2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
+
 [[package]]
 name = "anstream"
 version = "1.0.0"
@@ -67,6 +73,12 @@ dependencies = [
  "serde_core",
 ]
 
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
 [[package]]
 name = "clap"
 version = "4.6.1"
@@ -113,23 +125,65 @@ version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
 
+[[package]]
+name = "crc32fast"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
+dependencies = [
+ "cfg-if",
+]
+
 [[package]]
 name = "electron-cli"
-version = "0.3.0-alpha.3"
+version = "0.3.0-alpha.4"
 dependencies = [
  "anyhow",
  "camino",
  "clap",
  "serde",
  "serde_json",
+ "zip",
+]
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "flate2"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"
+dependencies = [
+ "miniz_oxide",
+ "zlib-rs",
 ]
 
+[[package]]
+name = "hashbrown"
+version = "0.17.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
+
 [[package]]
 name = "heck"
 version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
+[[package]]
+name = "indexmap"
+version = "2.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"
+dependencies = [
+ "equivalent",
+ "hashbrown",
+]
+
 [[package]]
 name = "is_terminal_polyfill"
 version = "1.70.2"
@@ -148,6 +202,16 @@ version = "2.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6b947ae49db0d222b1dbc6b113ce7248a3fc3a6ca21b696717bfc000ba4484d8"
 
+[[package]]
+name = "miniz_oxide"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
+dependencies = [
+ "adler2",
+ "simd-adler32",
+]
+
 [[package]]
 name = "once_cell_polyfill"
 version = "1.70.2"
@@ -215,6 +279,12 @@ dependencies = [
  "zmij",
 ]
 
+[[package]]
+name = "simd-adler32"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "703d5c7ef118737c72f1af64ad2f6f8c5e1921f818cdcb97b8fe6fc69bf66214"
+
 [[package]]
 name = "strsim"
 version = "0.11.1"
@@ -232,6 +302,12 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "typed-path"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e28f89b80c87b8fb0cf04ab448d5dd0dd0ade2f8891bae878de66a75a28600e"
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.24"
@@ -259,6 +335,25 @@ dependencies = [
  "windows-link",
 ]
 
+[[package]]
+name = "zip"
+version = "8.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d04a6b5381502aa6087c94c669499eb1602eb9c5e8198e534de571f7154809b"
+dependencies = [
+ "crc32fast",
+ "flate2",
+ "indexmap",
+ "memchr",
+ "typed-path",
+]
+
+[[package]]
+name = "zlib-rs"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3be3d40e40a133f9c916ee3f9f4fa2d9d63435b5fbe1bfc6d9dae0aa0ada1513"
+
 [[package]]
 name = "zmij"
 version = "1.0.21"

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "electron-cli"
-version = "0.3.0-alpha.3"
+version = "0.3.0-alpha.4"
 edition = "2021"
 description = "Experimental Rust CLI for Electron project diagnostics and workflow automation"
 license = "MIT"
@@ -12,3 +12,4 @@ camino = { version = "1.1", features = ["serde1"] }
 clap = { version = "4.6", features = ["derive"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
+zip = { version = "8.6.0", default-features = false, features = ["deflate-flate2-zlib-rs"] }

package/README.md

@@ -17,18 +17,19 @@ electron-cli plan
 electron-cli init my-app
 electron-cli start
 electron-cli package
+electron-cli make
 electron-cli inspect --json
 electron-cli doctor --json
 electron-cli plan --json
 electron-cli init my-app --dry-run --json
 electron-cli start --dry-run --json
 electron-cli package --dry-run --json
+electron-cli make --dry-run --json
 ```
 
 Planned commands:
 
 ```sh
-electron-cli make
 electron-cli publish
 ```
 
@@ -39,8 +40,9 @@ The Rust-native flow currently owns:
 - `init --template minimal`: writes a local Electron starter without Electron Forge.
 - `start`: launches the installed Electron runtime directly.
 - `package`: copies the installed Electron runtime and app files into a local app bundle for the current platform and architecture. The first package pass supports apps without production `dependencies`; dependency pruning and bundled runtime dependencies are still TODO.
+- `make`: runs `package` and writes a ZIP distributable under `out/make/zip/<platform>/<arch>/`.
 
-`make` and `publish` are not implemented yet. They are the next pieces of the Forge lifecycle to replace.
+`publish` is not implemented yet. It is the next piece of the Forge lifecycle to replace.
 
 ## Install
 
@@ -74,6 +76,7 @@ cargo run -- inspect --json
 cargo run -- init my-app
 cargo run -- start --dry-run
 cargo run -- package --dry-run
+cargo run -- make --dry-run
 ```
 
 ## Design Goals
@@ -97,6 +100,7 @@ The inspection and planning commands support `--json` so agents and scripts can
 `init --dry-run --json` shows whether the CLI will write native template files or delegate to `create-electron-app`.
 `start --dry-run --json` shows the Electron executable that will be launched.
 `package --dry-run --json` shows the runtime and app file copy plan.
+`make --dry-run --json` shows the package prerequisite and ZIP artifact path.
 
 ```sh
 electron-cli plan --json

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electron-cli",
-  "version": "0.3.0-alpha.3",
+  "version": "0.3.0-alpha.4",
   "description": "Experimental Rust CLI for Electron project diagnostics and workflow automation",
   "license": "MIT",
   "repository": {

package/src/cli.rs

@@ -22,6 +22,8 @@ pub enum Commands {
     Init(InitArgs),
     /// Print a structured snapshot of the current JavaScript/Electron project.
     Inspect(CommandArgs),
+    /// Create distributable artifacts from a packaged Electron app.
+    Make(MakeArgs),
     /// Create a local Electron application bundle without Electron Forge.
     Package(PackageArgs),
     /// Recommend next commands and risks from the project snapshot.
@@ -138,6 +140,49 @@ pub struct PackageArgs {
     pub json: bool,
 }
 
+#[derive(Debug, Clone, Args)]
+pub struct MakeArgs {
+    /// Project directory to make distributables for.
+    #[arg(long, default_value = ".", value_name = "PATH")]
+    pub cwd: PathBuf,
+
+    /// Output directory used for package and make artifacts.
+    #[arg(long, default_value = "out", value_name = "PATH")]
+    pub out_dir: PathBuf,
+
+    /// Override the application name.
+    #[arg(long)]
+    pub name: Option<String>,
+
+    /// Target platform label. Defaults to the current platform.
+    #[arg(long)]
+    pub platform: Option<String>,
+
+    /// Target architecture label. Defaults to the current architecture.
+    #[arg(long)]
+    pub arch: Option<String>,
+
+    /// Maker target to run.
+    #[arg(long, value_enum, default_value_t = MakeTarget::Zip)]
+    pub target: MakeTarget,
+
+    /// Reuse an existing package output instead of running package first.
+    #[arg(long)]
+    pub skip_package: bool,
+
+    /// Overwrite existing package and make artifacts.
+    #[arg(long)]
+    pub force: bool,
+
+    /// Print the make plan without creating files.
+    #[arg(long)]
+    pub dry_run: bool,
+
+    /// Emit machine-readable JSON.
+    #[arg(long)]
+    pub json: bool,
+}
+
 #[derive(Debug, Clone, Copy, ValueEnum)]
 #[value(rename_all = "lower")]
 pub enum PackageManager {
@@ -157,3 +202,17 @@ impl PackageManager {
         }
     }
 }
+
+#[derive(Debug, Clone, Copy, ValueEnum)]
+#[value(rename_all = "lower")]
+pub enum MakeTarget {
+    Zip,
+}
+
+impl MakeTarget {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            MakeTarget::Zip => "zip",
+        }
+    }
+}

package/src/commands/make.rs

@@ -0,0 +1,426 @@
+use std::{
+    fs,
+    fs::File,
+    io::{self, BufWriter},
+    path::{Path, PathBuf},
+};
+
+use anyhow::{bail, Context, Result};
+use camino::Utf8PathBuf;
+use serde::Serialize;
+use zip::{write::SimpleFileOptions, CompressionMethod, ZipWriter};
+
+use crate::{
+    cli::{MakeArgs, PackageArgs},
+    commands::package::{self, PackageReport},
+    output,
+};
+
+#[derive(Debug, Serialize)]
+struct MakeReport {
+    package: PackageReport,
+    target: String,
+    skip_package: bool,
+    dry_run: bool,
+    make_dir: Utf8PathBuf,
+    artifact: Utf8PathBuf,
+    artifact_size: Option<u64>,
+    status: MakeStatus,
+    warnings: Vec<String>,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "kebab-case")]
+enum MakeStatus {
+    Planned,
+    Made,
+}
+
+pub fn run(args: MakeArgs) -> Result<()> {
+    let mut report = build_report(&args)?;
+
+    if args.dry_run {
+        return print_report(&report, args.json);
+    }
+
+    execute_make(&mut report, &args)?;
+    report.status = MakeStatus::Made;
+    report.artifact_size = Some(
+        fs::metadata(report.artifact.as_str())
+            .with_context(|| format!("Could not stat {}", report.artifact))?
+            .len(),
+    );
+
+    print_report(&report, args.json)
+}
+
+fn build_report(args: &MakeArgs) -> Result<MakeReport> {
+    let package_args = PackageArgs {
+        cwd: args.cwd.clone(),
+        out_dir: args.out_dir.clone(),
+        name: args.name.clone(),
+        platform: args.platform.clone(),
+        arch: args.arch.clone(),
+        force: args.force,
+        dry_run: false,
+        json: false,
+    };
+    let snapshot = crate::project::inspect(&package_args.cwd)?;
+    let package = package::build_report(snapshot, &package_args)?;
+    let make_dir = Path::new(package.output_dir().as_str())
+        .join("make")
+        .join(args.target.as_str())
+        .join(package.platform())
+        .join(package.arch());
+    let artifact = make_dir.join(format!(
+        "{}-{}-{}.zip",
+        package.artifact_stem(),
+        package.platform(),
+        package.arch()
+    ));
+
+    let mut warnings = package.warnings().to_vec();
+    if args.skip_package && !Path::new(package.bundle_dir().as_str()).exists() {
+        warnings.push(format!(
+            "Package output does not exist: {}.",
+            package.bundle_dir()
+        ));
+    }
+
+    if artifact.exists() && !args.force {
+        warnings.push(format!(
+            "Make artifact already exists: {}. Use --force to overwrite it.",
+            artifact.display()
+        ));
+    }
+
+    Ok(MakeReport {
+        package,
+        target: args.target.as_str().to_string(),
+        skip_package: args.skip_package,
+        dry_run: args.dry_run,
+        make_dir: utf8_path(make_dir)?,
+        artifact: utf8_path(artifact)?,
+        artifact_size: None,
+        status: MakeStatus::Planned,
+        warnings,
+    })
+}
+
+fn execute_make(report: &mut MakeReport, args: &MakeArgs) -> Result<()> {
+    if !args.skip_package {
+        package::execute_package(&report.package, args.force)?;
+        report.package.mark_packaged();
+    } else if !Path::new(report.package.bundle_dir().as_str()).exists() {
+        bail!(
+            "Package output does not exist: {}. Run without --skip-package or run electron-cli package first.",
+            report.package.bundle_dir()
+        );
+    }
+
+    let artifact = Path::new(report.artifact.as_str());
+    if artifact.exists() {
+        if args.force {
+            fs::remove_file(artifact)
+                .with_context(|| format!("Could not remove {}", artifact.display()))?;
+        } else {
+            bail!(
+                "Make artifact already exists: {}. Use --force to overwrite it.",
+                artifact.display()
+            );
+        }
+    }
+
+    fs::create_dir_all(report.make_dir.as_str())
+        .with_context(|| format!("Could not create {}", report.make_dir))?;
+    write_zip_archive(Path::new(report.package.bundle_dir().as_str()), artifact)?;
+
+    Ok(())
+}
+
+fn print_report(report: &MakeReport, json: bool) -> Result<()> {
+    if json {
+        return output::json(report);
+    }
+
+    println!("electron-cli make");
+    println!();
+    println!("Project");
+    println!("  root: {}", report.package.project().root);
+    match report.package.project().package_label() {
+        Some(label) => println!("  package: {label}"),
+        None => println!("  package: not found"),
+    }
+    println!("  app name: {}", report.package.app_name());
+    println!(
+        "  target: {} {} {}",
+        report.target,
+        report.package.platform(),
+        report.package.arch()
+    );
+    println!("  status: {}", report.status.as_str());
+
+    println!();
+    println!("Artifact");
+    println!("  {}", report.artifact);
+    if let Some(size) = report.artifact_size {
+        println!("  size: {size} bytes");
+    }
+
+    if !report.warnings.is_empty() {
+        println!();
+        println!("Warnings");
+        for warning in &report.warnings {
+            println!("  {warning}");
+        }
+    }
+
+    Ok(())
+}
+
+fn write_zip_archive(source: &Path, artifact: &Path) -> Result<()> {
+    if !source.exists() {
+        bail!("Package output does not exist: {}", source.display());
+    }
+
+    let parent = artifact
+        .parent()
+        .with_context(|| format!("Artifact path has no parent: {}", artifact.display()))?;
+    fs::create_dir_all(parent).with_context(|| format!("Could not create {}", parent.display()))?;
+
+    let file = File::create(artifact)
+        .with_context(|| format!("Could not create {}", artifact.display()))?;
+    let mut writer = ZipWriter::new(BufWriter::new(file));
+    let base = source
+        .parent()
+        .with_context(|| format!("Package output has no parent: {}", source.display()))?;
+
+    add_path_to_zip(source, base, &mut writer)?;
+    writer
+        .finish()
+        .with_context(|| format!("Could not finish {}", artifact.display()))?;
+
+    Ok(())
+}
+
+fn add_path_to_zip(
+    path: &Path,
+    base: &Path,
+    writer: &mut ZipWriter<BufWriter<File>>,
+) -> Result<()> {
+    let metadata =
+        fs::metadata(path).with_context(|| format!("Could not stat {}", path.display()))?;
+    let relative_path = zip_relative_path(path, base)?;
+
+    if metadata.is_dir() {
+        if !relative_path.is_empty() {
+            let directory_name = format!("{relative_path}/");
+            writer
+                .add_directory(directory_name, directory_options(&metadata))
+                .with_context(|| format!("Could not add {} to archive", path.display()))?;
+        }
+
+        let mut entries = fs::read_dir(path)
+            .with_context(|| format!("Could not read {}", path.display()))?
+            .collect::<Result<Vec<_>, io::Error>>()?;
+        entries.sort_by_key(|entry| entry.path());
+
+        for entry in entries {
+            add_path_to_zip(&entry.path(), base, writer)?;
+        }
+    } else {
+        writer
+            .start_file(relative_path, file_options(&metadata))
+            .with_context(|| format!("Could not add {} to archive", path.display()))?;
+        let mut file =
+            File::open(path).with_context(|| format!("Could not open {}", path.display()))?;
+        io::copy(&mut file, writer)
+            .with_context(|| format!("Could not write {} to archive", path.display()))?;
+    }
+
+    Ok(())
+}
+
+fn zip_relative_path(path: &Path, base: &Path) -> Result<String> {
+    let relative = path.strip_prefix(base).with_context(|| {
+        format!(
+            "Could not make {} relative to {}",
+            path.display(),
+            base.display()
+        )
+    })?;
+    Ok(relative
+        .components()
+        .map(|component| component.as_os_str().to_string_lossy())
+        .collect::<Vec<_>>()
+        .join("/"))
+}
+
+fn file_options(metadata: &fs::Metadata) -> SimpleFileOptions {
+    SimpleFileOptions::default()
+        .compression_method(CompressionMethod::Deflated)
+        .unix_permissions(unix_mode(metadata, 0o644))
+}
+
+fn directory_options(metadata: &fs::Metadata) -> SimpleFileOptions {
+    SimpleFileOptions::default()
+        .compression_method(CompressionMethod::Stored)
+        .unix_permissions(unix_mode(metadata, 0o755))
+}
+
+#[cfg(unix)]
+fn unix_mode(metadata: &fs::Metadata, _fallback: u32) -> u32 {
+    use std::os::unix::fs::PermissionsExt;
+
+    metadata.permissions().mode()
+}
+
+#[cfg(not(unix))]
+fn unix_mode(_metadata: &fs::Metadata, fallback: u32) -> u32 {
+    fallback
+}
+
+fn utf8_path(path: PathBuf) -> Result<Utf8PathBuf> {
+    Utf8PathBuf::from_path_buf(path).map_err(|path| {
+        anyhow::anyhow!(
+            "Path contains invalid UTF-8 and cannot be represented in JSON: {}",
+            path.display()
+        )
+    })
+}
+
+impl MakeStatus {
+    fn as_str(&self) -> &'static str {
+        match self {
+            MakeStatus::Planned => "planned",
+            MakeStatus::Made => "made",
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use zip::ZipArchive;
+
+    #[test]
+    fn builds_make_report_for_zip_target() {
+        let root = unique_temp_dir("plan");
+        write_package_json(&root);
+        write_app_file(&root);
+        write_fake_electron_dist(&root);
+
+        let args = MakeArgs {
+            cwd: root.clone(),
+            out_dir: PathBuf::from("out"),
+            name: None,
+            platform: None,
+            arch: None,
+            target: crate::cli::MakeTarget::Zip,
+            skip_package: false,
+            force: false,
+            dry_run: true,
+            json: true,
+        };
+        let report = build_report(&args).expect("report should build");
+
+        assert_eq!(report.target, "zip");
+        let expected_suffix = PathBuf::from("out")
+            .join("make")
+            .join("zip")
+            .join(report.package.platform())
+            .join(report.package.arch())
+            .join(format!(
+                "starter-app-{}-{}.zip",
+                report.package.platform(),
+                report.package.arch()
+            ));
+        assert!(Path::new(report.artifact.as_str()).ends_with(expected_suffix));
+
+        let _ = fs::remove_dir_all(root);
+    }
+
+    #[test]
+    fn makes_zip_artifact_after_packaging() {
+        let root = unique_temp_dir("execute");
+        write_package_json(&root);
+        write_app_file(&root);
+        write_fake_electron_dist(&root);
+
+        let args = MakeArgs {
+            cwd: root.clone(),
+            out_dir: PathBuf::from("out"),
+            name: None,
+            platform: None,
+            arch: None,
+            target: crate::cli::MakeTarget::Zip,
+            skip_package: false,
+            force: false,
+            dry_run: false,
+            json: false,
+        };
+        let mut report = build_report(&args).expect("report should build");
+
+        execute_make(&mut report, &args).expect("make should succeed");
+
+        let file = File::open(report.artifact.as_str()).expect("artifact should exist");
+        let mut archive = ZipArchive::new(file).expect("zip should open");
+        let app_entry = if report.package.platform() == "darwin" {
+            "starter-app.app/Contents/Resources/app/package.json".to_string()
+        } else {
+            format!(
+                "starter-app-{}-{}/resources/app/package.json",
+                report.package.platform(),
+                report.package.arch()
+            )
+        };
+
+        archive
+            .by_name(&app_entry)
+            .expect("app package.json should be archived");
+
+        let _ = fs::remove_dir_all(root);
+    }
+
+    fn write_package_json(root: &Path) {
+        fs::write(
+            root.join("package.json"),
+            r#"{"name":"starter-app","version":"0.1.0","main":"src/main.js","devDependencies":{"electron":"30.0.0"}}"#,
+        )
+        .expect("package.json 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');")
+            .expect("main file should be written");
+    }
+
+    fn write_fake_electron_dist(root: &Path) {
+        let dist = root.join("node_modules/electron/dist");
+        if cfg!(target_os = "macos") {
+            let app = dist.join("Electron.app/Contents/MacOS");
+            fs::create_dir_all(&app).expect("fake macOS electron app should be created");
+            fs::write(app.join("Electron"), "").expect("fake macOS binary should be written");
+        } else if cfg!(target_os = "windows") {
+            fs::create_dir_all(&dist).expect("fake electron dist should be created");
+            fs::write(dist.join("electron.exe"), "").expect("fake exe should be written");
+        } else {
+            fs::create_dir_all(&dist).expect("fake electron dist should be created");
+            fs::write(dist.join("electron"), "").expect("fake binary should be written");
+        }
+    }
+
+    fn unique_temp_dir(label: &str) -> PathBuf {
+        let nanos = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .expect("clock should be after epoch")
+            .as_nanos();
+        let path = std::env::temp_dir().join(format!(
+            "electron-cli-make-{label}-{}-{nanos}",
+            std::process::id()
+        ));
+        fs::create_dir_all(&path).expect("temp dir should be created");
+        path
+    }
+}

package/src/commands/mod.rs

@@ -1,6 +1,7 @@
 pub mod doctor;
 pub mod init;
 pub mod inspect;
+pub mod make;
 pub mod package;
 pub mod plan;
 pub mod start;

package/src/commands/package.rs

@@ -10,7 +10,7 @@ use serde::Serialize;
 use crate::{cli::PackageArgs, output, project::ProjectSnapshot};
 
 #[derive(Debug, Serialize)]
-struct PackageReport {
+pub(crate) struct PackageReport {
     project: ProjectSnapshot,
     app_name: String,
     executable_name: String,
@@ -54,7 +54,7 @@ pub fn run(args: PackageArgs) -> Result<()> {
     print_report(&report, args.json)
 }
 
-fn build_report(snapshot: ProjectSnapshot, args: &PackageArgs) -> Result<PackageReport> {
+pub(crate) fn build_report(snapshot: ProjectSnapshot, args: &PackageArgs) -> Result<PackageReport> {
     let root = Path::new(snapshot.root.as_str());
     let platform = args.platform.clone().unwrap_or_else(current_platform);
     let arch = args.arch.clone().unwrap_or_else(current_arch);
@@ -150,7 +150,7 @@ fn build_report(snapshot: ProjectSnapshot, args: &PackageArgs) -> Result<Package
     })
 }
 
-fn execute_package(report: &PackageReport, force: bool) -> Result<()> {
+pub(crate) fn execute_package(report: &PackageReport, force: bool) -> Result<()> {
     if report.project.package_json.is_none() {
         bail!("No package.json found. Run electron-cli package inside an Electron project.");
     }
@@ -508,6 +508,44 @@ impl PackageStatus {
     }
 }
 
+impl PackageReport {
+    pub(crate) fn project(&self) -> &ProjectSnapshot {
+        &self.project
+    }
+
+    pub(crate) fn mark_packaged(&mut self) {
+        self.status = PackageStatus::Packaged;
+    }
+
+    pub(crate) fn app_name(&self) -> &str {
+        &self.app_name
+    }
+
+    pub(crate) fn artifact_stem(&self) -> String {
+        sanitize_artifact_name(&self.app_name)
+    }
+
+    pub(crate) fn platform(&self) -> &str {
+        &self.platform
+    }
+
+    pub(crate) fn arch(&self) -> &str {
+        &self.arch
+    }
+
+    pub(crate) fn output_dir(&self) -> &Utf8PathBuf {
+        &self.output_dir
+    }
+
+    pub(crate) fn bundle_dir(&self) -> &Utf8PathBuf {
+        &self.bundle_dir
+    }
+
+    pub(crate) fn warnings(&self) -> &[String] {
+        &self.warnings
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

package/src/commands/plan.rs

@@ -106,7 +106,9 @@ fn build_report(snapshot: &project::ProjectSnapshot) -> PlanReport {
         );
     }
 
-    if let Some(script) = first_script(snapshot, &["make", "dist"]) {
+    if matches!(project_type, ProjectType::Electron) && snapshot.main.is_some() {
+        recommended_commands.insert("make".to_string(), "electron-cli make".to_string());
+    } else if let Some(script) = first_script(snapshot, &["make", "dist"]) {
         recommended_commands.insert("make".to_string(), run_script(snapshot, script));
     }
 
@@ -270,5 +272,9 @@ mod tests {
                 .map(String::as_str),
             Some("electron-cli package")
         );
+        assert_eq!(
+            report.recommended_commands.get("make").map(String::as_str),
+            Some("electron-cli make")
+        );
     }
 }

package/src/main.rs

@@ -21,6 +21,7 @@ fn run() -> Result<()> {
         Commands::Doctor(args) => commands::doctor::run(args),
         Commands::Init(args) => commands::init::run(args),
         Commands::Inspect(args) => commands::inspect::run(args),
+        Commands::Make(args) => commands::make::run(args),
         Commands::Package(args) => commands::package::run(args),
         Commands::Plan(args) => commands::plan::run(args),
         Commands::Start(args) => commands::start::run(args),