solforge 0.2.12 → 0.2.13

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

@@ -1,122 +0,0 @@
-import * as p from "@clack/prompts";
-import { readConfig, writeConfig } from "../../config";
-import { parseFlags } from "../utils/args";
-
-export async function programCloneCommand(args: string[]) {
-	const { flags, rest } = parseFlags(args);
-	const programId = (
-		(rest[0] as string) ||
-		(flags.program as string) ||
-		""
-	).trim();
-	const configPath = flags.config as string | undefined;
-	const cfg = await readConfig(configPath);
-	const endpoint = (flags.endpoint as string) || cfg.clone.endpoint;
-	const withAccounts = !!flags["with-accounts"];
-	const accountsLimit = flags["accounts-limit"]
-		? Number(flags["accounts-limit"])
-		: undefined;
-	if (!programId) {
-		p.log.error(
-			"Usage: solforge program clone <programId> [--endpoint URL] [--with-accounts] [--accounts-limit N]",
-		);
-		return;
-	}
-	const url = `http://localhost:${cfg.server.rpcPort}`;
-	const s = p.spinner();
-	s.start("Cloning program...");
-	try {
-		const res = await fetch(url, {
-			method: "POST",
-			headers: { "content-type": "application/json" },
-			body: JSON.stringify({
-				jsonrpc: "2.0",
-				id: 1,
-				method: "solforgeAdminCloneProgram",
-				params: [programId, { endpoint, withAccounts, accountsLimit }],
-			}),
-		});
-		const json = await res.json();
-		if (json.error) {
-			const details = json.error.data
-				? `\nDetails: ${JSON.stringify(json.error.data)}`
-				: "";
-			throw new Error((json.error.message || "program clone failed") + details);
-		}
-		s.stop("Program cloned");
-		console.log(JSON.stringify(json.result, null, 2));
-		await recordProgramClone(configPath, programId);
-	} catch (e) {
-		s.stop("Clone failed");
-		p.log.error(String(e));
-	}
-}
-
-export async function programAccountsCloneCommand(args: string[]) {
-	const { flags, rest } = parseFlags(args);
-	const programId = (
-		(rest[0] as string) ||
-		(flags.program as string) ||
-		""
-	).trim();
-	const configPath = flags.config as string | undefined;
-	const cfg = await readConfig(configPath);
-	const endpoint = (flags.endpoint as string) || cfg.clone.endpoint;
-	const limit = flags.limit ? Number(flags.limit) : undefined;
-	const filters = flags.filters ? safeJson(flags.filters as string) : undefined;
-	if (!programId) {
-		p.log.error(
-			"Usage: solforge program accounts clone <programId> [--endpoint URL] [--limit N] [--filters JSON]",
-		);
-		return;
-	}
-	const url = `http://localhost:${cfg.server.rpcPort}`;
-	const s = p.spinner();
-	s.start("Cloning program accounts...");
-	try {
-		const res = await fetch(url, {
-			method: "POST",
-			headers: { "content-type": "application/json" },
-			body: JSON.stringify({
-				jsonrpc: "2.0",
-				id: 1,
-				method: "solforgeAdminCloneProgramAccounts",
-				params: [programId, { endpoint, limit, filters }],
-			}),
-		});
-		const json = await res.json();
-		if (json.error)
-			throw new Error(json.error.message || "program accounts clone failed");
-		s.stop("Program accounts cloned");
-		console.log(JSON.stringify(json.result, null, 2));
-	} catch (e) {
-		s.stop("Clone failed");
-		p.log.error(String(e));
-	}
-}
-
-function safeJson(s: string): unknown {
-	try {
-		return JSON.parse(s);
-	} catch {
-		return undefined;
-	}
-}
-
-async function recordProgramClone(
-	configPath: string | undefined,
-	programId: string,
-) {
-	try {
-		const cfg = await readConfig(configPath);
-		const next = new Set(cfg.clone.programs ?? []);
-		if (!next.has(programId)) {
-			next.add(programId);
-			cfg.clone.programs = Array.from(next);
-			await writeConfig(cfg, configPath ?? "sf.config.json");
-			p.log.info(`Added ${programId} to clone programs in config`);
-		}
-	} catch (error) {
-		console.warn(`[config] Failed to update clone programs: ${String(error)}`);
-	}
-}

