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

package/Cargo.lock

@@ -136,7 +136,7 @@ dependencies = [
 
 [[package]]
 name = "electron-cli"
-version = "0.3.0-alpha.4"
+version = "0.3.0-alpha.6"
 dependencies = [
  "anyhow",
  "camino",

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "electron-cli"
-version = "0.3.0-alpha.4"
+version = "0.3.0-alpha.6"
 edition = "2021"
 description = "Experimental Rust CLI for Electron project diagnostics and workflow automation"
 license = "MIT"

package/README.md

@@ -18,6 +18,7 @@ electron-cli init my-app
 electron-cli start
 electron-cli package
 electron-cli make
+electron-cli publish
 electron-cli inspect --json
 electron-cli doctor --json
 electron-cli plan --json
@@ -25,12 +26,13 @@ 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
+electron-cli publish --dry-run --json
 ```
 
 Planned commands:
 
 ```sh
-electron-cli publish
+electron-cli publish --publisher github
 ```
 
 The default `init` template is `minimal`, a built-in starter written by this project. Non-native template names are still passed to `create-electron-app` as an escape hatch while this project grows.
@@ -39,10 +41,11 @@ 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.
+- `package`: copies the installed Electron runtime, app files, and installed production dependency closure into a local app bundle for the current platform and architecture.
 - `make`: runs `package` and writes a ZIP distributable under `out/make/zip/<platform>/<arch>/`.
+- `publish`: runs `make` and publishes the distributable to a local directory with a manifest.
 
-`publish` is not implemented yet. It is the next piece of the Forge lifecycle to replace.
+Remote publishers such as GitHub Releases are not implemented yet. Platform-specific makers, app metadata, signing, and notarization are also still TODO.
 
 ## Install
 
@@ -77,6 +80,7 @@ cargo run -- init my-app
 cargo run -- start --dry-run
 cargo run -- package --dry-run
 cargo run -- make --dry-run
+cargo run -- publish --dry-run
 ```
 
 ## Design Goals
@@ -101,6 +105,7 @@ The inspection and planning commands support `--json` so agents and scripts can
 `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.
+`publish --dry-run --json` shows the make prerequisite, destination artifact, and manifest path.
 
 ```sh
 electron-cli plan --json

package/package.json

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

package/src/cli.rs

@@ -28,6 +28,8 @@ pub enum Commands {
     Package(PackageArgs),
     /// Recommend next commands and risks from the project snapshot.
     Plan(CommandArgs),
+    /// Publish made artifacts to a distribution target.
+    Publish(PublishArgs),
     /// Launch the current Electron app without Electron Forge.
     Start(StartArgs),
 }
@@ -183,6 +185,61 @@ pub struct MakeArgs {
     pub json: bool,
 }
 
+#[derive(Debug, Clone, Args)]
+pub struct PublishArgs {
+    /// Project directory to publish from.
+    #[arg(long, default_value = ".", value_name = "PATH")]
+    pub cwd: PathBuf,
+
+    /// Output directory used for package, make, and publish 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 whose artifact should be published.
+    #[arg(long, value_enum, default_value_t = MakeTarget::Zip)]
+    pub target: MakeTarget,
+
+    /// Publisher target to use.
+    #[arg(long, value_enum, default_value_t = PublishTarget::Local)]
+    pub publisher: PublishTarget,
+
+    /// Destination for local published artifacts.
+    #[arg(long, default_value = "out/publish/local", value_name = "PATH")]
+    pub to: PathBuf,
+
+    /// Release channel label written into the publish manifest.
+    #[arg(long, default_value = "default")]
+    pub channel: String,
+
+    /// Reuse an existing make artifact instead of running package and make first.
+    #[arg(long)]
+    pub skip_make: bool,
+
+    /// Overwrite existing publish artifacts.
+    #[arg(long)]
+    pub force: bool,
+
+    /// Print the publish 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 {
@@ -216,3 +273,17 @@ impl MakeTarget {
         }
     }
 }
+
+#[derive(Debug, Clone, Copy, ValueEnum)]
+#[value(rename_all = "lower")]
+pub enum PublishTarget {
+    Local,
+}
+
+impl PublishTarget {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            PublishTarget::Local => "local",
+        }
+    }
+}

