solforge 0.1.7 → 0.2.1

package/src/cli/commands/token-clone.ts

@@ -0,0 +1,113 @@
+import * as p from "@clack/prompts";
+import { readConfig, writeConfig } from "../../config";
+import { parseFlags } from "../utils/args";
+
+// Simplified token "clone": create an ATA locally with the requested amount.
+// Usage:
+//   solforge token clone <mint> --to <owner> --amount <baseUnits>
+//   solforge token clone <mint> --to <owner> --ui-amount <num> --decimals <d>
+export async function tokenCloneCommand(args: string[]) {
+	const { flags, rest } = parseFlags(args);
+	const mint = ((rest[0] as string) || (flags["mint"] as string) || "").trim();
+	if (!mint) {
+		p.log.error(
+			"Usage: solforge token clone <mint> [--amount <baseUnits> | --ui-amount <num>] [--endpoint URL]",
+		);
+		return;
+	}
+
+	const owner = flags["to"] as string | undefined; // optional; defaults to faucet on server
+	const configPath = flags["config"] as string | undefined;
+	const cfg = await readConfig(configPath);
+	const endpoint = (flags["endpoint"] as string) || cfg.clone.endpoint;
+	const url = `http://localhost:${cfg.server.rpcPort}`;
+	const s = p.spinner();
+	s.start("Cloning mint into LiteSVM...");
+	try {
+		// First, mirror the mint account so downstream reads work
+		const resMint = await fetch(url, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({
+				jsonrpc: "2.0",
+				id: 1,
+				method: "solforgeAdminCloneTokenMint",
+				params: [mint, { endpoint }],
+			}),
+		});
+		const jsonMint = await resMint.json();
+		if (jsonMint.error) {
+			const data = jsonMint.error.data
+				? `\nDetails: ${JSON.stringify(jsonMint.error.data)}`
+				: "";
+			throw new Error((jsonMint.error.message || "clone mint failed") + data);
+		}
+		// Record mint in config immediately after a successful clone
+		await recordTokenClone(configPath, mint);
+		// Try to adopt faucet as mint authority for local usage (do not fail the command if this step fails)
+		try {
+			s.message("Adopting faucet as authority...");
+			const resAdopt = await fetch(url, {
+				method: "POST",
+				headers: { "content-type": "application/json" },
+				body: JSON.stringify({
+					jsonrpc: "2.0",
+					id: 3,
+					method: "solforgeAdoptMintAuthority",
+					params: [mint],
+				}),
+			});
+			const jsonAdopt = await resAdopt.json();
+			if (jsonAdopt.error) {
+				p.log.warn(jsonAdopt.error.message || "adopt authority failed");
+				s.stop("Mint cloned (authority unchanged)");
+				console.log(
+					JSON.stringify({ mint: jsonMint.result, adopt: null }, null, 2),
+				);
+				return;
+			}
+			s.stop("Mint cloned and authority adopted");
+			console.log(
+				JSON.stringify(
+					{ mint: jsonMint.result, adopt: jsonAdopt.result },
+					null,
+					2,
+				),
+			);
+			return;
+		} catch (adoptErr: any) {
+			p.log.warn(
+				`Adopt authority failed: ${adoptErr?.message || String(adoptErr)}`,
+			);
+			s.stop("Mint cloned (authority unchanged)");
+			console.log(
+				JSON.stringify({ mint: jsonMint.result, adopt: null }, null, 2),
+			);
+			return;
+		}
+		return;
+	} catch (e) {
+		s.stop("Clone failed");
+		p.log.error(String(e));
+		p.log.info(
+			"Token clone mirrors an on-chain mint and requires network access to --endpoint. For an offline token, use 'solforge token create'.",
+		);
+	}
+}
+
+// intentionally no UI conversion here; clone mirrors the on-chain mint only
+
+async function recordTokenClone(configPath: string | undefined, mint: string) {
+	try {
+		const cfg = await readConfig(configPath);
+		const next = new Set(cfg.clone.tokens ?? []);
+		if (!next.has(mint)) {
+			next.add(mint);
+			cfg.clone.tokens = Array.from(next);
+			await writeConfig(cfg, configPath ?? "sf.config.json");
+			p.log.info(`Added ${mint} to clone tokens in config`);
+		}
+	} catch (error) {
+		console.warn(`[config] Failed to update clone tokens: ${String(error)}`);
+	}
+}

