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

package/Cargo.lock

@@ -64,6 +64,12 @@ version = "1.0.102"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
 
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
 [[package]]
 name = "camino"
 version = "1.2.2"
@@ -134,13 +140,23 @@ dependencies = [
  "cfg-if",
 ]
 
+[[package]]
+name = "deranged"
+version = "0.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"
+dependencies = [
+ "powerfmt",
+]
+
 [[package]]
 name = "electron-cli"
-version = "0.3.0-alpha.6"
+version = "0.3.0-alpha.7"
 dependencies = [
  "anyhow",
  "camino",
  "clap",
+ "plist",
  "serde",
  "serde_json",
  "zip",
@@ -212,12 +228,37 @@ dependencies = [
  "simd-adler32",
 ]
 
+[[package]]
+name = "num-conv"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "521739c6d2bac4aa25192232afe6841231376b2b26d4d9fae5ecf8ca5772e441"
+
 [[package]]
 name = "once_cell_polyfill"
 version = "1.70.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
 
+[[package]]
+name = "plist"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "092791278e026273c1b65bbdcfbba3a300f2994c896bd01ab01da613c29c46f1"
+dependencies = [
+ "base64",
+ "indexmap",
+ "quick-xml",
+ "serde",
+ "time",
+]
+
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
 [[package]]
 name = "proc-macro2"
 version = "1.0.106"
@@ -227,6 +268,15 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "quick-xml"
+version = "0.39.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdcc8dd4e2f670d309a5f0e83fe36dfdc05af317008fea29144da1a2ac858e5e"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "quote"
 version = "1.0.45"
@@ -302,6 +352,37 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "time"
+version = "0.3.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "743bd48c283afc0388f9b8827b976905fb217ad9e647fae3a379a9283c4def2c"
+dependencies = [
+ "deranged",
+ "itoa",
+ "num-conv",
+ "powerfmt",
+ "serde_core",
+ "time-core",
+ "time-macros",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7694e1cfe791f8d31026952abf09c69ca6f6fa4e1a1229e18988f06a04a12dca"
+
+[[package]]
+name = "time-macros"
+version = "0.2.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e70e4c5a0e0a8a4823ad65dfe1a6930e4f4d756dcd9dd7939022b5e8c501215"
+dependencies = [
+ "num-conv",
+ "time-core",
+]
+
 [[package]]
 name = "typed-path"
 version = "0.12.3"

package/Cargo.toml

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

package/README.md

@@ -41,11 +41,29 @@ 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, app files, and installed production dependency closure into a local app bundle for the current platform and architecture.
+- `package`: copies the installed Electron runtime, app files, installed production dependency closure, app metadata, macOS icon, and extra resources 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.
 
-Remote publishers such as GitHub Releases are not implemented yet. Platform-specific makers, app metadata, signing, and notarization are also still TODO.
+Remote publishers such as GitHub Releases are not implemented yet. Platform-specific makers, Windows/Linux icon embedding, signing, and notarization are also still TODO.
+
+Package metadata can be configured in `package.json`:
+
+```json
+{
+  "productName": "My App",
+  "electronCli": {
+    "packagerConfig": {
+      "appBundleId": "com.example.my-app",
+      "appCategoryType": "public.app-category.developer-tools",
+      "icon": "assets/icon",
+      "extraResource": "assets/config.json"
+    }
+  }
+}
+```
+
+The package command also reads JSON-shaped `config.forge.packagerConfig` and `electronPackagerConfig` entries for the same fields. JavaScript Forge config files are not evaluated.
 
 ## Install
 
@@ -103,7 +121,7 @@ The inspection and planning commands support `--json` so agents and scripts can
 `plan` is designed around that workflow: it recommends stable commands and reports missing project conventions as structured data.
 `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.
+`package --dry-run --json` shows the runtime, app file, metadata, icon, and extra-resource 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.
 

package/package.json

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

package/src/commands/init.rs

@@ -447,8 +447,11 @@ fn write_template_file(target: &Path, relative_path: &str, contents: &str) -> Re
 }
 
 fn package_json(package_name: &str, electron_version: &str) -> Result<String> {
+    let product_name = product_name(package_name);
+    let app_bundle_id = format!("com.electron.{package_name}");
     let package = serde_json::json!({
         "name": package_name,
+        "productName": product_name,
         "version": "0.1.0",
         "private": true,
         "description": "Minimal Electron app generated by electron-cli",
@@ -459,6 +462,11 @@ fn package_json(package_name: &str, electron_version: &str) -> Result<String> {
         },
         "devDependencies": {
             "electron": electron_version
+        },
+        "electronCli": {
+            "packagerConfig": {
+                "appBundleId": app_bundle_id
+            }
         }
     });
 
@@ -639,6 +647,25 @@ fn sanitize_package_name(raw_name: &str) -> String {
     }
 }
 
+fn product_name(package_name: &str) -> String {
+    package_name
+        .split(['-', '_', '.'])
+        .filter(|part| !part.is_empty())
+        .map(|part| {
+            let mut chars = part.chars();
+            match chars.next() {
+                Some(first) => {
+                    let mut word = first.to_uppercase().collect::<String>();
+                    word.push_str(chars.as_str());
+                    word
+                }
+                None => String::new(),
+            }
+        })
+        .collect::<Vec<_>>()
+        .join(" ")
+}
+
 fn utf8_path(path: PathBuf) -> Result<Utf8PathBuf> {
     Utf8PathBuf::from_path_buf(path).map_err(|path| {
         anyhow::anyhow!(
@@ -756,7 +783,9 @@ mod tests {
         assert!(target.join("src/renderer.js").exists());
         assert!(target.join(".github/workflows/ci.yml").exists());
         assert!(package_json.contains("\"name\": \"native-app\""));
+        assert!(package_json.contains("\"productName\": \"Native App\""));
         assert!(package_json.contains("\"electron\": \"30.0.0\""));
+        assert!(package_json.contains("\"appBundleId\": \"com.electron.native-app\""));
         assert!(config.contains("\"generator\": \"electron-cli\""));
 
         let _ = fs::remove_dir_all(cwd);
@@ -767,6 +796,7 @@ mod tests {
         assert_eq!(sanitize_package_name("Native App"), "native-app");
         assert_eq!(sanitize_package_name("..."), "electron-app");
         assert_eq!(sanitize_package_name("@Scope/App"), "scope-app");
+        assert_eq!(product_name("native-app"), "Native App");
     }
 
     fn unique_temp_dir() -> PathBuf {

package/src/commands/package.rs

@@ -6,8 +6,9 @@ use std::{
 
 use anyhow::{bail, Context, Result};
 use camino::Utf8PathBuf;
+use plist::{Dictionary as PlistDictionary, Value as PlistValue};
 use serde::Serialize;
-use serde_json::Value;
+use serde_json::Value as JsonValue;
 
 use crate::{cli::PackageArgs, output, project::ProjectSnapshot};
 
@@ -16,6 +17,7 @@ pub(crate) struct PackageReport {
     project: ProjectSnapshot,
     app_name: String,
     executable_name: String,
+    metadata: PackageMetadata,
     platform: String,
     arch: String,
     electron_dist: Utf8PathBuf,
@@ -35,6 +37,24 @@ struct CopyStep {
     to: Utf8PathBuf,
 }
 
+#[derive(Debug, Serialize)]
+struct PackageMetadata {
+    bundle_identifier: String,
+    app_version: Option<String>,
+    build_version: Option<String>,
+    app_category_type: Option<String>,
+    app_copyright: Option<String>,
+    icon: Option<IconResource>,
+    extra_resources: Vec<CopyStep>,
+    darwin_dark_mode_support: bool,
+}
+
+#[derive(Debug, Serialize)]
+struct IconResource {
+    from: Utf8PathBuf,
+    to: Utf8PathBuf,
+}
+
 #[derive(Debug, Serialize)]
 #[serde(rename_all = "kebab-case")]
 enum PackageStatus {
@@ -42,6 +62,27 @@ enum PackageStatus {
     Packaged,
 }
 
+#[derive(Debug, Default)]
+struct PackageJsonConfig {
+    product_name: Option<String>,
+    app_version: Option<String>,
+    packager: PackagerConfig,
+}
+
+#[derive(Debug, Default)]
+struct PackagerConfig {
+    name: Option<String>,
+    executable_name: Option<String>,
+    app_bundle_id: Option<String>,
+    app_category_type: Option<String>,
+    app_version: Option<String>,
+    build_version: Option<String>,
+    app_copyright: Option<String>,
+    icon: Vec<String>,
+    extra_resource: Vec<String>,
+    darwin_dark_mode_support: bool,
+}
+
 pub fn run(args: PackageArgs) -> Result<()> {
     let snapshot = crate::project::inspect(&args.cwd)?;
     let mut report = build_report(snapshot, &args)?;
@@ -58,16 +99,25 @@ pub fn run(args: PackageArgs) -> Result<()> {
 
 pub(crate) fn build_report(snapshot: ProjectSnapshot, args: &PackageArgs) -> Result<PackageReport> {
     let root = Path::new(snapshot.root.as_str());
+    let package_config = read_package_json_config(&snapshot)?;
     let platform = args.platform.clone().unwrap_or_else(current_platform);
     let arch = args.arch.clone().unwrap_or_else(current_arch);
     let app_name = clean_app_name(
         &args
             .name
             .clone()
+            .or_else(|| package_config.packager.name.clone())
+            .or_else(|| package_config.product_name.clone())
             .or_else(|| snapshot.name.clone())
             .unwrap_or_else(|| "electron-app".to_string()),
     );
-    let executable_name = executable_name(&app_name, &platform);
+    let executable_base = package_config
+        .packager
+        .executable_name
+        .clone()
+        .map(|name| clean_app_name(&name))
+        .unwrap_or_else(|| app_name.clone());
+    let executable_name = executable_name(&executable_base, &platform);
     let artifact_name = sanitize_artifact_name(&app_name);
     let output_dir = resolve_output_dir(root, &args.out_dir);
     let package_root = output_dir.join(format!("{artifact_name}-{platform}-{arch}"));
@@ -75,6 +125,13 @@ pub(crate) fn build_report(snapshot: ProjectSnapshot, args: &PackageArgs) -> Res
     let app_resources_dir = app_resources_dir(&bundle_dir, &platform);
     let electron_dist = root.join("node_modules/electron/dist");
     let electron_source = electron_source(&electron_dist, &platform);
+    let (metadata, metadata_warnings) = package_metadata(
+        root,
+        &package_config,
+        &artifact_name,
+        &app_resources_dir,
+        &platform,
+    )?;
 
     let mut warnings = Vec::new();
     if snapshot.package_json.is_none() {
@@ -111,6 +168,7 @@ pub(crate) fn build_report(snapshot: ProjectSnapshot, args: &PackageArgs) -> Res
     }
 
     warnings.extend(runtime_dependency_warnings(root, &snapshot));
+    warnings.extend(metadata_warnings);
 
     let create_dirs = vec![package_root.clone(), app_resources_dir.clone()];
     let mut copy_steps = vec![
@@ -123,11 +181,24 @@ pub(crate) fn build_report(snapshot: ProjectSnapshot, args: &PackageArgs) -> Res
             app_resources_dir.join("app/node_modules"),
         ));
     }
+    if let Some(icon) = &metadata.icon {
+        copy_steps.push((
+            Path::new(icon.from.as_str()).to_path_buf(),
+            Path::new(icon.to.as_str()).to_path_buf(),
+        ));
+    }
+    for resource in &metadata.extra_resources {
+        copy_steps.push((
+            Path::new(resource.from.as_str()).to_path_buf(),
+            Path::new(resource.to.as_str()).to_path_buf(),
+        ));
+    }
 
     Ok(PackageReport {
         project: snapshot,
         app_name,
         executable_name,
+        metadata,
         platform,
         arch,
         electron_dist: utf8_path(electron_dist)?,
@@ -212,6 +283,8 @@ pub(crate) fn execute_package(report: &PackageReport, force: bool) -> Result<()>
         )
     })?;
     rename_runtime_executable(bundle_dir, &report.executable_name, &report.platform)?;
+    apply_package_metadata(report)?;
+    copy_package_resources(report)?;
 
     fs::create_dir_all(&app_dir)
         .with_context(|| format!("Could not create {}", app_dir.display()))?;
@@ -244,6 +317,10 @@ fn print_report(report: &PackageReport, json: bool) -> Result<()> {
     }
     println!("  app name: {}", report.app_name);
     println!("  executable: {}", report.executable_name);
+    println!("  bundle id: {}", report.metadata.bundle_identifier);
+    if let Some(version) = &report.metadata.app_version {
+        println!("  app version: {version}");
+    }
     println!("  target: {} {}", report.platform, report.arch);
     println!("  status: {}", report.status.as_str());
 
@@ -268,6 +345,290 @@ fn print_report(report: &PackageReport, json: bool) -> Result<()> {
     Ok(())
 }
 
+fn read_package_json_config(snapshot: &ProjectSnapshot) -> Result<PackageJsonConfig> {
+    let Some(package_json_path) = &snapshot.package_json else {
+        return Ok(PackageJsonConfig::default());
+    };
+
+    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 packager = PackagerConfig::default();
+    if let Some(config) = package
+        .get("config")
+        .and_then(|config| config.get("forge"))
+        .and_then(|forge| forge.get("packagerConfig"))
+    {
+        packager.merge(parse_packager_config(config));
+    }
+    if let Some(config) = package.get("electronPackagerConfig") {
+        packager.merge(parse_packager_config(config));
+    }
+    if let Some(config) = package
+        .get("electronCli")
+        .or_else(|| package.get("electron-cli"))
+        .and_then(|config| config.get("packagerConfig"))
+    {
+        packager.merge(parse_packager_config(config));
+    }
+
+    Ok(PackageJsonConfig {
+        product_name: package
+            .get("productName")
+            .and_then(JsonValue::as_str)
+            .map(ToOwned::to_owned),
+        app_version: package
+            .get("version")
+            .and_then(JsonValue::as_str)
+            .map(ToOwned::to_owned),
+        packager,
+    })
+}
+
+fn parse_packager_config(value: &JsonValue) -> PackagerConfig {
+    PackagerConfig {
+        name: string_value(value, "name"),
+        executable_name: string_value(value, "executableName"),
+        app_bundle_id: string_value(value, "appBundleId"),
+        app_category_type: string_value(value, "appCategoryType"),
+        app_version: string_value(value, "appVersion"),
+        build_version: string_value(value, "buildVersion"),
+        app_copyright: string_value(value, "appCopyright"),
+        icon: string_list(value.get("icon")),
+        extra_resource: string_list(value.get("extraResource")),
+        darwin_dark_mode_support: value
+            .get("darwinDarkModeSupport")
+            .and_then(JsonValue::as_bool)
+            .unwrap_or(false),
+    }
+}
+
+fn string_value(value: &JsonValue, key: &str) -> Option<String> {
+    value
+        .get(key)
+        .and_then(JsonValue::as_str)
+        .map(ToOwned::to_owned)
+}
+
+fn string_list(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 package_metadata(
+    root: &Path,
+    config: &PackageJsonConfig,
+    artifact_name: &str,
+    app_resources_dir: &Path,
+    platform: &str,
+) -> Result<(PackageMetadata, Vec<String>)> {
+    let mut warnings = Vec::new();
+    let icon = resolve_icon_resource(
+        root,
+        &config.packager.icon,
+        artifact_name,
+        app_resources_dir,
+        platform,
+        &mut warnings,
+    )?;
+    let extra_resources = resolve_extra_resources(
+        root,
+        &config.packager.extra_resource,
+        app_resources_dir,
+        &mut warnings,
+    )?;
+    let app_version = config
+        .packager
+        .app_version
+        .clone()
+        .or_else(|| config.app_version.clone());
+
+    Ok((
+        PackageMetadata {
+            bundle_identifier: config
+                .packager
+                .app_bundle_id
+                .clone()
+                .unwrap_or_else(|| default_bundle_identifier(artifact_name)),
+            app_version: app_version.clone(),
+            build_version: config
+                .packager
+                .build_version
+                .clone()
+                .or_else(|| app_version.clone()),
+            app_category_type: config.packager.app_category_type.clone(),
+            app_copyright: config.packager.app_copyright.clone(),
+            icon,
+            extra_resources,
+            darwin_dark_mode_support: config.packager.darwin_dark_mode_support,
+        },
+        warnings,
+    ))
+}
+
+fn resolve_icon_resource(
+    root: &Path,
+    configured_icons: &[String],
+    artifact_name: &str,
+    app_resources_dir: &Path,
+    platform: &str,
+    warnings: &mut Vec<String>,
+) -> Result<Option<IconResource>> {
+    let candidates = configured_icons
+        .iter()
+        .filter_map(|icon| icon_candidate(root, icon, platform))
+        .collect::<Vec<_>>();
+    let source = if platform == "darwin" {
+        candidates
+            .iter()
+            .find(|candidate| candidate.exists() && path_extension(candidate) == Some("icns"))
+            .cloned()
+            .or_else(|| {
+                candidates
+                    .iter()
+                    .find(|candidate| candidate.exists())
+                    .cloned()
+            })
+    } else {
+        candidates
+            .iter()
+            .find(|candidate| candidate.exists())
+            .cloned()
+    };
+    let Some(source) = source else {
+        if let Some(first) = configured_icons.first() {
+            let expected = icon_candidate(root, first, platform)
+                .unwrap_or_else(|| resolve_project_path(root, first));
+            warnings.push(format!(
+                "Configured icon was not found for {platform}: {}.",
+                expected.display()
+            ));
+        }
+        return Ok(None);
+    };
+
+    if platform == "darwin" && path_extension(&source) == Some("icon") {
+        warnings.push(
+            "macOS .icon files are not applied yet; provide an .icns icon for now.".to_string(),
+        );
+        return Ok(None);
+    }
+
+    if platform == "win32" {
+        warnings.push("Windows executable icon embedding is not implemented yet.".to_string());
+        return Ok(None);
+    }
+
+    if platform == "linux" {
+        warnings.push(
+            "Linux executable icons are not embedded; set the BrowserWindow icon in app code."
+                .to_string(),
+        );
+        return Ok(None);
+    }
+
+    let extension = path_extension(&source).unwrap_or("icns");
+    let destination = app_resources_dir.join(format!("{artifact_name}.{extension}"));
+
+    Ok(Some(IconResource {
+        from: utf8_path(source)?,
+        to: utf8_path(destination)?,
+    }))
+}
+
+fn path_extension(path: &Path) -> Option<&str> {
+    path.extension().and_then(|extension| extension.to_str())
+}
+
+fn icon_candidate(root: &Path, configured_icon: &str, platform: &str) -> Option<PathBuf> {
+    if configured_icon.trim().is_empty() {
+        return None;
+    }
+
+    let path = resolve_project_path(root, configured_icon);
+    if path.extension().is_some() {
+        return Some(path);
+    }
+
+    let extension = match platform {
+        "darwin" => "icns",
+        "win32" => "ico",
+        "linux" => "png",
+        _ => return Some(path),
+    };
+    Some(path.with_extension(extension))
+}
+
+fn resolve_extra_resources(
+    root: &Path,
+    extra_resources: &[String],
+    app_resources_dir: &Path,
+    warnings: &mut Vec<String>,
+) -> Result<Vec<CopyStep>> {
+    extra_resources
+        .iter()
+        .filter(|resource| !resource.trim().is_empty())
+        .map(|resource| {
+            let source = resolve_project_path(root, resource);
+            if !source.exists() {
+                warnings.push(format!(
+                    "Configured extra resource does not exist and packaging will fail: {}.",
+                    source.display()
+                ));
+            }
+
+            let file_name = source
+                .file_name()
+                .with_context(|| format!("Extra resource has no file name: {}", source.display()))?
+                .to_owned();
+            Ok(CopyStep {
+                from: utf8_path(source)?,
+                to: utf8_path(app_resources_dir.join(file_name))?,
+            })
+        })
+        .collect()
+}
+
+fn resolve_project_path(root: &Path, path: &str) -> PathBuf {
+    let path = Path::new(path);
+    if path.is_absolute() {
+        path.to_path_buf()
+    } else {
+        root.join(path)
+    }
+}
+
+fn default_bundle_identifier(artifact_name: &str) -> String {
+    let component = artifact_name
+        .chars()
+        .map(|char| {
+            if char.is_ascii_alphanumeric() || char == '-' {
+                char
+            } else {
+                '.'
+            }
+        })
+        .collect::<String>()
+        .trim_matches(['.', '-'])
+        .to_string();
+    let component = if component.is_empty() {
+        "electron-app".to_string()
+    } else {
+        component
+    };
+    format!("com.electron.{component}")
+}
+
 fn copy_project_files(source: &Path, destination: &Path, output_dir: &Path) -> Result<()> {
     for entry in
         fs::read_dir(source).with_context(|| format!("Could not read {}", source.display()))?
@@ -403,6 +764,99 @@ fn copy_runtime_dependencies(
     Ok(())
 }
 
+fn apply_package_metadata(report: &PackageReport) -> Result<()> {
+    if report.platform == "darwin" {
+        apply_macos_metadata(report)?;
+    }
+
+    Ok(())
+}
+
+fn apply_macos_metadata(report: &PackageReport) -> Result<()> {
+    let bundle_dir = Path::new(report.bundle_dir.as_str());
+    let info_plist_path = bundle_dir.join("Contents/Info.plist");
+    let mut dictionary = if info_plist_path.exists() {
+        match PlistValue::from_file(&info_plist_path)
+            .with_context(|| format!("Could not read {}", info_plist_path.display()))?
+        {
+            PlistValue::Dictionary(dictionary) => dictionary,
+            _ => bail!("{} is not a plist dictionary", info_plist_path.display()),
+        }
+    } else {
+        PlistDictionary::new()
+    };
+
+    set_plist_string(&mut dictionary, "CFBundleName", &report.app_name);
+    set_plist_string(&mut dictionary, "CFBundleDisplayName", &report.app_name);
+    set_plist_string(
+        &mut dictionary,
+        "CFBundleExecutable",
+        &report.executable_name,
+    );
+    set_plist_string(
+        &mut dictionary,
+        "CFBundleIdentifier",
+        &report.metadata.bundle_identifier,
+    );
+
+    if let Some(version) = &report.metadata.app_version {
+        set_plist_string(&mut dictionary, "CFBundleShortVersionString", version);
+    }
+    if let Some(version) = &report.metadata.build_version {
+        set_plist_string(&mut dictionary, "CFBundleVersion", version);
+    }
+    if let Some(category) = &report.metadata.app_category_type {
+        set_plist_string(&mut dictionary, "LSApplicationCategoryType", category);
+    }
+    if let Some(copyright) = &report.metadata.app_copyright {
+        set_plist_string(&mut dictionary, "NSHumanReadableCopyright", copyright);
+    }
+    if let Some(icon) = &report.metadata.icon {
+        let icon_name = Path::new(icon.to.as_str())
+            .file_name()
+            .and_then(|file_name| file_name.to_str())
+            .context("Icon destination has no file name")?;
+        set_plist_string(&mut dictionary, "CFBundleIconFile", icon_name);
+    }
+    if report.metadata.darwin_dark_mode_support {
+        dictionary.insert(
+            "NSRequiresAquaSystemAppearance".to_string(),
+            PlistValue::Boolean(false),
+        );
+    }
+
+    if let Some(parent) = info_plist_path.parent() {
+        fs::create_dir_all(parent)
+            .with_context(|| format!("Could not create {}", parent.display()))?;
+    }
+    PlistValue::Dictionary(dictionary)
+        .to_file_xml(&info_plist_path)
+        .with_context(|| format!("Could not write {}", info_plist_path.display()))?;
+
+    Ok(())
+}
+
+fn set_plist_string(dictionary: &mut PlistDictionary, key: &str, value: &str) {
+    dictionary.insert(key.to_string(), PlistValue::String(value.to_string()));
+}
+
+fn copy_package_resources(report: &PackageReport) -> Result<()> {
+    if let Some(icon) = &report.metadata.icon {
+        copy_recursively(Path::new(icon.from.as_str()), Path::new(icon.to.as_str()))
+            .with_context(|| format!("Could not copy icon to {}", icon.to))?;
+    }
+
+    for resource in &report.metadata.extra_resources {
+        copy_recursively(
+            Path::new(resource.from.as_str()),
+            Path::new(resource.to.as_str()),
+        )
+        .with_context(|| format!("Could not copy extra resource to {}", resource.to))?;
+    }
+
+    Ok(())
+}
+
 fn runtime_dependency_warnings(root: &Path, snapshot: &ProjectSnapshot) -> Vec<String> {
     let mut warnings = Vec::new();
     let root_node_modules = root.join("node_modules");
@@ -454,17 +908,17 @@ fn dependency_relative_path(name: &str) -> PathBuf {
     path
 }
 
-fn read_dependency_package_json(package_dir: &Path) -> Result<Value> {
+fn read_dependency_package_json(package_dir: &Path) -> Result<JsonValue> {
     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)
+    serde_json::from_str::<JsonValue>(&raw)
         .with_context(|| format!("Could not parse {}", package_json_path.display()))
 }
 
-fn string_map(value: Option<&Value>) -> BTreeMap<String, String> {
+fn string_map(value: Option<&JsonValue>) -> BTreeMap<String, String> {
     value
-        .and_then(Value::as_object)
+        .and_then(JsonValue::as_object)
         .map(|object| {
             object
                 .iter()
@@ -526,16 +980,18 @@ fn rename_runtime_executable(
     executable_name: &str,
     platform: &str,
 ) -> Result<()> {
-    if platform == "darwin" {
-        return Ok(());
-    }
-
-    let current = if platform == "win32" {
+    let current = if platform == "darwin" {
+        bundle_dir.join("Contents/MacOS/Electron")
+    } else if platform == "win32" {
         bundle_dir.join("electron.exe")
     } else {
         bundle_dir.join("electron")
     };
-    let target = bundle_dir.join(executable_name);
+    let target = if platform == "darwin" {
+        bundle_dir.join("Contents/MacOS").join(executable_name)
+    } else {
+        bundle_dir.join(executable_name)
+    };
 
     if current.exists() && current != target {
         fs::rename(&current, &target).with_context(|| {
@@ -684,6 +1140,30 @@ impl PackageStatus {
     }
 }
 
+impl PackagerConfig {
+    fn merge(&mut self, other: PackagerConfig) {
+        self.name = other.name.or_else(|| self.name.take());
+        self.executable_name = other
+            .executable_name
+            .or_else(|| self.executable_name.take());
+        self.app_bundle_id = other.app_bundle_id.or_else(|| self.app_bundle_id.take());
+        self.app_category_type = other
+            .app_category_type
+            .or_else(|| self.app_category_type.take());
+        self.app_version = other.app_version.or_else(|| self.app_version.take());
+        self.build_version = other.build_version.or_else(|| self.build_version.take());
+        self.app_copyright = other.app_copyright.or_else(|| self.app_copyright.take());
+        if !other.icon.is_empty() {
+            self.icon = other.icon;
+        }
+        if !other.extra_resource.is_empty() {
+            self.extra_resource = other.extra_resource;
+        }
+        self.darwin_dark_mode_support =
+            other.darwin_dark_mode_support || self.darwin_dark_mode_support;
+    }
+}
+
 impl PackageReport {
     pub(crate) fn project(&self) -> &ProjectSnapshot {
         &self.project
@@ -845,6 +1325,135 @@ mod tests {
         let _ = fs::remove_dir_all(root);
     }
 
+    #[test]
+    fn plans_packager_metadata_from_package_json() {
+        let root = unique_temp_dir("metadata-plan");
+        write_metadata_package_json(&root);
+        write_app_file(&root);
+        write_fake_electron_dist(&root);
+        write_icon_and_resource_files(&root);
+
+        let args = PackageArgs {
+            cwd: root.clone(),
+            out_dir: PathBuf::from("out"),
+            name: None,
+            platform: None,
+            arch: None,
+            force: false,
+            dry_run: true,
+            json: true,
+        };
+        let snapshot = crate::project::inspect(&root).expect("project should inspect");
+        let report = build_report(snapshot, &args).expect("report should build");
+
+        assert_eq!(report.app_name, "Starter Pro");
+        assert_eq!(
+            report.executable_name,
+            executable_name("StarterExec", &report.platform)
+        );
+        assert_eq!(report.metadata.bundle_identifier, "com.example.starter");
+        assert_eq!(report.metadata.app_version.as_deref(), Some("2.3.4"));
+        assert_eq!(report.metadata.build_version.as_deref(), Some("234"));
+        assert_eq!(
+            report.metadata.app_category_type.as_deref(),
+            Some("public.app-category.developer-tools")
+        );
+        assert_eq!(
+            report.metadata.app_copyright.as_deref(),
+            Some("Copyright 2026 Example")
+        );
+        assert_eq!(report.metadata.extra_resources.len(), 1);
+        assert!(report
+            .copy_steps
+            .iter()
+            .any(|step| step.to.as_str().ends_with("config.json")));
+
+        if current_platform() == "darwin" {
+            assert!(report.metadata.icon.is_some());
+            assert!(report.warnings.is_empty());
+        }
+
+        let _ = fs::remove_dir_all(root);
+    }
+
+    #[test]
+    fn packages_macos_info_plist_metadata() {
+        if current_platform() != "darwin" {
+            return;
+        }
+
+        let root = unique_temp_dir("metadata-execute");
+        write_metadata_package_json(&root);
+        write_app_file(&root);
+        write_fake_electron_dist(&root);
+        write_icon_and_resource_files(&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");
+
+        execute_package(&report, false).expect("package should succeed");
+
+        let bundle_dir = Path::new(report.bundle_dir.as_str());
+        assert!(bundle_dir
+            .join("Contents/MacOS")
+            .join(&report.executable_name)
+            .exists());
+        assert!(bundle_dir
+            .join("Contents/Resources/starter-pro.icns")
+            .exists());
+        assert!(bundle_dir.join("Contents/Resources/config.json").exists());
+
+        let plist = PlistValue::from_file(bundle_dir.join("Contents/Info.plist"))
+            .expect("Info.plist should parse");
+        let dictionary = plist
+            .as_dictionary()
+            .expect("Info.plist should be a dictionary");
+
+        assert_eq!(
+            plist_string(dictionary, "CFBundleDisplayName"),
+            Some("Starter Pro")
+        );
+        assert_eq!(
+            plist_string(dictionary, "CFBundleExecutable"),
+            Some(report.executable_name.as_str())
+        );
+        assert_eq!(
+            plist_string(dictionary, "CFBundleIdentifier"),
+            Some("com.example.starter")
+        );
+        assert_eq!(
+            plist_string(dictionary, "CFBundleShortVersionString"),
+            Some("2.3.4")
+        );
+        assert_eq!(plist_string(dictionary, "CFBundleVersion"), Some("234"));
+        assert_eq!(
+            plist_string(dictionary, "LSApplicationCategoryType"),
+            Some("public.app-category.developer-tools")
+        );
+        assert_eq!(
+            plist_string(dictionary, "CFBundleIconFile"),
+            Some("starter-pro.icns")
+        );
+        assert_eq!(
+            dictionary
+                .get("NSRequiresAquaSystemAppearance")
+                .and_then(PlistValue::as_boolean),
+            Some(false)
+        );
+
+        let _ = fs::remove_dir_all(root);
+    }
+
     #[test]
     fn missing_required_runtime_dependency_fails() {
         let root = unique_temp_dir("runtime-deps");
@@ -928,6 +1537,34 @@ mod tests {
         .expect("package.json should be written");
     }
 
+    fn write_metadata_package_json(root: &Path) {
+        fs::write(
+            root.join("package.json"),
+            r#"{
+                "name": "starter-app",
+                "productName": "Starter Pro",
+                "version": "2.3.4",
+                "main": "src/main.js",
+                "devDependencies": {
+                    "electron": "30.0.0"
+                },
+                "electronCli": {
+                    "packagerConfig": {
+                        "executableName": "StarterExec",
+                        "appBundleId": "com.example.starter",
+                        "appCategoryType": "public.app-category.developer-tools",
+                        "buildVersion": "234",
+                        "appCopyright": "Copyright 2026 Example",
+                        "icon": "assets/starter",
+                        "extraResource": "assets/config.json",
+                        "darwinDarkModeSupport": true
+                    }
+                }
+            }"#,
+        )
+        .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');")
@@ -945,6 +1582,16 @@ mod tests {
             .expect("dependency index should be written");
     }
 
+    fn write_icon_and_resource_files(root: &Path) {
+        fs::create_dir_all(root.join("assets")).expect("assets should be created");
+        fs::write(root.join("assets/starter.icns"), b"icns").expect("icon should be written");
+        fs::write(root.join("assets/config.json"), "{}").expect("resource should be written");
+    }
+
+    fn plist_string<'a>(dictionary: &'a PlistDictionary, key: &str) -> Option<&'a str> {
+        dictionary.get(key).and_then(PlistValue::as_string)
+    }
+
     fn write_fake_electron_dist(root: &Path) {
         let dist = root.join("node_modules/electron/dist");
         if current_platform() == "darwin" {