solforge 0.1.6 → 0.2.0

package/src/services/port-manager.ts

@@ -1,177 +0,0 @@
-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

@@ -1,154 +0,0 @@
-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

@@ -1,317 +0,0 @@
-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 };
-    }
-  }
-}