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

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "electron-cli"
-version = "0.3.0-alpha.2"
+version = "0.3.0-alpha.20"
 edition = "2021"
 description = "Experimental Rust CLI for Electron project diagnostics and workflow automation"
 license = "MIT"
@@ -8,7 +8,23 @@ repository = "https://github.com/Ikana/electron-cli"
 
 [dependencies]
 anyhow = "1.0"
+app-store-connect = "0.7"
+apple-codesign = { version = "0.29", default-features = false, features = ["notarize"] }
+apple-dmg = "0.5"
+cab = "0.6"
 camino = { version = "1.1", features = ["serde1"] }
 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"
+rpm = { version = "0.24", default-features = false, features = ["payload", "gzip-compression"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
+tar = "0.4"
+ureq = { version = "3.3", features = ["json"] }
+uuid = { version = "1", features = ["v5"] }
+zip = { version = "8.6.0", default-features = false, features = ["deflate-flate2-zlib-rs"] }

package/README.md

@@ -6,7 +6,7 @@ This is an independent learning project. It is not affiliated with Electron, Ele
 
 ## Status
 
-This repository is intentionally small and public-learning friendly. The first useful surface area is inspection and diagnostics, because those commands are valuable for humans and easy for agents to consume safely.
+This repository is intentionally small and public-learning friendly. The first useful surface area is inspection and diagnostics, because those commands are valuable for humans and easy for agents to consume safely. The next surface area is a Rust-owned version of the main Electron Forge flow: initialize, start, package, make, and eventually publish.
 
 Current commands:
 
@@ -14,22 +14,99 @@ Current commands:
 electron-cli inspect
 electron-cli doctor
 electron-cli plan
-electron-cli init my-app --dry-run
+electron-cli init my-app
+electron-cli start
+electron-cli package
+electron-cli make
+electron-cli publish
 electron-cli inspect --json
 electron-cli doctor --json
 electron-cli plan --json
 electron-cli init my-app --dry-run --json
+electron-cli start --dry-run --json
+electron-cli package --dry-run --json
+electron-cli make --dry-run --json
+electron-cli publish --dry-run --json
 ```
 
-Planned commands:
-
-```sh
-electron-cli package
-electron-cli dev
-electron-cli make
+The default `init` template is `minimal`, a built-in starter written by this project. Non-native template names are still passed to `create-electron-app` as an escape hatch while this project grows.
+
+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; it reads package metadata from `package.json`, JSON-shaped Forge config, and static Forge config files, and can apply experimental Rust-native ad-hoc macOS bundle signatures.
+- `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`.
+
+The package command recognizes macOS `packagerConfig.osxSign` and `packagerConfig.osxNotarize` options and reports the signing/notarization plan without serializing credential values. When `osxSign` is enabled on macOS and no certificate identity is configured, or the identity is `"-"`, `package` writes an experimental Rust-native ad-hoc signature for the generated `.app` bundle. When `osxSign.p12File` points at a `.p12`/PFX certificate export, `package` can sign the bundle with that certificate and can request a CMS timestamp token for notarization-compatible signatures. With p12 signing and App Store Connect API key auth, `package` can submit to Apple notarization, wait for the result, and staple the ticket natively in Rust. macOS keychain identity lookup and keychain/Apple ID notarization auth are not implemented yet.
+
+The DMG maker is currently a pure-Rust FAT32 image with the app bundle and an Applications entry. The MSI maker writes a compressed embedded CAB, Windows Installer database tables, and a Start Menu shortcut when the packaged executable is present. HFS+/APFS DMG layout customization, installer UI customization, Windows/Linux icon embedding, macOS keychain signing, and additional notarization auth modes are 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",
+      "osxSign": {
+        "p12File": "certs/developer-id.p12",
+        "p12PasswordEnv": "ELECTRON_CLI_P12_PASSWORD",
+        "timestamp": true,
+        "entitlements": "assets/entitlements.plist",
+        "hardenedRuntime": true
+      },
+      "osxNotarize": {
+        "appleApiKey": "certs/AuthKey_ABC123DEFG.p8",
+        "appleApiKeyId": "ABC123DEFG",
+        "appleApiIssuer": "00000000-0000-0000-0000-000000000000",
+        "maxWaitSeconds": 600
+      }
+    },
+    "makers": [
+      { "name": "@electron-forge/maker-zip" },
+      { "name": "@electron-forge/maker-dmg", "platforms": ["darwin"] },
+      { "name": "@electron-forge/maker-deb", "platforms": ["linux"] },
+      { "name": "@electron-forge/maker-rpm", "platforms": ["linux"] },
+      { "name": "@electron-forge/maker-wix", "platforms": ["win32"] }
+    ],
+    "publishers": [
+      { "name": "local", "config": { "to": "out/publish/local", "channel": "alpha" } },
+      {
+        "name": "@electron-forge/publisher-github",
+        "config": {
+          "repository": { "owner": "example", "name": "my-app" },
+          "draft": true,
+          "prerelease": true
+        }
+      }
+    ]
+  },
+  "config": {
+    "forge": {
+      "makers": [
+        { "name": "@electron-forge/maker-zip" }
+      ],
+      "publishers": [
+        { "name": "@electron-forge/publisher-github" }
+      ]
+    }
+  }
+}
 ```
 
-The planned workflow commands may start by wrapping Electron Forge or other established tools. Rust-native implementations can replace narrow pieces over time when there is a clear reason.
+Use `p12PasswordEnv`, `p12PasswordFile`, or `p12Password` for the `.p12` password; password values are not serialized in package reports. Set `osxSign.timestamp` to a timestamp server URL, `true` for Apple's default `http://timestamp.apple.com/ts01`, or `"none"` / `false` to disable timestamping. When `osxNotarize` is enabled with p12 signing, `electron-cli` automatically enables notarization-compatible signing and uses Apple's timestamp server unless timestamping is disabled explicitly. Rust-native notarization execution currently requires `appleApiKey`, `appleApiKeyId`, and `appleApiIssuer`; `appleApiKey` may point at the `.p8` file from App Store Connect or a unified API key JSON file. It waits up to `maxWaitSeconds` or 600 seconds by default and staples by default. Set `staple: false` to skip stapling, or set both `staple: false` and `wait: false` to submit without waiting. Set `identity` to a Developer ID certificate name when you want the plan to reflect Forge-style keychain release signing, but this project will report it as not executable until Rust-native keychain lookup exists. Use `identity: "-"` or omit `identity` for the current ad-hoc signing path.
+
+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
 
