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

package/Cargo.lock

@@ -376,7 +376,7 @@ checksum = "91622ff5e7162018101f2fea40d6ebf4a78bbe5a49736a2020649edf9693679e"
 
 [[package]]
 name = "electron-cli"
-version = "0.3.0-alpha.14"
+version = "0.3.0-alpha.15"
 dependencies = [
  "anyhow",
  "apple-dmg",
@@ -386,6 +386,7 @@ dependencies = [
  "fatfs",
  "flate2",
  "fscommon",
+ "json5",
  "md5",
  "msi",
  "plist",
@@ -805,6 +806,16 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "json5"
+version = "1.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "733a844dbd6fef128e98cb4487b887cb55454d92cd9994b1bafe004fabbe670c"
+dependencies = [
+ "serde",
+ "ucd-trie",
+]
+
 [[package]]
 name = "keccak"
 version = "0.1.6"
@@ -1448,6 +1459,12 @@ version = "1.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
 
+[[package]]
+name = "ucd-trie"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971"
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.24"

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "electron-cli"
-version = "0.3.0-alpha.14"
+version = "0.3.0-alpha.15"
 edition = "2021"
 description = "Experimental Rust CLI for Electron project diagnostics and workflow automation"
 license = "MIT"
@@ -15,6 +15,7 @@ clap = { version = "4.6", features = ["derive"] }
 fatfs = "0.3"
 flate2 = { version = "1.1", default-features = false, features = ["rust_backend"] }
 fscommon = "0.1"
+json5 = "1"
 md5 = "0.7"
 msi = "0.10"
 plist = "1"

package/README.md

@@ -35,9 +35,9 @@ The Rust-native flow currently owns:
 
 - `init --template minimal`: writes a local Electron starter without Electron Forge.
 - `start`: launches the installed Electron runtime directly.
-- `package`: copies the installed Electron runtime, 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 distributables under `out/make/<target>/<platform>/<arch>/`; it reads JSON-shaped `config.forge.makers` / `electronCli.makers` arrays when `--target` is omitted, and `--target` still forces one maker. ZIP works on all platforms, `--target dmg` writes a basic macOS disk image, `--target deb` / `--target rpm` write Linux packages, and `--target msi` writes a basic Windows Installer package.
-- `publish`: runs `make` and publishes distributables to a local directory with a manifest or to GitHub Releases; it reads JSON-shaped `config.forge.publishers` / `electronCli.publishers` arrays when `--publisher` is omitted, and `--publisher` still forces one publisher.
+- `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; it reads package metadata from `package.json`, JSON-shaped Forge config, and static Forge config files.
+- `make`: runs `package` and writes distributables under `out/make/<target>/<platform>/<arch>/`; it reads JSON-shaped `config.forge.makers` / `electronCli.makers` arrays and static Forge config files when `--target` is omitted, and `--target` still forces one maker. ZIP works on all platforms, `--target dmg` writes a basic macOS disk image, `--target deb` / `--target rpm` write Linux packages, and `--target msi` writes a basic Windows Installer package.
+- `publish`: runs `make` and publishes distributables to a local directory with a manifest or to GitHub Releases; it reads JSON-shaped `config.forge.publishers` / `electronCli.publishers` arrays and static Forge config files when `--publisher` is omitted, and `--publisher` still forces one publisher.
 
 The GitHub publisher creates or reuses a release, uploads selected make artifacts, and can replace an existing asset with `--force`. It reads `GITHUB_TOKEN` or `GH_TOKEN` and can infer `OWNER/REPO` from package metadata, Forge GitHub publisher config, or `package.json` `repository`. You can also pass `--github-repo`.
 
@@ -87,7 +87,9 @@ Package metadata can be configured in `package.json`:
 }
 ```
 
-The package command also reads JSON-shaped `config.forge.packagerConfig` and `electronPackagerConfig` entries for the same fields. The make command maps JSON-shaped Forge maker names to the Rust-native targets it supports: zip, dmg, deb, rpm, and wix/msi. The publish command maps JSON-shaped publisher names to local and GitHub. JavaScript Forge config files are not evaluated.
+The package command also reads JSON-shaped `config.forge.packagerConfig` and `electronPackagerConfig` entries for the same fields. The make command maps JSON-shaped Forge maker names to the Rust-native targets it supports: zip, dmg, deb, rpm, and wix/msi. The publish command maps JSON-shaped publisher names to local and GitHub.
+
+Static `forge.config.js`, `forge.config.cjs`, `forge.config.mjs`, and `forge.config.ts` files are parsed in Rust when they export an object literal directly or via a local `const`/`let`/`var` identifier. Dynamic JavaScript config that calls functions, reads environment state, or computes the config at runtime is not evaluated.
 
 ## Install
 

package/package.json

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

package/src/commands/make.rs

@@ -228,24 +228,13 @@ fn resolve_make_targets(
 }
 
 fn configured_makers(snapshot: &ProjectSnapshot) -> Result<Vec<ConfiguredMaker>> {
-    let Some(package_json_path) = &snapshot.package_json else {
-        return Ok(Vec::new());
-    };
-    let package_json_path = Path::new(package_json_path.as_str());
-    let raw = fs::read_to_string(package_json_path)
-        .with_context(|| format!("Could not read {}", package_json_path.display()))?;
-    let package = serde_json::from_str::<JsonValue>(&raw)
-        .with_context(|| format!("Could not parse {}", package_json_path.display()))?;
+    let project_config = crate::forge_config::read(snapshot)?;
 
     let mut makers = Vec::new();
     for value in [
-        package
-            .get("config")
-            .and_then(|config| config.get("forge"))
-            .and_then(|forge| forge.get("makers")),
-        package
-            .get("electronCli")
-            .or_else(|| package.get("electron-cli"))
+        project_config.forge().and_then(|forge| forge.get("makers")),
+        project_config
+            .electron_cli()
             .and_then(|config| config.get("makers")),
     ]
     .into_iter()
@@ -2421,6 +2410,46 @@ mod tests {
         let _ = fs::remove_dir_all(root);
     }
 
+    #[test]
+    fn builds_make_reports_from_static_forge_config_js() {
+        let root = unique_temp_dir("configured-makers-js");
+        write_package_json(&root);
+        fs::write(
+            root.join("forge.config.js"),
+            r#"
+            module.exports = {
+              makers: [
+                { name: '@electron-forge/maker-zip' },
+                { name: '@electron-forge/maker-rpm', platforms: ['linux'] },
+              ],
+            };
+            "#,
+        )
+        .expect("forge config should be written");
+        write_app_file(&root);
+        write_fake_electron_dist(&root);
+
+        let args = MakeArgs {
+            cwd: root.clone(),
+            out_dir: PathBuf::from("out"),
+            name: None,
+            platform: Some("linux".to_string()),
+            arch: Some("x64".to_string()),
+            target: None,
+            skip_package: false,
+            force: false,
+            dry_run: true,
+            json: true,
+        };
+        let reports = build_reports(&args).expect("reports should build");
+
+        assert_eq!(reports.len(), 2);
+        assert_eq!(reports[0].target(), "zip");
+        assert_eq!(reports[1].target(), "rpm");
+
+        let _ = fs::remove_dir_all(root);
+    }
+
     #[test]
     fn explicit_make_target_overrides_configured_makers() {
         let root = unique_temp_dir("target-override");

package/src/commands/package.rs

@@ -67,6 +67,7 @@ struct PackageJsonConfig {
     product_name: Option<String>,
     app_version: Option<String>,
     packager: PackagerConfig,
+    warnings: Vec<String>,
 }
 
 #[derive(Debug, Default)]
@@ -133,7 +134,7 @@ pub(crate) fn build_report(snapshot: ProjectSnapshot, args: &PackageArgs) -> Res
         &platform,
     )?;
 
-    let mut warnings = Vec::new();
+    let mut warnings = package_config.warnings.clone();
     if snapshot.package_json.is_none() {
         warnings.push("No package.json found.".to_string());
     }
@@ -346,44 +347,40 @@ fn print_report(report: &PackageReport, json: bool) -> Result<()> {
 }
 
 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 project_config = crate::forge_config::read(snapshot)?;
 
     let mut packager = PackagerConfig::default();
-    if let Some(config) = package
-        .get("config")
-        .and_then(|config| config.get("forge"))
+    if let Some(config) = project_config
+        .forge()
         .and_then(|forge| forge.get("packagerConfig"))
     {
         packager.merge(parse_packager_config(config));
     }
-    if let Some(config) = package.get("electronPackagerConfig") {
+    if let Some(config) = project_config
+        .package()
+        .and_then(|package| package.get("electronPackagerConfig"))
+    {
         packager.merge(parse_packager_config(config));
     }
-    if let Some(config) = package
-        .get("electronCli")
-        .or_else(|| package.get("electron-cli"))
+    if let Some(config) = project_config
+        .electron_cli()
         .and_then(|config| config.get("packagerConfig"))
     {
         packager.merge(parse_packager_config(config));
     }
 
     Ok(PackageJsonConfig {
-        product_name: package
-            .get("productName")
+        product_name: project_config
+            .package()
+            .and_then(|package| package.get("productName"))
             .and_then(JsonValue::as_str)
             .map(ToOwned::to_owned),
-        app_version: package
-            .get("version")
+        app_version: project_config
+            .package()
+            .and_then(|package| package.get("version"))
             .and_then(JsonValue::as_str)
             .map(ToOwned::to_owned),
+        warnings: project_config.warnings().to_vec(),
         packager,
     })
 }
@@ -1380,6 +1377,52 @@ mod tests {
         let _ = fs::remove_dir_all(root);
     }
 
+    #[test]
+    fn plans_packager_metadata_from_forge_config_js() {
+        let root = unique_temp_dir("forge-config-metadata");
+        write_package_json(&root);
+        fs::write(
+            root.join("forge.config.js"),
+            r#"
+            module.exports = {
+              packagerConfig: {
+                name: 'Forge Config App',
+                executableName: 'ForgeExec',
+                appBundleId: 'com.example.forge-config',
+              },
+            };
+            "#,
+        )
+        .expect("forge config 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: 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, "Forge Config App");
+        assert_eq!(
+            report.executable_name,
+            executable_name("ForgeExec", &report.platform)
+        );
+        assert_eq!(
+            report.metadata.bundle_identifier,
+            "com.example.forge-config"
+        );
+
+        let _ = fs::remove_dir_all(root);
+    }
+
     #[test]
     fn packages_macos_info_plist_metadata() {
         if current_platform() != "darwin" {

package/src/commands/publish.rs

@@ -449,24 +449,15 @@ fn resolved_publisher_from_args(
 }
 
 fn configured_publishers(project: &ProjectSnapshot) -> Result<Vec<ConfiguredPublisher>> {
-    let Some(package_json_path) = &project.package_json else {
-        return Ok(Vec::new());
-    };
-    let package_json_path = Path::new(package_json_path.as_str());
-    let raw = fs::read_to_string(package_json_path)
-        .with_context(|| format!("Could not read {}", package_json_path.display()))?;
-    let package = serde_json::from_str::<JsonValue>(&raw)
-        .with_context(|| format!("Could not parse {}", package_json_path.display()))?;
+    let project_config = crate::forge_config::read(project)?;
 
     let mut publishers = Vec::new();
     for value in [
-        package
-            .get("config")
-            .and_then(|config| config.get("forge"))
+        project_config
+            .forge()
             .and_then(|forge| forge.get("publishers")),
-        package
-            .get("electronCli")
-            .or_else(|| package.get("electron-cli"))
+        project_config
+            .electron_cli()
             .and_then(|config| config.get("publishers")),
     ]
     .into_iter()
@@ -1394,6 +1385,46 @@ mod tests {
         let _ = fs::remove_dir_all(root);
     }
 
+    #[test]
+    fn builds_github_publish_report_from_static_forge_config_js() {
+        let root = unique_temp_dir("configured-github-js-plan");
+        write_package_json(&root);
+        fs::write(
+            root.join("forge.config.js"),
+            r#"
+            module.exports = {
+              publishers: [
+                {
+                  name: '@electron-forge/publisher-github',
+                  config: {
+                    repository: { owner: 'Ikana', name: 'electron-cli' },
+                    tagPrefix: 'release-',
+                    prerelease: true,
+                  },
+                },
+              ],
+            };
+            "#,
+        )
+        .expect("forge config should be written");
+        write_app_file(&root);
+        write_fake_electron_dist(&root);
+
+        let mut args = publish_args(root.clone(), true);
+        args.publisher = None;
+        args.github_api_url = None;
+        args.channel = None;
+        let report = build_report(&args).expect("report should build");
+
+        assert_eq!(report.publisher, "github");
+        let github = report.github.as_ref().expect("github plan should exist");
+        assert_eq!(github.repo, "Ikana/electron-cli");
+        assert_eq!(github.tag, "release-0.1.0");
+        assert!(github.prerelease);
+
+        let _ = fs::remove_dir_all(root);
+    }
+
     #[test]
     fn builds_publish_reports_from_configured_makers_and_publishers() {
         let root = unique_temp_dir("configured-publishers");

package/src/forge_config.rs

@@ -0,0 +1,547 @@
+use std::{
+    fs,
+    path::{Path, PathBuf},
+};
+
+use anyhow::{anyhow, Context, Result};
+use serde_json::Value as JsonValue;
+
+use crate::project::ProjectSnapshot;
+
+#[derive(Clone, Debug, Default)]
+pub(crate) struct ProjectConfig {
+    package: Option<JsonValue>,
+    forge: Option<JsonValue>,
+    electron_cli: Option<JsonValue>,
+    warnings: Vec<String>,
+}
+
+pub(crate) fn read(snapshot: &ProjectSnapshot) -> Result<ProjectConfig> {
+    let package = read_package_json(snapshot)?;
+    let root = Path::new(snapshot.root.as_str());
+    let mut warnings = Vec::new();
+    let forge = resolve_forge_config(root, package.as_ref(), &mut warnings);
+    let electron_cli = package
+        .as_ref()
+        .and_then(|package| {
+            package
+                .get("electronCli")
+                .or_else(|| package.get("electron-cli"))
+        })
+        .cloned();
+
+    Ok(ProjectConfig {
+        package,
+        forge,
+        electron_cli,
+        warnings,
+    })
+}
+
+fn read_package_json(snapshot: &ProjectSnapshot) -> Result<Option<JsonValue>> {
+    let Some(package_json_path) = &snapshot.package_json else {
+        return Ok(None);
+    };
+    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()))?;
+    serde_json::from_str::<JsonValue>(&raw)
+        .with_context(|| format!("Could not parse {}", package_json_path.display()))
+        .map(Some)
+}
+
+fn resolve_forge_config(
+    root: &Path,
+    package: Option<&JsonValue>,
+    warnings: &mut Vec<String>,
+) -> Option<JsonValue> {
+    match package
+        .and_then(|package| package.get("config"))
+        .and_then(|config| config.get("forge"))
+    {
+        Some(JsonValue::Object(_)) => {
+            return package
+                .and_then(|package| package.get("config"))
+                .and_then(|config| config.get("forge"))
+                .cloned()
+        }
+        Some(JsonValue::String(path)) => {
+            return read_forge_config_file(root, Path::new(path), warnings);
+        }
+        Some(_) => {
+            warnings.push(
+                "package.json config.forge must be an object or relative config file path."
+                    .to_string(),
+            );
+            return None;
+        }
+        None => {}
+    }
+
+    for candidate in [
+        "forge.config.js",
+        "forge.config.cjs",
+        "forge.config.mjs",
+        "forge.config.ts",
+    ] {
+        let path = root.join(candidate);
+        if path.exists() {
+            return read_forge_config_file(root, &PathBuf::from(candidate), warnings);
+        }
+    }
+
+    None
+}
+
+fn read_forge_config_file(
+    root: &Path,
+    configured_path: &Path,
+    warnings: &mut Vec<String>,
+) -> Option<JsonValue> {
+    let path = if configured_path.is_absolute() {
+        configured_path.to_path_buf()
+    } else {
+        root.join(configured_path)
+    };
+    let display = path.display();
+
+    let raw = match fs::read_to_string(&path) {
+        Ok(raw) => raw,
+        Err(error) => {
+            warnings.push(format!(
+                "Could not read Forge config file {display}: {error}."
+            ));
+            return None;
+        }
+    };
+
+    match parse_forge_config_file(&raw, &path) {
+        Ok(config) => Some(config),
+        Err(error) => {
+            warnings.push(format!(
+                "Could not parse Forge config file {display} without JavaScript execution: {error}."
+            ));
+            None
+        }
+    }
+}
+
+fn parse_forge_config_file(raw: &str, path: &Path) -> Result<JsonValue> {
+    if path.extension().and_then(|extension| extension.to_str()) == Some("json") {
+        return serde_json::from_str(raw).with_context(|| "Forge JSON config is not valid JSON");
+    }
+
+    let object_literal = extract_static_config_object(raw)
+        .ok_or_else(|| anyhow!("expected a static object export"))?;
+    json5::from_str::<JsonValue>(&object_literal)
+        .with_context(|| "static Forge config object is not valid JSON5")
+}
+
+fn extract_static_config_object(source: &str) -> Option<String> {
+    for marker in ["module.exports", "exports.default"] {
+        if let Some(object) = extract_assignment_object(source, marker) {
+            return Some(object);
+        }
+    }
+
+    if let Some(object) = extract_export_default_object(source) {
+        return Some(object);
+    }
+
+    if let Some(identifier) = export_default_identifier(source)
+        .or_else(|| assignment_identifier(source, "module.exports"))
+        .or_else(|| assignment_identifier(source, "exports.default"))
+    {
+        return extract_variable_object(source, &identifier);
+    }
+
+    None
+}
+
+fn extract_assignment_object(source: &str, marker: &str) -> Option<String> {
+    let marker_index = source.find(marker)?;
+    let after_marker = &source[marker_index + marker.len()..];
+    let equals = after_marker.find('=')?;
+    let after_equals_start = marker_index + marker.len() + equals + 1;
+    let object_start = find_next_object_start(source, after_equals_start)?;
+    extract_balanced_object(source, object_start)
+}
+
+fn extract_export_default_object(source: &str) -> Option<String> {
+    let marker = "export default";
+    let marker_index = source.find(marker)?;
+    let after_marker = marker_index + marker.len();
+    let object_start = find_next_object_start(source, after_marker)?;
+    let identifier = read_identifier(source, skip_whitespace(source, after_marker)).0;
+    if identifier.is_some() {
+        return None;
+    }
+    extract_balanced_object(source, object_start)
+}
+
+fn export_default_identifier(source: &str) -> Option<String> {
+    let marker = "export default";
+    let marker_index = source.find(marker)?;
+    let start = skip_whitespace(source, marker_index + marker.len());
+    read_identifier(source, start).0
+}
+
+fn assignment_identifier(source: &str, marker: &str) -> Option<String> {
+    let marker_index = source.find(marker)?;
+    let after_marker = &source[marker_index + marker.len()..];
+    let equals = after_marker.find('=')?;
+    let start = skip_whitespace(source, marker_index + marker.len() + equals + 1);
+    read_identifier(source, start).0
+}
+
+fn extract_variable_object(source: &str, identifier: &str) -> Option<String> {
+    for keyword in ["const", "let", "var"] {
+        for (keyword_index, _) in source.match_indices(keyword) {
+            if !is_word_boundary(source, keyword_index, keyword.len()) {
+                continue;
+            }
+            let start = skip_whitespace(source, keyword_index + keyword.len());
+            let (name, after_name) = read_identifier(source, start);
+            if name.as_deref() != Some(identifier) {
+                continue;
+            }
+            let rest = &source[after_name..];
+            let equals = rest.find('=')?;
+            let object_start = find_next_object_start(source, after_name + equals + 1)?;
+            return extract_balanced_object(source, object_start);
+        }
+    }
+
+    None
+}
+
+fn find_next_object_start(source: &str, start: usize) -> Option<usize> {
+    let bytes = source.as_bytes();
+    let mut index = start;
+    while index < bytes.len() {
+        match bytes[index] {
+            b'{' => return Some(index),
+            b';' | b'\n' if !source[start..index].trim().is_empty() => return None,
+            _ => index += 1,
+        }
+    }
+    None
+}
+
+fn extract_balanced_object(source: &str, object_start: usize) -> Option<String> {
+    let bytes = source.as_bytes();
+    let mut index = object_start;
+    let mut depth = 0usize;
+    let mut state = ScanState::Normal;
+
+    while index < bytes.len() {
+        match state {
+            ScanState::Normal => match bytes[index] {
+                b'{' => {
+                    depth += 1;
+                    index += 1;
+                }
+                b'}' => {
+                    depth = depth.checked_sub(1)?;
+                    index += 1;
+                    if depth == 0 {
+                        return Some(source[object_start..index].to_string());
+                    }
+                }
+                b'\'' | b'"' | b'`' => {
+                    state = ScanState::String(bytes[index]);
+                    index += 1;
+                }
+                b'/' if bytes.get(index + 1) == Some(&b'/') => {
+                    state = ScanState::LineComment;
+                    index += 2;
+                }
+                b'/' if bytes.get(index + 1) == Some(&b'*') => {
+                    state = ScanState::BlockComment;
+                    index += 2;
+                }
+                _ => index += 1,
+            },
+            ScanState::String(quote) => {
+                if bytes[index] == b'\\' {
+                    index = (index + 2).min(bytes.len());
+                } else if bytes[index] == quote {
+                    state = ScanState::Normal;
+                    index += 1;
+                } else {
+                    index += 1;
+                }
+            }
+            ScanState::LineComment => {
+                if bytes[index] == b'\n' {
+                    state = ScanState::Normal;
+                }
+                index += 1;
+            }
+            ScanState::BlockComment => {
+                if bytes[index] == b'*' && bytes.get(index + 1) == Some(&b'/') {
+                    state = ScanState::Normal;
+                    index += 2;
+                } else {
+                    index += 1;
+                }
+            }
+        }
+    }
+
+    None
+}
+
+fn skip_whitespace(source: &str, start: usize) -> usize {
+    let bytes = source.as_bytes();
+    let mut index = start;
+    while index < bytes.len() && bytes[index].is_ascii_whitespace() {
+        index += 1;
+    }
+    index
+}
+
+fn read_identifier(source: &str, start: usize) -> (Option<String>, usize) {
+    let bytes = source.as_bytes();
+    if bytes.get(start).is_none_or(|byte| !identifier_start(*byte)) {
+        return (None, start);
+    }
+
+    let mut index = start + 1;
+    while index < bytes.len() && identifier_continue(bytes[index]) {
+        index += 1;
+    }
+
+    (Some(source[start..index].to_string()), index)
+}
+
+fn is_word_boundary(source: &str, start: usize, len: usize) -> bool {
+    let bytes = source.as_bytes();
+    let before = start
+        .checked_sub(1)
+        .and_then(|index| bytes.get(index))
+        .copied();
+    let after = bytes.get(start + len).copied();
+    before.is_none_or(|byte| !identifier_continue(byte))
+        && after.is_none_or(|byte| !identifier_continue(byte))
+}
+
+fn identifier_start(byte: u8) -> bool {
+    byte.is_ascii_alphabetic() || matches!(byte, b'_' | b'$')
+}
+
+fn identifier_continue(byte: u8) -> bool {
+    identifier_start(byte) || byte.is_ascii_digit()
+}
+
+#[derive(Clone, Copy, Debug)]
+enum ScanState {
+    Normal,
+    String(u8),
+    LineComment,
+    BlockComment,
+}
+
+impl ProjectConfig {
+    pub(crate) fn package(&self) -> Option<&JsonValue> {
+        self.package.as_ref()
+    }
+
+    pub(crate) fn forge(&self) -> Option<&JsonValue> {
+        self.forge.as_ref()
+    }
+
+    pub(crate) fn electron_cli(&self) -> Option<&JsonValue> {
+        self.electron_cli.as_ref()
+    }
+
+    pub(crate) fn warnings(&self) -> &[String] {
+        &self.warnings
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use camino::Utf8PathBuf;
+
+    #[test]
+    fn parses_commonjs_static_forge_config() {
+        let config = parse_forge_config_file(
+            r#"
+            module.exports = {
+              packagerConfig: {
+                name: 'Desk Tool',
+              },
+              makers: [
+                { name: '@electron-forge/maker-zip' },
+              ],
+            };
+            "#,
+            Path::new("forge.config.js"),
+        )
+        .expect("config should parse");
+
+        assert_eq!(
+            config
+                .get("packagerConfig")
+                .and_then(|config| config.get("name"))
+                .and_then(JsonValue::as_str),
+            Some("Desk Tool")
+        );
+    }
+
+    #[test]
+    fn parses_typescript_exported_config_identifier() {
+        let config = parse_forge_config_file(
+            r#"
+            import type { ForgeConfig } from '@electron-forge/shared-types';
+
+            const config: ForgeConfig = {
+              publishers: [
+                {
+                  name: '@electron-forge/publisher-github',
+                  platforms: ['darwin'],
+                  config: { repository: { owner: 'Ikana', name: 'electron-cli' } },
+                },
+              ],
+            };
+
+            export default config;
+            "#,
+            Path::new("forge.config.ts"),
+        )
+        .expect("config should parse");
+
+        assert_eq!(
+            config
+                .get("publishers")
+                .and_then(JsonValue::as_array)
+                .and_then(|publishers| publishers.first())
+                .and_then(|publisher| publisher.get("platforms"))
+                .and_then(JsonValue::as_array)
+                .and_then(|platforms| platforms.first())
+                .and_then(JsonValue::as_str),
+            Some("darwin")
+        );
+    }
+
+    #[test]
+    fn reads_config_path_from_package_json() {
+        let root = unique_temp_dir("config-path");
+        fs::write(
+            root.join("package.json"),
+            r#"{"name":"app","config":{"forge":"./build/forge.config.js"}}"#,
+        )
+        .expect("package.json should be written");
+        fs::create_dir_all(root.join("build")).expect("build dir should be created");
+        fs::write(
+            root.join("build/forge.config.js"),
+            "module.exports = { makers: [{ name: '@electron-forge/maker-deb' }] };",
+        )
+        .expect("forge config should be written");
+
+        let snapshot = snapshot(&root);
+        let config = read(&snapshot).expect("config should read");
+
+        assert_eq!(
+            config
+                .forge()
+                .and_then(|forge| forge.get("makers"))
+                .and_then(JsonValue::as_array)
+                .and_then(|makers| makers.first())
+                .and_then(|maker| maker.get("name"))
+                .and_then(JsonValue::as_str),
+            Some("@electron-forge/maker-deb")
+        );
+        assert!(config.warnings().is_empty());
+
+        let _ = fs::remove_dir_all(root);
+    }
+
+    #[test]
+    fn discovers_default_forge_config_js() {
+        let root = unique_temp_dir("default-config");
+        fs::write(root.join("package.json"), r#"{"name":"app"}"#)
+            .expect("package.json should be written");
+        fs::write(
+            root.join("forge.config.js"),
+            "module.exports = { packagerConfig: { executableName: 'desk-tool' } };",
+        )
+        .expect("forge config should be written");
+
+        let snapshot = snapshot(&root);
+        let config = read(&snapshot).expect("config should read");
+
+        assert_eq!(
+            config
+                .forge()
+                .and_then(|forge| forge.get("packagerConfig"))
+                .and_then(|packager| packager.get("executableName"))
+                .and_then(JsonValue::as_str),
+            Some("desk-tool")
+        );
+
+        let _ = fs::remove_dir_all(root);
+    }
+
+    #[test]
+    fn warns_when_config_requires_javascript_execution() {
+        let root = unique_temp_dir("dynamic-config");
+        fs::write(root.join("package.json"), r#"{"name":"app"}"#)
+            .expect("package.json should be written");
+        fs::write(
+            root.join("forge.config.js"),
+            "module.exports = buildConfig(process.env.NODE_ENV);",
+        )
+        .expect("forge config should be written");
+
+        let snapshot = snapshot(&root);
+        let config = read(&snapshot).expect("config should read");
+
+        assert!(config.forge().is_none());
+        assert!(config
+            .warnings()
+            .iter()
+            .any(|warning| warning.contains("without JavaScript execution")));
+
+        let _ = fs::remove_dir_all(root);
+    }
+
+    fn snapshot(root: &Path) -> ProjectSnapshot {
+        ProjectSnapshot {
+            root: Utf8PathBuf::from_path_buf(root.to_path_buf()).expect("root should be utf-8"),
+            package_json: Some(
+                Utf8PathBuf::from_path_buf(root.join("package.json"))
+                    .expect("package path should be utf-8"),
+            ),
+            name: Some("app".to_string()),
+            version: None,
+            repository: None,
+            license: None,
+            main: Some("src/main.js".to_string()),
+            package_manager: None,
+            scripts: Default::default(),
+            dependencies: Default::default(),
+            dev_dependencies: Default::default(),
+            optional_dependencies: Default::default(),
+            peer_dependencies: Default::default(),
+            electron_dependency: Some("30.0.0".to_string()),
+            forge_dependencies: Default::default(),
+            signals: Vec::new(),
+        }
+    }
+
+    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-forge-config-{label}-{}-{nanos}",
+            std::process::id()
+        ));
+        fs::create_dir_all(&path).expect("temp dir should be created");
+        path
+    }
+}

package/src/main.rs

@@ -1,5 +1,6 @@
 mod cli;
 mod commands;
+mod forge_config;
 mod output;
 mod project;