package/src/cli/commands/token-create.ts

@@ -0,0 +1,81 @@
+import * as p from "@clack/prompts";
+import { readConfig } from "../../config";
+import { parseFlags } from "../utils/args";
+
+// Create a new local SPL mint with given decimals and (optional) owner authority.
+// Also optionally create the owner's ATA with a starting balance (base units or UI amount).
+// Usage:
+//   solforge token create --decimals <d> --owner <pubkey> [--mint <pubkey>] [--amount <baseUnits> | --ui-amount <num>]
+export async function tokenCreateCommand(args: string[]) {
+	const { flags } = parseFlags(args);
+	const decimals = flags["decimals"] ? Number(flags["decimals"]) : NaN;
+	const owner = flags["owner"] as string | undefined;
+	const mint = flags["mint"] as string | undefined;
+	const amountBase = flags["amount"] as string | undefined;
+	const uiAmount = flags["ui-amount"] as string | undefined;
+
+	if (!isFinite(decimals)) {
+		p.log.error("--decimals is required (0-18)");
+		return;
+	}
+	if (!owner) {
+		p.log.error("--owner <pubkey> is required");
+		return;
+	}
+
+	const cfg = await readConfig();
+	const url = `http://localhost:${cfg.server.rpcPort}`;
+	const s = p.spinner();
+	s.start("Creating mint...");
+	try {
+		const res = await fetch(url, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify({
+				jsonrpc: "2.0",
+				id: 1,
+				method: "solforgeCreateMint",
+				params: [mint ?? null, Number(decimals), owner],
+			}),
+		});
+		const json = await res.json();
+		if (json.error) throw new Error(json.error.message || "create mint failed");
+		const createdMint = json.result.mint as string;
+
+		if (amountBase || uiAmount) {
+			s.message("Creating owner ATA with balance...");
+			const base =
+				amountBase ??
+				(uiAmount ? toBaseUnits(uiAmount, Number(decimals)) : undefined);
+			const res2 = await fetch(url, {
+				method: "POST",
+				headers: { "content-type": "application/json" },
+				body: JSON.stringify({
+					jsonrpc: "2.0",
+					id: 2,
+					method: "solforgeCreateTokenAccount",
+					params: [createdMint, owner, String(base)],
+				}),
+			});
+			const json2 = await res2.json();
+			if (json2.error)
+				throw new Error(json2.error.message || "create token account failed");
+			s.stop("Token created");
+			console.log(
+				JSON.stringify({ mint: json.result, account: json2.result }, null, 2),
+			);
+			return;
+		}
+		s.stop("Mint created");
+		console.log(JSON.stringify(json.result, null, 2));
+	} catch (e) {
+		s.stop("Create failed");
+		p.log.error(String(e));
+	}
+}
+
+function toBaseUnits(ui: string, decimals: number): string {
+	const [i, f = ""] = String(ui).split(".");
+	const frac = (f + "0".repeat(decimals)).slice(0, decimals);
+	return BigInt(i + (decimals ? frac : "")).toString();
+}

package/src/cli/main.ts

