solforge 0.1.0

package/src/commands/add-program.ts

@@ -0,0 +1,337 @@
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { existsSync } from "fs";
+import { configManager } from "../config/manager.js";
+import { ProgramCloner } from "../services/program-cloner.js";
+import { processRegistry } from "../services/process-registry.js";
+import type { ProgramConfig } from "../types/config.js";
+
+export async function addProgramCommand(
+  options: {
+    name?: string;
+    programId?: string;
+    interactive?: boolean;
+  } = {}
+): Promise<void> {
+  console.log(chalk.blue("📦 Adding program to configuration...\n"));
+
+  // Check if config exists
+  if (!existsSync("./sf.config.json")) {
+    console.error(chalk.red("❌ No sf.config.json found in current directory"));
+    console.log(chalk.yellow("💡 Run `solforge init` to create one"));
+    return;
+  }
+
+  // Load current config
+  try {
+    await configManager.load("./sf.config.json");
+  } catch (error) {
+    console.error(chalk.red("❌ Failed to load sf.config.json"));
+    console.error(
+      chalk.red(error instanceof Error ? error.message : String(error))
+    );
+    return;
+  }
+
+  const config = configManager.getConfig();
+
+  // Get program details
+  let programId: string;
+  let programName: string | undefined;
+  let upgradeable: boolean = false;
+
+  if (options.interactive !== false && !options.programId) {
+    // Interactive mode - show common programs + custom option
+    const { programChoice } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "programChoice",
+        message: "Select a program to add:",
+        choices: [
+          {
+            name: "Token Metadata Program",
+            value: {
+              id: "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s",
+              name: "Token Metadata",
+              upgradeable: true,
+            },
+          },
+          {
+            name: "Associated Token Account Program",
+            value: {
+              id: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
+              name: "Associated Token Account",
+              upgradeable: false,
+            },
+          },
+          {
+            name: "System Program",
+            value: {
+              id: "11111111111111111111111111111112",
+              name: "System Program",
+              upgradeable: false,
+            },
+          },
+          {
+            name: "Token Program",
+            value: {
+              id: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
+              name: "Token Program",
+              upgradeable: false,
+            },
+          },
+          {
+            name: "Token Program 2022",
+            value: {
+              id: "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb",
+              name: "Token Program 2022",
+              upgradeable: true,
+            },
+          },
+          {
+            name: "Rent Sysvar",
+            value: {
+              id: "SysvarRent111111111111111111111111111111111",
+              name: "Rent Sysvar",
+              upgradeable: false,
+            },
+          },
+          {
+            name: "Clock Sysvar",
+            value: {
+              id: "SysvarC1ock11111111111111111111111111111111",
+              name: "Clock Sysvar",
+              upgradeable: false,
+            },
+          },
+          {
+            name: "Jupiter V6 Program",
+            value: {
+              id: "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4",
+              name: "Jupiter V6",
+              upgradeable: true,
+            },
+          },
+          {
+            name: "Raydium AMM Program",
+            value: {
+              id: "675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8",
+              name: "Raydium AMM",
+              upgradeable: false,
+            },
+          },
+          {
+            name: "Serum DEX Program",
+            value: {
+              id: "9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin",
+              name: "Serum DEX",
+              upgradeable: false,
+            },
+          },
+          {
+            name: "Custom (enter program ID manually)",
+            value: "custom",
+          },
+        ],
+      },
+    ]);
+
+    if (programChoice === "custom") {
+      const answers = await inquirer.prompt([
+        {
+          type: "input",
+          name: "programId",
+          message: "Enter program ID:",
+          validate: (input) =>
+            input.trim().length > 0 || "Program ID is required",
+        },
+        {
+          type: "input",
+          name: "name",
+          message: "Enter program name (optional):",
+          default: "",
+        },
+        {
+          type: "confirm",
+          name: "upgradeable",
+          message: "Is this an upgradeable program?",
+          default: false,
+        },
+      ]);
+
+      programId = answers.programId;
+      programName = answers.name || undefined;
+      upgradeable = answers.upgradeable;
+    } else {
+      programId = programChoice.id;
+      programName = programChoice.name;
+      upgradeable = programChoice.upgradeable;
+    }
+  } else {
+    // Non-interactive mode
+    if (!options.programId) {
+      console.error(chalk.red("❌ Program ID is required"));
+      console.log(
+        chalk.gray(
+          "💡 Use --program-id flag, or run without flags for interactive mode"
+        )
+      );
+      return;
+    }
+
+    programId = options.programId;
+    programName = options.name;
+    // Default to false for CLI, could add --upgradeable flag later
+    upgradeable = false;
+  }
+
+  try {
+    // Check if program already exists in config
+    const existingProgram = config.programs.find(
+      (p) => p.mainnetProgramId === programId
+    );
+    if (existingProgram) {
+      console.log(
+        chalk.yellow(`⚠️  Program ${programId} already exists in configuration`)
+      );
+      console.log(chalk.gray(`   Name: ${existingProgram.name || "unnamed"}`));
+      return;
+    }
+
+    // Verify program exists on mainnet first
+    console.log(chalk.gray("🔍 Verifying program exists on mainnet..."));
+    const programCloner = new ProgramCloner();
+    const programInfo = await programCloner.getProgramInfo(
+      programId,
+      "mainnet-beta"
+    );
+
+    if (!programInfo.exists) {
+      console.error(chalk.red(`❌ Program ${programId} not found on mainnet`));
+      return;
+    }
+
+    if (!programInfo.executable) {
+      console.error(chalk.red(`❌ ${programId} is not an executable program`));
+      return;
+    }
+
+    console.log(
+      chalk.gray(`  ✓ Found executable program (${programInfo.size} bytes)`)
+    );
+
+    // Create new program config
+    const newProgram: ProgramConfig = {
+      name: programName,
+      mainnetProgramId: programId,
+      upgradeable: upgradeable,
+      cluster: "mainnet-beta",
+      dependencies: [],
+    };
+
+    // Add to config
+    config.programs.push(newProgram);
+
+    // Save updated config
+    await configManager.save("./sf.config.json");
+
+    console.log(
+      chalk.green(
+        `\n✅ Successfully added ${programName || programId} to configuration!`
+      )
+    );
+    console.log(chalk.cyan(`📝 Updated sf.config.json`));
+    console.log(chalk.gray(`   Program ID: ${programId}`));
+    console.log(chalk.gray(`   Upgradeable: ${upgradeable ? "Yes" : "No"}`));
+
+    // Check if there are running validators
+    await processRegistry.cleanup();
+    const validators = processRegistry.getRunning();
+
+    if (validators.length > 0) {
+      console.log(
+        chalk.yellow(`\n⚠️  Found ${validators.length} running validator(s)`)
+      );
+      console.log(
+        chalk.gray("💡 Programs are added to genesis config and require RESET")
+      );
+      console.log(chalk.red("   ⚠️  RESET will WIPE all ledger data!"));
+      console.log(
+        chalk.gray(
+          `   1. Stop validators using "${config.name}": solforge stop <validator-id>`
+        )
+      );
+      console.log(chalk.gray("   2. Start with reset: solforge start"));
+
+      const { shouldRestart } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "shouldRestart",
+          message: "⚠️  Reset validators now? (This will WIPE all ledger data)",
+          default: false,
+        },
+      ]);
+
+      if (shouldRestart) {
+        console.log(chalk.yellow("\n🔄 Resetting validators..."));
+        console.log(chalk.red("⚠️  This will delete all ledger data!"));
+
+        // Import the commands we need
+        const { stopCommand } = await import("./stop.js");
+        const { startCommand } = await import("./start.js");
+
+        // Get current config for modifications
+        const currentConfig = configManager.getConfig();
+
+        // Stop validators that use this config
+        const configName = currentConfig.name;
+        const matchingValidators = validators.filter((v) =>
+          v.name.startsWith(configName)
+        );
+
+        if (matchingValidators.length > 0) {
+          console.log(
+            chalk.gray(
+              `🛑 Stopping ${matchingValidators.length} validator(s) using config "${configName}"...`
+            )
+          );
+
+          for (const validator of matchingValidators) {
+            await stopCommand(validator.id, {});
+          }
+        }
+
+        // Wait a moment for clean shutdown
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+
+        // Temporarily enable reset for this start
+        const originalReset = currentConfig.localnet.reset;
+        currentConfig.localnet.reset = true;
+
+        console.log(
+          chalk.cyan(
+            "🚀 Starting validator with reset to apply program changes..."
+          )
+        );
+
+        // Start new validator (will reset due to config)
+        await startCommand(false);
+
+        // Restore original reset setting
+        currentConfig.localnet.reset = originalReset;
+        await configManager.save("./sf.config.json");
+      }
+    } else {
+      console.log(
+        chalk.gray(
+          "\n💡 Start a validator to use the new program: solforge start"
+        )
+      );
+    }
+  } catch (error) {
+    console.error(chalk.red("❌ Failed to add program:"));
+    console.error(
+      chalk.red(`   ${error instanceof Error ? error.message : String(error)}`)
+    );
+  }
+}