@@ -60,7 +137,17 @@ Or use Cargo directly:
 ```sh
 cargo run -- doctor
 cargo run -- inspect --json
-cargo run -- init my-app --dry-run
+cargo run -- init my-app
+cargo run -- start --dry-run
+cargo run -- package --dry-run
+cargo run -- make --dry-run
+cargo run -- make --target dmg --dry-run
+cargo run -- make --target deb --dry-run
+cargo run -- make --target rpm --dry-run
+cargo run -- make --target msi --platform win32 --dry-run
+cargo run -- publish --dry-run
+cargo run -- publish --publisher github --dry-run
+cargo run -- publish --publisher github --github-repo OWNER/REPO --github-tag v0.1.0
 ```
 
 ## Design Goals
@@ -68,7 +155,7 @@ cargo run -- init my-app --dry-run
 - Learn Rust through a real developer tool.
 - Make Electron project state easy to inspect.
 - Prefer structured output for agentic workflows.
-- Wrap proven ecosystem tools before replacing them.
+- Replace the main Forge-style app flow with narrow Rust-owned pieces.
 - Keep the project clearly independent and experimental.
 
 ## Non-Goals
@@ -81,7 +168,11 @@ cargo run -- init my-app --dry-run
 
 The inspection and planning commands support `--json` so agents and scripts can consume project state without scraping terminal output.
 `plan` is designed around that workflow: it recommends stable commands and reports missing project conventions as structured data.
