electron-cli 0.3.0-alpha.0 → 0.3.0-alpha.10

package/Cargo.toml

@@ -1,14 +1,23 @@
 [package]
 name = "electron-cli"
-version = "0.3.0-alpha.0"
+version = "0.3.0-alpha.10"
 edition = "2021"
 description = "Experimental Rust CLI for Electron project diagnostics and workflow automation"
 license = "MIT"
-repository = "https://github.com/roderik/electron-cli"
+repository = "https://github.com/Ikana/electron-cli"
 
 [dependencies]
 anyhow = "1.0"
+apple-dmg = "0.5"
 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"
+md5 = "0.7"
+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"
+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,31 +14,72 @@ Current commands:
 electron-cli inspect
 electron-cli doctor
 electron-cli plan
+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 dev
-electron-cli init
-electron-cli package
-electron-cli make
+electron-cli publish --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.
+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.
+- `make`: runs `package` and writes a distributable under `out/make/<target>/<platform>/<arch>/`; ZIP works on all platforms, `--target dmg` writes a basic macOS disk image, and `--target deb` / `--target rpm` write Linux packages.
+- `publish`: runs `make` and publishes the distributable to a local directory with a manifest.
+
+Remote publishers such as GitHub Releases are not implemented yet. The DMG maker is currently a pure-Rust FAT32 image with the app bundle and an Applications entry; HFS+/APFS layout customization, Windows installers, Windows/Linux icon embedding, signing, and notarization 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"
+    }
+  }
+}
+```
+
+The package command also reads JSON-shaped `config.forge.packagerConfig` and `electronPackagerConfig` entries for the same fields. JavaScript Forge config files are not evaluated.
 
 ## Install
 
-During the experimental phase, the npm package runs from Rust source when a prebuilt binary is not available. You need Node.js and Rust installed.
+During the experimental phase, the npm package downloads a prebuilt binary from GitHub Releases when one is available. If a prebuilt binary is not available for your platform, it falls back to running from Rust source.
 
 ```sh
-npm install -g electron-cli
+npm install -g electron-cli@alpha
 electron-cli doctor
 ```
 
+To skip binary download and use the Cargo fallback:
+
+```sh
+ELECTRON_CLI_SKIP_DOWNLOAD=1 npm install -g electron-cli@alpha
+```
+
 For local development:
 
 ```sh
@@ -53,6 +94,14 @@ Or use Cargo directly:
 ```sh
 cargo run -- doctor
 cargo run -- inspect --json
+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 -- publish --dry-run
 ```
 
 ## Design Goals
@@ -60,7 +109,7 @@ cargo run -- inspect --json
 - 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
@@ -71,8 +120,13 @@ cargo run -- inspect --json
 
 ## JSON Output
 