@@ -0,0 +1,130 @@
+// Minimal, fast CLI router with @clack/prompts for UX
+import * as p from "@clack/prompts";
+
+// Robust arg parsing for both bun script and compiled binary
+const known = new Set([
+  "help",
+  "-h",
+  "--help",
+  "rpc",
+  "start",
+  "config",
+  "airdrop",
+  "mint",
+  "token",
+  "program",
+]);
+const raw = Bun.argv.slice(1);
+const firstIdx = raw.findIndex((a) => known.has(String(a)));
+const argv = firstIdx >= 0 ? raw.slice(firstIdx) : [];
+
+async function main() {
+	const [cmd, sub, ...rest] = argv;
+
+	if (!cmd) {
+		const { runSolforge } = await import("./run-solforge");
+		await runSolforge();
+		return;
+	}
+
+	if (cmd === "help" || cmd === "-h" || cmd === "--help") {
+		printHelp();
+		return;
+	}
+
+	// Alias: solforge start -> solforge rpc start
+	if (cmd === "start") {
+		const { rpcStartCommand } = await import("./commands/rpc-start");
+		await rpcStartCommand(rest);
+		return;
+	}
+
+	switch (cmd) {
+		case "rpc": {
+			if (sub === "start") {
+				const { rpcStartCommand } = await import("./commands/rpc-start");
+				return rpcStartCommand(rest);
+			}
+			return unknownCommand([cmd, sub]);
+		}
+		case "config": {
+			const { configCommand } = await import("./commands/config");
+			return configCommand(sub, rest);
+		}
+		case "airdrop": {
+			const { airdropCommand } = await import("./commands/airdrop");
+			return airdropCommand(rest);
+		}
+		case "mint": {
+			const { mintCommand } = await import("./commands/mint");
+			return mintCommand(rest);
+		}
+		case "token": {
+			if (sub === "clone") {
+				const { tokenCloneCommand } = await import("./commands/token-clone");
+				return tokenCloneCommand(rest);
+			}
+			if (sub === "create") {
+				const { tokenCreateCommand } = await import("./commands/token-create");
+				return tokenCreateCommand(rest);
+			}
+			if (sub === "adopt-authority") {
+				const { tokenAdoptAuthorityCommand } = await import(
+					"./commands/token-adopt-authority"
+				);
+				return tokenAdoptAuthorityCommand(rest);
+			}
+			return unknownCommand([cmd, sub]);
+		}
+		case "program": {
+			if (sub === "clone") {
+				const { programCloneCommand } = await import(
+					"./commands/program-clone"
+				);
+				return programCloneCommand(rest);
+			}
+			if (sub === "load") {
+				const { programLoadCommand } = await import("./commands/program-load");
+				return programLoadCommand(rest);
+			}
+			if (sub === "accounts") {
+				const [_, __, ...tail] = argv.slice(2); // re-read to check deep subcommand
+				if (tail[0] === "clone") {
+					const { programAccountsCloneCommand } = await import(
+						"./commands/program-clone"
+					);
+					return programAccountsCloneCommand(tail.slice(1));
+				}
+			}
+			return unknownCommand([cmd, sub]);
+		}
+		default:
+			return unknownCommand([cmd, sub]);
+	}
+}
+
+function printHelp() {
+	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
+`);
+}
+
+async function unknownCommand(parts: (string | undefined)[]) {
+	p.log.error(`Unknown command: ${parts.filter(Boolean).join(" ")}`);
+	printHelp();
+}
+
+main();

package/src/cli/run-solforge.ts

@@ -0,0 +1,98 @@
+import * as p from "@clack/prompts";
+import {
+	defaultConfig,
+	readConfig,
+	type SolforgeConfig,
+	writeConfig,
+} from "../config";
+import { startRpcServers } from "../rpc/start";
+import { bootstrapEnvironment } from "./bootstrap";
+import { cancelSetup } from "./setup-utils";
+import { runSetupWizard } from "./setup-wizard";
+
+const CONFIG_PATH = "sf.config.json";
+
+export async function runSolforge() {
+	const config = await ensureConfig();
+	await startWithConfig(config);
+}
+
+async function ensureConfig(): Promise<SolforgeConfig> {
+	const exists = await Bun.file(CONFIG_PATH).exists();
+	if (!exists) {
+		p.intro("Solforge setup");
+		const config = await runSetupWizard();
+		await saveConfig(config);
+		p.outro("Configuration saved");
+		return config;
+	}
+
+	const current = await readConfig(CONFIG_PATH);
+	const reuse = await p.confirm({
+		message: `Use existing config at ${CONFIG_PATH}?`,
+		initialValue: true,
+	});
+	if (p.isCancel(reuse)) cancelSetup();
+
+	if (reuse) return current;
+
+	const updated = await runSetupWizard(current);
+	await saveConfig(updated);
+	return updated;
+}
+
+async function startWithConfig(config: SolforgeConfig) {
+	const host = String(process.env.RPC_HOST || "127.0.0.1");
+	const rpcPort = Number(config.server.rpcPort || defaultConfig.server.rpcPort);
+	const wsPort = Number(config.server.wsPort || rpcPort + 1);
+	const guiEnabled = config.gui?.enabled !== false;
+	const guiPort = Number(config.gui?.port ?? defaultConfig.gui.port);
+
+	const spinner = p.spinner();
+	const guiPart = guiEnabled ? `, GUI ${guiPort}` : "";
+	spinner.start(
+		`Starting RPC on ${host}:${rpcPort} (WS ${wsPort}${guiPart})...`,
+	);
+	try {
+		const started = startRpcServers({
+			rpcPort,
+			wsPort,
+			dbMode: config.server.db.mode,
+			dbPath: config.server.db.path,
+			host,
+			guiEnabled,
+			guiPort,
+		});
+		spinner.stop("RPC started");
+
+		await waitForRpc(`http://${host}:${started.rpcPort}`);
+		await bootstrapEnvironment(config, host, started.rpcPort);
+
+		p.log.success(
+			`Solforge ready ➜ HTTP http://${host}:${started.rpcPort} | WS ws://${host}:${started.wsPort}${
+				started.guiPort ? ` | GUI http://${host}:${started.guiPort}` : ""
+			}`,
+		);
+	} catch (error) {
+		spinner.stop("Failed to start RPC");
+		p.log.error(String(error));
+		process.exitCode = 1;
+	}
+}
+
+async function waitForRpc(url: string, timeoutMs = 10_000) {
+	const start = Date.now();
+	while (Date.now() - start < timeoutMs) {
+		try {
+			const res = await fetch(`${url}/health`);
+			if (res.ok) return;
+		} catch {}
+		await Bun.sleep(200);
+	}
+	throw new Error("RPC server did not become ready in time");
+}
+
+async function saveConfig(config: SolforgeConfig) {
+	await writeConfig(config, CONFIG_PATH);
+	p.log.success(`Updated ${CONFIG_PATH}`);
+}

package/src/cli/setup-utils.ts

@@ -0,0 +1,54 @@
+import * as p from "@clack/prompts";
+
+const CANCEL_MESSAGE = "Setup cancelled";
+
+export function cancelSetup(): never {
+	p.cancel(CANCEL_MESSAGE);
+	process.exit(0);
+}
+
+export function ensure<T>(value: T | symbol): T {
+	if (p.isCancel(value)) cancelSetup();
+	return value as T;
+}
+
+export function validatePort(value: string | number | undefined) {
+	const num = Number(value);
+	if (!Number.isInteger(num)) return "Port must be an integer";
+	if (num < 1 || num > 65535) return "Port must be between 1 and 65535";
+	return undefined;
+}
+
+export function validatePositiveNumber(value: string) {
+	const num = Number(value);
+	if (!Number.isFinite(num)) return "Enter a number";
+	if (num <= 0) return "Enter a positive number";
+	return undefined;
+}
+
+export function validatePubkey(value: string | undefined) {
+	if (!value) return "Value is required";
+	const trimmed = value.trim();
+	if (trimmed.length < 32 || trimmed.length > 44)
+		return "Expected base58 address";
+	return undefined;
+}
+
+export async function collectCustomEntries(label: string) {
+	const results: string[] = [];
+	while (true) {
+		const value = await p.text({
+			message: `Enter ${label} (leave blank to finish)`,
+		});
+		if (p.isCancel(value)) cancelSetup();
+		const trimmed = typeof value === "string" ? value.trim() : "";
+		if (!trimmed) break;
+		const error = validatePubkey(trimmed);
+		if (error) {
+			p.log.error(error);
+			continue;
+		}
+		results.push(trimmed);
+	}
+	return results;
+}