solforge 0.2.0 → 0.2.2

package/src/commands/status.ts

@@ -0,0 +1,99 @@
+import chalk from "chalk";
+import { runCommand, checkSolanaTools } from "../utils/shell.js";
+import { configManager } from "../config/manager.js";
+import { processRegistry } from "../services/process-registry.js";
+
+export async function statusCommand(): Promise<void> {
+  console.log(chalk.blue("📊 Checking system status...\n"));
+
+  // Check Solana CLI tools
+  console.log(chalk.cyan("🔧 Solana CLI Tools:"));
+  const tools = await checkSolanaTools();
+
+  console.log(
+    `  ${tools.solana ? "✅" : "❌"} solana CLI: ${
+      tools.solana ? "Available" : "Not found"
+    }`
+  );
+  console.log(
+    `  ${tools.splToken ? "✅" : "❌"} spl-token CLI: ${
+      tools.splToken ? "Available" : "Not found"
+    }`
+  );
+
+  if (!tools.solana || !tools.splToken) {
+    console.log(chalk.yellow("\n💡 Install Solana CLI tools:"));
+    console.log(
+      chalk.gray(
+        '   sh -c "$(curl -sSfL https://release.solana.com/v1.18.4/install)"'
+      )
+    );
+    console.log();
+  }
+
+  // Check running validators
+  console.log(chalk.cyan("\n🏗️  Validator Status:"));
+
+  // Clean up dead processes first
+  await processRegistry.cleanup();
+
+  const validators = processRegistry.getRunning();
+
+  if (validators.length === 0) {
+    console.log(`  ❌ No validators running`);
+    console.log(`  💡 Run 'solforge start' to launch a validator`);
+  } else {
+    console.log(
+      `  ✅ ${validators.length} validator${
+        validators.length > 1 ? "s" : ""
+      } running`
+    );
+
+    for (const validator of validators) {
+      const isRunning = await processRegistry.isProcessRunning(validator.pid);
+      if (isRunning) {
+        console.log(`  🔹 ${validator.name} (${validator.id}):`);
+        console.log(`     🌐 RPC: ${validator.rpcUrl}`);
+        console.log(`     💰 Faucet: ${validator.faucetUrl}`);
+        console.log(`     🆔 PID: ${validator.pid}`);
+
+        // Get current slot for this validator
+        try {
+          const slotResult = await runCommand(
+            "solana",
+            ["slot", "--url", validator.rpcUrl, "--output", "json"],
+            { silent: true, jsonOutput: true }
+          );
+
+          if (slotResult.success && typeof slotResult.stdout === "object") {
+            console.log(`     📊 Current slot: ${slotResult.stdout}`);
+          }
+        } catch {
+          // Ignore slot check errors
+        }
+      } else {
+        processRegistry.updateStatus(validator.id, "stopped");
+        console.log(
+          `  ⚠️  ${validator.name} (${validator.id}): Process stopped`
+        );
+      }
+    }
+
+    console.log(`  💡 Run 'solforge list' for detailed validator information`);
+  }
+
+  // Check config file
+  console.log(chalk.cyan("\n📄 Configuration:"));
+  try {
+    const config = configManager.getConfig();
+    console.log(`  ✅ Config loaded: ${configManager.getConfigPath()}`);
+    console.log(`  📝 Project: ${config.name}`);
+    console.log(`  🪙 Tokens: ${config.tokens.length}`);
+    console.log(`  📦 Programs: ${config.programs.length}`);
+  } catch (error) {
+    console.log(`  ❌ No valid configuration found`);
+    console.log(`  💡 Run 'solforge init' to create one`);
+  }
+
+  console.log();
+}

package/src/commands/stop.ts