package/src/commands/make.rs

@@ -17,7 +17,7 @@ use crate::{
 };
 
 #[derive(Debug, Serialize)]
-struct MakeReport {
+pub(crate) struct MakeReport {
     package: PackageReport,
     target: String,
     skip_package: bool,
@@ -44,17 +44,12 @@ pub fn run(args: MakeArgs) -> Result<()> {
     }
 
     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(),
-    );
+    report.mark_made()?;
 
     print_report(&report, args.json)
 }
 
-fn build_report(args: &MakeArgs) -> Result<MakeReport> {
+pub(crate) fn build_report(args: &MakeArgs) -> Result<MakeReport> {
     let package_args = PackageArgs {
         cwd: args.cwd.clone(),
         out_dir: args.out_dir.clone(),
@@ -107,7 +102,7 @@ fn build_report(args: &MakeArgs) -> Result<MakeReport> {
     })
 }
 
-fn execute_make(report: &mut MakeReport, args: &MakeArgs) -> Result<()> {
+pub(crate) fn execute_make(report: &mut MakeReport, args: &MakeArgs) -> Result<()> {
     if !args.skip_package {
         package::execute_package(&report.package, args.force)?;
         report.package.mark_packaged();
@@ -298,6 +293,34 @@ impl MakeStatus {
     }
 }
 
+impl MakeReport {
+    pub(crate) fn mark_made(&mut self) -> Result<()> {
+        self.status = MakeStatus::Made;
+        self.artifact_size = Some(
+            fs::metadata(self.artifact.as_str())
+                .with_context(|| format!("Could not stat {}", self.artifact))?
+                .len(),
+        );
+        Ok(())
+    }
+
+    pub(crate) fn package(&self) -> &PackageReport {
+        &self.package
+    }
+
+    pub(crate) fn target(&self) -> &str {
+        &self.target
+    }
+
+    pub(crate) fn artifact(&self) -> &Utf8PathBuf {
+        &self.artifact
+    }
+
+    pub(crate) fn warnings(&self) -> &[String] {
+        &self.warnings
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

package/src/commands/mod.rs

@@ -4,4 +4,5 @@ pub mod inspect;
 pub mod make;
 pub mod package;
 pub mod plan;
+pub mod publish;
 pub mod start;

package/src/commands/package.rs

@@ -1,4 +1,5 @@
 use std::{
+    collections::{BTreeMap, BTreeSet, VecDeque},
     fs,
     path::{Path, PathBuf},
 };
@@ -6,6 +7,7 @@ use std::{
 use anyhow::{bail, Context, Result};
 use camino::Utf8PathBuf;
 use serde::Serialize;
+use serde_json::Value;
 
 use crate::{cli::PackageArgs, output, project::ProjectSnapshot};
 
@@ -87,13 +89,6 @@ pub(crate) fn build_report(snapshot: ProjectSnapshot, args: &PackageArgs) -> Res
         warnings.push("No package.json main field found.".to_string());
     }
 
-    if has_runtime_dependencies(&snapshot) {
-        warnings.push(
-            "Packaging production node_modules is not implemented yet; this project declares runtime dependencies."
-                .to_string(),
-        );
-    }
-
     if !electron_source.exists() {
         warnings.push(format!(
             "Electron runtime was not found at {}.",
@@ -115,11 +110,19 @@ pub(crate) fn build_report(snapshot: ProjectSnapshot, args: &PackageArgs) -> Res
         ));
     }
 
+    warnings.extend(runtime_dependency_warnings(root, &snapshot));
+
     let create_dirs = vec![package_root.clone(), app_resources_dir.clone()];
-    let copy_steps = [
+    let mut copy_steps = vec![
         (electron_source, bundle_dir.clone()),
         (root.to_path_buf(), app_resources_dir.join("app")),
     ];
+    if has_runtime_dependencies(&snapshot) {
+        copy_steps.push((
+            root.join("node_modules"),
+            app_resources_dir.join("app/node_modules"),
+        ));
+    }
 
     Ok(PackageReport {
         project: snapshot,
@@ -159,12 +162,6 @@ pub(crate) fn execute_package(report: &PackageReport, force: bool) -> Result<()>
         bail!("No electron dependency found. Install Electron before packaging the app.");
     }
 
-    if has_runtime_dependencies(&report.project) {
-        bail!(
-            "Packaging production node_modules is not implemented yet. Remove runtime dependencies or wait for dependency pruning support."
-        );
-    }
-
     if report.platform != current_platform() {
         bail!(
             "Cross-platform packaging is not implemented yet. Requested {}, host is {}.",
@@ -223,6 +220,11 @@ pub(crate) fn execute_package(report: &PackageReport, force: bool) -> Result<()>
         &app_dir,
         Path::new(report.output_dir.as_str()),
     )?;
+    copy_runtime_dependencies(
+        Path::new(report.project.root.as_str()),
+        &app_dir,
+        &report.project,
+    )?;
 
     Ok(())
 }
@@ -300,6 +302,180 @@ fn copy_project_files(source: &Path, destination: &Path, output_dir: &Path) -> R
     Ok(())
 }
 
+#[derive(Debug)]
+struct DependencyRequest {
+    name: String,
+    requested_by: Option<PathBuf>,
+    optional: bool,
+}
+
+fn copy_runtime_dependencies(
+    root: &Path,
+    app_dir: &Path,
+    snapshot: &ProjectSnapshot,
+) -> Result<()> {
+    if !has_runtime_dependencies(snapshot) {
+        return Ok(());
+    }
+
+    let root_node_modules = root.join("node_modules");
+    let app_node_modules = app_dir.join("node_modules");
+    let mut queue = VecDeque::new();
+    let mut copied_paths = BTreeSet::new();
+
+    for name in snapshot.dependencies.keys() {
+        queue.push_back(DependencyRequest {
+            name: name.clone(),
+            requested_by: None,
+            optional: false,
+        });
+    }
+
+    for name in snapshot.optional_dependencies.keys() {
+        queue.push_back(DependencyRequest {
+            name: name.clone(),
+            requested_by: None,
+            optional: true,
+        });
+    }
+
+    while let Some(request) = queue.pop_front() {
+        let Some(package_dir) = resolve_dependency_dir(
+            &root_node_modules,
+            request.requested_by.as_deref(),
+            &request.name,
+        ) else {
+            if request.optional {
+                continue;
+            }
+
+            bail!(
+                "Runtime dependency '{}' is not installed. Run your package manager install first.",
+                request.name
+            );
+        };
+
+        let canonical_package_dir = package_dir
+            .canonicalize()
+            .with_context(|| format!("Could not resolve {}", package_dir.display()))?;
+        let canonical_root_node_modules = root_node_modules
+            .canonicalize()
+            .with_context(|| format!("Could not resolve {}", root_node_modules.display()))?;
+        if !copied_paths.insert(canonical_package_dir.clone()) {
+            continue;
+        }
+
+        let relative_path = canonical_package_dir
+            .strip_prefix(&canonical_root_node_modules)
+            .with_context(|| {
+                format!(
+                    "Could not make dependency {} relative to {}",
+                    canonical_package_dir.display(),
+                    canonical_root_node_modules.display()
+                )
+            })?;
+        let destination = app_node_modules.join(relative_path);
+        copy_recursively(&canonical_package_dir, &destination).with_context(|| {
+            format!(
+                "Could not copy runtime dependency {} to {}",
+                canonical_package_dir.display(),
+                destination.display()
+            )
+        })?;
+
+        let package_json = read_dependency_package_json(&canonical_package_dir)?;
+        for name in string_map(package_json.get("dependencies")).keys() {
+            queue.push_back(DependencyRequest {
+                name: name.clone(),
+                requested_by: Some(canonical_package_dir.clone()),
+                optional: false,
+            });
+        }
+        for name in string_map(package_json.get("optionalDependencies")).keys() {
+            queue.push_back(DependencyRequest {
+                name: name.clone(),
+                requested_by: Some(canonical_package_dir.clone()),
+                optional: true,
+            });
+        }
+    }
+
+    Ok(())
+}
+
+fn runtime_dependency_warnings(root: &Path, snapshot: &ProjectSnapshot) -> Vec<String> {
+    let mut warnings = Vec::new();
+    let root_node_modules = root.join("node_modules");
+
+    for name in snapshot.dependencies.keys() {
+        if resolve_dependency_dir(&root_node_modules, None, name).is_none() {
+            warnings.push(format!(
+                "Runtime dependency is not installed and packaging will fail: {name}."
+            ));
+        }
+    }
+
+    for name in snapshot.optional_dependencies.keys() {
+        if resolve_dependency_dir(&root_node_modules, None, name).is_none() {
+            warnings.push(format!(
+                "Optional runtime dependency is not installed and will be skipped: {name}."
+            ));
+        }
+    }
+
+    warnings
+}
+
+fn resolve_dependency_dir(
+    root_node_modules: &Path,
+    requested_by: Option<&Path>,
+    name: &str,
+) -> Option<PathBuf> {
+    let relative_path = dependency_relative_path(name);
+
+    if let Some(requested_by) = requested_by {
+        let nested = requested_by.join("node_modules").join(&relative_path);
+        if nested.exists() {
+            return Some(nested);
+        }
+    }
+
+    let hoisted = root_node_modules.join(relative_path);
+    hoisted.exists().then_some(hoisted)
+}
+
+fn dependency_relative_path(name: &str) -> PathBuf {
+    let mut path = PathBuf::new();
+    for part in name.split('/') {
+        if !part.is_empty() {
+            path.push(part);
+        }
+    }
+    path
+}
+
+fn read_dependency_package_json(package_dir: &Path) -> Result<Value> {
+    let package_json_path = package_dir.join("package.json");
+    let raw = fs::read_to_string(&package_json_path)
+        .with_context(|| format!("Could not read {}", package_json_path.display()))?;
+    serde_json::from_str::<Value>(&raw)
+        .with_context(|| format!("Could not parse {}", package_json_path.display()))
+}
+
+fn string_map(value: Option<&Value>) -> BTreeMap<String, String> {
+    value
+        .and_then(Value::as_object)
+        .map(|object| {
+            object
+                .iter()
+                .filter_map(|(key, value)| {
+                    value.as_str().map(|value| (key.clone(), value.to_string()))
+                })
+                .collect()
+        })
+        .unwrap_or_default()
+}
+
 fn copy_recursively(source: &Path, destination: &Path) -> Result<()> {
     if source.is_dir() {
         fs::create_dir_all(destination)
@@ -622,7 +798,55 @@ mod tests {
     }
 
     #[test]
-    fn refuses_runtime_dependencies_until_pruning_exists() {
+    fn packages_runtime_dependency_closure_from_node_modules() {
+        let root = unique_temp_dir("runtime-deps");
+        fs::write(
+            root.join("package.json"),
+            r#"{"name":"starter-app","version":"0.1.0","main":"src/main.js","dependencies":{"dep-a":"1.0.0"},"devDependencies":{"electron":"30.0.0","dev-only":"1.0.0"}}"#,
+        )
+        .expect("package.json should be written");
+        write_app_file(&root);
+        write_fake_electron_dist(&root);
+        write_dependency_package(
+            &root,
+            "dep-a",
+            r#"{"name":"dep-a","version":"1.0.0","dependencies":{"dep-b":"1.0.0"}}"#,
+        );
+        write_dependency_package(&root, "dep-b", r#"{"name":"dep-b","version":"1.0.0"}"#);
+        write_dependency_package(
+            &root,
+            "dev-only",
+            r#"{"name":"dev-only","version":"1.0.0"}"#,
+        );
+
+        let args = PackageArgs {
+            cwd: root.clone(),
+            out_dir: PathBuf::from("out"),
+            name: None,
+            platform: None,
+            arch: None,
+            force: false,
+            dry_run: false,
+            json: false,
+        };
+        let snapshot = crate::project::inspect(&root).expect("project should inspect");
+        let report = build_report(snapshot, &args).expect("report should build");
+
+        assert!(report.warnings.is_empty());
+        execute_package(&report, false).expect("package should succeed");
+
+        let app_node_modules = Path::new(report.app_resources_dir.as_str())
+            .join("app")
+            .join("node_modules");
+        assert!(app_node_modules.join("dep-a/package.json").exists());
+        assert!(app_node_modules.join("dep-b/package.json").exists());
+        assert!(!app_node_modules.join("dev-only").exists());
+
+        let _ = fs::remove_dir_all(root);
+    }
+
+    #[test]
+    fn missing_required_runtime_dependency_fails() {
         let root = unique_temp_dir("runtime-deps");
         fs::write(
             root.join("package.json"),
@@ -645,18 +869,55 @@ mod tests {
         let snapshot = crate::project::inspect(&root).expect("project should inspect");
         let report = build_report(snapshot, &args).expect("report should build");
 
-        assert!(report
-            .warnings
-            .contains(&"Packaging production node_modules is not implemented yet; this project declares runtime dependencies.".to_string()));
+        assert!(report.warnings.contains(
+            &"Runtime dependency is not installed and packaging will fail: left-pad.".to_string()
+        ));
         assert!(execute_package(&report, false).is_err());
 
         let _ = fs::remove_dir_all(root);
     }
 
+    #[test]
+    fn missing_optional_runtime_dependency_is_skipped() {
+        let root = unique_temp_dir("optional-runtime-deps");
+        fs::write(
+            root.join("package.json"),
+            r#"{"name":"starter-app","version":"0.1.0","main":"src/main.js","optionalDependencies":{"optional-native":"1.0.0"},"devDependencies":{"electron":"30.0.0"}}"#,
+        )
+        .expect("package.json should be written");
+        write_app_file(&root);
+        write_fake_electron_dist(&root);
+
+        let args = PackageArgs {
+            cwd: root.clone(),
+            out_dir: PathBuf::from("out"),
+            name: None,
+            platform: None,
+            arch: None,
+            force: false,
+            dry_run: false,
+            json: false,
+        };
+        let snapshot = crate::project::inspect(&root).expect("project should inspect");
+        let report = build_report(snapshot, &args).expect("report should build");
+
+        assert!(report.warnings.contains(
+            &"Optional runtime dependency is not installed and will be skipped: optional-native."
+                .to_string()
+        ));
+        execute_package(&report, false).expect("optional dependency should be skipped");
+
+        let _ = fs::remove_dir_all(root);
+    }
+
     #[test]
     fn cleans_scoped_package_names_for_bundle_paths() {
         assert_eq!(clean_app_name("@scope/app"), "scope-app");
         assert_eq!(sanitize_artifact_name("Starter App"), "starter-app");
+        assert_eq!(
+            dependency_relative_path("@scope/app"),
+            PathBuf::from("@scope/app")
+        );
     }
 
     fn write_package_json(root: &Path) {
@@ -673,6 +934,17 @@ mod tests {
             .expect("main file should be written");
     }
 
+    fn write_dependency_package(root: &Path, name: &str, package_json: &str) {
+        let package_dir = root
+            .join("node_modules")
+            .join(dependency_relative_path(name));
+        fs::create_dir_all(&package_dir).expect("dependency package dir should be created");
+        fs::write(package_dir.join("package.json"), package_json)
+            .expect("dependency package.json should be written");
+        fs::write(package_dir.join("index.js"), "module.exports = true;")
+            .expect("dependency index should be written");
+    }
+
     fn write_fake_electron_dist(root: &Path) {
         let dist = root.join("node_modules/electron/dist");
         if current_platform() == "darwin" {

package/src/commands/plan.rs

@@ -112,6 +112,12 @@ fn build_report(snapshot: &project::ProjectSnapshot) -> PlanReport {
         recommended_commands.insert("make".to_string(), run_script(snapshot, script));
     }
 
+    if matches!(project_type, ProjectType::Electron) && snapshot.main.is_some() {
+        recommended_commands.insert("publish".to_string(), "electron-cli publish".to_string());
+    } else if let Some(script) = first_script(snapshot, &["publish", "release"]) {
+        recommended_commands.insert("publish".to_string(), run_script(snapshot, script));
+    }
+
     recommended_commands.insert(
         "diagnostics".to_string(),
         "electron-cli doctor --json".to_string(),
@@ -142,7 +148,7 @@ fn build_report(snapshot: &project::ProjectSnapshot) -> PlanReport {
     if matches!(project_type, ProjectType::ElectronForge) {
         notes.push("Electron Forge was detected; its scripts remain the safest path for Forge-managed apps today.".to_string());
     } else if snapshot.electron_dependency.is_some() {
-        notes.push("Electron was detected without Forge; electron-cli can start and package the current-platform app directly.".to_string());
+        notes.push("Electron was detected without Forge; electron-cli can start, package, make, and publish local artifacts directly.".to_string());
     } else {
         notes.push("This does not currently look like an Electron app.".to_string());
     }
@@ -276,5 +282,12 @@ mod tests {
             report.recommended_commands.get("make").map(String::as_str),
             Some("electron-cli make")
         );
+        assert_eq!(
+            report
+                .recommended_commands
+                .get("publish")
+                .map(String::as_str),
+            Some("electron-cli publish")
+        );
     }
 }

package/src/commands/publish.rs

@@ -0,0 +1,432 @@
+use std::{
+    fs,
+    path::{Path, PathBuf},
+    time::{SystemTime, UNIX_EPOCH},
+};
+
+use anyhow::{bail, Context, Result};
+use camino::Utf8PathBuf;
+use serde::Serialize;
+
+use crate::{
+    cli::{MakeArgs, PublishArgs},
+    commands::make::{self, MakeReport},
+    output,
+};
+
+#[derive(Debug, Serialize)]
+struct PublishReport {
+    make: MakeReport,
+    publisher: String,
+    channel: String,
+    destination_dir: Utf8PathBuf,
+    destination_artifact: Utf8PathBuf,
+    manifest: Utf8PathBuf,
+    skip_make: bool,
+    dry_run: bool,
+    status: PublishStatus,
+    published_at_unix_seconds: Option<u64>,
+    warnings: Vec<String>,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "kebab-case")]
+enum PublishStatus {
+    Planned,
+    Published,
+}
+
+#[derive(Debug, Serialize)]
+struct PublishManifest {
+    schema_version: u8,
+    publisher: String,
+    channel: String,
+    app_name: String,
+    package_name: Option<String>,
+    package_version: Option<String>,
+    platform: String,
+    arch: String,
+    target: String,
+    published_at_unix_seconds: u64,
+    artifacts: Vec<PublishedArtifact>,
+}
+
+#[derive(Debug, Serialize)]
+struct PublishedArtifact {
+    file: String,
+    path: Utf8PathBuf,
+    size: u64,
+}
+
+pub fn run(args: PublishArgs) -> Result<()> {
+    let mut report = build_report(&args)?;
+
+    if args.dry_run {
+        return print_report(&report, args.json);
+    }
+
+    execute_publish(&mut report, &args)?;
+    report.status = PublishStatus::Published;
+
+    print_report(&report, args.json)
+}
+
+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 root = Path::new(make.package().project().root.as_str());
+    let publish_root = resolve_destination(root, &args.to);
+    let destination_dir = publish_root
+        .join(&args.channel)
+        .join(make.package().platform())
+        .join(make.package().arch());
+    let artifact_name = make
+        .artifact()
+        .file_name()
+        .context("Make artifact path has no file name")?;
+    let destination_artifact = destination_dir.join(artifact_name);
+    let manifest = destination_dir.join("manifest.json");
+
+    let mut warnings = make.warnings().to_vec();
+    if args.skip_make && !Path::new(make.artifact().as_str()).exists() {
+        warnings.push(format!(
+            "Make artifact does not exist: {}.",
+            make.artifact()
+        ));
+    }
+    if destination_artifact.exists() && !args.force {
+        warnings.push(format!(
+            "Publish artifact already exists: {}. Use --force to overwrite it.",
+            destination_artifact.display()
+        ));
+    }
+    if manifest.exists() && !args.force {
+        warnings.push(format!(
+            "Publish manifest already exists: {}. Use --force to overwrite it.",
+            manifest.display()
+        ));
+    }
+
+    Ok(PublishReport {
+        make,
+        publisher: args.publisher.as_str().to_string(),
+        channel: args.channel.clone(),
+        destination_dir: utf8_path(destination_dir)?,
+        destination_artifact: utf8_path(destination_artifact)?,
+        manifest: utf8_path(manifest)?,
+        skip_make: args.skip_make,
+        dry_run: args.dry_run,
+        status: PublishStatus::Planned,
+        published_at_unix_seconds: None,
+        warnings,
+    })
+}
+
+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)?;
+        report.make.mark_made()?;
+    } else if !Path::new(report.make.artifact().as_str()).exists() {
+        bail!(
+            "Make artifact does not exist: {}. Run without --skip-make or run electron-cli make first.",
+            report.make.artifact()
+        );
+    }
+
+    let destination_artifact = Path::new(report.destination_artifact.as_str());
+    let manifest = Path::new(report.manifest.as_str());
+
+    for path in [destination_artifact, manifest] {
+        if path.exists() {
+            if args.force {
+                fs::remove_file(path)
+                    .with_context(|| format!("Could not remove {}", path.display()))?;
+            } else {
+                bail!(
+                    "Publish output already exists: {}. Use --force to overwrite it.",
+                    path.display()
+                );
+            }
+        }
+    }
+
+    fs::create_dir_all(report.destination_dir.as_str())
+        .with_context(|| format!("Could not create {}", report.destination_dir))?;
+    fs::copy(report.make.artifact().as_str(), destination_artifact).with_context(|| {
+        format!(
+            "Could not publish {} to {}",
+            report.make.artifact(),
+            destination_artifact.display()
+        )
+    })?;
+
+    let published_at_unix_seconds = now_unix_seconds()?;
+    report.published_at_unix_seconds = Some(published_at_unix_seconds);
+    let manifest_json =
+        serde_json::to_string_pretty(&build_manifest(report, published_at_unix_seconds)?)?;
+    fs::write(manifest, format!("{manifest_json}\n"))
+        .with_context(|| format!("Could not write {}", manifest.display()))?;
+
+    Ok(())
+}
+
+fn build_manifest(
+    report: &PublishReport,
+    published_at_unix_seconds: u64,
+) -> Result<PublishManifest> {
+    let destination_artifact = Path::new(report.destination_artifact.as_str());
+    let artifact_size = fs::metadata(destination_artifact)
+        .with_context(|| format!("Could not stat {}", destination_artifact.display()))?
+        .len();
+    let artifact_file = destination_artifact
+        .file_name()
+        .and_then(|name| name.to_str())
+        .context("Published artifact path has no UTF-8 file name")?
+        .to_string();
+
+    Ok(PublishManifest {
+        schema_version: 1,
+        publisher: report.publisher.clone(),
+        channel: report.channel.clone(),
+        app_name: report.make.package().app_name().to_string(),
+        package_name: report.make.package().project().name.clone(),
+        package_version: report.make.package().project().version.clone(),
+        platform: report.make.package().platform().to_string(),
+        arch: report.make.package().arch().to_string(),
+        target: report.make.target().to_string(),
+        published_at_unix_seconds,
+        artifacts: vec![PublishedArtifact {
+            file: artifact_file,
+            path: report.destination_artifact.clone(),
+            size: artifact_size,
+        }],
+    })
+}
+
+fn print_report(report: &PublishReport, json: bool) -> Result<()> {
+    if json {
+        return output::json(report);
+    }
+
+    println!("electron-cli publish");
+    println!();
+    println!("Project");
+    println!("  root: {}", report.make.package().project().root);
+    match report.make.package().project().package_label() {
+        Some(label) => println!("  package: {label}"),
+        None => println!("  package: not found"),
+    }
+    println!("  app name: {}", report.make.package().app_name());
+    println!(
+        "  target: {} {} {}",
+        report.make.target(),
+        report.make.package().platform(),
+        report.make.package().arch()
+    );
+    println!("  publisher: {}", report.publisher);
+    println!("  channel: {}", report.channel);
+    println!("  status: {}", report.status.as_str());
+
+    println!();
+    println!("Publish");
+    println!("  artifact: {}", report.destination_artifact);
+    println!("  manifest: {}", report.manifest);
+
+    if !report.warnings.is_empty() {
+        println!();
+        println!("Warnings");
+        for warning in &report.warnings {
+            println!("  {warning}");
+        }
+    }
+
+    Ok(())
+}
+
+fn resolve_destination(root: &Path, destination: &Path) -> PathBuf {
+    if destination.is_absolute() {
+        destination.to_path_buf()
+    } else {
+        root.join(destination)
+    }
+}
+
+fn now_unix_seconds() -> Result<u64> {
+    Ok(SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .context("System clock is before the Unix epoch")?
+        .as_secs())
+}
+
+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 PublishStatus {
+    fn as_str(&self) -> &'static str {
+        match self {
+            PublishStatus::Planned => "planned",
+            PublishStatus::Published => "published",
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn builds_local_publish_report() {
+        let root = unique_temp_dir("plan");
+        write_package_json(&root);
+        write_app_file(&root);
+        write_fake_electron_dist(&root);
+
+        let args = publish_args(root.clone(), true);
+        let report = build_report(&args).expect("report should build");
+
+        assert_eq!(report.publisher, "local");
+        assert_eq!(report.channel, "default");
+        assert!(Path::new(report.destination_artifact.as_str()).ends_with(
+            PathBuf::from("out")
+                .join("publish")
+                .join("local")
+                .join("default")
+                .join(report.make.package().platform())
+                .join(report.make.package().arch())
+                .join(format!(
+                    "starter-app-{}-{}.zip",
+                    report.make.package().platform(),
+                    report.make.package().arch()
+                ))
+        ));
+
+        let _ = fs::remove_dir_all(root);
+    }
+
+    #[test]
+    fn publishes_make_artifact_to_local_directory() {
+        let root = unique_temp_dir("execute");
+        write_package_json(&root);
+        write_app_file(&root);
+        write_fake_electron_dist(&root);
+
+        let args = publish_args(root.clone(), false);
+        let mut report = build_report(&args).expect("report should build");
+
+        execute_publish(&mut report, &args).expect("publish should succeed");
+
+        assert!(Path::new(report.destination_artifact.as_str()).exists());
+        assert!(Path::new(report.manifest.as_str()).exists());
+        let manifest =
+            fs::read_to_string(report.manifest.as_str()).expect("manifest should be readable");
+        assert!(manifest.contains("\"publisher\": \"local\""));
+        assert!(manifest.contains("\"app_name\": \"starter-app\""));
+
+        let _ = fs::remove_dir_all(root);
+    }
+
+    #[test]
+    fn skip_make_requires_existing_artifact() {
+        let root = unique_temp_dir("skip-make");
+        write_package_json(&root);
+        write_app_file(&root);
+        write_fake_electron_dist(&root);
+
+        let mut args = publish_args(root.clone(), false);
+        args.skip_make = true;
+        let mut report = build_report(&args).expect("report should build");
+
+        assert!(execute_publish(&mut report, &args).is_err());
+
+        let _ = fs::remove_dir_all(root);
+    }
+
+    fn publish_args(root: PathBuf, dry_run: bool) -> PublishArgs {
+        PublishArgs {
+            cwd: root,
+            out_dir: PathBuf::from("out"),
+            name: None,
+            platform: None,
+            arch: None,
+            target: crate::cli::MakeTarget::Zip,
+            publisher: crate::cli::PublishTarget::Local,
+            to: PathBuf::from("out/publish/local"),
+            channel: "default".to_string(),
+            skip_make: false,
+            force: false,
+            dry_run,
+            json: true,
+        }
+    }
+
+    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-publish-{label}-{}-{nanos}",
+            std::process::id()
+        ));
+        fs::create_dir_all(&path).expect("temp dir should be created");
+        path
+    }
+}

package/src/main.rs

@@ -24,6 +24,7 @@ fn run() -> Result<()> {
         Commands::Make(args) => commands::make::run(args),
         Commands::Package(args) => commands::package::run(args),
         Commands::Plan(args) => commands::plan::run(args),
+        Commands::Publish(args) => commands::publish::run(args),
         Commands::Start(args) => commands::start::run(args),
     }
 }