solforge 0.2.0 → 0.2.2

package/src/services/port-manager.ts

@@ -0,0 +1,177 @@
+import { processRegistry } from "./process-registry.js";
+
+export interface PortAllocation {
+  rpcPort: number;
+  faucetPort: number;
+}
+
+export class PortManager {
+  private readonly defaultRpcPort = 8899;
+  private readonly defaultFaucetPort = 9900;
+  private readonly portRangeStart = 8000;
+  private readonly portRangeEnd = 9999;
+
+  /**
+   * Get the next available port pair (RPC + Faucet)
+   */
+  async getAvailablePorts(preferredRpcPort?: number): Promise<PortAllocation> {
+    const usedPorts = this.getUsedPorts();
+
+    // If preferred port is specified and available, use it
+    if (preferredRpcPort && !this.isPortUsed(preferredRpcPort, usedPorts)) {
+      const faucetPort = this.findAvailableFaucetPort(
+        preferredRpcPort,
+        usedPorts
+      );
+      if (faucetPort) {
+        return { rpcPort: preferredRpcPort, faucetPort };
+      }
+    }
+
+    // Otherwise, find the next available ports
+    return this.findNextAvailablePorts(usedPorts);
+  }
+
+  /**
+   * Check if a specific port is available
+   */
+  async isPortAvailable(port: number): Promise<boolean> {
+    const usedPorts = this.getUsedPorts();
+    return (
+      !this.isPortUsed(port, usedPorts) &&
+      (await this.checkPortActuallyFree(port))
+    );
+  }
+
+  /**
+   * Get all currently used ports from running validators
+   */
+  private getUsedPorts(): Set<number> {
+    const validators = processRegistry.getRunning();
+    const usedPorts = new Set<number>();
+
+    validators.forEach((validator) => {
+      usedPorts.add(validator.rpcPort);
+      usedPorts.add(validator.faucetPort);
+    });
+
+    return usedPorts;
+  }
+
+  /**
+   * Check if a port is in the used ports set
+   */
+  private isPortUsed(port: number, usedPorts: Set<number>): boolean {
+    return usedPorts.has(port);
+  }
+
+  /**
+   * Find an available faucet port for a given RPC port
+   */
+  private findAvailableFaucetPort(
+    rpcPort: number,
+    usedPorts: Set<number>
+  ): number | null {
+    // Try default offset first (faucet = rpc + 1001)
+    let faucetPort = rpcPort + 1001;
+    if (
+      !this.isPortUsed(faucetPort, usedPorts) &&
+      this.isPortInRange(faucetPort)
+    ) {
+      return faucetPort;
+    }
+
+    // Try other offsets
+    const offsets = [1000, 1002, 1003, 1004, 1005, 999, 998, 997];
+    for (const offset of offsets) {
+      faucetPort = rpcPort + offset;
+      if (
+        !this.isPortUsed(faucetPort, usedPorts) &&
+        this.isPortInRange(faucetPort)
+      ) {
+        return faucetPort;
+      }
+    }
+
+    // Search in the entire range
+    for (let port = this.portRangeStart; port <= this.portRangeEnd; port++) {
+      if (!this.isPortUsed(port, usedPorts)) {
+        return port;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Find the next available port pair
+   */
+  private findNextAvailablePorts(usedPorts: Set<number>): PortAllocation {
+    // Start from default ports if available
+    if (!this.isPortUsed(this.defaultRpcPort, usedPorts)) {
+      const faucetPort = this.findAvailableFaucetPort(
+        this.defaultRpcPort,
+        usedPorts
+      );
+      if (faucetPort) {
+        return { rpcPort: this.defaultRpcPort, faucetPort };
+      }
+    }
+
+    // Search for available RPC port
+    for (
+      let rpcPort = this.portRangeStart;
+      rpcPort <= this.portRangeEnd;
+      rpcPort++
+    ) {
+      if (!this.isPortUsed(rpcPort, usedPorts)) {
+        const faucetPort = this.findAvailableFaucetPort(rpcPort, usedPorts);
+        if (faucetPort) {
+          return { rpcPort, faucetPort };
+        }
+      }
+    }
+
+    throw new Error("No available port pairs found in the specified range");
+  }
+
+  /**
+   * Check if port is within allowed range
+   */
+  private isPortInRange(port: number): boolean {
+    return port >= this.portRangeStart && port <= this.portRangeEnd;
+  }
+
+  /**
+   * Actually check if a port is free by attempting to bind to it
+   */
+  private async checkPortActuallyFree(port: number): Promise<boolean> {
+    return new Promise((resolve) => {
+      const net = require("net");
+      const server = net.createServer();
+
+      server.listen(port, (err: any) => {
+        if (err) {
+          resolve(false);
+        } else {
+          server.once("close", () => resolve(true));
+          server.close();
+        }
+      });
+
+      server.on("error", () => resolve(false));
+    });
+  }
+
+  /**
+   * Get recommended ports for a configuration
+   */
+  async getRecommendedPorts(config: {
+    localnet: { port: number; faucetPort: number };
+  }): Promise<PortAllocation> {
+    return this.getAvailablePorts(config.localnet.port);
+  }
+}
+
+// Singleton instance
+export const portManager = new PortManager();

package/src/services/process-registry.ts

@@ -0,0 +1,154 @@
+import { writeFileSync, readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import type { Config } from "../types/config.js";
+
+export interface RunningValidator {
+  id: string;
+  name: string;
+  pid: number;
+  rpcPort: number;
+  faucetPort: number;
+  rpcUrl: string;
+  faucetUrl: string;
+  configPath: string;
+  startTime: Date;
+  status: "running" | "stopped" | "error";
+  apiServerPort?: number;
+  apiServerUrl?: string;
+  apiServerPid?: number;
+}
+
+export class ProcessRegistry {
+  private registryPath: string;
+
+  constructor() {
+    // Store registry in user's home directory
+    this.registryPath = join(homedir(), ".solforge", "running-validators.json");
+  }
+
+  /**
+   * Get all running validators
+   */
+  getRunning(): RunningValidator[] {
+    if (!existsSync(this.registryPath)) {
+      return [];
+    }
+
+    try {
+      const content = readFileSync(this.registryPath, "utf-8");
+      const validators = JSON.parse(content) as RunningValidator[];
+
+      // Convert startTime strings back to Date objects
+      return validators.map((v) => ({
+        ...v,
+        startTime: new Date(v.startTime),
+      }));
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Register a new running validator
+   */
+  register(validator: RunningValidator): void {
+    const validators = this.getRunning();
+
+    // Remove any existing entry with the same ID
+    const updated = validators.filter((v) => v.id !== validator.id);
+    updated.push(validator);
+
+    this.save(updated);
+  }
+
+  /**
+   * Unregister a validator
+   */
+  unregister(id: string): void {
+    const validators = this.getRunning();
+    const updated = validators.filter((v) => v.id !== id);
+    this.save(updated);
+  }
+
+  /**
+   * Update validator status
+   */
+  updateStatus(id: string, status: RunningValidator["status"]): void {
+    const validators = this.getRunning();
+    const validator = validators.find((v) => v.id === id);
+
+    if (validator) {
+      validator.status = status;
+      this.save(validators);
+    }
+  }
+
+  /**
+   * Get validator by ID
+   */
+  getById(id: string): RunningValidator | undefined {
+    return this.getRunning().find((v) => v.id === id);
+  }
+
+  /**
+   * Get validator by PID
+   */
+  getByPid(pid: number): RunningValidator | undefined {
+    return this.getRunning().find((v) => v.pid === pid);
+  }
+
+  /**
+   * Get validator by port
+   */
+  getByPort(port: number): RunningValidator | undefined {
+    return this.getRunning().find(
+      (v) => v.rpcPort === port || v.faucetPort === port
+    );
+  }
+
+  /**
+   * Check if a process is actually running
+   */
+  async isProcessRunning(pid: number): Promise<boolean> {
+    try {
+      // Send signal 0 to check if process exists
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Clean up dead processes from registry
+   */
+  async cleanup(): Promise<void> {
+    const validators = this.getRunning();
+    const active: RunningValidator[] = [];
+
+    for (const validator of validators) {
+      if (await this.isProcessRunning(validator.pid)) {
+        active.push(validator);
+      }
+    }
+
+    this.save(active);
+  }
+
+  /**
+   * Save validators to registry file
+   */
+  private save(validators: RunningValidator[]): void {
+    // Ensure directory exists
+    const dir = join(homedir(), ".solforge");
+    if (!existsSync(dir)) {
+      require("fs").mkdirSync(dir, { recursive: true });
+    }
+
+    writeFileSync(this.registryPath, JSON.stringify(validators, null, 2));
+  }
+}
+
+// Singleton instance
+export const processRegistry = new ProcessRegistry();

package/src/services/program-cloner.ts

@@ -0,0 +1,317 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import chalk from "chalk";
+import { Connection, PublicKey } from "@solana/web3.js";
+import { runCommand } from "../utils/shell.js";
+import type { ProgramConfig } from "../types/config.js";
+
+export class ProgramCloner {
+  private workDir: string;
+
+  constructor(workDir: string = ".solforge") {
+    this.workDir = workDir;
+  }
+
+  /**
+   * Clone programs for validator startup (saved as .so files)
+   */
+  async clonePrograms(
+    programs: ProgramConfig[],
+    targetCluster: string = "mainnet-beta"
+  ): Promise<
+    Array<{
+      success: boolean;
+      program: ProgramConfig;
+      error?: string;
+      filePath?: string;
+    }>
+  > {
+    console.log(chalk.cyan("\n🔧 Cloning programs from mainnet..."));
+
+    if (!existsSync(this.workDir)) {
+      mkdirSync(this.workDir, { recursive: true });
+    }
+
+    const programsDir = join(this.workDir, "programs");
+    if (!existsSync(programsDir)) {
+      mkdirSync(programsDir, { recursive: true });
+    }
+
+    const results = [];
+
+    for (const program of programs) {
+      console.log(
+        chalk.gray(
+          `  📦 Processing ${program.name || program.mainnetProgramId}...`
+        )
+      );
+
+      try {
+        // Clone dependencies first
+        if (program.dependencies && program.dependencies.length > 0) {
+          console.log(
+            chalk.gray(
+              `    📚 Cloning ${program.dependencies.length} dependencies...`
+            )
+          );
+          for (const depId of program.dependencies) {
+            await this.cloneSingleProgram(depId, programsDir, targetCluster);
+          }
+        }
+
+        // Clone the main program
+        const result = await this.cloneSingleProgram(
+          program.mainnetProgramId,
+          programsDir,
+          targetCluster,
+          program.name
+        );
+
+        results.push({
+          success: true,
+          program,
+          filePath: result.filePath,
+        });
+
+        console.log(chalk.gray(`    ✓ Cloned to ${result.filePath}`));
+      } catch (error) {
+        console.error(
+          chalk.red(`    ❌ Failed to clone ${program.mainnetProgramId}`)
+        );
+        console.error(
+          chalk.red(
+            `       ${error instanceof Error ? error.message : String(error)}`
+          )
+        );
+
+        results.push({
+          success: false,
+          program,
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+    }
+
+    const successful = results.filter((r) => r.success).length;
+    console.log(
+      chalk.cyan(`\n✅ Cloned ${successful}/${programs.length} programs`)
+    );
+
+    return results;
+  }
+
+  /**
+   * Clone a single program from mainnet
+   */
+  private async cloneSingleProgram(
+    programId: string,
+    outputDir: string,
+    cluster: string = "mainnet-beta",
+    name?: string
+  ): Promise<{ filePath: string }> {
+    const fileName = name
+      ? `${name.toLowerCase().replace(/\s+/g, "-")}.so`
+      : `${programId}.so`;
+    const outputPath = join(outputDir, fileName);
+
+    // Skip if already exists
+    if (existsSync(outputPath)) {
+      return { filePath: outputPath };
+    }
+
+    // Use solana account command to fetch program data
+    const rpcUrl = this.getClusterUrl(cluster);
+    const accountResult = await runCommand(
+      "solana",
+      ["account", programId, "--output", "json", "--url", rpcUrl],
+      { silent: true }
+    );
+
+    if (!accountResult.success) {
+      throw new Error(
+        `Failed to fetch program account: ${accountResult.stderr}`
+      );
+    }
+
+    try {
+      const accountData = JSON.parse(accountResult.stdout);
+      const programData = accountData.account.data;
+
+      if (!programData || programData[1] !== "base64") {
+        throw new Error("Invalid program data format");
+      }
+
+      // Decode base64 program data
+      const binaryData = Buffer.from(programData[0], "base64");
+
+      // Write as .so file
+      writeFileSync(outputPath, binaryData);
+
+      return { filePath: outputPath };
+    } catch (error) {
+      throw new Error(
+        `Failed to process program data: ${
+          error instanceof Error ? error.message : String(error)
+        }`
+      );
+    }
+  }
+
+  /**
+   * Generate validator arguments for cloned programs
+   */
+  generateValidatorArgs(
+    clonedPrograms: Array<{
+      success: boolean;
+      program: ProgramConfig;
+      filePath?: string;
+    }>
+  ): string[] {
+    const args: string[] = [];
+
+    for (const result of clonedPrograms) {
+      if (result.success && result.filePath) {
+        args.push("--bpf-program");
+        args.push(result.program.mainnetProgramId);
+        args.push(result.filePath);
+      }
+    }
+
+    return args;
+  }
+
+  /**
+   * Deploy program to running validator (hot deployment)
+   */
+  async deployToRunningValidator(
+    programId: string,
+    rpcUrl: string,
+    name?: string
+  ): Promise<{ success: boolean; deployedAddress?: string; error?: string }> {
+    try {
+      console.log(
+        chalk.cyan(`\n🚀 Hot deploying program ${name || programId}...`)
+      );
+
+      // First, clone the program if we don't have it
+      const programsDir = join(this.workDir, "programs");
+      if (!existsSync(programsDir)) {
+        mkdirSync(programsDir, { recursive: true });
+      }
+
+      const cloneResult = await this.cloneSingleProgram(
+        programId,
+        programsDir,
+        "mainnet-beta",
+        name
+      );
+
+      // Deploy to running validator using solana program deploy
+      console.log(chalk.gray("  📤 Deploying to validator..."));
+
+      const deployResult = await runCommand(
+        "solana",
+        [
+          "program",
+          "deploy",
+          cloneResult.filePath,
+          "--program-id",
+          programId,
+          "--url",
+          rpcUrl,
+        ],
+        { silent: false }
+      );
+
+      if (!deployResult.success) {
+        return {
+          success: false,
+          error: `Deployment failed: ${
+            deployResult.stderr || deployResult.stdout
+          }`,
+        };
+      }
+
+      console.log(
+        chalk.green(`  ✅ Successfully deployed ${name || programId}`)
+      );
+
+      return {
+        success: true,
+        deployedAddress: programId,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  /**
+   * Get cluster RPC URL
+   */
+  private getClusterUrl(cluster: string): string {
+    switch (cluster) {
+      case "mainnet-beta":
+        return "https://api.mainnet-beta.solana.com";
+      case "devnet":
+        return "https://api.devnet.solana.com";
+      case "testnet":
+        return "https://api.testnet.solana.com";
+      default:
+        return cluster; // Assume it's a custom URL
+    }
+  }
+
+  /**
+   * Verify program exists on cluster
+   */
+  async verifyProgram(
+    programId: string,
+    cluster: string = "mainnet-beta"
+  ): Promise<boolean> {
+    try {
+      const connection = new Connection(this.getClusterUrl(cluster));
+      const programAccount = await connection.getAccountInfo(
+        new PublicKey(programId)
+      );
+      return programAccount !== null && programAccount.executable;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get program info from cluster
+   */
+  async getProgramInfo(
+    programId: string,
+    cluster: string = "mainnet-beta"
+  ): Promise<{
+    exists: boolean;
+    executable?: boolean;
+    owner?: string;
+    size?: number;
+  }> {
+    try {
+      const connection = new Connection(this.getClusterUrl(cluster));
+      const programAccount = await connection.getAccountInfo(
+        new PublicKey(programId)
+      );
+
+      if (!programAccount) {
+        return { exists: false };
+      }
+
+      return {
+        exists: true,
+        executable: programAccount.executable,
+        owner: programAccount.owner.toBase58(),
+        size: programAccount.data.length,
+      };
+    } catch (error) {
+      return { exists: false };
+    }
+  }
+}