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

package/src/commands/package.rs

@@ -1,11 +1,14 @@
 use std::{
+    collections::{BTreeMap, BTreeSet, VecDeque},
     fs,
     path::{Path, PathBuf},
 };
 
 use anyhow::{bail, Context, Result};
 use camino::Utf8PathBuf;
+use plist::{Dictionary as PlistDictionary, Value as PlistValue};
 use serde::Serialize;
+use serde_json::Value as JsonValue;
 
 use crate::{cli::PackageArgs, output, project::ProjectSnapshot};
 
@@ -14,6 +17,7 @@ pub(crate) struct PackageReport {
     project: ProjectSnapshot,
     app_name: String,
     executable_name: String,
+    metadata: PackageMetadata,
     platform: String,
     arch: String,
     electron_dist: Utf8PathBuf,
@@ -33,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 {
@@ -40,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)?;
@@ -56,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}"));
@@ -73,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() {
@@ -87,13 +146,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,16 +167,38 @@ 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 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"),
+        ));
+    }
+    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)?,
@@ -159,12 +233,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 {}.",
@@ -215,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()))?;
@@ -223,6 +293,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(())
 }
@@ -242,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());
 
@@ -266,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()))?
@@ -300,6 +663,273 @@ 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 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");
+
+    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<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::<JsonValue>(&raw)
+        .with_context(|| format!("Could not parse {}", package_json_path.display()))
+}
+
+fn string_map(value: Option<&JsonValue>) -> BTreeMap<String, String> {
+    value
+        .and_then(JsonValue::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)
@@ -350,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(|| {
@@ -508,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
@@ -622,15 +1278,26 @@ 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":{"left-pad":"1.3.0"},"devDependencies":{"electron":"30.0.0"}}"#,
+            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(),
@@ -645,18 +1312,221 @@ 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.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 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
-            .warnings
-            .contains(&"Packaging production node_modules is not implemented yet; this project declares runtime dependencies.".to_string()));
+            .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");
+        fs::write(
+            root.join("package.json"),
+            r#"{"name":"starter-app","version":"0.1.0","main":"src/main.js","dependencies":{"left-pad":"1.3.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(
+            &"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) {
@@ -667,12 +1537,61 @@ 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');")
             .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_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" {