package/src/cli/commands/program-load.ts

@@ -1,64 +0,0 @@
-import * as p from "@clack/prompts";
-import { Connection, PublicKey } from "@solana/web3.js";
-import { readConfig } from "../../config";
-import { parseFlags } from "../utils/args";
-
-export async function programLoadCommand(args: string[]) {
-	const { flags, rest } = parseFlags(args);
-	const programId = (rest[0] as string) || (flags.program as string);
-	const fromFile = flags.file as string | undefined;
-	const endpoint = flags.endpoint as string | undefined;
-	if (!programId) {
-		p.log.error(
-			"Usage: solforge program load <programId> [--file PATH | --endpoint URL]",
-		);
-		return;
-	}
-	let base64: string | undefined;
-	try {
-		if (fromFile) {
-			const bytes = await Bun.file(fromFile).arrayBuffer();
-			base64 = Buffer.from(bytes).toString("base64");
-		} else if (endpoint) {
-			// Fetch ProgramData from endpoint
-			const conn = new Connection(endpoint, "confirmed");
-			const pid = new PublicKey(programId);
-			const info = await conn.getAccountInfo(pid, "confirmed");
-			if (!info) throw new Error("Program account not found on endpoint");
-			// Program account should be upgradeable; fetch ProgramData and extract bytes after header
-			// Heuristic: delegate parsing to server if unsure. Here, try raw first.
-			base64 = Buffer.from(info.data as Buffer).toString("base64");
-		} else {
-			p.log.error("Either --file or --endpoint must be provided");
-			return;
-		}
-	} catch (e) {
-		p.log.error(`Failed to read ELF: ${String(e)}`);
-		return;
-	}
-
-	const cfg = await readConfig();
-	const url = `http://localhost:${cfg.server.rpcPort}`;
-	const s = p.spinner();
-	s.start("Loading program into LiteSVM...");
-	try {
-		const res = await fetch(url, {
-			method: "POST",
-			headers: { "content-type": "application/json" },
-			body: JSON.stringify({
-				jsonrpc: "2.0",
-				id: 1,
-				method: "solforgeLoadProgram",
-				params: [programId, base64],
-			}),
-		});
-		const json = await res.json();
-		if (json.error)
-			throw new Error(json.error.message || "program load failed");
-		s.stop("Program loaded");
-		console.log(JSON.stringify(json.result, null, 2));
-	} catch (e) {
-		s.stop("Load failed");
-		p.log.error(String(e));
-	}
-}

package/src/cli/commands/rpc-start.ts

