solforge 0.2.10 → 0.2.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "solforge",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "module": "index.ts",
   "type": "module",
   "private": false,
@@ -13,10 +13,10 @@
     "url": "https://github.com/nitishxyz/solforge/issues"
   },
   "bin": {
-    "solforge": "cli.cjs"
+    "solforge": "start.cjs"
   },
   "files": [
-    "cli.cjs",
+    "start.cjs",
     "scripts",
     "src",
     "server",
@@ -37,8 +37,7 @@
     "build:gui": "bun build src/gui/src/main.tsx --outdir src/gui/public/build --target=browser --minify",
     "cli": "bun src/cli/main.ts",
     "lint": "biome check",
-    "postinstall": "node scripts/postinstall.cjs || true",
-    "prepack": "chmod +x cli.cjs || true"
+    "prepack": "chmod +x start.cjs || true"
   },
   "devDependencies": {
     "@biomejs/biome": "2.2.4",

package/src/cli/main.ts

@@ -1,7 +1,13 @@
 // Minimal, fast CLI router with @clack/prompts for UX
 import * as p from "@clack/prompts";
-// CLI version string; keep in sync with package.json if possible
-const VERSION = "0.2.4";
+import { readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkgPath = join(__dirname, "../../package.json");
+const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+const VERSION = pkg.version;
 
 // Robust arg parsing for both bun script and compiled binary
 const known = new Set([

package/start.cjs

@@ -0,0 +1,277 @@
+#!/usr/bin/env node
+// SolForge CLI bootstrapper
+// - Checks if solforge binary exists in PATH (preinstalled/global)
+// - Downloads and installs to ~/.local/bin if not found
+// - Falls back to Bun-based TS entry if available
+
+const fs = require("node:fs");
+const path = require("node:path");
+const https = require("node:https");
+const os = require("node:os");
+const { spawn, spawnSync } = require("node:child_process");
+
+function pkg() {
+	// Resolve package.json next to this file regardless of install location
+	const p = path.join(__dirname, "package.json");
+	try {
+		return require(p);
+	} catch {
+		return { version: "" };
+	}
+}
+
+function isInWorkspace() {
+	return (
+		fs.existsSync(path.join(__dirname, "src")) &&
+		fs.existsSync(path.join(__dirname, "package.json"))
+	);
+}
+
+function findBinaryInPath() {
+	const pathDirs = (process.env.PATH || "").split(path.delimiter);
+	const ext = process.platform === "win32" ? ".exe" : "";
+	const binName = "solforge" + ext;
+
+	for (const dir of pathDirs) {
+		const binPath = path.join(dir, binName);
+		if (fs.existsSync(binPath)) {
+			try {
+				const stat = fs.statSync(binPath);
+				if (stat.isFile() && binPath !== __filename) {
+					const result = spawnSync("file", [binPath], { encoding: "utf8" });
+					if (!result.stdout || !result.stdout.includes("script text")) {
+						return binPath;
+					}
+				}
+			} catch (err) {}
+		}
+	}
+	return null;
+}
+
+function assetName() {
+	const p = process.platform;
+	const a = process.arch;
+	if (p === "darwin" && a === "arm64") return "solforge-darwin-arm64";
+	if (p === "darwin" && a === "x64") return "solforge-darwin-x64";
+	if (p === "linux" && a === "x64") return "solforge-linux-x64";
+	if (p === "linux" && a === "arm64") return "solforge-linux-arm64";
+	if (p === "win32" && a === "x64") return "solforge-windows-x64.exe";
+	return null;
+}
+
+function downloadWithProgress(url, dest) {
+	return new Promise((resolve, reject) => {
+		const file = fs.createWriteStream(dest);
+		let totalBytes = 0;
+		let downloadedBytes = 0;
+
+		function handleRedirect(response) {
+			if (
+				response.statusCode >= 300 &&
+				response.statusCode < 400 &&
+				response.headers.location
+			) {
+				https.get(response.headers.location, handleRedirect);
+			} else if (response.statusCode === 200) {
+				totalBytes = Number.parseInt(
+					response.headers["content-length"] || "0",
+					10
+				);
+
+				response.on("data", (chunk) => {
+					downloadedBytes += chunk.length;
+					if (totalBytes > 0) {
+						const percent = ((downloadedBytes / totalBytes) * 100).toFixed(1);
+						const downloadedMB = (downloadedBytes / 1024 / 1024).toFixed(1);
+						const totalMB = (totalBytes / 1024 / 1024).toFixed(1);
+						process.stdout.write(
+							`\rDownloading: ${percent}% (${downloadedMB}MB / ${totalMB}MB)`
+						);
+					}
+				});
+
+				response.pipe(file);
+				file.on("finish", () => {
+					file.close();
+					process.stdout.write("\n");
+					resolve();
+				});
+			} else {
+				reject(new Error(`Download failed: ${response.statusCode}`));
+			}
+		}
+
+		https.get(url, handleRedirect).on("error", (err) => {
+			file.close();
+			reject(err);
+		});
+	});
+}
+
+function updateShellProfile(userBin) {
+	if (process.platform === "win32") return;
+
+	const shell = process.env.SHELL || "";
+	let configFile;
+	let shellType;
+
+	if (shell.includes("zsh")) {
+		configFile = path.resolve(os.homedir(), ".zshrc");
+		shellType = "zsh";
+	} else if (shell.includes("bash")) {
+		configFile = path.resolve(os.homedir(), ".bashrc");
+		shellType = "bash";
+	} else {
+		configFile = path.resolve(os.homedir(), ".profile");
+		shellType = "shell";
+	}
+
+	const pathExport = 'export PATH="$HOME/.local/bin:$PATH"';
+
+	try {
+		let fileContent = "";
+		if (fs.existsSync(configFile)) {
+			fileContent = fs.readFileSync(configFile, "utf8");
+		}
+
+		if (fileContent.includes(".local/bin")) {
+			console.log(`✓ PATH already configured in ${configFile}`);
+			return;
+		}
+
+		fs.appendFileSync(configFile, `\n${pathExport}\n`);
+		console.log(`✓ Added ${userBin} to PATH in ${configFile}`);
+		console.log(`✓ Restart your ${shellType} or run: source ${configFile}`);
+	} catch (error) {
+		console.log(`⚠️  Could not automatically update ${configFile}`);
+	}
+}
+
+async function install() {
+	try {
+		const asset = assetName();
+		if (!asset) {
+			throw new Error(`Unsupported platform: ${process.platform}-${process.arch}`);
+		}
+
+		const { version, repository } = pkg();
+		const repo =
+			process.env.SOLFORGE_REPO ||
+			(repository &&
+				(typeof repository === "string"
+					? repository.replace(/^github:/, "")
+					: repository.url &&
+						(repository.url.match(/github\.com[:/](.+?)\.git$/) || [])[1])) ||
+			"nitishxyz/solforge";
+
+		const url = `https://github.com/${repo}/releases/latest/download/${asset}`;
+
+		console.log(`Installing solforge (${process.platform}/${process.arch})...`);
+
+		const userBin = path.resolve(os.homedir(), ".local", "bin");
+		fs.mkdirSync(userBin, { recursive: true });
+		const ext = process.platform === "win32" ? ".exe" : "";
+		const binPath = path.resolve(userBin, `solforge${ext}`);
+
+		await downloadWithProgress(url, binPath);
+
+		fs.chmodSync(binPath, 0o755);
+
+		const result = spawnSync(binPath, ["--version"], { encoding: "utf8" });
+		if (result.status === 0) {
+			console.log("\n✓ solforge installed successfully!");
+			console.log(`Version: ${result.stdout.trim()}`);
+			console.log(`Location: ${binPath}`);
+
+			const pathDirs = (process.env.PATH || "").split(path.delimiter);
+			if (!pathDirs.includes(userBin)) {
+				updateShellProfile(userBin);
+				console.log(`\n⚠️  Add ${userBin} to your PATH:`);
+				console.log(
+					`   echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc`
+				);
+				console.log(
+					`   Or for zsh: echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.zshrc`
+				);
+			} else {
+				console.log(`✓ ${userBin} already in PATH`);
+			}
+		} else {
+			console.log(`\n✓ Installed to ${binPath}`);
+		}
+
+		console.log("\nRun: solforge --help");
+		return binPath;
+	} catch (error) {
+		console.error("Failed to install solforge CLI:", error.message);
+		console.error("\nPlease try installing manually:");
+		console.error("  curl -fsSL https://sh.solforge.sh | sh");
+		process.exit(1);
+	}
+}
+
+function run(cmd, args) {
+	return new Promise((resolve) => {
+		const child = spawn(cmd, args, { stdio: "inherit" });
+		child.on("exit", (code) => resolve(typeof code === "number" ? code : 0));
+	});
+}
+
+(async () => {
+	// Fast path for --version/--help without booting the app
+	const args = process.argv.slice(2);
+	if (
+		args.includes("-v") ||
+		args.includes("--version") ||
+		args[0] === "version"
+	) {
+		console.log(pkg().version || "");
+		process.exit(0);
+	}
+	if (args.includes("-h") || args.includes("--help") || args[0] === "help") {
+		console.log(`
+solforge <command>
+
+Commands:
+  (no command)        Run setup then start RPC & WS servers
+  rpc start           Start RPC & WS servers
+  start               Alias for 'rpc start'
+  config init         Create sf.config.json in CWD
+  config get <key>    Read a config value (dot path)
+  config set <k> <v>  Set a config value
+  airdrop --to <pubkey> --sol <amount>  Airdrop SOL via RPC faucet
+  mint                 Interactive: pick mint, receiver, amount
+  token clone <mint>  Clone SPL token mint + accounts
+  program clone <programId>              Clone program code (and optionally accounts)
+  program accounts clone <programId>     Clone accounts owned by program
+
+Options:
+  -h, --help          Show help
+  -v, --version       Show version
+  --network           Bind servers to 0.0.0.0 (LAN access)
+  -y, --ci            Non-interactive; auto-accept prompts (use existing config)
+`);
+		process.exit(0);
+	}
+
+	if (isInWorkspace()) {
+		const bun = process.env.SOLFORGE_BUN || "bun";
+		const entry = path.join(__dirname, "src", "cli", "main.ts");
+		const code = await run(bun, [entry, ...process.argv.slice(2)]);
+		process.exit(code);
+	}
+
+	const pathBinary = findBinaryInPath();
+	if (pathBinary) {
+		const code = await run(pathBinary, process.argv.slice(2));
+		process.exit(code);
+	}
+
+	const installedPath = await install();
+
+	if (process.argv.length > 2) {
+		const code = await run(installedPath, process.argv.slice(2));
+		process.exit(code);
+	}
+})();

package/cli.cjs

@@ -1,159 +0,0 @@
-#!/usr/bin/env node
-// SolForge CLI bootstrapper
-// - Prefers a prebuilt vendor binary (downloaded via postinstall or on first run)
-// - Falls back to Bun-based TS entry if available
-
-const fs = require("node:fs");
-const path = require("node:path");
-const https = require("node:https");
-const { spawn } = require("node:child_process");
-
-function pkg() {
-	// Resolve package.json next to this file regardless of install location
-	const p = path.join(__dirname, "package.json");
-	try {
-		return require(p);
-	} catch {
-		return { version: "" };
-	}
-}
-
-function assetName() {
-	const p = process.platform;
-	const a = process.arch;
-	if (p === "darwin" && a === "arm64") return "solforge-darwin-arm64";
-	if (p === "darwin" && a === "x64") return "solforge-darwin-x64";
-	if (p === "linux" && a === "x64") return "solforge-linux-x64";
-	if (p === "linux" && a === "arm64") return "solforge-linux-arm64";
-	if (p === "win32" && a === "x64") return "solforge-windows-x64.exe";
-	return null;
-}
-
-function vendorPath() {
-	const name = assetName();
-	if (!name) return null;
-	return path.join(__dirname, "vendor", name);
-}
-
-function download(url, outPath) {
-	return new Promise((resolve, reject) => {
-		const req = https.get(url, (res) => {
-			if (
-				[301, 302, 307, 308].includes(res.statusCode) &&
-				res.headers.location
-			) {
-				return resolve(download(res.headers.location, outPath));
-			}
-			if (res.statusCode !== 200) {
-				return reject(new Error(`HTTP ${res.statusCode}`));
-			}
-			const file = fs.createWriteStream(outPath, {
-				mode: process.platform === "win32" ? undefined : 0o755,
-			});
-			res.pipe(file);
-			file.on("finish", () => file.close(() => resolve()));
-			file.on("error", reject);
-		});
-		req.on("error", reject);
-	});
-}
-
-async function ensureBinary() {
-	const vp = vendorPath();
-	if (!vp) return null;
-	if (fs.existsSync(vp)) return vp;
-
-	// Respect opt-out
-	if (
-		String(process.env.SOLFORGE_SKIP_DOWNLOAD || "").toLowerCase() === "true"
-	) {
-		return null;
-	}
-
-	const { version, repository } = pkg();
-	const repo =
-		process.env.SOLFORGE_REPO ||
-		(repository &&
-			(typeof repository === "string"
-				? repository.replace(/^github:/, "")
-				: repository.url &&
-					(repository.url.match(/github\.com[:/](.+?)\.git$/) || [])[1])) ||
-		"nitishxyz/solforge";
-	if (!version) return null;
-	const asset = path.basename(vp);
-	const url = `https://github.com/${repo}/releases/download/v${version}/${asset}`;
-
-	try {
-		fs.mkdirSync(path.dirname(vp), { recursive: true });
-		await download(url, vp);
-		if (process.platform !== "win32") {
-			try {
-				fs.chmodSync(vp, 0o755);
-			} catch {}
-		}
-		return fs.existsSync(vp) ? vp : null;
-	} catch {
-		return null;
-	}
-}
-
-function run(cmd, args) {
-	return new Promise((resolve) => {
-		const child = spawn(cmd, args, { stdio: "inherit" });
-		child.on("exit", (code) => resolve(typeof code === "number" ? code : 0));
-	});
-}
-
-(async () => {
-	// Fast path for --version/--help without booting the app
-	const args = process.argv.slice(2);
-	if (
-		args.includes("-v") ||
-		args.includes("--version") ||
-		args[0] === "version"
-	) {
-		console.log(pkg().version || "");
-		process.exit(0);
-	}
-	if (args.includes("-h") || args.includes("--help") || args[0] === "help") {
-		console.log(`
-solforge <command>
-
-Commands:
-  (no command)        Run setup then start RPC & WS servers
-  rpc start           Start RPC & WS servers
-  start               Alias for 'rpc start'
-  config init         Create sf.config.json in CWD
-  config get <key>    Read a config value (dot path)
-  config set <k> <v>  Set a config value
-  airdrop --to <pubkey> --sol <amount>  Airdrop SOL via RPC faucet
-  mint                 Interactive: pick mint, receiver, amount
-  token clone <mint>  Clone SPL token mint + accounts
-  program clone <programId>              Clone program code (and optionally accounts)
-  program accounts clone <programId>     Clone accounts owned by program
-
-Options:
-  -h, --help          Show help
-  -v, --version       Show version
-  --network           Bind servers to 0.0.0.0 (LAN access)
-  -y, --ci            Non-interactive; auto-accept prompts (use existing config)
-`);
-		process.exit(0);
-	}
-
-	const vp = await ensureBinary();
-	if (vp) {
-		const code = await run(vp, process.argv.slice(2));
-		process.exit(code);
-	}
-	// Fallback: try to run TS entry via Bun
-	const bun = process.env.SOLFORGE_BUN || "bun";
-	const entry = path.join(__dirname, "src", "cli", "main.ts");
-	const code = await run(bun, [entry, ...process.argv.slice(2)]);
-	if (code !== 0) {
-		console.error(
-			"solforge: failed to run binary and Bun fallback. Install Bun or ensure a release asset exists.",
-		);
-	}
-	process.exit(code);
-})();

package/scripts/postinstall.cjs

@@ -1,118 +0,0 @@
-#!/usr/bin/env node
-/*
-  SolForge postinstall: fetch the platform-specific prebuilt binary from GitHub Releases.
-  - Skips if SOLFORGE_SKIP_DOWNLOAD=true
-  - Falls back silently on errors (CLI will still work via Bun if installed)
-*/
-const fs = require("node:fs");
-const path = require("node:path");
-const https = require("node:https");
-
-function log(msg) {
-	console.log(`[solforge] ${msg}`);
-}
-function warn(msg) {
-	console.warn(`[solforge] ${msg}`);
-}
-
-if (String(process.env.SOLFORGE_SKIP_DOWNLOAD || "").toLowerCase() === "true") {
-	log("Skipping binary download due to SOLFORGE_SKIP_DOWNLOAD=true");
-	process.exit(0);
-}
-
-function assetName() {
-	const p = process.platform;
-	const a = process.arch;
-	if (p === "darwin" && a === "arm64") return "solforge-darwin-arm64";
-	if (p === "darwin" && a === "x64") return "solforge-darwin-x64";
-	if (p === "linux" && a === "x64") return "solforge-linux-x64";
-	if (p === "linux" && a === "arm64") return "solforge-linux-arm64";
-	if (p === "win32" && a === "x64") return "solforge-windows-x64.exe";
-	return null;
-}
-
-function getRepo() {
-	try {
-		const pkg = require(path.join(__dirname, "..", "package.json"));
-		if (pkg.repository) {
-			if (typeof pkg.repository === "string")
-				return pkg.repository.replace(/^github:/, "");
-			if (pkg.repository.url) {
-				const m = pkg.repository.url.match(/github\.com[:/](.+?)\.git$/);
-				if (m) return m[1];
-			}
-		}
-	} catch {}
-	return process.env.SOLFORGE_REPO || "nitishxyz/solforge";
-}
-
-function getVersion() {
-	try {
-		const pkg = require(path.join(__dirname, "..", "package.json"));
-		return pkg.version;
-	} catch {
-		return process.env.npm_package_version || "";
-	}
-}
-
-const name = assetName();
-if (!name) {
-	warn(`No prebuilt binary for ${process.platform}/${process.arch}; skipping`);
-	process.exit(0);
-}
-
-const version = getVersion();
-if (!version) {
-	warn("Unable to determine package version; skipping binary download");
-	process.exit(0);
-}
-
-const repo = getRepo();
-const url = `https://github.com/${repo}/releases/download/v${version}/${name}`;
-
-const vendorDir = path.join(__dirname, "..", "vendor");
-const outPath = path.join(vendorDir, name);
-
-if (fs.existsSync(outPath)) {
-	log(`Binary already present at vendor/${name}`);
-	process.exit(0);
-}
-
-fs.mkdirSync(vendorDir, { recursive: true });
-
-function download(to, from, cb, redirects = 0) {
-	const req = https.get(from, (res) => {
-		if (
-			[301, 302, 307, 308].includes(res.statusCode) &&
-			res.headers.location &&
-			redirects < 5
-		) {
-			return download(to, res.headers.location, cb, redirects + 1);
-		}
-		if (res.statusCode !== 200) {
-			return cb(new Error(`HTTP ${res.statusCode} for ${from}`));
-		}
-		const file = fs.createWriteStream(to, { mode: 0o755 });
-		res.pipe(file);
-		file.on("finish", () => file.close(cb));
-	});
-	req.on("error", (err) => cb(err));
-}
-
-log(`Fetching ${name} for v${version}...`);
-download(outPath, url, (err) => {
-	if (err) {
-		warn(`Could not download prebuilt binary: ${err.message}`);
-		warn("CLI will fall back to running via Bun if available.");
-		try {
-			fs.unlinkSync(outPath);
-		} catch {}
-		process.exit(0);
-	}
-	if (process.platform !== "win32") {
-		try {
-			fs.chmodSync(outPath, 0o755);
-		} catch {}
-	}
-	log(`Installed vendor/${name}`);
-});