package/src/commands/init.ts

@@ -0,0 +1,122 @@
+import { writeFileSync, existsSync } from "fs";
+import { resolve } from "path";
+import chalk from "chalk";
+import inquirer from "inquirer";
+import type { Config } from "../types/config.js";
+
+const defaultConfig: Config = {
+  name: "my-localnet",
+  description: "Local Solana development environment",
+  tokens: [
+    {
+      symbol: "USDC",
+      mainnetMint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+      recipients: [],
+      mintAmount: 1000000,
+      cloneMetadata: true,
+    },
+  ],
+  programs: [],
+  localnet: {
+    airdropAmount: 100,
+    faucetAccounts: [],
+    port: 8899,
+    faucetPort: 9900,
+    reset: true,
+    logLevel: "info",
+    bindAddress: "127.0.0.1",
+    quiet: false,
+    rpc: "https://mainnet.helius-rpc.com/?api-key=3a3b84ef-2985-4543-9d67-535eb707b6ec",
+    limitLedgerSize: 100000,
+  },
+};
+
+export async function initCommand(): Promise<void> {
+  const configPath = resolve(process.cwd(), "sf.config.json");
+
+  // Check if config already exists
+  if (existsSync(configPath)) {
+    const { overwrite } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "overwrite",
+        message: "sf.config.json already exists. Overwrite?",
+        default: false,
+      },
+    ]);
+
+    if (!overwrite) {
+      console.log(chalk.yellow("⚠️  Initialization cancelled"));
+      return;
+    }
+  }
+
+  // Gather basic configuration
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "name",
+      message: "Project name:",
+      default: "my-localnet",
+    },
+    {
+      type: "input",
+      name: "description",
+      message: "Description:",
+      default: "Local Solana development environment",
+    },
+    {
+      type: "number",
+      name: "port",
+      message: "RPC port:",
+      default: 8899,
+    },
+    {
+      type: "confirm",
+      name: "includeUsdc",
+      message: "Include USDC token?",
+      default: true,
+    },
+  ]);
+
+  // Build config
+  const config: Config = {
+    ...defaultConfig,
+    name: answers.name,
+    description: answers.description,
+    localnet: {
+      ...defaultConfig.localnet,
+      port: answers.port,
+    },
+  };
+
+  if (!answers.includeUsdc) {
+    config.tokens = [];
+  }
+
+  try {
+    // Write config file
+    writeFileSync(configPath, JSON.stringify(config, null, 2));
+
+    console.log(chalk.green("✅ sf.config.json created successfully!"));
+    console.log(chalk.gray(`📄 Config saved to: ${configPath}`));
+    console.log();
+    console.log(chalk.blue("Next steps:"));
+    console.log(
+      chalk.gray("1. Edit sf.config.json to add your tokens and programs")
+    );
+    console.log(chalk.gray("2. Run `solforge start` to launch your localnet"));
+    console.log();
+    console.log(
+      chalk.yellow(
+        "💡 Tip: Check configs/example.sf.config.json for more examples"
+      )
+    );
+  } catch (error) {
+    console.error(chalk.red("❌ Failed to create sf.config.json"));
+    console.error(
+      chalk.red(error instanceof Error ? error.message : String(error))
+    );
+    process.exit(1);
+  }
+}