@@ -0,0 +1,406 @@
+import chalk from "chalk";
+import { select } from "@inquirer/prompts";
+import { processRegistry } from "../services/process-registry.js";
+
+import type { RunningValidator } from "../services/process-registry.js";
+
+export async function stopCommand(
+  validatorId?: string,
+  options: { all?: boolean; kill?: boolean } = {}
+): Promise<void> {
+  console.log(chalk.blue("🛑 Stopping validator(s)...\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"));
+    return;
+  }
+
+  let validatorsToStop: RunningValidator[] = [];
+
+  if (options.all) {
+    // Stop all validators
+    validatorsToStop = validators;
+    console.log(
+      chalk.cyan(`🔄 Stopping all ${validators.length} validator(s)...`)
+    );
+  } else if (validatorId) {
+    // Stop specific validator
+    const validator = processRegistry.getById(validatorId);
+    if (!validator) {
+      console.error(
+        chalk.red(`❌ Validator with ID '${validatorId}' not found`)
+      );
+      console.log(
+        chalk.gray("💡 Use `solforge list` to see running validators")
+      );
+      return;
+    }
+    validatorsToStop = [validator];
+    console.log(
+      chalk.cyan(
+        `🔄 Stopping validator '${validator.name}' (${validatorId})...`
+      )
+    );
+  } else {
+    // No specific validator specified, show available options
+    console.log(chalk.yellow("⚠️  Please specify which validator to stop:"));
+    console.log(
+      chalk.gray("💡 Use `solforge stop <id>` to stop a specific validator")
+    );
+    console.log(
+      chalk.gray("💡 Use `solforge stop --all` to stop all validators")
+    );
+    console.log(chalk.gray("💡 Use `solforge list` to see running validators"));
+    return;
+  }
+
+  // Stop each validator
+  let stoppedCount = 0;
+  let errorCount = 0;
+
+  for (const validator of validatorsToStop) {
+    try {
+      const result = await stopValidator(validator, options.kill);
+      if (result.success) {
+        console.log(
+          chalk.green(`✅ Stopped ${validator.name} (${validator.id})`)
+        );
+        stoppedCount++;
+      } else {
+        console.error(
+          chalk.red(
+            `❌ Failed to stop ${validator.name} (${validator.id}): ${result.error}`
+          )
+        );
+        errorCount++;
+      }
+    } catch (error) {
+      console.error(
+        chalk.red(
+          `❌ Error stopping ${validator.name} (${validator.id}): ${
+            error instanceof Error ? error.message : String(error)
+          }`
+        )
+      );
+      errorCount++;
+    }
+  }
+
+  // Summary
+  console.log();
+  if (stoppedCount > 0) {
+    console.log(
+      chalk.green(`✅ Successfully stopped ${stoppedCount} validator(s)`)
+    );
+  }
+  if (errorCount > 0) {
+    console.log(chalk.red(`❌ Failed to stop ${errorCount} validator(s)`));
+  }
+}
+
+async function stopValidator(
+  validator: RunningValidator,
+  forceKill: boolean = false
+): Promise<{ success: boolean; error?: string }> {
+  try {
+    // Stop the API server first if it has a PID
+    if (validator.apiServerPid) {
+      try {
+        process.kill(validator.apiServerPid, "SIGTERM");
+        console.log(
+          chalk.gray(`📡 Stopped API server (PID: ${validator.apiServerPid})`)
+        );
+      } catch (error) {
+        console.log(
+          chalk.yellow(
+            `⚠️  Warning: Failed to stop API server: ${
+              error instanceof Error ? error.message : String(error)
+            }`
+          )
+        );
+      }
+    }
+
+    // Check if process is still running
+    const isRunning = await processRegistry.isProcessRunning(validator.pid);
+    if (!isRunning) {
+      // Process already stopped, just clean up registry
+      processRegistry.unregister(validator.id);
+      return { success: true };
+    }
+
+    const signal = forceKill ? "SIGKILL" : "SIGTERM";
+
+    // Send termination signal
+    process.kill(validator.pid, signal);
+
+    if (forceKill) {
+      // For SIGKILL, process should stop immediately
+      processRegistry.unregister(validator.id);
+      return { success: true };
+    } else {
+      // For SIGTERM, wait for graceful shutdown
+      const shutdownResult = await waitForProcessShutdown(validator.pid, 10000);
+
+      if (shutdownResult.success) {
+        processRegistry.unregister(validator.id);
+        return { success: true };
+      } else {
+        // Graceful shutdown failed, try force kill
+        console.log(
+          chalk.yellow(
+            `⚠️  Graceful shutdown failed for ${validator.name}, force killing...`
+          )
+        );
+        process.kill(validator.pid, "SIGKILL");
+        processRegistry.unregister(validator.id);
+        return { success: true };
+      }
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+
+    // If error is "ESRCH" (No such process), the process is already gone
+    if (errorMessage.includes("ESRCH")) {
+      processRegistry.unregister(validator.id);
+      return { success: true };
+    }
+
+    return { success: false, error: errorMessage };
+  }
+}
+
+async function waitForProcessShutdown(
+  pid: number,
+  timeoutMs: number = 10000
+): Promise<{ success: boolean; error?: string }> {
+  const startTime = Date.now();
+
+  while (Date.now() - startTime < timeoutMs) {
+    try {
+      // Send signal 0 to check if process exists
+      process.kill(pid, 0);
+      // If no error thrown, process is still running
+      await new Promise((resolve) => setTimeout(resolve, 500));
+    } catch (error) {
+      // Process is gone
+      return { success: true };
+    }
+  }
+
+  return { success: false, error: "Process shutdown timeout" };
+}
+
+export async function killCommand(
+  validatorId?: string,
+  options: { all?: boolean } = {}
+): Promise<void> {
+  console.log(chalk.red("💀 Force killing validator(s)...\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"));
+    return;
+  }
+
+  let validatorsToKill: RunningValidator[] = [];
+
+  if (options.all) {
+    // Kill all validators
+    validatorsToKill = validators;
+    console.log(
+      chalk.cyan(`🔄 Force killing all ${validators.length} validator(s)...`)
+    );
+  } else if (validatorId) {
+    // Kill specific validator
+    const validator = processRegistry.getById(validatorId);
+    if (!validator) {
+      console.error(
+        chalk.red(`❌ Validator with ID '${validatorId}' not found`)
+      );
+      console.log(
+        chalk.gray("💡 Use `solforge list` to see running validators")
+      );
+      return;
+    }
+    validatorsToKill = [validator];
+    console.log(
+      chalk.cyan(
+        `🔄 Force killing validator '${validator.name}' (${validatorId})...`
+      )
+    );
+  } else {
+    // No specific validator specified, show interactive selection
+    console.log(chalk.cyan("📋 Select validator(s) to force kill:\n"));
+
+    // Display current validators
+    displayValidatorsTable(validators);
+
+    const choices = [
+      ...validators.map((v) => ({
+        name: `${v.name} (${v.id}) - PID: ${v.pid}`,
+        value: v.id,
+      })),
+      {
+        name: chalk.red("Kill ALL validators"),
+        value: "all",
+      },
+      {
+        name: chalk.gray("Cancel"),
+        value: "cancel",
+      },
+    ];
+
+    const selectedValidator = await select({
+      message: "Which validator would you like to force kill?",
+      choices,
+    });
+
+    if (selectedValidator === "cancel") {
+      console.log(chalk.gray("Operation cancelled"));
+      return;
+    }
+
+    if (selectedValidator === "all") {
+      validatorsToKill = validators;
+      console.log(
+        chalk.cyan(`🔄 Force killing all ${validators.length} validator(s)...`)
+      );
+    } else {
+      const validator = processRegistry.getById(selectedValidator);
+      if (!validator) {
+        console.error(chalk.red("❌ Selected validator not found"));
+        return;
+      }
+      validatorsToKill = [validator];
+      console.log(
+        chalk.cyan(
+          `🔄 Force killing validator '${validator.name}' (${selectedValidator})...`
+        )
+      );
+    }
+  }
+
+  // Kill each validator
+  let killedCount = 0;
+  let errorCount = 0;
+
+  for (const validator of validatorsToKill) {
+    try {
+      const result = await stopValidator(validator, true); // Force kill
+      if (result.success) {
+        console.log(
+          chalk.green(`✅ Killed ${validator.name} (${validator.id})`)
+        );
+        killedCount++;
+      } else {
+        console.error(
+          chalk.red(
+            `❌ Failed to kill ${validator.name} (${validator.id}): ${result.error}`
+          )
+        );
+        errorCount++;
+      }
+    } catch (error) {
+      console.error(
+        chalk.red(
+          `❌ Error killing ${validator.name} (${validator.id}): ${
+            error instanceof Error ? error.message : String(error)
+          }`
+        )
+      );
+      errorCount++;
+    }
+  }
+
+  // Summary
+  console.log();
+  if (killedCount > 0) {
+    console.log(
+      chalk.green(`✅ Successfully killed ${killedCount} validator(s)`)
+    );
+  }
+  if (errorCount > 0) {
+    console.log(chalk.red(`❌ Failed to kill ${errorCount} validator(s)`));
+  }
+}
+
+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
+}
+
+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`;
+  }
+}

package/src/config/manager.ts

@@ -0,0 +1,157 @@
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join, resolve } from "path";
+import { ConfigSchema } from "../types/config.js";
+import type { Config, ValidationResult } from "../types/config.js";
+
+export class ConfigManager {
+  private config: Config | null = null;
+  private configPath: string | null = null;
+
+  /**
+   * Load configuration from a file path
+   */
+  async load(configPath: string): Promise<Config> {
+    try {
+      const fullPath = resolve(configPath);
+
+      if (!existsSync(fullPath)) {
+        throw new Error(`Configuration file not found: ${fullPath}`);
+      }
+
+      const configContent = readFileSync(fullPath, "utf-8");
+      const rawConfig = JSON.parse(configContent);
+
+      // Validate and parse with Zod
+      const result = ConfigSchema.safeParse(rawConfig);
+
+      if (!result.success) {
+        const errors = result.error.issues.map((issue) => ({
+          path: issue.path.join("."),
+          message: issue.message,
+        }));
+        throw new Error(
+          `Configuration validation failed:\n${errors
+            .map((e) => `  - ${e.path}: ${e.message}`)
+            .join("\n")}`
+        );
+      }
+
+      this.config = result.data;
+      this.configPath = fullPath;
+
+      return this.config;
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        throw new Error(`Invalid JSON in configuration file: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Save current configuration to file
+   */
+  async save(configPath?: string): Promise<void> {
+    if (!this.config) {
+      throw new Error("No configuration loaded");
+    }
+
+    const targetPath = configPath || this.configPath;
+    if (!targetPath) {
+      throw new Error("No configuration path specified");
+    }
+
+    try {
+      const configContent = JSON.stringify(this.config, null, 2);
+      writeFileSync(targetPath, configContent, "utf-8");
+      this.configPath = targetPath;
+    } catch (error) {
+      throw new Error(
+        `Failed to save configuration: ${
+          error instanceof Error ? error.message : String(error)
+        }`
+      );
+    }
+  }
+
+  /**
+   * Validate a configuration object
+   */
+  validate(config: any): ValidationResult {
+    const result = ConfigSchema.safeParse(config);
+
+    if (result.success) {
+      return { valid: true, errors: [] };
+    }
+
+    const errors = result.error.issues.map((issue) => ({
+      path: issue.path.join("."),
+      message: issue.message,
+    }));
+
+    return { valid: false, errors };
+  }
+
+  /**
+   * Create a default configuration
+   */
+  createDefault(): Config {
+    const defaultConfig = ConfigSchema.parse({});
+    this.config = defaultConfig;
+    return defaultConfig;
+  }
+
+  /**
+   * Get current configuration
+   */
+  getConfig(): Config {
+    if (!this.config) {
+      throw new Error("No configuration loaded. Call load() first.");
+    }
+    return this.config;
+  }
+
+  /**
+   * Update configuration
+   */
+  updateConfig(updates: Partial<Config>): Config {
+    if (!this.config) {
+      throw new Error("No configuration loaded. Call load() first.");
+    }
+
+    const updated = { ...this.config, ...updates };
+    const result = ConfigSchema.safeParse(updated);
+
+    if (!result.success) {
+      const errors = result.error.issues.map((issue) => ({
+        path: issue.path.join("."),
+        message: issue.message,
+      }));
+      throw new Error(
+        `Configuration update validation failed:\n${errors
+          .map((e) => `  - ${e.path}: ${e.message}`)
+          .join("\n")}`
+      );
+    }
+
+    this.config = result.data;
+    return this.config;
+  }
+
+  /**
+   * Get configuration file path
+   */
+  getConfigPath(): string | null {
+    return this.configPath;
+  }
+
+  /**
+   * Check if configuration is loaded
+   */
+  isLoaded(): boolean {
+    return this.config !== null;
+  }
+}
+
+// Singleton instance
+export const configManager = new ConfigManager();