solforge 0.2.4 → 0.2.6

package/src/services/port-manager.ts

@@ -1,176 +1,173 @@
 import { processRegistry } from "./process-registry.js";
 
 export interface PortAllocation {
-  rpcPort: number;
-  faucetPort: number;
+	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);
-  }
+	private readonly defaultRpcPort = 8899;
+	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("node:net");
+			const server = net.createServer();
+
+			server.once("listening", () => {
+				server.once("close", () => resolve(true));
+				server.close();
+			});
+
+			server.once("error", () => resolve(false));
+
+			server.listen(port);
+		});
+	}
+
+	/**
+	 * Get recommended ports for a configuration
+	 */
+	async getRecommendedPorts(config: {
+		localnet: { port: number; faucetPort: number };
+	}): Promise<PortAllocation> {
+		return this.getAvailablePorts(config.localnet.port);
+	}
 }
 
 // Singleton instance

package/src/services/process-registry.ts

@@ -1,153 +1,152 @@
-import { writeFileSync, readFileSync, existsSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-import type { Config } from "../types/config.js";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
 
 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;
+	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));
-  }
+	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("node:fs").mkdirSync(dir, { recursive: true });
+		}
+
+		writeFileSync(this.registryPath, JSON.stringify(validators, null, 2));
+	}
 }
 
 // Singleton instance