package/src/commands/list.ts

@@ -0,0 +1,136 @@
+import chalk from "chalk";
+import { processRegistry } from "../services/process-registry.js";
+import type { RunningValidator } from "../services/process-registry.js";
+
+export async function listCommand(): Promise<void> {
+  console.log(chalk.blue("📋 Listing running validators...\n"));
+
+  // Clean up dead processes first
+  await processRegistry.cleanup();
+
+  const validators = processRegistry.getRunning();
+
+  if (validators.length === 0) {
+    console.log(chalk.yellow("⚠️  No running validators found"));
+    console.log(chalk.gray("💡 Use `solforge start` to start a validator"));
+    return;
+  }
+
+  // Verify each validator is actually still running
+  const activeValidators: RunningValidator[] = [];
+  for (const validator of validators) {
+    const isRunning = await processRegistry.isProcessRunning(validator.pid);
+    if (isRunning) {
+      activeValidators.push({ ...validator, status: "running" });
+    } else {
+      processRegistry.updateStatus(validator.id, "stopped");
+    }
+  }
+
+  if (activeValidators.length === 0) {
+    console.log(
+      chalk.yellow(
+        "⚠️  No active validators found (all processes have stopped)"
+      )
+    );
+    console.log(chalk.gray("💡 Use `solforge start` to start a validator"));
+    return;
+  }
+
+  console.log(
+    chalk.green(
+      `✅ Found ${activeValidators.length} running validator${
+        activeValidators.length > 1 ? "s" : ""
+      }\n`
+    )
+  );
+
+  // Display validators in a table format
+  displayValidatorsTable(activeValidators);
+
+  console.log(
+    chalk.gray("\n💡 Use `solforge stop <id>` to stop a specific validator")
+  );
+  console.log(
+    chalk.gray("💡 Use `solforge stop --all` to stop all validators")
+  );
+}
+
+function displayValidatorsTable(validators: RunningValidator[]): void {
+  // Calculate column widths
+  const maxIdWidth = Math.max(2, ...validators.map((v) => v.id.length));
+  const maxNameWidth = Math.max(4, ...validators.map((v) => v.name.length));
+  const maxPidWidth = Math.max(
+    3,
+    ...validators.map((v) => v.pid.toString().length)
+  );
+  const maxPortWidth = 9; // "8899/9900" format
+  const maxUptimeWidth = 7;
+
+  // Header
+  const header =
+    chalk.bold("ID".padEnd(maxIdWidth)) +
+    " | " +
+    chalk.bold("Name".padEnd(maxNameWidth)) +
+    " | " +
+    chalk.bold("PID".padEnd(maxPidWidth)) +
+    " | " +
+    chalk.bold("RPC/Faucet".padEnd(maxPortWidth)) +
+    " | " +
+    chalk.bold("Uptime".padEnd(maxUptimeWidth)) +
+    " | " +
+    chalk.bold("Status");
+
+  console.log(header);
+  console.log("-".repeat(header.length - 20)); // Subtract ANSI codes length
+
+  // Rows
+  validators.forEach((validator) => {
+    const uptime = formatUptime(validator.startTime);
+    const ports = `${validator.rpcPort}/${validator.faucetPort}`;
+    const status =
+      validator.status === "running" ? chalk.green("●") : chalk.red("●");
+
+    const row =
+      validator.id.padEnd(maxIdWidth) +
+      " | " +
+      validator.name.padEnd(maxNameWidth) +
+      " | " +
+      validator.pid.toString().padEnd(maxPidWidth) +
+      " | " +
+      ports.padEnd(maxPortWidth) +
+      " | " +
+      uptime.padEnd(maxUptimeWidth) +
+      " | " +
+      status;
+
+    console.log(row);
+  });
+
+  console.log(); // Empty line
+
+  // URLs section
+  console.log(chalk.cyan("🌐 Connection URLs:"));
+  validators.forEach((validator) => {
+    console.log(chalk.gray(`  ${validator.name} (${validator.id}):`));
+    console.log(chalk.gray(`    RPC:    ${validator.rpcUrl}`));
+    console.log(chalk.gray(`    Faucet: ${validator.faucetUrl}`));
+  });
+}
+
+function formatUptime(startTime: Date): string {
+  const now = new Date();
+  const uptimeMs = now.getTime() - startTime.getTime();
+  const uptimeSeconds = Math.floor(uptimeMs / 1000);
+
+  if (uptimeSeconds < 60) {
+    return `${uptimeSeconds}s`;
+  } else if (uptimeSeconds < 3600) {
+    const minutes = Math.floor(uptimeSeconds / 60);
+    return `${minutes}m`;
+  } else {
+    const hours = Math.floor(uptimeSeconds / 3600);
+    const minutes = Math.floor((uptimeSeconds % 3600) / 60);
+    return `${hours}h${minutes}m`;
+  }
+}