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

package/src/commands/plan.rs

@@ -83,7 +83,9 @@ fn build_report(snapshot: &project::ProjectSnapshot) -> PlanReport {
     let mut risks = Vec::new();
     let mut notes = Vec::new();
 
-    if let Some(script) = first_script(snapshot, &["start", "dev"]) {
+    if matches!(project_type, ProjectType::Electron) && snapshot.main.is_some() {
+        recommended_commands.insert("dev".to_string(), "electron-cli start".to_string());
+    } else if let Some(script) = first_script(snapshot, &["start", "dev"]) {
         recommended_commands.insert("dev".to_string(), run_script(snapshot, script));
     } else if snapshot.electron_dependency.is_some() && snapshot.main.is_some() {
         recommended_commands.insert("dev".to_string(), package_exec(snapshot, "electron ."));
@@ -94,7 +96,9 @@ fn build_report(snapshot: &project::ProjectSnapshot) -> PlanReport {
         missing.push("No start or dev script was found.".to_string());
     }
 
-    if let Some(script) = first_script(snapshot, &["package", "pack"]) {
+    if matches!(project_type, ProjectType::Electron) && snapshot.main.is_some() {
+        recommended_commands.insert("package".to_string(), "electron-cli package".to_string());
+    } else if let Some(script) = first_script(snapshot, &["package", "pack"]) {
         recommended_commands.insert("package".to_string(), run_script(snapshot, script));
     } else if matches!(project_type, ProjectType::ElectronForge) {
         missing.push(
@@ -102,7 +106,9 @@ fn build_report(snapshot: &project::ProjectSnapshot) -> PlanReport {
         );
     }
 
-    if let Some(script) = first_script(snapshot, &["make", "dist"]) {
+    if matches!(project_type, ProjectType::Electron) && snapshot.main.is_some() {
+        recommended_commands.insert("make".to_string(), "electron-cli make".to_string());
+    } else if let Some(script) = first_script(snapshot, &["make", "dist"]) {
         recommended_commands.insert("make".to_string(), run_script(snapshot, script));
     }
 
@@ -134,9 +140,9 @@ fn build_report(snapshot: &project::ProjectSnapshot) -> PlanReport {
     }
 
     if matches!(project_type, ProjectType::ElectronForge) {
-        notes.push("Electron Forge was detected; wrapping Forge commands is the safest workflow path today.".to_string());
+        notes.push("Electron Forge was detected; its scripts remain the safest path for Forge-managed apps today.".to_string());
     } else if snapshot.electron_dependency.is_some() {
-        notes.push("Electron was detected without Forge; prefer inspection before choosing a packaging path.".to_string());
+        notes.push("Electron was detected without Forge; electron-cli can start and package the current-platform app directly.".to_string());
     } else {
         notes.push("This does not currently look like an Electron app.".to_string());
     }
@@ -232,4 +238,43 @@ mod tests {
         );
         assert!(report.risks.is_empty());
     }
+
+    #[test]
+    fn plans_native_electron_cli_flow_for_plain_electron_app() {
+        let snapshot = project::ProjectSnapshot {
+            root: camino::Utf8PathBuf::from("/tmp/native-app"),
+            package_json: Some(camino::Utf8PathBuf::from("/tmp/native-app/package.json")),
+            name: Some("native-app".to_string()),
+            version: Some("0.1.0".to_string()),
+            main: Some("src/main.js".to_string()),
+            package_manager: Some("npm".to_string()),
+            scripts: BTreeMap::new(),
+            dependencies: BTreeMap::new(),
+            dev_dependencies: BTreeMap::from([("electron".to_string(), "30.0.0".to_string())]),
+            optional_dependencies: BTreeMap::new(),
+            peer_dependencies: BTreeMap::new(),
+            electron_dependency: Some("30.0.0".to_string()),
+            forge_dependencies: BTreeMap::new(),
+            signals: vec!["electron dependency declared".to_string()],
+        };
+
+        let report = build_report(&snapshot);
+
+        assert!(matches!(report.project_type, ProjectType::Electron));
+        assert_eq!(
+            report.recommended_commands.get("dev").map(String::as_str),
+            Some("electron-cli start")
+        );
+        assert_eq!(
+            report
+                .recommended_commands
+                .get("package")
+                .map(String::as_str),
+            Some("electron-cli package")
+        );
+        assert_eq!(
+            report.recommended_commands.get("make").map(String::as_str),
+            Some("electron-cli make")
+        );
+    }
 }

package/src/commands/start.rs

@@ -0,0 +1,287 @@
+use std::{
+    path::{Path, PathBuf},
+    process::Command,
+};
+
+use anyhow::{bail, Context, Result};
+use camino::Utf8PathBuf;
+use serde::Serialize;
+
+use crate::{cli::StartArgs, output, project::ProjectSnapshot};
+
+#[derive(Debug, Serialize)]
+struct StartReport {
+    project: ProjectSnapshot,
+    electron_path: Option<Utf8PathBuf>,
+    command: Vec<String>,
+    command_display: String,
+    passthrough_args: Vec<String>,
+    dry_run: bool,
+    status: StartStatus,
+    exit_code: Option<i32>,
+    warnings: Vec<String>,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "kebab-case")]
+enum StartStatus {
+    Planned,
+    Exited,
+}
+
+pub fn run(args: StartArgs) -> Result<()> {
+    let snapshot = crate::project::inspect(&args.cwd)?;
+    let mut report = build_report(snapshot, &args)?;
+
+    if args.dry_run {
+        return print_report(&report, args.json);
+    }
+
+    let exit_code = execute_start(&report)?;
+    report.status = StartStatus::Exited;
+    report.exit_code = exit_code;
+
+    if args.json {
+        output::json(&report)?;
+    }
+
+    if let Some(code) = exit_code {
+        bail!("Electron exited with status code {code}");
+    } else {
+        Ok(())
+    }
+}
+
+fn build_report(snapshot: ProjectSnapshot, args: &StartArgs) -> Result<StartReport> {
+    let root = Path::new(snapshot.root.as_str());
+    let electron_path = find_electron_executable(root);
+    let mut warnings = Vec::new();
+
+    if snapshot.package_json.is_none() {
+        warnings.push("No package.json found.".to_string());
+    }
+
+    if snapshot.electron_dependency.is_none() {
+        warnings.push("No electron dependency is declared in package.json.".to_string());
+    }
+
+    if electron_path.is_none() {
+        warnings.push(
+            "Electron executable was not found under node_modules/electron/dist.".to_string(),
+        );
+    }
+
+    let mut command = Vec::new();
+    if let Some(path) = &electron_path {
+        command.push(path_arg(path));
+        command.push(snapshot.root.to_string());
+        command.extend(args.electron_args.clone());
+    }
+
+    let command_display = if command.is_empty() {
+        "electron executable not found".to_string()
+    } else {
+        display_command(&command)
+    };
+
+    Ok(StartReport {
+        project: snapshot,
+        electron_path: electron_path.map(utf8_path).transpose()?,
+        command,
+        command_display,
+        passthrough_args: args.electron_args.clone(),
+        dry_run: args.dry_run,
+        status: StartStatus::Planned,
+        exit_code: None,
+        warnings,
+    })
+}
+
+fn execute_start(report: &StartReport) -> Result<Option<i32>> {
+    if report.project.package_json.is_none() {
+        bail!("No package.json found. Run electron-cli start inside an Electron project.");
+    }
+
+    if report.project.electron_dependency.is_none() {
+        bail!("No electron dependency found. Install Electron before starting the app.");
+    }
+
+    let (program, args) = report
+        .command
+        .split_first()
+        .context("Electron executable was not found. Run your package manager install first.")?;
+
+    let status = Command::new(program)
+        .args(args)
+        .current_dir(report.project.root.as_str())
+        .status()
+        .with_context(|| format!("Could not execute {}", report.command_display))?;
+
+    if status.success() {
+        Ok(None)
+    } else {
+        Ok(status.code())
+    }
+}
+
+fn print_report(report: &StartReport, json: bool) -> Result<()> {
+    if json {
+        return output::json(report);
+    }
+
+    println!("electron-cli start");
+    println!();
+    println!("Project");
+    println!("  root: {}", report.project.root);
+    match report.project.package_label() {
+        Some(label) => println!("  package: {label}"),
+        None => println!("  package: not found"),
+    }
+
+    println!();
+    println!("Command");
+    println!("  {}", report.command_display);
+
+    if !report.warnings.is_empty() {
+        println!();
+        println!("Warnings");
+        for warning in &report.warnings {
+            println!("  {warning}");
+        }
+    }
+
+    Ok(())
+}
+
+fn find_electron_executable(root: &Path) -> Option<PathBuf> {
+    let dist = root.join("node_modules/electron/dist");
+    let candidates = electron_executable_candidates(&dist);
+
+    candidates.into_iter().find(|path| path.exists())
+}
+
+fn electron_executable_candidates(dist: &Path) -> Vec<PathBuf> {
+    if cfg!(target_os = "macos") {
+        vec![
+            dist.join("Electron.app/Contents/MacOS/Electron"),
+            dist.join("electron"),
+        ]
+    } else if cfg!(target_os = "windows") {
+        vec![dist.join("electron.exe")]
+    } else {
+        vec![dist.join("electron")]
+    }
+}
+
+fn display_command(command: &[String]) -> String {
+    command
+        .iter()
+        .map(|arg| shell_quote(arg))
+        .collect::<Vec<_>>()
+        .join(" ")
+}
+
+fn shell_quote(value: &str) -> String {
+    if value
+        .chars()
+        .all(|char| char.is_ascii_alphanumeric() || matches!(char, '.' | '/' | '-' | '_' | '@'))
+    {
+        value.to_string()
+    } else {
+        format!("'{}'", value.replace('\'', "'\\''"))
+    }
+}
+
+fn path_arg(path: &Path) -> String {
+    path.to_string_lossy().to_string()
+}
+
+fn utf8_path(path: PathBuf) -> Result<Utf8PathBuf> {
+    Utf8PathBuf::from_path_buf(path).map_err(|path| {
+        anyhow::anyhow!(
+            "Path contains invalid UTF-8 and cannot be represented in JSON: {}",
+            path.display()
+        )
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+
+    #[test]
+    fn plans_start_command_when_electron_dist_exists() {
+        let root = unique_temp_dir();
+        write_package_json(&root);
+        write_fake_electron(&root);
+
+        let args = StartArgs {
+            cwd: root.clone(),
+            dry_run: true,
+            json: true,
+            electron_args: vec!["--trace-warnings".to_string()],
+        };
+        let snapshot = crate::project::inspect(&root).expect("project should inspect");
+        let report = build_report(snapshot, &args).expect("report should build");
+
+        assert!(report.electron_path.is_some());
+        assert!(report.command_display.contains("--trace-warnings"));
+        assert!(report.warnings.is_empty());
+
+        let _ = fs::remove_dir_all(root);
+    }
+
+    #[test]
+    fn reports_missing_electron_dist_as_warning() {
+        let root = unique_temp_dir();
+        write_package_json(&root);
+
+        let args = StartArgs {
+            cwd: root.clone(),
+            dry_run: true,
+            json: true,
+            electron_args: Vec::new(),
+        };
+        let snapshot = crate::project::inspect(&root).expect("project should inspect");
+        let report = build_report(snapshot, &args).expect("report should build");
+
+        assert!(report.electron_path.is_none());
+        assert!(report.warnings.contains(
+            &"Electron executable was not found under node_modules/electron/dist.".to_string()
+        ));
+
+        let _ = fs::remove_dir_all(root);
+    }
+
+    fn write_package_json(root: &Path) {
+        fs::write(
+            root.join("package.json"),
+            r#"{"name":"starter","version":"0.1.0","main":"src/main.js","devDependencies":{"electron":"30.0.0"}}"#,
+        )
+        .expect("package.json should be written");
+    }
+
+    fn write_fake_electron(root: &Path) {
+        let path = electron_executable_candidates(&root.join("node_modules/electron/dist"))
+            .into_iter()
+            .next()
+            .expect("candidate should exist");
+        fs::create_dir_all(path.parent().expect("candidate should have parent"))
+            .expect("electron parent should be created");
+        fs::write(path, "").expect("electron executable should be written");
+    }
+
+    fn unique_temp_dir() -> 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-start-test-{}-{nanos}",
+            std::process::id()
+        ));
+        fs::create_dir_all(&path).expect("temp dir should be created");
+        path
+    }
+}

package/src/main.rs

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

package/templates/minimal/gitignore

@@ -0,0 +1,5 @@
+node_modules
+out
+dist
+.DS_Store
+*.log

package/templates/minimal/src/index.html

@@ -0,0 +1,82 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>electron-cli</title>
+    <style>
+      :root {
+        color-scheme: light dark;
+        font-family:
+          Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont,
+          "Segoe UI", sans-serif;
+        background: #f5f5f2;
+        color: #1d2328;
+      }
+
+      body {
+        margin: 0;
+        min-height: 100vh;
+        display: grid;
+        place-items: center;
+      }
+
+      main {
+        width: min(720px, calc(100vw - 48px));
+      }
+
+      h1 {
+        margin: 0 0 12px;
+        font-size: 5rem;
+        line-height: 0.92;
+        letter-spacing: 0;
+      }
+
+      p {
+        max-width: 48rem;
+        margin: 0 0 24px;
+        font-size: 1.05rem;
+        line-height: 1.6;
+      }
+
+      dl {
+        display: grid;
+        grid-template-columns: max-content 1fr;
+        gap: 8px 16px;
+        margin: 0;
+        padding-top: 20px;
+        border-top: 1px solid color-mix(in srgb, currentColor 24%, transparent);
+      }
+
+      dt {
+        font-weight: 700;
+      }
+
+      dd {
+        margin: 0;
+      }
+
+      @media (max-width: 640px) {
+        h1 {
+          font-size: 3rem;
+        }
+      }
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1>electron-cli</h1>
+      <p>
+        This app was generated by the experimental Rust-native electron-cli
+        template.
+      </p>
+      <dl>
+        <dt>Runtime</dt>
+        <dd id="runtime">Loading...</dd>
+        <dt>Platform</dt>
+        <dd id="platform">Loading...</dd>
+      </dl>
+    </main>
+    <script src="./renderer.js"></script>
+  </body>
+</html>

package/templates/minimal/src/main.js

@@ -0,0 +1,33 @@
+const { app, BrowserWindow } = require("electron");
+const path = require("node:path");
+
+function createWindow() {
+  const window = new BrowserWindow({
+    width: 960,
+    height: 640,
+    minWidth: 640,
+    minHeight: 420,
+    title: "electron-cli",
+    webPreferences: {
+      preload: path.join(__dirname, "preload.js"),
+    },
+  });
+
+  window.loadFile(path.join(__dirname, "index.html"));
+}
+
+app.whenReady().then(() => {
+  createWindow();
+
+  app.on("activate", () => {
+    if (BrowserWindow.getAllWindows().length === 0) {
+      createWindow();
+    }
+  });
+});
+
+app.on("window-all-closed", () => {
+  if (process.platform !== "darwin") {
+    app.quit();
+  }
+});

package/templates/minimal/src/preload.js

@@ -0,0 +1,6 @@
+const { contextBridge } = require("electron");
+
+contextBridge.exposeInMainWorld("electronCli", {
+  platform: process.platform,
+  versions: process.versions,
+});

package/templates/minimal/src/renderer.js

@@ -0,0 +1,5 @@
+const runtime = document.querySelector("#runtime");
+const platform = document.querySelector("#platform");
+
+runtime.textContent = `Electron ${window.electronCli.versions.electron}`;
+platform.textContent = window.electronCli.platform;