@@ -1,49 +0,0 @@
-import * as p from "@clack/prompts";
-import { readConfig } from "../../config";
-import { startRpcServers } from "../../rpc/start";
-import { parseFlags } from "../utils/args";
-
-export async function rpcStartCommand(args: string[]) {
-	const { flags } = parseFlags(args);
-	const cfg = await readConfig(flags.config as string | undefined);
-	const rpcPort = Number(flags.port ?? cfg.server.rpcPort ?? 8899);
-	const wsPort = Number(flags["ws-port"] ?? cfg.server.wsPort ?? rpcPort + 1);
-	const host =
-		flags.network === true ? "0.0.0.0" : (flags.host as string) || "127.0.0.1";
-	const dbMode =
-		(flags["db-mode"] as string) || cfg.server.db.mode || "ephemeral";
-	const dbPath =
-		(flags["db-path"] as string) || cfg.server.db.path || ".solforge/db.db";
-	const guiPort = Number(flags["gui-port"] ?? cfg.gui.port ?? 42069);
-	const guiEnabled =
-		flags["no-gui"] === true
-			? false
-			: flags.gui === true
-				? true
-				: cfg.gui.enabled !== false;
-
-	const s = p.spinner();
-	const guiMsg = guiEnabled ? `, GUI on ${guiPort}` : "";
-	s.start(`Starting RPC on ${host}:${rpcPort}, WS on ${wsPort}${guiMsg}...`);
-	try {
-		const mode: "ephemeral" | "persistent" =
-			dbMode === "persistent" ? "persistent" : "ephemeral";
-		const started = startRpcServers({
-			rpcPort,
-			wsPort,
-			dbMode: mode,
-			dbPath,
-			host,
-			guiEnabled,
-			guiPort,
-		});
-		s.stop("RPC started");
-		console.log(`HTTP: http://${host}:${started.rpcPort}`);
-		console.log(`WS:   ws://${host}:${started.wsPort}`);
-		if (started.guiPort) console.log(`GUI:  http://${host}:${started.guiPort}`);
-	} catch (e) {
-		s.stop("Failed to start RPC");
-		p.log.error(String(e));
-		process.exitCode = 1;
-	}
-}

package/src/cli/commands/token-adopt-authority.ts

@@ -1,37 +0,0 @@
-import * as p from "@clack/prompts";
-import { readConfig } from "../../config";
-import { parseFlags } from "../utils/args";
-
-// Set the faucet as mint authority for an existing mint in LiteSVM (local-only)
-export async function tokenAdoptAuthorityCommand(args: string[]) {
-	const { flags, rest } = parseFlags(args);
-	const mint = (rest[0] as string) || (flags.mint as string);
-	if (!mint) {
-		p.log.error("Usage: solforge token adopt-authority <mint>");
-		return;
-	}
-	const cfg = await readConfig();
-	const url = `http://localhost:${cfg.server.rpcPort}`;
-	const s = p.spinner();
-	s.start("Adopting faucet as mint authority...");
-	try {
-		const res = await fetch(url, {
-			method: "POST",
-			headers: { "content-type": "application/json" },
-			body: JSON.stringify({
-				jsonrpc: "2.0",
-				id: 1,
-				method: "solforgeAdoptMintAuthority",
-				params: [mint],
-			}),
-		});
-		const json = await res.json();
-		if (json.error)
-			throw new Error(json.error.message || "adopt authority failed");
-		s.stop("Authority updated");
-		console.log(JSON.stringify(json.result, null, 2));
-	} catch (e) {
-		s.stop("Failed");
-		p.log.error(String(e));
-	}
-}

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

@@ -1,112 +0,0 @@
-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: unknown) {
-			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;
-		}
-	} 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

@@ -1,81 +0,0 @@
-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 (!Number.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

@@ -1,158 +0,0 @@
-// Minimal, fast CLI router with @clack/prompts for UX
-import * as p from "@clack/prompts";
-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([
-	"help",
-	"-h",
-	"--help",
-	"version",
-	"-v",
-	"--version",
-	"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");
-		// Pass through any flags provided when no explicit command was given
-		await runSolforge(raw);
-		return;
-	}
-
-	if (cmd === "help" || cmd === "-h" || cmd === "--help") {
-		printHelp();
-		return;
-	}
-
-	if (cmd === "version" || cmd === "-v" || cmd === "--version") {
-		printVersion();
-		return;
-	}
-
-	// Alias: solforge start -> solforge rpc start
-	if (cmd === "start") {
-		// Run the full Solforge flow (config ensure + bootstrap + servers)
-		const { runSolforge } = await import("./run-solforge");
-		await runSolforge(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
-
-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)
-`);
-}
-
-async function unknownCommand(parts: (string | undefined)[]) {
-	p.log.error(`Unknown command: ${parts.filter(Boolean).join(" ")}`);
-	printHelp();
-}
-
-function printVersion() {
-	console.log(String(VERSION));
-}
-
-main();