@podx/cli/src/handlers/config.ts

💻 Command-line interface for PODx - Advanced Twitter/X scraping and crypto analysis toolkit

import chalk from 'chalk';
import { promises as fs } from 'fs';
import { logger, ValidationError } from '@podx/core';

export async function runConfiguration(): Promise<void> {
  logger.info("Starting configuration setup", { operation: "config_setup" });

  console.log(chalk.blue.bold('⚙️  CONFIGURATION SETUP ⚙️\n'));

  try {
    const { input, password } = await import('@inquirer/prompts');

    // Twitter credentials
    const username = await input({
      message: 'Enter your X/Twitter username:',
      validate: (value) => value.trim() ? true : 'Username is required'
    });

    const twitterPassword = await password({
      message: 'Enter your X/Twitter password:',
      mask: '*'
    });

    const email = await input({
      message: 'Enter your X/Twitter email (optional):',
      default: ''
    });

    // Scraping configuration
    const targetUsername = await input({
      message: 'Enter target username to scrape:',
      default: 'pmarca',
      validate: (value) => value.trim() ? true : 'Target username is required'
    });

    const maxTweets = await input({
      message: 'Enter maximum tweets to scrape:',
      default: '1000',
      validate: (value) => {
        const num = parseInt(value);
        return !isNaN(num) && num > 0 ? true : 'Must be a positive number';
      }
    });

    const credentials = {
      username,
      password: twitterPassword,
      email
    };

    const scrapingConfig = {
      targetUsername,
      maxTweets: parseInt(maxTweets, 10)
    };

    await saveConfiguration(credentials, scrapingConfig);

    console.log(chalk.green('\n✅ Configuration saved successfully!'));

    logger.info("Configuration setup completed", { operation: "config_setup" });

  } catch (error) {
    logger.error("Configuration setup failed", { operation: "config_setup" }, error as Error);
    throw error;
  }
}

export async function saveConfiguration(
  credentials: { username: string; password: string; email: string },
  scrapingConfig: { targetUsername: string; maxTweets: number }
): Promise<void> {
  logger.info("Saving configuration", { operation: "config_save" });

  try {
    // Validate configuration
    if (!credentials.username || !credentials.password) {
      throw ValidationError("Twitter credentials are required");
    }

    if (!scrapingConfig.targetUsername) {
      throw ValidationError("Target username is required");
    }

    if (scrapingConfig.maxTweets <= 0) {
      throw ValidationError("Max tweets must be greater than 0");
    }

    // Create .env content
    const envContent = `# X/Twitter Credentials
XSERVE_USERNAME=${credentials.username}
XSERVE_PASSWORD=${credentials.password}
${credentials.email ? `XSERVE_EMAIL=${credentials.email}` : ''}

# Scraping Configuration
TARGET_USERNAME=${scrapingConfig.targetUsername}
MAX_TWEETS=${scrapingConfig.maxTweets}
`;

    // Save to .env file
    await fs.writeFile('.env', envContent.trim());

    // Update environment variables for current session
    process.env.XSERVE_USERNAME = credentials.username;
    process.env.XSERVE_PASSWORD = credentials.password;
    if (credentials.email) {
      process.env.XSERVE_EMAIL = credentials.email;
    }
    process.env.TARGET_USERNAME = scrapingConfig.targetUsername;
    process.env.MAX_TWEETS = scrapingConfig.maxTweets.toString();

    logger.info("Configuration saved successfully", {
      operation: "config_save",
      hasEmail: !!credentials.email,
      targetUsername: scrapingConfig.targetUsername,
      maxTweets: scrapingConfig.maxTweets
    });

  } catch (error) {
    logger.error("Failed to save configuration", { operation: "config_save" }, error as Error);
    throw error;
  }
}