-`init --dry-run --json` shows the exact create command before running any networked tooling.
+`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, app file, metadata, icon, and extra-resource copy plan.
+`make --dry-run --json` shows the package prerequisite and selected maker artifact path.
+`publish --dry-run --json` shows the make prerequisite plus either the local destination/manifest path or the GitHub release/upload plan. When multiple configured makers or publishers apply, the JSON output contains a `publishes` array.
 
 ```sh
 electron-cli plan --json

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electron-cli",
-  "version": "0.3.0-alpha.2",
+  "version": "0.3.0-alpha.20",
   "description": "Experimental Rust CLI for Electron project diagnostics and workflow automation",
   "license": "MIT",
   "repository": {
@@ -18,6 +18,7 @@
     "bin/electron-cli.js",
     "scripts",
     "src",
+    "templates",
     "tests",
     "Cargo.toml",
     "Cargo.lock",

package/src/cli.rs

@@ -18,12 +18,20 @@ pub struct Cli {
 pub enum Commands {
     /// Check whether the current project looks ready for Electron development.
     Doctor(CommandArgs),
-    /// Bootstrap a new Electron app through the Electron Forge create tooling.
+    /// Bootstrap a new Electron app.
     Init(InitArgs),
     /// Print a structured snapshot of the current JavaScript/Electron project.
     Inspect(CommandArgs),
+    /// Create distributable artifacts from a packaged Electron app.
+    Make(MakeArgs),
+    /// Create a local Electron application bundle without Electron Forge.
+    Package(PackageArgs),
     /// Recommend next commands and risks from the project snapshot.
     Plan(CommandArgs),
+    /// Publish made artifacts to a distribution target.
+    Publish(PublishArgs),
+    /// Launch the current Electron app without Electron Forge.
+    Start(StartArgs),
 }
 
 #[derive(Debug, Clone, Args)]
@@ -47,8 +55,8 @@ pub struct InitArgs {
     #[arg(long, default_value = ".", value_name = "PATH")]
     pub cwd: PathBuf,
 
-    /// Forge template to use.
-    #[arg(long, short = 't', default_value = "vite-typescript")]
+    /// Template to use. "minimal" is native; other names are passed to create-electron-app.
+    #[arg(long, short = 't', default_value = "minimal")]
     pub template: String,
 
     /// Package manager command strategy to use.
@@ -80,7 +88,183 @@ pub struct InitArgs {
     pub json: bool,
 }
 
-#[derive(Debug, Clone, Copy, ValueEnum)]
+#[derive(Debug, Clone, Args)]
+pub struct StartArgs {
+    /// Project directory to launch.
+    #[arg(long, default_value = ".", value_name = "PATH")]
+    pub cwd: PathBuf,
+
+    /// Print the launch command without starting Electron.
+    #[arg(long)]
+    pub dry_run: bool,
+
+    /// Emit machine-readable JSON.
+    #[arg(long)]
+    pub json: bool,
+
+    /// Extra arguments passed to Electron after `--`.
+    #[arg(last = true, value_name = "ELECTRON_ARG")]
+    pub electron_args: Vec<String>,
+}
+
+#[derive(Debug, Clone, Args)]
+pub struct PackageArgs {
+    /// Project directory to package.
+    #[arg(long, default_value = ".", value_name = "PATH")]
+    pub cwd: PathBuf,
+
+    /// Output directory for packaged app bundles.
+    #[arg(long, default_value = "out", value_name = "PATH")]
+    pub out_dir: PathBuf,
+
+    /// Override the packaged application name.
+    #[arg(long)]
+    pub name: Option<String>,
+
+    /// Target platform label. Defaults to the current platform.
+    #[arg(long)]
+    pub platform: Option<String>,
+
+    /// Target architecture label. Defaults to the current architecture.
+    #[arg(long)]
+    pub arch: Option<String>,
+
+    /// Overwrite an existing package output directory.
+    #[arg(long)]
+    pub force: bool,
+
+    /// Print the package plan without creating files.
+    #[arg(long)]
+    pub dry_run: bool,
+
+    /// Emit machine-readable JSON.
+    #[arg(long)]
+    pub json: bool,
+}
+
+#[derive(Debug, Clone, Args)]
+pub struct MakeArgs {
+    /// Project directory to make distributables for.
+    #[arg(long, default_value = ".", value_name = "PATH")]
+    pub cwd: PathBuf,
+
+    /// Output directory used for package and make artifacts.
+    #[arg(long, default_value = "out", value_name = "PATH")]
+    pub out_dir: PathBuf,
+
+    /// Override the application name.
+    #[arg(long)]
+    pub name: Option<String>,
+
+    /// Target platform label. Defaults to the current platform.
+    #[arg(long)]
+    pub platform: Option<String>,
+
+    /// Target architecture label. Defaults to the current architecture.
+    #[arg(long)]
+    pub arch: Option<String>,
+
+    /// Maker target to run. Overrides configured makers when provided.
+    #[arg(long, value_enum)]
+    pub target: Option<MakeTarget>,
+
+    /// Reuse an existing package output instead of running package first.
+    #[arg(long)]
+    pub skip_package: bool,
+
+    /// Overwrite existing package and make artifacts.
+    #[arg(long)]
+    pub force: bool,
+
+    /// Print the make plan without creating files.
+    #[arg(long)]
+    pub dry_run: bool,
+
+    /// Emit machine-readable JSON.
+    #[arg(long)]
+    pub json: bool,
+}
+
+#[derive(Debug, Clone, Args)]
+pub struct PublishArgs {
+    /// Project directory to publish from.
+    #[arg(long, default_value = ".", value_name = "PATH")]
+    pub cwd: PathBuf,
+
+    /// Output directory used for package, make, and publish artifacts.
+    #[arg(long, default_value = "out", value_name = "PATH")]
+    pub out_dir: PathBuf,
+
+    /// Override the application name.
+    #[arg(long)]
+    pub name: Option<String>,
+
+    /// Target platform label. Defaults to the current platform.
+    #[arg(long)]
+    pub platform: Option<String>,
+
+    /// Target architecture label. Defaults to the current architecture.
+    #[arg(long)]
+    pub arch: Option<String>,
+
+    /// Maker target whose artifact should be published. Overrides configured makers when provided.
+    #[arg(long, value_enum)]
+    pub target: Option<MakeTarget>,
+
+    /// Publisher target to use. Overrides configured publishers when provided.
+    #[arg(long, value_enum)]
+    pub publisher: Option<PublishTarget>,
+
+    /// Destination for local published artifacts.
+    #[arg(long, value_name = "PATH")]
+    pub to: Option<PathBuf>,
+
+    /// GitHub repository to publish to, in OWNER/REPO form.
+    #[arg(long, value_name = "OWNER/REPO")]
+    pub github_repo: Option<String>,
+
+    /// GitHub release tag. Defaults to v<package version>, then channel.
+    #[arg(long)]
+    pub github_tag: Option<String>,
+
+    /// GitHub release name. Defaults to the release tag.
+    #[arg(long)]
+    pub github_release_name: Option<String>,
+
+    /// Mark a newly created GitHub release as draft.
+    #[arg(long)]
+    pub github_draft: bool,
+
+    /// Mark a newly created GitHub release as prerelease.
+    #[arg(long)]
+    pub github_prerelease: bool,
+
+    /// GitHub API base URL, useful for GitHub Enterprise.
+    #[arg(long, value_name = "URL")]
+    pub github_api_url: Option<String>,
+
+    /// Release channel label written into the publish manifest.
+    #[arg(long)]
+    pub channel: Option<String>,
+
+    /// Reuse an existing make artifact instead of running package and make first.
+    #[arg(long)]
+    pub skip_make: bool,
+
+    /// Overwrite existing publish artifacts.
+    #[arg(long)]
+    pub force: bool,
+
+    /// Print the publish plan without creating files.
+    #[arg(long)]
+    pub dry_run: bool,
+
+    /// Emit machine-readable JSON.
+    #[arg(long)]
+    pub json: bool,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
 #[value(rename_all = "lower")]
 pub enum PackageManager {
     Npm,
@@ -99,3 +283,41 @@ impl PackageManager {
         }
     }
 }
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
+#[value(rename_all = "lower")]
+pub enum MakeTarget {
+    Deb,
+    Dmg,
+    Msi,
+    Rpm,
+    Zip,
+}
+
+impl MakeTarget {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            MakeTarget::Deb => "deb",
+            MakeTarget::Dmg => "dmg",
+            MakeTarget::Msi => "msi",
+            MakeTarget::Rpm => "rpm",
+            MakeTarget::Zip => "zip",
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
+#[value(rename_all = "lower")]
+pub enum PublishTarget {
+    Github,
+    Local,
+}
+
+impl PublishTarget {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            PublishTarget::Github => "github",
+            PublishTarget::Local => "local",
+        }
+    }
+}