electrobun 1.18.4-beta.18 → 1.18.4-beta.19

package/README.md

@@ -25,6 +25,15 @@ curl -fsSL https://hutch.blackboard.sh/hutch/install.sh | sh
 hutch electrobun init
 ```
 
+Or bootstrap the same interactive initializer from npm or Bun. This installs
+Hutch when it is not already available:
+
+```bash
+npx electrobun init
+# or
+bunx electrobun init
+```
+
 Don't miss our:
 - self-extracting bundles that use Zstandard compression for compact distributables
 - a Zig-optimized BSDIFF implementation that can produce kilobyte-scale updates

package/bin/electrobun.cjs

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+"use strict";
+
+const { existsSync, mkdtempSync, rmSync, writeFileSync } = require("node:fs");
+const { get } = require("node:https");
+const { homedir, tmpdir } = require("node:os");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+
+const packageVersion = require("../package.json").version;
+const installerBaseUrl = "https://hutch.blackboard.sh/hutch";
+const maxInstallerBytes = 1024 * 1024;
+
+function normalizeChannel(value) {
+	if (value === "stable") return "production";
+	if (value === "production" || value === "canary") return value;
+	return null;
+}
+
+function channelForVersion(version, environment) {
+	for (const key of ["ELECTROBUN_HUTCH_CHANNEL", "HUTCH_ACTIVE_CHANNEL"]) {
+		const selected = normalizeChannel(environment[key]);
+		if (selected) return selected;
+	}
+	return version.includes("-") ? "canary" : "production";
+}
+
+function hutchBinaryPath(channel, environment, platform, userHome) {
+	if (environment.ELECTROBUN_HUTCH_BINARY) {
+		return environment.ELECTROBUN_HUTCH_BINARY;
+	}
+	const dashHome = environment.DASH_HOME || path.join(userHome, ".dash");
+	const command = channel === "canary" ? "hutch-canary" : "hutch";
+	const pathApi = platform === "win32" ? path.win32 : path.posix;
+	return pathApi.join(dashHome, "bin", `${command}${platform === "win32" ? ".exe" : ""}`);
+}
+
+function download(url, redirects = 0) {
+	if (redirects > 5) return Promise.reject(new Error("too many installer redirects"));
+	return new Promise((resolve, reject) => {
+		const request = get(url, (response) => {
+			if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+				response.resume();
+				resolve(download(new URL(response.headers.location, url).href, redirects + 1));
+				return;
+			}
+			if (response.statusCode !== 200) {
+				response.resume();
+				reject(new Error(`installer download returned HTTP ${response.statusCode}`));
+				return;
+			}
+
+			const chunks = [];
+			let size = 0;
+			response.on("data", (chunk) => {
+				size += chunk.length;
+				if (size > maxInstallerBytes) {
+					request.destroy(new Error("installer download exceeded 1 MiB"));
+					return;
+				}
+				chunks.push(chunk);
+			});
+			response.on("end", () => resolve(Buffer.concat(chunks)));
+		});
+		request.on("error", reject);
+	});
+}
+
+function checkedSpawn(command, args, options) {
+	const result = spawnSync(command, args, options);
+	if (result.error) throw result.error;
+	if (result.status !== 0) {
+		throw new Error(`${command} exited with status ${result.status ?? "unknown"}`);
+	}
+}
+
+async function installHutch({ channel, environment, platform }) {
+	const temporary = mkdtempSync(path.join(tmpdir(), "electrobun-hutch-"));
+	try {
+		if (platform === "win32") {
+			const installer = path.join(temporary, "install.ps1");
+			writeFileSync(installer, await download(`${installerBaseUrl}/install.ps1`));
+			checkedSpawn(
+				"powershell.exe",
+				[
+					"-NoProfile",
+					"-NonInteractive",
+					"-ExecutionPolicy",
+					"Bypass",
+					"-File",
+					installer,
+					"-Channel",
+					channel,
+				],
+				{ env: environment, stdio: "inherit" },
+			);
+		} else {
+			const installer = path.join(temporary, "install.sh");
+			writeFileSync(installer, await download(`${installerBaseUrl}/install.sh`), {
+				mode: 0o700,
+			});
+			checkedSpawn("sh", [installer, "--channel", channel], {
+				env: environment,
+				stdio: "inherit",
+			});
+		}
+	} finally {
+		rmSync(temporary, { force: true, recursive: true });
+	}
+}
+
+function runHutch({ binary, args, environment }) {
+	const result = spawnSync(binary, ["electrobun", ...args], {
+		env: environment,
+		stdio: "inherit",
+	});
+	if (result.error) throw result.error;
+	if (result.status !== null) return result.status;
+	return result.signal === "SIGINT" ? 130 : result.signal === "SIGTERM" ? 143 : 1;
+}
+
+async function main(options = {}) {
+	const args = options.args || process.argv.slice(2);
+	if (args[0] !== "init") {
+		throw new Error(
+			"the npm entry point supports only `electrobun init`; use `hutch electrobun` for project commands",
+		);
+	}
+	const environment = options.environment || process.env;
+	const platform = options.platform || process.platform;
+	const version = options.version || packageVersion;
+	const userHome = options.userHome || homedir();
+	const fileExists = options.existsSync || existsSync;
+	const install = options.installHutch || installHutch;
+	const run = options.runHutch || runHutch;
+	const channel = channelForVersion(version, environment);
+	const binary = hutchBinaryPath(channel, environment, platform, userHome);
+
+	if (!fileExists(binary)) {
+		if (environment.ELECTROBUN_HUTCH_BINARY) {
+			throw new Error(`ELECTROBUN_HUTCH_BINARY does not exist: ${binary}`);
+		}
+		console.error(`Electrobun requires Hutch; installing the latest ${channel} release...`);
+		await install({ channel, environment, platform });
+	}
+	if (!fileExists(binary)) throw new Error(`Hutch was not installed at ${binary}`);
+	return run({ binary, args, environment });
+}
+
+if (require.main === module) {
+	main()
+		.then((status) => {
+			process.exitCode = status;
+		})
+		.catch((error) => {
+			console.error(`electrobun: ${error.message}`);
+			process.exitCode = 1;
+		});
+}
+
+module.exports = {
+	channelForVersion,
+	hutchBinaryPath,
+	main,
+};

package/dash.config.ts

@@ -1,4 +1,4 @@
-// @dash cli=0.5.0-canary.8 cottontail=0.2.3
+// @dash cli=0.5.0-canary.9 cottontail=0.2.3
 export default {
 	scripts: {
 		start: "hutch src/sdks/main/index.ts",
@@ -46,7 +46,7 @@ export default {
 		"test:deployment-target": "node scripts/run-cottontail-test.js scripts/verify-macho-deployment-target.test.ts",
 		"test:linux-abi": "node scripts/run-cottontail-test.js scripts/verify-linux-elf-abi.test.ts",
 		"test:linux-extractor": "node scripts/test-linux-adjacent-extractor.mjs",
-		"test:npm-bootstrap": "node scripts/run-cottontail-test.js bin/npm-bootstrap-retirement.test.ts",
+		"test:npm-bootstrap": "node scripts/run-cottontail-test.js bin/npm-bootstrap.test.ts",
 		"test:release-notes": "node scripts/release-notes-contract.test.mjs",
 		"test:spell-check": "node --test src/shared/spell-check.test.js",
 		"test:macos-spell-check": "scripts/test-macos-spell-check.sh",

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "electrobun",
-	"version": "1.18.4-beta.18",
+	"version": "1.18.4-beta.19",
 	"description": "Build ultra fast, tiny, and cross-platform desktop apps with Typescript.",
 	"license": "MIT",
 	"author": "Blackboard Technologies Inc.",
@@ -56,6 +56,9 @@
 		"type": "git",
 		"url": "git+https://github.com/blackboardsh/electrobun.git"
 	},
+	"bin": {
+		"electrobun": "./bin/electrobun.cjs"
+	},
 	"scripts": {
 		"build:local": "node scripts/build-local.js"
 	},