-Both initial commands support `--json` so agents and scripts can consume project state without scraping terminal output.
+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 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, destination artifact, and manifest path.
 
 ```sh
 electron-cli plan --json

package/bin/electron-cli.js

@@ -7,11 +7,14 @@ const path = require("node:path");
 const root = path.resolve(__dirname, "..");
 const exe = process.platform === "win32" ? "electron-cli.exe" : "electron-cli";
 const args = process.argv.slice(2);
+const envBinary = process.env.ELECTRON_CLI_BINARY;
 
 const candidates = [
+  envBinary,
+  path.join(root, "bin", "downloaded", exe),
   path.join(root, "target", "release", exe),
   path.join(root, "target", "debug", exe),
-];
+].filter(Boolean);
 
 const binary = candidates.find((candidate) => fs.existsSync(candidate));
 
@@ -28,8 +31,8 @@ if (!fs.existsSync(manifest)) {
   process.exit(1);
 }
 
-console.error("electron-cli is experimental and needs Rust to run from npm source packages.");
-console.error("Building/running through cargo; install Rust from https://rustup.rs if this fails.");
+console.error("electron-cli could not find a prebuilt binary for this install.");
+console.error("Building/running through Cargo fallback; install Rust from https://rustup.rs if this fails.");
 
 exitWith(
   spawnSync(cargo, ["run", "--quiet", "--manifest-path", manifest, "--", ...args], {

package/package.json

@@ -1,22 +1,24 @@
 {
   "name": "electron-cli",
-  "version": "0.3.0-alpha.0",
+  "version": "0.3.0-alpha.10",
   "description": "Experimental Rust CLI for Electron project diagnostics and workflow automation",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/roderik/electron-cli.git"
+    "url": "git+https://github.com/Ikana/electron-cli.git"
   },
-  "homepage": "https://github.com/roderik/electron-cli#readme",
+  "homepage": "https://github.com/Ikana/electron-cli#readme",
   "bugs": {
-    "url": "https://github.com/roderik/electron-cli/issues"
+    "url": "https://github.com/Ikana/electron-cli/issues"
   },
   "bin": {
     "electron-cli": "bin/electron-cli.js"
   },
   "files": [
-    "bin",
+    "bin/electron-cli.js",
+    "scripts",
     "src",
+    "templates",
     "tests",
     "Cargo.toml",
     "Cargo.lock",
@@ -30,6 +32,7 @@
     "format": "cargo fmt",
     "lint": "cargo fmt --check && cargo clippy --all-targets -- -D warnings",
     "test": "cargo test",
+    "postinstall": "node scripts/install.js",
     "prepack": "cargo build --release"
   },
   "engines": {

package/scripts/install.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+
+const fs = require("node:fs");
+const https = require("node:https");
+const os = require("node:os");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+
+const root = path.resolve(__dirname, "..");
+const packageJson = require(path.join(root, "package.json"));
+const version = packageJson.version;
+const installDir = path.join(root, "bin", "downloaded");
+const exe = process.platform === "win32" ? "electron-cli.exe" : "electron-cli";
+const destination = path.join(installDir, exe);
+const target = resolveTarget();
+
+if (process.env.ELECTRON_CLI_SKIP_DOWNLOAD === "1") {
+  process.exit(0);
+}
+
+if (!target) {
+  warn(`No prebuilt binary is available for ${process.platform}/${process.arch}; Cargo fallback remains available.`);
+  process.exit(0);
+}
+
+const assetName = `electron-cli-v${version}-${target}${process.platform === "win32" ? ".exe" : ""}`;
+const baseUrl = process.env.ELECTRON_CLI_DOWNLOAD_BASE_URL || "https://github.com/Ikana/electron-cli/releases/download";
+const url = `${baseUrl}/v${version}/${assetName}`;
+const tempFile = path.join(os.tmpdir(), `${assetName}.${process.pid}.tmp`);
+
+main().catch((error) => {
+  warn(`Could not install prebuilt binary: ${error.message}`);
+
+  if (process.env.ELECTRON_CLI_STRICT_INSTALL === "1") {
+    process.exit(1);
+  }
+
+  warn("Install completed with Cargo fallback enabled.");
+});
+
+async function main() {
+  fs.mkdirSync(installDir, { recursive: true });
+
+  await download(url, tempFile);
+  fs.renameSync(tempFile, destination);
+
+  if (process.platform !== "win32") {
+    fs.chmodSync(destination, 0o755);
+  }
+
+  const result = spawnSync(destination, ["--version"], { encoding: "utf8" });
+  if (result.error || result.status !== 0) {
+    fs.rmSync(destination, { force: true });
+    throw new Error(result.error ? result.error.message : result.stderr.trim() || "downloaded binary failed verification");
+  }
+
+  console.error(`electron-cli installed prebuilt binary ${assetName}`);
+}
+
+function resolveTarget() {
+  const key = `${process.platform}-${process.arch}`;
+
+  return {
+    "darwin-arm64": "darwin-arm64",
+    "darwin-x64": "darwin-x64",
+    "linux-x64": "linux-x64",
+    "win32-x64": "win32-x64",
+  }[key];
+}
+
+function download(url, destinationPath) {
+  return new Promise((resolve, reject) => {
+    const request = https.get(url, (response) => {
+      if ([301, 302, 303, 307, 308].includes(response.statusCode)) {
+        response.resume();
+        download(response.headers.location, destinationPath).then(resolve, reject);
+        return;
+      }
+
+      if (response.statusCode !== 200) {
+        response.resume();
+        reject(new Error(`download failed with HTTP ${response.statusCode}: ${url}`));
+        return;
+      }
+
+      const file = fs.createWriteStream(destinationPath, { mode: 0o755 });
+      response.pipe(file);
+      file.on("finish", () => file.close(resolve));
+      file.on("error", reject);
+    });
+
+    request.on("error", reject);
+    request.setTimeout(30_000, () => {
+      request.destroy(new Error("download timed out"));
+    });
+  });
+}
+
+function warn(message) {
+  console.error(`electron-cli postinstall: ${message}`);
+}

package/src/cli.rs

@@ -1,6 +1,6 @@
 use std::path::PathBuf;
 
-use clap::{Args, Parser, Subcommand};
+use clap::{Args, Parser, Subcommand, ValueEnum};
 
 #[derive(Debug, Parser)]
 #[command(
@@ -18,10 +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.
+    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)]
@@ -34,3 +44,252 @@ pub struct CommandArgs {
     #[arg(long)]
     pub json: bool,
 }
+
+#[derive(Debug, Clone, Args)]
+pub struct InitArgs {
+    /// Directory to initialize. Defaults to the current directory.
+    #[arg(default_value = ".", value_name = "DIR")]
+    pub dir: PathBuf,
+
+    /// Directory to run the create command from.
+    #[arg(long, default_value = ".", value_name = "PATH")]
+    pub cwd: PathBuf,
+
+    /// 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.
+    #[arg(long, value_enum)]
+    pub package_manager: Option<PackageManager>,
+
+    /// Set a specific Electron version, or use latest/beta/nightly.
+    #[arg(long, value_name = "VERSION")]
+    pub electron_version: Option<String>,
+
+    /// Copy template CI files when the Forge template supports them.
+    #[arg(long)]
+    pub copy_ci_files: bool,
+
+    /// Overwrite an existing target directory.
+    #[arg(long)]
+    pub force: bool,
+
+    /// Skip initializing a git repository in the created project.
+    #[arg(long)]
+    pub skip_git: bool,
+
+    /// Print the command and metadata without creating files.
+    #[arg(long)]
+    pub dry_run: bool,
+
+    /// Emit machine-readable JSON.
+    #[arg(long)]
+    pub json: bool,
+}
+
+#[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.
+    #[arg(long, value_enum, default_value_t = MakeTarget::Zip)]
+    pub target: 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.
+    #[arg(long, value_enum, default_value_t = MakeTarget::Zip)]
+    pub target: MakeTarget,
+
+    /// Publisher target to use.
+    #[arg(long, value_enum, default_value_t = PublishTarget::Local)]
+    pub publisher: PublishTarget,
+
+    /// Destination for local published artifacts.
+    #[arg(long, default_value = "out/publish/local", value_name = "PATH")]
+    pub to: PathBuf,
+
+    /// Release channel label written into the publish manifest.
+    #[arg(long, default_value = "default")]
+    pub channel: 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,
+    Pnpm,
+    Yarn,
+    Bun,
+}
+
+impl PackageManager {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            PackageManager::Npm => "npm",
+            PackageManager::Pnpm => "pnpm",
+            PackageManager::Yarn => "yarn",
+            PackageManager::Bun => "bun",
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
+#[value(rename_all = "lower")]
+pub enum MakeTarget {
+    Deb,
+    Dmg,
+    Rpm,
+    Zip,
+}
+
+impl MakeTarget {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            MakeTarget::Deb => "deb",
+            MakeTarget::Dmg => "dmg",
+            MakeTarget::Rpm => "rpm",
+            MakeTarget::Zip => "zip",
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, ValueEnum)]
+#[value(rename_all = "lower")]
+pub enum PublishTarget {
+    Local,
+}
+
+impl PublishTarget {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            PublishTarget::Local => "local",
+        }
+    }
+}